Esempio n. 1
0
        public unsafe bool BuildMeasurement(INCCTransferFile itf, int num)
        {
            bool overwrite = NC.App.AppContext.OverwriteImportedDefs;
            results_rec results = itf.results_rec_list[0];
            meas_id id;

            TransferUtils.Copy(results.meas_date, 0, id.meas_date, 0, INCC.DATE_TIME_LENGTH);
            TransferUtils.Copy(results.meas_time, 0, id.meas_time, 0, INCC.DATE_TIME_LENGTH);
            TransferUtils.Copy(results.filename, 0, id.filename, 0, INCC.FILE_NAME_LENGTH);
            TransferUtils.Copy(results.results_detector_id, 0, id.results_detector_id, 0, INCC.MAX_DETECTOR_ID_LENGTH);
            DateTime dt = INCC.DateTimeFrom(TransferUtils.str(id.meas_date, INCC.DATE_TIME_LENGTH), TransferUtils.str(id.meas_time, INCC.DATE_TIME_LENGTH));

            // do not use content from last BuildDetector call, instead look up the detector on the pre-existing list
            string detname = TransferUtils.str(id.results_detector_id, INCC.MAX_DETECTOR_ID_LENGTH);
            Detector det = NC.App.DB.Detectors.GetItByDetectorId(detname);
            if (det == null)
            {
                mlogger.TraceEvent(LogLevels.Error, 34087, "Unknown detector '{0}', not importing this measurement {1}", detname, dt.ToString("s"));
                return false;
            }

            meas = new Measurement((AssaySelector.MeasurementOption)results.meas_option, mlogger);

            // TODO: update detector details from this meas result, since there could be a difference
            meas.MeasurementId.MeasDateTime = dt;
            meas.MeasurementId.FileName = TransferUtils.str(id.filename, INCC.FILE_NAME_LENGTH);

            meas.Detectors.Add(det);  // in practice this is a list with one element, e.g. meas.Detector

            TestParameters t = new TestParameters();
            t.accSnglTestRateLimit = results.r_acc_sngl_test_rate_limit;
            t.accSnglTestPrecisionLimit = results.r_acc_sngl_test_precision_limit;
            t.accSnglTestOutlierLimit = results.r_acc_sngl_test_outlier_limit;
            t.outlierTestLimit = results.r_outlier_test_limit;
            t.bkgDoublesRateLimit = results.r_bkg_doubles_rate_limit;
            t.bkgTriplesRateLimit = results.r_bkg_triples_rate_limit;
            t.chiSquaredLimit = results.r_chisq_limit;
            t.maxNumFailures = results.r_max_num_failures;
            t.highVoltageTestLimit = results.r_high_voltage_test_limit;
            t.normalBackupAssayTestLimit = results.r_normal_backup_assay_test_lim;
            t.maxCyclesForOutlierTest = (uint)results.r_max_runs_for_outlier_test;
            t.checksum = (results.r_checksum_test == 0.0 ? false : true);
            t.accidentalsMethod = INCCAccidentalsMethod((int)results.results_accidentals_method);
            meas.Tests.Copy(t);

            NormParameters n = NC.App.DB.NormParameters.Get(detname);
            meas.Norm.Copy(n);
            BackgroundParameters b = NC.App.DB.BackgroundParameters.Get(detname);
            meas.Background.Copy(b);
            // DB write for these occurs at end of processing here

            // Isotopics handled in this block
            if (itf.isotopics_table.Count > 0)
            {
                string isoname = TransferUtils.str(results.item_isotopics_id, INCC.MAX_ISOTOPICS_ID_LENGTH);
                NCCTransfer.isotopics_rec isotopics = itf.isotopics_table[0];
                //bool first = true; // forgot why the code does this, to put the default in the map?
                // foreach (LMTransfer.isotopics_rec ir in itf.istopics_table)
                // {
                AnalysisDefs.Isotopics iso;
                //       if (first)
                iso = meas.Isotopics;
                //        else
                //            iso = new Isotopics();
                //         first = false;
                iso.am_date = INCC.DateFrom(TransferUtils.str(isotopics.am_date, INCC.DATE_TIME_LENGTH));
                iso.pu_date = INCC.DateFrom(TransferUtils.str(isotopics.pu_date, INCC.DATE_TIME_LENGTH));
                iso.id = TransferUtils.str(isotopics.isotopics_id, INCC.MAX_ISOTOPICS_ID_LENGTH);
                AnalysisDefs.Isotopics.SourceCode checksc = AnalysisDefs.Isotopics.SourceCode.OD;
                string check = TransferUtils.str(isotopics.isotopics_source_code, INCC.ISO_SOURCE_CODE_LENGTH);
                bool okparse = Enum.TryParse(check, true, out checksc);
                iso.source_code = checksc;
                iso.SetValueError(Isotope.am241, isotopics.am241, isotopics.am241_err);
                iso.SetValueError(Isotope.pu238, isotopics.pu238, isotopics.pu238_err);
                iso.SetValueError(Isotope.pu239, isotopics.pu239, isotopics.pu239_err);
                iso.SetValueError(Isotope.pu240, isotopics.pu240, isotopics.pu240_err);
                iso.SetValueError(Isotope.pu241, isotopics.pu241, isotopics.pu241_err);
                iso.SetValueError(Isotope.pu242, isotopics.pu242, isotopics.pu242_err);

                if (!NC.App.DB.Isotopics.Has(iso.id))
                {
                    NC.App.DB.Isotopics.GetList().Add(iso);
                    mlogger.TraceEvent(LogLevels.Info, 34021, "Identified new isotopics {0}", iso.id);
                }
                else
                {
                    if (overwrite)
                    {
                        NC.App.DB.Isotopics.Replace(iso);
                        mlogger.TraceEvent(LogLevels.Warning, 34022, "Replaced existing isotopics {0}", iso.id);
                    }
                    else
                    {
                        mlogger.TraceEvent(LogLevels.Warning, 34022, "Not replacing existing isotopics {0}", iso.id);
                    }
                }
                iso.modified = true;
            }

            AcquireParameters acq = meas.AcquireState;
            acq.detector_id = det.Id.DetectorId;
            acq.meas_detector_id = string.Copy(det.Id.DetectorId);  // probably incorrect usage, but differnce is ambiguous in INCC5
            acq.item_type = TransferUtils.str(results.results_item_type, INCC.MAX_ITEM_TYPE_LENGTH);
            acq.qc_tests = TransferUtils.ByteBool(results.results_qc_tests);
            acq.user_id = TransferUtils.str(results.user_id, INCC.CHAR_FIELD_LENGTH);
            acq.num_runs = results.total_number_runs;
            if (results.number_good_runs > 0)
                acq.run_count_time = results.total_good_count_time / results.number_good_runs;
            else
                acq.run_count_time = results.total_good_count_time; // should be 0.0 by default for this special case
            acq.MeasDateTime = meas.MeasurementId.MeasDateTime;
            acq.error_calc_method = INCCErrorCalculationTechnique(results.error_calc_method);
            acq.campaign_id = TransferUtils.str(results.results_campaign_id, INCC.MAX_CAMPAIGN_ID_LENGTH);
            if (string.IsNullOrEmpty(acq.campaign_id))
                acq.campaign_id = TransferUtils.str(results.results_inspection_number, INCC.MAX_CAMPAIGN_ID_LENGTH);
            acq.comment = TransferUtils.str(results.comment, INCC.MAX_COMMENT_LENGTH);//"Original file name " + meas.MeasurementId.FileName;
            string ending_comment_str = TransferUtils.str(results.ending_comment, INCC.MAX_COMMENT_LENGTH);
            acq.ending_comment = !string.IsNullOrEmpty(acq.ending_comment_str);

            acq.data_src = (ConstructedSource)results.data_source;
            acq.well_config = (WellConfiguration)results.well_config;
            acq.print = TransferUtils.ByteBool(results.results_print);

            mlogger.TraceEvent(LogLevels.Verbose, 34000, "Building {0} measurement {1} '{2},{3}' from {2}", meas.MeasOption.PrintName(), num, acq.detector_id, acq.item_type, itf.Path);

            if (itf.facility_table.Count > 0)
                meas.AcquireState.facility = new INCCDB.Descriptor(string.Copy(itf.facility_table[0].id), string.Copy(itf.facility_table[0].desc));
            if (itf.mba_table.Count > 0)
                meas.AcquireState.mba = new INCCDB.Descriptor(string.Copy(itf.mba_table[0].id), string.Copy(itf.mba_table[0].desc));
            if (itf.stratum_id_names_rec_table.Count > 0)
                meas.AcquireState.stratum_id = new INCCDB.Descriptor(string.Copy(itf.stratum_id_names_rec_table[0].id), string.Copy(itf.stratum_id_names_rec_table[0].desc));

            // stratum values
            meas.Stratum = new Stratum();
            meas.Stratum.bias_uncertainty = results.bias_uncertainty;
            meas.Stratum.random_uncertainty = results.random_uncertainty;
            meas.Stratum.relative_std_dev = results.relative_std_dev;
            meas.Stratum.systematic_uncertainty = results.systematic_uncertainty;

            INCCDB.Descriptor mtdesc = new INCCDB.Descriptor(string.Copy(acq.item_type), string.Empty);
            if (!NC.App.DB.Materials.Has(mtdesc) || overwrite)
            {
                NC.App.DB.Materials.Update(mtdesc);
            }

            // prepare norm parms, should be done with a prior pass with the detector file, then this code looks it up in the collection set at this point in the processing
            meas.Norm.currNormalizationConstant.v = results.normalization_constant;
            meas.Norm.currNormalizationConstant.err = results.normalization_constant_err;

            foreach (DescriptorPair dp in itf.facility_table)
            {
                INCCDB.Descriptor idesc = new INCCDB.Descriptor(string.Copy(dp.id), string.Copy(dp.desc));
                if (!NC.App.DB.Facilities.Has(idesc) || overwrite)
                {
                    idesc.modified = true;
                    NC.App.DB.Facilities.Update(idesc);
                }
            }
            foreach (DescriptorPair dp in itf.mba_table)
            {
                INCCDB.Descriptor idesc = new INCCDB.Descriptor(string.Copy(dp.id), string.Copy(dp.desc));
                if (!NC.App.DB.MBAs.Has(idesc) || overwrite)
                {
                    idesc.modified = true;
                    NC.App.DB.MBAs.Update(idesc);
                }
            }
            foreach (DescriptorPair dp in itf.stratum_id_names_rec_table)
            {
                INCCDB.Descriptor idesc = new INCCDB.Descriptor(string.Copy(dp.id), string.Copy(dp.desc));
                if (meas.Stratum != null)
                {
                   idesc.modified = true;
                   NC.App.DB.UpdateStratum(idesc, meas.Stratum);  // creates it
                   NC.App.DB.AssociateStratum(det, idesc, meas.Stratum); // associates it with the detector
                }
            }

            if (itf.item_id_table.Count > 0)  // devnote: there should be only one item entry
            {
                ItemId item = new ItemId();
                item.declaredMass = results.declared_mass;
                item.declaredUMass = results.declared_u_mass;
                item.length = results.length;
                item.IOCode = TransferUtils.str(results.io_code, INCC.IO_CODE_LENGTH);
                item.inventoryChangeCode = TransferUtils.str(results.inventory_change_code, INCC.INVENTORY_CHG_LENGTH);
                item.isotopics = TransferUtils.str(results.item_isotopics_id, INCC.MAX_ISOTOPICS_ID_LENGTH);
                item.stratum = TransferUtils.str(results.stratum_id, INCC.MAX_STRATUM_ID_LENGTH);
                item.item = TransferUtils.str(results.item_id, INCC.MAX_ITEM_ID_LENGTH);
                item.material = TransferUtils.str(results.results_item_type, INCC.MAX_ITEM_TYPE_LENGTH);
                //copy measurement dates to item
                item.pu_date = new DateTime(meas.Isotopics.pu_date.Ticks);
                item.am_date = new DateTime(meas.Isotopics.am_date.Ticks);
                item.modified = true;

                List<ItemId> list = NC.App.DB.ItemIds.GetList();
                bool flump = list.Exists(i => { return string.Compare(item.item, i.item, true) == 0; });
                if (flump && overwrite)
                {
                    list.Remove(item);
                    list.Add(item);
                }
                else
                    list.Add(item);

                // fill in the acquire record from the item id
                acq.ApplyItemId(item);

                meas.MeasurementId.Item = new ItemId(item);
            }

            meas.INCCAnalysisState = new INCCAnalysisState();

            INCCSelector sel = new INCCSelector(acq.detector_id, acq.item_type);
            AnalysisMethods am;
            bool found = NC.App.DB.DetectorMaterialAnalysisMethods.TryGetValue(sel, out am);
            if (found)
            {
                meas.INCCAnalysisState.Methods = am;
                meas.INCCAnalysisState.Methods.selector = sel;
            }
            else
            {
                mlogger.TraceEvent(LogLevels.Error, 34063, "No analysis methods for {0}, (calibration information is missing), creating placeholders", sel.ToString()); // devnote: can get missing paramters from the meas results for calib and verif below, so need to visit this condition after results processing below (newres.methodParams!) and reconstruct the calib parameters.
                meas.INCCAnalysisState.Methods = new AnalysisMethods(mlogger);
                meas.INCCAnalysisState.Methods.selector = sel;
            }
            // prepare analyzer params from sr params above
            meas.AnalysisParams = new AnalysisDefs.CountingAnalysisParameters();
            meas.AnalysisParams.Add(det.MultiplicityParams);

            mlogger.TraceEvent(LogLevels.Verbose, 34030, "Transferring the {0} cycles", itf.run_rec_list.Count);
            meas.InitializeContext();
            meas.PrepareINCCResults(); // prepares INCCResults objects
            ulong MaxBins = 0;
            foreach (run_rec r in itf.run_rec_list)
            {
                ulong x= AddToCycleList(r, det);
                if (x > MaxBins)
                    MaxBins = x;
            }
            for (int cf = 1; (itf.CFrun_rec_list != null) && (cf < itf.CFrun_rec_list.Length); cf++)
            {
                foreach (run_rec r in itf.CFrun_rec_list[cf])
                {
                    AddToCycleList(r, det, cf);
                }
            }

            // summarize the result in the result, if you know what I mean
            MultiplicityCountingRes mcr = (MultiplicityCountingRes)meas.CountingAnalysisResults[det.MultiplicityParams];
            for (int i = 0; i < 9; i++)
                mcr.covariance_matrix[i] = results.covariance_matrix[i];
            mcr.DeadtimeCorrectedRates.Singles.err = results.singles_err;
            mcr.DeadtimeCorrectedRates.Doubles.err = results.doubles_err;
            mcr.DeadtimeCorrectedRates.Triples.err = results.triples_err;
            mcr.DeadtimeCorrectedRates.Singles.v = results.singles;
            mcr.DeadtimeCorrectedRates.Doubles.v = results.doubles;
            mcr.DeadtimeCorrectedRates.Triples.v = results.triples;
            mcr.Scaler1Rate.v = results.scaler1;
            mcr.Scaler2Rate.v = results.scaler2;
            mcr.Scaler1Rate.err = results.scaler1_err;
            mcr.Scaler2Rate.err = results.scaler2_err;
            mcr.Scaler1.v = results.scaler1;
            mcr.Scaler2.v = results.scaler2;
            mcr.Scaler1.err = results.scaler1_err;
            mcr.Scaler2.err = results.scaler2_err;
            mcr.ASum = results.acc_sum;
            mcr.RASum = results.reals_plus_acc_sum;
            mcr.S1Sum = results.scaler1_sum;
            mcr.S2Sum = results.scaler2_sum;
            mcr.mass = results.declared_mass;
            mcr.FA = det.MultiplicityParams.FA;
            mcr.RAMult = TransferUtils.multarrayxfer(results.mult_reals_plus_acc_sum, INCC.MULTI_ARRAY_SIZE);
            mcr.NormedAMult = TransferUtils.multarrayxfer(results.mult_acc_sum, INCC.MULTI_ARRAY_SIZE);
            mcr.MaxBins = (ulong)Math.Max(mcr.RAMult.Length, mcr.NormedAMult.Length);
            mcr.MinBins = (ulong)Math.Min(mcr.RAMult.Length, mcr.NormedAMult.Length);
            mcr.RawDoublesRate.v = results.uncorrected_doubles;
            mcr.RawDoublesRate.err = results.uncorrected_doubles_err;
            mcr.singles_multi = results.singles_multi;
            mcr.doubles_multi = results.doubles_multi;
            mcr.triples_multi = results.triples_multi;

            INCCResult result;
            MeasOptionSelector mos = new MeasOptionSelector(meas.MeasOption, det.MultiplicityParams);
            result = meas.INCCAnalysisState.Lookup(mos);
            result.DeadtimeCorrectedRates.Singles.err = results.singles_err;
            result.DeadtimeCorrectedRates.Doubles.err = results.doubles_err;
            result.DeadtimeCorrectedRates.Triples.err = results.triples_err;
            result.DeadtimeCorrectedRates.Singles.v = results.singles;
            result.DeadtimeCorrectedRates.Doubles.v = results.doubles;
            result.DeadtimeCorrectedRates.Triples.v = results.triples;
            result.rates.RawRates.Scaler1s.v = results.scaler1;
            result.rates.RawRates.Scaler2s.v = results.scaler2;
            result.rates.RawRates.Scaler1s.err = results.scaler1_err;
            result.rates.RawRates.Scaler2s.err = results.scaler2_err;
            result.S1Sum = results.scaler1_sum;
            result.S2Sum = results.scaler2_sum;
            result.ASum = results.acc_sum;
            result.RASum = results.reals_plus_acc_sum;
            result.RAMult = TransferUtils.multarrayxfer(results.mult_reals_plus_acc_sum, INCC.MULTI_ARRAY_SIZE);
            result.NormedAMult = TransferUtils.multarrayxfer(results.mult_acc_sum, INCC.MULTI_ARRAY_SIZE);
            result.MaxBins = (ulong)Math.Max(result.RAMult.Length, result.NormedAMult.Length);
            result.MinBins = (ulong)Math.Min(result.RAMult.Length, result.NormedAMult.Length);
            mcr.RawDoublesRate.v = results.uncorrected_doubles;
            mcr.RawDoublesRate.err = results.uncorrected_doubles_err;
            result.singles_multi = results.singles_multi;
            result.doubles_multi = results.doubles_multi;
            result.triples_multi = results.triples_multi;

            // hack expansion of Normed mult array to same length as Acc mult array on each cycle to accomodate TheoreticalOutlier calc array length bug
            ExpandMaxBins(MaxBins, meas.Cycles, det.MultiplicityParams);
            Bloat(MaxBins, mcr);

            List<MeasurementMsg> msgs = meas.GetMessageList(det.MultiplicityParams);

            // move the error messages
            for (int i = 0; i < INCC.NUM_ERROR_MSG_CODES; i++)
            {
                int index = i * INCC.ERR_MSG_LENGTH;
                string e = TransferUtils.str(results.error_msg_codes + index, INCC.ERR_MSG_LENGTH);
                if (e.Length > 0)
                    meas.AddMessage(msgs, LogLevels.Error, 911, e, meas.MeasurementId.MeasDateTime);
            }
            // move the warning messages
            for (int i = 0; i < INCC.NUM_WARNING_MSG_CODES; i++)
            {
                int index = i * INCC.ERR_MSG_LENGTH;
                string w = TransferUtils.str(results.warning_msg_codes + index, INCC.ERR_MSG_LENGTH);
                if (w.Length > 0)
                    meas.AddMessage(msgs, LogLevels.Warning, 411, w, meas.MeasurementId.MeasDateTime);
            }

            #region results transfer
            INCCMethodResults imr;
            bool got = meas.INCCAnalysisResults.TryGetINCCResults(det.MultiplicityParams, out imr); // only ever this single mkey for INCC5-style transfer import, (thankfully)
            if (got)
                imr.primaryMethod = OldToNewMethodId(results.primary_analysis_method);
            // check these results against the meas.MeasOption expectation => seems to always be 1 - 1 with (opt, sr) -> results, and subresults only for verif and calib choice
            //         rates -> none,
            //         bkg -> bkg, norm -> bias, init src -> init src, prec ->  prec,
            //         calib -> calib, 1 or more INCC methods on the methods submap
            //         verif -> 1 or more INCC methods on the methods submap
            foreach (iresultsbase r in itf.method_results_list)
            {
                if (r is results_init_src_rec)
                {
                    mlogger.TraceEvent(LogLevels.Verbose, 34041, ("Transferring initial source results"));

                    results_init_src_rec oldres = (results_init_src_rec)r;

                    INCCResults.results_init_src_rec newres = (INCCResults.results_init_src_rec)
                    meas.INCCAnalysisState.Lookup(new MeasOptionSelector(meas.MeasOption, det.MultiplicityParams), typeof(INCCResults.results_init_src_rec));

                    newres.mode = OldToNewBiasTestId(oldres.init_src_mode);
                    newres.pass = TransferUtils.PassCheck(oldres.init_src_pass_fail);
                    newres.init_src_id = TransferUtils.str(oldres.init_src_id, INCC.SOURCE_ID_LENGTH);
                }
                else if (r is results_bias_rec)
                {
                    mlogger.TraceEvent(LogLevels.Verbose, 34042, ("Transferring normalization results"));

                    results_bias_rec oldres = (results_bias_rec)r;
                    INCCResults.results_bias_rec newres = (INCCResults.results_bias_rec)meas.INCCAnalysisState.Lookup(new MeasOptionSelector(meas.MeasOption, det.MultiplicityParams), typeof(INCCResults.results_bias_rec));

                    newres.pass = TransferUtils.PassCheck(oldres.bias_pass_fail);
                    newres.biasDblsRateExpect.v = oldres.bias_dbls_rate_expect;
                    newres.biasDblsRateExpectMeas.v = oldres.bias_dbls_rate_expect_meas;
                    newres.biasSnglsRateExpect.v = oldres.bias_sngls_rate_expect;
                    newres.biasSnglsRateExpectMeas.v = oldres.bias_sngls_rate_expect_meas;
                    newres.biasDblsRateExpect.err = oldres.bias_dbls_rate_expect_err;
                    newres.biasDblsRateExpectMeas.err = oldres.bias_dbls_rate_expect_meas_err;
                    newres.biasSnglsRateExpect.err = oldres.bias_sngls_rate_expect_err;
                    newres.biasSnglsRateExpectMeas.err = oldres.bias_sngls_rate_expect_meas_err;
                    newres.newNormConstant.v = oldres.new_norm_constant;
                    newres.newNormConstant.err = oldres.new_norm_constant_err;
                    newres.measPrecision = oldres.meas_precision;
                    newres.requiredMeasSeconds = oldres.required_meas_seconds;
                    newres.requiredPrecision = oldres.required_precision;
                    newres.mode = OldToNewBiasTestId(oldres.results_bias_mode);
                    newres.sourceId = TransferUtils.str(oldres.bias_source_id, INCC.SOURCE_ID_LENGTH);
                      // NEXT: for init src and bias, results norm values transferred to meas.norm

                }
                else if (r is results_precision_rec)
                {
                    mlogger.TraceEvent(LogLevels.Verbose, 34043, ("Transferring precision results"));

                    results_precision_rec oldres = (results_precision_rec)r;
                    INCCResults.results_precision_rec newres =
                        (INCCResults.results_precision_rec)meas.INCCAnalysisState.Lookup(new MeasOptionSelector(meas.MeasOption, det.MultiplicityParams), typeof(INCCResults.results_precision_rec));

                    newres.chiSqLowerLimit = oldres.chi_sq_lower_limit;
                    newres.chiSqUpperLimit = oldres.chi_sq_upper_limit;
                    newres.precChiSq = oldres.prec_chi_sq;
                    newres.precSampleVar = oldres.prec_sample_var;
                    newres.precTheoreticalVar = oldres.prec_theoretical_var;
                    newres.pass = TransferUtils.PassCheck(oldres.prec_pass_fail);
                }
                else
                {
                    if (r is results_cal_curve_rec)
                    {
                        // need to look up in existing map and see if it is there and then create and load it if not
                        mlogger.TraceEvent(LogLevels.Verbose, 34050, ("Transferring method results for " + r.GetType().ToString()));
                        results_cal_curve_rec oldres = (results_cal_curve_rec)r;
                        INCCMethodResults.results_cal_curve_rec newres =
                            (INCCMethodResults.results_cal_curve_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.CalibrationCurve, true);

                        newres.pu240e_mass = new Tuple(oldres.cc_pu240e_mass, oldres.cc_pu240e_mass_err);
                        newres.pu_mass = new Tuple(oldres.cc_pu_mass, oldres.cc_pu_mass_err);
                        newres.dcl_pu240e_mass = oldres.cc_dcl_pu240e_mass;
                        newres.dcl_pu_mass = oldres.cc_dcl_pu_mass;
                        newres.dcl_minus_asy_pu_mass = new Tuple(oldres.cc_dcl_minus_asy_pu_mass, oldres.cc_dcl_minus_asy_pu_mass_err);
                        newres.dcl_minus_asy_pu_mass_pct = oldres.cc_dcl_minus_asy_pu_mass_pct;
                        newres.pass = TransferUtils.PassCheck(oldres.cc_pass_fail);
                        newres.dcl_u_mass = oldres.cc_dcl_u_mass;
                        newres.length = oldres.cc_length;
                        newres.heavy_metal_content = oldres.cc_heavy_metal_content;
                        newres.heavy_metal_correction = oldres.cc_heavy_metal_correction;
                        newres.heavy_metal_corr_singles = new Tuple(oldres.cc_heavy_metal_corr_singles, oldres.cc_heavy_metal_corr_singles_err);
                        newres.heavy_metal_corr_doubles = new Tuple(oldres.cc_heavy_metal_corr_doubles, oldres.cc_heavy_metal_corr_doubles_err);
                        newres.methodParams.heavy_metal_corr_factor = oldres.cc_heavy_metal_corr_factor_res;
                        newres.methodParams.heavy_metal_reference = oldres.cc_heavy_metal_reference_res;
                        // newres.methodParams.cev.lower_mass_limit = oldres.cc_lower_mass_limit_res;
                        // newres.methodParams.cev.upper_mass_limit = oldres.cc_upper_mass_limit_res;
                        newres.methodParams.percent_u235 = oldres.cc_percent_u235_res;

                        newres.methodParams.cev.a = oldres.cc_a_res; newres.methodParams.cev.b = oldres.cc_b_res;
                        newres.methodParams.cev.c = oldres.cc_c_res; newres.methodParams.cev.d = oldres.cc_d_res;
                        newres.methodParams.cev.var_a = oldres.cc_var_a_res; newres.methodParams.cev.var_b = oldres.cc_var_b_res;
                        newres.methodParams.cev.var_c = oldres.cc_var_c_res; newres.methodParams.cev.var_d = oldres.cc_var_d_res;
                        newres.methodParams.cev.setcovar(Coeff.a,Coeff.b,oldres.cc_covar_ab_res);
                        newres.methodParams.cev._covar[0, 2] = oldres.cc_covar_ac_res;
                        newres.methodParams.cev._covar[0, 3] = oldres.cc_covar_ad_res;
                        newres.methodParams.cev._covar[1, 2] = oldres.cc_covar_bc_res;
                        newres.methodParams.cev._covar[1, 3] = oldres.cc_covar_bd_res;
                        newres.methodParams.cev._covar[2, 3] = oldres.cc_covar_cd_res;
                        newres.methodParams.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)oldres.cc_cal_curve_equation;
                        newres.methodParams.CalCurveType = (INCCAnalysisParams.CalCurveType)oldres.cc_cal_curve_type_res;
                        newres.methodParams.cev.sigma_x = oldres.cc_sigma_x_res;
                    }
                    else if (r is results_known_alpha_rec)
                    {
                        //  need to look up in existing map and see if it is there and then create and load it if not
                        mlogger.TraceEvent(LogLevels.Verbose, 34051, ("Transferring method results for " + r.GetType().ToString()));
                        results_known_alpha_rec oldres = (results_known_alpha_rec)r;
                        INCCMethodResults.results_known_alpha_rec newres =
                            (INCCMethodResults.results_known_alpha_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.KnownA, true);
                        newres.corr_doubles.v = oldres.ka_corr_doubles;
                        newres.corr_doubles.err = oldres.ka_corr_doubles_err;
                        newres.mult = oldres.ka_mult;
                        newres.alphaK = oldres.ka_alpha;
                        newres.mult_corr_doubles = new Tuple(oldres.ka_mult_corr_doubles, oldres.ka_mult_corr_doubles_err);
                        newres.pu240e_mass = new Tuple(oldres.ka_pu240e_mass, oldres.ka_pu240e_mass_err);
                        newres.pu_mass = new Tuple(oldres.ka_pu_mass, oldres.ka_pu_mass_err);
                        newres.dcl_pu240e_mass = oldres.ka_dcl_pu240e_mass;
                        newres.dcl_pu_mass = oldres.ka_dcl_pu_mass;
                        newres.dcl_minus_asy_pu_mass = new Tuple(oldres.ka_dcl_minus_asy_pu_mass, oldres.ka_dcl_minus_asy_pu_mass_err);
                        newres.dcl_minus_asy_pu_mass_pct = oldres.ka_dcl_minus_asy_pu_mass_pct;
                        newres.pass = TransferUtils.PassCheck(oldres.ka_pass_fail);
                        newres.dcl_u_mass = oldres.ka_dcl_u_mass;
                        newres.length = oldres.ka_length;
                        newres.heavy_metal_content = oldres.ka_heavy_metal_content;
                        newres.heavy_metal_correction = oldres.ka_heavy_metal_correction;
                        newres.corr_singles = new Tuple(oldres.ka_corr_singles, oldres.ka_corr_singles_err);
                        newres.corr_doubles = new Tuple(oldres.ka_corr_doubles, oldres.ka_corr_doubles_err);
                        newres.corr_factor = oldres.ka_corr_factor;
                        newres.dry_alpha_or_mult_dbls = oldres.ka_dry_alpha_or_mult_dbls;
                        newres.upper_corr_factor_limit = oldres.ka_upper_corr_factor_limit_res;
                        newres.lower_corr_factor_limit = oldres.ka_lower_corr_factor_limit_res;

                        newres.methodParams = new INCCAnalysisParams.known_alpha_rec();
                        newres.methodParams.alpha_wt = oldres.ka_alpha_wt_res;
                        newres.methodParams.heavy_metal_corr_factor = oldres.ka_heavy_metal_corr_factor_res;
                        newres.methodParams.heavy_metal_reference = oldres.ka_heavy_metal_reference_res;
                        newres.methodParams.k = oldres.ka_k_res;
                        newres.methodParams.known_alpha_type = (INCCAnalysisParams.KnownAlphaVariant)oldres.ka_known_alpha_type_res;
                        newres.methodParams.lower_corr_factor_limit = oldres.ka_lower_corr_factor_limit_res;
                        newres.methodParams.upper_corr_factor_limit = oldres.ka_upper_corr_factor_limit_res;
                        newres.methodParams.rho_zero = oldres.ka_rho_zero_res;

                        newres.methodParams.ring_ratio.cal_curve_equation = (INCCAnalysisParams.CurveEquation)oldres.ka_ring_ratio_equation_res;
                        newres.methodParams.ring_ratio.a = oldres.ka_ring_ratio_a_res;
                        newres.methodParams.ring_ratio.b = oldres.ka_ring_ratio_b_res;
                        newres.methodParams.ring_ratio.c = oldres.ka_ring_ratio_c_res;
                        newres.methodParams.ring_ratio.d = oldres.ka_ring_ratio_d_res;

                        newres.methodParams.cev.a = oldres.ka_a_res;
                        newres.methodParams.cev.b = oldres.ka_b_res;
                        newres.methodParams.cev.var_a = oldres.ka_var_a_res;
                        newres.methodParams.cev.var_b= oldres.ka_var_b_res;
                        newres.methodParams.cev.sigma_x = oldres.ka_sigma_x_res;
                        newres.methodParams.cev.setcovar(Coeff.a, Coeff.b, oldres.ka_covar_ab_res);
                        newres.methodParams.cev.lower_mass_limit = oldres.ka_lower_corr_factor_limit_res;
                        newres.methodParams.cev.upper_mass_limit = oldres.ka_upper_corr_factor_limit_res;
                    }
                    else if (r is results_multiplicity_rec)
                    {
                        mlogger.TraceEvent(LogLevels.Verbose, 34052, ("Transferring method results for " + r.GetType().ToString()));
                        results_multiplicity_rec oldres = (results_multiplicity_rec)r;
                        INCCMethodResults.results_multiplicity_rec newres =
                            (INCCMethodResults.results_multiplicity_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.Multiplicity, true);

                        newres.solve_efficiency_choice = (INCCAnalysisParams.MultChoice)oldres.mul_solve_efficiency_res;
                        newres.pass = TransferUtils.PassCheck(oldres.mul_pass_fail);
                        newres.efficiencyComputed.v = oldres.mul_efficiency; newres.efficiencyComputed.err = oldres.mul_efficiency_err;
                        newres.mult.v = oldres.mul_mult; newres.mult.err = oldres.mul_mult_err;
                        newres.alphaK.v = oldres.mul_alpha; newres.alphaK.err = oldres.mul_alpha_err;
                        newres.corr_factor.v = oldres.mul_corr_factor; newres.corr_factor.err = oldres.mul_corr_factor_err;
                        newres.pu240e_mass.v = oldres.mul_pu240e_mass; newres.pu240e_mass.err = oldres.mul_pu240e_mass_err;
                        newres.pu_mass.v = oldres.mul_pu_mass; newres.pu_mass.err = oldres.mul_pu_mass_err;
                        newres.dcl_minus_asy_pu_mass.v = oldres.mul_dcl_minus_asy_pu_mass; newres.dcl_minus_asy_pu_mass.err = oldres.mul_dcl_minus_asy_pu_mass_err;
                        newres.dcl_pu240e_mass = oldres.mul_dcl_pu240e_mass;
                        newres.dcl_pu_mass = oldres.mul_dcl_pu_mass;
                        newres.dcl_minus_asy_pu_mass_pct = oldres.mul_dcl_minus_asy_pu_mass_pct;

                        newres.methodParams = new INCCAnalysisParams.multiplicity_rec();
                        newres.methodParams.sf_rate = oldres.mul_sf_rate_res;
                        newres.methodParams.vs1 = oldres.mul_vs1_res;
                        newres.methodParams.vs2 = oldres.mul_vs2_res;
                        newres.methodParams.vs3 = oldres.mul_vs3_res;
                        newres.methodParams.vi1 = oldres.mul_vi1_res;
                        newres.methodParams.vi2 = oldres.mul_vi2_res;
                        newres.methodParams.vi3 = oldres.mul_vi3_res;
                        newres.methodParams.a = oldres.mul_a_res;
                        newres.methodParams.b = oldres.mul_b_res;
                        newres.methodParams.c = oldres.mul_b_res;
                        newres.methodParams.sigma_x = oldres.mul_sigma_x_res;
                        newres.methodParams.alpha_weight = oldres.mul_alpha_weight_res;
                        newres.methodParams.multEffCorFactor = oldres.mul_corr_factor;
                    }
                    else if (r is results_truncated_mult_rec)
                    {
                        mlogger.TraceEvent(LogLevels.Verbose, 34053, ("Transferring method results for " + r.GetType().ToString()));
                        results_truncated_mult_rec oldres = (results_truncated_mult_rec)r;
                        INCCMethodResults.results_truncated_mult_rec newres =
                            (INCCMethodResults.results_truncated_mult_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.TruncatedMultiplicity, true);
                        newres.k.pass = TransferUtils.PassCheck(oldres.tm_k_pass_fail);
                        newres.bkg.Singles.v = oldres.tm_bkg_singles;
                        newres.bkg.Singles.err = oldres.tm_bkg_singles_err;
                        newres.bkg.Zeros.v = oldres.tm_bkg_zeros;
                        newres.bkg.Zeros.err = oldres.tm_bkg_zeros_err;
                        newres.bkg.Ones.v = oldres.tm_bkg_ones;
                        newres.bkg.Ones.err = oldres.tm_bkg_ones_err;
                        newres.bkg.Twos.v = oldres.tm_bkg_twos;
                        newres.bkg.Twos.err = oldres.tm_bkg_twos_err;
                        newres.net.Singles.v = oldres.tm_net_singles;
                        newres.net.Singles.err = oldres.tm_net_singles_err;
                        newres.net.Zeros.v = oldres.tm_net_zeros;
                        newres.net.Zeros.err = oldres.tm_net_zeros_err;
                        newres.net.Ones.v = oldres.tm_net_ones;
                        newres.net.Ones.err = oldres.tm_net_ones_err;
                        newres.net.Twos.v = oldres.tm_net_twos;
                        newres.net.Twos.err = oldres.tm_net_twos_err;
                        newres.k.alpha.v = oldres.tm_k_alpha;
                        newres.k.alpha.err = oldres.tm_k_alpha_err;
                        newres.k.pu_mass.v = oldres.tm_k_pu_mass;
                        newres.k.pu_mass.err = oldres.tm_k_pu_mass_err;
                        newres.k.pu240e_mass.v = oldres.tm_k_pu240e_mass;
                        newres.k.pu240e_mass.err = oldres.tm_k_pu240e_mass_err;
                        newres.k.dcl_minus_asy_pu_mass.v = oldres.tm_k_dcl_minus_asy_pu_mass;
                        newres.k.dcl_minus_asy_pu_mass.err = oldres.tm_k_dcl_minus_asy_pu_mass_err;
                        newres.s.alpha.v = oldres.tm_s_alpha;
                        newres.s.alpha.err = oldres.tm_s_alpha_err;
                        newres.s.pu_mass.v = oldres.tm_s_pu_mass;
                        newres.s.pu_mass.err = oldres.tm_s_pu_mass_err;
                        newres.s.pu240e_mass.v = oldres.tm_s_pu240e_mass;
                        newres.s.pu240e_mass.err = oldres.tm_s_pu240e_mass_err;
                        newres.s.dcl_minus_asy_pu_mass.v = oldres.tm_s_dcl_minus_asy_pu_mass;
                        newres.s.dcl_minus_asy_pu_mass.err = oldres.tm_s_dcl_minus_asy_pu_mass_err;
                        newres.methodParams.a = oldres.tm_a_res;
                        newres.methodParams.b = oldres.tm_b_res;
                        newres.methodParams.known_eff = (oldres.tm_known_eff_res == 0 ? false : true);
                        newres.methodParams.solve_eff = (oldres.tm_solve_eff_res == 0 ? false : true);
                    }
                    else if (r is results_known_m_rec)
                    {
                        // dev note: untested
                        mlogger.TraceEvent(LogLevels.Verbose, 34054, ("Transferring method results for " + r.GetType().ToString()));
                        results_known_m_rec oldres = (results_known_m_rec)r;
                        INCCMethodResults.results_known_m_rec newres =
                            (INCCMethodResults.results_known_m_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.KnownM, true);
                        newres.pu_mass = new Tuple(oldres.km_pu_mass, oldres.km_pu_mass_err);
                        newres.pu240e_mass = new Tuple(oldres.km_pu240e_mass, oldres.km_pu240e_mass);
                        newres.alpha = oldres.km_alpha;
                        newres.mult = oldres.km_mult;
                        newres.dcl_minus_asy_pu_mass = new Tuple(oldres.km_dcl_minus_asy_pu_mass, oldres.km_dcl_minus_asy_pu_mass_err);
                        newres.pu239e_mass = oldres.km_pu240e_mass;
                        newres.dcl_pu240e_mass = oldres.km_dcl_pu240e_mass;
                        newres.dcl_pu_mass = oldres.km_dcl_pu_mass;
                        newres.dcl_minus_asy_pu_mass_pct = oldres.km_dcl_minus_asy_pu_mass_pct;
                        newres.pass = TransferUtils.PassCheck(oldres.km_pass_fail);
                        newres.methodParams.b = oldres.km_b_res;
                        newres.methodParams.c = oldres.km_c_res;
                        newres.methodParams.sf_rate = oldres.km_sf_rate_res;
                        newres.methodParams.sigma_x = oldres.km_sigma_x_res;
                        newres.methodParams.vs1 = oldres.km_vs1_res;
                        newres.methodParams.vi1 = oldres.km_vi1_res;
                        newres.methodParams.vs2 = oldres.km_vs2_res;
                        newres.methodParams.vi2 = oldres.km_vi2_res;
                    }
                    else if (r is results_add_a_source_rec)
                    {
                        // dev note: untested
                        mlogger.TraceEvent(LogLevels.Verbose, 34055, ("Transferring method results for " + r.GetType().ToString()));
                        results_add_a_source_rec oldres = (results_add_a_source_rec)r;
                        INCCMethodResults.results_add_a_source_rec newres =
                            (INCCMethodResults.results_add_a_source_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.KnownM, true);
                        newres.pu_mass = new Tuple(oldres.ad_pu_mass, oldres.ad_pu_mass_err);
                        newres.pu240e_mass = new Tuple(oldres.ad_pu240e_mass, oldres.ad_pu240e_mass);
                        newres.dcl_minus_asy_pu_mass = new Tuple(oldres.ad_dcl_minus_asy_pu_mass, oldres.ad_dcl_minus_asy_pu_mass_err);
                        newres.dcl_pu240e_mass = oldres.ad_dcl_pu240e_mass;
                        newres.dcl_pu_mass = oldres.ad_dcl_pu_mass;
                        newres.dcl_minus_asy_pu_mass_pct = oldres.ad_dcl_minus_asy_pu_mass_pct;
                        newres.pass = TransferUtils.PassCheck(oldres.ad_pass_fail);

                        newres.dzero_cf252_doubles = oldres.ad_dzero_cf252_doubles;
                        newres.sample_avg_cf252_doubles.v = oldres.ad_sample_avg_cf252_doubles;
                        newres.sample_avg_cf252_doubles.err = oldres.ad_sample_avg_cf252_doubles_err;
                        newres.corr_doubles.v = oldres.ad_corr_doubles;
                        newres.corr_doubles.err = oldres.ad_corr_doubles_err;
                        newres.delta.v = oldres.ad_delta;
                        newres.delta.err = oldres.ad_delta_err;
                        newres.corr_factor.v = oldres.ad_corr_factor;
                        newres.corr_factor.err = oldres.ad_corr_factor_err;
                        newres.sample_cf252_ratio = TransferUtils.Copy(oldres.ad_sample_cf252_ratio, INCC.MAX_ADDASRC_POSITIONS);
                        newres.sample_cf252_doubles = Tuple.MakeArray(
                                vals: TransferUtils.Copy(oldres.ad_sample_cf252_doubles, INCC.MAX_ADDASRC_POSITIONS),
                                errs: TransferUtils.Copy(oldres.ad_sample_cf252_doubles_err, INCC.MAX_ADDASRC_POSITIONS));
                        newres.tm_doubles_bkg.v = oldres.ad_tm_doubles_bkg;
                        newres.tm_uncorr_doubles.v = oldres.ad_tm_uncorr_doubles;
                        newres.tm_corr_doubles.v = oldres.ad_corr_doubles;
                        newres.tm_doubles_bkg.err = oldres.ad_tm_doubles_bkg_err;
                        newres.tm_uncorr_doubles.err = oldres.ad_tm_uncorr_doubles_err;
                        newres.tm_corr_doubles.err = oldres.ad_corr_doubles_err;
                        newres.methodParams.cev.a = oldres.ad_a_res; newres.methodParams.cev.b = oldres.ad_b_res;
                        newres.methodParams.cev.c = oldres.ad_c_res; newres.methodParams.cev.d = oldres.ad_d_res;
                        newres.methodParams.cev.var_a = oldres.ad_var_a_res; newres.methodParams.cev.var_b = oldres.ad_var_b_res;
                        newres.methodParams.cev.var_c = oldres.ad_var_c_res; newres.methodParams.cev.var_d = oldres.ad_var_d_res;
                        newres.methodParams.cev.setcovar(Coeff.a, Coeff.b, oldres.ad_covar_ab_res);
                        newres.methodParams.cev._covar[0, 2] = oldres.ad_covar_ac_res;
                        newres.methodParams.cev._covar[0, 3] = oldres.ad_covar_ad_res;
                        newres.methodParams.cev._covar[1, 2] = oldres.ad_covar_bc_res;
                        newres.methodParams.cev._covar[1, 3] = oldres.ad_covar_bd_res;
                        newres.methodParams.cev._covar[2, 3] = oldres.ad_covar_cd_res;
                        newres.methodParams.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)oldres.ad_add_a_source_equation;
                        newres.methodParams.cev.sigma_x = oldres.ad_sigma_x_res;

                        newres.methodParams.cf.a = oldres.ad_cf_a_res; newres.methodParams.cf.b = oldres.ad_cf_b_res;
                        newres.methodParams.cf.c = oldres.ad_cf_c_res; newres.methodParams.cf.d = oldres.ad_cf_d_res;
                        newres.methodParams.dzero_avg = oldres.ad_dzero_avg_res;
                        newres.methodParams.num_runs = oldres.ad_num_runs_res;
                        newres.methodParams.tm_dbls_rate_upper_limit = oldres.ad_tm_dbls_rate_upper_limit_res;
                        newres.methodParams.tm_weighting_factor = oldres.ad_tm_weighting_factor_res;
                        newres.methodParams.use_truncated_mult = (oldres.ad_use_truncated_mult_res == 0 ? false : true);
                        newres.methodParams.dzero_ref_date = INCC.DateFrom(TransferUtils.str(oldres.ad_dzero_ref_date_res, INCC.DATE_TIME_LENGTH));
                        newres.methodParams.position_dzero = TransferUtils.Copy(oldres.ad_position_dzero_res, INCC.MAX_ADDASRC_POSITIONS);
                        // devnote: the original methodParams dcl_mass, doubles, min, max not preserved in INCC5 aas result rec
                    }
                    else if (r is results_curium_ratio_rec)
                    {
                        // dev note: untested
                        mlogger.TraceEvent(LogLevels.Verbose, 34056, ("Transferring method results for " + r.GetType().ToString()));
                        results_curium_ratio_rec oldres = (results_curium_ratio_rec)r;
                        INCCMethodResults.results_curium_ratio_rec newres = (INCCMethodResults.results_curium_ratio_rec)
                        meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.CuriumRatio, true);
                        newres.pu.pu240e_mass = new Tuple(oldres.cr_pu240e_mass, oldres.cr_pu240e_mass_err);
                        newres.pu.mass = new Tuple(oldres.cr_pu_mass, oldres.cr_pu_mass_err);
                        newres.pu.dcl_mass = oldres.cr_dcl_pu_mass;
                        newres.pu.dcl_minus_asy_mass = new Tuple(oldres.cr_dcl_minus_asy_pu_mass, oldres.cr_dcl_minus_asy_pu_mass_err);
                        newres.pu.dcl_minus_asy_mass_pct = oldres.cr_dcl_minus_asy_pu_mass_pct;
                        newres.pu.dcl_minus_asy_pu_mass = new Tuple(oldres.cr_dcl_minus_asy_pu_mass, oldres.cr_dcl_minus_asy_pu_mass_err);
                        newres.pu.dcl_minus_asy_pu_mass_pct = oldres.cr_dcl_minus_asy_pu_mass_pct;
                        newres.pu.pass = TransferUtils.PassCheck(oldres.cr_pu_pass_fail);

                        newres.u.mass = new Tuple(oldres.cr_u_mass, oldres.cr_u_mass_err);
                        newres.u.dcl_mass = oldres.cr_dcl_u_mass_res;
                        newres.u.dcl_minus_asy_mass = new Tuple(oldres.cr_dcl_minus_asy_u_mass, oldres.cr_dcl_minus_asy_u_mass_err);
                        newres.u.dcl_minus_asy_mass_pct = oldres.cr_dcl_minus_asy_u_mass_pct;
                        newres.u.pass = TransferUtils.PassCheck(oldres.cr_u_pass_fail);

                        newres.u235.mass = new Tuple(oldres.cr_u235_mass, oldres.cr_u235_mass_err);
                        newres.u235.dcl_mass = oldres.cr_dcl_u235_mass_res;
                        newres.u235.dcl_minus_asy_mass = new Tuple(oldres.cr_dcl_minus_asy_u235_mass, oldres.cr_dcl_minus_asy_u235_mass_err);
                        newres.u235.dcl_minus_asy_mass_pct = oldres.cr_dcl_minus_asy_u235_mass_pct;

                        newres.cm_mass = new Tuple(oldres.cr_cm_mass, oldres.cr_cm_mass_err);
                        newres.methodParams2.cm_pu_ratio = new Tuple(oldres.cr_cm_pu_ratio, oldres.cr_cm_pu_ratio_err);
                        newres.cm_pu_ratio_decay_corr = new Tuple(oldres.cr_cm_pu_ratio_decay_corr, oldres.cr_cm_pu_ratio_decay_corr_err);
                        newres.methodParams2.cm_pu_ratio_date = INCC.DateFrom(TransferUtils.str(oldres.cr_cm_pu_ratio_date, INCC.DATE_TIME_LENGTH));
                        newres.cm_u_ratio_decay_corr = new Tuple(oldres.cr_cm_u_ratio_decay_corr, oldres.cr_cm_u_ratio_decay_corr_err);
                        newres.methodParams2.cm_u_ratio_date = INCC.DateFrom(TransferUtils.str(oldres.cr_cm_pu_ratio_date, INCC.DATE_TIME_LENGTH));
                        newres.methodParams2.pu_half_life = oldres.cr_pu_half_life;

                        newres.methodParams2.cm_id_label = TransferUtils.str(oldres.cr_cm_id_label, INCC.MAX_ITEM_ID_LENGTH);
                        newres.methodParams2.cm_id = TransferUtils.str(oldres.cr_cm_id, INCC.MAX_ITEM_ID_LENGTH);
                        newres.methodParams2.cm_input_batch_id = TransferUtils.str(oldres.cr_cm_input_batch_id, INCC.MAX_ITEM_ID_LENGTH);

                        newres.methodParams.cev.a = oldres.cr_a_res; newres.methodParams.cev.b = oldres.cr_b_res;
                        newres.methodParams.cev.c = oldres.cr_c_res; newres.methodParams.cev.d = oldres.cr_d_res;
                        newres.methodParams.cev.var_a = oldres.cr_var_a_res; newres.methodParams.cev.var_b = oldres.cr_var_b_res;
                        newres.methodParams.cev.var_c = oldres.cr_var_c_res; newres.methodParams.cev.var_d = oldres.cr_var_d_res;
                        newres.methodParams.cev.setcovar(Coeff.a,Coeff.b,oldres.cr_covar_ab_res);
                        newres.methodParams.cev._covar[0, 2] = oldres.cr_covar_ac_res;
                        newres.methodParams.cev._covar[0, 3] = oldres.cr_covar_ad_res;
                        newres.methodParams.cev._covar[1, 2] = oldres.cr_covar_bc_res;
                        newres.methodParams.cev._covar[1, 3] = oldres.cr_covar_bd_res;
                        newres.methodParams.cev._covar[2, 3] = oldres.cr_covar_cd_res;
                        newres.methodParams.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)oldres.cr_curium_ratio_equation;
                        newres.methodParams.cev.sigma_x = oldres.cr_sigma_x_res;
                        newres.methodParams.curium_ratio_type = OldToNewCRVariants(oldres.curium_ratio_type_res);
                    }
                    else if (r is results_active_passive_rec) // NEXT: confusion with combined, it's the same as Active internally? expand and study
                    {
                        mlogger.TraceEvent(LogLevels.Verbose, 34057, ("Transferring method results for " + r.GetType().ToString()));
                        results_active_passive_rec oldres = (results_active_passive_rec)r;
                        INCCMethodResults.results_active_passive_rec newres =
                            (INCCMethodResults.results_active_passive_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.ActivePassive, true);

                        newres.pass = TransferUtils.PassCheck(oldres.ap_pass_fail);
                        newres.k.v = oldres.ap_k; newres.k.err = oldres.ap_k_err;
                        newres.k0.v = oldres.ap_k0;
                        newres.k1.v = oldres.ap_k1; newres.k1.err = oldres.ap_k1_err;
                        newres.u235_mass.v = oldres.ap_u235_mass; newres.u235_mass.err = oldres.ap_u235_mass_err;
                        newres.dcl_minus_asy_u235_mass.v = oldres.ap_dcl_minus_asy_u235_mass; newres.dcl_minus_asy_u235_mass.err = oldres.ap_dcl_minus_asy_u235_mass_err;

                        newres.dcl_u235_mass = oldres.ap_dcl_u235_mass;
                        newres.dcl_minus_asy_u235_mass_pct = oldres.ap_dcl_minus_asy_u235_mass_pct;

                        newres.methodParams = new INCCAnalysisParams.active_passive_rec();
                        newres.methodParams.cev.a = oldres.ap_a_res; newres.methodParams.cev.b = oldres.ap_b_res;
                        newres.methodParams.cev.c = oldres.ap_c_res; newres.methodParams.cev.d = oldres.ap_d_res;
                        newres.methodParams.cev.var_a = oldres.ap_var_a_res; newres.methodParams.cev.var_b = oldres.ap_var_b_res;
                        newres.methodParams.cev.var_c = oldres.ap_var_c_res; newres.methodParams.cev.var_d = oldres.ap_var_d_res;
                        newres.methodParams.cev.setcovar(Coeff.a, Coeff.b, oldres.ap_covar_ab_res);
                        newres.methodParams.cev._covar[0, 2] = oldres.ap_covar_ac_res;
                        newres.methodParams.cev._covar[0, 3] = oldres.ap_covar_ad_res;
                        newres.methodParams.cev._covar[1, 2] = oldres.ap_covar_bc_res;
                        newres.methodParams.cev._covar[1, 3] = oldres.ap_covar_bd_res;
                        newres.methodParams.cev._covar[2, 3] = oldres.ap_covar_cd_res;
                        newres.methodParams.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)oldres.ap_active_passive_equation;
                        newres.methodParams.cev.sigma_x = oldres.ap_sigma_x_res;
                        newres.delta_doubles.v = oldres.ap_delta_doubles;
                        newres.delta_doubles.err = oldres.ap_delta_doubles_err;
                    }
                    else if (r is results_active_rec)
                    {
                        mlogger.TraceEvent(LogLevels.Verbose, 34058, ("Transferring method results for " + r.GetType().ToString()));
                        results_active_rec oldres = (results_active_rec)r;
                        INCCMethodResults.results_active_rec newres =
                            (INCCMethodResults.results_active_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.Active, true);
                        newres.pass = TransferUtils.PassCheck(oldres.act_pass_fail);
                        newres.k.v = oldres.act_k; newres.k.err = oldres.act_k_err;
                        newres.k0.v = oldres.act_k0;
                        newres.k1.v = oldres.act_k1; newres.k1.err = oldres.act_k1_err;
                        newres.u235_mass.v = oldres.act_u235_mass; newres.u235_mass.err = oldres.act_u235_mass_err;
                        newres.dcl_minus_asy_u235_mass.v = oldres.act_dcl_minus_asy_u235_mass; newres.dcl_minus_asy_u235_mass.err = oldres.act_dcl_minus_asy_u235_mass_err;

                        newres.dcl_u235_mass = oldres.act_dcl_u235_mass;
                        newres.dcl_minus_asy_u235_mass_pct = oldres.act_dcl_minus_asy_u235_mass_pct;

                        newres.methodParams = new INCCAnalysisParams.active_rec();
                        newres.methodParams.cev.a = oldres.act_a_res; newres.methodParams.cev.b = oldres.act_b_res;
                        newres.methodParams.cev.c = oldres.act_c_res; newres.methodParams.cev.d = oldres.act_d_res;
                        newres.methodParams.cev.var_a = oldres.act_var_a_res; newres.methodParams.cev.var_b = oldres.act_var_b_res;
                        newres.methodParams.cev.var_c = oldres.act_var_c_res; newres.methodParams.cev.var_d = oldres.act_var_d_res;
                        newres.methodParams.cev.setcovar(Coeff.a,Coeff.b,oldres.act_covar_ab_res);
                        newres.methodParams.cev._covar[0, 2] = oldres.act_covar_ac_res;
                        newres.methodParams.cev._covar[0, 3] = oldres.act_covar_ad_res;
                        newres.methodParams.cev._covar[1, 2] = oldres.act_covar_bc_res;
                        newres.methodParams.cev._covar[1, 3] = oldres.act_covar_bd_res;
                        newres.methodParams.cev._covar[2, 3] = oldres.act_covar_cd_res;
                        newres.methodParams.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)oldres.act_active_equation;
                        newres.methodParams.cev.sigma_x = oldres.act_sigma_x_res;
                    }
                    else if (r is results_active_mult_rec)
                    {
                        mlogger.TraceEvent(LogLevels.Verbose, 34059, ("Transferring method results for " + r.GetType().ToString()));
                        results_active_mult_rec oldres = (results_active_mult_rec)r;
                        INCCMethodResults.results_active_mult_rec newres =
                            (INCCMethodResults.results_active_mult_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.ActiveMultiplicity, true);
                        newres.methodParams = new INCCAnalysisParams.active_mult_rec();
                        newres.methodParams.vf1 = oldres.am_vf1_res;
                        newres.methodParams.vf2 = oldres.am_vf2_res;
                        newres.methodParams.vf3 = oldres.am_vf3_res;
                        newres.methodParams.vt1 = oldres.am_vt1_res;
                        newres.methodParams.vt2 = oldres.am_vt2_res;
                        newres.methodParams.vt3 = oldres.am_vt2_res;
                        newres.mult.v = oldres.am_mult;
                        newres.mult.err = oldres.am_mult_err;
                     }
                    else if (r is results_collar_rec)
                    {
                        mlogger.TraceEvent(LogLevels.Verbose, 34060, ("Transferring method results for " + r.GetType().ToString()));
                        results_collar_rec oldres = (results_collar_rec)r;
                        INCCMethodResults.results_collar_rec newres =
                            (INCCMethodResults.results_collar_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.Collar, true);

                        newres.u235_mass.v = oldres.col_u235_mass; newres.u235_mass.err = oldres.col_u235_mass_err;
                        newres.percent_u235 = oldres.col_percent_u235;
                        newres.total_u_mass = oldres.col_total_u_mass;
                        newres.k0.v = oldres.col_k0; newres.k0.err = oldres.col_k0_err;
                        newres.k1.v = oldres.col_k1; newres.k1.err = oldres.col_k1_err;
                        newres.k2.v = oldres.col_k2; newres.k2.err = oldres.col_k2_err;
                        newres.k3.v = oldres.col_k3; newres.k3.err = oldres.col_k3_err;
                        newres.k4.v = oldres.col_k4; newres.k4.err = oldres.col_k4_err;
                        newres.k5.v = oldres.col_k5; newres.k5.err = oldres.col_k5_err;
                        newres.source_id = TransferUtils.str(oldres.col_source_id, INCC.SOURCE_ID_LENGTH);
                        newres.total_corr_fact.v = oldres.col_total_corr_fact; newres.total_corr_fact.err = oldres.col_total_corr_fact_err;
                        newres.corr_doubles.v = oldres.col_corr_doubles; newres.corr_doubles.err = oldres.col_corr_doubles_err;
                        newres.dcl_length.v = oldres.col_dcl_length; newres.dcl_length.err = oldres.col_dcl_length_err;
                        newres.dcl_total_u235.v = oldres.col_dcl_total_u235; newres.dcl_total_u235.err = oldres.col_dcl_total_u235_err;
                        newres.dcl_total_u238.v = oldres.col_dcl_total_u238; newres.dcl_total_u238.err = oldres.col_dcl_total_u238_err;
                        newres.dcl_total_rods = oldres.col_dcl_total_rods;
                        newres.dcl_total_poison_rods = oldres.col_dcl_total_poison_rods;

                        newres.dcl_poison_percent.v = oldres.col_dcl_poison_percent;
                        newres.dcl_poison_percent.err = oldres.col_dcl_poison_percent_err;
                        newres.dcl_minus_asy_u235_mass_pct = oldres.col_dcl_minus_asy_u235_mass_pct;
                        newres.dcl_minus_asy_u235_mass.v = oldres.col_dcl_minus_asy_u235_mass;
                        newres.dcl_minus_asy_u235_mass.err = oldres.col_dcl_minus_asy_u235_mass_err;

                        newres.methodParamsC.cev.a = oldres.col_a_res; newres.methodParamsC.cev.b = oldres.col_b_res;
                        newres.methodParamsC.cev.c = oldres.col_c_res; newres.methodParamsC.cev.d = oldres.col_d_res;
                        newres.methodParamsC.cev.var_a = oldres.col_var_a_res; newres.methodParamsC.cev.var_b = oldres.col_var_b_res;
                        newres.methodParamsC.cev.var_c = oldres.col_var_c_res; newres.methodParamsC.cev.var_d = oldres.col_var_d_res;
                        newres.methodParamsC.cev.setcovar(Coeff.a,Coeff.b,oldres.col_covar_ab_res);
                        newres.methodParamsC.cev._covar[0, 2] = oldres.col_covar_ac_res;
                        newres.methodParamsC.cev._covar[0, 3] = oldres.col_covar_ad_res;
                        newres.methodParamsC.cev._covar[1, 2] = oldres.col_covar_bc_res;
                        newres.methodParamsC.cev._covar[1, 3] = oldres.col_covar_bd_res;
                        newres.methodParamsC.cev._covar[2, 3] = oldres.col_covar_cd_res;
                        newres.methodParamsC.cev.cal_curve_equation = (INCCAnalysisParams.CurveEquation)oldres.col_collar_equation;
                        newres.methodParamsC.cev.sigma_x = oldres.col_sigma_x_res;
                        newres.methodParamsC.poison_absorption_fact[0] = oldres.col_poison_absorption_fact_res;
                        newres.methodParamsC.poison_rod_a[0] = new Tuple(oldres.col_poison_rod_a_res, oldres.col_poison_rod_a_err_res);
                        newres.methodParamsC.poison_rod_b[0] = new Tuple(oldres.col_poison_rod_b_res, oldres.col_poison_rod_b_err_res);
                        newres.methodParamsC.poison_rod_c[0] = new Tuple(oldres.col_poison_rod_c_res, oldres.col_poison_rod_c_err_res);
                        newres.methodParamsC.collar_mode = (oldres.col_collar_mode == 0 ? false : true);
                        newres.methodParamsC.number_calib_rods = (int)oldres.col_number_calib_rods_res;
                        newres.methodParamsC.poison_rod_type[0] = TransferUtils.str(oldres.col_poison_rod_type_res, INCC.MAX_ROD_TYPE_LENGTH);
                        newres.methodParamsC.u_mass_corr_fact_a.v = oldres.col_u_mass_corr_fact_a_res; newres.methodParamsC.u_mass_corr_fact_a.err = oldres.col_u_mass_corr_fact_a_err_res;
                        newres.methodParamsC.u_mass_corr_fact_b.v = oldres.col_u_mass_corr_fact_b_res; newres.methodParamsC.u_mass_corr_fact_b.err = oldres.col_u_mass_corr_fact_b_err_res;
                        newres.methodParamsC.sample_corr_fact.v = oldres.col_sample_corr_fact_res; newres.methodParamsC.sample_corr_fact.err = oldres.col_sample_corr_fact_err_res;

                        newres.methodParamsDetector.collar_mode = (oldres.col_collar_mode == 0 ? false : true);
                        newres.methodParamsDetector.reference_date = INCC.DateFrom(TransferUtils.str(oldres.col_reference_date_res, INCC.DATE_TIME_LENGTH));
                        newres.methodParamsDetector.relative_doubles_rate = oldres.col_relative_doubles_rate_res;

                        newres.methodParamsK5.k5_mode = (oldres.col_collar_mode == 0 ? false : true);
                        newres.methodParamsK5.k5_item_type = TransferUtils.str(oldres.col_collar_item_type, INCC.MAX_ITEM_TYPE_LENGTH);
                        newres.methodParamsK5.k5 = Copy(oldres.collar_k5_res, oldres.collar_k5_err_res, INCC.MAX_COLLAR_K5_PARAMETERS);
                        newres.methodParamsK5.k5_checkbox = TransferUtils.Copy(oldres.collar_k5_checkbox_res, INCC.MAX_COLLAR_K5_PARAMETERS);
                        for (int i = 0; i < INCC.MAX_COLLAR_K5_PARAMETERS; i++)
                        {
                            int index = i * INCC.MAX_K5_LABEL_LENGTH;
                            newres.methodParamsK5.k5_label[i] = TransferUtils.str(oldres.collar_k5_label_res + index, INCC.MAX_K5_LABEL_LENGTH);
                        }

                        CollarItemId cid = new CollarItemId(TransferUtils.str(results.item_id, INCC.MAX_ITEM_ID_LENGTH));
                        cid.length = new Tuple(newres.dcl_length);
                        cid.total_u235 = new Tuple(newres.dcl_total_u235);
                        cid.total_u238 = new Tuple(newres.dcl_total_u238);
                        cid.total_rods = newres.dcl_total_rods;
                        cid.total_poison_rods = newres.dcl_total_poison_rods;
                        cid.poison_percent = new Tuple(newres.dcl_poison_percent);
                        cid.rod_type = newres.methodParamsC.poison_rod_type[0];
                        cid.modified = true;

                        List<CollarItemId> list = NC.App.DB.CollarItemIds.GetList();
                        bool glump = list.Exists(i => { return string.Compare(cid.item_id, i.item_id, true) == 0; });
                        if (glump && overwrite)
                        {
                            list.Remove(cid);
                            list.Add(cid);
                        }
                        else list.Add(cid);
                    }
                    else if (r is results_de_mult_rec)
                    {
                        mlogger.TraceEvent(LogLevels.Verbose, 34061, ("Transferring method results for " + r.GetType().ToString()));
                        results_de_mult_rec oldres = (results_de_mult_rec)r;
                        INCCMethodResults.results_de_mult_rec newres =
                            (INCCMethodResults.results_de_mult_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.DUAL_ENERGY_MULT_SAVE_RESTORE, true);
                        newres.meas_ring_ratio = oldres.de_meas_ring_ratio;
                        newres.energy_corr_factor = oldres.de_energy_corr_factor;
                        newres.interpolated_neutron_energy = oldres.de_interpolated_neutron_energy;
                        newres.methodParams.detector_efficiency = TransferUtils.Copy(oldres.de_detector_efficiency_res, INCC.MAX_DUAL_ENERGY_ROWS);
                        newres.methodParams.inner_outer_ring_ratio = TransferUtils.Copy(oldres.de_inner_outer_ring_ratio_res, INCC.MAX_DUAL_ENERGY_ROWS);
                        newres.methodParams.neutron_energy = TransferUtils.Copy(oldres.de_neutron_energy_res, INCC.MAX_DUAL_ENERGY_ROWS);
                        newres.methodParams.relative_fission = TransferUtils.Copy(oldres.de_relative_fission_res, INCC.MAX_DUAL_ENERGY_ROWS);
                        newres.methodParams.inner_ring_efficiency = oldres.de_inner_ring_efficiency_res;
                        newres.methodParams.outer_ring_efficiency = oldres.de_outer_ring_efficiency_res;
                    }
                    else if (r is results_tm_bkg_rec)
                    {
                        mlogger.TraceEvent(LogLevels.Warning, 34062, ("Transferring method results for " + r.GetType().ToString()));
                        results_tm_bkg_rec oldres = (results_tm_bkg_rec)r;  // todo: tm bkg handling design incomplete, these values are attached to bkg measurements when the truncated flag is enabled
                        INCCMethodResults.results_tm_bkg_rec newres =
                            (INCCMethodResults.results_tm_bkg_rec)meas.INCCAnalysisResults.LookupMethodResults(det.MultiplicityParams, meas.INCCAnalysisState.Methods.selector, AnalysisMethod.None, true);
                        newres.methodParams.Singles.v = oldres.results_tm_singles_bkg;
                        newres.methodParams.Singles.err = oldres.results_tm_singles_bkg_err;
                        newres.methodParams.Zeros.v = oldres.results_tm_zeros_bkg;
                        newres.methodParams.Zeros.err = oldres.results_tm_zeros_bkg_err;
                        newres.methodParams.Ones.v = oldres.results_tm_ones_bkg;
                        newres.methodParams.Ones.err = oldres.results_tm_ones_bkg_err;
                        newres.methodParams.Twos.v = oldres.results_tm_twos_bkg;
                        newres.methodParams.Twos.err = oldres.results_tm_twos_bkg_err;
                    }
                    else
                    {
                        mlogger.TraceEvent(LogLevels.Warning, 34040, ("todo: Transferring method results for " + r.GetType().ToString())); // todo: complete the list
                    }
                }

            }
            #endregion results transfer
            // dev note: here is where the detector tree creation and replacement with restore_replace_detector_structs occurs in the original code
            // todo: based on overwrite flag, replace det-dependent classes, the analysis_methods: (none-map) and each (det,mat) -> calib from results class instances

            #region Meas&Results

            AnalysisDefs.holdup_config_rec hc = new AnalysisDefs.holdup_config_rec();
            hc.glovebox_id = TransferUtils.str(results.results_glovebox_id, INCC.MAX_GLOVEBOX_ID_LENGTH);
            hc.num_columns = results.results_num_columns;
            hc.num_rows = results.results_num_rows;
            hc.distance = results.results_distance;
            meas.AcquireState.glovebox_id = hc.glovebox_id;
            // this is a good place to create the general results_rec
            INCCResults.results_rec xres = new INCCResults.results_rec(meas);
            meas.INCCAnalysisResults.TradResultsRec = xres;
            // oddball entries in need of preservation
            xres.total_good_count_time = results.total_good_count_time;
            xres.total_number_runs = results.total_number_runs;
            xres.primary = imr.primaryMethod;
            xres.net_drum_weight = results.net_drum_weight;
            xres.completed = (results.completed != 0 ? true : false);
            xres.db_version = results.db_version;
            xres.hc = hc;
            xres.original_meas_date = INCC.DateFrom(TransferUtils.str(results.original_meas_date, INCC.DATE_TIME_LENGTH));
            // NEXT: copy move passive and active meas id's here

             long mid = meas.Persist();

            // save the warning and error messages from the results here, these rode on the results rec in INCC5
            NC.App.DB.AddAnalysisMessages(msgs, mid);

            // Store off Params

            NC.App.DB.UpdateDetector(det);
            NC.App.DB.NormParameters.Set(det, meas.Norm);  // might have been saved in earlier step already
            NC.App.DB.BackgroundParameters.Set(det, meas.Background);

            INCCDB.AcquireSelector acqsel = new INCCDB.AcquireSelector(det, acq.item_type, acq.MeasDateTime);
            if (overwrite)
            {
                NC.App.DB.ReplaceAcquireParams(acqsel, acq);
            }
            else
                NC.App.DB.AddAcquireParams(acqsel, acq); // gotta add it to the global map, then push it to the DB

            if (meas.Tests != null) // added only if not found on the list
                NC.App.DB.TestParameters.Set(meas.Tests);

            NC.App.DB.Isotopics.SetList();  // new style de 'mouser'!
            //NC.App.DB.CompositeIsotopics.SetList();// next:NYI
            NC.App.DB.ItemIds.SetList(); // This writes any new items ids to the DB
            NC.App.DB.CollarItemIds.SetList(); // so does this

            //Loop over measurement cycles
            NC.App.DB.AddCycles(meas.Cycles, det.MultiplicityParams, mid);

            //Store off Params

            // todo: complete table design and creation/update here, still have issues with collar and curium ratio results
            // get results based on meas option, (Calib and Verif have method results, others do not), update into DB here
            IEnumerator iter = meas.INCCAnalysisResults.GetMeasSelectorResultsEnumerator();
            while (iter.MoveNext())  // only one result indexer is present when doing an INCC5 transfer
            {
                MeasOptionSelector moskey = (MeasOptionSelector)iter.Current;
                INCCResult ir = meas.INCCAnalysisResults[moskey];
                // ir contains the measurement option-specific results: empty for rates and holdup, and also empty for calib and verif, the method-focused analyses,
                // but values are present for initial, normalization, precision, and should be present for background for the tm bkg results
                switch (meas.MeasOption)
                {
                    case AssaySelector.MeasurementOption.background:
                        if (meas.Background.TMBkgParams.ComputeTMBkg)
                            mlogger.TraceEvent(LogLevels.Warning, 82010, "Background truncated multiplicity"); // todo: present the tm bkg results on m.Background
                        break;
                    case AssaySelector.MeasurementOption.initial:
                    case AssaySelector.MeasurementOption.normalization:
                    case AssaySelector.MeasurementOption.precision:
                        {
                            ElementList els = ir.ToDBElementList();
                            ParamsRelatedBackToMeasurement ar = new ParamsRelatedBackToMeasurement(ir.Table);
                            long resid = ar.Create(mid, els);
                            mlogger.TraceEvent(LogLevels.Verbose, 34103, string.Format("Preserving {0} as {1}", ir.Table, resid));
                        }
                        break;
                    case AssaySelector.MeasurementOption.verification:
                    case AssaySelector.MeasurementOption.calibration:
                    {
                        INCCMethodResults imrs;
                        bool have = meas.INCCAnalysisResults.TryGetINCCResults(moskey.MultiplicityParams, out imrs);
                        if (have) // should be true for verification and calibration
                        {
                            if (imrs.ContainsKey(meas.INCCAnalysisState.Methods.selector))
                            {
                                // we've got a distinct detector id and material type on the methods, so that is the indexer here
                                Dictionary<AnalysisMethod, INCCMethodResult> amimr = imrs[meas.INCCAnalysisState.Methods.selector];

                                // now get an enumerator over the map of method results
                                Dictionary<AnalysisMethod, INCCMethodResult>.Enumerator ai = amimr.GetEnumerator();
                                while (ai.MoveNext())
                                {
                                    if (ai.Current.Key.IsNone())
                                        continue;
                                    INCCMethodResult _imr = ai.Current.Value;
                                    // insert this into the DB under the current meas key
                                    try
                                    {
                                        ElementList els = _imr.ToDBElementList(); // also sets table property, gotta do it first
                                        ParamsRelatedBackToMeasurement ar = new ParamsRelatedBackToMeasurement(_imr.Table);
                                        long resid = ar.Create(mid, els);
                                        do
                                        {
                                            long resmid = ar.CreateMethod(resid, mid, _imr.methodParams.ToDBElementList());
                                            mlogger.TraceEvent(LogLevels.Verbose, 34101, string.Format("Preserving {0} as {1},{2}", _imr.Table, resmid, resid));
                                        } while (_imr.methodParams.Pump > 0);
                                    }
                                    catch (Exception e)
                                    {
                                        mlogger.TraceEvent(LogLevels.Warning, 34102, "Results processing error {0} {1}", _imr.ToString(), e.Message);
                                    }
                                }
                            } else
                                mlogger.TraceEvent(LogLevels.Error, 34102, "Results missing for {0}", meas.INCCAnalysisState.Methods.selector.ToString());

                        }
                    }
                    break;
                    case AssaySelector.MeasurementOption.rates:
                    case AssaySelector.MeasurementOption.holdup:
                    case AssaySelector.MeasurementOption.unspecified:
                    default: // nothing new to present with these
                        break;
                }
            }
            #endregion Meas&Results

              // todo: handle well config setting with bkg here;

            return true;
        }