def timescan(count_time, *counters, **kwargs):
save_flag = kwargs.get("save", True)
dm = DataManager()
filename = kwargs.get("filename", SCANFILE)
sleep_time = kwargs.get("sleep_time", 0)
npoints = kwargs.get("npoints", 0)
if max(count_time, sleep_time) == 0:
raise RuntimeError("Either sleep or count time has to be specified.")
logging.getLogger().info("Doing timescan")
scan = dm.new_timescan(filename, counters)
t0 = time.time()
with cleanup(scan.end):
while True:
acquisitions = []
tt = time.time() - t0
values = [tt]
for counter in counters:
acquisitions.append(gevent.spawn(counter.read, count_time))
gevent.joinall(acquisitions)
values.extend([a.get() for a in acquisitions])
scan.add(values)
npoints -= 1
if npoints == 0:
break
time.sleep(sleep_time)
def energyscan(start, end, npoints):
mstart = energy.controller.calc_to_real(start)
mend = energy.controller.calc_to_real(end)
delta = abs(mend - mstart) / float(npoints) * mono.encoder.steps_per_unit
mdelta = int(delta / mono.encoder.steps_per_unit)
npoints = (delta * npoints / int(delta)) - 1
chain = AcquisitionChain()
musst_acq_dev = MusstAcquisitionDevice(
musst,
program="monoscan.mprg",
store_list=["timer", "ch2", "ch3"],
vars={
"e1": mstart * mono.encoder.steps_per_unit,
"e2": mend * mono.encoder.steps_per_unit,
"de": mdelta,
"monoangle": mono.position() * mono.encoder.steps_per_unit,
"npoints": npoints
})
master = MotorMaster(mono, start, end)
# in this case, prepare can be done in parallel, is it always the case?
# if yes, the code can be optimized
chain.add(master, musst_acq_dev)
cscan = Scan(DataManager())
cscan.set_acquisition_chain(chain)
cscan.prepare()
return cscan.start()
def a2scan(
motor1, start1, stop1, motor2, start2, stop2, npoints, count_time, *
counters, **kwargs):
save_flag = kwargs.get("save", True)
dm = DataManager()
filename = kwargs.get("filename", SCANFILE)
logging.getLogger().info(
"Scanning %s from %f to %f and %s from %f to %f in %d points" %
(motor1.name, start1, stop1, motor2.name, start2, stop2, npoints))
motors = [motor1, motor2]
scan = dm.new_scan(filename, motors, npoints, counters, save_flag)
start_pos1 = motor1.position()
start_pos2 = motor2.position()
motor_group = Group(motor1, motor2)
def scan_cleanup():
logging.getLogger().info(
"Returning motor %s to %f and motor %s to %f" %
(motor1.name, start_pos1, motor2.name, start_pos2))
motor_group.move(motor1, start_pos1, motor2, start_pos2)
motor_group.move(motor1, start1, motor2, start2)
ipoint = 0
countlabellen = len("{0:d}".format(npoints))
countformatstr = "{0:" + "{0:d}".format(countlabellen) + "d}"
s1 = numpy.linspace(start1, stop1, npoints)
s2 = numpy.linspace(start2, stop2, npoints)
with cleanup(scan.end):
with error_cleanup(scan_cleanup):
for ii in range(npoints):
ipoint = ipoint + 1
motor_group.move(motor1, s1[ii], motor2, s2[ii])
acquisitions = []
values = [m.position() for m in (motor1, motor2)]
for counter in counters:
acquisitions.append(gevent.spawn(counter.read, count_time))
gevent.joinall(acquisitions)
values.extend([a.get() for a in acquisitions])
# print values
scan.add(values)
def ascan(motor, start, stop, npoints, count_time, *counters, **kwargs):
save_flag = kwargs.get("save", True)
dm = DataManager()
filename = kwargs.get("filename", SCANFILE)
logging.getLogger().info("Scanning %s from %f to %f in %d points" %
(motor.name, start, stop, npoints))
motors = [motor]
scan = dm.new_scan(filename, motors, npoints, counters, save_flag)
start_pos = motor.position()
def scan_cleanup():
print "Returning motor %s to %f" % (motor.name, start_pos)
motor.move(start_pos)
motor.move(start)
ipoint = 0
countlabellen = len("{0:d}".format(npoints))
countformatstr = "{0:" + "{0:d}".format(countlabellen) + "d}"
with cleanup(scan.end):
with error_cleanup(scan_cleanup):
for position in numpy.linspace(start, stop, npoints):
ipoint = ipoint + 1
countlabel = "(" + "{0:3d}".format(
ipoint) + "/" + "{0:3d}".format(npoints) + ")"
countlabel = "(" + countformatstr.format(
ipoint) + "/" + countformatstr.format(npoints) + ")"
motor.move(float(position))
acquisitions = []
values = [position]
for counter in counters:
acquisitions.append(gevent.spawn(counter.read, count_time))
gevent.joinall(acquisitions)
values.extend([a.get() for a in acquisitions])
# print values
scan.add(values)
def __init__(self, *args):
BlissWidget.__init__(self, *args)
self.defineSignal("newScan", ())
self.scanObject = None
self.xdata = []
self.ylable = ""
self.mylog = 0
self.canAddPoint = True
self.dm = DataManager()
event.connect(self.dm, "scan_new", self.newScan)
event.connect(self.dm, "scan_data", self.newScanPoint)
self.addProperty("backgroundColor", "combo", ("white", "default"),
"white")
self.addProperty("graphColor", "combo", ("white", "default"), "white")
self.lblTitle = QLabel(self)
self.graphPanel = QFrame(self)
buttonBox = QHBox(self)
self.lblPosition = QLabel(buttonBox)
self.graph = QtBlissGraph(self.graphPanel)
QObject.connect(self.graph, PYSIGNAL("QtBlissGraphSignal"),
self.handleBlissGraphSignal)
QObject.disconnect(
self.graph,
SIGNAL("plotMousePressed(const QMouseEvent&)"),
self.graph.onMousePressed,
)
QObject.disconnect(
self.graph,
SIGNAL("plotMouseReleased(const QMouseEvent&)"),
self.graph.onMouseReleased,
)
self.graph.canvas().setMouseTracking(True)
self.graph.enableLegend(False)
self.graph.enableZoom(False)
self.graph.setAutoLegend(False)
self.lblPosition.setAlignment(Qt.AlignRight)
self.lblTitle.setAlignment(Qt.AlignHCenter)
self.lblTitle.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.lblPosition.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
buttonBox.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
QVBoxLayout(self.graphPanel)
self.graphPanel.layout().addWidget(self.graph)
QVBoxLayout(self)
self.layout().addWidget(self.lblTitle)
self.layout().addWidget(buttonBox)
self.layout().addWidget(self.graphPanel)
