private void MaterialTypeComboBox_SelectedIndexChanged(object sender, EventArgs e)
{
acq.item_type = (string)((ComboBox)sender).SelectedItem;
INCCSelector sel = new INCCSelector(acq.detector_id, acq.item_type);
AnalysisMethods lam;
bool found = NC.App.DB.DetectorMaterialAnalysisMethods.TryGetValue(sel, out lam);
if (found)
{
am = new AnalysisMethods(sel);
am.CopySettings(lam);
ActivePassiveCheckBox.Checked = am.choices[(int)AnalysisMethod.ActivePassive];
ActiveCalCurveCheckBox.Checked = am.choices[(int)AnalysisMethod.Active];
ActiveMultCheckBox.Checked = am.choices[(int)AnalysisMethod.ActiveMultiplicity];
CollarCheckBox.Checked = am.choices[(int)AnalysisMethod.Collar];
PassiveCalCurveCheckBox.Checked = am.choices[(int)AnalysisMethod.CalibrationCurve];
KnownAlphaCheckBox.Checked = am.choices[(int)AnalysisMethod.KnownA];
KnownMCheckBox.Checked = am.choices[(int)AnalysisMethod.KnownM];
PassiveMultiplicityCheckBox.Checked = am.choices[(int)AnalysisMethod.Multiplicity];
AddASourceCheckBox.Checked = am.choices[(int)AnalysisMethod.AddASource];
CuRatioCheckBox.Checked = am.choices[(int)AnalysisMethod.CuriumRatio];
TruncatedMultCheckBox.Checked = am.choices[(int)AnalysisMethod.TruncatedMultiplicity];
collaractive();
}
else
{
// create an AM marked None and insert in Map here, set modified flag
am = new AnalysisMethods(sel);
NC.App.DB.DetectorMaterialAnalysisMethods.Add(sel, am);
am.modified = true;
}
}
private void MaterialTypeComboBox_SelectedIndexChanged(object sender, EventArgs e)
{
acq.item_type = (string)((ComboBox)sender).SelectedItem;
INCCSelector sel = new INCCSelector(acq.detector_id, acq.item_type);
AnalysisMethods lam;
bool found = NC.App.DB.DetectorMaterialAnalysisMethods.TryGetValue(sel, out lam);
if (found)
{
am = new AnalysisMethods(sel);
am.CopySettings(lam);
ActivePassiveCheckBox.Checked = am.choices[(int)AnalysisMethod.ActivePassive];
ActiveCalCurveCheckBox.Checked = am.choices[(int)AnalysisMethod.Active];
ActiveMultCheckBox.Checked = am.choices[(int)AnalysisMethod.ActiveMultiplicity];
CollarAmLiCheckBox.Checked = am.choices[(int)AnalysisMethod.CollarAmLi] && (acq.collar_mode == (int)CollarType.AmLiThermal || acq.collar_mode == (int)CollarType.AmLiFast);
CollarCfCheckBox.Checked = am.choices[(int)AnalysisMethod.CollarCf] && (acq.collar_mode == (int)CollarType.CfThermal || acq.collar_mode == (int)CollarType.CfFast);
PassiveCalCurveCheckBox.Checked = am.choices[(int)AnalysisMethod.CalibrationCurve];
KnownAlphaCheckBox.Checked = am.choices[(int)AnalysisMethod.KnownA];
KnownMCheckBox.Checked = am.choices[(int)AnalysisMethod.KnownM];
PassiveMultiplicityCheckBox.Checked = am.choices[(int)AnalysisMethod.Multiplicity];
AddASourceCheckBox.Checked = am.choices[(int)AnalysisMethod.AddASource];
CuRatioCheckBox.Checked = am.choices[(int)AnalysisMethod.CuriumRatio];
TruncatedMultCheckBox.Checked = am.choices[(int)AnalysisMethod.TruncatedMultiplicity];
collaractive();
}
else
{
// create an AM marked None and insert in Map here, set modified flag
am = new AnalysisMethods(sel);
NC.App.DB.DetectorMaterialAnalysisMethods.Add(sel, am);
am.modified = 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_;
}
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_;
}
private void FieldFiller()
{
// Populate the UI fields with values from the local AcquireParameters object
UseCurrentCalibCheckBox.Checked = true;
ReplaceOriginalCheckBox.Checked = false;
QCTestsCheckBox.Checked = ah.ap.qc_tests;
PrintResultsCheckBox.Checked = ah.ap.print;
CommentAtEndCheckBox.Checked = ah.ap.ending_comment;
CommentTextBox.Text = ah.ap.comment;
DeclaredMassTextBox.Text = ah.ap.mass.ToString("F3");
NormConst.Text = norm.v.ToString("F4");
NormConstErr.Text = norm.err.ToString("F4");
dateTimePicker1.Value = new DateTime(meas.MeasDate.Ticks);
InventoryChangeCodeComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in N.App.DB.InvChangeCodes.GetList())
{
InventoryChangeCodeComboBox.Items.Add(desc.Name);
}
IOCodeComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in N.App.DB.IOCodes.GetList())
{
IOCodeComboBox.Items.Add(desc.Name);
}
ItemIdComboBox.Items.Clear();
foreach (ItemId id in N.App.DB.ItemIds.GetList())
{
ItemIdComboBox.Items.Add(id.item);
}
StratumIdComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in N.App.DB.Stratums.GetList())
{
StratumIdComboBox.Items.Add(desc.Name);
}
StratumIdComboBox.SelectedItem = null;
MaterialTypeComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in N.App.DB.Materials.GetList())
{
MaterialTypeComboBox.Items.Add(desc.Name);
}
MaterialTypeComboBox.SelectedItem = ah.ap.item_type;
StratumIdComboBox.SelectedItem = ah.ap.stratum_id.Name;
InventoryChangeCodeComboBox.SelectedItem = ah.ap.inventory_change_code;
IOCodeComboBox.SelectedItem = ah.ap.io_code;
ItemIdComboBox.SelectedItem = ah.ap.item_id;
am = Integ.GetMethodSelections(ah.ap);
if (am != null)
{
if (am.Has(AnalysisMethod.CuriumRatio))
{
IsotopicsBtn.Enabled = false; BackgroundBtn.Enabled = false;
}
}
}
public IDDHeavyMetalItemData(AnalysisMethods ams_, ItemId item)
{
InitializeComponent();
umass = item.declaredUMass;
length = item.length;
DeclaredUMassTextBox.Text = umass.ToString("F3");
LengthTextBox.Text = length.ToString("F3");
Integ.GetCurrentAcquireDetectorPair(ref acq, ref det);
}
public IDDHeavyMetalItemData(AnalysisMethods ams_, ItemId item)
{
InitializeComponent();
umass = item.declaredUMass;
length = item.length;
DeclaredUMassTextBox.Text = umass.ToString("F3");
LengthTextBox.Text = length.ToString("F3");
Integ.GetCurrentAcquireDetectorPair(ref acq, ref det);
}
// stub, TBD
public void UpdateAnalysisMethodResults(string detname, string mat, DB.AnalysisMethodSpecifiers db = null)
{
if (db == null)
{
db = new DB.AnalysisMethodSpecifiers();
}
var res = // this finds the am for the given detector and acquire type
from am in this.DetectorMaterialAnalysisMethods
where (am.Key.detectorid.Equals(detname, StringComparison.OrdinalIgnoreCase) &&
am.Key.material.Equals(mat, StringComparison.OrdinalIgnoreCase))
select am;
if (res.Count() > 0) // now execute the select expression and test the result for existence
{
KeyValuePair <INCCSelector, AnalysisMethods> kv = res.First();
AnalysisMethods sam = kv.Value; // the descriptor instance
IEnumerator iter = kv.Value.GetMethodEnumerator();
while (iter.MoveNext())
{
System.Tuple <AnalysisMethod, INCCAnalysisParams.INCCMethodDescriptor> md = (System.Tuple <AnalysisMethod, INCCAnalysisParams.INCCMethodDescriptor>)iter.Current;
if (md.Item2 == null) // case from INCC5 transfer missing params, reflects file write bugs in INCC5 code
{
NC.App.Pest.logger.TraceEvent(LogLevels.Warning, 34029, "Missing {0}'s INCC {1} method parameters, skipping to next entry", detname, md.Item1.ToString());
continue;
}
NC.App.Pest.logger.TraceEvent(LogLevels.Verbose, 34030, "Updating <{0},{1}>: {2}", detname, mat, md.Item2.GetType().Name);
DB.ElementList parms = null;
switch (md.Item1)
{
case AnalysisMethod.KnownA:
case AnalysisMethod.CalibrationCurve:
case AnalysisMethod.KnownM:
case AnalysisMethod.Multiplicity:
case AnalysisMethod.TruncatedMultiplicity:
case AnalysisMethod.AddASource:
case AnalysisMethod.CuriumRatio:
case AnalysisMethod.Active:
case AnalysisMethod.ActivePassive:
case AnalysisMethod.Collar:
case AnalysisMethod.ActiveMultiplicity:
parms = ((ParameterBase)md.Item2).ToDBElementList();
break;
default:
break;
}
if (parms != null)
{
db.UpdateCalib(detname, mat, md.Item2.GetType().Name, parms); // det, mat, amid, params
}
}
}
}
public void UpdateAnalysisMethod(INCCSelector sel, AnalysisMethods ams)
{
DB.AnalysisMethodSpecifiers db = new DB.AnalysisMethodSpecifiers();
if (ams.modified)
{
UpdateAnalysisMethods(sel, ams, db);
}
UpdateAnalysisMethodSpecifics(sel.detectorid, sel.material, db);
}
private void OKBtn_Click(object sender, EventArgs e)
{
AnalysisMethods am = Integ.GetMethodSelections(ah.ap);
if (am != null)
{
bool isCollar = Integ.GetMethodSelections(Integ.GetCurrentAcquireParams()).Has(AnalysisMethod.CollarAmLi) || Integ.GetMethodSelections(Integ.GetCurrentAcquireParams()).Has(AnalysisMethod.CollarCf);
if (string.IsNullOrEmpty(ItemIdComboBox.Text))
{
MessageBox.Show("You must enter an item id for this assay.", "ERROR");
DialogResult = DialogResult.Abort;
}
else if (!isCollar)
{
// save/update item id changes only when user selects OK
ItemId Cur = NC.App.DB.ItemIds.Get(ah.ap.item_id);
Cur.IsoApply(NC.App.DB.Isotopics.Get(ah.ap.isotopics_id)); // apply the iso dates to the item
NC.App.DB.ItemIds.Set(); // writes any new or modified item ids to the DB
NC.App.DB.ItemIds.Refresh(); // save and update the in-memory item list
bool ocntinue = GetAdditionalParameters();
if (ocntinue && (ah.OKButton_Click(sender, e) == DialogResult.OK))
{
Visible = false;
// Add strata update to measurement object. HN 9.23.2015
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
Close();
}
DialogResult = DialogResult.None;
}
else
{
//Collar
// save/update item id changes only when user selects OK
ItemId Cur = NC.App.DB.ItemIds.Get(ah.ap.item_id);
Cur.IsoApply(NC.App.DB.Isotopics.Get(ah.ap.isotopics_id)); // apply the iso dates to the item
NC.App.DB.ItemIds.Set(); // writes any new or modified item ids to the DB
NC.App.DB.ItemIds.Refresh(); // save and update the in-memory item list
DialogResult = DialogResult.OK;
Close();
}
}
else
{
MessageBox.Show(string.Format("No analysis methods specified for detector {0} and material {1}", ah.ap.detector_id, ah.ap.item_type),
"Verification", MessageBoxButtons.OK);
}
}
private bool GetAdditionalParameters()
{
bool res = false;
AnalysisMethods am = Integ.GetMethodSelections(ah.ap);
if (am != null)
{
DialogResult dlgres = DialogResult.OK;
// if Verif + cal curve get U235 percent/get heavy metal data
if (am.Has(AnalysisMethod.CalibrationCurve))
{
INCCAnalysisParams.cal_curve_rec cal_curve = (INCCAnalysisParams.cal_curve_rec)am.GetMethodParameters(AnalysisMethod.CalibrationCurve);
if (cal_curve.CalCurveType == INCCAnalysisParams.CalCurveType.U)
{
dlgres = (new IDDPercentU235(am, cal_curve).ShowDialog());
}
else if (cal_curve.CalCurveType == INCCAnalysisParams.CalCurveType.HM)
{
dlgres = (new IDDHeavyMetalItemData(am, ah.ap.ItemId).ShowDialog());
}
}
// if Verif + (cal curve or KA) get heavy metal data
if (am.Has(AnalysisMethod.KnownA))
{
INCCAnalysisParams.known_alpha_rec ka = (INCCAnalysisParams.known_alpha_rec)am.GetMethodParameters(AnalysisMethod.KnownA);
if (ka.known_alpha_type == INCCAnalysisParams.KnownAlphaVariant.HeavyMetalCorrection)
{
dlgres = (new IDDHeavyMetalItemData(am, ah.ap.ItemId).ShowDialog());
}
}
// if Verif + collar get collar data
if (am.Has(AnalysisMethod.CollarAmLi))
{
dlgres = (new IDDCollarData().ShowDialog());
}
// if Verif + curium ratio, get cm_pu_ratio w dlg;
if (am.Has(AnalysisMethod.CuriumRatio))
{
dlgres = (new IDDCmPuRatio(ah.ap).ShowDialog());
}
res = (dlgres == DialogResult.OK);
}
else
{
MessageBox.Show(string.Format("No analysis methods specified for detector {0} and material {1}", ah.ap.detector_id, ah.ap.item_type),
"Verification", MessageBoxButtons.OK);
}
return(res);
}
private void AcquireVerificationClick(object sender, RoutedEventArgs e)
{
AcquireParameters ap = Integ.GetCurrentAcquireParams();
Detector det = new Detector();
INCCAnalysisParams.collar_combined_rec parms = new INCCAnalysisParams.collar_combined_rec();
Integ.GetCurrentAcquireDetectorPair(ref ap, ref det);
NormParameters npp = Integ.GetCurrentNormParams(det);
AnalysisMethods am = Integ.GetMethodSelections(ap);
if (am != null)
{
if (Integ.GetMethodSelections(det.Id.DetectorId, ap.ItemId.material).Has(AnalysisMethod.CollarAmLi))
{
IDDAcquireAssay f = new IDDAcquireAssay();
DialogResult result = f.ShowDialog();
f.Close();
if (result == System.Windows.Forms.DialogResult.OK)
{
IDDCollarItemData data = new IDDCollarItemData();
result = data.ShowDialog();
data.Close();
}
if (result == System.Windows.Forms.DialogResult.OK)
{
IDDK5CollarItemData k5 = new IDDK5CollarItemData(parms, true);
result = k5.ShowDialog();
k5.Close();
}
if (result == System.Windows.Forms.DialogResult.OK)
{
IDDCollarAcquire dlg = new IDDCollarAcquire(npp);
dlg.ShowDialog();
}
}
else
{
IDDAcquireAssay f = new IDDAcquireAssay();
f.ShowDialog();
}
}
else
{
System.Windows.Forms.MessageBox.Show("You must define at least one analysis method.", "ERROR");
}
}
public IDDCollarAcquire(NormParameters npp)
{
InitializeComponent();
ap = Integ.GetCurrentAcquireParams();
col = new INCCAnalysisParams.collar_combined_rec();
ah = new AcquireHandlers();
ah.mo = AssaySelector.MeasurementOption.verification;
Text += " for detector " + ah.det.Id.DetectorName;
//ableTermControls();
Detector d= new Detector();
Integ.GetCurrentAcquireDetectorPair(ref ap, ref d);
npp.CopyTo(norm);
Integ.BuildMeasurement(ap, d, AssaySelector.MeasurementOption.verification);
am = Integ.GetMethodSelections(ah.ap);
// Main window checks if Collar is defined for material type. No check needed here.
FillForm();
}
public AnalyserViewModel(Dictionary <int, MouseFrameViewModel> frames, IWhiskerVideo video)
{
Video = video;
Frames = frames;
MaxIndex = Frames.Count - 1;
bool hasNosePoint = frames[0].Model.Whiskers.Any(x => x.WhiskerId == -1);
bool hasOrientationPoint = frames[0].Model.Whiskers.Any(x => x.WhiskerId == 0);
bool hasWhiskers = frames[0].Model.Whiskers.Any(x => !x.IsGenericPoint);
AnalysisMethods.Add(new None());
if (hasNosePoint)
{
AnalysisMethods.Add(new NoseDisplacementViewModel(this));
if (hasOrientationPoint)
{
AnalysisMethods.Add(new HeadOrientationViewModel(this));
if (hasWhiskers)
{
AnalysisMethods.Add(new WhiskerSpreadViewModel(this));
}
}
}
if (hasWhiskers)
{
AnalysisMethods.Add(new WhiskerCurvatureViewModel(this));
AnalysisMethods.Add(new WhiskerAngleViewModel(this));
AnalysisMethods.Add(new WhiskerAngularVelocityViewModel(this));
AnalysisMethods.Add(new WhiskerFrequencyViewModel(this));
AnalysisMethods.Add(new WhiskerMeanOffsetViewModel(this));
AnalysisMethods.Add(new WhiskerAmplitudeViewModel(this));
AnalysisMethods.Add(new WhiskerProtractionRetractionViewModel(this));
}
if (hasWhiskers || hasNosePoint)
{
AnalysisMethods.Add(new WhiskerVelocityViewModel(this));
}
AnalysisMethods.Add(new AnalyseEverythingViewModel(this));
SelectedMethod = AnalysisMethods.First();
}
public void UpdateAnalysisMethods(INCCSelector sel, AnalysisMethods am, DB.AnalysisMethodSpecifiers db = null)
{
if (db == null)
{
db = new DB.AnalysisMethodSpecifiers();
}
DB.ElementList saParams;
saParams = am.ToDBElementList();
if (!db.Update(sel.detectorid, sel.material, saParams)) // am not there, so add it
{
NC.App.Pest.logger.TraceEvent(LogLevels.Verbose, 34027, "Failed to update analysis method spec for " + sel.ToString());
}
else
{
NC.App.Pest.logger.TraceEvent(LogLevels.Verbose, 34026, "Updated/created analysis method spec for " + sel.ToString());
}
am.modified = false;
}
private void SetAnalysisStrategy(AnalysisMethods analysisMethod)
{
switch (analysisMethod)
{
case AnalysisMethods.Regression:
AnalysisStrategy = new RegressionStrategy();
break;
case AnalysisMethods.AssociationRulesSearch:
AnalysisStrategy = new AssociationRulesSearchStrategy();
break;
case AnalysisMethods.Clustering:
AnalysisStrategy = new ClusteringStrategy();
break;
default:
throw new Exception("Невідомий метод аналізу.");
}
}
private void FillForm()
{
AnalysisMethods am = Integ.GetMethodSelections(ap);
col = new INCCAnalysisParams.collar_combined_rec();
if (am != null)
{
// Grab the settings.
if (am.HasMethod(AnalysisMethod.CollarAmLi))
col = (INCCAnalysisParams.collar_combined_rec)am.GetMethodParameters(AnalysisMethod.CollarAmLi);
}
// Default is to request passive measurement info. Once that is entered or pulled from a measurement, we
// can enable the active, then the calculation. HN 5/3/2017
ModeComboBox.SelectedIndex = col.collar.collar_mode;
PassiveMeasurementRadioButton.Checked = true;
PassiveMeasurementRadioButton.Enabled = false;
ActiveMeasurementRadioButton.Checked = false;
ActiveMeasurementRadioButton.Enabled = false;
CalculateResultsRadioButton.Checked = false;
CalculateResultsRadioButton.Enabled = false;
//These are all filled based on 1) a live measurement or 2) a stored measurement
ActiveSinglesTextBox.ReadOnly = true;
ActiveSinglesTextBox.NumberFormat = NumericTextBox.Formatter.F3;
ActiveSinglesErrorTextBox.ReadOnly = true;
ActiveSinglesErrorTextBox.NumberFormat = NumericTextBox.Formatter.F3;
ActiveDoublesTextBox.ReadOnly = true;
ActiveDoublesTextBox.NumberFormat = NumericTextBox.Formatter.F3;
ActiveDoublesErrorTextBox.ReadOnly = true;
ActiveDoublesErrorTextBox.NumberFormat = NumericTextBox.Formatter.F3;
PassiveSinglesTextBox.ReadOnly = true;
PassiveSinglesTextBox.NumberFormat = NumericTextBox.Formatter.F3;
PassiveSinglesErrorTextBox.ReadOnly = true;
PassiveSinglesErrorTextBox.NumberFormat = NumericTextBox.Formatter.F3;
PassiveDoublesTextBox.ReadOnly = true;
PassiveDoublesTextBox.NumberFormat = NumericTextBox.Formatter.F3;
PassiveDoublesErrorTextBox.ReadOnly = true;
PassiveDoublesErrorTextBox.NumberFormat = NumericTextBox.Formatter.F3;
}
public void Persist()
{
if (imd.modified)
{
if (ams == null) // HN No analysis methods existed.
{
ams = new AnalysisMethods();
ams.AddMethod(am, imd);
}
if (ams.HasMethod(am)) // if found, update the existing parameter values
{
INCCAnalysisParams.INCCMethodDescriptor c = ams.GetMethodParameters(am);
imd.CopyTo(c); // This a virtual so imd can be the primary type
}
else // add the new method params under the current method key
{
ams.AddMethod(am, imd);
}
INCCSelector sel = new INCCSelector(acq.detector_id, acq.item_type);
N.App.DB.UpdateAnalysisMethod(sel, ams); // flush changes on internal map to the DB
}
}
private void OKBtn_Click(object sender, EventArgs e)
{
if (ItemIdComboBox.Text == String.Empty)
{
MessageBox.Show("You must enter an item id for this assay.", "ERROR");
}
else
{
if (ah.OKButton_Click(sender, e) == System.Windows.Forms.DialogResult.OK)
{
//This is fubar. Must save changed parameters before running analysis. HN 9.10.2015
AnalysisMethods am = Integ.GetMethodSelections(ah.ap);
if (am != null)
{
// NEXT: implement these choices, needs dialogs
// if Verif + cal curve get U235 percent
// if Verif + (cal curve or KA) get heavy metal data
// if Verif + collar get collar data
// if Verif + curium ratio, get cm_pu_ratio w dlg;
if (am.Has(AnalysisMethod.CuriumRatio))
{
new IDDCmPuRatio(ah.ap).ShowDialog();
}
this.Visible = false;
// Add strata update to measurement object. HN 9.23.2015
//user can cancel in here during LM set-up, account for it.
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
this.Close();
}
else
{
MessageBox.Show(String.Format("No analysis methods specified for detector {0} and material {1}", ah.ap.detector_id, ah.ap.item_type),
"Verification", MessageBoxButtons.OK);
}
}
}
}
void PrepareCalibList()
{
CalibDataList.Clear();
CalibDataList.am = AnalysisMethod;
AnalysisMethods ams = Integ.GetMethodSelections(DetectorId, Material);
INCCAnalysisParams.INCCMethodDescriptor imd = ams.GetMethodParameters(AnalysisMethod);
INCCAnalysisParams.CurveEquationVals cev = null;
double[] doubles = null; double[] decl_mass = null;
GetCalCurve(imd, ref cev, ref doubles, ref decl_mass);
for (int i = 0; i < doubles.Length; i++)
{
CalibData p = new CalibData();
p.CalPtsMass = decl_mass[i];
p.CalPtsDoubles = doubles[i];
p.number = i + 1;
CalibDataList.Add(p);
}
CalibDataList.CalcLowerUpper();
CalibDataList.CalculateMassBasis(cev);
ApplyMethodCurve(CalibDataList, cev);
}
public void Persist()
{
if (imd.modified)
{
if (ams == null) // HN No analysis methods existed.
{
ams = new AnalysisMethods();
ams.AddMethod(am, imd);
}
if (ams.HasMethod(am)) // if found, update the existing parameter values
{
INCCAnalysisParams.INCCMethodDescriptor c = ams.GetMethodParameters(am);
imd.CopyTo(c); // This a virtual so imd can be the primary type
}
else // add the new method params under the current method key
{
ams.AddMethod(am, imd);
}
INCCSelector sel = new INCCSelector(acq.detector_id, acq.item_type);
N.App.DB.UpdateAnalysisMethod(sel, ams); // flush changes on internal map to the DB
}
}
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);
}
public void SelectMaterialType(ComboBox mtcb)
{
acq.item_type = String.Copy((string)(mtcb.SelectedItem));
ams = Integ.GetMethodSelections(acq.detector_id, acq.item_type); // unfinished, test and firm up
}
private void FieldFiller()
{
// Populate the UI fields with values from the local AcquireParameters object
QCTestsCheckBox.Checked = ah.ap.qc_tests;
PrintResultsCheckBox.Checked = ah.ap.print;
CommentAtEndCheckBox.Checked = ah.ap.ending_comment;
NumPassiveCyclesTextBox.Text = Format.Rend(ah.ap.num_runs);
NumActiveCyclesTextBox.Text = Format.Rend(ah.ap.active_num_runs);
CommentTextBox.Text = ah.ap.comment;
CountTimeTextBox.Text = Format.Rend(ah.ap.run_count_time);
MeasPrecisionTextBox.Text = ah.ap.meas_precision.ToString("F2");
MinNumCyclesTextBox.Text = Format.Rend(ah.ap.min_num_runs);
MaxNumCyclesTextBox.Text = Format.Rend(ah.ap.max_num_runs);
DeclaredMassTextBox.Text = ah.ap.mass.ToString("F3");
DrumWeightTextBox.Text = ah.ap.drum_empty_weight.ToString("F3");
MBAComboBox.Items.Clear();
InventoryChangeCodeComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in NC.App.DB.InvChangeCodes.GetList())
{
InventoryChangeCodeComboBox.Items.Add(desc.Name);
}
IOCodeComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in NC.App.DB.IOCodes.GetList())
{
IOCodeComboBox.Items.Add(desc.Name);
}
foreach (INCCDB.Descriptor desc in NC.App.DB.MBAs.GetList())
{
MBAComboBox.Items.Add(desc);
}
ItemIdComboBox.Items.Clear();
foreach (ItemId id in NC.App.DB.ItemIds.GetList())
{
ItemIdComboBox.Items.Add(id.item);
}
StratumIdComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in NC.App.DB.Stratums.GetList())
{
StratumIdComboBox.Items.Add(desc.Name);
}
MaterialTypeComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in NC.App.DB.Materials.GetList())
{
MaterialTypeComboBox.Items.Add(desc.Name);
}
DataSourceComboBox.Items.Clear();
foreach (ConstructedSource cs in Enum.GetValues(typeof(ConstructedSource)))
{
if (cs.AcquireChoices() || cs.LMFiles(ah.det.Id.SRType))
{
DataSourceComboBox.Items.Add(cs.NameForViewing(ah.det.Id.SRType));
}
}
am = Integ.GetMethodSelections(ah.ap);
if (ah.ap.acquire_type == AcquireConvergence.CycleCount)
{
UseNumCyclesRadioButton.Checked = true;
}
else if (ah.ap.acquire_type == AcquireConvergence.DoublesPrecision)
{
UseDoublesRadioButton.Checked = true;
}
else if (ah.ap.acquire_type == AcquireConvergence.TriplesPrecision)
{
UseTriplesRadioButton.Checked = true;
}
else if (ah.ap.acquire_type == AcquireConvergence.Pu240EffPrecision)
{
UsePu240eRadioButton.Checked = true;
}
DataSourceComboBox.SelectedIndex = DataSourceComboBox.FindString(ah.ap.data_src.NameForViewing(ah.det.Id.SRType));
//TODO: When this is a PTR File, there is no match. Should that be a Disk File?
//For now, default to SR.
if (DataSourceComboBox.SelectedItem == null)
{
DataSourceComboBox.SelectedIndex = DataSourceComboBox.FindString("Shift Register");
ah.ap.modified = true;
}
Integ.SetNewCurrentDetector(ah.ap.detector_id, true);
MaterialTypeComboBox_SelectedItem();
StratumIdComboBox.SelectedItem = ah.ap.stratum_id.Name;
MBAComboBox.SelectedItem = ah.ap.mba;
InventoryChangeCodeComboBox.SelectedItem = ah.ap.inventory_change_code;
IOCodeComboBox.SelectedItem = ah.ap.io_code;
ItemIdComboBox.SelectedItem = ah.ap.item_id;
if (am != null)
{
if (am.Has(AnalysisMethod.CuriumRatio))
{
IsotopicsBtn.Enabled = false; CompositeIsotopicsBtn.Enabled = false;
}
if (am.Has(AnalysisMethod.ActivePassive) || am.Has(AnalysisMethod.CollarAmLi) || am.Has(AnalysisMethod.CollarCf))
{
NumActiveCyclesLabel.Visible = NumActiveCyclesTextBox.Visible = true;
}
else
{
NumActiveCyclesLabel.Visible = NumActiveCyclesTextBox.Visible = false;
}
if (!am.Has(AnalysisMethod.AddASource))
{
DrumWeightLabel.Visible = DrumWeightTextBox.Visible = false;
DrumWeightTextBox.Text = ah.ap.drum_empty_weight.ToString("F3");
}
}
}
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;
}
}
}
}
/// <summary>
/// Get specific parameter sets for the given detector, material type pair.
/// Returns default values if database entry not found
/// </summary>
/// <param name="detname"></param>
/// <param name="mat"></param>
/// <param name="db"></param>
public void IngestAnalysisMethodSpecificsFromDB(INCCSelector sel, AnalysisMethods ams, DB.AnalysisMethodSpecifiers db)
{
foreach (AnalysisMethod am in System.Enum.GetValues(typeof(AnalysisMethod)))
{
if (!ams.choices[(int)am])
{
continue;
}
if (!(am > AnalysisMethod.None && am <= AnalysisMethod.TruncatedMultiplicity && (am != AnalysisMethod.INCCNone)))
{
if (!am.IsNone())
{
NC.App.Pest.logger.TraceEvent(LogLevels.Warning, 34061, "Skipping DB ingest of {0} {1} calib params", sel, am);
}
continue;
}
string current = String.Format("{0} {1} parameters", sel, am.FullName());
int logid = 34170 + (int)am;
LogLevels lvl = LogLevels.Verbose;
DataRow dr;
switch (am)
{
case AnalysisMethod.KnownA:
INCCAnalysisParams.known_alpha_rec ks = new INCCAnalysisParams.known_alpha_rec();
dr = db.Get(sel.detectorid, sel.material, "known_alpha_rec");
if (dr != null)
{
ks.rho_zero = DB.Utils.DBDouble(dr["rho_zero"]);
ks.alpha_wt = DB.Utils.DBDouble(dr["alpha_wt"]);
ks.k = DB.Utils.DBDouble(dr["k"]);
ks.cev.a = DB.Utils.DBDouble(dr["a"]);
ks.cev.b = DB.Utils.DBDouble(dr["b"]);
ks.cev.var_a = DB.Utils.DBDouble(dr["var_a"]);
ks.cev.var_b = DB.Utils.DBDouble(dr["var_b"]);
ks.cev.setcovar(Coeff.a, Coeff.b, DB.Utils.DBDouble(dr["covar_ab"]));
ks.cev.sigma_x = DB.Utils.DBDouble(dr["sigma_x"]);
ks.known_alpha_type = (INCCAnalysisParams.KnownAlphaVariant)(DB.Utils.DBInt32(dr["known_alpha_type"]));
ks.ring_ratio.cal_curve_equation = (INCCAnalysisParams.CurveEquation)(DB.Utils.DBInt32(dr["ring_ratio_equation"]));
ks.ring_ratio.a = DB.Utils.DBDouble(dr["ring_ratio_a"]);
ks.ring_ratio.b = DB.Utils.DBDouble(dr["ring_ratio_b"]);
ks.ring_ratio.c = DB.Utils.DBDouble(dr["ring_ratio_c"]);
ks.ring_ratio.d = DB.Utils.DBDouble(dr["ring_ratio_d"]);
ks.dcl_mass = DB.Utils.ReifyDoubles((string)dr["dcl_mass"]);
ks.doubles = DB.Utils.ReifyDoubles((string)dr["doubles"]);
ks.heavy_metal_reference = DB.Utils.DBDouble(dr["heavy_metal_reference"]);
ks.heavy_metal_corr_factor = DB.Utils.DBDouble(dr["heavy_metal_corr_factor"]);
ks.cev.upper_mass_limit = DB.Utils.DBDouble(dr["upper_mass_limit"]);
ks.cev.lower_mass_limit = DB.Utils.DBDouble(dr["lower_mass_limit"]);
}
else
{
lvl = LogLevels.Info;
}
ams.AddMethod(am, ks);
break;
case AnalysisMethod.CalibrationCurve:
INCCAnalysisParams.cal_curve_rec cs = new INCCAnalysisParams.cal_curve_rec();
dr = db.Get(sel.detectorid, sel.material, "cal_curve_rec");
if (dr != null)
{
CalCurveDBSnock(cs.cev, dr);
cs.CalCurveType = (INCCAnalysisParams.CalCurveType)DB.Utils.DBInt32(dr["cal_curve_type"]);
cs.dcl_mass = DB.Utils.ReifyDoubles((string)dr["dcl_mass"]);
cs.doubles = DB.Utils.ReifyDoubles((string)dr["doubles"]);
cs.percent_u235 = DB.Utils.DBDouble(dr["percent_u235"]);
cs.heavy_metal_reference = DB.Utils.DBDouble(dr["heavy_metal_reference"]);
cs.heavy_metal_corr_factor = DB.Utils.DBDouble(dr["heavy_metal_corr_factor"]);
}
else
{
lvl = LogLevels.Info;
}
ams.AddMethod(am, cs);
break;
case AnalysisMethod.KnownM:
INCCAnalysisParams.known_m_rec ms = new INCCAnalysisParams.known_m_rec();
dr = db.Get(sel.detectorid, sel.material, "known_m_rec");
if (dr != null)
{
ms.sf_rate = DB.Utils.DBDouble(dr["sf_rate"]);
ms.vs1 = DB.Utils.DBDouble(dr["vs1"]);
ms.vs2 = DB.Utils.DBDouble(dr["vs2"]);
ms.vi1 = DB.Utils.DBDouble(dr["vi1"]);
ms.vi2 = DB.Utils.DBDouble(dr["vi2"]);
ms.b = DB.Utils.DBDouble(dr["b"]);
ms.c = DB.Utils.DBDouble(dr["c"]);
ms.sigma_x = DB.Utils.DBDouble(dr["sigma_x"]);
ms.lower_mass_limit = DB.Utils.DBDouble(dr["lower_mass_limit"]);
ms.upper_mass_limit = DB.Utils.DBDouble(dr["upper_mass_limit"]);
}
else
{
lvl = LogLevels.Info;
}
ams.AddMethod(am, ms);
break;
case AnalysisMethod.Multiplicity:
INCCAnalysisParams.multiplicity_rec mu = new INCCAnalysisParams.multiplicity_rec();
dr = db.Get(sel.detectorid, sel.material, "multiplicity_rec");
if (dr != null)
{
mu.solve_efficiency = (INCCAnalysisParams.MultChoice)DB.Utils.DBInt32(dr["solve_efficiency"]);
mu.sf_rate = DB.Utils.DBDouble(dr["sf_rate"]);
mu.vs1 = DB.Utils.DBDouble(dr["vs1"]);
mu.vs2 = DB.Utils.DBDouble(dr["vs2"]);
mu.vs3 = DB.Utils.DBDouble(dr["vs3"]);
mu.vi1 = DB.Utils.DBDouble(dr["vi1"]);
mu.vi2 = DB.Utils.DBDouble(dr["vi2"]);
mu.vi3 = DB.Utils.DBDouble(dr["vi3"]);
mu.a = DB.Utils.DBDouble(dr["a"]);
mu.b = DB.Utils.DBDouble(dr["b"]);
mu.c = DB.Utils.DBDouble(dr["c"]);
mu.sigma_x = DB.Utils.DBDouble(dr["sigma_x"]);
mu.alpha_weight = DB.Utils.DBDouble(dr["alpha_weight"]);
mu.multEffCorFactor = DB.Utils.DBDouble(dr["eff_cor"]);
}
else
{
lvl = LogLevels.Info;
}
ams.AddMethod(am, mu);
break;
case AnalysisMethod.TruncatedMultiplicity:
INCCAnalysisParams.truncated_mult_rec tm = new INCCAnalysisParams.truncated_mult_rec();
dr = db.Get(sel.detectorid, sel.material, "truncated_mult_rec");
if (dr != null)
{
tm.known_eff = DB.Utils.DBBool(dr["known_eff"]);
tm.solve_eff = DB.Utils.DBBool(dr["vs1"]);
tm.a = DB.Utils.DBDouble(dr["a"]);
tm.b = DB.Utils.DBDouble(dr["b"]);
}
else
{
lvl = LogLevels.Info;
}
ams.AddMethod(am, tm);
break;
case AnalysisMethod.CuriumRatio:
INCCAnalysisParams.curium_ratio_rec cm = new INCCAnalysisParams.curium_ratio_rec();
dr = db.Get(sel.detectorid, sel.material, "curium_ratio_rec");
if (dr != null)
{
cm.curium_ratio_type = (INCCAnalysisParams.CuriumRatioVariant)DB.Utils.DBInt32(dr["curium_ratio_type"]);
CalCurveDBSnock(cm.cev, dr);
}
else
{
lvl = LogLevels.Info;
}
ams.AddMethod(am, cm);
break;
case AnalysisMethod.Active:
INCCAnalysisParams.active_rec ar = new INCCAnalysisParams.active_rec();
dr = db.Get(sel.detectorid, sel.material, "active_rec");
if (dr != null)
{
CalCurveDBSnock(ar.cev, dr);
ar.dcl_mass = DB.Utils.ReifyDoubles((string)dr["dcl_mass"]);
ar.doubles = DB.Utils.ReifyDoubles((string)dr["doubles"]);
}
else
{
lvl = LogLevels.Warning;
}
ams.AddMethod(am, ar);
break;
case AnalysisMethod.AddASource:
INCCAnalysisParams.add_a_source_rec aas = new INCCAnalysisParams.add_a_source_rec();
dr = db.Get(sel.detectorid, sel.material, "add_a_source_rec");
if (dr != null)
{
CalCurveDBSnock(aas.cev, dr);
aas.dcl_mass = DB.Utils.ReifyDoubles((string)dr["dcl_mass"]);
aas.doubles = DB.Utils.ReifyDoubles((string)dr["doubles"]);
aas.cf.a = DB.Utils.DBDouble(dr["cf_a"]);
aas.cf.b = DB.Utils.DBDouble(dr["cf_b"]);
aas.cf.c = DB.Utils.DBDouble(dr["cf_c"]);
aas.cf.d = DB.Utils.DBDouble(dr["cf_d"]);
aas.dzero_avg = DB.Utils.DBDouble(dr["dzero_avg"]);
aas.num_runs = DB.Utils.DBUInt16(dr["num_runs"]);
aas.position_dzero = DB.Utils.ReifyDoubles((string)dr["position_dzero"]);
aas.dzero_ref_date = DB.Utils.DBDateTime(dr["dzero_ref_date"]);
aas.use_truncated_mult = DB.Utils.DBBool(dr["use_truncated_mult"]);
aas.tm_dbls_rate_upper_limit = DB.Utils.DBDouble(dr["tm_dbls_rate_upper_limit"]);
aas.tm_weighting_factor = DB.Utils.DBDouble(dr["tm_weighting_factor"]);
}
else
{
lvl = LogLevels.Info;
}
ams.AddMethod(am, aas);
break;
case AnalysisMethod.ActiveMultiplicity:
INCCAnalysisParams.active_mult_rec amr = new INCCAnalysisParams.active_mult_rec();
dr = db.Get(sel.detectorid, sel.material, "active_mult_rec");
if (dr != null)
{
amr.vf1 = DB.Utils.DBDouble(dr["vf1"]);
amr.vf2 = DB.Utils.DBDouble(dr["vf2"]);
amr.vf3 = DB.Utils.DBDouble(dr["vf3"]);
amr.vt1 = DB.Utils.DBDouble(dr["vt1"]);
amr.vt2 = DB.Utils.DBDouble(dr["vt2"]);
amr.vt3 = DB.Utils.DBDouble(dr["vt3"]);
}
else
{
lvl = LogLevels.Info;
}
ams.AddMethod(am, amr);
break;
case AnalysisMethod.ActivePassive:
INCCAnalysisParams.active_passive_rec acp = new INCCAnalysisParams.active_passive_rec();
dr = db.Get(sel.detectorid, sel.material, "active_passive_rec");
if (dr != null)
{
CalCurveDBSnock(acp.cev, dr);
}
else
{
lvl = LogLevels.Info;
}
ams.AddMethod(am, acp);
break;
case AnalysisMethod.Collar:
INCCAnalysisParams.collar_rec cr = new INCCAnalysisParams.collar_rec();
dr = db.Get(sel.detectorid, sel.material, "collar_rec");
if (dr != null)
{
CalCurveDBSnock(cr.cev, dr);
cr.collar_mode = DB.Utils.DBBool(dr["collar_mode"]);
cr.number_calib_rods = DB.Utils.DBInt32(dr["number_calib_rods"]);
cr.sample_corr_fact.v = DB.Utils.DBDouble(dr["sample_corr_fact"]);
cr.sample_corr_fact.err = DB.Utils.DBDouble(dr["sample_corr_fact_err"]);
cr.u_mass_corr_fact_a.v = DB.Utils.DBDouble(dr["u_mass_corr_fact_a"]);
cr.u_mass_corr_fact_a.err = DB.Utils.DBDouble(dr["u_mass_corr_fact_a_err"]);
cr.u_mass_corr_fact_b.v = DB.Utils.DBDouble(dr["u_mass_corr_fact_b"]);
cr.u_mass_corr_fact_b.err = DB.Utils.DBDouble(dr["u_mass_corr_fact_b_err"]);
cr.poison_absorption_fact = DB.Utils.ReifyDoubles((string)dr["poison_absorption_fact"]);
cr.poison_rod_type = DB.Utils.ReifyStrings((string)dr["poison_rod_type"]);
cr.poison_rod_a = TupleArraySlurp(ref cr.poison_rod_a, "poison_rod_a", dr);
cr.poison_rod_b = TupleArraySlurp(ref cr.poison_rod_b, "poison_rod_b", dr);
cr.poison_rod_c = TupleArraySlurp(ref cr.poison_rod_c, "poison_rod_c", dr);
}
else
{
lvl = LogLevels.Info;
}
ams.AddMethod(am, cr);
break;
default:
lvl = LogLevels.Error; logid = 34181; current = "Choosing to not construct" + current;
break;
}
switch (lvl)
{
case LogLevels.Info:
current = "Using default for " + current;
lvl = LogLevels.Verbose;
break;
case LogLevels.Verbose:
current = "Retrieved for " + current;
break;
default:
break;
}
NC.App.Pest.logger.TraceEvent(lvl, logid, current);
} // for
}
// todo: collar/k5 detached params (no explicit detector mapping)
/// the details
public void UpdateAnalysisMethodSpecifics(string detname, string mat, DB.AnalysisMethodSpecifiers db = null)
{
if (db == null)
{
db = new DB.AnalysisMethodSpecifiers();
}
var res = // this finds the am for the given detector and acquire type
from am in this.DetectorMaterialAnalysisMethods
where (am.Key.detectorid.Equals(detname, StringComparison.OrdinalIgnoreCase) &&
am.Key.material.Equals(mat, StringComparison.OrdinalIgnoreCase))
select am;
if (res.Count() > 0) // now execute the select expression and test the result for existence
{
KeyValuePair <INCCSelector, AnalysisMethods> kv = res.First();
AnalysisMethods sam = kv.Value; // the descriptor instance
IEnumerator iter = kv.Value.GetMethodEnumerator();
while (iter.MoveNext())
{
System.Tuple <AnalysisMethod, INCCAnalysisParams.INCCMethodDescriptor> md = (System.Tuple <AnalysisMethod, INCCAnalysisParams.INCCMethodDescriptor>)iter.Current;
if (md.Item2 == null) // case from INCC5 transfer missing params, reflects file write bugs in INCC5 code
{
NC.App.Pest.logger.TraceEvent(LogLevels.Warning, 34029, "Missing {0}'s INCC {1} {2} method parameters, adding default values", detname, kv.Key.material, md.Item1.FullName());
//OK, there is probably smarter way of doing ths, but for now, does find the nulls, then add default params where necessary. hn 9.23.2015
if (md.Item2 == null)
{
INCCAnalysisParams.INCCMethodDescriptor rec = new INCCAnalysisParams.INCCMethodDescriptor();
switch (md.Item1)
{
case AnalysisMethod.Active:
rec = (INCCAnalysisParams.INCCMethodDescriptor) new INCCAnalysisParams.active_rec();
break;
case AnalysisMethod.ActiveMultiplicity:
rec = (INCCAnalysisParams.INCCMethodDescriptor) new INCCAnalysisParams.active_mult_rec();
break;
case AnalysisMethod.ActivePassive:
rec = (INCCAnalysisParams.INCCMethodDescriptor) new INCCAnalysisParams.active_passive_rec();
break;
case AnalysisMethod.AddASource:
rec = (INCCAnalysisParams.INCCMethodDescriptor) new INCCAnalysisParams.add_a_source_rec();
break;
case AnalysisMethod.CalibrationCurve:
rec = (INCCAnalysisParams.INCCMethodDescriptor) new INCCAnalysisParams.cal_curve_rec();
break;
case AnalysisMethod.Collar:
//This may not be enough for collar params creation. hn 9.23.2015
rec = (INCCAnalysisParams.INCCMethodDescriptor) new INCCAnalysisParams.collar_combined_rec();
break;
case AnalysisMethod.CuriumRatio:
rec = (INCCAnalysisParams.INCCMethodDescriptor) new INCCAnalysisParams.cm_pu_ratio_rec();
break;
case AnalysisMethod.KnownA:
rec = (INCCAnalysisParams.INCCMethodDescriptor) new INCCAnalysisParams.known_alpha_rec();
break;
case AnalysisMethod.KnownM:
rec = (INCCAnalysisParams.INCCMethodDescriptor) new INCCAnalysisParams.known_m_rec();
break;
case AnalysisMethod.Multiplicity:
rec = (INCCAnalysisParams.INCCMethodDescriptor) new INCCAnalysisParams.multiplicity_rec();
break;
case AnalysisMethod.TruncatedMultiplicity:
rec = (INCCAnalysisParams.INCCMethodDescriptor) new INCCAnalysisParams.truncated_mult_rec();
break;
default:
break;
}
sam.AddMethod(md.Item1, rec);
}
continue;
}
NC.App.Pest.logger.TraceEvent(LogLevels.Verbose, 34030, "Updating {0},{1} {2}", detname, mat, md.Item2.GetType().Name);
DB.ElementList parms = null;
switch (md.Item1)
{
case AnalysisMethod.KnownA:
case AnalysisMethod.CalibrationCurve:
case AnalysisMethod.KnownM:
case AnalysisMethod.Multiplicity:
case AnalysisMethod.TruncatedMultiplicity:
case AnalysisMethod.AddASource:
case AnalysisMethod.CuriumRatio:
case AnalysisMethod.Active:
case AnalysisMethod.ActivePassive:
case AnalysisMethod.Collar:
case AnalysisMethod.ActiveMultiplicity:
parms = ((ParameterBase)md.Item2).ToDBElementList();
break;
default:
break;
}
if (parms != null)
{
db.UpdateCalib(detname, mat, md.Item2.GetType().Name, parms); // det, mat, amid, params
}
//Something amiss and sometimes not storing. Could this be it?
else
{
//Didn't exist, so create and store. hn 9.22.2015
sam.AddMethod(md.Item1, md.Item2);
}
}
}
}
public void UpdateAnalysisMethod(INCCSelector sel, AnalysisMethods ams)
{
DB.AnalysisMethodSpecifiers db = new DB.AnalysisMethodSpecifiers();
if (ams.modified)
{
UpdateAnalysisMethods(sel, ams, db);
}
UpdateAnalysisMethodSpecifics(sel.detectorid, sel.material,db);
}
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);
}
public void SelectMaterialType(string mt)
{
acq.item_type = String.Copy(mt);
ams = Integ.GetMethodSelections(acq.detector_id, acq.item_type); // unfinished, test and firm up
}
private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
{
List <string> ls = null;
if (e.Node.Parent == null)
{
if (e.Node.Tag == null)
{
return;
}
else
{
Type t = (Type)e.Node.Tag;
if (t == typeof(TestParameters))
{
TestParameters d = N.App.DB.TestParameters.Get();
ls = d.ToDBElementList(generate: true).AlignedNameValueList;
}
}
}
else
{
object o = e.Node.Parent.Tag;
if (o == null)
{
return;
}
else // display content in the right-hand pane
{
Type t = e.Node.Tag.GetType();
if (t == typeof(ItemId))
{
ls = ((ParameterBase)e.Node.Tag).ToDBElementList(generate: true).AlignedNameValueList;
}
else if (t == typeof(Detector))
{
ls = GenDetIdStr(((Detector)e.Node.Tag).Id);
}
else if (t == typeof(Isotopics))
{
ls = ((ParameterBase)e.Node.Tag).ToDBElementList(generate: true).AlignedNameValueList;
}
else if (t == typeof(CompositeIsotopics))
{
ls = ((ParameterBase)e.Node.Tag).ToDBElementList(generate: true).AlignedNameValueList;
}
else if (t == typeof(CollarItemId))
{
ls = ((ParameterBase)e.Node.Tag).ToDBElementList(generate: true).AlignedNameValueList;
}
else if (t == typeof(Stratum))
{
ls = ((ParameterBase)e.Node.Tag).ToDBElementList(generate: true).AlignedNameValueList;
}
else if (t == typeof(INCCDB.Descriptor))
{
INCCDB.Descriptor d = (INCCDB.Descriptor)e.Node.Tag;
ls = new List <string>(); ls.Add(d.Item1 + ": " + d.Item2);
}
else if (t == typeof(AnalysisMethods))
{
AnalysisMethods d = (AnalysisMethods)e.Node.Tag;
ls = d.ToDBElementList(generate: true).AlignedNameValueList;
}
else if (t == typeof(AcquireParameters))
{
AcquireParameters d = (AcquireParameters)e.Node.Tag;
ls = d.ToDBElementList(generate: true).AlignedNameValueList;
}
else if (t == typeof(AlphaBeta))
{
AlphaBeta AB = (AlphaBeta)e.Node.Tag;
ls = GenDetABStr(AB);
}
else if (t == typeof(Multiplicity))
{
Multiplicity m = (Multiplicity)e.Node.Tag;
ls = GenDetMultStr((Detector)o, m);
}
else if (t == typeof(DataSourceIdentifier))
{
DataSourceIdentifier d = (DataSourceIdentifier)e.Node.Tag;
ls = GenDetIdStr(d);
}
else if (t == typeof(INCCDB.IndexedResults))
{
ls = GenMeasStr((INCCDB.IndexedResults)e.Node.Tag);;
}
}
}
StringBuilder sb = new StringBuilder(100);
if (ls != null)
{
foreach (string s in ls)
{
sb.Append(s); sb.Append('\r');
}
richTextBox1.Text = sb.ToString();
}
}
public IDDSelectPrimaryAM(AnalysisDefs.AnalysisMethods aam)
{
am = aam;
InitializeComponent();
EnableThoseWhomAreChosen();
if (am.Normal == AnalysisMethod.None)
am.Normal = am.GetFirstSelected();
switch (am.Normal)
{
case AnalysisMethod.None:
case AnalysisMethod.INCCNone:
break;
case AnalysisMethod.CalibrationCurve:
CalibrationCurveRadioButton.Checked = true;
break;
case AnalysisMethod.KnownA:
KnownAlphaRadioButton.Checked = true;
break;
case AnalysisMethod.KnownM:
KnownMRadioButton.Checked = true;
break;
case AnalysisMethod.Multiplicity:
MultiplicityRadioButton.Checked = true;
break;
case AnalysisMethod.AddASource:
AddASourceRadioButton.Checked = true;
break;
case AnalysisMethod.CuriumRatio:
CuriumRatioRadioButton.Checked = true;
break;
case AnalysisMethod.TruncatedMultiplicity:
TruncatedMultiplicityRadioButton.Checked = true;
break;
}
if (am.Backup.IsNone() || am.Normal == am.Backup)
am.Backup = am.GetSecondSelected();
switch (am.Backup)
{
case AnalysisMethod.None:
case AnalysisMethod.INCCNone:
break;
case AnalysisMethod.CalibrationCurve:
BCalibrationCurveRadioButton.Checked = true;
break;
case AnalysisMethod.KnownA:
BKnownAlphaRadioButton.Checked = true;
break;
case AnalysisMethod.KnownM:
BKnownMRadioButton.Checked = true;
break;
case AnalysisMethod.Multiplicity:
BMultiplicityRadioButton.Checked = true;
break;
case AnalysisMethod.AddASource:
BAddASourceRadioButton.Checked = true;
break;
case AnalysisMethod.CuriumRatio:
BCuriumRatioRadioButton.Checked = true;
break;
case AnalysisMethod.TruncatedMultiplicity:
BTruncatedMultiplicityRadioButton.Checked = true;
break;
}
if (am.Auxiliary.IsNone() || am.Auxiliary == am.Backup)
am.Auxiliary = am.GetThirdSelected();
switch (am.Auxiliary)
{
case AnalysisMethod.None:
case AnalysisMethod.INCCNone:
break;
case AnalysisMethod.CalibrationCurve:
ACalibrationCurveRadioButton.Checked = true;
break;
case AnalysisMethod.KnownA:
AKnownAlphaRadioButton.Checked = true;
break;
case AnalysisMethod.KnownM:
AKnownMRadioButton.Checked = true;
break;
case AnalysisMethod.Multiplicity:
AMultiplicityRadioButton.Checked = true;
break;
case AnalysisMethod.AddASource:
AAddASourceRadioButton.Checked = true;
break;
case AnalysisMethod.CuriumRatio:
ACuriumRatioRadioButton.Checked = true;
break;
case AnalysisMethod.TruncatedMultiplicity:
ATruncatedMultiplicityRadioButton.Checked = true;
break;
}
}
private void FieldFiller()
{
// Populate the UI fields with values from the local AcquireParameters object
UseCurrentCalibCheckBox.Checked = true;
ReplaceOriginalCheckBox.Checked = false;
QCTestsCheckBox.Checked = ah.ap.qc_tests;
PrintResultsCheckBox.Checked = ah.ap.print;
CommentAtEndCheckBox.Checked = ah.ap.ending_comment;
CommentTextBox.Text = ah.ap.comment;
DeclaredMassTextBox.Text = ah.ap.mass.ToString("F3");
NormConst.Text = norm.v.ToString("F4");
NormConstErr.Text = norm.err.ToString("F4");
dateTimePicker1.Value = new DateTime(meas.MeasDate.Ticks);
InventoryChangeCodeComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in N.App.DB.InvChangeCodes.GetList())
{
InventoryChangeCodeComboBox.Items.Add(desc.Name);
}
IOCodeComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in N.App.DB.IOCodes.GetList())
{
IOCodeComboBox.Items.Add(desc.Name);
}
ItemIdComboBox.Items.Clear();
foreach (ItemId id in N.App.DB.ItemIds.GetList())
{
ItemIdComboBox.Items.Add(id.item);
}
StratumIdComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in N.App.DB.Stratums.GetList())
{
StratumIdComboBox.Items.Add(desc.Name);
}
StratumIdComboBox.SelectedItem = null;
MaterialTypeComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in N.App.DB.Materials.GetList())
{
MaterialTypeComboBox.Items.Add(desc.Name);
}
MaterialTypeComboBox.SelectedItem = ah.ap.item_type;
StratumIdComboBox.SelectedItem = ah.ap.stratum_id.Name;
InventoryChangeCodeComboBox.SelectedItem = ah.ap.inventory_change_code;
IOCodeComboBox.SelectedItem = ah.ap.io_code;
ItemIdComboBox.SelectedItem = ah.ap.item_id;
am = Integ.GetMethodSelections(ah.ap);
if (am != null)
{
if (am.Has(AnalysisMethod.CuriumRatio))
{
IsotopicsBtn.Enabled = false; BackgroundBtn.Enabled = false;
}
}
}
private void FieldFiller()
{
// Populate the UI fields with values from the local AcquireParameters object
this.QCTestsCheckBox.Checked = ah.ap.qc_tests;
this.PrintResultsCheckBox.Checked = ah.ap.print;
this.CommentAtEndCheckBox.Checked = ah.ap.ending_comment;
this.NumPassiveCyclesTextBox.Text = Format.Rend(ah.ap.num_runs);
this.NumActiveCyclesTextBox.Text = Format.Rend(ah.ap.active_num_runs);
this.CommentTextBox.Text = ah.ap.comment;
this.CountTimeTextBox.Text = Format.Rend(ah.ap.run_count_time);
this.MeasPrecisionTextBox.Text = ah.ap.meas_precision.ToString("F2");
this.MinNumCyclesTextBox.Text = Format.Rend(ah.ap.min_num_runs);
this.MaxNumCyclesTextBox.Text = Format.Rend(ah.ap.max_num_runs);
this.DeclaredMassTextBox.Text = ah.ap.mass.ToString("F3");
this.DrumWeightTextBox.Text = ah.ap.drum_empty_weight.ToString("F3");
this.MBAComboBox.Items.Clear();
InventoryChangeCodeComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in NC.App.DB.InvChangeCodes.GetList())
{
this.InventoryChangeCodeComboBox.Items.Add(desc.Name);
}
IOCodeComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in NC.App.DB.IOCodes.GetList())
{
this.IOCodeComboBox.Items.Add(desc.Name);
}
foreach (INCCDB.Descriptor desc in NC.App.DB.MBAs.GetList())
{
MBAComboBox.Items.Add(desc);
}
this.ItemIdComboBox.Items.Clear();
foreach (ItemId id in NC.App.DB.ItemIds.GetList())
{
ItemIdComboBox.Items.Add(id.item);
}
this.StratumIdComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in NC.App.DB.Stratums.GetList())
{
StratumIdComboBox.Items.Add(desc);
}
this.MaterialTypeComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in NC.App.DB.Materials.GetList())
{
MaterialTypeComboBox.Items.Add(desc.Name);
}
this.DataSourceComboBox.Items.Clear();
foreach (ConstructedSource cs in System.Enum.GetValues(typeof(ConstructedSource)))
{
if (cs.AcquireChoices() || cs.LMFiles(ah.det.Id.SRType))
{
DataSourceComboBox.Items.Add(cs.HappyFunName());
}
}
if (ah.ap.acquire_type == AcquireConvergence.CycleCount)
{
this.UseNumCyclesRadioButton.Checked = true;
}
else if (ah.ap.acquire_type == AcquireConvergence.DoublesPrecision)
{
this.UseDoublesRadioButton.Checked = true;
}
else if (ah.ap.acquire_type == AcquireConvergence.TriplesPrecision)
{
this.UseTriplesRadioButton.Checked = true;
}
else if (ah.ap.acquire_type == AcquireConvergence.Pu240EffPrecision)
{
this.UsePu240eRadioButton.Checked = true;
}
DataSourceComboBox.SelectedItem = ah.ap.data_src.HappyFunName();
MaterialTypeComboBox.SelectedItem = ah.ap.item_type;
StratumIdComboBox.SelectedItem = ah.ap.stratum_id;
MBAComboBox.SelectedItem = ah.ap.mba;
InventoryChangeCodeComboBox.SelectedItem = ah.ap.inventory_change_code;
IOCodeComboBox.SelectedItem = ah.ap.io_code;
ItemIdComboBox.SelectedItem = ah.ap.item_id;
am = Integ.GetMethodSelections(ah.ap);
if (am != null)
{
if (am.Has(AnalysisMethod.CuriumRatio))
{
IsotopicsBtn.Enabled = false; CompositeIsotopicsBtn.Enabled = false;
}
if (am.Has(AnalysisMethod.ActivePassive) || am.Has(AnalysisMethod.Collar))
NumActiveCyclesLabel.Visible = NumActiveCyclesTextBox.Visible = true;
else
NumActiveCyclesLabel.Visible = NumActiveCyclesTextBox.Visible = false;
if (!am.Has(AnalysisMethod.AddASource))
{
DrumWeightLabel.Visible = DrumWeightTextBox.Visible = false;
DrumWeightTextBox.Text = ah.ap.drum_empty_weight.ToString("F3");
}
}
}
/// <summary>
/// Get specific parameter sets for the given detector, material type pair.
/// Returns default values if database entry not found
/// </summary>
/// <param name="detname"></param>
/// <param name="mat"></param>
/// <param name="db"></param>
public void IngestAnalysisMethodSpecificsFromDB(INCCSelector sel, AnalysisMethods ams, DB.AnalysisMethodSpecifiers db)
{
foreach (AnalysisMethod am in System.Enum.GetValues(typeof(AnalysisMethod)))
{
if (!ams.choices[(int)am])
continue;
if (!(am > AnalysisMethod.None && am <= AnalysisMethod.TruncatedMultiplicity && (am != AnalysisMethod.INCCNone)))
{
if (!am.IsNone())
NC.App.Pest.logger.TraceEvent(LogLevels.Warning, 34061, "Skipping DB ingest of {0} {1} calib params", sel, am);
continue;
}
string current = String.Format("{0} {1} parameters", sel, am.FullName());
int logid = 34170 + (int)am;
LogLevels lvl = LogLevels.Verbose;
DataRow dr;
switch (am)
{
case AnalysisMethod.KnownA:
INCCAnalysisParams.known_alpha_rec ks = new INCCAnalysisParams.known_alpha_rec();
dr = db.Get(sel.detectorid, sel.material, "known_alpha_rec");
if (dr != null)
{
ks.rho_zero = DB.Utils.DBDouble(dr["rho_zero"]);
ks.alpha_wt = DB.Utils.DBDouble(dr["alpha_wt"]);
ks.k = DB.Utils.DBDouble(dr["k"]);
ks.cev.a = DB.Utils.DBDouble(dr["a"]);
ks.cev.b = DB.Utils.DBDouble(dr["b"]);
ks.cev.var_a = DB.Utils.DBDouble(dr["var_a"]);
ks.cev.var_b = DB.Utils.DBDouble(dr["var_b"]);
ks.cev.setcovar(Coeff.a, Coeff.b, DB.Utils.DBDouble(dr["covar_ab"]));
ks.cev.sigma_x = DB.Utils.DBDouble(dr["sigma_x"]);
ks.known_alpha_type = (INCCAnalysisParams.KnownAlphaVariant)(DB.Utils.DBInt32(dr["known_alpha_type"]));
ks.ring_ratio.cal_curve_equation = (INCCAnalysisParams.CurveEquation)(DB.Utils.DBInt32(dr["ring_ratio_equation"]));
ks.ring_ratio.a = DB.Utils.DBDouble(dr["ring_ratio_a"]);
ks.ring_ratio.b = DB.Utils.DBDouble(dr["ring_ratio_b"]);
ks.ring_ratio.c = DB.Utils.DBDouble(dr["ring_ratio_c"]);
ks.ring_ratio.d = DB.Utils.DBDouble(dr["ring_ratio_d"]);
ks.dcl_mass = DB.Utils.ReifyDoubles((string)dr["dcl_mass"]);
ks.doubles = DB.Utils.ReifyDoubles((string)dr["doubles"]);
ks.heavy_metal_reference = DB.Utils.DBDouble(dr["heavy_metal_reference"]);
ks.heavy_metal_corr_factor = DB.Utils.DBDouble(dr["heavy_metal_corr_factor"]);
ks.cev.upper_mass_limit = DB.Utils.DBDouble(dr["upper_mass_limit"]);
ks.cev.lower_mass_limit = DB.Utils.DBDouble(dr["lower_mass_limit"]);
}
else
lvl = LogLevels.Info;
ams.AddMethod(am, ks);
break;
case AnalysisMethod.CalibrationCurve:
INCCAnalysisParams.cal_curve_rec cs = new INCCAnalysisParams.cal_curve_rec();
dr = db.Get(sel.detectorid, sel.material, "cal_curve_rec");
if (dr != null)
{
CalCurveDBSnock(cs.cev, dr);
cs.CalCurveType = (INCCAnalysisParams.CalCurveType)DB.Utils.DBInt32(dr["cal_curve_type"]);
cs.dcl_mass = DB.Utils.ReifyDoubles((string)dr["dcl_mass"]);
cs.doubles = DB.Utils.ReifyDoubles((string)dr["doubles"]);
cs.percent_u235 = DB.Utils.DBDouble(dr["percent_u235"]);
cs.heavy_metal_reference = DB.Utils.DBDouble(dr["heavy_metal_reference"]);
cs.heavy_metal_corr_factor = DB.Utils.DBDouble(dr["heavy_metal_corr_factor"]);
}
else
lvl = LogLevels.Info;
ams.AddMethod(am, cs);
break;
case AnalysisMethod.KnownM:
INCCAnalysisParams.known_m_rec ms = new INCCAnalysisParams.known_m_rec();
dr = db.Get(sel.detectorid, sel.material, "known_m_rec");
if (dr != null)
{
ms.sf_rate = DB.Utils.DBDouble(dr["sf_rate"]);
ms.vs1 = DB.Utils.DBDouble(dr["vs1"]);
ms.vs2 = DB.Utils.DBDouble(dr["vs2"]);
ms.vi1 = DB.Utils.DBDouble(dr["vi1"]);
ms.vi2 = DB.Utils.DBDouble(dr["vi2"]);
ms.b = DB.Utils.DBDouble(dr["b"]);
ms.c = DB.Utils.DBDouble(dr["c"]);
ms.sigma_x = DB.Utils.DBDouble(dr["sigma_x"]);
ms.lower_mass_limit = DB.Utils.DBDouble(dr["lower_mass_limit"]);
ms.upper_mass_limit = DB.Utils.DBDouble(dr["upper_mass_limit"]);
}
else
lvl = LogLevels.Info;
ams.AddMethod(am, ms);
break;
case AnalysisMethod.Multiplicity:
INCCAnalysisParams.multiplicity_rec mu = new INCCAnalysisParams.multiplicity_rec();
dr = db.Get(sel.detectorid, sel.material, "multiplicity_rec");
if (dr != null)
{
mu.solve_efficiency = (INCCAnalysisParams.MultChoice)DB.Utils.DBInt32(dr["solve_efficiency"]);
mu.sf_rate = DB.Utils.DBDouble(dr["sf_rate"]);
mu.vs1 = DB.Utils.DBDouble(dr["vs1"]);
mu.vs2 = DB.Utils.DBDouble(dr["vs2"]);
mu.vs3 = DB.Utils.DBDouble(dr["vs3"]);
mu.vi1 = DB.Utils.DBDouble(dr["vi1"]);
mu.vi2 = DB.Utils.DBDouble(dr["vi2"]);
mu.vi3 = DB.Utils.DBDouble(dr["vi3"]);
mu.a = DB.Utils.DBDouble(dr["a"]);
mu.b = DB.Utils.DBDouble(dr["b"]);
mu.c = DB.Utils.DBDouble(dr["c"]);
mu.sigma_x = DB.Utils.DBDouble(dr["sigma_x"]);
mu.alpha_weight = DB.Utils.DBDouble(dr["alpha_weight"]);
mu.multEffCorFactor = DB.Utils.DBDouble(dr["eff_cor"]);
}
else
lvl = LogLevels.Info;
ams.AddMethod(am, mu);
break;
case AnalysisMethod.TruncatedMultiplicity:
INCCAnalysisParams.truncated_mult_rec tm = new INCCAnalysisParams.truncated_mult_rec();
dr = db.Get(sel.detectorid, sel.material, "truncated_mult_rec");
if (dr != null)
{
tm.known_eff = DB.Utils.DBBool(dr["known_eff"]);
tm.solve_eff = DB.Utils.DBBool(dr["vs1"]);
tm.a = DB.Utils.DBDouble(dr["a"]);
tm.b = DB.Utils.DBDouble(dr["b"]);
}
else
lvl = LogLevels.Info;
ams.AddMethod(am, tm);
break;
case AnalysisMethod.CuriumRatio:
INCCAnalysisParams.curium_ratio_rec cm = new INCCAnalysisParams.curium_ratio_rec();
dr = db.Get(sel.detectorid, sel.material, "curium_ratio_rec");
if (dr != null)
{
cm.curium_ratio_type = (INCCAnalysisParams.CuriumRatioVariant)DB.Utils.DBInt32(dr["curium_ratio_type"]);
CalCurveDBSnock(cm.cev, dr);
}
else
lvl = LogLevels.Info;
ams.AddMethod(am, cm);
break;
case AnalysisMethod.Active:
INCCAnalysisParams.active_rec ar = new INCCAnalysisParams.active_rec();
dr = db.Get(sel.detectorid, sel.material, "active_rec");
if (dr != null)
{
CalCurveDBSnock(ar.cev, dr);
ar.dcl_mass = DB.Utils.ReifyDoubles((string)dr["dcl_mass"]);
ar.doubles = DB.Utils.ReifyDoubles((string)dr["doubles"]);
}
else
lvl = LogLevels.Info;
ams.AddMethod(am, ar);
break;
case AnalysisMethod.AddASource:
INCCAnalysisParams.add_a_source_rec aas = new INCCAnalysisParams.add_a_source_rec();
dr = db.Get(sel.detectorid, sel.material, "add_a_source_rec");
if (dr != null)
{
CalCurveDBSnock(aas.cev, dr);
aas.dcl_mass = DB.Utils.ReifyDoubles((string)dr["dcl_mass"]);
aas.doubles = DB.Utils.ReifyDoubles((string)dr["doubles"]);
aas.cf.a = DB.Utils.DBDouble(dr["cf_a"]);
aas.cf.b = DB.Utils.DBDouble(dr["cf_b"]);
aas.cf.c = DB.Utils.DBDouble(dr["cf_c"]);
aas.cf.d = DB.Utils.DBDouble(dr["cf_d"]);
aas.dzero_avg = DB.Utils.DBDouble(dr["dzero_avg"]);
aas.num_runs = DB.Utils.DBUInt16(dr["num_runs"]);
aas.position_dzero = DB.Utils.ReifyDoubles((string)dr["position_dzero"]);
aas.dzero_ref_date = DB.Utils.DBDateTime(dr["dzero_ref_date"]);
aas.use_truncated_mult = DB.Utils.DBBool(dr["use_truncated_mult"]);
aas.tm_dbls_rate_upper_limit = DB.Utils.DBDouble(dr["tm_dbls_rate_upper_limit"]);
aas.tm_weighting_factor = DB.Utils.DBDouble(dr["tm_weighting_factor"]);
}
else
lvl = LogLevels.Info;
ams.AddMethod(am, aas);
break;
case AnalysisMethod.ActiveMultiplicity:
INCCAnalysisParams.active_mult_rec amr = new INCCAnalysisParams.active_mult_rec();
dr = db.Get(sel.detectorid, sel.material, "active_mult_rec");
if (dr != null)
{
amr.vf1 = DB.Utils.DBDouble(dr["vf1"]);
amr.vf2 = DB.Utils.DBDouble(dr["vf2"]);
amr.vf3 = DB.Utils.DBDouble(dr["vf3"]);
amr.vt1 = DB.Utils.DBDouble(dr["vt1"]);
amr.vt2 = DB.Utils.DBDouble(dr["vt2"]);
amr.vt3 = DB.Utils.DBDouble(dr["vt3"]);
}
else
lvl = LogLevels.Info;
ams.AddMethod(am, amr);
break;
case AnalysisMethod.ActivePassive:
INCCAnalysisParams.active_passive_rec acp = new INCCAnalysisParams.active_passive_rec();
dr = db.Get(sel.detectorid, sel.material, "active_passive_rec");
if (dr != null)
{
CalCurveDBSnock(acp.cev, dr);
}
else
lvl = LogLevels.Info;
ams.AddMethod(am, acp);
break;
case AnalysisMethod.Collar:
INCCAnalysisParams.collar_combined_rec cr = new INCCAnalysisParams.collar_combined_rec();
dr = db.Get(sel.detectorid, sel.material, "collar_detector_rec");
if (dr != null)
{
cr.collar_det.collar_mode = DB.Utils.DBBool(dr["collar_detector_mode"]);
cr.collar_det.reference_date = DB.Utils.DBDateTime(dr["reference_date"]);
cr.collar_det.relative_doubles_rate = DB.Utils.DBDouble(dr["relative_doubles_rate"]);
}
else
lvl = LogLevels.Info;
dr = db.Get(sel.detectorid, sel.material, "collar_rec");
if (dr != null)
{
CalCurveDBSnock(cr.collar.cev, dr);
cr.collar.collar_mode = DB.Utils.DBBool(dr["collar_mode"]);
cr.collar.number_calib_rods = DB.Utils.DBInt32(dr["number_calib_rods"]);
cr.collar.sample_corr_fact.v = DB.Utils.DBDouble(dr["sample_corr_fact"]);
cr.collar.sample_corr_fact.err = DB.Utils.DBDouble(dr["sample_corr_fact_err"]);
cr.collar.u_mass_corr_fact_a.v = DB.Utils.DBDouble(dr["u_mass_corr_fact_a"]);
cr.collar.u_mass_corr_fact_a.err = DB.Utils.DBDouble(dr["u_mass_corr_fact_a_err"]);
cr.collar.u_mass_corr_fact_b.v = DB.Utils.DBDouble(dr["u_mass_corr_fact_b"]);
cr.collar.u_mass_corr_fact_b.err = DB.Utils.DBDouble(dr["u_mass_corr_fact_b_err"]);
cr.collar.poison_absorption_fact = DB.Utils.ReifyDoubles(dr["poison_absorption_fact"].ToString());
cr.collar.poison_rod_type = DB.Utils.ReifyStrings(dr["poison_rod_type"].ToString());
TupleArraySlurp(ref cr.collar.poison_rod_a, "poison_rod_a", dr);
TupleArraySlurp(ref cr.collar.poison_rod_b, "poison_rod_b", dr);
TupleArraySlurp(ref cr.collar.poison_rod_c, "poison_rod_c", dr);
}
else
lvl = LogLevels.Info;
dr = db.Get(sel.detectorid, sel.material, "collar_k5_rec");
if (dr != null)
{
cr.k5.k5_mode = DB.Utils.DBBool(dr["k5_mode"]);
cr.k5.k5_checkbox = DB.Utils.ReifyBools(dr["k5_checkbox"].ToString());
cr.k5.k5_item_type = string.Copy(sel.material);
cr.k5.k5_label = DB.Utils.ReifyStrings(dr["k5_label"].ToString());
TupleArraySlurp(ref cr.k5.k5, "k5", dr);
}
else
lvl = LogLevels.Info;
ams.AddMethod(am, cr);
break;
default:
lvl = LogLevels.Error; logid = 34181; current = "Choosing to not construct" + current;
break;
}
switch (lvl)
{
case LogLevels.Info:
current = "Using default for " + current;
lvl = LogLevels.Verbose;
break;
case LogLevels.Verbose:
current = "Retrieved for " + current;
break;
default:
break;
}
NC.App.Pest.logger.TraceEvent(lvl, logid, current);
} // for
}
private void FieldFiller()
{
// Populate the UI fields with values from the local AcquireParameters object
this.QCTestsCheckBox.Checked = ah.ap.qc_tests;
this.PrintResultsCheckBox.Checked = ah.ap.print;
this.CommentAtEndCheckBox.Checked = ah.ap.ending_comment;
this.NumPassiveCyclesTextBox.Text = Format.Rend(ah.ap.num_runs);
this.NumActiveCyclesTextBox.Text = Format.Rend(ah.ap.active_num_runs);
this.CommentTextBox.Text = ah.ap.comment;
this.CountTimeTextBox.Text = Format.Rend(ah.ap.run_count_time);
this.MeasPrecisionTextBox.Text = ah.ap.meas_precision.ToString("F2");
this.MinNumCyclesTextBox.Text = Format.Rend(ah.ap.min_num_runs);
this.MaxNumCyclesTextBox.Text = Format.Rend(ah.ap.max_num_runs);
this.DeclaredMassTextBox.Text = ah.ap.mass.ToString("F3");
this.DrumWeightTextBox.Text = ah.ap.drum_empty_weight.ToString("F3");
this.MBAComboBox.Items.Clear();
InventoryChangeCodeComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in NC.App.DB.InvChangeCodes.GetList())
{
this.InventoryChangeCodeComboBox.Items.Add(desc.Name);
}
IOCodeComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in NC.App.DB.IOCodes.GetList())
{
this.IOCodeComboBox.Items.Add(desc.Name);
}
foreach (INCCDB.Descriptor desc in NC.App.DB.MBAs.GetList())
{
MBAComboBox.Items.Add(desc);
}
this.ItemIdComboBox.Items.Clear();
foreach (ItemId id in NC.App.DB.ItemIds.GetList())
{
ItemIdComboBox.Items.Add(id.item);
}
this.StratumIdComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in NC.App.DB.Stratums.GetList())
{
StratumIdComboBox.Items.Add(desc);
}
this.MaterialTypeComboBox.Items.Clear();
foreach (INCCDB.Descriptor desc in NC.App.DB.Materials.GetList())
{
MaterialTypeComboBox.Items.Add(desc.Name);
}
this.DataSourceComboBox.Items.Clear();
foreach (ConstructedSource cs in System.Enum.GetValues(typeof(ConstructedSource)))
{
if (cs.AcquireChoices() || cs.LMFiles(ah.det.Id.SRType))
{
DataSourceComboBox.Items.Add(cs.HappyFunName());
}
}
if (ah.ap.acquire_type == AcquireConvergence.CycleCount)
{
this.UseNumCyclesRadioButton.Checked = true;
}
else if (ah.ap.acquire_type == AcquireConvergence.DoublesPrecision)
{
this.UseDoublesRadioButton.Checked = true;
}
else if (ah.ap.acquire_type == AcquireConvergence.TriplesPrecision)
{
this.UseTriplesRadioButton.Checked = true;
}
else if (ah.ap.acquire_type == AcquireConvergence.Pu240EffPrecision)
{
this.UsePu240eRadioButton.Checked = true;
}
DataSourceComboBox.SelectedItem = ah.ap.data_src.HappyFunName();
MaterialTypeComboBox.SelectedItem = ah.ap.item_type;
StratumIdComboBox.SelectedItem = ah.ap.stratum_id;
MBAComboBox.SelectedItem = ah.ap.mba;
InventoryChangeCodeComboBox.SelectedItem = ah.ap.inventory_change_code;
IOCodeComboBox.SelectedItem = ah.ap.io_code;
ItemIdComboBox.SelectedItem = ah.ap.item_id;
am = Integ.GetMethodSelections(ah.ap);
if (am != null)
{
if (am.Has(AnalysisMethod.CuriumRatio))
{
IsotopicsBtn.Enabled = false; CompositeIsotopicsBtn.Enabled = false;
}
if (am.Has(AnalysisMethod.ActivePassive) || am.Has(AnalysisMethod.Collar))
{
NumActiveCyclesLabel.Visible = NumActiveCyclesTextBox.Visible = true;
}
else
{
NumActiveCyclesLabel.Visible = NumActiveCyclesTextBox.Visible = false;
}
if (!am.Has(AnalysisMethod.AddASource))
{
DrumWeightLabel.Visible = DrumWeightTextBox.Visible = false;
DrumWeightTextBox.Text = ah.ap.drum_empty_weight.ToString("F3");
}
}
}
public IDDSelectPrimaryAM(AnalysisDefs.AnalysisMethods aam)
{
am = aam;
InitializeComponent();
EnableThoseWhomAreChosen();
if (am.Normal == AnalysisMethod.None)
{
am.Normal = am.GetFirstSelected();
}
switch (am.Normal)
{
case AnalysisMethod.None:
case AnalysisMethod.INCCNone:
break;
case AnalysisMethod.CalibrationCurve:
CalibrationCurveRadioButton.Checked = true;
break;
case AnalysisMethod.KnownA:
KnownAlphaRadioButton.Checked = true;
break;
case AnalysisMethod.KnownM:
KnownMRadioButton.Checked = true;
break;
case AnalysisMethod.Multiplicity:
MultiplicityRadioButton.Checked = true;
break;
case AnalysisMethod.AddASource:
AddASourceRadioButton.Checked = true;
break;
case AnalysisMethod.CuriumRatio:
CuriumRatioRadioButton.Checked = true;
break;
case AnalysisMethod.TruncatedMultiplicity:
TruncatedMultiplicityRadioButton.Checked = true;
break;
}
if (am.Backup.IsNone() || am.Normal == am.Backup)
{
am.Backup = am.GetSecondSelected();
}
switch (am.Backup)
{
case AnalysisMethod.None:
case AnalysisMethod.INCCNone:
break;
case AnalysisMethod.CalibrationCurve:
BCalibrationCurveRadioButton.Checked = true;
break;
case AnalysisMethod.KnownA:
BKnownAlphaRadioButton.Checked = true;
break;
case AnalysisMethod.KnownM:
BKnownMRadioButton.Checked = true;
break;
case AnalysisMethod.Multiplicity:
BMultiplicityRadioButton.Checked = true;
break;
case AnalysisMethod.AddASource:
BAddASourceRadioButton.Checked = true;
break;
case AnalysisMethod.CuriumRatio:
BCuriumRatioRadioButton.Checked = true;
break;
case AnalysisMethod.TruncatedMultiplicity:
BTruncatedMultiplicityRadioButton.Checked = true;
break;
}
if (am.Auxiliary.IsNone() || am.Auxiliary == am.Backup)
{
am.Auxiliary = am.GetThirdSelected();
}
switch (am.Auxiliary)
{
case AnalysisMethod.None:
case AnalysisMethod.INCCNone:
break;
case AnalysisMethod.CalibrationCurve:
ACalibrationCurveRadioButton.Checked = true;
break;
case AnalysisMethod.KnownA:
AKnownAlphaRadioButton.Checked = true;
break;
case AnalysisMethod.KnownM:
AKnownMRadioButton.Checked = true;
break;
case AnalysisMethod.Multiplicity:
AMultiplicityRadioButton.Checked = true;
break;
case AnalysisMethod.AddASource:
AAddASourceRadioButton.Checked = true;
break;
case AnalysisMethod.CuriumRatio:
ACuriumRatioRadioButton.Checked = true;
break;
case AnalysisMethod.TruncatedMultiplicity:
ATruncatedMultiplicityRadioButton.Checked = true;
break;
}
}
private void OKBtn_Click(object sender, EventArgs e)
{
if (DeclaredMassTextBox.Value != ah.ap.mass)
{
ah.ap.mass = DeclaredMassTextBox.Value; ah.ap.modified = true;
}
if (CountTimeTextBox.Value != ah.ap.run_count_time)
{
ah.ap.run_count_time = CountTimeTextBox.Value; ah.ap.modified = true;
}
if ((ushort)NumCyclesTextBox.Value != ah.ap.num_runs)
{
ah.ap.num_runs = (ushort)NumCyclesTextBox.Value; ah.ap.modified = true;
}
if (MeasPrecisionTextBox.Value != ah.ap.meas_precision)
{
ah.ap.meas_precision = MeasPrecisionTextBox.Value; ah.ap.modified = true;
}
if ((ushort)MinNumCyclesTextBox.Value != ah.ap.min_num_runs)
{
ah.ap.min_num_runs = (ushort)MinNumCyclesTextBox.Value; ah.ap.modified = true;
}
if ((ushort)MaxNumCyclesTextBox.Value != ah.ap.max_num_runs)
{
ah.ap.max_num_runs = (ushort)MaxNumCyclesTextBox.Value; ah.ap.modified = true;
}
if (ah.ap.modified)
{
NCC.CentralizedState.App.DB.UpdateAcquireParams(ah.ap);
}
if (ah.det.ListMode)
{
CreateMultiplicityAnalyzer();
}
// save/update item id changes only when user selects OK
NC.App.DB.ItemIds.Set(); // writes any new or modified item ids to the DB
NC.App.DB.ItemIds.Refresh(); // save and update the in-memory item list
DialogResult res = DialogResult.Cancel;
/* build message to warn user about selected analysis methods and requirements for calibration of known alpha. */
AnalysisMethods am = Integ.GetMethodSelections(ah.ap);
if (am == null || !am.CalibrationAnalysisSelected())
{
MessageBox.Show("Warning - no analysis methods selected for calibration.", "Check calibration methods", MessageBoxButtons.OKCancel);
}
else
{
string a = string.Format("These analysis methods are selected for calibration of material type {0} for detector {1}",
ah.ap.item_type,
ah.ap.detector_id);
if (am.Has(AnalysisMethod.CalibrationCurve))
{
a += "\r\n" + " Calibration Curve";
}
if (am.Has(AnalysisMethod.Active))
{
a += "\r\n" + " Active";
}
if (am.Has(AnalysisMethod.AddASource))
{
a += "\r\n" + " Add-A-Source";
}
if (am.Has(AnalysisMethod.KnownA))
{
a += "\r\n" + " Known Alpha";
a += "\r\n Known alpha calibration requires correct values for alpha weight and rho zero.";
}
a += "\r\n" + String.Format("Declared mass for item {0} = {1}\r\n", ah.ap.item_id, ah.ap.mass.ToString("F4"));
res = MessageBox.Show(a, "Check calibration methods", MessageBoxButtons.OKCancel);
}
if (res != DialogResult.OK)
{
return;
}
if (ah.OKButton_Click(sender, e) == System.Windows.Forms.DialogResult.OK)
{
//user can cancel in here during LM set-up, account for it.
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
Close();
}
}
public void UpdateAnalysisMethods(INCCSelector sel, AnalysisMethods am, DB.AnalysisMethodSpecifiers db = null)
{
if (db == null)
db = new DB.AnalysisMethodSpecifiers();
DB.ElementList saParams;
saParams = am.ToDBElementList();
if (!db.Update(sel.detectorid, sel.material, saParams)) // am not there, so add it
{
NC.App.Pest.logger.TraceEvent(LogLevels.Verbose, 34027, "Failed to update analysis method spec for " + sel.ToString());
}
else
{
NC.App.Pest.logger.TraceEvent(LogLevels.Verbose, 34026, "Updated/created analysis method spec for " + sel.ToString());
}
am.modified = false;
}
