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;
}
}
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);
DataType = (DfsSimpleType)data_type;
valueType = (DataValueType)value_type;
_name = (Marshal.PtrToStringAnsi(name));
eumUnitString = Marshal.PtrToStringAnsi(Eum);
if(item_type!=0)
_eumitem = (eumItem)item_type;
}
public override void CopyFromTemplate(DFSBase DFSTemplate1)
{
base.CopyFromTemplate(DFSTemplate1);
DFS2DBase DFSTemplate = DFSTemplate1 as DFS2DBase;
CopyGrid(DFSTemplate);
}
public void SetStartDateTest()
{
System.IO.File.Copy(@"..\..\..\TestData\dmi_kgrid_55hr_temp_fcast.dfs2", @"..\..\..\TestData\dmi_kgrid_55hr_temp_fcast_copy.dfs2", true);
HydroNumerics.MikeSheTools.DFS.DFSBase target = DfsFileFactory.OpenFile(@"..\..\..\TestData\dmi_kgrid_55hr_temp_fcast_copy.dfs2");
target.TimeOfFirstTimestep = new DateTime(2010, 1, 1);
target.Dispose();
}
/// <summary>
/// Calculates the Percentiles [0;1] of an Item. MaxEntriesInMemory is used to reduce the memory consumption by sweeping multiple times. Units is MB of memory
/// </summary>
public void Percentile(int Item, DFSBase df, double[] Percentiles, int MaxEntriesInMemory)
{
int[] TSteps = new int[NumberOfTimeSteps];
for (int i = 0; i < NumberOfTimeSteps; i++)
{
TSteps[i] = i;
}
Percentile(Item, TSteps, df, Percentiles, MaxEntriesInMemory);
}
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);
//Adjust z-count if we go from dfs3 to dfs2
if (_numberOfLayers == 1 & dfs._numberOfLayers > 1)
{
en = en / dfs._numberOfLayers;
xkey = xkey.Take(en).ToArray();
ykey = ykey.Take(en).ToArray();
zkey = zkey.Take(en).ToArray();
for (int i = 0; i < en; i++)
{
zkey[i] = 0;
}
}
DfsDLLWrapper.dfsSetEncodeKey(_headerPointer, xkey, ykey, zkey, en);
}
}
public override void CopyFromTemplate(DFSBase DFSTemplate1)
{
base.CopyFromTemplate(DFSTemplate1);
this.NumberOfLayers = ((DFS3)DFSTemplate1).NumberOfLayers;
}
/// <summary>
/// Calculates the Percentiles [0;1] of an Item. MaxEntriesInMemory is used to reduce the memory consumption by sweeping multiple times. Units is MB of memory
/// </summary>
public void Percentile(int Item, int[] TSteps, DFSBase df, double[] Percentiles, int MaxEntriesInMemory)
{
//List counts percentiles
float[][] OutData = new float[Percentiles.Count()][];
for (int i = 0; i < Percentiles.Count(); i++)
OutData[i] = new float[dfsdata.Count()];
List<int> steps = new List<int>();
steps.Add(0);
//Get the delete values
float delete = DfsDLLWrapper.dfsGetDeleteValFloat(_headerPointer);
//Read first time step and create a list with the indeces of non-delete values
ReadItemTimeStep(0, Item);
List<int> NonDeleteEntries = new List<int>();
for (int i = 0; i < dfsdata.Length; i++)
if (dfsdata[i] != delete)
NonDeleteEntries.Add(i);
//Find out how many sweeps are necessary to not exceed max memory
double TotalData = (double)NonDeleteEntries.Count * (double)TSteps.Count();
if (TotalData > (MaxEntriesInMemory*40000))
{
int nsteps = (int) Math.Max( TotalData / (MaxEntriesInMemory*40000),1);
int StepLength = NonDeleteEntries.Count() / nsteps;
for (int i = 0; i < nsteps; i++)
steps.Add(steps.Last() + StepLength);
}
steps.Add(NonDeleteEntries.Count);
//Now start the loop
for (int m = 0; m < steps.Count-1; m++)
{
int dfscount = steps[m + 1] - steps[m];
//First iterater is dfsdata
float[][] Data = new float[dfscount][];
for (int i = 0; i < Data.Count(); i++)
Data[i] = new float[TSteps.Count()];
//Collect all data
for (int i = 0; i < TSteps.Count(); i++)
{
var data = ReadItemTimeStep(TSteps[i], Item);
int local = 0;
for (int k = steps[m]; k < steps[m + 1]; k++)
{
Data[local][i] = (dfsdata[NonDeleteEntries[k]]);
local++;
}
}
int local2 = 0;
for (int k = steps[m]; k < steps[m + 1]; k++)
{
//Convert to doubles from float
double[] ddata = new double[TSteps.Count()];
for (int n = 0; n < TSteps.Count(); n++)
ddata[n]=Data[local2][n];
//Calculate the percentile
MathNet.Numerics.Statistics.Percentile pCalc = new MathNet.Numerics.Statistics.Percentile(ddata);
pCalc.Method = MathNet.Numerics.Statistics.PercentileMethod.Excel;
var p = pCalc.Compute(Percentiles);
for (int l = 0; l < Percentiles.Count(); l++)
OutData[l][NonDeleteEntries[k]] = (float)p[l];
local2++;
}
}
//Insert deletevalues in output data
for (int i = 0; i < dfsdata.Length; i++)
{
if (!NonDeleteEntries.Contains(i))
{
for (int l = 0; l < Percentiles.Count(); l++)
OutData[l][i] = delete;
}
}
//Set Item infor
for (int i = 0; i < Percentiles.Count(); i++)
{
df.Items[i].EumItem = Items[Item - 1].EumItem;
df.Items[i].EumUnit = Items[Item - 1].EumUnit;
df.Items[i].Name = Percentiles[i].ToString() + " percentile";
}
for (int i = 0; i < Percentiles.Count(); i++)
{
df.WriteItemTimeStep(0, i + 1, OutData[i]);
}
}
/// <summary>
/// Calculates the Percentiles [0;1] of an Item. MaxEntriesInMemory is used to reduce the memory consumption by sweeping multiple times. Units is MB of memory
/// </summary>
public void Percentile(int Item, DFSBase df, double[] Percentiles, int MaxEntriesInMemory)
{
int[] TSteps = new int[NumberOfTimeSteps];
for (int i=0;i<NumberOfTimeSteps;i++)
TSteps[i]=i;
Percentile(Item, TSteps, df, Percentiles, MaxEntriesInMemory);
}
public void Percentile(int Item, int[] TSteps, DFSBase df, double[] Percentiles)
{
Percentile(Item, TSteps, df, Percentiles, 500);
}
/// <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)
{
//Initialize all items and fill the buffer with Deletevalues
Dictionary<int, float[]> BufferData = new Dictionary<int, float[]>();
foreach (var j in Items)
{
BufferData[j] = new float[dfsdata.Count()];
for (int i = 0; i < dfsdata.Count(); i++)
BufferData[j][i] = (float)DeleteValue;
}
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);
if (df._timeAxis == TimeAxisType.CalendarNonEquidistant)
df.AppendTimeStep(df.TimeSteps.Last().AddDays(30));
df.WriteItemTimeStep(df.NumberOfTimeSteps, j, BufferData[j]);
//Reset buffer
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 (i == 0) //fill initial values in buffer
{
foreach (var k in NonDeleteIndex)
{
if (mathtype == MathType.Min)
BufferData[j][k] = float.MaxValue;
else if (mathtype == MathType.Max)
BufferData[j][k] = float.MinValue;
else
BufferData[j][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]);
}
}
/// <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 MonthAggregation(int Item, DFSBase df)
{
SortedList<int, float[]> SumBuffer = new SortedList<int, float[]>();
SortedList<int, float[]> MaxBuffer = new SortedList<int, float[]>();
SortedList<int, float[]> MinBuffer = new SortedList<int, float[]>();
Dictionary<int, int> TstepCounter = new Dictionary<int, int>();
df.Items[0].Name = "MonthlyAverage";
df.items[0].EumItem = this.Items[Item-1].EumItem;
df.Items[1].Name = "MonthlyMax";
df.items[1].EumItem = this.Items[Item-1].EumItem;
df.Items[2].Name = "MonthlyMin";
df.items[2].EumItem = this.Items[Item-1].EumItem;
//Initialize arrays
foreach (var month in TimeSteps.Select(t => t.Month).Distinct())
{
TstepCounter.Add(month, 0);
SumBuffer.Add(month, new float[dfsdata.Count()]);
MaxBuffer.Add(month, new float[dfsdata.Count()]);
MinBuffer.Add(month, new float[dfsdata.Count()]);
//Set everything to delete values
for (int i = 0; i < dfsdata.Count(); i++)
{
SumBuffer[month][i] = (float)DeleteValue;
MaxBuffer[month][i] = (float)DeleteValue;
MinBuffer[month][i] = (float)DeleteValue;
}
ReadItemTimeStep(0, Item);
foreach (var k in NonDeleteIndex)
{
SumBuffer[month][k] = 0;
MaxBuffer[month][k] = float.MinValue;
MinBuffer[month][k] = float.MaxValue;
}
}
//Loop the time steps
for (int i = 0; i < NumberOfTimeSteps; i++)
{
int currentmonth = TimeSteps[i].Month;
ReadItemTimeStep(i, Item);
TstepCounter[currentmonth] += 1;
foreach (var k in NonDeleteIndex)
{
SumBuffer[currentmonth][k] += dfsdata[k];
if (dfsdata[k] != (float)DeleteValue)
{
MaxBuffer[currentmonth][k] = Math.Max(MaxBuffer[currentmonth][k], dfsdata[k]);
MinBuffer[currentmonth][k] = Math.Min(MinBuffer[currentmonth][k], dfsdata[k]);
}
}
}
//Go from sum to average
for(int i =0;i< SumBuffer.Count;i++)
{
foreach (var k in NonDeleteIndex)
SumBuffer.Values[i][k] /= TstepCounter[SumBuffer.Keys[i]];
df.WriteItemTimeStep(i, 1, SumBuffer.Values[i]);
df.WriteItemTimeStep(i, 2, MaxBuffer.Values[i]);
df.WriteItemTimeStep(i, 3, MinBuffer.Values[i]);
}
}
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);
//Adjust z-count if we go from dfs3 to dfs2
if (_numberOfLayers == 1 & dfs._numberOfLayers > 1)
{
en = en / dfs._numberOfLayers;
xkey = xkey.Take(en).ToArray();
ykey = ykey.Take(en).ToArray();
zkey = zkey.Take(en).ToArray();
for (int i = 0; i < en; i++)
zkey[i] = 0;
}
DfsDLLWrapper.dfsSetEncodeKey(_headerPointer, xkey, ykey, zkey, en);
}
}
public override void CopyFromTemplate(DFSBase dfs)
{
base.CopyFromTemplate(dfs);
InsertTimeStep(dfs.TimeOfFirstTimestep);
IsDirty = false;
}
public override void CopyFromTemplate(DFSBase DFSTemplate1)
{
base.CopyFromTemplate(DFSTemplate1);
DFS2DBase DFSTemplate = DFSTemplate1 as DFS2DBase;
CopyGrid(DFSTemplate);
}
/// <summary>
/// Calculates the Percentiles [0;1] of an Item. MaxEntriesInMemory is used to reduce the memory consumption by sweeping multiple times. Units is MB of memory
/// </summary>
public void Percentile(int Item, int[] TSteps, DFSBase df, double[] Percentiles, int MaxEntriesInMemory)
{
//List counts percentiles
float[][] OutData = new float[Percentiles.Count()][];
for (int i = 0; i < Percentiles.Count(); i++)
{
OutData[i] = new float[dfsdata.Count()];
}
List <int> steps = new List <int>();
steps.Add(0);
//Get the delete values
float delete = DfsDLLWrapper.dfsGetDeleteValFloat(_headerPointer);
//Read first time step and create a list with the indeces of non-delete values
ReadItemTimeStep(0, Item);
List <int> NonDeleteEntries = new List <int>();
for (int i = 0; i < dfsdata.Length; i++)
{
if (dfsdata[i] != delete)
{
NonDeleteEntries.Add(i);
}
}
//Find out how many sweeps are necessary to not exceed max memory
double TotalData = (double)NonDeleteEntries.Count * (double)TSteps.Count();
if (TotalData > (MaxEntriesInMemory * 40000))
{
int nsteps = (int)Math.Max(TotalData / (MaxEntriesInMemory * 40000), 1);
int StepLength = NonDeleteEntries.Count() / nsteps;
for (int i = 0; i < nsteps; i++)
{
steps.Add(steps.Last() + StepLength);
}
}
steps.Add(NonDeleteEntries.Count);
//Now start the loop
for (int m = 0; m < steps.Count - 1; m++)
{
int dfscount = steps[m + 1] - steps[m];
//First iterater is dfsdata
float[][] Data = new float[dfscount][];
for (int i = 0; i < Data.Count(); i++)
{
Data[i] = new float[TSteps.Count()];
}
//Collect all data
for (int i = 0; i < TSteps.Count(); i++)
{
var data = ReadItemTimeStep(TSteps[i], Item);
int local = 0;
for (int k = steps[m]; k < steps[m + 1]; k++)
{
Data[local][i] = (dfsdata[NonDeleteEntries[k]]);
local++;
}
}
int local2 = 0;
for (int k = steps[m]; k < steps[m + 1]; k++)
{
//Convert to doubles from float
double[] ddata = new double[TSteps.Count()];
for (int n = 0; n < TSteps.Count(); n++)
{
ddata[n] = Data[local2][n];
}
//Calculate the percentile
MathNet.Numerics.Statistics.Percentile pCalc = new MathNet.Numerics.Statistics.Percentile(ddata);
pCalc.Method = MathNet.Numerics.Statistics.PercentileMethod.Excel;
var p = pCalc.Compute(Percentiles);
for (int l = 0; l < Percentiles.Count(); l++)
{
OutData[l][NonDeleteEntries[k]] = (float)p[l];
}
local2++;
}
}
//Insert deletevalues in output data
for (int i = 0; i < dfsdata.Length; i++)
{
if (!NonDeleteEntries.Contains(i))
{
for (int l = 0; l < Percentiles.Count(); l++)
{
OutData[l][i] = delete;
}
}
}
//Set Item infor
for (int i = 0; i < Percentiles.Count(); i++)
{
df.Items[i].EumItem = Items[Item - 1].EumItem;
df.Items[i].EumUnit = Items[Item - 1].EumUnit;
df.Items[i].Name = Percentiles[i].ToString() + " percentile";
}
for (int i = 0; i < Percentiles.Count(); i++)
{
df.WriteItemTimeStep(0, i + 1, OutData[i]);
}
}
public void Percentile(int Item, int[] TSteps, DFSBase df, double[] Percentiles)
{
Percentile(Item, TSteps, df, Percentiles, 500);
}
/// <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)
{
//Initialize all items and fill the buffer with Deletevalues
Dictionary <int, float[]> BufferData = new Dictionary <int, float[]>();
foreach (var j in Items)
{
BufferData[j] = new float[dfsdata.Count()];
for (int i = 0; i < dfsdata.Count(); i++)
{
BufferData[j][i] = (float)DeleteValue;
}
}
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);
}
}
if (df._timeAxis == TimeAxisType.CalendarNonEquidistant)
{
df.AppendTimeStep(df.TimeSteps.Last().AddDays(30));
}
df.WriteItemTimeStep(df.NumberOfTimeSteps, j, BufferData[j]);
//Reset buffer
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 (i == 0) //fill initial values in buffer
{
foreach (var k in NonDeleteIndex)
{
if (mathtype == MathType.Min)
{
BufferData[j][k] = float.MaxValue;
}
else if (mathtype == MathType.Max)
{
BufferData[j][k] = float.MinValue;
}
else
{
BufferData[j][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]);
}
}
/// <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 MonthAggregation(int Item, DFSBase df)
{
SortedList <int, float[]> SumBuffer = new SortedList <int, float[]>();
SortedList <int, float[]> MaxBuffer = new SortedList <int, float[]>();
SortedList <int, float[]> MinBuffer = new SortedList <int, float[]>();
Dictionary <int, int> TstepCounter = new Dictionary <int, int>();
df.Items[0].Name = "MonthlyAverage";
df.items[0].EumItem = this.Items[Item - 1].EumItem;
df.Items[1].Name = "MonthlyMax";
df.items[1].EumItem = this.Items[Item - 1].EumItem;
df.Items[2].Name = "MonthlyMin";
df.items[2].EumItem = this.Items[Item - 1].EumItem;
//Initialize arrays
foreach (var month in TimeSteps.Select(t => t.Month).Distinct())
{
TstepCounter.Add(month, 0);
SumBuffer.Add(month, new float[dfsdata.Count()]);
MaxBuffer.Add(month, new float[dfsdata.Count()]);
MinBuffer.Add(month, new float[dfsdata.Count()]);
//Set everything to delete values
for (int i = 0; i < dfsdata.Count(); i++)
{
SumBuffer[month][i] = (float)DeleteValue;
MaxBuffer[month][i] = (float)DeleteValue;
MinBuffer[month][i] = (float)DeleteValue;
}
ReadItemTimeStep(0, Item);
foreach (var k in NonDeleteIndex)
{
SumBuffer[month][k] = 0;
MaxBuffer[month][k] = float.MinValue;
MinBuffer[month][k] = float.MaxValue;
}
}
//Loop the time steps
for (int i = 0; i < NumberOfTimeSteps; i++)
{
int currentmonth = TimeSteps[i].Month;
ReadItemTimeStep(i, Item);
TstepCounter[currentmonth] += 1;
foreach (var k in NonDeleteIndex)
{
SumBuffer[currentmonth][k] += dfsdata[k];
if (dfsdata[k] != (float)DeleteValue)
{
MaxBuffer[currentmonth][k] = Math.Max(MaxBuffer[currentmonth][k], dfsdata[k]);
MinBuffer[currentmonth][k] = Math.Min(MinBuffer[currentmonth][k], dfsdata[k]);
}
}
}
//Go from sum to average
for (int i = 0; i < SumBuffer.Count; i++)
{
foreach (var k in NonDeleteIndex)
{
SumBuffer.Values[i][k] /= TstepCounter[SumBuffer.Keys[i]];
}
df.WriteItemTimeStep(i, 1, SumBuffer.Values[i]);
df.WriteItemTimeStep(i, 2, MaxBuffer.Values[i]);
df.WriteItemTimeStep(i, 3, MinBuffer.Values[i]);
}
}
private void button4_Click(object sender, RoutedEventArgs e)
{
string ext = System.IO.Path.GetExtension(DFS2File.Text);
Microsoft.Win32.SaveFileDialog SaveFileDialog = new Microsoft.Win32.SaveFileDialog();
SaveFileDialog.Filter = string.Format("Known file types (*{0})|*{0}",ext);
SaveFileDialog.Title = "Merge into dfs-file";
if (SaveFileDialog.ShowDialog().HasValue)
{
DFS = DfsFileFactory.OpenFile(DFS2File.Text);
var dfsout = DfsFileFactory.CreateFile(SaveFileDialog.FileName, 1);
using (System.IO.StreamReader sr = new System.IO.StreamReader(TxtFile.Text))
{
dfsout.CopyFromTemplate(DFS);
dfsout.FirstItem.EumItem = DHI.Generic.MikeZero.eumItem.eumIPrecipitationRate;
dfsout.FirstItem.EumUnit = DHI.Generic.MikeZero.eumUnit.eumUmmPerDay;
dfsout.TimeStep = TimeControl.Value;
dfsout.TimeOfFirstTimestep = datePicker1.DateTimeSelected;
sr.ReadLine();
var gridcodes = DFS.ReadItemTimeStep(0, 1);
Dictionary<int, List<int>> GridcodesIndex = new Dictionary<int, List<int>>();
for (int i = 0; i<gridcodes.Count(); i++)
{
if (gridcodes[i] != DFS.DeleteValue)
{
List<int> grids;
if (!GridcodesIndex.TryGetValue((int)gridcodes[i], out grids))
{
grids = new List<int>();
GridcodesIndex.Add((int)gridcodes[i], grids);
}
grids.Add(i);
gridcodes[i] = (float)DFS.DeleteValue;
}
}
var splits = sr.ReadLine().Split(new string[] { " ", "\t" }, StringSplitOptions.RemoveEmptyEntries);
List<int> gridcodestxt = new List<int>(splits.Select(var => (int)float.Parse(var)));
int tscounter=0;
while (!sr.EndOfStream)
{
splits = sr.ReadLine().Split(new string[] { " ", "\t" }, StringSplitOptions.RemoveEmptyEntries);
for (int j = 0; j < splits.Count(); j++)
{
List<int> grids;
if (GridcodesIndex.TryGetValue(gridcodestxt[j], out grids))
{
float val = float.Parse(splits[j]);
foreach (var k in grids)
gridcodes[k] = val;
}
}
dfsout.WriteItemTimeStep(tscounter, 1, gridcodes);
tscounter++;
}
}
DFS.Dispose();
dfsout.Dispose();
}
}
public override void CopyFromTemplate(DFSBase DFSTemplate1)
{
base.CopyFromTemplate(DFSTemplate1);
this.NumberOfLayers = ((DFS3)DFSTemplate1).NumberOfLayers;
}
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 override void CopyFromTemplate(DFSBase dfs)
{
base.CopyFromTemplate(dfs);
InsertTimeStep(dfs.TimeOfFirstTimestep);
IsDirty = false;
}