def getResult(self):
SampleFileName = self.getParameter(0).value
BackGroundFileName = self.getParameter(1).value
useCadmium = self.getParameter(2).getbooleanValue()
if useCadmium:
CadmiumFileName = self.getParameter(3).value
else:
CadmiumFileName = ""
calcTransmission = self.getParameter(4).getbooleanValue()
if calcTransmission:
TransmissionFileName = ""
else:
TransmissionFileName = self.getParameter(5).value
SampleDataSets = ScriptUtil.load(SampleFileName)
if SampleDataSets == None:
return ErrorString("Could not load Sample File")
BackGroundDataSets = ScriptUtil.load(BackGroundFileName)
if BackGroundDataSets == None:
return ErrorString("Could not load BackGroundFile")
if useCadmium:
CadmiumDataSets = ScriptUtil.load(CadmiumFileName)
if CadmiumDataSets == None:
return ErrorString("Cannot load Cadmium File")
else:
pass
else:
CadmiumDataSets = [DataSet.EMPTY_DATA_SET, DataSet.EMPTY_DATA_SET]
n = SampleDataSets[1].getData_entry(0).getX_scale().getNum_x() - 1
if calcTransmission:
NeutronDelay = self.getParameter(6).getfloatValue()
polyfitIndx1 = self.getParameter(7).getintValue()
polyfitIndx2 = self.getParameter(8).getintValue()
polyDegree = self.getParameter(9).getintValue()
sqrtWeight = self.getParameter(10).getbooleanValue()
TransmissionDataSet = CalcTransmission(
SampleDataSets[0], BackGroundDataSets[0], CadmiumDataSets[0],
SampleDataSets[1], useCadmium, NeutronDelay, polyfitIndx1,
polyfitIndx2, polyDegree, sqrtWeight).getResult()
if isinstance(TransmissionDataSet, ErrorString):
return TransmissionDataSet
else:
TransmissionDataSet = ReadTransmission(TransmissionFileName,
n).getResult()
if isinstance(TransmissionDataSet, ErrorString):
return TransmissionDataSet
V = Vector()
V.addElement(SampleDataSets[0])
V.addElement(SampleDataSets[1])
V.addElement(BackGroundDataSets[0])
V.addElement(BackGroundDataSets[1])
V.addElement(CadmiumDataSets[0])
V.addElement(CadmiumDataSets[1])
V.addElement(Boolean(useCadmium))
V.addElement(TransmissionDataSet)
return V
def processRun(self, runnumber):
print runnumber
self.args[0] = runnumber
SampleDS = ScriptUtil.ExecuteCommand("PG3_to_dspace", self.args)
if isinstance(SampleDS, ErrorString):
print SampleDS
return SampleDS
if self.BackgroundDS is not None:
op = DataSetSubtract(SampleDS, self.BackgroundDS, 0)
op.getResult()
SampleDS.clampToZero()
GsasFileName = self.toGSASFilename(runnumber)
save_as = self.getParamValue(self.filetypes)
if self.VanadiumDS is not None:
op = SampleDS.getOperator("Divide by a DataSet")
op.getParameter(0).setValue(self.VanadiumDS)
X = op.getResult()
if isinstance(X, ErrorString):
return X
useSeqNumbering = self.getParamValue(self.SeqNums)
if "fullprof" in save_as:
filename = str(runnumber) + ".dat"
import os
filename = os.path.join(self.outputDir, filename)
X = ScriptUtil.ExecuteCommand(
"SaveFullProf", [SampleDS, filename, useSeqNumbering])
if isinstance(X, ErrorString):
return X
self.send(SampleDS, self.getParamValue(self.show),
self.getParamValue(self.toTree))
if GsasFileName is not None and "gsas" in save_as:
op = SampleDS.getOperator("Multiply sample values yi, by delta_xi")
if op is None:
op = SampleDS.getOperator("MultiplyByDeltaX")
op.getParameter(0).setValue(True)
SampleDS_gsas = op.getResult()
if isinstance(X, ErrorString):
return X
X = ScriptUtil.ExecuteCommand(
"Save3ColGSAS",
[None, SampleDS_gsas, GsasFileName, useSeqNumbering])
if isinstance(X, ErrorString):
return X
self.send(SampleDS_gsas, self.getParamValue(self.show),
self.getParamValue(self.toTree))
if self.getParamValue(self.toTree):
return SampleDS
else:
return None
def send(self, ds, showPlots, sendData):
if ds is None:
return
from Command import ScriptUtil
if showPlots:
ScriptUtil.display(ds)
if sendData:
pass # should do something here
def send( ds, showPlots, sendData,IOBS):
if ds is None:
return
from Command import ScriptUtil
if showPlots:
ScriptUtil.display(ds)
if sendData and IOBS is not None:
ScriptUtil.send(ds, IOBS)
def setDefaultParameters(self):
self.super__clearParametersVector()
# copy all of the parameters from the main script
self.focus_op = ScriptUtil.getOperator("PG3_to_dspace", None)
self.CopyParametersFrom(self.focus_op)
runnum = self.getParameter(0)
runnum.setValue(733)
# add the peak removal stuff
self.remove_op = ScriptUtil.getOperator("RemovePeaks", None)
numParam = self.remove_op.getNum_parameters()
for i in xrange(1, numParam):
self.addParameter(self.remove_op.getParameter(i).clone())
def applyMultScatt(self, datain):
# constants
rod_radius = 0.3175 # V rod radius in cm
COEFF1 = 2.8 # Absorption Cross Section/1.81
COEFF2 = 0.0721 # Density
COEFF3 = 5.1 # Total Scattering Cross Section
L1 = datain.getData_entry(0).getAttribute("Initial Path").getValue()
datatemp = datain.empty_clone()
dataout = datain.empty_clone()
from math import pi
from Command import ScriptUtil
num_spectra = datain.getNum_entries()
for i in xrange(num_spectra):
data = datain.getData_entry(i)
pos = data.getAttribute("Effective Position").getDetectorPosition()
flight_path = L1 + pos.getDistance()
angle = 180. * pos.getScatteringAngle() / pi
datatemp.addData_entry(data)
result = ScriptUtil.ExecuteCommand("Abs_MScatt_Correct",
[datatemp, angle, rod_radius, COEFF1, COEFF2, COEFF3, flight_path])
if isinstance(result, ErrorString):
return result
data = result.getData_entry(0)
dataout.addData_entry(data)
datatemp.removeData_entry(0)
return dataout
def getResult(self):
# get the configuration file and load it
execfile(self.getParamValue(1))
config = getConfig()
# whether or not to send all datasets to the tree
sendData = self.getParamValue(self.toTree)
# whether or not to plot intermediate results
showData = self.getParamValue(self.show)
from Command import ScriptUtil
args = []
args.append(self.getParamValue(self.EventFile)) # event file
args.append(self.getParamValue(self.ConfigFile)) # config file
args.append(self.getParamValue(self.firstEvent)) # first event
args.append(self.getParamValue(self.NEvents)) # number of events
args.append(self.getParamValue(self.mind)) # d-space min
args.append(self.getParamValue(self.maxd)) # d-space max
args.append(self.getParamValue(self.delta))
args.append(self.getParamValue(self.pchargeScalar))
args.append( 0)
args.append(0)
X = ScriptUtil.ExecuteCommand( "PG3_to_dspace", args)
if isinstance( X, ErrorString):
return X
BadPeakFile = config["VAN_PEAKS"]
PeakWidth_bad = self.getParamValue( self.BadPeakWidth)
PeakInterval_bad = self.getParamValue( self.BadIntrvlReplace)
NChanAv_bad = self.getParamValue( self.BadNumChanAv)
RemovePeaks_Calc.RemovePeaks_tof(X, BadPeakFile,PeakWidth_bad, PeakInterval_bad,NChanAv_bad)
CutOffFilter = self.getParameter(self.FilterCutOff).getValue()
OrderFilter = self.getParameter( self.FilterOrder).getValue()
Res = LowPassFilterDS( X, CutOffFilter, OrderFilter).getResult()
if isinstance( Res, ErrorString):
return Res
if self.getParamValue(self.ZeroUncertainties):
num_spectra = X.getNum_entries()
for i in xrange(num_spectra):
data = X.getData_entry(i)
errors = data.getErrors()
for j in xrange(len(errors)):
errors[j] = 0.
self.send(X, showData, sendData)
return self.applyMultScatt(X)
def rotateDetectors( instr, runnum, DetCalFile1):
if DetCalFile1 is None:
DetCalFile1 = getDefaultDetCalFile( instr)
import os
(nxs, prenxs) = getRunDir(instr, runnum)
cvinfo = "%s_%d_cvinfo.xml" % (instr, runnum)
cvinfo = os.path.join(prenxs, cvinfo)
print "CVinfo=",cvinfo,runnum,instr
if not os.path.exists(cvinfo):
raise Error, "%s does not exist" % cvinfo
V = Util.getRotationAngles( cvinfo)
if V is None or V.size()< 1:
print "No information to rotate the Detectors"
return DetCalFile1
ang1 = V.firstElement().firstElement()
ang2 = V.elementAt(1).firstElement()
DetCal1 = System.getProperty("user.home")
if not DetCal1.endswith("/"):
DetCal1 +='/'
Save = DetCal1
Save= DetCal1
DetCal1 += "ISAW/tmp/dummy.DetCal"
DetCal2 = Save+"ISAW/tmp/dummy2.DetCal"
General_Utils.RotateDetectors( DetCalFile1,14,DetCal1, ang1,0,0)
try:
General_Utils.RotateDetectors( DetCal1,5,DetCal2, ang2,0,0, ScriptUtil.ToVec([1,2,3,4,5,6,7,8,9]))
except:
return DetCal1
return DetCal2
def getResult(self):
# get the configuration file and load it
execfile(self.getParamValue(self.ConfigFile))
config = getConfig()
runs = self.getRuns()
self.args = [
None,
self.getParamValue(self.ConfigFile),
self.getParamValue(self.firstEvent),
self.getParamValue(self.NEvents),
self.getParamValue(self.mind),
self.getParamValue(self.maxd),
self.getParamValue(self.delta),
self.getParamValue(self.pchargeScalar),
self.getParamValue(self.toTree),
self.getParamValue(self.show)
]
BackgroundFile = self.getParamValue(1)
if BackgroundFile is None or BackgroundFile <= 0:
BackgroundFile = None
if BackgroundFile is not None:
self.args[0] = BackgroundFile
self.BackgroundDS = ScriptUtil.ExecuteCommand(
"PG3_to_dspace", self.args)
else:
self.BackgroundDS = None
VanadiumFile = self.getParamValue(self.VFile)
if VanadiumFile is None or VanadiumFile <= 0:
VanadiumFile = None
if VanadiumFile is not None:
vanargs = [
VanadiumFile,
self.getParamValue(self.ConfigFile),
self.getParamValue(self.firstEvent),
self.getParamValue(self.NEvents),
self.getParamValue(self.mind),
self.getParamValue(self.maxd),
self.getParamValue(self.delta),
self.getParamValue(self.pchargeScalar),
self.getParamValue(self.BadPeakWidth),
self.getParamValue(self.BadIntrvlReplace),
self.getParamValue(self.BadNumChanAv),
self.getParamValue(self.FilterCutOff),
self.getParamValue(self.FilterOrder), True, False, False
]
X = ScriptUtil.ExecuteCommand("VanadiumLoad", vanargs)
if isinstance(X, ErrorString):
return X
self.VanadiumDS = X
else:
self.VanadiumDS = None
self.outputDir = self.getParamValue(self.data)
for runnumber in runs:
X = self.processRun(runnumber)
if isinstance(X, ErrorString):
return X
return None
def getResult(self):
# get the configuration file and load it
execfile(self.getParamValue(1))
config = getConfig()
# whether or not to send all datasets to the tree
sendData = self.getParamValue(8)
# whether or not to plot intermediate results
showData = self.getParamValue(9)
# ghost file information
ghostFile = config.get('GHOST_MAP', None)
if ghostFile is None or len(ghostFile) <= 0:
ghostFile = None
# get the information about the run to process
runnum = self.getParamValue(0)
(eventfile, pcharge) = self.getRunStuff(runnum)
print "pcharge = %.0f" % pcharge
if float(self.getParamValue(7)) > 0.:
pcharge = pcharge/float(self.getParamValue(7))
else:
pcharge = 1.
print "scale = %.2f" % pcharge
d_min = float(self.getParamValue(4)) # d-space min
log_param = float(self.getParamValue(6)) # deltaD/D
log_param = log_param * d_min # log param
# do the initial load and time focus
from Command import ScriptUtil
args = []
args.append(eventfile) # event file
args.append(config['DET_CAL']) # detcal file
args.append(config['TS_BANK']) # banking file
args.append(config['TS_MAP']) # mapping file
args.append(self.getParamValue(2)) # first event
args.append(self.getParamValue(3)) # number of events
args.append(d_min) # d-space min
args.append(float(self.getParamValue(5))) # d-space max
args.append(True) # use log binning
args.append(log_param) # log param
args.append(10000) # number of bins - not used
args.append(True) # use d-space map
args.append(config['DSPACE_MAP']) # dspace map file
args.append(False)
args.append("")
op = ScriptUtil.getOperator("Make_d_DataSet", args)
panel_ds = op.getResult()
if isinstance(panel_ds, ErrorString): # error occured
return panel_ds
self.send(panel_ds, showData, sendData)
panel_ds.setSqrtErrorsAtLeast_1()
# create the ghost histogram and plot it
args[-2] = (not ghostFile is None) # generate ghosts
if ghostFile is not None:
args[-1] = ghostFile
op = ScriptUtil.getOperator("Make_d_DataSet", args)
ghost_ds = op.getResult()
if isinstance(ghost_ds, ErrorString): #error occured
return ghost_ds
self.send(ghost_ds, showData, sendData)
op = panel_ds.getOperator("Subtract a DataSet")
other = op.getParameter(0)
other.setValue(ghost_ds)
op.getResult()
self.send(panel_ds, showData, sendData)
panel_ds.clampToZero()
(groups, positions) = getGrouping()
for key in positions.keys():
positions[key] = self.getPosAttr(positions[key])
# sum spectra together
gsas_ds = panel_ds.empty_clone()
for key in groups.keys():
self.sumGroups(panel_ds, gsas_ds, groups[key], key, positions[key])
title = gsas_ds.getTitle() + " summed"
gsas_ds.setTitle(title)
self.send(gsas_ds, showData, sendData)
# convert back to tof
op = gsas_ds.getOperator("ToTof")
if op is None:
op = gsas_ds.getOperator("Convert d-Spacing to TOF")
gsas_tof = op.getResult()
if isinstance(gsas_tof, ErrorString): # error occured
return gsas_tof
title = gsas_tof.getTitle().replace("_d-spacing", " tof")
gsas_tof.setTitle(title)
self.send(gsas_tof, showData, sendData)
# normalize the data
if pcharge != 1.:
op = gsas_tof.getOperator("Divide by Scalar")
scalar = op.getParameter(0)
import java.lang.Float
scalar.setValue(java.lang.Float(pcharge))
op.getResult()
self.fixUnits(gsas_tof)
self.removeZeros(gsas_tof)
#return gsas_ds
return gsas_tof