def _makePack(self, name, id, instrument, pressure, npixels, radius,
height, gap):
'''make a unique 8-pack
all physical parameters must have units attached.
'''
from .ARCS.packSize import getSize
size = getSize(radius, height, gap)
shape = shapes.block(**size)
pack = elements.detectorPack(name,
shape=shape,
guid=instrument.getUniqueID(),
id=id)
packGeometer = geometers.geometer(pack)
self.local_geometers.append(packGeometer)
det0 = self._makeDetector('det0', 0, instrument, pressure, npixels,
radius, height)
pack.addElement(det0)
#180 degree is an artifact of current limitation of simulation
#package.
from .ARCS.tubePositions import getPositions
positions = getPositions(radius, gap)
packGeometer.register(det0, (0 * m, positions[0], 0 * m), (0, 180, 0))
for i in range(1, 8):
det = elements.copy('det%s' % i,
det0.guid(),
guid=instrument.getUniqueID())
pack.addElement(det)
packGeometer.register(det, (0 * m, positions[i], 0 * m),
(0, 180, 0))
continue
return pack
def makeDetectorSystem(self, instrument, geometer):
#detector system
detSystem = elements.detectorSystem('detSystem')
instrument.addElement(detSystem)
geometer.register(detSystem, (0 * mm, 0 * mm, 0 * mm), (0, 0, 0))
detSystemGeometer = geometers.geometer(
detSystem, registry_coordinate_system='InstrumentScientist')
self.local_geometers.append(detSystemGeometer)
for detInd in range(numdets):
detGuid = instrument.getUniqueID()
name = 'detector%s' % detInd
detector = self.makeDetector(name, detInd, instrument, pressure,
numpxls, tubeRadius, tubeLength)
detSystem.addElement(detector)
angle = detInd - 10.
angle1 = angle * pi / 180.
x = R * cos(angle1)
y = R * sin(angle1)
position = (x, y, R * 0)
detSystemGeometer.register(detector, position, (0, 0, 0))
continue
return
def notify(self, parent):
#parent is a xml node. parent.element is a instrument element
#that the geometer should attach to
target = parent.element
#create geometer
import instrument.geometers as ig
geometer = ig.geometer(
target, registry_coordinate_system = self._coord_system )
#register elements
for pinfo in self._pinfos:
name = pinfo.objname
element = target.elementFromName( name )
geometer.register(element , pinfo.position, pinfo.orientation)
continue
geometer.finishRegistration()
#attach to target
target.local_geometer = geometer
#add geometer to the geometer list
document = self.document
try:
geometers = document.geometers
except AttributeError :
geometers = document.geometers = []
pass
geometers.append( geometer )
return geometer
def construct(self, lrmecsDataFilename):
import os
if not os.path.exists(lrmecsDataFilename):
raise RuntimeError("Cannot find file %s" %
os.path.abspath(lrmecsDataFilename))
self._instrument = lrmecs = elements.instrument(
"Lrmecs") # version="0.0.0")
#instrument local geometer
geometer = geometers.geometer(
lrmecs, registry_coordinate_system='InstrumentScientist')
self.local_geometers = [geometer]
#parse the file and get all tube records and monitor records
from .LrmecsDataFileParser import Parser
self.distMod2Sample, monitorRecords, tubeRecords = Parser(
lrmecsDataFilename, self.interpolateData).parse()
# make Moderator
self.makeModerator(lrmecs, geometer)
# make monitors: adds elements to lrmecs & geometer
self.makeMonitors(lrmecs, geometer, monitorRecords)
#make sample
sample = elements.sample('sample')
lrmecs.addElement(sample)
# sample is placed at origin to simplify computation
geometer.register(sample, (0 * mm, 0 * mm, 0 * mm), (0, 0, 0))
# make detector array: adds elements to lrmecs & geometer
self.makeDetectorSystem(lrmecs, geometer, tubeRecords)
# set up guid registry
lrmecs.guidRegistry.registerAll(lrmecs)
# instrument global geometer
instrumentGeometer = geometers.arcs(
lrmecs,
self.local_geometers,
registry_coordinate_system='InstrumentScientist')
lrmecs.geometer = instrumentGeometer
# clean up temporary variables
del self._detectorModules, self.distMod2Sample, self.local_geometers
del self._instrument
# save the xml description
from instrument.nixml import weave
import os
f = '%s-interp%s.xml' % (os.path.basename(lrmecsDataFilename),
self.interpolateData)
print('write lrmecs instrument to %s' % f)
weave(lrmecs, open(f, 'w'))
return lrmecs, instrumentGeometer
def makeDetectorSystem( self, instrument, geometer, packs):
#detector system
detSystem = elements.detectorSystem(
'detSystem', guid = instrument.getUniqueID())
instrument.addElement( detSystem )
geometer.register( detSystem, (0*m,0*m,0*m), (0,0,0),
relative = instrument.getSample() )
detSystemGeometer = geometers.geometer(
detSystem, registry_coordinate_system = 'InstrumentScientist' )
self.local_geometers.append( detSystemGeometer )
from numpy import array
cache = {}
for packinfo in packs:
rotation = packinfo.orientation
translation = tuple(array( packinfo.position )*mm)
packID = packinfo.id
name = 'pack%s' % packID
packtype = packType(packinfo)
pack = cache.get(packtype)
if pack is None:
pressure, ntubes, height, radius, gap, npixels = \
packtype
assert ntubes == 8, "not implemented"
pack = cache[packtype] = self._makePack(
name, packID, instrument,
pressure*atm, npixels, radius*mm, height*mm, gap*mm)
else:
copy = elements.copy(
'pack%s' % packID, pack.guid(),
id = packID,
guid = instrument.getUniqueID() )
pack = copy
pass
detSystem.addElement( pack )
detSystemGeometer.register(
pack, translation, rotation )
continue
return # detArray # sequoia, geometer
def construct(
self, packs,
mod2sample = 20.0254*m, xmloutput = None ):
'''construct a new SEQUOIA instrument
Parameters:
-packs: a list of PackInfo instances
-mod2sample: moderator to sample distance
'''
self._instrument = sequoia = elements.instrument(
"SEQUOIA" )# version="0.0.0")
#instrument local geometer
geometer = geometers.geometer(
sequoia, registry_coordinate_system = 'InstrumentScientist' )
self.local_geometers = [geometer]
# make Moderator
self.makeModerator( sequoia, geometer )
# make monitors: adds elements to sequoia & geometer
self.makeMonitors( sequoia, geometer, monitorRecords)
#make sample
sample = elements.sample(
'sample',guid = sequoia.getUniqueID() )
sequoia.addElement( sample )
geometer.register( sample, (mod2sample,0*m,0*m), (0,0,0) )
# make detector array: adds elements to sequoia & geometer
self.makeDetectorSystem(sequoia, geometer, packs)
# set up guid registry
sequoia.guidRegistry.registerAll( sequoia )
# instrument global geometer
instrumentGeometer = geometers.arcs(
sequoia, self.local_geometers,
registry_coordinate_system = 'InstrumentScientist' )
sequoia.geometer = instrumentGeometer
# clean up temporary variables
del self.local_geometers, self._instrument
# save the xml description
if xmloutput:
from instrument.nixml import weave
print('write sequoia instrument to %s' % xmloutput)
weave( sequoia, open(xmloutput, 'w') )
return sequoia, instrumentGeometer
def construct(
self, packs,
xmloutput = None ):
'''construct a new HYSPEC instrument
Parameters:
-packs: a list of PackInfo instances
'''
self._instrument = hyspec = elements.instrument(
"HYSPEC" )# version="0.0.0")
#instrument local geometer
geometer = geometers.geometer(
hyspec, registry_coordinate_system = 'InstrumentScientist' )
self.local_geometers = [geometer]
# make Moderator
# self.makeModerator( hyspec, geometer )
# make monitors: adds elements to hyspec & geometer
# self.makeMonitors( hyspec, geometer, monitorRecords)
#make sample
sample = elements.sample(
'sample',guid = hyspec.getUniqueID() )
hyspec.addElement( sample )
geometer.register( sample, (0*m,0*m,0*m), (0,0,0) )
# make detector array: adds elements to hyspec & geometer
self.makeDetectorSystem(hyspec, geometer, packs)
# set up guid registry
hyspec.guidRegistry.registerAll( hyspec )
# instrument global geometer
instrumentGeometer = geometers.arcs(
hyspec, self.local_geometers,
registry_coordinate_system = 'InstrumentScientist' )
hyspec.geometer = instrumentGeometer
# clean up temporary variables
del self.local_geometers, self._instrument
# save the xml description
if xmloutput:
from instrument.nixml import weave
print('write hyspec instrument to %s' % xmloutput)
weave( hyspec, open(xmloutput, 'w') )
return hyspec, instrumentGeometer
def makeDetectorSystem(self, instrument, geometer, packRecords,
packInfoDict):
#detector system
detSystem = elements.detectorSystem('detSystem',
guid=instrument.getUniqueID())
instrument.addElement(detSystem)
geometer.register(detSystem, (0 * m, 0 * m, 0 * m), (0, 0, 0),
relative=instrument.getSample())
detSystemGeometer = geometers.geometer(
detSystem, registry_coordinate_system='InstrumentScientist')
self.local_geometers.append(detSystemGeometer)
from numpy import array
cache = {}
for record in packRecords:
packID, type, position, orientation = record
rotation = 0, 0, 90 + orientation[2]
translation = tuple(array(position) * mm)
name = 'pack%s' % packID
pack = cache.get(type)
if pack is None:
pressure, npixels, radius, height, gap = \
packInfoDict[ type ]
pack = cache[type] = self._makePack(name, packID, instrument,
pressure, npixels, radius,
height, gap)
else:
copy = elements.copy('pack%s' % packID,
pack.guid(),
id=packID,
guid=instrument.getUniqueID())
pack = copy
pass
detSystem.addElement(pack)
detSystemGeometer.register(pack, translation, rotation)
continue
return # detArray # arcs, geometer
def makeDetectorSystem(self, instrument, geometer, tubeRecords):
#detector system
detSystem = elements.detectorSystem('detSystem')
instrument.addElement(detSystem)
geometer.register(detSystem, (0 * mm, 0 * mm, 0 * mm), (0, 0, 0))
detSystemGeometer = geometers.geometer(
detSystem, registry_coordinate_system='InstrumentScientist')
self.local_geometers.append(detSystemGeometer)
numTubes = len(tubeRecords)
for i, record in enumerate(tubeRecords):
detID = i #record['id']
debug.log('detID=%s' % detID)
#debug.log( 'record=%s' % record )
pressure = 10.0 # ???
detLength = record['geometry']['height']
detRadius = record['geometry']['radius']
name = 'detector%s' % detID
detector = self.makeDetector(name, detID, instrument, pressure,
numPixelsPerTube, detRadius,
detLength)
debug.log("LPSD: %s" % detector)
detSystem.addElement(detector)
rho = record['distance']['value']
phi = record['angle']['value']
#phi *= -1.0 #???
# convert from polar to cartesian coordinates. Note theta = 90 (in
# other words, the detector centers all lie in the scattering plane).
x = rho * cos(phi * pi / 180.0)
y = rho * sin(phi * pi / 180.0)
z = 0.0
detSystemGeometer.register(detector, (x * mm, y * mm, z * mm),
detectorOrientation)
continue
return # detArray # arcs, geometer
def construct(self, detPackFilename):
pharos = elements.instrument("Pharos")
#instrument local geometer
geometer = geometers.geometer(
pharos, registry_coordinate_system='InstrumentScientist')
self.local_geometers = [geometer]
# Pharos currently don't have monitors. The following are commented out
# make monitors: adds elements to pharos & geometer
# self.makeMonitors( pharos, geometer)
# make detector array: adds elements to pharos & geometer
import os
if not os.path.exists(detPackFilename):
raise RuntimeError("Cannot find file %s" % detPackFilename)
self.makeDetectorSystem(pharos, geometer, detPackFilename)
# make Moderator
self.makeModerator(pharos, geometer)
# make sample
sample = elements.sample('sample')
pharos.addElement(sample)
geometer.register(sample, (0, 0, 0), (0, 0, 0))
# set up guid registry
pharos.guidRegistry.registerAll(pharos)
# instrument global geometer
instrumentGeometer = geometers.arcs(
pharos,
self.local_geometers,
registry_coordinate_system='InstrumentScientist')
pharos.geometer = instrumentGeometer
del self.local_geometers
# save the xml description
from instrument.nixml import weave
import os
f = '%s.xml' % (os.path.basename(detPackFilename), )
print('write pharos instrument to %s' % f)
weave(pharos, open(f, 'w'))
return pharos, instrumentGeometer
def construct(self):
fake = elements.instrument("CylinderDetectors")
#instrument local geometer
geometer = geometers.geometer(
fake, registry_coordinate_system='InstrumentScientist')
self.local_geometers = [geometer]
# make monitors: adds elements to arcs & geometer
# self.makeMonitors( arcs, geometer)
# make detector array: adds elements to arcs & geometer
self.makeDetectorSystem(fake, geometer)
# make Moderator
self.makeModerator(fake, geometer)
#make sample
sample = elements.sample('sample')
fake.addElement(sample)
# sample is placed at origin to simplify computation
geometer.register(sample, (0 * mm, 0 * mm, 0 * mm), (0, 0, 0))
# set up guid registry
fake.guidRegistry.registerAll(fake)
# instrument global geometer
instrumentGeometer = geometers.arcs(
fake,
self.local_geometers,
registry_coordinate_system='InstrumentScientist')
fake.geometer = instrumentGeometer
self._check(fake, instrumentGeometer)
return fake, instrumentGeometer
def construct(self,
detconfigfile,
longpackinfo,
shortpack1info,
shortpack2info,
mod2sample=13.6,
xmloutput=None):
'''construct a new ARCS instrument
Parameters:
-detconfigfile: detector configuration file from Doug
-longpackinfo: long pack related info, a tuple of
(pressure, npixels, radius, height, gap )
-shortpack1info: short pack type 1 info, a tuple too (pack 71)
-shortpack2info: short pack type 2 info, a tuple too (pack 70)
-mod2sample: moderator to sample distance
'''
#read detector pack records
import os
if not os.path.exists(detconfigfile):
raise IOError("Cannot find file %s" %
(os.path.abspath(detconfigfile), ))
self._instrument = arcs = elements.instrument(
"ARCS") # version="0.0.0")
#instrument local geometer
geometer = geometers.geometer(
arcs, registry_coordinate_system='InstrumentScientist')
self.local_geometers = [geometer]
#parse the file and get all tube records and monitor records
from .ARCSDetPackCSVParser import readConf
packRecords = readConf(detconfigfile)
# make Moderator
self.makeModerator(arcs, geometer)
# make monitors: adds elements to arcs & geometer
self.makeMonitors(arcs, geometer, monitorRecords)
#make sample
sample = elements.sample('sample', guid=arcs.getUniqueID())
arcs.addElement(sample)
geometer.register(sample, (mod2sample * m, 0 * m, 0 * m), (0, 0, 0))
# make detector array: adds elements to arcs & geometer
self.makeDetectorSystem(
arcs, geometer, packRecords, {
'long': longpackinfo,
'short1': shortpack1info,
'short2': shortpack2info,
})
# set up guid registry
arcs.guidRegistry.registerAll(arcs)
# instrument global geometer
instrumentGeometer = geometers.arcs(
arcs,
self.local_geometers,
registry_coordinate_system='InstrumentScientist')
arcs.geometer = instrumentGeometer
# clean up temporary variables
del self.local_geometers, self._instrument
# save the xml description
if not xmloutput:
xmloutput = '%s.xml' % (os.path.basename(detconfigfile), )
from instrument.nixml import weave
import os
print('write arcs instrument to %s' % xmloutput)
weave(arcs, open(xmloutput, 'w'))
return arcs, instrumentGeometer
def makeDetectorSystem(self, instrument, geometer, detPackFilename):
instrument.detIDs = [] #keep the list of detector IDs
# detector array
did = instrument.getUniqueID()
detSystem = elements.detectorSystem('detSystem', guid=did)
instrument.addElement(detSystem)
geometer.register(detSystem, (0 * mm, 0 * mm, 0 * mm), (0, 0, 0))
# geometer for tubes
detSystemGeometer = geometers.geometer(
detSystem, registry_coordinate_system='InstrumentScientist')
self.local_geometers.append(detSystemGeometer)
# detectorPacks
# get detector pack info records
parser = Parser(detPackFilename)
instrument.raw_detector_records = records = parser.parse()
# make detectors
for i, record in enumerate(records):
if 'short' in record['type']['value']: continue
detGuid = instrument.getUniqueID()
detID = record['tubeNo']['value']
instrument.detIDs.append(detID)
detDescr = record['type']['value']
# properties of the detector
pressure = 0.0
if '6atm' in detDescr:
pressure = 6.0 * atm
elif '10atm' in detDescr:
pressure = 10.0 * atm
else:
raise ValueError("unknown detector pressure")
height = record['length']['value'] * _todimensional(
record['length']['unit'])
radius = tubeRadius
if height / mm > 999.0:
numPixels = numPixels1m
elif height / mm < 330.0 and height > 310.0:
numPixels = numPixels32cm
raise ValueError("did not expect short detectors yet!")
name = 'detector%s' % detID
# create detector element
detector = self.makeDetector(name, detID, instrument, pressure,
numPixels, radius, height)
rho = record['distance']['value'] * _todimensional(
record['distance']['unit'])
phi = record['angle']['value'] * _todimensional(
record['angle']['unit'])
phi *= -1.0
# convert from polar to cartesian coordinates. Note theta = 90 (in
# other words, the detector centers all lie in the scattering plane).
x = rho * cos(phi)
y = rho * sin(phi)
position = [x, y, 0. * mm]
orientation = [0.0, 0.0, 0.0]
detSystem.addElement(detector)
detSystemGeometer.register(detector, position, orientation)
continue
return # detSystem # arcs, geometer
