public IDDCollarCrossRef(INCCAnalysisParams.collar_combined_rec c = null, bool mod = false)
{
InitializeComponent();
mp = new MethodParamFormFields(AnalysisMethod.Collar);
RelativeDoublesRateTextBox.ToValidate = NumericTextBox.ValidateType.Float;
RelativeDoublesRateTextBox.NumberFormat = NumericTextBox.Formatter.F3;
Integ.GetCurrentAcquireDetectorPair(ref mp.acq, ref mp.det);
this.Text += " for " + mp.det.Id.DetectorName;
modified = mod;
mp.RefreshMatTypeComboBox(MaterialTypeComboBox);
mp.SelectMaterialType(MaterialTypeComboBox);
if (mp.HasMethod && c == null)
{
mp.imd = new INCCAnalysisParams.collar_combined_rec((INCCAnalysisParams.collar_combined_rec)mp.ams.GetMethodParameters(mp.am));
col = (INCCAnalysisParams.collar_combined_rec)mp.imd;
}
else if (mp.HasMethod && c != null)
{
col = c;
}
else
{
mp.imd = new INCCAnalysisParams.collar_combined_rec(); // not mapped, so make a new one
col = (INCCAnalysisParams.collar_combined_rec)mp.imd;
modified = true;
}
CrossReferenceFieldFiller(col);
this.TopMost = true;
}
public IDDCorrectionFactors(INCCAnalysisParams.collar_combined_rec c, bool mod)
{
InitializeComponent();
mp = new MethodParamFormFields(AnalysisMethod.Collar);
modified = mod;
Integ.GetCurrentAcquireDetectorPair(ref mp.acq, ref mp.det);
this.Text += " for " + mp.det.Id.DetectorName;
col = c;
MaterialLabel.Text = mp.acq.item_type;
ModeLabel.Text = col.collar.collar_mode ? "Fast(Cd)" : "Thermal (no Cd)";
DetectorLabel.Text = mp.det.Id.DetectorName;
ATextBox.NumberFormat = NumericTextBox.Formatter.E6;
ATextBox.ToValidate = NumericTextBox.ValidateType.Double;
AErrorTextBox.NumberFormat = NumericTextBox.Formatter.E6;
AErrorTextBox.ToValidate = NumericTextBox.ValidateType.Double;
BTextBox.NumberFormat = NumericTextBox.Formatter.E6;
BTextBox.ToValidate = NumericTextBox.ValidateType.Double;
BErrorTextBox.NumberFormat = NumericTextBox.Formatter.E6;
BErrorTextBox.ToValidate = NumericTextBox.ValidateType.Double;
FillForm();
this.TopMost = true;
}
public IDDPercentU235(AnalysisMethods ams_, INCCAnalysisParams.cal_curve_rec c)
{
InitializeComponent();
percent = c.percent_u235;
U235PercentTextBox.Text = percent.ToString("F3");
Integ.GetCurrentAcquireDetectorPair(ref acq, ref det);
ams = ams_;
}
protected void FieldFiller(INCCAnalysisParams.active_mult_rec amr)
{
Thermal1stMomentTextBox.Text = amr.vt1.ToString("E6");
Thermal2ndMomentTextBox.Text = amr.vt2.ToString("E6");
Thermal3rdMomentTextBox.Text = amr.vt3.ToString("E6");
Fast1stMomentTextBox.Text = amr.vf1.ToString("E6");
Fast2ndMomentTextBox.Text = amr.vf2.ToString("E6");
Fast3rdMomentTextBox.Text = amr.vf3.ToString("E6");
}
public void RefreshCurveEqComboBox(ComboBox cb, INCCAnalysisParams.CurveEquationVals v)
{
cb.Items.Clear();
foreach (INCCAnalysisParams.CurveEquation cs in System.Enum.GetValues(typeof(INCCAnalysisParams.CurveEquation)))
{
//Per Martyn, use equation string, not named value. 7/17/2014 HN
cb.Items.Add(cs.ToDisplayString());
}
cb.Refresh();
cb.SelectedIndex = cb.FindString (v.cal_curve_equation.ToDisplayString());
}
public void FieldFiller(INCCAnalysisParams.CurveEquationVals cev)
{
LowerMassLimitTextBox.Value = cev.lower_mass_limit;
UpperMassLimitTextBox.Value = cev.upper_mass_limit;
LowerAlphaLimitTextBox.Value = known_alpha.lower_corr_factor_limit;
UpperAlphaLimitTextBox.Value = known_alpha.upper_corr_factor_limit;
ConventionalATextBox.Value = cev.a;
ConventionalBTextBox.Value = cev.b;
VarianceATextBox.Value = cev.var_a;
VarianceBTextBox.Value = cev.var_b;
CovarianceABTextBox.Value = cev.covar(Coeff.a, Coeff.b);
SigmaXTextBox.Value = cev.sigma_x;
}
public EqCoeffViewer(INCCAnalysisParams.CurveEquationVals coeff, INCCAnalysisParams.CurveEquation eq, CalibrationCurveList cclist)
{
InitializeComponent();
det = Integ.GetCurrentAcquireDetector();
Text += " for detector " + det.Id.DetectorName;
disprows = new List<DataLoad>();
CurveEquation = eq;
Coefficients = coeff;
CalcDataList = cclist;
BuildRep();
BuildRows();
BuildCurveCombo();
LowerMassLimitTextBox.Text = CalcDataList.LowerMassLimit.ToString("N4");
UpperMassLimitTextBox.Text = CalcDataList.UpperMassLimit.ToString("N4");
_reg = new Regex("[1-9][0-9]*\\.?[0-9]*([Ee][+-]?[0-9]+)?"); // reg ex for number test
}
public void CalibrationFieldFiller(INCCAnalysisParams.CurveEquationVals cev)
{
LowerMassLimitTextBox.Text = cev.lower_mass_limit.ToString("N3");
UpperMassLimitTextBox.Text = cev.upper_mass_limit.ToString("N3");
ATextBox.Text = cev.a.ToString("E6");
BTextBox.Text = cev.b.ToString("E6");
CTextBox.Text = cev.c.ToString("E6");
DTextBox.Text = cev.d.ToString("E6");
VarianceATextBox.Text = cev.var_a.ToString("E6");
VarianceBTextBox.Text = cev.var_b.ToString("E6");
VarianceCTextBox.Text = cev.var_c.ToString("E6");
VarianceDTextBox.Text = cev.var_d.ToString("E6");
CovarianceABTextBox.Text = cev.covar(Coeff.a, Coeff.b).ToString("E6");
CovarianceACTextBox.Text = cev.covar(Coeff.a, Coeff.c).ToString("E6");
CovarianceADTextBox.Text = cev.covar(Coeff.a, Coeff.d).ToString("E6");
CovarianceBCTextBox.Text = cev.covar(Coeff.b, Coeff.c).ToString("E6");
CovarianceBDTextBox.Text = cev.covar(Coeff.b, Coeff.d).ToString("E6");
CovarianceCDTextBox.Text = cev.covar(Coeff.c, Coeff.d).ToString("E6");
SigmaXTextBox.Text = cev.sigma_x.ToString("E6");
}
public IDDK5CollarItemData(INCCAnalysisParams.collar_combined_rec c, bool mod)
{
InitializeComponent();
col = c;
modified = mod;
K5TextBox.ToValidate = NumericTextBox.ValidateType.Double;
K5TextBox.NumberFormat = NumericTextBox.Formatter.E3;
K5ErrorTextBox.ToValidate = NumericTextBox.ValidateType.Double;
K5ErrorTextBox.NumberFormat = NumericTextBox.Formatter.E3;
K5TextBox.Value = col.collar.sample_corr_fact.v;
K5ErrorTextBox.Value = col.collar.sample_corr_fact.err;
for (int i = 0; i < INCCAnalysisParams.MAX_COLLAR_K5_PARAMETERS; i ++)
{
if (col.k5.k5[i] != null)
{
DataGridViewRow row = new DataGridViewRow();
row.CreateCells(dataGridView1);
dataGridView1.Rows.Add(new object[] { col.k5.k5_checkbox[i], col.k5.k5_label[i], col.k5.k5[i].v, col.k5.k5[i].err });
}
}
k5TotalTextBox.Value = total;
k5TotalErrTextBox.Value = totalerr;
}
internal static unsafe known_alpha_rec MoveKA(INCCSelector se, INCCAnalysisParams.INCCMethodDescriptor md)
{
INCCAnalysisParams.known_alpha_rec imr = (INCCAnalysisParams.known_alpha_rec)md;
known_alpha_rec m = new known_alpha_rec();
byte[] b = new byte[INCC.MAX_DETECTOR_ID_LENGTH];
char[] a = se.detectorid.ToCharArray(0, Math.Min(se.detectorid.Length, INCC.MAX_DETECTOR_ID_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.known_alpha_detector_id);
b = new byte[INCC.MAX_ITEM_TYPE_LENGTH];
a = se.material.ToCharArray(0, Math.Min(se.material.Length, INCC.MAX_ITEM_TYPE_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.known_alpha_item_type);
m.ka_a = imr.cev.a;
m.ka_b = imr.cev.b;
m.ka_var_a = imr.cev.var_a;
m.ka_var_b = imr.cev.var_b;
m.ka_covar_ab = imr.cev.covar(Coeff.a, Coeff.b);
m.ka_sigma_x = imr.cev.sigma_x;
m.ka_ring_ratio_a = imr.ring_ratio.a;
m.ka_ring_ratio_b = imr.ring_ratio.b;
m.ka_ring_ratio_c = imr.ring_ratio.c;
m.ka_ring_ratio_d = imr.ring_ratio.d;
m.ka_alpha_wt = imr.alpha_wt;
m.ka_rho_zero = imr.rho_zero;
m.ka_ring_ratio_equation = (double)imr.ring_ratio.cal_curve_equation;
m.ka_upper_mass_limit = imr.cev.upper_mass_limit;
m.ka_lower_mass_limit = imr.cev.lower_mass_limit;
m.ka_heavy_metal_corr_factor = imr.heavy_metal_corr_factor;
m.ka_heavy_metal_reference = imr.heavy_metal_reference;
m.ka_k = imr.k;
m.ka_known_alpha_type = (double)imr.known_alpha_type;
TransferUtils.CopyDbls(imr.dcl_mass, m.ka_dcl_mass);
TransferUtils.CopyDbls(imr.doubles, m.ka_doubles);
return m;
}
internal static unsafe de_mult_rec MoveDE(INCCSelector se, INCCAnalysisParams.INCCMethodDescriptor md)
{
INCCAnalysisParams.de_mult_rec imr = (INCCAnalysisParams.de_mult_rec)md;
de_mult_rec m = new de_mult_rec();
byte[] b = new byte[INCC.MAX_DETECTOR_ID_LENGTH];
char[] a = se.detectorid.ToCharArray(0, Math.Min(se.detectorid.Length, INCC.MAX_DETECTOR_ID_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.de_detector_id);
b = new byte[INCC.MAX_ITEM_TYPE_LENGTH];
a = se.material.ToCharArray(0, Math.Min(se.material.Length, INCC.MAX_ITEM_TYPE_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.de_item_type);
m.de_inner_ring_efficiency = imr.inner_ring_efficiency;
m.de_outer_ring_efficiency = imr.outer_ring_efficiency;
TransferUtils.CopyDbls(imr.neutron_energy, m.de_neutron_energy);
TransferUtils.CopyDbls(imr.detector_efficiency, m.de_detector_efficiency);
TransferUtils.CopyDbls(imr.inner_outer_ring_ratio, m.de_inner_outer_ring_ratio);
TransferUtils.CopyDbls(imr.relative_fission, m.de_relative_fission);
return m;
}
internal static unsafe curium_ratio_rec MoveCR(INCCSelector se, INCCAnalysisParams.INCCMethodDescriptor md)
{
INCCAnalysisParams.curium_ratio_rec imr = (INCCAnalysisParams.curium_ratio_rec)md;
curium_ratio_rec m = new curium_ratio_rec();
byte[] b = new byte[INCC.MAX_DETECTOR_ID_LENGTH];
char[] a = se.detectorid.ToCharArray(0, Math.Min(se.detectorid.Length, INCC.MAX_DETECTOR_ID_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.curium_ratio_detector_id);
b = new byte[INCC.MAX_ITEM_TYPE_LENGTH];
a = se.material.ToCharArray(0, Math.Min(se.material.Length, INCC.MAX_ITEM_TYPE_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.curium_ratio_item_type);
m.cr_a = imr.cev.a;
m.cr_b = imr.cev.b;
m.cr_c = imr.cev.c;
m.cr_d = imr.cev.d;
m.curium_ratio_equation = (byte)imr.cev.cal_curve_equation;
m.curium_ratio_type = NewToOldCRVariants(imr.curium_ratio_type);
m.cr_covar_ab = imr.cev.covar(Coeff.a, Coeff.b);
m.cr_covar_ac = imr.cev.covar(Coeff.a, Coeff.c);
m.cr_covar_ad = imr.cev.covar(Coeff.a, Coeff.d);
m.cr_covar_bc = imr.cev.covar(Coeff.b, Coeff.c);
m.cr_covar_bd = imr.cev.covar(Coeff.b, Coeff.d);
m.cr_covar_cd = imr.cev.covar(Coeff.c, Coeff.d);
m.cr_var_a = imr.cev.var_a;
m.cr_var_b = imr.cev.var_b;
m.cr_var_c = imr.cev.var_c;
m.cr_var_d = imr.cev.var_d;
m.cr_sigma_x = imr.cev.sigma_x;
m.cr_upper_mass_limit = imr.cev.upper_mass_limit;
m.cr_lower_mass_limit = imr.cev.lower_mass_limit;
return m;
}
internal static unsafe collar_rec MoveCO(INCCSelector se, INCCAnalysisParams.INCCMethodDescriptor md)
{
INCCAnalysisParams.collar_combined_rec imr = (INCCAnalysisParams.collar_combined_rec)md;
collar_rec m = new collar_rec();
byte[] b = new byte[INCC.MAX_ITEM_TYPE_LENGTH];
char[] a = se.material.ToCharArray(0, Math.Min(se.material.Length, INCC.MAX_ITEM_TYPE_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.collar_item_type);
m.col_a = imr.collar.cev.a;
m.col_b = imr.collar.cev.b;
m.col_c = imr.collar.cev.c;
m.col_d = imr.collar.cev.d;
m.collar_equation = (byte)imr.collar.cev.cal_curve_equation;
m.col_covar_ab = imr.collar.cev.covar(Coeff.a, Coeff.b);
m.col_covar_ac = imr.collar.cev.covar(Coeff.a, Coeff.c);
m.col_covar_ad = imr.collar.cev.covar(Coeff.a, Coeff.d);
m.col_covar_bc = imr.collar.cev.covar(Coeff.b, Coeff.c);
m.col_covar_bd = imr.collar.cev.covar(Coeff.b, Coeff.d);
m.col_covar_cd = imr.collar.cev.covar(Coeff.c, Coeff.d);
m.col_var_a = imr.collar.cev.var_a;
m.col_var_b = imr.collar.cev.var_b;
m.col_var_c = imr.collar.cev.var_c;
m.col_var_d = imr.collar.cev.var_d;
m.col_sigma_x = imr.collar.cev.sigma_x;
m.col_upper_mass_limit = imr.collar.cev.upper_mass_limit;
m.col_lower_mass_limit = imr.collar.cev.lower_mass_limit;
m.col_number_calib_rods = imr.collar.number_calib_rods;
m.col_sample_corr_fact = imr.collar.sample_corr_fact.v;
m.col_sample_corr_fact_err = imr.collar.sample_corr_fact.err;
m.col_u_mass_corr_fact_a = imr.collar.u_mass_corr_fact_a.v;
m.col_u_mass_corr_fact_a_err = imr.collar.u_mass_corr_fact_a.err;
m.col_u_mass_corr_fact_b = imr.collar.u_mass_corr_fact_b.v;
m.col_u_mass_corr_fact_b_err = imr.collar.u_mass_corr_fact_b.err;
m.collar_mode = (byte)(imr.collar.collar_mode ? 1 : 0);
byte[] bb = new byte[INCC.MAX_POISON_ROD_TYPES * INCC.MAX_ROD_TYPE_LENGTH];
int indx = 0;
for (int i = 0; i < INCC.MAX_POISON_ROD_TYPES; i++)
{
if (string.IsNullOrEmpty(imr.collar.poison_rod_type[i]))
{
char[] aa = imr.collar.poison_rod_type[i].ToCharArray(0, Math.Min(imr.collar.poison_rod_type[i].Length, INCC.MAX_ROD_TYPE_LENGTH));
Encoding.ASCII.GetBytes(aa, 0, aa.Length, bb, indx);
}
indx += 2;
}
TransferUtils.Copy(bb, 0, m.col_poison_rod_type, 0, INCC.MAX_POISON_ROD_TYPES * INCC.MAX_ROD_TYPE_LENGTH);
TransferUtils.CopyDbls(imr.collar.poison_absorption_fact, m.col_poison_absorption_fact);
CopyTuples(imr.collar.poison_rod_a, m.col_poison_rod_a, m.col_poison_rod_a_err, INCC.MAX_POISON_ROD_TYPES);
CopyTuples(imr.collar.poison_rod_b, m.col_poison_rod_b, m.col_poison_rod_b_err, INCC.MAX_POISON_ROD_TYPES);
CopyTuples(imr.collar.poison_rod_c, m.col_poison_rod_c, m.col_poison_rod_c_err, INCC.MAX_POISON_ROD_TYPES);
return m;
}
internal static unsafe collar_k5_rec MoveCK(INCCSelector se, INCCAnalysisParams.INCCMethodDescriptor md)
{
INCCAnalysisParams.collar_combined_rec imr = (INCCAnalysisParams.collar_combined_rec)md;
collar_k5_rec m = new collar_k5_rec();
byte[] b = new byte[INCC.MAX_ITEM_TYPE_LENGTH];
char[] a = se.material.ToCharArray(0, Math.Min(se.material.Length, INCC.MAX_ITEM_TYPE_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.collar_k5_item_type);
CopyTuples(imr.k5.k5, m.collar_k5, m.collar_k5_err, INCC.MAX_COLLAR_K5_PARAMETERS);
TransferUtils.CopyBoolsToInts(imr.k5.k5_checkbox, m.collar_k5_checkbox);
m.collar_k5_mode = (byte)(imr.k5.k5_mode ? 1 : 0);
byte[] bb = new byte[INCC.MAX_COLLAR_K5_PARAMETERS * INCC.MAX_K5_LABEL_LENGTH];
int indx = 0;
for (int i = 0; i < INCC.MAX_COLLAR_K5_PARAMETERS; i++)
{
char[] aa = imr.k5.k5_label[i].ToCharArray(0, Math.Min(imr.k5.k5_label[i].Length, INCC.MAX_K5_LABEL_LENGTH));
Encoding.ASCII.GetBytes(aa, 0, aa.Length, bb, indx);
indx += INCC.MAX_K5_LABEL_LENGTH;
}
TransferUtils.Copy(bb, 0, m.collar_k5_label, 0, INCC.MAX_COLLAR_K5_PARAMETERS * INCC.MAX_K5_LABEL_LENGTH);
return m;
}
void ApplyCoefficients(INCCAnalysisParams.CurveEquationVals coeff, CalibrationCurveList cclist)
{
INCCSelector sel = new INCCSelector(det.Id.DetectorId, Material);
AnalysisMethods lam;
bool found = N.App.DB.DetectorMaterialAnalysisMethods.TryGetValue(sel, out lam);
if (!found)
{
lam = new AnalysisMethods(sel);
}
if (!lam.HasMethod(AnalysisMethod)) // create it from scratch here ????
{
MessageBox.Show(string.Format("{0} method not specified for detector {1} and material {2}",
AnalysisMethod.FullName(), det.Id.DetectorId, Material),
"Coefficient File Ingester", MessageBoxButtons.OK);
return;
}
INCCAnalysisParams.INCCMethodDescriptor imd = lam.GetMethodParameters(AnalysisMethod);
switch (AnalysisMethod)
{
case AnalysisMethod.CalibrationCurve:
INCCAnalysisParams.cal_curve_rec c = (INCCAnalysisParams.cal_curve_rec)imd;
CopyCoefficients(coeff, c.cev);
c.cev.cal_curve_equation = CurveEquation;
c.cev.lower_mass_limit = cclist.LowerMassLimit;
c.cev.upper_mass_limit = cclist.UpperMassLimit;
c.dcl_mass = cclist.MassAsArray;
c.doubles = cclist.DoublesAsArray;
break;
case AnalysisMethod.KnownA:
INCCAnalysisParams.known_alpha_rec ka = (INCCAnalysisParams.known_alpha_rec)imd;
CopyCoefficients(coeff, ka.cev);
ka.cev.cal_curve_equation = CurveEquation;
ka.cev.lower_mass_limit = cclist.LowerMassLimit;
ka.cev.upper_mass_limit = cclist.UpperMassLimit;
ka.dcl_mass = cclist.MassAsArray;
ka.doubles = cclist.DoublesAsArray;
break;
case AnalysisMethod.AddASource:
INCCAnalysisParams.add_a_source_rec aas = (INCCAnalysisParams.add_a_source_rec)imd;
CopyCoefficients(coeff, aas.cev);
aas.cev.cal_curve_equation = CurveEquation;
aas.cev.lower_mass_limit = cclist.LowerMassLimit;
aas.cev.upper_mass_limit = cclist.UpperMassLimit;
aas.dcl_mass = cclist.MassAsArray;
aas.doubles = cclist.DoublesAsArray;
break;
case AnalysisMethod.Active:
INCCAnalysisParams.active_rec ac = (INCCAnalysisParams.active_rec)imd;
CopyCoefficients(coeff, ac.cev);
ac.cev.cal_curve_equation = CurveEquation;
ac.cev.lower_mass_limit = cclist.LowerMassLimit;
ac.cev.upper_mass_limit = cclist.UpperMassLimit;
ac.dcl_mass = cclist.MassAsArray;
ac.doubles = cclist.DoublesAsArray;
break;
}
imd.modified = true;
// ok save it now
N.App.DB.UpdateAnalysisMethod(sel, lam); // flush changes on internal map to the DB
MessageBox.Show(string.Format("Calibration data for analysis method {0} and material type {1} successfully stored in the database",
det.Id.DetectorId, Material),
"Coefficient File Ingester", MessageBoxButtons.OK);
}
internal static unsafe truncated_mult_rec MoveTM(INCCSelector se, INCCAnalysisParams.INCCMethodDescriptor md)
{
INCCAnalysisParams.truncated_mult_rec imr = (INCCAnalysisParams.truncated_mult_rec)md;
truncated_mult_rec m = new truncated_mult_rec();
byte[] b = new byte[INCC.MAX_DETECTOR_ID_LENGTH];
char[] a = se.detectorid.ToCharArray(0, Math.Min(se.detectorid.Length, INCC.MAX_DETECTOR_ID_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.truncated_mult_detector_id);
b = new byte[INCC.MAX_ITEM_TYPE_LENGTH];
a = se.material.ToCharArray(0, Math.Min(se.material.Length, INCC.MAX_ITEM_TYPE_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.truncated_mult_item_type);
m.tm_a = imr.a;
m.tm_b = imr.b;
m.tm_known_eff = (byte)(imr.known_eff ? 1 : 0);
m.tm_solve_eff = (byte)(imr.solve_eff ? 1 : 0);
return m;
}
internal static unsafe add_a_source_rec MoveAS(INCCSelector se, INCCAnalysisParams.INCCMethodDescriptor md)
{
INCCAnalysisParams.add_a_source_rec imr = (INCCAnalysisParams.add_a_source_rec)md;
add_a_source_rec m = new add_a_source_rec();
byte[] b = new byte[INCC.MAX_DETECTOR_ID_LENGTH];
char[] a = se.detectorid.ToCharArray(0, Math.Min(se.detectorid.Length, INCC.MAX_DETECTOR_ID_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.add_a_source_detector_id);
b = new byte[INCC.MAX_ITEM_TYPE_LENGTH];
a = se.material.ToCharArray(0, Math.Min(se.material.Length, INCC.MAX_ITEM_TYPE_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.add_a_source_item_type);
m.ad_a = imr.cev.a;
m.ad_b = imr.cev.b;
m.ad_c = imr.cev.c;
m.ad_d = imr.cev.d;
m.add_a_source_equation = (byte)imr.cev.cal_curve_equation;
m.ad_covar_ab = imr.cev.covar(Coeff.a, Coeff.b);
m.ad_covar_ac = imr.cev.covar(Coeff.a, Coeff.c);
m.ad_covar_ad = imr.cev.covar(Coeff.a, Coeff.d);
m.ad_covar_bc = imr.cev.covar(Coeff.b, Coeff.c);
m.ad_covar_bd = imr.cev.covar(Coeff.b, Coeff.d);
m.ad_covar_cd = imr.cev.covar(Coeff.c, Coeff.d);
m.ad_var_a = imr.cev.var_a;
m.ad_var_b = imr.cev.var_b;
m.ad_var_c = imr.cev.var_c;
m.ad_var_d = imr.cev.var_d;
m.ad_sigma_x = imr.cev.sigma_x;
m.ad_upper_mass_limit = imr.cev.upper_mass_limit;
m.ad_lower_mass_limit = imr.cev.lower_mass_limit;
TransferUtils.CopyDbls(imr.dcl_mass, m.ad_dcl_mass);
TransferUtils.CopyDbls(imr.doubles, m.ad_doubles);
TransferUtils.CopyDbls(imr.position_dzero, m.ad_position_dzero);
m.ad_cf_a = imr.cf.a;
m.ad_cf_b = imr.cf.b;
m.ad_cf_c = imr.cf.c;
m.ad_cf_d = imr.cf.d;
m.ad_dzero_avg = imr.dzero_avg;
m.ad_num_runs = imr.num_runs;
m.ad_tm_dbls_rate_upper_limit = imr.tm_dbls_rate_upper_limit;
m.ad_tm_weighting_factor = imr.tm_weighting_factor;
m.ad_use_truncated_mult = imr.use_truncated_mult ? 1 : 0;
b = new byte[INCC.DATE_TIME_LENGTH];
a = imr.dzero_ref_date.ToString("yy.MM.dd").ToCharArray();
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.ad_dzero_ref_date);
return m;
}
unsafe void CollarK5(INCCAnalysisParams.collar_combined_rec combined, collar_k5_rec collar_k5, ushort bonk)
{
combined.k5 = new INCCAnalysisParams.collar_k5_rec();
combined.k5.k5_mode = (collar_k5.collar_k5_mode != 0 ? true: false);
combined.k5.k5_item_type = TransferUtils.str(collar_k5.collar_k5_item_type, INCC.MAX_ITEM_TYPE_LENGTH);
combined.k5.k5 = Copy(collar_k5.collar_k5, collar_k5.collar_k5_err, INCC.MAX_COLLAR_K5_PARAMETERS);
combined.k5.k5_checkbox = TransferUtils.Copy(collar_k5.collar_k5_checkbox,INCC.MAX_COLLAR_K5_PARAMETERS);
for (int i = 0; i < INCC.MAX_COLLAR_K5_PARAMETERS; i++)
{
int index = i * INCC.MAX_K5_LABEL_LENGTH;
combined.k5.k5_label[i] = TransferUtils.str(collar_k5.collar_k5_label + index, INCC.MAX_K5_LABEL_LENGTH);
}
mlogger.TraceEvent(LogLevels.Verbose, 34214, " -- Collar k5 has mode {0} and is ready to be bonked", combined.k5.k5_mode);
}
static void CalCurveDBSnock(INCCAnalysisParams.CurveEquationVals cev, DataRow dr)
{
if (dr == null) return;
cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)(DB.Utils.DBInt32(dr["cal_curve_equation"]));
cev.a = DB.Utils.DBDouble(dr["a"]);
cev.b = DB.Utils.DBDouble(dr["b"]);
cev.c = DB.Utils.DBDouble(dr["c"]);
cev.d = DB.Utils.DBDouble(dr["d"]);
cev.var_a = DB.Utils.DBDouble(dr["var_a"]);
cev.var_b = DB.Utils.DBDouble(dr["var_b"]);
cev.var_c = DB.Utils.DBDouble(dr["var_c"]);
cev.var_d = DB.Utils.DBDouble(dr["var_d"]);
cev.setcovar(Coeff.a, Coeff.b, DB.Utils.DBDouble(dr["covar_ab"]));
cev.setcovar(Coeff.a, Coeff.c, DB.Utils.DBDouble(dr["covar_ac"]));
cev.setcovar(Coeff.a, Coeff.d, DB.Utils.DBDouble(dr["covar_ad"]));
cev.setcovar(Coeff.b, Coeff.c, DB.Utils.DBDouble(dr["covar_bc"]));
cev.setcovar(Coeff.b, Coeff.d, DB.Utils.DBDouble(dr["covar_bd"]));
cev.setcovar(Coeff.c, Coeff.d, DB.Utils.DBDouble(dr["covar_cd"]));
cev.sigma_x = DB.Utils.DBDouble(dr["sigma_x"]);
cev.upper_mass_limit = DB.Utils.DBDouble(dr["upper_mass_limit"]);
cev.lower_mass_limit = DB.Utils.DBDouble(dr["lower_mass_limit"]);
}
unsafe void CollarDet(INCCAnalysisParams.collar_combined_rec combined, collar_detector_rec collar_detector, ushort bonk)
{
combined.collar_det = new INCCAnalysisParams.collar_detector_rec();
combined.collar_det.collar_mode = (collar_detector.collar_detector_mode == 0 ? false : true);
combined.collar_det.reference_date = INCC.DateFrom(TransferUtils.str(collar_detector.col_reference_date, INCC.DATE_TIME_LENGTH));
combined.collar_det.relative_doubles_rate = collar_detector.col_relative_doubles_rate;
mlogger.TraceEvent(LogLevels.Verbose, 34212, " -- Collar det has mode {0} {1}", combined.collar_det.collar_mode, bonk);
}
private static ushort NewToOldCRVariants(INCCAnalysisParams.CuriumRatioVariant id)
{
ushort isdh = INCC.IDC_USE_DOUBLES;
switch (id)
{
case INCCAnalysisParams.CuriumRatioVariant.UseDoubles:
isdh = INCC.IDC_USE_DOUBLES;
break;
case INCCAnalysisParams.CuriumRatioVariant.UseSingles:
isdh = INCC.IDC_USE_SINGLES;
break;
case INCCAnalysisParams.CuriumRatioVariant.UseAddASourceDoubles:
isdh = INCC.IDC_USE_ADD_A_SOURCE_DOUBLES;
break;
}
return isdh;
}
private void CheckBox_fandango(Boolean ischecked, INCCAnalysisParams.KnownAlphaVariant known_alpha_type)
{
known_alpha.modified |= (known_alpha.known_alpha_type != known_alpha_type);
known_alpha.known_alpha_type = known_alpha_type;
}
internal static unsafe known_m_rec MoveKM(INCCSelector se, INCCAnalysisParams.INCCMethodDescriptor md)
{
INCCAnalysisParams.known_m_rec imr = (INCCAnalysisParams.known_m_rec)md;
known_m_rec m = new known_m_rec();
byte[] b = new byte[INCC.MAX_DETECTOR_ID_LENGTH];
char[] a = se.detectorid.ToCharArray(0, Math.Min(se.detectorid.Length, INCC.MAX_DETECTOR_ID_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.known_m_detector_id);
b = new byte[INCC.MAX_ITEM_TYPE_LENGTH];
a = se.material.ToCharArray(0, Math.Min(se.material.Length, INCC.MAX_ITEM_TYPE_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.known_m_item_type);
m.km_b = imr.b;
m.km_c = imr.c;
m.km_sf_rate = imr.sf_rate;
m.km_sigma_x = imr.sigma_x;
m.km_upper_mass_limit = imr.upper_mass_limit;
m.km_lower_mass_limit = imr.lower_mass_limit;
m.km_vi1 = imr.vi1;
m.km_vi2 = imr.vi2;
m.km_vs1 = imr.vs1;
m.km_vs2 = imr.vs2;
return m;
}
internal static unsafe cal_curve_rec MoveCC(INCCSelector se, INCCAnalysisParams.INCCMethodDescriptor md)
{
INCCAnalysisParams.cal_curve_rec imr = (INCCAnalysisParams.cal_curve_rec)md;
cal_curve_rec m = new cal_curve_rec();
byte[] b = new byte[INCC.MAX_DETECTOR_ID_LENGTH];
char[] a = se.detectorid.ToCharArray(0, Math.Min(se.detectorid.Length, INCC.MAX_DETECTOR_ID_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.cal_curve_detector_id);
b = new byte[INCC.MAX_ITEM_TYPE_LENGTH];
a = se.material.ToCharArray(0, Math.Min(se.material.Length, INCC.MAX_ITEM_TYPE_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.cal_curve_item_type);
m.cc_a = imr.cev.a;
m.cc_b = imr.cev.b;
m.cc_c = imr.cev.c;
m.cc_d = imr.cev.d;
m.cc_cal_curve_type = (double)imr.CalCurveType;
m.cc_covar_ab = imr.cev.covar(Coeff.a, Coeff.b);
m.cc_covar_ac = imr.cev.covar(Coeff.a, Coeff.c);
m.cc_covar_ad = imr.cev.covar(Coeff.a, Coeff.d);
m.cc_covar_bc = imr.cev.covar(Coeff.b, Coeff.c);
m.cc_covar_bd = imr.cev.covar(Coeff.b, Coeff.d);
m.cc_covar_cd = imr.cev.covar(Coeff.c, Coeff.d);
m.cc_var_a = imr.cev.var_a;
m.cc_var_b = imr.cev.var_b;
m.cc_var_c = imr.cev.var_c;
m.cc_var_d = imr.cev.var_d;
m.cc_sigma_x = imr.cev.sigma_x;
m.cc_upper_mass_limit = imr.cev.upper_mass_limit;
m.cc_lower_mass_limit = imr.cev.lower_mass_limit;
m.cc_heavy_metal_corr_factor = imr.heavy_metal_corr_factor;
m.cc_heavy_metal_reference = imr.heavy_metal_reference;
m.cc_cal_curve_type = (double)imr.CalCurveType;
m.cc_percent_u235 = imr.percent_u235;
TransferUtils.CopyDbls(imr.dcl_mass, m.cc_dcl_mass);
TransferUtils.CopyDbls(imr.doubles, m.cc_doubles);
return m;
}
internal static unsafe multiplicity_rec MoveMult(INCCSelector se, INCCAnalysisParams.INCCMethodDescriptor md)
{
INCCAnalysisParams.multiplicity_rec imr = (INCCAnalysisParams.multiplicity_rec)md;
multiplicity_rec mr = new multiplicity_rec();
byte[] b = new byte[INCC.MAX_DETECTOR_ID_LENGTH];
char[] a = se.detectorid.ToCharArray(0, Math.Min(se.detectorid.Length, INCC.MAX_DETECTOR_ID_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, mr.multiplicity_detector_id);
b = new byte[INCC.MAX_ITEM_TYPE_LENGTH];
a = se.material.ToCharArray(0, Math.Min(se.material.Length, INCC.MAX_ITEM_TYPE_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, mr.multiplicity_item_type);
mr.mul_a = imr.a;
mr.mul_b = imr.b;
mr.mul_c = imr.c;
mr.mul_vi1 = imr.vi1;
mr.mul_vi2 = imr.vi2;
mr.mul_vi3 = imr.vi3;
mr.mul_vs1 = imr.vs1;
mr.mul_vs2 = imr.vs2;
mr.mul_vs3 = imr.vs3;
mr.mul_alpha_weight = imr.alpha_weight;
mr.mul_sf_rate = imr.sf_rate;
mr.mul_sigma_x = imr.sigma_x;
mr.mul_solve_efficiency = (byte)imr.solve_efficiency;
return mr;
}
internal static unsafe collar_detector_rec MoveCD(INCCSelector se, INCCAnalysisParams.INCCMethodDescriptor md)
{
INCCAnalysisParams.collar_combined_rec imr = (INCCAnalysisParams.collar_combined_rec)md;
collar_detector_rec m = new collar_detector_rec();
byte[] b = new byte[INCC.MAX_DETECTOR_ID_LENGTH];
char[] a = se.detectorid.ToCharArray(0, Math.Min(se.detectorid.Length, INCC.MAX_DETECTOR_ID_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.collar_detector_id);
b = new byte[INCC.MAX_ITEM_TYPE_LENGTH];
a = se.material.ToCharArray(0, Math.Min(se.material.Length, INCC.MAX_ITEM_TYPE_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.collar_detector_item_type);
m.collar_detector_mode = (byte)(imr.collar_det.collar_mode ? 1 : 0);
b = new byte[INCC.DATE_TIME_LENGTH];
a = imr.collar_det.reference_date.ToString("yy.MM.dd").ToCharArray();
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.col_reference_date);
m.col_relative_doubles_rate = imr.collar_det.relative_doubles_rate;
return m;
}
unsafe void CollarParm(INCCAnalysisParams.collar_combined_rec combined, collar_rec collar, ushort bonk)
{
combined.collar = new INCCAnalysisParams.collar_rec();
combined.collar.cev.lower_mass_limit = collar.col_lower_mass_limit;
combined.collar.cev.upper_mass_limit = collar.col_upper_mass_limit;
combined.collar.cev.a = collar.col_a;
combined.collar.cev.b = collar.col_b;
combined.collar.cev.c = collar.col_c;
combined.collar.cev.d = collar.col_d;
combined.collar.cev.var_a = collar.col_var_a;
combined.collar.cev.var_b = collar.col_var_b;
combined.collar.cev.var_c = collar.col_var_c;
combined.collar.cev.var_d = collar.col_var_d;
combined.collar.cev.setcovar(Coeff.a, Coeff.b, collar.col_covar_ab);
combined.collar.cev._covar[0, 2] = collar.col_covar_ac;
combined.collar.cev._covar[0, 3] = collar.col_covar_ad;
combined.collar.cev._covar[1, 2] = collar.col_covar_bc;
combined.collar.cev._covar[1, 3] = collar.col_covar_bd;
combined.collar.cev._covar[2, 3] = collar.col_covar_cd;
combined.collar.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)collar.collar_equation;
combined.collar.cev.sigma_x = collar.col_sigma_x;
combined.collar.poison_absorption_fact = TransferUtils.Copy(collar.col_poison_absorption_fact, INCC.MAX_POISON_ROD_TYPES);
combined.collar.poison_rod_a = Copy(collar.col_poison_rod_a, collar.col_poison_rod_a_err, INCC.MAX_POISON_ROD_TYPES);
combined.collar.poison_rod_b = Copy(collar.col_poison_rod_b, collar.col_poison_rod_b_err, INCC.MAX_POISON_ROD_TYPES);
combined.collar.poison_rod_c = Copy(collar.col_poison_rod_c, collar.col_poison_rod_c_err, INCC.MAX_POISON_ROD_TYPES);
combined.collar.collar_mode = (collar.collar_mode == 0 ? false : true);
combined.collar.u_mass_corr_fact_a.v = collar.col_u_mass_corr_fact_a;
combined.collar.u_mass_corr_fact_a.err = collar.col_u_mass_corr_fact_a_err;
combined.collar.u_mass_corr_fact_b.v = collar.col_u_mass_corr_fact_b;
combined.collar.u_mass_corr_fact_b.err = collar.col_u_mass_corr_fact_b_err;
combined.collar.sample_corr_fact.v = collar.col_sample_corr_fact;
combined.collar.sample_corr_fact.err = collar.col_sample_corr_fact_err;
combined.collar.number_calib_rods = (int)collar.col_number_calib_rods;
for (int i = 0; i < INCC.MAX_POISON_ROD_TYPES; i++)
{
int index = i * INCC.MAX_ROD_TYPE_LENGTH;
combined.collar.poison_rod_type[i] = TransferUtils.str(collar.col_poison_rod_type + index, INCC.MAX_ROD_TYPE_LENGTH);
}
mlogger.TraceEvent(LogLevels.Verbose, 34213, " -- Collar params has mode {0} {1}", combined.collar.collar_mode, bonk);
}
void CopyCoefficients(INCCAnalysisParams.CurveEquationVals src, INCCAnalysisParams.CurveEquationVals tgt)
{
tgt.a = src.a;
tgt.b = src.b;
tgt.c = src.c;
tgt.d = src.d;
tgt.var_a = src.var_a;
tgt.var_b = src.var_b;
tgt.var_c = src.var_c;
tgt.var_d = src.var_d;
tgt.setcovar(Coeff.a, Coeff.b, src.covar(Coeff.a, Coeff.b));
tgt.setcovar(Coeff.a, Coeff.c, src.covar(Coeff.a, Coeff.c));
tgt.setcovar(Coeff.a, Coeff.d, src.covar(Coeff.a, Coeff.d));
tgt.setcovar(Coeff.b, Coeff.c, src.covar(Coeff.b, Coeff.c));
tgt.setcovar(Coeff.b, Coeff.d, src.covar(Coeff.b, Coeff.d));
tgt.setcovar(Coeff.c, Coeff.d, src.covar(Coeff.c, Coeff.d));
}
public void CrossReferenceFieldFiller(INCCAnalysisParams.collar_combined_rec col)
{
MaterialTypeComboBox.SelectedIndex = MaterialTypeComboBox.FindStringExact(mp.acq.item_type)>=0?MaterialTypeComboBox.FindStringExact(mp.acq.item_type):0;
ModeComboBox.SelectedIndex = Convert.ToInt32(col.collar_det.collar_mode);
RelativeDoublesRateTextBox.Value = col.collar_det.relative_doubles_rate;
ReferenceDateTimePicker.Value = col.collar_det.reference_date;
poison = NCC.CentralizedState.App.DB.PoisonRods.GetList();
SetHelp();
}
internal static unsafe active_mult_rec MoveAM(INCCSelector se, INCCAnalysisParams.INCCMethodDescriptor md)
{
INCCAnalysisParams.active_mult_rec imr = (INCCAnalysisParams.active_mult_rec)md;
active_mult_rec m = new active_mult_rec();
byte[] b = new byte[INCC.MAX_DETECTOR_ID_LENGTH];
char[] a = se.detectorid.ToCharArray(0, Math.Min(se.detectorid.Length, INCC.MAX_DETECTOR_ID_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.active_mult_detector_id);
b = new byte[INCC.MAX_ITEM_TYPE_LENGTH];
a = se.material.ToCharArray(0, Math.Min(se.material.Length, INCC.MAX_ITEM_TYPE_LENGTH));
Encoding.ASCII.GetBytes(a, 0, a.Length, b, 0);
TransferUtils.Copy(b, m.active_mult_item_type);
m.am_vf1 = imr.vf1;
m.am_vf2 = imr.vf2;
m.am_vf3 = imr.vf3;
m.am_vt1 = imr.vt1;
m.am_vt2 = imr.vt2;
m.am_vt3 = imr.vt3;
return m;
}
