def simulation():
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"]
options = Options(program, beam, sample, analyses, tags)
results = []
analysis = PhotonIntensityAnalysis(detector)
builder = EmittedPhotonIntensityResultBuilder(analysis)
builder.add_intensity((29, "Ka1"), 1.0, 0.1)
builder.add_intensity((29, "Ka2"), 2.0, 0.2)
builder.add_intensity((29, "Kb1"), 4.0, 0.5)
builder.add_intensity((29, "Kb3"), 5.0, 0.7)
builder.add_intensity((29, "Kb5I"), 1.0, 0.1)
builder.add_intensity((29, "Kb5II"), 0.5, 0.1)
builder.add_intensity((29, "Ll"), 3.0, 0.1)
results.append(builder.build())
analysis = KRatioAnalysis(detector)
builder = KRatioResultBuilder(analysis)
builder.add_kratio((29, "Ka1"), 1.0, 1.0)
builder.add_kratio((29, "Ka2"), 2.0, 1.0)
builder.add_kratio((29, "Kb1"), 0.5, 1.0)
builder.add_kratio((29, "Kb3"), 1.5, 1.0)
builder.add_kratio((29, "Kb5I"), 1.0, 1.0)
builder.add_kratio((29, "Kb5II"), 0.5, 1.0)
builder.add_kratio((29, "Ll"), 2.0, 1.0)
results.append(builder.build())
return Simulation(options, results)
def create_homogeneous_sample(data, density_start = None, density_end = None):
'''
Function to create a list of substrate samples for Xray signal reference
input: dataframe of atomic fractions at various positions
output: list[Substrate]
'''
elements_data = get_elements_data(data)
colors = generate_colors(steps = len(data) - 1)
densities = generate_densities(elements_data, density_start, density_end)
# 1. Creating materials at both ends
material_start, material_end = generate_end_materials(elements_data, colors, density_start, density_end)
materials = [material_start, material_end]
# 2. Iterate through all regions, create the material representations
for i in range(1, len(data) - 1):
density = densities[i]
color = colors[i]
material = Material(
name = f'region_{i}',
composition = to_weight_fraction(dict(elements_data.iloc[i])),
density_kg_per_m3 = density,
color = color)
materials.append(material)
# 3. Creating substrate sample from the materials
substrate_list = [SubstrateSample(mat) for mat in materials]
return substrate_list
def estimated_builder(builder):
program_mock_added = False
if not builder.programs:
builder.add_program(ProgramMock())
program_mock_added = True
beam_mock_added = False
if not builder.beams:
builder.add_beam(PencilBeam(10e3))
beam_mock_added = True
sample_mock_added = False
if not builder.samples:
builder.add_sample(SubstrateSample(Material.pure(26)))
sample_mock_added = True
try:
yield builder
finally:
if program_mock_added:
builder.programs.clear()
if beam_mock_added:
builder.beams.clear()
if sample_mock_added:
builder.samples.clear()
def _create_standard_options(self, options):
builder = OptionsBuilder()
builder.add_program(options.program)
beam = GaussianBeam(energy_eV=options.beam.energy_eV,
diameter_m=0.0,
particle=options.beam.particle)
builder.add_beam(beam)
for material in options.sample.materials:
for z in material.composition:
standard = self.get_standard_material(z)
builder.add_sample(SubstrateSample(standard))
for limit in options.limits:
builder.add_limit(options.program, limit)
for model in options.models:
builder.add_model(options.program, model)
analysis = PhotonIntensityAnalysis(self.photon_detector)
builder.add_analysis(analysis)
return builder.build()
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 test_validate_sample_substrate_invalid(exporter, options):
sample = SubstrateSample(VACUUM, float("inf"), float("nan"))
erracc = ErrorAccumulator()
exporter._validate_sample_substrate(sample, options, erracc)
assert len(erracc.exceptions) == 3
assert len(erracc.warnings) == 0
def testvalidate_sample_substrate_exception(self):
sample = SubstrateSample(VACUUM, float('inf'), float('nan'))
self.assertRaises(ValidationError, self.v.validate_sample, sample,
self.options)
errors = set()
self.v._validate_sample(sample, self.options, errors)
self.assertEqual(3, len(errors))
def _validate_sample_substrate(self, sample, options, errors):
material = \
self._validate_sample_substrate_material(sample.material, options, errors)
tilt_rad = \
self._validate_sample_base_tilt_rad(sample.tilt_rad, options, errors)
azimuth_rad = \
self._validate_sample_base_azimuth_rad(sample.azimuth_rad, options, errors)
return SubstrateSample(material, tilt_rad, azimuth_rad)
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 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 _create_samples():
yield SubstrateSample(Material.pure(39))
for number_layers in range(1, 10 + 1):
sample = HorizontalLayerSample(Material.pure(39))
for i in range(number_layers):
sample.add_layer(Material.pure(40 + i), 20e-9)
yield sample
for number_layers in range(0, 9 + 1):
sample = VerticalLayerSample(Material.pure(39), Material.pure(40))
for i in range(number_layers):
sample.add_layer(Material.pure(40 + i), 20e-9)
yield sample
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 _create_samples(number_layers=2):
yield SubstrateSample(Material.pure(39))
yield InclusionSample(Material.pure(39), Material.pure(40), 20e-9)
sample = HorizontalLayerSample(Material.pure(39))
for i in range(number_layers):
sample.add_layer(Material.pure(50 + i), 20e-9)
yield sample
sample = VerticalLayerSample(Material.pure(39), Material.pure(40))
for i in range(number_layers):
sample.add_layer(Material.pure(40 + i), 20e-9)
yield sample
yield SphereSample(Material.pure(39), 20e-9)
def _create_standard_options(self, options):
builder = OptionsBuilder(tags=[TAG_STANDARD])
program = copy.copy(options.program)
builder.add_program(program)
beam = PencilBeam(energy_eV=options.beam.energy_eV,
particle=options.beam.particle)
builder.add_beam(beam)
for material in options.sample.materials:
for z in material.composition:
standard = self.get_standard_material(z)
builder.add_sample(SubstrateSample(standard))
analysis = PhotonIntensityAnalysis(self.photon_detector)
builder.add_analysis(analysis)
return builder.build()
Layer(MATERIAL_DS, 0.1),
Layer(MATERIAL_RG, 0.15),
Layer(MATERIAL_AU, 0.2),
Layer(MATERIAL_DS, 0.05),
]
def test_samplefigure_draw_nothing(samplefigure, ax):
samplefigure.draw(ax)
assert len(ax.collections) == 0
@pytest.mark.parametrize(
"sample,perspective,expected_path_count",
[
(SubstrateSample(MATERIAL_DS), Perspective.XY, 1),
(SubstrateSample(MATERIAL_DS), Perspective.XZ, 1),
(SubstrateSample(MATERIAL_DS), Perspective.YZ, 1),
(InclusionSample(MATERIAL_DS, MATERIAL_RG, 0.5), Perspective.XY, 2),
(InclusionSample(MATERIAL_DS, MATERIAL_RG, 0.5), Perspective.XZ, 2),
(InclusionSample(MATERIAL_DS, MATERIAL_RG, 0.5), Perspective.YZ, 2),
(HorizontalLayerSample(MATERIAL_DS, LAYERS), Perspective.XY, 1),
(HorizontalLayerSample(MATERIAL_DS, LAYERS), Perspective.XZ, 5),
(HorizontalLayerSample(MATERIAL_DS, LAYERS), Perspective.YZ, 5),
(VerticalLayerSample(MATERIAL_DS, MATERIAL_AU,
LAYERS), Perspective.XY, 6),
(VerticalLayerSample(MATERIAL_DS, MATERIAL_AU,
LAYERS), Perspective.XZ, 6),
(VerticalLayerSample(MATERIAL_DS, MATERIAL_AU,
LAYERS), Perspective.YZ, 1),
(SphereSample(MATERIAL_DS, 0.5), Perspective.XY, 1),
def create_basic_sample(self):
return SubstrateSample(Material.pure(29))
def plot(self):
tilt_rad = math.radians(self._slider_tilt_deg.value())
rotation_rad = math.radians(self._slider_rotation_deg.value())
layer = [
Layer(RE, 10e-9),
Layer(OS, 15e-9),
Layer(IR, 20e-9),
Layer(PT, 5e-9)
]
sample_cls = self._combo_sample.currentData()
if sample_cls == SubstrateSample:
sample = SubstrateSample(DS,
tilt_rad=tilt_rad,
rotation_rad=rotation_rad)
elif sample_cls == InclusionSample:
sample = InclusionSample(DS,
AU,
0.5e-6,
tilt_rad=tilt_rad,
rotation_rad=rotation_rad)
elif sample_cls == HorizontalLayerSample:
sample = HorizontalLayerSample(DS,
layer,
tilt_rad=tilt_rad,
rotation_rad=rotation_rad)
elif sample_cls == VerticalLayerSample:
sample = VerticalLayerSample(DS,
RG,
layer,
tilt_rad=tilt_rad,
rotation_rad=rotation_rad)
elif sample_cls == SphereSample:
sample = SphereSample(AU,
0.5e-6,
tilt_rad=tilt_rad,
rotation_rad=rotation_rad)
else:
sample = None
beam_cls = self._combo_beam.currentData()
if beam_cls == GaussianBeam:
beams = [GaussianBeam(42.0, 5e-9)]
else:
beams = []
# trajectory_cls = self._combo_trajectory.currentData()
# TODO handle trajectories
trajectories = []
sf = SampleFigure(sample, beams, trajectories)
if self.radio_yz.isChecked():
sf.perspective = Perspective.YZ
elif self.radio_xy.isChecked():
sf.perspective = Perspective.XY
else:
sf.perspective = Perspective.XZ
self._figure.clf()
ax = self._figure.add_subplot(111)
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)
sf.draw(ax)
scalebar = ScaleBar(1.0, location="lower left")
ax.add_artist(scalebar)
self._canvas.draw_idle()
def test_compose_sample_substrate(self):
sample = SubstrateSample(self.mat_ds)
self._compose_sample(sample, (1, 1, 1))
def test_draw_sample(self):
sample = SubstrateSample(self.mat_ds)
sf = SampleFigure(sample)
sf._draw_sample(self.ax, sample, Perspective.XZ, 2.0)
self.assertEqual(len(self.ax.collections), 1)
def testsubstrate(self):
sample = SubstrateSample(Material.pure(39))
self._run_and_test(sample)
def testvalidate_sample_substrate(self):
sample = SubstrateSample(COPPER)
sample2 = self.v.validate_sample(sample, self.options)
self.assertEqual(sample2, sample)
self.assertIsNot(sample2, sample)
from pymontecarlo.options.material import Material
from pymontecarlo.options.sample import HorizontalLayerSample, SubstrateSample, VerticalLayerSample
from pymontecarlo.options.detector import PhotonDetector
from pymontecarlo.options.analysis import KRatioAnalysis
from pymontecarlo.options.limit import ShowersLimit
from pymontecarlo.options.options import Options
program = pymontecarlo.settings.get_program('casino2')
beam = GaussianBeam(15e3, 10e-9)
mat1 = Material.pure(29)
mat2 = Material.from_formula('SiO2')
mat3 = Material('Stuff', {27: 0.5, 25: 0.2, 8: 0.3}, 4500.0)
sample = SubstrateSample(mat2)
#sample = HorizontalLayerSample(mat3)
#sample.add_layer(mat2, 10e-9)
#sample.add_layer(mat3, 25e-9)
#sample = VerticalLayerSample(mat1, mat2)
#sample.add_layer(mat3, 10e-9)
photon_detector = PhotonDetector('xray', math.radians(35.0))
analysis = KRatioAnalysis(photon_detector)
limit = ShowersLimit(1000)
options = Options(program, beam, sample, [analysis], [limit])
