# Set the energy bins
energy_bins = numpy.logspace(numpy.log10(1.5e-5), numpy.log10(15.7), num=101) #[ 1.5e-5, 99l, 15.7 ]
track_flux_estimator.setEnergyDiscretization( energy_bins )
# Add the estimator to the event handler
event_handler.addEstimator( track_flux_estimator )
##---------------------------------------------------------------------------##
## ----------------------- SIMULATION MANAGER SETUP ------------------------ ##
##---------------------------------------------------------------------------##
data_directory = os.path.dirname(database_path)
# Initialized database
database = Data.ScatteringCenterPropertiesDatabase(database_path)
scattering_center_definition_database = Collision.ScatteringCenterDefinitionDatabase()
# Set element properties
element_properties = database.getAtomProperties( Data.Au_ATOM )
element_definition = scattering_center_definition_database.createDefinition( element, Data.ZAID(zaid) )
version = 1
if file_type == Data.ElectroatomicDataProperties.ACE_EPR_FILE:
version = 14
element_definition.setElectroatomicDataProperties(
element_properties.getSharedElectroatomicDataProperties( file_type, version ) )
material_definition_database = Collision.MaterialDefinitionDatabase()
def runSimulation(threads, histories, time):
##--------------------------------------------------------------------------##
## ------------------------------ MPI Session ----------------------------- ##
##--------------------------------------------------------------------------##
session = MPI.GlobalMPISession(len(sys.argv), sys.argv)
Utility.removeAllLogs()
session.initializeLogs(0, True)
if session.rank() == 0:
print "The PyFrensie path is set to: ", pyfrensie_path
properties = setSimulationProperties(histories, time)
##--------------------------------------------------------------------------##
## ---------------------------- GEOMETRY SETUP ---------------------------- ##
##--------------------------------------------------------------------------##
# Set element zaid and name
atom = Data.H_ATOM
zaid = 1000
element = "H"
# Set geometry path and type
model_properties = DagMC.DagMCModelProperties(geometry_path)
model_properties.useFastIdLookup()
# Set model
geom_model = DagMC.DagMCModel(model_properties)
##--------------------------------------------------------------------------##
## -------------------------- EVENT HANDLER SETUP ------------------------- ##
##--------------------------------------------------------------------------##
# Set event handler
event_handler = Event.EventHandler(properties)
# Set the energy bins
if energy == 0.1:
bins = list(Utility.doubleArrayFromString("{ 1e-4, 5e-4, 198i, 1e-1}"))
elif energy == 0.01:
bins = list(
Utility.doubleArrayFromString("{ 1e-4, 58i, 6e-3, 99i, 1e-2}"))
elif energy == 0.001:
bins = list(Utility.doubleArrayFromString("{ 1e-4, 197i, 1e-3}"))
else:
print "ERROR: energy ", energy, " not supported!"
## -------------------------- Track Length Flux --------------------------- ##
# Setup a track length flux estimator
estimator_id = 1
cell_ids = [1]
track_flux_estimator = Event.WeightMultipliedCellTrackLengthFluxEstimator(
estimator_id, 1.0, cell_ids, geom_model)
# Set the particle type
track_flux_estimator.setParticleTypes([MonteCarlo.ELECTRON])
# Set the energy bins
track_flux_estimator.setEnergyDiscretization(bins)
# Add the estimator to the event handler
event_handler.addEstimator(track_flux_estimator)
## ------------------------ Surface Flux Estimator ------------------------ ##
# Setup a surface flux estimator
estimator_id = 2
surface_ids = [1]
surface_flux_estimator = Event.WeightMultipliedSurfaceFluxEstimator(
estimator_id, 1.0, surface_ids, geom_model)
# Set the particle type
surface_flux_estimator.setParticleTypes([MonteCarlo.ELECTRON])
# Set the energy bins
surface_flux_estimator.setEnergyDiscretization(bins)
# Add the estimator to the event handler
event_handler.addEstimator(surface_flux_estimator)
## ---------------------- Surface Current Estimator ----------------------- ##
# Setup a surface current estimator
estimator_id = 3
surface_ids = [1]
surface_current_estimator = Event.WeightMultipliedSurfaceCurrentEstimator(
estimator_id, 1.0, surface_ids)
# Set the particle type
surface_current_estimator.setParticleTypes([MonteCarlo.ELECTRON])
# Set the energy bins
surface_current_estimator.setEnergyDiscretization(bins)
# Add the estimator to the event handler
event_handler.addEstimator(surface_current_estimator)
##--------------------------------------------------------------------------##
## ----------------------- SIMULATION MANAGER SETUP ----------------------- ##
##--------------------------------------------------------------------------##
# Initialized database
database = Data.ScatteringCenterPropertiesDatabase(database_path)
scattering_center_definition_database = Collision.ScatteringCenterDefinitionDatabase(
)
# Set element properties
element_properties = database.getAtomProperties(atom)
element_definition = scattering_center_definition_database.createDefinition(
element, Data.ZAID(zaid))
version = 0
if file_type == Data.ElectroatomicDataProperties.ACE_EPR_FILE:
version = 14
element_definition.setElectroatomicDataProperties(
element_properties.getSharedElectroatomicDataProperties(
file_type, version))
material_definition_database = Collision.MaterialDefinitionDatabase()
material_definition_database.addDefinition(element, 1, (element, ),
(1.0, ))
# Fill model
model = Collision.FilledGeometryModel(
database_path, scattering_center_definition_database,
material_definition_database, properties, geom_model, True)
# Set particle distribution
particle_distribution = ActiveRegion.StandardParticleDistribution(
"source distribution")
# Set the energy dimension distribution
delta_energy = Distribution.DeltaDistribution(energy)
energy_dimension_dist = ActiveRegion.IndependentEnergyDimensionDistribution(
delta_energy)
particle_distribution.setDimensionDistribution(energy_dimension_dist)
# Set the spatial dimension distribution
particle_distribution.setPosition(0.0, 0.0, 0.0)
particle_distribution.constructDimensionDistributionDependencyTree()
# Set source components
source_component = [
ActiveRegion.StandardElectronSourceComponent(0, 1.0, geom_model,
particle_distribution)
]
# Set source
source = ActiveRegion.StandardParticleSource(source_component)
# Set the archive type
archive_type = "xml"
name, title = setSimulationName(properties)
factory = Manager.ParticleSimulationManagerFactory(model, source,
event_handler,
properties, name,
archive_type, threads)
manager = factory.getManager()
Utility.removeAllLogs()
session.initializeLogs(0, False)
manager.runSimulation()
if session.rank() == 0:
print "Processing the results:"
processData(event_handler, name, title)
print "Results will be in ", path.dirname(name)
def runSimulation(threads, histories, time):
##--------------------------------------------------------------------------##
## ------------------------------ MPI Session ----------------------------- ##
##--------------------------------------------------------------------------##
session = MPI.GlobalMPISession(len(sys.argv), sys.argv)
Utility.removeAllLogs()
session.initializeLogs(0, True)
if session.rank() == 0:
print "The PyFrensie path is set to: ", pyfrensie_path
properties = setSimulationProperties(histories, time)
##--------------------------------------------------------------------------##
## ---------------------------- GEOMETRY SETUP ---------------------------- ##
##--------------------------------------------------------------------------##
# Set geometry path and type
model_properties = DagMC.DagMCModelProperties(geometry_path)
model_properties.useFastIdLookup()
# Construct model
geom_model = DagMC.DagMCModel(model_properties)
##--------------------------------------------------------------------------##
## -------------------------- EVENT HANDLER SETUP ------------------------- ##
##--------------------------------------------------------------------------##
# Set event handler
event_handler = Event.EventHandler(properties)
## -------------------- Energy Deposition Calorimeter --------------------- ##
# Setup a cell pulse height estimator
estimator_id = 1
cell_ids = [2]
energy_deposition_estimator = Event.WeightAndEnergyMultipliedCellPulseHeightEstimator(
estimator_id, 1.0, cell_ids)
# Add the estimator to the event handler
event_handler.addEstimator(energy_deposition_estimator)
##--------------------------------------------------------------------------##
## ----------------------- SIMULATION MANAGER SETUP ----------------------- ##
##--------------------------------------------------------------------------##
# Initialized database
database = Data.ScatteringCenterPropertiesDatabase(database_path)
scattering_center_definition_database = Collision.ScatteringCenterDefinitionDatabase(
)
# Set element properties
element_properties = database.getAtomProperties(atom)
element_definition = scattering_center_definition_database.createDefinition(
element, Data.ZAID(zaid))
version = 0
if file_type == Data.ElectroatomicDataProperties.ACE_EPR_FILE:
version = 14
element_definition.setElectroatomicDataProperties(
element_properties.getSharedElectroatomicDataProperties(
file_type, version))
material_definition_database = Collision.MaterialDefinitionDatabase()
material_definition_database.addDefinition(element, 1, (element, ),
(1.0, ))
# Fill model
model = Collision.FilledGeometryModel(
database_path, scattering_center_definition_database,
material_definition_database, properties, geom_model, True)
# Set particle distribution
particle_distribution = ActiveRegion.StandardParticleDistribution(
"source distribution")
# Set the energy dimension distribution
delta_energy = Distribution.DeltaDistribution(energy)
energy_dimension_dist = ActiveRegion.IndependentEnergyDimensionDistribution(
delta_energy)
particle_distribution.setDimensionDistribution(energy_dimension_dist)
# Set the direction dimension distribution
particle_distribution.setDirection(0.0, 0.0, 1.0)
# Set the spatial dimension distribution
particle_distribution.setPosition(0.0, 0.0, 0.0)
particle_distribution.constructDimensionDistributionDependencyTree()
# Set source components
source_component = [
ActiveRegion.StandardElectronSourceComponent(0, 1.0, geom_model,
particle_distribution)
]
# Set source
source = ActiveRegion.StandardParticleSource(source_component)
# Set the archive type
archive_type = "xml"
# Set the simulation name and title
name, title = setSimulationName(properties)
factory = Manager.ParticleSimulationManagerFactory(model, source,
event_handler,
properties, name,
archive_type, threads)
manager = factory.getManager()
Utility.removeAllLogs()
session.initializeLogs(0, False)
manager.runSimulation()
if session.rank() == 0:
print "Processing the results:"
processData(energy_deposition_estimator, name, title, test_range,
calorimeter_thickness)
print "Results will be in ", path.dirname(name)
def sphereSimulation(sim_name,
db_path,
num_particles,
source_energy,
energy_bins,
threads,
log_file=None):
##---------------------------------------------------------------------------##
## Initialize the MPI Session
##---------------------------------------------------------------------------##
session = MPI.GlobalMPISession(len(sys.argv), sys.argv)
# Suppress logging on all procs except for the master (proc=0)
Utility.removeAllLogs()
session.initializeLogs(0, True)
if not log_file is None:
session.initializeLogs(log_file, 0, True)
##---------------------------------------------------------------------------##
## Set the simulation properties
##---------------------------------------------------------------------------##
simulation_properties = MonteCarlo.SimulationProperties()
# Simulate neutrons only
simulation_properties.setParticleMode(MonteCarlo.NEUTRON_MODE)
simulation_properties.setUnresolvedResonanceProbabilityTableModeOff()
simulation_properties.setNumberOfNeutronHashGridBins(100)
# Set the number of histories to run and the number of rendezvous
simulation_properties.setNumberOfHistories(num_particles)
simulation_properties.setMinNumberOfRendezvous(10)
##---------------------------------------------------------------------------##
## Set up the materials
##---------------------------------------------------------------------------##
# Load the database
database = Data.ScatteringCenterPropertiesDatabase(db_path)
# Set the definition of H1 for this simulation
scattering_center_definitions = Collision.ScatteringCenterDefinitionDatabase(
)
# Extract the properties for H1 from the database
nuclide_properties = database.getNuclideProperties(Data.ZAID(82204))
nuclide_definition = scattering_center_definitions.createDefinition(
"Pb204", Data.ZAID(82204))
nuclide_definition.setNuclearDataProperties(
nuclide_properties.getSharedNuclearDataProperties(
Data.NuclearDataProperties.ACE_FILE, 8, 293.6, False))
nuclide_properties = database.getNuclideProperties(Data.ZAID(82206))
nuclide_definition = scattering_center_definitions.createDefinition(
"Pb206", Data.ZAID(82206))
nuclide_definition.setNuclearDataProperties(
nuclide_properties.getSharedNuclearDataProperties(
Data.NuclearDataProperties.ACE_FILE, 8, 293.6, False))
nuclide_properties = database.getNuclideProperties(Data.ZAID(82207))
nuclide_definition = scattering_center_definitions.createDefinition(
"Pb207", Data.ZAID(82207))
nuclide_definition.setNuclearDataProperties(
nuclide_properties.getSharedNuclearDataProperties(
Data.NuclearDataProperties.ACE_FILE, 8, 293.6, False))
nuclide_properties = database.getNuclideProperties(Data.ZAID(82208))
nuclide_definition = scattering_center_definitions.createDefinition(
"Pb208", Data.ZAID(82208))
nuclide_definition.setNuclearDataProperties(
nuclide_properties.getSharedNuclearDataProperties(
Data.NuclearDataProperties.ACE_FILE, 8, 293.6, False))
material_definitions = Collision.MaterialDefinitionDatabase()
material_definitions.addDefinition("Pb_nat", 1,
["Pb204", "Pb206", "Pb207", "Pb208"],
[0.014, 0.241, 0.221, 0.524])
##---------------------------------------------------------------------------##
## Set up the geometry
##---------------------------------------------------------------------------##
# Set the model properties before loading the model
model_properties = DagMC.DagMCModelProperties("sphere.h5m")
model_properties.setMaterialPropertyName("mat")
model_properties.setDensityPropertyName("rho")
model_properties.setTerminationCellPropertyName("termination.cell")
model_properties.setSurfaceFluxName("surface.flux")
model_properties.setSurfaceCurrentName("surface.current")
model_properties.useFastIdLookup()
# Load the model
model = DagMC.DagMCModel(model_properties)
# Fill the model with the defined materials
filled_model = Collision.FilledGeometryModel(
db_path, scattering_center_definitions, material_definitions,
simulation_properties, model, True)
##---------------------------------------------------------------------------##
## Set up the source
##---------------------------------------------------------------------------##
# Define the generic particle distribution
particle_distribution = ActiveRegion.StandardParticleDistribution(
"source distribution")
particle_distribution.setEnergy(source_energy)
particle_distribution.setPosition(0.0, 0.0, 0.0)
particle_distribution.constructDimensionDistributionDependencyTree()
# The generic distribution will be used to generate neutrons
neutron_distribution = ActiveRegion.StandardNeutronSourceComponent(
0, 1.0, model, particle_distribution)
# Assign the neutron source component to the source
source = ActiveRegion.StandardParticleSource([neutron_distribution])
##---------------------------------------------------------------------------##
## Set up the event handler
##---------------------------------------------------------------------------##
# The model must be passed to the event handler so that the estimators
# defined in the model can be constructed
event_handler = Event.EventHandler(model, simulation_properties)
# Set the energy and collision number bins in estimator 1
event_handler.getEstimator(1).setEnergyDiscretization(energy_bins)
# Set the energy and collision number bins in estimator 2
event_handler.getEstimator(2).setEnergyDiscretization(energy_bins)
##---------------------------------------------------------------------------##
## Set up the simulation manager
##---------------------------------------------------------------------------##
# The factory will use the simulation properties and the MPI session
# properties to determine the appropriate simulation manager to construct
factory = Manager.ParticleSimulationManagerFactory(filled_model, source,
event_handler,
simulation_properties,
sim_name, "xml",
threads)
# Create the simulation manager
manager = factory.getManager()
# Allow logging on all procs
session.restoreOutputStreams()
##---------------------------------------------------------------------------##
## Run the simulation
##---------------------------------------------------------------------------##
if session.size() == 1:
manager.runInterruptibleSimulation()
else:
manager.runSimulation()
def runSimulation(threads, histories, time):
##--------------------------------------------------------------------------##
## ------------------------------ MPI Session ----------------------------- ##
##--------------------------------------------------------------------------##
session = MPI.GlobalMPISession(len(sys.argv), sys.argv)
Utility.removeAllLogs()
session.initializeLogs(0, True)
if session.rank() == 0:
print "The PyFrensie path is set to: ", pyfrensie_path
properties = setSimulationProperties(histories, time)
##--------------------------------------------------------------------------##
## ---------------------------- GEOMETRY SETUP ---------------------------- ##
##--------------------------------------------------------------------------##
# Set geometry path and type
model_properties = DagMC.DagMCModelProperties(geometry_path)
model_properties.useFastIdLookup()
# Construct model
geom_model = DagMC.DagMCModel(model_properties)
##--------------------------------------------------------------------------##
## -------------------------- EVENT HANDLER SETUP ------------------------- ##
##--------------------------------------------------------------------------##
# Set event handler
event_handler = Event.EventHandler(properties)
# Set the energy bins
bins = list(Utility.doubleArrayFromString("{ 1e-4, 58i, 6e-3, 99i, 1e-2}"))
## ------------------------ Surface Flux Estimator ------------------------ ##
# Setup an adjoint surface flux estimator
estimator_id = 2
surface_ids = [1, 16, 18]
surface_flux_estimator = Event.WeightMultipliedSurfaceFluxEstimator(
estimator_id, 1.0, surface_ids, geom_model)
# Set the particle type
surface_flux_estimator.setParticleTypes([MonteCarlo.ADJOINT_ELECTRON])
# Set the energy bins
surface_flux_estimator.setSourceEnergyDiscretization(bins)
# Create response function
delta_energy = Distribution.DeltaDistribution(energy)
particle_response_function = ActiveRegion.EnergyParticleResponseFunction(
delta_energy)
response_function = ActiveRegion.StandardParticleResponse(
particle_response_function)
# Set the response function
surface_flux_estimator.setResponseFunctions([response_function])
# Add the estimator to the event handler
event_handler.addEstimator(surface_flux_estimator)
## -------------------------- Particle Tracker ---------------------------- ##
# particle_tracker = Event.ParticleTracker( 0, 1000 )
# # Add the particle tracker to the event handler
# event_handler.addParticleTracker( particle_tracker )
##--------------------------------------------------------------------------##
## ----------------------- SIMULATION MANAGER SETUP ----------------------- ##
##--------------------------------------------------------------------------##
# Initialized database
database = Data.ScatteringCenterPropertiesDatabase(database_path)
scattering_center_definition_database = Collision.ScatteringCenterDefinitionDatabase(
)
# Set element properties
element_properties = database.getAtomProperties(atom)
element_definition = scattering_center_definition_database.createDefinition(
element, Data.ZAID(zaid))
# version = 0
if "debug" in pyfrensie_path:
version = 1
else:
version = 0
file_type = Data.AdjointElectroatomicDataProperties.Native_EPR_FILE
element_definition.setAdjointElectroatomicDataProperties(
element_properties.getSharedAdjointElectroatomicDataProperties(
file_type, version))
material_definition_database = Collision.MaterialDefinitionDatabase()
material_definition_database.addDefinition(element, 1, (element, ),
(1.0, ))
# Fill model
model = Collision.FilledGeometryModel(
database_path, scattering_center_definition_database,
material_definition_database, properties, geom_model, True)
# Set particle distribution
particle_distribution = ActiveRegion.StandardParticleDistribution(
"source distribution")
# Set the energy dimension distribution
uniform_energy = Distribution.UniformDistribution(energy_cutoff, energy)
energy_dimension_dist = ActiveRegion.IndependentEnergyDimensionDistribution(
uniform_energy)
particle_distribution.setDimensionDistribution(energy_dimension_dist)
# Set the spatial dimension distribution
particle_distribution.setPosition(0.0, 0.0, 0.0)
particle_distribution.constructDimensionDistributionDependencyTree()
# Set source components
source_component = [
ActiveRegion.StandardAdjointElectronSourceComponent(
0, 1.0, model, particle_distribution)
]
# Set source
source = ActiveRegion.StandardParticleSource(source_component)
# Set the archive type
archive_type = "xml"
# Set the simulation name and title
name, title = setSimulationName(properties)
factory = Manager.ParticleSimulationManagerFactory(model, source,
event_handler,
properties, name,
archive_type, threads)
manager = factory.getManager()
Utility.removeAllLogs()
session.initializeLogs(0, False)
manager.runSimulation()
if session.rank() == 0:
print "Processing the results:"
processData(event_handler, name, title)
print "Results will be in ", path.dirname(name)
max_ionization = total_ionization / cs
max_brem = (total_ionization + brem_cs) / cs
max_excitation = (total_ionization + brem_cs + excitation_cs) / cs
max_elastic = (total_ionization + brem_cs + excitation_cs +
elastic_cs) / cs
print '\tAdjoint_weight_factor = ', '%.16e' % weight_factor
print '\t---------------------------------------'
print '\tmax ionization random number = ', '%.16e' % max_ionization
print '\tmax brem random number = ', '%.16e' % max_brem
print '\tactual min excitation random number = .28545'
print '\tactual max excitation random number = ', excitation_cs / cs + .28545
print '\tmax excitation random number = ', max_excitation
print '\tmax elastic random number = ', '%.16e' % max_elastic
brem_dist = Collision.createLogLogLogCorrelatedBremsstrahlungDistribution(
adjoint_data, 1e-12)
atomic_dist = Collision.createAtomicExcitationDistribution(adjoint_data)
random_numbers = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
Prng.RandomNumberGenerator.setFakeStream(random_numbers)
incoming_energy = 1.55
outgoing_energy, scattering_angle = brem_dist.sample(incoming_energy)
print "\noutgoing_energy = ", '%.16e' % outgoing_energy
print "scattering_angle = ", '%.16e' % scattering_angle
outgoing_energy, scattering_angle = atomic_dist.sample(incoming_energy)
print "\noutgoing_energy = ", '%.16e' % outgoing_energy
print "scattering_angle = ", '%.16e' % scattering_angle
simulation_properties.setUnresolvedResonanceProbabilityTableModeOff()
simulation_properties.setNumberOfNeutronHashGridBins(100)
# Set the number of histories to run and the number of rendezvous
simulation_properties.setNumberOfHistories(num_particles)
simulation_properties.setMinNumberOfRendezvous(10)
##---------------------------------------------------------------------------##
## Set up the materials
##---------------------------------------------------------------------------##
# Load the database
database = Data.ScatteringCenterPropertiesDatabase(db_path)
# Set the definition of H2O for this simulation and extract the properties for H2O from the database
scattering_center_definitions = Collision.ScatteringCenterDefinitionDatabase()
# Hydrogen 1
nuclide_properties = database.getNuclideProperties(Data.ZAID(1001))
nuclide_definition = scattering_center_definitions.createDefinition(
"H1", Data.ZAID(1001))
nuclide_definition.setNuclearDataProperties(
nuclide_properties.getSharedNuclearDataProperties(
Data.NuclearDataProperties.ACE_FILE, 8, 293.6, False))
# Oxygen 16
nuclide_properties = database.getNuclideProperties(Data.ZAID(8016))
nuclide_definition = scattering_center_definitions.createDefinition(
"O16", Data.ZAID(8016))
nuclide_definition.setNuclearDataProperties(
nuclide_properties.getSharedNuclearDataProperties(
data_list = cs_list.get('Pb-Native')
native_file_name = datadir + data_list.get('electroatomic_file_path')
pb_data = Native.ElectronPhotonRelaxationDataContainer(native_file_name)
###
### Construct Coupled Distribution
###
interps = ["LinLinLog", "LogLogLog", "LinLinLin"]
methods = ["Simplified Union", "One D Union", "Two D Union"]
interps = ["LogLogLog", "LinLinLin"]
methods = ["Two D Union"]
for interp in interps:
print "\n-----", interp, "-----"
for method in methods:
coupled_dist = Collision.createLinLinLogCorrelatedCoupledElasticDistribution(
pb_data, method, 1e-15)
if interp == "LogLogLog":
coupled_dist = Collision.createLogLogLogCorrelatedCoupledElasticDistribution(
pb_data, method, 1e-15)
elif interp == "LinLinLin":
coupled_dist = Collision.createLinLinLinCorrelatedCoupledElasticDistribution(
pb_data, method, 1e-15)
print "\n----- ", method, " -----\n"
print "\t -- evaluateLegendreExpandedRutherford --\n"
etas = [
2.51317958942017e3, 2.68213671998009, 4.14887699806239e-14,
2.51317958942017e3
]
angles = [[0.999999], [1.0, 1.0, 1.0], [0.999999], [1.0]]
### -------------------------------------------------------------------------- ##
native_file_name = datadir + data_list.get('electroatomic_file_path')
native_data = Native.ElectronPhotonRelaxationDataContainer(native_file_name)
energy_grid = native_data.getElectronEnergyGrid()
tot_elastic_cs = native_data.getTotalElasticCrossSection()
cutoff_cs = native_data.getCutoffElasticCrossSection()
screen_rutherford_cs = native_data.getScreenedRutherfordElasticCrossSection()
screen_rutherford_index = native_data.getScreenedRutherfordElasticCrossSectionThresholdEnergyIndex(
)
###
### Lin-Log Analog Reaction Unit Test Check
###
print "\n----- Lin-Lin-Log -----"
analog_dist = Collision.createAnalogElasticDistribution(
native_data, "LinLinLog", True, 1e-15)
energies = [1e-5, 4e-4, 1e5]
for energy in energies:
print "Energy = ", energy
index = 0
for i in range(0, energy_grid.size):
if energy_grid[i] <= energy:
index = i
energy_0 = energy_grid[index]
cs_0 = cutoff_cs[index]
cs = cs_0
if energy_0 != energy:
source = Teuchos.FileInputSource(datadir + '/cross_sections.xml')
xml_obj = source.getObject()
cs_list = Teuchos.XMLParameterListReader().toParameterList(xml_obj)
# -------------------------------------------------------------------------- ##
# Native Data
# -------------------------------------------------------------------------- ##
data_list = cs_list.get('H-Native')
file_name = datadir + data_list.get('electroatomic_file_path')
native_data = Native.ElectronPhotonRelaxationDataContainer(file_name)
energy_grid = native_data.getElectronEnergyGrid()
elastic_energy_grid = native_data.getElasticAngularEnergyGrid()
cs_reduction = native_data.getMomentPreservingCrossSectionReduction()
hybrid_reaction = Collision.createHybridElasticReaction(
native_data, 0.9, False, True, 1e-15)
cutoff_reaction = Collision.createCutoffElasticReaction(
native_data, 1.0, False, True, 1e-15)
analog_reaction = Collision.createAnalogElasticReaction(
native_data, False, True, 1e-15)
hybrid_dist = Collision.createHybridElasticDistribution(
native_data, 0.9, False, True, 1e-15)
cutoff_dist = Collision.createCutoffElasticDistribution(
native_data, 1.0, False, True, 1e-15)
analog_dist = Collision.createAnalogElasticDistribution(
native_data, False, True, 1e-15)
bin_index = 4
energy = elastic_energy_grid[bin_index]
mp_cs_reduction = cs_reduction[bin_index]
)
adjoint_screen_rutherford_index = adjoint_data.getAdjointScreenedRutherfordElasticCrossSectionThresholdEnergyIndex(
)
adjoint_excitation_cs = adjoint_data.getAdjointAtomicExcitationCrossSection()
adjoint_ionization_cs = adjoint_data.getAdjointElectroionizationCrossSection(1)
adjoint_brem_cs = adjoint_data.getAdjointBremsstrahlungElectronCrossSection()
energies = [20.0, 3.2e-2, 1.0e-2]
angles = [-1.0, 0.0, 0.999999, 1.0]
###
### Coupled Distribution/Reaction Unit Test Check
###
adjoint_dist = Collision.createLinLinLogDirectCoupledElasticDistribution(
adjoint_data, "Simplified Union", 1e-7)
print "\n------------------------------------------------"
print "\nAdjoint Coupled"
print "------------------------------------------------"
print "\nAdjoint Coupled evaluate"
print "------------------------------------------------"
for energy in energies:
print "\n---- energy =", energy, "----"
for angle in angles:
pdf = adjoint_dist.evaluate(energy, angle)
print '\teval(', '%.5e' % angle, ') =\t', '%.16e' % pdf
print "\nAdjoint Coupled evaluatePDF"
def runSimulation(threads, histories, time):
##--------------------------------------------------------------------------##
## ------------------------------ MPI Session ----------------------------- ##
##--------------------------------------------------------------------------##
session = MPI.GlobalMPISession(len(sys.argv), sys.argv)
Utility.removeAllLogs()
session.initializeLogs(0, True)
if session.rank() == 0:
print "The PyFrensie path is set to: ", pyfrensie_path
properties = setSimulationProperties(histories, time)
##--------------------------------------------------------------------------##
## ---------------------------- GEOMETRY SETUP ---------------------------- ##
##--------------------------------------------------------------------------##
# Set geometry path and type
geometry_type = "DagMC" #(ROOT or DAGMC)
# Set element zaid and name
atom = Data.Au_ATOM
zaid = 79000
element = "Au"
# Set geometry path and type
model_properties = DagMC.DagMCModelProperties(geometry_path)
model_properties.useFastIdLookup()
# Set model
geom_model = DagMC.DagMCModel(model_properties)
##--------------------------------------------------------------------------##
## -------------------------- EVENT HANDLER SETUP ------------------------- ##
##--------------------------------------------------------------------------##
# Set event handler
event_handler = Event.EventHandler(properties)
## -------------------- Transmission Current Estimator -------------------- ##
# Setup a surface current estimator for the transmission current
estimator_id = 1
surface_ids = [1]
transmission_current_estimator = Event.WeightMultipliedSurfaceCurrentEstimator(
estimator_id, 1.0, surface_ids)
# Set the particle type
transmission_current_estimator.setParticleTypes([MonteCarlo.ELECTRON])
# Set the cosine bins
cosine_bins_1 = [
-1.000000000000000, 0.000000000000000, 0.939692620785908,
0.965925826289068, 0.984807753012208, 0.990268068741570,
0.994521895368273, 0.995396198367179, 0.996194698091746,
0.996917333733128, 0.997564050259824, 0.998134798421867,
0.998629534754574, 0.999048221581858, 0.999390827019096,
0.999657324975557, 0.999847695156391, 0.999961923064171,
1.000000000000000
]
transmission_current_estimator.setCosineDiscretization(cosine_bins_1)
# Add the estimator to the event handler
event_handler.addEstimator(transmission_current_estimator)
## --------------------- Reflection Current Estimator --------------------- ##
# Setup a surface current estimator for the reflection current
estimator_id = 2
surface_ids = [2]
reflection_current_estimator = Event.WeightMultipliedSurfaceCurrentEstimator(
estimator_id, 1.0, surface_ids)
# Set the particle type
reflection_current_estimator.setParticleTypes([MonteCarlo.ELECTRON])
# Set the cosine bins
cosine_bins_2 = [-1.0, -0.999999, 0.0, 1.0]
reflection_current_estimator.setCosineDiscretization(cosine_bins_2)
# Add the estimator to the event handler
event_handler.addEstimator(reflection_current_estimator)
## ---------------------- Track Length Flux Estimator --------------------- ##
# Setup a track length flux estimator
estimator_id = 3
cell_ids = [1]
track_flux_estimator = Event.WeightMultipliedCellTrackLengthFluxEstimator(
estimator_id, 1.0, cell_ids, geom_model)
# Set the particle type
track_flux_estimator.setParticleTypes([MonteCarlo.ELECTRON])
# Set the energy bins
energy_bins = numpy.logspace(numpy.log10(1.5e-5),
numpy.log10(15.7),
num=101) #[ 1.5e-5, 99l, 15.7 ]
track_flux_estimator.setEnergyDiscretization(energy_bins)
# Add the estimator to the event handler
event_handler.addEstimator(track_flux_estimator)
##--------------------------------------------------------------------------##
## ----------------------- SIMULATION MANAGER SETUP ----------------------- ##
##--------------------------------------------------------------------------##
# Initialized database
database = Data.ScatteringCenterPropertiesDatabase(database_path)
scattering_center_definition_database = Collision.ScatteringCenterDefinitionDatabase(
)
# Set element properties
element_properties = database.getAtomProperties(atom)
element_definition = scattering_center_definition_database.createDefinition(
element, Data.ZAID(zaid))
version = 0
if file_type == Data.ElectroatomicDataProperties.ACE_EPR_FILE:
version = 14
element_definition.setElectroatomicDataProperties(
element_properties.getSharedElectroatomicDataProperties(
file_type, version))
material_definition_database = Collision.MaterialDefinitionDatabase()
material_definition_database.addDefinition(element, 1, (element, ),
(1.0, ))
# Fill model
model = Collision.FilledGeometryModel(
database_path, scattering_center_definition_database,
material_definition_database, properties, geom_model, True)
# Set particle distribution
particle_distribution = ActiveRegion.StandardParticleDistribution(
"source distribution")
# Set the energy dimension distribution
delta_energy = Distribution.DeltaDistribution(15.7)
energy_dimension_dist = ActiveRegion.IndependentEnergyDimensionDistribution(
delta_energy)
particle_distribution.setDimensionDistribution(energy_dimension_dist)
# Set the direction dimension distribution
particle_distribution.setDirection(0.0, 0.0, 1.0)
# Set the spatial dimension distribution
particle_distribution.setPosition(0.0, 0.0, -0.1)
particle_distribution.constructDimensionDistributionDependencyTree()
# Set source components
source_component = [
ActiveRegion.StandardElectronSourceComponent(0, 1.0, geom_model,
particle_distribution)
]
# Set source
source = ActiveRegion.StandardParticleSource(source_component)
# Set the archive type
archive_type = "xml"
name, title = setSimulationName(properties)
factory = Manager.ParticleSimulationManagerFactory(model, source,
event_handler,
properties, name,
archive_type, threads)
manager = factory.getManager()
Utility.removeAllLogs()
session.initializeLogs(0, False)
manager.runSimulation()
if session.rank() == 0:
print "Processing the results:"
processCosineBinData(transmission_current_estimator, cosine_bins_1,
name, title)
print "Results will be in ", path.dirname(name)
print "----------------------------"
data_list = cs_list.get(z)
file_name = datadir + data_list.get('electroatomic_file_path')
print file_name
native_data = Native.ElectronPhotonRelaxationDataContainer(file_name)
subshells = native_data.getSubshells()
shells = [6, subshells[len(subshells) - 1]]
for shell in shells:
binding_energy = native_data.getSubshellBindingEnergy(shell)
print "\nshell = ", shell, "\tbinding energy =", binding_energy
print "----------------------------\n"
ionization_dist = Collision.createLinLinLinExactElectroionizationSubshellDistribution(
native_data, shell, binding_energy, 1e-15)
### -------------------------------------------------------------------------- ##
### Forward Elastic Unit Test Check
### -------------------------------------------------------------------------- ##
h_native_file_name = datadir + h_data_list.get('electroatomic_file_path')
native_data = Native.ElectronPhotonRelaxationDataContainer(h_native_file_name)
energy_grid = native_data.getElectronEnergyGrid()
tot_elastic_cs = native_data.getTotalElasticCrossSection()
cutoff_cs = native_data.getCutoffElasticCrossSection()
screen_rutherford_cs = native_data.getScreenedRutherfordElasticCrossSection()
screen_rutherford_index = native_data.getScreenedRutherfordElasticCrossSectionThresholdEnergyIndex(
)
moment_cs = native_data.getMomentPreservingCrossSection()
moment_index = native_data.getMomentPreservingCrossSectionThresholdEnergyIndex(
# Choose the random numbers at which to sample the distribution
lower_number = numpy.logspace(numpy.log10(1e-10), numpy.log10(1e-4), num=length/10+1)
upper_numbers = numpy.logspace(numpy.log10(1e-4), numpy.log10(1.0-1e-10), num=length*9/10)
random_numbers = numpy.unique(numpy.concatenate((lower_number, upper_numbers), axis=0))
pdfs = numpy.empty(shape=(len(schemes), length))
cdfs = numpy.empty(shape=(len(schemes), length))
samples = numpy.empty(shape=(len(schemes), length))
labels = []
for n in range(0, len(schemes)):
if interpolation == "LogLogLog":
labels.append(schemes[n] + " - log")
if schemes[n] == "Unit-base":
dist = Collision.createLogLogLogUnitBaseCoupledElasticDistribution(native_data, "One D Union", tol)
if schemes[n] == "Unit-base Correlated":
dist = Collision.createLogLogLogUnitBaseCorrelatedCoupledElasticDistribution(native_data, "Two D Union", tol)
if schemes[n] == "Correlated":
dist = Collision.createLogLogLogCorrelatedCoupledElasticDistribution(native_data, "Two D Union", tol)
elif interpolation == "LinLinLin":
labels.append(schemes[n] + " - lin")
if schemes[n] == "Unit-base":
dist = Collision.createLinLinLinUnitBaseCoupledElasticDistribution(native_data, "Two D Union", tol)
if schemes[n] == "Unit-base Correlated":
dist = Collision.createLinLinLinUnitBaseCorrelatedCoupledElasticDistribution(native_data, "Two D Union", tol)
if schemes[n] == "Correlated":
dist = Collision.createLinLinLinCorrelatedCoupledElasticDistribution(native_data, "Two D Union", tol)
for i in range(0, length):
pdfs[n, i] = dist.evaluatePDF(energy, angles[i])
tot_adjoint_elastic_cs = adjoint_data.getAdjointTotalElasticCrossSection()
adjoint_cutoff_cs = adjoint_data.getAdjointCutoffElasticCrossSection()
reduced_cutoff_ratio = adjoint_data.getReducedCutoffCrossSectionRatios()
adjoint_screen_rutherford_cs = adjoint_data.getAdjointScreenedRutherfordElasticCrossSection(
)
adjoint_screen_rutherford_index = adjoint_data.getAdjointScreenedRutherfordElasticCrossSectionThresholdEnergyIndex(
)
adjoint_excitation_cs = adjoint_data.getAdjointAtomicExcitationCrossSection()
adjoint_ionization_cs = adjoint_data.getAdjointElectroionizationCrossSection(1)
adjoint_brem_cs = adjoint_data.getAdjointBremsstrahlungElectronCrossSection()
###
### Cutoff Distribution/Reaction Unit Test Check
###
adjoint_cutoff_dist = Collision.createLogLogLogCorrelatedCutoffElasticDistribution(
adjoint_data, 1.0, 1e-7)
cutoff_cdf = adjoint_cutoff_dist.evaluateCDF(20.0, 0.9)
ratio = reduced_cutoff_ratio[reduced_cutoff_ratio.size - 1]
cutoff_cs = adjoint_cutoff_cs[reduced_cutoff_ratio.size - 1]
print 'cutoff_cdf = ', '%.16e' % cutoff_cdf
print 'ratio = ', '%.16e' % ratio
print 'cutoff_cs = ', '%.16e' % cutoff_cs
cutoff_cdf = adjoint_cutoff_dist.evaluateCDF(1e-3, 0.9)
print 'cutoff_cdf = ', '%.16e' % cutoff_cdf
cutoff_cdf = adjoint_cutoff_dist.evaluateCDF(1e-5, 0.9)
print 'cutoff_cdf = ', '%.16e' % cutoff_cdf
# change cutoff
energy_1 = adjoint_energy_grid[index + 1]
cs_1 = adjoint_ionization_cs[index + 1]
print "energy = ", energy
cs = cs_0 + (cs_1 - cs_0) * (energy - energy_0) / (energy_1 - energy_0)
print '\tcs = ', '%.16e' % cs
energy = 20.0
print "energy = ", energy
print '\tcs = ', '%.16e' % adjoint_ionization_cs[adjoint_ionization_cs.size -
1]
interpolations = ["LogLogLog", "LinLinLog"]
for interp in interpolations:
ionization_dist = Collision.createLogLogLogUnitBaseCorrelatedElectroionizationSubshellDistribution(
adjoint_data, shell, binding_energy, 1e-10)
if interp == "LinLinLog":
ionization_dist = Collision.createLinLinLogUnitBaseCorrelatedElectroionizationSubshellDistribution(
adjoint_data, shell, binding_energy, 1e-10)
if interp == "LinLinLin":
ionization_dist = Collision.createLinLinLinUnitBaseCorrelatedElectroionizationSubshellDistribution(
adjoint_data, shell, binding_energy, 1e-10)
print "\n--- ", interp, " ---"
print "\nEvaluate"
pdf = ionization_dist.evaluate(9.99e-6, 2.3711E-5)
print "\teval 1 = ", '%.16e' % pdf
pdf = ionization_dist.evaluate(1e-5, 2.3711E-5)
print "\teval 2 = ", '%.16e' % pdf
###
### Cutoff Distribution Pyfrensie Unit Test Check
###
interpolations = ["LinLinLin", "LinLinLog", "LogLogLog"]
cutoff_angle_cosines = [0.9, 0.999999]
energies = [1e5, 1e-3, 4e-4]
angles = [0.0, 0.9]
interpolations = ["LinLinLog"]
cutoff_angle_cosines = [0.9]
for interp in interpolations:
print "\n\n\t-----",interp,"-----"
for cutoff in cutoff_angle_cosines:
cutoff_dist = Collision.createLinLinLogCorrelatedCutoffElasticDistribution(native_data, cutoff, 1e-14)
full_cutoff_dist = Collision.createLinLinLogCorrelatedCutoffElasticDistribution( native_data, 1.0, 1e-14)
print "\n\t--- Cutoff Angle Cosine = ",cutoff," ---"
print "\n\tEvaluate"
for energy in energies:
print "Energy = ",energy
for angle in angles:
pdf = cutoff_dist.evaluate( energy, angle )
full_pdf = full_cutoff_dist.evaluate( energy, angle )
print '\teval[',angle,'] = ','%.16e' % pdf
# print '\tfull eval[',angle,'] = ','%.16e' % full_pdf
print "\n\tEvaluate PDF"
for energy in energies:
print "Energy = ",energy
shells = selected_shells
else:
shells = subshells
for shell in shells:
binding_energy = native_data.getSubshellBindingEnergy(shell)
print "\nshell = ", shell, "\tbinding energy =", binding_energy
print "----------------------------\n"
for interp in interps:
for scheme in schemes:
print "\n-----", interp, "-", scheme, "-----\n"
if interp == "LogLogLog":
if scheme == "Unit-base":
dist = Collision.createLogLogLogUnitBaseElectroionizationSubshellDistribution(
native_data, shell, binding_energy, tol)
if scheme == "Unit-base Correlated":
dist = Collision.createLogLogLogUnitBaseCorrelatedElectroionizationSubshellDistribution(
native_data, shell, binding_energy, tol)
if scheme == "Correlated":
dist = Collision.createLogLogLogCorrelatedElectroionizationSubshellDistribution(
native_data, shell, binding_energy, tol)
elif interp == "LinLinLin":
if scheme == "Unit-base":
dist = Collision.createLinLinLinUnitBaseElectroionizationSubshellDistribution(
native_data, shell, binding_energy, tol)
elif scheme == "Unit-base Correlated":
dist = Collision.createLinLinLinUnitBaseCorrelatedElectroionizationSubshellDistribution(
native_data, shell, binding_energy, tol)
elif scheme == "Correlated":
dist = Collision.createLinLinLinCorrelatedElectroionizationSubshellDistribution(
for z in elements:
print "\n----------------------------"
print "-----", z, "Tests -----"
print "----------------------------"
data_list = cs_list.get(z)
file_name = datadir + data_list.get('electroatomic_file_path')
native_data = Native.ElectronPhotonRelaxationDataContainer(file_name)
energy_grid = native_data.getElectronEnergyGrid()
tot_elastic_cs = native_data.getTotalElasticCrossSection()
cutoff_cross_sections = native_data.getCutoffElasticCrossSection()
screen_rutherford_cs = native_data.getScreenedRutherfordElasticCrossSection(
)
screen_rutherford_index = native_data.getScreenedRutherfordElasticCrossSectionThresholdEnergyIndex(
)
moment_cross_sections = Collision.createLogLogLogCorrelatedMomentPreservingElasticReaction(
native_data, 0.9, 1e-7)
# if z == 'Pb-Native':
# energies = [1e-5,4e-4,1e5]
# else:
# energies = [1e-5, 1e-3, 1e5 ]
for interp in interps:
print "\n--- ", interp, "Tests ---"
cutoff_dist = Collision.createLogLogLogCorrelatedCutoffElasticDistribution(
native_data, 0.9, 1e-7)
if interp == "LinLinLog":
cutoff_dist = Collision.createLinLinLogCorrelatedCutoffElasticDistribution(
native_data, 0.9, 1e-15)
elif interp == "LinLinLin":
)
adjoint_screen_rutherford_index = adjoint_data.getAdjointScreenedRutherfordElasticCrossSectionThresholdEnergyIndex(
)
adjoint_moment_cs = adjoint_data.getAdjointMomentPreservingCrossSection()
adjoint_moment_index = adjoint_data.getAdjointMomentPreservingCrossSectionThresholdEnergyIndex(
)
adjoint_excitation_cs = adjoint_data.getAdjointAtomicExcitationCrossSection()
adjoint_ionization_cs = adjoint_data.getAdjointElectroionizationCrossSection(1)
adjoint_brem_cs = adjoint_data.getAdjointBremsstrahlungElectronCrossSection()
###
### Coupled Distribution/Reaction Unit Test Check
###
adjoint_dist = Collision.createCoupledElasticDistribution(
adjoint_data, "LinLinLog", "Simplified Union", True, 1e-7)
energy = 6.625e1
cutoff_pdf = adjoint_dist.evaluatePDF(energy, 0.999999)
print cutoff_pdf
max_cdf = adjoint_dist.evaluateCDF(energy, 0.1)
print max_cdf
random_numbers = [0.1, 0.5, 1.0 - 1e-15]
Prng.RandomNumberGenerator.setFakeStream(random_numbers)
print "------------------------------------------------"
print "energy ", energy
print "------------------------------------------------"
E_out, mu = adjoint_dist.sample(energy)
print '1st angle cosine = ', '%.16e' % mu
### Forward Elastic Unit Test Check
### -------------------------------------------------------------------------- ##
name = 'Pb-Native'
data_list = cs_list.get(name)
native_file_name = datadir + data_list.get('electroatomic_file_path')
native_data = Native.ElectronPhotonRelaxationDataContainer(native_file_name)
interps = ["LinLinLin", "LinLinLog"]
energies = [1e-4]
for interp in interps:
print "\n----------------------------"
print "--- ", interp, name, "Tests ---"
print "----------------------------"
hybrid_dist = Collision.createHybridElasticDistribution(
native_data, 0.9, interp, True, 1e-14)
###
### Sample
###
print '\n--- Sampling ---'
for energy in energies:
print "\n\t Energy = ", energy
random_numbers = [0.5, 0.9, 0.95, 1.0 - 1e-15]
Prng.RandomNumberGenerator.setFakeStream(random_numbers)
for rnd in random_numbers:
energy, angle = hybrid_dist.sample(energy)
print "\tsample[", energy, ",", '%.16e' % rnd, "] = ", '%.16e' % angle
### -------------------------------------------------------------------------- ##
def runForwardSimulation( sim_name,
db_path,
geom_name,
num_particles,
incoherent_model_type,
threads,
use_energy_bins = False,
use_native = False,
log_file = None,
enable_relax = True ):
## Initialize the MPI session
session = MPI.GlobalMPISession( len(sys.argv), sys.argv )
# Suppress logging on all procs except for the master (proc=0)
Utility.removeAllLogs()
session.initializeLogs( 0, True )
if not log_file is None:
session.initializeLogs( log_file, 0, True )
## Set the simulation properties
simulation_properties = MonteCarlo.SimulationProperties()
# Simulate photons only
simulation_properties.setParticleMode( MonteCarlo.PHOTON_MODE )
simulation_properties.setIncoherentModelType( incoherent_model_type )
simulation_properties.setNumberOfPhotonHashGridBins( 100 )
# Enable atomic relaxation
if enable_relax:
simulation_properties.setAtomicRelaxationModeOn( MonteCarlo.PHOTON )
else:
simulation_properties.setAtomicRelaxationModeOff( MonteCarlo.PHOTON )
# Set the number of histories to run and the number of rendezvous
simulation_properties.setNumberOfHistories( num_particles )
simulation_properties.setMinNumberOfRendezvous( 10 )
simulation_properties.setNumberOfSnapshotsPerBatch( 10 )
## Set up the materials
database = Data.ScatteringCenterPropertiesDatabase( db_path )
# Extract the properties from the database
c_atom_properties = database.getAtomProperties( Data.ZAID(6000) )
n_atom_properties = database.getAtomProperties( Data.ZAID(7000) )
o_atom_properties = database.getAtomProperties( Data.ZAID(8000) )
na_atom_properties = database.getAtomProperties( Data.ZAID(11000) )
mg_atom_properties = database.getAtomProperties( Data.ZAID(12000) )
al_atom_properties = database.getAtomProperties( Data.ZAID(13000) )
si_atom_properties = database.getAtomProperties( Data.ZAID(14000) )
ar_atom_properties = database.getAtomProperties( Data.ZAID(18000) )
k_atom_properties = database.getAtomProperties( Data.ZAID(19000) )
ca_atom_properties = database.getAtomProperties( Data.ZAID(20000) )
ti_atom_properties = database.getAtomProperties( Data.ZAID(22000) )
mn_atom_properties = database.getAtomProperties( Data.ZAID(25000) )
fe_atom_properties = database.getAtomProperties( Data.ZAID(26000) )
# Set the atom definitions
scattering_center_definitions = Collision.ScatteringCenterDefinitionDatabase()
c_atom_definition = scattering_center_definitions.createDefinition( "C", Data.ZAID(6000) )
n_atom_definition = scattering_center_definitions.createDefinition( "N", Data.ZAID(7000) )
o_atom_definition = scattering_center_definitions.createDefinition( "O", Data.ZAID(8000) )
na_atom_definition = scattering_center_definitions.createDefinition( "Na", Data.ZAID(11000) )
mg_atom_definition = scattering_center_definitions.createDefinition( "Mg", Data.ZAID(12000) )
al_atom_definition = scattering_center_definitions.createDefinition( "Al", Data.ZAID(13000) )
si_atom_definition = scattering_center_definitions.createDefinition( "Si", Data.ZAID(14000) )
ar_atom_definition = scattering_center_definitions.createDefinition( "Ar", Data.ZAID(18000) )
k_atom_definition = scattering_center_definitions.createDefinition( "K", Data.ZAID(19000) )
ca_atom_definition = scattering_center_definitions.createDefinition( "Ca", Data.ZAID(20000) )
ti_atom_definition = scattering_center_definitions.createDefinition( "Ti", Data.ZAID(22000) )
mn_atom_definition = scattering_center_definitions.createDefinition( "Mn", Data.ZAID(25000) )
fe_atom_definition = scattering_center_definitions.createDefinition( "Fe", Data.ZAID(26000) )
if use_native:
data_file_type = Data.PhotoatomicDataProperties.Native_EPR_FILE
file_version = 0
else:
data_file_type = Data.PhotoatomicDataProperties.ACE_EPR_FILE
file_version = 12
c_atom_definition.setPhotoatomicDataProperties( c_atom_properties.getSharedPhotoatomicDataProperties( data_file_type, file_version ) )
n_atom_definition.setPhotoatomicDataProperties( n_atom_properties.getSharedPhotoatomicDataProperties( data_file_type, file_version ) )
o_atom_definition.setPhotoatomicDataProperties( o_atom_properties.getSharedPhotoatomicDataProperties( data_file_type, file_version ) )
na_atom_definition.setPhotoatomicDataProperties( na_atom_properties.getSharedPhotoatomicDataProperties( data_file_type, file_version ) )
mg_atom_definition.setPhotoatomicDataProperties( mg_atom_properties.getSharedPhotoatomicDataProperties( data_file_type, file_version ) )
al_atom_definition.setPhotoatomicDataProperties( al_atom_properties.getSharedPhotoatomicDataProperties( data_file_type, file_version ) )
si_atom_definition.setPhotoatomicDataProperties( si_atom_properties.getSharedPhotoatomicDataProperties( data_file_type, file_version ) )
ar_atom_definition.setPhotoatomicDataProperties( ar_atom_properties.getSharedPhotoatomicDataProperties( data_file_type, file_version ) )
k_atom_definition.setPhotoatomicDataProperties( k_atom_properties.getSharedPhotoatomicDataProperties( data_file_type, file_version ) )
ca_atom_definition.setPhotoatomicDataProperties( ca_atom_properties.getSharedPhotoatomicDataProperties( data_file_type, file_version ) )
ti_atom_definition.setPhotoatomicDataProperties( ti_atom_properties.getSharedPhotoatomicDataProperties( data_file_type, file_version ) )
mn_atom_definition.setPhotoatomicDataProperties( mn_atom_properties.getSharedPhotoatomicDataProperties( data_file_type, file_version ) )
fe_atom_definition.setPhotoatomicDataProperties( fe_atom_properties.getSharedPhotoatomicDataProperties( data_file_type, file_version ) )
# Set the definition for material 1 (ave soil US from PNNL-15870 Rev1)
material_definitions = Collision.MaterialDefinitionDatabase()
material_definitions.addDefinition( "Soil", 1, ["O", "Na", "Mg", "Al", "Si", "K", "Ca", "Ti", "Mn", "Fe"], [0.670604, 0.005578, 0.011432, 0.053073, 0.201665, 0.007653, 0.026664, 0.002009, 0.000272, 0.021050] )
material_definitions.addDefinition( "Air", 2, ["C", "N", "O", "Ar"], [0.000150, 0.784431, 0.231781, 0.004671] )
# Set up the geometry
model_properties = DagMC.DagMCModelProperties( geom_name )
model_properties.setMaterialPropertyName( "mat" )
model_properties.setDensityPropertyName( "rho" )
model_properties.setTerminationCellPropertyName( "termination.cell" )
model_properties.setReflectingSurfacePropertyName( "reflecting.surface" )
model_properties.setSurfaceFluxName( "surface.flux" )
model_properties.useFastIdLookup()
# Load the model
model = DagMC.DagMCModel( model_properties )
# Fill the model with the defined material
filled_model = Collision.FilledGeometryModel( db_path, scattering_center_definitions, material_definitions, simulation_properties, model, True )
# Set up the source
particle_distribution = ActiveRegion.StandardParticleDistribution( "contaminated soil dist" )
decay_energy_dist = Distribution.DiscreteDistribution( [0.186211, 0.241995, 0.2656, 0.2952228, 0.3046, 0.3519321, 0.60932, 0.6496, 0.665447, 0.76836, 0.78596, 0.80618, 0.934056, 1.120294, 1.15521, 1.238122, 1.280976, 1.377669, 1.401515, 1.407988, 1.50921, 1.661274, 1.729595, 1.764491, 1.847429, 2.118514, 2.204059, 2.44770],
[3.64, 7.251, 51.0, 18.42, 28.0, 35.60, 45.49, 3.4, 1.531, 4.894, 1.06, 1.264, 3.107, 14.92, 1.633, 5.834, 1.434, 3.988, 1.330, 2.394, 2.130, 1.047, 2.878, 15.30, 2.025, 1.160, 4.924, 1.548] )
energy_dimension_dist = ActiveRegion.IndependentEnergyDimensionDistribution( decay_energy_dist )
particle_distribution.setDimensionDistribution( energy_dimension_dist )
uniform_xy_position_dist = Distribution.UniformDistribution( -5.0, 5.0 )
uniform_z_position_dist = Distribution.UniformDistribution( 5000, 5100 )
x_position_dimension_dist = ActiveRegion.IndependentPrimarySpatialDimensionDistribution( uniform_xy_position_dist )
y_position_dimension_dist = ActiveRegion.IndependentSecondarySpatialDimensionDistribution( uniform_xy_position_dist )
z_position_dimension_dist = ActiveRegion.IndependentTertiarySpatialDimensionDistribution( uniform_z_position_dist )
particle_distribution.setDimensionDistribution( x_position_dimension_dist )
particle_distribution.setDimensionDistribution( y_position_dimension_dist )
particle_distribution.setDimensionDistribution( z_position_dimension_dist )
particle_distribution.constructDimensionDistributionDependencyTree()
# The generic distribution will be used to generate photons
photon_distribution = ActiveRegion.StandardPhotonSourceComponent( 0, 1.0, model, particle_distribution )
# Assign the photon source component to the source
source = ActiveRegion.StandardParticleSource( [photon_distribution] )
# Set up the event handler
event_handler = Event.EventHandler( model, simulation_properties )
# Create the estimator response functions (flux-to-effective dose from
# ICRP-116 table A.1, ISO values)
flux_to_dose_dist = Distribution.TabularDistribution_LinLin( [0.01, 0.015, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.1, 0.15, 0.2, 0.3, 0.4, 0.5, 0.511, 0.6, 0.662, 0.8, 1.0, 1.117, 1.33, 1.5, 2.0, 3.0],
[0.0288, 0.0560, 0.0812, 0.127, 0.158, 0.180, 0.199, 0.218, 0.239, 0.287, 0.429, 0.589, 0.932, 1.28, 1.63, 1.67, 1.97, 2.17, 2.62, 3.25, 3.60, 4.20, 4.66, 5.90, 8.08] )
partial_response_function = ActiveRegion.EnergyParticleResponseFunction( flux_to_dose_dist )
# convert from pSv to nSv
response_function = partial_response_function / 1000.0
response = ActiveRegion.StandardParticleResponse( response_function )
source_norm = 1462129.344
# Create the surface flux estimator
surface_flux_estimator = Event.WeightMultipliedSurfaceFluxEstimator( 1, source_norm, [13], model )
surface_flux_estimator.setParticleTypes( [MonteCarlo.PHOTON] )
surface_flux_estimator.setCosineCutoffValue( 0.1 )
surface_flux_estimator.setResponseFunctions( [response] )
event_handler.addEstimator( surface_flux_estimator )
# Create the second surface flux estimator
if use_energy_bins:
surface_flux_estimator_2 = Event.WeightMultipliedSurfaceFluxEstimator( 2, source_norm, [13], model )
surface_flux_estimator_2.setEnergyDiscretization( energy_bins )
surface_flux_estimator_2.setParticleTypes( [MonteCarlo.PHOTON] )
surface_flux_estimator_2.setCosineCutoffValue( 0.1 )
surface_flux_estimator_2.setResponseFunctions( [response] )
event_handler.addEstimator( surface_flux_estimator_2 )
# Set up the simulation manager
factory = Manager.ParticleSimulationManagerFactory( filled_model,
source,
event_handler,
simulation_properties,
sim_name,
"xml",
threads )
# Create the simulation manager
manager = factory.getManager()
manager.useSingleRendezvousFile()
# Allow logging on all procs
session.restoreOutputStreams()
## Run the simulation
if session.size() == 1:
manager.runInterruptibleSimulation()
else:
manager.runSimulation()
def runBroomstickSimulation(sim_name,
db_path,
num_particles,
incoherent_model_type,
source_energy,
energy_bins,
threads,
log_file=None):
## Initialize the MPI session
session = MPI.GlobalMPISession(len(sys.argv), sys.argv)
# Suppress logging on all procs except for the master (proc=0)
Utility.removeAllLogs()
session.initializeLogs(0, True)
if not log_file is None:
session.initializeLogs(log_file, 0, True)
## Set the simulation properties
simulation_properties = MonteCarlo.SimulationProperties()
# Simulate photons only
simulation_properties.setParticleMode(MonteCarlo.PHOTON_MODE)
simulation_properties.setIncoherentModelType(incoherent_model_type)
simulation_properties.setNumberOfPhotonHashGridBins(100)
# Set the number of histories to run and the number of rendezvous
simulation_properties.setNumberOfHistories(num_particles)
simulation_properties.setMinNumberOfRendezvous(100)
simulation_properties.setNumberOfSnapshotsPerBatch(1)
## Set up the materials
database = Data.ScatteringCenterPropertiesDatabase(db_path)
# Extract the properties for H from the database
atom_properties = database.getAtomProperties(Data.ZAID(82000))
# Set the definition for H for this simulation
scattering_center_definitions = Collision.ScatteringCenterDefinitionDatabase(
)
atom_definition = scattering_center_definitions.createDefinition(
"Pb", Data.ZAID(82000))
if incoherent_model_type == MonteCarlo.IMPULSE_INCOHERENT_MODEL or incoherent_model_type == MonteCarlo.FULL_PROFILE_DB_IMPULSE_INCOHERENT_MODEL:
atom_definition.setPhotoatomicDataProperties(
atom_properties.getSharedPhotoatomicDataProperties(
Data.PhotoatomicDataProperties.Native_EPR_FILE, 0))
else:
atom_definition.setPhotoatomicDataProperties(
atom_properties.getSharedPhotoatomicDataProperties(
Data.PhotoatomicDataProperties.ACE_EPR_FILE, 12))
# Set the definition for material 1
material_definitions = Collision.MaterialDefinitionDatabase()
material_definitions.addDefinition("Pb", 1, ["Pb"], [1.0])
## Set up the geometry
model_properties = DagMC.DagMCModelProperties("broomstick.h5m")
model_properties.setMaterialPropertyName("mat")
model_properties.setDensityPropertyName("rho")
model_properties.setTerminationCellPropertyName("termination.cell")
model_properties.setSurfaceFluxName("surface.flux")
model_properties.setSurfaceCurrentName("surface.current")
model_properties.useFastIdLookup()
# Load the model
model = DagMC.DagMCModel(model_properties)
# Fill the model with the defined material
filled_model = Collision.FilledGeometryModel(
db_path, scattering_center_definitions, material_definitions,
simulation_properties, model, True)
## Set up the source
particle_distribution = ActiveRegion.StandardParticleDistribution(
"mono-directional mono-energetic dist")
particle_distribution.setEnergy(source_energy)
particle_distribution.setPosition(0.0, 0.0, -500.1)
particle_distribution.setDirection(0.0, 0.0, 1.0)
particle_distribution.constructDimensionDistributionDependencyTree()
# The generic distribution will be used to generate photons
photon_distribution = ActiveRegion.StandardPhotonSourceComponent(
0, 1.0, model, particle_distribution)
# Assign the photon source component to the source
source = ActiveRegion.StandardParticleSource([photon_distribution])
## Set up the event handler
event_handler = Event.EventHandler(model, simulation_properties)
# Set the energy and collision number bins in estimator 1
event_handler.getEstimator(1).setEnergyDiscretization(energy_bins)
event_handler.getEstimator(1).setCollisionNumberDiscretization([0, 1, 10])
# Set the energy and collision number bins in estimator 2
event_handler.getEstimator(2).setEnergyDiscretization(energy_bins)
event_handler.getEstimator(2).setCollisionNumberDiscretization([0, 1, 10])
## Set up the simulation manager
factory = Manager.ParticleSimulationManagerFactory(filled_model, source,
event_handler,
simulation_properties,
sim_name, "xml",
threads)
# Create the simulation manager
manager = factory.getManager()
manager.useSingleRendezvousFile()
# Allow logging on all procs
session.restoreOutputStreams()
## Run the simulation
if session.size() == 1:
manager.runInterruptibleSimulation()
else:
manager.runSimulation()
def runAdjointSimulation( sim_name,
db_path,
geom_name,
num_particles,
incoherent_model_type,
threads,
use_energy_bins = False,
log_file= None ):
## Initialize the MPI session
session = MPI.GlobalMPISession( len(sys.argv), sys.argv )
# Suppress logging on all procs except for the master (proc=0)
Utility.removeAllLogs()
session.initializeLogs( 0, True )
if not log_file is None:
session.initializeLogs( log_file, 0, True )
## Set the simulation properties
simulation_properties = MonteCarlo.SimulationProperties()
# Simulate photons only
simulation_properties.setParticleMode( MonteCarlo.ADJOINT_PHOTON_MODE )
simulation_properties.setIncoherentAdjointModelType( incoherent_model_type )
simulation_properties.setMinAdjointPhotonEnergy( 1e-3 )
if incoherent_model_type == MonteCarlo.DB_IMPULSE_INCOHERENT_ADJOINT_MODEL:
simulation_properties.setMaxAdjointPhotonEnergy( energy_bins[-1]*1.5 )
else:
simulation_properties.setMaxAdjointPhotonEnergy( energy_bins[-1] )
simulation_properties.setCriticalAdjointPhotonLineEnergies( [0.186211, 0.241995, 0.2656, 0.2952228, 0.3046, 0.3519321, 0.60932, 0.6496, 0.665447, 0.76836, 0.78596, 0.80618, 0.934056, 1.120294, 1.15521, 1.238122, 1.280976, 1.377669, 1.401515, 1.407988, 1.50921, 1.661274, 1.729595, 1.764491, 1.847429, 2.118514, 2.204059, 2.44770] )
simulation_properties.setAdjointPhotonRouletteThresholdWeight( 0.0025 )
simulation_properties.setAdjointPhotonRouletteSurvivalWeight( 0.005 )
simulation_properties.setNumberOfAdjointPhotonHashGridBins( 100 )
# Set the number of histories to run and the number of rendezvous
simulation_properties.setNumberOfHistories( num_particles )
simulation_properties.setMinNumberOfRendezvous( 100 )
simulation_properties.setNumberOfSnapshotsPerBatch( 1 )
## Set up the materials
database = Data.ScatteringCenterPropertiesDatabase( db_path )
# Extract the properties from the database
c_atom_properties = database.getAtomProperties( Data.ZAID(6000) )
n_atom_properties = database.getAtomProperties( Data.ZAID(7000) )
o_atom_properties = database.getAtomProperties( Data.ZAID(8000) )
na_atom_properties = database.getAtomProperties( Data.ZAID(11000) )
mg_atom_properties = database.getAtomProperties( Data.ZAID(12000) )
al_atom_properties = database.getAtomProperties( Data.ZAID(13000) )
si_atom_properties = database.getAtomProperties( Data.ZAID(14000) )
ar_atom_properties = database.getAtomProperties( Data.ZAID(18000) )
k_atom_properties = database.getAtomProperties( Data.ZAID(19000) )
ca_atom_properties = database.getAtomProperties( Data.ZAID(20000) )
ti_atom_properties = database.getAtomProperties( Data.ZAID(22000) )
mn_atom_properties = database.getAtomProperties( Data.ZAID(25000) )
fe_atom_properties = database.getAtomProperties( Data.ZAID(26000) )
# Set the atom definitions
scattering_center_definitions = Collision.ScatteringCenterDefinitionDatabase()
c_atom_definition = scattering_center_definitions.createDefinition( "C", Data.ZAID(6000) )
n_atom_definition = scattering_center_definitions.createDefinition( "N", Data.ZAID(7000) )
o_atom_definition = scattering_center_definitions.createDefinition( "O", Data.ZAID(8000) )
na_atom_definition = scattering_center_definitions.createDefinition( "Na", Data.ZAID(11000) )
mg_atom_definition = scattering_center_definitions.createDefinition( "Mg", Data.ZAID(12000) )
al_atom_definition = scattering_center_definitions.createDefinition( "Al", Data.ZAID(13000) )
si_atom_definition = scattering_center_definitions.createDefinition( "Si", Data.ZAID(14000) )
ar_atom_definition = scattering_center_definitions.createDefinition( "Ar", Data.ZAID(18000) )
k_atom_definition = scattering_center_definitions.createDefinition( "K", Data.ZAID(19000) )
ca_atom_definition = scattering_center_definitions.createDefinition( "Ca", Data.ZAID(20000) )
ti_atom_definition = scattering_center_definitions.createDefinition( "Ti", Data.ZAID(22000) )
mn_atom_definition = scattering_center_definitions.createDefinition( "Mn", Data.ZAID(25000) )
fe_atom_definition = scattering_center_definitions.createDefinition( "Fe", Data.ZAID(26000) )
data_file_type = Data.AdjointPhotoatomicDataProperties.Native_EPR_FILE
file_version = 0
c_atom_definition.setAdjointPhotoatomicDataProperties( c_atom_properties.getSharedAdjointPhotoatomicDataProperties( data_file_type, file_version ) )
n_atom_definition.setAdjointPhotoatomicDataProperties( n_atom_properties.getSharedAdjointPhotoatomicDataProperties( data_file_type, file_version ) )
o_atom_definition.setAdjointPhotoatomicDataProperties( o_atom_properties.getSharedAdjointPhotoatomicDataProperties( data_file_type, file_version ) )
na_atom_definition.setAdjointPhotoatomicDataProperties( na_atom_properties.getSharedAdjointPhotoatomicDataProperties( data_file_type, file_version ) )
mg_atom_definition.setAdjointPhotoatomicDataProperties( mg_atom_properties.getSharedAdjointPhotoatomicDataProperties( data_file_type, file_version ) )
al_atom_definition.setAdjointPhotoatomicDataProperties( al_atom_properties.getSharedAdjointPhotoatomicDataProperties( data_file_type, file_version ) )
si_atom_definition.setAdjointPhotoatomicDataProperties( si_atom_properties.getSharedAdjointPhotoatomicDataProperties( data_file_type, file_version ) )
ar_atom_definition.setAdjointPhotoatomicDataProperties( ar_atom_properties.getSharedAdjointPhotoatomicDataProperties( data_file_type, file_version ) )
k_atom_definition.setAdjointPhotoatomicDataProperties( k_atom_properties.getSharedAdjointPhotoatomicDataProperties( data_file_type, file_version ) )
ca_atom_definition.setAdjointPhotoatomicDataProperties( ca_atom_properties.getSharedAdjointPhotoatomicDataProperties( data_file_type, file_version ) )
ti_atom_definition.setAdjointPhotoatomicDataProperties( ti_atom_properties.getSharedAdjointPhotoatomicDataProperties( data_file_type, file_version ) )
mn_atom_definition.setAdjointPhotoatomicDataProperties( mn_atom_properties.getSharedAdjointPhotoatomicDataProperties( data_file_type, file_version ) )
fe_atom_definition.setAdjointPhotoatomicDataProperties( fe_atom_properties.getSharedAdjointPhotoatomicDataProperties( data_file_type, file_version ) )
# Set the definition for material 1 (ave soil US from PNNL-15870 Rev1)
material_definitions = Collision.MaterialDefinitionDatabase()
material_definitions.addDefinition( "Soil", 1, ["O", "Na", "Mg", "Al", "Si", "K", "Ca", "Ti", "Mn", "Fe"], [0.670604, 0.005578, 0.011432, 0.053073, 0.201665, 0.007653, 0.026664, 0.002009, 0.000272, 0.021050] )
material_definitions.addDefinition( "Air", 2, ["C", "N", "O", "Ar"], [0.000150, 0.784431, 0.231781, 0.004671] )
# Set up the geometry
model_properties = DagMC.DagMCModelProperties( geom_name )
model_properties.setMaterialPropertyName( "mat" )
model_properties.setDensityPropertyName( "rho" )
model_properties.setTerminationCellPropertyName( "termination.cell" )
model_properties.setReflectingSurfacePropertyName( "reflecting.surface" )
model_properties.setSurfaceFluxName( "surface.flux" )
model_properties.useFastIdLookup()
# Load the model
model = DagMC.DagMCModel( model_properties )
# Fill the model with the defined material
filled_model = Collision.FilledGeometryModel( db_path, scattering_center_definitions, material_definitions, simulation_properties, model, True )
# Set up the source
particle_distribution = ActiveRegion.StandardParticleDistribution( "isotropic point source" )
uniform_energy = Distribution.UniformDistribution( 1e-3, energy_bins[-1] )
energy_dimension_dist = ActiveRegion.IndependentEnergyDimensionDistribution( uniform_energy )
particle_distribution.setDimensionDistribution( energy_dimension_dist )
particle_distribution.setPosition( 0.0, 0.0, 5200.0 )
particle_distribution.constructDimensionDistributionDependencyTree()
# The generic distribution will be used to generate photons
adjoint_photon_distribution = ActiveRegion.StandardAdjointPhotonSourceComponent( 0, 1.0, filled_model, particle_distribution )
# Assign the photon source component to the source
source = ActiveRegion.StandardParticleSource( [adjoint_photon_distribution] )
## Set up the event handler
event_handler = Event.EventHandler( model, simulation_properties )
# Create the discrete forward source line energy response function
discrete_energy_response_function = ActiveRegion.EnergyParticleResponseFunction( Distribution.DiscreteDistribution( [0.186211, 0.241995, 0.2656, 0.2952228, 0.3046, 0.3519321, 0.60932, 0.6496, 0.665447, 0.76836, 0.78596, 0.80618, 0.934056, 1.120294, 1.15521, 1.238122, 1.280976, 1.377669, 1.401515, 1.407988, 1.50921, 1.661274, 1.729595, 1.764491, 1.847429, 2.118514, 2.204059, 2.44770],
[0.013622652525055947, 0.02713677292834634, 0.1908668348290806, 0.068936609755915, 0.10478963480812267, 0.13323253568461313, 0.17024573169362503, 0.012724455655272039, 0.0057297475318298504, 0.01831573116967687, 0.00396703617487893, 0.004730503514195252, 0.011627906976744184, 0.05583790540489965, 0.006111481201488011, 0.021833668909663845, 0.005366726296958854, 0.014925037986242614, 0.004977507653385827, 0.00895951377609449, 0.007971497219332189, 0.003918383844432301, 0.010770877463492038, 0.057260050448724176, 0.007578536088801728, 0.004341284870622224, 0.01842800577839986, 0.005793369810106211] ) )
# Create the flux-to-effective dose from ICRP-116 table A.1, ISO values)
flux_to_dose_response_function = ActiveRegion.SourceEnergyParticleResponseFunction( Distribution.TabularDistribution_LinLin( [0.01, 0.015, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.1, 0.15, 0.2, 0.3, 0.4, 0.5, 0.511, 0.6, 0.662, 0.8, 1.0, 1.117, 1.33, 1.5, 2.0, 3.0],
[0.0288, 0.0560, 0.0812, 0.127, 0.158, 0.180, 0.199, 0.218, 0.239, 0.287, 0.429, 0.589, 0.932, 1.28, 1.63, 1.67, 1.97, 2.17, 2.62, 3.25, 3.60, 4.20, 4.66, 5.90, 8.08] ) )
# Create the complete response function
response = ActiveRegion.StandardParticleResponse( discrete_energy_response_function*flux_to_dose_response_function/1000.0 )
source_norm = 1462129.344*(energy_bins[-1] - 1e-3)
# Create the cell track-length flux estimator
cell_flux_estimator = Event.WeightMultipliedCellTrackLengthFluxEstimator( 1, source_norm, [2], model )
cell_flux_estimator.setParticleTypes( [MonteCarlo.ADJOINT_PHOTON] )
cell_flux_estimator.setResponseFunctions( [response] )
event_handler.addEstimator( cell_flux_estimator )
# Create the second estimator
if use_energy_bins:
cell_flux_estimator_2 = Event.WeightMultipliedCellTrackLengthFluxEstimator( 2, source_norm, [2], model )
cell_flux_estimator_2.setSourceEnergyDiscretization( energy_bins )
cell_flux_estimator_2.setParticleTypes( [MonteCarlo.ADJOINT_PHOTON] )
cell_flux_estimator_2.setResponseFunctions( [response] )
event_handler.addEstimator( cell_flux_estimator_2 )
# Set up the simulation manager
factory = Manager.ParticleSimulationManagerFactory( filled_model,
source,
event_handler,
simulation_properties,
sim_name,
"xml",
threads )
# Create the simulation manager
manager = factory.getManager()
manager.useSingleRendezvousFile()
# Allow logging on all procs
session.restoreOutputStreams()
## Run the simulation
if session.size() == 1:
manager.runInterruptibleSimulation()
else:
manager.runSimulation()
file_name = datadir + data_list.get('electroatomic_file_path')
native_data = Native.ElectronPhotonRelaxationDataContainer(file_name)
energy_grid = native_data.getElectronEnergyGrid()
###
### Electroionization Reaction Unit Test Check
###
print "\n----- C -----"
subshells = native_data.getSubshells()
shell = subshells[0]
binding_energy = native_data.getSubshellBindingEnergy(shell)
ionization_cs = native_data.getElectroionizationCrossSection(shell)
threshold = native_data.getElectroionizationCrossSectionThresholdEnergyIndex(
shell)
ionization_dist = Collision.createLinLinLogUnitBaseCorrelatedElectroionizationSubshellDistribution(
native_data, shell, binding_energy, 1e-15)
print "\nshell = ", shell
energies = [
1.70425200079801E-03, 1.70425200079802E-03, 1.98284583249127E-03,
2.00191878322064E-03
]
e_outs = [
8.52126000399011E-04, 8.52126000399011E-04, 8.52126000399011E-04,
8.52126000399011E-04
]
for i in range(0, len(energies)):
energy = energies[i]
e_out = e_outs[i]
#datadir = '/home/software/mcnpdata/'
datadir = '/home/lkersting/frensie/src/packages/test_files/'
source = Teuchos.FileInputSource(datadir + '/cross_sections.xml')
xml_obj = source.getObject()
cs_list = Teuchos.XMLParameterListReader().toParameterList(xml_obj)
data_list = cs_list.get('Al-Native')
### -------------------------------------------------------------------------- ##
### Forward Elastic Unit Test Check
### -------------------------------------------------------------------------- ##
native_file_name = datadir + data_list.get('electroatomic_file_path')
native_data = Native.ElectronPhotonRelaxationDataContainer(native_file_name)
###
### Analog vs Cutoff DCS
###
cutoff_reaction = Collision.createCutoffElasticReaction(
native_data, 1.0, True, True, 1e-15)
analog_reaction = Collision.createAnalogElasticReaction(
native_data, True, True, 1e-15)
energy = 15.7
cosines = numpy.linspace(-1.0, 0.999999, 100)
for cosine in cosines:
analog_dcs = analog_reaction.getDifferentialCrossSection(1e-5, cosine)
cutoff_dcs = cutoff_reaction.getDifferentialCrossSection(1e-5, cosine)
diff = analog_dcs - cutoff_dcs
print "difference (", cosine, ") =", diff
print "\n----- H -----\n"
tot_adjoint_elastic_cs = adjoint_data.getAdjointTotalElasticCrossSection()
reduced_cutoff_ratio = adjoint_data.getReducedCutoffCrossSectionRatios()
adjoint_cutoff_cs = adjoint_data.getAdjointCutoffElasticCrossSection()
adjoint_rutherford_cs = adjoint_data.getAdjointScreenedRutherfordElasticCrossSection(
)
adjoint_sr_index = adjoint_data.getAdjointScreenedRutherfordElasticCrossSectionThresholdEnergyIndex(
)
angular_energy_grid = adjoint_data.getAdjointElasticAngularEnergyGrid()
moment_cs_reduction = adjoint_data.getAdjointMomentPreservingCrossSectionReduction(
)
subshells = adjoint_data.getSubshells()
shell = subshells[0]
adjoint_ionization_cs = adjoint_data.getAdjointElectroionizationCrossSection(
shell)
adjoint_cutoff_dist = Collision.createLogLogLogCorrelatedCutoffElasticDistribution(
adjoint_data, 0.9, 1e-7)
adjoint_mp_reaction = Collision.createLogLogLogCorrelatedMomentPreservingElasticReaction(
adjoint_data, 0.9, 1e-7)
adjoint_hybrid_reaction = Collision.createLogLogLogCorrelatedHybridElasticReaction(
adjoint_data, 0.9, 1e-7)
adjoint_hybrid_dist = Collision.createLogLogLogCorrelatedHybridElasticDistribution(
adjoint_data, 0.9, 1e-7)
adjoint_cutoff_reaction = Collision.createLogLogLogCorrelatedCutoffElasticReaction(
adjoint_data, 0.9, 1e-7)
energies = [1e-5, 1e-3, 20.0]
#energies = [1.0, 10.0, 20.0]
for energy in energies:
index = 0
for i in range(0, adjoint_energy_grid.size):
if adjoint_energy_grid[i] <= energy:
def runSimulation(threads, histories, time):
##--------------------------------------------------------------------------##
## ------------------------------ MPI Session ----------------------------- ##
##--------------------------------------------------------------------------##
session = MPI.GlobalMPISession(len(sys.argv), sys.argv)
Utility.removeAllLogs()
session.initializeLogs(0, True)
properties = setSimulationProperties(histories, time)
name, title = setSimulationName(properties)
path_to_database = database_path
path_to_geometry = geometry_path
##--------------------------------------------------------------------------##
## ---------------------------- GEOMETRY SETUP ---------------------------- ##
##--------------------------------------------------------------------------##
# Set geometry path and type
geometry_type = "DagMC" #(ROOT or DAGMC)
# Set geometry model properties
if geometry_type == "DagMC":
model_properties = DagMC.DagMCModelProperties(path_to_geometry)
model_properties.useFastIdLookup()
# model_properties.setMaterialPropertyName( "mat" )
# model_properties.setDensityPropertyName( "rho" )
# model_properties.setTerminationCellPropertyName( "graveyard" )
# model_properties.setEstimatorPropertyName( "tally" )
else:
print "ERROR: geometry type ", geometry_type, " not supported!"
# Construct model
geom_model = DagMC.DagMCModel(model_properties)
##--------------------------------------------------------------------------##
## -------------------------- EVENT HANDLER SETUP ------------------------- ##
##--------------------------------------------------------------------------##
# Set event handler
event_handler = Event.EventHandler(properties)
## -------------------- Charge Deposition Calorimeter --------------------- ##
number_of_subzones = 40
# Setup a cell pulse height estimator
estimator_id = 1
cell_ids = range(1, number_of_subzones + 1)
charge_deposition_estimator = Event.WeightAndChargeMultipliedCellPulseHeightEstimator(
estimator_id, 1.0, cell_ids)
# Set the particle type
charge_deposition_estimator.setParticleTypes([MonteCarlo.ELECTRON])
# Add the estimator to the event handler
event_handler.addEstimator(charge_deposition_estimator)
##--------------------------------------------------------------------------##
## ----------------------- SIMULATION MANAGER SETUP ------------------------ ##
##--------------------------------------------------------------------------##
# Initialized database
database = Data.ScatteringCenterPropertiesDatabase(path_to_database)
scattering_center_definition_database = Collision.ScatteringCenterDefinitionDatabase(
)
# Set material properties
version = 0
if file_type == Data.ElectroatomicDataProperties.ACE_EPR_FILE:
version = 14
# Definition for Aluminum
if material == "Al":
al_properties = database.getAtomProperties(Data.Al_ATOM)
al_definition = scattering_center_definition_database.createDefinition(
material, Data.ZAID(13000))
al_definition.setElectroatomicDataProperties(
al_properties.getSharedElectroatomicDataProperties(
file_type, version))
elif material == "Be":
be_properties = database.getAtomProperties(Data.Be_ATOM)
be_definition = scattering_center_definition_database.createDefinition(
material, Data.ZAID(4000))
be_definition.setElectroatomicDataProperties(
be_properties.getSharedElectroatomicDataProperties(
file_type, version))
else:
print "ERROR: material ", material, " is currently not supported!"
definition = ((material, 1.0), )
material_definition_database = Collision.MaterialDefinitionDatabase()
material_definition_database.addDefinition(material, 1, definition)
# Fill model
model = Collision.FilledGeometryModel(
path_to_database, scattering_center_definition_database,
material_definition_database, properties, geom_model, True)
# Set the source energy (14.9 MeV)
energy = 14.9
# Set particle distribution
particle_distribution = ActiveRegion.StandardParticleDistribution(
"source distribution")
# Set the energy dimension distribution
delta_energy = Distribution.DeltaDistribution(energy)
energy_dimension_dist = ActiveRegion.IndependentEnergyDimensionDistribution(
delta_energy)
particle_distribution.setDimensionDistribution(energy_dimension_dist)
# Set the direction dimension distribution
particle_distribution.setDirection(0.0, 0.0, 1.0)
# Set the spatial dimension distribution
particle_distribution.setPosition(0.0, 0.0, -0.01)
particle_distribution.constructDimensionDistributionDependencyTree()
# Set source components
source_component = [
ActiveRegion.StandardElectronSourceComponent(0, 1.0, geom_model,
particle_distribution)
]
# Set source
source = ActiveRegion.StandardParticleSource(source_component)
# Set the archive type
archive_type = "xml"
factory = Manager.ParticleSimulationManagerFactory(model, source,
event_handler,
properties, name,
archive_type, threads)
manager = factory.getManager()
Utility.removeAllLogs()
session.initializeLogs(0, False)
manager.runSimulation()
if session.rank() == 0:
print "Processing the results:"
processData(charge_deposition_estimator, name, title,
subzone_width * density)
print "Results will be in ", path.dirname(name)
energy_0 = adjoint_energy_grid[index] cs_0 = adjoint_brem_cs[index] energy_1 = adjoint_energy_grid[index+1] cs_1 = adjoint_brem_cs[index+1] print "energy = ", energy cs = cs_0 + (cs_1 - cs_0)*( energy - energy_0 )/( energy_1 - energy_0 ) print '\tcs = ','%.16e' % cs energy = 20.0 print "energy = ", energy print '\tcs = ','%.16e' % adjoint_brem_cs[adjoint_brem_cs.size -1] brem_dist = Collision.createLogLogLogUnitBaseCorrelatedBremsstrahlungDistribution(adjoint_data, 1e-7) E_in = [1e-6, 1e-5, 1.1e-5, 20.0, 21.0] E_out = [2.0e-5, 20.2, 1.0, 20.000000201, 22.0] print "\nEvaluate[ E_in, E_out]" for i in range(0,len(E_in)): pdf = brem_dist.evaluate( E_in[i], E_out[i] ) print "\teval[",E_in[i],",",E_out[i],"] =\t",'%.16e' % pdf print "\nEvaluate PDF[ E_in, E_out]" for i in range(0,len(E_in)): pdf = brem_dist.evaluatePDF( E_in[i], E_out[i] ) print "\teval[",E_in[i],",",E_out[i],"] =\t",'%.16e' % pdf E_in = [1e-6, 1e-5, 1.1e-5, 20.0, 21.0] E_out = [2.0e-5, 10.1000050505, 1.0, 20.1000000505, 22.0]
print shells
binding_energies = [
shell_binding_energies[0],
shell_binding_energies[len(shell_binding_energies) - 1]
]
shells = [subshells[0]]
binding_energies = [shell_binding_energies[0]]
for i in range(0, len(shells)):
shell = int(shells[i])
binding_energy = binding_energies[i]
print "\nshell = ", shell, "\tbinding energy =", binding_energy
print "----------------------------\n"
ionization_dist = Collision.createElectroionizationSubshellDistribution(
ace_data, shell, 1e-7)
print "\n--- evaluateCDF ---\n"
energies = [
binding_energy + 1e-8, binding_energy + 3e-8, 9.12175e-2, 1.0, 1.0,
1e5
]
e_outs = [
1e-8, 1.0001e-8, 4.275e-4, 1.33136131511529e-1, 9.7163e-2,
1.75297e2
]
energies = [1e5, 1e5, 1e5, 1e-3, 1e-3, 1e-3]
e_outs = [1e-5, 1.0, 10.0, 1e-5, 1e-4, 5e-4]