private void openFileButton_Click(object sender, EventArgs e)
{
System.Windows.Forms.OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Title = "Open time series file file";
openFileDialog.Filter = "Open time series file (*.xts; *.xml)|*.xts; *.xml";
openFileDialog.ShowDialog();
if (openFileDialog.FileName.Length > 3)
{
if (System.IO.Path.GetExtension(openFileDialog.FileName).ToLower().Equals(".xml"))
{
timeSeriesGroup = TimeSeriesGroupFactory.CreateAll(openFileDialog.FileName);
}
else
{
timeSeriesGroup = TimeSeriesGroupFactory.Create(openFileDialog.FileName);
}
foreach (BaseTimeSeries timeSeries in timeSeriesGroup.Items)
{
itemSelectionComboBox.Items.Add(timeSeries.Name);
}
itemSelectionComboBox.SelectedIndex = 0;
OkButton.Enabled = true;
}
}
public void MyTestInitialize()
{
filename = "HydroNumerics.Time.OpenMI.UnitTest.LinkableTimeSeriesGroupTest.xts";
outputFilename = "HydroNumerics.Time.OpenMI.UnitTest.LinkableTimeSeriesGroupTest.out.xts";
TimespanSeries timespanSeries = new TimespanSeries("Flow", new System.DateTime(2010, 1, 1), 10, 2, TimestepUnit.Days, 4.3);
timespanSeries.Unit = new HydroNumerics.Core.Unit("Liters pr. sec", 0.001, 0.0, "Liters pr second");
timespanSeries.Unit.Dimension.Length = 3;
timespanSeries.Unit.Dimension.Time = -1;
timespanSeries.Description = "Measured Flow";
TimestampSeries timestampSeries = new TimestampSeries("Water Level", new System.DateTime(2010, 1, 1), 6, 2, TimestepUnit.Days, 6.3);
timestampSeries.Unit = new HydroNumerics.Core.Unit("cm", 0.01, 0.0, "centimeters");
timestampSeries.Unit.Dimension.Length = 1;
timestampSeries.Description = "Measured Head";
TimeSeriesGroup tsg = new TimeSeriesGroup();
tsg.Name = "MyTsGroup";
tsg.Items.Add(timespanSeries);
tsg.Items.Add(timestampSeries);
tsg.Save(filename);
Argument filenameArgument = new Argument("Filename", filename, true, "someDescription");
Argument outputFilenameArgument = new Argument("OutputFilename", outputFilename, true, "someDescription");
arguments = new Argument[2] {
filenameArgument, outputFilenameArgument
};
}
private static double GetTotalByIdAndDay(TimeSeriesGroup data, string[] ids, DateTime startDateTime)
{
var endDateTime = startDateTime + TimeSpan.FromDays(1);
if (ids.Length == 1)
{
var timeSeries = data[ids[0]];
if (timeSeries?.AnyBetween(startDateTime, endDateTime) == true)
{
return timeSeries.TotalUntil(endDateTime);
}
}
else if (ids.Length > 1)
{
// create a sub group of all time series
TimeSeriesGroup group = new TimeSeriesGroup();
foreach (var exId in ids)
{
var item = data[exId];
if (item != null)
{
group.Add(item);
}
}
if (group.AnyBetween(startDateTime, endDateTime))
{
return group.TotalUntil(endDateTime);
}
}
return double.NaN;
}
public void Name()
{
TimeSeriesGroup timeSeriesGroup = new TimeSeriesGroup();
timeSeriesGroup.Name = "test name";
Assert.AreEqual("test name", timeSeriesGroup.Name);
}
public TimsspanSeriesPlotForm()
{
InitializeComponent();
timeSeriesGroup = new TimeSeriesGroup();
//TimestampSeries timestampSeries = new TimestampSeries();
//timestampSeries.AddTimeValueRecord(new TimeValue(new DateTime(2010, 1, 1, 0, 0, 0), 5.0));
//timestampSeries.AddTimeValueRecord(new TimeValue(new DateTime(2010, 1, 2, 0, 0, 0), 5.0));
//timestampSeries.AddTimeValueRecord(new TimeValue(new DateTime(2010, 1, 3, 0, 0, 0), 5.0));
//TimestampSeries timestampSeries1 = new TimestampSeries();
//timestampSeries1.AddTimeValueRecord(new TimeValue(new DateTime(2010, 1, 1, 0, 0, 0), 2.0));
//timestampSeries1.AddTimeValueRecord(new TimeValue(new DateTime(2010, 1, 2, 0, 0, 0), 2.0));
//timestampSeries1.AddTimeValueRecord(new TimeValue(new DateTime(2010, 1, 3, 0, 0, 0), 2.0));
TimespanSeries timespanSeries = new TimespanSeries();
timespanSeries.Items.Add(new TimespanValue(new Timespan(new DateTime(2010, 1, 1, 0, 0, 0), new DateTime(2010, 1, 2, 0, 0, 0)), 2));
timespanSeries.Items.Add(new TimespanValue(new Timespan(new DateTime(2010, 1, 2, 0, 0, 0), new DateTime(2010, 1, 3, 0, 0, 0)), 3));
timespanSeries.Items.Add(new TimespanValue(new Timespan(new DateTime(2010, 1, 3, 0, 0, 0), new DateTime(2010, 1, 4, 0, 0, 0)), 6));
//timeSeriesGroup.TimeSeriesList.Add(timestampSeries);
//timeSeriesGroup.TimeSeriesList.Add(timestampSeries1);
timeSeriesGroup.Items.Add(timespanSeries);
timeSeriesPlot = new TimeSeriesPlot(timeSeriesGroup);
timeSeriesPlot.Visible = true;
timeSeriesPlot.Anchor = (AnchorStyles.Bottom | AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right);
this.Controls.Add(timeSeriesPlot);
this.Update();
}
public void Write(IEnumerable<ITimeSeries> timeSeriesGroup, string summaryFile, SummaryConfig excelConfig)
{
if (timeSeriesGroup == null) throw new ArgumentNullException(nameof(timeSeriesGroup));
if (timeSeriesGroup.Any(x => x == null)) throw new ArgumentException("IEnumerable contains null values.", nameof(timeSeriesGroup));
if (excelConfig.Sheet == null) throw new ArgumentNullException(nameof(excelConfig.Sheet));
if (excelConfig.Row <= 0) throw new ArgumentOutOfRangeException(nameof(excelConfig.Row), "Value must be higher than 0.");
if (!(timeSeriesGroup is TimeSeriesGroup timeSeriesGroupInstance))
{
timeSeriesGroupInstance = new TimeSeriesGroup();
timeSeriesGroupInstance.AddRange(timeSeriesGroup);
}
using (var excelPack = new ExcelPackage(new FileInfo(summaryFile)))
{
var worksheet = excelPack.Workbook.Worksheets[excelConfig.Sheet];
if (worksheet == null)
{
throw new InvalidDataException($"Table '{excelConfig.Sheet}' not found.");
}
var edrWorksheet = new EppWorksheet(worksheet);
FillDataIntoTable(edrWorksheet, timeSeriesGroupInstance, excelConfig.Row);
excelPack.Save();
}
}
//=====================================================================================================
// Menu: File | New...
//=====================================================================================================
private void newToolStripMenuItem_Click(object sender, EventArgs e)
{
TimeSeriesCreationDialog timeSeriesCreationDialog = new TimeSeriesCreationDialog();
timeSeriesCreationDialog.ShowDialog();
this.timeSeriesGroup = new TimeSeriesGroup();
BaseTimeSeries timeseries = timeSeriesCreationDialog.TimeSeries;
timeSeriesGroup.Items.Add(timeseries);
if (timeseries is TimestampSeries)
{
this.timestampSeriesGrid.TimeSeriesData = (TimestampSeries)timeseries;
this.timespanSeriesGrid.Visible = false;
this.timestampSeriesGrid.Visible = true;
}
else if (timeseries is TimespanSeries)
{
this.timespanSeriesGrid.TimeSeriesData = (TimespanSeries)timeseries;
this.timestampSeriesGrid.Visible = false;
this.timespanSeriesGrid.Visible = true;
}
this.tsPlot.TimeSeriesDataSet = this.timeSeriesGroup;
this.tsPlot.Repaint();
this.tsPlot.Visible = true;
}
/// <summary>
/// Small program that extracts a time series from a time variant dfs2.
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
TimespanSeries PrecipTS = new TimespanSeries();
PrecipTS.Name = "Precipitation";
PrecipTS.Description = "Precipitation extracted from dfs2";
PrecipTS.Unit = UnitFactory.Instance.GetUnit(NamedUnits.millimeterperday);
//Open the DFS2-file
DFS2 precip = new DFS2(@"C:\Users\Jacob\Projekter\MikeSheWrapperForGEUS\novomr6\2-layer-filer\Standard_korrigeret_Prec_DK_10km_1990-2008.dfs2");
//UTM-coordinates for Gjeller sø
double XUTM = 456198;
double YUTM = 6272321;
//Get column and row index from UTM- coordinates
int col = precip.GetColumnIndex(XUTM);
int row = precip.GetRowIndex(YUTM);
//Loop all the time steps
for (int i = 0; i < precip.NumberOfTimeSteps; i++)
{
//Extract the value
var val = precip.GetData(i, 1)[row, col];
//Insert into timeseries
PrecipTS.AddValue(precip.TimeSteps[i].Subtract(TimeSpan.FromDays(1)), precip.TimeSteps[i], val);
}
precip.Dispose();
//Now do the same for evaporation. DFS2-file may have another grid and timesteps
DFS2 evap = new DFS2(@"C:\Users\Jacob\Projekter\MikeSheWrapperForGEUS\novomr6\2-layer-filer\Novana_DK_EPmak_40km_1990-1998_20km_1999-2008_ed.dfs2");
TimespanSeries EvapTS = new TimespanSeries();
EvapTS.Name = "Evaporation";
EvapTS.Description = "Evaporation extracted from dfs2";
EvapTS.Unit = UnitFactory.Instance.GetUnit(NamedUnits.millimeterperday);
//Get column and row index from UTM- coordinates
col = evap.GetColumnIndex(XUTM);
row = evap.GetRowIndex(YUTM);
for (int i = 0; i < evap.NumberOfTimeSteps; i++)
{
//Extract the value
var val = evap.GetData(i, 1)[row, col];
//Insert into timeseries
EvapTS.AddValue(evap.TimeSteps[i].Subtract(TimeSpan.FromDays(1)), evap.TimeSteps[i], val);
}
//Put all time series into a group and save
TimeSeriesGroup tsgroup = new TimeSeriesGroup();
tsgroup.Items.Add(PrecipTS);
tsgroup.Items.Add(EvapTS);
tsgroup.Save(@"C:\Users\Jacob\Projekter\GWSW-Interaction\Gjeller Sø\climate.xts");
}
private TimeSeriesGroup CreateTimeSeriesGroup()
{
TimeSeriesGroup tsg = new TimeSeriesGroup();
tsg.Items.Add(new TimestampSeries("test1", new System.DateTime(1965, 2, 3), 10, 1, TimestepUnit.Years, 1));
tsg.Items.Add(new TimestampSeries("test2", new System.DateTime(1955, 2, 3), 10, 1, TimestepUnit.Years, 1));
tsg.Items.Add(new TimespanSeries("test2", new System.DateTime(1967, 2, 3), 10, 1, TimestepUnit.Years, 1));
return(tsg);
}
public void TimeSeriesGroup_AddNullElements_Throws()
{
var group = new TimeSeriesGroup();
Assert.Throws <ArgumentNullException>(() => group.Add(null));
Assert.Throws <ArgumentNullException>(() => group.AddRange(null));
Assert.Throws <ArgumentException>(() => group.AddRange(new List <ITimeSeries>()
{
null
}));
}
public void TimeSeriesGroup_Empty()
{
var group = new TimeSeriesGroup();
Assert.Equal(0, group.Count);
Assert.Null(group.FirstDataPoint);
Assert.Null(group.LastDataPoint);
Assert.False(group.AnyBetween(DateTimeOffset.MinValue, DateTimeOffset.MaxValue));
Assert.InRange(group.Sum(DateTimeOffset.MinValue, DateTimeOffset.MaxValue), 0.0 - Accuracy, 0.0 + Accuracy);
Assert.InRange(group.TotalUntil(DateTimeOffset.MaxValue), 0.0 - Accuracy, 0.0 + Accuracy);
}
public HideOrShowCurves(TimeSeriesGroup timeSeriesGroup)
{
InitializeComponent();
checkedListBox1.CheckOnClick = true;
this.timeSeriesGroup = timeSeriesGroup;
for (int i = 0; i < timeSeriesGroup.Items.Count; i++)
{
checkedListBox1.Items.Add(timeSeriesGroup.Items[i].Name, timeSeriesGroup.Items[i].IsVisible);
}
}
public TimestampGridTestForm()
{
InitializeComponent();
timeSeriesGroup = new TimeSeriesGroup();
timeSeriesGroup.Items.Add(new TimestampSeries());
timeSeriesGridControl = new TimestampSeriesGrid((TimestampSeries)timeSeriesGroup.Items[0]);
timeSeriesGridControl.Visible = true;
timeSeriesGridControl.Anchor = (AnchorStyles.Bottom | AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right);
panel1.Controls.Add(timeSeriesGridControl);
this.Update();
}
public void Overlap()
{
TimeSeriesGroup tsg = CreateTimeSeriesGroup();
Assert.AreEqual(null, tsg.Overlap); // no overlap between all timeseries
tsg = new TimeSeriesGroup();
tsg.Items.Add(new TimestampSeries("test1", new System.DateTime(1965, 2, 3), 10, 1, TimestepUnit.Years, 1));
tsg.Items.Add(new TimestampSeries("test2", new System.DateTime(1962, 2, 3), 10, 1, TimestepUnit.Years, 1));
tsg.Items.Add(new TimespanSeries("test2", new System.DateTime(1967, 2, 3), 10, 1, TimestepUnit.Years, 1));
Assert.AreEqual(new System.DateTime(1967, 2, 3), tsg.Overlap.Start);
Assert.AreEqual(new System.DateTime(1971, 2, 3), tsg.Overlap.End);
}
private void FillDataIntoTable(IWorksheet worksheet, TimeSeriesGroup data, int excelIdRowIndex)
{
DateTime start = data.FirstDataPoint.CapturedAt.Date;
DateTime current = start;
DateTime end = data.LastDataPoint.CapturedAt.Date;
while (current <= end)
{
var rowIndex = GetOrCreateRowByDateTime(worksheet, current);
InsertData(worksheet, data, rowIndex, current, excelIdRowIndex);
current = NextDay(data, current);
}
}
// -- Open menu ---
private void openToolStripMenuItem_Click(object sender, EventArgs e)
{
System.Windows.Forms.OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Title = "Open time series file file";
openFileDialog.Filter = "Open time series file (*.xts;*.xml)|*.xts;*.xml";
openFileDialog.ShowDialog();
if (openFileDialog.FileName.Length > 3)
{
foreach (TimestampSeries timeSeriesData in timeSeriesGroup.Items)
{
while (timeSeriesData.Items.Count > 0)
{
timeSeriesData.Items.RemoveAt(0);
}
}
while (timeSeriesGroup.Items.Count > 0)
{
timeSeriesGroup.Items.RemoveAt(0);
}
this.bottomStatusStrip.Items[0].Text = "Loading time series file. Please wait...";
if (System.IO.Path.GetExtension(openFileDialog.FileName).ToLower().Equals(".xml"))
{
timeSeriesGroup = TimeSeriesGroupFactory.CreateAll(openFileDialog.FileName);
}
else
{
timeSeriesGroup = TimeSeriesGroupFactory.Create(openFileDialog.FileName);
}
this.tsPlot.TimeSeriesDataSet = this.timeSeriesGroup;
this.tsPlot.Visible = true;
this.bottomStatusStrip.Items[0].Text = "Ready...";
this.tsPlot.Repaint();
if (this.timeSeriesGroup.Items[0] is TimestampSeries)
{
this.timespanSeriesGrid.Visible = false;
this.timestampSeriesGrid.Visible = true;
this.timestampSeriesGrid.TimeSeriesData = (TimestampSeries)this.timeSeriesGroup.Items[0];
}
else if (this.timeSeriesGroup.Items[0] is TimespanSeries)
{
this.timestampSeriesGrid.Visible = false;
this.timespanSeriesGrid.Visible = true;
this.timespanSeriesGrid.TimeSeriesData = (TimespanSeries)this.timeSeriesGroup.Items[0];
}
}
}
public void Current()
{
TimeSeriesGroup timeSeriesGroup = new TimeSeriesGroup();
timeSeriesGroup.Items.Add(new TimestampSeries());
timeSeriesGroup.Items.Add(new TimestampSeries());
timeSeriesGroup.Items.Add(new TimestampSeries());
Assert.AreEqual(0, timeSeriesGroup.Current);
timeSeriesGroup.Current = 2;
Assert.AreEqual(2, timeSeriesGroup.Current);
timeSeriesGroup.Current = 3;
Assert.AreEqual(2, timeSeriesGroup.Current);
timeSeriesGroup.Current = -1;
Assert.AreEqual(0, timeSeriesGroup.Current);
}
public void TimeSeriesGroup_OneEmptyTimeSeries()
{
var group = new TimeSeriesGroup();
var container = new SensorTimeSeries("1234");
group.Add(container);
Assert.Equal(1, group.Count);
Assert.Null(group.FirstDataPoint);
Assert.Null(group.LastDataPoint);
Assert.False(group.AnyBetween(DateTimeOffset.MinValue, DateTimeOffset.MaxValue));
Assert.InRange(group.Sum(DateTimeOffset.MinValue, DateTimeOffset.MaxValue), 0.0 - Accuracy, 0.0 + Accuracy);
Assert.InRange(group.TotalUntil(DateTimeOffset.MaxValue), 0.0 - Accuracy, 0.0 + Accuracy);
}
private void InsertData(IWorksheet worksheet, TimeSeriesGroup data, int rowIndex, DateTime startDateTime, int excelIdRowIndex)
{
var colsCount = worksheet.Cols;
for (int col = 1; col <= colsCount; col++)
{
var idStr = worksheet[excelIdRowIndex, col]?.ToString();
var ids = GetIds(idStr, COL_SEPERATOR);
if (ids.Length == 0)
{
continue;
}
if (ids.Length == 1 && data[ids[0]] is MeteoTimeSeries)
{
var meteoTimeSeries = data[ids[0]] as MeteoTimeSeries;
var endDateTime = startDateTime + TimeSpan.FromDays(1);
var dataPoint = meteoTimeSeries.FirstOrDefault(x =>
x.CapturedAt >= startDateTime &&
x.CapturedAt < endDateTime &&
x.CapturedAt.ToUniversalTime().Hour == 12);
if (dataPoint != null)
{
var value = dataPoint.Value.ToString("0.##", CultureInfo.InvariantCulture);
worksheet[rowIndex, col] = value;
}
}
else
{
var total = GetTotalByIdAndDay(data, ids, startDateTime);
// change unit (Wh to kWh)
total /= 1000.0;
// rounding to 2 fractional digits
total = Math.Round(total, 2);
// write value to excel field
if (!double.IsNaN(total))
{
var value = total.ToString("0.##", CultureInfo.InvariantCulture);
worksheet[rowIndex, col] = value;
}
}
}
}
private static DateTime NextDay(TimeSeriesGroup dataPoints, DateTime currentDateTime)
{
var tomorrow = currentDateTime + TimeSpan.FromDays(1);
if (dataPoints.Any(x => tomorrow >= x.First.CapturedAt && tomorrow < x.Last.CapturedAt))
{
return tomorrow;
}
var leftTimeSeries = dataPoints.OrderBy(x => x.Last.CapturedAt).SkipWhile(x => tomorrow > x.Last.CapturedAt);
return !leftTimeSeries.Any() ?
tomorrow :
leftTimeSeries
.Aggregate((minItem, nextItem) => minItem.First.CapturedAt < nextItem.First.CapturedAt ? minItem : nextItem)
.First.CapturedAt.Date;
}
public void PropertyChangedEvent()
{
TimeSeriesGroup timeSeriesGroup = new TimeSeriesGroup();
timeSeriesGroup.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(timeSeriesGroup_PropertyChanged);
eventWasRaised = false;
timeSeriesGroup.Items.Add(new TimestampSeries());
Assert.IsTrue(eventWasRaised); eventWasRaised = false;
((TimestampSeries)timeSeriesGroup.Items[0]).AppendValue(4.3);
Assert.IsTrue(eventWasRaised); eventWasRaised = false;
((TimestampSeries)timeSeriesGroup.Items[0]).Items[0].Value = 2.1;
Assert.IsTrue(eventWasRaised); eventWasRaised = false;
((TimestampSeries)timeSeriesGroup.Items[0]).Items[0].Time = new System.DateTime(2010, 1, 1, 0, 0, 0);
Assert.IsTrue(eventWasRaised); eventWasRaised = false;
//TODO: more testing needed
}
public void Initialize(System.Collections.Hashtable properties)
{
currentTimestep = 0;
simulationStart = new DateTime(2001, 1, 1);
dt = 172800; //timestep length (2 days)
nt = 80; // number of timesteps
nx = 2; //number of grid cells in x-direction
ny = 2; //number of grid cells in y-direction
grid = new RegularGrid(10, 10, 1000, nx, ny, 0);
groundwaterHeads = new TimeSeriesGroup();
infiltrations = new TimeSeriesGroup();
for (int i = 0; i < nx * ny; i++)
{
groundwaterHeads.Items.Add(new TimestampSeries("GwHead" + i.ToString(), simulationStart, nt, dt, TimestepUnit.Seconds, 4.9, new HydroNumerics.Core.Unit("meters", 1.0, 0.0)));
infiltrations.Items.Add(new TimestampSeries("Infiltration" + i.ToString(), simulationStart, nt, dt, TimestepUnit.Seconds, -9999.9999, new HydroNumerics.Core.Unit("flow", 1.0, 0.0)));
}
Quantity infiltQuantity = new Quantity();
infiltQuantity.Unit = new HydroNumerics.OpenMI.Sdk.Backbone.Unit("level", 1.0, 0.0);
infiltQuantity.ID = "Infiltration";
infiltQuantity.Description = "infiltration";
infiltQuantity.ValueType = global::OpenMI.Standard.ValueType.Scalar;
InputExchangeItem infiltExItem = new InputExchangeItem();
infiltExItem.Quantity = infiltQuantity;
infiltExItem.ElementSet = grid;
inputExchangeItems = new List <InputExchangeItem>();
inputExchangeItems.Add(infiltExItem);
Quantity headQuantity = new Quantity();
headQuantity.Description = "Groundwater head";
headQuantity.ID = "Head";
headQuantity.Unit = new HydroNumerics.OpenMI.Sdk.Backbone.Unit("meters", 1, 0);
headQuantity.ValueType = global::OpenMI.Standard.ValueType.Scalar;
OutputExchangeItem headOutItem = new OutputExchangeItem();
headOutItem.Quantity = headQuantity;
headOutItem.ElementSet = grid;
outputExchangeItems = new List <OutputExchangeItem>();
outputExchangeItems.Add(headOutItem);
}
public void Create()
{
string filename = "HydroNumerics.Time.Core.UnitTest.TimeSeriesGroupFactoryTest.Create.xts";
TimeSeriesGroup tsg = new TimeSeriesGroup();
TimespanSeries timespanSeries = new TimespanSeries("timespanseriesname", new System.DateTime(2010, 1, 1), 10, 2, TimestepUnit.Days, 4.3);
TimestampSeries timestampSeries = new TimestampSeries("timestampseriesname", new System.DateTime(2010, 1, 1), 10, 2, TimestepUnit.Days, 4.3);
tsg.Items.Add(timespanSeries);
tsg.Items.Add(timestampSeries);
tsg.Save(filename);
TimeSeriesGroup tsg2 = TimeSeriesGroupFactory.Create(filename);
for (int i = 0; i < tsg.Items.Count; i++)
{
Assert.AreEqual(tsg.Items[i], tsg2.Items[i]);
}
}
public HydroCatEngine()
{
isConfigurated = false;
//--- Default values ----
SimulationStartTime = new DateTime(2010, 1, 1);
SimulationEndTime = new DateTime(2011, 1, 1);
OutputTimeSeries = new TimeSeriesGroup();
//-- Default values (parameters)
this.CatchmentArea = 160000000;
this.SnowmeltCoefficient = 2.0;
this.SurfaceStorageCapacity = 18;
this.RootZoneStorageCapacity = 250;
this.OverlandFlowCoefficient = 0.61;
this.InterflowCoefficient = 0.6;
this.OverlandFlowTreshold = 0.38;
this.InterflowTreshold = 0.08;
this.OverlandFlowTimeConstant = 0.3;
this.InterflowTimeConstant = 30;
this.BaseflowTimeConstant = 2800;
}
public void Save()
{
string filename = "HydroNumerics.Time.Core.UnitTest.TimeSeriesGroupTest.Save.xts";
TimespanSeries timespanSeries = new TimespanSeries("Flow", new System.DateTime(2010, 1, 1), 10, 2, TimestepUnit.Days, 4.3);
timespanSeries.Unit = new HydroNumerics.Core.Unit("Liters pr. sec", 0.001, 0.0, "Liters pr second");
timespanSeries.Unit.Dimension.Length = 3;
timespanSeries.Unit.Dimension.Time = -1;
timespanSeries.Description = "Measured Flow";
TimestampSeries timestampSeries = new TimestampSeries("Water Level", new System.DateTime(2010, 1, 1), 6, 2, TimestepUnit.Days, 6.3);
timestampSeries.Unit = new HydroNumerics.Core.Unit("cm", 0.01, 0.0, "centimeters");
timestampSeries.Unit.Dimension.Length = 1;
timestampSeries.Description = "Measured Head";
TimeSeriesGroup tsg = new TimeSeriesGroup();
tsg.Name = "MyTsGroup";
tsg.Items.Add(timespanSeries);
tsg.Items.Add(timestampSeries);
tsg.Save(filename);
}
public TimeSeriesEditor()
{
InitializeComponent();
timeSeriesGroup = new TimeSeriesGroup();
timestampSeriesGrid = new TimestampSeriesGrid();
timestampSeriesGrid.Visible = false;
timespanSeriesGrid = new TimespanSeriesGrid();
timespanSeriesGrid.Visible = false;
tsPlot = new TimeSeriesPlot(timeSeriesGroup);
//tsPlot.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) | System.Windows.Forms.AnchorStyles.Left) | System.Windows.Forms.AnchorStyles.Right)));
tsPlot.Height = this.mainSplitContainer.Panel1.Height;
tsPlot.Width = this.mainSplitContainer.Panel1.Width;
this.mainSplitContainer.Panel1.Controls.Add(tsPlot);
tsPlot.Anchor = (AnchorStyles.Bottom | AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right);
timestampSeriesGrid.Anchor = (AnchorStyles.Bottom | AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right);
timespanSeriesGrid.Anchor = (AnchorStyles.Bottom | AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right);
this.mainSplitContainer.Panel2.Controls.Add(timestampSeriesGrid);
this.mainSplitContainer.Panel2.Controls.Add(timespanSeriesGrid);
this.tsPlot.Visible = false;
this.Update();
}
public TimespanSeriesPlot(TimeSeriesGroup timeSeriesDataSet)
{
InitializeComponent();
TimeSeriesDataSet = timeSeriesDataSet;
}
public override void Initialize(IArgument[] properties)
{
SendEvent(new Event(EventType.Informative, this, "Started initialization.."));
Dictionary <string, string> arguments = new Dictionary <string, string>();
for (int i = 0; i < properties.Length; i++)
{
arguments.Add(properties[i].Key, properties[i].Value);
}
filename = arguments["Filename"];
outputFilename = arguments["OutputFilename"];
tsGroup = TimeSeriesGroupFactory.Create(filename);
foreach (BaseTimeSeries baseTimeSeries in tsGroup.Items)
{
HydroNumerics.OpenMI.Sdk.Backbone.Dimension dimention = new HydroNumerics.OpenMI.Sdk.Backbone.Dimension();
dimention.AmountOfSubstance = baseTimeSeries.Unit.Dimension.AmountOfSubstance;
dimention.Currency = baseTimeSeries.Unit.Dimension.Currency;
dimention.ElectricCurrent = baseTimeSeries.Unit.Dimension.ElectricCurrent;
dimention.Length = baseTimeSeries.Unit.Dimension.Length;
dimention.LuminousIntensity = baseTimeSeries.Unit.Dimension.LuminousIntensity;
dimention.Mass = baseTimeSeries.Unit.Dimension.Mass;
dimention.Time = baseTimeSeries.Unit.Dimension.Time;
HydroNumerics.OpenMI.Sdk.Backbone.Unit unit = new HydroNumerics.OpenMI.Sdk.Backbone.Unit();
unit.ID = baseTimeSeries.Unit.ID;
unit.Description = baseTimeSeries.Unit.Description;
unit.ConversionFactorToSI = baseTimeSeries.Unit.ConversionFactorToSI;
unit.OffSetToSI = baseTimeSeries.Unit.OffSetToSI;
TsQuantity quantity = new TsQuantity();
quantity.ID = baseTimeSeries.Name;
quantity.Description = baseTimeSeries.Description;
quantity.Dimension = dimention;
quantity.Unit = unit;
quantity.BaseTimeSeries = baseTimeSeries;
ElementSet elementSet = new ElementSet();
elementSet.ID = "IDBased";
elementSet.Description = "IDBased";
elementSet.ElementType = global::OpenMI.Standard.ElementType.IDBased;
elementSet.SpatialReference = new SpatialReference("Undefined");
Element element = new Element();
element.ID = "IDBased";
elementSet.AddElement(element);
OutputExchangeItem outputExchangeItem = new OutputExchangeItem();
outputExchangeItem.Quantity = quantity;
outputExchangeItem.ElementSet = elementSet;
this.AddOutputExchangeItem(outputExchangeItem);
InputExchangeItem inputExchangeItem = new InputExchangeItem();
inputExchangeItem.Quantity = quantity;
inputExchangeItem.ElementSet = elementSet;
this.AddInputExchangeItem(inputExchangeItem);
}
initializeWasInvoked = true;
SendEvent(new Event(EventType.Informative, this, "Completed initialization"));
}
public override void Initialize()
{
Dictionary <string, string> argumentsDictionary = new Dictionary <string, string>();
//TODO: Check that you can assume that e.g. a configuration editor will populate the Argumenst, based on data from the OMI file
foreach (IArgument argument in this.Arguments)
{
argumentsDictionary.Add(argument.Id, argument.ValueAsString);
}
filename = argumentsDictionary["Filename"];
//outputFilename = argumentsDictionary["OutputFilename"];
timeSeriesGroup = TimeSeriesGroupFactory.Create(filename);
Outputs = new List <IBaseOutput>();
foreach (var ts in timeSeriesGroup.Items)
{
Dimension dimention = new Dimension();
dimention.SetPower(DimensionBase.AmountOfSubstance, ts.Unit.Dimension.AmountOfSubstance);
dimention.SetPower(DimensionBase.Currency, ts.Unit.Dimension.Currency);
dimention.SetPower(DimensionBase.ElectricCurrent, ts.Unit.Dimension.ElectricCurrent);
dimention.SetPower(DimensionBase.Length, ts.Unit.Dimension.Length);
dimention.SetPower(DimensionBase.LuminousIntensity, ts.Unit.Dimension.LuminousIntensity);
dimention.SetPower(DimensionBase.Mass, ts.Unit.Dimension.Mass);
dimention.SetPower(DimensionBase.Time, ts.Unit.Dimension.Time);
Unit unit = new Unit(ts.Unit.ID);
unit.Description = ts.Unit.Description;
unit.ConversionFactorToSI = ts.Unit.ConversionFactorToSI;
unit.OffSetToSI = ts.Unit.OffSetToSI;
unit.Dimension = dimention;
Quantity quantity = new Quantity();
quantity.Caption = ts.Name;
quantity.Description = ts.Description;
quantity.Unit = unit;
ElementSet elementSet = new ElementSet("IDBased");
elementSet.Description = "IDBased";
elementSet.ElementType = global::OpenMI.Standard2.TimeSpace.ElementType.IdBased;
Element element = new Element();
element.Caption = "IDBased";
elementSet.AddElement(element);
Output o = new Output(ts.Name, quantity, elementSet);
o.TimeSet = new TimeSet();
o.Values = new HydroNumerics.OpenMI.Sdk.Backbone.Generic.TimeSpaceValueSet <double>();
if (ts is TimespanSeries)
{
foreach (var tsi in ((TimespanSeries)ts).Items)
{
o.TimeSet.Times.Add(new HydroNumerics.OpenMI.Sdk.Backbone.Time(ts.StartTime, ts.EndTime));
o.Values.Values2D.Add(new List <double> {
tsi.Value
});
}
}
else
{
foreach (var tsi in ((TimestampSeries)ts).Items)
{
o.TimeSet.Times.Add(new HydroNumerics.OpenMI.Sdk.Backbone.Time(ts.StartTime));
o.Values.Values2D.Add(new List <double> {
tsi.Value
});
}
}
Outputs.Add(o);
}
Caption = timeSeriesGroup.Name;
Description = timeSeriesGroup.Name;
}
public TimeSeriesGroupPropertiesDialog(TimeSeriesGroup timeSeriesGroup)
{
InitializeComponent();
propertyGrid1.SelectedObject = timeSeriesGroup;
}
