示例#1
0
        public MeasPointData GetTheDataPoints(Measurement m)
        {
            MeasPointData           p   = new MeasPointData(m.MeasDate);
            MultiplicityCountingRes mcr = (MultiplicityCountingRes)m.CountingAnalysisResults[m.Detector.MultiplicityParams];
            INCCMethodResult        imr = m.INCCAnalysisResults.LookupMethodResults(m.Detector.MultiplicityParams, m.INCCAnalysisState.Methods.selector, AnalysisMethod, create: false);

            switch (AnalysisMethod)
            {
            case AnalysisMethod.CalibrationCurve:
                INCCMethodResults.results_cal_curve_rec ccres = (INCCMethodResults.results_cal_curve_rec)imr;
                p.Doubles = mcr.DeadtimeCorrectedDoublesRate.v;
                p.Mass    = ccres.dcl_pu240e_mass;
                break;

            case AnalysisMethod.KnownA:
                INCCMethodResults.results_known_alpha_rec kares = (INCCMethodResults.results_known_alpha_rec)imr;
                p.Doubles = (kares.mult_corr_doubles.v == 0 ? mcr.DeadtimeCorrectedDoublesRate.v : kares.mult_corr_doubles.v);
                p.Mass    = kares.dcl_pu240e_mass;
                break;

            case AnalysisMethod.AddASource:
                INCCMethodResults.results_add_a_source_rec aares = (INCCMethodResults.results_add_a_source_rec)imr;
                p.Doubles = mcr.DeadtimeCorrectedDoublesRate.v;
                p.Mass    = aares.dcl_pu240e_mass;
                break;

            case AnalysisMethod.Active:
                INCCMethodResults.results_active_rec acres = (INCCMethodResults.results_active_rec)imr;
                p.Doubles = mcr.DeadtimeCorrectedDoublesRate.v;
                p.Mass    = acres.dcl_u235_mass;
                break;
            }
            return(p);
        }
示例#2
0
        public DoublesDclMass GetTheDataPoints(Measurement m)
        {
            DoublesDclMass dl = new DoublesDclMass();

            dl.dt = m.MeasDate;
            MultiplicityCountingRes mcr = (MultiplicityCountingRes)m.CountingAnalysisResults[m.Detector.MultiplicityParams];

            dl.Doubles = mcr.DeadtimeCorrectedDoublesRate;
            INCCMethodResult imr = m.INCCAnalysisResults.LookupMethodResults(m.Detector.MultiplicityParams, m.INCCAnalysisState.Methods.selector, AnalysisMethod, create: false);

            switch (AnalysisMethod)
            {
            case AnalysisMethod.CalibrationCurve:
                INCCMethodResults.results_cal_curve_rec ccres = (INCCMethodResults.results_cal_curve_rec)imr;
                dl.Mass = ccres.pu240e_mass;
                break;

            case AnalysisMethod.KnownA:
                INCCMethodResults.results_known_alpha_rec kares = (INCCMethodResults.results_known_alpha_rec)imr;
                dl.Mass = kares.pu240e_mass;
                break;

            case AnalysisMethod.AddASource:
                INCCMethodResults.results_add_a_source_rec aares = (INCCMethodResults.results_add_a_source_rec)imr;
                dl.Mass = aares.pu240e_mass;
                break;

            case AnalysisMethod.Active:
                INCCMethodResults.results_active_rec acres = (INCCMethodResults.results_active_rec)imr;
                dl.Mass = acres.u235_mass;
                break;
            }
            return(dl);
        }
