internal Item(IntPtr ItemPointer, DFSBase DFS, int Number)
{
ItemNumber = Number;
_dfs = DFS;
int item_type = 0;
int data_type = 0;
int value_type = 0;
IntPtr name = new IntPtr();
IntPtr Eum = new IntPtr();
this.ItemPointer = ItemPointer;
DfsDLLAccess.dfsGetItemInfo_(ItemPointer, out item_type, ref name, ref Eum, out data_type);
DfsDLLAccess.dfsGetItemValueType(ItemPointer, out value_type);
NumberOfElements = (int)DfsDLLAccess.dfsGetItemElements(ItemPointer);
valueType = (DataValueType)value_type;
_name = (Marshal.PtrToStringAnsi(name));
eumUnitString = Marshal.PtrToStringAnsi(Eum);
if (item_type != 0)
{
_eumitem = (eumItem)item_type;
}
}
protected void CopyItemInfo(DFSBase TemplateDFS)
{
for (int i = 0; i < TemplateDFS.Items.Count(); i++)
{
Items[i].Name = TemplateDFS.Items[i].Name;
Items[i].EumItem = TemplateDFS.Items[i].EumItem;
Items[i].EumUnit = TemplateDFS.Items[i].EumUnit;
Items[i].ValueType = TemplateDFS.Items[i].ValueType;
}
}
public virtual void CopyFromTemplate(DFSBase dfs)
{
_timeAxis = dfs._timeAxis;
if (dfs._timeAxis == TimeAxisType.CalendarEquidistant || dfs._timeAxis == TimeAxisType.TimeEquidistant)
{
this.TimeOfFirstTimestep = dfs.TimeOfFirstTimestep;
this.TimeStep = dfs.TimeStep;
}
this.DeleteValue = dfs.DeleteValue;
if (DfsDLLWrapper.dfsIsFileCompressed(dfs._headerPointer))
{
var en = DfsDLLWrapper.dfsGetEncodeKeySize(dfs._headerPointer);
int[] xkey = new int[en];
int[] ykey = new int[en];
int[] zkey = new int[en];
DfsDLLWrapper.dfsGetEncodeKey(dfs._headerPointer, xkey, ykey, zkey);
DfsDLLWrapper.dfsSetEncodeKey(_headerPointer, xkey, ykey, zkey, en);
}
}
/// <summary>
/// Sums the values of the items to the selected time interval and puts them in the new dfs file
/// Assumes that the there are delete values at the same places in all items and timesteps!
/// </summary>
/// <param name="Items"></param>
/// <param name="df"></param>
/// <param name="SumTim"></param>
public void TimeAggregation(int[] Items, DFSBase df, TimeInterval SumTim, int Tsteps, MathType mathtype)
{
Dictionary <int, float[]> BufferData = new Dictionary <int, float[]>();
List <int> NonDeleteIndex = null;
List <int> DeleteIndex = null;
//Initialize all items
foreach (var j in Items)
{
BufferData[j] = new float[dfsdata.Count()];
}
DateTime LastPrint = TimeSteps[0];
bool PrintNow = false;
int tstepCounter = 0;
//Loop the time steps
for (int i = 0; i < NumberOfTimeSteps; i++)
{
tstepCounter++;
switch (SumTim)
{
case TimeInterval.Year:
PrintNow = (LastPrint.Year + Tsteps == TimeSteps[i].Year);
break;
case TimeInterval.Month:
int nextmonth = LastPrint.Month + Tsteps;
if (nextmonth > 12)
{
nextmonth -= 12;
}
PrintNow = (nextmonth == TimeSteps[i].Month);
break;
case TimeInterval.Day:
PrintNow = ((TimeSteps[i].Subtract(LastPrint) >= TimeSpan.FromDays(Tsteps)));
break;
default:
break;
}
//Now print summed values and empty buffer
if (PrintNow)
{
foreach (var j in Items)
{
if (mathtype == MathType.Average) //Average, and a division with the number of time steps is required
{
foreach (var n in NonDeleteIndex)
{
BufferData[j][n] = BufferData[j][n] / ((float)tstepCounter);
}
}
df.WriteItemTimeStep(df.NumberOfTimeSteps, j, BufferData[j]);
foreach (var n in NonDeleteIndex)
{
if (mathtype == MathType.Min)
{
BufferData[j][n] = float.MaxValue;
}
else if (mathtype == MathType.Max)
{
BufferData[j][n] = float.MinValue;
}
else
{
BufferData[j][n] = 0;
}
}
}
tstepCounter = 0;
LastPrint = TimeSteps[i];
PrintNow = false;
}
//Sum all items
foreach (var j in Items)
{
ReadItemTimeStep(i, j);
if (DeleteIndex == null) //For the first time step build a list of the non-delete values
{
DeleteIndex = new List <int>();
NonDeleteIndex = new List <int>();
for (int k = 0; k < dfsdata.Count(); k++)
{
if (dfsdata[k] == DeleteValue)
{
DeleteIndex.Add(k);
foreach (var n in Items)
{
BufferData[n][k] = dfsdata[k]; //Set the delete values for all items
}
}
else
{
NonDeleteIndex.Add(k);
}
foreach (var n in Items)
{
if (mathtype == MathType.Min)
{
BufferData[n][k] = float.MaxValue;
}
else if (mathtype == MathType.Max)
{
BufferData[n][k] = float.MinValue;
}
else
{
BufferData[n][k] = 0;
}
}
}
}
var arr = BufferData[j];
foreach (int k in NonDeleteIndex)
{
if (mathtype == MathType.Min)
{
arr[k] = Math.Min(arr[k], dfsdata[k]);
}
else if (mathtype == MathType.Max)
{
arr[k] = Math.Max(arr[k], dfsdata[k]);
}
else
{
arr[k] += dfsdata[k];
}
}
}
}
//print the last summed values
foreach (var j in Items)
{
if (mathtype == MathType.Average) //If not sum it is average and a division with the number of time steps is required
{
foreach (var n in NonDeleteIndex)
{
BufferData[j][n] = BufferData[j][n] / ((float)tstepCounter);
}
}
df.WriteItemTimeStep(df.NumberOfTimeSteps, j, BufferData[j]);
}
}
