def run_mda(self,scope):
""" Run an MDA.
args: initialized scope object
"""
## check for MDA setup
if self.path_set_up is False: self.setup_path()
if self.verbose: scope.verbose=True
if self.pos_order==[]: print "Provide positions"; return None
if self.channels=={}: print "Provide channels"; return None
if self.channel_type=="": print "Provide channel format"; return None
## dependencies must have been met, continue with MDA
try:
for t in range(0,self.n_timepoints):
try:
t=t ## for easier reporting on progress
acquisition_start=time.time()
for pos_label in self.pos_order:
try: ## try positions
pos_label=pos_label ## for easier reporting on progress
print "####################%s###################" % pos_label
if self.verbose is True: t1=time.time()
pos=self.positions[pos_label]
x_target,y_target,z_target=pos.get_xyz()
afc_target=pos.get_afc_offset()
if self.verbose is True: move_t0=time.time()
scope.mmc.enableContinuousFocus(True) ## to enable afc hold during move
scope.move_XYstage(x_target,y_target,blocking=True)
time.sleep(1) ## wait a while once you are there to make sure it focus
## To do , maybe add applying the first settings here
if self.verbose is True:
deltaT=time.time()-move_t0
print "Arrived at location %s in %.2f seconds" % (pos_label,deltaT)
x_final,y_final,z_final,afc_final=scope.get_stage_loc()
print " Now at %sx %sy %sz %s afc" % (x_final,
y_final,
z_final,
afc_final)
focus_t0=time.time()
scope.mmc.enableContinuousFocus(False)
time.sleep(1) ## wait a bit for focus to be turned off
scope.move_to_offset(afc_target,post_focus_delay=.1,attempt_delay=.1)
if self.verbose is True:
deltaT=time.time()-focus_t0
x_final,y_final,z_final,afc_final=scope.get_stage_loc()
print "Focus after %s seconds" % deltaT
print "Now at afc: %s (target: %s)" % (afc_final,afc_target)
## set up channels
print "Channels to image at this position (%s)t%s: %s" % (pos_label,t,self.channels[pos_label][t])
c_to_image = self.channels[pos_label][t]
## set up z stack
z_params = self.z_params
if t in self.specialized_z_params:
if pos_label in self.specialized_z_params[t]:
for c in self.specialized_z_params[t][pos_label]:
z_params[c]=self.specialized_z_params[t][pos_label][c]
if self.verbose:
print "Z stack updated; taking %s at c %s %s t%s" % (z_params[c],c,pos_label,t)
## take images
if self.verbose:image_t0=time.time()
images,metadata=scope.multichannel_zstack(c_to_image,
z_params=z_params,
md_format="list")
if self.verbose:
deltaT=time.time()-image_t0
print "Finished images %s: %s seconds" % (pos_label,deltaT)
## save the images
for c in range(0,len(c_to_image)):
stack=images[c]
md_stack=metadata[c]
if self.channel_type == "MM Config":
channel_name = c_to_image[c][1]
elif self.channel_type == "Illuminations":
channel_name = c_to_image[c].name
full_save_dir=os.path.join(self.save_dir,
pos_label,
channel_name)
full_file_name="%s_%s_c%s%s_t%s" % (self.file_name_prefix,
pos_label,
c,
channel_name,
t)
md=md_stack[len(md_stack)/2]
md.append("ImagingLoop:Timepoint=%s" % t)
md.append("ImagingLoop:Position=%s" % pos_label)
md.append("ImagingLoop:Channel=%s" % channel_name)
try:
channel_description = self.experiment_metadata["ChannelMapping"]["ChannelDescription"][channel_name]
except:
channel_description = "Error"
md.append("ImagingLoop:ChannelDescription=%s" % channel_description)
try:
channel_purpose = self.experiment_metadata["ChannelMapping"]["ChannelPurpose"][channel_name]
except:
channel_purpose = "Error"
md.append("ImagingLoop:ChannelPurpose=%s" % channel_purpose)
try:
microfluidic_device_id = self.experiment_metadata["MicrofluidicDeviceId"]
except:
microfluidic_device_id = "Error"
md.append("ExperimentData:MicrofluidicDeviceId=%s" % microfluidic_device_id)
try:
microfluidic_device_type = self.experiment_metadata["MicrofluidicDeviceType"]
except:
microfluidic_device_type = "Error"
md.append("ExperimentData:MicrofluidicDeviceType=%s" % microfluidic_device_type)
try:
microfluidic_channel = self.experiment_metadata["MicrofluidicChannel"][pos_label]
except:
microfluidic_channel = "Error"
print "Unable to map position to 'microfluidic_channel'"
print pos_label
md.append("ExperimentData:MicrofluidicChannel=%s" % microfluidic_channel)
try:
strain = self.experiment_metadata["Strain"][microfluidic_channel]
except:
strain = "Error"
md.append("ExperimentData:Strain=%s" % strain)
try:
media = self.experiment_metadata["Media"][microfluidic_channel]
if isinstance(media,dict):
media=media[t]
except:
media = "Error"
md.append("ExperimentData:Media=%s" % media)
try:
flow_rate = self.experiment_metadata["FlowRate"][microfluidic_channel]
if isinstance(flow_rate,dict):
flow_rate=flow_rate[t]
except:
flow_rate = "Error"
md.append("ExperimentData:FlowRate=%s" % flow_rate)
try:
file_out.stack_writer(full_save_dir,
full_file_name,
stack,
md)
except:
try:
if self.backup_save_path:
if os.path.isdir(self.backup_save_path) is False:
os.mkdir(self.backup_save_path)
file_out.stack_writer(self.backup_save_path,
full_file_name,
stack,
md)
print "Warning! Your first save path failed"
print "%s written to backup save path" % full_file_name
else:
print "You did not have the backup path set"
print "%s was not saved" % full_file_name
except:
print "Warning! Your backup save failed."
deltaT_acquistion=time.time()-acquisition_start
print "%s completed after %s seconds from start of timeloop" % (pos_label,deltaT_acquistion)
if self.verbose:
deltaT=time.time()-t1
print "Position took a total of % seconds" % deltaT
#scope.mmc.enableContinuousFocus(True)
except KeyboardInterrupt:
raise
except:
print "Position aborted because of error!!!"
print "Attempting to reconnect to the scope"
scope.disconnect()
time.sleep(10)
scope.reconnect()
except KeyboardInterrupt:
raise
except:
print "Timepoint aborted because of error!!!"
scope.move_to_offset(afc_target)
x_next=self.positions[self.pos_order[0]].get_x()
y_next=self.positions[self.pos_order[0]].get_y()
scope.mmc.enableContinuousFocus(True)
time.sleep(2)
scope.move_XYstage(x_next,y_next,blocking=True)
#scope.mmc.enableContinuousFocus(False)
acquisition_finish_time=time.time()
until_next=self.frequency-(acquisition_finish_time-acquisition_start)
scope.mmc.setProperty("TL-Shutter","State",0)
verbose_sleeper(until_next)
print "Timelapse completed"
results="Scan Completed"
return results
except KeyboardInterrupt:
print "print Timelapse was interupted after %s timepoints" % t
def image_position(self,
scope,
pos_label,
t,
x_target,
y_target,
afc_target,
c_to_image,
z_params,
delay_after_move):
##move stage
if self.afc_on_during_move:
scope.afc_on()
try: ##moving XYstage
scope.move_XYstage(x_target,
y_target,
blocking=True)
except KeyboardInterrupt:
raise CancelTimeLapse(pos_label=pos_label,
t=t)
except:
raise StageMovementError
time.sleep(delay_after_move)
try: ##focusing to offset
if self.afc_on_during_move:
scope.mmc.enableContinuousFocus(False)
autofocus_device = scope.mmc.getAutoFocusDevice()
scope.mmc.waitForDevice(autofocus_device)
time.sleep(1)
scope.move_to_offset(afc_target,
post_focus_delay=.1,
attempt_delay=.1)
except UnableToFocusAFC :
if self.force_focus:
raise
else:
pass
try:
images,metadata=scope.multichannel_zstack(
c_to_image,
z_params=z_params)
except ConfigError:
print "#!#!"*10
print "Error in MDA configuration. Please fix the configurations file."
print "#!#!"*10
raise
except:
print "This wasnt the exception that i wanted"
raise ImageAcquisitionError()
for c in range(0,len(c_to_image)):
stack=images[c]
md_stack=metadata[c]
channel_name=c_to_image[c][1]
full_save_dir=os.path.join(
self.save_dir,
pos_label,
channel_name)
full_file_name="%s_%s_c%s%s_t%s" % (
self.file_name_prefix,
pos_label,
c,
channel_name,
t)
md=md_stack[len(md_stack)/2]
md=self.append_experimental_md(md,
t,
pos_label,
channel_name)
try:
## TODO handle saving of images as a child process?
file_out.stack_writer(full_save_dir,
full_file_name,
stack,
md)
self.file_log.append((full_file_name,full_save_dir))
except:
try:
if self.backup_save_path:
if os.path.isdir(self.backup_save_path) is False:
os.mkdir(self.backup_save_path)
file_out.stack_writer(self.backup_save_path,
full_file_name,
stack,
md)
print "Warning! Your first save path failed"
print "%s written to backup save path" % full_file_name
self.file_log.append((full_file_name,self.backup_save_path))
else:
print "You did not have the backup path set"
print "%s was not saved" % full_file_name
except:
#TODO: Handle this case a little better?
print "Warning! Your backup save failed."
print "Proceeding with timelapse..."
for setting in self.end_location_settings:
try:
device_label,prop,value=setting
self.scope.property_changer(device_label,prop,value,blocking=False)
except:
print "Unable to apply setting: %s" % setting
pass