def testconvert(self):
handler = Casino2ProgramSeriesHandler()
program = Casino2Program(number_trajectories=500)
s = self.convert_serieshandler(handler, program)
self.assertEqual(8, len(s))
self.assertEqual(program.name, s['program'])
self.assertEqual(500, s['number of trajectories'])
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 _has_casino2():
try:
program = Casino2Program()
program.executable # Raise RuntimeError
except ProgramNotFound:
return False
return True
def setUp(self):
super().setUp()
self.tmpdir = self.create_temp_dir()
self.e = Casino2Exporter()
self.options = self.create_basic_options()
self.options.program = Casino2Program()
def setUp(self):
super().setUp()
self.token = Token()
self.outputdir = self.create_temp_dir()
self.options = self.create_basic_options()
self.options.program = Casino2Program()
self.options.program.number_trajectories = 50
self.worker = Casino2Worker()
def __init__(self, model):
super().__init__(model)
self.field_number_trajectories = NumberTrajectoriesField()
self.addLabelField(self.field_number_trajectories)
default_program = Casino2Program()
self.field_elastic_cross_section_model = ElasticCrossSectionModelField()
for model in ELASTIC_CROSS_SECTION_MODEL_LOOKUP:
checked = model == default_program.elastic_cross_section_model
self.field_elastic_cross_section_model.addModel(model, checked)
self.addGroupField(self.field_elastic_cross_section_model)
self.field_ionization_cross_section_model = IonizationCrossSectionModelField()
for model in IONIZATION_CROSS_SECTION_MODEL_LOOKUP:
checked = model == default_program.ionization_cross_section_model
self.field_ionization_cross_section_model.addModel(model, checked)
self.addGroupField(self.field_ionization_cross_section_model)
self.field_ionization_potential_model = IonizationPotentialModelField()
for model in IONIZATION_POTENTIAL_MODEL_LOOKUP:
checked = model == default_program.ionization_potential_model
self.field_ionization_potential_model.addModel(model, checked)
self.addGroupField(self.field_ionization_potential_model)
self.field_random_number_generator_model = RandomNumberGeneratorModelField()
for model in RANDOM_NUMBER_GENERATOR_MODEL_LOOKUP:
checked = model == default_program.random_number_generator_model
self.field_random_number_generator_model.addModel(model, checked)
self.addGroupField(self.field_random_number_generator_model)
self.field_direction_cosine_model = DirectionCosineModelField()
for model in DIRECTION_COSINES_MODEL_LOOKUP:
checked = model == default_program.direction_cosine_model
self.field_direction_cosine_model.addModel(model, checked)
self.addGroupField(self.field_direction_cosine_model)
self.field_energy_loss_model = EnergyLossModelField()
for model in ENERGY_LOSS_MODEL_LOOKUP:
checked = model == default_program.energy_loss_model
self.field_energy_loss_model.addModel(model, checked)
self.addGroupField(self.field_energy_loss_model)
def program():
return Casino2Program()
def setUp(self):
super().setUp()
self.program = Casino2Program()
def testconvert(self):
handler = Casino2ProgramDocumentHandler()
program = Casino2Program(number_trajectories=500)
document = self.convert_documenthandler(handler, program)
self.assertEqual(5, self.count_document_nodes(document))
def create_program(num_of_trajectory = 5000):
program = Casino2Program(num_of_trajectory if num_of_trajectory > 2000 else NUM_OF_ELECTRON) # minimum 2000 trajectories
return program
def testconvert_parse(self):
handler = Casino2ProgramHDF5Handler()
program = Casino2Program(number_trajectories=500)
program2 = self.convert_parse_hdf5handler(handler, program)
self.assertEqual(program2, program)
def main(argv=None):
options_builder = OptionsBuilder()
program = Casino2Program()
program.number_trajectories = 1000
options_builder.add_program(program)
beam_builder = GaussianBeamBuilder()
beam_builder.add_energy_eV(15e3)
beam_builder.add_diameter_m(10e-9)
beam_builder.add_linescan_x(-1e-07, 1e-07, 5e-08)
beams = beam_builder.build()
print("beams", beams)
options_builder.beams.extend(beams)
mat1 = Material.pure(26)
mat2 = Material.pure(14)
sample = VerticalLayerSample(mat1, mat2)
options_builder.add_sample(sample)
photon_detector = PhotonDetector("xray", math.radians(35.0))
# analysis = KRatioAnalysis(photon_detector)
analysis = PhotonIntensityAnalysis(photon_detector)
options_builder.add_analysis(analysis)
list_options = options_builder.build()
# Run simulation
project = Project()
# for options in opt:
with LocalSimulationRunner(project, max_workers=3) as runner:
futures = runner.submit(*list_options)
print("{} simulations launched".format(len(futures)))
while not runner.wait(1):
print(runner.progress)
print("{} simulations succeeded".format(runner.done_count))
print("{} simulations failed".format(runner.failed_count))
for future in runner.failed_futures:
print(future.exception())
# Results
project.recalculate()
print("{} were simulated".format(len(project.simulations)))
################################################################################################
### Ab hier wird es relevant ###
################################################################################################
# Hier werden die Ergebnisse gespeichert
data_all = []
for simulation in project.simulations:
# results = simulation.results
position = simulation.options.beam.x0_m
for unkresult in simulation.find_result(EmittedPhotonIntensityResult):
for xrayline, unkintensity in unkresult.items():
# z = xrayline.atomic_number
data = unkintensity.nominal_value
data_all.append((xrayline, position, data))
results = {}
# Zu jeder simulierten Röntgenlinie wird der Datensatz in einem Dictionary gespeichert
for x, p, d in data_all:
if not x in results:
results[x] = []
results[x].append((p, d))
# Sortiere Werte und gebe sie aus
sorted_results = []
for k, v in results.items():
v.sort(key=lambda t: t[0])
print("{}\t{}".format(k, v))
print(v)
plot_results(k, v)
sorted_results.append((k, v))
return sorted_results
print(sorted_results)