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)
if __name__ == "__main__":
# Parse the command-line arguments
parser = OptionParser()
parser.add_option("-d",
"--db_name",
type="string",
dest="db_name",
default="database.xml",
help="the database file with path")
options, args = parser.parse_args()
if path.exists(options.db_name):
# Open the database
database = Data.ScatteringCenterPropertiesDatabase(options.db_name)
else:
print "ERROR: The file", options.db_name, "doesn't exist!"
sys.exit(1)
print "The PyFrensie path is set to: ", path.dirname(
path.dirname(path.abspath(Data.__file__)))
# Get the atom properties for the zaid
if not database.doAtomPropertiesExist(Data.H_ATOM):
print "The database does not contain the H data"
sys.exit(1)
element_properties = database.getAtomProperties(Data.H_ATOM)
# Check if the native file exists
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 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 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)
# 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 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(
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 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()
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)
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)
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()
#! /usr/bin/env python
import PyFrensie.Data as Data
import PyFrensie.Data.ACE as ACE
import PyFrensie.Utility as Utility
import PyFrensie.Utility.Prng as Prng
import PyFrensie.MonteCarlo.Collision as Collision
import numpy
import matplotlib.pyplot as plt
Utility.initFrensiePrng()
datadir = '/home/software/mcnpdata/'
database_path = datadir + 'database.xml'
database = Data.ScatteringCenterPropertiesDatabase(database_path)
au_properties = database.getAtomProperties(Data.ZAID(79000))
au_electron_prop = au_properties.getSharedElectroatomicDataProperties(
Data.ElectroatomicDataProperties.ACE_EPR_FILE, 14)
file_name = datadir + au_electron_prop.filePath()
table_start = au_electron_prop.fileStartLine()
table_name = au_electron_prop.tableName()
# -------------------------------------------------------------------------- ##
# Electroatom Tests
# -------------------------------------------------------------------------- ##
ace_file = ACE.ACEFileHandler(file_name, table_name, table_start)
xss_extractor = ACE.XSSEPRDataExtractor(ace_file.getTableNXSArray(),
ace_file.getTableJXSArray(),
# 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 ) )
#simulation_properties.setPhotonRouletteSurvivalWeight( survival_weight )
#simulation_properties.setImplicitCaptureModeOn()
#simulation_properties.setIncoherentModelType(MonteCarlo.FULL_PROFILE_DB_IMPULSE_INCOHERENT_MODEL)
model_properties = DagMC.DagMCModelProperties("model.h5m")
model_properties.setMaterialPropertyName( "material" )
model_properties.setDensityPropertyName( "density" )
model_properties.setTerminationCellPropertyName( "termination.cell" )
model_properties.useFastIdLookup()
model = DagMC.DagMCModel( model_properties )
data_file_type = Data.PhotoatomicDataProperties.Native_EPR_FILE
## Set up the materials
database = Data.ScatteringCenterPropertiesDatabase( db_path )
#MATERIAL INFO. MATERIAL IS ASSIGNED IN TRELIS FILE ALONG WITH DENSITY. ZAID IS BELOW.
# Extract the properties for H from the database
H_properties = database.getAtomProperties( Data.ZAID(1000) )
# Set the definition for H, Pb, Mn, Ge for this simulation
scattering_center_definitions = Collision.ScatteringCenterDefinitionDatabase()
H_definition = scattering_center_definitions.createDefinition( "H", Data.ZAID(1000) )
file_version = 0
H_definition.setPhotoatomicDataProperties( H_properties.getSharedPhotoatomicDataProperties( data_file_type, file_version) )
# Set the definition for materials
print "ERROR: geometry type ", geometry_type, " not supprted!"
##---------------------------------------------------------------------------##
## ----------------------- SIMULATION MANAGER SETUP ------------------------ ##
##---------------------------------------------------------------------------##
# Set the number of threads
threads = 1
# Set database directory path.
database_path = "/home/lkersting/frensie/build/packages/database.xml"
# database_path = "/home/alexr/Research/transport/build/packages/database.xml"
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)
print element_properties.photoatomicDataAvailable(
Data.PhotoatomicDataProperties.ACE_EPR_FILE)
element_definition = scattering_center_definition_database.createDefinition(
element, Data.ZAID(zaid))
element_definition.setElectroatomicDataProperties(
element_properties.getSharedElectroatomicDataProperties(
Data.ElectroatomicDataProperties.ACE_EPR_FILE, 14))
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 --------------------- ##
number_of_subzones = 50
# Setup a cell pulse height estimator
estimator_id = 1
cell_ids = range(1, number_of_subzones + 1)
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 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))
definition = (("Al", 1.0), )
else:
h_properties = database.getAtomProperties(Data.H_ATOM)
h_definition = scattering_center_definition_database.createDefinition(
"H", Data.ZAID(1000))
h_definition.setElectroatomicDataProperties(
h_properties.getSharedElectroatomicDataProperties(
file_type, version))
c_properties = database.getAtomProperties(Data.C_ATOM)
c_definition = scattering_center_definition_database.createDefinition(
"C", Data.ZAID(6000))
c_definition.setElectroatomicDataProperties(
c_properties.getSharedElectroatomicDataProperties(
file_type, version))
# Definition for polystyrene
if material == "polystyrene":
definition = (("H", -0.077418), ("C", -0.922582))
# Definition for polyethylene
elif material == "polyethylene":
definition = (("H", -0.14), ("C", -0.86))
else:
print "ERROR: material ", material, " is currently not supported!"
material_definition_database = Collision.MaterialDefinitionDatabase()
material_definition_database.addDefinition(material, 1, definition)
# 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.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"
# 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,
subzone_width * density)
print "Results will be in ", path.dirname(name)