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()
# Set the definition for materials
material_definitions = Collision.MaterialDefinitionDatabase()
material_definitions.addDefinition( "H", 1, ["H"], [1.0] )
filled_model = Collision.FilledGeometryModel( db_path, scattering_center_definitions, material_definitions, simulation_properties, model, True )
#source
particle_distribution = ActiveRegion.StandardParticleDistribution("Forward source")
particle_distribution.setPosition(0, 0, 0)
particle_distribution.setEnergy(20)
particle_distribution.constructDimensionDistributionDependencyTree()
source_component = ActiveRegion.StandardPhotonSourceComponent(1, 1.0, model, particle_distribution)
source = ActiveRegion.StandardParticleSource([source_component])
event_handler = Event.EventHandler( model, simulation_properties )
#I DON'T THINK MCNP HAS THIS KIND OF ESTIMATOR, SO IGNORE IF IT DOESN'T EXIST
cell_integral_estimator = Event.WeightMultipliedCellCollisionFluxEstimator(1, 1.0, [1], model)
cell_integral_estimator.setParticleTypes([MonteCarlo.PHOTON])
event_handler.addEstimator(cell_integral_estimator)
#ESTIMATOR OF INTEREST - TRACK LENGTH ESTIMATOR IN VOLUME 5
cell_integral_tl_estimator = Event.WeightMultipliedCellTrackLengthFluxEstimator(2, 1.0, [1], model)
cell_integral_tl_estimator.setParticleTypes([MonteCarlo.PHOTON])
event_handler.addEstimator(cell_integral_tl_estimator)