public Move GetMove(Boards boards, int searchDepth)
{
if (boards.moves.Count == 0)
throw (null);
int best = -1000000, bestIndex = -1;
List<MoveRating> moveRatings = new List<MoveRating>();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
for (int i = 0; i < boards.moves.Count; ++i)
{
int score = -NegaMax(CopyAndMove(boards, boards.moves[i]),
searchDepth, -1000000, 1000000);
if (score >= best) {
best = score;
bestIndex = i;
moveRatings.Add(new MoveRating(boards.moves[bestIndex],best));
}
}
moveRatings.RemoveAll(delegate(MoveRating mr) {
return mr.rating != best; });
stopwatch.Stop();
if (stopwatch.ElapsedMilliseconds < 750)
System.Threading.Thread.Sleep(500);
return moveRatings[new Random().Next(0,moveRatings.Count)].move;
}
private int NegaMax(Boards boards, int depth, int alpha, int beta)
{
int bigBoardRating = boards.GetWinner(9);
if (bigBoardRating == Game.DRAW)
return 0;
if (bigBoardRating == Game.X)
return 100000 * (boards.turn ? -1 : 1);
if (bigBoardRating == Game.O)
return -100000 * (boards.turn ? -1 : 1);
if (depth == 0)
return Eval(boards) * (boards.turn ? -1 : 1);
int best = -1000000;
foreach (Move m in boards.moves)
{
int score = -NegaMax(CopyAndMove(boards, m),
depth - 1, -beta, -alpha);
if (score > best)
best = score;
if (best > alpha)
alpha = best;
if (alpha >= beta)
return alpha;
}
return best;
}
public HttpResponseMessage DeleteBoard(string deviceJson)
{
if (ModelState.IsValid)
{
var boards = new Boards();
var result = boards.DeleteBoard(deviceJson);
}
return new HttpResponseMessage(HttpStatusCode.BadRequest);
}
private int Eval(Boards boards)
{
int rating = 0;
for (int i = 0; i < 9; ++i)
{
rating += (int)HashTables.boardRatings[boards.smallboards[i]];
}
return rating + ((int)HashTables.boardRatings
[boards.smallboards[9]] * 10);
}
private Boards CopyAndMove(Boards boards, Move move)
{
Boards newBoards = new Boards(boards);
newBoards.SetTile_Small(move);
if (newBoards.GetWinner(move.board) != Game.EMPTY)
newBoards.SetTile_Big(move.board);
newBoards.lastmove = newBoards.GetWinner(move.tile)
== Game.EMPTY ? move.tile : -1;
newBoards.FillMoves();
return newBoards;
}
/// <summary>
/// Create new Board Device
/// </summary>
/// <param name="board">Board Device Info</param>
/// <returns>HttpResponseMessage</returns>
public HttpResponseMessage PostBoard(BoardDevice board)
{
if (ModelState.IsValid)
{
var boards = new Boards();
var result = boards.SaveBoard(board);
if (result)
{
return new HttpResponseMessage(HttpStatusCode.OK);
}
}
return new HttpResponseMessage(HttpStatusCode.BadRequest);
}
// Initialize Boards Config
public bool GetInitializeBoards()
{
try
{
var board = new Boards();
board.InitTypeBoards();
board.InitBoards();
}
catch (Exception)
{
return false;
}
return true;
}
public IActionResult SumbitBoardForm(Boards model)
{
if (!ModelState.IsValid) //not valid
{
return RedirectToAction("Index");
}
//var query = from board in m_context.Boards where board.Name.Equals(model.Name) select board;
var boards = m_context.Boards.ToList();
foreach (var boardModel in boards)
{
if (boardModel.Name == model.Name)
{
return RedirectToAction("Load", "Board", new { p_BoardID = boardModel.ID}); // Board Found
}
}
//model.ID = boards.Count + 1;
TempData["BoardName"] = model.Name;
//TempData["BoardID"] = model.ID;
return RedirectToAction("Create", "Board", new { p_BoardID = boards.Count + 1} );
}
public IActionResult Create(int p_BoardID)
{
string boardName = "";
try
{
boardName = (string) TempData["BoardName"];
}
catch (Exception e)
{
}
//int boardID = (int) TempData["BoardID"];
var boards = m_context.Boards.ToList();
if (boards.Count == p_BoardID)
{
return RedirectToAction("Load", "Board", new { p_BoardID = boards.Count });
}
m_Board = new Boards(boardName);
m_context.Boards.Add(m_Board);
m_context.SaveChanges();
return View("Show", m_Board);
}
public IActionResult Load(int p_BoardID)
{
var boardList = m_context.Boards.ToList();
foreach (Boards b in boardList)
{
if (b.ID == p_BoardID)
{
m_Board = b;
m_Board.ColumnList = new List<Columns>();
break;
}
}
if (m_Board == null)
{
return NotFound();
}
var columnList = m_context.Columns.ToList();
var taskList = m_context.Tasks.ToList();
var labelList = m_context.Labels.ToList();
var commentList = m_context.Comments.ToList();
foreach (Columns c in columnList)
{
if (c.BoardID == m_Board.ID)
{
c.TasksList = new List<Tasks>();
foreach (Tasks t in taskList)
{
if (t.ColumnName == c.Name)
{
/*
t.LabelList = new List<Labels>();
t.CommentList = new List<Comments>();
foreach (Labels label in labelList)
{
if (t.ID == label.TaskID)
{
t.LabelList.Add(label);
}
}
foreach (var comment in commentList)
{
if (t.ID == comment.TaskID)
{
t.CommentList.Add(comment);
}
}
*/
c.TasksList.Add(t);
}
}
m_Board.ColumnList.Add(c);
//c.ParentBoard = m_Board;
}
}
return View("Show", m_Board);
}
public ActionResult Index(SnowboardModel sbModel)
{
Response.Write("Method: POST <br>");
if (sbModel.DiscountSenior && sbModel.DiscountStudent)
{
ModelState.AddModelError("Discounts", "You annot have both student and senior discounts.");
}
// return to view if any feilds are invalid
if (!ModelState.IsValid)
{
return(View(sbModel));
}
// new custOrder object
CustomerOrderModel custOrder = new CustomerOrderModel();
// find board model
Boards boardModel = ListBoardsViewModel.BoardList.Find(m => m.ModelId == sbModel.ModelID);
// assign model name from boardModel to CustOrder
custOrder.ModelName = boardModel.ModelName;
// assign model price from boardModel to CustOrder
custOrder.ModelPrice = boardModel.Price;
// get surcharge from experiences list model
Experience expModel = ListExperienceViewModel.ExperienceLevel.Find(m => m.Level == sbModel.ExperienceLevel);
// get experieince surcharge percentage
custOrder.ExperienceSurchargePercent = expModel.Surcharge;
// calculate the surcharge
custOrder.ExperienceSurchargeDollars = custOrder.ModelPrice * (1 + expModel.Surcharge);
// check for discounts
if (sbModel.DiscountStudent)
{
custOrder.DiscountsTaken += "student, ";
custOrder.DiscountsPercent += 0.1;
}
if (sbModel.DiscountSenior)
{
custOrder.DiscountsTaken += "senior, ";
custOrder.DiscountsPercent += 0.05;
}
if (sbModel.DiscountGoldClub)
{
custOrder.DiscountsTaken += "gold club, ";
custOrder.DiscountsPercent += 0.08;
}
// trim list of discounts
if (custOrder.DiscountsTaken != null)
{
custOrder.DiscountsTaken = custOrder.DiscountsTaken.TrimEnd(',', ' ');
}
// get discount dollar amount
custOrder.DiscountDollars = custOrder.ModelPrice * custOrder.DiscountsPercent;
// calculate subtotal
custOrder.Subtotal = custOrder.ExperienceSurchargeDollars * (1 + custOrder.DiscountsPercent);
// get tax rate
State stateTax = ListStatesViewModel.StateList.Find(m => m.StateAbbr == sbModel.State);
// get tax rate
custOrder.TaxPercent = stateTax.TaxRate;
// get the tax dollar amount
custOrder.TaxDollars = custOrder.Subtotal * custOrder.TaxPercent;
// calculate total price
custOrder.TotalPrice = custOrder.Subtotal * (1 + stateTax.TaxRate);
return(View("OrderConfirmation", custOrder));
}
public NAND(Boards.IBoard board)
: base(board)
{
NANDInformation = new NANDInfo();
}
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("shutter1", pgBoard, 1, 3); //
AddDigitalOutputChannel("shutter2", pgBoard, 1, 4); //
AddDigitalOutputChannel("flash", pgBoard, 0, 2); //Pin 45
AddDigitalOutputChannel("chirpTrigger", pgBoard, 0, 3);
//(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 input 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
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 + "/ai0", AITerminalConfiguration.Rse);
AddAnalogInputChannel("VIScavityRampMonitor", TCLBoard2 + "/ai1", AITerminalConfiguration.Rse);
AddAnalogInputChannel("VISp1", TCLBoard2 + "/ai2", AITerminalConfiguration.Rse);
AddAnalogInputChannel("VISp2", TCLBoard2 + "/ai3", AITerminalConfiguration.Rse);
AddAnalogInputChannel("VISp3", TCLBoard2 + "/ai16", AITerminalConfiguration.Rse);
// map the analog output channels
AddAnalogOutputChannel("phaseLockAnalogOutput", daqBoard + "/ao1"); //pin 21
AddAnalogOutputChannel("v0laser", TCLBoard + "/ao1");
AddAnalogOutputChannel("v2laser", TCLBoard + "/ao2");
AddAnalogOutputChannel("laser", daqBoard + "/ao0");//Pin 22
AddAnalogOutputChannel("rampfb", TCLBoard + "/ao0");
AddAnalogOutputChannel("v1laser", TCLBoard2 + "/ao1", 0, 10);
AddAnalogOutputChannel("VISrampfb", TCLBoard2 + "/ao0");
AddAnalogOutputChannel("probelaser", TCLBoard2 + "/ao2", 0, 10);
AddAnalogOutputChannel("v3laser", TCLBoard2 + "/ao3", 0, 10);
// TCL, we can now put many cavities in a single instance of TCL (thanks to Luke)
// multiple cavities share a single ramp (BaseRamp analog input) + trigger
// Hardware limitation that all read photodiode/ramp signals must share the same hardware card (hardware configured triggered read)
TCLConfig tclConfig = new TCLConfig("TCL");
tclConfig.Trigger = TCLBoard2 + "/PFI0"; // probe card atm
tclConfig.BaseRamp = "VIScavityRampMonitor";
tclConfig.TCPChannel = 1190;
tclConfig.DefaultScanPoints = 600;
tclConfig.AnalogSampleRate = 15000;
tclConfig.SlaveVoltageLowerLimit = 0.0;
tclConfig.SlaveVoltageUpperLimit = 10.0;
tclConfig.PointsToConsiderEitherSideOfPeakInFWHMs = 4;
tclConfig.MaximumNLMFSteps = 20;
/*
* string IRCavity = "IRCavity";
* tclConfig.AddCavity(IRCavity);
* tclConfig.Cavities[IRCavity].RampOffset = "rampfb";
* tclConfig.Cavities[IRCavity].MasterLaser = "master";
* tclConfig.Cavities[IRCavity].AddDefaultGain("master", 0.4);
* tclConfig.Cavities[IRCavity].AddSlaveLaser("v0laser", "p1");
* tclConfig.Cavities[IRCavity].AddDefaultGain("v0laser", 0.04);
* tclConfig.Cavities[IRCavity].AddFSRCalibration("v0laser", 3.84);
* tclConfig.Cavities[IRCavity].AddSlaveLaser("v2laser", "p2");
* tclConfig.Cavities[IRCavity].AddDefaultGain("v2laser", 0.04);
* tclConfig.Cavities[IRCavity].AddFSRCalibration("v2laser", 3.84);
*/
string VISCavity = "VISCavity";
tclConfig.AddCavity(VISCavity);
tclConfig.Cavities[VISCavity].RampOffset = "VISrampfb";
tclConfig.Cavities[VISCavity].MasterLaser = "VISmaster";
tclConfig.Cavities[VISCavity].AddDefaultGain("VISmaster", 0.4);
tclConfig.Cavities[VISCavity].AddSlaveLaser("v1laser", "VISp1");
tclConfig.Cavities[VISCavity].AddDefaultGain("v1laser", 0.04);
tclConfig.Cavities[VISCavity].AddFSRCalibration("v1laser", 3.84);
tclConfig.Cavities[VISCavity].AddSlaveLaser("probelaser", "VISp2");
tclConfig.Cavities[VISCavity].AddDefaultGain("probelaser", 0.04);
tclConfig.Cavities[VISCavity].AddFSRCalibration("probelaser", 3.84);
tclConfig.Cavities[VISCavity].AddSlaveLaser("v3laser", "VISp3");
tclConfig.Cavities[VISCavity].AddDefaultGain("v3laser", 0.04);
tclConfig.Cavities[VISCavity].AddFSRCalibration("v3laser", 3.84);
Info.Add("TCLConfig", tclConfig);
/*
* // OLD TCL SETUP, one configuration/instance of TCL per cavity
* //TransferCavityLock info
* TCLConfig tcl1 = new TCLConfig("IR Cavity");
* tcl1.AddLaser("v0laser", "p1");
* tcl1.AddLaser("v2laser", "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.AnalogSampleRate = 15000;
* // tcl1.DefaultScanPoints = 600;
* Info.Add("IR", tcl1);
*
* //TransferCavityLock info
* TCLConfig tcl2 = new TCLConfig("VIS Cavity");
* tcl2.AddLaser("v1laser", "VISp1");
* tcl2.AddLaser("probelaser", "VISp2");
* tcl2.AddLaser("v3laser", "VISp3");
* 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);
*
*/
//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
}
private void OnLoad()
{
try
{
var messageTypes = new[] { MessageTypes.Time, ExtendedMessageTypes.Clearing };
var token = _cancellationToken.Token;
while (!token.IsCancellationRequested)
{
_syncRoot.WaitSignal();
_messageQueue.Clear();
_messageQueue.Open();
_isInitialized = true;
_isChanged = false;
_moveNextSyncRoot.PulseSignal();
foreach (var action in _actions.CopyAndClear())
{
if (action.Item2)
{
_basketStorage.InnerStorages.Add(action.Item1);
}
else
{
_basketStorage.InnerStorages.Remove(action.Item1);
}
}
var boards = Boards.ToArray();
var loadDate = _currentTime != DateTimeOffset.MinValue ? _currentTime.Date : StartDate;
var startTime = _currentTime;
while (loadDate.Date <= StopDate.Date && !_isChanged && !token.IsCancellationRequested)
{
if (boards.Length == 0 || boards.Any(b => b.IsTradeDate(loadDate, true)))
{
this.AddInfoLog("Loading {0}", loadDate.Date);
var messages = _basketStorage.Load(loadDate.UtcDateTime.Date);
// storage for the specified date contains only time messages and clearing events
var noData = !messages.DataTypes.Except(messageTypes).Any();
if (noData)
{
EnqueueMessages(loadDate, startTime, token, GetSimpleTimeLine(loadDate));
}
else
{
EnqueueMessages(loadDate, startTime, token, messages);
}
}
loadDate = loadDate.Date.AddDays(1).ApplyTimeZone(loadDate.Offset);
}
if (!_isChanged)
{
EnqueueMessage(new LastMessage {
LocalTime = StopDate
});
}
_isInitialized = false;
}
}
catch (Exception ex)
{
EnqueueMessage(ex.ToErrorMessage());
EnqueueMessage(new LastMessage {
IsError = true
});
}
}
public PXIEDMHardware()
{
// add the boards
Boards.Add("daq", "/PXI1Slot18");
Boards.Add("pg", "/PXI1Slot10");
Boards.Add("counter", "/PXI1Slot3");
Boards.Add("aoBoard", "/PXI1Slot4");
// this drives the rf attenuators
Boards.Add("usbDAQ1", "/Dev2");
Boards.Add("analogIn", "/PXI1Slot2");
Boards.Add("usbDAQ2", "/dev1");
Boards.Add("usbDAQ3", "/dev4");
Boards.Add("usbDAQ4", "/dev3");
Boards.Add("tclBoard", "/PXI1Slot9");
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 tclBoard = (string)Boards["tclBoard"];
// add things to the info
// the analog triggers
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("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("ASRL2::INSTR");
// add the GPIB/RS232 instruments
Instruments.Add("green", new HP8657ASynth("GPIB0::7::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("ASRL12::INSTR"));
Instruments.Add("rfCounter2", new SerialAgilent53131A("ASRL8::INSTR"));
Instruments.Add("probePolControl", new SerialMotorControllerBCD("ASRL5::INSTR"));
Instruments.Add("pumpPolControl", new SerialMotorControllerBCD("ASRL3::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("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("targetStepper", pgBoard, 2, 5);
AddDigitalOutputChannel("ePol", pgBoard, 2, 6);
AddDigitalOutputChannel("notEPol", pgBoard, 2, 7);
AddDigitalOutputChannel("eBleed", pgBoard, 3, 0);
AddDigitalOutputChannel("piFlipEnable", pgBoard, 3, 1);
AddDigitalOutputChannel("notPIFlipEnable", pgBoard, 3, 5);
AddDigitalOutputChannel("pumpShutter", pgBoard, 3, 3);
AddDigitalOutputChannel("probeShutter", pgBoard, 3, 4);
AddDigitalOutputChannel("argonShutter", pgBoard, 3, 2);// (3,6) & (3,7) are dead.
AddDigitalOutputChannel("fibreAmpEnable", aoBoard, 0, 0);
// Map the digital input channels
AddDigitalInputChannel("fibreAmpMasterErr", aoBoard, 0, 1);
AddDigitalInputChannel("fibreAmpSeedErr", aoBoard, 0, 2);
AddDigitalInputChannel("fibreAmpBackFeflectErr", aoBoard, 0, 3);
AddDigitalInputChannel("fibreAmpTempErr", aoBoard, 0, 4);
AddDigitalInputChannel("fibreAmpPowerSupplyErr", aoBoard, 0, 5);
// map the analog channels
// These channels are on the daq board. Used mainly for diagnostic purposes.
// On no account should they switch during the edm acquisition pattern.
AddAnalogInputChannel("diodeLaserCurrent", daqBoard + "/ai0", AITerminalConfiguration.Differential);
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);
// 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("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
AddAnalogInputChannel("top", analogIn + "/ai0", AITerminalConfiguration.Differential);
AddAnalogInputChannel("norm", analogIn + "/ai1", AITerminalConfiguration.Differential);
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 + "/ao0");
AddAnalogOutputChannel("b", aoBoard + "/ao1");
// 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);
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");
//TCL Lockable lasers
//Info.Add("TCLLockableLasers", new string[][] { new string[] { "flPZT2" }, /*new string[] { "flPZT2Temp" },*/ new string[] { "fibreAOM", "flPZT2Temp" } });
Info.Add("TCLLockableLasers", new string[] { "flPZT2" }); //, new string[] { "flPZT2Temp" }, new string[] { "fibreAOM"} });
Info.Add("TCLPhotodiodes", new string[] { "transCavV", "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", 0.0); //volts: Laser control
Info.Add("TCL_Default_Gain", -1.1);
//Info.Add("TCL_Default_ScanPoints", 250);
Info.Add("TCL_Default_VoltageToLaser", 2.5);
Info.Add("TCL_Default_VoltageToDependent", 1.0);
// Some matching up for TCL
Info.Add("flPZT2", "p1");
Info.Add("flPZT2Temp", "p1");
//Info.Add("fibreAOM", "p1");
Info.Add("TCLTrigger", tclBoard + "/PFI0");
Info.Add("TCL_MAX_INPUT_VOLTAGE", 10.0);
AddAnalogInputChannel("transCavV", tclBoard + "/ai0", AITerminalConfiguration.Rse);
AddAnalogInputChannel("master", tclBoard + "/ai1", AITerminalConfiguration.Rse);
AddAnalogInputChannel("p1", tclBoard + "/ai2", AITerminalConfiguration.Rse);
// Laser control
//AddAnalogOutputChannel("flPZT", usbDAQ4 + "/ao1", 0, 5);
AddAnalogOutputChannel("flPZT", aoBoard + "/ao7", 0, 10);
AddAnalogOutputChannel("flPZT2", aoBoard + "/ao2", 0, 5);
AddAnalogOutputChannel("fibreAmpPwr", aoBoard + "/ao3");
//AddAnalogOutputChannel("pumpAOM", aoBoard + "/ao4", 0, 10);
AddAnalogOutputChannel("pumpAOM", usbDAQ4 + "/ao0", 0, 5);
AddAnalogOutputChannel("flPZT2Temp", aoBoard + "/ao5", 0, 4); //voltage must not exceed 4V for Koheras laser
AddAnalogOutputChannel("flPZT2Cur", aoBoard + "/ao6", 0, 5); //voltage must not exceed 5V for Koheras laser
//AddAnalogOutputChannel("fibreAOM", usbDAQ4 + "/ao1", 0, 5);
AddAnalogOutputChannel("rampfb", aoBoard + "/ao4", -10, 10);
}
public IEnumerable <TrelloBoard> GetBoardsByOrganization(string idOrganization)
{
return(Boards.Where(x => x.IdOrganization == idOrganization));
}
public ActionResult <Boards> Update(int id, [FromBody] Boards newDetails)
{
context.Entry(newDetails).State = EntityState.Modified;
context.SaveChanges();
return(newDetails);
}
public ActionResult <Boards> InsertData([FromBody] Boards insertion)
{
context.Boards.Add(insertion);
context.SaveChanges();
return(insertion);
}
public HomeViewModel()
{
_boards = new ObservableCollection <Board>();
Boards = CollectionViewSource.GetDefaultView(_boards);
Boards.CurrentChanged += (sender, args) =>
{
_deleteBoard.RaiseCanExecuteChanged();
_cloneBoard.RaiseCanExecuteChanged();
if (Boards.CurrentItem == null)
{
Hexes = null;
}
else
{
var currentBoard = GetCurrentBoard();
Hexes = CollectionViewSource.GetDefaultView(currentBoard.Hexes);
}
if (Hexes != null)
{
Hexes.CurrentChanged -= Hexes_CurrentChanged;
Hexes.CurrentChanged += Hexes_CurrentChanged;
}
};
_load = new DelegateCommand(
canExecute: () => true,
action: () =>
{
var dlg = new Microsoft.Win32.OpenFileDialog
{
FileName = _defaultTestFileName,
DefaultExt = ".json",
Filter = "JSON documents (.json)|*.json"
};
var result = dlg.ShowDialog();
if (result == true)
{
string filename = dlg.FileName;
var jsonText = File.ReadAllText(filename);
var loadedBoards = JsonConvert.DeserializeObject <List <Board> >(jsonText);
_boards.Clear();
foreach (var b in _boards)
{
_boards.Remove(b);
}
foreach (var b in loadedBoards)
{
_boards.Add(b);
}
if (_boards.Count > 0)
{
Boards.MoveCurrentToFirst();
}
}
});
_save = new DelegateCommand(
canExecute: () => true,
action: () =>
{
var dlg = new Microsoft.Win32.SaveFileDialog
{
FileName = _defaultTestFileName,
DefaultExt = ".json",
Filter = "JSON documents (.json)|*.json"
};
var result = dlg.ShowDialog();
if (result == true)
{
string filename = dlg.FileName;
File.WriteAllText(dlg.FileName, JsonConvert.SerializeObject(
_boards
.OrderBy(i => i.Title)
.ThenBy(i => i.CreatedOn)));
}
});
_deleteBoard = new DelegateCommand(
canExecute: () => Boards.CurrentItem != null,
action: () =>
{
_boards.Remove(GetCurrentBoard());
}
);
_cloneBoard = new DelegateCommand(
canExecute: () => Boards.CurrentItem != null,
action: () =>
{
Board currentBoard = GetCurrentBoard();
Board clone = new Board {
Title = string.Empty
};
foreach (var h in currentBoard.Hexes)
{
clone.Hexes.Add(new Hex {
X = h.X, Y = h.Y, Tag = h.Tag, Color = h.Color
});
}
_boards.Add(clone);
}
);
_addBoard = new DelegateCommand(
action: () =>
{
Board b = new Board();
b.Hexes.Add(new Hex {
X = 0, Y = 0
});
_boards.Add(b);
Boards.MoveCurrentTo(b);
});
_addNeighbors = new DelegateCommand(
canExecute: () => Hexes != null && Hexes.CurrentItem != null,
action: () =>
{
Hex currentHex = Hexes.CurrentItem as Hex;
Board currentBoard = GetCurrentBoard();
var neighborsToAdd =
new List <Tuple <int, int> > {
Tuple.Create(1, 0),
Tuple.Create(1, -1),
Tuple.Create(0, -1),
Tuple.Create(-1, 0),
Tuple.Create(-1, 1),
Tuple.Create(0, 1)
}
.Select(i => new Tuple <int, int>(currentHex.X + i.Item1, currentHex.Y + i.Item2))
.Except(currentBoard.Hexes.Select(i => new Tuple <int, int>(i.X, i.Y)));
foreach (var newNeighbor in neighborsToAdd)
{
var hex = new Hex {
Color = "empty", Tag = null, X = newNeighbor.Item1, Y = newNeighbor.Item2
};
currentBoard.Hexes.Add(hex);
}
}
);
_deleteHex = new DelegateCommand(
canExecute: () => Hexes != null && Hexes.CurrentItem != null,
action: () =>
{
Hex currentHex = Hexes.CurrentItem as Hex;
Board currentBoard = GetCurrentBoard();
currentBoard.Hexes.Remove(currentHex);
if (currentBoard.Hexes.Count == 0)
{
currentBoard.Hexes.Add(new Hex {
Color = "black", X = 0, Y = 0
});
}
});
_setHexColor = new DelegateCommand <string>(
action: (color) =>
{
var currentHex = Hexes.CurrentItem as Hex;
if (currentHex != null)
{
currentHex.Color = color;
}
});
BoardFilter = null;
}
public IActionResult Index()
{
var Board = new Boards();
return View(Board);
}
public void Connect(ISaveRepository repo)
{
///////////////////
// Boards AutoSaver
///////////////////
var boardsChanges = Boards.Connect().Publish();
SubscribeChanged(boardsChanges,
bvm =>
{
mon.LogicVerbose($"Box.Boards.ItemChanged {bvm.Id}::{bvm.Name}::{bvm.Modified}");
var bi = mapper.Map <BoardViewModel, Board>(bvm);
repo.CreateOrUpdateBoard(bi).Wait();
});
SubscribeAdded(boardsChanges,
bvm =>
{
mon.LogicVerbose($"Box.Boards.Add {bvm.Id}::{bvm.Name}");
var bi = mapper.Map <BoardViewModel, Board>(bvm);
bi = repo.CreateOrUpdateBoard(bi).Result;
bvm.Id = bi.Id;
});
SubscribeRemoved(boardsChanges,
bvm =>
{
mon.LogicVerbose($"Box.Boards.Remove {bvm.Id}::{bvm.Name}");
repo.DeleteBoard(bvm.Id).Wait();
});
boardsChanges.Connect();
////////////////////
// Columns AutoSaver
////////////////////
var columnsChanges = Columns.Connect().Publish();
SubscribeChanged(columnsChanges,
cvm =>
{
mon.LogicVerbose($"Box.Columns.ItemChanged {cvm.Id}::{cvm.Name}::{cvm.Order}");
var ci = mapper.Map <ColumnViewModel, Column>(cvm);
repo.CreateOrUpdateColumn(ci).Wait();
});
SubscribeAdded(columnsChanges,
cvm =>
{
mon.LogicVerbose($"Box.Columns.Add {cvm.Id}::{cvm.Name}::{cvm.Order}");
var ci = mapper.Map <ColumnViewModel, Column>(cvm);
ci = repo.CreateOrUpdateColumn(ci).Result;
cvm.Id = ci.Id;
});
SubscribeRemoved(columnsChanges,
cvm =>
{
mon.LogicVerbose($"Box.Columns.Remove {cvm.Id}::{cvm.Name}::{cvm.Order}");
repo.DeleteColumn(cvm.Id).Wait();
});
columnsChanges.Connect();
/////////////////
// Rows AutoSaver
/////////////////
var rowsChanges = Rows.Connect().Publish();
SubscribeChanged(rowsChanges,
rvm =>
{
mon.LogicVerbose($"Box.Rows.ItemChanged {rvm.Id}::{rvm.Name}::{rvm.Order}");
var row = mapper.Map <RowViewModel, Row>(rvm);
repo.CreateOrUpdateRow(row).Wait();
});
SubscribeAdded(rowsChanges,
rvm =>
{
mon.LogicVerbose($"Box.Rows.Add {rvm.Id}::{rvm.Name}::{rvm.Order}");
var ri = mapper.Map <RowViewModel, Row>(rvm);
ri = repo.CreateOrUpdateRow(ri).Result;
rvm.Id = ri.Id;
});
SubscribeRemoved(rowsChanges,
rvm =>
{
mon.LogicVerbose($"Box.Rows.Remove {rvm.Id}::{rvm.Name}::{rvm.Order}");
repo.DeleteRow(rvm.Id).Wait();
});
rowsChanges.Connect();
//////////////////
// Cards AutoSaver
//////////////////
var cardsChanges = Cards.Connect().Publish();
SubscribeChanged(cardsChanges,
cvm =>
{
mon.LogicVerbose($"Box.Cards.ItemChanged {cvm.Id}::{cvm.Header}");
var iss = mapper.Map <CardViewModel, Card>(cvm);
repo.CreateOrUpdateCard(iss).Wait();
});
SubscribeAdded(cardsChanges,
cvm =>
{
mon.LogicVerbose($"Box.Cards.Add {cvm.Id}::{cvm.Header}");
var ci = mapper.Map <CardViewModel, Card>(cvm);
ci = repo.CreateOrUpdateCard(ci).Result;
cvm.Id = ci.Id;
});
SubscribeRemoved(cardsChanges,
cvm =>
{
mon.LogicVerbose($"Box.Cards.Remove {cvm.Id}::{cvm.Header}");
repo.DeleteCard(cvm.Id).Wait();
});
cardsChanges.Connect();
}
private void ReloadComandExecute()
{
IsBusy = true;
Boards.Clear();
Task.Factory.StartNew(() => Business.Jira.GetBoards()).ContinueWith(t =>
{
t.Result.Select(b => new Tuple <int, string>(b.Key, b.Value)).ToList().ForEach(i => Boards.Add(i));
IsBusy = false;
}, TaskScheduler.FromCurrentSynchronizationContext());
}
// Get all devices not deleted
public IEnumerable<BoardDevice> GetBoards()
{
var boards = new Boards();
var result = boards.GetAllBoards();
return result;
}
public MoleculeMOTHardware()
{
//Boards
string digitalPatternBoardName = "digitalPattern";
string digitalPatternBoardAddress = "/Dev1";
Boards.Add(digitalPatternBoardName, digitalPatternBoardAddress);
string analogPatternBoardName = "analogPattern";
string analogPatternBoardAddress = "/PXI1Slot2"; //7
Boards.Add(analogPatternBoardName, analogPatternBoardAddress);
string tclBoard1Name = "tclBoard1";
string tclBoard1Address = "/PXI1Slot3";
Boards.Add(tclBoard1Name, tclBoard1Address);
string tclBoard2Name = "tclBoard2";
string tclBoard2Address = "/PXI1Slot8";
Boards.Add(tclBoard2Name, tclBoard2Address);
string tclBoard3Name = "tclBoard3";
string tclBoard3Address = "/PXI1Slot6";
Boards.Add(tclBoard3Name, tclBoard3Address);
string usbBoard1Name = "usbBoard1";
string usbBoard1Address = "/Dev2";
Boards.Add(usbBoard1Name, usbBoard1Address);
string usbBoard2Name = "usbBoard2";
string usbBoard2Address = "/Dev3";
Boards.Add(usbBoard2Name, usbBoard2Address);
// Channel Declarations
AddAnalogInputChannel("ramp", tclBoard1Address + "/ai4", AITerminalConfiguration.Rse);
// Hamish
AddAnalogInputChannel("v00PD", tclBoard1Address + "/ai0", AITerminalConfiguration.Rse);
AddAnalogInputChannel("v10PD", tclBoard1Address + "/ai1", AITerminalConfiguration.Rse);
AddAnalogInputChannel("bXPD", tclBoard1Address + "/ai2", AITerminalConfiguration.Rse);
AddDigitalInputChannel("bXLockBlockFlag", tclBoard1Address, 0, 0);
AddDigitalInputChannel("v00LockBlockFlag", tclBoard1Address, 0, 1);
AddAnalogInputChannel("refPDHamish", tclBoard1Address + "/ai3", AITerminalConfiguration.Rse);
AddAnalogOutputChannel("v00Lock", tclBoard1Address + "/ao0");
AddAnalogOutputChannel("v10Lock", tclBoard1Address + "/ao1");
AddAnalogOutputChannel("bXLock", tclBoard3Address + "/ao2");
AddAnalogOutputChannel("cavityLockHamish", tclBoard3Address + "/ao3");
// Carlos
AddAnalogInputChannel("v21PD", tclBoard1Address + "/ai5", AITerminalConfiguration.Rse);
AddAnalogInputChannel("v32PD", tclBoard1Address + "/ai6", AITerminalConfiguration.Rse);
AddAnalogInputChannel("refPDCarlos", tclBoard1Address + "/ai7", AITerminalConfiguration.Rse);
AddAnalogOutputChannel("v21Lock", tclBoard2Address + "/ao0");
AddAnalogOutputChannel("v32Lock", usbBoard1Address + "/ao0", 0, 5);
AddAnalogOutputChannel("cavityLockCarlos", tclBoard2Address + "/ao1");
// Digital Pattern
AddDigitalOutputChannel("flashLamp", digitalPatternBoardAddress, 0, 0);
AddDigitalOutputChannel("qSwitch", digitalPatternBoardAddress, 0, 1);
AddDigitalOutputChannel("bXSlowingAOM", digitalPatternBoardAddress, 0, 2);
AddDigitalOutputChannel("v00MOTAOM", digitalPatternBoardAddress, 0, 3);
AddDigitalOutputChannel("v10SlowingAOM", digitalPatternBoardAddress, 0, 4);
AddDigitalOutputChannel("microwaveA", digitalPatternBoardAddress, 0, 5);
AddDigitalOutputChannel("microwaveB", digitalPatternBoardAddress, 0, 6);
AddDigitalOutputChannel("cameraTrigger", digitalPatternBoardAddress, 0, 7);
AddDigitalOutputChannel("cameraTrigger2", digitalPatternBoardAddress, 1, 7);
AddDigitalOutputChannel("aoPatternTrigger", digitalPatternBoardAddress, 1, 0);
AddDigitalOutputChannel("v00MOTShutter", digitalPatternBoardAddress, 1, 1);
AddDigitalOutputChannel("bXSlowingShutter", digitalPatternBoardAddress, 1, 2);
AddDigitalOutputChannel("bXLockBlock", digitalPatternBoardAddress, 1, 3);
AddDigitalOutputChannel("v00LockBlock", digitalPatternBoardAddress, 2, 1);
AddDigitalOutputChannel("topCoilDirection", digitalPatternBoardAddress, 1, 4);
AddDigitalOutputChannel("bottomCoilDirection", digitalPatternBoardAddress, 1, 5);
AddDigitalOutputChannel("rbCoolingAOM", digitalPatternBoardAddress, 1, 6);
AddDigitalOutputChannel("v00Sidebands", digitalPatternBoardAddress, 2, 0);
AddDigitalOutputChannel("heliumShutter", digitalPatternBoardAddress, 2, 2);
AddDigitalOutputChannel("rbOpticalPumpingAOM", digitalPatternBoardAddress, 2, 3);
AddDigitalOutputChannel("rbCoolingShutter", digitalPatternBoardAddress, 2, 4);
AddDigitalOutputChannel("rbOpticalPumpingShutter", digitalPatternBoardAddress, 2, 5);
AddDigitalOutputChannel("microwaveC", digitalPatternBoardAddress, 2, 6);
// Analog Pattern
AddAnalogOutputChannel("slowingChirp", analogPatternBoardAddress + "/ao8");
AddAnalogOutputChannel("v00Intensity", analogPatternBoardAddress + "/ao9");
AddAnalogOutputChannel("v00EOMAmp", analogPatternBoardAddress + "/ao11");
AddAnalogOutputChannel("v00Frequency", analogPatternBoardAddress + "/ao12");
AddAnalogOutputChannel("MOTCoilsCurrent", analogPatternBoardAddress + "/ao13"); //13
AddAnalogOutputChannel("triggerDelay", analogPatternBoardAddress + "/ao15");
AddAnalogOutputChannel("xShimCoilCurrent", analogPatternBoardAddress + "/ao17");
AddAnalogOutputChannel("yShimCoilCurrent", analogPatternBoardAddress + "/ao16");
AddAnalogOutputChannel("zShimCoilCurrent", analogPatternBoardAddress + "/ao21");
AddAnalogOutputChannel("slowingCoilsCurrent", analogPatternBoardAddress + "/ao18");
AddAnalogOutputChannel("v00Chirp", analogPatternBoardAddress + "/ao22");
AddAnalogOutputChannel("rbCoolingIntensity", analogPatternBoardAddress + "/ao23");
AddAnalogOutputChannel("rbCoolingFrequency", analogPatternBoardAddress + "/ao24");
AddAnalogOutputChannel("topCoilShunt", analogPatternBoardAddress + "/ao26");
// Source
AddDigitalOutputChannel("cryoCooler", usbBoard2Address, 0, 0);
AddDigitalOutputChannel("sourceHeater", usbBoard2Address, 0, 1);
AddAnalogInputChannel("sourceTemp", usbBoard2Address + "/ai0", AITerminalConfiguration.Rse);
AddAnalogInputChannel("sf6Temp", tclBoard2Address + "/ai0", AITerminalConfiguration.Rse);
// TCL Config
//TCLConfig tcl1 = new TCLConfig("Hamish");
//tcl1.AddLaser("v00Lock", "v00PD");
//tcl1.AddLaser("v10Lock", "v10PD");
//tcl1.AddLaser("bXLock", "bXPD");
//tcl1.Trigger = tclBoard1Address + "/PFI0";
//tcl1.Cavity = "rampHamish";
//tcl1.MasterLaser = "refPDHamish";
//tcl1.Ramp = "cavityLockHamish";
//tcl1.TCPChannel = 1190;
//tcl1.AddDefaultGain("Master", 1.0);
//tcl1.AddDefaultGain("v00Lock", 2);
//tcl1.AddDefaultGain("v10Lock", 0.5);
//tcl1.AddDefaultGain("bXLock", -2);
//tcl1.AddFSRCalibration("v00Lock", 3.95); //This is an approximate guess
//tcl1.AddFSRCalibration("v10Lock", 4.15);
//tcl1.AddFSRCalibration("bXLock", 3.9);
//tcl1.DefaultScanPoints = 850;
//tcl1.PointsToConsiderEitherSideOfPeakInFWHMs = 3;
//Info.Add("Hamish", tcl1);
//TCLConfig tcl2 = new TCLConfig("Carlos");
//tcl2.AddLaser("v21Lock", "v21PD");
//tcl2.AddLaser("v32Lock", "v32PD");
//tcl2.Trigger = tclBoard2Address + "/PFI0";
//tcl2.Cavity = "rampCarlos";
//tcl2.MasterLaser = "refPDCarlos";
//tcl2.Ramp = "cavityLockCarlos";
//tcl2.TCPChannel = 1191;
//tcl2.AddDefaultGain("Master", 1.0);
//tcl2.AddDefaultGain("v21Lock", -0.4);
//tcl2.AddDefaultGain("v32Lock", 0.2);
//tcl2.AddFSRCalibration("v21Lock", 3.7); //This is an approximate guess
//tcl2.AddFSRCalibration("v32Lock", 3.7);
//tcl2.DefaultScanPoints = 900;
//tcl2.PointsToConsiderEitherSideOfPeakInFWHMs = 3;
//Info.Add("Carlos", tcl2);
TCLConfig tclConfig = new TCLConfig("Hamish & Carlos");
tclConfig.Trigger = tclBoard1Address + "/PFI0";
tclConfig.BaseRamp = "ramp";
tclConfig.TCPChannel = 1190;
tclConfig.DefaultScanPoints = 1000;
tclConfig.PointsToConsiderEitherSideOfPeakInFWHMs = 4;
tclConfig.AnalogSampleRate = 62000;
string hamish = "Hamish";
string carlos = "Carlos";
tclConfig.AddCavity(hamish);
tclConfig.Cavities[hamish].AddSlaveLaser("v00Lock", "v00PD");
tclConfig.Cavities[hamish].AddLockBlocker("v00Lock", "v00LockBlockFlag");
tclConfig.Cavities[hamish].AddSlaveLaser("v10Lock", "v10PD");
tclConfig.Cavities[hamish].AddSlaveLaser("bXLock", "bXPD");
tclConfig.Cavities[hamish].AddLockBlocker("bXLock", "bXLockBlockFlag");
tclConfig.Cavities[hamish].MasterLaser = "refPDHamish";
tclConfig.Cavities[hamish].RampOffset = "cavityLockHamish";
tclConfig.Cavities[hamish].AddDefaultGain("Master", 1.0);
tclConfig.Cavities[hamish].AddDefaultGain("v00Lock", 2);
tclConfig.Cavities[hamish].AddDefaultGain("v10Lock", 0.5);
tclConfig.Cavities[hamish].AddDefaultGain("bXLock", -2);
tclConfig.Cavities[hamish].AddFSRCalibration("v00Lock", 3.95); //This is an approximate guess
tclConfig.Cavities[hamish].AddFSRCalibration("v10Lock", 4.15);
tclConfig.Cavities[hamish].AddFSRCalibration("bXLock", 3.9);
tclConfig.AddCavity(carlos);
tclConfig.Cavities[carlos].AddSlaveLaser("v21Lock", "v21PD");
tclConfig.Cavities[carlos].AddSlaveLaser("v32Lock", "v32PD");
tclConfig.Cavities[carlos].MasterLaser = "refPDCarlos";
tclConfig.Cavities[carlos].RampOffset = "cavityLockCarlos";
tclConfig.Cavities[carlos].AddDefaultGain("Master", 1.0);
tclConfig.Cavities[carlos].AddDefaultGain("v21Lock", -0.2);
tclConfig.Cavities[carlos].AddDefaultGain("v32Lock", 1.0);
tclConfig.Cavities[carlos].AddFSRCalibration("v21Lock", 3.7); //This is an approximate guess
tclConfig.Cavities[carlos].AddFSRCalibration("v32Lock", 3.7);
Info.Add("TCLConfig", tclConfig);
// MOTMaster configuration
MMConfig mmConfig = new MMConfig(false, false, true, false);
mmConfig.ExternalFilePattern = "*.tif";
Info.Add("MotMasterConfiguration", mmConfig);
Info.Add("AOPatternTrigger", analogPatternBoardAddress + "/PFI4"); //PFI6
Info.Add("PatternGeneratorBoard", digitalPatternBoardAddress);
Info.Add("PGType", "dedicated");
Info.Add("Element", "CaF");
//Info.Add("PGTrigger", Boards["pg"] + "/PFI2"); // trigger from "cryocooler sync" box, delay controlled from "triggerDelay" analog output
// ScanMaster configuration
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)
// Instruments
Instruments.Add("windfreak", new WindfreakSynth("ASRL8::INSTR"));
Instruments.Add("gigatronics 1", new Gigatronics7100Synth("GPIB0::19::INSTR"));
Instruments.Add("gigatronics 2", new Gigatronics7100Synth("GPIB0::6::INSTR"));
// Calibrations
//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
}
// Get all type boards
public Boards.BoardTypesResult GetTypeBoards()
{
var boards = new Boards();
var result = boards.GetAllBoardTypes();
return result;
}
public JsonResult GetBoardTypes()
{
var boards = new Boards();
var boardsResult = boards.GetAllBoardTypes();
boardsResult.
}
public Move GetMove(Boards boards)
{
if (boards.moves.Count == 0)
throw(null);
Random rand = new Random();
System.Threading.Thread.Sleep(rand.Next(600,1000));
return boards.moves[rand.Next(0, boards.moves.Count)];
}
public BoardEntity GetBoard(Guid boardId)
{
return(Boards
.FirstOrDefault(b => b.BoardId == boardId)
?? throw new ArgumentException($"Не найдена доска с id = '{boardId}'"));
}
public void Solve()
{
ensureDataLoaded();
Boards.Clear();
Solutions.Clear();
var level = 1;
MaxLevelReached = 1;
Combinations.Clear();
var totalCombinations = GetTotalCombinations();
Combinations.Add(totalCombinations);
var prevCombinations = totalCombinations;
var boardSize = Math.Max(_data.Width, _data.Height);
while (true)
{
// get all possible combinations of nr+1 indexes, so that we can filter the possibilities away
// nr=0 means the possible combinations are just one of each perpendicular rows or columns
// nr=1 means possibilities are weighed against every combination in any two perpendicular rows or columns,etc
var piRows = getAllPossibleIndexes(_data.Height, level);
filterPossibilities(_colPossibilities, _rowPossibilities, piRows); // filter column possibilities by rows
totalCombinations = GetTotalCombinations();
addCombinationNr(totalCombinations);
generateBoard(); // generates a board with partial results
if (prevCombinations != totalCombinations)
{
level = 1;
}
Debug.WriteLine($"Combinations so far: {totalCombinations}, level: {level}, max level reached: {MaxLevelReached}");
Console.WriteLine($"Combinations so far: {totalCombinations}, level: {level}, max level reached: {MaxLevelReached}");
var piCols = getAllPossibleIndexes(_data.Width, level);
filterPossibilities(_rowPossibilities, _colPossibilities, piCols); // filter row possibilities by columns
totalCombinations = GetTotalCombinations();
if (totalCombinations <= 1)
{
break;
}
addCombinationNr(totalCombinations);
generateBoard(); // generates a board with partial results
if (prevCombinations == totalCombinations)
{
if (level <= boardSize && level < MaxPuzzleLevel)
{
level++;
if (level > MaxLevelReached)
{
MaxLevelReached = level;
}
}
else
{
Debug.WriteLine("Maximum puzzle level reached");
Console.WriteLine("Maximum puzzle level reached. Starting brute force (it will take a while, please wait...)");
break;
}
}
else
{
level = 1;
}
Debug.WriteLine($"Combinations so far: {totalCombinations}, level: {level}, max level reached: {MaxLevelReached}");
Console.WriteLine($"Combinations so far: {totalCombinations}, level: {level}, max level reached: {MaxLevelReached}");
prevCombinations = totalCombinations;
}
// fill all possible solutions from the remaining column and row possibilities
generateSolutions();
}
public PXIEDMHardware()
{
// add the boards
Boards.Add("daq", "/PXI1Slot18");
Boards.Add("pg", "/PXI1Slot10");
Boards.Add("doBoard", "/PXI1Slot11");
Boards.Add("analogIn2", "/PXI1Slot17");
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 rfAWG = (string)Boards["rfAWG"];
string pgBoard = (string)Boards["pg"];
string daqBoard = (string)Boards["daq"];
string analogIn2 = (string)Boards["analogIn2"];
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 doBoard = (string)Boards["doBoard"];
//string tclBoardPump = (string)Boards["tclBoardPump"];
//string tclBoardProbe = (string)Boards["tclBoardProbe"];
// add things to the info
// the analog triggers
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/USB instruments
Instruments.Add("green", new HP8657ASynth("GPIB0::7::INSTR"));
//Instruments.Add("gigatronix", new Gigatronics7100Synth("GPIB0::19::INSTR"));
Instruments.Add("red", new SRSDS345Synth("GPIB0::19::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"));
Instruments.Add("anapico", new AnapicoSynth("USB0::1003::45055::321-028100000-0168::0::INSTR"));
Instruments.Add("rfAWG", new NIPXI5670("PXI1Slot4"));
// 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("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("ttlSwitch", pgBoard, 3, 5); // This is the output that the pg
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);
AddDigitalOutputChannel("mwEnable", pgBoard, 3, 3);
AddDigitalOutputChannel("mwSelectPumpChannel", pgBoard, 3, 6);
AddDigitalOutputChannel("mwSelectTopProbeChannel", pgBoard, 3, 2);
AddDigitalOutputChannel("mwSelectBottomProbeChannel", pgBoard, 2, 4);
AddDigitalOutputChannel("pumprfSwitch", pgBoard, 3, 4);
// rf awg test
AddDigitalOutputChannel("rfAWGTestTrigger", doBoard, 0, 1);
// these channel are usually software switched - they are on the AO board
AddDigitalOutputChannel("b", aoBoard, 0, 0);
AddDigitalOutputChannel("notB", aoBoard, 0, 1);
AddDigitalOutputChannel("db", aoBoard, 0, 2);
AddDigitalOutputChannel("notDB", aoBoard, 0, 3);
AddDigitalOutputChannel("piFlipEnable", aoBoard, 0, 4);
AddDigitalOutputChannel("notPIFlipEnable", aoBoard, 0, 5); //doesn't seem to be connected to anything
AddDigitalOutputChannel("mwSwitching", aoBoard, 0, 6);
// these digitial outputs are switched slowly during the pattern
AddDigitalOutputChannel("ePol", usbDAQ4, 0, 4);
AddDigitalOutputChannel("notEPol", usbDAQ4, 0, 5);
AddDigitalOutputChannel("eBleed", usbDAQ4, 0, 6);
AddDigitalOutputChannel("eSwitching", usbDAQ4, 0, 7);
// these digitial outputs are are not switched during the pattern
AddDigitalOutputChannel("argonShutter", usbDAQ4, 0, 0);
AddDigitalOutputChannel("patternTTL", usbDAQ4, 0, 2);
AddDigitalOutputChannel("rfPowerAndFreqSelectSwitch", usbDAQ4, 0, 3);
AddDigitalOutputChannel("targetStepper", usbDAQ4, 0, 1);;
// 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("middlePenningGauge", analogIn + "/ai5", 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);
//temporarily disable quspins 19Jul2018
AddAnalogInputChannel("quSpinB0_Y", analogIn + "/ai6", AITerminalConfiguration.Differential);
AddAnalogInputChannel("quSpinB0_Z", analogIn + "/ai7", AITerminalConfiguration.Differential);
//AddAnalogInputChannel("quSpinEV_Y", analogIn + "/ai4", AITerminalConfiguration.Differential);
AddAnalogInputChannel("quSpinEV_Z", analogIn2 + "/ai1", AITerminalConfiguration.Differential);
AddAnalogInputChannel("quSpinEW_Y", analogIn2 + "/ai2", AITerminalConfiguration.Differential);
AddAnalogInputChannel("quSpinEW_Z", analogIn2 + "/ai3", AITerminalConfiguration.Differential);
AddAnalogInputChannel("quSpinEX_Y", analogIn2 + "/ai4", AITerminalConfiguration.Differential);
AddAnalogInputChannel("quSpinEX_Z", analogIn2 + "/ai5", AITerminalConfiguration.Differential);
AddAnalogInputChannel("quSpinEU_Y", analogIn2 + "/ai6", AITerminalConfiguration.Differential);
AddAnalogInputChannel("quSpinEU_Z", analogIn2 + "/ai7", AITerminalConfiguration.Differential);
AddAnalogOutputChannel("phaseScramblerVoltage", aoBoard + "/ao10");
AddAnalogOutputChannel("bScan", aoBoard + "/ao2");
// B field control
//AddAnalogOutputChannel("steppingBBias", usbDAQ4 + "/ao0", 0, 5);
// Add B field stepping box bias analog output to this board for now (B field controller is not connected to anything!)
AddAnalogOutputChannel("steppingBBias", aoBoard + "/ao8", -10, 10);
// 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 + "/ao1", 0, 10);
AddAnalogOutputChannel("cMinus", usbDAQ3 + "/ao0", 0, 10);
// 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);
}
public void Initialize()
{
var boards = new Boards();
boards.InitTypeBoards(boardTypeModel);
}
public BoardController(ScrumToolDB p_context)
{
m_Board = null;
m_context = p_context;
}
private void UpdateTiles(Boards boards)
{
for (int i = 0; i < 9; ++i)
{
for (int j = 0; j < 9; ++j)
{
if (boards.lastmove == i)
boardRects[i][j].Fill = new SolidColorBrush(Colors.Yellow);
else
boardRects[i][j].Fill = new SolidColorBrush(
i % 2 == 0 ? filled : Colors.White);
boardImages[i][j].Opacity = 1;
boardImages[i][j].Source = TryFindResource
(boards.GetTile_String(new Move(i, j))) as BitmapImage;
}
string result = boards.GetWinner_String(i);
if(result == "X" || result == "O")
{
for (int j = 0; j < 9; ++j)
boardImages[i][j].Opacity = .33;
boardImages[9][i].Source = TryFindResource(result) as BitmapImage;
}
else { boardImages[9][i].Source = null; }
}
string winner = boards.GetWinner_String(9);
if (winner == " ") { InfoGridUpdate(boards.turn); }
else { for (int i = 0; i < 9; ++i) { for (int j = 0; j < 9; ++j) { boardRects[i][j].Fill = new SolidColorBrush(i % 2 == 0 ? filled : Colors.White); } }
if (winner == "D") { InfoImage.Source = null; InfoBox.Text = "Game Over: It's a Draw"; }
else { InfoImage.Source = TryFindResource(winner) as BitmapImage; InfoBox.Text = "Game Over: " + winner + " Wins"; }
}
if(lastMove != null && turnToDisplay == game.currentTurn)
{
boardRects[lastMove.board][lastMove.tile].Fill = new SolidColorBrush(filledOrange);
}
}
public DecelerationHardware()
{
// YAG laser
yag = new MiniliteLaser();
// add the boards
Boards.Add("daq", "/dev2");
Boards.Add("pg", "/dev1");
Boards.Add("usbDev", "/dev3");
Boards.Add("PXI6", "/PXI1Slot6");
Boards.Add("PXI4", "/PXI1Slot4");
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"];
// add things to the info
Info.Add("PGClockLine", Boards["pg"] + "/PFI2");
Info.Add("PatternGeneratorBoard", pgBoard);
Info.Add("PGType", "dedicated");
//TCL Lockable lasers
Info.Add("TCLLockableLasers", new string[] { "laser", "laser2" });
Info.Add("TCLPhotodiodes", new string[] { "cavity", "master", "p1", "p2" }); // 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.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");
// the analog triggers
Info.Add("analogTrigger0", (string)Boards["daq"] + "/PFI0"); // pin 10
Info.Add("analogTrigger1", (string)Boards["daq"] + "/PFI1"); // pin 11
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
//distance information
Info.Add("sourceToDetect", 0.81); //in m
Info.Add("sourceToSoftwareDecelerator", 0.12); //in m
//information about the molecule
Info.Add("molecule", "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("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("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("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("cavityTriggerOut", usbBoard, 0, 1); //Pin 18
//AddDigitalOutputChannel("ttl1", pgBoard, 2, 2); //Pin 58 Used to be used with AomLevelControlPlugin.
//AddDigitalOutputChannel("ttl2", pgBoard, 2, 1); //Pin 57
// AddDigitalOutputChannel("ttlSwitch", pgBoard, 1, 3); // This is the output that the pg
// will switch if it's switch scanning.
// map the analog channels
AddAnalogInputChannel("pmt", daqBoard + "/ai0", AITerminalConfiguration.Rse);
AddAnalogInputChannel("pmt2", daqBoard + "/ai8", AITerminalConfiguration.Rse);
AddAnalogInputChannel("longcavity", daqBoard + "/ai3", AITerminalConfiguration.Rse);
AddAnalogInputChannel("refcavity", daqBoard + "/ai1", AITerminalConfiguration.Rse);
AddAnalogInputChannel("lockcavity", daqBoard + "/ai2", AITerminalConfiguration.Rse);
AddAnalogInputChannel("master", TCLBoard + "/ai1", AITerminalConfiguration.Rse);
AddAnalogInputChannel("p1", TCLBoard + "/ai3", AITerminalConfiguration.Rse);
AddAnalogInputChannel("cavity", TCLBoard + "/ai2", AITerminalConfiguration.Rse);
AddAnalogInputChannel("p2", TCLBoard + "/ai0", AITerminalConfiguration.Rse);
AddAnalogOutputChannel("laser", PXIBoard + "/ao13");
//AddAnalogOutputChannel("cavity", daqBoard + "/ao0");
// AddAnalogOutputChannel("cavity", PXIBoard + "/ao5");
AddAnalogOutputChannel("laser2", PXIBoard + "/ao25");
AddAnalogOutputChannel("laser3", PXIBoard + "/ao31");
AddAnalogOutputChannel("rampfb", PXIBoard + "/ao19");
AddAnalogOutputChannel("highvoltage", daqBoard + "/ao1");// hardwareController has "highvoltage" hardwired into it and so needs to see this ao, otherwise it crashes. Need to fix this.
// map the counter channels
AddCounterChannel("pmt", daqBoard + "/ctr0");
AddCounterChannel("sample clock", daqBoard + "/ctr1");
}
