Пример #1
0
        public RainbowHardware()
        {
            // add the boards
            Boards.Add("daq", "/PXI1Slot4");
            Boards.Add("TCLBoard", "/PXI1Slot6");
            string daqBoard = (string)Boards["daq"];
            string TCLBoard = (string)Boards["TCLBoard"];

            // add things to the info
            // the analog triggers
            Info.Add("analogTrigger0", (string)Boards["daq"] + "/PFI1");
            Info.Add("analogTrigger1", (string)Boards["daq"] + "/PFI2");
            Info.Add("sourceToDetect", 0.4);
            Info.Add("moleculeMass", 100.0);
            Info.Add("phaseLockControlMethod", "synth");
            Info.Add("PGClockLine", daqBoard + "/PFI4");
            Info.Add("PatternGeneratorBoard", daqBoard);
            Info.Add("PGType", "integrated");
            Info.Add("PGClockCounter", "/ctr0");

            //TCL Configuration
            TCLConfig tcl1 = new TCLConfig("Hamish McCavity");

            tcl1.AddLaser("laser", "p1");
            tcl1.AddLaser("laser2", "p2");
            tcl1.AddLaser("laser4", "p4");
            tcl1.Trigger          = TCLBoard + "/PFI0";
            tcl1.Cavity           = "cavityRampMonitor";
            tcl1.MasterLaser      = "master";
            tcl1.Ramp             = "rampfb";
            tcl1.AnalogSampleRate = 50000;
            tcl1.TCPChannel       = 1190;
            Info.Add("Hamish", tcl1);
            Info.Add("DefaultCavity", tcl1);

            //TCL Lockable lasers - this stuff should no longer be needed - leave here for reference

            //Info.Add("TCLLockableLasers", new string[] { "laser","laser2","laser4"});
            //Info.Add("TCLPhotodiodes", new string[] { "cavityRampMonitor", "master", "p1", "p2","p4"});// THE FIRST TWO MUST BE CAVITY AND MASTER PHOTODIODE!!!!
            //Info.Add("TCL_Slave_Voltage_Limit_Upper", 2.0); //volts: Laser control
            //Info.Add("TCL_Slave_Voltage_Limit_Lower", -2.0); //volts: Laser control
            //Info.Add("TCL_Default_Gain", -0.01);
            //Info.Add("TCL_Default_VoltageToLaser", 0.0);
            //Info.Add("TCL_MAX_INPUT_VOLTAGE", 10.0);
            //// Some matching up for TCL
            //Info.Add("laser", "p1");
            //Info.Add("laser2", "p2");
            //Info.Add("laser4", "p4");
            //Info.Add("TCLTrigger", TCLBoard + "/PFI0");

            // YAG laser
            yag = new BrilliantLaser("ASRL3::INSTR");

            // add the GPIB instruments

            // map the digital channels
            AddDigitalOutputChannel("valve", daqBoard, 0, 0);
            AddDigitalOutputChannel("flash", daqBoard, 0, 1);
            AddDigitalOutputChannel("q", daqBoard, 0, 2);
            AddDigitalOutputChannel("detector", daqBoard, 0, 3);
            AddDigitalOutputChannel("detectorprime", daqBoard, 0, 4); // this trigger is for switch scanning
            AddDigitalOutputChannel("aom", daqBoard, 0, 5);           // this trigger is for switch scanning

            // map the analog input channels
            AddAnalogInputChannel("pmt", daqBoard + "/ai1", AITerminalConfiguration.Nrse);
            AddAnalogInputChannel("norm", daqBoard + "/ai0", AITerminalConfiguration.Nrse);
            AddAnalogInputChannel("iodine", daqBoard + "/ai2", AITerminalConfiguration.Nrse);
            AddAnalogInputChannel("cavity", daqBoard + "/ai3", AITerminalConfiguration.Nrse);

            AddAnalogInputChannel("master", TCLBoard + "/ai1", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("p1", TCLBoard + "/ai3", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("cavityRampMonitor", TCLBoard + "/ai2", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("p4", TCLBoard + "/ai0", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("p2", TCLBoard + "/ai5", AITerminalConfiguration.Rse);


            // map the analog output channels
            AddAnalogOutputChannel("laser", TCLBoard + "/ao0");
            AddAnalogOutputChannel("laser4", TCLBoard + "/ao1");
            AddAnalogOutputChannel("laser2", daqBoard + "/ao1");
            AddAnalogOutputChannel("laser3", daqBoard + "/ao2");
            AddAnalogOutputChannel("rampfb", daqBoard + "/ao0");

            //Transfer Cavity Lock
            //AddAnalogOutputChannel("cavity", daqBoard + "/ao1");
            //Info.Add("analogTrigger2", (string)Boards["daq"] + "/PFI0");
            //Info.Add("analogTrigger3", (string)Boards["daq"] + "/PFI3");
            //AddDigitalOutputChannel("scanTrigger", daqBoard, 0, 6);
            //AddAnalogInputChannel("slavepd", daqBoard + "/ai4", AITerminalConfiguration.Nrse);
            //AddAnalogInputChannel("masterpd", daqBoard + "/ai5", AITerminalConfiguration.Nrse);


            // map the counter channels
            //AddCounterChannel("phaseLockOscillator", daqBoard + "/ctr7");
            //AddCounterChannel("phaseLockReference", daqBoard + "/pfi10");
            //AddCounterChannel("northLeakage", counterBoard + "/ctr0");
            //AddCounterChannel("southLeakage", counterBoard + "/ctr1");
        }
Пример #2
0
        public BufferClassicHardware()
        {
            // add the boards
            //Boards.Add("daq", "/PXI1Slot2");
            //Boards.Add("pg", "/PXI1Slot3");
            Boards.Add("daq", "/DAQ");
            Boards.Add("pg", "/PG");
            Boards.Add("tcl", "/PXI1Slot4");
            Boards.Add("tclvis", "/VisCavity");
            Boards.Add("tclvis2", "/VisCavity2");
            string TCLBoard  = (string)Boards["tcl"];
            string TCLBoard2 = (string)Boards["tclvis"];
            string TCLBoard3 = (string)Boards["tclvis2"];

            // map the digital channels
            string pgBoard = (string)Boards["pg"];

            AddDigitalOutputChannel("q", pgBoard, 0, 0);             //Pin 10
            AddDigitalOutputChannel("aom", pgBoard, 1, 1);           //
            AddDigitalOutputChannel("aom2", pgBoard, 1, 2);          //
            AddDigitalOutputChannel("flash", pgBoard, 0, 2);         //Pin 45
            //(0,3) pin 12 is unconnected
            AddDigitalOutputChannel("shutterTrig1", pgBoard, 1, 6);  // Pin 21, triggers camera for on-shots (not wired up)
            AddDigitalOutputChannel("shutterTrig2", pgBoard, 1, 7);  // Pin 22, triggers camera for off-shots (not wired up)
            AddDigitalOutputChannel("probe", pgBoard, 0, 1);         //Pin 44 previously connected to aom (not wired up)

            AddDigitalOutputChannel("valve", pgBoard, 0, 6);         //

            AddDigitalOutputChannel("detector", pgBoard, 1, 0);      //Pin 16 (onShot)from pg to daq
            AddDigitalOutputChannel("detectorprime", pgBoard, 0, 7); //Pin 15 (OffShot)from pg to daq

            //digital output P 0.6 wired up, not used (Pin 48)
            // this is the digital output from the daq board that the TTlSwitchPlugin wil switch
            AddDigitalOutputChannel("digitalSwitchChannel", (string)Boards["daq"], 0, 0);//enable for camera



            // add things to the info
            // the analog triggers
            Info.Add("analogTrigger0", (string)Boards["daq"] + "/PFI0");
            Info.Add("analogTrigger1", (string)Boards["daq"] + "/PFI1");
            Info.Add("phaseLockControlMethod", "analog");
            Info.Add("PGClockLine", Boards["pg"] + "/PFI4");
            Info.Add("PatternGeneratorBoard", pgBoard);
            Info.Add("PGType", "dedicated");

            // external triggering control
            Info.Add("PGTrigger", pgBoard + "/PFI1"); //Mapped to PFI7 on 6533 connector

            // map the analog channels
            //string daqBoard = (string)Boards["daq"];
            //AddAnalogInputChannel("detector1", daqBoard + "/ai0", AITerminalConfiguration.Nrse);//Pin 68
            //AddAnalogInputChannel("detector2", daqBoard + "/ai3", AITerminalConfiguration.Nrse);//Pin
            //AddAnalogInputChannel("detector3", daqBoard + "/ai8", AITerminalConfiguration.Nrse);//Pin 34
            //AddAnalogInputChannel("pressure1", daqBoard + "/ai1", AITerminalConfiguration.Nrse);//Pin 33 pressure reading at the moment
            //AddAnalogInputChannel("cavity", daqBoard + "/ai2", AITerminalConfiguration.Nrse);//Pin 65
            //AddAnalogInputChannel("cavitylong", daqBoard + "/ai4", AITerminalConfiguration.Nrse);//Pin 28
            //AddAnalogInputChannel("cavityshort", daqBoard + "/ai5", AITerminalConfiguration.Nrse);//Pin 60

            // map the analog channels
            string daqBoard = (string)Boards["daq"];

            AddAnalogInputChannel("detector1", daqBoard + "/ai4", AITerminalConfiguration.Rse);   //Pin 68
            AddAnalogInputChannel("detector2", daqBoard + "/ai5", AITerminalConfiguration.Rse);   //Pin
            AddAnalogInputChannel("detector3", daqBoard + "/ai6", AITerminalConfiguration.Rse);   //Pin 34

            AddAnalogInputChannel("cavitylong", daqBoard + "/ai7", AITerminalConfiguration.Rse);  //Pin 28
            AddAnalogInputChannel("cavityshort", daqBoard + "/ai8", AITerminalConfiguration.Rse); //Pin 60

            AddAnalogInputChannel("Temp1", daqBoard + "/ai0", AITerminalConfiguration.Rse);       //Pin 31
            AddAnalogInputChannel("Temp2", daqBoard + "/ai1", AITerminalConfiguration.Rse);       //Pin 31
            AddAnalogInputChannel("TempRef", daqBoard + "/ai2", AITerminalConfiguration.Rse);     //Pin 66
            AddAnalogInputChannel("pressure1", daqBoard + "/ai3", AITerminalConfiguration.Rse);   //Pin 33 pressure reading at the moment


            AddAnalogOutputChannel("phaseLockAnalogOutput", daqBoard + "/ao1"); //pin 21

            //TransferCavityLock info
            TCLConfig tcl1 = new TCLConfig("IR Cavity");

            tcl1.AddLaser("pumplaser", "p1");
            tcl1.AddLaser("v21repump", "p2");
            tcl1.Trigger                = TCLBoard + "/PFI0";
            tcl1.Cavity                 = "cavityRampMonitor";
            tcl1.MasterLaser            = "master";
            tcl1.Ramp                   = "rampfb";
            tcl1.TCPChannel             = 1190;
            tcl1.SlaveVoltageLowerLimit = 0.0;
            tcl1.SlaveVoltageUpperLimit = 10.0;
            //      tcl1.DefaultScanPoints = 600;
            Info.Add("IR", tcl1);


            //TransferCavityLock info
            TCLConfig tcl2 = new TCLConfig("VIS Cavity");

            tcl2.AddLaser("v1repump", "VISp1");
            tcl2.Trigger                = TCLBoard2 + "/PFI0";
            tcl2.Cavity                 = "VIScavityRampMonitor";
            tcl2.MasterLaser            = "VISmaster";
            tcl2.Ramp                   = "VISrampfb";
            tcl2.TCPChannel             = 1191;
            tcl2.SlaveVoltageLowerLimit = -10.0;
            tcl2.SlaveVoltageUpperLimit = 10.0;
            //tcl2.AnalogSampleRate = 15000;
            //       tcl2.DefaultScanPoints = 300;
            Info.Add("VIS", tcl2);
            // The next line is try two DAQ cards for one cavity. (14 Nov 2016) Feel free to delete it.
            tcl2.AddLaser("v2repump", "VISp2");

            //TCL Lockable lasers
            // Info.Add("TCLLockableLasers", new string[] { "pumplaser"});
            // Info.Add("TCLPhotodiodes", new string[] { "cavityRampMonitor", "master", "p1"});// THE FIRST TWO MUST BE CAVITY AND MASTER PHOTODIODE!!!!
            // Info.Add("TCL_Slave_Voltage_Limit_Upper", 2.0); //volts: Laser control
            // Info.Add("TCL_Slave_Voltage_Limit_Lower", -2.0); //volts: Laser control
            // Info.Add("TCL_Default_Gain", -0.01);
            // Info.Add("TCL_Default_VoltageToLaser", 0.0);
            // Info.Add("TCL_MAX_INPUT_VOLTAGE", 10.0);
            // Info.Add("TCL_Default_ScanPoints", 1000);
            // Some matching up for TCL
            // Info.Add("pumplaser", "p1");
            // Info.Add("TCLTrigger", TCLBoard + "/PFI0");

            AddAnalogInputChannel("master", TCLBoard + "/ai0", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("p1", TCLBoard + "/ai2", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("p2", TCLBoard + "/ai16", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("cavityRampMonitor", TCLBoard + "/ai1", AITerminalConfiguration.Rse);

            //      AddAnalogInputChannel("VISmaster", TCLBoard2 + "/ai5", AITerminalConfiguration.Rse);
            //      AddAnalogInputChannel("VISp1", TCLBoard2 + "/ai2", AITerminalConfiguration.Rse);
            //      AddAnalogInputChannel("VIScavityRampMonitor", TCLBoard2 + "/ai4", AITerminalConfiguration.Rse);
            //      //The next line is try two DAQ cards for one cavity. (14 Nov 2016) Feel free to delete it.
            //      AddAnalogInputChannel("VISp2", TCLBoard2 + "/ai7", AITerminalConfiguration.Rse);

            AddAnalogInputChannel("VISmaster", TCLBoard2 + "/ai0", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("VISp1", TCLBoard2 + "/ai2", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("VIScavityRampMonitor", TCLBoard2 + "/ai1", AITerminalConfiguration.Rse);
            //The next line is try two DAQ cards for one cavity. (14 Nov 2016) Feel free to delete it.
            AddAnalogInputChannel("VISp2", TCLBoard2 + "/ai3", AITerminalConfiguration.Rse);



            // map the analog output channels
            AddAnalogOutputChannel("pumplaser", TCLBoard + "/ao1");
            AddAnalogOutputChannel("v21repump", TCLBoard + "/ao2");
            AddAnalogOutputChannel("laser", daqBoard + "/ao0");//Pin 22
            AddAnalogOutputChannel("rampfb", TCLBoard + "/ao0");


            AddAnalogOutputChannel("v1repump", TCLBoard2 + "/ao1");
            AddAnalogOutputChannel("VISrampfb", TCLBoard2 + "/ao0");
            AddAnalogOutputChannel("v2repump", TCLBoard2 + "/ao2");



            //map the counter channels
            //AddCounterChannel("pmt", daqBoard + "/ctr0");
            //AddCounterChannel("sample clock", daqBoard + "/ctr1");

            //These need to be activated for the phase lock
            AddCounterChannel("phaseLockOscillator", daqBoard + "/ctr0"); //This should be the source pin of a counter PFI 8
            AddCounterChannel("phaseLockReference", daqBoard + "/PFI9");  //This should be the gate pin of the same counter - need to check it's name
        }
Пример #3
0
        public TCLEDMHardware()
        {
            //Add the boards
            Boards.Add("tclBoardPump", "/PXI1Slot5");
            Boards.Add("tclBoardProbe", "/PXI1Slot2");

            string tclBoardPump  = (string)Boards["tclBoardPump"];
            string tclBoardProbe = (string)Boards["tclBoardProbe"];

            // Cavity inputs for the cavity that controls the Pump lasers
            AddAnalogInputChannel("PumpCavityRampVoltage", tclBoardPump + "/ai8", AITerminalConfiguration.Rse); //tick
            AddAnalogInputChannel("Pumpmaster", tclBoardPump + "/ai1", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("Pumpp1", tclBoardPump + "/ai2", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("Pumpp2", tclBoardPump + "/ai3", AITerminalConfiguration.Rse);

            // Lasers locked to pump cavity
            AddAnalogOutputChannel("KeopsysDiodeLaser", tclBoardPump + "/ao2", -4, 4); //tick
            AddAnalogOutputChannel("MenloPZT", tclBoardPump + "/ao0", 0, 10);          //tick

            // Length stabilisation for pump cavity
            AddAnalogOutputChannel("PumpCavityLengthVoltage", tclBoardPump + "/ao1", -10, 10); //tick

            //TCL configuration for pump cavity
            TCLConfig tcl1 = new TCLConfig("Pump Cavity");

            tcl1.AddLaser("MenloPZT", "Pumpp1");
            tcl1.AddLaser("KeopsysDiodeLaser", "Pumpp2");
            tcl1.Trigger           = tclBoardPump + "/PFI0";
            tcl1.Cavity            = "PumpCavityRampVoltage";
            tcl1.MasterLaser       = "Pumpmaster";
            tcl1.Ramp              = "PumpCavityLengthVoltage";
            tcl1.TCPChannel        = 1190;
            tcl1.AnalogSampleRate  = 61250;
            tcl1.DefaultScanPoints = 500;
            tcl1.MaximumNLMFSteps  = 20;
            tcl1.PointsToConsiderEitherSideOfPeakInFWHMs = 2.5;
            tcl1.TriggerOnRisingEdge = false;
            tcl1.AddFSRCalibration("MenloPZT", 3.84);
            tcl1.AddFSRCalibration("KeopsysDiodeLaser", 3.84);
            tcl1.AddDefaultGain("Master", 0.3);
            tcl1.AddDefaultGain("MenloPZT", -0.2);
            tcl1.AddDefaultGain("KeopsysDiodeLaser", 4);
            Info.Add("PumpCavity", tcl1);
            //Info.Add("DefaultCavity", tcl1);

            // Probe cavity inputs
            AddAnalogInputChannel("ProbeRampVoltage", tclBoardProbe + "/ai0", AITerminalConfiguration.Rse); //tick
            AddAnalogInputChannel("Probemaster", tclBoardProbe + "/ai1", AITerminalConfiguration.Rse);      //tick
            AddAnalogInputChannel("Probep1", tclBoardProbe + "/ai2", AITerminalConfiguration.Rse);          //tick

            // Lasers locked to Probe cavity
            AddAnalogOutputChannel("TopticaSHGPZT", tclBoardProbe + "/ao0", -4, 4);              //tick
            AddAnalogOutputChannel("ProbeCavityLengthVoltage", tclBoardProbe + "/ao1", -10, 10); //tick

            // TCL configuration for Probe cavity
            TCLConfig tcl2 = new TCLConfig("Probe Cavity");

            tcl2.AddLaser("TopticaSHGPZT", "Probep1");
            tcl2.Trigger           = tclBoardProbe + "/PFI0";
            tcl2.Cavity            = "ProbeRampVoltage";
            tcl2.MasterLaser       = "Probemaster";
            tcl2.Ramp              = "ProbeCavityLengthVoltage";
            tcl2.TCPChannel        = 1191;
            tcl2.AnalogSampleRate  = 61250 / 2;
            tcl2.DefaultScanPoints = 250;
            tcl2.MaximumNLMFSteps  = 20;
            tcl2.PointsToConsiderEitherSideOfPeakInFWHMs = 12;
            tcl2.AddFSRCalibration("TopticaSHGPZT", 3.84);
            tcl2.TriggerOnRisingEdge = false;
            tcl2.AddDefaultGain("Master", 0.4);
            tcl2.AddDefaultGain("TopticaSHGPZT", 0.04);
            Info.Add("ProbeCavity", tcl2);
            Info.Add("DefaultCavity", tcl2);
        }
Пример #4
0
        public DecelerationHardware()
        {
            // YAG laser
            yag = new MiniliteLaser();

            // add the boards
            Boards.Add("daq", "/dev2");
            Boards.Add("multiDAQ", "/dev1");
            Boards.Add("pg", "/dev1");
            Boards.Add("aoBoard", "/PXI1Slot5");
            Boards.Add("usbDev", "/dev4");
            //Boards.Add("PXI6", "/PXI1Slot6_4");
            Boards.Add("PXI6", "/PXI1Slot6");
            Boards.Add("PXI4", "/PXI1Slot4");
            Boards.Add("PXI5", "/PXI1Slot5");
            string pgBoard   = (string)Boards["pg"];
            string usbBoard  = (string)Boards["usbDev"];
            string daqBoard  = (string)Boards["daq"];
            string PXIBoard  = (string)Boards["PXI6"];
            string TCLBoard  = (string)Boards["PXI4"];
            string TCLBoard2 = (string)Boards["PXI6"];
            string aoBoard   = (string)Boards["aoBoard"];

            //configure instance 1 of transfer cavity lock
            TCLConfig tcl1 = new TCLConfig("Hamish McCavity");

            tcl1.AddLaser("v00cooling", "p1");
            tcl1.AddLaser("v10repump", "p2");
            tcl1.AddLaser("eylsa", "p3");
            tcl1.Trigger     = TCLBoard + "/PFI0";
            tcl1.Cavity      = "cavity";
            tcl1.MasterLaser = "master";
            tcl1.Ramp        = "rampfb";
            tcl1.TCPChannel  = 1190;
            Info.Add("Hamish", tcl1);

            //configure instance 2 of transfer cavity lock
            TCLConfig tcl2 = new TCLConfig("Carlos the Cavity");

            tcl2.AddLaser("v21repump", "p12");
            tcl2.AddLaser("v32repump", "p22");
            tcl2.Trigger     = TCLBoard2 + "/PFI0";
            tcl2.Cavity      = "cavity2";
            tcl2.MasterLaser = "master2";
            tcl2.Ramp        = "rampfb2";
            tcl2.TCPChannel  = 1191;
            Info.Add("Carlos", tcl2);

            //MotMaster configuration
            MMConfig mmConfig = new MMConfig(false, false, false, false);

            mmConfig.ExternalFilePattern = "*.tif";
            Info.Add("MotMasterConfiguration", mmConfig);


            Instruments.Add("synth", new HP8673BSynth("GPIB0::19::INSTR"));
            //Instruments.Add("counter", new HP5350BCounter("GPIB0::14::INSTR"));

            //Instruments.Add("flowmeter", new FlowMeter("ASRL1::INSTR"));


            //VCO lock
            //AddAnalogOutputChannel("VCO_Out", PXIBoard + "/ao12", 0.0, 10.0);

            // add things to the info
            Info.Add("PGTrigger", Boards["pg"] + "/PFI2");          // trigger from "cryocooler sync" box, delay controlled from "triggerDelay" analog output
            //Info.Add("PGClockLine", Boards["pg"] + "/PFI2");
            Info.Add("PatternGeneratorBoard", pgBoard);
            Info.Add("PGType", "dedicated");
            Info.Add("AOPatternTrigger", aoBoard + "/PFI0");

            Info.Add("defaultTOFRange", new double[] { 4000, 12000 }); // these entries are the two ends of the range for the upper TOF graph
            Info.Add("defaultTOF2Range", new double[] { 0, 1000 });    // these entries are the two ends of the range for the middle TOF graph
            Info.Add("defaultGate", new double[] { 6000, 2000 });      // the first entry is the centre of the gate, the second is the half width of the gate (upper TOF graph)


            // the analog triggers
            Info.Add("analogTrigger0", (string)Boards["daq"] + "/PFI0"); // pin 11
            Info.Add("analogTrigger1", (string)Boards["daq"] + "/PFI1"); // pin 10
            //Info.Add("TCLTrigger", (string)Boards["PXI4"] + "/PFI0");
            //Info.Add("analogTrigger2", (string)Boards["usbDev"] + "/PFI0"); //Pin 29
            Info.Add("analogTrigger3", (string)Boards["daq"] + "/PFI6"); //Pin 5 - breakout 31
            Info.Add("usbAnalogTrigger", usbBoard + "/PFI0");
            //distance information
            Info.Add("sourceToDetect", 0.535);             //in m
            Info.Add("sourceToSoftwareDecelerator", 0.12); //in m
            //information about the molecule
            Info.Add("molecule", "caf");
            Info.Add("Element", "CaF");
            Info.Add("moleculeMass", 58.961);                   // this is 40CaF in atomic mass units
            Info.Add("moleculeRotationalConstant", 1.02675E10); //in Hz
            Info.Add("moleculeDipoleMoment", 15400.0);          //in Hz/(V/m)
            //information about the decelerator

            //These settings for WF
            Info.Add("deceleratorStructure", DecelerationConfig.DecelerationExperiment.SwitchStructure.V_H);             //Vertical first
            Info.Add("deceleratorLensSpacing", 0.006);
            Info.Add("deceleratorFieldMap", "RodLayout3_EonAxis.dat");
            Info.Add("mapPoints", 121);
            Info.Add("mapStartPoint", 0.0);
            Info.Add("mapResolution", 0.0001);

            // These settings for AG
            //	Info.Add("deceleratorStructure", DecelerationConfig.DecelerationExperiment.SwitchStructure.H_V); //Horizontal first
            //  Info.Add("deceleratorLensSpacing", 0.024);
            //  Info.Add("deceleratorFieldMap", "Section1v1_onAxisFieldTemplate.dat");
            //  Info.Add("mapPoints", 481);
            //  Info.Add("mapStartPoint", 0.0);
            //  Info.Add("mapResolution", 0.0001);

            //Here are constants for 174YbF for future reference
            //Info.Add("molecule", "ybf");
            //Info.Add("moleculeMass", 192.937); // this is 174YbF in atomic mass units
            //Info.Add("moleculeRotationalConstant", 7.2338E9); //in Hz
            //Info.Add("moleculeDipoleMoment", 19700.0); //in Hz/(V/m)

            // map the digital channels
            AddDigitalOutputChannel("valve", pgBoard, 0, 6);
            AddDigitalOutputChannel("tclBlock", pgBoard, 0, 6); //Same as valve; deliberately!
            AddDigitalOutputChannel("flash", pgBoard, 0, 0);    //Changed from pg board P.0.5 because that appears to have died mysteriously (line dead in ribbon cable?) TEW 06/04/09
            AddDigitalOutputChannel("q", pgBoard, 0, 2);
            AddDigitalOutputChannel("chirpTrigger", pgBoard, 1, 0);
            AddDigitalOutputChannel("detector", pgBoard, 3, 7);
            AddDigitalOutputChannel("detectorprime", pgBoard, 3, 6);
            AddDigitalOutputChannel("aom", pgBoard, 2, 1);  //Same channel as "ttl2" as used by the AomLevelControlPlugin. Now commented out.
            AddDigitalOutputChannel("aom2", pgBoard, 1, 6); // Pin 21 of PG board. Output 31 of front panel
            AddDigitalOutputChannel("v00Shutter", pgBoard, 2, 2);
            //AddDigitalOutputChannel("digitalSwitchChannel", pgBoard, 2, 2);
            AddDigitalOutputChannel("v00AOM", pgBoard, 1, 1);               //Pin 17
            AddDigitalOutputChannel("shimCoilSwitch", pgBoard, 1, 2);       //Pin 51
            AddDigitalOutputChannel("bXShutter", pgBoard, 1, 3);            //Pin 52
            AddDigitalOutputChannel("cameraTrigger", pgBoard, 0, 4);        // Pin 13
            AddDigitalOutputChannel("AnalogPatternTrigger", pgBoard, 3, 3); //Pin 31

            // map the analog channels
            AddAnalogInputChannel("pmt", daqBoard + "/ai0", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("pmt2", daqBoard + "/ai1", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("refcavity", daqBoard + "/ai1", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("lockcavity", daqBoard + "/ai2", AITerminalConfiguration.Rse);

            AddAnalogInputChannel("master", TCLBoard + "/ai1", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("cavity", TCLBoard + "/ai15", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("p1", TCLBoard + "/ai3", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("p2", TCLBoard + "/ai10", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("p3", TCLBoard + "/ai4", AITerminalConfiguration.Rse);

            AddAnalogOutputChannel("v10repump", TCLBoard + "/ao0");
            AddAnalogOutputChannel("rampfb", TCLBoard + "/ao1");

            AddAnalogOutputChannel("v00cooling", TCLBoard2 + "/ao2");
            AddAnalogOutputChannel("eylsa", TCLBoard2 + "/ao3");

            AddAnalogOutputChannel("slowingChirp", aoBoard + "/ao8");

            AddAnalogOutputChannel("v00Intensity", aoBoard + "/ao9");
            AddAnalogOutputChannel("v00Frequency", aoBoard + "/ao12");

            AddAnalogOutputChannel("MOTCoilsCurrent", aoBoard + "/ao13");

            AddAnalogOutputChannel("xShimCoilCurrent", aoBoard + "/ao17");
            AddAnalogOutputChannel("yShimCoilCurrent", aoBoard + "/ao16");
            AddAnalogOutputChannel("zShimCoilCurrent", aoBoard + "/ao14");

            AddAnalogOutputChannel("slowingCoilsCurrent", aoBoard + "/ao18");

            //second cavity

            AddAnalogInputChannel("master2", TCLBoard2 + "/ai0", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("cavity2", TCLBoard2 + "/ai4", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("p12", TCLBoard2 + "/ai1", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("p22", TCLBoard2 + "/ai2", AITerminalConfiguration.Rse);
            AddAnalogOutputChannel("v21repump", TCLBoard2 + "/ao0");
            AddAnalogOutputChannel("v32repump", usbBoard + "/ao0", 0, 5);
            AddAnalogOutputChannel("rampfb2", TCLBoard2 + "/ao1");



            // map the counter channels
            AddCounterChannel("pmt", daqBoard + "/ctr0");
            AddCounterChannel("sample clock", daqBoard + "/ctr1");

            //map the monitoring source chamber in deceleration hardware
            // AddAnalogInputChannel("RoughVacuum", PXIBoard + "/ai0", AITerminalConfiguration.Rse);
            //  AddAnalogInputChannel("PressureSourceChamber", PXIBoard + "/ai1", AITerminalConfiguration.Rse);
            //  AddAnalogInputChannel("VoltageReference", PXIBoard + "/ai2", AITerminalConfiguration.Rse);
            //  AddAnalogInputChannel("10KThermistor30KPlate", PXIBoard + "/ai3", AITerminalConfiguration.Rse);
            //  AddAnalogInputChannel("30KShield", PXIBoard + "/ai4", AITerminalConfiguration.Rse);
            //  AddAnalogInputChannel("4KCell", PXIBoard + "/ai5", AITerminalConfiguration.Rse);

            //map the channels to monitor the sidebands in deceleration hardware
            AddAnalogInputChannel("cavityVoltage", usbBoard + "/ai0", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("mot606", usbBoard + "/ai1", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("mot628V1", usbBoard + "/ai2", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("mot628V2", usbBoard + "/ai3", AITerminalConfiguration.Rse);
            //AddAnalogInputChannel("mot628V3", usbBoard + "/ai4", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("slowing531", usbBoard + "/ai4", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("slowing628V1", usbBoard + "/ai7", AITerminalConfiguration.Rse);

            //analog output channels controlled by the hardware controller and/or MOTMaster
            AddAnalogOutputChannel("motAOMFreq", aoBoard + "/ao10");
            AddAnalogOutputChannel("v00EOMAmp", aoBoard + "/ao11");
            AddAnalogOutputChannel("triggerDelay", aoBoard + "/ao15");

            //   AddCalibration("freqToVoltage", new PolynomialCalibration(new double[] { -9.7727, 0.16604, -0.0000272 }, 70, 130)); //this is a quadratic fit to the manufacturer's data for a POS-150
            //AddCalibration("motAOMAmp", new PolynomialCalibration(new double[] {6.2871, -0.5907, -0.0706, -0.0088, -0.0004}, -12, 4)); // this is a polynomial fit (up to quartic) to measured behaviour
        }
Пример #5
0
        public PXIEDMHardware()
        {
            // add the boards
            Boards.Add("rfPulseGenerator", "PXI1Slot4");
            Boards.Add("daq", "/PXI1Slot18");
            Boards.Add("pg", "/PXI1Slot10");
            Boards.Add("counter", "/PXI1Slot16");
            Boards.Add("aoBoard", "/PXI1Slot2");
            // this drives the rf attenuators
            Boards.Add("usbDAQ1", "/Dev6");
            Boards.Add("analogIn", "/PXI1Slot15");
            Boards.Add("usbDAQ2", "/Dev1");
            Boards.Add("usbDAQ3", "/Dev2");
            Boards.Add("usbDAQ4", "/Dev5");
            Boards.Add("tclBoardPump", "/PXI1Slot17");
            Boards.Add("tclBoardProbe", "/PXI1Slot9");
            string rfPulseGenerator = (string)Boards["rfPulseGenerator"];
            string pgBoard          = (string)Boards["pg"];
            string daqBoard         = (string)Boards["daq"];
            string counterBoard     = (string)Boards["counter"];
            string aoBoard          = (string)Boards["aoBoard"];
            string usbDAQ1          = (string)Boards["usbDAQ1"];
            string analogIn         = (string)Boards["analogIn"];
            string usbDAQ2          = (string)Boards["usbDAQ2"];
            string usbDAQ3          = (string)Boards["usbDAQ3"];
            string usbDAQ4          = (string)Boards["usbDAQ4"];
            string tclBoardPump     = (string)Boards["tclBoardPump"];
            string tclBoardProbe    = (string)Boards["tclBoardProbe"];

            // add things to the info
            // the analog triggersf
            Info.Add("analogTrigger0", (string)Boards["analogIn"] + "/PFI0");
            Info.Add("analogTrigger1", (string)Boards["analogIn"] + "/PFI1");

            Info.Add("sourceToDetect", 1.3);
            Info.Add("moleculeMass", 193.0);
            Info.Add("machineLengthRatio", 3.842);
            Info.Add("defaultGate", new double[] { 2190, 80 });


            Info.Add("phaseLockControlMethod", "synth");
            Info.Add("PGClockLine", pgBoard + "/PFI4"); //Mapped to PFI2 on 6533 connector
            Info.Add("PatternGeneratorBoard", pgBoard);
            Info.Add("PGType", "dedicated");
            // rf counter switch control seq``
            Info.Add("IodineFreqMon", new bool[] { false, false });      // IN 1
            Info.Add("pumpAOMFreqMon", new bool[] { false, true });      // IN 2
            Info.Add("FLModulationFreqMon", new bool[] { true, false }); // IN 3

            Info.Add("PGTrigger", pgBoard + "/PFI5");                    //Mapped to PFI7 on 6533 connector

            // YAG laser
            yag = new BrilliantLaser("ASRL21::INSTR");

            // add the GPIB/RS232 instruments
            Instruments.Add("green", new HP8657ASynth("GPIB0::7::INSTR"));
            Instruments.Add("gigatronix", new Gigatronics7100Synth("GPIB0::19::INSTR"));
            Instruments.Add("red", new HP3325BSynth("GPIB0::12::INSTR"));
            Instruments.Add("4861", new ICS4861A("GPIB0::4::INSTR"));
            Instruments.Add("bCurrentMeter", new HP34401A("GPIB0::22::INSTR"));
            Instruments.Add("rfCounter", new Agilent53131A("GPIB0::3::INSTR"));
            //Instruments.Add("rfCounter2", new Agilent53131A("GPIB0::5::INSTR"));
            Instruments.Add("rfPower", new HP438A("GPIB0::13::INSTR"));
            Instruments.Add("BfieldController", new SerialDAQ("ASRL19::INSTR"));
            Instruments.Add("rfCounter2", new SerialAgilent53131A("ASRL17::INSTR"));
            Instruments.Add("probePolControl", new SerialMotorControllerBCD("ASRL8::INSTR"));
            Instruments.Add("pumpPolControl", new SerialMotorControllerBCD("ASRL11::INSTR"));


            // map the digital channels
            // these channels are generally switched by the pattern generator
            // they're all in the lower half of the pg
            AddDigitalOutputChannel("valve", pgBoard, 0, 0);
            AddDigitalOutputChannel("flash", pgBoard, 0, 1);
            AddDigitalOutputChannel("q", pgBoard, 0, 2);
            AddDigitalOutputChannel("detector", pgBoard, 0, 3);
            AddDigitalOutputChannel("detectorprime", pgBoard, 1, 2); // this trigger is for switch scanning
            // see ModulatedAnalogShotGatherer.cs
            // for details.
            AddDigitalOutputChannel("rfSwitch", pgBoard, 0, 4);
            AddDigitalOutputChannel("pumprfSwitch", pgBoard, 3, 4);
            AddDigitalOutputChannel("fmSelect", pgBoard, 1, 0);         // This line selects which fm voltage is
            // sent to the synth.
            AddDigitalOutputChannel("attenuatorSelect", pgBoard, 0, 5); // This line selects the attenuator voltage
            // sent to the voltage-controlled attenuator.
            AddDigitalOutputChannel("piFlip", pgBoard, 1, 1);
            AddDigitalOutputChannel("ttlSwitch", pgBoard, 1, 3);        // This is the output that the pg
            // will switch if it's switch scanning.
            AddDigitalOutputChannel("scramblerEnable", pgBoard, 1, 4);

            //RF Counter Control (single pole 4 throw)
            //AddDigitalOutputChannel("rfCountSwBit1", pgBoard, 3, 5);
            //AddDigitalOutputChannel("rfCountSwBit2", pgBoard, 3, 6);

            // new rf amp blanking
            AddDigitalOutputChannel("rfAmpBlanking", pgBoard, 1, 5);

            // these channel are usually software switched - they should not be in
            // the lower half of the pattern generator
            AddDigitalOutputChannel("b", pgBoard, 2, 0);
            AddDigitalOutputChannel("notB", pgBoard, 2, 1);
            AddDigitalOutputChannel("db", pgBoard, 2, 2);
            AddDigitalOutputChannel("notDB", pgBoard, 2, 3);
            //			AddDigitalOutputChannel("notEOnOff", pgBoard, 2, 4);  // this line seems to be broken on our pg board
            //          AddDigitalOutputChannel("eOnOff", pgBoard, 2, 5);  // this and the above are not used now we have analog E control

            AddDigitalOutputChannel("ePol", pgBoard, 2, 6);
            AddDigitalOutputChannel("notEPol", pgBoard, 2, 7);
            AddDigitalOutputChannel("eBleed", pgBoard, 3, 0);
            AddDigitalOutputChannel("eSwitching", aoBoard, 0, 3);
            AddDigitalOutputChannel("piFlipEnable", pgBoard, 3, 1);
            AddDigitalOutputChannel("notPIFlipEnable", pgBoard, 3, 5);
            AddDigitalOutputChannel("mwEnable", pgBoard, 3, 3);
            AddDigitalOutputChannel("mwSelectPumpChannel", pgBoard, 3, 6);
            AddDigitalOutputChannel("mwSelectTopProbeChannel", pgBoard, 3, 2);
            AddDigitalOutputChannel("mwSelectBottomProbeChannel", pgBoard, 2, 4);

            // these digitial outputs are are not switched during the pattern
            AddDigitalOutputChannel("argonShutter", aoBoard, 0, 0);
            AddDigitalOutputChannel("patternTTL", aoBoard, 0, 7);
            AddDigitalOutputChannel("rfPowerAndFreqSelectSwitch", aoBoard, 0, 1);
            AddDigitalOutputChannel("targetStepper", aoBoard, 0, 2);;


            // map the analog channels
            // These channels are on the daq board. Used mainly for diagnostic purposes.
            AddAnalogInputChannel("iodine", daqBoard + "/ai2", AITerminalConfiguration.Nrse);
            AddAnalogInputChannel("cavity", daqBoard + "/ai3", AITerminalConfiguration.Nrse);
            AddAnalogInputChannel("probePD", daqBoard + "/ai4", AITerminalConfiguration.Nrse);
            AddAnalogInputChannel("pumpPD", daqBoard + "/ai5", AITerminalConfiguration.Nrse);
            AddAnalogInputChannel("northLeakage", daqBoard + "/ai6", AITerminalConfiguration.Nrse);
            AddAnalogInputChannel("southLeakage", daqBoard + "/ai7", AITerminalConfiguration.Nrse);
            //AddAnalogInputChannel("northLeakage", usbDAQ4 + "/ai0", AITerminalConfiguration.Rse);
            //AddAnalogInputChannel("southLeakage", usbDAQ4 + "/ai1", AITerminalConfiguration.Rse);

            // Used ai13,11 & 12 over 6,7 & 8 for miniFluxgates, because ai8, 9 have an isolated ground.
            AddAnalogInputChannel("miniFlux1", daqBoard + "/ai13", AITerminalConfiguration.Nrse);
            AddAnalogInputChannel("miniFlux2", daqBoard + "/ai11", AITerminalConfiguration.Nrse);
            AddAnalogInputChannel("miniFlux3", daqBoard + "/ai12", AITerminalConfiguration.Nrse);
            AddAnalogInputChannel("ground", daqBoard + "/ai14", AITerminalConfiguration.Nrse);
            AddAnalogInputChannel("piMonitor", daqBoard + "/ai10", AITerminalConfiguration.Nrse);
            //AddAnalogInputChannel("diodeLaserRefCavity", daqBoard + "/ai13", AITerminalConfiguration.Nrse);
            // Don't use ai10, cross talk with other channels on this line

            // high quality analog inputs (will be) on the S-series analog in board
            // The last number in AddAnalogInputChannel is an optional calibration which turns VuS and MHz
            AddAnalogInputChannel("topProbe", analogIn + "/ai0", AITerminalConfiguration.Differential, 0.1);
            AddAnalogInputChannel("bottomProbe", analogIn + "/ai1", AITerminalConfiguration.Differential, 0.02);
            AddAnalogInputChannel("magnetometer", analogIn + "/ai2", AITerminalConfiguration.Differential);
            AddAnalogInputChannel("gnd", analogIn + "/ai3", AITerminalConfiguration.Differential);
            AddAnalogInputChannel("battery", analogIn + "/ai4", AITerminalConfiguration.Differential);
            //AddAnalogInputChannel("piMonitor", analogIn + "/ai5", AITerminalConfiguration.Differential);
            //AddAnalogInputChannel("bFieldCurrentMonitor", analogIn + "/ai6", AITerminalConfiguration.Differential);
            AddAnalogInputChannel("reflectedrf1Amplitude", analogIn + "/ai5", AITerminalConfiguration.Differential);
            AddAnalogInputChannel("reflectedrf2Amplitude", analogIn + "/ai6", AITerminalConfiguration.Differential);
            AddAnalogInputChannel("rfCurrent", analogIn + "/ai7 ", AITerminalConfiguration.Differential);

            AddAnalogOutputChannel("phaseScramblerVoltage", aoBoard + "/ao10");
            AddAnalogOutputChannel("b", aoBoard + "/ao2");


            // rf rack control
            //AddAnalogInputChannel("rfPower", usbDAQ1 + "/ai0", AITerminalConfiguration.Rse);

            AddAnalogOutputChannel("rf1Attenuator", usbDAQ1 + "/ao0", 0, 5);
            AddAnalogOutputChannel("rf2Attenuator", usbDAQ1 + "/ao1", 0, 5);
            AddAnalogOutputChannel("rf1FM", usbDAQ2 + "/ao0", 0, 5);
            AddAnalogOutputChannel("rf2FM", usbDAQ2 + "/ao1", 0, 5);

            // E field control and monitoring
            //AddAnalogInputChannel("cPlusMonitor", usbDAQ3 + "/ai1", AITerminalConfiguration.Differential);
            //AddAnalogInputChannel("cMinusMonitor", usbDAQ3 + "/ai2", AITerminalConfiguration.Differential);
            AddAnalogInputChannel("cPlusMonitor", daqBoard + "/ai0", AITerminalConfiguration.Differential);
            AddAnalogInputChannel("cMinusMonitor", daqBoard + "/ai1", AITerminalConfiguration.Differential);

            AddAnalogOutputChannel("cPlus", usbDAQ3 + "/ao0", 0, 10);
            AddAnalogOutputChannel("cMinus", usbDAQ3 + "/ao1", 0, 10);



            // B field control
            //AddAnalogOutputChannel("steppingBBias", usbDAQ4 + "/ao0", 0, 5);


            // map the counter channels
            AddCounterChannel("phaseLockOscillator", counterBoard + "/ctr7");
            AddCounterChannel("phaseLockReference", counterBoard + "/pfi10");
            //AddCounterChannel("northLeakage", counterBoard + "/ctr0");
            //AddCounterChannel("southLeakage", counterBoard + "/ctr1");


            // Cavity inputs for the cavity that controls the Pump lasers
            AddAnalogInputChannel("PumpCavityRampVoltage", tclBoardPump + "/ai8", AITerminalConfiguration.Rse); //tick
            AddAnalogInputChannel("Pumpmaster", tclBoardPump + "/ai1", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("Pumpp1", tclBoardPump + "/ai2", AITerminalConfiguration.Rse);
            AddAnalogInputChannel("Pumpp2", tclBoardPump + "/ai3", AITerminalConfiguration.Rse);

            // Lasers locked to pump cavity
            AddAnalogOutputChannel("KeopsysDiodeLaser", tclBoardPump + "/ao2", -4, 4); //tick
            AddAnalogOutputChannel("MenloPZT", tclBoardPump + "/ao0", 0, 10);          //tick

            // Length stabilisation for pump cavity
            AddAnalogOutputChannel("PumpCavityLengthVoltage", tclBoardPump + "/ao1", -10, 10); //tick

            //TCL configuration for pump cavity
            TCLConfig tcl1 = new TCLConfig("Pump Cavity");

            tcl1.AddLaser("MenloPZT", "Pumpp1");
            tcl1.AddLaser("KeopsysDiodeLaser", "Pumpp2");
            tcl1.Trigger           = tclBoardPump + "/PFI0";
            tcl1.Cavity            = "PumpCavityRampVoltage";
            tcl1.MasterLaser       = "Pumpmaster";
            tcl1.Ramp              = "PumpCavityLengthVoltage";
            tcl1.TCPChannel        = 1190;
            tcl1.AnalogSampleRate  = 61250;
            tcl1.DefaultScanPoints = 500;
            tcl1.MaximumNLMFSteps  = 20;
            tcl1.PointsToConsiderEitherSideOfPeakInFWHMs = 2.5;
            tcl1.TriggerOnRisingEdge = false;
            tcl1.AddFSRCalibration("MenloPZT", 3.84);
            tcl1.AddFSRCalibration("KeopsysDiodeLaser", 3.84);
            tcl1.AddDefaultGain("Master", 0.3);
            tcl1.AddDefaultGain("MenloPZT", -0.2);
            tcl1.AddDefaultGain("KeopsysDiodeLaser", 4);
            Info.Add("PumpCavity", tcl1);
            Info.Add("DefaultCavity", tcl1);

            // Probe cavity inputs
            AddAnalogInputChannel("ProbeRampVoltage", tclBoardProbe + "/ai0", AITerminalConfiguration.Rse); //tick
            AddAnalogInputChannel("Probemaster", tclBoardProbe + "/ai1", AITerminalConfiguration.Rse);      //tick
            AddAnalogInputChannel("Probep1", tclBoardProbe + "/ai2", AITerminalConfiguration.Rse);          //tick

            // Lasers locked to Probe cavity
            AddAnalogOutputChannel("TopticaSHGPZT", tclBoardProbe + "/ao0", -4, 4);              //tick
            AddAnalogOutputChannel("ProbeCavityLengthVoltage", tclBoardProbe + "/ao1", -10, 10); //tick

            // TCL configuration for Probe cavity
            TCLConfig tcl2 = new TCLConfig("Probe Cavity");

            tcl2.AddLaser("TopticaSHGPZT", "Probep1");
            tcl2.Trigger           = tclBoardProbe + "/PFI0";
            tcl2.Cavity            = "ProbeRampVoltage";
            tcl2.MasterLaser       = "Probemaster";
            tcl2.Ramp              = "ProbeCavityLengthVoltage";
            tcl2.TCPChannel        = 1191;
            tcl2.AnalogSampleRate  = 61250 / 2;
            tcl2.DefaultScanPoints = 250;
            tcl2.MaximumNLMFSteps  = 20;
            tcl2.PointsToConsiderEitherSideOfPeakInFWHMs = 12;
            tcl2.AddFSRCalibration("TopticaSHGPZT", 3.84);
            tcl2.TriggerOnRisingEdge = false;
            tcl2.AddDefaultGain("Master", 0.4);
            tcl2.AddDefaultGain("TopticaSHGPZT", 0.04);
            Info.Add("ProbeCavity", tcl2);
            //Info.Add("DefaultCavity", tcl2);


            // Obsolete Laser control
            AddAnalogOutputChannel("probeAOM", aoBoard + "/ao19", 0, 10);
            AddAnalogOutputChannel("pumpAOM", aoBoard + "/ao20", 0, 10);
            AddAnalogOutputChannel("fibreAmpPwr", aoBoard + "/ao3");
            AddAnalogOutputChannel("I2LockBias", aoBoard + "/ao5", 0, 5);

            //Microwave Control Channels
            AddAnalogOutputChannel("uWaveDCFM", aoBoard + "/ao11", -2.5, 2.5);
            //AddAnalogOutputChannel("uWaveMixerV", aoBoard + "/ao12", 0, 10);
            AddAnalogOutputChannel("pumpMixerV", aoBoard + "/ao19", 0, 5);
            AddAnalogOutputChannel("bottomProbeMixerV", aoBoard + "/ao24", 0, 5);
            AddAnalogOutputChannel("topProbeMixerV", aoBoard + "/ao25", 0, 5);



            //RF control Channels
            AddAnalogOutputChannel("VCO161Amp", aoBoard + "/ao13", 0, 10);
            AddAnalogOutputChannel("VCO161Freq", aoBoard + "/ao14", 0, 10);
            AddAnalogOutputChannel("VCO30Amp", aoBoard + "/ao15", 0, 10);
            AddAnalogOutputChannel("VCO30Freq", aoBoard + "/ao16", 0, 10);
            AddAnalogOutputChannel("VCO155Amp", aoBoard + "/ao17", 0, 10);
            AddAnalogOutputChannel("VCO155Freq", aoBoard + "/ao18", 0, 10);
        }
Пример #6
0
        public SympatheticHardware()
        {
            // YAG laser
            yag = new QuantaRayLaser();

            // add the boards
            Boards.Add("daq", "/dev2");
            Boards.Add("pg", "/dev1");
            Boards.Add("usbDAQ2", "/dev3");
            Boards.Add("TCLAIBoard", "/dev4");
            //Boards.Add("usbDAQ1", "/dev4");
            string pgBoard  = (string)Boards["pg"];
            string daqBoard = (string)Boards["daq"];
            string usbDAQ1  = (string)Boards["usbDAQ1"];
            string usbDAQ2  = (string)Boards["usbDAQ2"];
            string TCLBoard = (string)Boards["TCLAIBoard"];

            // add things to the info
            Info.Add("PGClockLine", Boards["pg"] + "/PFI2");
            Info.Add("PatternGeneratorBoard", pgBoard);
            Info.Add("PGType", "dedicated");

            // the analog triggers
            Info.Add("analogTrigger0", (string)Boards["daq"] + "/PFI0"); //DAQ Pin 11
            Info.Add("analogTrigger1", (string)Boards["daq"] + "/PFI1"); //DAQ Pin 10
            //Info.Add("analogTrigger2", (string)Boards["daq"] + "/PFI5"); //DAQ Pin 6
            //Info.Add("analogTrigger2", (string)Boards["usbDAQ2"] + "/PFI0");
            Info.Add("analogTrigger2", TCLBoard + "/PFI0");
            //Info.Add("analogTrigger2", (string)Boards["daq"] + "/PFI1"); //DAQ Pin 10
            //distance information
            Info.Add("sourceToDetect", 0.787);
            Info.Add("sourceToSoftwareDecelerator", 0.123);
            //information about the molecule
            Info.Add("moleculeMass", 8.024);                                                                 //this is 7LiH in amu
            Info.Add("moleculeRotationalConstant", 2.22545E11);                                              //in Hz
            Info.Add("moleculeDipoleMoment", 29600.0);                                                       //in Hz/(V/m)
            //information about the decelerator
            Info.Add("deceleratorStructure", DecelerationConfig.DecelerationExperiment.SwitchStructure.H_V); //Horizontal first
            Info.Add("deceleratorLensSpacing", 0.006);
            Info.Add("deceleratorFieldMap", "RodLayout3_EonAxis.dat");
            Info.Add("mapPoints", 121);
            Info.Add("mapStartPoint", 0.0);
            Info.Add("mapResolution", 0.0001);

            // TCL configuration
            TCLConfig tcl1 = new TCLConfig("Hamish McCavity");

            tcl1.AddLaser("laser", "p1");
            tcl1.Trigger     = TCLBoard + "/PFI0";
            tcl1.Cavity      = "cavity";
            tcl1.MasterLaser = "master";
            tcl1.Ramp        = "rampfb";
            tcl1.TCPChannel  = 1190;
            Info.Add("Hamish", tcl1);
            Info.Add("DefaultCavity", tcl1);

            //TCL Lockable lasers - I'm not yet sure whether these settings are redundant for the SympatheticHardware - may be using an old version of TransferCavityLock??
            Info.Add("TCLLockableLasers", new string[] { "laser" });
            Info.Add("TCLPhotodiodes", new string[] { "cavity", "master", "p1" }); // THE FIRST TWO MUST BE CAVITY AND MASTER PHOTODIODE!!!!
            Info.Add("TCL_Slave_Voltage_Limit_Upper", 10.0);                       //volts: Laser control
            Info.Add("TCL_Slave_Voltage_Limit_Lower", -10.0);                      //volts: Laser control
            Info.Add("TCL_Default_Gain", 0.5);
            Info.Add("TCL_Default_VoltageToLaser", 0.0);
            Info.Add("TCL_MAX_INPUT_VOLTAGE", 10.0);

            // map the GPIB instruments
            Instruments.Add("microwave", new EIP578Synth("GPIB0::19::INSTR"));
            Instruments.Add("agilent", new Agilent33250Synth("GPIB0::10::INSTR"));
            Instruments.Add("gigatronics", new Gigatronics7100Synth("GPIB0::6::INSTR"));

            // map the digital channels
            // these channels are to be part of the "PatternList" and shoud all be on the low half of the board
            AddDigitalOutputChannel("valve", pgBoard, 0, 0);             //Pin 10
            AddDigitalOutputChannel("flash", pgBoard, 0, 1);             //Pin 44
            AddDigitalOutputChannel("valve2", pgBoard, 0, 1);
            AddDigitalOutputChannel("discharge", pgBoard, 0, 3);
            AddDigitalOutputChannel("q", pgBoard, 0, 2);                //Pin 45
            AddDigitalOutputChannel("detector", pgBoard, 0, 7);         //Pin 15
            AddDigitalOutputChannel("detectorprime", pgBoard, 1, 7);    //Pin 22
            //	AddDigitalOutputChannel("fig", pgBoard, 3, 1); //Pin 63
            AddDigitalOutputChannel("aom", pgBoard, 0, 4);              //Pin 13
            AddDigitalOutputChannel("flash2", pgBoard, 0, 5);           //Pin 47
            AddDigitalOutputChannel("q2", pgBoard, 0, 6);               //Pin 48
            AddDigitalOutputChannel("cavityTriggerOut", usbDAQ2, 0, 1); //Pin 17
            // the following are the decelerator channels for the burst
            AddDigitalOutputChannel("decelhplus", pgBoard, 1, 0);       //Pin 16
            AddDigitalOutputChannel("decelhminus", pgBoard, 1, 1);      //Pin 17
            AddDigitalOutputChannel("decelvplus", pgBoard, 1, 2);       //Pin 51
            AddDigitalOutputChannel("decelvminus", pgBoard, 1, 3);      //Pin 52
            AddDigitalOutputChannel("SynthTrigger", pgBoard, 0, 3);     //Pin 48

            // these channels are to be switched "manually" and should all be on the high half of the board
            // the following set of switches are used to enable or disable the burst
            AddDigitalOutputChannel("hplusBurstEnable", pgBoard, 2, 0);
            AddDigitalOutputChannel("hminusBurstEnable", pgBoard, 3, 4);
            AddDigitalOutputChannel("vplusBurstEnable", pgBoard, 2, 2);
            AddDigitalOutputChannel("vminusBurstEnable", pgBoard, 2, 3);
            // the following set of switches are used for dc on or off
            AddDigitalOutputChannel("hplusdc", pgBoard, 2, 4);
            AddDigitalOutputChannel("hminusdc", pgBoard, 2, 5);
            AddDigitalOutputChannel("vplusdc", pgBoard, 2, 6);
            AddDigitalOutputChannel("vminusdc", pgBoard, 3, 3);


            // map the analog input channels
            AddAnalogInputChannel("pmt", daqBoard + "/ai0", AITerminalConfiguration.Rse);             //Pin 68
            //AddAnalogInputChannel("p1", daqBoard + "/ai7", AITerminalConfiguration.Rse);//Pin 57
            //AddAnalogInputChannel("p2", daqBoard + "/ai14", AITerminalConfiguration.Rse);//Pin 58
            //AddAnalogInputChannel("cavityVoltageRead", daqBoard + "/ai12", AITerminalConfiguration.Rse); //Pin 61

            //AddAnalogInputChannel("p1", usbDAQ2 + "/ai0", AITerminalConfiguration.Rse);//Pin 2
            //AddAnalogInputChannel("p2", usbDAQ2 + "/ai1", AITerminalConfiguration.Rse);//Pin 5
            //AddAnalogInputChannel("cavityVoltageRead", usbDAQ2 + "/ai2", AITerminalConfiguration.Rse); //Pin 8
            AddAnalogInputChannel("p1", TCLBoard + "/ai0", AITerminalConfiguration.Rse);                          //Pin 2
            AddAnalogInputChannel("p2", TCLBoard + "/ai1", AITerminalConfiguration.Rse);                          //Pin 5
            AddAnalogInputChannel("cavityVoltageRead", TCLBoard + "/ai2", AITerminalConfiguration.Rse);           //Pin 8

            AddAnalogInputChannel("lockcavity", daqBoard + "/ai1", AITerminalConfiguration.Rse);                  //Pin 33
            AddAnalogInputChannel("probepower", daqBoard + "/ai9", AITerminalConfiguration.Rse);                  //Pin 66
            //AddAnalogInputChannel("refcavity", daqBoard + "/ai2", AITerminalConfiguration.Rse); //Pin 65
            AddAnalogInputChannel("pressureP1", daqBoard + "/ai2", AITerminalConfiguration.Rse);                  //Pin 65
            AddAnalogInputChannel("fig", daqBoard + "/ai5", AITerminalConfiguration.Rse);                         //Pin 60
            AddAnalogInputChannel("atomSourcePressure1", usbDAQ1 + "/ai0", AITerminalConfiguration.Differential); //ai0+ is pin 2, ai0- is pin 3
            AddAnalogInputChannel("atomSourcePressure2", usbDAQ1 + "/ai1", AITerminalConfiguration.Differential); //ai1+ is pin 5, ai1- is pin 6

            //map the analog output channels
            AddAnalogOutputChannel("laser", daqBoard + "/ao0");       // Pin 22
            // AddAnalogOutputChannel("dyelaser", daqBoard + "/ao1",-5,5); // Pin 21
            AddAnalogOutputChannel("highvoltage", daqBoard + "/ao1"); // Note - this is just here because a channel called "highvoltage" has been hard-wired into DecelerationHardwareControl - this needs to be rectified
            AddAnalogOutputChannel("cavity", daqBoard + "/ao1");      // Pin 21
            //AddAnalogOutputChannel("cavity", usbDAQ2 + "/ao0"); // Pin 14

            // map the counter channels
            AddCounterChannel("pmt", daqBoard + "/ctr0");          //Source is pin 37, gate is pin 3, out is pin 2
            AddCounterChannel("sample clock", daqBoard + "/ctr1"); //Source is pin 42, gate is pin 41, out is pin 40
        }