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);
}
