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')