示例#3
0
        // INCC5 enables subselecting each field and creates a two line header instead of one.
        Dictionary <string, string> GenerateEntries(Selections s, Measurement m)
        {
            Dictionary <string, string> entries = new Dictionary <string, string>();

            switch (s)
            {
            case Selections.AcquireParams:
                entries["Facility"]          = Q(m.AcquireState.facility.Name);
                entries["MBA"]               = Q(m.AcquireState.mba.Name);
                entries["Detector"]          = Q(m.AcquireState.detector_id);
                entries["IC"]                = Q(m.AcquireState.inventory_change_code);
                entries["IO"]                = Q(m.AcquireState.io_code);
                entries["Measurement Type"]  = Q(m.MeasOption.PrintName());
                entries["Meas Date"]         = m.MeasurementId.MeasDateTime.ToString("yy.MM.dd");
                entries["Meas Time"]         = m.MeasurementId.MeasDateTime.ToString("HH:mm:ss");
                entries["File Name"]         = Q(GetMainFilePath(m.ResultsFiles, m.MeasOption, true));
                entries["Inspector"]         = Q(m.AcquireState.user_id);
                entries["Inspection Number"] = Q(m.AcquireState.campaign_id);
                entries["Item ID"]           = Q(m.AcquireState.item_id);
                entries["Isotopics ID"]      = Q(m.AcquireState.isotopics_id);
                entries["Stratum ID"]        = Q(m.AcquireState.stratum_id.Name);
                entries["Material Type"]     = Q(m.AcquireState.item_type);
                break;

            case Selections.NormalizationParams:
                entries["Norm Cnst"]       = m.Norm.currNormalizationConstant.v.ToString("F4");           //	"Normalization constant"
                entries["Norm Cnst Error"] = m.Norm.currNormalizationConstant.err.ToString("F4");         //	"Normalization constant error"
                break;

            case Selections.BackgroundParams:
                entries["Singles Bkg"]         = m.Background.DeadtimeCorrectedSinglesRate.v.ToString("F1");   //	"Passive singles background"
                entries["Singles Bkg Error"]   = m.Background.DeadtimeCorrectedSinglesRate.err.ToString("F3"); //	"Passive singles background error"
                entries["Doubles Bkg"]         = m.Background.DeadtimeCorrectedDoublesRate.v.ToString("F2");   //	"Passive doubles background"
                entries["Doubles Bkg Error"]   = m.Background.DeadtimeCorrectedDoublesRate.err.ToString("F3"); //	"Passive doubles background error"
                entries["Triples Bkg"]         = m.Background.DeadtimeCorrectedTriplesRate.v.ToString("F2");   //	"Passive triples background"
                entries["Triples Bkg Error"]   = m.Background.DeadtimeCorrectedTriplesRate.err.ToString("F3"); //	"Passive triples background error"
                entries["Act Sngls Bkg"]       = m.Background.INCCActive.SinglesRate.ToString("F1");           //	"Active singles background"
                entries["Act Sngls Bkg Error"] = m.Background.INCCActive.Singles.err.ToString("F3");           //	"Active singles background error"
                break;

            case Selections.Summaries:
                if (m.INCCAnalysisState != null && m.INCCAnalysisResults != null)
                {
                    System.Collections.IEnumerator iter = m.INCCAnalysisResults.GetMeasSelectorResultsEnumerator();
                    while (iter.MoveNext())
                    {
                        MeasOptionSelector moskey = (MeasOptionSelector)iter.Current;
                        INCCResult         ir     = m.INCCAnalysisResults[moskey];
                        entries["Singles"]       = ir.DeadtimeCorrectedSinglesRate.v.ToString("F1");                   //	"Singles"
                        entries["Singles Error"] = ir.DeadtimeCorrectedSinglesRate.err.ToString("F3");                 //	"Singles error"
                        entries["Doubles"]       = ir.DeadtimeCorrectedDoublesRate.v.ToString("F2");                   //	"Doubles"
                        entries["Doubles Error"] = ir.DeadtimeCorrectedDoublesRate.err.ToString("F3");                 //	"Doubles error"
                        entries["Triples"]       = ir.DeadtimeCorrectedTriplesRate.v.ToString("F2");                   //	"Triples"
                        entries["Triples Error"] = ir.DeadtimeCorrectedTriplesRate.err.ToString("F3");                 //	"Triples error"
                        if (ir.Scaler1.v > 0 || ir.Scaler2.v > 0)
                        {
                            entries["Scaler 1"]       = ir.Scaler1.v.ToString("F1");
                            entries["Scaler 1 Error"] = ir.Scaler1.err.ToString("F3");
                            entries["Scaler 2"]       = ir.Scaler2.v.ToString("F1");
                            entries["Scaler 2 Error"] = ir.Scaler2.err.ToString("F3");
                        }
                        entries["Count Time"]  = (m.Cycles.Count > 0 ? m.Cycles[0].TS.TotalSeconds.ToString("F0") : "0"); // "Total count time for a measurement"
                        entries["Singles Sum"] = m.SinglesSum.ToString("F0");                                             // Sums - singles  Singles sum for a measurement"
                        entries["R+A Sum"]     = ir.RASum.ToString("F0");                                                 // Reals + accidentals sum for a measurement"
                        entries["A Sum"]       = ir.ASum.ToString("F0");                                                  // "Accidentals sum for a measurement"
                    }
                }
                break;

            case Selections.Comments:
                entries["Comment"] = m.AcquireState.comment;
                if (m.INCCAnalysisResults.TradResultsRec.acq.ending_comment &&
                    !string.IsNullOrEmpty(m.INCCAnalysisResults.TradResultsRec.acq.ending_comment_str))
                {
                    entries["End Comment"] = m.AcquireState.ending_comment_str;
                }
                break;

            case Selections.MassAnalysisMethods:
                break;

            case Selections.CalibrationCurve:
                INCCMethodResults.results_cal_curve_rec ccres = (INCCMethodResults.results_cal_curve_rec)
                                                                m.INCCAnalysisResults.LookupMethodResults(m.Detector.MultiplicityParams, m.INCCAnalysisState.Methods.selector, AnalysisMethod.CalibrationCurve, false);
                if (ccres != null)
                {
                    entries["Cal Cur Dcl Mass"]  = ccres.dcl_pu_mass.ToString("F2");               //	Calibration curve - declared mass"
                    entries["Cal Cur Mass"]      = ccres.pu_mass.v.ToString("F2");                 //	"Calibration curve - mass"
                    entries["Cal Cur Mass Err"]  = ccres.pu_mass.err.ToString("F3");               //	"Calibration curve - mass error"
                    entries["Cal Cur Dcl-Asy"]   = ccres.dcl_minus_asy_pu_mass.v.ToString("F2");   //	"Calibration curve - declared minus assay"
                    entries["Cal Cur Dcl-Asy %"] = ccres.dcl_minus_asy_pu_mass_pct.ToString("F2"); //	"Calibration curve - declared minus assay %"
                    entries["Cal Cur Status"]    = ccres.pass ? "Pass": "";                        //	"Calibration curve - measurement status"
                }
                break;

            case Selections.KnownAlpha:
                INCCMethodResults.results_known_alpha_rec kares = (INCCMethodResults.results_known_alpha_rec)
                                                                  m.INCCAnalysisResults.LookupMethodResults(m.Detector.MultiplicityParams, m.INCCAnalysisState.Methods.selector, AnalysisMethod.KnownA, false);
                if (kares != null)
                {
                    entries["Known A Dcl Mass"]  = kares.dcl_pu_mass.ToString("F2");               //	Known alpha - declared mass"
                    entries["Known A Mass"]      = kares.pu_mass.v.ToString("F2");                 //	"Known alpha - mass"
                    entries["Known A Mass Err"]  = kares.pu_mass.err.ToString("F3");               //	"Known alpha - mass error"
                    entries["Known A Dcl-Asy"]   = kares.dcl_minus_asy_pu_mass.v.ToString("F2");   //	"Known alpha - declared minus assay"
                    entries["Known A Dcl-Asy %"] = kares.dcl_minus_asy_pu_mass_pct.ToString("F2"); //	"Known alpha - declared minus assay %"
                    entries["Known A Mult"]      = kares.mult.ToString("F3");                      //	"Known alpha - multiplication"
                    entries["Known A Alpha"]     = kares.alphaK.ToString("F3");                    //	"Known alpha - alpha"
                    entries["Known A Status"]    = kares.pass ? "Pass": "";                        //	"Known alpha - measurement status"
                }
                break;

            case Selections.KnownM:
                INCCMethodResults.results_known_m_rec kmres = (INCCMethodResults.results_known_m_rec)
                                                              m.INCCAnalysisResults.LookupMethodResults(m.Detector.MultiplicityParams, m.INCCAnalysisState.Methods.selector, AnalysisMethod.KnownM, false);
                if (kmres != null)
                {
                    entries["Known M Dcl Mass"]  = kmres.dcl_pu_mass.ToString("F2");               //	Known M - declared mass"
                    entries["Known M Mass"]      = kmres.pu_mass.v.ToString("F2");                 //	"Known M - mass"
                    entries["Known M Mass Err"]  = kmres.pu_mass.err.ToString("F3");               //	"Known M - mass error"
                    entries["Known M Dcl-Asy"]   = kmres.dcl_minus_asy_pu_mass.v.ToString("F2");   //	"Known M - declared minus assay"
                    entries["Known M Dcl-Asy %"] = kmres.dcl_minus_asy_pu_mass_pct.ToString("F2"); //	"Known M - declared minus assay %"
                    entries["Known M Mult"]      = kmres.mult.ToString("F3");                      //	"Known M - multiplication"
                    entries["Known M Alpha"]     = kmres.alpha.ToString("F3");                     //	"Known M - alpha"
                    entries["Known M Status"]    = kmres.pass ? "Pass": "";                        //	"Known M - measurement status"
                }
                break;

            case Selections.Multiplicity:
                INCCMethodResults.results_multiplicity_rec mres = (INCCMethodResults.results_multiplicity_rec)
                                                                  m.INCCAnalysisResults.LookupMethodResults(m.Detector.MultiplicityParams, m.INCCAnalysisState.Methods.selector, AnalysisMethod.Multiplicity, false);
                if (mres != null)
                {
                    entries["Mult Dcl Mass"]    = mres.dcl_pu_mass.ToString("F2");               //	Multiplicity - declared mass"
                    entries["Mult Mass"]        = mres.pu_mass.v.ToString("F2");                 //	"Multiplicity- mass"
                    entries["Mult Mass Err"]    = mres.pu_mass.err.ToString("F3");               //	"Multiplicity - mass error"
                    entries["Mult Dcl-Asy"]     = mres.dcl_minus_asy_pu_mass.v.ToString("F2");   //	"Multiplicity - declared minus assay"
                    entries["Mult Dcl-Asy %"]   = mres.dcl_minus_asy_pu_mass_pct.ToString("F2"); //	"Multiplicity - declared minus assay %"
                    entries["Mult Mult"]        = mres.mult.v.ToString("F3");                    //	"Multiplicity - multiplication"
                    entries["Mult Mult Err"]    = mres.mult.err.ToString("F3");                  //	"Multiplicity - multiplication error"
                    entries["Mult Alpha"]       = mres.alphaK.v.ToString("F3");                  //	"Multiplicity - alpha"
                    entries["Mult Alpha Err"]   = mres.alphaK.err.ToString("F3");                //	"Multiplicity - alpha error"
                    entries["Mult Efficiency"]  = mres.efficiencyComputed.v.ToString("F3");      //	"Multiplicity - efficiency"
                    entries["Mult Eff Err"]     = mres.efficiencyComputed.err.ToString("F3");    //	"Multiplicity - efficiency error"
                    entries["Mult Status"]      = mres.pass ? "Pass": "";                        //	"Multiplicity - measurement status"
                    entries["Mult Predelay ms"] = m.Detector.SRParams.predelayMS.ToString();     //     "Multiplicity - predelay "
                    entries["Mult Gate ms"]     = m.Detector.SRParams.gateLengthMS.ToString();   //     "Multiplicity - gate width"
                }
                break;

            case Selections.AddASource:
                INCCMethodResults.results_add_a_source_rec aares = (INCCMethodResults.results_add_a_source_rec)
                                                                   m.INCCAnalysisResults.LookupMethodResults(m.Detector.MultiplicityParams, m.INCCAnalysisState.Methods.selector, AnalysisMethod.AddASource, false);
                if (aares != null)
                {
                    entries["Add-a-src Dcl Mass"]  = aares.dcl_pu_mass.ToString("F2");               //	Add-a-source - declared mass"
                    entries["Add-a-src Mass"]      = aares.pu_mass.v.ToString("F2");                 //	"Add-a-source - mass"
                    entries["Add-a-src Mass Err"]  = aares.pu_mass.err.ToString("F3");               //	"Add-a-source - mass error"
                    entries["Add-a-src Dcl-Asy"]   = aares.dcl_minus_asy_pu_mass.v.ToString("F2");   //	"Add-a-source - declared minus assay"
                    entries["Add-a-src Dcl-Asy %"] = aares.dcl_minus_asy_pu_mass_pct.ToString("F2"); //	"Add-a-source - declared minus assay %"
                    entries["Add-a-src Status"]    = aares.pass ? "Pass": "";                        //	"Add-a-source - measurement status"
                    entries["Add-a-src Corr"]      = aares.corr_factor.v.ToString("F3");             //	"Add-a-source - measurement status"
                }
                break;

            case Selections.CuriumRatio:
                INCCMethodResults.results_curium_ratio_rec cures = (INCCMethodResults.results_curium_ratio_rec)
                                                                   m.INCCAnalysisResults.LookupMethodResults(m.Detector.MultiplicityParams, m.INCCAnalysisState.Methods.selector, AnalysisMethod.CuriumRatio, false);
                if (cures != null)
                {
                    entries["Cm Ratio ID"]       = cures.methodParams2.cm_id;                               // Curium ratio - ID"
                    entries["Cm Ratio Input ID"] = cures.methodParams2.cm_input_batch_id;                   // Curium ratio - input batch ID"
                    entries["Cm Ratio Cm/Pu"]    = cures.methodParams2.cm_pu_ratio.v.ToString("F4");        // Curium ratio - Cm/Pu ratio"
                    entries["Cm Ratio Cm/U"]     = cures.methodParams2.cm_u_ratio.v.ToString("F4");         // Curium ratio - Cm/U ratio"
                    entries["Cm Mass"]           = cures.cm_mass.v.ToString("F3");                          // Curium ratio - Cm mass"
                    entries["Cm Err"]            = cures.cm_mass.err.ToString("F3");                        // Curium ratio - Cm mass error"

                    entries["Cm Ratio Pu Dcl Mass"]    = cures.pu.dcl_pu_mass.ToString("F2");               // Curium ratio - declared mass"
                    entries["Cm Ratio Pu Mass"]        = cures.pu.pu_mass.v.ToString("F2");                 //	"Curium ratio - mass"
                    entries["Cm Ratio Pu Mass Err"]    = cures.pu.pu_mass.err.ToString("F3");               //	"Curium ratio - mass error"
                    entries["Cm Ratio Pu Dcl-Asy"]     = cures.pu.dcl_minus_asy_pu_mass.v.ToString("F2");   //	"Curium ratio - declared minus assay"
                    entries["Cm Ratio Pu Dcl-Asy %"]   = cures.pu.dcl_minus_asy_pu_mass_pct.ToString("F2"); //	"Curium ratio - declared minus assay %"
                    entries["Cm Ratio U Dcl Mass"]     = cures.u.dcl_mass.ToString("F2");                   // "Curium ratio - U declared mass"
                    entries["Cm Ratio U Mass"]         = cures.u.mass.v.ToString("F2");                     //	"Curium ratio - U mass"
                    entries["Cm Ratio U Mass Err"]     = cures.u.mass.err.ToString("F3");                   //	"Curium ratio - U mass error"
                    entries["Cm Ratio U Dcl-Asy"]      = cures.u.dcl_minus_asy_mass.v.ToString("F2");       //	"Curium ratio - U declared minus assay"
                    entries["Cm Ratio U Dcl-Asy %"]    = cures.u.dcl_minus_asy_mass_pct.ToString("F2");     //	"Curium ratio - U declared minus assay %"
                    entries["Cm Ratio U235 Dcl Mass"]  = cures.u235.dcl_mass.ToString("F2");                // Curium ratio - U235 declared mass"
                    entries["Cm Ratio U235 Mass"]      = cures.u235.mass.v.ToString("F2");                  //	"Curium ratio - U235 mass"
                    entries["Cm Ratio U235 Mass Err"]  = cures.u235.mass.err.ToString("F3");                //	"Curium ratio - U235 mass error"
                    entries["Cm Ratio U235 Dcl-Asy"]   = cures.u235.dcl_minus_asy_mass.v.ToString("F2");    //	"Curium ratio - U235 declared minus assay"
                    entries["Cm Ratio U235 Dcl-Asy %"] = cures.u235.dcl_minus_asy_mass_pct.ToString("F2");  //	"Curium ratio - U235 declared minus assay %"
                    entries["Cm Ratio Pu Status"]      = cures.pu.pass ? "Pass": "";                        //	"Curium ratio - Pu measurement status"
                    entries["Cm Ratio U Status"]       = cures.u.pass ? "Pass": "";                         //	"Curium ratio - U measurement status"
                }
                break;

            case Selections.TruncatedMultiplicity:
                INCCMethodResults.results_truncated_mult_rec tmres = (INCCMethodResults.results_truncated_mult_rec)
                                                                     m.INCCAnalysisResults.LookupMethodResults(m.Detector.MultiplicityParams, m.INCCAnalysisState.Methods.selector, AnalysisMethod.TruncatedMultiplicity, false);
                if (tmres != null)
                {
                    entries["Trunc Mult Dcl Mass"] = tmres.k.dcl_mass.ToString("F2");               // "Truncated multiplicity - declared mass"
                    entries["Trunc Mult Mass"]     = tmres.k.pu_mass.v.ToString("F2");              // "Truncated multiplicity - mass"
                    entries["Trunc Mult Mass Err"] = tmres.k.pu_mass.err.ToString("F3");            // "Truncated multiplicity - mass error"
                    entries["Trunc Mult Dcl-Asy"]  = tmres.k.dcl_minus_asy_mass.v.ToString("F2");   // "Truncated multiplicity - declared minus assay"
                    entries["Trunc Dcl-Asy %"]     = tmres.k.dcl_minus_asy_mass_pct.ToString("F2"); //"Truncated multiplicity - declared minus assay %"
                    entries["Trunc Mult Status"]   = tmres.k.pass ? "Pass": "";                     // "Truncated multiplicity - measurement status"  // todo: what about 's'?
                }
                break;

            case Selections.ActiveCalibCurve:
                INCCMethodResults.results_active_rec acres = (INCCMethodResults.results_active_rec)
                                                             m.INCCAnalysisResults.LookupMethodResults(m.Detector.MultiplicityParams, m.INCCAnalysisState.Methods.selector, AnalysisMethod.Active, false);
                if (acres != null)
                {
                    entries["Active Dcl Mass"]  = acres.dcl_u235_mass.ToString("F2");               //	Active calibration curve - declared mass"
                    entries["Active Mass"]      = acres.u235_mass.v.ToString("F2");                 //	"Active calibration curve - mass"
                    entries["Active Mass Err"]  = acres.u235_mass.err.ToString("F3");               //	"Active calibration curve - mass error"
                    entries["Active Dcl-Asy"]   = acres.dcl_minus_asy_u235_mass.v.ToString("F2");   //	"Active calibration curve - declared minus assay"
                    entries["Active Dcl-Asy %"] = acres.dcl_minus_asy_u235_mass_pct.ToString("F2"); //	"Active calibration curve - declared minus assay %"
                    entries["Active Status"]    = acres.pass ? "Pass": "";                          //	"Active calibration curve - measurement status"
                }
                break;

            case Selections.CollarAmLi:
                INCCMethodResults.results_collar_rec rcres = (INCCMethodResults.results_collar_rec)
                                                             m.INCCAnalysisResults.LookupMethodResults(m.Detector.MultiplicityParams, m.INCCAnalysisState.Methods.selector, AnalysisMethod.CollarAmLi, false);
                if (rcres != null)
                {
                    entries["Collar Dbls Rate"]     = rcres.total_corr_fact.v.ToString("F2");           //	Collar - corrected doubles rate"
                    entries["Collar Dbls Rate Err"] = rcres.total_corr_fact.v.ToString("F2");           //	Collar -- corrected doubles rate error"
                    entries["Collar Dcl Mass"]      = rcres.dcl_total_u235.v.ToString("F2");            //	Collar - declared mass"
                    entries["Collar Mass"]          = rcres.u235_mass.v.ToString("F2");                 //	"Collar - mass"
                    entries["Collar Mass Err"]      = rcres.u235_mass.err.ToString("F3");               //	"Collar - mass error"
                    entries["Collar Dcl-Asy"]       = rcres.dcl_minus_asy_u235_mass.v.ToString("F2");   //	"Collar - declared minus assay"
                    entries["Collar Dcl-Asy %"]     = rcres.dcl_minus_asy_u235_mass_pct.ToString("F2"); //	"Collar - declared minus assay %"
                    entries["Collar Status"]        = rcres.pass ? "Pass": "";                          //	"Collar - measurement status"
                }
                break;

            case Selections.CollarCf:
                rcres = (INCCMethodResults.results_collar_rec)
                        m.INCCAnalysisResults.LookupMethodResults(m.Detector.MultiplicityParams, m.INCCAnalysisState.Methods.selector, AnalysisMethod.CollarCf, false);
                if (rcres != null)
                {
                    entries["Collar Dbls Rate"]     = rcres.total_corr_fact.v.ToString("F2");           //	Collar - corrected doubles rate"
                    entries["Collar Dbls Rate Err"] = rcres.total_corr_fact.v.ToString("F2");           //	Collar -- corrected doubles rate error"
                    entries["Collar Dcl Mass"]      = rcres.dcl_total_u235.v.ToString("F2");            //	Collar - declared mass"
                    entries["Collar Mass"]          = rcres.u235_mass.v.ToString("F2");                 //	"Collar - mass"
                    entries["Collar Mass Err"]      = rcres.u235_mass.err.ToString("F3");               //	"Collar - mass error"
                    entries["Collar Dcl-Asy"]       = rcres.dcl_minus_asy_u235_mass.v.ToString("F2");   //	"Collar - declared minus assay"
                    entries["Collar Dcl-Asy %"]     = rcres.dcl_minus_asy_u235_mass_pct.ToString("F2"); //	"Collar - declared minus assay %"
                    entries["Collar Status"]        = rcres.pass ? "Pass" : "";                         //	"Collar - measurement status"
                }
                break;

            default:
                break;
            }
            return(entries);
        }
