public virtual INCCTransferBase Restore() { // current file INCCTransferBase result = null; switch (mft) { case eFileType.eInitialDataDetector: { INCCInitialDataDetectorFile idd = new INCCInitialDataDetectorFile(mlogger, mpath); bool good = idd.Restore(mpath); if (good) result = idd; // this now has the structs ready } break; case eFileType.eInitialDataCalibration: { INCCInitialDataCalibrationFile idcal = new INCCInitialDataCalibrationFile(mlogger, mpath); bool good = idcal.Restore(mpath); if (good) result = idcal; // this now has the structs ready } break; case eFileType.eTransfer: { INCCTransferFile idt = new INCCTransferFile(mlogger, mpath); bool good = idt.Restore(mpath); if (good) result = idt; // this now has the structs ready } break; case eFileType.eNCC: { INCCReviewFile irf = new INCCReviewFile(mlogger, mpath); bool good = irf.Restore(mpath); if (good) result = irf; // this now has the structs ready } break; case eFileType.eUnknown: mlogger.TraceEvent(LogLevels.Info, 34007, "Skipping {0}", mpath); break; default: // for future expansion // dev note: NOP and COP files are just CSV or Tab-delimited text files, so no binary matching is needed, so I am moving the handling of these to another class (OPfiles) mlogger.TraceEvent(LogLevels.Info, 34008, "Not processing the unsupported file {0}", mpath); break; }; return result; }
public static unsafe List<INCCInitialDataCalibrationFile> CalibFromDetectors(List<Detector> dets) { List<INCCInitialDataCalibrationFile> list = new List<INCCInitialDataCalibrationFile>(); foreach(Detector det in dets) { INCCInitialDataCalibrationFile idcf = new INCCInitialDataCalibrationFile(NC.App.Loggers.Logger(LMLoggers.AppSection.Control), null); idcf.Name = det.Id.DetectorId; foreach (INCCDB.Descriptor desc in NC.App.DB.Materials.GetList()) { INCCSelector se = new INCCSelector(det.Id.DetectorId, desc.Name); if (!NC.App.DB.DetectorMaterialAnalysisMethods.ContainsKey(se)) continue; // do the method choice rec first DetectorMaterialMethod dmm = new DetectorMaterialMethod(se.material, se.detectorid, INCC.METHOD_NONE); idcf.DetectorMaterialMethodParameters.Add(dmm, Calib5.MoveAMR(se)); // then do each method rec AnalysisMethods ams = NC.App.DB.DetectorMaterialAnalysisMethods[se]; IEnumerator iter = ams.GetMethodEnumerator(); while (iter.MoveNext()) { Tuple<AnalysisMethod, INCCAnalysisParams.INCCMethodDescriptor> md = (Tuple<AnalysisMethod, INCCAnalysisParams.INCCMethodDescriptor>)iter.Current; dmm = new DetectorMaterialMethod(se.material, se.detectorid, (byte)NewTypeToOldMethodId(md.Item1)); switch(md.Item1) { case AnalysisMethod.KnownA: idcf.DetectorMaterialMethodParameters.Add(dmm, Calib5.MoveKA(se, md.Item2)); break; case AnalysisMethod.CalibrationCurve: idcf.DetectorMaterialMethodParameters.Add(dmm, Calib5.MoveCC(se, md.Item2)); break; case AnalysisMethod.KnownM: idcf.DetectorMaterialMethodParameters.Add(dmm, Calib5.MoveKM(se, md.Item2)); break; case AnalysisMethod.Multiplicity: idcf.DetectorMaterialMethodParameters.Add(dmm, Calib5.MoveMult(se, md.Item2)); break; case AnalysisMethod.TruncatedMultiplicity: idcf.DetectorMaterialMethodParameters.Add(dmm, Calib5.MoveTM(se, md.Item2)); break; case AnalysisMethod.AddASource: idcf.DetectorMaterialMethodParameters.Add(dmm, Calib5.MoveAS(se, md.Item2)); break; case AnalysisMethod.CuriumRatio: idcf.DetectorMaterialMethodParameters.Add(dmm, Calib5.MoveCR(se, md.Item2)); break; case AnalysisMethod.Active: idcf.DetectorMaterialMethodParameters.Add(dmm, Calib5.MoveCA(se, md.Item2)); break; case AnalysisMethod.ActivePassive: idcf.DetectorMaterialMethodParameters.Add(dmm, Calib5.MoveAP(se, md.Item2)); break; case AnalysisMethod.ActiveMultiplicity: idcf.DetectorMaterialMethodParameters.Add(dmm, Calib5.MoveAM(se, md.Item2)); break; case AnalysisMethod.DUAL_ENERGY_MULT_SAVE_RESTORE: idcf.DetectorMaterialMethodParameters.Add(dmm, Calib5.MoveDE(se, md.Item2)); break; case AnalysisMethod.Collar: try { idcf.DetectorMaterialMethodParameters. Add(new DetectorMaterialMethod(se.material, se.detectorid, INCC.COLLAR_DETECTOR_SAVE_RESTORE), Calib5.MoveCD(se, md.Item2)); idcf.DetectorMaterialMethodParameters. Add(new DetectorMaterialMethod(se.material, se.detectorid, INCC.COLLAR_SAVE_RESTORE), Calib5.MoveCO(se, md.Item2)); idcf.DetectorMaterialMethodParameters. Add(new DetectorMaterialMethod(se.material, se.detectorid, INCC.COLLAR_K5_SAVE_RESTORE), Calib5.MoveCK(se, md.Item2)); } catch (Exception e) { NC.App.Loggers.Logger(LMLoggers.AppSection.Control).TraceEvent(LogLevels.Warning, 34102, "Collar xfer processing error {0} {1}", md.Item1.FullName(), e.Message); } break; case AnalysisMethod.COLLAR_SAVE_RESTORE: case AnalysisMethod.COLLAR_DETECTOR_SAVE_RESTORE: case AnalysisMethod.COLLAR_K5_SAVE_RESTORE: NC.App.Loggers.Logger(LMLoggers.AppSection.Control).TraceEvent(LogLevels.Verbose, 34100, "Got '{0}' ", md.Item1.FullName()); break; case AnalysisMethod.INCCNone: break; default: break; } } } list.Add(idcf); } return list; }
INCCAnalysisParams.collar_combined_rec CollarEntryProcesser(INCCInitialDataCalibrationFile idcf, INCCSelector sel, byte mode) { DetectorMaterialMethod m1 = new DetectorMaterialMethod(sel.material, sel.detectorid, INCC.COLLAR_DETECTOR_SAVE_RESTORE); m1.extra = mode; DetectorMaterialMethod m2 = new DetectorMaterialMethod(sel.material, sel.detectorid, INCC.COLLAR_SAVE_RESTORE); m2.extra = mode; DetectorMaterialMethod m3 = new DetectorMaterialMethod(sel.material, sel.detectorid, INCC.COLLAR_K5_SAVE_RESTORE); m3.extra = mode; KeyValuePair<DetectorMaterialMethod, object> k1, k2, k3; bool ok = idcf.DetectorMaterialMethodParameters.GetPair(m1, out k1); if (!ok) { mlogger.TraceEvent(LogLevels.Verbose, 30811, "No collar detector values for " + m1.ToString()); ok = idcf.DetectorMaterialMethodParameters.GetPair(m2, out k2); if (ok) { // k5 and collar but no det entry, find the closest match det entry and make a fake one and use it List<KeyValuePair<DetectorMaterialMethod, object>> l = idcf.DetectorMaterialMethodParameters.GetDetectorsWithEntries; if (l.Count > 0) { object o = l[0].Value; collar_detector_rec rec = MakeAFake((collar_detector_rec)o, sel.detectorid, sel.material); DetectorMaterialMethod mf1 = new DetectorMaterialMethod(sel.material, sel.detectorid, INCC.COLLAR_DETECTOR_SAVE_RESTORE); mf1.extra = mode; k1 = new KeyValuePair<DetectorMaterialMethod, object>(mf1, rec); } else return null; } else { mlogger.TraceEvent(LogLevels.Verbose, 30812, "No collar values for " + m2.ToString()); return null; } } else { ok = idcf.DetectorMaterialMethodParameters.GetPair(m2, out k2); if (!ok) { mlogger.TraceEvent(LogLevels.Verbose, 30812, "No collar values for " + m2.ToString()); return null; } } ok = idcf.DetectorMaterialMethodParameters.GetPair(m3, out k3); if (!ok) { mlogger.TraceEvent(LogLevels.Verbose, 30813, "No k5 values for " + m3.ToString()); return null; } collar_rec collar; collar_detector_rec collar_detector; collar_k5_rec collar_k5; if (k1.Key.extra == -1) return null; collar_detector = (collar_detector_rec)k1.Value; if (k2.Key.extra == -1) return null; collar = (collar_rec)k2.Value; if (k3.Key.extra == -1) return null; collar_k5 = (collar_k5_rec)k3.Value; // got the three INCCAnalysisParams.collar_combined_rec combined = new INCCAnalysisParams.collar_combined_rec(); ushort bonk = 0; CollarDet(combined, collar_detector, bonk); bonk = 1; CollarParm(combined, collar, bonk); bonk = 2; CollarK5(combined, collar_k5, bonk); bonk = 3; k1.Key.extra = -1; k2.Key.extra = -1; k3.Key.extra = -1; return combined; }
public unsafe void BuildCalibration(INCCInitialDataCalibrationFile idcf, int num) { mlogger.TraceEvent(LogLevels.Verbose, 34200, "Building calibration content from {0} {1}", num, idcf.Path); bool overwrite = NC.App.AppContext.OverwriteImportedDefs; IEnumerator iter = idcf.DetectorMaterialMethodParameters.GetDetectorMaterialEnumerator(); while (iter.MoveNext()) { DetectorMaterialMethod mkey = ((KeyValuePair<DetectorMaterialMethod, object>)iter.Current).Key; mlogger.TraceEvent(LogLevels.Verbose, 34210, "Constructing calibration for {0} {1}", mkey.detector_id, mkey.item_type); INCCDB.Descriptor desc = new INCCDB.Descriptor(mkey.item_type, ""); if (!NC.App.DB.Materials.Has(desc) || overwrite) { NC.App.DB.Materials.Update(desc); } Detector det; // look in real detector list for entry with this basic id, if not found, punt or later try creating a new empty detector, it will be filled in later as processing proceeds det = NC.App.DB.Detectors.GetItByDetectorId(mkey.detector_id); if (det == null) { // old code punted if detector not found mlogger.TraceEvent(LogLevels.Warning, 34207, "Skipping detector {0}, pre-existing def not found", mkey.detector_id); // dev note: need flags to control this ehavior in a few more places continue; } IEnumerator miter2 = idcf.DetectorMaterialMethodParameters.GetMethodEnumerator(mkey.detector_id, mkey.item_type); if (miter2 == null) continue; INCCSelector sel = new INCCSelector(mkey.detector_id, mkey.item_type); AnalysisMethods am; bool found = NC.App.DB.DetectorMaterialAnalysisMethods.TryGetValue(sel, out am); if (!found || am == null) { am = new AnalysisMethods(mlogger); am.modified = true; NC.App.DB.DetectorMaterialAnalysisMethods.Add(sel, am); } while (miter2.MoveNext()) { // use ref here, not copy so updates update the ref? nope, it;s a map, need to remove and replace int cam = OldTypeToOldMethodId(miter2.Current); mlogger.TraceEvent(LogLevels.Verbose, 34211, "Converting {0} {1} method {2}", mkey.detector_id, mkey.item_type, OldToNewMethodId(cam).FullName()); // save the analysis method obtained here under the existing/new detector+material type pair switch (cam) { case INCC.METHOD_NONE: analysis_method_rec iamr = (analysis_method_rec)miter2.Current; // create entries in the am map if needed, copy other settings onto am proper am.Backup = OldToNewMethodId(iamr.backup_method); am.Normal = OldToNewMethodId(iamr.normal_method); am.choices[(int)AnalysisMethod.CalibrationCurve] = (iamr.cal_curve == 0 ? false : true); am.choices[(int)AnalysisMethod.Active] = (iamr.active == 0 ? false : true); am.choices[(int)AnalysisMethod.ActiveMultiplicity] = (iamr.active_mult == 0 ? false : true); am.choices[(int)AnalysisMethod.ActivePassive] = (iamr.active_passive == 0 ? false : true); am.choices[(int)AnalysisMethod.AddASource] = (iamr.add_a_source == 0 ? false : true); am.choices[(int)AnalysisMethod.Collar] = (iamr.collar == 0 ? false : true); am.choices[(int)AnalysisMethod.CuriumRatio] = (iamr.curium_ratio == 0 ? false : true); am.choices[(int)AnalysisMethod.KnownA] = (iamr.known_alpha == 0 ? false : true); am.choices[(int)AnalysisMethod.KnownM] = (iamr.known_m == 0 ? false : true); am.choices[(int)AnalysisMethod.Multiplicity] = (iamr.multiplicity == 0 ? false : true); am.choices[(int)AnalysisMethod.TruncatedMultiplicity] = (iamr.truncated_mult == 0 ? false : true); if (am.AnySelected()) am.choices[(int)AnalysisMethod.None] = am.choices[(int)AnalysisMethod.INCCNone] = false; break; case INCC.METHOD_CALCURVE: cal_curve_rec cal_curve = (cal_curve_rec)miter2.Current; INCCAnalysisParams.cal_curve_rec cc = new INCCAnalysisParams.cal_curve_rec(); cc.heavy_metal_corr_factor = cal_curve.cc_heavy_metal_corr_factor; cc.heavy_metal_reference = cal_curve.cc_heavy_metal_reference; cc.cev.lower_mass_limit = cal_curve.cc_lower_mass_limit; cc.cev.upper_mass_limit = cal_curve.cc_upper_mass_limit; cc.percent_u235 = cal_curve.cc_percent_u235; TransferUtils.Copy(ref cc.dcl_mass, cal_curve.cc_dcl_mass, INCC.MAX_NUM_CALIB_PTS); TransferUtils.Copy(ref cc.doubles, cal_curve.cc_doubles, INCC.MAX_NUM_CALIB_PTS); cc.cev.a = cal_curve.cc_a; cc.cev.b = cal_curve.cc_b; cc.cev.c = cal_curve.cc_c; cc.cev.d = cal_curve.cc_d; cc.cev.var_a = cal_curve.cc_var_a; cc.cev.var_b = cal_curve.cc_var_b; cc.cev.var_c = cal_curve.cc_var_c; cc.cev.var_d = cal_curve.cc_var_d; cc.cev.setcovar(Coeff.a,Coeff.b,cal_curve.cc_covar_ab); cc.cev._covar[0, 2] = cal_curve.cc_covar_ac; cc.cev._covar[0, 3] = cal_curve.cc_covar_ad; cc.cev._covar[1, 2] = cal_curve.cc_covar_bc; cc.cev._covar[1, 3] = cal_curve.cc_covar_bd; cc.cev._covar[2, 3] = cal_curve.cc_covar_cd; cc.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)cal_curve.cal_curve_equation; cc.CalCurveType = (INCCAnalysisParams.CalCurveType)cal_curve.cc_cal_curve_type; cc.cev.sigma_x = cal_curve.cc_sigma_x; am.AddMethod(AnalysisMethod.CalibrationCurve, cc); break; case INCC.METHOD_AKNOWN: known_alpha_rec known_alpha = (known_alpha_rec)miter2.Current; INCCAnalysisParams.known_alpha_rec ka = new INCCAnalysisParams.known_alpha_rec(); ka.alpha_wt = known_alpha.ka_alpha_wt; TransferUtils.Copy(ref ka.dcl_mass, known_alpha.ka_dcl_mass, INCC.MAX_NUM_CALIB_PTS); TransferUtils.Copy(ref ka.doubles, known_alpha.ka_doubles, INCC.MAX_NUM_CALIB_PTS); ka.heavy_metal_corr_factor = known_alpha.ka_heavy_metal_corr_factor; ka.heavy_metal_reference = known_alpha.ka_heavy_metal_reference; ka.k = known_alpha.ka_k; ka.known_alpha_type = (INCCAnalysisParams.KnownAlphaVariant)known_alpha.ka_known_alpha_type; ka.lower_corr_factor_limit = known_alpha.ka_lower_corr_factor_limit; ka.upper_corr_factor_limit = known_alpha.ka_upper_corr_factor_limit; ka.rho_zero = known_alpha.ka_rho_zero; ka.ring_ratio.cal_curve_equation = (INCCAnalysisParams.CurveEquation)known_alpha.ka_ring_ratio_equation; ka.ring_ratio.a = known_alpha.ka_ring_ratio_a; ka.ring_ratio.b = known_alpha.ka_ring_ratio_b; ka.ring_ratio.c = known_alpha.ka_ring_ratio_c; ka.ring_ratio.d = known_alpha.ka_ring_ratio_d; ka.cev.a = known_alpha.ka_a; ka.cev.b = known_alpha.ka_b; ka.cev.var_a = known_alpha.ka_var_a; ka.cev.var_b = known_alpha.ka_var_b; ka.cev.sigma_x = known_alpha.ka_sigma_x; ka.cev._covar[(int)Coeff.a, (int)Coeff.b] = known_alpha.ka_covar_ab; ka.cev.lower_mass_limit = known_alpha.ka_lower_mass_limit; ka.cev.upper_mass_limit = known_alpha.ka_upper_mass_limit; am.AddMethod(AnalysisMethod.KnownA, ka); break; case INCC.METHOD_MKNOWN: known_m_rec known_m = (known_m_rec)miter2.Current; INCCAnalysisParams.known_m_rec km = new INCCAnalysisParams.known_m_rec(); km.sf_rate = known_m.km_sf_rate; km.vs1 = known_m.km_vs1; km.vs2 = known_m.km_vs2; km.vi1 = known_m.km_vi1; km.vi2 = known_m.km_vi2; km.b = known_m.km_b; km.c = known_m.km_c; km.lower_mass_limit = known_m.km_lower_mass_limit; km.upper_mass_limit = known_m.km_upper_mass_limit; am.AddMethod(AnalysisMethod.KnownM, km); break; case INCC.METHOD_MULT: multiplicity_rec multiplicity = (multiplicity_rec)miter2.Current; INCCAnalysisParams.multiplicity_rec m = new INCCAnalysisParams.multiplicity_rec(); m.solve_efficiency = (INCCAnalysisParams.MultChoice)multiplicity.mul_solve_efficiency; m.sf_rate = multiplicity.mul_sf_rate; m.vs1 = multiplicity.mul_vs1; m.vs2 = multiplicity.mul_vs2; m.vs3 = multiplicity.mul_vs3; m.vi1 = multiplicity.mul_vi1; m.vi2 = multiplicity.mul_vi2; m.vi3 = multiplicity.mul_vi3; m.a = multiplicity.mul_a; m.b = multiplicity.mul_b; m.c = multiplicity.mul_c; m.sigma_x = multiplicity.mul_sigma_x; m.alpha_weight = multiplicity.mul_alpha_weight; am.AddMethod(AnalysisMethod.Multiplicity, m); break; case INCC.DUAL_ENERGY_MULT_SAVE_RESTORE: de_mult_rec de_mult = (de_mult_rec)miter2.Current; INCCAnalysisParams.de_mult_rec de = new INCCAnalysisParams.de_mult_rec(); TransferUtils.Copy(ref de.detector_efficiency, de_mult.de_detector_efficiency, INCC.MAX_DUAL_ENERGY_ROWS); TransferUtils.Copy(ref de.inner_outer_ring_ratio, de_mult.de_inner_outer_ring_ratio, INCC.MAX_DUAL_ENERGY_ROWS); TransferUtils.Copy(ref de.neutron_energy, de_mult.de_neutron_energy, INCC.MAX_DUAL_ENERGY_ROWS); TransferUtils.Copy(ref de.relative_fission, de_mult.de_relative_fission, INCC.MAX_DUAL_ENERGY_ROWS); de.inner_ring_efficiency = de_mult.de_inner_ring_efficiency; de.outer_ring_efficiency = de_mult.de_outer_ring_efficiency; am.AddMethod(AnalysisMethod.DUAL_ENERGY_MULT_SAVE_RESTORE, de); break; case INCC.METHOD_TRUNCATED_MULT: truncated_mult_rec truncated_mult = (truncated_mult_rec)miter2.Current; INCCAnalysisParams.truncated_mult_rec tm = new INCCAnalysisParams.truncated_mult_rec(); tm.a = truncated_mult.tm_a; tm.b = truncated_mult.tm_b; tm.known_eff = (truncated_mult.tm_known_eff == 0 ? false : true); tm.solve_eff = (truncated_mult.tm_solve_eff == 0 ? false : true); am.AddMethod(AnalysisMethod.TruncatedMultiplicity, tm); break; case INCC.METHOD_CURIUM_RATIO: curium_ratio_rec curium_ratio = (curium_ratio_rec)miter2.Current; INCCAnalysisParams.curium_ratio_rec cr = new INCCAnalysisParams.curium_ratio_rec(); cr.curium_ratio_type = OldToNewCRVariants(curium_ratio.curium_ratio_type); cr.cev.a = curium_ratio.cr_a; cr.cev.b = curium_ratio.cr_b; cr.cev.c = curium_ratio.cr_c; cr.cev.d = curium_ratio.cr_d; cr.cev.var_a = curium_ratio.cr_var_a; cr.cev.var_b = curium_ratio.cr_var_b; cr.cev.var_c = curium_ratio.cr_var_c; cr.cev.var_d = curium_ratio.cr_var_d; cr.cev.setcovar(Coeff.a,Coeff.b,curium_ratio.cr_covar_ab); cr.cev._covar[0, 2] = curium_ratio.cr_covar_ac; cr.cev._covar[0, 3] = curium_ratio.cr_covar_ad; cr.cev._covar[1, 2] = curium_ratio.cr_covar_bc; cr.cev._covar[1, 3] = curium_ratio.cr_covar_bd; cr.cev._covar[2, 3] = curium_ratio.cr_covar_cd; cr.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)curium_ratio.curium_ratio_equation; cr.cev.sigma_x = curium_ratio.cr_sigma_x; cr.cev.lower_mass_limit = curium_ratio.cr_lower_mass_limit; cr.cev.upper_mass_limit = curium_ratio.cr_upper_mass_limit; am.AddMethod(AnalysisMethod.CuriumRatio, cr); break; case INCC.METHOD_ADDASRC: add_a_source_rec add_a_source = (add_a_source_rec)miter2.Current; INCCAnalysisParams.add_a_source_rec aas = new INCCAnalysisParams.add_a_source_rec(); aas.cev.a = add_a_source.ad_a; aas.cev.b = add_a_source.ad_b; aas.cev.c = add_a_source.ad_c; aas.cev.d = add_a_source.ad_d; aas.cev.var_a = add_a_source.ad_var_a; aas.cev.var_b = add_a_source.ad_var_b; aas.cev.var_c = add_a_source.ad_var_c; aas.cev.var_d = add_a_source.ad_var_d; aas.cev.setcovar(Coeff.a,Coeff.b,add_a_source.ad_covar_ab); aas.cev._covar[0, 2] = add_a_source.ad_covar_ac; aas.cev._covar[0, 3] = add_a_source.ad_covar_ad; aas.cev._covar[1, 2] = add_a_source.ad_covar_bc; aas.cev._covar[1, 3] = add_a_source.ad_covar_bd; aas.cev._covar[2, 3] = add_a_source.ad_covar_cd; aas.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)add_a_source.add_a_source_equation; aas.cev.sigma_x = add_a_source.ad_sigma_x; aas.cev.lower_mass_limit = add_a_source.ad_lower_mass_limit; aas.cev.upper_mass_limit = add_a_source.ad_upper_mass_limit; TransferUtils.Copy(ref aas.dcl_mass, add_a_source.ad_dcl_mass, INCC.MAX_NUM_CALIB_PTS); TransferUtils.Copy(ref aas.doubles, add_a_source.ad_doubles, INCC.MAX_NUM_CALIB_PTS); aas.cf.a = add_a_source.ad_cf_a; aas.cf.b = add_a_source.ad_cf_b; aas.cf.c = add_a_source.ad_cf_c; aas.cf.d = add_a_source.ad_cf_d; aas.dzero_avg = add_a_source.ad_dzero_avg; aas.num_runs = add_a_source.ad_num_runs; aas.tm_dbls_rate_upper_limit = add_a_source.ad_tm_dbls_rate_upper_limit; aas.tm_weighting_factor = add_a_source.ad_tm_weighting_factor; aas.use_truncated_mult = (add_a_source.ad_use_truncated_mult == 0 ? false : true); aas.dzero_ref_date = INCC.DateFrom(TransferUtils.str(add_a_source.ad_dzero_ref_date, INCC.DATE_TIME_LENGTH)); aas.position_dzero = TransferUtils.Copy(add_a_source.ad_position_dzero, INCC.MAX_ADDASRC_POSITIONS); am.AddMethod(AnalysisMethod.AddASource, aas); break; case INCC.METHOD_ACTIVE: active_rec active = (active_rec)miter2.Current; INCCAnalysisParams.active_rec ar = new INCCAnalysisParams.active_rec(); ar.cev.lower_mass_limit = active.act_lower_mass_limit; ar.cev.upper_mass_limit = active.act_upper_mass_limit; TransferUtils.Copy(ref ar.dcl_mass, active.act_dcl_mass, INCC.MAX_NUM_CALIB_PTS); TransferUtils.Copy(ref ar.doubles, active.act_doubles, INCC.MAX_NUM_CALIB_PTS); ar.cev.a = active.act_a; ar.cev.b = active.act_b; ar.cev.c = active.act_c; ar.cev.d = active.act_d; ar.cev.var_a = active.act_var_a; ar.cev.var_b = active.act_var_b; ar.cev.var_c = active.act_var_c; ar.cev.var_d = active.act_var_d; ar.cev.setcovar(Coeff.a,Coeff.b,active.act_covar_ab); ar.cev._covar[0, 2] = active.act_covar_ac; ar.cev._covar[0, 3] = active.act_covar_ad; ar.cev._covar[1, 2] = active.act_covar_bc; ar.cev._covar[1, 3] = active.act_covar_bd; ar.cev._covar[2, 3] = active.act_covar_cd; ar.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)active.active_equation; ar.cev.sigma_x = active.act_sigma_x; am.AddMethod(AnalysisMethod.Active, ar); break; case INCC.METHOD_ACTPAS: active_passive_rec active_passive = (active_passive_rec)miter2.Current; INCCAnalysisParams.active_passive_rec apr = new INCCAnalysisParams.active_passive_rec(); apr.cev.lower_mass_limit = active_passive.ap_lower_mass_limit; apr.cev.upper_mass_limit = active_passive.ap_upper_mass_limit; apr.cev.a = active_passive.ap_a; apr.cev.b = active_passive.ap_b; apr.cev.c = active_passive.ap_c; apr.cev.d = active_passive.ap_d; apr.cev.var_a = active_passive.ap_var_a; apr.cev.var_b = active_passive.ap_var_b; apr.cev.var_c = active_passive.ap_var_c; apr.cev.var_d = active_passive.ap_var_d; apr.cev.setcovar(Coeff.a,Coeff.b,active_passive.ap_covar_ab); apr.cev._covar[0, 2] = active_passive.ap_covar_ac; apr.cev._covar[0, 3] = active_passive.ap_covar_ad; apr.cev._covar[1, 2] = active_passive.ap_covar_bc; apr.cev._covar[1, 3] = active_passive.ap_covar_bd; apr.cev._covar[2, 3] = active_passive.ap_covar_cd; apr.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)active_passive.active_passive_equation; apr.cev.sigma_x = active_passive.ap_sigma_x; am.AddMethod(AnalysisMethod.ActivePassive, apr); break; case INCC.COLLAR_SAVE_RESTORE: mlogger.TraceEvent(LogLevels.Verbose, 34213, " Collar params entry for COLLAR_SAVE_RESTORE"); break; case INCC.COLLAR_DETECTOR_SAVE_RESTORE: mlogger.TraceEvent(LogLevels.Verbose, 34212, " Main entry for COLLAR_DETECTOR_SAVE_RESTORE"); break; case INCC.COLLAR_K5_SAVE_RESTORE: mlogger.TraceEvent(LogLevels.Verbose, 34214, " K5 entry for COLLAR_K5_SAVE_RESTORE"); collar_k5_rec collar_k5 = (collar_k5_rec)miter2.Current; INCCAnalysisParams.collar_combined_rec combined = CollarEntryProcesser(idcf, sel, collar_k5.collar_k5_mode); if (combined != null) am.AddMethod(AnalysisMethod.Collar, combined); break; case INCC.METHOD_ACTIVE_MULT: active_mult_rec active_mult = (active_mult_rec)miter2.Current; INCCAnalysisParams.active_mult_rec acm = new INCCAnalysisParams.active_mult_rec(); acm.vf1 = active_mult.am_vf1; acm.vf2 = active_mult.am_vf2; acm.vf3 = active_mult.am_vf3; acm.vt1 = active_mult.am_vt1; acm.vt2 = active_mult.am_vt2; acm.vt3 = active_mult.am_vt2; am.AddMethod(AnalysisMethod.ActiveMultiplicity, acm); break; case INCC.WMV_CALIB_TOKEN: mlogger.TraceEvent(LogLevels.Warning, 34247, "Skipping calib token"); // todo: weighted multiplicity not fully implemented throughout break; } } } }
public virtual INCCTransferBase Restore() { // current file INCCTransferBase result = null; switch (mft) { case eFileType.eInitialDataDetector: { INCCInitialDataDetectorFile idd = new INCCInitialDataDetectorFile(mlogger, mpath); bool good = idd.Restore(mpath); if (good) { result = idd; // this now has the structs ready } } break; case eFileType.eInitialDataCalibration: { INCCInitialDataCalibrationFile idcal = new INCCInitialDataCalibrationFile(mlogger, mpath); bool good = idcal.Restore(mpath); if (good) { result = idcal; // this now has the structs ready } } break; case eFileType.eTransfer: { INCCTransferFile idt = new INCCTransferFile(mlogger, mpath); bool good = idt.Restore(mpath); if (good) { result = idt; // this now has the structs ready } } break; case eFileType.eNCC: { INCCReviewFile irf = new INCCReviewFile(mlogger, mpath); bool good = irf.Restore(mpath); if (good) { result = irf; // this now has the structs ready } } break; case eFileType.eUnknown: mlogger.TraceEvent(LogLevels.Info, 34007, "Skipping {0}", mpath); break; default: // for future expansion // dev note: NOP and COP files are just CSV or Tab-delimited text files, so no binary matching is needed, so I am moving the handling of these to another class (OPfiles) mlogger.TraceEvent(LogLevels.Info, 34008, "Not processing the unsupported file {0}", mpath); break; } ; return(result); }