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]
