parser.add_option("--db_path",
type="string",
dest="db_path",
help="the database name (with extension)")
parser.add_option("--sim_name",
type="string",
dest="sim_name",
default="sphere",
help="the simulation name")
parser.add_option("--log_file",
type="string",
dest="log_file",
help="the file that will be used for logging")
parser.add_option("--num_particles",
type="float",
dest="num_particles",
default=1e3,
help="the number of particles to run")
options, args = parser.parse_args()
if options.db_path is None:
print "The database path must be specified!"
sys.exit(1)
# Run the simulation
runBroomstickSimulation(
options.sim_name, options.db_path, options.num_particles,
MonteCarlo.DECOUPLED_HALF_PROFILE_DB_HYBRID_INCOHERENT_MODEL, 0.2,
Utility.doubleArrayFromString("{1e-3, 998i, 0.2}"), options.threads,
options.log_file)
# Parse the command line options
parser = OptionParser()
parser.add_option("--threads", type="int", dest="threads", default=1,
help="the number of threads to use")
parser.add_option("--db_path", type="string", dest="db_path",
help="the database name (with extension)")
parser.add_option("--sim_name", type="string", dest="sim_name", default="sphere",
help="the simulation name")
parser.add_option("--log_file", type="string", dest="log_file",
help="the file that will be used for logging")
parser.add_option("--num_particles", type="float", dest="num_particles", default=1e3,
help="the number of particles to run")
options,args = parser.parse_args()
if options.db_path is None:
print "The database path must be specified!"
sys.exit(1)
# Run the simulation
runBroomstickSimulation( options.sim_name,
options.db_path,
options.num_particles,
MonteCarlo.IMPULSE_INCOHERENT_MODEL,
1.0,
Utility.doubleArrayFromString( "{1e-3, 998i, 1.0}" ),
options.threads,
options.log_file )
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)
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)
"KO4": 8.82612e-2,
"KO5": 8.8264e-2,
"KP2": 8.8283e-2,
"KP3": 8.82847e-2
}
sorted_x_ray_line_names = [
"KL2", "KL3", "KM2", "KM3", "KM4", "KM5", "KN2", "KN3", "KN4", "KN5",
"KO2", "KO3", "KO4", "KO5", "KP2", "KP3"
]
#energy_bins = list(Utility.doubleArrayFromString( "{1e-3, 499i, 0.1}" ))
#energy_bins = list(Utility.doubleArrayFromString( "{1e-3, 499i, 0.2}" ))
#energy_bins = list(Utility.doubleArrayFromString( "{1e-3, 499i, 0.5}" ))
#energy_bins = list(Utility.doubleArrayFromString( "{1e-3, 499i, 1.0}" ))
energy_bins = list(Utility.doubleArrayFromString("{1e-3, 499i, 10.0}"))
x_ray_line_indices = set()
# Loop through each x-ray line and determine the bin that it falls in
for i in range(0, len(sorted_x_ray_line_names)):
name = sorted_x_ray_line_names[i]
x_ray_energy = x_ray_lines[name]
for j in range(0, len(energy_bins) - 1):
if x_ray_energy > energy_bins[j] and x_ray_energy <= energy_bins[j +
1]:
#print name, "in bin", j, "->", x_ray_energy, energy_bins[j], energy_bins[j+1]
index = 0
if j in x_ray_line_indices:
parser.add_option("--sim_name",
type="string",
dest="sim_name",
default="sphere",
help="the simulation name")
parser.add_option("--log_file",
type="string",
dest="log_file",
help="the file that will be used for logging")
parser.add_option("--num_particles",
type="float",
dest="num_particles",
default=1e3,
help="the number of particles to run")
parser.add_option("--source_energy",
type="float",
dest="source_energy",
default=1.0,
help="the source energy in MeV")
options, args = parser.parse_args()
if options.db_path is None:
print "The database path must be specified!"
sys.exit(1)
# Run the simulation
sphereSimulation(options.sim_name, options.db_path, options.num_particles,
options.source_energy,
Utility.doubleArrayFromString("{1e-9,100l,1.0}"),
options.threads, options.log_file)
parser.add_option("--db_path",
type="string",
dest="db_path",
help="the database name (with extension)")
parser.add_option("--sim_name",
type="string",
dest="sim_name",
default="sphere",
help="the simulation name")
parser.add_option("--log_file",
type="string",
dest="log_file",
help="the file that will be used for logging")
parser.add_option("--num_particles",
type="float",
dest="num_particles",
default=1e3,
help="the number of particles to run")
options, args = parser.parse_args()
if options.db_path is None:
print "The database path must be specified!"
sys.exit(1)
# Run the simulation
runBroomstickSimulation(
options.sim_name, options.db_path, options.num_particles,
MonteCarlo.DECOUPLED_HALF_PROFILE_DB_HYBRID_INCOHERENT_MODEL, 0.1,
Utility.doubleArrayFromString("{1e-3, 988i, 0.0999, 9i, 0.1}"),
options.threads, options.log_file)
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
]
energy_bins = list(Utility.doubleArrayFromString("{1e-3, 998i, 2.44770}"))
gamma_line_indices = set()
# Loop through each gamma line and determine the bin that it falls in
for i in range(0, len(gamma_lines)):
gamma_energy = gamma_lines[i]
for j in range(0, len(energy_bins) - 1):
if gamma_energy > energy_bins[j] and gamma_energy <= energy_bins[j +
1]:
#print name, "in bin", j, "->", gamma_energy, energy_bins[j], energy_bins[j+1]
index = 0
if j in gamma_line_indices:
print "Error: x-ray line energy bin width too large!"
def sphereSimulation( sim_name,
db_path,
num_particles,
temp,
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 )
simulation_properties.setSurfaceFluxEstimatorAngleCosineCutoff( 0.1 )
# 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 )
# Extract the properties for H1 from the database
nuclide_properties = database.getNuclideProperties( Data.ZAID(1001) )
# Set the definition of H1 for this simulation
scattering_center_definitions = Collision.ScatteringCenterDefinitionDatabase()
nuclide_definition = scattering_center_definitions.createDefinition( "H1", Data.ZAID(1001) )
nuclide_definition.setNuclearDataProperties( nuclide_properties.getSharedNuclearDataProperties( Data.NuclearDataProperties.ACE_FILE, 8, temp, False ) )
# Set the definition for material 1
material_definitions = Collision.MaterialDefinitionDatabase()
material_definitions.addDefinition( "H1", 1, ["H1"], [1.0] )
##---------------------------------------------------------------------------##
## 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( 1.0 );
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( Utility.doubleArrayFromString( "{1e-9, 100l, 1.0}" ) )
# Set the energy and collision number bins in estimator 2
event_handler.getEstimator( 2 ).setEnergyDiscretization( Utility.doubleArrayFromString( "{1e-9, 100l, 1.0}" ) )
##---------------------------------------------------------------------------##
## 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()