public void AddDA_variable(SmOutput.OutputType outputType, string nodeOrOutlet, string toNode, string name, string additionalParams) { if (DA_Points == null) { DA_Points = new List <EnsembleValuesForPoint>(); E = DenseMatrix.Create(models[0].state.values.Length, models.Length, 0); //Updater = new EnKFsmartInflation(); Updater = new EnKF(); } EnsembleValuesForPoint DApoint; switch (outputType) { case SmOutput.OutputType.outletFlowTimeSeries: case SmOutput.OutputType.nodeWaterLevel: DApoint = new EnsembleValuesForPoint(models, outputType, nodeOrOutlet, additionalParams); break; default: throw new NotImplementedException(); } DA_Points.Add(DApoint); p_DA_obs++; }
public bool addOutputVariable(string nodeName, SmOutput.OutputType type) { bool bsuccess = false; if (type != SmOutput.OutputType.nodeVolume) { throw new Exception("Unsupported output type for node " + nodeName); } foreach (Node _node in nodes) { if (_node.name == nodeName) { SmOutput xout = new SmOutput(); xout.type = SmOutput.OutputType.nodeVolume; xout.name = "Volume in " + nodeName; xout.nodex = _node; output.addNewDataSeries(xout); bsuccess = true; } } if (!bsuccess) { throw new Exception("could not find output variable " + nodeName); } return(bsuccess); }
//to make it easy to interface from matlab etc. public bool Mat_AddOutputVariable(SmOutput.OutputType hydraulicType, string name, bool mean, bool std, bool min, bool max, bool median) { EnsembleStatistics stats = new EnsembleStatistics(); stats.SetStats(mean, std, min, max, median); AddOutputVariable(hydraulicType, stats, name); return(true); }
public EnsembleValuesForPoint(MainModel[] models, SmOutput.OutputType type, string name, string additionalParams) { Models = models; Values = new double[Models.Length]; _type = type; switch (_type) { case SmOutput.OutputType.linkFlowTimeSeries: throw new NotImplementedException(); for (int i = 0; i < Models.Length; i++) { //cons[i] = models[i].get } break; case SmOutput.OutputType.nodeVolume: nodex = Models[0].getNode(name); break; case SmOutput.OutputType.nodeWaterLevel: nodex = Models[0].getNode(name); _type = SmOutput.OutputType.nodeWaterLevel; _derived = new DerivedValue(additionalParams); break; case SmOutput.OutputType.outletFlowTimeSeries: outlets = new Outlet[Models.Length]; int outletIndexInNodeArray = int.MaxValue; foreach (int i in Models[0].iOutlets) { if (Models[0].Nodes[i].name == name) { outletIndexInNodeArray = i; } } if (outletIndexInNodeArray == int.MaxValue) { throw new Exception("could not find outlet"); } for (int i = 0; i < Models.Length; i++) { outlets[i] = (Outlet)models[i].Nodes[outletIndexInNodeArray]; } break; default: break; } }
public bool addOutputVariable(SmOutput.OutputType type) { bool bsuccess = false; SmOutput xout = new SmOutput(); xout.type = type; xout.name = type.ToString(); output.addNewDataSeries(xout); bsuccess = true; return(bsuccess); }
public bool AddOutputVariable(SmOutput.OutputType hydraulicType, EnsembleStatistics stats, string name) { EnsOutput xouts = new EnsOutput(stats); xouts.name = name; xouts.hydraulicType = hydraulicType; MainModel model = models[0]; switch (hydraulicType) { case SmOutput.OutputType.linkFlowTimeSeries: break; case SmOutput.OutputType.nodeVolume: xouts.nodex = models[0].getNode(name); break; case SmOutput.OutputType.GlobalVolumen: break; case SmOutput.OutputType.outletFlowTimeSeries: bool bsuccess = false; foreach (int i in model.iOutlets) { if (model.Nodes[i].name == name) { xouts.outletx = new Outlet[models.Length]; for (int j = 0; j < models.Length; j++) { xouts.outletx[j] = (Outlet)models[j].Nodes[i]; } bsuccess = true; } } if (!bsuccess) { throw new Exception("could not find output variable " + name); } break; default: break; } outputCollection.addNewDataSeries(xouts); return(true); }
public bool Mat_AddOutputVariableLinkFlow(string fromNode, string toNode, string name, bool mean, bool std, bool min, bool max, bool median) { SmOutput.OutputType hydraulicType = SmOutput.OutputType.linkFlowTimeSeries; EnsembleStatistics stats = new EnsembleStatistics(); stats.SetStats(mean, std, min, max, median); EnsOutput xouts = new EnsOutput(stats); xouts.name = name; xouts.hydraulicType = hydraulicType; MainModel model = models[0]; List <Connection> cons = model.getConnections(); int fromIndex = model.getNode(fromNode).index; int toIndex = model.getNode(toNode).index; bool bsuccess = false; for (int i = 0; i < cons.Count; i++) { if (cons[i].from == fromIndex && cons[i].to == toIndex) { SmOutput xout = new SmOutput(); xout.name = name; xouts.con = new Connection[models.Length]; for (int j = 0; j < models.Length; j++) { xouts.con[j] = models[j].Connections[i]; } } bsuccess = true; } if (!bsuccess) { throw new Exception("could not find output variable " + name); } outputCollection.addNewDataSeries(xouts); return(true); }
private void AddEnsembleOutputFromParameterTable(string[,] paramTable, int ix) { bool[] ensStats = new bool[5]; for (int i = ix; i < paramTable.Length; i++) { if (paramTable[i, 0] == "[EndSect]") { return; } if (paramTable[i, 0] == "<Stats>") { string[] split = paramTable[i, 1].Split(new Char[] { ' ', '\t', '=', ',', '(', ')', ';' }, StringSplitOptions.RemoveEmptyEntries); ensStats = new bool[split.Length]; for (int j = 0; j < split.Length; j++) { ensStats[j] = (split[j] == "1"); } } if (paramTable[i, 0] == "<output>") { switch (paramTable[i, 1]) { case "Flow": Mat_AddOutputVariableLinkFlow(paramTable[i, 2], paramTable[i, 3], paramTable[i, 4], ensStats[0], ensStats[1], ensStats[2], ensStats[3], ensStats[4]); break; case "Vol": Mat_AddOutputVariable(SmOutput.OutputType.nodeVolume, paramTable[i, 2], ensStats[0], ensStats[1], ensStats[2], ensStats[3], ensStats[4]); break; case "outletFlow": Mat_AddOutputVariable(SmOutput.OutputType.outletFlowTimeSeries, paramTable[i, 2], ensStats[0], ensStats[1], ensStats[2], ensStats[3], ensStats[4]); break; case "GlobalVolume": // addOutputVariable(SmOutput.OutputType.GlobalVolumen); throw new NotImplementedException("Unknown connection type: " + paramTable[i, 1]); break; case "NodeWL": SmOutput.OutputType hydraulicType = SmOutput.OutputType.nodeWaterLevel; EnsembleStatistics stats = new EnsembleStatistics(); stats.SetStats(ensStats[0], ensStats[1], ensStats[2], ensStats[3], ensStats[4]); EnsOutput xouts = new EnsOutput(stats); xouts.name = paramTable[i, 4]; xouts.hydraulicType = hydraulicType; MainModel model = models[0]; xouts.nodex = model.getNode((paramTable[i, 2])); xouts.derived = new DerivedValue(paramTable[i, 5]); for (int j = 0; j < models.Length; j++) { SmOutput xout = new SmOutput(); xout.name = paramTable[i, 4]; } outputCollection.addNewDataSeries(xouts); break; default: throw new NotImplementedException("Unknown connection type: " + paramTable[i, 1]); } } } }
private void CollectOutputData() { outputCollection.timeInSeconds.Add(models[0].t); foreach (EnsOutput ensOut in outputCollection.hydraulicOutput) { SmOutput.OutputType hydraulicType = ensOut.hydraulicType; double[] ensValues = new double[m_ensembleMembers]; switch (hydraulicType) { case SmOutput.OutputType.linkFlowTimeSeries: for (int i = 0; i < m_ensembleMembers; i++) { ensValues[i] = ensOut.con[i].retrieveMeanFlow(); } break; case SmOutput.OutputType.nodeVolume: for (int i = 0; i < m_ensembleMembers; i++) { ensValues[i] = models[i].state.values[ensOut.nodex.index]; } break; case SmOutput.OutputType.GlobalVolumen: for (int i = 0; i < m_ensembleMembers; i++) { ensValues[i] = models[i].state.values.Sum(); } break; case SmOutput.OutputType.outletFlowTimeSeries: for (int i = 0; i < m_ensembleMembers; i++) { ensValues[i] = ensOut.outletx[i].flow; } break; case SmOutput.OutputType.nodeWaterLevel: try { for (int i = 0; i < m_ensembleMembers; i++) { ensValues[i] = ensOut.derived.calculate(models[i].state.values[ensOut.nodex.index]); } } catch (Exception e) { throw new Exception("Error collecting derived WL output for node " + ensOut.name + ": " + e.Message); } break; default: break; } int j = 0; foreach (SmOutput.StatType statType in ensOut.stats.types) { switch (statType) { case SmOutput.StatType.deterministic: throw new Exception("Error collecting output"); break; case SmOutput.StatType.mean: ensOut.dataSeries[j].updateData(ensValues.Average()); break; case SmOutput.StatType.std: double average = ensValues.Average(); double sumOfSquaresOfDifferences = ensValues.Select(val => (val - average) * (val - average)).Sum(); double std = Math.Sqrt(sumOfSquaresOfDifferences / ensValues.Length); ensOut.dataSeries[j].updateData(std); break; case SmOutput.StatType.min: ensOut.dataSeries[j].updateData(ensValues.Min()); break; case SmOutput.StatType.max: ensOut.dataSeries[j].updateData(ensValues.Max()); break; case SmOutput.StatType.median: ensOut.dataSeries[j].updateData(ensValues.Median()); break; case SmOutput.StatType.accumulated: throw new Exception("Error collecting output"); break; default: throw new Exception("Error collecting output"); break; } j++; } } }