def __init__(self, name, idctrl, pgmenergy, lut="JIDEnergy2GapCalibrations.csv", energyConstant=False, polarisationConstant=False, gap_offset=None, feedbackPV=None): '''Constructor - Only succeed if it find the lookupTable table, otherwise raise exception.''' self.lut,self.header = load_lookup_table(LocalProperties.get("gda.config")+"/lookupTables/"+lut) self.idscannable = idctrl self.mono_energy = pgmenergy self.scannables = ScannableGroup(name, [pgmenergy, idctrl]) self.detune = gap_offset self.feedbackPV = feedbackPV self._busy = 0 self.setName(name) self.setLevel(3) self.setOutputFormat(["%10.6f"]) self.setInputNames([name]) self.setExtraNames([]) self.polarisation = 'LH' self.gap = 50 self.phase = 0 self.energyConstant = energyConstant self.polarisationConstant = polarisationConstant self.SCANNING = False if self.energyConstant and self.polarisationConstant: raise RuntimeError("Cannot create an instance with both energy and polarisation being constant.") self.isConfigured = False self.inputSignSwitched = False self.beamlinename = LocalProperties.get(LocalProperties.GDA_BEAMLINE_NAME) self.logger = logger.getChild(self.__class__.__name__)
def __init__(self, name, idctrl, pgmenergy, lut="JIDEnergy2GapCalibrations.txt", energyConstant=False, polarisationConstant=False): '''Constructor - Only succeed if it find the lookupTable table, otherwise raise exception.''' self.lut=loadLookupTable(LocalProperties.get("gda.config")+"/lookupTables/"+lut) self.idscannable=idctrl self.pgmenergy=pgmenergy self.scannables=ScannableGroup(name, [pgmenergy, idctrl]) self._busy=0 self.setName(name) self.setLevel(3) self.setOutputFormat(["%10.6f"]) self.setInputNames([name]) self.setExtraNames([]) self.order=1 self.polarisation=0.0 self.gap=50 self.polarisationMode='UNKNOWN' self.phase=0 self.energyConstant=energyConstant self.polarisationConstant=polarisationConstant self.SCANNING=False if self.energyConstant and self.polarisationConstant: raise Exception("Cannot create an instance with both energy and polarisation being constant.") self.isConfigured=False self.inputSignSwitched=False self.beamlinename=LocalProperties.get(LocalProperties.GDA_BEAMLINE_NAME) self.logger = logger.getChild(self.__class__.__name__)
def __init__(self, filespec=None, dir=None): self.format = LocalProperties.get( "gda.data.scan.datawriter.dataFormat") if dir != None and dir != "None": self.dir = dir else: self.dir = PathConstructor.createFromDefaultProperty() self.beamline = GDAMetadataProvider.getInstance().getMetadataValue( "instrument", LocalProperties.GDA_INSTRUMENT, "tmp") if (self.format == "NexusDataWriter"): #really should use scanFileName prefix rather than forcing to beamline- self.prefix = LocalProperties.get("gda.data.filePrefix", self.beamline + "-") self.ext = "nxs" if filespec == None: filespec = "%d" % NumTracker(self.beamline).currentFileNumber else: self.prefix = "" self.ext = "dat" if filespec == None: filespec = "%d" % NumTracker().currentFileNumber filespec = filespec.__str__() self.filename = self.tryFiles([ filespec, self.dir + "/" + filespec, self.prefix + filespec + "." + self.ext, self.dir + "/" + self.prefix + filespec + "." + self.ext, self.dir + "/" + filespec + "." + self.ext ]) if (self.filename == None): raise Exception("no file found for %s" % filespec)
def __init__(self, filespec=None, dir=None): self.format = LocalProperties.get("gda.data.scan.datawriter.dataFormat") if dir!=None and dir != "None": self.dir=dir else: self.dir = PathConstructor.createFromDefaultProperty() self.beamline = GDAMetadataProvider.getInstance().getMetadataValue("instrument", LocalProperties.GDA_INSTRUMENT, "tmp") if (self.format == "NexusDataWriter"): #really should use scanFileName prefix rather than forcing to beamline- self.prefix = LocalProperties.get("gda.data.filePrefix",self.beamline + "-") self.ext = "nxs" if filespec==None: filespec = "%d" % NumTracker(self.beamline).currentFileNumber else: self.prefix = "" self.ext = "dat" if filespec==None: filespec = "%d" % NumTracker().currentFileNumber filespec = filespec.__str__() self.filename = self.tryFiles([ filespec, self.dir+"/"+filespec, self.prefix+filespec+"."+self.ext, self.dir+"/"+self.prefix+filespec+"."+self.ext, self.dir+"/"+filespec+"."+self.ext ]) if (self.filename == None): raise Exception("no file found for %s" % filespec)
def setDir(proposal, visit, LocalProperties=LocalProperties): #get beamline name from GDA propertie #beamlineName = LocalProperties.get("gda.beamline.name"); beamlineName = LocalProperties.get("gda.instrument.name"); commissioningProposal = bpDict.get(beamlineName, 'unknownPorposal'); if proposal == commissioningProposal: # the default commissioning proposal userDir = proposal; else: userDir = proposal + "-" + str(visit); #get current Year currentTime = time.localtime(); currentYear = currentTime[0]; userDir="/dls/" + beamlineName + "/data/" + str(currentYear) + "/" + userDir; symbolicLink = "/dls/" + beamlineName + "/data/operation"; print "New user data directory is: " + userDir; #remove the old symbolic link os.system("rm -f " + symbolicLink); #create the new symbolic link to point to the user data directory os.system("ln -s " + userDir + " " + symbolicLink);
def __getGdaModeProperty(): mode = str(LocalProperties.get("gda.mode")) if mode not in ("live", "dummy", "simulation"): raise ValueError( "gda.mode LocalProperty (perhaps via a System property) must be 'live' or 'dummy' not:", mode) return mode
def setDir(proposal=None, visit=1): #get beamline name from GDA propertie #beamlineName = LocalProperties.get("gda.instrument"); beamlineName = LocalProperties.get("gda.beamline.name") commissioningProposal = bpDict.get(beamlineName, 'unknownPorposal') if proposal is None: # the default commissioning proposal proposal = commissioningProposal userDir = proposal + "-" + str(visit) #get current Year currentTime = localtime() currentYear = currentTime[0] userDir = "/dls/" + beamlineName + "/data/" + str( currentYear) + "/" + userDir symbolicLink = "/dls/" + beamlineName + "/data/operation" print "New user data directory is: " + userDir #remove the old symbolic link system("rm -f " + symbolicLink) #create the new symbolic link to point to the user data directory system("ln -s " + userDir + " " + symbolicLink)
def __init__(self, name, idgap, dcmenergy, lut, gap_offset=None, feedbackPVs=None): """ Constructor - Only succeeds if it finds the lookup table, otherwise raises exception. """ self.lut = readLookupTable( LocalProperties.get("gda.config") + "/lookupTables/" + lut) self.gap = idgap self.mono_energy = dcmenergy self.lambdau = 27 # undulator period self.scannables = ScannableGroup(name, [dcmenergy, idgap]) self.detune = gap_offset self.feedbackPVs = feedbackPVs self._busy = 0 self.setName(name) self.setLevel(3) self.setOutputFormat(["%10.6f"]) self.inputNames = [name] self.order = 3 self.SCANNING = False self.logger = logger.getChild(self.__class__.__name__)
def doCalibration(self, calibrant='Si', calibrant_x=0, calibrant_y=0, calibrant_exposure=1.0): if self.calibration_required: mycalibrant=Finder.getInstance().find("calibrant_name") mycalibrant.moveTo(calibrant) dummyScannable=DummyScannable("dummyScannable") #additional_plugin_list = pixium.getAdditionalPluginList()[0] #Detector calibration if self.calibration_required: self.stage_x.moveTo(calibrant_x) self.stage_y.moveTo(calibrant_y) scan([dummyScannable, 1, 1, 1, self.pixium, calibrant_exposure]) #TODO GDA .nxs file, not EPICS h5 file scan_data_point_provider = InterfaceProvider.getScanDataPointProvider() self.calibrant_file_name = scan_data_point_provider.getLastScanDataPoint().getCurrentFilename() #calibrant_file_name = additional_plugin_list.getFullFileName() #do detector calibration on cluster serevrs builder = OSCommandRunnerBuilder.defaults() builder=builder.command([LocalProperties.get("org.opengda.lde.pixium.data.reduction.script","/dls_sw/apps/i11-scripts/bin/LDE-RunFromGDAAtEndOfScan.sh")]) builder=builder.keepOutput(True) builder = builder.inputFilename(self.calibrant_file_name) builder = builder.outputFilename(os.path.splitext(self.calibrant_file_name)[0]+"_output.log") builder=builder.noTimeout() builder.build() self.calibration_required=False
def loadEnergyFocus(): stashFilePath = LocalProperties.get( "gda.var") + "/energyFocusFunction.json" print("Loading energy/focus parameters from " + abspath(stashFilePath)) try: stashFile = open(stashFilePath, 'r') stashedValue = json.load(stashFile) stashFile.close() slopeDividend = stashedValue.get('slopeDividend') interception = stashedValue.get('interception') slopeDivisor = stashedValue.get('slopeDivisor') except: print("Cannot load stored energy focus values from " + abspath(stashFilePath) + ", using defaults") slopeDividend = u'0.0 µm' interception = u'0.0 µm' slopeDivisor = '1.0 eV' energyFocusFunction.setSlopeDividend( QuantityFactory.createFromString(slopeDividend)) energyFocusFunction.setInterception( QuantityFactory.createFromString(interception)) energyFocusFunction.setSlopeDivisor( QuantityFactory.createFromString(slopeDivisor)) print("energyFocusFunction set to: " + energyFocusFunction.toString())
def reload(self, commandServer): self.commandServer = commandServer self.jythonNamespaceMapping = {} self.jythonNamespaceMapFilePath = LocalProperties.get( JYTHON_NAMESPACE_MAPPING_FILE_PROPERTY) if (self.jythonNamespaceMapFilePath != None): self.jythonNamespaceMapping = readDictionaryFromFile( self.jythonNamespaceMapFilePath, self.jythonNamespaceMapping)
def reload(self, finder): self.finder = finder self.finderNameMapping = {} self.finderNameMapFilePath = LocalProperties.get( FINDER_NAME_MAPPING_FILE_PROPERTY) if (self.finderNameMapFilePath != None): self.finderNameMapping = readDictionaryFromFile( self.finderNameMapFilePath, self.finderNameMapping)
def dataCollection(samples=[]): lookuptable=readLookupTable(LocalProperties.get("gda.function.lookupTable.dir")+os.path.sep+"lde_stages_home_positions.txt") for each in lookuptable.keys: stage=StageDataCollection(each) for sample in samples: if sample["cell_ID"].contains(each): stage.addSample(sample) stage.processSamples()
def __init__(self, stageName): self.name=stageName self.calibrant_file_name=None self.stage_x=Finder.getInstance().find(stageName+"x") self.stage_y=Finder.getInstance().find(stageName+"y") self.stage_rot=Finder.getInstance().find(stageName+"rot") self.lookup_table = readLookupTable(LocalProperties.get("gda.function.lookupTable.dir")+os.path.sep+"lde_stages_home_positions.txt") self.samples=[] self.calibration_required=True self.pixium=Finder.getInstance().find('pixium_hdf')
def reload(self, parametersFilePath=None): if parametersFilePath == None: self.parametersFilePath = LocalProperties.get( BEAMLINE_PARAMETERS_FILE_PROPERTY) if (self.parametersFilePath == None): raise AttributeError, "property " + BEAMLINE_PARAMETERS_FILE_PROPERTY + " is not set" else: self.parametersFilePath = parametersFilePath self.parameters = {} self.parameters = readDictionaryFromFile(self.parametersFilePath, self.parameters)
def __init__(self, name): logger.debug("Camera Setup") self.pin = -1 self.device = name self.setName(name) self.currentPosition = 0 self.lastPosition = 0 # required self.busyStatus = False beamlineName = LocalProperties.get("gda.beamline.name") self.numTracker = data.NumTracker(beamlineName) rpiComms.rpiCommunicator.scannables.append(self)
def __init__(self, name): logger.debug("Camera Setup") self.pin = -1 self.device = name self.setName(name) self.currentPosition = 0 self.lastPosition = 0 # required self.busyStatus = False beamlineName = LocalProperties.get("gda.beamline.name") self.numTracker = data.NumTracker(beamlineName) rpiComms.rpiCommunicator.scannables.append(self)
def __init__(self, name): #setup stuff logger.debug("Camera Setup") #self.pin = -1 self.device = name self.setName( name) #this is setting up the name passed in localstation.py self.currentPosition = 0 self.lastPosition = 0 # required self.busyStatus = False beamlineName = LocalProperties.get("gda.beamline.name") self.numTracker = data.NumTracker(beamlineName) print "camera setup"
def getLastCommand(self): #jsf=InterfaceProvider.getJythonNamespace() jsf=JythonServerFacade.getInstance(); historyFilePath = LocalProperties.get("gda.jythonTerminal.commandHistory.path", jsf.getDefaultScriptProjectFolder()); historyFileName = os.path.join(historyFilePath, ".cmdHistory.txt") if not os.path.exists(historyFileName): print "No history found" strCmd='' else: historyFile=open(historyFileName, 'r'); strCmd=( historyFile.readlines() )[-1]; historyFile.close(); #print "The last command is: " + strCmd; return strCmd
def loadsampleinformationfile(filename, LocalProperties=LocalProperties): """Load sample information from users provided Excel spreadsheet into GDA system. usage: loadsampleinformationfile('/absolute/File/Path/To/Excel/Spreadsheet') """ vardir = LocalProperties.get("gda.config") + "/var"; defaulfFilename = vardir + "/SampleInfo.xls"; #copy user supplied file over to GDA system val=os.system("cp -f " + filename + " " + defaulfFilename); if val == 0: print "load completed." else: raise Exception("File load failed.") # health check on file read/write permissions si.setSampleInfoFile(defaulfFilename) #@UndefinedVariable
def __init__(self, name, lut): """ Constructor - Only succeeds if it finds the lookup table, otherwise raises exception. """ self.lut = readLookupTable( LocalProperties.get("gda.config") + "/lookupTables/" + lut) self.gap = "igap" self.dcm = "dcmenergy" self.lambdau = 27 # undulator period self.scannableNames = ["dcmenergy", "igap"] self.scannables = ScannableGroup( name, [Finder.find(x) for x in self.scannableNames]) self._busy = 0 self.setName(name) self.setLevel(3) self.setOutputFormat(["%10.6f"]) self.inputNames = [name] self.order = 3 self.logger = logger.getChild(self.__class__.__name__)
def __init__(self, name, idgap, pgmenergy, lut, gap_offset=None, feedbackPV=None): """ Constructor - Only succeeds if it finds the lookup table, otherwise raises exception. """ self.lut = readLookupTable(LocalProperties.get("gda.config") + "/lookupTables/" + lut) self.gap = idgap self.mono_energy = pgmenergy self.scannables = ScannableGroup(name, [pgmenergy, idgap]) self.detune=gap_offset self.feedbackPV=feedbackPV self._busy = 0 self.setName(name) self.setLevel(3) self.setOutputFormat(["%10.6f"]) self.inputNames = [name] self.SCANNING=False self.order = 1 self.polarisation = 'LH' self.jidphase = Finder.find("jidphase") self.logger = logger.getChild(self.__class__.__name__)
def getDir(proposal, visit, LocalProperties=LocalProperties): #get beamline name from GDA propertie #beamlineName = LocalProperties.get("gda.beamline.name"); beamlineName = LocalProperties.get("gda.instrument.name"); commissioningProposal = bpDict.get(beamlineName, 'unknownPorposal'); if proposal == commissioningProposal: # the default commissioning proposal userDir = proposal; else: userDir = proposal + "-" + str(visit); #get current Year currentTime = time.localtime(); currentYear = currentTime[0]; userDir="/dls/" + beamlineName + "/data/" + str(currentYear) + "/" + userDir; symbolicLink = "/dls/" + beamlineName + "/data/operation"; print userDir + " is the user data directory for this proposal and visit.";
def getDir(proposal, visit, LocalProperties=LocalProperties): #get beamline name from GDA propertie #beamlineName = LocalProperties.get("gda.beamline.name"); beamlineName = LocalProperties.get("gda.instrument.name") commissioningProposal = bpDict.get(beamlineName, 'unknownPorposal') if proposal == commissioningProposal: # the default commissioning proposal userDir = proposal else: userDir = proposal + "-" + str(visit) #get current Year currentTime = time.localtime() currentYear = currentTime[0] userDir = "/dls/" + beamlineName + "/data/" + str( currentYear) + "/" + userDir symbolicLink = "/dls/" + beamlineName + "/data/operation" print userDir + " is the user data directory for this proposal and visit."
def __init__(self, name, gap="jgap", dcm="pgmenergy", undulatorperiod=27, lut="JIDCalibrationTable.txt"): '''Constructor - Only succeed if it find the lookup table, otherwise raise exception.''' self.lut=readLookupTable(LocalProperties.get("gda.config")+"/lookupTables/"+lut) self.gap=gap self.dcm=dcm self.lambdau=undulatorperiod if dcm is None: self.scannableNames=[gap] else: self.scannableNames=[dcm,gap] self.scannables=ScannableGroup(name, [Finder.find(x) for x in self.scannableNames]) self._busy=0 self.setName(name) self.setLevel(3) self.setOutputFormat(["%10.6f"]) self.inputNames=[name] if self.dcm == "dcmenergy": self.order=3 else: self.order=1 self.energy=self.scannables.getGroupMember(self.scannableNames[0]).getPosition() self.polarisation='H'
def doSampleDataCollection(self, sample_x_start=None, sample_x_stop=None, sample_x_step=None, sample_y_start=None, sample_y_stop=None, sample_y_step=None, sample_exposure=1.0): # sample diffraction data args=[] if sample_x_start is not None or sample_x_stop is not None or sample_x_step is not None: args.append(self.stage_x) if sample_y_start is not None: args.append(sample_x_start) if sample_y_stop is not None: args.append(sample_x_stop) if sample_y_step is not None: args.append(sample_x_step) if sample_y_start is not None or sample_y_stop is not None or sample_y_step is not None: args.append(self.stage_y) if sample_y_start is not None: args.append(sample_y_start) if sample_y_stop is not None: args.append(sample_y_stop) if sample_y_step is not None: args.append(sample_y_step) if args.count!=0: args.append(self.pixium) args.append(sample_exposure) scan(args) #sample_file_name = additional_plugin_list.getFullFileName() scan_data_point_provider = InterfaceProvider.getScanDataPointProvider() sample_file_name = scan_data_point_provider.getLastScanDataPoint().getCurrentFilename() #builder = OSCommandRunnerBuilder.defaults() builder = OSCommandRunnerBuilder.defaults() builder=builder.command([LocalProperties.get("org.opengda.lde.pixium.data.reduction.script","/dls_sw/apps/i11-scripts/bin/LDE-RunFromGDAAtEndOfScan.sh"),self.calibrant_file_name]) builder=builder.keepOutput(True) builder = builder.inputFilename(sample_file_name) builder = builder.outputFilename(os.path.splitext(sample_file_name)[0]+"_output.log") builder=builder.noTimeout() builder.build()
fileHeader = MetadataHeaderDeviceClass("fileHeader") import __main__ # @UnresolvedImport blList = [__main__.beamenergy, __main__.ringcurrent] fileHeader.add(blList) #bpmList= [xbpm1x, xbpm1y, xbpm2x, xbpm2y, xbpm1anglex, xbpm1angley]; fileHeader.add(bpmList); idList = [ __main__.iddgap, __main__.iddtrp, __main__.iddbrp, __main__.idugap, __main__.idutrp, __main__.idubrp, __main__.pugap ] fileHeader.add(idList) beamline = LocalProperties.get(LocalProperties.GDA_BEAMLINE_NAME) if installation.isLive() and beamline != "lab44": pgmList = [ __main__.pgmpitch, __main__.pgmgratpitch, __main__.cff, __main__.grating, __main__.pgmenergy ] else: #grating requires EPICS access pgmList = [ __main__.pgmpitch, __main__.pgmgratpitch, __main__.cff, __main__.pgmenergy ] fileHeader.add(pgmList)
def parkingAllDevices(): '''move all stages to parking positions''' lookuptable=readLookupTable(LocalProperties.get("gda.function.lookupTable.dir")+os.path.sep+"lde_stages_home_positions.txt") for each in lookuptable.keys: stage=StageDataCollection(each) stage.moveToSafePosition()
''' Created on 29 Jan 2014 @author: fy65 ''' from time import sleep from gda.configuration.properties import LocalProperties from gda.data import NumTracker scanNumTracker=NumTracker(LocalProperties.get(LocalProperties.GDA_BEAMLINE_NAME)) scanNumTracker.incrementNumber() EXPOSURETIME=120 #seconds TARGETCOUNT=100000 ONEMINUTECOUNT=1000 DELTAMIN=-15.0 DELTAMAX=77.0 scancount=0 Tolerance=0.1 NUMBEROFSCANS=TARGETCOUNT/ONEMINUTECOUNT*60/EXPOSURETIME print "Number of scans to do: %d, total time taken: %f" % (NUMBEROFSCANS, NUMBEROFSCANS*EXPOSURETIME) mythen.configure() # @UndefinedVariable mythen.atScanStart() # @UndefinedVariable mythen.setCollectionTime(EXPOSURETIME+10) # @UndefinedVariable delta.moveTo(DELTAMIN) # @UndefinedVariable delta.setSpeed((DELTAMAX-DELTAMIN)/(EXPOSURETIME)) # @UndefinedVariable target=DELTAMAX for i in range(NUMBEROFSCANS): sleep(5) if scancount % 2==0: target=DELTAMAX else:
import sys from gda.jython import InterfaceProvider from gda.jython.commands.GeneralCommands import alias from Diamond.Utility.UtilFun import UtilFunctions from Diamond.Utility.BeamlineFunctions import BeamlineFunctionClass, logger from Diamond.PseudoDevices.FastEnergyScan import FastEnergyScanControlClass, FastEnergyScanIDModeClass from Diamond.PseudoDevices.FastEnergyScan import FastEnergyDeviceClass #from Diamond.PseudoDevices.FastEnergyScan import EpicsScandataDeviceClass; from Diamond.PseudoDevices.FastEnergyScan import EpicsWaveformDeviceClass from gda.configuration.properties import LocalProperties uuu = UtilFunctions() beamline_name = LocalProperties.get(LocalProperties.GDA_BEAMLINE_NAME, "i06") beamlineutil = BeamlineFunctionClass(beamline_name) # Change rootPV to switch zacscan between IDs. (search for "switch zacscan" to find other changes needed) rootPV = "BL06J-MO-FSCAN-01" fastScanElementCounter = "iddFastScanElementCounter" #rootPV = "BL06J-MO-FSCAN-02"; #fastScanElementCounter="iduFastScanElementCounter" fesController = FastEnergyScanControlClass("fesController", rootPV) zacmode = FastEnergyScanIDModeClass("zacmode", fesController) #fesData = EpicsScandataDeviceClass("fesData", rootPV); fesData = EpicsWaveformDeviceClass( "fesData", rootPV, ['C1', 'C2', 'C3', 'C4', 'iddenergy', 'pgmenergy', 'C5', 'C6'], ['idio', 'ifio'], elementCounter=fastScanElementCounter)
def _getCurrentFileName(filenumber): ''' convert relative file number to its absolute path to the file with file extension as ".dat"''' filename = str(filenumber) if long(filenumber) < 0: filename = os.path.join(PathConstructor.createFromDefaultProperty(),str(int(NumTracker(LocalProperties.get(LocalProperties.GDA_BEAMLINE_NAME)).getCurrentFileNumber()+int(filenumber)))+".dat") else: filename = os.path.join(PathConstructor.createFromDefaultProperty(),str(filenumber)+ ".dat") return filename
''' Created on 17 Apr 2018 @author: fy65 ''' from gda.configuration.properties import LocalProperties lookup_tables_dir = LocalProperties.get("gda.function.lookupTable.dir")
''' Scannable defines the X-ray source mode to be one of ['idd','idu','dpu','dmu'] in GDA only. It enables and disable 'zacscan' support when sets the mode value. Created on 13 Apr 2017 @author: fy65 ''' from gda.device.scannable import ScannableBase from gda.configuration.properties import LocalProperties from time import sleep from gda.jython.commands import GeneralCommands from i06shared import installation gda_git_loc = LocalProperties.get(LocalProperties.GDA_GIT_LOC) class SourceMode(ScannableBase): ''' implements the 4 X-ray beam source modes 1. Single operation of HU64a - specified by value 'idd' 2. Single operation of HU64b - specified by value 'idu' 3. Operation of HU64a and HU64b in the same polarisation - specified by value 'dpu' 4. Operation of HU64a and HU64b, but with different polarisations - specified by value 'dmu' Instance of this Scannable set/get source mode value in GDA only which - enables 'zacscan' for the single source modes - 'idd' and 'idu' - disables 'zacscan' for combined source modes - 'dpu' and 'dmu' ''' SOURCE_MODES = ['idd', 'idu', 'dpu', 'dmu', 'unknown']
def tomoScanWithFrames(description, inBeamPosition, outOfBeamPosition, exposureTime=1., start=0., stop=180., step=0.1, darkFieldInterval=0, flatFieldInterval=0, imagesPerDark=10, imagesPerFlat=10, optimizeBeamInterval=0, pattern="default", nframes=1, tomoRotationAxis=0, addNXEntry=True, autoAnalyse=True, additionalScannables=[]): """ Function to collect a tomography step scan with multiple projection frames per scan point Arguments: description - description of the scan or the sample that is being scanned. This is generally user-specific information that may be used to map to this scan later and is available in the NeXus file) inBeamPosition - position of X drive to move sample into the beam to take a projection outOfBeamPosition - position of X drive to move sample out of the beam to take a flat field image exposureTime - exposure time in seconds (default=1.0) start - first rotation angle (default=0.0) stop - last rotation angle (default=180.0) step - rotation step size (default=0.1) darkFieldInterval - number of projection-frame sub-series between each dark-field sub-series. NOTE: at least 1 dark is ALWAYS taken both at the start and end of the scan, provided imagesPerDark>0 (default=0: use this value if you DON'T want to take any darks between projections) flatFieldInterval - number of projection-frame sub-series between each flat-field sub-series. NOTE: at least 1 flat is ALWAYS taken both at the start and end the scan, provided imagesPerFlat>0 (default=0: use this value if you DON'T want to take any flats between projections) imagesPerDark - number of images to be taken in each dark-field sub-series (default=10) imagesPerFlat - number of images to be taken in each flat-field sub-series (default=10) nframes - number of projection frames per angular position (default=1) General scan sequence is: D, F, P,..., P, F, D where D stands for dark field, F - for flat field, and P - for projection. """ dataFormat = LocalProperties.get("gda.data.scan.datawriter.dataFormat") try: darkFieldInterval = int(darkFieldInterval) flatFieldInterval = int(flatFieldInterval) optimizeBeamInterval = int(optimizeBeamInterval) image_key_frame = 3 nframes = int(nframes) if nframes < 1: nframes = 1 jns = beamline_parameters.JythonNameSpaceMapping( InterfaceProvider.getJythonNamespace()) tomography_theta = jns.tomography_theta if tomography_theta is None: raise NameError( "tomography_theta is not defined in Jython namespace") tomography_shutter = jns.tomography_shutter if tomography_shutter is None: raise NameError( "tomography_shutter is not defined in Jython namespace") tomography_translation = jns.tomography_translation if tomography_translation is None: raise NameError( "tomography_translation is not defined in Jython namespace") tomography_detector = jns.tomography_detector if tomography_detector is None: raise NameError( "tomography_detector is not defined in Jython namespace") tomography_optimizer = jns.tomography_optimizer if tomography_optimizer is None: raise NameError( "tomography_optimizer is not defined in Jython namespace") tomography_time = jns.tomography_time if tomography_time is None: raise NameError( "tomography_time is not defined in Jython namespace") tomography_beammonitor = jns.tomography_beammonitor if tomography_beammonitor is None: raise NameError( "tomography_beammonitor is not defined in Jython namespace") tomography_camera_stage = jns.tomography_camera_stage if tomography_camera_stage is None: raise NameError( "tomography_camera_stage is not defined in Jython namespace") tomography_sample_stage = jns.tomography_sample_stage if tomography_sample_stage is None: raise NameError( "tomography_sample_stage is not defined in Jython namespace") tomo_additional_scannables = jns.tomography_additional_scannables if tomo_additional_scannables is None: raise NameError( "tomo_additional_scannables is not defined in Jython namespace" ) index = SimpleScannable() index.setCurrentPosition(0.0) index.setInputNames(["imageNumber"]) index.setName("imageNumber") index.configure() image_key = SimpleScannable() image_key.setCurrentPosition(0.0) image_key.setInputNames(["image_key"]) image_key.setName("image_key") image_key.configure() tomoScanDevice = make_tomoScanDevice(tomography_theta, tomography_shutter, tomography_translation, tomography_optimizer, image_key, index) # return tomoScanDevice #generate list of positions numberSteps = ScannableUtils.getNumberSteps(tomography_theta, start, stop, step) theta_points = [] theta_points.append(start) previousPoint = start for i in range(numberSteps): nextPoint = ScannableUtils.calculateNextPoint(previousPoint, step) theta_points.append(nextPoint) previousPoint = nextPoint #generateScanPoints optimizeBeamNo = 0 optimizeBeamYes = 1 shutterOpen = 1 shutterClosed = 0 shutterNoChange = 2 scan_points = [] theta_pos = theta_points[0] index = 0 #Added shutterNoChange state for the shutter. The scan points are added using the (pseudo) ternary operator, #if index is 0 then the shutterPosition is added to the scan point, else shutterNoChange is added to scan points. for i in range(imagesPerDark): scan_points.append( (theta_pos, [shutterClosed, shutterNoChange][i != 0], inBeamPosition, optimizeBeamNo, image_key_dark, index)) #dark index = index + 1 for i in range(imagesPerFlat): scan_points.append( (theta_pos, [shutterOpen, shutterNoChange][i != 0], outOfBeamPosition, optimizeBeamNo, image_key_flat, index)) #flat index = index + 1 for frm in range(nframes): scan_points.append( (theta_pos, shutterOpen, inBeamPosition, optimizeBeamNo, image_key_project if frm == 0 else image_key_frame, index)) #first index = index + 1 imageSinceDark = 1 imageSinceFlat = 1 optimizeBeam = 0 for i in range(numberSteps): theta_pos = theta_points[i + 1] for frm in range(nframes): scan_points.append( (theta_pos, [shutterOpen, shutterNoChange ][i != 0], inBeamPosition, optimizeBeamNo, image_key_project if frm == 0 else image_key_frame, index)) #main image index = index + 1 imageSinceFlat = imageSinceFlat + 1 if imageSinceFlat == flatFieldInterval and flatFieldInterval != 0: for i in range(imagesPerFlat): scan_points.append( (theta_pos, [shutterOpen, shutterNoChange ][i != 0], outOfBeamPosition, optimizeBeamNo, image_key_flat, index)) index = index + 1 imageSinceFlat = 0 imageSinceDark = imageSinceDark + 1 if imageSinceDark == darkFieldInterval and darkFieldInterval != 0: for i in range(imagesPerDark): scan_points.append( (theta_pos, [shutterClosed, shutterNoChange][i != 0], inBeamPosition, optimizeBeamNo, image_key_dark, index)) index = index + 1 imageSinceDark = 0 optimizeBeam = optimizeBeam + 1 if optimizeBeam == optimizeBeamInterval and optimizeBeamInterval != 0: scan_points.append( (theta_pos, [shutterOpen, shutterNoChange][i != 0], inBeamPosition, optimizeBeamYes, image_key_project, index)) index = index + 1 optimizeBeam = 0 #add dark and flat only if not done in last steps if imageSinceFlat != 0: for i in range(imagesPerFlat): scan_points.append( (theta_pos, [shutterOpen, shutterNoChange][i != 0], outOfBeamPosition, optimizeBeamNo, image_key_flat, index)) #flat index = index + 1 if imageSinceDark != 0: for i in range(imagesPerDark): scan_points.append( (theta_pos, [shutterClosed, shutterNoChange][i != 0], inBeamPosition, optimizeBeamNo, image_key_dark, index)) #dark index = index + 1 # scan_points1 = generateScanPoints(inBeamPosition, outOfBeamPosition, theta_points, darkFieldInterval, flatFieldInterval, # imagesPerDark, imagesPerFlat, optimizeBeamInterval, pattern=pattern) # if pattern == 'default' or pattern == 'DFPFD': # i = 0 # for pt1 in scan_points1: # pt = scan_points[i] # if pt1 != pt: # print "Mismatch - please tell Kaz about your scan and its arguments!" # print "i = ", i # print "pt = ", pt # print "pt1 = ", pt1 # i += 1 #return None positionProvider = tomoScan_positions(start, stop, step, darkFieldInterval, imagesPerDark, flatFieldInterval, imagesPerFlat, \ inBeamPosition, outOfBeamPosition, optimizeBeamInterval, scan_points) scan_args = [ tomoScanDevice, positionProvider, tomography_time, tomography_beammonitor, tomography_detector, exposureTime, tomography_camera_stage, tomography_sample_stage ] #scan_args.append(RotationAxisScannable("approxCOR", tomoRotationAxis)) #meta_add(RotationAxisScannable("approxCOR", tomoRotationAxis)) #meta_add("RotationCoord_as_list", [tomoRotationAxis]) meta_add("approxCOR", tomoRotationAxis) for scannable in additionalScannables: scan_args.append(scannable) for scannable in tomo_additional_scannables: scan_args.append(scannable) ''' setting the description provided as the title''' if not description == None: setTitle(description) else: setTitle("undefined") dataFormat = LocalProperties.get("gda.data.scan.datawriter.dataFormat") if not dataFormat == "NexusDataWriter": handle_messages.simpleLog( "Data format inconsistent. Setting 'gda.data.scan.datawriter.dataFormat' to 'NexusDataWriter'" ) LocalProperties.set("gda.data.scan.datawriter.dataFormat", "NexusDataWriter") scanObject = createConcurrentScan(scan_args) if addNXEntry: addNXTomoSubentry(scanObject, tomography_detector.name, tomography_theta.name) scanObject.runScan() if autoAnalyse: lsdp = jns.lastScanDataPoint() OSCommandRunner.runNoWait([ "/dls_sw/apps/tomopy/tomopy/bin/gda/tomo_at_scan_end_kz", lsdp.currentFilename ], OSCommandRunner.LOGOPTION.ALWAYS, None) return scanObject except InterruptedException: exceptionType, exception, traceback = sys.exc_info() handle_messages.log(None, "User interrupted the scan", exceptionType, exception, traceback, False) raise InterruptedException("User interrupted the scan") except: exceptionType, exception, traceback = sys.exc_info() handle_messages.log(None, "Error during tomography scan", exceptionType, exception, traceback, False) raise Exception("Error during tomography scan", exception) finally: handle_messages.simpleLog( "Data Format reset to the original setting: " + dataFormat) LocalProperties.set("gda.data.scan.datawriter.dataFormat", dataFormat)
def isLive(): mode = LocalProperties.get("gda.mode") return mode =="live"
# See notes in: http://wiki.diamond.ac.uk/Wiki/Wiki.jsp?page=I06_Diffcalc try: import diffcalc except ImportError: from gda.configuration.properties import LocalProperties import sys diffcalc_path = LocalProperties.get( "gda.install.git.loc") + '/diffcalc.git' sys.path = [diffcalc_path] + sys.path print diffcalc_path + ' added to GDA Jython path.' import diffcalc from gdascripts.pd.dummy_pds import DummyPD from diffcalc.gdasupport.factory import create_objects, add_objects_to_namespace CREATE_DUMMY_AXES = False if CREATE_DUMMY_AXES: print "!!! Starting dummy diffcalc with tth, th, chi, phi and en." tth = DummyPD('tth') th = DummyPD('th') en = DummyPD('en') en(1500) diffcalc_energy = en else: print "!!! Starting LIVE diffcalc with th(dd2th), th(ddth), chi(dummy), phi(dummy) and denergy." tth = dd2th th = ddth diffcalc_energy = denergy chi = DummyPD('chi')
from gda.oe import OE from gda.oe.dofs import DOF from gda.device import ScannableMotion from gda.oe import OE from gda.device.epicsdevice import IEpicsDevice from gda.util.converters import IReloadableQuantitiesConverter # Channel access commands from gda.epics import CAClient from gda.epics.CAClient import * from org.pf.joi import Inspector # Get the location of the GDA beamline script directory from gda.configuration.properties import LocalProperties LocalProperties=LocalProperties gdaScriptDir = LocalProperties.get("gda.jython.gdaScriptDir") gdaScriptDir = gdaScriptDir + "/" userScriptDir = LocalProperties.get("gda.jython.userScriptDir") userScriptDir = userScriptDir + "/" commonScriptDir = LocalProperties.get("gda.jython.commonScriptDir") commonScriptDir = commonScriptDir + "/" # we need all OEs and their DOFs to be available in the # namespace, by wrapping references to them in Adapter objects finder = Finder.getInstance() OEs = [] DOFs=[] OEs = finder.listAllNames("OE"); for fullName in OEs: objRef = finder.find(fullName) # create an OE adapter object
IPYTHON = False try: from gda.device.scannable.scannablegroup import ScannableGroup from gdascripts.scannable.dummy import SingleInputDummy as Dummy from diffcmd.diffcmd_utils import alias_commands GDA = True except ImportError: # Not running in gda environment so fall back to minigda emulation from diffcalc.gdasupport.minigda.scannable import ScannableGroup from diffcalc.gdasupport.minigda.scannable import SingleFieldDummyScannable as Dummy GDA = False HELP_STRING = \ """Quick: https://github.com/DiamondLightSource/diffcalc/blob/master/README.rst Manual: http://diffcalc.readthedocs.io/en/latest/youmanual.html Type: > help ub > help hkl""" if GDA: from gda.configuration.properties import LocalProperties # @UnresolvedImport var_folder = LocalProperties.get("gda.var") diffcalc_persistance_path = os.path.join(var_folder, 'diffcalc') if not os.path.exists(diffcalc_persistance_path): print "Making diffcalc var folder:'%s'" % diffcalc_persistance_path os.makedirs(diffcalc_persistance_path) settings.ubcalc_persister = UBCalculationJSONPersister( diffcalc_persistance_path, YouStateEncoder) # else: should have been set if outside GDA
from gda.device.scannable.scannablegroup import ScannableGroup from gdascripts.scannable.dummy import SingleInputDummy as Dummy from diffcmd.diffcmd_utils import alias_commands GDA = True except ImportError: # Not running in gda environment so fall back to minigda emulation from diffcalc.gdasupport.minigda.scannable import ScannableGroup from diffcalc.gdasupport.minigda.scannable import SingleFieldDummyScannable as Dummy GDA = False HELP_STRING = \ """Quick: https://github.com/DiamondLightSource/diffcalc/blob/master/README.rst Manual: http://diffcalc.readthedocs.io/en/latest/youmanual.html Type: > help ub > help hkl""" if GDA: from gda.configuration.properties import LocalProperties var_folder = LocalProperties.get("gda.var") diffcalc_persistance_path = os.path.join(var_folder, 'diffcalc') if not os.path.exists(diffcalc_persistance_path): print "Making diffcalc var folder:'%s'" % diffcalc_persistance_path os.makedirs(diffcalc_persistance_path) settings.ubcalc_persister = UBCalculationJSONPersister(diffcalc_persistance_path) # else: should have been set if outside GDA
def FindScanPeak2(ordinateName, printNameList=[], abscissaNameList=[], scanID=0, peakRatio=-1, ToPrint=1, LocalProperties=LocalProperties): """ Values= FindScanPeak(ordinateName, printNameList=[], scanID='null', ToPrint=1) Finds the peak value within a scan (currently just the maximum value). Returns all values from this line as dictionary. If enabled prints some values from this line. Will return only a peak that extends at least peakRatio*noise_rate above the Poisson noise floor. If no peak large enougth exists then Values returned is empty. Keyword arguements: ordinateName -- the header name of the value whose peak is to be found printNameList -- a list of header names to print (if enabled), abscissaNameList -- NOT USED. may later be used for more advanced peak finding algorithms scanID -- leave empty to read most recent scan. Else a scan number or an absolute file path. If negative (-n), will find the peak of the scan n scans old. peakRatio -- If non-negative, this is the factor that a peak must extend above the Poisson noise floor to count. i.e. (peakValue-noise) >= peakRatio*noise, where noise is the avergae poisson noise floor. Be warned that the measured poisson noise floor is calculated without accounting for any real signal that may be present, so will be an overestimate. ToPrint -- Set to 0 to disable printing Returns: The values of all elements from the selected line in a dictionary with header names as keys (or an empty dictionary if peakRatio is ser, and no peak was found) Example: run FindScanPeak (as import is dodgy!) peakValues = FindScanPeak("y", ["x","y"], scanID = 15) #loads scan number 15, finds the maximum y, prints x and y, and returns all values. peakValues = FindScanPeak("y", ["x","y"], peakRatio=5) #loads the most recent scan and finds the maximum y if it large enougth, prints x and y, and returns all values. """ # ----- Generate path ----- # Use scanID as path if it is a string if type(scanID) == type('gda rocks'): filepath = scanID else: # Assemble a path from the scan number, using current scan if not given # If no scanID given, use current scan number if scanID <= 0: import gda.data.NumTracker numtracker = gda.data.NumTracker('tmp') scanID = numtracker.getCurrentFileNumber() + scanID # Implicit else: scanID must be a positive number # scanID now contains the number of a scan filepath = LocalProperties.get("gda.data.scan.datawriter.datadir") filepath = filepath + '/' + str(scanID) + '.dat' if ToPrint == 1: print "In file: %s" % filepath # ----- Read the file ----- (headerList, columnList) = readSRSDataFile(filepath) # ----- Turn these into dictionary objects with header names as keys ----- dataDict = {} for i in range(0, len(headerList)): dataDict[headerList[i]]=columnList[i] # ----- Find the index of the point ----- iPeak = findMaxPointNonInterp(dataDict[ordinateName]) # Get the value of the peak tempList = dataDict[ordinateName] peakValue = tempList[iPeak] # ----- Calculate statistics ----- y_array = dataDict[ordinateName] calc_noPoints = len(y_array) # Normal distribution statistics calc_mean = average(y_array) calc_stdDev = standardDeviation(y_array) # Poisson distribution statistics calc_lambda = calc_mean calc_poisson_stddev = math.sqrt(calc_lambda) # Threshold based on Poisson statistics calc_threshold = peakRatio*calc_poisson_stddev + calc_lambda # ----- Print some stuff unless ToPrint passed in as 0 ----- if ToPrint == 1: print "Max %s occurs at point %i (starting from 0) where:" % (ordinateName, iPeak) for i in range(0, len(printNameList)): tempList = dataDict[printNameList[i]] print "%s = %f" % (printNameList[i],tempList[iPeak]) print "" if (peakRatio >=0): # Show statistics as a peak threshold exists print "Number points: %i" % calc_noPoints print "Normal:\tmean: %f \t stddev: %f" % ( calc_mean, calc_stdDev) print "Poisson:\tlambda: %f \t stddev(noise): %f" % ( calc_lambda, calc_poisson_stddev) print "Threshold (%f*%f+%f) is:%f" % (peakRatio, calc_poisson_stddev, calc_lambda, calc_threshold) if peakValue>=calc_threshold: print "*Peak found*: The peak value of %f is greater than the threshold" % peakValue else: print "*No peak found* The peak value of %f less than the threshold" % peakValue # ----- Return a dict object of values line where max occured ----- # If threshold is exceeded... if ((peakValue>=calc_threshold) or peakRatio<0): maxPeak = {} for i in range(0, len(headerList)): tempList = dataDict[headerList[i]] maxPeak[headerList[i]] = tempList[iPeak] return maxPeak else: # Return an empty dictionary return {}
def setDataWriterToSrs(): oldDW = LocalProperties.get("gda.data.scan.datawriter.dataFormat") LocalProperties.set("gda.data.scan.datawriter.dataFormat", "SrsDataFile") newDW = LocalProperties.get("gda.data.scan.datawriter.dataFormat") print "Old DataWriter: ", oldDW print "New DataWriter: ", newDW
def tomoScan( description, inBeamPosition, outOfBeamPosition, exposureTime=1.0, start=0.0, stop=180.0, step=0.1, darkFieldInterval=0, flatFieldInterval=0, imagesPerDark=10, imagesPerFlat=10, optimizeBeamInterval=0, pattern="default", tomoRotationAxis=0, addNXEntry=True, autoAnalyse=True, additionalScannables=[], ): """ Function to collect a tomography step scan Arguments: description - description of the scan or the sample that is being scanned. This is generally user-specific information that may be used to map to this scan later and is available in the NeXus file) inBeamPosition - position of X drive to move sample into the beam to take a projection outOfBeamPosition - position of X drive to move sample out of the beam to take a flat field image exposureTime - exposure time in seconds (default=1.0) start - first rotation angle (default=0.0) stop - last rotation angle (default=180.0) step - rotation step size (default=0.1) darkFieldInterval - number of projections between each dark-field sub-sequence. NOTE: at least 1 dark is ALWAYS taken both at the start and end of the scan provided imagesPerDark>0 (default=0: use this value if you DON'T want to take any darks between projections) flatFieldInterval - number of projections between each flat-field sub-sequence. NOTE: at least 1 flat is ALWAYS taken both at the start and end the scan provided imagesPerFlat>0 (default=0: use this value if you DON'T want to take any flats between projections) imagesPerDark - number of images to be taken for each dark-field sub-sequence (default=10) imagesPerFlat - number of images to be taken for each flat-field sub-sequence (default=10) General scan sequence is: D, F, P,..., P, F, D where D stands for dark field, F - for flat field, and P - for projection. """ dataFormat = LocalProperties.get("gda.data.scan.datawriter.dataFormat") try: darkFieldInterval = int(darkFieldInterval) flatFieldInterval = int(flatFieldInterval) optimizeBeamInterval = int(optimizeBeamInterval) jns = beamline_parameters.JythonNameSpaceMapping(InterfaceProvider.getJythonNamespace()) tomography_theta = jns.tomography_theta if tomography_theta is None: raise "tomography_theta is not defined in Jython namespace" tomography_shutter = jns.tomography_shutter if tomography_shutter is None: raise "tomography_shutter is not defined in Jython namespace" tomography_translation = jns.tomography_translation if tomography_translation is None: raise "tomography_translation is not defined in Jython namespace" tomography_detector = jns.tomography_detector if tomography_detector is None: raise "tomography_detector is not defined in Jython namespace" tomography_optimizer = jns.tomography_optimizer if tomography_optimizer is None: raise "tomography_optimizer is not defined in Jython namespace" tomography_time = jns.tomography_time if tomography_time is None: raise "tomography_time is not defined in Jython namespace" tomography_beammonitor = jns.tomography_beammonitor if tomography_beammonitor is None: raise "tomography_beammonitor is not defined in Jython namespace" tomography_camera_stage = jns.tomography_camera_stage if tomography_camera_stage is None: raise "tomography_camera_stage is not defined in Jython namespace" tomography_sample_stage = jns.tomography_sample_stage if tomography_sample_stage is None: raise "tomography_sample_stage is not defined in Jython namespace" tomo_additional_scannables = jns.tomography_additional_scannables if tomo_additional_scannables is None: raise "tomo_additional_scannables is not defined in Jython namespace" index = SimpleScannable() index.setCurrentPosition(0.0) index.setInputNames(["imageNumber"]) index.setName("imageNumber") index.configure() image_key = SimpleScannable() image_key.setCurrentPosition(0.0) image_key.setInputNames(["image_key"]) image_key.setName("image_key") image_key.configure() tomoScanDevice = make_tomoScanDevice( tomography_theta, tomography_shutter, tomography_translation, tomography_optimizer, image_key, index ) # return tomoScanDevice # generate list of positions numberSteps = ScannableUtils.getNumberSteps(tomography_theta, start, stop, step) theta_points = [] theta_points.append(start) previousPoint = start for i in range(numberSteps): nextPoint = ScannableUtils.calculateNextPoint(previousPoint, step) theta_points.append(nextPoint) previousPoint = nextPoint # generateScanPoints optimizeBeamNo = 0 optimizeBeamYes = 1 shutterOpen = 1 shutterClosed = 0 shutterNoChange = 2 scan_points = [] theta_pos = theta_points[0] index = 0 # Added shutterNoChange state for the shutter. The scan points are added using the (pseudo) ternary operator, # if index is 0 then the shutterPosition is added to the scan point, else shutterNoChange is added to scan points. for i in range(imagesPerDark): scan_points.append( ( theta_pos, [shutterClosed, shutterNoChange][i != 0], inBeamPosition, optimizeBeamNo, image_key_dark, index, ) ) # dark index = index + 1 for i in range(imagesPerFlat): scan_points.append( ( theta_pos, [shutterOpen, shutterNoChange][i != 0], outOfBeamPosition, optimizeBeamNo, image_key_flat, index, ) ) # flat index = index + 1 scan_points.append((theta_pos, shutterOpen, inBeamPosition, optimizeBeamNo, image_key_project, index)) # first index = index + 1 imageSinceDark = 1 imageSinceFlat = 1 optimizeBeam = 0 for i in range(numberSteps): theta_pos = theta_points[i + 1] scan_points.append( ( theta_pos, [shutterOpen, shutterNoChange][i != 0], inBeamPosition, optimizeBeamNo, image_key_project, index, ) ) # main image index = index + 1 imageSinceFlat = imageSinceFlat + 1 if imageSinceFlat == flatFieldInterval and flatFieldInterval != 0: for i in range(imagesPerFlat): scan_points.append( ( theta_pos, [shutterOpen, shutterNoChange][i != 0], outOfBeamPosition, optimizeBeamNo, image_key_flat, index, ) ) index = index + 1 imageSinceFlat = 0 imageSinceDark = imageSinceDark + 1 if imageSinceDark == darkFieldInterval and darkFieldInterval != 0: for i in range(imagesPerDark): scan_points.append( ( theta_pos, [shutterClosed, shutterNoChange][i != 0], inBeamPosition, optimizeBeamNo, image_key_dark, index, ) ) index = index + 1 imageSinceDark = 0 optimizeBeam = optimizeBeam + 1 if optimizeBeam == optimizeBeamInterval and optimizeBeamInterval != 0: scan_points.append( ( theta_pos, [shutterOpen, shutterNoChange][i != 0], inBeamPosition, optimizeBeamYes, image_key_project, index, ) ) index = index + 1 optimizeBeam = 0 # add dark and flat only if not done in last steps if imageSinceFlat != 0: for i in range(imagesPerFlat): scan_points.append( ( theta_pos, [shutterOpen, shutterNoChange][i != 0], outOfBeamPosition, optimizeBeamNo, image_key_flat, index, ) ) # flat index = index + 1 if imageSinceDark != 0: for i in range(imagesPerDark): scan_points.append( ( theta_pos, [shutterClosed, shutterNoChange][i != 0], inBeamPosition, optimizeBeamNo, image_key_dark, index, ) ) # dark index = index + 1 scan_points1 = generateScanPoints( inBeamPosition, outOfBeamPosition, theta_points, darkFieldInterval, flatFieldInterval, imagesPerDark, imagesPerFlat, optimizeBeamInterval, pattern=pattern, ) if pattern == "default" or pattern == "DFPFD": i = 0 for pt1 in scan_points1: pt = scan_points[i] if pt1 != pt: print "Mismatch - please tell Kaz about your scan and its arguments!" print "i = ", i print "pt = ", pt print "pt1 = ", pt1 i += 1 # return None positionProvider = tomoScan_positions( start, stop, step, darkFieldInterval, imagesPerDark, flatFieldInterval, imagesPerFlat, inBeamPosition, outOfBeamPosition, optimizeBeamInterval, scan_points, ) scan_args = [ tomoScanDevice, positionProvider, tomography_time, tomography_beammonitor, tomography_detector, exposureTime, tomography_camera_stage, tomography_sample_stage, ] # scan_args.append(RotationAxisScannable("approxCOR", tomoRotationAxis)) # meta_add(RotationAxisScannable("approxCOR", tomoRotationAxis)) # meta_add("RotationCoord_as_list", [tomoRotationAxis]) meta_add("approxCOR", tomoRotationAxis) for scannable in additionalScannables: scan_args.append(scannable) for scannable in tomo_additional_scannables: scan_args.append(scannable) """ setting the description provided as the title""" if not description == None: setTitle(description) else: setTitle("undefined") dataFormat = LocalProperties.get("gda.data.scan.datawriter.dataFormat") if not dataFormat == "NexusDataWriter": handle_messages.simpleLog( "Data format inconsistent. Setting 'gda.data.scan.datawriter.dataFormat' to 'NexusDataWriter'" ) LocalProperties.set("gda.data.scan.datawriter.dataFormat", "NexusDataWriter") scanObject = createConcurrentScan(scan_args) if addNXEntry: addNXTomoSubentry(scanObject, tomography_detector.name, tomography_theta.name) scanObject.runScan() if autoAnalyse: lsdp = jns.lastScanDataPoint() OSCommandRunner.runNoWait( ["/dls_sw/apps/tomopy/tomopy/bin/gda/tomo_at_scan_end", lsdp.currentFilename], OSCommandRunner.LOGOPTION.ALWAYS, None, ) return scanObject except InterruptedException: exceptionType, exception, traceback = sys.exc_info() handle_messages.log(None, "User interrupted the scan", exceptionType, exception, traceback, False) raise InterruptedException("User interrupted the scan") except: exceptionType, exception, traceback = sys.exc_info() handle_messages.log(None, "Error during tomography scan", exceptionType, exception, traceback, False) raise Exception("Error during tomography scan", exception) finally: handle_messages.simpleLog("Data Format reset to the original setting: " + dataFormat) LocalProperties.set("gda.data.scan.datawriter.dataFormat", dataFormat)
def getDataWriter(): return LocalProperties.get("gda.data.scan.datawriter.dataFormat")
#localStation.py #For beamline specific initialisation code. print "===================================================================" print "Performing Beanline I06 Mobile Rack specific initialisation code (localStation_mobilerack.py)." print import sys from os import system from gda.configuration.properties import LocalProperties import scisoftpy as dnp # Get the locatation of the GDA beamline script directory gdaScriptDir = LocalProperties.get("gda.jython.gdaScriptDir") + "/" # Get the location of the USERS script directory userScriptDir = LocalProperties.get("gda.jython.userScriptDir") + "/" gdaDevScriptDir = LocalProperties.get("gda.jython.gdaDevScriptDir") + "/" try: execfile(gdaScriptDir + "BeamlineI06/beamline.py") except: exceptionType, exception, traceback = sys.exc_info() print "XXXXXXXXXX: beamline.py script error" raise RuntimeError("Basic beamline script error") try: #Setup the environment variables from Diamond.Utility.Functions import * execfile(gdaScriptDir + "BeamlineI06/createAlias.py")
def show(): print "ScanDataPoint pipeline:" print " " + lengthProp + " = " + LocalProperties.get( lengthProp, '4') # duplicated in ScannableCommands print " " + simultaneousProp + " = " + LocalProperties.get( simultaneousProp, '3') # duplicated in ScannableCommands
import os import sys from ScannableInvertedValue import PositionInvertedValue from gda.configuration.properties import LocalProperties from gda.jython.commands.GeneralCommands import run, alias # @UnusedImport from gdascripts.pd.time_pds import waittimeClass, showtimeClass, showincrementaltimeClass, actualTimeClass from gdascripts.scan.installStandardScansWithProcessing import * # @UnusedWildImport from gdascripts.watchdogs.watchdogs import enable_watchdogs, disable_watchdogs, list_watchdogs # @UnusedImport from gdascripts.malcolm.malcolm import reset_malcolm_after_scan from i08_shared_utilities import is_live, ls_scannables # Add config/scripts to import search path (why is this not already set in gda9?). # Also, this seems to be different to run search path... imh 11/11/2016 scriptDir = LocalProperties.get("gda.config") + "/scripts/" sys.path.append(os.path.abspath(scriptDir)) print("Initialisation Started") alias("setTitle") alias("meta_add") alias("meta_ll") alias("meta_ls") alias("meta_rm") scan_processor.rootNamespaceDict = globals() # @UndefinedVariable waittime = waittimeClass('waittime') showtime = showtimeClass('showtime') inctime = showincrementaltimeClass('inctime')
def isLive(): mode = LocalProperties.get("gda.mode") return mode =="live"
def whichformat(): return LocalProperties.get( LocalProperties.GDA_DATA_SCAN_DATAWRITER_DATAFORMAT)