def setUp(self):
self.config_dir = tmp_dir("config_dir")
self.process = Process("proc")
self.o = ProcessController("MyMRI", self.prefix, self.config_dir.value)
self.process.add_controller(self.o)
self.process.start()
self.b = self.process.block_view("MyMRI")
def setUp(self):
self.p = Process("proc")
self.config_dir = tmp_dir("config_dir")
for c in detector_block("mri", config_dir=self.config_dir.value):
self.p.add_controller(c)
self.p.start()
self.b = self.p.block_view("mri")
self.tmpdir = tempfile.mkdtemp()
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.child = self.create_child_block(hdf_writer_block,
self.process,
mri="BLOCK:HDF5",
prefix="prefix")
self.config_dir = tmp_dir("config_dir")
self.process.start()
def setUp(self):
self.p = Process("proc")
self.config_dir = tmp_dir("config_dir")
for c in motion_block("mri", config_dir=self.config_dir.value):
self.p.add_controller(c)
self.p.start()
self.b = self.p.block_view("mri")
self.bx = self.p.block_view("mri:COUNTERX")
self.by = self.p.block_view("mri:COUNTERY")
def setUp(self):
self.o = UnrollingPart(name="Unroll",
mri="mri",
initial_visibility=True)
self.process = Process("proc")
self.process.start()
self.addCleanup(self.process.stop, 2)
self.config_dir = tmp_dir("config_dir")
c = RunnableController("mri", self.config_dir.value)
c.add_part(self.o)
self.process.add_controller(c)
self.b = c.block_view()
def setUp(self):
try:
os.mkdir("/tmp/prod")
except OSError:
pass
self.testArea = "/tmp/prod/testpath-" + floor(time.time()).__repr__()[:-2]
os.mkdir(self.testArea)
self.cwd = os.getcwd()
# Create temporary config directory for ProcessController
config_dir = tmp_dir("config_dir")
self.obj = ProcessController("", "", config_dir.value)
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
# Create a fake PandA with a pulse block
self.panda = ManagerController("PANDA", "/tmp")
controller = BasicController("PANDA:PULSE3")
self.pulse_part = PulsePart("part")
controller.add_part(self.pulse_part)
self.process.add_controller(controller)
self.panda.add_part(
ChildPart("PULSE3",
"PANDA:PULSE3",
initial_visibility=True,
stateful=False))
self.process.add_controller(self.panda)
# And the detector
self.config_dir = tmp_dir("config_dir")
for c in detector_block("DET", config_dir=self.config_dir.value):
self.process.add_controller(c)
# Make the child block holding panda and pmac mri
self.child = self.create_child_block(
panda_pulse_trigger_block,
self.process,
mri="SCAN:PULSE",
panda="PANDA",
detector="DET",
)
# And our part under test
self.o = PandAPulseTriggerPart("detTrigger", "SCAN:PULSE")
# Add in a scan block
self.scan = RunnableController("SCAN", "/tmp")
self.scan.add_part(DetectorChildPart("det", "DET", True))
self.scan.add_part(self.o)
self.process.add_controller(self.scan)
# Now start the process off and tell the panda which sequencer tables
# to use
self.process.start()
exports = ExportTable.from_rows([
("PULSE3.width", "detTriggerWidth"),
("PULSE3.step", "detTriggerStep"),
("PULSE3.delay", "detTriggerDelay"),
("PULSE3.pulses", "detTriggerPulses"),
])
self.panda.set_exports(exports)
self.tmpdir = tempfile.mkdtemp()
def setUp(self):
self.process = Process("proc")
self.config_dir = tmp_dir("config_dir")
for controller in motion_block(
mri="TESTMOTION",
config_dir=self.config_dir.value) + pva_server_block(
mri="PVA-SERVER"):
self.process.add_controller(controller)
self.process.start()
self.process2 = Process("proc2")
for controller in pva_client_block(mri="PVA-CLIENT") + proxy_block(
mri="TESTMOTION", comms="PVA-CLIENT"):
self.process2.add_controller(controller)
self.process2.start()
def setUp(self):
self.p = Process("proc")
self.config_dir = tmp_dir("config_dir")
for c in (
detector_block("DETECTOR", config_dir=self.config_dir.value) +
motion_block("MOTION", config_dir=self.config_dir.value) +
scan_1det_block("SCANMRI", config_dir=self.config_dir.value)):
self.p.add_controller(c)
self.pub = PublishController("PUB")
self.p.add_controller(self.pub)
self.p.start()
self.b = self.p.block_view("SCANMRI")
self.bd = self.p.block_view("DETECTOR")
self.tmpdir = tempfile.mkdtemp()
def setUp(self, mock_client):
self.process = Process()
self.config_dir = tmp_dir("config_dir")
self.o = PandAManagerController(mri="P",
config_dir=self.config_dir.value,
poll_period=1000)
self.client = self.o._client
self.client.started = False
blocks_data = OrderedDict()
fields = OrderedDict()
fields["INP"] = FieldData("pos_mux", "", "Input A",
["ZERO", "COUNTER.OUT"])
fields["START"] = FieldData("param", "", "Start position", [])
fields["STEP"] = FieldData("param", "", "Step position", [])
fields["OUT"] = FieldData("bit_out", "", "Output", [])
blocks_data["PCOMP"] = BlockData(1, "Position Compare", fields)
fields = OrderedDict()
fields["INP"] = FieldData("bit_mux", "", "Input",
["ZERO", "TTLIN.VAL"])
fields["START"] = FieldData("param", "pos", "Start position", [])
fields["OUT"] = FieldData("pos_out", "", "Output", ["No", "Capture"])
blocks_data["COUNTER"] = BlockData(1, "", fields)
fields = OrderedDict()
fields["VAL"] = FieldData("bit_out", "", "Output", [])
blocks_data["TTLIN"] = BlockData(2, "", fields)
blocks_data["PCAP"] = BlockData(1, "", {})
self.client.get_blocks_data.return_value = blocks_data
changes = [
["PCOMP.INP", "ZERO"],
["PCOMP.STEP", "0"],
["PCOMP.START", "0"],
["PCOMP.OUT", "0"],
["COUNTER.INP", "ZERO"],
["COUNTER.INP.DELAY", "0"],
["COUNTER.OUT", "0"],
["COUNTER.OUT.SCALE", "1"],
["COUNTER.OUT.OFFSET", "0"],
["COUNTER.OUT.UNITS", ""],
["TTLIN1.VAL", "0"],
["TTLIN2.VAL", "0"],
]
self.client.get_changes.return_value = changes
pcap_bit_fields = {
"PCAP.BITS0.CAPTURE":
["TTLIN1.VAL", "TTLIN2.VAL", "PCOMP.OUT", ""]
}
self.client.get_pcap_bits_fields.return_value = pcap_bit_fields
self.process.add_controller(self.o)
self.process.start()
def setUp(self):
self.process = Process("proc")
self.config_dir = tmp_dir("config_dir")
for controller in detector_block(
mri="TESTDET",
config_dir=self.config_dir.value) + pva_server_block(
mri="PVA-SERVER"):
self.process.add_controller(controller)
self.process.start()
self.process2 = Process("proc2")
for controller in pva_client_block(mri="PVA-CLIENT") + proxy_block(
mri="TESTDET", comms="PVA-CLIENT"):
self.process2.add_controller(controller)
self.process2.start()
self.tmpdir = tempfile.mkdtemp()
def setUp(self):
self.p = Process("process1")
self.p1, self.c1 = self.makeChildBlock("child1")
self.p2, self.c2 = self.makeChildBlock("child2")
self.p3, self.c3 = self.makeChildBlock("child3")
self.c1._block.sinkportConnector.set_value("Connector3")
self.c2._block.sinkportConnector.set_value("Connector1")
self.c3._block.sinkportConnector.set_value("Connector2")
# create a root block for the child blocks to reside in
self.config_dir = tmp_dir("config_dir")
self.c = ManagerController(mri="mainBlock", config_dir=self.config_dir.value)
for part in [self.p1, self.p2, self.p3]:
self.c.add_part(part)
self.p.add_controller(self.c)
# Start the process
# check that do_initial_reset works asynchronously
assert self.c.state.value == sm.DISABLED
self.p.start()
assert self.c.state.value == sm.READY
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
self.config_dir = tmp_dir("config_dir")
pmac_block = make_block_creator(__file__,
"test_pmac_manager_block.yaml")
self.child = self.create_child_block(
pmac_block,
self.process,
mri_prefix="PMAC",
config_dir=self.config_dir.value,
)
# These are the child blocks we are interested in
self.child_x = self.process.get_controller("BL45P-ML-STAGE-01:X")
# self.child_y = self.process.get_controller(
# "BL45P-ML-STAGE-01:Y")
self.child_cs1 = self.process.get_controller("PMAC:CS1")
self.child_traj = self.process.get_controller("PMAC:TRAJ")
self.child_status = self.process.get_controller("PMAC:STATUS")
# CS1 needs to have the right port otherwise we will error
self.set_attributes(self.child_cs1, port="CS1")
self.move_time = 0.5
self.o = BeamSelectorPart(
name="beamSelector",
mri="PMAC",
selector_axis="x",
imaging_angle=0,
diffraction_angle=0.5,
imaging_detector="imagingDetector",
diffraction_detector="diffDetector",
move_time=self.move_time,
)
self.context.set_notify_dispatch_request(
self.o.notify_dispatch_request)
self.process.start()
pass
def setUp(self):
self.p = Process("process1")
# create a child to client
self.c_child = StatefulController("childBlock")
self.c_part = MyPart("cp1")
self.c_child.add_part(self.c_part)
self.p.add_controller(self.c_child)
# Create temporary config directory for ProcessController
self.config_dir = tmp_dir("config_dir")
self.main_block_name = "mainBlock"
self.c = ManagerController("mainBlock",
config_dir=self.config_dir.value)
self.c.add_part(MyPart("part1"))
self.c.add_part(
ChildPart("part2", mri="childBlock", initial_visibility=True))
self.p.add_controller(self.c)
self.b = self.p.block_view("mainBlock")
# check that do_initial_reset works asynchronously
assert self.c.state.value == "Disabled"
self.p.start()
assert self.c.state.value == "Ready"
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
# Create a fake PandA
self.panda = ManagerController("PANDA", "/tmp", use_git=False)
self.busses = PositionsPart("busses")
self.panda.add_part(self.busses)
self.process.add_controller(self.panda)
# TODO: Add axes to the positions table
# And the PMAC
pmac_block = make_block_creator(
os.path.join(os.path.dirname(__file__), "..", "test_pmac", "blah"),
"test_pmac_manager_block.yaml",
)
self.config_dir = tmp_dir("config_dir")
self.pmac = self.create_child_block(
pmac_block,
self.process,
mri_prefix="PMAC",
config_dir=self.config_dir.value,
)
# These are the motors we are interested in
self.child_x = self.process.get_controller("BL45P-ML-STAGE-01:X")
self.child_y = self.process.get_controller("BL45P-ML-STAGE-01:Y")
# Set up port and kinematics on CS1
self.child_cs1 = self.process.get_controller("PMAC:CS1")
self.set_attributes(self.child_cs1, port="CS1")
self.set_attributes(self.child_cs1, qVariables="Q22=12345 Q23=999")
self.set_attributes(self.child_cs1,
forwardKinematic="Q1=P1+10 Q5=Q22+4 Q7=8+4 RET ")
# Set up variables on CS1
self.child_status = self.process.get_controller("PMAC:STATUS")
self.set_attributes(self.child_status, iVariables="I12=3")
self.set_attributes(self.child_status, pVariables="")
self.set_attributes(self.child_status, mVariables="M45=1 M42=561")
# Make the child block holding panda and pmac mri
self.child = self.create_child_block(
panda_kinematicssavu_block,
self.process,
mri="SCAN:KINSAV",
panda="PANDA",
pmac="PMAC",
)
self.o = KinematicsSavuPart(name="kinsav",
mri="SCAN:KINSAV",
cs_port="CS1",
cs_mri_suffix="CS1")
self.context.set_notify_dispatch_request(
self.o.notify_dispatch_request)
self.process.start()
self.set_attributes(self.pmac)
self.completed_steps = 0
# goal for these is 3000, 2000, True
cols, rows, alternate = 3000, 2000, False
self.steps_to_do = cols * rows
xs = LineGenerator("x", "mm", 0.0, 0.1, cols, alternate=alternate)
ys = LineGenerator("y", "mm", 0.0, 0.1, rows)
self.generator = CompoundGenerator([ys, xs], [], [], 0.1)
self.generator.prepare()
def test_tmp_dir(self):
d = tmp_dir("config")
assert d.name == "config"
assert d.value.startswith("/tmp")
assert os.path.isdir(d.value)
os.rmdir(d.value)
def setUp(self):
self.process = Process("Process")
self.context = Context(self.process)
# Create a fake PandA
self.panda = ManagerController("PANDA", "/tmp", use_git=False)
self.busses = PositionsPart("busses")
self.panda.add_part(self.busses)
# Make 2 sequencers we can prod
self.seq_parts = {}
for i in (1, 2):
controller = BasicController("PANDA:SEQ%d" % i)
self.seq_parts[i] = SequencerPart("part")
controller.add_part(self.seq_parts[i])
self.process.add_controller(controller)
self.panda.add_part(
ChildPart(
"SEQ%d" % i,
"PANDA:SEQ%d" % i,
initial_visibility=True,
stateful=False,
))
self.child_seq1 = self.process.get_controller("PANDA:SEQ1")
self.child_seq2 = self.process.get_controller("PANDA:SEQ2")
# And an srgate
controller = BasicController("PANDA:SRGATE1")
self.gate_part = GatePart("part")
controller.add_part(self.gate_part)
self.process.add_controller(controller)
self.panda.add_part(
ChildPart("SRGATE1",
"PANDA:SRGATE1",
initial_visibility=True,
stateful=False))
self.process.add_controller(self.panda)
# And the PMAC
pmac_block = make_block_creator(
os.path.join(os.path.dirname(__file__), "..", "test_pmac", "blah"),
"test_pmac_manager_block.yaml",
)
self.config_dir = tmp_dir("config_dir")
self.pmac = self.create_child_block(
pmac_block,
self.process,
mri_prefix="PMAC",
config_dir=self.config_dir.value,
)
# These are the motors we are interested in
self.child_x = self.process.get_controller("BL45P-ML-STAGE-01:X")
self.child_y = self.process.get_controller("BL45P-ML-STAGE-01:Y")
self.child_cs1 = self.process.get_controller("PMAC:CS1")
# CS1 needs to have the right port otherwise we will error
self.set_attributes(self.child_cs1, port="CS1")
# Make the child block holding panda and pmac mri
self.child = self.create_child_block(
panda_seq_trigger_block,
self.process,
mri="SCAN:PCOMP",
panda="PANDA",
pmac="PMAC",
)
# And our part under test
self.o = PandASeqTriggerPart("pcomp", "SCAN:PCOMP")
# Now start the process off and tell the panda which sequencer tables
# to use
self.process.start()
exports = ExportTable.from_rows([
("SEQ1.table", "seqTableA"),
("SEQ2.table", "seqTableB"),
("SRGATE1.forceSet", "seqSetEnable"),
("SRGATE1.forceReset", "seqReset"),
])
self.panda.set_exports(exports)