/// <summary> /// On user Ok, preserve any changes to the current Acquire state as well as the current detector /// </summary> private void OKBtn_Click(object sender, EventArgs e) { if (acq.modified) { INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, DateTime.Now); acq.review_detector_parms = DetectorParametersCheckBox.Checked; acq.review_calib_parms = CalibrationParametersCheckBox.Checked; acq.review_isotopics = IsotopicsCheckBox.Checked; acq.review_run_raw_data = IndividualCycleRawDataCheckBox.Checked; acq.review_run_rate_data = IndividualCycleRateData.Checked; acq.review_summed_raw_data = SummedRawCoincidenceDataCheckBox.Checked; acq.review_summed_mult_dist = SummedMultiplicityDistributionsCheckBox.Checked; acq.review_run_mult_dist = IndividualMultiplicityDistributionsCheckBox.Checked; acq.user_id = InspectorNameTextBox.Text; acq.campaign_id = InspectionNumberTextBox.Text; acq.MeasDateTime = sel.TimeStamp; acq.lm.TimeStamp = sel.TimeStamp; // facility and mba already set by selector handlers NC.App.DB.AcquireParametersMap().Add(sel, acq); // it's a new one, not the existing one modified NC.App.DB.UpdateAcquireParams(acq, det.ListMode); } if (det.Id.modified) { NC.App.DB.UpdateDetector(det); } this.Close(); }
AcquireParameters ConfigureAcquireState(Detector det, AcquireParameters def, DateTimeOffset dto, ushort runs, string path) { AcquireParameters acq = NC.App.DB.LastAcquireFor(det); if (acq == null) { acq = new AcquireParameters(def); } acq.MeasDateTime = dto; acq.lm.TimeStamp = dto; acq.detector_id = String.Copy(det.Id.DetectorId); acq.meas_detector_id = string.Copy(acq.detector_id); acq.num_runs = runs; int tx = def.comment.IndexOf(" (Original file name"); if (tx >= 0) { acq.comment = def.comment.Substring(0, tx); } else { acq.comment = def.comment; } acq.comment += " (Original file name " + System.IO.Path.GetFileName(path) + ")"; INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, dto); if (NC.App.DB.AcquireParametersMap().ContainsKey(sel)) // only one allowed, same for actual measurement { NC.App.DB.AcquireParametersMap().Remove(sel); } NC.App.DB.AcquireParametersMap().Add(sel, acq); NC.App.DB.UpdateAcquireParams(acq, det.ListMode); return(acq); }
/// <summary> /// On user Ok, preserve any changes to the current Acquire state as well as the current detector /// </summary> private void OKBtn_Click(object sender, EventArgs e) { if (acq.modified) { INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, DateTime.Now); acq.review.DetectorParameters = DetectorParametersCheckBox.Checked; acq.review.CalibrationParameters = CalibrationParametersCheckBox.Checked; acq.review.Isotopics = IsotopicsCheckBox.Checked; acq.review.RawCycleData = IndividualCycleRawDataCheckBox.Checked; acq.review.RateCycleData = IndividualCycleRateData.Checked; acq.review.SummedRawCoincData = SummedRawCoincidenceDataCheckBox.Checked; acq.review.SummedMultiplicityDistributions = SummedMultiplicityDistributionsCheckBox.Checked; acq.review.MultiplicityDistributions = IndividualMultiplicityDistributionsCheckBox.Checked; acq.user_id = InspectorNameTextBox.Text; acq.campaign_id = InspectionNumberTextBox.Text; acq.MeasDateTime = sel.TimeStamp; // The Setter handles the LM params field copy too // facility and mba already set by selector handlers NC.App.DB.AddAcquireParams(sel, acq); // it's a new one, not the existing one modified } if (det.Id.modified) { NC.App.DB.UpdateDetector(det); } this.Close(); }
AcquireParameters ConfigureAcquireState(Detector det, AcquireParameters def, DateTimeOffset dto, ushort runs, string path) { AcquireParameters acq = NC.App.DB.LastAcquireFor(det, def.item_type); if (acq == null) { acq = new AcquireParameters(def); } acq.MeasDateTime = dto; acq.lm.TimeStamp = dto; acq.detector_id = string.Copy(det.Id.DetectorId); acq.meas_detector_id = string.Copy(acq.detector_id); acq.num_runs = runs; int tx = def.comment.IndexOf(SourceFilePrefixComment); if (tx >= 0) { acq.comment = def.comment.Substring(0, tx); } else { acq.comment = def.comment; } acq.comment += (SourceFilePrefixComment + " " + System.IO.Path.GetFileName(path)); INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, dto); NC.App.DB.ReplaceAcquireParams(sel, acq); // only one allowed, same for actual measurement return(acq); }
AcquireParameters ConfigureAcquireState(Detector det, AcquireParameters def, INCCReviewFile irf) { AcquireParameters acq = NC.App.DB.LastAcquireFor(det); if (acq == null) { acq = new AcquireParameters(def); } acq.MeasDateTime = irf.dt; acq.lm.TimeStamp = irf.dt; acq.num_runs = irf.num_runs; // RequestedRepetitions int tx = def.comment.IndexOf(" (Original file name"); if (tx >= 0) { acq.comment = def.comment.Substring(0, tx); } else { acq.comment = def.comment; } acq.comment += " (Original file name " + System.IO.Path.GetFileName(irf.Path) + ")"; acq.detector_id = String.Copy(det.Id.DetectorId); acq.meas_detector_id = string.Copy(acq.detector_id); // iid should have been added from the NOP processing above ItemId iid = NC.App.DB.ItemIds.Get(irf.item); if (iid == null) { ctrllog.TraceEvent(LogLevels.Warning, 5439, "Item id '" + irf.item + "' is referenced by the Review file measurement data, but is not found in op. rev. files or the database"); } else { acq.ApplyItemId(iid); INCCDB.Descriptor s = NC.App.DB.Stratums.Get(iid.stratum); INCCDB.Descriptor m = NC.App.DB.MBAs.Get(iid.mba); if (s != null) { acq.stratum_id = s; } if (m != null) { acq.mba = m; } } // todo: also need to account for iid UMass to mass condition INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, irf.dt); if (NC.App.DB.AcquireParametersMap().ContainsKey(sel)) // only one allowed, same for actual measurement { NC.App.DB.AcquireParametersMap().Remove(sel); } NC.App.DB.AcquireParametersMap().Add(sel, acq); NC.App.DB.UpdateAcquireParams(acq, det.ListMode); return(acq); }
void SaveAcquireState() { acq.review.DetectorParameters = DetectorParametersCheckBox.Checked; acq.review.CalibrationParameters = CalibrationParametersCheckBox.Checked; acq.review.Isotopics = IsotopicsCheckBox.Checked; acq.review.RawCycleData = IndividualCycleRawDataCheckBox.Checked; acq.review.RateCycleData = IndividualCycleRateDataCheckBox.Checked; INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, acq.MeasDateTime); N.App.DB.ReplaceAcquireParams(sel, acq); }
void SaveAcquireState() { acq.review.DetectorParameters = DetectorParametersCheckBox.Checked; acq.review.RawCycleData = IndividualCycleRawDataCheckBox.Checked; acq.review.RateCycleData = IndividualCycleRateDataCheckBox.Checked; acq.review.SummedRawCoincData = SummedRawCoincidenceDataCheckBox.Checked; acq.review.SummedMultiplicityDistributions = SummedMultiplicityDistributionsCheckBox.Checked; acq.review.MultiplicityDistributions = IndividualCycleMultiplicityDistributionsCheckBox.Checked; INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, acq.MeasDateTime); N.App.DB.ReplaceAcquireParams(sel, acq); }
private void OKBtn_Click(object sender, EventArgs e) { DialogResult = DialogResult.OK; if (string.Compare(ap.item_type, (string)MaterialTypeComboBox.SelectedItem, true) != 0) // mtl type changed on the way out { ap.item_type = (string)MaterialTypeComboBox.SelectedItem; INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, ap.item_type, DateTime.Now); ap.MeasDateTime = sel.TimeStamp; ap.lm.TimeStamp = sel.TimeStamp; N.App.DB.AddAcquireParams(sel, ap); // it's a new one, not the existing one modified } Close(); }
static void BuildMeasurement() { Detector det = null; AcquireParameters ap = null; AssaySelector.MeasurementOption mo = (AssaySelector.MeasurementOption)N.App.Config.Cur.AssayType; Integ.GetCurrentAcquireDetectorPair(ref ap, ref det); INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, ap.item_type, DateTime.Now); N.App.DB.ReplaceAcquireParams(sel, ap); // add new or replace existing with new // The acquire is set to occur, build up the measurement state Integ.BuildMeasurement(ap, det, mo); }
static void BuildMeasurement() { Detector det = null; AcquireParameters ap = null; AssaySelector.MeasurementOption mo = (AssaySelector.MeasurementOption)NC.App.Config.Cur.AssayType; Integ.GetCurrentAcquireDetectorPair(ref ap, ref det); INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, ap.item_type, DateTime.Now); NC.App.DB.AcquireParametersMap().Add(sel, ap); // it's a new one, not the existing one modified NC.App.DB.UpdateAcquireParams(ap, det.ListMode); // The acquire is set to occur, build up the measurement state Integ.BuildMeasurement(ap, det, mo); }
private void SetDet_Click(object sender, EventArgs e) { TreeNode node = treeView1.SelectedNode; if (node.Tag != null && node.Tag.GetType() == typeof(Detector)) { Detector det = (Detector)node.Tag; INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, curacq.item_type, DateTime.Now); curacq.detector_id = string.Copy(det.Id.DetectorId); curacq.meas_detector_id = string.Copy(det.Id.DetectorId); curacq.MeasDateTime = sel.TimeStamp; N.App.DB.AddAcquireParams(sel, curacq); // same material type but new detecror name // now gotta unbold the previous node bold this node font, } }
public static bool SetNewCurrentDetector(string name, bool checkForExistence) { AcquireParameters acq = GetCurrentAcquireParams(); bool exists = true; Detector det = CentralizedState.App.DB.Detectors.Find(d => string.Compare(d.Id.DetectorName, name, true) == 0); if (det == null) { exists = false; CentralizedState.App.Logger(LMLoggers.AppSection.Control).TraceEvent(LogLevels.Warning, 32441, "Detector " + name + " undefined"); if (checkForExistence) { return(false); } else { det = new Detector(); } } acq.MeasDateTime = DateTime.Now; if (!acq.detector_id.Equals(name, StringComparison.OrdinalIgnoreCase) || !acq.meas_detector_id.Equals(name, StringComparison.OrdinalIgnoreCase)) { // change detector on current acquire parms state if (!exists) { CentralizedState.App.Logger(LMLoggers.AppSection.Control).TraceEvent(LogLevels.Warning, 32442, "Temporary detector definition for missing detector " + name + " created"); } acq.detector_id = string.Copy(name); acq.meas_detector_id = string.Copy(name); INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, acq.MeasDateTime); CentralizedState.App.DB.AddAcquireParams(sel, acq); if (!exists) { CentralizedState.App.DB.Detectors.Add(det); } } else // update existing entry { CentralizedState.App.DB.UpdateAcquireParams(acq, det.ListMode); } CentralizedState.App.Logger(LMLoggers.AppSection.Control).TraceEvent(LogLevels.Info, 32444, "The current detector is now " + name); return(true); }
private void OKBtn_Click(object sender, EventArgs e) { DialogResult = DialogResult.OK; if (string.Compare(ap.item_type, (string)MaterialTypeComboBox.SelectedItem, true) != 0) // mtl type changed on the way out { ap.item_type = (string)MaterialTypeComboBox.SelectedItem; INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, ap.item_type, DateTime.Now); ap.MeasDateTime = sel.TimeStamp; ap.lm.TimeStamp = sel.TimeStamp; N.App.DB.AddAcquireParams(sel, ap); // it's a new one, not the existing one modified } Close(); IDDPlotAssaySelect measlist = new IDDPlotAssaySelect(); measlist.AnalysisMethod = AnalysisMethod; measlist.Material = Material; measlist.Init(det.Id.DetectorId, AssaySelector.MeasurementOption.verification); if (measlist.bGood) { measlist.ShowDialog(); PlotAssayChart chart = new PlotAssayChart(measlist.MeasDataList, measlist.CalibDataList); chart.ShowDialog(); } }
public unsafe bool BuildMeasurement(INCCTransferFile itf, int num) { bool overwrite = NC.App.AppContext.OverwriteImportedDefs; results_rec results = itf.results_rec_list[0]; meas_id id; TransferUtils.Copy(results.meas_date, 0, id.meas_date, 0, INCC.DATE_TIME_LENGTH); TransferUtils.Copy(results.meas_time, 0, id.meas_time, 0, INCC.DATE_TIME_LENGTH); TransferUtils.Copy(results.filename, 0, id.filename, 0, INCC.FILE_NAME_LENGTH); TransferUtils.Copy(results.results_detector_id, 0, id.results_detector_id, 0, INCC.MAX_DETECTOR_ID_LENGTH); DateTime dt = INCC.DateTimeFrom(TransferUtils.str(id.meas_date, INCC.DATE_TIME_LENGTH), TransferUtils.str(id.meas_time, INCC.DATE_TIME_LENGTH)); // do not use content from last BuildDetector call, instead look up the detector on the pre-existing list string detname = TransferUtils.str(id.results_detector_id, INCC.MAX_DETECTOR_ID_LENGTH); Detector det = NC.App.DB.Detectors.GetItByDetectorId(detname); if (det == null) { mlogger.TraceEvent(LogLevels.Error, 34087, "Unknown detector '{0}', not importing this measurement {1}", detname, dt.ToString("s")); return false; } meas = new Measurement((AssaySelector.MeasurementOption)results.meas_option, mlogger); // TODO: update detector details from this meas result, since there could be a difference meas.MeasurementId.MeasDateTime = dt; meas.MeasurementId.FileName = TransferUtils.str(id.filename, INCC.FILE_NAME_LENGTH); meas.Detectors.Add(det); // in practice this is a list with one element, e.g. meas.Detector TestParameters t = new TestParameters(); t.accSnglTestRateLimit = results.r_acc_sngl_test_rate_limit; t.accSnglTestPrecisionLimit = results.r_acc_sngl_test_precision_limit; t.accSnglTestOutlierLimit = results.r_acc_sngl_test_outlier_limit; t.outlierTestLimit = results.r_outlier_test_limit; t.bkgDoublesRateLimit = results.r_bkg_doubles_rate_limit; t.bkgTriplesRateLimit = results.r_bkg_triples_rate_limit; t.chiSquaredLimit = results.r_chisq_limit; t.maxNumFailures = results.r_max_num_failures; t.highVoltageTestLimit = results.r_high_voltage_test_limit; t.normalBackupAssayTestLimit = results.r_normal_backup_assay_test_lim; t.maxCyclesForOutlierTest = (uint)results.r_max_runs_for_outlier_test; t.checksum = (results.r_checksum_test == 0.0 ? false : true); t.accidentalsMethod = INCCAccidentalsMethod((int)results.results_accidentals_method); meas.Tests.Copy(t); NormParameters n = NC.App.DB.NormParameters.Get(detname); meas.Norm.Copy(n); BackgroundParameters b = NC.App.DB.BackgroundParameters.Get(detname); meas.Background.Copy(b); // DB write for these occurs at end of processing here // Isotopics handled in this block if (itf.isotopics_table.Count > 0) { string isoname = TransferUtils.str(results.item_isotopics_id, INCC.MAX_ISOTOPICS_ID_LENGTH); NCCTransfer.isotopics_rec isotopics = itf.isotopics_table[0]; //bool first = true; // forgot why the code does this, to put the default in the map? // foreach (LMTransfer.isotopics_rec ir in itf.istopics_table) // { AnalysisDefs.Isotopics iso; // if (first) iso = meas.Isotopics; // else // iso = new Isotopics(); // first = false; iso.am_date = INCC.DateFrom(TransferUtils.str(isotopics.am_date, INCC.DATE_TIME_LENGTH)); iso.pu_date = INCC.DateFrom(TransferUtils.str(isotopics.pu_date, INCC.DATE_TIME_LENGTH)); iso.id = TransferUtils.str(isotopics.isotopics_id, INCC.MAX_ISOTOPICS_ID_LENGTH); AnalysisDefs.Isotopics.SourceCode checksc = AnalysisDefs.Isotopics.SourceCode.OD; string check = TransferUtils.str(isotopics.isotopics_source_code, INCC.ISO_SOURCE_CODE_LENGTH); bool okparse = Enum.TryParse(check, true, out checksc); iso.source_code = checksc; iso.SetValueError(Isotope.am241, isotopics.am241, isotopics.am241_err); iso.SetValueError(Isotope.pu238, isotopics.pu238, isotopics.pu238_err); iso.SetValueError(Isotope.pu239, isotopics.pu239, isotopics.pu239_err); iso.SetValueError(Isotope.pu240, isotopics.pu240, isotopics.pu240_err); iso.SetValueError(Isotope.pu241, isotopics.pu241, isotopics.pu241_err); iso.SetValueError(Isotope.pu242, isotopics.pu242, isotopics.pu242_err); if (!NC.App.DB.Isotopics.Has(iso.id)) { NC.App.DB.Isotopics.GetList().Add(iso); mlogger.TraceEvent(LogLevels.Info, 34021, "Identified new isotopics {0}", iso.id); } else { if (overwrite) { NC.App.DB.Isotopics.Replace(iso); mlogger.TraceEvent(LogLevels.Warning, 34022, "Replaced existing isotopics {0}", iso.id); } else { mlogger.TraceEvent(LogLevels.Warning, 34022, "Not replacing existing isotopics {0}", iso.id); } } iso.modified = true; } AcquireParameters acq = meas.AcquireState; acq.detector_id = det.Id.DetectorId; acq.meas_detector_id = string.Copy(det.Id.DetectorId); // probably incorrect usage, but differnce is ambiguous in INCC5 acq.item_type = TransferUtils.str(results.results_item_type, INCC.MAX_ITEM_TYPE_LENGTH); acq.qc_tests = TransferUtils.ByteBool(results.results_qc_tests); acq.user_id = TransferUtils.str(results.user_id, INCC.CHAR_FIELD_LENGTH); acq.num_runs = results.total_number_runs; if (results.number_good_runs > 0) acq.run_count_time = results.total_good_count_time / results.number_good_runs; else acq.run_count_time = results.total_good_count_time; // should be 0.0 by default for this special case acq.MeasDateTime = meas.MeasurementId.MeasDateTime; acq.error_calc_method = INCCErrorCalculationTechnique(results.error_calc_method); acq.campaign_id = TransferUtils.str(results.results_campaign_id, INCC.MAX_CAMPAIGN_ID_LENGTH); if (string.IsNullOrEmpty(acq.campaign_id)) acq.campaign_id = TransferUtils.str(results.results_inspection_number, INCC.MAX_CAMPAIGN_ID_LENGTH); acq.comment = TransferUtils.str(results.comment, INCC.MAX_COMMENT_LENGTH);//"Original file name " + meas.MeasurementId.FileName; string ending_comment_str = TransferUtils.str(results.ending_comment, INCC.MAX_COMMENT_LENGTH); acq.ending_comment = !string.IsNullOrEmpty(acq.ending_comment_str); acq.data_src = (ConstructedSource)results.data_source; acq.well_config = (WellConfiguration)results.well_config; acq.print = TransferUtils.ByteBool(results.results_print); mlogger.TraceEvent(LogLevels.Verbose, 34000, "Building {0} measurement {1} '{2},{3}' from {2}", meas.MeasOption.PrintName(), num, acq.detector_id, acq.item_type, itf.Path); if (itf.facility_table.Count > 0) meas.AcquireState.facility = new INCCDB.Descriptor(string.Copy(itf.facility_table[0].id), string.Copy(itf.facility_table[0].desc)); if (itf.mba_table.Count > 0) meas.AcquireState.mba = new INCCDB.Descriptor(string.Copy(itf.mba_table[0].id), string.Copy(itf.mba_table[0].desc)); if (itf.stratum_id_names_rec_table.Count > 0) meas.AcquireState.stratum_id = new INCCDB.Descriptor(string.Copy(itf.stratum_id_names_rec_table[0].id), string.Copy(itf.stratum_id_names_rec_table[0].desc)); // stratum values meas.Stratum = new Stratum(); meas.Stratum.bias_uncertainty = results.bias_uncertainty; meas.Stratum.random_uncertainty = results.random_uncertainty; meas.Stratum.relative_std_dev = results.relative_std_dev; meas.Stratum.systematic_uncertainty = results.systematic_uncertainty; INCCDB.Descriptor mtdesc = new INCCDB.Descriptor(string.Copy(acq.item_type), string.Empty); if (!NC.App.DB.Materials.Has(mtdesc) || overwrite) { NC.App.DB.Materials.Update(mtdesc); } // prepare norm parms, should be done with a prior pass with the detector file, then this code looks it up in the collection set at this point in the processing meas.Norm.currNormalizationConstant.v = results.normalization_constant; meas.Norm.currNormalizationConstant.err = results.normalization_constant_err; foreach (DescriptorPair dp in itf.facility_table) { INCCDB.Descriptor idesc = new INCCDB.Descriptor(string.Copy(dp.id), string.Copy(dp.desc)); if (!NC.App.DB.Facilities.Has(idesc) || overwrite) { idesc.modified = true; NC.App.DB.Facilities.Update(idesc); } } foreach (DescriptorPair dp in itf.mba_table) { INCCDB.Descriptor idesc = new INCCDB.Descriptor(string.Copy(dp.id), string.Copy(dp.desc)); if (!NC.App.DB.MBAs.Has(idesc) || overwrite) { idesc.modified = true; NC.App.DB.MBAs.Update(idesc); } } foreach (DescriptorPair dp in itf.stratum_id_names_rec_table) { INCCDB.Descriptor idesc = new INCCDB.Descriptor(string.Copy(dp.id), string.Copy(dp.desc)); if (meas.Stratum != null) { idesc.modified = true; NC.App.DB.UpdateStratum(idesc, meas.Stratum); // creates it NC.App.DB.AssociateStratum(det, idesc, meas.Stratum); // associates it with the detector } } if (itf.item_id_table.Count > 0) // devnote: there should be only one item entry { ItemId item = new ItemId(); item.declaredMass = results.declared_mass; item.declaredUMass = results.declared_u_mass; item.length = results.length; item.IOCode = TransferUtils.str(results.io_code, INCC.IO_CODE_LENGTH); item.inventoryChangeCode = TransferUtils.str(results.inventory_change_code, INCC.INVENTORY_CHG_LENGTH); item.isotopics = TransferUtils.str(results.item_isotopics_id, INCC.MAX_ISOTOPICS_ID_LENGTH); item.stratum = TransferUtils.str(results.stratum_id, INCC.MAX_STRATUM_ID_LENGTH); item.item = TransferUtils.str(results.item_id, INCC.MAX_ITEM_ID_LENGTH); item.material = TransferUtils.str(results.results_item_type, INCC.MAX_ITEM_TYPE_LENGTH); //copy measurement dates to item item.pu_date = new DateTime(meas.Isotopics.pu_date.Ticks); item.am_date = new DateTime(meas.Isotopics.am_date.Ticks); item.modified = true; List<ItemId> list = NC.App.DB.ItemIds.GetList(); bool flump = list.Exists(i => { return string.Compare(item.item, i.item, true) == 0; }); if (flump && overwrite) { list.Remove(item); list.Add(item); } else list.Add(item); // fill in the acquire record from the item id acq.ApplyItemId(item); meas.MeasurementId.Item = new ItemId(item); } meas.INCCAnalysisState = new INCCAnalysisState(); INCCSelector sel = new INCCSelector(acq.detector_id, acq.item_type); AnalysisMethods am; bool found = NC.App.DB.DetectorMaterialAnalysisMethods.TryGetValue(sel, out am); if (found) { meas.INCCAnalysisState.Methods = am; meas.INCCAnalysisState.Methods.selector = sel; } else { mlogger.TraceEvent(LogLevels.Error, 34063, "No analysis methods for {0}, (calibration information is missing), creating placeholders", sel.ToString()); // devnote: can get missing paramters from the meas results for calib and verif below, so need to visit this condition after results processing below (newres.methodParams!) and reconstruct the calib parameters. meas.INCCAnalysisState.Methods = new AnalysisMethods(mlogger); meas.INCCAnalysisState.Methods.selector = sel; } // prepare analyzer params from sr params above meas.AnalysisParams = new AnalysisDefs.CountingAnalysisParameters(); meas.AnalysisParams.Add(det.MultiplicityParams); mlogger.TraceEvent(LogLevels.Verbose, 34030, "Transferring the {0} cycles", itf.run_rec_list.Count); meas.InitializeContext(); meas.PrepareINCCResults(); // prepares INCCResults objects ulong MaxBins = 0; foreach (run_rec r in itf.run_rec_list) { ulong x= AddToCycleList(r, det); if (x > MaxBins) MaxBins = x; } for (int cf = 1; (itf.CFrun_rec_list != null) && (cf < itf.CFrun_rec_list.Length); cf++) { foreach (run_rec r in itf.CFrun_rec_list[cf]) { AddToCycleList(r, det, cf); } } // summarize the result in the result, if you know what I mean MultiplicityCountingRes mcr = (MultiplicityCountingRes)meas.CountingAnalysisResults[det.MultiplicityParams]; for (int i = 0; i < 9; i++) mcr.covariance_matrix[i] = results.covariance_matrix[i]; mcr.DeadtimeCorrectedRates.Singles.err = results.singles_err; mcr.DeadtimeCorrectedRates.Doubles.err = results.doubles_err; mcr.DeadtimeCorrectedRates.Triples.err = results.triples_err; mcr.DeadtimeCorrectedRates.Singles.v = results.singles; mcr.DeadtimeCorrectedRates.Doubles.v = results.doubles; mcr.DeadtimeCorrectedRates.Triples.v = results.triples; mcr.Scaler1Rate.v = results.scaler1; mcr.Scaler2Rate.v = results.scaler2; mcr.Scaler1Rate.err = results.scaler1_err; mcr.Scaler2Rate.err = results.scaler2_err; mcr.Scaler1.v = results.scaler1; mcr.Scaler2.v = results.scaler2; mcr.Scaler1.err = results.scaler1_err; mcr.Scaler2.err = results.scaler2_err; mcr.ASum = results.acc_sum; mcr.RASum = results.reals_plus_acc_sum; mcr.S1Sum = results.scaler1_sum; mcr.S2Sum = results.scaler2_sum; mcr.mass = results.declared_mass; mcr.FA = det.MultiplicityParams.FA; mcr.RAMult = TransferUtils.multarrayxfer(results.mult_reals_plus_acc_sum, INCC.MULTI_ARRAY_SIZE); mcr.NormedAMult = TransferUtils.multarrayxfer(results.mult_acc_sum, INCC.MULTI_ARRAY_SIZE); mcr.MaxBins = (ulong)Math.Max(mcr.RAMult.Length, mcr.NormedAMult.Length); mcr.MinBins = (ulong)Math.Min(mcr.RAMult.Length, mcr.NormedAMult.Length); mcr.RawDoublesRate.v = results.uncorrected_doubles; mcr.RawDoublesRate.err = results.uncorrected_doubles_err; mcr.singles_multi = results.singles_multi; mcr.doubles_multi = results.doubles_multi; mcr.triples_multi = results.triples_multi; INCCResult result; MeasOptionSelector mos = new MeasOptionSelector(meas.MeasOption, det.MultiplicityParams); result = meas.INCCAnalysisState.Lookup(mos); result.DeadtimeCorrectedRates.Singles.err = results.singles_err; result.DeadtimeCorrectedRates.Doubles.err = results.doubles_err; result.DeadtimeCorrectedRates.Triples.err = results.triples_err; result.DeadtimeCorrectedRates.Singles.v = results.singles; result.DeadtimeCorrectedRates.Doubles.v = results.doubles; result.DeadtimeCorrectedRates.Triples.v = results.triples; result.rates.RawRates.Scaler1s.v = results.scaler1; result.rates.RawRates.Scaler2s.v = results.scaler2; result.rates.RawRates.Scaler1s.err = results.scaler1_err; result.rates.RawRates.Scaler2s.err = results.scaler2_err; result.S1Sum = results.scaler1_sum; result.S2Sum = results.scaler2_sum; result.ASum = results.acc_sum; result.RASum = results.reals_plus_acc_sum; result.RAMult = TransferUtils.multarrayxfer(results.mult_reals_plus_acc_sum, INCC.MULTI_ARRAY_SIZE); result.NormedAMult = TransferUtils.multarrayxfer(results.mult_acc_sum, INCC.MULTI_ARRAY_SIZE); result.MaxBins = (ulong)Math.Max(result.RAMult.Length, result.NormedAMult.Length); result.MinBins = (ulong)Math.Min(result.RAMult.Length, result.NormedAMult.Length); mcr.RawDoublesRate.v = results.uncorrected_doubles; mcr.RawDoublesRate.err = results.uncorrected_doubles_err; result.singles_multi = results.singles_multi; result.doubles_multi = results.doubles_multi; result.triples_multi = results.triples_multi; // hack expansion of Normed mult array to same length as Acc mult array on each cycle to accomodate TheoreticalOutlier calc array length bug ExpandMaxBins(MaxBins, meas.Cycles, det.MultiplicityParams); Bloat(MaxBins, mcr); List<MeasurementMsg> msgs = meas.GetMessageList(det.MultiplicityParams); // move the error messages for (int i = 0; i < INCC.NUM_ERROR_MSG_CODES; i++) { int index = i * INCC.ERR_MSG_LENGTH; string e = TransferUtils.str(results.error_msg_codes + index, INCC.ERR_MSG_LENGTH); if (e.Length > 0) meas.AddMessage(msgs, LogLevels.Error, 911, e, meas.MeasurementId.MeasDateTime); } // move the warning messages for (int i = 0; i < INCC.NUM_WARNING_MSG_CODES; i++) { int index = i * INCC.ERR_MSG_LENGTH; string w = TransferUtils.str(results.warning_msg_codes + index, INCC.ERR_MSG_LENGTH); if (w.Length > 0) meas.AddMessage(msgs, LogLevels.Warning, 411, w, meas.MeasurementId.MeasDateTime); } #region results transfer INCCMethodResults imr; bool got = meas.INCCAnalysisResults.TryGetINCCResults(det.MultiplicityParams, out imr); // only ever this single mkey for INCC5-style transfer import, (thankfully) if (got) imr.primaryMethod = OldToNewMethodId(results.primary_analysis_method); // check these results against the meas.MeasOption expectation => seems to always be 1 - 1 with (opt, sr) -> results, and subresults only for verif and calib choice // rates -> none, // bkg -> bkg, norm -> bias, init src -> init src, prec -> prec, // calib -> calib, 1 or more INCC methods on the methods submap // verif -> 1 or more INCC methods on the methods submap foreach (iresultsbase r in itf.method_results_list) { if (r is results_init_src_rec) { mlogger.TraceEvent(LogLevels.Verbose, 34041, ("Transferring initial source results")); results_init_src_rec oldres = (results_init_src_rec)r; INCCResults.results_init_src_rec newres = (INCCResults.results_init_src_rec) meas.INCCAnalysisState.Lookup(new MeasOptionSelector(meas.MeasOption, det.MultiplicityParams), typeof(INCCResults.results_init_src_rec)); newres.mode = OldToNewBiasTestId(oldres.init_src_mode); newres.pass = TransferUtils.PassCheck(oldres.init_src_pass_fail); newres.init_src_id = TransferUtils.str(oldres.init_src_id, INCC.SOURCE_ID_LENGTH); } else if (r is results_bias_rec) { mlogger.TraceEvent(LogLevels.Verbose, 34042, ("Transferring normalization results")); results_bias_rec oldres = (results_bias_rec)r; INCCResults.results_bias_rec newres = (INCCResults.results_bias_rec)meas.INCCAnalysisState.Lookup(new MeasOptionSelector(meas.MeasOption, det.MultiplicityParams), typeof(INCCResults.results_bias_rec)); newres.pass = TransferUtils.PassCheck(oldres.bias_pass_fail); newres.biasDblsRateExpect.v = oldres.bias_dbls_rate_expect; newres.biasDblsRateExpectMeas.v = oldres.bias_dbls_rate_expect_meas; newres.biasSnglsRateExpect.v = oldres.bias_sngls_rate_expect; newres.biasSnglsRateExpectMeas.v = oldres.bias_sngls_rate_expect_meas; newres.biasDblsRateExpect.err = oldres.bias_dbls_rate_expect_err; newres.biasDblsRateExpectMeas.err = oldres.bias_dbls_rate_expect_meas_err; newres.biasSnglsRateExpect.err = oldres.bias_sngls_rate_expect_err; newres.biasSnglsRateExpectMeas.err = oldres.bias_sngls_rate_expect_meas_err; newres.newNormConstant.v = oldres.new_norm_constant; newres.newNormConstant.err = oldres.new_norm_constant_err; newres.measPrecision = oldres.meas_precision; newres.requiredMeasSeconds = oldres.required_meas_seconds; newres.requiredPrecision = oldres.required_precision; newres.mode = OldToNewBiasTestId(oldres.results_bias_mode); newres.sourceId = TransferUtils.str(oldres.bias_source_id, INCC.SOURCE_ID_LENGTH); // NEXT: for init src and bias, results norm values transferred to meas.norm } else if (r is results_precision_rec) { mlogger.TraceEvent(LogLevels.Verbose, 34043, ("Transferring precision results")); results_precision_rec oldres = (results_precision_rec)r; INCCResults.results_precision_rec newres = (INCCResults.results_precision_rec)meas.INCCAnalysisState.Lookup(new MeasOptionSelector(meas.MeasOption, det.MultiplicityParams), typeof(INCCResults.results_precision_rec)); newres.chiSqLowerLimit = oldres.chi_sq_lower_limit; newres.chiSqUpperLimit = oldres.chi_sq_upper_limit; newres.precChiSq = oldres.prec_chi_sq; newres.precSampleVar = oldres.prec_sample_var; newres.precTheoreticalVar = oldres.prec_theoretical_var; newres.pass = TransferUtils.PassCheck(oldres.prec_pass_fail); } else { if (r is results_cal_curve_rec) { // need to look up in existing map and see if it is there and then create and load it if not mlogger.TraceEvent(LogLevels.Verbose, 34050, ("Transferring method results for " + r.GetType().ToString())); results_cal_curve_rec oldres = (results_cal_curve_rec)r; INCCMethodResults.results_cal_curve_rec newres = (INCCMethodResults.results_cal_curve_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.CalibrationCurve, true); newres.pu240e_mass = new Tuple(oldres.cc_pu240e_mass, oldres.cc_pu240e_mass_err); newres.pu_mass = new Tuple(oldres.cc_pu_mass, oldres.cc_pu_mass_err); newres.dcl_pu240e_mass = oldres.cc_dcl_pu240e_mass; newres.dcl_pu_mass = oldres.cc_dcl_pu_mass; newres.dcl_minus_asy_pu_mass = new Tuple(oldres.cc_dcl_minus_asy_pu_mass, oldres.cc_dcl_minus_asy_pu_mass_err); newres.dcl_minus_asy_pu_mass_pct = oldres.cc_dcl_minus_asy_pu_mass_pct; newres.pass = TransferUtils.PassCheck(oldres.cc_pass_fail); newres.dcl_u_mass = oldres.cc_dcl_u_mass; newres.length = oldres.cc_length; newres.heavy_metal_content = oldres.cc_heavy_metal_content; newres.heavy_metal_correction = oldres.cc_heavy_metal_correction; newres.heavy_metal_corr_singles = new Tuple(oldres.cc_heavy_metal_corr_singles, oldres.cc_heavy_metal_corr_singles_err); newres.heavy_metal_corr_doubles = new Tuple(oldres.cc_heavy_metal_corr_doubles, oldres.cc_heavy_metal_corr_doubles_err); newres.methodParams.heavy_metal_corr_factor = oldres.cc_heavy_metal_corr_factor_res; newres.methodParams.heavy_metal_reference = oldres.cc_heavy_metal_reference_res; // newres.methodParams.cev.lower_mass_limit = oldres.cc_lower_mass_limit_res; // newres.methodParams.cev.upper_mass_limit = oldres.cc_upper_mass_limit_res; newres.methodParams.percent_u235 = oldres.cc_percent_u235_res; newres.methodParams.cev.a = oldres.cc_a_res; newres.methodParams.cev.b = oldres.cc_b_res; newres.methodParams.cev.c = oldres.cc_c_res; newres.methodParams.cev.d = oldres.cc_d_res; newres.methodParams.cev.var_a = oldres.cc_var_a_res; newres.methodParams.cev.var_b = oldres.cc_var_b_res; newres.methodParams.cev.var_c = oldres.cc_var_c_res; newres.methodParams.cev.var_d = oldres.cc_var_d_res; newres.methodParams.cev.setcovar(Coeff.a,Coeff.b,oldres.cc_covar_ab_res); newres.methodParams.cev._covar[0, 2] = oldres.cc_covar_ac_res; newres.methodParams.cev._covar[0, 3] = oldres.cc_covar_ad_res; newres.methodParams.cev._covar[1, 2] = oldres.cc_covar_bc_res; newres.methodParams.cev._covar[1, 3] = oldres.cc_covar_bd_res; newres.methodParams.cev._covar[2, 3] = oldres.cc_covar_cd_res; newres.methodParams.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)oldres.cc_cal_curve_equation; newres.methodParams.CalCurveType = (INCCAnalysisParams.CalCurveType)oldres.cc_cal_curve_type_res; newres.methodParams.cev.sigma_x = oldres.cc_sigma_x_res; } else if (r is results_known_alpha_rec) { // need to look up in existing map and see if it is there and then create and load it if not mlogger.TraceEvent(LogLevels.Verbose, 34051, ("Transferring method results for " + r.GetType().ToString())); results_known_alpha_rec oldres = (results_known_alpha_rec)r; INCCMethodResults.results_known_alpha_rec newres = (INCCMethodResults.results_known_alpha_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.KnownA, true); newres.corr_doubles.v = oldres.ka_corr_doubles; newres.corr_doubles.err = oldres.ka_corr_doubles_err; newres.mult = oldres.ka_mult; newres.alphaK = oldres.ka_alpha; newres.mult_corr_doubles = new Tuple(oldres.ka_mult_corr_doubles, oldres.ka_mult_corr_doubles_err); newres.pu240e_mass = new Tuple(oldres.ka_pu240e_mass, oldres.ka_pu240e_mass_err); newres.pu_mass = new Tuple(oldres.ka_pu_mass, oldres.ka_pu_mass_err); newres.dcl_pu240e_mass = oldres.ka_dcl_pu240e_mass; newres.dcl_pu_mass = oldres.ka_dcl_pu_mass; newres.dcl_minus_asy_pu_mass = new Tuple(oldres.ka_dcl_minus_asy_pu_mass, oldres.ka_dcl_minus_asy_pu_mass_err); newres.dcl_minus_asy_pu_mass_pct = oldres.ka_dcl_minus_asy_pu_mass_pct; newres.pass = TransferUtils.PassCheck(oldres.ka_pass_fail); newres.dcl_u_mass = oldres.ka_dcl_u_mass; newres.length = oldres.ka_length; newres.heavy_metal_content = oldres.ka_heavy_metal_content; newres.heavy_metal_correction = oldres.ka_heavy_metal_correction; newres.corr_singles = new Tuple(oldres.ka_corr_singles, oldres.ka_corr_singles_err); newres.corr_doubles = new Tuple(oldres.ka_corr_doubles, oldres.ka_corr_doubles_err); newres.corr_factor = oldres.ka_corr_factor; newres.dry_alpha_or_mult_dbls = oldres.ka_dry_alpha_or_mult_dbls; newres.upper_corr_factor_limit = oldres.ka_upper_corr_factor_limit_res; newres.lower_corr_factor_limit = oldres.ka_lower_corr_factor_limit_res; newres.methodParams = new INCCAnalysisParams.known_alpha_rec(); newres.methodParams.alpha_wt = oldres.ka_alpha_wt_res; newres.methodParams.heavy_metal_corr_factor = oldres.ka_heavy_metal_corr_factor_res; newres.methodParams.heavy_metal_reference = oldres.ka_heavy_metal_reference_res; newres.methodParams.k = oldres.ka_k_res; newres.methodParams.known_alpha_type = (INCCAnalysisParams.KnownAlphaVariant)oldres.ka_known_alpha_type_res; newres.methodParams.lower_corr_factor_limit = oldres.ka_lower_corr_factor_limit_res; newres.methodParams.upper_corr_factor_limit = oldres.ka_upper_corr_factor_limit_res; newres.methodParams.rho_zero = oldres.ka_rho_zero_res; newres.methodParams.ring_ratio.cal_curve_equation = (INCCAnalysisParams.CurveEquation)oldres.ka_ring_ratio_equation_res; newres.methodParams.ring_ratio.a = oldres.ka_ring_ratio_a_res; newres.methodParams.ring_ratio.b = oldres.ka_ring_ratio_b_res; newres.methodParams.ring_ratio.c = oldres.ka_ring_ratio_c_res; newres.methodParams.ring_ratio.d = oldres.ka_ring_ratio_d_res; newres.methodParams.cev.a = oldres.ka_a_res; newres.methodParams.cev.b = oldres.ka_b_res; newres.methodParams.cev.var_a = oldres.ka_var_a_res; newres.methodParams.cev.var_b= oldres.ka_var_b_res; newres.methodParams.cev.sigma_x = oldres.ka_sigma_x_res; newres.methodParams.cev.setcovar(Coeff.a, Coeff.b, oldres.ka_covar_ab_res); newres.methodParams.cev.lower_mass_limit = oldres.ka_lower_corr_factor_limit_res; newres.methodParams.cev.upper_mass_limit = oldres.ka_upper_corr_factor_limit_res; } else if (r is results_multiplicity_rec) { mlogger.TraceEvent(LogLevels.Verbose, 34052, ("Transferring method results for " + r.GetType().ToString())); results_multiplicity_rec oldres = (results_multiplicity_rec)r; INCCMethodResults.results_multiplicity_rec newres = (INCCMethodResults.results_multiplicity_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.Multiplicity, true); newres.solve_efficiency_choice = (INCCAnalysisParams.MultChoice)oldres.mul_solve_efficiency_res; newres.pass = TransferUtils.PassCheck(oldres.mul_pass_fail); newres.efficiencyComputed.v = oldres.mul_efficiency; newres.efficiencyComputed.err = oldres.mul_efficiency_err; newres.mult.v = oldres.mul_mult; newres.mult.err = oldres.mul_mult_err; newres.alphaK.v = oldres.mul_alpha; newres.alphaK.err = oldres.mul_alpha_err; newres.corr_factor.v = oldres.mul_corr_factor; newres.corr_factor.err = oldres.mul_corr_factor_err; newres.pu240e_mass.v = oldres.mul_pu240e_mass; newres.pu240e_mass.err = oldres.mul_pu240e_mass_err; newres.pu_mass.v = oldres.mul_pu_mass; newres.pu_mass.err = oldres.mul_pu_mass_err; newres.dcl_minus_asy_pu_mass.v = oldres.mul_dcl_minus_asy_pu_mass; newres.dcl_minus_asy_pu_mass.err = oldres.mul_dcl_minus_asy_pu_mass_err; newres.dcl_pu240e_mass = oldres.mul_dcl_pu240e_mass; newres.dcl_pu_mass = oldres.mul_dcl_pu_mass; newres.dcl_minus_asy_pu_mass_pct = oldres.mul_dcl_minus_asy_pu_mass_pct; newres.methodParams = new INCCAnalysisParams.multiplicity_rec(); newres.methodParams.sf_rate = oldres.mul_sf_rate_res; newres.methodParams.vs1 = oldres.mul_vs1_res; newres.methodParams.vs2 = oldres.mul_vs2_res; newres.methodParams.vs3 = oldres.mul_vs3_res; newres.methodParams.vi1 = oldres.mul_vi1_res; newres.methodParams.vi2 = oldres.mul_vi2_res; newres.methodParams.vi3 = oldres.mul_vi3_res; newres.methodParams.a = oldres.mul_a_res; newres.methodParams.b = oldres.mul_b_res; newres.methodParams.c = oldres.mul_b_res; newres.methodParams.sigma_x = oldres.mul_sigma_x_res; newres.methodParams.alpha_weight = oldres.mul_alpha_weight_res; newres.methodParams.multEffCorFactor = oldres.mul_corr_factor; } else if (r is results_truncated_mult_rec) { mlogger.TraceEvent(LogLevels.Verbose, 34053, ("Transferring method results for " + r.GetType().ToString())); results_truncated_mult_rec oldres = (results_truncated_mult_rec)r; INCCMethodResults.results_truncated_mult_rec newres = (INCCMethodResults.results_truncated_mult_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.TruncatedMultiplicity, true); newres.k.pass = TransferUtils.PassCheck(oldres.tm_k_pass_fail); newres.bkg.Singles.v = oldres.tm_bkg_singles; newres.bkg.Singles.err = oldres.tm_bkg_singles_err; newres.bkg.Zeros.v = oldres.tm_bkg_zeros; newres.bkg.Zeros.err = oldres.tm_bkg_zeros_err; newres.bkg.Ones.v = oldres.tm_bkg_ones; newres.bkg.Ones.err = oldres.tm_bkg_ones_err; newres.bkg.Twos.v = oldres.tm_bkg_twos; newres.bkg.Twos.err = oldres.tm_bkg_twos_err; newres.net.Singles.v = oldres.tm_net_singles; newres.net.Singles.err = oldres.tm_net_singles_err; newres.net.Zeros.v = oldres.tm_net_zeros; newres.net.Zeros.err = oldres.tm_net_zeros_err; newres.net.Ones.v = oldres.tm_net_ones; newres.net.Ones.err = oldres.tm_net_ones_err; newres.net.Twos.v = oldres.tm_net_twos; newres.net.Twos.err = oldres.tm_net_twos_err; newres.k.alpha.v = oldres.tm_k_alpha; newres.k.alpha.err = oldres.tm_k_alpha_err; newres.k.pu_mass.v = oldres.tm_k_pu_mass; newres.k.pu_mass.err = oldres.tm_k_pu_mass_err; newres.k.pu240e_mass.v = oldres.tm_k_pu240e_mass; newres.k.pu240e_mass.err = oldres.tm_k_pu240e_mass_err; newres.k.dcl_minus_asy_pu_mass.v = oldres.tm_k_dcl_minus_asy_pu_mass; newres.k.dcl_minus_asy_pu_mass.err = oldres.tm_k_dcl_minus_asy_pu_mass_err; newres.s.alpha.v = oldres.tm_s_alpha; newres.s.alpha.err = oldres.tm_s_alpha_err; newres.s.pu_mass.v = oldres.tm_s_pu_mass; newres.s.pu_mass.err = oldres.tm_s_pu_mass_err; newres.s.pu240e_mass.v = oldres.tm_s_pu240e_mass; newres.s.pu240e_mass.err = oldres.tm_s_pu240e_mass_err; newres.s.dcl_minus_asy_pu_mass.v = oldres.tm_s_dcl_minus_asy_pu_mass; newres.s.dcl_minus_asy_pu_mass.err = oldres.tm_s_dcl_minus_asy_pu_mass_err; newres.methodParams.a = oldres.tm_a_res; newres.methodParams.b = oldres.tm_b_res; newres.methodParams.known_eff = (oldres.tm_known_eff_res == 0 ? false : true); newres.methodParams.solve_eff = (oldres.tm_solve_eff_res == 0 ? false : true); } else if (r is results_known_m_rec) { // dev note: untested mlogger.TraceEvent(LogLevels.Verbose, 34054, ("Transferring method results for " + r.GetType().ToString())); results_known_m_rec oldres = (results_known_m_rec)r; INCCMethodResults.results_known_m_rec newres = (INCCMethodResults.results_known_m_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.KnownM, true); newres.pu_mass = new Tuple(oldres.km_pu_mass, oldres.km_pu_mass_err); newres.pu240e_mass = new Tuple(oldres.km_pu240e_mass, oldres.km_pu240e_mass); newres.alpha = oldres.km_alpha; newres.mult = oldres.km_mult; newres.dcl_minus_asy_pu_mass = new Tuple(oldres.km_dcl_minus_asy_pu_mass, oldres.km_dcl_minus_asy_pu_mass_err); newres.pu239e_mass = oldres.km_pu240e_mass; newres.dcl_pu240e_mass = oldres.km_dcl_pu240e_mass; newres.dcl_pu_mass = oldres.km_dcl_pu_mass; newres.dcl_minus_asy_pu_mass_pct = oldres.km_dcl_minus_asy_pu_mass_pct; newres.pass = TransferUtils.PassCheck(oldres.km_pass_fail); newres.methodParams.b = oldres.km_b_res; newres.methodParams.c = oldres.km_c_res; newres.methodParams.sf_rate = oldres.km_sf_rate_res; newres.methodParams.sigma_x = oldres.km_sigma_x_res; newres.methodParams.vs1 = oldres.km_vs1_res; newres.methodParams.vi1 = oldres.km_vi1_res; newres.methodParams.vs2 = oldres.km_vs2_res; newres.methodParams.vi2 = oldres.km_vi2_res; } else if (r is results_add_a_source_rec) { // dev note: untested mlogger.TraceEvent(LogLevels.Verbose, 34055, ("Transferring method results for " + r.GetType().ToString())); results_add_a_source_rec oldres = (results_add_a_source_rec)r; INCCMethodResults.results_add_a_source_rec newres = (INCCMethodResults.results_add_a_source_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.KnownM, true); newres.pu_mass = new Tuple(oldres.ad_pu_mass, oldres.ad_pu_mass_err); newres.pu240e_mass = new Tuple(oldres.ad_pu240e_mass, oldres.ad_pu240e_mass); newres.dcl_minus_asy_pu_mass = new Tuple(oldres.ad_dcl_minus_asy_pu_mass, oldres.ad_dcl_minus_asy_pu_mass_err); newres.dcl_pu240e_mass = oldres.ad_dcl_pu240e_mass; newres.dcl_pu_mass = oldres.ad_dcl_pu_mass; newres.dcl_minus_asy_pu_mass_pct = oldres.ad_dcl_minus_asy_pu_mass_pct; newres.pass = TransferUtils.PassCheck(oldres.ad_pass_fail); newres.dzero_cf252_doubles = oldres.ad_dzero_cf252_doubles; newres.sample_avg_cf252_doubles.v = oldres.ad_sample_avg_cf252_doubles; newres.sample_avg_cf252_doubles.err = oldres.ad_sample_avg_cf252_doubles_err; newres.corr_doubles.v = oldres.ad_corr_doubles; newres.corr_doubles.err = oldres.ad_corr_doubles_err; newres.delta.v = oldres.ad_delta; newres.delta.err = oldres.ad_delta_err; newres.corr_factor.v = oldres.ad_corr_factor; newres.corr_factor.err = oldres.ad_corr_factor_err; newres.sample_cf252_ratio = TransferUtils.Copy(oldres.ad_sample_cf252_ratio, INCC.MAX_ADDASRC_POSITIONS); newres.sample_cf252_doubles = Tuple.MakeArray( vals: TransferUtils.Copy(oldres.ad_sample_cf252_doubles, INCC.MAX_ADDASRC_POSITIONS), errs: TransferUtils.Copy(oldres.ad_sample_cf252_doubles_err, INCC.MAX_ADDASRC_POSITIONS)); newres.tm_doubles_bkg.v = oldres.ad_tm_doubles_bkg; newres.tm_uncorr_doubles.v = oldres.ad_tm_uncorr_doubles; newres.tm_corr_doubles.v = oldres.ad_corr_doubles; newres.tm_doubles_bkg.err = oldres.ad_tm_doubles_bkg_err; newres.tm_uncorr_doubles.err = oldres.ad_tm_uncorr_doubles_err; newres.tm_corr_doubles.err = oldres.ad_corr_doubles_err; newres.methodParams.cev.a = oldres.ad_a_res; newres.methodParams.cev.b = oldres.ad_b_res; newres.methodParams.cev.c = oldres.ad_c_res; newres.methodParams.cev.d = oldres.ad_d_res; newres.methodParams.cev.var_a = oldres.ad_var_a_res; newres.methodParams.cev.var_b = oldres.ad_var_b_res; newres.methodParams.cev.var_c = oldres.ad_var_c_res; newres.methodParams.cev.var_d = oldres.ad_var_d_res; newres.methodParams.cev.setcovar(Coeff.a, Coeff.b, oldres.ad_covar_ab_res); newres.methodParams.cev._covar[0, 2] = oldres.ad_covar_ac_res; newres.methodParams.cev._covar[0, 3] = oldres.ad_covar_ad_res; newres.methodParams.cev._covar[1, 2] = oldres.ad_covar_bc_res; newres.methodParams.cev._covar[1, 3] = oldres.ad_covar_bd_res; newres.methodParams.cev._covar[2, 3] = oldres.ad_covar_cd_res; newres.methodParams.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)oldres.ad_add_a_source_equation; newres.methodParams.cev.sigma_x = oldres.ad_sigma_x_res; newres.methodParams.cf.a = oldres.ad_cf_a_res; newres.methodParams.cf.b = oldres.ad_cf_b_res; newres.methodParams.cf.c = oldres.ad_cf_c_res; newres.methodParams.cf.d = oldres.ad_cf_d_res; newres.methodParams.dzero_avg = oldres.ad_dzero_avg_res; newres.methodParams.num_runs = oldres.ad_num_runs_res; newres.methodParams.tm_dbls_rate_upper_limit = oldres.ad_tm_dbls_rate_upper_limit_res; newres.methodParams.tm_weighting_factor = oldres.ad_tm_weighting_factor_res; newres.methodParams.use_truncated_mult = (oldres.ad_use_truncated_mult_res == 0 ? false : true); newres.methodParams.dzero_ref_date = INCC.DateFrom(TransferUtils.str(oldres.ad_dzero_ref_date_res, INCC.DATE_TIME_LENGTH)); newres.methodParams.position_dzero = TransferUtils.Copy(oldres.ad_position_dzero_res, INCC.MAX_ADDASRC_POSITIONS); // devnote: the original methodParams dcl_mass, doubles, min, max not preserved in INCC5 aas result rec } else if (r is results_curium_ratio_rec) { // dev note: untested mlogger.TraceEvent(LogLevels.Verbose, 34056, ("Transferring method results for " + r.GetType().ToString())); results_curium_ratio_rec oldres = (results_curium_ratio_rec)r; INCCMethodResults.results_curium_ratio_rec newres = (INCCMethodResults.results_curium_ratio_rec) meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.CuriumRatio, true); newres.pu.pu240e_mass = new Tuple(oldres.cr_pu240e_mass, oldres.cr_pu240e_mass_err); newres.pu.mass = new Tuple(oldres.cr_pu_mass, oldres.cr_pu_mass_err); newres.pu.dcl_mass = oldres.cr_dcl_pu_mass; newres.pu.dcl_minus_asy_mass = new Tuple(oldres.cr_dcl_minus_asy_pu_mass, oldres.cr_dcl_minus_asy_pu_mass_err); newres.pu.dcl_minus_asy_mass_pct = oldres.cr_dcl_minus_asy_pu_mass_pct; newres.pu.dcl_minus_asy_pu_mass = new Tuple(oldres.cr_dcl_minus_asy_pu_mass, oldres.cr_dcl_minus_asy_pu_mass_err); newres.pu.dcl_minus_asy_pu_mass_pct = oldres.cr_dcl_minus_asy_pu_mass_pct; newres.pu.pass = TransferUtils.PassCheck(oldres.cr_pu_pass_fail); newres.u.mass = new Tuple(oldres.cr_u_mass, oldres.cr_u_mass_err); newres.u.dcl_mass = oldres.cr_dcl_u_mass_res; newres.u.dcl_minus_asy_mass = new Tuple(oldres.cr_dcl_minus_asy_u_mass, oldres.cr_dcl_minus_asy_u_mass_err); newres.u.dcl_minus_asy_mass_pct = oldres.cr_dcl_minus_asy_u_mass_pct; newres.u.pass = TransferUtils.PassCheck(oldres.cr_u_pass_fail); newres.u235.mass = new Tuple(oldres.cr_u235_mass, oldres.cr_u235_mass_err); newres.u235.dcl_mass = oldres.cr_dcl_u235_mass_res; newres.u235.dcl_minus_asy_mass = new Tuple(oldres.cr_dcl_minus_asy_u235_mass, oldres.cr_dcl_minus_asy_u235_mass_err); newres.u235.dcl_minus_asy_mass_pct = oldres.cr_dcl_minus_asy_u235_mass_pct; newres.cm_mass = new Tuple(oldres.cr_cm_mass, oldres.cr_cm_mass_err); newres.methodParams2.cm_pu_ratio = new Tuple(oldres.cr_cm_pu_ratio, oldres.cr_cm_pu_ratio_err); newres.cm_pu_ratio_decay_corr = new Tuple(oldres.cr_cm_pu_ratio_decay_corr, oldres.cr_cm_pu_ratio_decay_corr_err); newres.methodParams2.cm_pu_ratio_date = INCC.DateFrom(TransferUtils.str(oldres.cr_cm_pu_ratio_date, INCC.DATE_TIME_LENGTH)); newres.cm_u_ratio_decay_corr = new Tuple(oldres.cr_cm_u_ratio_decay_corr, oldres.cr_cm_u_ratio_decay_corr_err); newres.methodParams2.cm_u_ratio_date = INCC.DateFrom(TransferUtils.str(oldres.cr_cm_pu_ratio_date, INCC.DATE_TIME_LENGTH)); newres.methodParams2.pu_half_life = oldres.cr_pu_half_life; newres.methodParams2.cm_id_label = TransferUtils.str(oldres.cr_cm_id_label, INCC.MAX_ITEM_ID_LENGTH); newres.methodParams2.cm_id = TransferUtils.str(oldres.cr_cm_id, INCC.MAX_ITEM_ID_LENGTH); newres.methodParams2.cm_input_batch_id = TransferUtils.str(oldres.cr_cm_input_batch_id, INCC.MAX_ITEM_ID_LENGTH); newres.methodParams.cev.a = oldres.cr_a_res; newres.methodParams.cev.b = oldres.cr_b_res; newres.methodParams.cev.c = oldres.cr_c_res; newres.methodParams.cev.d = oldres.cr_d_res; newres.methodParams.cev.var_a = oldres.cr_var_a_res; newres.methodParams.cev.var_b = oldres.cr_var_b_res; newres.methodParams.cev.var_c = oldres.cr_var_c_res; newres.methodParams.cev.var_d = oldres.cr_var_d_res; newres.methodParams.cev.setcovar(Coeff.a,Coeff.b,oldres.cr_covar_ab_res); newres.methodParams.cev._covar[0, 2] = oldres.cr_covar_ac_res; newres.methodParams.cev._covar[0, 3] = oldres.cr_covar_ad_res; newres.methodParams.cev._covar[1, 2] = oldres.cr_covar_bc_res; newres.methodParams.cev._covar[1, 3] = oldres.cr_covar_bd_res; newres.methodParams.cev._covar[2, 3] = oldres.cr_covar_cd_res; newres.methodParams.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)oldres.cr_curium_ratio_equation; newres.methodParams.cev.sigma_x = oldres.cr_sigma_x_res; newres.methodParams.curium_ratio_type = OldToNewCRVariants(oldres.curium_ratio_type_res); } else if (r is results_active_passive_rec) // NEXT: confusion with combined, it's the same as Active internally? expand and study { mlogger.TraceEvent(LogLevels.Verbose, 34057, ("Transferring method results for " + r.GetType().ToString())); results_active_passive_rec oldres = (results_active_passive_rec)r; INCCMethodResults.results_active_passive_rec newres = (INCCMethodResults.results_active_passive_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.ActivePassive, true); newres.pass = TransferUtils.PassCheck(oldres.ap_pass_fail); newres.k.v = oldres.ap_k; newres.k.err = oldres.ap_k_err; newres.k0.v = oldres.ap_k0; newres.k1.v = oldres.ap_k1; newres.k1.err = oldres.ap_k1_err; newres.u235_mass.v = oldres.ap_u235_mass; newres.u235_mass.err = oldres.ap_u235_mass_err; newres.dcl_minus_asy_u235_mass.v = oldres.ap_dcl_minus_asy_u235_mass; newres.dcl_minus_asy_u235_mass.err = oldres.ap_dcl_minus_asy_u235_mass_err; newres.dcl_u235_mass = oldres.ap_dcl_u235_mass; newres.dcl_minus_asy_u235_mass_pct = oldres.ap_dcl_minus_asy_u235_mass_pct; newres.methodParams = new INCCAnalysisParams.active_passive_rec(); newres.methodParams.cev.a = oldres.ap_a_res; newres.methodParams.cev.b = oldres.ap_b_res; newres.methodParams.cev.c = oldres.ap_c_res; newres.methodParams.cev.d = oldres.ap_d_res; newres.methodParams.cev.var_a = oldres.ap_var_a_res; newres.methodParams.cev.var_b = oldres.ap_var_b_res; newres.methodParams.cev.var_c = oldres.ap_var_c_res; newres.methodParams.cev.var_d = oldres.ap_var_d_res; newres.methodParams.cev.setcovar(Coeff.a, Coeff.b, oldres.ap_covar_ab_res); newres.methodParams.cev._covar[0, 2] = oldres.ap_covar_ac_res; newres.methodParams.cev._covar[0, 3] = oldres.ap_covar_ad_res; newres.methodParams.cev._covar[1, 2] = oldres.ap_covar_bc_res; newres.methodParams.cev._covar[1, 3] = oldres.ap_covar_bd_res; newres.methodParams.cev._covar[2, 3] = oldres.ap_covar_cd_res; newres.methodParams.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)oldres.ap_active_passive_equation; newres.methodParams.cev.sigma_x = oldres.ap_sigma_x_res; newres.delta_doubles.v = oldres.ap_delta_doubles; newres.delta_doubles.err = oldres.ap_delta_doubles_err; } else if (r is results_active_rec) { mlogger.TraceEvent(LogLevels.Verbose, 34058, ("Transferring method results for " + r.GetType().ToString())); results_active_rec oldres = (results_active_rec)r; INCCMethodResults.results_active_rec newres = (INCCMethodResults.results_active_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.Active, true); newres.pass = TransferUtils.PassCheck(oldres.act_pass_fail); newres.k.v = oldres.act_k; newres.k.err = oldres.act_k_err; newres.k0.v = oldres.act_k0; newres.k1.v = oldres.act_k1; newres.k1.err = oldres.act_k1_err; newres.u235_mass.v = oldres.act_u235_mass; newres.u235_mass.err = oldres.act_u235_mass_err; newres.dcl_minus_asy_u235_mass.v = oldres.act_dcl_minus_asy_u235_mass; newres.dcl_minus_asy_u235_mass.err = oldres.act_dcl_minus_asy_u235_mass_err; newres.dcl_u235_mass = oldres.act_dcl_u235_mass; newres.dcl_minus_asy_u235_mass_pct = oldres.act_dcl_minus_asy_u235_mass_pct; newres.methodParams = new INCCAnalysisParams.active_rec(); newres.methodParams.cev.a = oldres.act_a_res; newres.methodParams.cev.b = oldres.act_b_res; newres.methodParams.cev.c = oldres.act_c_res; newres.methodParams.cev.d = oldres.act_d_res; newres.methodParams.cev.var_a = oldres.act_var_a_res; newres.methodParams.cev.var_b = oldres.act_var_b_res; newres.methodParams.cev.var_c = oldres.act_var_c_res; newres.methodParams.cev.var_d = oldres.act_var_d_res; newres.methodParams.cev.setcovar(Coeff.a,Coeff.b,oldres.act_covar_ab_res); newres.methodParams.cev._covar[0, 2] = oldres.act_covar_ac_res; newres.methodParams.cev._covar[0, 3] = oldres.act_covar_ad_res; newres.methodParams.cev._covar[1, 2] = oldres.act_covar_bc_res; newres.methodParams.cev._covar[1, 3] = oldres.act_covar_bd_res; newres.methodParams.cev._covar[2, 3] = oldres.act_covar_cd_res; newres.methodParams.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)oldres.act_active_equation; newres.methodParams.cev.sigma_x = oldres.act_sigma_x_res; } else if (r is results_active_mult_rec) { mlogger.TraceEvent(LogLevels.Verbose, 34059, ("Transferring method results for " + r.GetType().ToString())); results_active_mult_rec oldres = (results_active_mult_rec)r; INCCMethodResults.results_active_mult_rec newres = (INCCMethodResults.results_active_mult_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.ActiveMultiplicity, true); newres.methodParams = new INCCAnalysisParams.active_mult_rec(); newres.methodParams.vf1 = oldres.am_vf1_res; newres.methodParams.vf2 = oldres.am_vf2_res; newres.methodParams.vf3 = oldres.am_vf3_res; newres.methodParams.vt1 = oldres.am_vt1_res; newres.methodParams.vt2 = oldres.am_vt2_res; newres.methodParams.vt3 = oldres.am_vt2_res; newres.mult.v = oldres.am_mult; newres.mult.err = oldres.am_mult_err; } else if (r is results_collar_rec) { mlogger.TraceEvent(LogLevels.Verbose, 34060, ("Transferring method results for " + r.GetType().ToString())); results_collar_rec oldres = (results_collar_rec)r; INCCMethodResults.results_collar_rec newres = (INCCMethodResults.results_collar_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.Collar, true); newres.u235_mass.v = oldres.col_u235_mass; newres.u235_mass.err = oldres.col_u235_mass_err; newres.percent_u235 = oldres.col_percent_u235; newres.total_u_mass = oldres.col_total_u_mass; newres.k0.v = oldres.col_k0; newres.k0.err = oldres.col_k0_err; newres.k1.v = oldres.col_k1; newres.k1.err = oldres.col_k1_err; newres.k2.v = oldres.col_k2; newres.k2.err = oldres.col_k2_err; newres.k3.v = oldres.col_k3; newres.k3.err = oldres.col_k3_err; newres.k4.v = oldres.col_k4; newres.k4.err = oldres.col_k4_err; newres.k5.v = oldres.col_k5; newres.k5.err = oldres.col_k5_err; newres.source_id = TransferUtils.str(oldres.col_source_id, INCC.SOURCE_ID_LENGTH); newres.total_corr_fact.v = oldres.col_total_corr_fact; newres.total_corr_fact.err = oldres.col_total_corr_fact_err; newres.corr_doubles.v = oldres.col_corr_doubles; newres.corr_doubles.err = oldres.col_corr_doubles_err; newres.dcl_length.v = oldres.col_dcl_length; newres.dcl_length.err = oldres.col_dcl_length_err; newres.dcl_total_u235.v = oldres.col_dcl_total_u235; newres.dcl_total_u235.err = oldres.col_dcl_total_u235_err; newres.dcl_total_u238.v = oldres.col_dcl_total_u238; newres.dcl_total_u238.err = oldres.col_dcl_total_u238_err; newres.dcl_total_rods = oldres.col_dcl_total_rods; newres.dcl_total_poison_rods = oldres.col_dcl_total_poison_rods; newres.dcl_poison_percent.v = oldres.col_dcl_poison_percent; newres.dcl_poison_percent.err = oldres.col_dcl_poison_percent_err; newres.dcl_minus_asy_u235_mass_pct = oldres.col_dcl_minus_asy_u235_mass_pct; newres.dcl_minus_asy_u235_mass.v = oldres.col_dcl_minus_asy_u235_mass; newres.dcl_minus_asy_u235_mass.err = oldres.col_dcl_minus_asy_u235_mass_err; newres.methodParamsC.cev.a = oldres.col_a_res; newres.methodParamsC.cev.b = oldres.col_b_res; newres.methodParamsC.cev.c = oldres.col_c_res; newres.methodParamsC.cev.d = oldres.col_d_res; newres.methodParamsC.cev.var_a = oldres.col_var_a_res; newres.methodParamsC.cev.var_b = oldres.col_var_b_res; newres.methodParamsC.cev.var_c = oldres.col_var_c_res; newres.methodParamsC.cev.var_d = oldres.col_var_d_res; newres.methodParamsC.cev.setcovar(Coeff.a,Coeff.b,oldres.col_covar_ab_res); newres.methodParamsC.cev._covar[0, 2] = oldres.col_covar_ac_res; newres.methodParamsC.cev._covar[0, 3] = oldres.col_covar_ad_res; newres.methodParamsC.cev._covar[1, 2] = oldres.col_covar_bc_res; newres.methodParamsC.cev._covar[1, 3] = oldres.col_covar_bd_res; newres.methodParamsC.cev._covar[2, 3] = oldres.col_covar_cd_res; newres.methodParamsC.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)oldres.col_collar_equation; newres.methodParamsC.cev.sigma_x = oldres.col_sigma_x_res; newres.methodParamsC.poison_absorption_fact[0] = oldres.col_poison_absorption_fact_res; newres.methodParamsC.poison_rod_a[0] = new Tuple(oldres.col_poison_rod_a_res, oldres.col_poison_rod_a_err_res); newres.methodParamsC.poison_rod_b[0] = new Tuple(oldres.col_poison_rod_b_res, oldres.col_poison_rod_b_err_res); newres.methodParamsC.poison_rod_c[0] = new Tuple(oldres.col_poison_rod_c_res, oldres.col_poison_rod_c_err_res); newres.methodParamsC.collar_mode = (oldres.col_collar_mode == 0 ? false : true); newres.methodParamsC.number_calib_rods = (int)oldres.col_number_calib_rods_res; newres.methodParamsC.poison_rod_type[0] = TransferUtils.str(oldres.col_poison_rod_type_res, INCC.MAX_ROD_TYPE_LENGTH); newres.methodParamsC.u_mass_corr_fact_a.v = oldres.col_u_mass_corr_fact_a_res; newres.methodParamsC.u_mass_corr_fact_a.err = oldres.col_u_mass_corr_fact_a_err_res; newres.methodParamsC.u_mass_corr_fact_b.v = oldres.col_u_mass_corr_fact_b_res; newres.methodParamsC.u_mass_corr_fact_b.err = oldres.col_u_mass_corr_fact_b_err_res; newres.methodParamsC.sample_corr_fact.v = oldres.col_sample_corr_fact_res; newres.methodParamsC.sample_corr_fact.err = oldres.col_sample_corr_fact_err_res; newres.methodParamsDetector.collar_mode = (oldres.col_collar_mode == 0 ? false : true); newres.methodParamsDetector.reference_date = INCC.DateFrom(TransferUtils.str(oldres.col_reference_date_res, INCC.DATE_TIME_LENGTH)); newres.methodParamsDetector.relative_doubles_rate = oldres.col_relative_doubles_rate_res; newres.methodParamsK5.k5_mode = (oldres.col_collar_mode == 0 ? false : true); newres.methodParamsK5.k5_item_type = TransferUtils.str(oldres.col_collar_item_type, INCC.MAX_ITEM_TYPE_LENGTH); newres.methodParamsK5.k5 = Copy(oldres.collar_k5_res, oldres.collar_k5_err_res, INCC.MAX_COLLAR_K5_PARAMETERS); newres.methodParamsK5.k5_checkbox = TransferUtils.Copy(oldres.collar_k5_checkbox_res, INCC.MAX_COLLAR_K5_PARAMETERS); for (int i = 0; i < INCC.MAX_COLLAR_K5_PARAMETERS; i++) { int index = i * INCC.MAX_K5_LABEL_LENGTH; newres.methodParamsK5.k5_label[i] = TransferUtils.str(oldres.collar_k5_label_res + index, INCC.MAX_K5_LABEL_LENGTH); } CollarItemId cid = new CollarItemId(TransferUtils.str(results.item_id, INCC.MAX_ITEM_ID_LENGTH)); cid.length = new Tuple(newres.dcl_length); cid.total_u235 = new Tuple(newres.dcl_total_u235); cid.total_u238 = new Tuple(newres.dcl_total_u238); cid.total_rods = newres.dcl_total_rods; cid.total_poison_rods = newres.dcl_total_poison_rods; cid.poison_percent = new Tuple(newres.dcl_poison_percent); cid.rod_type = newres.methodParamsC.poison_rod_type[0]; cid.modified = true; List<CollarItemId> list = NC.App.DB.CollarItemIds.GetList(); bool glump = list.Exists(i => { return string.Compare(cid.item_id, i.item_id, true) == 0; }); if (glump && overwrite) { list.Remove(cid); list.Add(cid); } else list.Add(cid); } else if (r is results_de_mult_rec) { mlogger.TraceEvent(LogLevels.Verbose, 34061, ("Transferring method results for " + r.GetType().ToString())); results_de_mult_rec oldres = (results_de_mult_rec)r; INCCMethodResults.results_de_mult_rec newres = (INCCMethodResults.results_de_mult_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.DUAL_ENERGY_MULT_SAVE_RESTORE, true); newres.meas_ring_ratio = oldres.de_meas_ring_ratio; newres.energy_corr_factor = oldres.de_energy_corr_factor; newres.interpolated_neutron_energy = oldres.de_interpolated_neutron_energy; newres.methodParams.detector_efficiency = TransferUtils.Copy(oldres.de_detector_efficiency_res, INCC.MAX_DUAL_ENERGY_ROWS); newres.methodParams.inner_outer_ring_ratio = TransferUtils.Copy(oldres.de_inner_outer_ring_ratio_res, INCC.MAX_DUAL_ENERGY_ROWS); newres.methodParams.neutron_energy = TransferUtils.Copy(oldres.de_neutron_energy_res, INCC.MAX_DUAL_ENERGY_ROWS); newres.methodParams.relative_fission = TransferUtils.Copy(oldres.de_relative_fission_res, INCC.MAX_DUAL_ENERGY_ROWS); newres.methodParams.inner_ring_efficiency = oldres.de_inner_ring_efficiency_res; newres.methodParams.outer_ring_efficiency = oldres.de_outer_ring_efficiency_res; } else if (r is results_tm_bkg_rec) { mlogger.TraceEvent(LogLevels.Warning, 34062, ("Transferring method results for " + r.GetType().ToString())); results_tm_bkg_rec oldres = (results_tm_bkg_rec)r; // todo: tm bkg handling design incomplete, these values are attached to bkg measurements when the truncated flag is enabled INCCMethodResults.results_tm_bkg_rec newres = (INCCMethodResults.results_tm_bkg_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.None, true); newres.methodParams.Singles.v = oldres.results_tm_singles_bkg; newres.methodParams.Singles.err = oldres.results_tm_singles_bkg_err; newres.methodParams.Zeros.v = oldres.results_tm_zeros_bkg; newres.methodParams.Zeros.err = oldres.results_tm_zeros_bkg_err; newres.methodParams.Ones.v = oldres.results_tm_ones_bkg; newres.methodParams.Ones.err = oldres.results_tm_ones_bkg_err; newres.methodParams.Twos.v = oldres.results_tm_twos_bkg; newres.methodParams.Twos.err = oldres.results_tm_twos_bkg_err; } else { mlogger.TraceEvent(LogLevels.Warning, 34040, ("todo: Transferring method results for " + r.GetType().ToString())); // todo: complete the list } } } #endregion results transfer // dev note: here is where the detector tree creation and replacement with restore_replace_detector_structs occurs in the original code // todo: based on overwrite flag, replace det-dependent classes, the analysis_methods: (none-map) and each (det,mat) -> calib from results class instances #region Meas&Results AnalysisDefs.holdup_config_rec hc = new AnalysisDefs.holdup_config_rec(); hc.glovebox_id = TransferUtils.str(results.results_glovebox_id, INCC.MAX_GLOVEBOX_ID_LENGTH); hc.num_columns = results.results_num_columns; hc.num_rows = results.results_num_rows; hc.distance = results.results_distance; meas.AcquireState.glovebox_id = hc.glovebox_id; // this is a good place to create the general results_rec INCCResults.results_rec xres = new INCCResults.results_rec(meas); meas.INCCAnalysisResults.TradResultsRec = xres; // oddball entries in need of preservation xres.total_good_count_time = results.total_good_count_time; xres.total_number_runs = results.total_number_runs; xres.primary = imr.primaryMethod; xres.net_drum_weight = results.net_drum_weight; xres.completed = (results.completed != 0 ? true : false); xres.db_version = results.db_version; xres.hc = hc; xres.original_meas_date = INCC.DateFrom(TransferUtils.str(results.original_meas_date, INCC.DATE_TIME_LENGTH)); // NEXT: copy move passive and active meas id's here long mid = meas.Persist(); // save the warning and error messages from the results here, these rode on the results rec in INCC5 NC.App.DB.AddAnalysisMessages(msgs, mid); // Store off Params NC.App.DB.UpdateDetector(det); NC.App.DB.NormParameters.Set(det, meas.Norm); // might have been saved in earlier step already NC.App.DB.BackgroundParameters.Set(det, meas.Background); INCCDB.AcquireSelector acqsel = new INCCDB.AcquireSelector(det, acq.item_type, acq.MeasDateTime); if (overwrite) { NC.App.DB.ReplaceAcquireParams(acqsel, acq); } else NC.App.DB.AddAcquireParams(acqsel, acq); // gotta add it to the global map, then push it to the DB if (meas.Tests != null) // added only if not found on the list NC.App.DB.TestParameters.Set(meas.Tests); NC.App.DB.Isotopics.SetList(); // new style de 'mouser'! //NC.App.DB.CompositeIsotopics.SetList();// next:NYI NC.App.DB.ItemIds.SetList(); // This writes any new items ids to the DB NC.App.DB.CollarItemIds.SetList(); // so does this //Loop over measurement cycles NC.App.DB.AddCycles(meas.Cycles, det.MultiplicityParams, mid); //Store off Params // todo: complete table design and creation/update here, still have issues with collar and curium ratio results // get results based on meas option, (Calib and Verif have method results, others do not), update into DB here IEnumerator iter = meas.INCCAnalysisResults.GetMeasSelectorResultsEnumerator(); while (iter.MoveNext()) // only one result indexer is present when doing an INCC5 transfer { MeasOptionSelector moskey = (MeasOptionSelector)iter.Current; INCCResult ir = meas.INCCAnalysisResults[moskey]; // ir contains the measurement option-specific results: empty for rates and holdup, and also empty for calib and verif, the method-focused analyses, // but values are present for initial, normalization, precision, and should be present for background for the tm bkg results switch (meas.MeasOption) { case AssaySelector.MeasurementOption.background: if (meas.Background.TMBkgParams.ComputeTMBkg) mlogger.TraceEvent(LogLevels.Warning, 82010, "Background truncated multiplicity"); // todo: present the tm bkg results on m.Background break; case AssaySelector.MeasurementOption.initial: case AssaySelector.MeasurementOption.normalization: case AssaySelector.MeasurementOption.precision: { ElementList els = ir.ToDBElementList(); ParamsRelatedBackToMeasurement ar = new ParamsRelatedBackToMeasurement(ir.Table); long resid = ar.Create(mid, els); mlogger.TraceEvent(LogLevels.Verbose, 34103, string.Format("Preserving {0} as {1}", ir.Table, resid)); } break; case AssaySelector.MeasurementOption.verification: case AssaySelector.MeasurementOption.calibration: { INCCMethodResults imrs; bool have = meas.INCCAnalysisResults.TryGetINCCResults(moskey.MultiplicityParams, out imrs); if (have) // should be true for verification and calibration { if (imrs.ContainsKey(meas.INCCAnalysisState.Methods.selector)) { // we've got a distinct detector id and material type on the methods, so that is the indexer here Dictionary<AnalysisMethod, INCCMethodResult> amimr = imrs[meas.INCCAnalysisState.Methods.selector]; // now get an enumerator over the map of method results Dictionary<AnalysisMethod, INCCMethodResult>.Enumerator ai = amimr.GetEnumerator(); while (ai.MoveNext()) { if (ai.Current.Key.IsNone()) continue; INCCMethodResult _imr = ai.Current.Value; // insert this into the DB under the current meas key try { ElementList els = _imr.ToDBElementList(); // also sets table property, gotta do it first ParamsRelatedBackToMeasurement ar = new ParamsRelatedBackToMeasurement(_imr.Table); long resid = ar.Create(mid, els); do { long resmid = ar.CreateMethod(resid, mid, _imr.methodParams.ToDBElementList()); mlogger.TraceEvent(LogLevels.Verbose, 34101, string.Format("Preserving {0} as {1},{2}", _imr.Table, resmid, resid)); } while (_imr.methodParams.Pump > 0); } catch (Exception e) { mlogger.TraceEvent(LogLevels.Warning, 34102, "Results processing error {0} {1}", _imr.ToString(), e.Message); } } } else mlogger.TraceEvent(LogLevels.Error, 34102, "Results missing for {0}", meas.INCCAnalysisState.Methods.selector.ToString()); } } break; case AssaySelector.MeasurementOption.rates: case AssaySelector.MeasurementOption.holdup: case AssaySelector.MeasurementOption.unspecified: default: // nothing new to present with these break; } } #endregion Meas&Results // todo: handle well config setting with bkg here; return true; }
private void OKBtn_Click(object sender, EventArgs e) { if (hvp.modified) { DialogResult = DialogResult.OK; HVCalibrationParameters c = NC.App.DB.HVParameters.Get(det.Id.DetectorName); if (c != null) c.Copy(hvp); // copy changes back to original on user affirmation else { c = hvp; NC.App.DB.HVParameters.GetMap().Add(det, c); } NC.App.DB.HVParameters.Set(det,c); // dev note: LM HV vals on LM Acquire record, but SR uses separate DB table so move HV vals so unify the scheme } else DialogResult = DialogResult.Ignore; acq.data_src = ConstructedSource.Live; if (OpenInExcel.Checked != acq.lm.HVX) { acq.lm.HVX = OpenInExcel.Checked; NC.App.DB.UpdateAcquireParams(acq, det.ListMode); } // The acquire is set to occur, build up the measurement state Integ.BuildMeasurement(acq, det, AssaySelector.MeasurementOption.unspecified); NC.App.Opstate.Measurement.Detector.Id.source = ConstructedSource.Live; if (acq.modified) { INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, DateTime.Now); acq.MeasDateTime = sel.TimeStamp; acq.lm.TimeStamp = sel.TimeStamp; NC.App.DB.AddAcquireParams(sel, acq); // it's a new one, not the existing one modified } UIIntegration.Controller.file = false; // make sure to use the DAQ controller, not the file controller NC.App.AppContext.FileInput = null; // reset the cmd line file input flag Instrument instrument = null; if (NC.App.Opstate.Measurement.Detector.ListMode) { if (NC.App.Opstate.Measurement.Detector.Id.SRType == InstrType.PTR32) { instrument = new Ptr32Instrument(NC.App.Opstate.Measurement.Detector); } else if (NC.App.Opstate.Measurement.Detector.Id.SRType == InstrType.MCA527) { instrument = new MCA527Instrument(NC.App.Opstate.Measurement.Detector); ((Analysis.MCA527ProcessingState)instrument.RDT.State).writingFile = false; // force this } else if (NC.App.Opstate.Measurement.Detector.Id.SRType == InstrType.LMMM) { instrument = new LMInstrument(NC.App.Opstate.Measurement.Detector); } instrument.DAQState = DAQInstrState.Offline; instrument.selected = true; instrument.Init(NC.App.Logger(LMLoggers.AppSection.Data), NC.App.Logger(LMLoggers.AppSection.Analysis)); if (!Instruments.Active.Exists(i => instrument.id.Equals(i.id))) Instruments.Active.Add(instrument); } else { instrument = new SRInstrument(NC.App.Opstate.Measurement.Detector); instrument.selected = true; instrument.Init(null, null); if (!Instruments.Active.Exists(i => instrument.id.Equals(i))) Instruments.All.Add(instrument); // add to global runtime list } UIIntegration.Controller.SetHVCalib(); // tell the controller to do an HV operation using the current measurement state UIIntegration.Controller.Perform(); // start the HV DAQ thread Close(); }
//// BUTTONCLICK HANDLERS /////////////////////////////////////////////// public DialogResult OKButton_Click(object sender, EventArgs e) { DialogResult dr = DialogResult.Cancel; if (ap.modified) { INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, ap.item_type, DateTime.Now); ap.MeasDateTime = sel.TimeStamp; ap.lm.TimeStamp = sel.TimeStamp; NC.App.DB.AddAcquireParams(sel, ap); // it's a new one, not the existing one modified } // The acquire is set to occur if (ap.data_src != ConstructedSource.Reanalysis) // Reanalysis is a bit backwards, the correct measurement is fully constructed before this point { LMAcquire.ResetMeasurement(); } switch (ap.data_src) { case ConstructedSource.Live: // set up the instrument list for the action controller Integ.BuildMeasurement(ap, det, mo); UIIntegration.Controller.file = false; // make sure to use the DAQ controller, not the file controller NC.App.AppContext.FileInput = null; // reset the cmd line file input flag if (det.ListMode) { // patch override lm.Interval with run_count_time from dialog // the acquire dialogs field values, as seen and modified by the user, override the LM-only acquire settings for virtual SR measurements NC.App.Opstate.Measurement.AcquireState.lm.Interval = NC.App.Opstate.Measurement.AcquireState.run_count_time; NC.App.Opstate.Measurement.AcquireState.lm.Cycles = NC.App.Opstate.Measurement.AcquireState.num_runs; // Check NC.App.Opstate.Measurement.AnalysisParams for at least one VSR // If not present, inform and pop up the wizard // If present, inform with new dialog, do not pop up the wizard if (NC.App.Opstate.Measurement.AnalysisParams.HasMatchingVSR(det.MultiplicityParams)) { dr = DialogResult.OK; } else { dr = (new LMAcquire(ap, det, fromINCC5Acq: true)).ShowDialog(); // analyzers are created in here, placed on global measurement if (dr == DialogResult.OK) { NC.App.DB.UpdateAcquireParams(ap); //update it again NC.App.DB.UpdateDetector(det); } } if (dr == DialogResult.OK) { // if ok, the analyzers are set up, so can kick it off now. UIIntegration.Controller.ActivateDetector(det); } } else { SRInstrument sri = new SRInstrument(det); sri.selected = true; sri.Init(NC.App.Loggers.Logger(LMLoggers.AppSection.Data), NC.App.Loggers.Logger(LMLoggers.AppSection.Analysis)); if (!Instruments.All.Contains(sri)) { Instruments.All.Add(sri); // add to global runtime list } dr = DialogResult.OK; } break; case ConstructedSource.DB: NC.App.AppContext.DBDataAssay = true; UIIntegration.Controller.file = true; IDDAcquireDBMeas dbdlg = new IDDAcquireDBMeas(this); if (dbdlg.HasItems()) { dr = dbdlg.ShowDialog(); if (dr == DialogResult.OK) { Integ.BuildMeasurement(ap, det, mo); DateTimeOffset dto = dbdlg.measurementId.MeasDateTime; NC.App.Logger(LMLoggers.AppSection.App).TraceEvent(LogLevels.Info, 87654, "Using " + dto.ToString("MMM dd yyy HH:mm:ss.ff K")); NC.App.Opstate.Measurement.MeasDate = dto; // get the cycles for the selected measurement from the database, and add them to the current measurement CycleList cl = NC.App.DB.GetCycles(det, dbdlg.measurementId, ap.data_src); // APluralityOfMultiplicityAnalyzers: // URGENT: get all the cycles associated with each analzyer, restoring into the correct key->result pair NC.App.Opstate.Measurement.Add(cl); // use the cycle time interval as found in the data, taking the first entry because equal intervals are assumed if (cl.Count > 0) { NC.App.Opstate.Measurement.AcquireState.lm.Interval = NC.App.Opstate.Measurement.AcquireState.run_count_time = cl[0].TS.TotalSeconds; } NC.App.DB.UpdateAcquireParams(ap); //update it again } } else { MessageBox.Show("No items found in database matching these parameters", "WARNING"); } break; case ConstructedSource.Manual: UIIntegration.Controller.file = true; NC.App.AppContext.DBDataAssay = true; IDDManualDataEntry mdlg = new IDDManualDataEntry(); mdlg.AH = this; dr = mdlg.ShowDialog(); // the work constructing the measurement is done in the dialog class break; case ConstructedSource.Reanalysis: UIIntegration.Controller.file = true; NC.App.AppContext.DBDataAssay = true; dr = DialogResult.OK; // the measurement re-creation work is done in the IDDReanalysisAssay dialog class prior to reaching this point break; case ConstructedSource.CycleFile: Integ.BuildMeasurementMinimal(ap, det, mo); // the measurement is reconstructed before each test data file processing, so this is meant as a carrier for certain kick-off values NC.App.AppContext.TestDataFileAssay = true; UIIntegration.Controller.file = true; dr = UIIntegration.GetUsersFile("Select a test data (disk) file", NC.App.AppContext.FileInput, "INCC5 Test data (disk)", "dat", "cnn"); break; case ConstructedSource.ReviewFile: Integ.BuildMeasurementMinimal(ap, det, mo); // acquire type and measurement option are read from each NCC file itself, so this instance is an acquire state kick-off carrier value NC.App.AppContext.ReviewFileAssay = true; UIIntegration.Controller.file = true; dr = UIIntegration.GetUsersFile("Select an NCC file", NC.App.AppContext.FileInput, "INCC5 Review", "NCC"); break; case ConstructedSource.NCDFile: Integ.BuildMeasurement(ap, det, mo); NC.App.AppContext.NCDFileAssay = true; UIIntegration.Controller.file = true; if (det.ListMode || NC.App.Opstate.Measurement.MeasOption.IsListMode()) { dr = (new LMAcquire(ap, det, fromINCC5Acq: true)).ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation } else { dr = UIIntegration.GetUsersFilesFolder("Select NCD files or folder", NC.App.AppContext.FileInput, "LMMM NCD", "ncd"); } break; case ConstructedSource.SortedPulseTextFile: Integ.BuildMeasurement(ap, det, mo); NC.App.AppContext.PulseFileAssay = true; UIIntegration.Controller.file = true; if (det.ListMode || NC.App.Opstate.Measurement.MeasOption.IsListMode()) { dr = (new LMAcquire(ap, det, fromINCC5Acq: true)).ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation } else { dr = UIIntegration.GetUsersFilesFolder("Select pulse files or folder", NC.App.AppContext.FileInput, "pulse", "txt"); } break; case ConstructedSource.PTRFile: Integ.BuildMeasurement(ap, det, mo); NC.App.AppContext.PTRFileAssay = true; UIIntegration.Controller.file = true; if (det.ListMode || NC.App.Opstate.Measurement.MeasOption.IsListMode()) { dr = (new LMAcquire(ap, det, fromINCC5Acq: true)).ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation } else { dr = UIIntegration.GetUsersFilesFolder("Select PTR-32 files or folder", NC.App.AppContext.FileInput, "PTR-32", "bin", "chn"); } break; case ConstructedSource.MCA527File: Integ.BuildMeasurement(ap, det, mo); NC.App.AppContext.MCA527FileAssay = true; UIIntegration.Controller.file = true; if (det.ListMode || NC.App.Opstate.Measurement.MeasOption.IsListMode()) { dr = (new LMAcquire(ap, det, fromINCC5Acq: true)).ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation } else { dr = UIIntegration.GetUsersFilesFolder("Select MCA files or folder", NC.App.AppContext.FileInput, "MCA527", "mca"); } break; default: break; } return(dr); }
void SaveAcquireState() { acq.review.DetectorParameters = DetectorParametersCheckBox.Checked; acq.review.CalibrationParameters = CalibrationParametersCheckBox.Checked; acq.review.Isotopics = IsotopicsCheckBox.Checked; acq.review.RawCycleData = IndividualCycleRawDataCheckBox.Checked; acq.review.RateCycleData = IndividualCycleRateDataCheckBox.Checked; INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det,acq.item_type, acq.MeasDateTime); N.App.DB.ReplaceAcquireParams(sel, acq); }
void SaveAcquireState() { acq.review.DetectorParameters = DetectorParametersCheckBox.Checked; acq.review.RawCycleData = IndividualCycleRawDataCheckBox.Checked; acq.review.RateCycleData = IndividualCycleRateDataCheckBox.Checked; acq.review.SummedRawCoincData = SummedRawCoincidenceDataCheckBox.Checked; acq.review.SummedMultiplicityDistributions = SummedMultiplicityDistributionsCheckBox.Checked; acq.review.MultiplicityDistributions = IndividualCycleMultiplicityDistributionsCheckBox.Checked; INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det,acq.item_type, acq.MeasDateTime); N.App.DB.ReplaceAcquireParams(sel, acq); }
/// <summary> /// On user Ok, preserve any changes to the current Acquire state as well as the current detector /// </summary> private void OKBtn_Click(object sender, EventArgs e) { if (acq.modified) { INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, DateTime.Now); acq.review.DetectorParameters = DetectorParametersCheckBox.Checked; acq.review.CalibrationParameters = CalibrationParametersCheckBox.Checked; acq.review.Isotopics = IsotopicsCheckBox.Checked; acq.review.RawCycleData = IndividualCycleRawDataCheckBox.Checked; acq.review.RateCycleData = IndividualCycleRateData.Checked; acq.review.SummedRawCoincData = SummedRawCoincidenceDataCheckBox.Checked; acq.review.SummedMultiplicityDistributions = SummedMultiplicityDistributionsCheckBox.Checked; acq.review.MultiplicityDistributions = IndividualMultiplicityDistributionsCheckBox.Checked; acq.user_id = InspectorNameTextBox.Text; acq.campaign_id = InspectionNumberTextBox.Text; acq.MeasDateTime = sel.TimeStamp; // The Setter handles the LM params field copy too // facility and mba already set by selector handlers NC.App.DB.AddAcquireParams(sel, acq); // it's a new one, not the existing one modified } if (det.Id.modified) NC.App.DB.UpdateDetector(det); this.Close(); }
private void OKBtn_Click(object sender, EventArgs e) { if (hvp.modified) { DialogResult = DialogResult.OK; HVCalibrationParameters c = NC.App.DB.HVParameters.Get(det.Id.DetectorName); if (c != null) { c.Copy(hvp); // copy changes back to original on user affirmation } else { c = hvp; NC.App.DB.HVParameters.GetMap().Add(det, c); } NC.App.DB.HVParameters.Set(det, c); // dev note: LM HV vals on LM Acquire record, but SR uses separate DB table so move HV vals so unify the scheme } else { DialogResult = DialogResult.Ignore; } acq.data_src = ConstructedSource.Live; if (OpenInExcel.Checked != acq.lm.HVX) { acq.lm.HVX = OpenInExcel.Checked; NC.App.DB.UpdateAcquireParams(acq, det.ListMode); } // The acquire is set to occur, build up the measurement state Integ.BuildMeasurement(acq, det, AssaySelector.MeasurementOption.unspecified); NC.App.Opstate.Measurement.Detector.Id.source = ConstructedSource.Live; if (acq.modified) { INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, DateTime.Now); acq.MeasDateTime = sel.TimeStamp; acq.lm.TimeStamp = sel.TimeStamp; NC.App.DB.AddAcquireParams(sel, acq); // it's a new one, not the existing one modified } UIIntegration.Controller.file = false; // make sure to use the DAQ controller, not the file controller NC.App.AppContext.FileInput = null; // reset the cmd line file input flag Instrument instrument = null; if (NC.App.Opstate.Measurement.Detector.ListMode) { if (NC.App.Opstate.Measurement.Detector.Id.SRType == InstrType.PTR32) { instrument = new Ptr32Instrument(NC.App.Opstate.Measurement.Detector); } else if (NC.App.Opstate.Measurement.Detector.Id.SRType == InstrType.MCA527) { instrument = new MCA527Instrument(NC.App.Opstate.Measurement.Detector); ((Analysis.MCA527ProcessingState)instrument.RDT.State).writingFile = false; // force this } else if (NC.App.Opstate.Measurement.Detector.Id.SRType == InstrType.LMMM) { instrument = new LMInstrument(NC.App.Opstate.Measurement.Detector); } instrument.DAQState = DAQInstrState.Offline; instrument.selected = true; instrument.Init(NC.App.Logger(LMLoggers.AppSection.Data), NC.App.Logger(LMLoggers.AppSection.Analysis)); if (!Instruments.Active.Exists(i => instrument.id.Equals(i.id))) { Instruments.Active.Add(instrument); } } else { instrument = new SRInstrument(NC.App.Opstate.Measurement.Detector); instrument.selected = true; instrument.Init(null, null); if (!Instruments.Active.Exists(i => instrument.id.Equals(i))) { Instruments.All.Add(instrument); // add to global runtime list } } UIIntegration.Controller.SetHVCalib(); // tell the controller to do an HV operation using the current measurement state UIIntegration.Controller.Perform(); // start the HV DAQ thread Close(); }
AcquireParameters ConfigureAcquireState(Detector det, AcquireParameters def, INCCReviewFile irf) { AcquireParameters acq = NC.App.DB.LastAcquireFor(det); if (acq == null) acq = new AcquireParameters(def); acq.MeasDateTime = irf.dt; acq.lm.TimeStamp = irf.dt; acq.num_runs = irf.num_runs; // RequestedRepetitions int tx = def.comment.IndexOf(" (Original file name"); if (tx >= 0) acq.comment = def.comment.Substring(0, tx); else acq.comment = def.comment; acq.comment += " (Original file name " + System.IO.Path.GetFileName(irf.Path) + ")"; acq.detector_id = String.Copy(det.Id.DetectorId); acq.meas_detector_id = string.Copy(acq.detector_id); // iid should have been added from the NOP processing above ItemId iid = NC.App.DB.ItemIds.Get(irf.item); if (iid == null) { ctrllog.TraceEvent(LogLevels.Warning, 5439, "Item id '" + irf.item + "' is referenced by the Review file measurement data, but is not found in op. rev. files or the database"); } else { acq.ApplyItemId(iid); INCCDB.Descriptor s = NC.App.DB.Stratums.Get(iid.stratum); INCCDB.Descriptor m = NC.App.DB.MBAs.Get(iid.mba); if (s != null) acq.stratum_id = s; if (m != null) acq.mba = m; } // todo: also need to account for iid UMass to mass condition INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, irf.dt); if (NC.App.DB.AcquireParametersMap().ContainsKey(sel)) // only one allowed, same for actual measurement { NC.App.DB.AcquireParametersMap().Remove(sel); } NC.App.DB.AcquireParametersMap().Add(sel, acq); NC.App.DB.UpdateAcquireParams(acq, det.ListMode); return acq; }
//// BUTTONCLICK HANDLERS /////////////////////////////////////////////// public DialogResult OKButton_Click(object sender, EventArgs e) { DialogResult dr = DialogResult.Cancel; if (ap.modified) { INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, ap.item_type, DateTime.Now); ap.MeasDateTime = sel.TimeStamp; ap.lm.TimeStamp = sel.TimeStamp; NC.App.DB.AcquireParametersMap().Add(sel, ap); // it's a new one, not the existing one modified NC.App.DB.UpdateAcquireParams(ap, det.ListMode); } // The acquire is set to occur, build up the measurement state AnalysisWizard.ResetMeasurement(); Integ.BuildMeasurement(ap, det, mo); switch (ap.data_src) { case ConstructedSource.Live: // set up the instrument list for the action controller UIIntegration.Controller.file = false; // make sure to use the DAQ controller, not the file controller NC.App.AppContext.FileInput = null; // reset the cmd line file input flag if (det.ListMode) { // patch override lm.Interval with run_count_time from dialog NC.App.Opstate.Measurement.AcquireState.lm.Interval = NC.App.Opstate.Measurement.AcquireState.run_count_time; // Check NC.App.Opstate.Measurement.AnalysisParams for at least one VSR // If not present, inform and pop up the wizard // If present, inform with new dialog, do not pop up the wizard if (NC.App.Opstate.Measurement.AnalysisParams.HasMultiplicity()) { dr = DialogResult.OK; } else { AnalysisWizard awl = new AnalysisWizard(AnalysisWizard.AWSteps.Step2B, ap, det); // analyzers are created in here, placed on global measurement dr = awl.ShowDialog(); if (dr == DialogResult.OK) { NC.App.DB.UpdateAcquireParams(ap); //update it again NC.App.DB.UpdateDetector(det); } } if (dr == DialogResult.OK) { // if ok, the analyzers are set up, so can kick it off now. UIIntegration.Controller.ActivateDetector(det); } } else { SRInstrument sri = new SRInstrument(det); sri.selected = true; sri.Init(NC.App.Loggers.Logger(LMLoggers.AppSection.Data), NC.App.Loggers.Logger(LMLoggers.AppSection.Analysis)); if (!Instruments.All.Contains(sri)) { Instruments.All.Add(sri); // add to global runtime list } dr = DialogResult.OK; } break; case ConstructedSource.DB: NC.App.AppContext.DBDataAssay = true; UIIntegration.Controller.file = true; IDDAcquireDBMeas dbdlg = new IDDAcquireDBMeas(this); if (dbdlg.HasItems()) { dr = dbdlg.ShowDialog(); if (dr == DialogResult.OK) { DateTimeOffset dto = dbdlg.measurementId.MeasDateTime; DateTimeOffset cur = new DateTimeOffset(dto.Ticks, dto.Offset); NC.App.Logger(NCCReporter.LMLoggers.AppSection.App).TraceEvent(NCCReporter.LogLevels.Info, 87654, "Using " + dto.ToString("MMM dd yyy HH:mm:ss.ff K")); // get the cycles for the selected measurement from the database, and add them to the current measurement CycleList cl = NC.App.DB.GetCycles(det, dbdlg.measurementId); foreach (Cycle cycle in cl) // add the necessary meta-data to the cycle identifier instance { cycle.UpdateDataSourceId(ap.data_src, det.Id.SRType, cur.AddTicks(cycle.TS.Ticks), det.Id.FileName); cur = cycle.DataSourceId.dt; } NC.App.Opstate.Measurement.Add(cl); // TODO: for Reanalysis, a full reconstruction of the measurement state based on the ResultsRec state and the method parameter map contents (for Calib and Verif) } } else { MessageBox.Show("No items found in database matching these parameters", "WARNING"); } break; case ConstructedSource.Manual: UIIntegration.Controller.file = true; NC.App.AppContext.DBDataAssay = true; IDDManualDataEntry mdlg = new IDDManualDataEntry(); mdlg.AH = this; dr = mdlg.ShowDialog(); if (dr == DialogResult.OK) { // the work is done in the dialog class } break; case ConstructedSource.CycleFile: NC.App.AppContext.TestDataFileAssay = true; UIIntegration.Controller.file = true; dr = UIIntegration.GetUsersFile("Select a test data (disk) file", NC.App.AppContext.FileInput, "INCC5 Test data (disk)", "dat"); break; case ConstructedSource.ReviewFile: NC.App.AppContext.ReviewFileAssay = true; UIIntegration.Controller.file = true; dr = UIIntegration.GetUsersFile("Select an NCC file", NC.App.AppContext.FileInput, "INCC5 Review", "NCC"); break; case ConstructedSource.NCDFile: NC.App.AppContext.NCDFileAssay = true; UIIntegration.Controller.file = true; if (NC.App.Opstate.Measurement.MeasOption == AssaySelector.MeasurementOption.unspecified) { AnalysisWizard aw = new AnalysisWizard(AnalysisWizard.AWSteps.Step2A, ap, det); dr = aw.ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation } else { dr = UIIntegration.GetUsersFilesFolder("Select NCD files or folder", NC.App.AppContext.FileInput, "LMMM NCD", "ncd"); } break; case ConstructedSource.SortedPulseTextFile: NC.App.AppContext.PulseFileAssay = true; UIIntegration.Controller.file = true; if (NC.App.Opstate.Measurement.MeasOption == AssaySelector.MeasurementOption.unspecified) { AnalysisWizard aw1 = new AnalysisWizard(AnalysisWizard.AWSteps.Step2A, ap, det); dr = aw1.ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation } else { dr = UIIntegration.GetUsersFilesFolder("Select pulse files or folder", NC.App.AppContext.FileInput, "pulse", "txt"); } break; case ConstructedSource.PTRFile: NC.App.AppContext.PTRFileAssay = true; UIIntegration.Controller.file = true; if (NC.App.Opstate.Measurement.MeasOption == AssaySelector.MeasurementOption.unspecified) { AnalysisWizard aw2 = new AnalysisWizard(AnalysisWizard.AWSteps.Step2A, ap, det); dr = aw2.ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation } else { dr = UIIntegration.GetUsersFilesFolder("Select PTR-32 files or folder", NC.App.AppContext.FileInput, "PTR-32", "bin", "chn"); } break; case ConstructedSource.NILAFile: NC.App.AppContext.NILAFileAssay = true; UIIntegration.Controller.file = true; dr = UIIntegration.GetUsersFilesFolder("Select NILA files or folder", NC.App.AppContext.FileInput, "MTS NILA", "dat"); //dr = DialogResult.Cancel; break; default: break; } return(dr); }
private void OKBtn_Click(object sender, EventArgs e) { if (hvp.modified) { DialogResult = System.Windows.Forms.DialogResult.OK; HVCalibrationParameters c = NC.App.DB.HVParameters.Get(det.Id.DetectorName); if (c != null) c.Copy(hvp); // copy changes back to original on user affirmation else { c = hvp; NC.App.DB.HVParameters.GetMap().Add(det, c); } NC.App.DB.HVParameters.Set(det,c); // dev note: LM HV vals on LM Acquire record, but SR uses separate DB table so move HV vals so unify the scheme } else DialogResult = System.Windows.Forms.DialogResult.Ignore; // The acquire is set to occur, build up the measurement state Integ.BuildMeasurement(acq, det, AssaySelector.MeasurementOption.unspecified); if (acq.modified) { INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, DateTime.Now); acq.MeasDateTime = sel.TimeStamp; acq.lm.TimeStamp = sel.TimeStamp; NC.App.DB.AcquireParametersMap().Add(sel, acq); // it's a new one, not the existing one modified NC.App.DB.UpdateAcquireParams(acq, det.ListMode); } UIIntegration.Controller.file = false; // make sure to use the DAQ controller, not the file controller NC.App.AppContext.FileInput = null; // reset the cmd line file input flag if (NC.App.Opstate.Measurement.Detectors[0].ListMode) { if (NC.App.Opstate.Measurement.Detectors[0].Id.SRType == InstrType.PTR32) { Ptr32Instrument instrument = new Ptr32Instrument(NC.App.Opstate.Measurement.Detectors[0]); instrument.DAQState = DAQInstrState.Offline; instrument.selected = true; instrument.Init(NC.App.Logger(LMLoggers.AppSection.Data), NC.App.Logger(LMLoggers.AppSection.Analysis)); if (!Instruments.Active.Contains(instrument)) { Instruments.Active.Add(instrument); } } else { // if ok, the analyzers are set up, so can kick it off now. LMInstrument lm = new LMInstrument(NC.App.Opstate.Measurement.Detectors[0]); lm.DAQState = DAQInstrState.Offline; // these are manually initiated as opposed to auto-pickup lm.selected = false; //must broadcast first to get it selected if (!Instruments.All.Contains(lm)) Instruments.All.Add(lm); // add to global runtime list } } else { SRInstrument sri = new SRInstrument(NC.App.Opstate.Measurement.Detectors[0]); sri.selected = true; sri.Init(null, null); if (!Instruments.All.Contains(sri)) Instruments.All.Add(sri); // add to global runtime list } UIIntegration.Controller.SetHVCalib(); // tell the controller to do an HV operation using the current measurement state UIIntegration.Controller.Perform(); // start the HV DAQ thread this.Close(); }
private void Step4SaveAndExit_Click(object sender, EventArgs e) { PreserveNewState(); if (ap.modified || ap.lm.modified) { INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, ap.item_type, DateTime.Now); ap.MeasDateTime = sel.TimeStamp; ap.lm.TimeStamp = sel.TimeStamp; NC.App.DB.AcquireParametersMap().Add(sel, ap); // it's a new one, not the existing one modified NC.App.DB.UpdateAcquireParams(ap, det.ListMode); } this.Close(); }
bool SetNewAcquireState(Detector det0, string mtl, string fac, string mba, string msg) { AcquireParameters acq = NC.App.DB.LastAcquire(); Detector det = NC.App.DB.Detectors.GetItByDetectorId(det0.Id.DetectorName); if (det == null) { det = det0; NC.App.Loggers.ControlLogger.TraceEvent(LogLevels.Warning, 32441, "Creating new detector " + det.Id.DetectorName + " now"); // add fresh param instances to in-memory maps NC.App.DB.NormParameters.Map.Add(det, new NormParameters()); NC.App.DB.UnattendedParameters.Map.Add(det, new UnattendedParameters()); NC.App.DB.BackgroundParameters.Map.Add(det, new BackgroundParameters()); NC.App.DB.AASSParameters.Map.Add(det, new AddASourceSetup()); NC.App.DB.HVParameters.Map.Add(det, new HVCalibrationParameters()); NC.App.DB.Detectors.Add(det); // add detector to in-memory list IntegrationHelpers.PersistDetectorAndAssociations(det); } else { // Apply any changes to GL, PD, HV (but not FA) to existing detector if (SRParamUpdateNeeded(det.MultiplicityParams, det0.MultiplicityParams)) { NC.App.Loggers.ControlLogger.TraceEvent(LogLevels.Warning, 32441, $"Modifying detector {det.Id.DetectorName} SR params"); det.SRParams.highVoltage = det0.SRParams.highVoltage; det.SRParams.predelayMS = det0.SRParams.predelayMS; det.SRParams.gateLengthMS = det0.SRParams.gateLengthMS; NC.App.DB.UpdateDetectorParams(det); } } INCCDB.Descriptor facdesc = null, mbadesc = null, mtldesc = null; if (!string.IsNullOrEmpty(fac)) { facdesc = NC.App.DB.Facilities.Get(fac); if (facdesc == null) { NC.App.Loggers.ControlLogger.TraceEvent(LogLevels.Warning, 32441, "Creating " + fac + " facility"); facdesc = new INCCDB.Descriptor(fac, "Dataz creation source"); NC.App.DB.Facilities.Update(facdesc); } } if (!string.IsNullOrEmpty(mba)) { mbadesc = NC.App.DB.MBAs.Get(mba); if (mbadesc == null) { NC.App.Loggers.ControlLogger.TraceEvent(LogLevels.Warning, 32441, "Creating " + mba + " MBA"); mbadesc = new INCCDB.Descriptor(mba, "Dataz creation source"); NC.App.DB.MBAs.Update(mbadesc); } } if (!string.IsNullOrEmpty(mtl)) { mtldesc = NC.App.DB.Materials.Get(mtl); if (mtldesc == null) { NC.App.Loggers.ControlLogger.TraceEvent(LogLevels.Warning, 32441, "Creating " + mtl + " material type"); mtldesc = new INCCDB.Descriptor(mtl, "Dataz creation source"); NC.App.DB.Materials.Update(mtldesc); } } acq.MeasDateTime = DateTimeOffset.Now; DataZDetector = NC.App.DB.Detectors.Find(d => string.Compare(d.Id.DetectorName, det0.Id.DetectorName, true) == 0); DataZDetector.Id.source = ConstructedSource.DatazFile; acq.data_src = ConstructedSource.DatazFile; if (!string.IsNullOrEmpty(msg)) { acq.ending_comment = true; acq.ending_comment_str = msg; } if (AcquistionChangeNeeded(acq, det.Id.DetectorName, mtl, fac, mba)) { acq.detector_id = string.Copy(det.Id.DetectorName); acq.meas_detector_id = string.Copy(det.Id.DetectorName); if (!string.IsNullOrEmpty(mtl)) { acq.item_type = string.Copy(mtl); } if (facdesc != null) { acq.facility = facdesc; } if (mbadesc != null) { acq.mba = mbadesc; } INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, acq.MeasDateTime); NC.App.DB.AddAcquireParams(sel, acq); } else // update existing entry { NC.App.DB.UpdateAcquireParams(acq, det.ListMode); } AcquistionStateChanged = true; NC.App.Loggers.ControlLogger.TraceEvent(LogLevels.Info, 32444, $"The current detector/material now {acq.detector_id},{acq.item_type}"); return(true); }
/////////////////// // MOUSER MENU // /////////////////// private void AnalysisWizardClick(object sender, RoutedEventArgs e) { AcquireParameters acq = null; Detector det = null; Integ.GetCurrentAcquireDetectorPair(ref acq, ref det); if (!det.ListMode) { MessageBox.Show("'" + det.ToString() + "' is not a List Mode detector,\r\ncreate or select a List Mode detector\r\n with Setup > Facility/Inspection...", "List Mode Acquire"); return; } NewUI.AnalysisWizard f = new NewUI.AnalysisWizard(NewUI.AnalysisWizard.AWSteps.Step1, acq, det); System.Windows.Forms.DialogResult dr = f.ShowDialog(); if (dr == System.Windows.Forms.DialogResult.OK) { if (acq.modified || acq.lm.modified) { INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, DateTime.Now); acq.MeasDateTime = sel.TimeStamp; acq.lm.TimeStamp = sel.TimeStamp; NC.App.DB.AcquireParametersMap().Add(sel, acq); // it's a new one, not the existing one modified NC.App.DB.UpdateAcquireParams(acq, det.ListMode); } switch (NC.App.Opstate.Measurement.AcquireState.data_src) // global access to latest acq here, same as acq set in wizard { case ConstructedSource.Live: UIIntegration.Controller.file = false; // make sure to use the DAQ controller, not the file controller NC.App.AppContext.FileInput = null; // reset the cmd line file input flag if (NC.App.Opstate.Measurement.Detectors[0].ListMode) { // NC.App.DB.UpdateAcquireParams(ap, det.ListMode); //update it again // NC.App.DB.UpdateDetector(det); // if ok, the analyzers are set up, so can kick it off now. if (NC.App.Opstate.Measurement.Detectors[0].Id.SRType == InstrType.PTR32) { Ptr32Instrument instrument = new Ptr32Instrument(NC.App.Opstate.Measurement.Detectors[0]); instrument.DAQState = DAQInstrState.Offline; instrument.selected = true; instrument.Init(NC.App.Logger(LMLoggers.AppSection.Data), NC.App.Logger(LMLoggers.AppSection.Analysis)); if (!Instruments.Active.Contains(instrument)) { Instruments.Active.Add(instrument); } } else { LMInstrument lm = new LMInstrument(NC.App.Opstate.Measurement.Detectors[0]); lm.DAQState = DAQInstrState.Offline; // these are manually initiated as opposed to auto-pickup lm.selected = false; //must broadcast first to get it selected if (!Instruments.All.Contains(lm)) { Instruments.All.Add(lm); // add to global runtime list } } } else { SRInstrument sri = new SRInstrument(NC.App.Opstate.Measurement.Detectors[0]); sri.selected = true; sri.Init(NC.App.Loggers.Logger(LMLoggers.AppSection.Data), NC.App.Loggers.Logger(LMLoggers.AppSection.Analysis)); if (!Instruments.All.Contains(sri)) { Instruments.All.Add(sri); // add to global runtime list } } break; case ConstructedSource.DB: UIIntegration.Controller.file = true; return; //break; case ConstructedSource.Manual: UIIntegration.Controller.file = true; return; //break; case ConstructedSource.CycleFile: case ConstructedSource.ReviewFile: UIIntegration.Controller.file = true; string xs = UIIntegration.GetUsersFolder("Select Input Folder", NC.App.AppContext.FileInput); if (!String.IsNullOrEmpty(xs)) { NC.App.AppContext.FileInput = xs; NC.App.AppContext.FileInputList = null; // no explicit file list } SRInstrument sri2 = new SRInstrument(NC.App.Opstate.Measurement.Detectors[0]); sri2.selected = true; sri2.Init(NC.App.Loggers.Logger(LMLoggers.AppSection.Data), NC.App.Loggers.Logger(LMLoggers.AppSection.Analysis)); if (!Instruments.All.Contains(sri2)) { Instruments.All.Add(sri2); // add to global runtime list } break; case ConstructedSource.NCDFile: NC.App.AppContext.NCDFileAssay = true; // suntoucher, this is right here how we're flowing now UIIntegration.Controller.file = true; break; case ConstructedSource.SortedPulseTextFile: NC.App.AppContext.PulseFileAssay = true; UIIntegration.Controller.file = true; break; case ConstructedSource.PTRFile: NC.App.AppContext.PTRFileAssay = true; UIIntegration.Controller.file = true; break; default: break; } NC.App.Opstate.Measurement.Detectors[0].Id.source = NC.App.Opstate.Measurement.AcquireState.data_src; // set the detector overall data source value here UIIntegration.Controller.SetAssay(); // tell the controller to do an assay operation using the current measurement state UIIntegration.Controller.Perform(); // start the measurement file or DAQ thread } }
AcquireParameters ConfigureAcquireState(Detector det, AcquireParameters def, DateTimeOffset dto, ushort runs, string path) { AcquireParameters acq = NC.App.DB.LastAcquireFor(det); if (acq == null) acq = new AcquireParameters(def); acq.MeasDateTime = dto; acq.lm.TimeStamp = dto; acq.detector_id = String.Copy(det.Id.DetectorId); acq.meas_detector_id = string.Copy(acq.detector_id); acq.num_runs = runs; int tx = def.comment.IndexOf(" (Original file name"); if (tx >= 0) acq.comment = def.comment.Substring(0, tx); else acq.comment = def.comment; acq.comment += " (Original file name " + System.IO.Path.GetFileName(path) + ")"; INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, dto); if (NC.App.DB.AcquireParametersMap().ContainsKey(sel)) // only one allowed, same for actual measurement { NC.App.DB.AcquireParametersMap().Remove(sel); } NC.App.DB.AcquireParametersMap().Add(sel, acq); NC.App.DB.UpdateAcquireParams(acq, det.ListMode); return acq; }
/////////////////// // MOUSER MENU // /////////////////// private void AnalysisWizardClick(object sender, RoutedEventArgs e) { AcquireParameters acq = null; Detector det = null; Integ.GetCurrentAcquireDetectorPair(ref acq, ref det); if (!det.ListMode) { MessageBox.Show("'" + det.ToString() + "' is not a List Mode detector,\r\ncreate or select a List Mode detector\r\n with Setup > Facility/Inspection...", "List Mode Acquire"); return; } NewUI.AnalysisWizard f = new NewUI.AnalysisWizard(NewUI.AnalysisWizard.AWSteps.Step1, acq, det); System.Windows.Forms.DialogResult dr = f.ShowDialog(); if (dr == System.Windows.Forms.DialogResult.OK) { if (acq.modified || acq.lm.modified) { INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, DateTime.Now); acq.MeasDateTime = sel.TimeStamp; acq.lm.TimeStamp = sel.TimeStamp; NC.App.DB.AcquireParametersMap().Add(sel, acq); // it's a new one, not the existing one modified NC.App.DB.UpdateAcquireParams(acq, det.ListMode); } switch (NC.App.Opstate.Measurement.AcquireState.data_src) // global access to latest acq here, same as acq set in wizard { case ConstructedSource.Live: UIIntegration.Controller.file = false; // make sure to use the DAQ controller, not the file controller NC.App.AppContext.FileInput = null; // reset the cmd line file input flag if (NC.App.Opstate.Measurement.Detectors[0].ListMode) { // NC.App.DB.UpdateAcquireParams(ap, det.ListMode); //update it again // NC.App.DB.UpdateDetector(det); // if ok, the analyzers are set up, so can kick it off now. if (NC.App.Opstate.Measurement.Detectors[0].Id.SRType == InstrType.PTR32) { Ptr32Instrument instrument = new Ptr32Instrument(NC.App.Opstate.Measurement.Detectors[0]); instrument.DAQState = DAQInstrState.Offline; instrument.selected = true; instrument.Init(NC.App.Logger(LMLoggers.AppSection.Data), NC.App.Logger(LMLoggers.AppSection.Analysis)); if (!Instruments.Active.Contains(instrument)) { Instruments.Active.Add(instrument); } } else { LMInstrument lm = new LMInstrument(NC.App.Opstate.Measurement.Detectors[0]); lm.DAQState = DAQInstrState.Offline; // these are manually initiated as opposed to auto-pickup lm.selected = false; //must broadcast first to get it selected if (!Instruments.All.Contains(lm)) Instruments.All.Add(lm); // add to global runtime list } } else { SRInstrument sri = new SRInstrument(NC.App.Opstate.Measurement.Detectors[0]); sri.selected = true; sri.Init(NC.App.Loggers.Logger(LMLoggers.AppSection.Data), NC.App.Loggers.Logger(LMLoggers.AppSection.Analysis)); if (!Instruments.All.Contains(sri)) Instruments.All.Add(sri); // add to global runtime list } break; case ConstructedSource.DB: UIIntegration.Controller.file = true; return; //break; case ConstructedSource.Manual: UIIntegration.Controller.file = true; return; //break; case ConstructedSource.CycleFile: case ConstructedSource.ReviewFile: UIIntegration.Controller.file = true; string xs = UIIntegration.GetUsersFolder("Select Input Folder", NC.App.AppContext.FileInput); if (!String.IsNullOrEmpty(xs)) { NC.App.AppContext.FileInput = xs; NC.App.AppContext.FileInputList = null; // no explicit file list } SRInstrument sri2 = new SRInstrument(NC.App.Opstate.Measurement.Detectors[0]); sri2.selected = true; sri2.Init(NC.App.Loggers.Logger(LMLoggers.AppSection.Data), NC.App.Loggers.Logger(LMLoggers.AppSection.Analysis)); if (!Instruments.All.Contains(sri2)) Instruments.All.Add(sri2); // add to global runtime list break; case ConstructedSource.NCDFile: NC.App.AppContext.NCDFileAssay = true; // suntoucher, this is right here how we're flowing now UIIntegration.Controller.file = true; break; case ConstructedSource.SortedPulseTextFile: NC.App.AppContext.PulseFileAssay = true; UIIntegration.Controller.file = true; break; case ConstructedSource.PTRFile: NC.App.AppContext.PTRFileAssay = true; UIIntegration.Controller.file = true; break; default: break; } NC.App.Opstate.Measurement.Detectors[0].Id.source = NC.App.Opstate.Measurement.AcquireState.data_src; // set the detector overall data source value here UIIntegration.Controller.SetAssay(); // tell the controller to do an assay operation using the current measurement state UIIntegration.Controller.Perform(); // start the measurement file or DAQ thread } }
public static bool SetNewCurrentDetector(string name, bool checkForExistence) { AcquireParameters acq = GetCurrentAcquireParams(); bool exists = true; Detector det = CentralizedState.App.DB.Detectors.Find(d => string.Compare(d.Id.DetectorName, name, true) == 0); if (det == null) { exists = false; CentralizedState.App.Logger(LMLoggers.AppSection.Control).TraceEvent(LogLevels.Warning, 32441, "Detector " + name + " undefined"); if (checkForExistence) return false; else det = new Detector(); } acq.MeasDateTime = DateTime.Now; if (!acq.detector_id.Equals(name, StringComparison.OrdinalIgnoreCase) || !acq.meas_detector_id.Equals(name, StringComparison.OrdinalIgnoreCase)) { // change detector on current acquire parms state if (!exists) CentralizedState.App.Logger(LMLoggers.AppSection.Control).TraceEvent(LogLevels.Warning, 32442, "Temporary detector definition for missing detector " + name + " created"); acq.detector_id = string.Copy(name); acq.meas_detector_id = string.Copy(name); INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, acq.MeasDateTime); CentralizedState.App.DB.AddAcquireParams(sel, acq); if (!exists) CentralizedState.App.DB.Detectors.Add(det); } else // update existing entry CentralizedState.App.DB.UpdateAcquireParams(acq, det.ListMode); CentralizedState.App.Logger(LMLoggers.AppSection.Control).TraceEvent(LogLevels.Info, 32444, "The current detector is now " + name); return true; }
void SaveAcqStateChanges() { if (!FromINCC5Acquire && ap.qc_tests) { ap.qc_tests = false; ap.modified = true; } if (ap.modified || ap.lm.modified) { Measurement meas = N.App.Opstate.Measurement; INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, ap.item_type, DateTime.Now); ap.MeasDateTime = sel.TimeStamp; ap.lm.TimeStamp = sel.TimeStamp; N.App.DB.AddAcquireParams(sel, ap); // update acquire and lmacquire tables with this new one if (LMParamUpdate) { meas.AcquireState.lm.Results = ap.lm.Results; meas.AcquireState.lm.IncludeConfig = ap.lm.IncludeConfig; meas.AcquireState.lm.SaveOnTerminate = ap.lm.SaveOnTerminate; meas.AcquireState.lm.Cycles = ap.lm.Cycles; meas.AcquireState.lm.Interval = ap.lm.Interval; LMParamUpdate = false; } N.App.Opstate.Measurement.AcquireState.data_src = ap.data_src; // copy any new changes to the current measurement AcqParamUpdate = false; } }
//// BUTTONCLICK HANDLERS /////////////////////////////////////////////// public DialogResult OKButton_Click(object sender, EventArgs e) { DialogResult dr = DialogResult.Cancel; if (ap.modified) { INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, ap.item_type, DateTime.Now); ap.MeasDateTime = sel.TimeStamp; ap.lm.TimeStamp = sel.TimeStamp; NC.App.DB.AcquireParametersMap().Add(sel, ap); // it's a new one, not the existing one modified NC.App.DB.UpdateAcquireParams(ap, det.ListMode); } // The acquire is set to occur, build up the measurement state AnalysisWizard.ResetMeasurement(); Integ.BuildMeasurement(ap, det, mo); switch (ap.data_src) { case ConstructedSource.Live: // set up the instrument list for the action controller UIIntegration.Controller.file = false; // make sure to use the DAQ controller, not the file controller NC.App.AppContext.FileInput = null; // reset the cmd line file input flag if (det.ListMode) { // patch override lm.Interval with run_count_time from dialog NC.App.Opstate.Measurement.AcquireState.lm.Interval = NC.App.Opstate.Measurement.AcquireState.run_count_time; // Check NC.App.Opstate.Measurement.AnalysisParams for at least one VSR // If not present, inform and pop up the wizard // If present, inform with new dialog, do not pop up the wizard if (NC.App.Opstate.Measurement.AnalysisParams.HasMultiplicity()) { dr = DialogResult.OK; } else { AnalysisWizard awl = new AnalysisWizard(AnalysisWizard.AWSteps.Step2B, ap, det); // analyzers are created in here, placed on global measurement dr = awl.ShowDialog(); if (dr == DialogResult.OK) { NC.App.DB.UpdateAcquireParams(ap); //update it again NC.App.DB.UpdateDetector(det); } } if (dr == DialogResult.OK) { // if ok, the analyzers are set up, so can kick it off now. UIIntegration.Controller.ActivateDetector(det); } } else { SRInstrument sri = new SRInstrument(det); sri.selected = true; sri.Init(NC.App.Loggers.Logger(LMLoggers.AppSection.Data), NC.App.Loggers.Logger(LMLoggers.AppSection.Analysis)); if (!Instruments.All.Contains(sri)) Instruments.All.Add(sri); // add to global runtime list dr = DialogResult.OK; } break; case ConstructedSource.DB: NC.App.AppContext.DBDataAssay = true; UIIntegration.Controller.file = true; IDDAcquireDBMeas dbdlg = new IDDAcquireDBMeas(this); if (dbdlg.HasItems()) { dr = dbdlg.ShowDialog(); if (dr == DialogResult.OK) { DateTimeOffset dto = dbdlg.measurementId.MeasDateTime; DateTimeOffset cur = new DateTimeOffset(dto.Ticks, dto.Offset); NC.App.Logger(NCCReporter.LMLoggers.AppSection.App).TraceEvent(NCCReporter.LogLevels.Info, 87654, "Using " + dto.ToString("MMM dd yyy HH:mm:ss.ff K")); // get the cycles for the selected measurement from the database, and add them to the current measurement CycleList cl = NC.App.DB.GetCycles(det, dbdlg.measurementId); foreach(Cycle cycle in cl) // add the necessary meta-data to the cycle identifier instance { cycle.UpdateDataSourceId(ap.data_src, det.Id.SRType, cur.AddTicks(cycle.TS.Ticks), det.Id.FileName); cur = cycle.DataSourceId.dt; } NC.App.Opstate.Measurement.Add(cl); // TODO: for Reanalysis, a full reconstruction of the measurement state based on the ResultsRec state and the method parameter map contents (for Calib and Verif) } } else MessageBox.Show("No items found in database matching these parameters", "WARNING"); break; case ConstructedSource.Manual: UIIntegration.Controller.file = true; NC.App.AppContext.DBDataAssay = true; IDDManualDataEntry mdlg = new IDDManualDataEntry(); mdlg.AH = this; dr = mdlg.ShowDialog(); if (dr == DialogResult.OK) { // the work is done in the dialog class } break; case ConstructedSource.CycleFile: NC.App.AppContext.TestDataFileAssay = true; UIIntegration.Controller.file = true; dr = UIIntegration.GetUsersFile("Select a test data (disk) file", NC.App.AppContext.FileInput, "INCC5 Test data (disk)", "dat"); break; case ConstructedSource.ReviewFile: NC.App.AppContext.ReviewFileAssay = true; UIIntegration.Controller.file = true; dr = UIIntegration.GetUsersFile("Select an NCC file", NC.App.AppContext.FileInput, "INCC5 Review", "NCC"); break; case ConstructedSource.NCDFile: NC.App.AppContext.NCDFileAssay = true; UIIntegration.Controller.file = true; if (NC.App.Opstate.Measurement.MeasOption == AssaySelector.MeasurementOption.unspecified) { AnalysisWizard aw = new AnalysisWizard(AnalysisWizard.AWSteps.Step2A, ap, det); dr = aw.ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation } else { dr = UIIntegration.GetUsersFilesFolder("Select NCD files or folder", NC.App.AppContext.FileInput, "LMMM NCD", "ncd"); } break; case ConstructedSource.SortedPulseTextFile: NC.App.AppContext.PulseFileAssay = true; UIIntegration.Controller.file = true; if (NC.App.Opstate.Measurement.MeasOption == AssaySelector.MeasurementOption.unspecified) { AnalysisWizard aw1 = new AnalysisWizard(AnalysisWizard.AWSteps.Step2A, ap, det); dr = aw1.ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation } else { dr = UIIntegration.GetUsersFilesFolder("Select pulse files or folder", NC.App.AppContext.FileInput, "pulse", "txt"); } break; case ConstructedSource.PTRFile: NC.App.AppContext.PTRFileAssay = true; UIIntegration.Controller.file = true; if (NC.App.Opstate.Measurement.MeasOption == AssaySelector.MeasurementOption.unspecified) { AnalysisWizard aw2 = new AnalysisWizard(AnalysisWizard.AWSteps.Step2A, ap, det); dr = aw2.ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation } else { dr = UIIntegration.GetUsersFilesFolder("Select PTR-32 files or folder", NC.App.AppContext.FileInput, "PTR-32", "bin", "chn"); } break; case ConstructedSource.NILAFile: NC.App.AppContext.NILAFileAssay = true; UIIntegration.Controller.file = true; dr = UIIntegration.GetUsersFilesFolder("Select NILA files or folder", NC.App.AppContext.FileInput, "MTS NILA", "dat"); //dr = DialogResult.Cancel; break; default: break; } return dr; }
/// <summary> /// On user Ok, preserve any changes to the current Acquire state as well as the current detector /// </summary> private void OKBtn_Click(object sender, EventArgs e) { if (acq.modified) { INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, DateTime.Now); acq.review_detector_parms = DetectorParametersCheckBox.Checked; acq.review_calib_parms = CalibrationParametersCheckBox.Checked; acq.review_isotopics = IsotopicsCheckBox.Checked; acq.review_run_raw_data = IndividualCycleRawDataCheckBox.Checked; acq.review_run_rate_data = IndividualCycleRateData.Checked; acq.review_summed_raw_data = SummedRawCoincidenceDataCheckBox.Checked; acq.review_summed_mult_dist = SummedMultiplicityDistributionsCheckBox.Checked; acq.review_run_mult_dist = IndividualMultiplicityDistributionsCheckBox.Checked; acq.user_id = InspectorNameTextBox.Text; acq.campaign_id = InspectionNumberTextBox.Text; acq.MeasDateTime = sel.TimeStamp; acq.lm.TimeStamp = sel.TimeStamp; // facility and mba already set by selector handlers NC.App.DB.AcquireParametersMap().Add(sel, acq); // it's a new one, not the existing one modified NC.App.DB.UpdateAcquireParams(acq, det.ListMode); } if (det.Id.modified) NC.App.DB.UpdateDetector(det); this.Close(); }
//// BUTTONCLICK HANDLERS /////////////////////////////////////////////// public DialogResult OKButton_Click(object sender, EventArgs e) { DialogResult dr = DialogResult.Cancel; if (ap.modified) { INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, ap.item_type, DateTime.Now); ap.MeasDateTime = sel.TimeStamp; ap.lm.TimeStamp = sel.TimeStamp; NC.App.DB.AddAcquireParams(sel, ap); // it's a new one, not the existing one modified } // The acquire is set to occur if (ap.data_src != ConstructedSource.Reanalysis) // Reanalysis is a bit backwards, the correct measurement is fully constructed before this point LMAcquire.ResetMeasurement(); switch (ap.data_src) { case ConstructedSource.Live: // set up the instrument list for the action controller Integ.BuildMeasurement(ap, det, mo); UIIntegration.Controller.file = false; // make sure to use the DAQ controller, not the file controller NC.App.AppContext.FileInput = null; // reset the cmd line file input flag if (det.ListMode) { // patch override lm.Interval with run_count_time from dialog // the acquire dialogs field values, as seen and modified by the user, override the LM-only acquire settings for virtual SR measurements NC.App.Opstate.Measurement.AcquireState.lm.Interval = NC.App.Opstate.Measurement.AcquireState.run_count_time; NC.App.Opstate.Measurement.AcquireState.lm.Cycles = NC.App.Opstate.Measurement.AcquireState.num_runs; // Check NC.App.Opstate.Measurement.AnalysisParams for at least one VSR // If not present, inform and pop up the wizard // If present, inform with new dialog, do not pop up the wizard if (NC.App.Opstate.Measurement.AnalysisParams.HasMatchingVSR(det.MultiplicityParams)) { dr = DialogResult.OK; } else { dr = (new LMAcquire(ap, det, fromINCC5Acq: true)).ShowDialog();// analyzers are created in here, placed on global measurement if (dr == DialogResult.OK) { NC.App.DB.UpdateAcquireParams(ap); //update it again NC.App.DB.UpdateDetector(det); } } if (dr == DialogResult.OK) { // if ok, the analyzers are set up, so can kick it off now. UIIntegration.Controller.ActivateDetector(det); } } else { SRInstrument sri = new SRInstrument(det); sri.selected = true; sri.Init(NC.App.Loggers.Logger(LMLoggers.AppSection.Data), NC.App.Loggers.Logger(LMLoggers.AppSection.Analysis)); if (!Instruments.All.Contains(sri)) Instruments.All.Add(sri); // add to global runtime list dr = DialogResult.OK; } break; case ConstructedSource.DB: NC.App.AppContext.DBDataAssay = true; UIIntegration.Controller.file = true; IDDAcquireDBMeas dbdlg = new IDDAcquireDBMeas(this); if (dbdlg.HasItems()) { dr = dbdlg.ShowDialog(); if (dr == DialogResult.OK) { Integ.BuildMeasurement(ap, det, mo); DateTimeOffset dto = dbdlg.measurementId.MeasDateTime; NC.App.Logger(LMLoggers.AppSection.App).TraceEvent(LogLevels.Info, 87654, "Using " + dto.ToString("MMM dd yyy HH:mm:ss.ff K")); NC.App.Opstate.Measurement.MeasDate = dto; // get the cycles for the selected measurement from the database, and add them to the current measurement CycleList cl = NC.App.DB.GetCycles(det, dbdlg.measurementId, ap.data_src); // APluralityOfMultiplicityAnalyzers: // URGENT: get all the cycles associated with each analyzer, restoring into the correct key->result pair NC.App.Opstate.Measurement.Add(cl); // use the cycle time interval as found in the data, taking the first entry because equal intervals are assumed if (cl.Count > 0) NC.App.Opstate.Measurement.AcquireState.lm.Interval = NC.App.Opstate.Measurement.AcquireState.run_count_time = cl[0].TS.TotalSeconds; NC.App.DB.UpdateAcquireParams(ap); //update it again } } else MessageBox.Show("No items found in database matching these parameters", "WARNING"); break; case ConstructedSource.Manual: UIIntegration.Controller.file = true; NC.App.AppContext.DBDataAssay = true; IDDManualDataEntry mdlg = new IDDManualDataEntry(); mdlg.AH = this; dr = mdlg.ShowDialog(); // the work constructing the measurement is done in the dialog class break; case ConstructedSource.Reanalysis: UIIntegration.Controller.file = true; NC.App.AppContext.DBDataAssay = true; dr = DialogResult.OK; // the measurement re-creation work is done in the IDDReanalysisAssay dialog class prior to reaching this point break; case ConstructedSource.CycleFile: Integ.BuildMeasurementMinimal(ap, det, mo); // the measurement is reconstructed before each test data file processing, so this is meant as a carrier for certain kick-off values NC.App.AppContext.TestDataFileAssay = true; UIIntegration.Controller.file = true; dr = UIIntegration.GetUsersFile("Select a test data (disk) file", NC.App.AppContext.FileInput, "INCC5 Test data (disk)", "dat", "cnn"); break; case ConstructedSource.ReviewFile: Integ.BuildMeasurementMinimal(ap, det, mo); // acquire type and measurement option are read from each NCC file itself, so this instance is an acquire state kick-off carrier value NC.App.AppContext.ReviewFileAssay = true; UIIntegration.Controller.file = true; dr = UIIntegration.GetUsersFile("Select an NCC file", NC.App.AppContext.FileInput, "INCC5 Review", "NCC"); break; case ConstructedSource.NCDFile: Integ.BuildMeasurement(ap, det, mo); NC.App.AppContext.NCDFileAssay = true; UIIntegration.Controller.file = true; if (det.ListMode || NC.App.Opstate.Measurement.MeasOption.IsListMode()) { dr = (new LMAcquire(ap, det, fromINCC5Acq: true)).ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation } else { dr = UIIntegration.GetUsersFilesFolder("Select NCD files or folder", NC.App.AppContext.FileInput, "LMMM NCD", "ncd"); } break; case ConstructedSource.SortedPulseTextFile: Integ.BuildMeasurement(ap, det, mo); NC.App.AppContext.PulseFileAssay = true; UIIntegration.Controller.file = true; if (det.ListMode || NC.App.Opstate.Measurement.MeasOption.IsListMode()) { dr = (new LMAcquire(ap, det, fromINCC5Acq: true)).ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation } else { dr = UIIntegration.GetUsersFilesFolder("Select pulse files or folder", NC.App.AppContext.FileInput, "pulse", "txt"); } break; case ConstructedSource.PTRFile: Integ.BuildMeasurement(ap, det, mo); NC.App.AppContext.PTRFileAssay = true; UIIntegration.Controller.file = true; if (det.ListMode || NC.App.Opstate.Measurement.MeasOption.IsListMode()) { dr = (new LMAcquire(ap, det, fromINCC5Acq: true)).ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation } else { dr = UIIntegration.GetUsersFilesFolder("Select PTR-32 files or folder", NC.App.AppContext.FileInput, "PTR-32", "bin", "chn"); } break; case ConstructedSource.MCA527File: Integ.BuildMeasurement(ap, det, mo); NC.App.AppContext.MCA527FileAssay = true; UIIntegration.Controller.file = true; if (det.ListMode || NC.App.Opstate.Measurement.MeasOption.IsListMode()) { dr = (new LMAcquire(ap, det, fromINCC5Acq: true)).ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation } else { dr = UIIntegration.GetUsersFilesFolder("Select MCA files or folder", NC.App.AppContext.FileInput, "MCA527", "mca"); } break; default: break; } return dr; }
private void OKBtn_Click(object sender, EventArgs e) { if (hvp.modified) { DialogResult = System.Windows.Forms.DialogResult.OK; HVCalibrationParameters c = NC.App.DB.HVParameters.Get(det.Id.DetectorName); if (c != null) { c.Copy(hvp); // copy changes back to original on user affirmation } else { c = hvp; NC.App.DB.HVParameters.GetMap().Add(det, c); } NC.App.DB.HVParameters.Set(det, c); // dev note: LM HV vals on LM Acquire record, but SR uses separate DB table so move HV vals so unify the scheme } else { DialogResult = System.Windows.Forms.DialogResult.Ignore; } // The acquire is set to occur, build up the measurement state Integ.BuildMeasurement(acq, det, AssaySelector.MeasurementOption.unspecified); if (acq.modified) { INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, acq.item_type, DateTime.Now); acq.MeasDateTime = sel.TimeStamp; acq.lm.TimeStamp = sel.TimeStamp; NC.App.DB.AcquireParametersMap().Add(sel, acq); // it's a new one, not the existing one modified NC.App.DB.UpdateAcquireParams(acq, det.ListMode); } UIIntegration.Controller.file = false; // make sure to use the DAQ controller, not the file controller NC.App.AppContext.FileInput = null; // reset the cmd line file input flag if (NC.App.Opstate.Measurement.Detectors[0].ListMode) { if (NC.App.Opstate.Measurement.Detectors[0].Id.SRType == InstrType.PTR32) { Ptr32Instrument instrument = new Ptr32Instrument(NC.App.Opstate.Measurement.Detectors[0]); instrument.DAQState = DAQInstrState.Offline; instrument.selected = true; instrument.Init(NC.App.Logger(LMLoggers.AppSection.Data), NC.App.Logger(LMLoggers.AppSection.Analysis)); if (!Instruments.Active.Contains(instrument)) { Instruments.Active.Add(instrument); } } else { // if ok, the analyzers are set up, so can kick it off now. LMInstrument lm = new LMInstrument(NC.App.Opstate.Measurement.Detectors[0]); lm.DAQState = DAQInstrState.Offline; // these are manually initiated as opposed to auto-pickup lm.selected = false; //must broadcast first to get it selected if (!Instruments.All.Contains(lm)) { Instruments.All.Add(lm); // add to global runtime list } } } else { SRInstrument sri = new SRInstrument(NC.App.Opstate.Measurement.Detectors[0]); sri.selected = true; sri.Init(null, null); if (!Instruments.All.Contains(sri)) { Instruments.All.Add(sri); // add to global runtime list } } UIIntegration.Controller.SetHVCalib(); // tell the controller to do an HV operation using the current measurement state UIIntegration.Controller.Perform(); // start the HV DAQ thread this.Close(); }