private bool AddOCtoTree(FTableCalculator aCalc)
{
bool lCalcAdded = false;
FTableCalculator.ControlDeviceType lOCType = aCalc.ControlDevice;
int lExit = aCalc.myExit;
Dictionary <string, double> lParamValues = aCalc.ParamValues();
string lOCDisplayName = "";
FTableCalculator.OCTypeNames.TryGetValue(aCalc.ControlDevice, out lOCDisplayName);
TreeNode lExitNode = null;
if (treeExitControls.Nodes.ContainsKey(lExit.ToString()))
{
lExitNode = treeExitControls.Nodes[lExit.ToString()]; //.Add(lKey, lOCName + "_" + Id.ToString());
}
else
{
lExitNode = treeExitControls.Nodes.Add(lExit.ToString(), "Exit " + lExit.ToString());
}
//add OC node
string lOCNameClass = aCalc.GetType().Name;
int Ctr = 0;
string lOCNodeName = lOCDisplayName + "_" + Ctr.ToString();
string lOCNodeKey = lOCNameClass + "_" + Ctr.ToString();
while (lExitNode.Nodes.ContainsKey(lOCNodeKey))
{
Ctr++;
lOCNodeKey = lOCNameClass + "_" + Ctr.ToString();
lOCNodeName = lOCDisplayName + "_" + Ctr.ToString();
}
TreeNode lOCNode = lExitNode.Nodes.Add(lOCNodeKey, lOCNodeName);
//add parameter value nodes
List <string> lParamNames = lParamValues.Keys.ToList <string>();
List <double> lParamVals = lParamValues.Values.ToList <double>();
for (int z = 0; z < lParamNames.Count; z++)
{
lOCNode.Nodes.Add(lParamNames[z], lParamNames[z] + "(" + lParamVals[z] + ")");
}
lCalcAdded = true;
return(lCalcAdded);
}
public bool PopulateFTableGrid()
{
bool TablePopulated = true;
if (FTableResults == null || FTableColumnNames == null)
{
btnCopyToSpreadsheet.Enabled = false;
btnCopyToUCI.Enabled = false;
btnClearFTable.Enabled = false;
chkExtendedFormat.Enabled = false;
if (string.IsNullOrEmpty(FTableMessage) && FTableMessage.Length > 0)
{
lblMessage.Text = "Note: " + FTableMessage;
}
return(false);
}
else if (FTableColumnNames.Count < 3)
{
lblMessage.Text = "Note: Incomplete FTable";
return(false);
}
ArrayList FTableColumnNamesRT = FTableColumnNames;
ArrayList FTableResultsRT = FTableResults;
if (chkExtendedFormat.Checked)
{
SetFTableResultExtendedFormat();
FTableColumnNamesRT = FTableColumnNamesExt;
FTableResultsRT = FTableResultsExt;
}
double lVal;
FTableSource = new atcControls.atcGridSource();
FTableSource.Columns = FTableColumnNamesRT.Count;
FTableSource.FixedRows = 1;
//set header
for (int i = 0; i < FTableColumnNamesRT.Count; i++)
{
FTableSource.set_CellValue(0, i, FTableColumnNamesRT[i].ToString());
}
ArrayList lRow = null;
int lgrdRow = 1;
string lFormat = "{0:0.000000}";
string lsValue = "";
string lcellValue = "";
for (int i = 0; i < FTableResultsRT.Count; i++)
{
lRow = (ArrayList)FTableResultsRT[i]; //get a FTable row
for (int c = 0; c < lRow.Count; c++)
{
lcellValue = lRow[c].ToString();
if (double.TryParse(lcellValue, out lVal)) //lRow[c].ToString()
{
if (lVal > 0 && lVal < 0.000001)
{
lsValue = String.Format(System.Globalization.CultureInfo.InvariantCulture, clsGlobals.NumberFormatSci, lVal);
}
else
{
lsValue = String.Format(lFormat, lVal);
}
FTableSource.set_CellValue(lgrdRow, c, lsValue);
}
else
{
FTableSource.set_CellValue(lgrdRow, c, "0.0");
}
}
lgrdRow++;
}
SetGridEditable(1, FTableSource.Rows - 1, 3, FTableSource.Columns - 1, true);
grdFtableResult.Initialize(FTableSource);
grdFtableResult.SizeAllColumnsToContents();
grdFtableResult.Refresh();
if (string.IsNullOrEmpty(FTableMessage))
{
lblMessage.Text = "Note: " + FTableMessage;
//jTableMessageLabel.setText(newResultMessage);
//jTable.setVisible(true);
//// set the data vector in the jTable.
//dfm.setDataVector(lFtableResultChannel, colNames);
string lMsg = "";
double lmaxVol = FTableCalculator.CalculateMaxVolume(FTableResults, out lMsg);
if (lmaxVol > 0)
{
lblMessage.Text = "Note:\n" + lMsg;
}
}
else
{
//this is for Green tool that has infiltration influenced maxVol that is preset
lblMessage.Text = FTableMessage;
}
//modifyTableForInfiltration(data, colNames);
//sri-09-11-2012
/* The code below checks if any column has continuous zero values resulted becauses of depth
* increment mismatch between channel depth and control device depth. If such a situation exist
* in any one of the control devices column the table is not displayed and a error message pops up
*/
//TableColumnModel clm = jTable.getColumnModel();
string cdevice = null;
// if(colNames.get(3).toString().trim().startsWith("outflow")==false) // i.e no control device used
//sri-09-11-2012
// if control devices used - column zero values check- depth increment check
if (FTableColumnNames.Count > 4) // > 3
{
int colcheck = 0;
double lEpslon = 0.0000001;
for (int col = 3; col < ((ArrayList)FTableResults[0]).Count; col++) //int col = 3
{
string lColHeader = FTableColumnNames[col].ToString();
int lExitNum = -1;
if (lColHeader.ToLower().StartsWith("outflow1") ||
lColHeader.ToLower().StartsWith("infil"))
{
continue;
}
if (lColHeader.ToLower().StartsWith("exit"))
{
int.TryParse(lColHeader.Substring(4, 1), out lExitNum);
}
int count = 0;
for (int row = 0; row < FTableResults.Count; row++)
{
lRow = (ArrayList)FTableResults[row];
double.TryParse(lRow[col].ToString(), out lVal);
if (Math.Abs(lVal - 0.0) < lEpslon)
{
count = count + 1;
}
}
if (count == FTableResults.Count && (lExitNum - 1 >= 0 && clsGlobals.gExitOCSetup[lExitNum - 1].Nodes.Count > 0))
{
colcheck = colcheck + 1;
if (cdevice == null)
{
cdevice = FTableColumnNames[col].ToString().Trim();
}
else
{
cdevice = cdevice + " , " + FTableColumnNames[col].ToString().Trim();
}
}
}
if (colcheck == 0 || cdevice.ToLower().Contains("infiltration"))
{
grdFtableResult.Visible = true;
}
else
{
TablePopulated = false;
grdFtableResult.Visible = false;
lblMessage.Text = "Note: ERROR-Depth Increment Mismatch Between Channel and Control Device/s\n" +
"Make sure that the depth increment is a multiple of the invert level";
}
} // end- column zero values check- depth increment check
else
{
grdFtableResult.Visible = true;
}
bool lOK = grdFtableResult.Visible;
btnCopyToSpreadsheet.Enabled = lOK;
btnCopyToUCI.Enabled = lOK;
btnClearFTable.Enabled = lOK;
chkExtendedFormat.Enabled = lOK;
return(TablePopulated);
}
private FTableCalculator GetControlDeviceFromForm()
{
List <FTableCalculator.ControlDeviceType> listOCTypes = FTableCalculator.OCTypeNames.Keys.ToList <FTableCalculator.ControlDeviceType>();
List <string> listOCCommonNames = FTableCalculator.OCTypeNames.Values.ToList <string>();
FTableCalculator.ControlDeviceType lSelectedOCType = FTableCalculator.ControlDeviceType.None;
for (int i = 0; i < listOCTypes.Count; i++)
{
if (cboOCTypes.SelectedItem.ToString() == listOCCommonNames[i])
{
lSelectedOCType = listOCTypes[i];
break;
}
}
int lSelectedExit = SelectedExit();
double lParam0 = 0;
double lParam1 = 0;
double lDisCoe = 0;
double.TryParse(txtOCParm_0.Text, out lParam0);
double.TryParse(txtOCParm_1.Text, out lParam1);
double.TryParse(txtOCDisCoeff.Text, out lDisCoe);
FTableCalculator lCalc = null;
switch (lSelectedOCType)
{
case FTableCalculator.ControlDeviceType.OrificeRiser:
lCalc = new FTableCalcOCOrificeRiser();
((FTableCalcOCOrificeRiser)lCalc).myExit = lSelectedExit;
((FTableCalcOCOrificeRiser)lCalc).OrificePipeDiameter = lParam0;
((FTableCalcOCOrificeRiser)lCalc).OrificeDepth = lParam1;
((FTableCalcOCOrificeRiser)lCalc).OrificeDischargeCoefficient = lDisCoe;
break;
case FTableCalculator.ControlDeviceType.OrificeUnderdrain:
lCalc = new FTableCalcOCOrificeUnderflow();
((FTableCalcOCOrificeUnderflow)lCalc).myExit = lSelectedExit;
((FTableCalcOCOrificeUnderflow)lCalc).OrificePipeDiameter = lParam0;
((FTableCalcOCOrificeUnderflow)lCalc).OrificeInvertDepth = lParam1;
((FTableCalcOCOrificeUnderflow)lCalc).OrificeDischargeCoefficient = lDisCoe;
break;
case FTableCalculator.ControlDeviceType.WeirBroadCrest:
lCalc = new FTableCalcOCWeirBroad();
((FTableCalcOCWeirBroad)lCalc).myExit = lSelectedExit;
((FTableCalcOCWeirBroad)lCalc).WeirWidth = lParam0;
((FTableCalcOCWeirBroad)lCalc).WeirInvert = lParam1;
((FTableCalcOCWeirBroad)lCalc).DischargeCoefficient = lDisCoe;
break;
case FTableCalculator.ControlDeviceType.WeirRectangular:
lCalc = new FTableCalcOCWeirRectangular();
((FTableCalcOCWeirRectangular)lCalc).myExit = lSelectedExit;
((FTableCalcOCWeirRectangular)lCalc).WeirWidth = lParam0;
((FTableCalcOCWeirRectangular)lCalc).WeirInvert = lParam1;
((FTableCalcOCWeirRectangular)lCalc).DischargeCoefficient = lDisCoe;
break;
case FTableCalculator.ControlDeviceType.WeirTrapeCipolletti:
lCalc = new FTableCalcOCWeirTrapeCipolletti();
((FTableCalcOCWeirTrapeCipolletti)lCalc).myExit = lSelectedExit;
((FTableCalcOCWeirTrapeCipolletti)lCalc).WeirWidth = lParam0;
((FTableCalcOCWeirTrapeCipolletti)lCalc).WeirInvert = lParam1;
((FTableCalcOCWeirTrapeCipolletti)lCalc).DischargeCoefficient = lDisCoe;
break;
case FTableCalculator.ControlDeviceType.WeirTriVNotch:
lCalc = new FTableCalcOCWeirTriVNotch();
((FTableCalcOCWeirTriVNotch)lCalc).myExit = lSelectedExit;
((FTableCalcOCWeirTriVNotch)lCalc).WeirAngle = lParam0;
((FTableCalcOCWeirTriVNotch)lCalc).WeirInvert = lParam1;
((FTableCalcOCWeirTriVNotch)lCalc).DischargeCoefficient = lDisCoe;
break;
}
return(lCalc);
}
private void cboOCTypes_SelectedIndexChanged(object sender, EventArgs e)
{
if (!pLoaded)
{
return;
}
string lSelectedOCName = cboOCTypes.SelectedItem.ToString();
if (lSelectedOCName == "None")
{
return;
}
string lName = "";
FTableCalculator.ControlDeviceType lSelectedOCType = FTableCalculator.ControlDeviceType.None;
foreach (FTableCalculator.ControlDeviceType lOCType in FTableCalculator.OCTypeNames.Keys)
{
if (FTableCalculator.OCTypeNames.TryGetValue(lOCType, out lName))
{
if (lSelectedOCName == lName)
{
lSelectedOCType = lOCType;
break;
}
}
}
Dictionary <string, double> lDefaults = null;
FTableCalculator lCalc = null;
switch (lSelectedOCType)
{
case FTableCalculator.ControlDeviceType.WeirTriVNotch:
lCalc = new FTableCalcOCWeirTriVNotch();
lDefaults = ((FTableCalcOCWeirTriVNotch)lCalc).ParamValueDefaults();
break;
case FTableCalculator.ControlDeviceType.WeirTrapeCipolletti:
lCalc = new FTableCalcOCWeirTrapeCipolletti();
lDefaults = ((FTableCalcOCWeirTrapeCipolletti)lCalc).ParamValueDefaults();
break;
case FTableCalculator.ControlDeviceType.WeirRectangular:
lCalc = new FTableCalcOCWeirRectangular();
lDefaults = ((FTableCalcOCWeirRectangular)lCalc).ParamValueDefaults();
break;
case FTableCalculator.ControlDeviceType.WeirBroadCrest:
lCalc = new FTableCalcOCWeirBroad();
lDefaults = ((FTableCalcOCWeirBroad)lCalc).ParamValueDefaults();
break;
case FTableCalculator.ControlDeviceType.OrificeUnderdrain:
lCalc = new FTableCalcOCOrificeUnderflow();
lDefaults = ((FTableCalcOCOrificeUnderflow)lCalc).ParamValueDefaults();
break;
case FTableCalculator.ControlDeviceType.OrificeRiser:
lCalc = new FTableCalcOCOrificeRiser();
lDefaults = ((FTableCalcOCOrificeRiser)lCalc).ParamValueDefaults();
break;
}
;
List <string> lParamLbls = lDefaults.Keys.ToList <string>();
List <double> lParamVals = lDefaults.Values.ToList <double>();
lblOCParm0.Text = lParamLbls[0];
lblOCParm1.Text = lParamLbls[1];
txtOCParm_0.Text = lParamVals[0].ToString();
txtOCParm_1.Text = lParamVals[1].ToString();
txtOCDisCoeff.Text = lParamVals[2].ToString();
//if (clsGlobals.gToolType == clsGlobals.ToolType.Gray)
//{
// rdoExit2.Checked = true;
//}
//else
//{
// rdoExit1.Checked = true;
//}
}
private void btnUpdate_Click(object sender, EventArgs e)
{
TreeNode lSelectedNode = treeExitControls.SelectedNode;
if (lSelectedNode == null || lSelectedNode.Text.StartsWith("Exit") || !lSelectedNode.Parent.Text.StartsWith("Exit"))
{
System.Windows.Forms.MessageBox.Show("Select a Control Device for update.", "Update Control Device");
return;
}
string lSelectedOCAlias = lSelectedNode.Text.Substring(0, lSelectedNode.Text.IndexOf("_"));
int lSelectedOCIndex = int.Parse(lSelectedNode.Text.Substring(lSelectedNode.Text.IndexOf("_") + 1));
string lParentNodeName = lSelectedNode.Parent.Text;
string lExitNo = lParentNodeName.Substring(lParentNodeName.IndexOf(" ") + 1);
int lExitNum = int.Parse(lExitNo);
FTableCalculator lCalc = GetControlDeviceFromForm();
if (lSelectedOCAlias == FTableCalculator.OCTypeNames[lCalc.ControlDevice].ToString())
{
Dictionary <string, double> lParams = lCalc.ParamValues();
double lVal = 0;
foreach (TreeNode lParamNode in lSelectedNode.Nodes)
{
string lParamName = lParamNode.Text.Substring(0, lParamNode.Text.LastIndexOf("("));
lVal = lParams[lParamName];
lParamNode.Text = lParamName + "(" + lVal.ToString() + ")";
}
this.treeExitControls.MouseUp -= this.treeExitControls_MouseUp;
AdjustNodeNames(lSelectedNode.Parent);
lSelectedNode.Expand();
treeExitControls.SelectedNode = lSelectedNode;
this.treeExitControls.MouseUp += new System.Windows.Forms.MouseEventHandler(this.treeExitControls_MouseUp);
}
if (lExitNum != SelectedExit())
{
TreeNode lNewNode = new TreeNode();
lNewNode.Text = lSelectedNode.Text;
foreach (TreeNode lParamNode in lSelectedNode.Nodes)
{
TreeNode lnewParamNode = new TreeNode();
lnewParamNode.Text = lParamNode.Text;
lNewNode.Nodes.Add(lnewParamNode);
}
lSelectedNode.Remove();
foreach (TreeNode lExitNode in treeExitControls.Nodes)
{
if (lExitNode.Text.Contains(SelectedExit().ToString()))
{
lExitNode.Nodes.Add(lNewNode);
break;
}
}
this.treeExitControls.MouseUp -= this.treeExitControls_MouseUp;
AdjustNodeNames(lNewNode.Parent);
lNewNode.Expand();
treeExitControls.SelectedNode = lNewNode;
this.treeExitControls.MouseUp += new System.Windows.Forms.MouseEventHandler(this.treeExitControls_MouseUp);
}
}
private void btnAdd_Click(object sender, EventArgs e)
{
string lErrMsg = ParamsOK();
if (!string.IsNullOrEmpty(lErrMsg))
{
System.Windows.Forms.MessageBox.Show("Please address the following error before proceeding:" + Environment.NewLine + lErrMsg,
"Adding New Control Devices");
return;
}
int lSelectedExit = SelectedExit();
FTableCalculator lCalc = GetControlDeviceFromForm();
if (lCalc == null)
{
System.Windows.Forms.MessageBox.Show("Please select a proper control device type.", "Adding New Control Devices");
return;
}
//Add OC node
string lOCCommonName = FTableCalculator.OCTypeNames[lCalc.ControlDevice];
int typeCounter = -99;
TreeNode lExitNode = treeExitControls.Nodes[lSelectedExit - 1];
foreach (TreeNode lOCNode in lExitNode.Nodes)
{
string lOCAlias = lOCNode.Text.Substring(0, lOCNode.Text.IndexOf("_"));
string lOCId = lOCNode.Text.Substring(lOCNode.Text.IndexOf("_") + 1);
int liOCId = int.Parse(lOCId);
if (lOCAlias == lOCCommonName)
{
if (typeCounter < liOCId)
{
typeCounter = liOCId;
}
}
}
if (typeCounter < 0)
{
typeCounter = 0;
}
else
{
typeCounter++;
}
string lnewOCName = lOCCommonName + "_" + typeCounter.ToString();
TreeNode lnewOCNode = lExitNode.Nodes.Add(lnewOCName);
//Add OC's param nodes
Dictionary <string, double> lParams = lCalc.ParamValues();
List <string> lParamNames = lParams.Keys.ToList <string>();
List <double> lParamValues = lParams.Values.ToList <double>();
foreach (string lParamName in lParams.Keys)
{
TreeNode lParamNode = new TreeNode();
lParamNode.Text = lParamName + "(" + lParams[lParamName].ToString() + ")";
lnewOCNode.Nodes.Add(lParamNode);
}
//Refresh tree
//AddOCtoTree(lCalc);
AdjustNodeNames(lExitNode);
}