示例#4
0
        // Based on the measurement type and result, show a bunch of stuff
        void FieldFiller()
        {
            Measurement m    = N.App.Opstate.Measurement;
            int         rep  = m.CountingAnalysisResults.GetResultsCount(typeof(Multiplicity));
            int         i    = 0;
            IEnumerator iter = m.CountingAnalysisResults.GetMultiplicityEnumerator();

            while (iter.MoveNext())
            {
                i++;
                string             augmenter = (rep > 1 ? " " + i.ToString() : ""); // use mkey indicator here, not just this indexer
                Multiplicity       mkey      = (Multiplicity)((KeyValuePair <SpecificCountingAnalyzerParams, object>)(iter.Current)).Key;
                INCCResult         r;
                MeasOptionSelector moskey = new MeasOptionSelector(m.MeasOption, mkey);
                bool found = m.INCCAnalysisResults.TryGetValue(moskey, out r);  // APluralityOfMultiplicityAnalyzers:
                switch (m.MeasOption)
                {
                case AssaySelector.MeasurementOption.rates:
                case AssaySelector.MeasurementOption.background:
                    //if (passive)
                    listView1.Items.Add(new ListViewItem(new string[] { "Passive rates" + augmenter }));
                    listView1.Items.Add(new ListViewItem(new string[] {
                        string.Format(" Singles: {0,13:F3} +- {1,9:F3}", r.DeadtimeCorrectedSinglesRate.v, r.DeadtimeCorrectedSinglesRate.err)
                    }));
                    listView1.Items.Add(new ListViewItem(new string[] {
                        string.Format(" Doubles: {0,13:F3} +- {1,9:F3}", r.DeadtimeCorrectedDoublesRate.v, r.DeadtimeCorrectedDoublesRate.err)
                    }));
                    listView1.Items.Add(new ListViewItem(new string[] {
                        string.Format(" Triples: {0,13:F3} +- {1,9:F3}", r.DeadtimeCorrectedTriplesRate.v, r.DeadtimeCorrectedTriplesRate.err)
                    }));
                    listView1.Items.Add(new ListViewItem(new string[] {
                        string.Format("Scaler 1: {0,13:F3} +- {1,9:F3}", r.Scaler1Rate.v, r.Scaler1Rate.err)
                    }));
                    listView1.Items.Add(new ListViewItem(new string[] {
                        string.Format("Scaler 2: {0,13:F3} +- {1,9:F3}", r.Scaler2Rate.v, r.Scaler2Rate.err)
                    }));
                    //if (active)
                    break;

                case AssaySelector.MeasurementOption.initial:
                    INCCResults.results_init_src_rec isr = (INCCResults.results_init_src_rec)r;
                    listView1.Items.Add(new ListViewItem(new string[] {
                        string.Format("                 Source id: {0}", isr.init_src_id)
                    }));
                    listView1.Items.Add(new ListViewItem(new string[] {
                        string.Format("Initial source measurement: {0}", (isr.pass ? "passed" : "failed"))
                    }));
                    break;

                case AssaySelector.MeasurementOption.normalization:
                    INCCResults.results_bias_rec br = (INCCResults.results_bias_rec)r;
                    listView1.Items.Add(new ListViewItem(new string[] {
                        string.Format("Normalization results for reference source: {0}", br.sourceId)
                    }));
                    if (br.mode == NormTest.Cf252Doubles)
                    {
                        listView1.Items.Add(new ListViewItem(new string[] {
                            string.Format("Normalization doubles rate expected/measured: {0,13:F3} +- {1,9:F3}",
                                          br.biasDblsRateExpectMeas.v, br.biasDblsRateExpectMeas.err)
                        }));
                    }
                    else if (br.mode == NormTest.Cf252Singles)
                    {
                        listView1.Items.Add(new ListViewItem(new string[] {
                            string.Format("Normalization singles rate expected/measured: {0,13:F3} +- {1,9:F3}",
                                          br.biasDblsRateExpectMeas.v, br.biasDblsRateExpectMeas.err)
                        }));
                    }
                    else
                    {
                        listView1.Items.Add(new ListViewItem(new string[] {
                            string.Format("Normalization singles rate expected/measured: {0,13:F3} +- {1,9:F3}",
                                          br.biasSnglsRateExpectMeas.v, br.biasSnglsRateExpectMeas.err)
                        }));
                    }
                    listView1.Items.Add(new ListViewItem(new string[] {
                        string.Format("Normalization test {0}", (br.pass ? "passed" : "failed"))
                    }));
                    break;

                case AssaySelector.MeasurementOption.precision:
                    INCCResults.results_precision_rec pr = (INCCResults.results_precision_rec)r;
                    listView1.Items.Add(new ListViewItem(new string[] { "Precision results" + augmenter }));
                    listView1.Items.Add(new ListViewItem(new string[] {
                        string.Format("Chi-square lower limit: {0,13:F3}", pr.chiSqLowerLimit)
                    }));
                    listView1.Items.Add(new ListViewItem(new string[] {
                        string.Format("Chi-square upper limit: {0,13:F3}", pr.chiSqUpperLimit)
                    }));
                    listView1.Items.Add(new ListViewItem(new string[] {
                        string.Format("       Sample variance: {0,13:F3}", pr.precSampleVar)
                    }));
                    listView1.Items.Add(new ListViewItem(new string[] {
                        string.Format("  Theoretical variance: {0,13:F3}", pr.precTheoreticalVar)
                    }));
                    listView1.Items.Add(new ListViewItem(new string[] {
                        string.Format("            Chi-square: {0,13:F3}", pr.precChiSq)
                    }));
                    listView1.Items.Add(new ListViewItem(new string[] {
                        string.Format("Precision test {0}.", (pr.pass ? "passed" : "failed"))
                    }));
                    break;

                case AssaySelector.MeasurementOption.calibration:
                    INCCMethodResults imrs;
                    bool ok = m.INCCAnalysisResults.TryGetINCCResults(moskey.MultiplicityParams, out imrs);
                    if (ok && imrs.Count > 0)     // should be true for verification and calibration
                    {
                        // we've got a distinct detector id and material type on the methods, so that is the indexer here
                        Dictionary <AnalysisMethod, INCCMethodResult> amimr = imrs[m.INCCAnalysisState.Methods.selector];

                        // now get an enumerator over the map of method results
                        Dictionary <AnalysisMethod, INCCMethodResult> .Enumerator ai = amimr.GetEnumerator();
                        while (ai.MoveNext())
                        {
                            INCCMethodResult imr = ai.Current.Value;
                            if (imr is INCCMethodResults.results_cal_curve_rec)
                            {
                                listView1.Items.Add(new ListViewItem(new string[] { "Passive calibration curve results" + augmenter }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("       Pu mass: {0,13:F3}", ((INCCMethodResults.results_cal_curve_rec)imr).pu_mass.v)
                                }));
                            }
                            else if (imr is INCCMethodResults.results_known_alpha_rec)
                            {
                                listView1.Items.Add(new ListViewItem(new string[] { "Known alpha results" + augmenter }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("Multiplication: {0,13:F3}", ((INCCMethodResults.results_known_alpha_rec)imr).mult)
                                }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("         Alpha: {0,13:F3}", ((INCCMethodResults.results_known_alpha_rec)imr).alphaK)
                                }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("       Pu mass: {0,13:F3}", ((INCCMethodResults.results_known_alpha_rec)imr).pu_mass.v)
                                }));
                            }
                            else if (imr is INCCMethodResults.results_add_a_source_rec)
                            {
                                listView1.Items.Add(new ListViewItem(new string[] { "Add-a-source results" + augmenter }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("       Pu mass: {0,13:F3}", ((INCCMethodResults.results_add_a_source_rec)imr).pu_mass.v)
                                }));
                            }
                            else if (imr is INCCMethodResults.results_active_rec)
                            {
                                listView1.Items.Add(new ListViewItem(new string[] { "Active calibration curve results" + augmenter }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("      U235 mass: {0,13:F3}", ((INCCMethodResults.results_active_rec)imr).u235_mass.v)
                                }));
                            }
                        }
                    }
                    break;

                case AssaySelector.MeasurementOption.verification:
                case AssaySelector.MeasurementOption.holdup:
                    INCCMethodResults imrvs;
                    bool okv = m.INCCAnalysisResults.TryGetINCCResults(moskey.MultiplicityParams, out imrvs);
                    if (okv && imrvs.Count > 0)     // should be true for verification and calibration
                    {
                        // we've got a distinct detector id and material type on the methods, so that is the indexer here
                        Dictionary <AnalysisMethod, INCCMethodResult> amimr = imrvs[m.INCCAnalysisState.Methods.selector];

                        // now get an enumerator over the map of method results
                        Dictionary <AnalysisMethod, INCCMethodResult> .Enumerator ai = amimr.GetEnumerator();
                        while (ai.MoveNext())
                        {
                            INCCMethodResult imr = ai.Current.Value;
                            if (imr is INCCMethodResults.results_cal_curve_rec)
                            {
                                INCCMethodResults.results_cal_curve_rec d = (INCCMethodResults.results_cal_curve_rec)imr;
                                listView1.Items.Add(new ListViewItem(new string[] { "Passive calibration curve results" + augmenter }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("                 Pu mass: {0,13:F3} +- {1,9:F3}", d.pu_mass.v, d.pu_mass.err)
                                }));
                                if (d.dcl_pu_mass > 0)
                                {
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("        Declared Pu mass: {0,13:F3}", d.dcl_pu_mass)
                                    }));
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("Declared - assay Pu mass: {0,13:F3} +- {1,9:F3} or {2,6:F2}%",
                                                      d.dcl_minus_asy_pu_mass.v, d.dcl_minus_asy_pu_mass.err, d.dcl_minus_asy_pu_mass_pct)
                                    }));
                                }
                            }
                            else if (imr is INCCMethodResults.results_known_alpha_rec)
                            {
                                INCCMethodResults.results_known_alpha_rec d = (INCCMethodResults.results_known_alpha_rec)imr;
                                listView1.Items.Add(new ListViewItem(new string[] { "Known alpha results" + augmenter }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("          Multiplication: {0,13:F3}", d.mult)
                                }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("                   Alpha: {0,13:F3}", d.alphaK)
                                }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("                 Pu mass: {0,13:F3} +- {1,9:F3}", d.pu_mass.v, d.pu_mass.err)
                                }));
                                if (d.dcl_pu_mass > 0)
                                {
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("        Declared Pu mass: {0,13:F3}", d.dcl_pu_mass)
                                    }));
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("Declared - assay Pu mass: {0,13:F3} +- {1,9:F3} or {2,6:F2}%",
                                                      d.dcl_minus_asy_pu_mass.v, d.dcl_minus_asy_pu_mass.err, d.dcl_minus_asy_pu_mass_pct)
                                    }));
                                }
                            }
                            else if (imr is INCCMethodResults.results_known_m_rec)
                            {
                                INCCMethodResults.results_known_m_rec d = (INCCMethodResults.results_known_m_rec)imr;
                                listView1.Items.Add(new ListViewItem(new string[] { "Known M results" + augmenter }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("          Multiplication: {0,13:F3}", d.mult)
                                }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("                   Alpha: {0,13:F3}", d.alpha)
                                }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("                 Pu mass: {0,13:F3} +- {1,9:F3}", d.pu_mass.v, d.pu_mass.err)
                                }));
                                if (d.dcl_pu_mass > 0)
                                {
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("        Declared Pu mass: {0,13:F3}", d.dcl_pu_mass)
                                    }));
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("Declared - assay Pu mass: {0,13:F3} +- {1,9:F3} or {2,6:F2}%",
                                                      d.dcl_minus_asy_pu_mass.v, d.dcl_minus_asy_pu_mass.err, d.dcl_minus_asy_pu_mass_pct)
                                    }));
                                }
                            }
                            else if (imr is INCCMethodResults.results_multiplicity_rec)
                            {
                                INCCMethodResults.results_multiplicity_rec d = (INCCMethodResults.results_multiplicity_rec)imr;
                                listView1.Items.Add(new ListViewItem(new string[] { "Passive multiplicity results" + augmenter }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("          Multiplication: {0,13:F3} +- {1,9:F3}", d.mult.v, d.mult.err)
                                }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("                   Alpha: {0,13:F3} +- {1,9:F3}", d.alphaK.v, d.alphaK.err)
                                }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("       Correction factor: {0,13:F3}", d.corr_factor.v, d.corr_factor.err)
                                }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("                 Pu mass: {0,13:F3} +- {1,9:F3}", d.pu_mass.v, d.pu_mass.err)
                                }));
                                if (d.dcl_pu_mass > 0)
                                {
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("        Declared Pu mass: {0,13:F3}", d.dcl_pu_mass)
                                    }));
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("Declared - assay Pu mass: {0,13:F3} +- {1,9:F3} or {2,6:F2}%",
                                                      d.dcl_minus_asy_pu_mass.v, d.dcl_minus_asy_pu_mass.err, d.dcl_minus_asy_pu_mass_pct)
                                    }));
                                }
                            }
                            else if (imr is INCCMethodResults.results_add_a_source_rec)
                            {
                                INCCMethodResults.results_add_a_source_rec d = (INCCMethodResults.results_add_a_source_rec)imr;
                                listView1.Items.Add(new ListViewItem(new string[] { "Add-a-source results" + augmenter }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("                   Delta: {0,13:F3} +- {1,9:F3}", d.delta.v, d.delta.err)
                                }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("       Correction factor: {0,13:F3}", d.corr_factor.v, d.corr_factor.err)
                                }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("                 Pu mass: {0,13:F3} +- {1,9:F3}", d.pu_mass.v, d.pu_mass.err)
                                }));
                                if (d.dcl_pu_mass > 0)
                                {
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("        Declared Pu mass: {0,13:F3}", d.dcl_pu_mass)
                                    }));
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("Declared - assay Pu mass: {0,13:F3} +- {1,9:F3} or {2,6:F2}%",
                                                      d.dcl_minus_asy_pu_mass.v, d.dcl_minus_asy_pu_mass.err, d.dcl_minus_asy_pu_mass_pct)
                                    }));
                                }
                            }
                            else if (imr is INCCMethodResults.results_curium_ratio_rec)
                            {
                                INCCMethodResults.results_curium_ratio_rec d = (INCCMethodResults.results_curium_ratio_rec)imr;
                                listView1.Items.Add(new ListViewItem(new string[] { "Curium ratio results" + augmenter }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("                 Cm mass: {0,13:F3}  +- {1,9:F3}", d.cm_mass.v, d.cm_mass.err)
                                }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("                 Pu mass: {0,13:F3} +- {1,9:F3}", d.pu.pu_mass.v, d.pu.pu_mass.err)
                                }));
                                if (d.pu.dcl_pu_mass > 0)
                                {
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("        Declared Pu mass: {0,13:F3}", d.pu.dcl_pu_mass)
                                    }));
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("Declared - assay Pu mass: {0,13:F3} +- {1,9:F3} or {2,6:F2}%",
                                                      d.pu.dcl_minus_asy_pu_mass.v, d.pu.dcl_minus_asy_pu_mass.err, d.pu.dcl_minus_asy_pu_mass_pct)
                                    }));
                                }
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("                  U mass: {0,13:F3} +- {1,9:F3}", d.u.mass.v, d.u.mass.err)
                                }));
                                if (d.u.dcl_mass > 0)
                                {
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("         Declared U mass: {0,13:F3}", d.u.dcl_mass)
                                    }));
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format(" Declared - assay U mass: {0,13:F3} +- {1,9:F3} or {2,6:F2}%",
                                                      d.u.dcl_minus_asy_mass.v, d.u.dcl_minus_asy_mass.err, d.u.dcl_minus_asy_mass_pct)
                                    }));
                                }
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("      Declared U235 mass: {0,13:F3} +- {1,9:F3}", d.u235.mass.v, d.u235.mass.err)
                                }));
                                if (d.u235.dcl_mass > 0)
                                {
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("      Declared U235 mass: {0,13:F3}", d.u235.dcl_mass)
                                    }));
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("  Decl - assay U235 mass: {0,13:F3} +- {1,9:F3} or {2,6:F2}%",
                                                      d.u235.dcl_minus_asy_mass.v, d.u235.dcl_minus_asy_mass.err, d.u235.dcl_minus_asy_mass_pct)
                                    }));
                                }
                            }
                            else if (imr is INCCMethodResults.results_truncated_mult_rec)
                            {
                                INCCMethodResults.results_truncated_mult_rec d = (INCCMethodResults.results_truncated_mult_rec)imr;
                                if (d.methodParams.known_eff)
                                {
                                    listView1.Items.Add(new ListViewItem(new string[] { "Known efficiency truncated multiplicity results" + augmenter }));
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("                 Pu mass: {0,13:F3} +- {1,9:F3}", d.k.pu_mass.v, d.k.pu_mass.err)
                                    }));
                                    if (d.k.dcl_pu_mass > 0)
                                    {
                                        listView1.Items.Add(new ListViewItem(new string[] {
                                            string.Format("        Declared Pu mass: {0,13:F3}", d.k.dcl_pu_mass)
                                        }));
                                        listView1.Items.Add(new ListViewItem(new string[] {
                                            string.Format("Declared - assay Pu mass: {0,13:F3} +- {1,9:F3} or {2,6:F2}%",
                                                          d.k.dcl_minus_asy_pu_mass.v, d.k.dcl_minus_asy_pu_mass.err, d.k.dcl_minus_asy_pu_mass_pct)
                                        }));
                                    }
                                }
                                if (d.methodParams.solve_eff)
                                {
                                    listView1.Items.Add(new ListViewItem(new string[] { "Solve efficiency truncated multiplicity results" + augmenter }));
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("                 Pu mass: {0,13:F3} +- {1,9:F3}", d.s.pu_mass.v, d.s.pu_mass.err)
                                    }));
                                    if (d.s.dcl_pu_mass > 0)
                                    {
                                        listView1.Items.Add(new ListViewItem(new string[] {
                                            string.Format("        Declared Pu mass: {0,13:F3}", d.s.dcl_pu_mass)
                                        }));
                                        listView1.Items.Add(new ListViewItem(new string[] {
                                            string.Format("Declared - assay Pu mass: {0,13:F3} +- {1,9:F3} or {2,6:F2}%",
                                                          d.s.dcl_minus_asy_pu_mass.v, d.s.dcl_minus_asy_pu_mass.err, d.s.dcl_minus_asy_pu_mass_pct)
                                        }));
                                    }
                                }
                            }
                            else if (imr is INCCMethodResults.results_active_rec)
                            {
                                INCCMethodResults.results_active_rec d = (INCCMethodResults.results_active_rec)imr;
                                listView1.Items.Add(new ListViewItem(new string[] { "Active calibration curve results" + augmenter }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("                 U235 mass: {0,13:F3} +- {1,9:F3}", d.u235_mass.v, d.u235_mass.err)
                                }));
                                if (d.dcl_u235_mass > 0)
                                {
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("        Declared U235 mass: {0,13:F3}", d.dcl_u235_mass)
                                    }));
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("Declared - assay U235 mass: {0,13:F3} +- {1,9:F3} or {2,6:F2}%",
                                                      d.dcl_minus_asy_u235_mass.v, d.dcl_minus_asy_u235_mass.err, d.dcl_minus_asy_u235_mass_pct)
                                    }));
                                }
                            }
                            else if (imr is INCCMethodResults.results_active_passive_rec)
                            {
                                INCCMethodResults.results_active_passive_rec d = (INCCMethodResults.results_active_passive_rec)imr;
                                listView1.Items.Add(new ListViewItem(new string[] { "Active/passive results" + augmenter }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("                 U235 mass: {0,13:F3} +- {1,9:F3}", d.u235_mass.v, d.u235_mass.err)
                                }));
                                if (d.dcl_u235_mass > 0)
                                {
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("        Declared U235 mass: {0,13:F3}", d.dcl_u235_mass)
                                    }));
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("Declared - assay U235 mass: {0,13:F3} +- {1,9:F3} or {2,6:F2}%",
                                                      d.dcl_minus_asy_u235_mass.v, d.dcl_minus_asy_u235_mass.err, d.dcl_minus_asy_u235_mass_pct)
                                    }));
                                }
                            }
                            else if (imr is INCCMethodResults.results_collar_rec)
                            {
                                INCCMethodResults.results_collar_rec d = (INCCMethodResults.results_collar_rec)imr;
                                listView1.Items.Add(new ListViewItem(new string[] { "Collar results" + augmenter }));
                                listView1.Items.Add(new ListViewItem(new string[] {
                                    string.Format("                 U235 mass: {0,13:F3} +- {1,9:F3}", d.u235_mass.v, d.u235_mass.err)
                                }));
                                if (d.dcl_total_u235.v > 0)
                                {
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("        Declared U235 mass: {0,13:F3} +- {1,9:F3}", d.dcl_total_u235.v, d.dcl_total_u235.err)
                                    }));
                                    listView1.Items.Add(new ListViewItem(new string[] {
                                        string.Format("Declared - assay U235 mass: {0,13:F3} +- {1,9:F3} or {2,6:F2}%",
                                                      d.dcl_minus_asy_u235_mass.v, d.dcl_minus_asy_u235_mass.err, d.dcl_minus_asy_u235_mass_pct)
                                    }));
                                }
                            }
                        }
                    }
                    break;

                case AssaySelector.MeasurementOption.unspecified:
                    listView1.Items.Add(new ListViewItem(new string[] { "List mode results" + augmenter }));
                    listView1.Items.Add(new ListViewItem(new string[] { "TODO " }));     // todo: fill in with something useful for LM
                    break;
                }
            }
        }