#/*##########################################################################
#
# The PyMca X-Ray Fluorescence Toolkit
#
# Copyright (c) 2004-2014 European Synchrotron Radiation Facility
#
# This file is part of the PyMca X-ray Fluorescence Toolkit developed at
# the ESRF by the Software group.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
#############################################################################*/
__author__ = "V.A. Sole - ESRF Data Analysis"
__contact__ = "sole@esrf.fr"
__license__ = "MIT"
__copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
"""
SpecFileLayer.py
Data derived class to access spec files
"""
################################################################################
import numpy
from PyMca5.PyMcaIO import specfilewrapper as specfile
################################################################################
SOURCE_TYPE = "SpecFile"
# Scan types
# ----------
SF_EMPTY= 0 # empty scan
SF_SCAN = 1 # non-empty scan
SF_MESH = 2 # mesh scan
SF_MCA = 4 # single mca
SF_NMCA = 8 # multi mca (more than 1 mca per acq)
SF_UMCA = 16 # mca number does not match pts number
[docs]class SpecFileLayer(object):
"""
Specializes Data class to access Spec files.
Interface: Data class interface.
"""
Error= "SpecFileDataError"
def __init__(self,refresh_interval=None,info={}):
"""
See Data.__init__
"""
info["Class"]="SpecFileData"
#Data.__init__(self,refresh_interval,info)
self.SourceName= None
self.SourceInfo= None
self.GetData = self.LoadSource
[docs] def GetPageInfo(self,index={}):
if 'SourceName' in index:
self.SetSource(index['SourceName'])
if 'Key' in index:
info=self.GetData(index['Key'])
return info[0]
[docs] def AppendPage(self,scan_info, scan_data):
return scan_info,scan_data
[docs] def SetSource (self,source_name=None,source_obj=None):
"""
Sets a new source for data retrieving, an specfile.
If the file exists, self.Source will be the Specfile
object associated to this file.
Parameters:
source_name: name of the specfile
"""
if source_name==self.SourceName: return 1
if source_name is not None:
if source_obj is not None:
self.Source= source_obj
else:
try:
self.Source= specfile.Specfile(source_name)
except:
self.Source= None
else:
self.Source= None
self.SourceInfo= None
if self.Source is None:
self.SourceName= None
return 0
else:
self.SourceName= source_name
return 1
[docs] def Refresh(self):
self.SourceInfo= None
if self.Source is not None:
self.Source.update()
#AS Data.Refresh(self)
[docs] def RefreshPage(source_obj,self,page):
return 0
[docs] def GetSourceInfo (self, key=None):
"""
Returns information about the Specfile object created by
SetSource, to give application possibility to know about
it before loading.
Returns a dictionary with the keys "Size" (number of possible
keys(to this source) and "KeyList" (list of all available keys
in this source). Each element in "KeyList" is an string in
the format "x.y" where x is the number of scan and y is
the order. "x.y" works as the key to retrieve the information
of this scan.
There's also the key "NumMca" in the returned dictionary,
which value is a list of numbers of mcas, for each value of
"KeyList".
If key given returns information of a perticular key instead.
"""
if self.SourceName == None: return None
if key is None:
if self.SourceInfo is None:
self.SourceInfo= self.__GetSourceInfo()
return self.SourceInfo
else:
key_type= self.__GetKeyType(key)
if key_type=="scan": scan_key= key
elif key_type=="mca": (scan_key, mca_no)=self.__GetMcaPars(key)
return self.__GetScanInfo(scan_key)
[docs] def LoadSource(self,key_list="ALL",append=0,invalidate=1):
"""
Creates a given number of pages, getting data from the actual
source (set by SetSource).
Parameters:
* key_list: list of all keys to be read from source. It is a list of strings
using the following formats:
"ALL": creates one data page for each scan.
valid for ScanType==SCAN or MESH or MCA
"s.o": loads all counter values (s=scan number, o=order)
- if ScanType==SCAN: in a 2D array (mot*cnts)
- if ScanType==MESH: in a 3D array (mot1*mot2*cnts)
- if ScanType==MCA: single MCA in 1D array (0:channels)
"s.o.n": loads a single MCA in a 1D array (0:channels)
- if ScanType==NMCA: n is the MCA number from 1 to N
- if ScanType==SCAN+MCA: n is the scan point number (from 1)
- if ScanType==MESH+MCA: n is the scan point number (from 1)
"s.o.p.n": loads a single MCA in a 1D array (0:channels)
- if ScanType==SCAN+NMCA:
p is the point number in the scan
n is the MCA device number
- NOT TRUE: Just follow previous.
if ScanType==MESH+MCA:
p is first motor index
n is second motor index
"s.o.MCA": loads all MCA in an array
- if ScanType==SCAN+MCA: 2D array (pts*mca)
- if ScanType==NMCA: 2D array (mca_det*mca)
- if ScanType==MESH+MCA: 3D array (pts_mot1*pts_mot2*mca)
- if ScanType==SCAN+NMCA: 3D array (pts_mot1*mca_det*mca)
- if ScanType==MESH+NMCA:
creates N data page, one for each MCA device,
with a 3D array (pts_mot1*pts_mot2*mca)
* append: if non-zero, appends to the end of the page list,
Otherwise, initializes the page list
* invalidate: if non-zero performs an invalidade call after loading
"""
#AS if append==0: Data.Delete(self)
if key_list == "ALL": key_list=self.__GetScanList()
if type(key_list)==type(" "): key_list=[key_list]
file_info= self.__GetFileInfo()
output=[]
for key in key_list:
key_type= self.__GetKeyType(key)
if key_type=="scan": output.append(self.__LoadScanData(key,file_info))
elif key_type=="mca": output.append(self.__LoadMcaData(key,file_info))
if len(output) == 1:
return output[0]
else:
return output
#AS if invalidate: self.Invalidate()
def __LoadScanData(self, scan_key, file_info={}):
scan_obj= self.Source.select(scan_key)
scan_info= self.__GetScanInfo(scan_key,scan_obj)
scan_info["Key"]= scan_key
scan_info["FileInfo"]= file_info
scan_type= scan_info["ScanType"]
scan_data= None
if scan_type&SF_SCAN:
try:
scan_data= numpy.transpose(scan_obj.data()).copy()
except:
raise IOError("SF_SCAN read failed")
elif scan_type&SF_MESH:
try:
scan_array= scan_obj.data()
(mot1,mot2,cnts)= self.__GetMeshSize(scan_array)
scan_data= numpy.zeros((mot1,mot2,cnts), numpy.float)
for idx in range(mot2):
scan_data[:,idx,:]= numpy.transpose(scan_array[:,idx*mot1:(idx+1)*mot1]).copy()
scan_data= numpy.transpose(scan_data).copy()
except:
raise IOError("SF_MESH read failed")
elif scan_type&SF_MCA:
return self.AppendPage(scan_info, scan_data)
elif scan_type&SF_NMCA:
return self.AppendPage(scan_info, scan_data)
if scan_data is not None:
return self.AppendPage(scan_info, scan_data)
else:
raise IOError("LoadScanData unknown type")
def __GetMeshSize(self, scan_array):
""" Given the scandata array, return the size tuple of the mesh
"""
mot2_array= scan_array[1]
mot2_max= mot2_array.shape[0]
mot1_idx= 1
while mot1_idx<mot2_max and mot2_array[mot1_idx]==mot2_array[0]: mot1_idx+=1
mot2_idx= scan_array.shape[1]/mot1_idx
cnts_idx= scan_array.shape[0]
return (mot1_idx, mot2_idx, cnts_idx)
def __GetScanMotorRange(self, info, obj):
name= info["LabelNames"][0]
values= obj.datacol(1)
length= values.shape[0]
return (name, values, length)
def __GetMeshMotorRange(self, info, obj):
return ()
def __LoadMcaData(self, key, file_info={}):
key_split= key.split(".")
scan_key= key_split[0]+"."+key_split[1]
scan_obj= self.Source.select(scan_key)
scan_info= self.__GetScanInfo(scan_key,scan_obj)
scan_info["Key"]= key
scan_info["FileInfo"]= file_info
scan_type= scan_info["ScanType"]
scan_data= None
mca_range= [] # for each dim., (name, length, values or None)
if key_split[2]=="MCA":
if scan_type==SF_SCAN+SF_MCA or scan_type==SF_MCA:
try:
mca_length= scan_obj.mca(1).shape[0]
scan_data= numpy.zeros((scan_info["NbMca"], mca_length), numpy.float)
for idx in range(scan_info["NbMca"]):
scan_data[idx]= scan_obj.mca(idx+1)
idx= 0
if scan_type==SF_SCAN+SF_MCA:
mca_range[idx]= self.__GetScanMotorRange(scan_info, scan_obj)
idx+=1
mca_range[idx]= ("Channels", mca_length, None)
scan_info["McaRange"]= mca_range
return self.AppendPage(scan_info, scan_data)
except:
raise IOError("SF_SCAN+SF_MCA read failed")
elif scan_type==SF_NMCA:
try:
mca_length= scan_obj.mca(1).shape[0]
mca_det= scan_info["NbMcaDet"]
scan_data= numpy.zeros((mca_det, mca_length), numpy.float)
for idx in range(mca_det):
scan_data[idx]= scan_obj.mca(idx+1)
mca_range[0]= ("McaDet", mca_det, None)
mca_range[1]= ("Channels", mca_length, None)
scan_info["McaRange"]= mca_range
return self.AppendPage(scan_info, scan_data)
except:
raise IOError("SF_NMCA read failed")
elif scan_type==SF_MESH+SF_MCA:
try:
scan_array= scan_obj.data()
(mot1,mot2,cnts)= self.__GetMeshSize(scan_array)
mca_length= scan_obj.mca(1).shape[0]
scan_data= numpy.zeros((mot1,mot2,mca_length), numpy.float)
for idx1 in range(mot1):
for idx2 in range(mot2):
mca_no= 1 + idx1 + idx2*mot1
scan_data[idx1,idx2,:]= scan_obj.mca(mca_no)
return self.AppendPage(scan_info, scan_data)
except:
raise IOError("SF_MESH+SF_MCA read failed")
elif scan_type==SF_SCAN+SF_NMCA:
try:
mca_length= scan_obj.mca(1).shape[0]
nbdet= scan_info["NbMcaDet"]
nbpts= scan_info["Lines"]
scan_data= numpy.zeros((nbpts, nbdet, mca_length), numpy.float)
for idx in range(nbpts):
for idy in range(nbdet):
scan_data[idx,idy,:]= scan_obj.mca(1+idx*nbdet+idy)
mca_range=[0,0,0]
mca_range[0]= self.__GetScanMotorRange(scan_info, scan_obj)
mca_range[1]= ("McaDet", nbdet, None)
mca_range[2]= ("Channels", mca_length, None)
scan_info["McaRange"]= mca_range
return self.AppendPage(scan_info, scan_data)
except:
raise IOError("SF_SCAN+SF_NMCA read failed")
elif scan_type==SF_MESH+SF_NMCA:
raise IOError("SF_MESH+SF_NMCA not yet implemented")
scan_data= None
elif len(key_split)==3:
if scan_type&SF_NMCA or scan_type&SF_MCA:
#if scan_type==SF_NMCA or \
# scan_type==SF_SCAN+SF_MCA or \
# scan_type==SF_MESH+SF_MCA:
try:
mca_no= int(key_split[2])
scan_data= scan_obj.mca(mca_no)
except:
raise IOError("Single MCA read failed")
if scan_data is not None:
scan_info.update(self.__GetMcaInfo(mca_no, scan_obj, scan_info))
return self.AppendPage(scan_info, scan_data)
elif len(key_split)==4:
if int(key_split[3]) > scan_info["NbMcaDet"]:
raise IOError(\
"Asked to read Mca %d having % d mca " % \
(int(key_split[3]), scan_info["NbMcaDet"]))
if scan_type==SF_SCAN+SF_NMCA:
try:
mca_no= (int(key_split[2])-1)*scan_info["NbMcaDet"] + int(key_split[3])
scan_data= scan_obj.mca(mca_no)
except:
raise IOError("SF_SCAN+SF_NMCA read failed")
elif scan_type==SF_MESH+SF_MCA:
try:
scan_array= scan_obj.data()
(mot1,mot2,cnts)= self.__GetMeshSize(scan_array)
#mca_no= 1 + int(key_split[2]) + int(key_split[3])*mot1
mca_no= (int(key_split[2])-1)*scan_info["NbMcaDet"] + int(key_split[3])
scan_data= scan_obj.mca(mca_no)
except:
raise IOError("SF_MESH+SF_MCA read failed")
elif scan_type&SF_NMCA or scan_type&SF_MCA:
try:
mca_no= (int(key_split[2])-1)*scan_info["NbMcaDet"] + int(key_split[3])
scan_data= scan_obj.mca(mca_no)
except:
raise IOError("SF_SCAN+SF_NMCA read failed")
else:
print("Unknown scan!!!!!!!!!!!!!!!!")
raise IOError("Unknown scan!!!!!!!!!!!!!!!!")
if scan_data is not None:
scan_info.update(self.__GetMcaInfo(mca_no, scan_obj, scan_info))
return self.AppendPage(scan_info, scan_data)
def __GetFileInfo(self):
file_info={}
try: file_info["Title"] = self.Source.title()
except: file_info["Title"] = None
try: file_info["User"] = self.Source.user()
except: file_info["User"] = None
try: file_info["Date"] = self.Source.date()
except: file_info["Date"] = None
try: file_info["Epoch"] = self.Source.epoch()
except: file_info["Epoch"] = None
try: file_info["ScanNo"] = self.Source.scanno()
except: file_info["ScanNo"] = None
try: file_info["List"] = list
except: file_info["List"] = None
return file_info
def __GetSourceInfo(self):
scanlist=self.__GetScanList()
source_info={}
source_info["Size"]=len(scanlist)
source_info["KeyList"]=scanlist
num_mca=[]
num_pts=[]
commands=[]
sf_type=[]
for i in scanlist:
sel=self.Source.select(i)
try: n= sel.nbmca()
except: n= 0
num_mca.append(n)
try: n= sel.lines()
except: n= 0
num_pts.append(n)
try: n= sel.command()
except: n= ""
commands.append(n)
source_info["NumMca"]=num_mca
source_info["NumPts"]=num_pts
source_info["Commands"]= commands
source_info["ScanType"]= map(self.__GetScanType, num_pts, num_mca, commands)
return source_info
def __GetScanType(self, num_pts, num_mca, command):
type= SF_EMPTY
if num_pts>0:
if command is None:
type= SF_SCAN
elif command.find("mesh") != -1:
type= SF_MESH
else:
type= SF_SCAN
if num_mca%num_pts:
type += SF_UMCA
elif num_mca==num_pts:
type += SF_MCA
elif num_mca>0:
type += SF_NMCA
else:
if num_mca==1:
type = SF_MCA
elif num_mca>1:
type = SF_NMCA
return type
def __GetScanList(self):
aux = self.Source.list().split(",")
newlistcount=[]
newlist=[]
for i in aux:
if i.find(":") == -1:
start_index = end_index = int(i)
else:
s = i.split(":")
start_index = int(s[0])
end_index = int(s[1])
for j in range(start_index, end_index+1):
newlist.append(j)
newlistcount.append(newlist.count(j))
for i in range(len(newlist)):
newlist[i]="%d.%d" % (newlist[i],newlistcount[i])
return newlist
def __GetKeyType (self,key):
count = key.count('.')
if (count==1):
return "scan"
elif (count==2) or (count==3):
return "mca"
else:
raise KeyError("SpecFileData: Invalid key %s" % key)
def __GetScanInfo(self, scankey, scandata=None):
if scandata is None:
scandata = self.Source.select(scankey)
info={}
info["SourceType"]= SOURCE_TYPE
info["SourceName"]=self.SourceName
info["Key"]=scankey
info["Source"]=self.Source
try: info["Number"] = scandata.number()
except: info["Number"] = None
try: info["Order"] = scandata.order()
except: info["Order"] = None
try: info["Cols"] = scandata.cols()
except: info["Cols"] = 0
try: info["Lines"] = scandata.lines()
except: info["Lines"] = 0
try: info["Date"] = scandata.date()
except: info["Date"] = None
try: info["MotorNames"] = self.Source.allmotors()
except: info["MotorNames"] = None
try: info["MotorValues"] = scandata.allmotorpos()
except: info["MotorValues"] = None
try: info["LabelNames"] = scandata.alllabels()
except: info["LabelNames"] = None
try: info["Command"] = scandata.command()
except: info["Command"] = None
try: info["Header"] = scandata.header("")
except: info["Header"] = None
try: info["NbMca"] = scandata.nbmca()
except: info["NbMca"] = 0
try: info["hkl"] = scandata.hkl()
except: info["hkl"] = None
if info["NbMca"]:
if info["Lines"]>0 and info["NbMca"]%info["Lines"]==0:
info["NbMcaDet"]= info["NbMca"]/info["Lines"]
else:
info["NbMcaDet"]= info["NbMca"]
info["ScanType"]= self.__GetScanType(info["Lines"], info["NbMca"], info["Command"])
return info
def __GetMcaInfo(self, mcano, scandata, info=None):
if info is None:
info = {}
mcainfo= {}
if "NbMcaDet" in info:
det= info["NbMcaDet"]
if info["Lines"]>0:
mcainfo["McaPoint"]= int(mcano/info["NbMcaDet"])+(mcano%info["NbMcaDet"]>0)
mcainfo["McaDet"]= mcano-((mcainfo["McaPoint"]-1)*info["NbMcaDet"])
try: mcainfo["LabelValues"]= scandata.dataline(mcainfo["McaPoint"])
except: mcainfo["LabelValues"]= None
else:
mcainfo["McaPoint"]= 0
mcainfo["McaDet"]= mcano
mcainfo["LabelValues"]= None
# TODO: This implementation seems to ignore the case of having different
# detectors in the same same scan
calib= scandata.header("@CALIB")
mcainfo["McaCalib"]=[0.0,1.0,0.0]
if len(calib):
# TODO: Instead of 0, one should use the index of the MCA detector
# requested.
ctxt= calib[0].split()
if len(ctxt)==4:
try:
cval= [ float(ctxt[1]), float(ctxt[2]), float(ctxt[3]) ]
mcainfo["McaCalib"]= cval
except:
mcainfo["McaCalib"]=[0.0,1.0,0.0]
# TODO: This implementation seems to ignore the case of having different
# detectors in the same scan, and the fact one can have more than one
# measurement in a single scan (different McaLiveTime)
ctime= scandata.header("@CTIME")
if len(ctime):
ctxt= ctime[0].split()
if len(ctxt)==4:
try:
mcainfo["McaPresetTime"]= float(ctxt[1])
mcainfo["McaLiveTime"]= float(ctxt[2])
mcainfo["McaRealTime"]= float(ctxt[3])
except:
pass
chann = scandata.header("@CHANN")
if len(chann):
ctxt= chann[0].split()
if len(ctxt)==5:
mcainfo['Channel0'] = float(ctxt[2])
else:
mcainfo['Channel0'] = 0.0
else:
mcainfo['Channel0'] = 0.0
return mcainfo
def __GetMcaPars(self,key):
nums = key.split('.')
size = len(nums)
sel_key = nums[0] + "." + nums[1]
if size == 3:
mca_no = int(nums[2])
elif size == 4:
sel = self.Source.select(sel_key)
try:
lines = sel.lines()
except:
lines=0
if nums[3]==0:
mca_no = int(nums[2])
else:
mca_no=((int(nums[3]) - 1) * lines) + int(nums[2])
else:
raise KeyError("SpecFileData: Invalid key %s" % key)
return (sel_key,mca_no)
################################################################################
#EXEMPLE CODE:
if __name__ == "__main__":
import sys,time
if len(sys.argv) not in [2,3]:
print("Usage: %s <filename> [<key_to_load>]")
sys.exit()
filename= sys.argv[1]
sf= SpecFileLayer()
if not sf.SetSource(filename):
print("ERROR: cannot open file %s" % filename)
sys.exit()
if len(sys.argv)==2:
info= sf.GetSourceInfo()
print("Filename :", sf.SourceName)
print("Number of scans :", info["Size"])
print("S# - command - pts - mca - type")
for (s,c,p,m,t) in zip(info["KeyList"],info["Commands"],info["NumPts"],info["NumMca"],info["ScanType"]):
print(s,"-",c,"-",p,"-",m,"-",t)
print("KeyList = ",info["KeyList"])
#print info['Channel0']
if len(sys.argv)==3:
info, data = sf.LoadSource(sys.argv[2])
print("Filename :", sf.SourceName)
print("Loaded key :", info["Key"])
print("Header :")
for i,v in info.items():
print("-", i, ":", v)
print("Data Shape :", data.shape)