// ######################################## BOD ISO Calculation ################################################################# // V6.3 20220816 // Installation procedure on confluence page: http://sis:8090/pages/editpage.action?pageId=22675730 // A - Debugger, Time and Log // B - SampleTypes // C - Errors // D - Variables // E - Calculation // E - 1. GetValues from tables // E - 2. Reset Table, Calc for all rows and initial day // E - 3. Blanks // E - 4. Dictionaries // E - 5. BOD calculation per dilution // E - 5.1 Dataset // E - 5.2 Calculation of BOD per row and Add to Average dictionary // E - 5.2.1 Declare variables and get values from BOD table // E - 5.2.2 BOD calculation and Range Check // E - 5.2.3 Put values on the BOD table // E - 5.2.4 QC Check // E - 5.2.5 Add values to the Average dictionary // E - 5.2.5.1 Not Norm // E - 5.2.5.2 Norm // E - 6. Average BOD // E - 6.1 calculate average // E - 6.2 Average for Norm // E - 6.3 COD/BOD & and RM // E - 6.4 Average for NN // E - 7. Final results // E - 7.1 Final Results Norm // E - 7.2 Final Results NN // E - 8. RI & CV // E - 9. BOD Correction Factor // E - 10. Case there is no blanks // Test Mode static public class Calculation { #region Calculate static public object Calculate(params object[] Parameters) { DataSet dataSet = Parameters[0] as DataSet; string AnalysisStatus = "NewAnalysis"; if (dataSet.Tables.Contains("_HiddenLastState")) { AnalysisStatus = (string)dataSet.Tables["_HiddenLastState"].Rows[0]["Status"]; } object oResult = null; string TemplateType = "ActionBase"; if (!dataSet.Tables.Contains("Type")) { TemplateType = "Workflow"; } bool TestISO_OK = TestISO(TemplateType, Parameters); if(TestISO_OK) { oResult = Calculate_ISO(TemplateType, Parameters); //UpdateBODWizardRows(TemplateType, Parameters); } else { MessageBox.Show("Your calculation need to be set up! \n\n Activate Test mode for more details"); } return dataSet; } #endregion #region Calculation ISO static public object Calculate_ISO( string TemplateType, params object[] Parameters) { #region A - Debugger, Time and Log if (System.Diagnostics.Debugger.IsAttached) System.Diagnostics.Debugger.Break(); DataSet dataSet = Parameters[0] as DataSet; DateTime dt = new DateTime(2001, 1, 1, 1, 1, 1); if (dataSet.Tables.Contains("_HiddenLastState")) { dt = (DateTime)dataSet.Tables["_HiddenLastState"].Rows[0]["Created"]; } #endregion string DilutionsTable = "SampleAnalysis"; string SampleTypesTableName = "Type"; if(TemplateType == "Workflow") { DilutionsTable = "BOD"; SampleTypesTableName = "SampleType"; } #region B - Sample types string SKSample = ""; string SKBlank = ""; string SKGGACheck = ""; string SKGGACheck2 = ""; string SKGGACheck3 = ""; DataRow[] Type = dataSet.Tables[SampleTypesTableName].Select(); foreach (DataRow row in Type) { switch (row["SKType"].ToString()) { case "SKSample": SKSample = row["SKType"].ToString(); break; case "SKBlank": SKBlank = row["SKType"].ToString(); break; case "SKGGACheck": SKGGACheck = row["SKType"].ToString(); break; case "SKGGACheck2": SKGGACheck2 = row["SKType"].ToString(); break; case "SKGGACheck3": SKGGACheck3 = row["SKType"].ToString(); break; } } #endregion #region C - Errors string Error1 = ""; string Error2 = ""; string Error3 = ""; string Error4 = ""; string Error5 = ""; string Error6 = ""; string Error7 = ""; string Error8 = ""; string Error9 = ""; DataRow[] Error = dataSet.Tables["GeneralErrors"].Select(); foreach (DataRow row in Error) { switch (row["ErrorNumber"].ToString()) { case "Error1": Error1 = row["DisplayName"].ToString(); break; case "Error2": Error2 = row["DisplayName"].ToString(); break; case "Error3": Error3 = row["DisplayName"].ToString(); break; case "Error4": Error4 = row["DisplayName"].ToString(); break; case "Error5": Error5 = row["DisplayName"].ToString(); break; case "Error6": Error6 = row["DisplayName"].ToString(); break; case "Error7": Error7 = row["DisplayName"].ToString(); break; case "Error8": Error8 = row["DisplayName"].ToString(); break; case "Error9": Error9 = row["DisplayName"].ToString(); break; } } #endregion #region D - Variables bool bSilent = (bool)Parameters[1]; double BlankAverage = 0; int ValidAmount = 0; bool BlankIsUsed = false; double Vd = 1; double Vs = 1; double TempCorrectionValue = 0; string DilutedMethodName = "ISO 5815-1:2019"; string UndilutedMethodName = "ISO 5815-2:2003"; bool DilutedDirectSeeding = false; bool UndilutedDirectSeeding = false; double mLSeedPer1000mL = 2; double LowestPossibleDilutionFactor = 1; string ValidTag = "T"; string InvalidTag = "Invalid"; //BlankInitTemp ; bool BlankInitTempCritical = true; double BlankInitTempMin = 0; string BlankInitTempMinMsg = ""; double BlankInitTempMax = 100; string BlankInitTempMaxMsg = ""; //BlankFinalTemp ; bool BlankFinalTempCritical = true; double BlankFinalTempMin = 0; string BlankFinalTempMinMsg = ""; double BlankFinalTempMax = 100; string BlankFinalTempMaxMsg = ""; //BlankInitDO ; bool BlankInitDOCritical = true; double BlankInitDOMin = 0; string BlankInitDOMinMsg = ""; double BlankInitDOMax = 100; string BlankInitDOMaxMsg = ""; //BlankFinalDO ; bool BlankFinalDOCritical = true; double BlankFinalDOMin = 0; string BlankFinalDOMinMsg = ""; double BlankFinalDOMax = 100; string BlankFinalDOMaxMsg = ""; //BlankDeplAlert ; bool BlankDeplAlertCritical = true; double BlankDeplAlertMin = 0; string BlankDeplAlertMinMsg = ""; double BlankDeplAlertMax = 100; string BlankDeplAlertMaxMsg = ""; //BlankDepl ; bool BlankDeplCritical = true; double BlankDeplMin = 0; string BlankDeplMinMsg = ""; double BlankDeplMax = 100; string BlankDeplMaxMsg = ""; //DilutedInitTemp ; bool DilutedInitTempCritical = true; double DilutedInitTempMin = 0; string DilutedInitTempMinMsg = ""; double DilutedInitTempMax = 100; string DilutedInitTempMaxMsg = ""; //DilutedFinalTemp ; bool DilutedFinalTempCritical = true; double DilutedFinalTempMin = 0; string DilutedFinalTempMinMsg = ""; double DilutedFinalTempMax = 100; string DilutedFinalTempMaxMsg = ""; //DilutedInitDO ; bool DilutedInitDOCritical = true; double DilutedInitDOMin = 0; string DilutedInitDOMinMsg = ""; double DilutedInitDOMax = 100; string DilutedInitDOMaxMsg = ""; //DilutedFinalDO ; bool DilutedFinalDOCritical = true; double DilutedFinalDOMin = 0; string DilutedFinalDOMinMsg = ""; double DilutedFinalDOMax = 100; string DilutedFinalDOMaxMsg = ""; //DilutedDepl ; bool DilutedDeplCritical = true; double DilutedDeplMin = 0; string DilutedDeplMinMsg = ""; double DilutedDeplMax = 100; string DilutedDeplMaxMsg = ""; //DilutedDeplPerc ; bool DilutedDeplPercCritical = true; double DilutedDeplPercMin = 0; string DilutedDeplPercMinMsg = ""; double DilutedDeplPercMax = 100; string DilutedDeplPercMaxMsg = ""; //DilutedRange ; bool DilutedRangeCritical = true; double DilutedRangeMin = 0; string DilutedRangeMinMsg = ""; double DilutedRangeMax = 100; string DilutedRangeMaxMsg = ""; //UndilutedInitTemp ; bool UndilutedInitTempCritical = true; double UndilutedInitTempMin = 0; string UndilutedInitTempMinMsg = ""; double UndilutedInitTempMax = 100; string UndilutedInitTempMaxMsg = ""; //UndilutedFinalTemp ; bool UndilutedFinalTempCritical = true; double UndilutedFinalTempMin = 0; string UndilutedFinalTempMinMsg = ""; double UndilutedFinalTempMax = 100; string UndilutedFinalTempMaxMsg = ""; //UndilutedInitDO ; bool UndilutedInitDOCritical = true; double UndilutedInitDOMin = 0; string UndilutedInitDOMinMsg = ""; double UndilutedInitDOMax = 100; string UndilutedInitDOMaxMsg = ""; //UndilutedFinalDO ; bool UndilutedFinalDOCritical = true; double UndilutedFinalDOMin = 0; string UndilutedFinalDOMinMsg = ""; double UndilutedFinalDOMax = 100; string UndilutedFinalDOMaxMsg = ""; //UndilutedDepl ; bool UndilutedDeplCritical = true; double UndilutedDeplMin = 0; string UndilutedDeplMinMsg = ""; double UndilutedDeplMax = 100; string UndilutedDeplMaxMsg = ""; //UndilutedDeplPerc ; bool UndilutedDeplPercCritical = true; double UndilutedDeplPercMin = 0; string UndilutedDeplPercMinMsg = ""; double UndilutedDeplPercMax = 100; string UndilutedDeplPercMaxMsg = ""; //UndilutedRange ; bool UndilutedRangeCritical = true; double UndilutedRangeMin = 0; string UndilutedRangeMinMsg = ""; double UndilutedRangeMax = 100; string UndilutedRangeMaxMsg = ""; //QC1 ; bool QC1Critical = true; double QC1Min = 0; string QC1MinMsg = ""; double QC1Max = 100; string QC1MaxMsg = ""; //QC2 ; bool QC2Critical = true; double QC2Min = 0; string QC2MinMsg = ""; double QC2Max = 100; string QC2MaxMsg = ""; //QC3 ; bool QC3Critical = true; double QC3Min = 0; string QC3MinMsg = ""; double QC3Max = 100; string QC3MaxMsg = ""; //pH ; bool pHCritical = true; double pHMin = 0; string pHMinMsg = ""; double pHMax = 100; string pHMaxMsg = ""; #endregion #region E - Calculation while (true) { #region 1 - GetValues from tables try { // BlankInitTemp BlankInitTempCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[0]["Critical"]; BlankInitTempMin = (double)dataSet.Tables["ISOCriterion"].Rows[0]["ValueMin"]; BlankInitTempMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[0]["ErrorMin"]; BlankInitTempMax = (double)dataSet.Tables["ISOCriterion"].Rows[0]["ValueMax"]; BlankInitTempMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[0]["ErrorMax"]; // BlankFinalTemp BlankFinalTempCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[1]["Critical"]; BlankFinalTempMin = (double)dataSet.Tables["ISOCriterion"].Rows[1]["ValueMin"]; BlankFinalTempMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[1]["ErrorMin"]; BlankFinalTempMax = (double)dataSet.Tables["ISOCriterion"].Rows[1]["ValueMax"]; BlankFinalTempMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[1]["ErrorMax"]; // BlankInitDO BlankInitDOCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[2]["Critical"]; BlankInitDOMin = (double)dataSet.Tables["ISOCriterion"].Rows[2]["ValueMin"]; BlankInitDOMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[2]["ErrorMin"]; BlankInitDOMax = (double)dataSet.Tables["ISOCriterion"].Rows[2]["ValueMax"]; BlankInitDOMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[2]["ErrorMax"]; // BlankFinalDO BlankFinalDOCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[3]["Critical"]; BlankFinalDOMin = (double)dataSet.Tables["ISOCriterion"].Rows[3]["ValueMin"]; BlankFinalDOMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[3]["ErrorMin"]; BlankFinalDOMax = (double)dataSet.Tables["ISOCriterion"].Rows[3]["ValueMax"]; BlankFinalDOMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[3]["ErrorMax"]; // BlankDeplAlert BlankDeplAlertCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[4]["Critical"]; BlankDeplAlertMin = (double)dataSet.Tables["ISOCriterion"].Rows[4]["ValueMin"]; BlankDeplAlertMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[4]["ErrorMin"]; BlankDeplAlertMax = (double)dataSet.Tables["ISOCriterion"].Rows[4]["ValueMax"]; BlankDeplAlertMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[4]["ErrorMax"]; // BlankDepl BlankDeplCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[5]["Critical"]; BlankDeplMin = (double)dataSet.Tables["ISOCriterion"].Rows[5]["ValueMin"]; BlankDeplMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[5]["ErrorMin"]; BlankDeplMax = (double)dataSet.Tables["ISOCriterion"].Rows[5]["ValueMax"]; BlankDeplMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[5]["ErrorMax"]; // DilutedInitTemp DilutedInitTempCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[6]["Critical"]; DilutedInitTempMin = (double)dataSet.Tables["ISOCriterion"].Rows[6]["ValueMin"]; DilutedInitTempMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[6]["ErrorMin"]; DilutedInitTempMax = (double)dataSet.Tables["ISOCriterion"].Rows[6]["ValueMax"]; DilutedInitTempMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[6]["ErrorMax"]; // DilutedFinalTemp DilutedFinalTempCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[7]["Critical"]; DilutedFinalTempMin = (double)dataSet.Tables["ISOCriterion"].Rows[7]["ValueMin"]; DilutedFinalTempMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[7]["ErrorMin"]; DilutedFinalTempMax = (double)dataSet.Tables["ISOCriterion"].Rows[7]["ValueMax"]; DilutedFinalTempMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[7]["ErrorMax"]; // DilutedInitDO DilutedInitDOCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[8]["Critical"]; DilutedInitDOMin = (double)dataSet.Tables["ISOCriterion"].Rows[8]["ValueMin"]; DilutedInitDOMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[8]["ErrorMin"]; DilutedInitDOMax = (double)dataSet.Tables["ISOCriterion"].Rows[8]["ValueMax"]; DilutedInitDOMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[8]["ErrorMax"]; // DilutedFinalDO DilutedFinalDOCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[9]["Critical"]; DilutedFinalDOMin = (double)dataSet.Tables["ISOCriterion"].Rows[9]["ValueMin"]; DilutedFinalDOMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[9]["ErrorMin"]; DilutedFinalDOMax = (double)dataSet.Tables["ISOCriterion"].Rows[9]["ValueMax"]; DilutedFinalDOMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[9]["ErrorMax"]; // DilutedDepl DilutedDeplCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[10]["Critical"]; DilutedDeplMin = (double)dataSet.Tables["ISOCriterion"].Rows[10]["ValueMin"]; DilutedDeplMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[10]["ErrorMin"]; DilutedDeplMax = (double)dataSet.Tables["ISOCriterion"].Rows[10]["ValueMax"]; DilutedDeplMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[10]["ErrorMax"]; // DilutedDeplPerc DilutedDeplPercCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[11]["Critical"]; DilutedDeplPercMin = (double)dataSet.Tables["ISOCriterion"].Rows[11]["ValueMin"]; DilutedDeplPercMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[11]["ErrorMin"]; DilutedDeplPercMax = (double)dataSet.Tables["ISOCriterion"].Rows[11]["ValueMax"]; DilutedDeplPercMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[11]["ErrorMax"]; // DilutedRange DilutedRangeCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[12]["Critical"]; DilutedRangeMin = (double)dataSet.Tables["ISOCriterion"].Rows[12]["ValueMin"]; DilutedRangeMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[12]["ErrorMin"]; DilutedRangeMax = (double)dataSet.Tables["ISOCriterion"].Rows[12]["ValueMax"]; DilutedRangeMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[12]["ErrorMax"]; // UndilutedInitTemp UndilutedInitTempCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[13]["Critical"]; UndilutedInitTempMin = (double)dataSet.Tables["ISOCriterion"].Rows[13]["ValueMin"]; UndilutedInitTempMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[13]["ErrorMin"]; UndilutedInitTempMax = (double)dataSet.Tables["ISOCriterion"].Rows[13]["ValueMax"]; UndilutedInitTempMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[13]["ErrorMax"]; // UndilutedFinalTemp UndilutedFinalTempCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[14]["Critical"]; UndilutedFinalTempMin = (double)dataSet.Tables["ISOCriterion"].Rows[14]["ValueMin"]; UndilutedFinalTempMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[14]["ErrorMin"]; UndilutedFinalTempMax = (double)dataSet.Tables["ISOCriterion"].Rows[14]["ValueMax"]; UndilutedFinalTempMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[14]["ErrorMax"]; // UndilutedInitDO UndilutedInitDOCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[15]["Critical"]; UndilutedInitDOMin = (double)dataSet.Tables["ISOCriterion"].Rows[15]["ValueMin"]; UndilutedInitDOMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[15]["ErrorMin"]; UndilutedInitDOMax = (double)dataSet.Tables["ISOCriterion"].Rows[15]["ValueMax"]; UndilutedInitDOMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[15]["ErrorMax"]; // UndilutedFinalDO UndilutedFinalDOCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[16]["Critical"]; UndilutedFinalDOMin = (double)dataSet.Tables["ISOCriterion"].Rows[16]["ValueMin"]; UndilutedFinalDOMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[16]["ErrorMin"]; UndilutedFinalDOMax = (double)dataSet.Tables["ISOCriterion"].Rows[16]["ValueMax"]; UndilutedFinalDOMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[16]["ErrorMax"]; // UndilutedDepl UndilutedDeplCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[17]["Critical"]; UndilutedDeplMin = (double)dataSet.Tables["ISOCriterion"].Rows[17]["ValueMin"]; UndilutedDeplMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[17]["ErrorMin"]; UndilutedDeplMax = (double)dataSet.Tables["ISOCriterion"].Rows[17]["ValueMax"]; UndilutedDeplMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[17]["ErrorMax"]; // UndilutedDeplPerc UndilutedDeplPercCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[18]["Critical"]; UndilutedDeplPercMin = (double)dataSet.Tables["ISOCriterion"].Rows[18]["ValueMin"]; UndilutedDeplPercMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[18]["ErrorMin"]; UndilutedDeplPercMax = (double)dataSet.Tables["ISOCriterion"].Rows[18]["ValueMax"]; UndilutedDeplPercMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[18]["ErrorMax"]; // UndilutedRange UndilutedRangeCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[19]["Critical"]; UndilutedRangeMin = (double)dataSet.Tables["ISOCriterion"].Rows[19]["ValueMin"]; UndilutedRangeMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[19]["ErrorMin"]; UndilutedRangeMax = (double)dataSet.Tables["ISOCriterion"].Rows[19]["ValueMax"]; UndilutedRangeMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[19]["ErrorMax"]; // QC1 QC1Critical = (bool)dataSet.Tables["ISOCriterion"].Rows[20]["Critical"]; QC1Min = (double)dataSet.Tables["ISOCriterion"].Rows[20]["ValueMin"]; QC1MinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[20]["ErrorMin"]; QC1Max = (double)dataSet.Tables["ISOCriterion"].Rows[20]["ValueMax"]; QC1MaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[20]["ErrorMax"]; // QC2 QC2Critical = (bool)dataSet.Tables["ISOCriterion"].Rows[21]["Critical"]; QC2Min = (double)dataSet.Tables["ISOCriterion"].Rows[21]["ValueMin"]; QC2MinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[21]["ErrorMin"]; QC2Max = (double)dataSet.Tables["ISOCriterion"].Rows[21]["ValueMax"]; QC2MaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[21]["ErrorMax"]; // QC3 QC3Critical = (bool)dataSet.Tables["ISOCriterion"].Rows[22]["Critical"]; QC3Min = (double)dataSet.Tables["ISOCriterion"].Rows[22]["ValueMin"]; QC3MinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[22]["ErrorMin"]; QC3Max = (double)dataSet.Tables["ISOCriterion"].Rows[22]["ValueMax"]; QC3MaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[22]["ErrorMax"]; // pH pHCritical = (bool)dataSet.Tables["ISOCriterion"].Rows[23]["Critical"]; pHMin = (double)dataSet.Tables["ISOCriterion"].Rows[23]["ValueMin"]; pHMinMsg = (string)dataSet.Tables["ISOCriterion"].Rows[23]["ErrorMin"]; pHMax = (double)dataSet.Tables["ISOCriterion"].Rows[23]["ValueMax"]; pHMaxMsg = (string)dataSet.Tables["ISOCriterion"].Rows[23]["ErrorMax"]; TempCorrectionValue = (double)dataSet.Tables["ISOSettings"].Rows[0]["TempCorrectionValue"]; DilutedMethodName = (string)dataSet.Tables["ISOSettings"].Rows[0]["DilutedMethodName"]; UndilutedMethodName = (string)dataSet.Tables["ISOSettings"].Rows[0]["UndilutedMethodName"]; DilutedDirectSeeding = (bool)dataSet.Tables["ISOSettings"].Rows[0]["DirectSeeding"]; UndilutedDirectSeeding = (bool)dataSet.Tables["ISOSettings"].Rows[0]["DirectSeeding"]; mLSeedPer1000mL = (double)dataSet.Tables["ISOSettings"].Rows[0]["mLSeedPer1000mL"]; LowestPossibleDilutionFactor = (double)dataSet.Tables["ISOSettings"].Rows[0]["LowestPossibleDilutionFactor"]; ValidTag = (string)dataSet.Tables["ISOSettings"].Rows[0]["ValidTag"]; InvalidTag = (string)dataSet.Tables["ISOSettings"].Rows[0]["InvalidTag"]; } catch { } #endregion #region 2 - reset Table, Calc for all rows and initial day #region 2.1 - reset the table DataRow[] everything = dataSet.Tables[DilutionsTable].Select("Status1<>'Skipped'"); DataRow[] ISOCriterion = dataSet.Tables["ISOCriterion"].Select(); foreach (DataRow row in everything) { try { foreach(DataRow rCriterion in ISOCriterion) { row["ErrorFlag"] = row["ErrorFlag"].ToString().Replace(rCriterion["ErrorMax"].ToString(), ""); row["ErrorFlag"] = row["ErrorFlag"].ToString().Replace(rCriterion["ErrorMin"].ToString(), ""); } row["ErrorCalc"] = ""; row["BOD"] = DBNull.Value; row["BOD_A"] = DBNull.Value; row["BOD_AS"] = ""; row["BOD_A2"] = DBNull.Value; row["BOD_A2S"] = ""; row["BOD_ANN"] = DBNull.Value; row["BOD_ANNS"] = ""; row["BOD_A2NN"] = DBNull.Value; row["BOD_A2NNS"] = ""; row["RI"] = DBNull.Value; row["CV"] = DBNull.Value; row["Method"] = ""; row["Vs"] = DBNull.Value; row["Vd"] = DBNull.Value; row["Rm"] = DBNull.Value; row["BlankAverageDepl"] = DBNull.Value; row["bValid"] = false; row["AnnexB_r"] = DBNull.Value; row["TotalDilutionsNumber"] = DBNull.Value; row["TotalReplicatesNumber"] = DBNull.Value; } catch { } } #endregion #region 2.3 - Calculation for Initial Measured rows DataRow[] InitMeasuredRows = dataSet.Tables[DilutionsTable].Select("(Status1='Measured' or Status1='Incubating') and YesNo=true"); foreach (DataRow row in InitMeasuredRows) { try { string strIdentity = row["Identity"].ToString(); string SampleType = row["Type"].ToString(); string tmpStr = dataSet.Tables[SampleTypesTableName].Select("DisplayName like '" + SampleType + "'")[0]["SKType"].ToString(); double TotalDil = 1; double Salinity = -1; double Init = -1; double TempInit = 0; double pH = 7; try { TotalDil = (double)row["TotDil"]; } catch { } try { Salinity = (double)row["Salinity"]; } catch { } try { Init = (double)row["Init"]; } catch { row["ErrorFlag"] = Error1; } try { TempInit = (double)row["TempInit"]; } catch { } try { pH = (double)row["pH"]; } catch { } try { TempInit += TempCorrectionValue; row["TempInitCorrected"] = TempInit; } catch { } try { if (Salinity != -1) { //double SalInitCorrected = Init * (1 - (-(0.001223 * TempInit + (-0.07161)) * Salinity) / ((-0.17647 * TempInit + 12.59215) * TotalDil )); double SalInitCorrected = Init * (1 - (0.0475 * Salinity) / (9.09 * TotalDil)); row["SalInitCorrected"] = SalInitCorrected; Init = SalInitCorrected; } } catch { } #region 2.2 check initial DO if (String.Compare(tmpStr, SKBlank, true) == 0) // Blanks { if (TempInit < BlankInitTempMin) { row["ErrorFlag"] += BlankInitTempMinMsg; } else if (TempInit > BlankInitTempMax) { row["ErrorFlag"] += BlankInitTempMaxMsg; } if (Init < BlankInitDOMin) { row["ErrorFlag"] += BlankInitDOMinMsg; } else if (Init > BlankInitDOMax) { row["ErrorFlag"] += BlankInitDOMaxMsg; } } else { if (TotalDil > 1) // Diluted Samples { // Temperature if (TempInit < DilutedInitTempMin) { row["ErrorFlag"] += DilutedInitTempMinMsg; } else if (TempInit > DilutedInitTempMax) { row["ErrorFlag"] += DilutedInitTempMaxMsg; } // Oxygen if (Init < DilutedInitDOMin) { row["ErrorFlag"] += DilutedInitDOMinMsg; } else if (Init > DilutedInitDOMax) { row["ErrorFlag"] += DilutedInitDOMaxMsg; } } else // UnDiluted Samples { // Temperature if (TempInit < UndilutedInitTempMin) { row["ErrorFlag"] += UndilutedInitTempMinMsg; } else if (TempInit > UndilutedInitTempMax) { row["ErrorFlag"] += UndilutedInitTempMaxMsg; } // Oxygen if (Init < UndilutedInitDOMin) { row["ErrorFlag"] += UndilutedInitDOMinMsg; } else if (Init > UndilutedInitDOMax) { row["ErrorFlag"] += UndilutedInitDOMaxMsg; } } } #endregion #region 2.4 check pH try { if (pH > 0) { if (pH < pHMin) { row["ErrorFlag"] += pHMinMsg; } if (pH > pHMax) { row["ErrorFlag"] += pHMaxMsg; } } } catch { } #endregion } catch { } } #endregion #endregion DataRow[] measuredRows = dataSet.Tables[DilutionsTable].Select("Status1='Measured' and YesNo=true"); #region 3 - Blanks foreach (DataRow row in measuredRows) { try { string strIdentity = row["Type"].ToString(); string strType = row["Type"].ToString(); string tmpStr = dataSet.Tables[SampleTypesTableName].Select("DisplayName like '" + strType + "'")[0]["SKType"].ToString(); if (String.Compare(tmpStr, SKBlank, true) == 0) { #region 5.1 declare variables double TempInit = 0; double TempFinal = 0; double Init = -1; double Final = -1; string ErrorCalc = ""; string ErrorFlag = ""; bool BlankError = false; #endregion #region 5.2 Get values from DilutionTable try { Init = (double)row["Init"]; } catch { row["ErrorCalc"] = Error1; } try { Final = (double)row["Final"]; } catch { row["ErrorCalc"] = Error2; } try { TempInit = (double)row["TempInit"]; } catch { } try { TempFinal = (double)row["TempFinal"]; } catch { } try { TempInit += TempCorrectionValue; TempFinal += TempCorrectionValue; row["TempInitCorrected"] = TempInit; row["TempFinalCorrected"] = TempFinal; } catch { } double Depl = Math.Round(Init - Final, 4); row["Depl"] = Depl; double depletionPercentage = 100 - (Final * 100 / Init); try { row["BOD_P"] = depletionPercentage; } catch { } #endregion #region 5.3 Validation #region 5.3.1 - Temperature if (TempInit < BlankInitTempMin) { if (BlankInitTempCritical) { row["ErrorCalc"] += BlankInitTempMinMsg; BlankError = true; } else { row["ErrorFlag"] += BlankInitTempMinMsg; } } else if (TempInit > BlankInitTempMax) { if (BlankInitTempCritical) { row["ErrorCalc"] += BlankInitTempMaxMsg; BlankError = true; } else { row["ErrorFlag"] += BlankInitTempMaxMsg; } } // Final Temperature Check if (TempFinal < BlankFinalTempMin) { if (BlankFinalTempCritical) { row["ErrorCalc"] += BlankFinalTempMinMsg; BlankError = true; } else { row["ErrorFlag"] += BlankFinalTempMinMsg; } } else if (TempFinal > BlankFinalTempMax) { if (BlankFinalTempCritical) { row["ErrorCalc"] += BlankFinalTempMaxMsg; BlankError = true; } else { row["ErrorFlag"] += BlankFinalTempMaxMsg; } } #endregion #region 5.3.2 Init and final DO if (Init < BlankInitDOMin) { if (BlankInitDOCritical) { row["ErrorCalc"] += BlankInitDOMinMsg; BlankError = true; } else { row["ErrorFlag"] += BlankInitDOMinMsg; } } else if (Init > BlankInitDOMax) { if (BlankInitDOCritical) { row["ErrorCalc"] += BlankInitDOMaxMsg; BlankError = true; } else { row["ErrorFlag"] += BlankInitDOMaxMsg; } } // Final DO if (Final < BlankFinalDOMin) { if (BlankFinalDOCritical) { row["ErrorCalc"] += BlankFinalDOMinMsg; BlankError = true; } else { row["ErrorFlag"] += BlankFinalDOMinMsg; } } else if (Final > BlankFinalDOMax) { if (BlankFinalDOCritical) { row["ErrorCalc"] += BlankFinalDOMaxMsg; BlankError = true; } else { row["ErrorFlag"] += BlankFinalDOMaxMsg; } } #endregion #region 5.3.3 Depletion //Warinng if (Depl < BlankDeplAlertMin) { row["ErrorFlag"] += BlankDeplAlertMinMsg; } else if (Depl > BlankDeplAlertMax) { row["ErrorFlag"] += BlankDeplAlertMaxMsg; } //deplextion if (Depl < BlankDeplMin) { if (BlankDeplCritical) { row["ErrorCalc"] += BlankDeplMinMsg; BlankError = true; } else { row["ErrorFlag"] += BlankDeplMinMsg; } } else if (Depl > BlankDeplMax) { if (BlankDeplCritical) { row["ErrorCalc"] += BlankDeplMaxMsg; BlankError = true; } else { row["ErrorFlag"] += BlankDeplMaxMsg; } } #endregion #endregion #region 5.4 Add to Average if (!BlankError) { row["bValid"] = true; row["ErrorCalc"] = ""; BlankAverage += Depl; ValidAmount++; row["BOD"] = Depl; } #endregion } } catch { } } if (ValidAmount > 0) { try { BlankAverage = Math.Round(BlankAverage / ValidAmount, 2); } catch { } try { dataSet.Tables["ISOSettings"].Rows[0]["BlankAverage"] = BlankAverage; } catch { } } else { try { dataSet.Tables["ISOSettings"].Rows[0]["BlankAverage"] = BlankAverage; } catch { } } bool bBlankAvgWritten = false; foreach (DataRow row in measuredRows) { try { string strType = row["Type"].ToString(); string tmpStr = dataSet.Tables[SampleTypesTableName].Select("DisplayName like '" + strType + "'")[0]["SKType"].ToString(); if (String.Compare(tmpStr, SKBlank, true) == 0) { if (ValidAmount > 0 && !bBlankAvgWritten) { if (row["ErrorCalc"].ToString() == "") { row["BOD_A"] = BlankAverage; row["Method"] = "Blank " + DilutedMethodName; row["BlankAverageDepl"] = BlankAverage; bBlankAvgWritten = true; if (UndilutedDirectSeeding) { try { row["Method"] = "Blank " + DilutedMethodName + " and " + UndilutedMethodName; double Seed = (double)row["Seed"]; double BottleVol = (double)row["Volume"]; if (Seed > 0) { Vd = (1000 * Seed / BottleVol); } else { Vd = mLSeedPer1000mL; } row["Vd"] = Vd; } catch { Vd = mLSeedPer1000mL; } } else { row["Method"] = "Blank " + DilutedMethodName; } } } else { row["BOD_A"] = DBNull.Value; row["Method"] = DBNull.Value; row["BlankAverageDepl"] = DBNull.Value; } } } catch (Exception e){ MessageBox.Show("check catch! "+ e.ToString());} } #endregion #region 4 - Dictionaries #region 6.1 - NN - Not Norm Disctionaries Dictionary AverageNN = new Dictionary(); Dictionary AverageRMNN = new Dictionary(); Dictionary AmountNN = new Dictionary(); List IdentitiesNN = new List(); #endregion #region 6.2 - Norm Dictionaries Dictionary Average = new Dictionary(); Dictionary AverageRM = new Dictionary(); Dictionary Amount = new Dictionary(); Dictionary AmountIncBlank = new Dictionary(); Dictionary SumSampleContent = new Dictionary(); Dictionary SumSampleContentSqr = new Dictionary(); Dictionary SumOxygenConsumption = new Dictionary(); Dictionary SumOxygenConsumptionSqr = new Dictionary(); Dictionary SumProdSCxOC = new Dictionary(); List Identities = new List(); #endregion #endregion #region 5 - BOD calculation per dilution foreach (DataRow row in measuredRows) { try { #region 7.1 - Dataset string strIdentity = row["Identity"].ToString(); string SampleType = row["Type"].ToString(); string tmpStr = dataSet.Tables[SampleTypesTableName].Select("DisplayName like '" + SampleType + "'")[0]["SKType"].ToString(); #endregion #region 7.2 - Calculation of BOD per row and Add to Average dictionary if (String.Compare(tmpStr, SKBlank, true) != 0) { #region 7.2.1 - Declare variables and get values from BOD table double TempInit = 0; double TempFinal = 0; double Salinity = -1; double Seed = 0; double Init = -1; double Final = -1; double BottleVol = 0; double Dilution = 0; double Predil = 0; double BOD = 0; double BOD_P = 0; double TotalDil = 1; bool bBODError = false; //samples Inside the Range bool bValid = true; // Valid Samples // TODO: maybe not needed - Reset the table row["ErrorCalc"] = ""; row["ErrorFlag"] = ""; row["bValid"] = true; try { BottleVol = (double)row["Volume"]; } catch { } try { Dilution = (double)row["Dil"]; } catch { } try { Predil = (double)row["PreDil"]; } catch { } try { Salinity = (double)row["Salinity"]; } catch { } try { Init = (double)row["Init"]; } catch { row["ErrorCalc"] += Error1; bValid = false; row["bValid"] = false;} try { Final = (double)row["Final"]; } catch { row["ErrorCalc"] += Error2; bValid = false;row["bValid"] = false;} try { Seed = (double)row["Seed"]; } catch { Seed = 0; } try { TempInit = (double)row["TempInit"]; } catch { } try { TempFinal = (double)row["TempFinal"]; } catch { } try { BOD_P = 100 - (Final * 100 / Init); } catch { } try { TotalDil = (double)row["TotDil"]; } catch { } try { TempInit += TempCorrectionValue; TempFinal += TempCorrectionValue; row["TempInitCorrected"] = TempInit; row["TempFinalCorrected"] = TempFinal; } catch { } try { if (Salinity != -1) { double SalInitCorrected = Init * (1 - (0.0475 * Salinity) / (9.09 * TotalDil)); row["SalInitCorrected"] = SalInitCorrected; Init = SalInitCorrected; double SalFinalCorrected = Final * (1 - (0.0475 * Salinity) / (9.09 * TotalDil)); row["SalFinalCorrected"] = SalFinalCorrected; Final = SalFinalCorrected; } } catch { } double Depl = Math.Round(Init - Final, 4); row["Depl"] = Depl; double depletionPercentage = 100 - (Final * 100 / Init); try { row["BOD_P"] = depletionPercentage; } catch { } #endregion #region 7.2.2 - BOD calculation and Range Check try { if(Init != -1 && Final != -1) { #region 7.2.3A - ISO 5815-1 Calculation if (TotalDil > 1) { #region BOD calculation row["Method"] = DilutedMethodName; if (!DilutedDirectSeeding) { BOD = ((Depl - (((BottleVol - (Dilution / Predil)) / BottleVol) * (BlankAverage))) * (BottleVol / (Dilution / Predil))); } else // Annex C calculation { row["Method"] = DilutedMethodName + " Annex C"; BOD = ((Depl - BlankAverage) * (BottleVol / Dilution) * Predil); } #endregion #region ISO 5815-1 Range Check //if ( BOD > 0 && BOD < DilutedRangeMin) if (BOD < DilutedRangeMin) { bValid = false; row["ErrorCalc"] += DilutedRangeMinMsg; } if (BOD > DilutedRangeMax) { bValid = false; row["ErrorCalc"] += DilutedRangeMaxMsg; } #endregion BlankIsUsed = true; } #endregion #region 7.2.3B - ISO 5815-2 Calculation else { #region BOD Calculation row["Method"] = UndilutedMethodName; if (!UndilutedDirectSeeding || Seed == 0) { BOD = Depl; } else // Annex B calculation { Vs = (1000 * Seed / BottleVol); row["Vs"] = Vs; BOD = (Depl - (BlankAverage * Vs / Vd)) * (1000 / (1000 - Vs)); row["Method"] = UndilutedMethodName + " Annex B"; BlankIsUsed = true; } #endregion #region ISO 5815-2 Range Check if (BOD > 0 && BOD < UndilutedRangeMin) { bValid = false; row["ErrorCalc"] += UndilutedRangeMinMsg; } if (BOD > UndilutedRangeMax) { bValid = false; row["ErrorCalc"] += UndilutedRangeMaxMsg; } #endregion } #endregion } } catch { } #endregion #region 7.2.3 - Put values on the BOD table if(BOD > 0) row["BOD"] = BOD; #endregion #region 7.2.4 - QC Check // Standard and GGA (LCS) ============================================================= if (String.Compare(tmpStr, SKGGACheck, true) == 0) { if (BOD < QC1Min) { bBODError = true; row["ErrorCalc"] += QC1MinMsg; row["BOD_A2S"] = QC1MinMsg; row["BOD_AS"] = QC1MinMsg; } if (BOD > QC1Max) { bBODError = true; row["ErrorCalc"] += QC1MaxMsg; row["BOD_AS"] = QC1MaxMsg; row["BOD_A2S"] = QC1MaxMsg; } } if (String.Compare(tmpStr, SKGGACheck2, true) == 0) { if (BOD < QC2Min) { bBODError = true; row["ErrorCalc"] += QC2MinMsg; row["BOD_A2S"] = QC2MinMsg; row["BOD_AS"] = QC2MinMsg; } if (BOD > QC2Max) { bBODError = true; row["ErrorCalc"] += QC2MaxMsg; row["BOD_AS"] = QC2MaxMsg; row["BOD_A2S"] = QC2MaxMsg; } } if (String.Compare(tmpStr, SKGGACheck3, true) == 0) { if (BOD < QC3Min) { bBODError = true; row["ErrorCalc"] += QC3MinMsg; row["BOD_A2S"] = QC3MinMsg; row["BOD_AS"] = QC3MinMsg; } if (BOD > QC1Max) { bBODError = true; row["ErrorCalc"] += QC3MaxMsg; row["BOD_AS"] = QC3MaxMsg; row["BOD_A2S"] = QC3MaxMsg; } } #endregion bool bUse = false; try { bUse = (bool)row["bUse"]; } catch { } string sMethod = row["Method"].ToString(); if ((Init > 0 && Final > 0 && !bBODError) || bUse) { if (TotalDil > 1) // Diluted Samples { // Initial Temperature if (TempInit < DilutedInitTempMin) { if (DilutedInitTempCritical) { row["ErrorCalc"] += DilutedInitTempMinMsg; bValid = false; } else { row["ErrorFlag"] = DilutedInitTempMinMsg; } } else if (TempInit > DilutedInitTempMax) { if (DilutedInitTempCritical) { row["ErrorCalc"] += DilutedInitTempMaxMsg; bValid = false; } else { row["ErrorFlag"] = DilutedInitTempMaxMsg; } } // Final Temperature if (TempFinal < DilutedFinalTempMin) { if (DilutedFinalTempCritical) { row["ErrorCalc"] += DilutedFinalTempMinMsg; bValid = false; } else { row["ErrorFlag"] = DilutedFinalTempMinMsg; } } else if (TempFinal > DilutedFinalTempMax) { if (DilutedInitTempCritical) { row["ErrorCalc"] += DilutedFinalTempMaxMsg; bValid = false; } else { row["ErrorFlag"] = DilutedFinalTempMaxMsg; } } // Oxygen Init if (Init < DilutedInitDOMin) { if (DilutedInitDOCritical) { row["ErrorCalc"] += DilutedInitDOMinMsg; bValid = false; } else { row["ErrorFlag"] = DilutedInitDOMinMsg; } } else if (Init > DilutedInitDOMax) { if (DilutedInitDOCritical) { row["ErrorCalc"] += DilutedInitDOMaxMsg; bValid = false; } else { row["ErrorFlag"] = DilutedInitDOMaxMsg; } } // Oxygen Final if (Final < DilutedFinalDOMin) { if (DilutedFinalDOCritical) { row["ErrorCalc"] += DilutedFinalDOMinMsg; bValid = false; } else { row["ErrorFlag"] = DilutedFinalDOMinMsg; } } else if (Final > DilutedFinalDOMax) { if (DilutedFinalDOCritical) { row["ErrorCalc"] += DilutedFinalDOMaxMsg; bValid = false; } else { row["ErrorFlag"] = DilutedFinalDOMaxMsg; } } // Depl mg/liter if (Depl < DilutedDeplMin && TotalDil > LowestPossibleDilutionFactor) { if (DilutedDeplCritical) { row["ErrorCalc"] += DilutedDeplMinMsg; bValid = false; } else { row["ErrorFlag"] = DilutedDeplMinMsg; } } else if (Depl > DilutedDeplMax) { if (DilutedDeplCritical) { row["ErrorCalc"] += DilutedDeplMaxMsg; bValid = false; } else { row["ErrorFlag"] = DilutedDeplMaxMsg; } } // depl in % if (BOD_P < DilutedDeplPercMin) { if (DilutedDeplPercCritical) { row["ErrorCalc"] += DilutedDeplPercMinMsg; bValid = false; } else { row["ErrorFlag"] = DilutedDeplPercMinMsg; } } else if (BOD_P > DilutedDeplPercMax) { if (DilutedDeplPercCritical) { row["ErrorCalc"] += DilutedDeplPercMaxMsg; bValid = false; } else { row["ErrorFlag"] = DilutedDeplPercMaxMsg; } } } else //Undiluted Samples { // Initial Temperature if (TempInit < UndilutedInitTempMin) { if (UndilutedInitTempCritical) { row["ErrorCalc"] += UndilutedInitTempMinMsg; bValid = false; } else { row["ErrorFlag"] = UndilutedInitTempMinMsg; } } else if (TempInit > UndilutedInitTempMax) { if (UndilutedInitTempCritical) { row["ErrorCalc"] += UndilutedInitTempMaxMsg; bValid = false; } else { row["ErrorFlag"] = UndilutedInitTempMaxMsg; } } // Final Temperature if (TempFinal < UndilutedFinalTempMin) { if (UndilutedFinalTempCritical) { row["ErrorCalc"] += UndilutedFinalTempMinMsg; bValid = false; } else { row["ErrorFlag"] = UndilutedFinalTempMinMsg; } } else if (TempFinal > UndilutedFinalTempMax) { if (UndilutedInitTempCritical) { row["ErrorCalc"] += UndilutedFinalTempMaxMsg; bValid = false; } else { row["ErrorFlag"] = UndilutedFinalTempMaxMsg; } } // Oxygen Init if (Init < UndilutedInitDOMin) { if (UndilutedInitDOCritical) { row["ErrorCalc"] += UndilutedInitDOMinMsg; bValid = false; } else { row["ErrorFlag"] = UndilutedInitDOMinMsg; } } else if (Init > UndilutedInitDOMax) { if (UndilutedInitDOCritical) { row["ErrorCalc"] += UndilutedInitDOMaxMsg; bValid = false; } else { row["ErrorFlag"] = UndilutedInitDOMaxMsg; } } // Oxygen Final if (Final < UndilutedFinalDOMin) { if (UndilutedFinalDOCritical) { row["ErrorCalc"] += UndilutedFinalDOMinMsg; bValid = false; } else { row["ErrorFlag"] = UndilutedFinalDOMinMsg; } } else if (Final > UndilutedFinalDOMax) { if (UndilutedFinalDOCritical) { row["ErrorCalc"] += UndilutedFinalDOMaxMsg; bValid = false; } else { row["ErrorFlag"] = UndilutedFinalDOMaxMsg; } } // Depl mg/liter if (Depl < DilutedDeplMin && TotalDil > LowestPossibleDilutionFactor) { if (UndilutedDeplCritical) { row["ErrorCalc"] += UndilutedDeplMinMsg; bValid = false; } else { row["ErrorFlag"] = UndilutedDeplMinMsg; } } else if (Depl > UndilutedDeplMax) { if (UndilutedDeplCritical) { row["ErrorCalc"] += UndilutedDeplMaxMsg; bValid = false; } else { row["ErrorFlag"] = UndilutedDeplMaxMsg; } } // depl in % if (BOD_P < UndilutedDeplPercMin) { if (UndilutedDeplPercCritical) { row["ErrorCalc"] += UndilutedDeplPercMinMsg; bValid = false; } else { row["ErrorFlag"] = UndilutedDeplPercMinMsg; } } else if (BOD_P > UndilutedDeplPercMax) { if (UndilutedDeplPercCritical) { row["ErrorCalc"] += UndilutedDeplPercMaxMsg; bValid = false; } else { row["ErrorFlag"] = UndilutedDeplPercMaxMsg; } } } if ((bValid || bUse) && ((String.Compare(tmpStr, SKGGACheck, true) != 0) && (String.Compare(tmpStr, SKGGACheck2, true) != 0) && (String.Compare(tmpStr, SKGGACheck3, true) != 0))) { string strIdentityX = strIdentity + "+-*=" + row["Method"].ToString(); if (!AverageNN.ContainsKey(strIdentityX)) { AverageNN.Add(strIdentityX, 0); AmountNN.Add(strIdentityX, 0); IdentitiesNN.Add(strIdentityX); } AverageNN[strIdentityX] += BOD; AmountNN[strIdentityX]++; } else { row["BOD_ANN"] = DBNull.Value; row["BOD_A2NN"] = DBNull.Value; row["BOD_ANNS"] = DBNull.Value; row["BOD_A2NNS"] = DBNull.Value; } if (bValid) { string strIdentityX = strIdentity + "+-*=" + row["Method"].ToString(); if (!Average.ContainsKey(strIdentityX)) { Average.Add(strIdentityX, 0); Amount.Add(strIdentityX, 0); Identities.Add(strIdentityX); AmountIncBlank.Add(strIdentityX, 0); SumSampleContent.Add(strIdentityX, 0); SumSampleContentSqr.Add(strIdentityX, 0); SumOxygenConsumption.Add(strIdentityX, 0); SumOxygenConsumptionSqr.Add(strIdentityX, 0); SumProdSCxOC.Add(strIdentityX, 0); foreach (DataRow row1 in measuredRows) { try { string strType1 = row1["Type"].ToString(); string tmpStr1 = dataSet.Tables[SampleTypesTableName].Select("DisplayName like '" + strType1 + "'")[0]["SKType"].ToString(); if (String.Compare(tmpStr1, SKBlank, true) == 0) { bool ValidBlank = false; double BlankDepl= (double)row1["Depl"]; ValidBlank = (bool)row1["bValid"]; if(ValidBlank) { AmountIncBlank[strIdentityX]++; SumSampleContent[strIdentityX] += 0; SumSampleContentSqr[strIdentityX] += 0; SumOxygenConsumption[strIdentityX] += BlankDepl; SumOxygenConsumptionSqr[strIdentityX] += BlankDepl*BlankDepl; SumProdSCxOC[strIdentityX] += 0; } } } catch{} } } Average[strIdentityX] += BOD; Amount[strIdentityX]++; if(TotalDil > 1) { AmountIncBlank[strIdentityX]++; SumSampleContent[strIdentityX] += Dilution / BottleVol; SumSampleContentSqr[strIdentityX] += (Dilution / BottleVol) * (Dilution / BottleVol); SumOxygenConsumption[strIdentityX] += Depl; SumOxygenConsumptionSqr[strIdentityX] += Depl*Depl; SumProdSCxOC[strIdentityX] += (Dilution / BottleVol)*Depl; } } else { row["BOD_A"] = DBNull.Value; row["BOD_A2"] = DBNull.Value; row["BOD_AS"] = DBNull.Value; row["BOD_A2S"] = DBNull.Value; row["bValid"] = false; } } } #endregion } catch (Exception e){ MessageBox.Show("check catch! "+ e.ToString());} } #endregion #region 6 - Average BOD #region 6.1 calculate average foreach (string strIdentity in Identities) { Average[strIdentity] = Average[strIdentity] / Amount[strIdentity]; AverageRM[strIdentity] = Average[strIdentity]; } // ############## NN ################# foreach (string strIdentity in IdentitiesNN) { AverageNN[strIdentity] = AverageNN[strIdentity] / AmountNN[strIdentity]; AverageRMNN[strIdentity] = AverageNN[strIdentity]; } // ############## NN ################# #endregion #region 6.2 - Average for Norm bool FirstOfSameIdentityHasAvgVal = true; foreach (DataRow row in measuredRows) { try { double TotalDil = 1; TotalDil = (double)row["TotDil"]; string strIdentity = row["Identity"].ToString(); string strMethod = row["Method"].ToString(); string strType = row["Type"].ToString(); string tmpStr = dataSet.Tables[SampleTypesTableName].Select("DisplayName like '" + strType + "'")[0]["SKType"].ToString(); string ID = (string)row["Identity"]; bool bValid = (bool)row["bValid"]; bool bUse = false; try { bUse = (bool)row["bUse"]; } catch { } string strIdentityX = strIdentity + "+-*=" + row["Method"].ToString(); if (String.Compare(tmpStr, SKBlank, true) != 0) { if (bValid) { if (row["ErrorCalc"].ToString() == "") { if (FirstOfSameIdentityHasAvgVal) // BOD Average only in 1st record for group with same Identity or all records { if (Average.ContainsKey(strIdentityX)) { row["BOD_A"] = Average[strIdentityX]; Average.Remove(strIdentityX); } else { row["BOD_A"] = DBNull.Value; } } else { row["BOD_A"] = Average[strIdentityX]; } } double dAvgBOD = -1; try { dAvgBOD = Convert.ToDouble(row["BOD_A"].ToString()); } catch { } if (dAvgBOD != -1) { if (TotalDil == 1) // average for Undiluted { if(dAvgBOD < 1) { row["BOD_A2"] = System.Math.Round(dAvgBOD, 2, System.MidpointRounding.AwayFromZero); } else { row["BOD_A2"] = System.Math.Round(dAvgBOD, 1, System.MidpointRounding.AwayFromZero); } } else { if (dAvgBOD < 100) { row["BOD_A2"] = System.Math.Round(dAvgBOD, 0, System.MidpointRounding.AwayFromZero); } else if (dAvgBOD < 1000) { row["BOD_A2"] = System.Math.Round(dAvgBOD / 10, 0, System.MidpointRounding.AwayFromZero) * 10; } else { row["BOD_A2"] = System.Math.Round(dAvgBOD / 100, 0, System.MidpointRounding.AwayFromZero) * 100; } } } } } else // Average value for blank { row["BOD_A2"] = row["BOD_A"]; } } catch { } } #endregion #region 6.3 - Rm & COD/BOD foreach (DataRow row in measuredRows) { try { string strType = row["Type"].ToString(); string tmpStr = dataSet.Tables[SampleTypesTableName].Select("DisplayName like '" + strType + "'")[0]["SKType"].ToString(); string strIdentity = row["Identity"].ToString() + "+-*=" + row["Method"].ToString(); string strID = row["Identity"].ToString(); string strMethod = row["Method"].ToString(); if (String.Compare(tmpStr, SKBlank, true) != 0) { try { #region Rm //TODO: Change this one to use the bValid DataRow[] rSameIDValid = dataSet.Tables[DilutionsTable].Select("Identity like '" + strID + "' and Method like '" + strMethod + "' and bValid = true "); double toShow = 0; try {toShow = (double)row["BOD_A"];} catch{ } double Rm = 0; bool bValid = (bool)row["bValid"]; double DilutionBOD = (double)row["BOD"]; double AverageBOD = AverageRM[strIdentity]; if (rSameIDValid.Length > 1) { Rm = (Math.Abs(DilutionBOD - AverageBOD)) / AverageBOD * 100; if(bValid) row["Rm"] = Rm; } #endregion #region r if (rSameIDValid.Length > 1) { if(toShow > 0) { int sAmountIncBlank = AmountIncBlank[strIdentity]; double sSumSampleContent = SumSampleContent[strIdentity]; double sSumSampleContentSqr = SumSampleContentSqr[strIdentity]; double sSumOxygenConsumption = SumOxygenConsumption[strIdentity]; double sSumOxygenConsumptionSqr = SumOxygenConsumptionSqr[strIdentity]; double sSumProdSCxOC = SumProdSCxOC[strIdentity]; double r = 1; double r1 = 1; double r2 = 1; double r2squared = 1; r1 = (sAmountIncBlank * sSumProdSCxOC) - (sSumSampleContent * sSumOxygenConsumption); r2 = (sAmountIncBlank * sSumSampleContentSqr - (sSumSampleContent * sSumSampleContent)) * (sAmountIncBlank * sSumOxygenConsumptionSqr - (sSumOxygenConsumption * sSumOxygenConsumption)); if(r2 > 0) { r2squared = Math.Sqrt(r2); r = r1 / r2squared; row["AnnexB_r"] = r; } } } #endregion } catch { } //catch(Exception e) {MessageBox.Show(e.ToString()); } } double dAvgBOD = -1; try { dAvgBOD = Convert.ToDouble(row["BOD_A2"].ToString()); } catch { } double dCOD = -1; try { dCOD = Convert.ToDouble(row["COD"].ToString()); } catch { } if (dAvgBOD != -1 && dCOD != -1) { double COD_Div_BOD = dCOD / dAvgBOD; row["COD_BOD"] = COD_Div_BOD; } } catch { } } #endregion #region 6.4 - Average for NN foreach (DataRow row in measuredRows) { try { string strIdentity = row["Identity"].ToString(); string strMethod = row["Method"].ToString(); string strType = row["Type"].ToString(); string tmpStr = dataSet.Tables[SampleTypesTableName].Select("DisplayName like '" + strType + "'")[0]["SKType"].ToString(); double TotalDil = 1; try { TotalDil = (double)row["TotDil"]; } catch { } bool bUse = false; try { bUse = (bool)row["bUse"]; } catch { } bool bValid = (bool)row["bValid"]; if (String.Compare(tmpStr, SKBlank, true) != 0) { if ((bValid || bUse) && ((String.Compare(tmpStr, SKGGACheck, true) != 0) && (String.Compare(tmpStr, SKGGACheck2, true) != 0) && (String.Compare(tmpStr, SKGGACheck3, true) != 0))) { string strIdentityX = strIdentity + "+-*=" + row["Method"].ToString(); if (FirstOfSameIdentityHasAvgVal) // BOD AverageNN only in 1st record for group with same Identity or all records { if (AverageNN.ContainsKey(strIdentityX)) { row["BOD_ANN"] = AverageNN[strIdentityX]; AverageNN.Remove(strIdentityX); } else { row["BOD_ANN"] = DBNull.Value; } } else { row["BOD_ANN"] = AverageNN[strIdentityX]; } double dAvgBOD = -1; try { dAvgBOD = Convert.ToDouble(row["BOD_ANN"].ToString()); } catch { } if (dAvgBOD != -1) { if (TotalDil == 1) // average for Undiluted { if(dAvgBOD < 1) { row["BOD_A2NN"] = System.Math.Round(dAvgBOD, 2, System.MidpointRounding.AwayFromZero); } else { row["BOD_A2NN"] = System.Math.Round(dAvgBOD, 1, System.MidpointRounding.AwayFromZero); } } else { if (dAvgBOD < 100) { row["BOD_A2NN"] = System.Math.Round(dAvgBOD, 0, System.MidpointRounding.AwayFromZero); } else if (dAvgBOD < 1000) { row["BOD_A2NN"] = System.Math.Round(dAvgBOD / 10, 0, System.MidpointRounding.AwayFromZero) * 10; } else { row["BOD_A2NN"] = System.Math.Round(dAvgBOD / 100, 0, System.MidpointRounding.AwayFromZero) * 100; } } } } } else // AverageNN value for blank { row["BOD_A2NN"] = row["BOD_A"]; } } catch { } } #endregion #endregion #region 7 - Final results #region 7.1 - Final Results Norm foreach (DataRow row in measuredRows) { string strType = row["Type"].ToString(); string tmpStr = dataSet.Tables[SampleTypesTableName].Select("DisplayName like '" + strType + "'")[0]["SKType"].ToString(); try { row["BOD_AS"] = row["BOD_A"]; row["BOD_A2S"] = row["BOD_A2"]; string ErrorCalcValue = row["ErrorCalc"].ToString(); if (ErrorCalcValue == QC1MaxMsg || ErrorCalcValue == QC1MinMsg || ErrorCalcValue == QC2MaxMsg || ErrorCalcValue == QC2MinMsg || ErrorCalcValue == QC3MaxMsg || ErrorCalcValue == QC3MinMsg) { row["BOD_AS"] = row["ErrorCalc"]; row["BOD_A2S"] = row["ErrorCalc"]; } else { string sIdent = row["Identity"].ToString(); string sMeth = row["Method"].ToString(); string sBOD = row["BOD_A"].ToString(); bool bUse = false; try { bUse = (bool)row["bUse"]; } catch { } bool bValid = (bool)row["bValid"]; if (sMeth.Contains(DilutedMethodName)) { DataRow[] rowSameIdentWithError = dataSet.Tables[DilutionsTable].Select("Identity like '" + sIdent + "' and Method like '" + sMeth + "' and bValid = False", "uid"); DataRow[] rowSameIdent = dataSet.Tables[DilutionsTable].Select("Identity like '" + sIdent + "' and Method like '" + sMeth + "'", "uid"); DataRow[] rowSameIdentWithUnderRange = dataSet.Tables[DilutionsTable].Select("Identity like '" + sIdent + "' and Method like '" + sMeth + "' and ErrorCalc like '" + DilutedRangeMinMsg + "'", "uid"); if (rowSameIdentWithError.Length > 0 && rowSameIdent.Length == rowSameIdentWithError.Length) // means that the BOD average was not calculated { if (rowSameIdentWithUnderRange.Length > 0) //means that there is a value under-range without other error { rowSameIdentWithUnderRange[0]["BOD_AS"] = "< " + DilutedRangeMin; rowSameIdentWithUnderRange[0]["BOD_A2S"] = "< " + DilutedRangeMin; } else // means there average was not calculated and there is no underrange value { rowSameIdent[0]["BOD_AS"] = InvalidTag; rowSameIdent[0]["BOD_A2S"] = InvalidTag; } } else //Means that everything is okay { row["BOD_AS"] = row["BOD_A"]; row["BOD_A2S"] = row["BOD_A2"]; } } else // EN1899-2 - this one can Be under and over-range { DataRow[] rowSameIdentWithError = dataSet.Tables[DilutionsTable].Select("Identity like '" + sIdent + "' and Method like '" + sMeth + "' and bValid = False", "uid"); DataRow[] rowSameIdent = dataSet.Tables[DilutionsTable].Select("Identity like '" + sIdent + "' and Method like '" + sMeth + "'", "uid"); DataRow[] rowSameIdentWithUnderRange = dataSet.Tables[DilutionsTable].Select("Identity like '" + sIdent + "' and Method like '" + sMeth + "' and ErrorCalc like '" + UndilutedRangeMinMsg + "'", "uid"); DataRow[] rowSameIdentWithOverRange = dataSet.Tables[DilutionsTable].Select("Identity like '" + sIdent + "' and Method like '" + sMeth + "' and ErrorCalc like '" + UndilutedRangeMaxMsg + "'", "uid"); if (rowSameIdentWithError.Length > 0 && rowSameIdent.Length == rowSameIdentWithError.Length) // means that the BOD average was not calculated { if (rowSameIdentWithUnderRange.Length > 0) //means that there is a value under-range without other error { rowSameIdentWithUnderRange[0]["BOD_AS"] = "< " + UndilutedRangeMin; rowSameIdentWithUnderRange[0]["BOD_A2S"] = "< " + UndilutedRangeMin; } else if (rowSameIdentWithOverRange.Length > 0) { rowSameIdentWithOverRange[0]["BOD_AS"] = "> " + UndilutedRangeMax; rowSameIdentWithOverRange[0]["BOD_A2S"] = "> " + UndilutedRangeMax; } else // means there average was not calculated and there is no under-range value { rowSameIdent[0]["BOD_AS"] = InvalidTag; rowSameIdent[0]["BOD_A2S"] = InvalidTag; } } else //Means that everything is okay or bUse { row["BOD_AS"] = row["BOD_A"]; row["BOD_A2S"] = row["BOD_A2"]; } } } } catch { } } #endregion #region 7.2 - Final Results NN foreach (DataRow row in measuredRows) { string strType = row["Type"].ToString(); string tmpStr = dataSet.Tables[SampleTypesTableName].Select("DisplayName like '" + strType + "'")[0]["SKType"].ToString(); try { row["BOD_ANNS"] = row["BOD_ANN"]; row["BOD_A2NNS"] = row["BOD_A2NN"]; if (row["ErrorCalc"] == QC1MaxMsg || row["ErrorCalc"] == QC1MinMsg || row["ErrorCalc"] == QC2MaxMsg || row["ErrorCalc"] == QC2MinMsg || row["ErrorCalc"] == QC3MaxMsg || row["ErrorCalc"] == QC3MinMsg) { row["BOD_ASNN"] = row["ErrorCalc"]; row["BOD_A2SNN"] = row["ErrorCalc"]; } else { string sIdent = row["Identity"].ToString(); string sMeth = row["Method"].ToString(); string sBOD = row["BOD_A"].ToString(); bool bUse = false; try { bUse = (bool)row["bUse"]; } catch { } bool bValid = (bool)row["bValid"]; if (sMeth.Contains(DilutedMethodName)) { DataRow[] rowSameIdentWithError = dataSet.Tables[DilutionsTable].Select("Identity like '" + sIdent + "' and Method like '" + sMeth + "' and bValid = False and bUse = False ", "uid"); DataRow[] rowSameIdent = dataSet.Tables[DilutionsTable].Select("Identity like '" + sIdent + "' and Method like '" + sMeth + "'", "uid"); DataRow[] rowSameIdentWithUnderRange = dataSet.Tables[DilutionsTable].Select("Identity like '" + sIdent + "' and Method like '" + sMeth + "' and ErrorCalc like '" + DilutedRangeMinMsg + "'", "uid"); if (rowSameIdentWithError.Length > 0 && rowSameIdent.Length == rowSameIdentWithError.Length && !bUse) // means that the BOD average was not calculated { if (rowSameIdentWithUnderRange.Length > 0) //means that there is a value under-range without other error { rowSameIdentWithUnderRange[0]["BOD_ANNS"] = "< " + DilutedRangeMin; rowSameIdentWithUnderRange[0]["BOD_A2NNS"] = "< " + DilutedRangeMin; } else // means there average was not calculated and there is no underrange value { rowSameIdent[0]["BOD_ANNS"] = InvalidTag; rowSameIdent[0]["BOD_A2NNS"] = InvalidTag; } } else //Means that everything is okay { row["BOD_ANNS"] = row["BOD_ANN"]; row["BOD_A2NNS"] = row["BOD_A2NN"]; } } else // EN1899-2 - this one can Be under and over-range { DataRow[] rowSameIdentWithError = dataSet.Tables[DilutionsTable].Select("Identity like '" + sIdent + "' and Method like '" + sMeth + "' and bValid = False and bUse = False", "uid"); DataRow[] rowSameIdent = dataSet.Tables[DilutionsTable].Select("Identity like '" + sIdent + "' and Method like '" + sMeth + "'", "uid"); DataRow[] rowSameIdentWithUnderRange = dataSet.Tables[DilutionsTable].Select("Identity like '" + sIdent + "' and Method like '" + sMeth + "' and ErrorCalc like '" + UndilutedRangeMinMsg + "'", "uid"); DataRow[] rowSameIdentWithOverRange = dataSet.Tables[DilutionsTable].Select("Identity like '" + sIdent + "' and Method like '" + sMeth + "' and ErrorCalc like '" + UndilutedRangeMaxMsg + "'", "uid"); if (rowSameIdentWithError.Length > 0 && rowSameIdent.Length == rowSameIdentWithError.Length && !bUse) // means that the BOD average was not calculated { if (rowSameIdentWithUnderRange.Length > 0) //means that there is a value under-range without other error { rowSameIdentWithUnderRange[0]["BOD_ANNS"] = "< " + UndilutedRangeMin; rowSameIdentWithUnderRange[0]["BOD_A2NNS"] = "< " + UndilutedRangeMin; } else if (rowSameIdentWithOverRange.Length > 0) { rowSameIdentWithOverRange[0]["BOD_ANNS"] = "> " + UndilutedRangeMax; rowSameIdentWithOverRange[0]["BOD_A2NNS"] = "> " + UndilutedRangeMax; } else // means there average was not calculated and there is no under-range value { rowSameIdent[0]["BOD_ANNS"] = InvalidTag; rowSameIdent[0]["BOD_A2NNS"] = InvalidTag; } } else //Means that everything is okay or bUse { row["BOD_ANNS"] = row["BOD_ANN"]; row["BOD_A2NNS"] = row["BOD_A2NN"]; } } } } catch { } } #endregion #endregion #region 8 - RI & CV Dictionary AvgRIPerIdentity = new Dictionary(); Dictionary AmountRIPerIdentity = new Dictionary(); List AlreadyHaveRI = new List(); bool RIOnlyOnFirstOffSameIdentity = true; foreach (DataRow row in measuredRows) { try { string strType = row["Type"].ToString(); string tmpStr = dataSet.Tables[SampleTypesTableName].Select("DisplayName like '" + strType + "'")[0]["SKType"].ToString(); if (String.Compare(tmpStr, SKBlank, true) != 0) { row["RI"] = DBNull.Value; row["CV"] = DBNull.Value; string strIdentityX = row["Identity"].ToString() + "+-*=" + row["Method"].ToString(); string sIdent = row["Identity"].ToString(); string sMeth = row["Method"].ToString(); bool bValid = (bool)row["bValid"]; if (bValid) { row["ErrorCalc"] += ValidTag; } if (bValid && (row["Method"].ToString().Contains(UndilutedMethodName) || row["Method"].ToString().Contains(UndilutedMethodName + " Annex B"))) { DataRow[] rSameIdentitiesValidAverage = dataSet.Tables[DilutionsTable].Select("Identity like '" + sIdent + "' and bValid = True and uid <> " + row["uid"].ToString()); DataRow[] rSameIdentitiesValidUndiluted = dataSet.Tables[DilutionsTable].Select("Identity like '" + sIdent + "' and Method like '" + sMeth + "' and bValid = True and uid <> " + row["uid"].ToString()); if (rSameIdentitiesValidAverage.Length > rSameIdentitiesValidUndiluted.Length) // TO USE ISO5815-1 RESULT IF THERE IS A VALID DILUTED RESULT { row["BOD_A"] = DBNull.Value; row["BOD_A2"] = DBNull.Value; row["BOD_ANN"] = DBNull.Value; row["BOD_A2NN"] = DBNull.Value; row["BOD_AS"] = DBNull.Value; row["BOD_A2S"] = DBNull.Value; row["BOD_ANNS"] = DBNull.Value; row["BOD_A2NNS"] = DBNull.Value; row["ErrorCalc"] = Error4; } else { if (AvgRIPerIdentity.ContainsKey(strIdentityX) == false) { AvgRIPerIdentity.Add(strIdentityX, 0); AmountRIPerIdentity.Add(strIdentityX, 0); } DataRow[] rSameIdentities = dataSet.Tables[DilutionsTable].Select("Identity like '" + sIdent + "' and Method like '" + sMeth + "' and bValid = True and uid <> " + row["uid"].ToString()); if (rSameIdentities.Length > 0) { double BOD1 = (double)rSameIdentities[0]["BOD"]; double BOD2 = (double)row["BOD"]; double RI = (Math.Abs(BOD1 - BOD2) * 100) / (0.5 * (BOD1 + BOD2)); AvgRIPerIdentity[strIdentityX] += RI; AmountRIPerIdentity[strIdentityX]++; if (RIOnlyOnFirstOffSameIdentity == false || !AlreadyHaveRI.Exists(r => r == strIdentityX)) row["RI"] = RI; if (!AlreadyHaveRI.Exists(r => r == strIdentityX)) AlreadyHaveRI.Add(strIdentityX); } } } } } catch { } } foreach (string sIdent in Identities) { if (AvgRIPerIdentity.ContainsKey(sIdent)) { AvgRIPerIdentity[sIdent] /= AmountRIPerIdentity[sIdent]; } } foreach (DataRow row in measuredRows) { try { string strType = row["Type"].ToString(); string tmpStr = dataSet.Tables[SampleTypesTableName].Select("DisplayName like '" + strType + "'")[0]["SKType"].ToString(); if (String.Compare(tmpStr, SKBlank, true) != 0) { row["CV"] = DBNull.Value; string strIdentityX = row["Identity"].ToString() + "+-*=" + row["Method"].ToString(); string sErrCalc = row["ErrorCalc"].ToString(); string sErrFlag = row["ErrorFlag"].ToString(); string sRI = row["RI"].ToString(); string sMethod = row["Method"].ToString(); if (AvgRIPerIdentity.ContainsKey(strIdentityX) && sErrCalc.Trim() == ValidTag && sRI.Trim() != "" && sMethod != DilutedMethodName) { row["CV"] = AvgRIPerIdentity[strIdentityX] / 1.128; } } } catch { } } #endregion #region 9 - BOD Correction Factor foreach (DataRow row in measuredRows) { try { string strType = row["Type"].ToString(); string tmpStr = dataSet.Tables[SampleTypesTableName].Select("DisplayName like '" + strType + "'")[0]["SKType"].ToString(); if (String.Compare(tmpStr, SKBlank, true) != 0) { double BODAverage = -9999; double iDayFactor = 1; int iIncubationDays = 5; int DaysForCorrection = 7; DaysForCorrection = (int)dataSet.Tables["ISOSettings"].Rows[0]["DaysForCorrection"]; row["BOD_AC"] = DBNull.Value; row["BODCorrectionFactor"] = DBNull.Value; try{BODAverage = (double)row["BOD_A"];} catch {} if (BODAverage > -9999) { try {iIncubationDays = (int)row["BODCorrectionDays"];} catch {iIncubationDays = -1;} if(iIncubationDays < 0) { try{iIncubationDays = (int)((double)dataSet.Tables["Settings"].Rows[0]["Incubation"] + 0.5);} catch {iIncubationDays = 5;} } DataRow[] rowFactorDay = dataSet.Tables["ISO_BODCorrection"].Select("Days = " + iIncubationDays); if(rowFactorDay.Length > 0) { switch (DaysForCorrection) { case 3: iDayFactor = (double)rowFactorDay[0]["Factor3Days"]; break; case 4: iDayFactor = (double)rowFactorDay[0]["Factor4Days"]; break; case 5: iDayFactor = (double)rowFactorDay[0]["Factor5Days"]; break; case 6: iDayFactor = (double)rowFactorDay[0]["Factor6Days"]; break; case 7: iDayFactor = (double)rowFactorDay[0]["Factor7Days"]; break; case 8: iDayFactor = (double)rowFactorDay[0]["Factor8Days"]; break; case 9: iDayFactor = (double)rowFactorDay[0]["Factor9Days"]; break; default: iDayFactor = (double)rowFactorDay[0]["Factor"]; break; } } try { row["BODCorrectionFactor"] = iDayFactor; row["BOD_AC"] = BODAverage * iDayFactor; } catch {} } } } catch { } } #endregion foreach (DataRow row in measuredRows) { string identity = row["Identity"].ToString(); DataRow[] sameIdentitySamples = dataSet.Tables[DilutionsTable].Select("Status1='Measured' and YesNo=true and Identity='" + identity + "'"); foreach (DataRow rowSameIdentity in sameIdentitySamples) { double dilutionVolume = 0; try { dilutionVolume = (double)rowSameIdentity["Dil"]; } catch { } rowSameIdentity["TotalDilutionsNumber"] = sameIdentitySamples.Length; DataRow[] sameIdentityAndVolumeSamples = dataSet.Tables[DilutionsTable].Select("Status1='Measured' and YesNo=true and Identity='" + identity + "' and Dil=" + dilutionVolume); foreach (DataRow rowSameIdentityAndVolume in sameIdentityAndVolumeSamples) { rowSameIdentityAndVolume["TotalReplicatesNumber"] = sameIdentityAndVolumeSamples.Length; } } } #region 10 - Case there is no blanks if (!bSilent) { bSilent = true; if (ValidAmount == 0 && BlankIsUsed) { string value = dataSet.Tables["ISOSettings"].Rows[0]["BlankAverage"].ToString(); while (true) { string Message_MissingBlanks = "There are no Blanks in this analysis!"; string Message_EnterBlankValue = "Please enter blank value:"; try {Message_MissingBlanks = Error5;} catch{} try {Message_EnterBlankValue = Error6;} catch{} if (General.InputBox(Message_MissingBlanks, Message_EnterBlankValue , ref value) == DialogResult.OK) { if (value == "") { System.Windows.Forms.MessageBox.Show("Cannot be empty text!"); } else { double dblTry; if (!double.TryParse(value, out dblTry)) { System.Windows.Forms.MessageBox.Show("Failed convert text to number!"); } else { BlankAverage = dblTry; try { dataSet.Tables["ISOSettings"].Rows[0]["BlankAverage"] = BlankAverage; } catch { } break; } } } else break; } } else { ValidAmount = 0; BlankAverage = 0; } } else break; #endregion } return dataSet; #endregion } #endregion #region Bod Wizard static public void UpdateBODWizardRows(string TemplateType, params object[] Parameters) { if (System.Diagnostics.Debugger.IsAttached) System.Diagnostics.Debugger.Break(); DataSet dataSet = Parameters[0] as DataSet; string DilutionsTable = "SampleAnalysis"; if(TemplateType == "Workflow") DilutionsTable = "BOD"; DataTable tblBOD = dataSet.Tables[DilutionsTable]; DataTable tblBODSamples = dataSet.Tables["BODSamples"]; DataRow[] Dilutions = tblBOD.Select("Status1='Incubating' or Status1='Incubated' or Status1='Measured' or Status1='Selected' or Status1='Measuring' or Status1='Transported' "); foreach (DataRow row in Dilutions) { string strIdentityName = row["Identity"].ToString(); if(!string.IsNullOrEmpty(strIdentityName)) { // states: // Measuring - Default // Selected - All rows as Selected // Incubating - All rows as incubating (exclude skiped) // incubated - All rows as incubated (exclude skiped) // Measured - All rows as measured (exclude skiped) DataRow[] rowsSameIdent = tblBOD.Select("Status1<>'Skipped' and YesNo=true and Identity = '" + strIdentityName + "'"); DataRow[] rowsSameIdentSelected = tblBOD.Select("Status1='Selected' and YesNo=true and Identity = '" + strIdentityName + "'"); DataRow[] rowsSameIdentIncubating = tblBOD.Select("Status1='Incubating' and YesNo=true and Identity = '" + strIdentityName + "'"); DataRow[] rowsSameIdentIncubated = tblBOD.Select("Status1='Incubated' and YesNo=true and Identity = '" + strIdentityName + "'"); DataRow[] rowsSameIdentMeasured = tblBOD.Select("Status1='Measured' and YesNo=true and Identity = '" + strIdentityName + "'"); DataRow[] rowsSameIdentPrepared = tblBOD.Select("Status1='Prepared' and YesNo=true and Identity = '" + strIdentityName + "'"); DataRow[] rowsSameIdentMeasuring = tblBOD.Select("Status1='Measuring' and YesNo=true and Identity = '" + strIdentityName + "'"); //DataRow[] rowsSameIdentTransported = tblBOD.Select("Status1='Transported' and YesNo=true and Identity = '" + strIdentityName + "'"); DataRow[] rowsSameIdentTransported = tblBOD.Select("Status1='Transported' and YesNo=true and TransportYesNo=true and Identity = '" + strIdentityName + "'"); string Status1 = "Measuring"; //MessageBox.Show("strIdentityName: "+strIdentityName+ " rowsSameIdentTransported: " + rowsSameIdentTransported.Length + "\n\n rowsSameIdent.Length: " + rowsSameIdent.Length); bool DoNotChange = false; if(rowsSameIdent.Length == rowsSameIdentSelected.Length ) { DoNotChange = true; } else { DoNotChange = false; } if(rowsSameIdentTransported.Length > 0) { if(rowsSameIdent.Length == rowsSameIdentTransported.Length ) { Status1 = "Transported"; } else { if(rowsSameIdentMeasured.Length > 0 || rowsSameIdentIncubating.Length> 0 ) { Status1 = "Measuring"; } else { Status1 = "Transporting"; } } } if(rowsSameIdent.Length == rowsSameIdentIncubating.Length || rowsSameIdentIncubating.Length == rowsSameIdent.Length -1) { Status1 = "Measured"; } else if(rowsSameIdent.Length == rowsSameIdentIncubated.Length ) { Status1 = "Incubated"; } else if(rowsSameIdent.Length == rowsSameIdentMeasured.Length || rowsSameIdentMeasured.Length == rowsSameIdent.Length -1) { Status1 = "Measured"; } double BOD_A = -9999; double BOD_AC = -9999; string BOD_AAS = ""; double BODCorrectionFactor = 1; foreach (DataRow srow1 in rowsSameIdent) { try{BOD_A = (double)srow1["BOD_A"];} catch{ } try{BOD_AAS = (string)srow1["BOD_AAS"];} catch{ } try{BOD_AC = (double)srow1["BOD_AC"];} catch{ } try{BODCorrectionFactor = (double)srow1["BODCorrectionFactor"];} catch{ } } DataRow[] rowBODSample = tblBODSamples.Select("YesNo=true and Identity = '" + strIdentityName + "'"); foreach (DataRow srow in rowBODSample) { // if ph or EC or ph adjust is selected it need to be prepared first string status1 = ""; bool Meas_pH = false; bool Meas_EC = false; bool AdjustpH = false; status1 = srow["Status1"].ToString(); Meas_pH = (bool)srow["pHYesNo"]; Meas_EC = (bool)srow["ECYesNo"]; AdjustpH = (bool)srow["pHAdjustmentYesNo"]; if((status1 == "Selected" && (Meas_pH || Meas_EC || AdjustpH )) || DoNotChange) { // do not change status on samples that need to be processed first } else { srow["Status1"] = Status1; if(BOD_A > -9999) { try{srow["BOD_A"] = BOD_A; } catch{} try{srow["BOD_AAS"] = BOD_AAS; } catch{} try{srow["BOD_AC"] = BOD_AC; } catch{} try{srow["BODCorrectionFactor"] = BODCorrectionFactor; } catch{} double COD = 0; double TOC = 0; double PMI = 0; try{COD = (double)srow["COD"];} catch{ } try{TOC = (double)srow["TOC"];} catch{ } try{PMI = (double)srow["PMI"];} catch{ } srow["BOD_CODRatio"] = DBNull.Value; srow["BOD_TOCRatio"] = DBNull.Value; srow["BOD_PMIRatio"] = DBNull.Value; if(COD > 0) { srow["BOD_CODRatio"] = BOD_A/COD; } else if(TOC > 0) { srow["BOD_TOCRatio"] = BOD_A/TOC; } else if(PMI > 0) { srow["BOD_PMIRatio"] = BOD_A/PMI; } } } } } } } #endregion #region Test Mode static public bool TestISO(string TemplateType,params object[] Parameters) { string DilutionsTable = "SampleAnalysis"; string SampleTypesTableName = "Type"; if(TemplateType == "Workflow") { DilutionsTable = "BOD"; SampleTypesTableName = "SampleType"; } DataSet dataSet = Parameters[0] as DataSet; DataTable tableDilutions = dataSet.Tables[DilutionsTable]; DataTable tableISOTest = dataSet.Tables["ISOTestTable"]; DataTable tableISOSettings = dataSet.Tables["ISOSettings"]; DataTable SampleTypes = dataSet.Tables[SampleTypesTableName]; DataTable tableISOBODNeededColumns = dataSet.Tables["ISOBODNeededColumns"]; DataTable tableISOBODColumnsToAdd = dataSet.Tables["ISOBODColumnsToAdd"]; DataRow[] rowsISOSettings = tableISOSettings.Select(); DataRow[] rowsBODNeededColumns = tableISOBODNeededColumns.Select(); DataRow[] rowsISOBODColumnsToAdd = tableISOBODColumnsToAdd.Select(); bool bError = false; bool TestMode = false; string TestType = "none"; bool copy = false; TestMode = (bool)dataSet.Tables["ISOSettings"].Rows[0]["TestMode"]; TestType = (string)dataSet.Tables["ISOSettings"].Rows[0]["TestType"]; if (TestMode) { DataRow[] DilutionsRows = tableDilutions.Select(); DataRow[] TestRows = tableISOTest.Select("TestType = '" + TestType + "'"); bool bWrong = false; foreach (DataRow columnToAdd in rowsISOBODColumnsToAdd) { columnToAdd["ColumnName"] = DBNull.Value; columnToAdd["DisplayName"] = DBNull.Value; columnToAdd["Type"] = DBNull.Value; columnToAdd["DefaultValue"] = DBNull.Value; columnToAdd["Calculation"] = DBNull.Value; columnToAdd["Units"] = DBNull.Value; columnToAdd["Observations"] = DBNull.Value; } try { DataColumnCollection ExistingColumns = tableDilutions.Columns; List MissingColumns = new List(); foreach (DataRow rowsBODNeededColumn in rowsBODNeededColumns) { if (!ExistingColumns.Contains(rowsBODNeededColumn["ColumnName"].ToString())) { DataRow[] columnToAdd = tableISOBODColumnsToAdd.Select("isnull(ColumnName,'')=''"); columnToAdd[0]["ColumnName"] = rowsBODNeededColumn["ColumnName"].ToString(); columnToAdd[0]["DisplayName"] = rowsBODNeededColumn["DisplayName"]; columnToAdd[0]["Type"] = rowsBODNeededColumn["Type"]; columnToAdd[0]["DefaultValue"] = rowsBODNeededColumn["DefaultValue"]; columnToAdd[0]["Calculation"] = rowsBODNeededColumn["Calculation"]; columnToAdd[0]["Units"] = rowsBODNeededColumn["Units"]; if(rowsBODNeededColumn["Type"] == "Boolean") { columnToAdd[0]["Observations"] = "This Column is missing, Default value as false is important!!!"; } else if(rowsBODNeededColumn["Calculation"] != DBNull.Value) { columnToAdd[0]["Observations"] = "This Column is missing, do not forget the calculation!"; } bWrong = true; } } if (bWrong) { MessageBox.Show("Please add the missing columns and test again, ISOBODColumnsToAdd table "); return false; } else { foreach (DataRow rowsBODNeededColumn in rowsBODNeededColumns) { if(rowsBODNeededColumn["Calculation"].ToString() != "") { bError = true; foreach(DataColumn d in ExistingColumns) { if(rowsBODNeededColumn["Calculation"].ToString() == d.Expression) { bError = false; copy = false; } } } if(bError) { MessageBox.Show("Missing Calculation on the column: " + rowsBODNeededColumn["ColumnName"].ToString() + "\nPlease copy the Calculation from the BODneededColumns Table"); copy = true; DataRow[] columnToAdd = tableISOBODColumnsToAdd.Select("isnull(ColumnName,'')=''"); columnToAdd[0]["ColumnName"] = rowsBODNeededColumn["ColumnName"].ToString(); columnToAdd[0]["DisplayName"] = rowsBODNeededColumn["DisplayName"]; columnToAdd[0]["Type"] = rowsBODNeededColumn["Type"]; columnToAdd[0]["DefaultValue"] = rowsBODNeededColumn["DefaultValue"]; columnToAdd[0]["Calculation"] = rowsBODNeededColumn["Calculation"]; columnToAdd[0]["Units"] = rowsBODNeededColumn["Units"]; columnToAdd[0]["Observations"] = "The Column is there but the calculation is missing or wrong."; bError = false; } } if(copy) { return false; } } } catch (Exception e){ MessageBox.Show("check catch! "+ e.ToString());} if (!bWrong) { MessageBox.Show("Your Calculation is set up. \n\n\n\n Hide the new columns, \n\and restart the software to show the display names."); dataSet.Tables["ISOSettings"].Rows[0]["TestMode"] = false; } #region Put test values (functionality is desactivated) /* if (!bWrong) { for (int i = 0; i < DilutionsRows.Length; i++) { DilutionsRows[i]["Identity"] = ""; DilutionsRows[i]["Type"] = "Sample"; DilutionsRows[i]["Dil"] = 1; DilutionsRows[i]["PreDil"] = 1; DilutionsRows[i]["Init"] = DBNull.Value; DilutionsRows[i]["TempInit"] = DBNull.Value; DilutionsRows[i]["Final"] = DBNull.Value; DilutionsRows[i]["TempFinal"] = DBNull.Value; //DilutionsRows[i]["Status1"] = "Selected"; } for (int i = 0; i < TestRows.Length; i++) { try { DilutionsRows[i]["Identity"] = TestRows[i]["Identity"]; DilutionsRows[i]["Init"] = TestRows[i]["Init"]; DilutionsRows[i]["TempInit"] = TestRows[i]["InitTemp"]; DilutionsRows[i]["Final"] = TestRows[i]["Final"]; DilutionsRows[i]["TempFinal"] = TestRows[i]["FinalTemp"]; DilutionsRows[i]["PreDil"] = TestRows[i]["Predil"]; DilutionsRows[i]["Status1"] = TestRows[i]["Status"]; if ((double)TestRows[i]["SampleVol"] == 9999) DilutionsRows[i]["Dil"] = DilutionsRows[i]["Volume"]; else if ((double)TestRows[i]["SampleVol"] == 9998) DilutionsRows[i]["Dil"] = (double)DilutionsRows[i]["Volume"] - 1; else DilutionsRows[i]["Dil"] = TestRows[i]["SampleVol"]; DataRow[] SelectedType = SampleTypes.Select("SKType = '" + TestRows[i]["SKType"] + "'"); DilutionsRows[i]["Type"] = SelectedType[0]["DisplayName"]; } catch {} } } */ #endregion } return true; } #endregion #region BODwizard static public bool ResetColors(string TemplateType,params object[] Parameters) { DataSet dataSet = Parameters[0] as DataSet; bool TestMode = false; string TestType = "none"; TestMode = (bool)dataSet.Tables["ISOSettings"].Rows[0]["TestMode"]; TestType = (string)dataSet.Tables["ISOSettings"].Rows[0]["TestType"]; if (TestMode && TestType != "none") { string DilutionsTable = "SampleAnalysis"; if(TemplateType == "Workflow") { DilutionsTable = "BOD"; } DataTable tableDilutions = dataSet.Tables[DilutionsTable]; DataRow[] MeasuredRows = tableDilutions.Select("Status1 = 'Measured' or Status1 = 'Measured_Invalid' or Status1 = 'Measured.' or Status1 = 'Measured_Invalid.'"); foreach (DataRow row in MeasuredRows) { row["Status1"] = "Measured"; } } return true; } static public bool UpdateTableColors(string TemplateType,params object[] Parameters) { if (System.Diagnostics.Debugger.IsAttached) System.Diagnostics.Debugger.Break(); string DilutionsTable = "SampleAnalysis"; if(TemplateType == "Workflow") { DilutionsTable = "BOD"; } DataSet dataSet = Parameters[0] as DataSet; DataTable tableDilutions = dataSet.Tables[DilutionsTable]; bool TestMode = false; string TestType = "none"; TestMode = (bool)dataSet.Tables["ISOSettings"].Rows[0]["TestMode"]; TestType = (string)dataSet.Tables["ISOSettings"].Rows[0]["TestType"]; if (TestMode && TestType != "none") { DataRow[] MeasuredRows = tableDilutions.Select("Status1 = 'Measured' or Status1 = 'Measured_Invalid' or Status1 = 'Measured.' or Status1 = 'Measured_Invalid.'"); bool bValid = true; int x = 0; foreach (DataRow row in MeasuredRows) { bValid = (bool)row["BValid"]; if(bValid) { row["Status1"] = "Measured"; } else { row["Status1"] = "Measured_Invalid"; } try { string rowIdentity = row["Identity"].ToString(); int rowUID = (int)row["uid"]; int previousRowUID = rowUID - 1; string PreviousRowIdentity = ""; DataRow[] previousRow = tableDilutions.Select("(Status1 = 'Measured' or Status1 = 'Measured_Invalid' or Status1 = 'Measured.' or Status1 = 'Measured_Invalid.') and uid = '" + previousRowUID + "'"); try{PreviousRowIdentity = previousRow[0]["Identity"].ToString();} catch{} if(rowIdentity != PreviousRowIdentity) { x = 1 - x; } if(x==1) { row["Status1"] = row["Status1"] + "."; } } catch{} } } return true; } #endregion } // ######################################## BOD ISO Calculation V6.3 #################################################################