def generateDetectorDictionary(configFileName): global ttAnalyze myWorkingDirectory = subprocess.check_output("pwd")[:-1] print("working directory = " + str(myWorkingDirectory)) print("reading config file") f = open(myWorkingDirectory + "/" + configFileName, 'r') myDetectorObjectDictionary = {} myDetectorObjectDictionary['analyzer'] = {} myDetectorObjectDictionary['summarizer'] = {} print("Generating analyzer summarizer and detector objects") #print(str(analysisFunctions.__dict__.keys())) for thisDetectorConfig in f: if ('#' not in thisDetectorConfig): myParsedString = thisDetectorConfig.split(',') print(thisDetectorConfig) print("found detector object named " + myParsedString[3]) try: test = psana.Detector(myParsedString[0]) except KeyError: print("detector named " + myParsedString[0] + " does not exist in this run") continue myDetectorObjectDictionary[myParsedString[3]] = psana.Detector( myParsedString[0]) if (myParsedString[4] != 'None'): myDetectorObjectDictionary['analyzer'][myParsedString[ 3]] = analysisFunctions.__dict__[myParsedString[4]] if (myParsedString[5] != 'None'): myDetectorObjectDictionary['summarizer'][myParsedString[ 3]] = analysisFunctions.__dict__[myParsedString[5]] else: pass if (ttAnalyze is not None): print("casting time tool as detector object") myDetectorObjectDictionary['TSS_OPAL'] = ttAnalyze myDetectorObjectDictionary['analyzer'][ 'TSS_OPAL'] = analysisFunctions.__dict__['getTimeToolData'] #myDetectorObjectDictionary['summarizer']['TSS_OPAL'] = None return myDetectorObjectDictionary
def setup(experimentName,runNumber,detInfo): ds = psana.DataSource('exp='+str(experimentName)+':run='+str(runNumber)+':idx') run = next(ds.runs()) times = run.times() env = ds.env() evt = run.event(times[0]) det = psana.Detector(str(detInfo), env) return run, times, det, evt
def get_raw_data(self, index): import psana from scitbx.array_family import flex assert len(self.params.detector_address) == 1 det = psana.Detector(self.params.detector_address[0], self._env) data = rayonix_tbx.get_data_from_psana_event( self._get_event(index), self.params.detector_address[0]) return flex.double(data)
def main(fileName): global my_dict my_hdf5_object = h5py.File("hdf5/xpptut15run440.h5", 'r') #convert hdf5 to dict my_list = [] def func(name, obj): my_list.append(name) my_hdf5_object.visititems(func) my_dict = {} for i in my_list: try: my_dict[i] = array(my_hdf5_object[i]) except: #IPython.embed() pass my_hdf5_object.close() #%matplotlib acqiris_alias = "Acq02" eigen_basis_file = "hdf5/xpptut15run440_eigen_basis.h5" experiment_name = "xpptut15" run_number = "440" channel_number = 3 event_number = int(200 * rand()) print("event number number for testing: " + str(event_number)) #################### ##################### my_eigen_basis = h5py.File(eigen_basis_file) eig_bas = array( my_eigen_basis['summary/nonMeaningfulCoreNumber0/' + acqiris_alias + '/ch' + str(channel_number) + '/norm_eigen_wave_forms']) import psana my_data_source = psana.MPIDataSource("exp=" + experiment_name + ":run=" + run_number + ":smd") acq_det_obj = psana.Detector(acqiris_alias) my_enum_events = enumerate(my_data_source.events()) for evt_num, this_event in my_enum_events: if evt_num > event_number: break my_index = argmax((this_event.get( psana.EventId).fiducials() == my_dict['fiducials']).astype(int)) #plot(acq_det_obj(this_event)[0][channel_number]-mean(acq_det_obj(this_event)[0][channel_number][:300])) plot( acq_det_obj(this_event)[0][channel_number] - mean(acq_det_obj(this_event)[0][channel_number][:300])) plot( dot( my_dict[acqiris_alias + '/ch' + str(channel_number) + '/weightings'][my_index], eig_bas), 'r.') ylim(-0.06, 0.0) xlim(1100, 1400) show()
def deployCenter(experimentName, runNumber, detectorName, newCx, newCy): ## deploy the new geometry file ## Calculate detector translation in x and y ds = psana.DataSource("exp=" + experimentName + ":run=" + str(runNumber) + ':idx') run = ds.runs().next() det = psana.Detector(detectorName) times = run.times() evt = None counter = 0 while evt is None: evt = run.event(times[counter]) # guarantee we have a valid event counter += 1 psanaCx, psanaCy = det.point_indexes(evt, pxy_um=(0, 0)) pixelSize = det.pixel_size(evt) print "##### current psana center: ", psanaCx, psanaCy dx = pixelSize * (psanaCx - newCx) # microns dy = pixelSize * (psanaCy - newCy) # microns geo = det.geometry(evt) if 'cspad' in detectorName.lower() and 'cxi' in experimentName: geo.move_geo('CSPAD:V1', 0, dx=dx, dy=dy, dz=0) elif 'rayonix' in detectorName.lower() and 'mfx' in experimentName: top = geo.get_top_geo() children = top.get_list_of_children()[0] geo.move_geo(children.oname, 0, dx=dx, dy=dy, dz=0) elif 'rayonix' in detectorName.lower() and 'xpp' in experimentName: top = geo.get_top_geo() children = top.get_list_of_children()[0] geo.move_geo(children.oname, 0, dx=dx, dy=dy, dz=0) else: print "autoDeploy not implemented" params = experiparams(experimentName=experimentName, runNumber=runNumber, detectorName=detectorName) fname = params.cxiDir + "/" + str(runNumber) + '-end.data' print "fname: ", fname geo.save_pars_in_file(fname) print "#################################################" print "Deploying psana detector geometry: ", fname print "#################################################" cmts = { 'exp': experimentName, 'app': 'psocake', 'comment': 'auto recentred geometry' } calibDir = '/reg/d/psdm/' + experimentName[:3] + '/' + experimentName + '/calib' deploy_calib_file(cdir=calibDir, src=str(det.name), type='geometry', run_start=int(runNumber), run_end=None, ifname=fname, dcmts=cmts, pbits=0)
def setupExperiment(self): self.ds = psana.DataSource('exp=' + str(self.exp) + ':run=' + str(self.run) + ':idx') self.run = self.ds.runs().next() self.times = self.run.times() self.eventTotal = len(self.times) self.env = self.ds.env() self.evt = self.run.event(self.times[0]) self.det = psana.Detector(str(self.detname), self.env) self.det.do_reshape_2d_to_3d(flag=True)
def get_detector_z(self, evt, src='CXI:DS2:MMS:06.RBV', offset=0.57538): try: dzp = psana.Detector(src, self.env_idx) dz = dzp(evt) * 1e-3 + offset except: dz = None print "(psanaWrapper.py) No detector distance found." return dz
def get_detector_z(self, evt, src='CXI:DS1:MMS:06.RBV'): try: dzp = psana.Detector(src, self.env_idx) dz = dzp(evt) except: dz = 0.5 print "(psanaWrapper.py) No detector distance found." return dz
def getCameraSaturationValue(evt): try: analysis_version = psana.Detector(Constants.ANALYSIS_VERSION) if analysis_version(evt) is not None: return (1 << 12) - 1 except: pass return (1 << 14) - 1
def _cache_psana_det(self): """Store a psana detector instance for each run""" assert len(self.params.detector_address) == 1 import psana self._psana_det = {} for run_number, run in self._psana_runs.items(): self._psana_det[run_number] = psana.Detector( self.params.detector_address[0], run.env())
def loadCspad(self, cspadsrc='CxiDs2.0:Cspad.0'): # # get a detector object # self.cspad = psana.Detector(cspadsrc, self.env_smd) self.shape = self.cspad.shape(par=0) self.size = self.cspad.size(par=0) self.ndim = self.cspad.ndim(par=0) self.instrument = self.cspad.instrument()
def mapstack2image(experimentName, runNumber, detectorName): ds = psana.DataSource("exp=" + experimentName + ":run=" + str(runNumber) + ':idx') run = ds.runs().next() det = psana.Detector(detectorName) times = run.times() evt = run.event(times[0]) stk2imgx = np.array(det.indexes_x(evt)) + 0.5 stk2imgy = np.array(det.indexes_y(evt)) + 0.5 return stk2imgx, stk2imgy
def getCalibrationValues(possible_detector_names): for i in range(len(possible_detector_names)): try: det = psana.Detector(possible_detector_names[i]) val = det(evt) if abs(val) < 1e-100: continue return val except KeyError: continue return None
def setupExperiment(self): access = 'exp=' + str(self.exp) + ':run=' + str(self.run) + ':idx' if 'ffb' in self.access.lower(): access += ':dir=/reg/d/ffb/' + self.exp[:3] + '/' + self.exp + '/xtc' self.ds = psana.DataSource(access) self.run = self.ds.runs().next() self.times = self.run.times() self.eventTotal = len(self.times) self.env = self.ds.env() self.evt = self.run.event(self.times[0]) self.det = psana.Detector(str(self.detname), self.env) self.det.do_reshape_2d_to_3d(flag=True)
def getStack(experimentName=None, runNumber=None, detInfo=None, eventInd=0): ds = psana.DataSource('exp=' + str(experimentName) + ':run=' + str(runNumber) + ':idx') run = ds.runs().next() times = run.times() env = ds.env() evt = run.event(times[0]) det = psana.Detector(str(detInfo), env) evt = run.event(times[eventInd]) stack = det.calib(evt) return stack
def __init__(self, name='epics', PVlist=[]): self.name = name self.detname='epics' self.PVlist = [] self.pvs = [] for pv in PVlist: try: self.pvs.append(psana.Detector(pv)) self.PVlist.append(pv) except: print('could not find EPICS PV %s in data'%pv)
def __init__(self, name='ttRaw', env=None): self.name = name self.detname = '' self.kind = 'stepDown' self.weights = None self.ttROI_signal = None self.ttROI_sideband = None self.ttROI_reference = None self.ttProj = False self.runningRef = None self.refitData = False self.useProjection = False self.beamOff = [] self.laserOff = [] self.sb_convergence = 1. self.ref_convergence = 1. self.subtract_sideband = False self.ttCalib = [0., 1.] ttCfg = None self.evrdet = psana.Detector('NoDetector.0:Evr.0') if env is None: env = psana.Env #getting the env this way unfortunatly does not work. Find out how psana.DetNames() does it. return for cfgKey in env.configStore().keys(): if cfgKey.type() == psana.TimeTool.ConfigV2: ttCfg = env.configStore().get(psana.TimeTool.ConfigV2, cfgKey.src()) self.detname = cfgKey.alias() defaultDetector.__init__(self, self.detname, 'ttRaw') if ttCfg is not None: self.ttProj = ttCfg.write_projections() self.ttROI_signal = [[ttCfg.sig_roi_lo().row(),ttCfg.sig_roi_hi().row()],\ [ttCfg.sig_roi_lo().column(),ttCfg.sig_roi_hi().column()]] self.ttROI_sideband = [[ttCfg.sb_roi_lo().row(),ttCfg.sb_roi_hi().row()],\ [ttCfg.sb_roi_lo().column(),ttCfg.sb_roi_hi().column()]] if ttCfg.use_reference_roi() > 0: self.ttROI_reference = [[ttCfg.ref_roi_lo().row(),ttCfg.ref_roi_hi().row()],\ [ttCfg.ref_roi_lo().column(),ttCfg.ref_roi_hi().column()]] else: self.ttROI_reference = self.ttROI_signal self.weights = ttCfg.weights() self.sb_convergence = ttCfg.sb_convergence() self.ref_convergence = ttCfg.ref_convergence() self.subtract_sideband = ttCfg.subtract_sideband() self.ttCalib = ttCfg.calib_poly() for el in ttCfg.beam_logic(): self.beamOff.append(el.event_code()) for el in ttCfg.laser_logic(): self.laserOff.append(el.event_code()) else: defaultDetector.__init__(self, self.detname, 'ttRaw')
def __init__(self, name='tt', baseName='TTSPEC:'): self.name = name self.detname='epics' self.ttNames = ['FLTPOS','FLTPOS_PS','AMPL','FLTPOSFWHM','REFAMPL','AMPLNXT'] self.PVlist = [ baseName+pvname for pvname in self.ttNames ] self.pvs=[] for pv in self.PVlist: try: self.pvs.append(psana.Detector(pv)) except: print('could not find timetool EPICS PV %s in data'%pv) self.ttCalib=None
def get_det_known(self): """ return the det object with KNOWN detname,expname,runnumber """ if self.detName is not None: try: ds = psana.DataSource("exp="+self.expName+":run="+str(self.runNumber)+':idx') return psana.Detector(self.detName) except Exception as err: print err return None return None
def findPsanaGeometry(experimentName, runNumber, detectorName): ds = psana.DataSource("exp=" + experimentName + ":run=" + str(runNumber) + ':idx') det = psana.Detector(detectorName) det.do_reshape_2d_to_3d(flag=True) run = ds.runs().next() times = run.times() evt = None counter = 0 while evt is None: evt = run.event(times[counter]) counter += 1 source = Detector.PyDetector.map_alias_to_source( detectorName, ds.env()) # 'DetInfo(CxiDs2.0:Cspad.0)' calibSource = source.split('(')[-1].split(')')[0] # 'CxiDs2.0:Cspad.0' detectorType = gu.det_type_from_source(source) # 1 calibGroup = gu.dic_det_type_to_calib_group[ detectorType] # 'CsPad::CalibV1' detectorName = gu.dic_det_type_to_name[detectorType].upper() # 'CSPAD' calibPath = "/reg/d/psdm/" + experimentName[0:3] + \ "/" + experimentName + "/calib/" + \ calibGroup + "/" + calibSource + "/geometry/" # Determine which calib file to use geometryFiles = os.listdir(calibPath) print "geometry: \n " + "\n".join(geometryFiles) calibFile = None minDiff = -1e6 for fname in geometryFiles: if fname.endswith('.data'): endValid = False startNum = int(fname.split('-')[0]) endNum = fname.split('-')[-1].split('.data')[0] diff = startNum - runNumber # Make sure it's end number is valid too if 'end' in endNum: endValid = True else: try: if runNumber <= int(endNum): endValid = True except: continue if diff <= 0 and diff > minDiff and endValid is True: minDiff = diff calibFile = calibPath + fname return calibFile
def runclient(args): ## "exprun" has the format: "(e.g. exp=xppd7114:run=43)" exprun = "exp="+str(args.exp)+":run="+str(args.run) ds = psana.DataSource(exprun+':idx') run = ds.runs().next() det = psana.Detector(args.det) times = run.times() eventTotal = len(times) if args.noe == -1: args.noe = eventTotal else: args.noe = min(eventTotal, args.noe) max_img = None mean_img = None median_img = None square_img = None counter = 0 nClients = comm_size-1 for nevent in range(args.noe): if nevent >= eventTotal: break if nevent%nClients != comm_rank-1: continue evt = run.event(times[nevent]) img = det.calib(evt) if img is None: continue if max_img is None: max_img = img mean_img = img median_img = img else: max_img = np.maximum(max_img, img) mean_img = (mean_img * counter + img)*1.0/(counter+1) median_img = utils.guessStreamMedian(median_img, img) counter += 1 print "##### Rank %3d is processing event %3d/%d" % (comm_rank, nevent, args.noe) print "##### Rank %3d processed %3d/%d" % (comm_rank, counter, args.noe) md=mpidata() md.addarray('max_img', max_img) md.addarray('mean_img', mean_img) md.addarray('median_img', median_img) md.small.counter = counter md.send()
def get_raw_data(self, index): self.get_detector(index) # is this line required? evt = self._get_event(index) run = self.get_run_from_index(index) if run.run() not in self._cached_psana_detectors: assert len(self.params.detector_address) == 1 self._cached_psana_detectors[run.run()] = psana.Detector( self.params.detector_address[0], self._env) det = self._cached_psana_detectors[run.run()] data = det.image(evt) data = data.astype(np.float64) self._raw_data = flex.double(data) return self._raw_data
def setupExperiment(self): self.ds = psana.DataSource('exp=' + str(self.experimentName) + ':run=' + str(self.runNumber) + ':idx') self.run = self.ds.runs().next() self.times = self.run.times() self.eventTotal = len(self.times) self.env = self.ds.env() self.evt = self.run.event(self.times[0]) self.det = psana.Detector(str(self.detInfo), self.env) self.det.do_reshape_2d_to_3d(flag=True) self.getDetInfoList() self.detAlias = self.getDetectorAlias(str(self.detInfo)) self.updateClen() # Get epics variable, clen
def _detector(self): import psana self._env = self._ds.env() self._det = psana.Detector(self._src,self._env) return self._detector_factory.simple( sensor = 'UNKNOWN', distance = 100.0, beam_centre = (50., 50.), fast_direction = '+x', slow_direction = '-y', pixel_size = (rayonix_tbx.get_rayonix_pixel_size(2), rayonix_tbx.get_rayonix_pixel_size(2)), image_size = self._det.shape(), trusted_range = (rayonix_tbx.rayonix_min_trusted_value, rayonix_tbx.rayonix_saturated_value), mask = [])
def getXTCAVImageROI(evt): for i in range(len(Constants.ROI_SIZE_X_names)): try: roiXN = psana.Detector(Constants.ROI_SIZE_X_names[i]) roiX = psana.Detector(Constants.ROI_START_X_names[i]) roiYN = psana.Detector(Constants.ROI_SIZE_Y_names[i]) roiY = psana.Detector(Constants.ROI_START_Y_names[i]) xN = roiXN(evt) #Size of the image in X x0 = roiX(evt) #Position of the first pixel in x yN = roiYN(evt) #Size of the image in Y y0 = roiY(evt) #Position of the first pixel in y x = x0 + np.arange(0, xN) y = y0 + np.arange(0, yN) return ROIMetrics(xN, x0, yN, y0, x, y) except KeyError: continue warnings.warn_explicit('No XTCAV ROI info', UserWarning, 'XTCAV', 0) return None
def stack2image(stack=None, experimentName=None, runNumber=None, detInfo=None, eventInd=0): ds = psana.DataSource('exp=' + str(experimentName) + ':run=' + str(runNumber) + ':idx') run = ds.runs().next() times = run.times() env = ds.env() evt = run.event(times[0]) det = psana.Detector(str(detInfo), env) evt = run.event(times[eventInd]) image = det.image(evt, stack) return image
def setupExperiment(self): access = 'exp=' + str(self.experimentName) + ':run=' + str(self.runNumber) + ':idx' if 'ffb' in self.access.lower(): access += ':dir=/reg/d/ffb/' + self.experimentName[:3] + \ '/' + self.experimentName + '/xtc' self.ds = psana.DataSource(access) self.run = self.ds.runs().next() self.times = self.run.times() self.eventTotal = len(self.times) self.env = self.ds.env() self.evt = self.run.event(self.times[0]) self.det = psana.Detector(str(self.detInfo), self.env) self.det.do_reshape_2d_to_3d(flag=True) self.getDetInfoList() self.detAlias = self.getDetectorAlias(str(self.detInfo)) self.updateClen() # Get epics variable, clen
def intensityROI(): ds = psana.MPIDataSource('exp=cxi02116:run=257:smd') det = psana.Detector('DsaCsPad') for nevent,evt in enumerate(ds.events()): raw_calib = np.array(det.calib(evt)) test = np.array(det.image(evt)) print(raw_calib.shape) print(test.shape) roi_approx = raw_calib[750:950, 775:975] print(roi_approx) roi_final = sum(sum(sum(roi_approx[65:176,42:154]))) print(roi_final)
def get_raw_data(self, index): import psana from scitbx.array_family import flex d = self.get_detector(index) evt = self._get_event(index) run = self.get_run_from_index(index) if run.run() not in self._cached_psana_detectors: assert len(self._src) == 1 self._cached_psana_detectors[run.run()] = psana.Detector( self._src[0], self._env) det = self._cached_psana_detectors[run.run()] data = det.image(evt) data = data.astype(np.float64) self._raw_data = flex.double(data) return self._raw_data
def __init__(self, codes=[[162], []]): evrNames = [n[0] for n in psana.DetNames() if ':Evr.' in n[0]] print('in lightStatus', evrNames) if len(evrNames) < 1: return nCodesMax = -1 for name in evrNames: nCodes = psana.Detector(name)._fetch_configs()[0].neventcodes() if nCodes > nCodesMax: nCodesMax = nCodes evrName = name if nCodesMax < 0: return defaultDetector.__init__(self, evrName, 'lightStatus') self.xrayCodes = codes[0] self.laserCodes = codes[1]