public TOFWithError(TOF t)
{
this.Data = t.Data;
this.Errors = new double[Length];
this.Calibration = t.Calibration;
this.GateStartTime = t.GateStartTime;
this.ClockPeriod = t.ClockPeriod;
}
public TOFWithError(TOF t)
{
this.Data = t.Data;
this.Errors = new double[Length];
this.Calibration = t.Calibration;
this.GateStartTime = t.GateStartTime;
this.ClockPeriod = t.ClockPeriod;
}
public static TOF Random()
{
TOF t = new TOF();
t.Data = new double[RANDOM_TOF_SIZE];
for (int i = 0; i < RANDOM_TOF_SIZE; i++)
{
t.Data[i] = r.NextDouble();
}
t.Calibration = 1.0;
t.ClockPeriod = 10;
t.GateStartTime = 1800;
return(t);
}
static public TOF operator *(TOF t1, TOF t2)
{
TOF temp = new TOF();
temp.Data = new double[t1.Data.Length];
temp.GateStartTime = t1.GateStartTime;
temp.ClockPeriod = t1.ClockPeriod;
for (int i = 0; i < t1.Data.Length; i++)
{
temp.Data[i] = t1.Data[i] * t2.Data[i];
}
return(temp);
}
public static TOF operator -(TOF p1, TOF p2)
{
TOF temp = new TOF();
temp.Data = new double[p2.Data.Length];
temp.GateStartTime = p1.GateStartTime;
temp.ClockPeriod = p1.ClockPeriod;
temp.Calibration = p1.Calibration;
for (int i = 0; i < p2.Data.Length; i++)
{
temp.Data[i] = -p2.Data[i];
}
return(p1 + temp);
}
static public TOF operator *(TOF t, double d)
{
TOF temp = new TOF();
temp.Data = new double[t.Data.Length];
temp.GateStartTime = t.GateStartTime;
temp.ClockPeriod = t.ClockPeriod;
temp.Calibration = t.Calibration;
for (int i = 0; i < t.Data.Length; i++)
{
temp.Data[i] = d * t.Data[i];
}
return(temp);
}
public static TOF operator /(TOF p, double d)
{
double[] tempData = new double[p.Length];
for (int i = 0; i < p.Length; i++)
{
tempData[i] = p.Data[i] / d;
}
TOF temp = new TOF();
temp.Data = tempData;
temp.GateStartTime = p.GateStartTime;
temp.ClockPeriod = p.ClockPeriod;
temp.Calibration = p.Calibration;
return(temp);
}
public static TOF operator +(TOF p1, double d)
{
TOF temp = new TOF();
temp.Data = new double[p1.Data.Length];
temp.GateStartTime = p1.GateStartTime;
temp.ClockPeriod = p1.ClockPeriod;
temp.Calibration = p1.Calibration;
for (int i = 0; i < p1.Data.Length; i++)
{
temp.Data[i] = p1.Data[i] + d;
}
return(temp);
}
public void Add(TOF t)
{
if (!initialised)
{
// the first TOF to be added defines the parameters
gateStartTime = t.GateStartTime;
clockPeriod = t.ClockPeriod;
calibration = t.Calibration;
stats = new RunningStatistics[t.Length];
for (int i = 0; i < Length; i++) stats[i] = new RunningStatistics();
initialised = true;
}
// add the TOF data - very minimal error checking: just check the lengths
if (t.Length == Length) for (int i = 0; i < Length; i++) stats[i].Push(t.Data[i]);
else throw new TOFAccumulatorException();
}
static public TOF operator /(TOF t1, TOF t2)
{
TOF temp = new TOF();
temp.Data = new double[t1.Data.Length];
temp.GateStartTime = t1.GateStartTime;
temp.ClockPeriod = t1.ClockPeriod;
temp.Calibration = t1.Calibration;
for (int i = 0; i < t1.Data.Length; i++)
{
if (t1.Data[i] == 0 && t2.Data[i] == 0)
{
temp.Data[i] = 0.0;
}
else
{
temp.Data[i] = t1.Data[i] / t2.Data[i];
}
}
return(temp);
}
//slight variant which can be useful for debugging
public static Shot GetFakeShot(int gateStart, int gateLength, int clockPeriod, double intensity,
int numberOfDetectors, double scanParameter)
{
Random rng = new Random();
// generate some fake data
double[] detectorOnData = new double[gateLength];
double newRand = rng.NextDouble();
double centre = gateLength / 2 + 10 * scanParameter;
for (int i = 0; i < gateLength; i++)
{
detectorOnData[i] = (5 * rng.NextDouble()) + 5 * intensity *
Math.Exp(-Math.Pow((i - centre), 2) / (0.9 * gateLength));
}
TOF tofOn = new TOF();
tofOn.Data = detectorOnData;
tofOn.GateStartTime = gateStart;
tofOn.ClockPeriod = clockPeriod;
tofOn.Calibration = 1;
Shot sOn = new Shot();
for (int j = 0; j < numberOfDetectors; j++) sOn.TOFs.Add(tofOn);
return sOn;
}
// 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();
}
hardwareController.UpdateLaserPhotodiodes();
p.SinglePointData.Add("ProbePD", hardwareController.probePDVoltage);
p.SinglePointData.Add("PumpPD", hardwareController.probePDVoltage);
hardwareController.UpdateMiniFluxgates();
p.SinglePointData.Add("MiniFlux1", hardwareController.miniFlux1Voltage);
p.SinglePointData.Add("MiniFlux2", hardwareController.miniFlux2Voltage);
p.SinglePointData.Add("MiniFlux3", hardwareController.miniFlux3Voltage);
hardwareController.UpdatePiMonitor();
p.SinglePointData.Add("piMonitor", hardwareController.piFlipMonVoltage);
hardwareController.ReadIMonitor();
p.SinglePointData.Add("NorthCurrent", hardwareController.NorthCurrent);
p.SinglePointData.Add("SouthCurrent", hardwareController.SouthCurrent);
// 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);
}
// This method is called by the GUI thread once the form has
// loaded and the UI is ready.
internal void UIInitialise()
{
// put the version number in the title bar to avoid confusion!
Version version = Assembly.GetEntryAssembly().GetName().Version;
mainWindow.Text += " " + version.ToString();
// This will load the shared code assembly so that we can get its
// version number and display that as well.
TOF t = new TOF();
Version sharedCodeVersion = Assembly.GetAssembly(t.GetType()).GetName().Version;
mainWindow.Text += " (" + sharedCodeVersion.ToString() + ")";
// start the status monitor
statusMonitorTimer = new System.Threading.Timer(new TimerCallback(UpdateStatusMonitor), null, 500, 500);
}
public static TOF operator *(TOF t, double d)
{
TOF temp = new TOF();
temp.Data = new double[t.Data.Length];
temp.GateStartTime = t.GateStartTime;
temp.ClockPeriod = t.ClockPeriod;
temp.Calibration = t.Calibration;
for (int i = 0; i < t.Data.Length; i++)
{
temp.Data[i] = d * t.Data[i];
}
return temp;
}
public static TOF operator +(TOF p1, TOF p2)
{
if (p1.ClockPeriod == p2.ClockPeriod && p1.GateStartTime == p2.GateStartTime
&& p1.Length == p2.Length)
{
double[] tempData = new double[p1.Length];
for (int i = 0; i < p1.Length; i++)
{
tempData[i] = p1.Data[i] + p2.Data[i];
}
TOF temp = new TOF();
temp.Data = tempData;
temp.GateStartTime = p1.GateStartTime;
temp.ClockPeriod = p1.ClockPeriod;
temp.Calibration = p1.Calibration;
return temp;
}
else
{
if (p1.Length == 0) return p2;
if (p2.Length == 0) return p1;
return null;
}
}
public void PlotOnTOF(TOF t)
{
PlotY(tofGraph, tofOnPlot, t.GateStartTime, t.ClockPeriod, t.Data);
}
public void PlotAverageOffTOF(TOF t)
{
PlotY(tofGraph, tofOffAveragePlot, t.GateStartTime, t.ClockPeriod, t.Data);
}
public TOFChannelSet TOFDemodulateBlock(Block b, int detectorIndex, bool allChannels)
{
// *** demodulate channels ***
// ** build the list of modulations **
List<string> modNames = new List<string>();
List<Waveform> modWaveforms = new List<Waveform>();
foreach (AnalogModulation mod in b.Config.AnalogModulations)
{
modNames.Add(mod.Name);
modWaveforms.Add(mod.Waveform);
}
foreach (DigitalModulation mod in b.Config.DigitalModulations)
{
modNames.Add(mod.Name);
modWaveforms.Add(mod.Waveform);
}
foreach (TimingModulation mod in b.Config.TimingModulations)
{
modNames.Add(mod.Name);
modWaveforms.Add(mod.Waveform);
}
// ** work out the switch state for each point **
int blockLength = modWaveforms[0].Length;
List<bool[]> wfBits = new List<bool[]>();
foreach (Waveform wf in modWaveforms) wfBits.Add(wf.Bits);
List<uint> switchStates = new List<uint>(blockLength);
for (int i = 0; i < blockLength; i++)
{
uint switchState = 0;
for (int j = 0; j < wfBits.Count; j++)
{
if (wfBits[j][i]) switchState += (uint)Math.Pow(2, j);
}
switchStates.Add(switchState);
}
// pre-calculate the state signs for each analysis channel
// the first index selects the analysis channel, the second the switchState
int numStates = (int)Math.Pow(2, modWaveforms.Count);
bool[,] stateSigns = new bool[numStates, numStates];
// make a BlockDemodulator just to use its stateSign code
// They should probably share a base class.
BlockDemodulator bd = new BlockDemodulator();
for (uint i = 0; i < numStates; i++)
{
for (uint j = 0; j < numStates; j++)
{
stateSigns[i, j] = (bd.stateSign(j, i) == 1);
}
}
TOFChannelSet tcs = new TOFChannelSet();
// By setting all channels to false only a limited number of channels are analysed,
// namely those required to extract the edm (and the correction term). This speeds
// up the execution enormously when the BlockTOFDemodulator is used by the
// BlockDemodulator for calculating the non-linear channel combinations.
//int[] channelsToAnalyse;
List<int> channelsToAnalyse;
if (allChannels)
{
//channelsToAnalyse = new int[numStates];
channelsToAnalyse = new List<int>();
//for (int i = 0; i < numStates; i++) channelsToAnalyse[i] = i;
for (int i = 0; i < numStates; i++) channelsToAnalyse.Add(i);
}
else
{
// just the essential channels - this code is a little awkward because, like
// so many bits of the analysis code, it was added long after the original
// code was written, and goes against some assumptions that were made back then!
int bIndex = modNames.IndexOf("B");
int dbIndex = modNames.IndexOf("DB");
int eIndex = modNames.IndexOf("E");
int rf1fIndex = modNames.IndexOf("RF1F");
int rf2fIndex = modNames.IndexOf("RF2F");
int rf1aIndex = modNames.IndexOf("RF1A");
int rf2aIndex = modNames.IndexOf("RF2A");
int lf1Index = modNames.IndexOf("LF1");
int lf2Index = modNames.IndexOf("LF2");
int sigChannel = 0;
int bChannel = (1 << bIndex);
int dbChannel = (1 << dbIndex);
int ebChannel = (1 << eIndex) + (1 << bIndex);
int edbChannel = (1 << eIndex) + (1 << dbIndex);
int dbrf1fChannel = (1 << dbIndex) + (1 << rf1fIndex);
int dbrf2fChannel = (1 << dbIndex) + (1 << rf2fIndex);
int brf1fChannel = (1 << bIndex) + (1 << rf1fIndex);
int brf2fChannel = (1 << bIndex) + (1 << rf2fIndex);
int edbrf1fChannel = (1 << eIndex) + (1 << dbIndex) + (1 << rf1fIndex);
int edbrf2fChannel = (1 << eIndex) + (1 << dbIndex) + (1 << rf2fIndex);
int ebdbChannel = (1 << eIndex) + (1 << bIndex) + (1 << dbIndex);
int rf1fChannel = (1 << rf1fIndex);
int rf2fChannel = (1 << rf2fIndex);
int erf1fChannel = (1 << eIndex) + (1 << rf1fIndex);
int erf2fChannel = (1 << eIndex) + (1 << rf2fIndex);
int rf1aChannel = (1 << rf1aIndex);
int rf2aChannel = (1 << rf2aIndex);
int dbrf1aChannel = (1 << dbIndex) + (1 << rf1aIndex);
int dbrf2aChannel = (1 << dbIndex) + (1 << rf2aIndex);
int lf1Channel = (1 << lf1Index);
int dblf1Channel = (1 << dbIndex) + (1 << lf1Index);
channelsToAnalyse = new List<int>() { sigChannel, bChannel, dbChannel, ebChannel, edbChannel, dbrf1fChannel,
dbrf2fChannel, brf1fChannel, brf2fChannel, edbrf1fChannel, edbrf2fChannel, ebdbChannel,
rf1fChannel, rf2fChannel, erf1fChannel, erf2fChannel, rf1aChannel, rf2aChannel, dbrf1aChannel,
dbrf2aChannel, lf1Channel, dblf1Channel,
};
if (lf2Index != -1) // Index = -1 if "LF2" not found
{
int lf2Channel = (1 << lf2Index);
channelsToAnalyse.Add(lf2Channel);
int dblf2Channel = (1 << dbIndex) + (1 << lf2Index);
channelsToAnalyse.Add(dblf2Channel);
}
//channelsToAnalyse = new int[] { bChannel, dbChannel, ebChannel, edbChannel, dbrf1fChannel,
// dbrf2fChannel, brf1fChannel, brf2fChannel, edbrf1fChannel, edbrf2fChannel, ebdbChannel,
// rf1fChannel, rf2fChannel, erf1fChannel, erf2fChannel, rf1aChannel, rf2aChannel, dbrf1aChannel,
// dbrf2aChannel, lf1Channel, dblf1Channel, lf2Channel, dblf2Channel
//};
}
foreach (int channel in channelsToAnalyse)
{
// generate the Channel
TOFChannel tc = new TOFChannel();
TOF tOn = new TOF();
TOF tOff = new TOF();
for (int i = 0; i < blockLength; i++)
{
if (stateSigns[channel, switchStates[i]]) tOn += ((TOF)((EDMPoint)(b.Points[i])).Shot.TOFs[detectorIndex]);
else tOff += ((TOF)((EDMPoint)(b.Points[i])).Shot.TOFs[detectorIndex]);
}
tOn /= (blockLength / 2);
tOff /= (blockLength / 2);
tc.On = tOn;
tc.Off = tOff;
// This "if" is to take care of the case of the "SIG" channel, for which there
// is no off TOF.
if (tc.Off.Length != 0) tc.Difference = tc.On - tc.Off;
else tc.Difference = tc.On;
// add the Channel to the ChannelSet
List<string> usedSwitches = new List<string>();
for (int i = 0; i < modNames.Count; i++)
if ((channel & (1 << i)) != 0) usedSwitches.Add(modNames[i]);
string[] channelName = usedSwitches.ToArray();
// the SIG channel has a special name
if (channel == 0) channelName = new string[] {"SIG"};
tcs.AddChannel(channelName, tc);
}
// ** add the special channels **
// extract the TOFChannels that we need.
TOFChannel c_eb = (TOFChannel)tcs.GetChannel(new string[] { "E", "B" });
TOFChannel c_edb = (TOFChannel)tcs.GetChannel(new string[] {"E", "DB"});
TOFChannel c_dbrf1f = (TOFChannel)tcs.GetChannel(new string[] { "DB", "RF1F" });
TOFChannel c_dbrf2f = (TOFChannel)tcs.GetChannel(new string[] { "DB", "RF2F" });
TOFChannel c_b = (TOFChannel)tcs.GetChannel(new string[] { "B" });
TOFChannel c_db = (TOFChannel)tcs.GetChannel(new string[] { "DB" });
TOFChannel c_sig = (TOFChannel)tcs.GetChannel(new string[] { "SIG" });
TOFChannel c_brf1f = (TOFChannel)tcs.GetChannel(new string[] { "B", "RF1F" });
TOFChannel c_brf2f = (TOFChannel)tcs.GetChannel(new string[] { "B", "RF2F" });
TOFChannel c_edbrf1f = (TOFChannel)tcs.GetChannel(new string[] { "E", "DB", "RF1F" });
TOFChannel c_edbrf2f = (TOFChannel)tcs.GetChannel(new string[] { "E", "DB", "RF2F" });
TOFChannel c_ebdb= (TOFChannel)tcs.GetChannel(new string[] { "E", "B", "DB" });
TOFChannel c_rf1f = (TOFChannel)tcs.GetChannel(new string[] { "RF1F" });
TOFChannel c_rf2f = (TOFChannel)tcs.GetChannel(new string[] { "RF2F" });
TOFChannel c_erf1f = (TOFChannel)tcs.GetChannel(new string[] { "E", "RF1F" });
TOFChannel c_erf2f = (TOFChannel)tcs.GetChannel(new string[] { "E", "RF2F" });
TOFChannel c_rf1a = (TOFChannel)tcs.GetChannel(new string[] { "RF1A" });
TOFChannel c_rf2a = (TOFChannel)tcs.GetChannel(new string[] { "RF2A" });
TOFChannel c_dbrf1a = (TOFChannel)tcs.GetChannel(new string[] { "DB", "RF1A" });
TOFChannel c_dbrf2a = (TOFChannel)tcs.GetChannel(new string[] { "DB", "RF2A" });
TOFChannel c_lf1 = (TOFChannel)tcs.GetChannel(new string[] { "LF1" });
TOFChannel c_dblf1 = (TOFChannel)tcs.GetChannel(new string[] { "DB", "LF1" });
TOFChannel c_lf2;
TOFChannel c_dblf2;
if (modNames.IndexOf("LF2") == -1) // Index = -1 if "LF2" not found
{
TOF tofTemp = new TOF();
TOFChannel tcTemp = new TOFChannel();
// For many blocks there is no LF2 channel (and hence switch states).
// To get around this problem I will populate the TOFChannel with "SIG"
// It will then be obvious in the analysis when LF2 takes on real values.
for (int i = 0; i < blockLength; i++)
{
tofTemp += ((TOF)((EDMPoint)(b.Points[i])).Shot.TOFs[detectorIndex]);
}
tofTemp /= (blockLength / 2);
tcTemp.On = tofTemp;
tcTemp.Off = tofTemp;
tcTemp.Difference = tofTemp;
c_lf2 = tcTemp;
c_dblf2 = tcTemp;
}
else
{
c_lf2 = (TOFChannel)tcs.GetChannel(new string[] { "LF2" });
c_dblf2 = (TOFChannel)tcs.GetChannel(new string[] { "DB", "LF2" });
}
// work out some intermediate terms for the full, corrected edm. The names
// refer to the joint power of c_db and c_b in the term.
TOFChannel squaredTerms = (((c_db * c_db) - (c_dbrf1f * c_dbrf1f) - (c_dbrf2f * c_dbrf2f)) * c_eb)
- (c_b * c_db * c_edb);
// this is missing the term /beta c_db c_ebdb at the moment, mainly because
// I've no idea what beta should be.
TOFChannel linearTerms = (c_b * c_dbrf1f * c_edbrf1f) + (c_b * c_dbrf2f * c_edbrf2f)
- (c_db * c_brf1f * c_edbrf1f) - (c_db * c_brf2f * c_edbrf2f);
TOFChannel preDenominator = (c_db * c_db * c_db)
+ (c_dbrf1f * c_edb * c_edbrf1f) + (c_dbrf1f * c_edb * c_edbrf1f)
+ (c_dbrf2f * c_edb * c_edbrf2f) + (c_dbrf2f * c_edb * c_edbrf2f)
- c_db * (
(c_dbrf1f * c_dbrf1f) + (c_dbrf2f * c_dbrf2f) + (c_edb * c_edb)
+ (c_edbrf1f * c_edbrf1f) + (c_edbrf2f * c_edbrf2f)
);
// it's important when working out the non-linear channel
// combinations to always keep them dimensionless. If you
// don't you'll run into trouble with integral vs. average
// signal.
TOFChannel edmDB = c_eb / c_db;
tcs.AddChannel(new string[] { "EDMDB" }, edmDB);
// The corrected edm channel. This should be proportional to the edm phase.
TOFChannel edmCorrDB = (squaredTerms + linearTerms) / preDenominator;
tcs.AddChannel(new string[] { "EDMCORRDB" }, edmCorrDB);
// It's useful to have an estimate of the size of the correction. Here
// we return the difference between the corrected edm channel and the
// naive guess, edmDB.
TOFChannel correctionDB = edmCorrDB - edmDB;
tcs.AddChannel(new string[] { "CORRDB" }, correctionDB);
// The "old" correction that just corrects for the E-correlated amplitude change.
// This is included in the dblocks for debugging purposes.
TOFChannel correctionDB_old = (c_edb * c_b) / (c_db * c_db);
tcs.AddChannel(new string[] { "CORRDB_OLD" }, correctionDB_old);
TOFChannel edmCorrDB_old = edmDB - correctionDB_old;
tcs.AddChannel(new string[] { "EDMCORRDB_OLD" }, edmCorrDB_old);
// Normalised RFxF channels.
TOFChannel rf1fDB = c_rf1f / c_db;
tcs.AddChannel(new string[] { "RF1FDB" }, rf1fDB);
TOFChannel rf2fDB = c_rf2f / c_db;
tcs.AddChannel(new string[] { "RF2FDB" }, rf2fDB);
// And RFxF.DB channels, again normalised to DB. The naming of these channels is quite
// unfortunate, but it's just tough.
TOFChannel rf1fDBDB = c_dbrf1f / c_db;
tcs.AddChannel(new string[] { "RF1FDBDB" }, rf1fDBDB);
TOFChannel rf2fDBDB = c_dbrf2f / c_db;
tcs.AddChannel(new string[] { "RF2FDBDB" }, rf2fDBDB);
// Normalised RFxAchannels.
TOFChannel rf1aDB = c_rf1a / c_db;
tcs.AddChannel(new string[] { "RF1ADB" }, rf1aDB);
TOFChannel rf2aDB = c_rf2a / c_db;
tcs.AddChannel(new string[] { "RF2ADB" }, rf2aDB);
// And RFxA.DB channels, again normalised to DB. The naming of these channels is quite
// unfortunate, but it's just tough.
TOFChannel rf1aDBDB = c_dbrf1a / c_db;
tcs.AddChannel(new string[] { "RF1ADBDB" }, rf1aDBDB);
TOFChannel rf2aDBDB = c_dbrf2a / c_db;
tcs.AddChannel(new string[] { "RF2ADBDB" }, rf2aDBDB);
// the E.RFxF channels, normalized to DB
TOFChannel erf1fDB = c_erf1f / c_db;
tcs.AddChannel(new string[] { "ERF1FDB" }, erf1fDB);
TOFChannel erf2fDB = c_erf2f / c_db;
tcs.AddChannel(new string[] { "ERF2FDB" }, erf2fDB);
// the E.RFxF.DB channels, normalized to DB, again dodgy naming convention.
TOFChannel erf1fDBDB = c_edbrf1f / c_db;
tcs.AddChannel(new string[] { "ERF1FDBDB" }, erf1fDBDB);
TOFChannel erf2fDBDB = c_edbrf2f / c_db;
tcs.AddChannel(new string[] { "ERF2FDBDB" }, erf2fDBDB);
// the LF1 channel, normalized to DB
TOFChannel lf1DB = c_lf1 / c_db;
tcs.AddChannel(new string[] { "LF1DB" }, lf1DB);
TOFChannel lf1DBDB = c_dblf1 / c_db;
tcs.AddChannel(new string[] { "LF1DBDB" }, lf1DBDB);
// the LF2 channel, normalized to DB
TOFChannel lf2DB = c_lf2 / c_db;
tcs.AddChannel(new string[] { "LF2DB" }, lf2DB);
TOFChannel lf2DBDB = c_dblf2 / c_db;
tcs.AddChannel(new string[] { "LF2DBDB" }, lf2DBDB);
TOFChannel bDB = c_b / c_db;
tcs.AddChannel(new string[] { "BDB" }, bDB);
// we also need to extract the rf-step induced phase shifts. These come out in the
// B.RFxF channels, but like the edm, need to be corrected. I'm going to use just the
// simplest level of correction for these.
TOFChannel brf1fCorrDB = (c_brf1f / c_db) - ((c_b * c_dbrf1f) / (c_db * c_db));
tcs.AddChannel(new string[] { "BRF1FCORRDB" }, brf1fCorrDB);
TOFChannel brf2fCorrDB = (c_brf2f / c_db) - ((c_b * c_dbrf2f) / (c_db * c_db));
tcs.AddChannel(new string[] { "BRF2FCORRDB" }, brf2fCorrDB);
//Some extra channels for various shot noise calculations, these are a bit weird
tcs.AddChannel(new string[] { "SIGNL" }, c_sig);
tcs.AddChannel(new string[] { "ONEOVERDB" }, 1/c_db);
TOFChannel dbSigNL = new TOFChannel();
dbSigNL.On = c_db.On/c_sig.On;
dbSigNL.Off = c_db.Off/c_sig.On;;
dbSigNL.Difference = c_db.Difference / c_sig.Difference;
tcs.AddChannel(new string[] { "DBSIG" }, dbSigNL);
TOFChannel dbdbSigSigNL = dbSigNL * dbSigNL;
tcs.AddChannel(new string[] { "DBDBSIGSIG" }, dbdbSigSigNL);
TOFChannel SigdbdbNL = new TOFChannel();
SigdbdbNL.On = c_sig.On / ( c_db.On* c_db.On);
SigdbdbNL.Off = c_sig.On / ( c_db.Off * c_db.Off);
SigdbdbNL.Difference = c_sig.Difference / (c_db.Difference * c_db.Difference);
tcs.AddChannel(new string[] { "SIGDBDB" }, SigdbdbNL);
return tcs;
}
public static TOF operator -(TOF p1, TOF p2)
{
TOF temp = new TOF();
temp.Data = new double[p2.Data.Length];
temp.GateStartTime = p1.GateStartTime;
temp.ClockPeriod = p1.ClockPeriod;
temp.Calibration = p1.Calibration;
for (int i = 0; i < p2.Data.Length; i++)
{
temp.Data[i] = -p2.Data[i];
}
return p1 + temp;
}
public static TOF operator /(double d,TOF p)
{
double[] tempData = new double[p.Length];
for (int i = 0; i < p.Length; i++)
{
tempData[i] = d/p.Data[i];
}
TOF temp = new TOF();
temp.Data = tempData;
temp.GateStartTime = p.GateStartTime;
temp.ClockPeriod = p.ClockPeriod;
temp.Calibration = p.Calibration;
return temp;
}
public static TOF operator /(TOF t1, TOF t2)
{
TOF temp = new TOF();
temp.Data = new double[t1.Data.Length];
temp.GateStartTime = t1.GateStartTime;
temp.ClockPeriod = t1.ClockPeriod;
temp.Calibration = t1.Calibration;
for (int i = 0; i < t1.Data.Length; i++)
{
temp.Data[i] = t1.Data[i] / t2.Data[i];
}
return temp;
}
public void PlotNormedOnTOF(TOF t)
{
PlotY(tofGraphNormed, tofOnNormedPlot, t.GateStartTime, t.ClockPeriod, t.Data);
}
public void HandleDataPoint(DataEventArgs e)
{
Profile currentProfile = Controller.GetController().ProfileManager.CurrentProfile;
// update the TOF graphs
if (currentProfile.GUIConfig.average)
{
if (shotCounter % currentProfile.GUIConfig.updateTOFsEvery == 0)
{
if (avOnTof != null)
{
window.PlotOnTOF(avOnTof/onAverages);
}
avOnTof = (TOF) e.point.AverageOnShot.TOFs[0];
onAverages = 1;
if ((bool)currentProfile.AcquisitorConfig.switchPlugin.Settings["switchActive"])
{
if (avOffTof != null)
{
window.PlotOffTOF(avOffTof/offAverages);
}
avOffTof = (TOF) e.point.AverageOffShot.TOFs[0];
offAverages = 1;
}
}
else // do the averaging
{
if (avOnTof != null)
{
avOnTof = avOnTof + ((TOF) e.point.AverageOnShot.TOFs[0]);
onAverages++;
}
if ((bool)currentProfile.AcquisitorConfig.switchPlugin.Settings["switchActive"] && avOffTof != null)
{
avOffTof = avOffTof + ((TOF) e.point.AverageOffShot.TOFs[0]);
offAverages++;
}
}
}
else // if not averaging
{
if (shotCounter % currentProfile.GUIConfig.updateTOFsEvery == 0)
{
window.PlotOnTOF((TOF)e.point.AverageOnShot.TOFs[0]);
if ((bool)currentProfile.AcquisitorConfig.switchPlugin.Settings["switchActive"])
{
window.PlotOffTOF((TOF)e.point.AverageOffShot.TOFs[0]);
}
}
}
// update the spectra
pointsToPlot.Points.Add(e.point);
if (shotCounter % currentProfile.GUIConfig.updateSpectraEvery == 0)
{
if (pointsToPlot.AnalogChannelCount >= 1)
window.AppendToAnalog1(pointsToPlot.ScanParameterArray, pointsToPlot.GetAnalogArray(0));
if (pointsToPlot.AnalogChannelCount >= 2)
window.AppendToAnalog2(pointsToPlot.ScanParameterArray, pointsToPlot.GetAnalogArray(1));
window.AppendToPMTOn(pointsToPlot.ScanParameterArray,
pointsToPlot.GetTOFOnIntegralArray(0,
startTOFGate, endTOFGate));
if ((bool)currentProfile.AcquisitorConfig.switchPlugin.Settings["switchActive"])
{
window.AppendToPMTOff(pointsToPlot.ScanParameterArray,
pointsToPlot.GetTOFOffIntegralArray(0,
startTOFGate, endTOFGate));
window.AppendToDifference(pointsToPlot.ScanParameterArray,
pointsToPlot.GetDifferenceIntegralArray(0,
startTOFGate, endTOFGate));
}
// update the spectrum fit if in shot mode.
if (spectrumFitMode == FitMode.Shot)
{
Scan currentScan = Controller.GetController().DataStore.CurrentScan;
if (currentScan.Points.Count > 10)
{
FitAndPlotSpectrum(currentScan);
}
}
pointsToPlot.Points.Clear();
}
shotCounter++;
}
public static TOF Random()
{
TOF t = new TOF();
t.Data = new double[RANDOM_TOF_SIZE];
for (int i = 0; i < RANDOM_TOF_SIZE; i++) t.Data[i] = r.NextDouble();
t.Calibration = 1.0;
t.ClockPeriod = 10;
t.GateStartTime = 1800;
return t;
}
