def testexport_multilayers1(self):
# Create options
mat1 = Material({79: 0.5, 47: 0.5}, "Mat1", absorption_energy_eV={ELECTRON: 123.0})
mat2 = Material({29: 0.5, 30: 0.5}, "Mat2", absorption_energy_eV={ELECTRON: 89.0})
mat3 = Material({13: 0.5, 14: 0.5}, "Mat3", absorption_energy_eV={ELECTRON: 89.0})
ops = Options()
ops.beam.energy_eV = 1234
ops.beam.diameter_m = 25e-9
ops.beam.origin_m = (100e-9, 0, 1)
ops.geometry = HorizontalLayers(mat1)
ops.geometry.add_layer(mat2, 25e-9)
ops.geometry.add_layer(mat3, 55e-9)
ops.limits.add(ShowersLimit(5678))
# Export to CAS
casfile = self.e.export_cas(ops)
# Test
simdata = casfile.getOptionSimulationData()
simops = simdata.getSimulationOptions()
regionops = simdata.getRegionOptions()
self.assertAlmostEqual(1.234, simops.getIncidentEnergy_keV(0), 4)
self.assertAlmostEqual(34.93392125, simops.Beam_Diameter, 4) # FWHM
self.assertAlmostEqual(100.0, simops._positionStart_nm, 4)
self.assertEqual(3, regionops.getNumberRegions())
region = regionops.getRegion(0)
elements = list(map(attrgetter("Z"), region.getElements()))
self.assertAlmostEqual(mat2.density_kg_m3 / 1000.0, region.Rho, 4)
self.assertEqual("Mat2", region.Name)
self.assertEqual(2, len(elements))
self.assertTrue(29 in elements)
self.assertTrue(30 in elements)
region = regionops.getRegion(1)
elements = list(map(attrgetter("Z"), region.getElements()))
self.assertAlmostEqual(mat3.density_kg_m3 / 1000.0, region.Rho, 4)
self.assertEqual("Mat3", region.Name)
self.assertEqual(2, len(elements))
self.assertTrue(13 in elements)
self.assertTrue(14 in elements)
region = regionops.getRegion(2)
elements = list(map(attrgetter("Z"), region.getElements()))
self.assertAlmostEqual(mat1.density_kg_m3 / 1000.0, region.Rho, 4)
self.assertEqual("Mat1", region.Name)
self.assertEqual(2, len(elements))
self.assertTrue(79 in elements)
self.assertTrue(47 in elements)
self.assertAlmostEqual(0.089, simops.Eminimum, 3)
self.assertEqual(5678, simops.getNumberElectrons())
self.assertFalse(simops.FEmissionRX)
def testexport_vertical_layers(self):
# Create
mat1 = PenelopeMaterial({79: 0.5, 47: 0.5}, "mat1")
mat2 = PenelopeMaterial({29: 0.5, 30: 0.5}, "mat2")
mat3 = PenelopeMaterial({13: 0.5, 14: 0.5}, "mat3")
ops = Options()
ops.beam.energy_eV = 1234
ops.beam.diameter_m = 25e-9
ops.beam.origin_m = (100e-9, 0, 1)
ops.geometry = VerticalLayers(mat1, mat2)
ops.geometry.add_layer(mat3, 5e-3)
ops.limits.add(TimeLimit(100))
self.c._convert_geometry(ops)
self.e.export_geometry(ops.geometry, self.tmpdir)
# Test
geofilepath = os.path.join(self.tmpdir, "verticallayers.geo")
repfilepath = os.path.join(self.tmpdir, "geometry.rep")
nmat, nbody = pengeom.init(geofilepath, repfilepath)
self.assertEqual(3, nmat)
self.assertEqual(4, nbody)
matfilepath = os.path.join(self.tmpdir, "mat1.mat")
self.assertTrue(os.path.exists(matfilepath))
matfilepath = os.path.join(self.tmpdir, "mat2.mat")
self.assertTrue(os.path.exists(matfilepath))
matfilepath = os.path.join(self.tmpdir, "mat3.mat")
self.assertTrue(os.path.exists(matfilepath))
def testexport_inclusion(self):
# Create
mat1 = PenelopeMaterial({79: 0.5, 47: 0.5}, "mat")
mat2 = PenelopeMaterial({29: 0.5, 30: 0.5}, "mat")
ops = Options()
ops.geometry = Inclusion(mat1, mat2, 0.01)
ops.limits.add(TimeLimit(100))
self.c._convert_geometry(ops)
self.e.export_geometry(ops.geometry, self.tmpdir)
# Test
geofilepath = os.path.join(self.tmpdir, "inclusion.geo")
repfilepath = os.path.join(self.tmpdir, "geometry.rep")
nmat, nbody = pengeom.init(geofilepath, repfilepath)
self.assertEqual(2, nmat)
self.assertEqual(3, nbody)
matfilepath = os.path.join(self.tmpdir, "mat1.mat")
self.assertTrue(os.path.exists(matfilepath))
matfilepath = os.path.join(self.tmpdir, "mat2.mat")
self.assertTrue(os.path.exists(matfilepath))
def testconvert1(self):
# Base options
ops = Options(name="Test")
ops.beam.energy_eV = 1234
ops.detectors['bse'] = BackscatteredElectronEnergyDetector(1000, (0, 1234))
ops.limits.add(ShowersLimit(5678))
ops.models.add(IONIZATION_CROSS_SECTION.jakoby)
# Convert
opss = self.converter.convert(ops)
# Test
self.assertEqual(1, len(opss))
self.assertAlmostEqual(1234, opss[0].beam.energy_eV, 4)
self.assertEqual(1, len(opss[0].detectors))
det = ops.detectors['bse']
self.assertAlmostEqual(0, det.limits_eV[0], 4)
self.assertAlmostEqual(1234, det.limits_eV[1], 4)
self.assertEqual(1000, det.channels)
self.assertEqual(1, len(opss[0].limits))
limit = list(ops.limits.iterclass(ShowersLimit))[0]
self.assertEqual(5678, limit.showers)
self.assertEqual(7, len(opss[0].models))
model = list(ops.models.iterclass(IONIZATION_CROSS_SECTION))[0]
self.assertEqual(IONIZATION_CROSS_SECTION.jakoby, model)
def testconvert2(self):
# Base options
ops = Options(name="Test")
ops.beam = PencilBeam(1234)
ops.detectors['bse'] = BackscatteredElectronEnergyDetector(1000, (0, 1234))
ops.detectors['photon'] = \
PhotonSpectrumDetector((radians(35), radians(45)), (0, radians(360.0)),
1000, (12.34, 56.78))
ops.limits.add(ShowersLimit(5678))
ops.limits.add(TimeLimit(60))
# Convert
opss = self.converter.convert(ops)
# Test
self.assertEqual(1, len(opss))
self.assertAlmostEqual(1234, opss[0].beam.energy_eV, 4)
self.assertEqual(1, len(opss[0].detectors))
det = ops.detectors['bse']
self.assertAlmostEqual(0, det.limits_eV[0], 4)
self.assertAlmostEqual(1234, det.limits_eV[1], 4)
self.assertEqual(1000, det.channels)
self.assertEqual(1, len(opss[0].limits))
limit = list(ops.limits.iterclass(ShowersLimit))[0]
self.assertEqual(5678, limit.showers)
self.assertEqual(7, len(opss[0].models))
def test_detector_photon_depth(self):
# Create
ops = Options(name="test1")
ops.beam.energy_eV = 20e3
ops.detectors["prz"] = PhotonDepthDetector((radians(35), radians(45)), (0, radians(360.0)), 100)
# Import
resultscontainer = self.i.import_(ops, self.testdata)
# Test
self.assertEqual(1, len(resultscontainer))
result = resultscontainer["prz"]
self.assertTrue(result.exists("Cu La1", absorption=True))
self.assertTrue(result.exists("Cu La1", absorption=False))
self.assertFalse(result.exists("Cu Ka1", absorption=True))
dist = result.get("Cu La1", absorption=False)
self.assertAlmostEqual(-5.750000e-7, dist[2, 0], 4)
self.assertAlmostEqual(4.737908e-6, dist[2, 1], 4)
self.assertAlmostEqual(1.005021e-5, dist[2, 2], 4)
dist = result.get("Cu La1", absorption=True)
self.assertAlmostEqual(-5.150000e-7, dist[8, 0], 4)
self.assertAlmostEqual(4.228566e-5, dist[8, 1], 4)
self.assertAlmostEqual(1.268544e-4, dist[8, 2], 4)
def testconvert4(self):
# Base options
ops = Options(name="Test")
ops.beam.energy = 100e3
ops.detectors['prz'] = PhiZDetector((0, 1), (2, 3), 1000)
ops.detectors['xray'] = PhotonIntensityDetector((0, 1), (2, 3))
ops.limits.add(ShowersLimit(5678))
# Convert
opss = self.converter.convert(ops)
# Test
self.assertEqual(1, len(opss))
self.assertEqual(2, len(opss[0].detectors))
self.assertEqual(7, len(opss[0].models))
# Test difference in elevation
ops.detectors['xray'] = PhotonIntensityDetector((0.5, 1), (2, 3))
opss = self.converter.convert(ops)
self.assertEqual(2, len(opss))
# Test difference in azimuth
ops.detectors['xray'] = PhotonIntensityDetector((0, 1), (2.5, 3))
opss = self.converter.convert(ops)
self.assertEqual(2, len(opss))
def test_detector_photon_intensity(self):
# Create
ops = Options(name="test1")
ops.beam.energy_eV = 20e3
ops.detectors["xray1"] = PhotonIntensityDetector((radians(35), radians(45)), (0, radians(360.0)))
ops.detectors["xray2"] = PhotonIntensityDetector((radians(-45), radians(-35)), (0, radians(360.0)))
# Import
resultscontainer = self.i.import_(ops, self.testdata)
# Test
# self.assertEqual(2, len(resultscontainer))
result = resultscontainer["xray2"]
val, unc = result.intensity("W Ma1")
self.assertAlmostEqual(6.07152e-05, val, 9)
self.assertAlmostEqual(2.23e-06, unc, 9)
val, unc = result.intensity("W Ma1", fluorescence=False)
self.assertAlmostEqual(5.437632e-05, val, 9)
self.assertAlmostEqual(2.12e-06, unc, 9)
val, unc = result.intensity("W Ma1", absorption=False)
self.assertAlmostEqual(5.521557e-4, val, 9)
self.assertAlmostEqual(4.79e-06, unc, 9)
val, unc = result.intensity("W Ma1", absorption=False, fluorescence=False)
self.assertAlmostEqual(4.883132e-4, val, 9)
self.assertAlmostEqual(4.45e-06, unc, 9)
def setUp(self):
TestCase.setUp(self)
# Results 1
self.ops1 = Options(name='test1')
self.ops1.detectors['det1'] = PhotonIntensityDetector((0, 1), (0, 1))
self.ops1.detectors['det2'] = TimeDetector()
self.ops1.detectors['det3'] = ElectronFractionDetector()
results1 = {}
results1['det1'] = PhotonIntensityResult()
results1['det2'] = TimeResult()
results1['det3'] = ElectronFractionResult()
# Results 2
ops2 = Options(name='test2')
ops2.detectors['det1'] = PhotonIntensityDetector((0, 1), (0, 1))
results2 = {}
results2['det1'] = PhotonIntensityResult()
# Base options
self.ops = Options(name='base')
# Sequence
list_results = [(self.ops1, results1), (ops2, results2)]
self.results = Results(self.ops, list_results)
def testconvert1(self):
# Base options
ops = Options(name="Test")
ops.beam = PencilBeam(1234)
ops.detectors['xrays'] = PhotonIntensityDetector((0.1, 0.2), (0.3, 0.4))
ops.limits.add(ShowersLimit(5678))
# Convert
with warnings.catch_warnings(record=True) as ws:
opss = self.converter.convert(ops)
# 6 warnings for the default models
self.assertEqual(5, len(ws))
self.assertEqual(1, len(opss))
# Test
self.assertAlmostEqual(1234, opss[0].beam.energy_eV, 4)
self.assertEqual(1, len(opss[0].detectors))
self.assertEqual(1, len(opss[0].limits))
limit = list(ops.limits.iterclass(ShowersLimit))[0]
self.assertEqual(5678, limit.showers)
self.assertEqual(5, len(opss[0].models))
def test_detector_photon_spectrum(self):
# Create
ops = Options(name="test1")
ops.beam.energy_eV = 20e3
ops.detectors["spectrum"] = PhotonSpectrumDetector(
(radians(35), radians(45)), (0, radians(360.0)), 1000, (0, 20e3)
)
# Import
resultscontainer = self.i.import_(ops, self.testdata)
# Test
self.assertEqual(1, len(resultscontainer))
result = resultscontainer["spectrum"]
total = result.get_total()
self.assertEqual(1000, len(total))
self.assertAlmostEqual(10.0, total[0, 0], 4)
self.assertAlmostEqual(19990.0, total[-1, 0], 4)
self.assertAlmostEqual(2.841637e-6, total[31, 1], 10)
self.assertAlmostEqual(8.402574e-6, total[31, 2], 10)
background = result.get_background()
self.assertEqual(1000, len(background))
self.assertAlmostEqual(10.0, background[0, 0], 4)
self.assertAlmostEqual(19990.0, background[-1, 0], 4)
self.assertAlmostEqual(0.0, background[31, 1], 10)
self.assertAlmostEqual(0.0, background[31, 2], 10)
def testexport(self):
# Create
ops = Options(name="test1")
ops.beam.energy_eV = 30e3
ops.detectors["trajectories"] = TrajectoryDetector(False)
ops.limits.add(ShowersLimit(100))
# Export
opss = self.c.convert(ops)
self.e.export(opss[0], self.tmpdir)
def test_append_photon_detectors_maxchannels(self):
ops = Options()
ops.limits.add(TimeLimit(100))
ops.detectors['spectrum'] = \
PhotonSpectrumDetector((radians(35), radians(45)), (0, radians(360.0)),
50000, (0, 1000))
opss = self.c.convert(ops)
self.e.export(opss[0], self.tmpdir)
def testinteraction_forcing(self):
ops = Options()
ops.beam.energy_eV = 30e3
intfor = InteractionForcing(ELECTRON, HARD_ELASTIC, -40)
ops.geometry.material = PenelopeMaterial.pure(29, interaction_forcings=[intfor])
ops.detectors['det1'] = TimeDetector()
ops.limits.add(TimeLimit(100))
opss = self.c.convert(ops)
self.e.export(opss[0], self.tmpdir)
def test_append_photon_detectors_maxlimit(self):
ops = Options()
ops.limits.add(TimeLimit(100))
for i in range(MAX_PHOTON_DETECTORS + 1):
ops.detectors['det%i' % i] = \
PhotonSpectrumDetector((radians(i), radians(45)), (0, radians(360.0)),
500, (0, 1000))
opss = self.c.convert(ops)
self.assertRaises(ExporterException, self.e.export, opss[0], self.tmpdir)
def testconvert7(self):
# Base options
ops = Options(name="Test")
ops.beam.energy_eV = 100e3
ops.detectors['prz'] = PhiZDetector((0, 1), (2, 3), 1000)
# Convert
opss = self.converter.convert(ops)
# No shower limit
self.assertEqual(0, len(opss))
def testconvert_no_detector(self):
# Base options
ops = Options(name="Test")
ops.detectors['det1'] = TimeDetector()
ops.limits.add(ShowersLimit(100))
# Convert
opss = self.converter.convert(ops)
# Test
self.assertEqual(0, len(opss))
def testconvert_nolimit(self):
# Base options
ops = Options(name="Test")
ops.detectors['trajectories'] = TrajectoryDetector(100)
ops.limits.add(TimeLimit(1))
# Convert
opss = self.converter.convert(ops)
# Test
self.assertEqual(0, len(opss))
def testconvert_toomany_detector(self):
# Base options
ops = Options(name="Test")
ops.detectors['trajectories'] = TrajectoryDetector(False)
ops.detectors['trajectories2'] = TrajectoryDetector(True)
ops.limits.add(ShowersLimit(100))
# Convert
opss = self.converter.convert(ops)
# Test
self.assertEqual(2, len(opss))
def setUp(self):
TestCase.setUp(self)
self.outputdir = tempfile.mkdtemp()
self.workdir = tempfile.mkdtemp()
ops = Options('test')
ops.detectors['traj'] = TrajectoryDetector(False)
ops.limits.add(ShowersLimit(1))
self.ops = Converter().convert(ops)[0]
self.worker = Worker(program)
def setUp(self):
TestCase.setUp(self)
self.outputdir = tempfile.mkdtemp()
self.workdir = tempfile.mkdtemp()
ops = Options("test")
ops.detectors["time"] = TimeDetector()
ops.limits.add(ShowersLimit(1))
self.ops = Converter().convert(ops)[0]
self.worker = Worker(program)
def test_photon_depth_detector(self):
# Create
ops = Options(name='test1')
ops.beam.energy_eV = 30e3
ops.geometry.body.material = PenelopeMaterial.pure(29)
ops.detectors['prz'] = \
PhotonDepthDetector((radians(0), radians(90)), (0, radians(360.0)),
500, [Transition(29, siegbahn='Ka1')])
ops.limits.add(TimeLimit(100))
# Export
opss = self.c.convert(ops)
self.e.export(opss[0], self.tmpdir)
def testconvert2(self):
# Base options
ops = Options("Test")
ops.beam.origin_m = (0.0, 0.0, 0.09)
det = PhotonIntensityDetector((radians(35), radians(45)),
(0, radians(360.0)))
ops.detectors['det1'] = det
# Convert
opss = self.converter.convert(ops)
self.assertEqual(0, len(opss)) # No showers limit
def testconvert3(self):
# Base options
ops = Options(name="Test")
ops.beam.energy_eV = 100e3
ops.detectors['bse'] = BackscatteredElectronEnergyDetector(1000, (0, 1234))
ops.detectors['bse2'] = BackscatteredElectronEnergyDetector(1000, (0, 1234))
ops.limits.add(ShowersLimit(5678))
# Convert
opss = self.converter.convert(ops)
# Test
self.assertEqual(2, len(opss))
def _run(self, element):
self._update_status(0.1, "Check version")
if self.is_cancelled():
return
version = self._read_version(element)
if version != VERSION:
raise ValueError("Incompatible version: %s != %s" % (version, VERSION))
self._update_status(0.13, "Reading name")
if self.is_cancelled():
return
name = self._read_name(element)
options = Options(name)
self._update_status(0.16, "Reading UUID")
if self.is_cancelled():
return
options._uuid = self._read_uuid(element)
self._update_status(0.2, "Reading programs")
if self.is_cancelled():
return
options.programs.update(self._read_programs(element))
self._update_status(0.3, "Reading beams")
if self.is_cancelled():
return
options.beam = self._read_beams(element)
self._update_status(0.4, "Reading geometries")
if self.is_cancelled():
return
options.geometry = self._read_geometries(element)
self._update_status(0.6, "Reading detectors")
if self.is_cancelled():
return
options.detectors.update(self._read_detectors(element))
self._update_status(0.8, "Reading limits")
if self.is_cancelled():
return
options.limits.update(self._read_limits(element))
self._update_status(0.9, "Reading models")
if self.is_cancelled():
return
options.models.update(self._read_models(element))
return options
def testexport_different_opening(self):
# Create options
mat = Material({79: 0.5, 47: 0.5}, "Mat1", absorption_energy_eV={ELECTRON: 123.0})
ops = Options()
ops.beam.energy_eV = 1234
ops.beam.diameter_m = 25e-9
ops.geometry.body.material = mat
ops.limits.add(ShowersLimit(5678))
ops.detectors["xrays"] = PhotonIntensityDetector((radians(30), radians(40)), (0, radians(360.0)))
ops.detectors["prz"] = PhiZDetector((radians(30), radians(50)), (0, radians(360.0)), 750)
# Test
self.assertRaises(ExporterException, self.e.export_wxroptions, ops)
def setUp(self):
TestCase.setUp(self)
self.outputdir = tempfile.mkdtemp()
self.workdir = tempfile.mkdtemp()
ops = Options('test')
ops.beam.energy_keV = 10
ops.geometry.body.material = Material.pure(29)
ops.detectors['fraction'] = ElectronFractionDetector()
ops.limits.add(ShowersLimit(1))
self.ops = Converter().convert(ops)[0]
self.worker = Worker(program)
def setUp(self):
TestCase.setUp(self)
self.outputdir = tempfile.mkdtemp()
self.workdir = tempfile.mkdtemp()
ops = Options('test')
ops.beam.origin_m = (0.0, 0.0, 0.001)
ops.geometry.body.material = \
Material({79: 1.0}, absorption_energy_eV={ELECTRON: 56.0})
ops.detectors['time'] = TimeDetector()
ops.limits.add(ShowersLimit(1))
self.ops = Converter().convert(ops)[0]
self.worker = Worker(program)
def test_detector_transmitted_electron_energy(self):
# Create
ops = Options(name="test1")
ops.beam.energy_eV = 20e3
ops.detectors["transmitted"] = TransmittedElectronEnergyDetector(100, (0.0, 20e3))
# Import
resultscontainer = self.i.import_(ops, self.testdata)
# Test
self.assertEqual(1, len(resultscontainer))
result = resultscontainer["transmitted"]
self.assertEqual(1000, len(result))
def test_detector_showers_statistics(self):
# Create
ops = Options(name="test1")
ops.beam.energy_eV = 20e3
ops.detectors["showers"] = ShowersStatisticsDetector()
# Import
resultscontainer = self.i.import_(ops, self.testdata)
# Test
self.assertEqual(1, len(resultscontainer))
result = resultscontainer["showers"]
self.assertEqual(76938, result.showers)
def test_detector_backscattered_electron_energy(self):
# Create
ops = Options(name='test1')
ops.beam.energy_eV = 20e3
ops.detectors['bse'] = \
BackscatteredElectronEnergyDetector(100, (0.0, 20e3))
# Import
resultscontainer = self.i.import_(ops, self.testdata)
# Test
self.assertEqual(1, len(resultscontainer))
result = resultscontainer['bse']
self.assertEqual(1000, len(result))
def setUp(self):
TestCase.setUp(self)
self.outputdir = tempfile.mkdtemp()
self.workdir = tempfile.mkdtemp()
ops = Options('test')
ops.beam = PencilBeam(5e3)
ops.geometry.body.material = \
Material({6: 0.4, 13: 0.6}, absorption_energy_eV={ELECTRON: 234.0})
ops.detectors['xray'] = \
PhotonIntensityDetector.annular(d2r(40.0), d2r(5.0))
ops.limits.add(ShowersLimit(1))
self.ops = Converter().convert(ops)[0]
self.worker = Worker(program)
def test_detector_time(self):
# Create
ops = Options(name='test1')
ops.beam.energy_eV = 20e3
ops.detectors['time'] = TimeDetector()
# Import
resultscontainer = self.i.import_(ops, self.testdata)
# Test
self.assertEqual(1, len(resultscontainer))
result = resultscontainer['time']
self.assertAlmostEqual(8.993401e1, result.simulation_time_s, 4)
self.assertAlmostEqual(1.0 / 8.554940e2, result.simulation_speed_s[0], 4)
def options():
program = Casino2Program(number_trajectories=50)
beam = GaussianBeam(15e3, 10e-9)
sample = SubstrateSample(Material.pure(29))
detector = PhotonDetector("xray", math.radians(40.0))
analyses = [PhotonIntensityAnalysis(detector)]
tags = ["basic", "test"]
return Options(program, beam, sample, analyses, tags)
def testconvert_pencilbeam(self):
# Base options
ops = Options(name="Test")
ops.beam = PencilBeam(1234)
ops.limits.add(ShowersLimit(100))
ops.detectors['trajectories'] = TrajectoryDetector(False)
# Convert
opss = self.converter.convert(ops)
# Test
self.assertEqual(1, len(opss))
self.assertAlmostEqual(1234, opss[0].beam.energy_eV, 4)
self.assertAlmostEqual(0.0, opss[0].beam.diameter_m, 4)
self.assertEqual(5, len(opss[0].models))
def _load(filepaths, list_options=None):
for filepath in filepaths:
if os.path.isdir(filepath):
_load(glob.glob(os.path.join(filepath, '*.xml')), list_options)
list_options.sort()
return
list_options.append(Options.read(filepath))
def testconvert4(self):
# Base options
ops = Options(name="Test")
ops.beam.energy = 100e3
ops.detectors['prz'] = PhiZDetector((0, 1), (2, 3), 1000)
ops.detectors['xray'] = PhotonIntensityDetector((0, 1), (2, 3))
ops.limits.add(ShowersLimit(5678))
# Convert
opss = self.converter.convert(ops)
# Test
self.assertEqual(1, len(opss))
self.assertEqual(2, len(opss[0].detectors))
self.assertEqual(7, len(opss[0].models))
# Test difference in elevation
ops.detectors['xray'] = PhotonIntensityDetector((0.5, 1), (2, 3))
opss = self.converter.convert(ops)
self.assertEqual(2, len(opss))
# Test difference in azimuth
ops.detectors['xray'] = PhotonIntensityDetector((0, 1), (2.5, 3))
opss = self.converter.convert(ops)
self.assertEqual(2, len(opss))
# Test difference in elevation (PhotonSpectrumDetector)
ops.detectors['xray'] = PhotonSpectrumDetector((0.5, 1), (2, 3), 1000,
(0, 1234))
opss = self.converter.convert(ops)
self.assertEqual(2, len(opss))
def testconvert_nolimit(self):
# Base options
ops = Options(name="Test")
# Convert
opss = self.converter.convert(ops)
# Test
self.assertEqual(0, len(opss))
def options():
program = PenepmaProgram(number_trajectories=100)
program.exporter.dump_interval_s = 2
beam = CylindricalBeam(15e3, 10e-9)
sample = SubstrateSample(Material.pure(29))
detector = PhotonDetector("xray", math.radians(40.0))
analyses = [PhotonIntensityAnalysis(detector)]
tags = ["basic", "test"]
return Options(program, beam, sample, analyses, tags)
def testexport(self):
# Create
ops = Options(name='test1')
ops.beam.energy_eV = 30e3
ops.geometry.body.material = PenelopeMaterial.pure(29)
ops.detectors['x-ray'] = \
PhotonIntensityDetector((radians(35), radians(45)), (0, radians(360.0)))
ops.detectors['spectrum'] = \
PhotonSpectrumDetector((radians(35), radians(45)), (0, radians(360.0)), 500, (0, 1000))
ops.detectors['prz'] = \
PhotonDepthDetector((radians(0), radians(90)), (0, radians(360.0)), 500)
ops.limits.add(TimeLimit(100))
ops.limits.add(
UncertaintyLimit(Transition(29, siegbahn='Ka1'), 'x-ray', 0.05))
# Export
opss = self.c.convert(ops)
self.e.export(opss[0], self.tmpdir)
def create_basic_options(self):
beam = self.create_basic_beam()
sample = self.create_basic_sample()
analyses = [
PhotonIntensityAnalysis(self.create_basic_photondetector())
]
limits = [ShowersLimit(100)]
models = [ElasticCrossSectionModel.RUTHERFORD]
return Options(self.program, beam, sample, analyses, limits, models)
def options():
"""
Creates basic options using the mock program.
"""
program = ProgramMock()
beam = GaussianBeam(15e3, 10e-9)
sample = SubstrateSample(Material.pure(29))
detector = PhotonDetector("xray", math.radians(40.0))
analyses = [PhotonIntensityAnalysis(detector)]
tags = ["basic", "test"]
return Options(program, beam, sample, analyses, tags)
def test_convert_geometry_substrate(self):
# Base options
ops = Options(name="Test")
mat = Material.pure(29, absorption_energy_eV={POSITRON: 63.4})
ops.geometry = Substrate(mat)
ops.limits.add(TimeLimit(100))
# Convert
self.converter._convert_geometry(ops)
# Test
self.assertEqual('Copper', str(ops.geometry.body.material))
for material in ops.geometry.get_materials():
self.assertAlmostEqual(0.1, material.elastic_scattering[0], 4)
self.assertAlmostEqual(0.2, material.elastic_scattering[1], 4)
self.assertAlmostEqual(51.2, material.cutoff_energy_inelastic_eV, 4)
self.assertAlmostEqual(53.4, material.cutoff_energy_bremsstrahlung_eV, 4)
self.assertAlmostEqual(63.4, material.absorption_energy_eV[POSITRON], 4)
self.assertAlmostEqual(1e20, material.maximum_step_length_m, 4)
def testexport_different_opening(self):
# Create options
mat = Material({
79: 0.5,
47: 0.5
},
'Mat1',
absorption_energy_eV={ELECTRON: 123.0})
ops = Options()
ops.beam.energy_eV = 1234
ops.beam.diameter_m = 25e-9
ops.geometry.body.material = mat
ops.limits.add(ShowersLimit(5678))
ops.detectors['xrays'] = \
PhotonIntensityDetector((radians(30), radians(40)), (0, radians(360.0)))
ops.detectors['prz'] = \
PhiZDetector((radians(30), radians(50)), (0, radians(360.0)), 750)
# Test
self.assertRaises(ExporterException, self.e.export_wxroptions, ops)
def test_detector_trajectory(self):
# Create
ops = Options(name='test1')
ops.beam.energy_eV = 20e3
ops.detectors['trajectories'] = TrajectoryDetector(50)
# Import
resultcontainer = self.i.import_(ops, self.testdata)
# Test
result = resultcontainer['trajectories']
self.assertEqual(559, len(result))
trajectory = list(result)[0]
self.assertTrue(trajectory.is_primary())
self.assertFalse(trajectory.is_secondary())
self.assertIs(ELECTRON, trajectory.particle)
self.assertIs(NO_COLLISION, trajectory.collision)
self.assertEqual(EXIT_STATE_ABSORBED, trajectory.exit_state)
self.assertEqual(577, len(trajectory.interactions))
self.assertEqual(5, trajectory.interactions.shape[1])
def test_detector_electron_fraction(self):
# Create
ops = Options(name='test1')
ops.beam.energy_eV = 20e3
ops.detectors['electron-fraction'] = ElectronFractionDetector()
# Import
filepath = os.path.join(self.testdata, 'gold_15kev.cas')
results = self.i.import_cas(ops, filepath)
# Test
result = results['electron-fraction']
self.assertAlmostEqual(0.46, result.absorbed[0], 4)
self.assertAlmostEqual(0.0, result.absorbed[1], 4)
self.assertAlmostEqual(0.54, result.backscattered[0], 4)
self.assertAlmostEqual(0.0, result.backscattered[1], 4)
self.assertAlmostEqual(0.0, result.transmitted[0], 4)
self.assertAlmostEqual(0.0, result.transmitted[1], 4)
def setUp(self):
unittest.TestCase.setUp(self)
self.tmpdir = tempfile.mkdtemp()
self.e = Exporter()
self.ops = Options('aatest')
self.ops.beam.energy_eV = 4e3
self.ops.geometry.body.material = \
Material({6: 0.4, 13: 0.6}, absorption_energy_eV={ELECTRON: 234.0})
self.ops.limits.add(ShowersLimit(1234))
def testexport_substrate(self):
# Create
mat1 = PenelopeMaterial({79: 0.5, 47: 0.5}, 'mat')
ops = Options()
ops.geometry = Substrate(mat1)
ops.limits.add(TimeLimit(100))
self.c._convert_geometry(ops)
self.e.export_geometry(ops.geometry, self.tmpdir)
# Test
geofilepath = os.path.join(self.tmpdir, 'substrate.geo')
repfilepath = os.path.join(self.tmpdir, 'geometry.rep')
nmat, nbody = pengeom.init(geofilepath, repfilepath)
self.assertEqual(1, nmat)
self.assertEqual(2, nbody)
matfilepath = os.path.join(self.tmpdir, 'mat1.mat')
self.assertTrue(os.path.exists(matfilepath))
def testconvert_pencilbeam(self):
# Base options
ops = Options(name="Test")
ops.beam = PencilBeam(1234)
ops.limits.add(ShowersLimit(100))
ops.detectors['trajectories'] = TrajectoryDetector(False)
# Convert
with warnings.catch_warnings(record=True) as ws:
opss = self.converter.convert(ops)
# 7 warning:
# PencilBeam -> GaussianBeam
# Set default models (6)
self.assertEqual(1, len(opss))
self.assertEqual(7, len(ws))
# Test
self.assertAlmostEqual(1234, opss[0].beam.energy_eV, 4)
self.assertAlmostEqual(0.0, opss[0].beam.diameter_m, 4)
self.assertEqual(6, len(opss[0].models))
def testconvert1(self):
# Base options
ops = Options("Test")
ops.beam.origin_m = (0.0, 0.0, 0.09)
ops.limits.add(ShowersLimit(1234))
det = PhotonIntensityDetector((radians(35), radians(45)),
(0, radians(360.0)))
ops.detectors['det1'] = det
# Convert
opss = self.converter.convert(ops)
self.assertEqual(1, len(opss))
self.assertEqual(1, len(opss[0].detectors))
self.assertEqual(1, len(opss[0].limits))
limit = list(ops.limits.iterclass(ShowersLimit))[0]
self.assertEqual(1234, limit.showers)
self.assertEqual(6, len(opss[0].models))
def test_detector_trajectory(self):
# Create
ops = Options(name='test1')
ops.beam.energy_eV = 20e3
ops.detectors['trajectories'] = TrajectoryDetector(50)
# Import
filepath = os.path.join(self.testdata, 'gold_15kev.cas')
results = self.i.import_cas(ops, filepath)
# Test
result = results['trajectories']
self.assertEqual(14689, len(result))
trajectory = list(result)[0]
self.assertTrue(trajectory.is_primary())
self.assertFalse(trajectory.is_secondary())
self.assertIs(ELECTRON, trajectory.particle)
self.assertIs(NO_COLLISION, trajectory.collision)
self.assertEqual(EXIT_STATE_ABSORBED, trajectory.exit_state)
self.assertEqual(851, len(trajectory.interactions))
self.assertEqual(5, trajectory.interactions.shape[1])
def test_detector_electron_fraction(self):
# Create
ops = Options(name='test1')
ops.beam.energy_eV = 20e3
ops.detectors['fraction'] = ElectronFractionDetector()
# Import
resultscontainer = self.i.import_(ops, self.testdata)
# Test
self.assertEqual(1, len(resultscontainer))
result = resultscontainer['fraction']
self.assertAlmostEqual(0.5168187, result.backscattered[0], 4)
self.assertAlmostEqual(7.5e-3, result.backscattered[1], 6)
self.assertAlmostEqual(0.0, result.transmitted[0], 4)
self.assertAlmostEqual(0.0, result.transmitted[1], 4)
self.assertAlmostEqual(0.5113858, result.absorbed[0], 4)
self.assertAlmostEqual(5.4e-3, result.absorbed[1], 6)
def setUp(self):
unittest.TestCase.setUp(self)
self.ops = Options('aatest')
self.ops.beam.energy_eV = 4e3
self.ops.geometry.material = \
Material({6: 0.4, 13: 0.6}, absorption_energy_eV={ELECTRON: 234.0})
self.ops.detectors['xray'] = PhotonIntensityDetector((0, 1), (2, 3))
self.ops.detectors['prz'] = PhiZDetector((0, 1), (2, 3), 128)
self.ops.limits.add(ShowersLimit(1234))
self.i = Importer()
self._testdata = os.path.join(os.path.dirname(__file__), 'testdata')
def testcalculate(self):
# Create options
beam = GaussianBeam(20e3, 10.e-9)
sample = SubstrateSample(Material.from_formula('CaSiO4'))
limit = ShowersLimit(100)
unkoptions = Options(self.program, beam, sample, [self.a], [limit])
list_standard_options = self.a.apply(unkoptions)
self.assertEqual(3, len(list_standard_options))
# Create simulations
def create_simulation(options):
builder = EmittedPhotonIntensityResultBuilder(self.a)
for z, wf in options.sample.material.composition.items():
builder.add_intensity((z, 'Ka'), wf * 1e3, math.sqrt(wf * 1e3))
result = builder.build()
return Simulation(options, [result])
unksim = create_simulation(unkoptions)
stdsims = [
create_simulation(options) for options in list_standard_options
]
sims = stdsims + [unksim]
# Calculate
newresult = self.a.calculate(unksim, sims)
self.assertTrue(newresult)
newresult = self.a.calculate(unksim, sims)
self.assertFalse(newresult)
# Test
results = unksim.find_result(KRatioResult)
self.assertEqual(1, len(results))
result = results[0]
self.assertEqual(3, len(result))
q = result[('Ca', 'Ka')]
self.assertAlmostEqual(0.303262, q.n, 4)
self.assertAlmostEqual(0.019880, q.s, 4)
q = result[('Si', 'Ka')]
self.assertAlmostEqual(0.212506, q.n, 4)
self.assertAlmostEqual(0.016052, q.s, 4)
q = result[('O', 'Ka')]
self.assertAlmostEqual(0.484232 / 0.470749, q.n, 4)
self.assertAlmostEqual(0.066579, q.s, 4)
def _validate_options(self, options, errors):
program = \
self._validate_program(options.program, options, errors)
beam = \
self._validate_beam(options.beam, options, errors)
sample = \
self._validate_sample(options.sample, options, errors)
analyses = \
self._validate_analyses(options.analyses, options, errors)
limits = \
self._validate_limits(options.limits, options, errors)
models = \
self._validate_models(options.models, options, errors)
return Options(program, beam, sample, analyses, limits, models)
def testexport_horizontal_layers(self):
# Create
mat1 = PenelopeMaterial({79: 0.5, 47: 0.5}, 'mat1')
mat2 = PenelopeMaterial({29: 0.5, 30: 0.5}, 'mat2')
mat3 = PenelopeMaterial({13: 0.5, 14: 0.5}, 'mat3')
ops = Options()
ops.beam.energy_eV = 1234
ops.beam.diameter_m = 25e-9
ops.beam.origin_m = (100e-9, 0, 1)
ops.geometry = HorizontalLayers(mat1)
ops.geometry.add_layer(mat2, 52e-9)
ops.geometry.add_layer(mat3, 25e-9)
ops.limits.add(TimeLimit(100))
self.c._convert_geometry(ops)
self.e.export_geometry(ops.geometry, self.tmpdir)
# Test
geofilepath = os.path.join(self.tmpdir, 'horizontallayers.geo')
repfilepath = os.path.join(self.tmpdir, 'geometry.rep')
nmat, nbody = pengeom.init(geofilepath, repfilepath)
self.assertEqual(3, nmat)
self.assertEqual(6, nbody)
matfilepath = os.path.join(self.tmpdir, 'mat1.mat')
self.assertTrue(os.path.exists(matfilepath))
matfilepath = os.path.join(self.tmpdir, 'mat2.mat')
self.assertTrue(os.path.exists(matfilepath))
matfilepath = os.path.join(self.tmpdir, 'mat3.mat')
self.assertTrue(os.path.exists(matfilepath))
def setUp(self):
TestCase.setUp(self)
self.ops = Options()
self.ops.detectors['xray'] = PhotonIntensityDetector((0, 1), (2, 3))
self.ops.detectors['fraction'] = ElectronFractionDetector()
self.ops.detectors['time'] = TimeDetector()
self.ops.detectors['showers'] = ShowersStatisticsDetector()
self.ops.detectors['prz'] = PhiZDetector((0, 1), (2, 3), 100)
self.ops.detectors['spectrum'] = \
PhotonSpectrumDetector((0, 1), (2, 3), 500, (0, 1000))
self.ops.limits.add(ShowersLimit(1000))
dirpath = os.path.join(os.path.dirname(__file__),
'testdata', 'al_10keV_1ke_001')
self.results = Importer().import_(self.ops, dirpath)
def testexport_substrate(self):
# Create options
mat = Material({
79: 0.5,
47: 0.5
},
'Mat1',
absorption_energy_eV={ELECTRON: 123.0})
ops = Options()
ops.beam.energy_eV = 1234
ops.beam.diameter_m = 25e-9
ops.beam.origin_m = (100e-9, 0, 1)
ops.geometry.body.material = mat
ops.limits.add(ShowersLimit(5678))
ops.detectors['bse'] = BackscatteredElectronEnergyDetector(
123, (0, 567))
ops.detectors['bse polar'] = BackscatteredElectronPolarAngularDetector(
125)
ops.detectors['xrays'] = \
PhotonIntensityDetector((radians(30), radians(40)), (0, radians(360.0)))
ops.detectors['prz'] = \
PhiZDetector((radians(30), radians(40)), (0, radians(360.0)), 750)
# Export to WinX-Ray options
wxrops = self.e.export_wxroptions(ops)
# Test
self.assertAlmostEqual(1.234, wxrops.getIncidentEnergy_keV(), 4)
self.assertAlmostEqual(25.0, wxrops.getBeamDiameter_nm(), 4)
self.assertEqual(5678, wxrops.getNbElectron())
zs, _wfs = wxrops.getElements()
self.assertTrue(79 in zs)
self.assertTrue(47 in zs)
self.assertAlmostEqual(13.6007, wxrops.getMeanDensity_g_cm3(),
4) # internally calculated by WinXray
self.assertAlmostEqual(123, wxrops.getMinimumElectronEnergy_eV(), 4)
self.assertTrue(wxrops.isComputeBSEDistribution())
self.assertTrue(wxrops.isComputeBSEEnergy())
self.assertEqual(123, wxrops.getNbBSEEnergy())
self.assertTrue(wxrops.isComputeBSEAngular())
self.assertEqual(125, wxrops.getNbBSEAngular())
self.assertTrue(wxrops.isXrayCompute())
self.assertTrue(wxrops.isXrayComputeCharacteristic())
self.assertAlmostEqual(35.0, wxrops.getTOA_deg(), 4)
self.assertAlmostEqual(55, wxrops.getAngleThetaDetector_deg(), 4)
self.assertAlmostEqual(180.0, wxrops.getAnglePhiDetector_deg(), 4)
self.assertEqual(750, wxrops.getNumberFilm())
def testexport_models(self):
# Create options
mat = Material({
79: 0.5,
47: 0.5
},
'Mat1',
absorption_energy_eV={ELECTRON: 123.0})
ops = Options()
ops.beam.energy_eV = 1234
ops.beam.diameter_m = 25e-9
ops.geometry.body.material = mat
ops.limits.add(ShowersLimit(5678))
ops.models.add(ELASTIC_CROSS_SECTION.rutherford)
ops.models.add(IONIZATION_CROSS_SECTION.casnati1982)
ops.models.add(IONIZATION_POTENTIAL.joy_luo1989)
ops.models.add(RANDOM_NUMBER_GENERATOR.press1966_rand3)
ops.models.add(DIRECTION_COSINE.demers2000)
ops.models.add(MASS_ABSORPTION_COEFFICIENT.thinh_leroux1979)
# Export to WinX-Ray options
wxrops = self.e.export_wxroptions(ops)
# Test
self.assertEqual(ElectronElasticCrossSection.TYPE_RUTHERFORD,
wxrops.getTypePartialCrossSection())
self.assertEqual(ElectronElasticCrossSection.TYPE_RUTHERFORD,
wxrops.getTypeTotalCrossSection())
self.assertEqual(IonizationCrossSection.TYPE_CASNATI,
wxrops.getTypeXrayCrossSectionBremsstrahlung())
self.assertEqual(IonizationCrossSection.TYPE_CASNATI,
wxrops.getTypeXrayCrossSectionCharacteristic())
self.assertEqual(IonizationPotential.TYPE_JOY_LUO,
wxrops.getTypeIonisationPotential())
self.assertEqual(DirectionCosine.TYPE_DEMERS,
wxrops.getTypeDirectionCosines())
self.assertEqual(EnergyLoss.TYPE_JOY_LUO, wxrops.getTypeEnergyLoss())
self.assertEqual(RandomNumberGenerator.TYPE_RAN3,
wxrops.getTypeRandomGenerator())
self.assertEqual(MassAbsorptionCoefficient.TYPE_THINH_LEROUX,
wxrops.getTypeMac())
fp.write(b'\x00\x00\x00\x00')
# DELPHI: Inc(s,l);Blockwrite(Matfile,rho[0],l,f);Inc(Sum,f);
fp.write(struct.pack('f', density_g_cm3))
# DELPHI:
# l:=NC+1;
# for i:=0 to NP do begin
# Inc(s,l);BlockWrite(Matfile,PC[i],l,f);Inc(Sum,f);
# end;
fp.write(struct.pack('b', len(composition)))
fp.write(b'\x00' * len(composition))
# DELPHI: Inc(s,l);BlockWrite(Matfile,PM,l,f);Inc(Sum,f);
fp.write(struct.pack('b', len(composition)))
for i in range(len(composition)):
fp.write(struct.pack('b', i + 1))
return filepath
if __name__ == '__main__':
from pymontecarlo.options.options import Options
from pymontecarlo.options.material import Material
options = Options('test')
options.geometry.body.material = Material({6: 0.4, 13: 0.1, 79: 0.5})
options.limits.add(ShowersLimit(1000))
Exporter().export(options, '/tmp')
