def main():
from helper import MantidGeom
inst_name = "VISION"
xml_outfile = inst_name + "_Definition.xml"
det = MantidGeom(inst_name, comment=" Created by Stuart Campbell ")
det.addSnsDefaults(indirect=True)
det.addComment("SOURCE AND SAMPLE POSITION")
det.addModerator(-16.0)
det.addSamplePosition()
# Backscattering Banks are 21-100
BACKSCATTERING_NTUBES = 80
det.addComponent("elastic-backscattering", "elastic-backscattering")
handle = det.makeTypeElement("elastic-backscattering")
idlist = []
for k in range(BACKSCATTERING_NTUBES):
id_start = 26624 + (256 * k)
id_end = 26624 + (256 * k) + 255
angle = -(2.25 + 4.5 * k)
bankid = 21 + k
bank_name = "bank%d" % bankid
det.addComponent(bank_name, root=handle)
z_coord = -0.998
if k % 2 == 0:
# Even tube number (long)
centre_offset = BS_ELASTIC_LONG_TUBE_INNER_RADIUS + (
BS_ELASTIC_LONG_TUBE_LENGTH / 2.0)
#centre_offset = BS_ELASTIC_LONG_TUBE_INNER_RADIUS
component_name = "tube-long-bs-elastic"
else:
# Odd tube number (short)
centre_offset = BS_ELASTIC_SHORT_TUBE_INNER_RADIUS + (
BS_ELASTIC_SHORT_TUBE_LENGTH / 2.0)
component_name = "tube-short-bs-elastic"
x_coord = centre_offset * math.cos(math.radians(90 - angle))
y_coord = centre_offset * math.sin(math.radians(90 - angle))
det.addDetector(x_coord, y_coord, z_coord, 0, 0, -angle, bank_name,
component_name)
idlist.append(id_start)
idlist.append(id_end)
idlist.append(None)
det.addDetectorIds("elastic-backscattering", idlist)
# 90 elastic banks
elastic_banklist = [3, 6, 9, 12, 15, 18]
elastic_bank_start = [2048, 6144, 10240, 14336, 18432, 22528]
elastic_angle = [22.5, -22.5, -67.5, -112.5, -157.5, 157.5]
sample_elastic_distance = 0.635
det.addComponent("elastic", "elastic")
handle = det.makeTypeElement("elastic")
idlist = []
elastic_index = 0
for i in elastic_banklist:
bank_name = "bank%d" % i
det.addComponent(bank_name, root=handle)
z_coord = 0.0
x_coord = sample_elastic_distance * math.cos(
math.radians(elastic_angle[elastic_index]))
y_coord = sample_elastic_distance * math.sin(
math.radians(elastic_angle[elastic_index]))
det.addDetector(x_coord,
y_coord,
z_coord,
-90.0,
0,
0.,
bank_name,
"eightpack-elastic",
facingSample=True)
idlist.append(elastic_bank_start[elastic_index])
idlist.append(elastic_bank_start[elastic_index] + 2047)
idlist.append(None)
elastic_index += 1
det.addDetectorIds("elastic", idlist)
# Inelastic
inelastic_banklist = [1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20]
inelastic_bank_start = [
0, 1024, 4096, 5120, 8192, 9216, 12288, 13312, 16384, 17408, 20480,
21504, 24576, 25600
]
inelastic_angle = [
45.0, 45.0, 0.0, 0.0, -45.0, -45.0, -90.0, -90.0, -135.0, -135.0,
180.0, 180.0, 135.0, 135.0
]
inelastic_angle_for_rotation = [
-45.0, -45.0, 180.0, 180.0, -135.0, -135.0, -90.0, -90.0, -225.0,
-225.0, 0.0, 0.0, 45.0, 45.0
]
sample_inelastic_distance = 0.5174
det.addComponent("inelastic", "inelastic")
handle = det.makeTypeElement("inelastic")
idlist = []
inelastic_index = 0
for i in inelastic_banklist:
bank_name = "bank%d" % i
bank_comp = det.addComponent(bank_name,
root=handle,
blank_location=True)
# location_element = le.SubElement(bank_comp, "location")
# le.SubElement(location_element, "rot", **{"val":"90", "axis-x":"0",
# "axis-y":"0", "axis-z":"1"})
# Neutronic Positions
z_coord_neutronic = sample_inelastic_distance * math.tan(
math.radians(45.0))
if inelastic_index % 2 == 0:
# Facing Downstream
z_coord = 0.01
else:
# Facing to Moderator
z_coord = -0.01
z_coord_neutronic = -z_coord_neutronic
# Physical Positions
x_coord = sample_inelastic_distance * math.cos(
math.radians(inelastic_angle[inelastic_index]))
y_coord = sample_inelastic_distance * math.sin(
math.radians(inelastic_angle[inelastic_index]))
det.addDetector(-x_coord,
y_coord,
z_coord,
0,
0,
inelastic_angle_for_rotation[inelastic_index] - 90.0,
bank_name,
"eightpack-inelastic",
neutronic=True,
nx=-x_coord,
ny=y_coord,
nz=z_coord_neutronic)
efixed = ("Efixed", "3.64", "meV")
det.addDetectorParameters(bank_name, efixed)
idlist.append(inelastic_bank_start[inelastic_index])
idlist.append(inelastic_bank_start[inelastic_index] + 1023)
idlist.append(None)
inelastic_index += 1
det.addDetectorIds("inelastic", idlist)
# 8 packs
det.addComment("INELASTIC 8-PACK")
det.addNPack("eightpack-inelastic",
INELASTIC_TUBES_PER_BANK,
INELASTIC_TUBE_WIDTH,
INELASTIC_AIR_GAP,
"tube-inelastic",
neutronic=True)
det.addComment("ELASTIC 8-PACK")
det.addNPack("eightpack-elastic",
ELASTIC_TUBES_PER_BANK,
ELASTIC_TUBE_WIDTH,
ELASTIC_AIR_GAP,
"tube-elastic",
neutronic=True,
neutronicIsPhysical=True)
# TUBES
det.addComment("INELASTIC TUBE")
det.addPixelatedTube("tube-inelastic",
INELASTIC_TUBE_NPIXELS,
INELASTIC_TUBE_LENGTH,
"pixel-inelastic-tube",
neutronic=True)
det.addComment("BACKSCATTERING LONG TUBE")
det.addPixelatedTube("tube-long-bs-elastic",
BS_ELASTIC_LONG_TUBE_NPIXELS,
BS_ELASTIC_LONG_TUBE_LENGTH,
"pixel-bs-elastic-long-tube",
neutronic=True,
neutronicIsPhysical=True)
det.addComment("BACKSCATTERING SHORT TUBE")
det.addPixelatedTube("tube-short-bs-elastic",
BS_ELASTIC_SHORT_TUBE_NPIXELS,
BS_ELASTIC_SHORT_TUBE_LENGTH,
"pixel-bs-elastic-short-tube",
neutronic=True,
neutronicIsPhysical=True)
det.addComment("ELASTIC TUBE (90 degrees)")
det.addPixelatedTube("tube-elastic",
ELASTIC_TUBE_NPIXELS,
ELASTIC_TUBE_LENGTH,
"pixel-elastic-tube",
neutronic=True,
neutronicIsPhysical=True)
# PIXELS
det.addComment("PIXEL FOR INELASTIC TUBES")
det.addCylinderPixel("pixel-inelastic-tube", (0.0, 0.0, 0.0),
(0.0, 1.0, 0.0), (INELASTIC_TUBE_WIDTH / 2.0),
(INELASTIC_TUBE_LENGTH / INELASTIC_TUBE_NPIXELS))
det.addComment("PIXEL FOR BACKSCATTERING ELASTIC TUBES (LONG)")
det.addCylinderPixel(
"pixel-bs-elastic-long-tube", (0.0, 0.0, 0.0), (0.0, 1.0, 0.0),
(BS_ELASTIC_LONG_TUBE_WIDTH / 2.0),
(BS_ELASTIC_LONG_TUBE_LENGTH / BS_ELASTIC_LONG_TUBE_NPIXELS))
det.addComment("PIXEL FOR BACKSCATTERING ELASTIC TUBES (SHORT)")
det.addCylinderPixel(
"pixel-bs-elastic-short-tube", (0.0, 0.0, 0.0), (0.0, 1.0, 0.0),
(BS_ELASTIC_SHORT_TUBE_WIDTH / 2.0),
(BS_ELASTIC_SHORT_TUBE_LENGTH / BS_ELASTIC_SHORT_TUBE_NPIXELS))
det.addComment("PIXEL FOR ELASTIC TUBES (90 degrees)")
det.addCylinderPixel("pixel-elastic-tube", (0.0, 0.0, 0.0),
(0.0, 1.0, 0.0), (ELASTIC_TUBE_WIDTH / 2.0),
(ELASTIC_TUBE_LENGTH / ELASTIC_TUBE_NPIXELS))
det.addComment(" ##### MONITORS ##### ")
det.addMonitors(names=["monitor1"], distance=["-6.71625"], neutronic=True)
# MONITORS
det.addComment("MONITOR SHAPE")
det.addComment("FIXME: Do something real here.")
det.addDummyMonitor(0.01, 0.03)
det.addComment("MONITOR IDs")
det.addMonitorIds(["-1"])
det.showGeom()
det.writeGeom(xml_outfile)
covering 2 Theta range from about 10 to 155 degrees
Detector tubes have 25 mm in diameter and are 250 mm in height
For more information, please visit
https://www.ill.eu/instruments-support/instruments-groups/instruments/d7/characteristics/
"""
d7 = MantidGeom(instrumentName, comment=comment, valid_from=validFrom)
d7.addSnsDefaults(default_view='3D', axis_view_3d='z-', theta_sign_axis="x")
d7.addComment("SOURCE")
d7.addComponentILL('SOURCE', 0.0, 0.0, source, 'Source')
d7.addComment("Sample position")
d7.addComponentILL("sample_position", 0., 0., 0., "SamplePos")
d7.addComment("MONITORS")
d7.addMonitors(names=["monitor1", "monitor2"], distance=[zMon1, zMon2])
d7.addComment("MONITOR SHAPE")
d7.addComment("FIXME: Do something real here.")
d7.addDummyMonitor(0.01, 0.03)
d7.addComment("MONITOR IDs")
d7.addMonitorIds([repr(100000), repr(100001)])
d7.addComment("DETECTORS")
d7.addComponentILL("detector", 0., 0., 0.)
detector = d7.makeTypeElement("detector")
# define detector banks
d7.addDetectorIds("bank2_ids", [1, 44, 1])
d7.addDetectorIds("bank3_ids", [45, 88, 1])
d7.addDetectorIds("bank4_ids", [89, 132, 1])
bank = d7.makeTypeElement("bank")
bank2 = d7.addComponent("bank", idlist="bank2_ids", root=detector)
bank3 = d7.addComponent("bank", idlist="bank3_ids", root=detector)
bank4 = d7.addComponent("bank", idlist="bank4_ids", root=detector)
Size 1024 mm x 1024 mm
Nominal resolution:
128 x 256
Pixel size 8 x 4 mm2
Low resolution:
128 x 128
Pixel size 8 x 8 mm2
For more information, please visit
https://www.ill.eu/instruments-support/instruments-groups/instruments/d22/characteristics/
"""
d22 = MantidGeom(instrumentName, comment=comment, valid_from=validFrom)
d22.addSnsDefaults()
d22.addComment("SOURCE")
d22.addComponentILL("moderator", 0., 0., moderator_source, "Source")
d22.addComment("Sample position")
d22.addComponentILL("sample_position", 0., 0., 0., "SamplePos")
d22.addComment("MONITORS")
d22.addMonitors(names=["monitor1", "monitor2"], distance=[zMon1, zMon2])
d22.addComment("MONITOR SHAPE")
d22.addComment("FIXME: Do something real here.")
d22.addDummyMonitor(0.01, 0.03)
d22.addComment("MONITOR IDs")
d22.addMonitorIds([repr(100000), repr(100001)])
d22.addComment("DETECTOR")
d22.addComponentRectangularDetector(detector0, 0., 0., zPos, idstart=id0, idfillbyfirst=FF, idstepbyrow=SR)
d22.addRectangularDetector(detector0, pixelName, xstart, xstep, xpixels, ystart, ystep, ypixels)
d22.addComment("PIXEL, EACH PIXEL IS A DETECTOR")
d22.addCuboidPixel(pixelName, [-x, -y, z], [x, y, z], [-x, -y, thickness], [x, -y, z], shape_id="pixel-shape")
d22.writeGeom("./ILL/IDF/" + instrumentName + "_Definition.xml")
Right detector:
Same orientation of tubes, same size of pixels
Only 96 tubes instead of 128 tubes in the main detector
For more information, please visit
https://www.ill.eu/instruments-support/instruments-groups/instruments/d22/characteristics/
"""
d22 = MantidGeom(instrumentName, comment=comment, valid_from=validFrom)
d22.addSnsDefaults(default_view='3D',axis_view_3d='z-')
d22.addComment("SOURCE")
d22.addComponentILL("moderator", 0., 0., moderator_source, "Source")
d22.addComment("Sample position")
d22.addComponentILL("sample_position", 0., 0., 0., "SamplePos")
d22.addComment("MONITORS")
d22.addMonitors(names=["monitor1", "monitor2"], distance=[zMon1, zMon2])
d22.addComment("MONITOR SHAPE")
d22.addDummyMonitor(0.01, 0.03)
d22.addComment("MONITOR IDs")
d22.addMonitorIds([repr(100000), repr(100001)])
d22.addComment("DETECTOR")
d22.addComponentILL("detector", 0., 0., 0.)
detector = d22.makeTypeElement("detector")
d22.addComponentRectangularDetector(detector0, 0., 0., zPos, idstart=id0, idfillbyfirst=FF, idstepbyrow=SR, root=detector)
d22.addComponentRectangularDetector(detector1, -right_center_offset, 0., zPos-z_gap, idstart=id1, idfillbyfirst=FF, idstepbyrow=SR, root=detector)
d22.addRectangularDetector(detector0, pixelName, xstart, xstep, xpixels, ystart, ystep, ypixels)
d22.addRectangularDetector(detector1, pixelName, xstart_right, xstep, xpixels_right, ystart, ystep, ypixels)
d22.addComment("PIXEL, EACH PIXEL IS A DETECTOR")
d22.addCuboidPixel(pixelName, [-x, -y, thickness/2.], [-x, y, thickness/2.], [-x, -y, -thickness/2.], [x, -y, thickness/2.], shape_id="pixel-shape")
d22.writeGeom("./ILL/IDF/" + instrumentName + "_Definition.xml")
comment=" Created by Peter Peterson",
valid_from="2017-06-05 00:00:01")
instr.addComment("DEFAULTS")
instr.addSnsDefaults()
instr.addComment("SOURCE")
instr.addModerator(-19.5)
instr.addComment("SAMPLE")
instr.addSamplePosition()
# monitors
instr.addComment("MONITORS")
instr.addMonitorIds([-1,-2])
instr.addMonitors([-0.879475,5.748782], ["monitor1", "monitor2"])
instr.addComment("Shape for monitors")
instr.addComment("TODO: Update to real shape")
instr.addDummyMonitor(0.01, .03)
# TODO choppers and slits could go here
####################
# read the positions of the pixels that was provided
positions = readEngineeringPositions('SNS/NOMAD/NOM_detpos.txt')
# update engineering postions with values from survey - survey values are worse
#positionsSurvey = readSurveyPositions('SNS/NOMAD/NOMAD_survey_20180530_group6.csv')
#for i, key in enumerate(positionsSurvey.keys()):
# positions[key] = positionsSurvey[key]
num_banks = [14, 23, 14,12, 18, 18]
pixel_radius=TUBE_RADIUS,
pixel_height=TUBE_LENGTH_SHORT / TUBE_PIXELS,
)
# -- DETECTOR ID --
logging.info("Add detector IDs")
vulcan_geom.addComment("DETECTOR IDs - panel is an 8-pack")
for i, bank_id in enumerate(bank_ids):
num_eightpacks = len(df.loc[df["bank"] == bank_id,
"eightpack"].unique())
addBankIds(
instr=vulcan_geom,
bankname=f"bank{bank_id}",
bank_offset=i * PIXELS_PER_BANK,
num_panels=num_eightpacks,
)
# -- MISC --
logging.info("Add misc")
# shape for monitors
vulcan_geom.addComment(" Shape for Monitors")
vulcan_geom.addComment(" TODO: Update to real shape ")
vulcan_geom.addDummyMonitor(0.01, 0.03)
# monitor ids
vulcan_geom.addComment("MONITOR IDs")
vulcan_geom.addMonitorIds([-2, -3])
# -- SAVE --
logging.info(f"Save new IDF as {xml_outfile}")
vulcan_geom.writeGeom(xml_outfile)
instr.addMonitors(distance=[-2.935, -0.898, 1.042],
names=["monitor1", 'monitor2', 'monitor3'])
# add banks here
for bank in detcal.banks:
bank.addToXml(instr)
# shape for detector pixels - ignored by required
instr.addComment(' Pixel for Detectors')
delta = 0.000309
instr.addCuboidPixel("pixel", [-delta, -delta, 0.0], [-delta, delta, 0.0],
[-delta, -delta, -0.0001], [delta, -delta, 0.0],
shape_id="pixel-shape")
instr.addComment(" Shape for Monitors")
instr.addComment(" TODO: Update to real shape ")
instr.addDummyMonitor(0.01, .03)
instr.addComment("MONITOR IDs")
instr.addMonitorIds([-1, -2, -3])
instr.writeGeom(filename)
# write the parameter file
filename = filename.replace('Definition', 'Parameters')
param_contents = parameters_template.format(validfrom=valid_from,
T0=detcal.t0)
print('writing', filename)
with open(filename, mode='w') as handle:
handle.write(param_contents)
monitorZ = -0.362
pixelSpacingDegrees = 0.605
tubeAngles = np.linspace(0., (numberOfTubes - 1) * pixelSpacingDegrees,
numberOfTubes)
comment = """ This is the instrument definition file of the SHARP spectrometer at the ILL.
Generated file, PLEASE DO NOT EDIT THIS FILE!
This file was automatically generated by mantidgeometry/ILL/IDF/sharp_generateIDF.py
"""
geometry = MantidGeom(instrumentName, comment=comment, valid_from=valid_from)
geometry.addSnsDefaults(theta_sign_axis='x')
geometry.addComponentILL('fermi_chopper', 0.0, 0.0, -l1, 'Source')
geometry.addComponentILL('sample-position', 0.0, 0.0, 0.0, 'SamplePos')
geometry.addMonitors(names=['monitor'], distance=[monitorZ])
geometry.addDummyMonitor(0.009, 0.036) # the real radius is 0.09
geometry.addMonitorIds(['100000'])
geometry.addCylinderPixelAdvanced('pixel',
center_bottom_base={
'x': 0.,
'y': -pixelHeight / 2.,
'z': 0.
},
axis={
'x': 0.,
'y': 1.,
'z': 0.
},
pixel_radius=pixelRadius,
pixel_height=pixelHeight,
algebra='pixel_shape')
def generate_reflection_file(reflection_key):
r"""
Parameters
----------
reflection_key: str
Returns
-------
"""
refl = reflections[reflection_key]
if not os.path.exists(refl['nexus']):
message = '{} not found. Not creating geometry'.format(refl['nexus'])
raise FileExistsError(message)
inst_name = "BASIS"
# Set header information
comment = "Created by Michael Reuter and Jose Borreguero"
# Time needs to be in UTC?
valid_from = "2014-01-01 00:00:00"
xml_outfile = '{}_Definition_Si{}.xml'.format(inst_name, reflection_key)
nfile = h5py.File(refl['nexus'], 'r')
det = MantidGeom(inst_name, comment=comment, valid_from=valid_from)
det.addSnsDefaults(indirect=True)
det.addComment("SOURCE AND SAMPLE POSITION")
det.addModerator(-84.0)
det.addSamplePosition()
det.addComment("MONITORS")
det.addMonitors(names=["monitor1"], distance=["-0.23368"], neutronic=True)
# Create the inelastic banks information
det.addComment('INELASTIC DECTECTORS')
det.addComponent('silicon')
handle_silicon = det.makeTypeElement("silicon")
# Slicer for removing ghosts. Due to the mapping, the ghost tubes sit
# on the same sides of the arrays for all banks.
remove_ghosts = slice(-INELASTIC_TUBES_NGHOST)
for i in range(n_inelastic_banks):
bank_id = "bank%d" % (i + 1)
pixel_id = nfile["/entry/instrument/bank%d/pixel_id" %
(i + 1)].value[remove_ghosts]
distance = nfile["/entry/instrument/bank%d/distance" %
(i + 1)].value[remove_ghosts]
# theta or polar_angle: angle from the Z-axis towards the X-axis
polar_angle = nfile["/entry/instrument/bank%d/polar_angle" %
(i + 1)].value[remove_ghosts]
polar_angle *= (180.0 / math.pi)
# phi or azimuthal_angle: angle in the XY-plane
azimuthal_angle = nfile["/entry/instrument/bank%d/azimuthal_angle" %
(i + 1)].value[remove_ghosts]
azimuthal_angle *= (180.0 / math.pi)
analyser_wavelength = nfile["/entry/instrument/analyzer%d/wavelength" %
(i + 1)].value[remove_ghosts]
analyser_wavelength *= refl['ratio_to_irreducible_hkl']
analyser_energy = 81.8042051 / analyser_wavelength**2
det.addComponent(bank_id, idlist=bank_id, root=handle_silicon)
xbank, ybank, zbank = pixels_physical_xyz(i)
det.addDetectorPixels(bank_id,
x=xbank,
y=ybank,
z=zbank,
names=pixel_id,
energy=analyser_energy,
nr=distance,
ntheta=polar_angle,
nphi=azimuthal_angle,
output_efixed=refl['efixed'])
det.addDetectorPixelsIdList(bank_id,
r=distance,
names=pixel_id,
elg="multiple_ranges")
# Create the diffraction bank information
det.addComponent("elastic", "elastic")
handle = det.makeTypeElement("elastic")
idlist = []
detector_z = [
-2.1474825, -1.704594, -1.108373, -0.4135165, 0.3181, 1.0218315,
1.6330115, 2.0993535, 2.376999
]
detector_x = [
1.1649855, 1.7484015, 2.175541, 2.408594, 2.422933, 2.216378,
1.8142005, 1.247867, 0.5687435
]
detector_y = [
-0.001807, -0.001801, -0.0011845, -0.0006885, -0.0013145, -0.001626,
-0.001397, 0.0003465, -0.0001125
]
for i in range(ELASTIC_BANK_START, ELASTIC_BANK_END + 1):
bank_name = "bank%d" % i
det.addComponent(bank_name, root=handle)
k = i - ELASTIC_BANK_START
x_coord = detector_x[k]
y_coord = detector_y[k]
z_coord = detector_z[k]
det.addDetector(x_coord,
y_coord,
z_coord,
0.0,
0.,
90.,
bank_name,
"tube-elastic",
facingSample=True)
idlist.append(ELASTIC_DETECTORID_START + ELASTIC_TUBE_NPIXELS *
(i - ELASTIC_BANK_START))
idlist.append(ELASTIC_DETECTORID_START + ELASTIC_TUBE_NPIXELS *
(i - ELASTIC_BANK_START) + ELASTIC_TUBE_NPIXELS - 1)
idlist.append(None)
# Diffraction tube information
det.addComment("ELASTIC TUBE (90 degrees)")
det.addPixelatedTube("tube-elastic",
ELASTIC_TUBE_NPIXELS,
ELASTIC_TUBE_LENGTH,
"pixel-elastic-tube",
neutronic=True,
neutronicIsPhysical=True)
# Set the diffraction pixel Ids
det.addDetectorIds("elastic", idlist)
# Creating diffraction pixel
det.addComment("PIXEL FOR DIFFRACTION TUBES")
det.addCylinderPixel("pixel-elastic-tube", (0.0, 0.0, 0.0),
(0.0, 1.0, 0.0), (ELASTIC_TUBE_WIDTH / 2.0),
(ELASTIC_TUBE_LENGTH / ELASTIC_TUBE_NPIXELS))
det.addComment("PIXEL FOR INELASTIC TUBES")
det.addCylinderPixel(
"pixel", (0.0, 0.0, 0.0), (0.0, 1.0, 0.0),
INELASTIC_TUBE_WIDTH * (1.0 - INELASTIC_PIXEL_RADIUS_GAP_RATIO) / 2.0,
INELASTIC_TUBE_LENGTH * (1.0 - INELASTIC_PIXEL_HEIGHT_GAP_RATIO) /
INELASTIC_TUBE_NPIXEL,
is_type="detector",
algebra="cyl-approx")
det.addComment("MONITOR SHAPE")
det.addComment("FIXME: Do something real here.")
det.addDummyMonitor(0.01, 0.03)
det.addComment("MONITOR IDs")
det.addMonitorIds(["-1"])
det.writeGeom(xml_outfile)
# Always clean after yourself
nfile.close()
Pixel size 5 x 5 mm^2 ( 32 x 128 pixels )
For more information, please visit
https://www.ill.eu/instruments-support/instruments-groups/instruments/d33/characteristics/
"""
d33 = MantidGeom(instrumentName, comment=comment, valid_from=validFrom)
d33.addSnsDefaults()
d33.addComment("SOURCE")
d33.addComponentILL("moderator", 0., 0., moderator_source, "Source")
d33.addComment("Sample position")
d33.addComponentILL("sample_position", 0., 0., 0., "SamplePos")
d33.addComment("MONITORS")
d33.addMonitors(names=["monitor1", "monitor2"], distance=[zMon1, zMon2])
d33.addComment("MONITOR SHAPE")
d33.addComment("FIXME: Do something real here.")
d33.addDummyMonitor(0.01, 0.03)
d33.addComment("MONITOR IDs")
d33.addMonitorIds([repr(500000), repr(500001)])
d33.addComment("DETECTORS")
d33.addComponentILL("detector", 0., 0., 0.)
detector = d33.makeTypeElement("detector")
d33.addComponentRectangularDetector(detector0, 0., 0., zPosRear, idstart=id0, idfillbyfirst=FF, idstepbyrow=SR, root=detector)
d33.addComponentILL("front_detector", 0., 0., 0., root=detector)
front_detector = d33.makeTypeElement("front_detector")
d33.addComponentRectangularDetector(detector1, dF+dR, 0., zFront, idstart=id1, idfillbyfirst="x",
idstepbyrow=SRF, rotz=90., roty=180., root=front_detector)
d33.addComponentRectangularDetector(detector2, -dR-dF, 0., zFront, idstart=id2, idfillbyfirst="x",
idstepbyrow=SRF, rotz=90., roty=180., root=front_detector)
d33.addComponentRectangularDetector(detector3, 0., -dF-dR, zFront, idstart=id3, idfillbyfirst=FF, idstepbyrow=SRF, root=front_detector)
d33.addComponentRectangularDetector(detector4, 0., dR+dF, zFront, idstart=id4, idfillbyfirst=FF, idstepbyrow=SRF, root=front_detector)
d33.addComment("REAR DETECTOR")
Slit 3 to sample distance: 0.205 m
For more information, please visit
https://www.ill.eu/instruments-support/instruments-groups/instruments/d17/characteristics/
"""
d17 = MantidGeom(instrumentName, comment=comment, valid_from=validFrom)
d17.addSnsDefaults(theta_sign_axis='x')
d17.addComment("SOURCE")
d17.addComponentILL("chopper1", 0.0, 0.0, chop1_source, "Source")
d17.addComment("Sample position")
d17.addComponentILL("sample_position", 0.0, 0.0, 0.0, "SamplePos")
d17.addComment("MONITORS")
d17.addMonitors(names=["monitor1", "monitor2"], distance=[zMon1, zMon2])
d17.addComment("MONITOR SHAPE")
d17.addComment("FIXME: Do something real here.")
d17.addDummyMonitor(0.01, 0.03)
d17.addComment("MONITOR IDs")
d17.addMonitorIds(["100000", "100001"])
d17.addComment("2 Slits")
d17.addComponentILL("slit2", 0.0, 0.0, slit2Centre)
d17.makeTypeElement("slit2")
d17.addComponentILL("slit3", 0.0, 0.0, slit3Centre)
d17.makeTypeElement("slit3")
d17.addComment("DETECTORS")
d17.addComment("64 TUBES FORM ONE DETECTOR")
d17.addComponentRectangularDetector("detector", 0.0, 0.0, detValue, idstart="1", idfillbyfirst="x",
idstepbyrow="1")
d17.addComment("PIXEL, EACH PIXEL IS A DETECTOR")
d17.addRectangularDetector("detector", "pixel", xstart, xstep, xpixels, ystart, ystep, ypixels)
d17.addCuboidPixel("pixel", [-x, -y, z], [x, y, z], [-x, -y, thickness], [x, -y, z], shape_id="pixel-shape")
d17.writeGeom("./ILL/IDF/" + instrumentName + "_Definition.xml")
r += 2 * analyser - psd
else:
p += pi
t = pi - t
r += 2 * analyser
return tocartesian(r, t, p)
geometry = MantidGeom(instrument_name, comment=comment, valid_from=valid_from)
geometry.addSnsDefaults(indirect=args.geometrytype != 'N')
geometry.addSamplePosition()
geometry.addModerator(distance=ch12, name="chopper")
geometry.addMonitors(names=["monitor"],
distance=[mon],
neutronic=args.geometrytype != 'N')
geometry.addDummyMonitor(0.001, 0.001)
geometry.addMonitorIds([0])
geometry.addComponent("single_detectors",
"single_detectors",
blank_location=False)
sds = geometry.makeTypeElement("single_detectors")
sdc = geometry.addComponent("single_pixel", root=sds)
for i in range(len(SD_azimuths)):
t = SD_azimuths[i] * pi / 180.
x = sd * sin(t)
y = 0.
z = -sd * cos(t)
nx, ny, nz = mirror(x, y, z, sd_analyser)
if args.geometrytype == 'N':
geometry.addLocation(root=sdc,
x=nx,
pixelSpacingDegrees = gammaSpan / 640
offset = float(args.GlobalOffset) - gammaSpan / 2.0
tubeAngles = np.linspace(offset,
(numberOfTubes - 1) * pixelSpacingDegrees + offset,
numberOfTubes)
comment = """ This is the instrument definition file of the D19 single-crystal diffractometer at the ILL.
Generated file, PLEASE DO NOT EDIT THIS FILE!
This file was automatically generated by mantidgeometry/ILL/IDF/d19_generateIDF.py
"""
geometry = MantidGeom(instrumentName, comment=comment, valid_from=valid_from)
geometry.addSnsDefaults(theta_sign_axis='x')
geometry.addComponentILL('fermi_chopper', 0.0, 0.0, -l1, 'Source')
geometry.addComponentILL('sample-position', 0.0, 0.0, 0.0, 'SamplePos')
geometry.addMonitors(names=['monitor'], distance=[monitorZ])
geometry.addDummyMonitor(0.009, 0.036) # temporary, not established
geometry.addMonitorIds(['200000'])
geometry.addCylinderPixelAdvanced('pixel',
center_bottom_base={
'x': 0.,
'y': -pixelHeight / 2.,
'z': 0.
},
axis={
'x': 0.,
'y': 1.,
'z': 0.
},
pixel_radius=pixelRadius,
pixel_height=pixelHeight,
algebra='pixel_shape')
def main():
from helper import MantidGeom
inst_name = "VISION"
xml_outfile = inst_name+"_Definition.xml"
det = MantidGeom(inst_name, comment=" Created by Stuart Campbell ")
det.addSnsDefaults(indirect=True)
det.addComment("SOURCE AND SAMPLE POSITION")
det.addModerator(-16.0)
det.addSamplePosition()
# Backscattering Banks are 21-100
BACKSCATTERING_NTUBES = 80
det.addComponent("elastic-backscattering", "elastic-backscattering")
handle = det.makeTypeElement("elastic-backscattering")
idlist = []
for k in range(BACKSCATTERING_NTUBES):
id_start = 26624+(256*k)
id_end = 26624 + (256*k) + 255
angle = -(2.25 + 4.5*k)
bankid = 21 + k
bank_name = "bank%d" % bankid
det.addComponent(bank_name, root=handle)
z_coord = -0.998
if k%2 == 0:
# Even tube number (long)
centre_offset = BS_ELASTIC_LONG_TUBE_INNER_RADIUS + (BS_ELASTIC_LONG_TUBE_LENGTH/2.0)
#centre_offset = BS_ELASTIC_LONG_TUBE_INNER_RADIUS
component_name = "tube-long-bs-elastic"
else:
# Odd tube number (short)
centre_offset = BS_ELASTIC_SHORT_TUBE_INNER_RADIUS + (BS_ELASTIC_SHORT_TUBE_LENGTH/2.0)
component_name = "tube-short-bs-elastic"
x_coord = centre_offset * math.cos(math.radians(90-angle))
y_coord = centre_offset * math.sin(math.radians(90-angle))
det.addDetector(x_coord, y_coord, z_coord, 0, 0, -angle, bank_name, component_name)
idlist.append(id_start)
idlist.append(id_end)
idlist.append(None)
det.addDetectorIds("elastic-backscattering", idlist)
# 90 elastic banks
elastic_banklist = [3,6,9,12,15,18]
elastic_bank_start = [2048,6144,10240,14336,18432,22528]
elastic_angle = [22.5,-22.5,-67.5,-112.5,-157.5,157.5]
sample_elastic_distance = 0.635
det.addComponent("elastic", "elastic")
handle = det.makeTypeElement("elastic")
idlist = []
elastic_index = 0
for i in elastic_banklist:
bank_name = "bank%d" % i
det.addComponent(bank_name, root=handle)
z_coord = 0.0
x_coord = sample_elastic_distance * math.cos(math.radians(elastic_angle[elastic_index]))
y_coord = sample_elastic_distance * math.sin(math.radians(elastic_angle[elastic_index]))
det.addDetector(x_coord, y_coord, z_coord, -90.0, 0, 0., bank_name, "eightpack-elastic", facingSample=True)
idlist.append(elastic_bank_start[elastic_index])
idlist.append(elastic_bank_start[elastic_index]+2047)
idlist.append(None)
elastic_index += 1
det.addDetectorIds("elastic", idlist)
# Inelastic
inelastic_banklist = [1,2,4,5,7,8,10,11,13,14,16,17,19,20]
inelastic_bank_start=[0,1024,4096,5120,8192,9216,12288,13312,16384,17408,20480,21504,24576,25600]
inelastic_angle = [45.0,45.0,0.0,0.0,-45.0,-45.0,-90.0,-90.0,-135.0,-135.0,180.0,180.0,135.0,135.0]
inelastic_angle_for_rotation = [-45.0,-45.0,180.0,180.0,-135.0,-135.0,-90.0,-90.0,-225.0,-225.0,0.0,0.0,45.0,45.0]
sample_inelastic_distance = 0.5174
det.addComponent("inelastic", "inelastic")
handle = det.makeTypeElement("inelastic")
idlist = []
inelastic_index = 0
for i in inelastic_banklist:
bank_name = "bank%d" % i
bank_comp = det.addComponent(bank_name, root=handle, blank_location=True)
# location_element = le.SubElement(bank_comp, "location")
# le.SubElement(location_element, "rot", **{"val":"90", "axis-x":"0",
# "axis-y":"0", "axis-z":"1"})
# Neutronic Positions
z_coord_neutronic = sample_inelastic_distance * math.tan(math.radians(45.0))
if inelastic_index % 2 == 0:
# Facing Downstream
z_coord = 0.01
else:
# Facing to Moderator
z_coord = -0.01
z_coord_neutronic = -z_coord_neutronic
# Physical Positions
x_coord = sample_inelastic_distance * math.cos(math.radians(inelastic_angle[inelastic_index]))
y_coord = sample_inelastic_distance * math.sin(math.radians(inelastic_angle[inelastic_index]))
det.addDetector(-x_coord, y_coord, z_coord, 0, 0, inelastic_angle_for_rotation[inelastic_index]-90.0, bank_name,
"eightpack-inelastic", neutronic=True, nx=-x_coord, ny=y_coord, nz=z_coord_neutronic)
efixed = ("Efixed", "3.64", "meV")
det.addDetectorParameters(bank_name, efixed )
idlist.append(inelastic_bank_start[inelastic_index])
idlist.append(inelastic_bank_start[inelastic_index]+1023)
idlist.append(None)
inelastic_index += 1
det.addDetectorIds("inelastic", idlist)
# 8 packs
det.addComment("INELASTIC 8-PACK")
det.addNPack("eightpack-inelastic", INELASTIC_TUBES_PER_BANK, INELASTIC_TUBE_WIDTH,
INELASTIC_AIR_GAP, "tube-inelastic", neutronic=True)
det.addComment("ELASTIC 8-PACK")
det.addNPack("eightpack-elastic", ELASTIC_TUBES_PER_BANK, ELASTIC_TUBE_WIDTH,
ELASTIC_AIR_GAP, "tube-elastic", neutronic=True, neutronicIsPhysical=True)
# TUBES
det.addComment("INELASTIC TUBE")
det.addPixelatedTube("tube-inelastic", INELASTIC_TUBE_NPIXELS,
INELASTIC_TUBE_LENGTH, "pixel-inelastic-tube", neutronic=True)
det.addComment("BACKSCATTERING LONG TUBE")
det.addPixelatedTube("tube-long-bs-elastic", BS_ELASTIC_LONG_TUBE_NPIXELS,
BS_ELASTIC_LONG_TUBE_LENGTH, "pixel-bs-elastic-long-tube",
neutronic=True, neutronicIsPhysical=True)
det.addComment("BACKSCATTERING SHORT TUBE")
det.addPixelatedTube("tube-short-bs-elastic", BS_ELASTIC_SHORT_TUBE_NPIXELS,
BS_ELASTIC_SHORT_TUBE_LENGTH, "pixel-bs-elastic-short-tube",
neutronic=True, neutronicIsPhysical=True)
det.addComment("ELASTIC TUBE (90 degrees)")
det.addPixelatedTube("tube-elastic", ELASTIC_TUBE_NPIXELS,
ELASTIC_TUBE_LENGTH, "pixel-elastic-tube", neutronic=True, neutronicIsPhysical=True)
# PIXELS
det.addComment("PIXEL FOR INELASTIC TUBES")
det.addCylinderPixel("pixel-inelastic-tube", (0.0, 0.0, 0.0), (0.0, 1.0, 0.0),
(INELASTIC_TUBE_WIDTH/2.0),
(INELASTIC_TUBE_LENGTH/INELASTIC_TUBE_NPIXELS))
det.addComment("PIXEL FOR BACKSCATTERING ELASTIC TUBES (LONG)")
det.addCylinderPixel("pixel-bs-elastic-long-tube", (0.0, 0.0, 0.0), (0.0, 1.0, 0.0),
(BS_ELASTIC_LONG_TUBE_WIDTH/2.0),
(BS_ELASTIC_LONG_TUBE_LENGTH/BS_ELASTIC_LONG_TUBE_NPIXELS))
det.addComment("PIXEL FOR BACKSCATTERING ELASTIC TUBES (SHORT)")
det.addCylinderPixel("pixel-bs-elastic-short-tube", (0.0, 0.0, 0.0), (0.0, 1.0, 0.0),
(BS_ELASTIC_SHORT_TUBE_WIDTH/2.0),
(BS_ELASTIC_SHORT_TUBE_LENGTH/BS_ELASTIC_SHORT_TUBE_NPIXELS))
det.addComment("PIXEL FOR ELASTIC TUBES (90 degrees)")
det.addCylinderPixel("pixel-elastic-tube", (0.0, 0.0, 0.0), (0.0, 1.0, 0.0),
(ELASTIC_TUBE_WIDTH/2.0),
(ELASTIC_TUBE_LENGTH/ELASTIC_TUBE_NPIXELS))
det.addComment(" ##### MONITORS ##### ")
det.addMonitors(names=["monitor1"], distance=["-6.71625"], neutronic=True)
# MONITORS
det.addComment("MONITOR SHAPE")
det.addComment("FIXME: Do something real here.")
det.addDummyMonitor(0.01, 0.03)
det.addComment("MONITOR IDs")
det.addMonitorIds(["-1"])
det.showGeom()
det.writeGeom(xml_outfile)
Pixel size 5 x 5 mm^2 ( 32 x 128 pixels )
For more information, please visit
https://www.ill.eu/instruments-support/instruments-groups/instruments/d33/characteristics/
"""
d33 = MantidGeom(instrumentName, comment=comment, valid_from=validFrom)
d33.addSnsDefaults(default_view='3D', axis_view_3d='z-')
d33.addComment("SOURCE")
d33.addComponentILL("moderator", 0., 0., moderator_source, "Source")
d33.addComment("Sample position")
d33.addComponentILL("sample_position", 0., 0., 0., "SamplePos")
d33.addComment("MONITORS")
d33.addMonitors(names=["monitor1", "monitor2"], distance=[zMon1, zMon2])
d33.addComment("MONITOR SHAPE")
d33.addComment("FIXME: Do something real here.")
d33.addDummyMonitor(0.01, 0.03)
d33.addComment("MONITOR IDs")
d33.addMonitorIds([repr(500000), repr(500001)])
d33.addComment("DETECTORS")
d33.addComponentILL("detector", 0., 0., 0.)
detector = d33.makeTypeElement("detector")
d33.addComponentRectangularDetector(detector0,
0.,
0.,
zPosRear,
idstart=id0,
idfillbyfirst="x",
idstepbyrow=SR,
rotz=90.,
root=detector)
d33.addComponentILL("front_detector", 0., 0., 0., root=detector)
salsa = MantidGeom(instrumentName, comment=comment, valid_from=validFrom)
salsa.addSnsDefaults(default_view='spherical_y',
axis_view_3d='z-',
theta_sign_axis="x")
salsa.addComment("SOURCE")
salsa.addComponentILL("monochromator", 0., 0., zSource, "Source")
# Sample is set as the origin
salsa.addComment("Sample position")
salsa.addComponentILL("sample_position", 0., 0., 0., "SamplePos")
salsa.addComment("MONITORS")
salsa.addMonitors(names=["monitor"], distance=[zMonitor])
salsa.addComment("MONITOR SHAPE")
salsa.addDummyMonitor(0.01, 0.01)
salsa.addComment("MONITOR IDs")
salsa.addMonitorIds([repr(256 * 256)])
salsa.addComment("DETECTOR")
salsa.addRectangularDetector(detector0, pixelName, xstart, xstep, xpixels,
ystart, ystep, ypixels)
salsa.addComponentRectangularDetector(detector0,
0.,
0.,
zDetector,
idstart=id0,
idfillbyfirst=FF,
idstepbyrow=SR)
salsa.addComment("PIXEL, EACH PIXEL IS A DETECTOR")
z = r * cos(t)
return [x, y, z]
def mirror(x, y, z):
r, t, p = topolar(x, y, z)
r += 2*analyser
t = pi - t
p += pi
return tocartesian(r, t, p)
geometry = MantidGeom(instrument_name, comment=comment, valid_from=valid_from)
geometry.addSnsDefaults(indirect=args.geometrytype != 'N')
geometry.addSamplePosition()
geometry.addModerator(distance=ch12, name="chopper")
geometry.addMonitors(names=["monitor"], distance=[mon], neutronic=args.geometrytype != 'N')
geometry.addDummyMonitor(0.001, 0.001)
geometry.addMonitorIds([0])
geometry.addComponent("single_detectors", "single_detectors")
sds = geometry.makeTypeElement("single_detectors")
sdc = geometry.addComponent("single_pixel", root=sds, blank_location=False)
r = 2*analyser+psd
for i in range(len(SD_azimuths)):
t=SD_azimuths[i]* pi/180.
x = - psd * sin(t)
y = 0.
z = - psd * cos(t)
nx, ny, nz = mirror(x, y, z)
if args.geometrytype == 'N':
geometry.addLocation(root=sdc, x=nx, y=ny, z=nz, name="single_tube_{0}".format(i+1))
else:
geometry.addLocation(root=sdc, x=x, y=y, z=z, nx=nx, ny=ny, nz=nz, name="single_tube_{0}".format(i+1), neutronic=True)
chopper_to_sample = -34.3
monitor_to_sample = -0.178
in16b = MantidGeom(instrument_name, comment=comment, valid_from=valid_from)
in16b.addSnsDefaults(default_view='3D', axis_view_3d='z-', theta_sign_axis="x")
in16b.addComment("Sample position")
in16b.addSamplePosition()
in16b.addComment("Chopper position")
in16b.addModerator(distance=chopper_to_sample, name="chopper")
in16b.addComment("MONITOR")
in16b.addMonitors(names=["monitor"], distance=[monitor_to_sample])
in16b.addDummyMonitor(0.001, 0.001)
in16b.addMonitorIds([0])
in16b.addComment("Detector")
in16b.addComponentILL("detector", 0, 0, 0)
detector = in16b.makeTypeElement("detector")
# create tubes id lists
for i in range(number_of_tubes):
in16b.addDetectorIds("tube_{0}_ids".format(i + 1),
[pixel_per_tube * i + 1, pixel_per_tube * (i + 1), 1])
# create standard tube component and place them
tube = in16b.makeTypeElement("tube")
for i in range(number_of_tubes):
current_tube = in16b.addComponent('tube',
fourpack_slip=0.0055103014,
number_eightpacks=24)
# Instrument handle
det = MantidGeom(iinfo['instrument_name'], **kw(iinfo, 'comment', 'valid_from', 'valid_to'))
det.addSnsDefaults(default_view="3D", axis_view_3d="Z-")
fn = make_filename(*ag(iinfo, 'instrument_name', 'valid_from', 'valid_to'))
add_basic_types(det, iinfo) # source, sample, pixel, tube, and fourpack
#
# Monitor Section
#
add_comment_section(det, 'COMPONENT, TYPE, and IDLIST: MONITORS')
det.addMonitors(distance=[m['z'] for m in iinfo['monitors']],
names=[m['name'] for m in iinfo['monitors']])
det.addMonitorIds(ids=[-1, -2])
det.addDummyMonitor(0.01, 0.1)
#
# Insert the flat panel
#
double_panel = add_double_flat_panel_type(det, iinfo)
pixel_idlist = 'flat_panel_ids'
double_panel = add_double_flat_panel_component(double_panel, 'flat_panel_ids', det, iinfo['flat_array'])
insert_location_from_logs(double_panel, log_key=['detector_trans_Readback', 'sample_detector_distance'],
coord_name=['x', 'z'], equation=['-0.001*value', 'value'])
add_double_panel_idlist(det, iinfo, pixel_idlist)
last_pixel_id = 8 * iinfo['number_eightpacks'] * iinfo['pixels_per_tube'] - 1
last_bank_number = 2 * iinfo['number_eightpacks']
#
# Insert the curved panel
#
"""
Q-range, down 0.0045 - 0.27 A-1
For more information, please visit
https://www.ill.eu/instruments-support/instruments-groups/instruments/figaro/characteristics/
"""
figaro = MantidGeom(instrumentName, comment=comment, valid_from=validFrom)
figaro.addSnsDefaults(theta_sign_axis='y')
figaro.addComment("SOURCE")
figaro.addComponentILL("chopper1", 0.0, 0.0, zSource, "Source")
figaro.addComment("Sample position")
figaro.addComponentILL("sample_position", 0.0, 0.0, 0.0, "SamplePos")
figaro.addComment("MONITORS")
figaro.addMonitors(names=["monitor1", "monitor2"], distance=[zMon1, zMon2])
figaro.addComment("MONITOR SHAPE")
figaro.addComment("FIXME: Do something real here.")
figaro.addDummyMonitor(0.01, 0.03)
figaro.addComment("MONITOR IDs")
figaro.addMonitorIds(["100000", "100001"])
figaro.addComment("2 Slits")
figaro.addComponentILL("slit2", 0.0, 0.0, slit2Centre)
figaro.makeTypeElement("slit2")
figaro.addComponentILL("slit3", 0.0, 0.0, slit3Centre)
figaro.makeTypeElement("slit3")
figaro.addComment("DETECTORS")
figaro.addComment("64 tubes form the detector")
figaro.addComponentRectangularDetector("detector",
0.0,
0.0,
zDetector,
idstart="1",
idfillbyfirst="x",
boxAngles = list()
firstBoxCenterAngle = -0.5 * (boxAngleWidth + boxGapAngle)
for i in range(numberOfBoxes):
boxAngles.append(firstBoxCenterAngle + i * (boxAngleWidth + boxGapAngle))
comment = """ This is the instrument definition file of the PANTHER spectrometer at the ILL.
This file was automatically generated by mantidgeometry/ILL/IDF/panther_generateIDF.py
"""
validFrom = '1900-01-31 23:59:59'
geometry = MantidGeom(instrumentName, comment=comment, valid_from=validFrom)
geometry.addSnsDefaults(theta_sign_axis='x')
geometry.addComponentILL('fermi_chopper', 0.0, 0.0, -l1, 'Source')
geometry.addComponentILL('sample-position', 0.0, 0.0, 0.0, 'SamplePos')
geometry.addMonitors(names=['monitor'], distance=[monitorZ])
geometry.addDummyMonitor(0.01, 0.03)
geometry.addMonitorIds(['100000'])
geometry.addCylinderPixelAdvanced(
'pixel', center_bottom_base={'x': 0., 'y': 0., 'z': -pixelHeight / 2.},
axis={'x': 0., 'y': 1., 'z': 0.}, pixel_radius=pixelRadius,
pixel_height=pixelHeight,
algebra='pixel_shape')
root = geometry.getRoot()
bank = le.SubElement(root, 'type', name='bank')
tubes = le.SubElement(bank, 'component', type='tube')
for boxIndex, boxAngle in enumerate(boxAngles):
for tubeIndex in range(numberOfTubesPerBox):
tubeAngle = boxAngle - boxAngleWidth / 2. + tubeIndex * tubeAngleStep
x = l2 * np.sin(np.deg2rad(tubeAngle))
y = tubeVerticalShift
z = l2 * np.cos(np.deg2rad(tubeAngle))
Pixel size 7.5 mm x 7.5 mm ( 128 x 128 pixels )
For more information, please visit
https://www.ill.eu/instruments-support/instruments-groups/instruments/d11/characteristics/
"""
d11 = MantidGeom(instrumentName, comment=comment, valid_from=validFrom)
d11.addSnsDefaults(default_view='3D', axis_view_3d='z-')
d11.addComment("SOURCE")
d11.addComponentILL("moderator", 0., 0., moderator_source, "Source")
d11.addComment("Sample position")
d11.addComponentILL("sample_position", 0., 0., 0., "SamplePos")
d11.addComment("MONITORS")
d11.addMonitors(names=["monitor1", "monitor2"], distance=[zMon1, zMon2])
d11.addComment("MONITOR SHAPE")
d11.addComment("FIXME: Do something real here.")
d11.addDummyMonitor(0.01, 0.03)
d11.addComment("MONITOR IDs")
d11.addMonitorIds([repr(100000), repr(100001)])
d11.addComment("DETECTOR")
d11.addComponentRectangularDetector(detector0,
0.,
0.,
zPos,
idstart=id0,
idfillbyfirst=FF,
idstepbyrow=SR)
d11.addRectangularDetector(detector0, pixelName, xstart, xstep, xpixels,
ystart, ystep, ypixels)
d11.addComment("PIXEL, EACH PIXEL IS A DETECTOR")
d11.addCuboidPixel(pixelName, [-x, -y, thickness / 2.],
[-x, y, thickness / 2.], [-x, -y, -thickness / 2.],
det.addDetector(xpos, ypos, zpos, ROTX, roty, ROTZ, detname, "eightpack")
det.addComment("STANDARD 8-PACK")
det.addNPack("eightpack", NUM_TUBES_PER_BANK, TUBE_WIDTH, AIR_GAP_WIDTH)
det.addComment("STANDARD 2m 128 PIXEL TUBE")
det.addPixelatedTube("tube", NUM_PIXELS_PER_TUBE, TUBE_SIZE)
det.addComment("PIXEL FOR STANDARD 2m 128 PIXEL TUBE")
det.addCylinderPixel("pixel", (0.0, 0.0, 0.0), (0.0, 1.0, 0.0),
(TUBE_WIDTH/2.0),
(TUBE_SIZE/NUM_PIXELS_PER_TUBE))
det.addComment("MONITOR SHAPE")
det.addComment("FIXME: Do something real here.")
det.addDummyMonitor(0.01, 0.03)
det.addComment("DETECTOR IDs")
det.addDetectorIds(label, [0, (num_dets * PIXELS_PER_BANK) - 1 , None])
det.addComment("MONITOR IDs")
det.addMonitorIds(["-1", "-2", "-3"])
det.addComment("DETECTOR PARAMETERS")
det.addDetectorParameters(label, TUBE_PRESSURE, TUBE_THICKNESS,
TUBE_TEMPERATURE)
#det.showGeom()
det.writeGeom(xml_outfile)
def generate_reflection_file(reflection_key):
r"""
Parameters
----------
reflection_key: str
Returns
-------
"""
refl = reflections[reflection_key]
if not os.path.exists(refl['nexus']):
message = '{} not found. Not creating geometry'.format(refl['nexus'])
raise FileExistsError(message)
inst_name = "BASIS"
# Set header information
comment = "Created by Michael Reuter and Jose Borreguero"
# Time needs to be in UTC?
valid_from = "2014-01-01 00:00:00"
xml_outfile = '{}_Definition_Si{}.xml'.format(inst_name, reflection_key)
nfile = h5py.File(refl['nexus'], 'r')
det = MantidGeom(inst_name, comment=comment, valid_from=valid_from)
det.addSnsDefaults(indirect=True)
det.addComment("SOURCE AND SAMPLE POSITION")
det.addModerator(-84.0)
det.addSamplePosition()
det.addComment("MONITORS")
det.addMonitors(names=["monitor1"], distance=["-0.23368"], neutronic=True)
# Create the inelastic banks information
det.addComment('INELASTIC DECTECTORS')
det.addComponent('silicon')
handle_silicon = det.makeTypeElement("silicon")
# Slicer for removing ghosts. Due to the mapping, the ghost tubes sit
# on the same sides of the arrays for all banks.
remove_ghosts = slice(-INELASTIC_TUBES_NGHOST)
for i in range(n_inelastic_banks):
bank_id = "bank%d" % (i+1)
pixel_id = nfile["/entry/instrument/bank%d/pixel_id" % (i+1)].value[remove_ghosts]
distance = nfile["/entry/instrument/bank%d/distance" % (i+1)].value[remove_ghosts]
# theta or polar_angle: angle from the Z-axis towards the X-axis
polar_angle = nfile["/entry/instrument/bank%d/polar_angle" % (i+1)].value[remove_ghosts]
polar_angle *= (180.0/math.pi)
# phi or azimuthal_angle: angle in the XY-plane
azimuthal_angle = nfile["/entry/instrument/bank%d/azimuthal_angle" % (i+1)].value[remove_ghosts]
azimuthal_angle *= (180.0/math.pi)
analyser_wavelength = nfile["/entry/instrument/analyzer%d/wavelength" % (i+1)].value[remove_ghosts]
analyser_wavelength *= refl['ratio_to_irreducible_hkl']
analyser_energy = 81.8042051/analyser_wavelength**2
det.addComponent(bank_id, idlist=bank_id, root=handle_silicon)
xbank, ybank, zbank = pixels_physical_xyz(i)
det.addDetectorPixels(bank_id, x=xbank, y=ybank, z=zbank,
names=pixel_id, energy=analyser_energy,
nr=distance, ntheta=polar_angle,
nphi=azimuthal_angle,
output_efixed=refl['efixed'])
det.addDetectorPixelsIdList(bank_id, r=distance, names=pixel_id,
elg="multiple_ranges")
# Create the diffraction bank information
det.addComponent("elastic", "elastic")
handle = det.makeTypeElement("elastic")
idlist = []
detector_z = [-2.1474825, -1.704594, -1.108373, -0.4135165, 0.3181,
1.0218315, 1.6330115, 2.0993535, 2.376999]
detector_x = [1.1649855, 1.7484015, 2.175541, 2.408594, 2.422933,
2.216378, 1.8142005, 1.247867, 0.5687435]
detector_y = [-0.001807, -0.001801, -0.0011845, -0.0006885, -0.0013145,
-0.001626, -0.001397, 0.0003465, -0.0001125]
for i in range(ELASTIC_BANK_START, ELASTIC_BANK_END+1):
bank_name = "bank%d" % i
det.addComponent(bank_name, root=handle)
k = i - ELASTIC_BANK_START
x_coord = detector_x[k]
y_coord = detector_y[k]
z_coord = detector_z[k]
det.addDetector(x_coord, y_coord, z_coord, 0.0, 0., 90.,
bank_name, "tube-elastic", facingSample=True)
idlist.append(ELASTIC_DETECTORID_START +
ELASTIC_TUBE_NPIXELS*(i-ELASTIC_BANK_START))
idlist.append(ELASTIC_DETECTORID_START +
ELASTIC_TUBE_NPIXELS*(i-ELASTIC_BANK_START) +
ELASTIC_TUBE_NPIXELS-1)
idlist.append(None)
# Diffraction tube information
det.addComment("ELASTIC TUBE (90 degrees)")
det.addPixelatedTube("tube-elastic", ELASTIC_TUBE_NPIXELS,
ELASTIC_TUBE_LENGTH, "pixel-elastic-tube",
neutronic=True, neutronicIsPhysical=True)
# Set the diffraction pixel Ids
det.addDetectorIds("elastic", idlist)
# Creating diffraction pixel
det.addComment("PIXEL FOR DIFFRACTION TUBES")
det.addCylinderPixel("pixel-elastic-tube",
(0.0, 0.0, 0.0), (0.0, 1.0, 0.0),
(ELASTIC_TUBE_WIDTH/2.0),
(ELASTIC_TUBE_LENGTH/ELASTIC_TUBE_NPIXELS))
det.addComment("PIXEL FOR INELASTIC TUBES")
det.addCylinderPixel("pixel", (0.0, 0.0, 0.0), (0.0, 1.0, 0.0),
INELASTIC_TUBE_WIDTH * (1.0-INELASTIC_PIXEL_RADIUS_GAP_RATIO) / 2.0,
INELASTIC_TUBE_LENGTH * (1.0-INELASTIC_PIXEL_HEIGHT_GAP_RATIO) / INELASTIC_TUBE_NPIXEL,
is_type="detector", algebra="cyl-approx")
det.addComment("MONITOR SHAPE")
det.addComment("FIXME: Do something real here.")
det.addDummyMonitor(0.01, 0.03)
det.addComment("MONITOR IDs")
det.addMonitorIds(["-1"])
det.writeGeom(xml_outfile)
# Always clean after yourself
nfile.close()
Q-range, down 0.0045 - 0.27 A-1
For more information, please visit
https://www.ill.eu/instruments-support/instruments-groups/instruments/figaro/characteristics/
"""
figaro = MantidGeom(instrumentName, comment=comment, valid_from=validFrom)
figaro.addSnsDefaults(theta_sign_axis='y')
figaro.addComment("SOURCE")
figaro.addComponentILL("chopper1", 0.0, 0.0, zSource, "Source")
figaro.addComment("Sample position")
figaro.addComponentILL("sample_position", 0.0, 0.0, 0.0, "SamplePos")
figaro.addComment("MONITORS")
figaro.addMonitors(names=["monitor1", "monitor2"], distance=[zMon1, zMon2])
figaro.addComment("MONITOR SHAPE")
figaro.addComment("FIXME: Do something real here.")
figaro.addDummyMonitor(0.01, 0.03)
figaro.addComment("MONITOR IDs")
figaro.addMonitorIds(["100000", "100001"])
figaro.addComment("2 Slits")
figaro.addComponentILL("slit2", 0.0, 0.0, slit2Centre)
figaro.makeTypeElement("slit2")
figaro.addComponentILL("slit3", 0.0, 0.0, slit3Centre)
figaro.makeTypeElement("slit3")
figaro.addComment("DETECTORS")
figaro.addComment("64 tubes form the detector")
figaro.addComponentRectangularDetector("detector", 0.0, 0.0, zDetector, idstart="1", idfillbyfirst="x",
idstepbyrow="1")
figaro.addComment("PIXEL, EACH PIXEL IS A DETECTOR")
figaro.addRectangularDetector("detector", "pixel", xstart, xstep, xpixels, ystart, ystep, ypixels)
figaro.addCuboidPixel("pixel", [-x, -y, z], [x, y, z], [-x, -y, -z], [x, -y, z], shape_id="pixel-shape")
figaro.writeGeom("./ILL/IDF/" + instrumentName.upper() + "_Definition.xml")
https://www.ill.eu/instruments-support/instruments-groups/instruments/d16/characteristics/
"""
# Instrument creation
d16 = MantidGeom(instrumentName, comment=comment, valid_from=validFrom)
d16.addSnsDefaults(default_view='3D', axis_view_3d='z-', theta_sign_axis="x")
d16.addComment("SOURCE")
d16.addComponentILL("monochromator", 0., 0., monochromator_source, "Source")
# Sample is set as the origin
d16.addComment("Sample position")
d16.addComponentILL("sample_position", 0., 0., 0., "SamplePos")
d16.addComment("MONITORS")
d16.addMonitors(names=["monitor1", "monitor2"], distance=[zMon1, zMon2])
d16.addComment("MONITOR SHAPE")
d16.addDummyMonitor(0.01, 0.01)
d16.addComment("MONITOR IDs")
d16.addMonitorIds([repr(500000), repr(500001)])
d16.addComment("DETECTOR")
d16.addComponentRectangularDetector(detector0, 0., 0., -zPosDetector, idstart=id0, idfillbyfirst=FF, idstepbyrow=SR)
d16.addRectangularDetector(detector0, pixelName, xstart, xstep, xpixels, ystart, ystep, ypixels)
d16.addComment("PIXEL, EACH PIXEL IS A DETECTOR")
d16.addCuboidPixel(pixelName, [-x, -y, thickness/2.], [-x, y, thickness/2.], [-x, -y, -thickness/2.], [x, -y, -thickness/2.], shape_id="pixel-shape")
d16.writeGeom("./ILL/IDF/" + instrumentName + "_Definition.xml")
