Inheritance: System.MarshalByRefObject
Esempio n. 1
0
 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;
 }
Esempio n. 2
0
 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;
 }
Esempio n. 3
0
        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);
        }
Esempio n. 4
0
        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);
        }
Esempio n. 5
0
        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);
        }
Esempio n. 6
0
        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);
        }
Esempio n. 7
0
        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);
        }
Esempio n. 8
0
        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);
        }
Esempio n. 9
0
        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();
        }
Esempio n. 10
0
        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);
        }
Esempio n. 11
0
        //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;
        }
Esempio n. 12
0
        // 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);
        }
Esempio n. 13
0
 // 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);
 }
Esempio n. 14
0
        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;
        }
Esempio n. 15
0
 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;
     }
 }
Esempio n. 16
0
 public void PlotOnTOF(TOF t)
 {
     PlotY(tofGraph, tofOnPlot, t.GateStartTime, t.ClockPeriod, t.Data);
 }
Esempio n. 17
0
 public void PlotAverageOffTOF(TOF t)
 {
     PlotY(tofGraph, tofOffAveragePlot, t.GateStartTime, t.ClockPeriod, t.Data);
 }
Esempio n. 18
0
        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;
        }
Esempio n. 19
0
        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;
        }
Esempio n. 20
0
 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;
 }
Esempio n. 21
0
        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;
        }
Esempio n. 22
0
 public void PlotNormedOnTOF(TOF t)
 {
     PlotY(tofGraphNormed, tofOnNormedPlot, t.GateStartTime, t.ClockPeriod, t.Data);
 }
Esempio n. 23
0
        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++;
        }
Esempio n. 24
0
 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;
 }