def test_write_fluxin_single():
"""This function tests the flux_mesh_to_fluxin function for a single energy
group case.
"""
if not HAVE_PYTAPS:
raise SkipTest
output_name = "fluxin.out"
forward_fluxin = os.path.join(thisdir, "files_test_alara",
"fluxin_single_forward.txt")
output = os.path.join(os.getcwd(), output_name)
flux_mesh = Mesh(structured=True,
structured_coords=[[0, 1, 2], [0, 1, 2], [0, 1]])
tag_flux = flux_mesh.mesh.createTag("flux", 1, float)
flux_data = [1, 2, 3, 4]
ves = flux_mesh.structured_iterate_hex("xyz")
for i, ve in enumerate(ves):
tag_flux[ve] = flux_data[i]
# test forward writting
mesh_to_fluxin(flux_mesh, "flux", output_name, False)
with open(output) as f:
written = f.readlines()
with open(forward_fluxin) as f:
expected = f.readlines()
assert_equal(written, expected)
if os.path.isfile(output):
os.remove(output)
def test_write_fluxin_single():
"""This function tests the flux_mesh_to_fluxin function for a single energy
group case.
"""
if not HAVE_PYTAPS:
raise SkipTest
output_name = "fluxin.out"
forward_fluxin = os.path.join(thisdir, "files_test_alara", "fluxin_single_forward.txt")
output = os.path.join(os.getcwd(), output_name)
flux_mesh = Mesh(structured=True, structured_coords=[[0, 1, 2], [0, 1, 2], [0, 1]])
tag_flux = flux_mesh.mesh.createTag("flux", 1, float)
flux_data = [1, 2, 3, 4]
ves = flux_mesh.structured_iterate_hex("xyz")
for i, ve in enumerate(ves):
tag_flux[ve] = flux_data[i]
# test forward writting
mesh_to_fluxin(flux_mesh, "flux", output_name, False)
with open(output) as f:
written = f.readlines()
with open(forward_fluxin) as f:
expected = f.readlines()
assert_equal(written, expected)
if os.path.isfile(output):
os.remove(output)
def test_write_fluxin_multiple():
"""This function tests the flux_mesh_to_fluxin function for a multiple
energy group case.
"""
if not HAVE_PYMOAB:
raise SkipTest
output_name = "fluxin.out"
forward_fluxin = os.path.join(thisdir, "files_test_alara",
"fluxin_multiple_forward.txt")
reverse_fluxin = os.path.join(thisdir, "files_test_alara",
"fluxin_multiple_reverse.txt")
output = os.path.join(os.getcwd(), output_name)
flux_mesh = Mesh(structured=True,
structured_coords=[[0, 1, 2], [0, 1], [0, 1]])
flux_data = [[1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, 14]]
flux_mesh.tag("flux", flux_data, "nat_mesh", size=7, dtype=float)
# test forward writting
mesh_to_fluxin(flux_mesh, "flux", output_name, False)
with open(output) as f:
written = f.readlines()
with open(forward_fluxin) as f:
expected = f.readlines()
assert_equal(written, expected)
if os.path.isfile(output):
os.remove(output)
# test reverse writting
mesh_to_fluxin(flux_mesh, "flux", output_name, True)
with open(output) as f:
written = f.readlines()
with open(reverse_fluxin) as f:
expected = f.readlines()
assert_equal(written, expected)
if os.path.isfile(output):
os.remove(output)
def irradiation_setup(flux_mesh, cell_mats, alara_params, tally_num=4,
geom=None, num_rays=10, grid=False, flux_tag="n_flux",
fluxin="alara_fluxin", reverse=False,
alara_inp="alara_geom", alara_matlib="alara_matlib",
output_mesh="r2s_step1.h5m", output_material=False):
"""This function is used to setup the irradiation inputs after the first
R2S transport step.
Parameters
----------
flux_mesh : PyNE Meshtal object, Mesh object, or str
The source of the neutron flux information. This can be a PyNE Meshtal
object, a pyne Mesh object, or the filename an MCNP meshtal file, or
the filename of an unstructured mesh tagged with fluxes.
tally_num : int
The MCNP FMESH4 tally number of the neutron flux tally within the
meshtal file.
cell_mats : dict
Maps geometry cell numbers to PyNE Material objects.
alara_params : str
The ALARA input blocks specifying everything except the geometry
and materials. This can either be passed as string or as a file name.
geom : str, optional
The file name of a DAGMC-loadable faceted geometry. This is only
necessary if the geometry is not already loaded into memory.
num_rays : int, optional
The number of rays to fire down a mesh row for geometry discretization.
This number must be a perfect square if grid=True.
grid : bool, optional
The if False, geometry discretization will be done with randomly fired
rays. If true, a grid of sqrt(num_rays) x sqrt(num_rays) rays is used
for each mesh row.
flux_tag : str, optional
The iMesh tag for the neutron flux.
fluxin : str, optional
The name of the ALARA fluxin file to be created.
reverse : bool, optional
If True the fluxes in the fluxin file will be printed in the reverse
order of how they appear within the flux vector tag. Since MCNP and
the Meshtal class order fluxes from low energy to high energy, this
option should only be true if the transmutation data being used is
ordered from high energy to low energy.
alara_inp : str, optional
The name of the ALARA input file to be created.
alara_matlib : str, optional
The name of the alara_matlib file to be created.
output_mesh : str, optional
A mesh containing all the fluxes and materials used for irradiation
setup.
output_material : bool, optional
If true, output mesh will have materials as determined by
dagmc.discretize_geom()
"""
from pyne.dagmc import load, discretize_geom
if geom is not None and isfile(geom):
load(geom)
# flux_mesh is Mesh object
if isinstance(flux_mesh, Mesh):
m = flux_mesh
# flux_mesh is unstructured mesh file
elif isinstance(flux_mesh, str) and isfile(flux_mesh) \
and flux_mesh.endswith(".h5m"):
m = Mesh(structured=False, mesh=flux_mesh)
# flux_mesh is Meshtal or meshtal file
else:
# flux_mesh is meshtal file
if isinstance(flux_mesh, str) and isfile(flux_mesh):
flux_mesh = Meshtal(flux_mesh,
{tally_num: (flux_tag, flux_tag + "_err",
flux_tag + "_total",
flux_tag + "_err_total")},
meshes_have_mats=output_material)
m = flux_mesh.tally[tally_num]
# flux_mesh is Meshtal object
elif isinstance(flux_mesh, Meshtal):
m = flux_mesh.tally[tally_num]
else:
raise ValueError("meshtal argument not a Mesh object, Meshtal"
" object, MCNP meshtal file or meshtal.h5m file.")
if m.structured:
cell_fracs = discretize_geom(m, num_rays=num_rays, grid=grid)
else:
cell_fracs = discretize_geom(m)
if output_material:
m.cell_fracs_to_mats(cell_fracs, cell_mats)
mesh_to_fluxin(m, flux_tag, fluxin, reverse)
record_to_geom(m, cell_fracs, cell_mats, alara_inp, alara_matlib)
if isfile(alara_params):
with open(alara_params, 'r') as f:
alara_params = f.read()
with open(alara_inp, 'a') as f:
f.write("\n" + alara_params)
m.write_hdf5(output_mesh)
def irradiation_setup(flux_mesh,
cell_mats,
cell_fracs,
alara_params,
tally_num=4,
num_rays=10,
grid=False,
flux_tag="n_flux",
fluxin="alara_fluxin",
reverse=False,
alara_inp="alara_inp",
alara_matlib="alara_matlib",
output_mesh="r2s_step1.h5m",
output_material=False,
decay_times=None,
sub_voxel=False,
responses=None,
wdr_file=None):
"""This function is used to setup the irradiation inputs after the first
R2S transport step.
Parameters
----------
flux_mesh : PyNE Meshtal object, Mesh object, or str
The source of the neutron flux information. This can be a PyNE Meshtal
object, a pyne Mesh object, or the filename an MCNP meshtal file, or
the filename of an unstructured mesh tagged with fluxes.
cell_mats : dict
Maps geometry cell numbers to PyNE Material objects.
cell_fracs : record array
The output of dagmc.discretize_geom().
alara_params : str
The ALARA input blocks specifying everything except the geometry
and materials. This can either be passed as string or as a file name.
tally_num : int
The MCNP FMESH4 tally number of the neutron flux tally within the
meshtal file.
num_rays : int, optional
The number of rays to fire down a mesh row for geometry discretization.
This number must be a perfect square if grid=True.
grid : bool, optional
The if False, geometry discretization will be done with randomly fired
rays. If true, a grid of sqrt(num_rays) x sqrt(num_rays) rays is used
for each mesh row.
flux_tag : str, optional
The mesh tag for the neutron flux.
fluxin : str, optional
The name of the ALARA fluxin file to be created.
reverse : bool, optional
If True the fluxes in the fluxin file will be printed in the reverse
order of how they appear within the flux vector tag. Since MCNP and
the Meshtal class order fluxes from low energy to high energy, this
option should only be true if the transmutation data being used is
ordered from high energy to low energy.
alara_inp : str, optional
The name of the ALARA input file to be created.
alara_matlib : str, optional
The name of the alara_matlib file to be created.
output_mesh : str, optional
A mesh containing all the fluxes and materials used for irradiation
setup.
output_material : bool, optional
If true, output mesh will have materials as determined by
dagmc.discretize_geom()
decay_times: list
List of the decay times. If no decay times given, use '1 s'.
sub_voxel : bool, optional
If true, sub-voxel r2s work flow will be used.
responses : list of str, optional
The list of requested responses.
wdr_file : str
Path to the wdr file.
"""
m = resolve_mesh(flux_mesh, tally_num, flux_tag, output_material)
if output_material:
m.cell_fracs_to_mats(cell_fracs, cell_mats)
mesh_to_fluxin(m, flux_tag, fluxin, reverse, sub_voxel, cell_fracs,
cell_mats)
record_to_geom(m,
cell_fracs,
cell_mats,
alara_inp,
alara_matlib,
sub_voxel=sub_voxel)
# write decay times into alara_inp
if decay_times is None:
decay_times = ['1 s']
decay_str = 'cooling\n'
for dc in decay_times:
decay_str = ''.join([decay_str, ' ', dc, '\n'])
decay_str = ''.join([decay_str, 'end\n'])
with open(alara_inp, 'a') as f:
f.write(decay_str)
if isfile(alara_params):
with open(alara_params, 'r') as f:
alara_params = f.read()
with open(alara_inp, 'a') as f:
f.write("\n" + alara_params)
# append responses output zone
with open(alara_inp, 'a') as f:
f.write(responses_output_zone(responses, wdr_file, alara_params))
m.write_hdf5(output_mesh)
def test_write_fluxin_multiple_subvoxel():
"""This function tests the flux_mesh_to_fluxin function for a multiple
energy group case under sub-voxel r2s.
"""
if not HAVE_PYMOAB:
raise SkipTest
output_name = "fluxin_subvoxel.out"
forward_fluxin = os.path.join(thisdir, "files_test_alara",
"fluxin_multiple_forward_subvoxel.txt")
reverse_fluxin = os.path.join(thisdir, "files_test_alara",
"fluxin_multiple_reverse_subvoxel.txt")
output = os.path.join(os.getcwd(), output_name)
flux_mesh = Mesh(structured=True,
structured_coords=[[0, 1, 2], [0, 1, 2], [0, 1]])
flux_data = [
[1, 2, 3, 4, 5, 6, 7],
[8, 9, 10, 11, 12, 13, 14],
[15, 16, 17, 18, 19, 20, 21],
[22, 23, 24, 25, 26, 27, 28],
]
flux_mesh.tag("flux", flux_data, "nat_mesh", size=7, dtype=float)
cell_fracs = np.zeros(
6,
dtype=[
("idx", np.int64),
("cell", np.int64),
("vol_frac", np.float64),
("rel_error", np.float64),
],
)
cell_fracs[:] = [
(0, 11, 1, 0.0),
(1, 11, 0.5, 0.0),
(1, 12, 0.5, 0.0),
(2, 11, 0.5, 0.0),
(2, 13, 0.5, 0.0),
(3, 13, 1, 0.0),
]
cell_mats = {
11: Material({"H": 1.0}, density=1.0),
12: Material({"He": 1.0}, density=1.0),
13: Material({}, density=0.0, metadata={"name": "void"}),
}
# test forward writting
mesh_to_fluxin(flux_mesh, "flux", output_name, False, True, cell_fracs,
cell_mats)
with open(output) as f:
written = f.readlines()
with open(forward_fluxin) as f:
expected = f.readlines()
assert_equal(written, expected)
if os.path.isfile(output):
os.remove(output)
# test reverse writting
mesh_to_fluxin(flux_mesh, "flux", output_name, True, True, cell_fracs,
cell_mats)
with open(output) as f:
written = f.readlines()
with open(reverse_fluxin) as f:
expected = f.readlines()
assert_equal(written, expected)
if os.path.isfile(output):
os.remove(output)
def irradiation_setup(flux_mesh,
cell_mats,
alara_params,
tally_num=4,
geom=None,
num_rays=10,
grid=False,
flux_tag="n_flux",
fluxin="alara_fluxin",
reverse=False,
alara_inp="alara_geom",
alara_matlib="alara_matlib",
output_mesh="r2s_step1.h5m"):
"""This function is used to setup the irradiation inputs after the first
R2S transport step.
Parameters
----------
flux_mesh : PyNE Meshtal object, Mesh object, or str
The source of the neutron flux information. This can be a PyNE Meshtal
object, a pyne Mesh object, or the filename an MCNP meshtal file, or
the filename of an unstructured mesh tagged with fluxes.
tally_num : int
The MCNP FMESH4 tally number of the neutron flux tally within the
meshtal file.
cell_mats : dict
Maps geometry cell numbers to PyNE Material objects.
alara_params : str
The ALARA input blocks specifying everything except the geometry
and materials. This can either be passed as string or as a file name.
geom : str, optional
The file name of a DAGMC-loadable faceted geometry. This is only
necessary if the geometry is not already loaded into memory.
num_rays : int, optional
The number of rays to fire down a mesh row for geometry discretization.
This number must be a perfect square if grid=True.
grid : bool, optional
The if False, geometry discretization will be done with randomly fired
rays. If true, a grid of sqrt(num_rays) x sqrt(num_rays) rays is used
for each mesh row.
flux_tag : str, optional
The iMesh tag for the neutron flux.
fluxin : str, optional
The name of the ALARA fluxin file to be created.
reverse : bool, optional
If True the fluxes in the fluxin file will be printed in the reverse
order of how they appear within the flux vector tag. Since MCNP and
the Meshtal class order fluxes from low energy to high energy, this
option should only be true if the transmutation data being used is
ordered from high energy to low energy.
alara_inp : str, optional
The name of the ALARA input file to be created.
alara_matlib : str, optional
The name of the alara_matlib file to be created.
output_mesh : str, optional
A mesh containing all the fluxes and materials used for irradiation
setup.
"""
if geom is not None and isfile(geom):
load(geom)
# flux_mesh is Mesh object
if isinstance(flux_mesh, Mesh):
m = flux_mesh
# flux_mesh is unstructured mesh file
elif isinstance(flux_mesh, str) and isfile(flux_mesh) \
and flux_mesh.endswith(".h5m"):
m = Mesh(structured=False, mesh=flux_mesh)
# flux_mesh is Meshtal or meshtal file
else:
# flux_mesh is meshtal file
if isinstance(flux_mesh, str) and isfile(flux_mesh):
flux_mesh = Meshtal(flux_mesh, {
tally_num: (flux_tag, flux_tag + "_err", flux_tag + "_total",
flux_tag + "_err_total")
},
meshes_have_mats=True)
m = flux_mesh.tally[tally_num]
# flux_mesh is Meshtal object
elif instance(flux_mesh, Meshtal):
m = flux_mesh.tally[tally_num]
else:
raise ValueError("meshtal argument not a Mesh object, Meshtal"
" object, MCNP meshtal file or meshtal.h5m file.")
if m.structured:
vol_fracs = discretize_geom(m, num_rays=num_rays, grid=grid)
else:
vol_fracs = discretize_geom(m)
m.cell_fracs_to_mats(vol_fracs, cell_mats)
mesh_to_fluxin(m, flux_tag, fluxin, reverse)
mesh_to_geom(m, alara_inp, alara_matlib)
if isfile(alara_params):
with open(alara_params, 'r') as f:
alara_params = f.read(alara_params)
with open(alara_inp, 'a') as f:
f.write("\n" + alara_params)
m.write_hdf5(output_mesh)
