public SimpleOutput(string elementSetName, string quantityName, SimpleLinkableComponent linkableComponent) :
base(elementSetName, quantityName, linkableComponent)
{
_simpleOutputIndex = ++_simpleOutputCounter;
_spatialDefinition = new SimpleElementSet(elementSetName);
TimeSet = new SimpleTimeSet(linkableComponent.TimeExtent.TimeHorizon.StampAsModifiedJulianDay);
}
public ElementSetPoints(
ISpatialDefinition spatial,
IEnumerable<IIdentifiable> ids,
IEnumerable<double> x,
IEnumerable<double> y,
IEnumerable<double> z = null,
IEnumerable<double> m = null)
: base(spatial, ids, ElementType.Point, z != null, m != null)
{
if (x.Count() != ElementCount)
throw new Exception(string.Format("x.Count() {0} != {1}",
x.Count(), ElementCount));
if (y.Count() != ElementCount)
throw new Exception(string.Format("y.Count() {0} != {1}",
y.Count(), ElementCount));
if (HasZ && (z == null || z.Count() != ElementCount))
throw new Exception(string.Format("z.Length = {0} != {1}",
z == null ? "null" : z.Count().ToString(), ElementCount));
if (HasM && (m == null || m.Count() != ElementCount))
throw new Exception(string.Format("m.Length = {0} != {1}",
m == null ? "null" : m.Count().ToString(), ElementCount));
X = x.ToArray();
Y = y.ToArray();
if (HasZ)
Z = z.ToArray();
if (HasM)
M = m.ToArray();
}
public InputSpace(IValueDefinition valueDefinition, ISpatialDefinition spatialDefinition, IBaseLinkableComponent component, IValueSetConverter valueSetConverter)
: base(valueDefinition, spatialDefinition, component)
{
_valueSetConverter = valueSetConverter;
if (_valueSetConverter != null)
_valueSetConverter.ExchangeItem = this;
}
public InputSpaceTime(IIdentifiable identity, IValueDefinition valueDefinition, ISpatialDefinition spatialDefinition, IBaseLinkableComponent component, IValueSetConverterTime valueSetConverterTime)
: base(identity, valueDefinition, spatialDefinition, component)
{
_valueSetConverterTime = valueSetConverterTime;
if (_valueSetConverterTime != null)
_valueSetConverterTime.ExchangeItem = this;
}
public ElementSetSelafinBase(ISpatialDefinition spatial, ElementType elementType, FileInfo selafinFileInfo = null)
: base(spatial, elementType)
{
Arguments = new IArgument[] {
new ArgumentFile(new Identity("Selafin file"), selafinFileInfo),
}.ToList();
Selafin = new Selafin(selafinFileInfo);
}
/// <summary>
/// ElementSet for a single polyline, each segment will be an element.
/// </summary>
/// <param name="spatial">Spatial definition</param>
/// <param name="polyLineX">PolyLine X coords #segments + 1</param>
/// <param name="polyLineY">PolyLine Y coords #segments + 1</param>
/// <param name="polyLineZ">Optional polyline Z coords #segments + 1</param>
/// <param name="polyLineM">Optional polyline M coords #segments + 1</param>
public ElementSetPolyLineSingle(
ISpatialDefinition spatial,
double[] polyLineX,
double[] polyLineY,
double[] polyLineZ = null,
double[] polyLineM = null)
: base(spatial, SegmentIds(spatial), ElementType.PolyLine, polyLineX, polyLineY, polyLineZ, polyLineM)
{
}
public ElementSetPolygons(
ISpatialDefinition spatial,
IEnumerable<IIdentifiable> ids,
IEnumerable<IEnumerable<double>> x,
IEnumerable<IEnumerable<double>> y,
IEnumerable<IEnumerable<double>> z = null,
IEnumerable<IEnumerable<double>> m = null)
: base(spatial, ids, ElementType.Polygon, x, y, z, m)
{
}
public ElementSetPolygonsUniqueVertices(
ISpatialDefinition spatial,
IEnumerable<IIdentifiable> ids,
IEnumerable<IEnumerable<int>> elementVertices,
IEnumerable<double> x,
IEnumerable<double> y,
IEnumerable<double> z = null,
IEnumerable<double> m = null)
: base(spatial, ids, elementVertices, ElementType.Polygon, x, y, z, m)
{
}
public ElementSetGridRegularBase(ParametersGridRegular grid, ISpatialDefinition spatialDefinition, ElementType elementType)
: base(spatialDefinition, elementType)
{
GridParameters = grid.Clone() as ParametersGridRegular;
Arguments = new IArgument[] {
new ArgumentGridRegular(new Identity("Grid Parameters"), GridParameters),
}.ToList();
ElementType = ElementType;
}
public ElementSetVerticesUniqueIndexed(
ISpatialDefinition spatial,
IEnumerable<IIdentifiable> ids,
IEnumerable<IEnumerable<int>> elementVertices,
ElementType elementType,
IEnumerable<double> x,
IEnumerable<double> y,
IEnumerable<double> z = null,
IEnumerable<double> m = null)
: base(spatial, ids, elementType, x, y, z, m)
{
IndexMap = elementVertices
.Select(a => a.ToArray())
.ToArray();
}
public ElementSetCuboidBlock(
ISpatialDefinition spatial,
IEnumerable<IIdentifiable> ids,
IEnumerable<double> x,
IEnumerable<double> y,
IEnumerable<double> z,
IEnumerable<double> m,
int nX, int nY, int nZ)
: base(spatial, ids, ElementType.Polyhedron, z != null, m != null)
{
int nTotal = nX * nY * nZ;
if (nTotal != ElementCount)
throw new Exception(string.Format("nX * nY * nZ = {1} != {2}",
nTotal, ElementCount));
if (x.Count() != ElementCount)
throw new Exception(string.Format("x.Count() {1} != {2}",
x.Count(), ElementCount));
if (y.Count() != ElementCount)
throw new Exception(string.Format("y.Count() {1} != {2}",
y.Count(), ElementCount));
if (HasZ && z.Count() != ElementCount)
throw new Exception(string.Format("z.Count() {1} != {2}",
z.Count(), ElementCount));
if (HasM && m.Count() != ElementCount)
throw new Exception(string.Format("m.Count() {1} != {2}",
m.Count(), ElementCount));
int[][] elementVertices = new int[nTotal][];
for (int i =
_x = x.ToArray();
_y = y.ToArray();
if (HasZ)
_z = z.ToArray();
if (HasM)
_m = m.ToArray();
_elementVertices = elementVertices;
}
public ElementSetCuboidBlock(
ISpatialDefinition spatial,
IEnumerable<IIdentifiable> ids,
IEnumerable<double> x,
IEnumerable<double> y,
IEnumerable<double> z,
IEnumerable<double> m,
int[,] elementVertices)
: base(spatial, ids, ElementType.Polyhedron, z != null, m != null)
{
if (x.Count() != ElementCount)
throw new Exception(string.Format("x.Count() {1} != {2}",
x.Count(), ElementCount));
if (y.Count() != ElementCount)
throw new Exception(string.Format("y.Count() {1} != {2}",
y.Count(), ElementCount));
if (HasZ && z.Count() != ElementCount)
throw new Exception(string.Format("z.Count() {1} != {2}",
z.Count(), ElementCount));
if (HasM && m.Count() != ElementCount)
throw new Exception(string.Format("m.Count() {1} != {2}",
m.Count(), ElementCount));
if (elementVertices == null || elementVertices.GetLength(0) != ElementCount)
throw new Exception(string.Format("elementVertices.GetLength(0) {1} != {2}",
elementVertices == null ? "null" : elementVertices.GetLength(0).ToString(), ElementCount));
if (elementVertices.GetLength(1) != 8)
throw new Exception(string.Format("elementVertices.GetLength(1) {0} != 8",
elementVertices.GetLength(1).ToString()));
_x = x.ToArray();
_y = y.ToArray();
if (HasZ)
_z = z.ToArray();
if (HasM)
_m = m.ToArray();
_elementVertices = elementVertices;
}
public ElementSetVerticesUniqueBase(
ISpatialDefinition spatial,
IEnumerable<IIdentifiable> ids,
ElementType elementType,
IEnumerable<double> x,
IEnumerable<double> y,
IEnumerable<double> z = null,
IEnumerable<double> m = null)
: base(spatial, ids, elementType, z != null, m != null)
{
Contract.Requires(y.Count() == x.Count(), "y.Count() == x.Count(); {0} != {1}", y.Count(), x.Count());
Contract.Requires(z == null || z.Count() == x.Count(), "z == null || z.Count() == x.Count(); z.Count() != {0}", x.Count());
Contract.Requires(m == null || m.Count() == x.Count(), "m == null || m.Count() == x.Count(); m.Count() != {0}", x.Count());
X = x.ToArray();
Y = y.ToArray();
Z = z != null ? z.ToArray() : null;
M = m != null ? m.ToArray() : null;
}
public ElementSetVerticesNonUnique(
ISpatialDefinition spatial,
IEnumerable<IIdentifiable> ids,
ElementType elementType,
IEnumerable<IEnumerable<double>> x,
IEnumerable<IEnumerable<double>> y,
IEnumerable<IEnumerable<double>> z = null,
IEnumerable<IEnumerable<double>> m = null)
: base(spatial, ids, elementType, z != null, m != null)
{
Contract.Requires(x.Count() == ids.Count(), "x.Count() == ids.Count(); {0} != {1}", x.Count(), ids.Count());
Contract.Requires(y.Count() == ids.Count(), "y.Count() == ids.Count(); {0} != {1}", y.Count(), ids.Count());
Contract.Requires(z == null || z.Count() == ids.Count(), "z == null || z.Count() == ids.Count(); z.Count() != {0}", ids.Count());
Contract.Requires(m == null || m.Count() == ids.Count(), "m == null || m.Count() == ids.Count(); m.Count() != {0}", ids.Count());
X = x.Select(a => a.ToArray()).ToArray();
Y = y.Select(a => a.ToArray()).ToArray();
Z = HasZ ? z.Select(a => a.ToArray()).ToArray() : null;
M = HasM ? m.Select(a => a.ToArray()).ToArray() : null;
}
public OutputSpaceTimeUserVariables(IIdentifiable identity, IBaseLinkableComponent component,
IValueDefinition iValueDefinition, ISpatialDefinition iSpatialDefinition,
string engineVariable, Vector3d<double> missingValue, int elementCount)
: base(identity, iValueDefinition, iSpatialDefinition, component,
new ValueSetConverterTimeEngineDoubleVector3d(engineVariable, missingValue, elementCount, ValueSetConverterTimeRecordBase<Vector3d<double>>.InterpolationTemporal.Linear))
{
}
protected ExchangeItem(string id, IValueDefinition valueDefinition, ISpatialDefinition spatialDefinition)
: this(id)
{
_valueDefinition = valueDefinition;
_spatialDefinition = spatialDefinition;
}
public ElementSetIds(ISpatialDefinition spatial, IEnumerable<IIdentifiable> ids)
: base(spatial, ElementType.IdBased)
{
Ids = ids.Select(i => new Identity(i as IDescribable)).ToArray();
ElementCount = Ids.Length;
}
public ElementSetProposed(ISpatialDefinition spatial, ElementType elementType)
: base(spatial, elementType)
{
}
public ElementSetProposed(ISpatialDefinition spatial, ElementType elementType, bool hasZ, bool hasM)
: base(spatial, elementType, hasZ, hasM)
{
}
public InputSpaceTimeUserVariables(IIdentifiable identity, IBaseLinkableComponent component,
IValueDefinition iValueDefinition, ISpatialDefinition iSpatialDefinition,
string engineVariable, double missingValue, int elementCount)
: base(identity, iValueDefinition, iSpatialDefinition, component,
new ValueSetConverterTimeEngineDouble(engineVariable, missingValue, elementCount, ValueSetConverterTimeRecordBase<double>.InterpolationTemporal.Linear))
{
UserVariables = new Dictionary<string, string>();
}
protected ElementSetIds(ISpatialDefinition spatial, IEnumerable<IIdentifiable> ids, ElementType elementType, bool hasZ, bool hasM)
: base(spatial, elementType, hasZ, hasM)
{
Ids = ids.Select(i => new Identity(i as IDescribable)).ToArray();
ElementCount = Ids.Length;
}
static IIdentifiable[] SegmentIds(ISpatialDefinition spatial)
{
var ids = new Identity[spatial.ElementCount];
for (int n = 0; n < spatial.ElementCount; ++n)
ids[n] = new Identity(string.Format("{0}[{1}]", spatial.Caption, n.ToString()));
return ids;
}
static int[][] GetElementVertexMapping(ISpatialDefinition spatial)
{
var mapping = new int[spatial.ElementCount][];
for (int n = 0; n < spatial.ElementCount; ++n)
mapping[n] = new int[] { n, n + 1 };
return mapping;
}
public OutputSpaceTimeComponent1(IIdentifiable identity, IBaseLinkableComponent component,
IValueDefinition iValueDefinition, ISpatialDefinition iSpatialDefinition,
string engineVariable, Vector3d<double> missingValue, int elementCount)
: base(identity, iValueDefinition, iSpatialDefinition, component,
new ValueSetConverterTimeEngineDoubleVector3dStandard1(engineVariable, missingValue, elementCount))
{
}
public ElementSetUnoptimisedStorage(ISpatialDefinition iSpatialDefinition, ElementType elementType, IEnumerable<Element> elements, bool hasZ, bool hasM)
: base(iSpatialDefinition, elementType, hasZ, hasM)
{
Elements = new List<Element>(elements);
ElementCount = Elements.Count;
}
protected ExchangeItem(string id, IValueDefinition valueDefinition, ISpatialDefinition spatialDefinition)
: this(id)
{
_valueDefinition = valueDefinition;
_spatialDefinition = spatialDefinition;
}
