/* THIS VERSION FOR AR */
// this sets up the scanned analog inputs. It's complicated a bit by the fact that
// each input would ideally have a different clock rate and gateLength. The board
// doesn't support that though.
public void MapAnalogInputs()
{
inputs = new ScannedAnalogInputCollection();
inputs.RawSampleRate = 100000;
inputs.GateStartTime = (int)scanMaster.GetShotSetting("gateStartTime");
inputs.GateLength = 280;
//inputs.GateLength = 1000;
// NOTE: this long version is for null runs, don't set it so long that the shots overlap!
// Comment the following line out if you're not null running.
//inputs.GateLength = 3000;
// this code should be used for normal running
ScannedAnalogInput bottomProbe = new ScannedAnalogInput();
bottomProbe.Channel = (AnalogInputChannel)Environs.Hardware.AnalogInputChannels["bottomProbe"];
bottomProbe.ReductionMode = DataReductionMode.Chop;
bottomProbe.ChopStart = 140;
bottomProbe.ChopLength = 80;
bottomProbe.LowLimit = 0;
bottomProbe.HighLimit = 10;
bottomProbe.Calibration = 0.209145; // calibration from 5-8-08, b14. p52, high gain setting
inputs.Channels.Add(bottomProbe);
// // this code can be enabled for faster null runs
// ScannedAnalogInput pmt = new ScannedAnalogInput();
// pmt.Channel = (AnalogInputChannel)Environs.Hardware.AnalogInputChannels["pmt"];
// pmt.ReductionMode = DataReductionMode.Average;
// pmt.AverageEvery = 40;
// pmt.LowLimit = 0;
// pmt.HighLimit = 10;
// pmt.Calibration = 0.14;
// inputs.Channels.Add(pmt);
ScannedAnalogInput topProbe = new ScannedAnalogInput();
topProbe.Channel = (AnalogInputChannel)Environs.Hardware.AnalogInputChannels["topProbe"];
topProbe.ReductionMode = DataReductionMode.Chop;
topProbe.ChopStart = 180;
topProbe.ChopLength = 80;
topProbe.LowLimit = 0;
topProbe.HighLimit = 10;
topProbe.Calibration = 0.0406658; // calibration from 5-8-08, b14. p52, high gain setting
inputs.Channels.Add(topProbe);
ScannedAnalogInput mag = new ScannedAnalogInput();
mag.ReductionMode = DataReductionMode.Average;
mag.Channel = (AnalogInputChannel)Environs.Hardware.AnalogInputChannels["magnetometer"];
mag.AverageEvery = 20;
mag.LowLimit = -10;
mag.HighLimit = 10;
mag.Calibration = 0.00001;
inputs.Channels.Add(mag);
ScannedAnalogInput gnd = new ScannedAnalogInput();
gnd.Channel = (AnalogInputChannel)Environs.Hardware.AnalogInputChannels["gnd"];
gnd.ReductionMode = DataReductionMode.Average;
gnd.AverageEvery = 20;
gnd.LowLimit = -1;
gnd.HighLimit = 1;
gnd.Calibration = 1;
inputs.Channels.Add(gnd);
ScannedAnalogInput battery = new ScannedAnalogInput();
battery.Channel = (AnalogInputChannel)Environs.Hardware.AnalogInputChannels["battery"];
battery.ReductionMode = DataReductionMode.Chop;
battery.ChopStart = 140;
battery.ChopLength = 80;
battery.LowLimit = 0;
battery.HighLimit = 10;
battery.Calibration = 1;
inputs.Channels.Add(battery);
ScannedAnalogInput rfCurrent = new ScannedAnalogInput();
rfCurrent.ReductionMode = DataReductionMode.Average;
rfCurrent.Channel = (AnalogInputChannel)Environs.Hardware.AnalogInputChannels["rfCurrent"];
rfCurrent.AverageEvery = 10; //Bandwidth of the ammeter is aprox 12kHz
rfCurrent.LowLimit = -10;
rfCurrent.HighLimit = 10;
inputs.Channels.Add(rfCurrent);
ScannedAnalogInput reflectedrf1Amplitude = new ScannedAnalogInput();
reflectedrf1Amplitude.Channel = (AnalogInputChannel)Environs.Hardware.AnalogInputChannels["reflectedrf1Amplitude"];
reflectedrf1Amplitude.ReductionMode = DataReductionMode.Chop;
reflectedrf1Amplitude.ChopStart = 30;
reflectedrf1Amplitude.ChopLength = 130;
reflectedrf1Amplitude.LowLimit = -10;
reflectedrf1Amplitude.HighLimit = 1;
inputs.Channels.Add(reflectedrf1Amplitude);
ScannedAnalogInput reflectedrf2Amplitude = new ScannedAnalogInput();
reflectedrf2Amplitude.Channel = (AnalogInputChannel)Environs.Hardware.AnalogInputChannels["reflectedrf2Amplitude"];
reflectedrf2Amplitude.ReductionMode = DataReductionMode.Chop;
reflectedrf2Amplitude.ChopStart = 30;
reflectedrf2Amplitude.ChopLength = 130;
reflectedrf2Amplitude.LowLimit = -10;
reflectedrf2Amplitude.HighLimit = 1;
inputs.Channels.Add(reflectedrf2Amplitude);
}
// this is the method that actually takes the data. It is called by Start() and shouldn't
// be called directly
public void Acquire()
{
// lock onto something that the front end can see
Monitor.Enter(MonitorLockObject);
scanMaster = new ScanMaster.Controller();
phaseLock = new EDMPhaseLock.MainForm();
hardwareController = new EDMHardwareControl.Controller();
// map modulations to physical channels
MapChannels();
// map the analog inputs
MapAnalogInputs();
Block b = new Block();
b.Config = config;
b.SetTimeStamp();
foreach (ScannedAnalogInput channel in inputs.Channels)
{
b.detectors.Add(channel.Channel.Name);
}
try
{
// get things going
AcquisitionStarting();
// enter the main loop
for (int point = 0; point < (int)config.Settings["numberOfPoints"]; point++)
{
// set the switch states and impose the appropriate wait times
ThrowSwitches(point);
// take a point
Shot s;
EDMPoint p;
if (Environs.Debug)
{
// just stuff a made up shot in
//Thread.Sleep(10);
s = DataFaker.GetFakeShot(1900, 50, 10, 3, 3);
((TOF)s.TOFs[0]).Calibration = ((ScannedAnalogInput)inputs.Channels[0]).Calibration;
p = new EDMPoint();
p.Shot = s;
//Thread.Sleep(20);
}
else
{
// everything should be ready now so start the analog
// input task (it will wait for a trigger)
inputTask.Start();
// get the raw data
double[,] analogData = inputReader.ReadMultiSample(inputs.GateLength);
inputTask.Stop();
// extract the data for each scanned channel and put it in a TOF
s = new Shot();
for (int i = 0; i < inputs.Channels.Count; i++)
{
// extract the raw data
double[] rawData = new double[inputs.GateLength];
for (int q = 0; q < inputs.GateLength; q++)
{
rawData[q] = analogData[i, q];
}
ScannedAnalogInput ipt = (ScannedAnalogInput)inputs.Channels[i];
// reduce the data
double[] data = ipt.Reduce(rawData);
TOF t = new TOF();
t.Calibration = ipt.Calibration;
// the 1000000 is because clock period is in microseconds;
t.ClockPeriod = 1000000 / ipt.CalculateClockRate(inputs.RawSampleRate);
t.GateStartTime = inputs.GateStartTime;
// this is a bit confusing. The chop is measured in points, so the gate
// has to be adjusted by the number of points times the clock period!
if (ipt.ReductionMode == DataReductionMode.Chop)
{
t.GateStartTime += (ipt.ChopStart * t.ClockPeriod);
}
t.Data = data;
// the 1000000 is because clock period is in microseconds;
t.ClockPeriod = 1000000 / ipt.CalculateClockRate(inputs.RawSampleRate);
s.TOFs.Add(t);
}
p = new EDMPoint();
p.Shot = s;
}
// do the "SinglePointData" (i.e. things that are measured once per point)
// We'll save the leakage monitor until right at the end.
// keep an eye on what the phase lock is doing
p.SinglePointData.Add("PhaseLockFrequency", phaseLock.OutputFrequency);
p.SinglePointData.Add("PhaseLockError", phaseLock.PhaseError);
// scan the analog inputs
double[] spd;
// fake some data if we're in debug mode
if (Environs.Debug)
{
spd = new double[7];
spd[0] = 1;
spd[1] = 2;
spd[2] = 3;
spd[3] = 4;
spd[4] = 5;
spd[5] = 6;
spd[6] = 7;
}
else
{
singlePointInputTask.Start();
spd = singlePointInputReader.ReadSingleSample();
singlePointInputTask.Stop();
}
p.SinglePointData.Add("ProbePD", spd[0]);
p.SinglePointData.Add("PumpPD", spd[1]);
p.SinglePointData.Add("MiniFlux1", spd[2]);
p.SinglePointData.Add("MiniFlux2", spd[3]);
p.SinglePointData.Add("MiniFlux3", spd[4]);
//p.SinglePointData.Add("CplusV", spd[5]);
//p.SinglePointData.Add("CminusV", spd[6]);
//hardwareController.UpdateVMonitor();
//p.SinglePointData.Add("CplusV", hardwareController.CPlusMonitorVoltage);
//hardwareController.UpdateLaserPhotodiodes();
//p.SinglePointData.Add("ProbePD", hardwareController.ProbePDVoltage);
//p.SinglePointData.Add("PumpPD", hardwareController.PumpPDVoltage);
//hardwareController.UpdateMiniFluxgates();
//p.SinglePointData.Add("MiniFlux1", hardwareController.MiniFlux1Voltage);
//p.SinglePointData.Add("MiniFlux2", hardwareController.MiniFlux2Voltage);
//p.SinglePointData.Add("MiniFlux3", hardwareController.MiniFlux3Voltage);
hardwareController.ReadIMonitor();
p.SinglePointData.Add("NorthCurrent", hardwareController.NorthCurrent);
p.SinglePointData.Add("SouthCurrent", hardwareController.SouthCurrent);
//hardwareController.UpdatePiMonitor();
//p.SinglePointData.Add("piMonitor", hardwareController.PiFlipMonVoltage);
//p.SinglePointData.Add("CminusV", hardwareController.CMinusMonitorVoltage);
// Hopefully the leakage monitors will have finished reading by now.
// We join them, read out the data, and then launch another asynchronous
// acquisition. [If this is the first shot of the block, the leakage monitor
// measurement will have been launched in AcquisitionStarting() ].
//hardwareController.WaitForIMonitorAsync();
//p.SinglePointData.Add("NorthCurrent", hardwareController.NorthCurrent);
//p.SinglePointData.Add("SouthCurrent", hardwareController.SouthCurrent);
//hardwareController.UpdateIMonitorAsync();
// randomise the Ramsey phase
// TODO: check whether the .NET rng is good enough
// TODO: reference where this number comes from
//double d = 2.3814 * (new Random().NextDouble());
//hardwareController.SetScramblerVoltage(d);
b.Points.Add(p);
// update the front end
Controller.GetController().GotPoint(point, p);
if (CheckIfStopping())
{
// release hardware
AcquisitionStopping();
// signal anybody waiting on the lock that we're done
Monitor.Pulse(MonitorLockObject);
Monitor.Exit(MonitorLockObject);
return;
}
}
}
catch (Exception e)
{
// try and stop the experiment gracefully
try
{
AcquisitionStopping();
}
catch (Exception) {} // about the best that can be done at this stage
Monitor.Pulse(MonitorLockObject);
Monitor.Exit(MonitorLockObject);
throw e;
}
AcquisitionStopping();
// hand the new block back to the controller
Controller.GetController().AcquisitionFinished(b);
// signal anybody waiting on the lock that we're done
Monitor.Pulse(MonitorLockObject);
Monitor.Exit(MonitorLockObject);
}
public void AcquireAndStepTarget()
{
// lock onto something that the front end can see
Monitor.Enter(MonitorLockObject);
scanMaster = new ScanMaster.Controller();
phaseLock = new EDMPhaseLock.MainForm();
hardwareController = new EDMHardwareControl.Controller();
// map modulations to physical channels
MapChannels();
// map the analog inputs
MapAnalogInputs();
Block b = new Block();
b.Config = config;
b.SetTimeStamp();
foreach (ScannedAnalogInput channel in inputs.Channels)
{
b.detectors.Add(channel.Channel.Name);
}
try
{
// get things going
AcquisitionStarting();
int point = 0;
// enter the main loop
for (point = 0; point < (int)config.Settings["maximumNumberOfTimesToStepTarget"]; point++)
{
// take a point
Shot s;
EDMPoint p;
if (Environs.Debug)
{
// just stuff a made up shot in
//Thread.Sleep(10);
s = DataFaker.GetFakeShot(1900, 50, 10, 3, 3);
((TOF)s.TOFs[0]).Calibration = ((ScannedAnalogInput)inputs.Channels[0]).Calibration;
p = new EDMPoint();
p.Shot = s;
//Thread.Sleep(20);
}
else
{
// everything should be ready now so start the analog
// input task (it will wait for a trigger)
inputTask.Start();
// get the raw data
double[,] analogData = inputReader.ReadMultiSample(inputs.GateLength);
inputTask.Stop();
// extract the data for each scanned channel and put it in a TOF
s = new Shot();
for (int i = 0; i < inputs.Channels.Count; i++)
{
// extract the raw data
double[] rawData = new double[inputs.GateLength];
for (int q = 0; q < inputs.GateLength; q++)
{
rawData[q] = analogData[i, q];
}
ScannedAnalogInput ipt = (ScannedAnalogInput)inputs.Channels[i];
// reduce the data
double[] data = ipt.Reduce(rawData);
TOF t = new TOF();
t.Calibration = ipt.Calibration;
// the 1000000 is because clock period is in microseconds;
t.ClockPeriod = 1000000 / ipt.CalculateClockRate(inputs.RawSampleRate);
t.GateStartTime = inputs.GateStartTime;
// this is a bit confusing. The chop is measured in points, so the gate
// has to be adjusted by the number of points times the clock period!
if (ipt.ReductionMode == DataReductionMode.Chop)
{
t.GateStartTime += (ipt.ChopStart * t.ClockPeriod);
}
t.Data = data;
// the 1000000 is because clock period is in microseconds;
t.ClockPeriod = 1000000 / ipt.CalculateClockRate(inputs.RawSampleRate);
s.TOFs.Add(t);
}
p = new EDMPoint();
p.Shot = s;
}
// do the "SinglePointData" (i.e. things that are measured once per point)
// We'll save the leakage monitor until right at the end.
// keep an eye on what the phase lock is doing
p.SinglePointData.Add("PhaseLockFrequency", phaseLock.OutputFrequency);
p.SinglePointData.Add("PhaseLockError", phaseLock.PhaseError);
// scan the analog inputs
double[] spd;
// fake some data if we're in debug mode
if (Environs.Debug)
{
spd = new double[7];
spd[0] = 1;
spd[1] = 2;
spd[2] = 3;
spd[3] = 4;
spd[4] = 5;
spd[5] = 6;
spd[6] = 7;
}
else
{
singlePointInputTask.Start();
spd = singlePointInputReader.ReadSingleSample();
singlePointInputTask.Stop();
}
p.SinglePointData.Add("ProbePD", spd[0]);
p.SinglePointData.Add("PumpPD", spd[1]);
p.SinglePointData.Add("MiniFlux1", spd[2]);
p.SinglePointData.Add("MiniFlux2", spd[3]);
p.SinglePointData.Add("MiniFlux3", spd[4]);
//p.SinglePointData.Add("CplusV", spd[5]);
//p.SinglePointData.Add("CminusV", spd[6]);
//hardwareController.UpdateVMonitor();
//p.SinglePointData.Add("CplusV", hardwareController.CPlusMonitorVoltage);
//hardwareController.UpdateLaserPhotodiodes();
//p.SinglePointData.Add("ProbePD", hardwareController.ProbePDVoltage);
//p.SinglePointData.Add("PumpPD", hardwareController.PumpPDVoltage);
//hardwareController.UpdateMiniFluxgates();
//p.SinglePointData.Add("MiniFlux1", hardwareController.MiniFlux1Voltage);
//p.SinglePointData.Add("MiniFlux2", hardwareController.MiniFlux2Voltage);
//p.SinglePointData.Add("MiniFlux3", hardwareController.MiniFlux3Voltage);
hardwareController.ReadIMonitor();
p.SinglePointData.Add("NorthCurrent", hardwareController.NorthCurrent);
p.SinglePointData.Add("SouthCurrent", hardwareController.SouthCurrent);
b.Points.Add(p);
// update the front end
Controller.GetController().GotPoint(point, p);
// Integrate the first toff and stop the sequence if the signal is sufficiently high
TOF detectorATOF = new TOF();
detectorATOF = (TOF)s.TOFs[0];
double sig = detectorATOF.Integrate((double)config.Settings["targetStepperGateStartTime"], (double)config.Settings["targetStepperGateEndTime"]);
if (sig > (double)config.Settings["minimumSignalToRun"])
{
Controller.GetController().TargetHealthy = true;
Stop();
point = (int)config.Settings["maximumNumberOfTimesToStepTarget"] + 1;
}
else
{
Controller.GetController().TargetHealthy = false;
hardwareController.StepTarget(2);
}
//if (CheckIfStopping())
//{
// release hardware
// AcquisitionStopping();
// signal anybody waiting on the lock that we're done
// Monitor.Pulse(MonitorLockObject);
// Monitor.Exit(MonitorLockObject);
// point = (int)config.Settings["maximumNumberOfTimesToStepTarget"];
// return;
//}
}
AcquisitionStopping();
// hand the new block back to the controller
Controller.GetController().IntelligentAcquisitionFinished();
// signal anybody waiting on the lock that we're done
Monitor.Pulse(MonitorLockObject);
Monitor.Exit(MonitorLockObject);
}
catch (Exception e)
{
// try and stop the experiment gracefully
try
{
AcquisitionStopping();
}
catch (Exception) { } // about the best that can be done at this stage
Monitor.Pulse(MonitorLockObject);
Monitor.Exit(MonitorLockObject);
throw e;
}
}