public override void RunTest(ISyncLock lockObject, TestParameters testParameters)
{
if (lockObject is NoOpLock)
{
throw new InapplicableTestException("Unbalanced calls test not applicable for this lock type");
}
Console.WriteLine("Normal usage scenario -- autolock create / dispose with using");
ExerciseStandardUsage(lockObject, false);
Console.WriteLine("Normal usage scenario -- succeeded");
Console.WriteLine("Exception in using -- lock should be freed");
try
{
ExerciseStandardUsage(lockObject, true);
}
catch (IntentionalTestException e)
{
Console.WriteLine("Expected exception caught: {0}: {1}", e.GetType().ToString(), e.Message);
}
Console.WriteLine("Validate that the lock is freed by exercising the normal scenario again");
ExerciseStandardUsage(lockObject, false);
}
public override void RunTest(Synchronization.ISyncLock lockObject, TestParameters testParameters)
{
if (lockObject is NoOpLock)
{
throw new InapplicableTestException("Timeout tests are not needed for no op locks");
}
Console.WriteLine("Trying simple timed wait with long timeout");
bool acquired = lockObject.WaitForLock(new TimeSpan(1, 0, 0));
if (!acquired)
{
throw new InvalidOperationException("Unable to acquire lock in single thread scenario");
}
Console.WriteLine("Successfully acquired lock after bounded wait");
lockObject.Unlock();
//
// Wait for 0 seconds for lock after it is known to have been released
//
Console.WriteLine("Now wait for 0 and verify correct signaled state");
TestLockWait(lockObject, new TimeSpan(0, 0, 0), new TimeSpan(0,0,0), true);
//
// Signal, Wait for 0 secondsm
//
Console.WriteLine("Now acquire the lock and verify that it is acquired after the other thread holds it for 0 s");
TestLockWait(lockObject, new TimeSpan(0, 0, 5), new TimeSpan(0,0,0), false);
//
// Wait for 5s for a lock that is held for 3s
//
Console.WriteLine("Wait 5s for a lock held 3s");
TestLockWait(lockObject, new TimeSpan(0, 0, 5), new TimeSpan(0, 0, 3), false);
//
// Wait for 0s for a lock that is held for 3s -- lock should fail to be released
//
Console.WriteLine("Wait 0s for a lock held 3s");
TestLockWait(lockObject, new TimeSpan(0, 0, 0), new TimeSpan(0, 0, 3), false);
//
// Wait for 1s for a lock that is held for 4s -- lock should fail to be released
//
Console.WriteLine("Wait 1s for a lock held 4s");
TestLockWait(lockObject, new TimeSpan(0, 0, 1), new TimeSpan(0, 0, 4), false);
//
// Wait for 4s for a lock held 1s
//
Console.WriteLine("Wait 7s for a lock held 4s");
TestLockWait(lockObject, new TimeSpan(0, 0, 7), new TimeSpan(0, 0, 4), false);
}
public INCCSR(ShiftRegisterParameters sr, DataSourceIdentifier id, AcquireParameters acq, TestParameters test, LMLoggers.LognLM log)
{
sr_parms = new ShiftRegisterParameters(sr);
dsid = new DataSourceIdentifier(id);
dsid.SerialPort -= 1; // serial ports are 0 based at the HW layer
acquire_parms = new AcquireParameters(acq);
test_parms = new TestParameters(test);
this.log = log;
}
public static void ParallelForBoundary3()
{
TestParameters parameters = new TestParameters(API.For64, StartIndexBase.Int16, 100)
{
Count = 1000,
WorkloadPattern = WorkloadPattern.Decreasing,
};
ParallelForTest test = new ParallelForTest(parameters);
test.RealRun();
}
public static void ParallelForBoundary5()
{
TestParameters parameters = new TestParameters(API.For64, StartIndexBase.Int32, -100)
{
Count = 1000,
WorkloadPattern = WorkloadPattern.Similar,
};
ParallelForTest test = new ParallelForTest(parameters);
test.RealRun();
}
public static void TestFor_Boundary(API api, StartIndexBase startIndexBase, int startIndexOffset, int count, WorkloadPattern workloadPattern)
{
var parameters = new TestParameters(api, startIndexBase, startIndexOffset)
{
Count = count,
WorkloadPattern = workloadPattern,
};
var test = new ParallelForTest(parameters);
test.RealRun();
}
public override void RunTest(ISyncLock syncLock, TestParameters testParameters)
{
this.syncLock = (ISyncLock)syncLock;
requireLock = !(syncLock is NoOpLock);
testTimeoutSeconds = testParameters.MaxWaitSeconds;
Thread[] threads = new Thread[desiredValues.Length];
for (int threadIndex = 0; threadIndex < threads.Length; threadIndex++)
{
threads[threadIndex] = new Thread(ContendingThreadFunction);
completedEvents[threadIndex] = new ManualResetEvent(false);
threads[threadIndex].Start(threadIndex);
}
startThreadsEvent.Set();
Console.WriteLine("Sleeping for {0} seconds", testParameters.MaxWaitSeconds);
Thread.Sleep(testParameters.MaxWaitSeconds * 1000);
Console.WriteLine("Signaling threads to terminate");
endTestEvent.Set();
Console.WriteLine("Waiting for {0} threads to complete after termination signal", threads.Length);
WaitHandle.WaitAll(completedEvents);
Console.WriteLine("Completed all waits for thread ids:");
for (int threadIndex = 0; threadIndex < threads.Length; threadIndex++)
{
Console.WriteLine("Thread: {0}\tIterations: {1}", threads[threadIndex].ManagedThreadId, iterationCounts[threadIndex]);
}
if (!requireLock)
{
if (!expectedSynchronizationErrorOccurred)
{
throw new InvalidOperationException("Expected synchronization error due to absence of lock did not occur.");
}
Console.WriteLine("Expected synchronization error successfully detected.");
}
else if (null != testException)
{
throw testException;
}
}
public static void ParallelForTest4()
{
TestParameters parameters = new TestParameters(API.For64, StartIndexBase.Int32)
{
Count = 1,
ParallelOption = WithParallelOption.WithDOP,
StateOption = ActionWithState.None,
LocalOption = ActionWithLocal.HasFinally,
};
ParallelForTest test = new ParallelForTest(parameters);
test.RealRun();
}
public static void ParrallelFor(API api, StartIndexBase startIndexBase, int count, WithParallelOption parallelOption, ActionWithState stateOption, ActionWithLocal localOption)
{
var parameters = new TestParameters(api, startIndexBase)
{
Count = count,
ParallelOption = parallelOption,
StateOption = stateOption,
LocalOption = localOption
};
var test = new ParallelForTest(parameters);
test.RealRun();
}
public static void TaskCreateTest3()
{
TestParameters parameters = new TestParameters(TaskType.FutureT)
{
HasCancellationToken = true,
HasActionState = true,
HasTaskManager = false,
HasTaskOption = false,
ExceptionTestsAction = ExceptionTestsAction.None,
};
TaskCreateTest test = new TaskCreateTest(parameters);
test.CreateTask();
}
public static void TestForeach_Partitioner(int count, int chunkSize, PartitionerType partitionerType, WithParallelOption parallelOption, ActionWithLocal localOption, ActionWithState stateOption)
{
var parameters = new TestParameters(API.Foreach, StartIndexBase.Zero)
{
Count = count,
ChunkSize = chunkSize,
PartitionerType = partitionerType,
ParallelForeachDataSourceType = DataSourceType.Partitioner,
ParallelOption = parallelOption,
LocalOption = localOption,
StateOption = stateOption,
};
var test = new ParallelForTest(parameters);
test.RealRun();
}
public static void ParallelForeachPartitioner3()
{
TestParameters parameters = new TestParameters(API.Foreach, StartIndexBase.Zero)
{
Count = 10,
ChunkSize = 3,
PartitionerType = PartitionerType.RangePartitioner,
ParallelForeachDataSourceType = DataSourceType.Partitioner,
ParallelOption = WithParallelOption.WithDOP,
LocalOption = ActionWithLocal.None,
StateOption = ActionWithState.None,
};
ParallelForTest test = new ParallelForTest(parameters);
test.RealRun();
}
public IDDTestParametersSetup()
{
InitializeComponent();
tp = new TestParameters(NC.App.DB.TestParameters.Get()); // last one on the list is the newest one, we make local copy, and we update on the way out
if (tp == null)
{
tp = new TestParameters();
}
// Fill in the GUI elements with the current values stored in the local data structure
this.AccidentalsSinglesTestRateLimitTextBox.Text = tp.accSnglTestRateLimit.ToString("F2");
this.AccidentalsSinglesTestPrecisionLimitTextBox.Text = tp.accSnglTestPrecisionLimit.ToString("F2");
this.AccidentalsSinglesTestOutlierLimitTextBox.Text = tp.accSnglTestOutlierLimit.ToString("F2");
this.OutlierTestLimitTextBox.Text = tp.outlierTestLimit.ToString("F2");
this.MaxCyclesTextBox.Text = tp.maxCyclesForOutlierTest.ToString();
this.MaxChecksumTextBox.Text = tp.maxNumFailures.ToString();
this.ChecksumCheckbox.Checked = tp.checksum;
this.VerificationLimitTextBox.Text = tp.normalBackupAssayTestLimit.ToString("F2");
this.BackgroundDoublesRateLimitTextBox.Text = tp.bkgDoublesRateLimit.ToString("F2");
this.BackgroundTriplesRateLimitTextBox.Text = tp.bkgTriplesRateLimit.ToString("F2");;
this.ChiSquaredLimitTextBox.Text = tp.chiSquaredLimit.ToString("F2");
this.HighVoltageTestLimitTextBox.Text = tp.highVoltageTestLimit.ToString("F2");
this.MeasureAccidentalsRadioButton.Checked = (tp.accidentalsMethod == AccidentalsMethod.Measure ? true : false);
this.CalculateAccidentalsRadioButton.Checked = (tp.accidentalsMethod == AccidentalsMethod.Calculate ? true : false);
}
public void ObjectToDictionary_AllReadablePropertiesBecomeKeys()
{
TestParameters p = new TestParameters { Key = "Key", Value = 1 };
var d = UrlHelper.ObjectToDictionary(p);
Assert.AreEqual(2, d.Count);
Assert.IsTrue(d.ContainsKey("Key"));
Assert.IsTrue(d.ContainsValue("Key"));
Assert.IsTrue(d.ContainsKey("Value"));
Assert.IsTrue(d.ContainsValue("1"));
}
public void CreateTestParameters()
{
_parameters = new TestParameters();
}
public static void TaskCreateTest42()
{
TestParameters parameters = new TestParameters(TaskType.Task)
{
HasCancellationToken = true,
HasActionState = false,
HasTaskManager = false,
HasTaskOption = false,
ExceptionTestsAction = ExceptionTestsAction.StartOnPromise,
};
TaskCreateTest test = new TaskCreateTest(parameters);
test.ExceptionTests();
}
public static void TaskCreateTest48()
{
TestParameters parameters = new TestParameters(TaskType.Task)
{
HasCancellationToken = true,
HasActionState = true,
HasTaskManager = true,
HasTaskOption = true,
ExceptionTestsAction = ExceptionTestsAction.None,
};
TaskCreateTest test = new TaskCreateTest(parameters);
test.StartNewTask();
}
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;
}
public override void ParseCommand(CommandCreationParam commandCreationParam){
base.ParseCommand(commandCreationParam);
_testParameters = commandCreationParam.TestParameters;
}
protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters) => new GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider((IPickMembersService)parameters.fixProviderData);
public static void ParallelForeachPartitioner8()
{
TestParameters parameters = new TestParameters(API.Foreach, StartIndexBase.Zero)
{
Count = 1,
ChunkSize = 1,
PartitionerType = PartitionerType.IEnumerableOOB,
ParallelForeachDataSourceType = DataSourceType.Partitioner,
ParallelOption = WithParallelOption.None,
LocalOption = ActionWithLocal.HasFinally,
StateOption = ActionWithState.Stop,
};
ParallelForTest test = new ParallelForTest(parameters);
test.RealRun();
}
private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
{
List <string> ls = null;
if (e.Node.Parent == null)
{
if (e.Node.Tag == null)
{
return;
}
else
{
Type t = (Type)e.Node.Tag;
if (t == typeof(TestParameters))
{
TestParameters d = N.App.DB.TestParameters.Get();
ls = d.ToDBElementList(generate: true).AlignedNameValueList;
}
}
}
else
{
object o = e.Node.Parent.Tag;
if (o == null)
{
return;
}
else // display content in the right-hand pane
{
Type t = e.Node.Tag.GetType();
if (t == typeof(ItemId))
{
ls = ((ParameterBase)e.Node.Tag).ToDBElementList(generate: true).AlignedNameValueList;
}
else if (t == typeof(Detector))
{
ls = GenDetIdStr(((Detector)e.Node.Tag).Id);
}
else if (t == typeof(Isotopics))
{
ls = ((ParameterBase)e.Node.Tag).ToDBElementList(generate: true).AlignedNameValueList;
}
else if (t == typeof(CompositeIsotopics))
{
ls = ((ParameterBase)e.Node.Tag).ToDBElementList(generate: true).AlignedNameValueList;
}
else if (t == typeof(CollarItemId))
{
ls = ((ParameterBase)e.Node.Tag).ToDBElementList(generate: true).AlignedNameValueList;
}
else if (t == typeof(Stratum))
{
ls = ((ParameterBase)e.Node.Tag).ToDBElementList(generate: true).AlignedNameValueList;
}
else if (t == typeof(INCCDB.Descriptor))
{
INCCDB.Descriptor d = (INCCDB.Descriptor)e.Node.Tag;
ls = new List <string>(); ls.Add(d.Item1 + ": " + d.Item2);
}
else if (t == typeof(AnalysisMethods))
{
AnalysisMethods d = (AnalysisMethods)e.Node.Tag;
ls = d.ToDBElementList(generate: true).AlignedNameValueList;
}
else if (t == typeof(AcquireParameters))
{
AcquireParameters d = (AcquireParameters)e.Node.Tag;
ls = d.ToDBElementList(generate: true).AlignedNameValueList;
}
else if (t == typeof(AlphaBeta))
{
AlphaBeta AB = (AlphaBeta)e.Node.Tag;
ls = GenDetABStr(AB);
}
else if (t == typeof(Multiplicity))
{
Multiplicity m = (Multiplicity)e.Node.Tag;
ls = GenDetMultStr((Detector)o, m);
}
else if (t == typeof(DataSourceIdentifier))
{
DataSourceIdentifier d = (DataSourceIdentifier)e.Node.Tag;
ls = GenDetIdStr(d);
}
else if (t == typeof(INCCDB.IndexedResults))
{
ls = GenMeasStr((INCCDB.IndexedResults)e.Node.Tag);;
}
}
}
StringBuilder sb = new StringBuilder(100);
if (ls != null)
{
foreach (string s in ls)
{
sb.Append(s); sb.Append('\r');
}
richTextBox1.Text = sb.ToString();
}
}
protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters) => new CSharpMoveDeclarationNearReferenceCodeRefactoringProvider();
protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters) => new CSharpUseNamedArgumentsCodeRefactoringProvider();
protected TestWorkspace CreateWorkspaceFromOptions(string workspaceMarkupOrCode, TestParameters parameters)
{
var composition = GetComposition().WithTestHostParts(parameters.testHost);
parameters = SetParameterDefaults(parameters);
var documentServiceProvider = GetDocumentServiceProvider();
var workspace = TestWorkspace.IsWorkspaceElement(workspaceMarkupOrCode)
? TestWorkspace.Create(XElement.Parse(workspaceMarkupOrCode), openDocuments: false, composition: composition, documentServiceProvider: documentServiceProvider, workspaceKind: parameters.workspaceKind)
: TestWorkspace.Create(GetLanguage(), parameters.compilationOptions, parameters.parseOptions, files: new[] { workspaceMarkupOrCode }, composition: composition, documentServiceProvider: documentServiceProvider, workspaceKind: parameters.workspaceKind);
#if !CODE_STYLE
if (parameters.testHost == TestHost.OutOfProcess && _logger != null)
{
var remoteHostProvider = (InProcRemoteHostClientProvider)workspace.Services.GetRequiredService <IRemoteHostClientProvider>();
remoteHostProvider.TraceListener = new XunitTraceListener(_logger);
}
#endif
InitializeWorkspace(workspace, parameters);
// For CodeStyle layer testing, we create an .editorconfig at project root
// to apply the options as workspace options are not available in CodeStyle layer.
// Otherwise, we apply the options directly to the workspace.
#if CODE_STYLE
// We need to ensure that our projects/documents are rooted for
// execution from CodeStyle layer as we will be adding a rooted .editorconfig to each project
// to apply the options.
if (parameters.options != null)
{
MakeProjectsAndDocumentsRooted(workspace);
AddAnalyzerConfigDocumentWithOptions(workspace, parameters.options);
}
#else
workspace.ApplyOptions(parameters.options);
#endif
return(workspace);
}
protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters) => new MoveTypeCodeRefactoringProvider();
private void Test(TestParameters[] tests)
{
PriorStudyLoaderExceptionPolicy.Reset();
var policy = new PriorStudyLoaderExceptionPolicy();
var context = new Context();
foreach (var test in tests)
{
//reset.
context.ShowedMessageBox = false;
if (test.FindFailed || !test.ResultsComplete)
{
var exception = test.FindFailed
? new LoadPriorStudiesException()
: new LoadPriorStudiesException(test.OtherExceptions, test.StudyCount, test.ResultsComplete);
PriorStudyLoaderExceptionPolicy.NotifyFailedQuery();
policy.Handle(exception, context);
Assert.AreEqual(test.MessageBoxExpected, context.ShowedMessageBox);
}
else
{
PriorStudyLoaderExceptionPolicy.NotifySuccessfulQuery();
if (test.OtherExceptions.Count > 0)
{
var exception = new LoadPriorStudiesException(test.OtherExceptions, test.StudyCount, test.ResultsComplete);
policy.Handle(exception, context);
}
Assert.AreEqual(test.MessageBoxExpected, context.ShowedMessageBox);
}
}
}
protected override CodeRefactoringProvider CreateCodeRefactoringProvider(
Workspace workspace,
TestParameters parameters
) => new ReplacePropertyWithMethodsCodeRefactoringProvider();
public static void ParallelForTest47()
{
TestParameters parameters = new TestParameters(API.Foreach, StartIndexBase.Zero)
{
Count = 97,
ParallelOption = WithParallelOption.WithDOP,
StateOption = ActionWithState.Stop,
LocalOption = ActionWithLocal.None,
};
ParallelForTest test = new ParallelForTest(parameters);
test.RealRun();
}
protected async Task TestChangeNamespaceAsync(
string initialMarkUp,
string expectedSourceOriginal,
string expectedSourceReference = null)
{
var testOptions = new TestParameters();
using (var workspace = CreateWorkspaceFromOptions(initialMarkUp, testOptions))
{
if (workspace.Projects.Count == 2)
{
var project = workspace.Documents.Single(doc => !doc.SelectedSpans.IsEmpty()).Project;
var dependentProject = workspace.Projects.Single(proj => proj.Id != project.Id);
var references = dependentProject.ProjectReferences.ToList();
references.Add(new ProjectReference(project.Id));
dependentProject.ProjectReferences = references;
workspace.OnProjectReferenceAdded(dependentProject.Id, new ProjectReference(project.Id));
}
if (expectedSourceOriginal != null)
{
var originalDocument = workspace.Documents.Single(doc => !doc.SelectedSpans.IsEmpty());
var originalDocumentId = originalDocument.Id;
var refDocument = workspace.Documents.Where(doc => doc.Id != originalDocumentId).SingleOrDefault();
var refDocumentId = refDocument?.Id;
var oldAndNewSolution = await TestOperationAsync(testOptions, workspace);
var oldSolution = oldAndNewSolution.Item1;
var newSolution = oldAndNewSolution.Item2;
var changedDocumentIds = SolutionUtilities.GetChangedDocuments(oldSolution, newSolution);
Assert.True(changedDocumentIds.Contains(originalDocumentId), "original document was not changed.");
var modifiedOriginalDocument = newSolution.GetDocument(originalDocumentId);
var modifiedOringinalRoot = await modifiedOriginalDocument.GetSyntaxRootAsync();
// One node/token will contain the warning we attached for change namespace action.
Assert.Single(modifiedOringinalRoot.DescendantNodesAndTokensAndSelf().Where(n =>
{
IEnumerable <SyntaxAnnotation> annotations;
if (n.IsNode)
{
annotations = n.AsNode().GetAnnotations(WarningAnnotation.Kind);
}
else
{
annotations = n.AsToken().GetAnnotations(WarningAnnotation.Kind);
}
return(annotations.Any(annotation =>
WarningAnnotation.GetDescription(annotation) == FeaturesResources.Warning_colon_changing_namespace_may_produce_invalid_code_and_change_code_meaning));
}));
var actualText = (await modifiedOriginalDocument.GetTextAsync()).ToString();
Assert.Equal(expectedSourceOriginal, actualText);
if (expectedSourceReference == null)
{
// there shouldn't be any textual change
if (changedDocumentIds.Contains(refDocumentId))
{
var oldRefText = (await oldSolution.GetDocument(refDocumentId).GetTextAsync()).ToString();
var newRefText = (await newSolution.GetDocument(refDocumentId).GetTextAsync()).ToString();
Assert.Equal(oldRefText, newRefText);
}
}
else
{
Assert.True(changedDocumentIds.Contains(refDocumentId));
var actualRefText = (await newSolution.GetDocument(refDocumentId).GetTextAsync()).ToString();
Assert.Equal(expectedSourceReference, actualRefText);
}
}
else
{
var(actions, _) = await GetCodeActionsAsync(workspace, testOptions);
if (actions.Length > 0)
{
var hasChangeNamespaceAction = actions.Any(action => action is CodeAction.SolutionChangeAction);
Assert.False(hasChangeNamespaceAction, "Change namespace to match folder action was not expected, but shows up.");
}
}
}
async Task <Tuple <Solution, Solution> > TestOperationAsync(TestParameters parameters, TestWorkspace workspace)
{
var(actions, _) = await GetCodeActionsAsync(workspace, parameters);
var changeNamespaceAction = actions.Single(a => a is CodeAction.SolutionChangeAction);
var operations = await changeNamespaceAction.GetOperationsAsync(CancellationToken.None);
return(ApplyOperationsAndGetSolution(workspace, operations));
}
}
protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters) => new CSharpConvertLocalFunctionToMethodCodeRefactoringProvider();
protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters) => new CSharpSyncNamespaceCodeRefactoringProvider();
protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters) => new UseExpressionBodyCodeRefactoringProvider();
protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters)
{
return(TestWorkspace.IsWorkspaceElement(initialMarkup)
? TestWorkspace.Create(initialMarkup)
: TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions));
}
internal abstract Task <(ImmutableArray <Diagnostic>, ImmutableArray <CodeAction>, CodeAction actionToInvoke)> GetDiagnosticAndFixesAsync(
TestWorkspace workspace, TestParameters parameters);
protected async Task TestMoveFileToMatchNamespace(string initialMarkup, List <string[]> expectedFolders = null)
{
var testOptions = new TestParameters();
using (var workspace = CreateWorkspaceFromOptions(initialMarkup, testOptions))
{
if (expectedFolders?.Count > 0)
{
var expectedFolderPaths = expectedFolders.Select(f => string.Join(PathUtilities.DirectorySeparatorStr, f));
var oldDocument = workspace.Documents[0];
var oldDocumentId = oldDocument.Id;
var expectedText = workspace.Documents[0].GetTextBuffer().CurrentSnapshot.GetText();
// a new document with the same text as old document is added.
var allResults = await TestOperationAsync(testOptions, workspace, expectedText);
var actualFolderPaths = new HashSet <string>();
foreach (var result in allResults)
{
// the original source document does not exist in the new solution.
var oldSolution = result.Item1;
var newSolution = result.Item2;
Assert.Null(newSolution.GetDocument(oldDocumentId));
var newDocument = GetDocumentToVerify(expectedChangedDocumentId: null, oldSolution, newSolution);
actualFolderPaths.Add(string.Join(PathUtilities.DirectorySeparatorStr, newDocument.Folders));
}
Assert.True(expectedFolderPaths.Count() == actualFolderPaths.Count, "Number of available \"Move file\" actions are not equal.");
foreach (var expected in expectedFolderPaths)
{
Assert.True(actualFolderPaths.Contains(expected));
}
}
else
{
var(actions, _) = await GetCodeActionsAsync(workspace, testOptions);
if (actions.Length > 0)
{
var renameFileAction = actions.Any(action => !(action is CodeAction.SolutionChangeAction));
Assert.False(renameFileAction, "Move File to match namespace code action was not expected, but shows up.");
}
}
}
async Task <List <Tuple <Solution, Solution> > > TestOperationAsync(
TestParameters parameters,
TestWorkspace workspace,
string expectedCode)
{
var results = new List <Tuple <Solution, Solution> >();
var(actions, _) = await GetCodeActionsAsync(workspace, parameters);
var moveFileActions = actions.Where(a => !(a is CodeAction.SolutionChangeAction));
foreach (var action in moveFileActions)
{
var operations = await action.GetOperationsAsync(CancellationToken.None);
results.Add(
await TestOperationsAsync(workspace,
expectedText: expectedCode,
operations: operations,
conflictSpans: ImmutableArray <TextSpan> .Empty,
renameSpans: ImmutableArray <TextSpan> .Empty,
warningSpans: ImmutableArray <TextSpan> .Empty,
navigationSpans: ImmutableArray <TextSpan> .Empty,
expectedChangedDocumentId: null));
}
return(results);
}
}
public void InitializeFromArray(TestArguments instance, string[] args)
{
TestParameters.Should().BeSameAs(instance);
Args = string.Join(" ", args);
}
protected sealed override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters)
=> TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions,
(parameters.compilationOptions ?? TestOptions.DebugDll).WithReportSuppressedDiagnostics(true));
public TaskCreateTest(TestParameters parameters)
{
_taskType = parameters.TaskType;
_hasTaskManager = parameters.HasTaskManager;
_hasActionState = parameters.HasActionState;
_hasTaskOption = parameters.HasTaskOption;
_hasCancellationToken = parameters.HasCancellationToken;
_exceptionTestsAction = parameters.ExceptionTestsAction;
}
protected virtual TestParameters SetParameterDefaults(TestParameters parameters) => parameters;
public void ObjectToDictionary_ObjectWithNullValueProperty_KeyIsSkipped()
{
TestParameters p = new TestParameters { Key = null, Value = 1 };
var d = UrlHelper.ObjectToDictionary(p);
Assert.AreEqual(1, d.Count);
Assert.IsFalse(d.ContainsKey("Key"));
Assert.IsTrue(d.ContainsKey("Value"));
Assert.IsTrue(d.ContainsValue("1"));
}
protected virtual void InitializeWorkspace(TestWorkspace workspace, TestParameters parameters)
{
}
public override void RunTest(ISyncLock lockObject, TestParameters testParameters)
{
if (lockObject is NoOpLock)
{
throw new InapplicableTestException("Unbalanced calls test not applicable for this lock type");
}
ISyncLock syncLock = (ISyncLock)lockObject;
Exception releaseUnlockedException = null;
Console.WriteLine("Trying unlock with no lock -- this should fail");
try
{
syncLock.Unlock();
}
catch (InvalidOperationException e)
{
Console.WriteLine("Caught expected InvalidOperationException");
releaseUnlockedException = e;
}
Console.WriteLine("Lock / unlock succeeded");
if (releaseUnlockedException == null)
{
throw new InvalidOperationException("Unlock of already unlocked lock should not have succeeded");
}
Console.WriteLine("Simple lock / unlock -- this should succeed");
syncLock.Lock();
syncLock.Unlock();
Console.WriteLine("Re-entrant lock scenario -- try locking twice -- this should fail for some locks, succeed for others");
Exception reentrantLockException = null;
syncLock.Lock();
try
{
Console.WriteLine("Second lock attempt");
syncLock.Lock();
Console.WriteLine("Second lock granted");
}
catch (InvalidOperationException e)
{
Console.WriteLine("Expected InvalidOperationException caught");
reentrantLockException = e;
}
syncLock.Unlock();
if (syncLock.GetType() == typeof(SimpleSpinLock))
{
if (reentrantLockException == null)
{
throw new InvalidOperationException("Lock should not allow re-entrant call to already locked lock");
}
}
else
{
Console.WriteLine("Successful re-entrant lock with lock count 2, now perform extra unlock");
syncLock.Unlock();
Console.WriteLine("Successfully performed second unlock");
VerifyUnlocked(syncLock);
}
// Now test higher scale re-entrance
Console.WriteLine("Testing locking {0} times on the same thread, then unlocking the same #", lockMax);
if (!(syncLock is SimpleSpinLock))
{
for (int lockCount = 0; lockCount < lockMax; lockCount++)
{
syncLock.Lock();
}
for (int unlockCount = 0; unlockCount < lockMax; unlockCount++)
{
syncLock.Unlock();
}
VerifyUnlocked(syncLock);
}
Console.WriteLine("Successfully verified lock re-entrance count for non-trivial number of re-entrant calls");
Console.WriteLine("Lock once, unlock twice -- this should fail");
syncLock.Lock();
syncLock.Unlock();
Exception unbalancedException = null;
try
{
syncLock.Unlock();
}
catch (InvalidOperationException e)
{
Console.WriteLine("Expected InvalidOperationException caught");
unbalancedException = e;
}
if (unbalancedException == null)
{
throw new InvalidOperationException("Lock should not allow unlock to be called twice after one call to lock");
}
}
protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters) => new IntroduceVariableCodeRefactoringProvider();
public static void ParallelForTest43()
{
TestParameters parameters = new TestParameters(API.Foreach, StartIndexBase.Zero)
{
Count = 2,
ParallelOption = WithParallelOption.None,
StateOption = ActionWithState.None,
LocalOption = ActionWithLocal.HasFinally,
};
ParallelForTest test = new ParallelForTest(parameters);
test.RealRun();
}
protected async Task <ImmutableArray <CodeAction> > GetCodeActionsAsync(
TestWorkspace workspace, TestParameters parameters)
{
return(MassageActions(await GetCodeActionsWorkerAsync(workspace, parameters)));
}
public void InitializeFromString(TestArguments instance, string args)
{
TestParameters.Should().BeSameAs(instance);
Args = args;
}
protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters) => new AddConstructorParametersFromMembersCodeRefactoringProvider();
public static void ParallelForeachPartitioner20()
{
TestParameters parameters = new TestParameters(API.Foreach, StartIndexBase.Zero)
{
Count = 97,
ChunkSize = 97,
PartitionerType = PartitionerType.ArrayBalancedOOB,
ParallelForeachDataSourceType = DataSourceType.Partitioner,
ParallelOption = WithParallelOption.WithDOP,
LocalOption = ActionWithLocal.HasFinally,
StateOption = ActionWithState.Stop,
};
ParallelForTest test = new ParallelForTest(parameters);
test.RealRun();
}
protected void AddAnalyzerToWorkspace(Workspace workspace, DiagnosticAnalyzer analyzer, TestParameters parameters)
{
AnalyzerReference[] analyzeReferences;
if (analyzer != null)
{
Contract.ThrowIfTrue(parameters.runProviderOutOfProc, $"Out-of-proc testing is not supported since {analyzer} can't be serialized.");
analyzeReferences = new[] { new AnalyzerImageReference(ImmutableArray.Create(analyzer)) };
}
else
{
// create a serializable analyzer reference:
analyzeReferences = new[]
{
new AnalyzerFileReference(DiagnosticExtensions.GetCompilerDiagnosticAnalyzer(LanguageNames.CSharp).GetType().Assembly.Location, TestAnalyzerAssemblyLoader.LoadFromFile),
new AnalyzerFileReference(DiagnosticExtensions.GetCompilerDiagnosticAnalyzer(LanguageNames.VisualBasic).GetType().Assembly.Location, TestAnalyzerAssemblyLoader.LoadFromFile)
};
}
workspace.TryApplyChanges(workspace.CurrentSolution.WithAnalyzerReferences(analyzeReferences));
}
public static void ParallelForeachPartitioner5()
{
TestParameters parameters = new TestParameters(API.Foreach, StartIndexBase.Zero)
{
Count = 1,
ChunkSize = -1,
PartitionerType = PartitionerType.ArrayBalancedOOB,
ParallelForeachDataSourceType = DataSourceType.Partitioner,
ParallelOption = WithParallelOption.None,
LocalOption = ActionWithLocal.None,
StateOption = ActionWithState.None,
};
ParallelForTest test = new ParallelForTest(parameters);
test.RealRun();
}
internal abstract Task <IEnumerable <Diagnostic> > GetDiagnosticsAsync(
TestWorkspace workspace, TestParameters parameters);
protected abstract Task <(ImmutableArray <CodeAction>, CodeAction actionToInvoke)> GetCodeActionsAsync(
TestWorkspace workspace, TestParameters parameters);
private TestParameters WithScriptOptions(TestParameters parameters) => parameters.WithParseOptions(parameters.parseOptions?.WithKind(SourceCodeKind.Script) ?? GetScriptOptions());
public static void ParallelForBoundary40()
{
TestParameters parameters = new TestParameters(API.For64, StartIndexBase.Zero, 0)
{
Count = 5,
WorkloadPattern = WorkloadPattern.Increasing,
};
ParallelForTest test = new ParallelForTest(parameters);
test.RealRun();
}
protected abstract Task <ImmutableArray <Diagnostic> > GetDiagnosticsWorkerAsync(
TestWorkspace workspace, TestParameters parameters);
public static void ParallelForBoundary72()
{
TestParameters parameters = new TestParameters(API.For, StartIndexBase.Zero, 1000)
{
Count = 5,
WorkloadPattern = WorkloadPattern.Random,
};
ParallelForTest test = new ParallelForTest(parameters);
test.RealRun();
}
protected abstract TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters);
private TestParameters WithRegularOptions(TestParameters parameters) => parameters.WithParseOptions(parameters.parseOptions?.WithKind(SourceCodeKind.Regular));
protected abstract Task <ImmutableArray <CodeAction> > GetCodeActionsWorkerAsync(
TestWorkspace workspace, TestParameters parameters);
