示例#1
0
文件: test_dagmc.py 项目: pyne/pyne
def boundary():
    from pyne import dagmc

    dagmc.load(path)

    low, high = dagmc.volume_boundary(2)
    return [low, high]
示例#2
0
文件: test_dagmc.py 项目: pyne/pyne
def versions():
    from pyne import dagmc

    dagmc.load(path)

    returned = dagmc.versions()
    return returned
示例#3
0
def ray_iterator():
    from pyne import dagmc
    dagmc.load(path)
    
    start = [-2, 0, 0]
    startvol = dagmc.find_volume(start)
    assert_equal(startvol, 3)
    direction = [1, 0, 0]

    expected_vols = [2, 3, 1, 4]
    expected_dists = [1, 2, 3.156921938, 0]

    for i, (vol, dist, surf) in enumerate(
            dagmc.ray_iterator(startvol, start, direction)):
        assert_equal(expected_vols[i], vol)
        if expected_dists[i] != 0:
            assert_almost_equal(expected_dists[i], dist)
    assert_equal(i, 3)

    for i, (vol, dist, surf) in enumerate(
            dagmc.ray_iterator(startvol, start, direction, dist_limit=4)):
        assert_equal(expected_vols[i], vol)
        if expected_dists[i] != 0:
            assert_almost_equal(expected_dists[i], dist)
    assert_equal(i, 1)
示例#4
0
def failures():
    from pyne import dagmc
    dagmc.load(path)

    assert_raises(Exception, dagmc.point_in_volume, [100, (0, 0, 0)])
    assert_raises(Exception, dagmc.point_in_volume, [1, (0, 0, 0, 0)])
    assert_raises(Exception, dagmc.fire_one_ray, [2, (0, 0, 0), 1])
示例#5
0
def get_zones_iteration_order():
    """Test that _get_zones function gives results in zyx order.
    """
    try:
        from pyne import dagmc
    except:
        raise SkipTest

    if not HAVE_PYMOAB:
        raise SkipTest

    # hdf5 test file
    THIS_DIR = os.path.dirname(os.path.realpath(__file__))
    hdf5 = THIS_DIR + '/files_test_partisn/fractal_box.h5m'
    data_hdf5path = '/materials'

    # Load dagmc geometry
    dagmc.load(hdf5)

    bounds = [-5., 0., 5.]
    sc = [bounds] * 3
    mesh = Mesh(structured_coords=sc, structured=True)
    bounds = {'x': bounds, 'y': bounds, 'z': bounds}
    num_rays = 9
    grid = True
    dg = None
    mat_assigns = None
    unique_names = {
        'mat:m1': 'M1',
        'mat:m2': 'M2',
        'mat:m3': 'M3',
        'mat:m4': 'M4'
    }

    voxel_zones, zones = partisn._get_zones(mesh, hdf5, bounds, num_rays, grid,
                                            dg, mat_assigns, unique_names)

    voxel_zones_expected = np.array([[1, 2], [1, 4], [1, 3], [1, 4]])
    zones_expected = {
        1: {
            'vol_frac': [1.0],
            'mat': ['M2']
        },
        2: {
            'vol_frac': [1.0],
            'mat': ['M4']
        },
        3: {
            'vol_frac': [1.0],
            'mat': ['M1']
        },
        4: {
            'vol_frac': [1.0],
            'mat': ['M3']
        }
    }

    vz_tf = voxel_zones.all() == voxel_zones_expected.all()
    z_tf = zones == zones_expected
    return [vz_tf, z_tf]
示例#6
0
def failures():
    from pyne import dagmc
    dagmc.load(path)
    
    assert_raises(Exception, dagmc.point_in_volume, [100, (0, 0, 0)])
    assert_raises(Exception, dagmc.point_in_volume, [1, (0, 0, 0, 0)])
    assert_raises(Exception, dagmc.fire_one_ray, [2, (0, 0, 0), 1])
示例#7
0
def ray_iterator():
    from pyne import dagmc
    dagmc.load(path)

    start = [-2, 0, 0]
    startvol = dagmc.find_volume(start)
    direction = [1, 0, 0]

    expected_vols = [2, 3, 1, 4]
    expected_dists = [1, 2, 3.156921938, 0]

    vols1 = []
    dists1 = []
    surfs1 = []
    for i, (vol, dist,
            surf) in enumerate(dagmc.ray_iterator(startvol, start, direction)):
        vols1.append(vol)
        dists1.append(dist)
        surfs1.append(surf)

    vols2 = []
    dists2 = []
    surfs2 = []
    for j, (vol, dist, surf) in enumerate(
            dagmc.ray_iterator(startvol, start, direction, dist_limit=4)):
        vols2.append(vol)
        dists2.append(dist)
        surfs2.append(surf)

    return [startvol, vols1, dists1, surfs1, i, vols2, dists2, surfs2, j]
示例#8
0
def step1():
    config = ConfigParser.ConfigParser()
    config.read(config_filename)

    structured = config.getboolean("general", "structured")
    sub_voxel = config.getboolean("general", "sub_voxel")
    meshtal = config.get("step1", "meshtal")
    tally_num = config.getint("step1", "tally_num")
    flux_tag = config.get("step1", "flux_tag")
    decay_times = config.get("step2", "decay_times").split(",")
    geom = config.get("step1", "geom")
    reverse = config.getboolean("step1", "reverse")
    num_rays = config.getint("step1", "num_rays")
    grid = config.getboolean("step1", "grid")

    load(geom)

    # get meshtal info from meshtal file
    flux_mesh = resolve_mesh(meshtal, tally_num, flux_tag)

    # create the cell_fracs array before irradiation_steup
    if flux_mesh.structured:
        cell_fracs = discretize_geom(flux_mesh, num_rays=num_rays, grid=grid)
        # tag cell fracs for both default and subvoxel r2s modes
        flux_mesh.tag_cell_fracs(cell_fracs)
    else:
        cell_fracs = discretize_geom(flux_mesh)

    cell_mats = cell_materials(geom)
    irradiation_setup(
        flux_mesh,
        cell_mats,
        cell_fracs,
        alara_params_filename,
        tally_num,
        num_rays=num_rays,
        grid=grid,
        reverse=reverse,
        flux_tag=flux_tag,
        decay_times=decay_times,
        sub_voxel=sub_voxel,
    )

    # create a blank mesh for step 2:
    ves = list(flux_mesh.iter_ve())
    tags_keep = (
        "cell_number",
        "cell_fracs",
        "cell_largest_frac_number",
        "cell_largest_frac",
    )
    for tag in flux_mesh.get_all_tags():
        if tag.name not in tags_keep and isinstance(tag, NativeMeshTag):
            tag.delete()
    flux_mesh.write_hdf5("blank_mesh.h5m")
    print("The file blank_mesh.h5m has been saved to disk.")
    print("Do not delete this file; it is needed by r2s.py step2.\n")

    print("R2S step1 complete, run ALARA with the command:")
    print(">> alara alara_inp > output.txt")
示例#9
0
def ray_iterator():
    from pyne import dagmc
    dagmc.load(path)

    start = [-2, 0, 0]
    startvol = dagmc.find_volume(start)
    assert_equal(startvol, 3)
    direction = [1, 0, 0]

    expected_vols = [2, 3, 1, 4]
    expected_dists = [1, 2, 3.156921938, 0]

    for i, (vol, dist,
            surf) in enumerate(dagmc.ray_iterator(startvol, start, direction)):
        assert_equal(expected_vols[i], vol)
        if expected_dists[i] != 0:
            assert_almost_equal(expected_dists[i], dist)
    assert_equal(i, 3)

    for i, (vol, dist, surf) in enumerate(
            dagmc.ray_iterator(startvol, start, direction, dist_limit=4)):
        assert_equal(expected_vols[i], vol)
        if expected_dists[i] != 0:
            assert_almost_equal(expected_dists[i], dist)
    assert_equal(i, 1)
示例#10
0
文件: test_dagmc.py 项目: pyne/pyne
def util_graveyard_bound():
    from pyne import dagmc

    dagmc.load(path)

    lo, hi = dagmc.find_graveyard_inner_box()
    return [lo, hi]
示例#11
0
文件: test_partisn.py 项目: pyne/pyne
def get_zones_iteration_order():
    """Test that _get_zones function gives results in zyx order."""
    try:
        from pyne import dagmc
    except:
        raise SkipTest

    if not HAVE_PYMOAB:
        raise SkipTest

    # hdf5 test file
    THIS_DIR = os.path.dirname(os.path.realpath(__file__))
    hdf5 = THIS_DIR + "/files_test_partisn/fractal_box.h5m"
    data_hdf5path = "/materials"

    # Load dagmc geometry
    dagmc.load(hdf5)

    bounds = [-5.0, 0.0, 5.0]
    sc = [bounds] * 3
    mesh = Mesh(structured_coords=sc, structured=True)
    bounds = {"x": bounds, "y": bounds, "z": bounds}
    num_rays = 9
    grid = True
    dg = None
    mat_assigns = None
    unique_names = {
        "mat:m1": "M1",
        "mat:m2": "M2",
        "mat:m3": "M3",
        "mat:m4": "M4"
    }

    voxel_zones, zones = partisn._get_zones(mesh, hdf5, bounds, num_rays, grid,
                                            dg, mat_assigns, unique_names)

    voxel_zones_expected = np.array([[1, 2], [1, 4], [1, 3], [1, 4]])
    zones_expected = {
        1: {
            "vol_frac": [1.0],
            "mat": ["M2"]
        },
        2: {
            "vol_frac": [1.0],
            "mat": ["M4"]
        },
        3: {
            "vol_frac": [1.0],
            "mat": ["M1"]
        },
        4: {
            "vol_frac": [1.0],
            "mat": ["M3"]
        },
    }

    vz_tf = voxel_zones.all() == voxel_zones_expected.all()
    z_tf = zones == zones_expected
    return [vz_tf, z_tf]
示例#12
0
def versions():
    from pyne import dagmc
    dagmc.load(path)

    returned = dagmc.versions()
    assert_equal(len(returned), 2)
    assert_true(isinstance(returned[0], STRING_TYPES))
    assert_true(isinstance(returned[1], int))
示例#13
0
def boundary():
    from pyne import dagmc
    dagmc.load(path)

    low, high = dagmc.volume_boundary(2)
    for i in range(0, 3):
        assert_true(low[i] <= -1.0)
        assert_true(high[i] >= 1.0)
示例#14
0
def boundary():
    from pyne import dagmc
    dagmc.load(path)
    
    low, high = dagmc.volume_boundary(2)
    for i in range(0, 3):
        assert_true(low[i] <= -1.0)
        assert_true(high[i] >= 1.0)
示例#15
0
def list_functions():
    from pyne import dagmc
    dagmc.load(path)

    surfs = dagmc.get_surface_list()
    vols = dagmc.get_volume_list()

    return [surfs, vols]
示例#16
0
def util_matlist():
    from pyne import dagmc
    dagmc.load(path)

    mats1 = dagmc.get_material_set()
    mats2 = dagmc.get_material_set(with_rho=True)

    return [mats1, mats2]
示例#17
0
def discretize_non_square():
    from pyne import dagmc
    dagmc.load(path)

    coords = [0, 1]
    mesh = Mesh(structured=True, 
                structured_coords=[coords, coords, coords])
    assert_raises(ValueError, dagmc.discretize_geom, mesh, num_rays=3, grid=True)
示例#18
0
def versions():
    from pyne import dagmc
    dagmc.load(path)
    
    returned = dagmc.versions()
    assert_equal(len(returned), 2)
    assert_true(isinstance(returned[0], STRING_TYPES))
    assert_true(isinstance(returned[1], int))
示例#19
0
def list_functions():
    from pyne import dagmc
    dagmc.load(path)
    
    surfs = dagmc.get_surface_list()
    assert_equal(set(surfs), set(range(1, 19)))

    vols = dagmc.get_volume_list()
    assert_equal(set(vols), set(range(1, 5)))
示例#20
0
def metadata():
    from pyne import dagmc
    dagmc.load(path)

    rets1 = [dagmc.volume_is_graveyard(x) for x in range(1, 5)]
    rets2 = [dagmc.volume_is_implicit_complement(x) for x in range(1, 5)]
    md = dagmc.volume_metadata(2)

    return [rets1, rets2, md]
示例#21
0
def discretize_geom_grid():
    from pyne import dagmc
    dagmc.load(path)

    coords = [-4, -1, 1, 4]
    mesh = Mesh(structured=True, structured_coords=[coords, coords, coords])
    results = dagmc.discretize_geom(mesh, num_rays=49, grid=True)

    return [results, coords]
示例#22
0
def util_matlist():
    from pyne import dagmc
    dagmc.load(path)
    
    mats = dagmc.get_material_set()
    assert_equal(set((0, 5)), mats)

    mats = dagmc.get_material_set(with_rho=True)
    assert_equal(set([(0, 0.0), (5, 0.5)]), mats)
示例#23
0
def cells_at_ve_centers():
    from pyne import dagmc
    dagmc.load(path)

    coords = [0, 1]
    coords2 = [0, 2, 4]
    mesh = Mesh(structured=True, structured_coords=[coords2, coords, coords])
    cells = dagmc.cells_at_ve_centers(mesh)
    assert_array_equal(cells, [2, 3])
示例#24
0
def list_functions():
    from pyne import dagmc
    dagmc.load(path)

    surfs = dagmc.get_surface_list()
    assert_equal(set(surfs), set(range(1, 19)))

    vols = dagmc.get_volume_list()
    assert_equal(set(vols), set(range(1, 5)))
示例#25
0
def util_matlist():
    from pyne import dagmc
    dagmc.load(path)

    mats = dagmc.get_material_set()
    assert_equal(set((0, 5)), mats)

    mats = dagmc.get_material_set(with_rho=True)
    assert_equal(set([(0, 0.0), (5, 0.5)]), mats)
示例#26
0
def step1():
    config = ConfigParser.ConfigParser()
    config.read(config_filename)

    structured = config.getboolean("general", "structured")
    meshtal = config.get("step1", "meshtal")
    tally_num = config.getint("step1", "tally_num")
    flux_tag = config.get("step1", "flux_tag")
    decay_times = config.get("step2", "decay_times").split(",")
    geom = config.get("step1", "geom")
    reverse = config.getboolean("step1", "reverse")
    num_rays = config.getint("step1", "num_rays")
    grid = config.getboolean("step1", "grid")
    responses = config.get("general", "responses").split(",")
    wdr_file = config.get("general", "wdr_file")

    load(geom)

    # get meshtal info from meshtal file
    flux_mesh = resolve_mesh(meshtal, tally_num, flux_tag)

    # create the cell_fracs array before irradiation_steup
    if flux_mesh.structured:
        cell_fracs = discretize_geom(flux_mesh, num_rays=num_rays, grid=grid)
    else:
        cell_fracs = discretize_geom(flux_mesh)

    cell_mats = cell_materials(geom)
    irradiation_setup(
        flux_mesh,
        cell_mats,
        cell_fracs,
        alara_params_filename,
        tally_num,
        num_rays=num_rays,
        grid=grid,
        reverse=reverse,
        output_mesh="activation_responses_step1.h5m",
        flux_tag=flux_tag,
        decay_times=decay_times,
        sub_voxel=False,
        responses=responses,
        wdr_file=wdr_file,
    )

    # create a blank mesh for step 2:
    ves = list(flux_mesh.iter_ve())
    for tag in flux_mesh.get_all_tags():
        tag.delete()
    flux_mesh.write_hdf5("blank_mesh.h5m")
    print("The file blank_mesh.h5m has been saved to disk.")
    print(
        "Do not delete this file; it is needed by activation_responses.py step2.\n"
    )
    print("Decay_heat step1 complete, run ALARA with the command:")
    print(">> alara alara_inp > output.txt")
示例#27
0
def ray_story():
    from pyne import dagmc
    dagmc.load(path)
    
    # Run with `nosetests -s` to see output printed on stdout
    dagmc.tell_ray_story((0, 0, 0), (1, 1, 0))
    dagmc.tell_ray_story((-3, 0, 0), (1, 0, 0))
    # tests edge behavior
    dagmc.tell_ray_story((-3, 0, 0), (1, 0, 0), dist_limit=4)
    dagmc.tell_ray_story((-3, 0, 0), (1, 0, 0), dist_limit=4.1)
示例#28
0
def util_graveyard_bound():
    from pyne import dagmc
    dagmc.load(path)
    
    lo, hi = dagmc.find_graveyard_inner_box()

    grave_diam = 4.15692194
    for i in range(0, 3):
        assert_almost_equal(lo[i], -grave_diam)
        assert_almost_equal(hi[i], grave_diam)
示例#29
0
def cells_at_ve_centers():
    from pyne import dagmc
    dagmc.load(path)

    coords = [0, 1]
    coords2 = [0, 2, 4]
    mesh = Mesh(structured=True, structured_coords=[coords2, coords, coords])
    cells = dagmc.cells_at_ve_centers(mesh)

    return cells
示例#30
0
def cells_at_ve_centers():
    from pyne import dagmc
    dagmc.load(path)

    coords = [0, 1]
    coords2 = [0, 2, 4]
    mesh = Mesh(structured=True, 
                structured_coords=[coords2, coords, coords])
    cells = dagmc.cells_at_ve_centers(mesh)
    assert_array_equal(cells, [2, 3])
示例#31
0
def ray_story():
    from pyne import dagmc
    dagmc.load(path)

    # Run with `nosetests -s` to see output printed on stdout
    dagmc.tell_ray_story((0, 0, 0), (1, 1, 0))
    dagmc.tell_ray_story((-3, 0, 0), (1, 0, 0))
    # tests edge behavior
    dagmc.tell_ray_story((-3, 0, 0), (1, 0, 0), dist_limit=4)
    dagmc.tell_ray_story((-3, 0, 0), (1, 0, 0), dist_limit=4.1)
示例#32
0
def util_graveyard_bound():
    from pyne import dagmc
    dagmc.load(path)

    lo, hi = dagmc.find_graveyard_inner_box()

    grave_diam = 4.15692194
    for i in range(0, 3):
        assert_almost_equal(lo[i], -grave_diam)
        assert_almost_equal(hi[i], grave_diam)
示例#33
0
def get_zones_with_void():
    """Test the _get_zones function if a void is present.
    """
    try:
        from pyne import dagmc
    except:
        raise SkipTest

    if not HAVE_PYMOAB:
        raise SkipTest

    # hdf5 test file
    THIS_DIR = os.path.dirname(os.path.realpath(__file__))
    hdf5 = THIS_DIR + '/files_test_partisn/partisn_test_geom.h5m'
    data_hdf5path = '/materials'
    nuc_hdf5path = '/nucid'

    dagmc.load(hdf5)

    # mesh
    xvals = [-5., 0., 10., 15., 15.1]
    yvals = [-5., 0., 5.]
    zvals = [-5., 0., 5.]
    mesh = Mesh(structured_coords=[xvals, yvals, zvals], structured=True,
                structured_ordering='xyz')
    # more inputs
    bounds = {'x': xvals, 'y': yvals, 'z': zvals}
    num_rays = 400
    grid = True
    dg = None
    mat_assigns = None

    unique_names = {'mat:Helium, Natural': 'HELIUMNA',
                    'mat:Mercury': 'MERCURY1'}
    voxel_zones, zones = partisn._get_zones(
        mesh, hdf5, bounds, num_rays, grid, dg, mat_assigns, unique_names)

    # expected results
    voxel_zones_expected = np.array([[1, 1, 1, 1],
                                     [2, 2, 2, 2],
                                     [3, 3, 3, 3],
                                     [0, 0, 0, 0]])
    zones_expected = {1: {'vol_frac': [1.0], 'mat': [u'HELIUMNA']},
                      2: {'vol_frac': [0.5, 0.5], 'mat': [u'HELIUMNA', u'MERCURY1']},
                      3: {'vol_frac': [1.0], 'mat': [u'MERCURY1']}}

    vz_tf = False
    z_tf = False
    if voxel_zones.all() == voxel_zones_expected.all():
        vz_tf = True
    if zones == zones_expected:
        z_tf = True
    #assert(voxel_zones.all() == voxel_zones_expected.all())
    #assert(zones == zones_expected)
    return [vz_tf, z_tf]
示例#34
0
def step1():
    config = ConfigParser.ConfigParser()
    config.read(config_filename)

    structured = config.getboolean('general', 'structured')
    sub_voxel = config.getboolean('general', 'sub_voxel')
    meshtal = config.get('step1', 'meshtal')
    tally_num = config.getint('step1', 'tally_num')
    flux_tag = config.get('step1', 'flux_tag')
    decay_times = config.get('step2', 'decay_times').split(',')
    geom = config.get('step1', 'geom')
    reverse = config.getboolean('step1', 'reverse')
    num_rays = config.getint('step1', 'num_rays')
    grid = config.getboolean('step1', 'grid')

    load(geom)

    # get meshtal info from meshtal file
    flux_mesh = resolve_mesh(meshtal, tally_num, flux_tag)

    # create the cell_fracs array before irradiation_steup
    if flux_mesh.structured:
        cell_fracs = discretize_geom(flux_mesh, num_rays=num_rays, grid=grid)
        # tag cell fracs for both default and subvoxel r2s modes
        flux_mesh.tag_cell_fracs(cell_fracs)
    else:
        cell_fracs = discretize_geom(flux_mesh)

    cell_mats = cell_materials(geom)
    irradiation_setup(flux_mesh,
                      cell_mats,
                      cell_fracs,
                      alara_params_filename,
                      tally_num,
                      num_rays=num_rays,
                      grid=grid,
                      reverse=reverse,
                      flux_tag=flux_tag,
                      decay_times=decay_times,
                      sub_voxel=sub_voxel)

    # create a blank mesh for step 2:
    ves = list(flux_mesh.iter_ve())
    tags_keep = ("cell_number", "cell_fracs", "cell_largest_frac_number",
                 "cell_largest_frac")
    for tag in flux_mesh.get_all_tags():
        if tag.name not in tags_keep and isinstance(tag, NativeMeshTag):
            tag.delete()
    flux_mesh.write_hdf5('blank_mesh.h5m')
    print('The file blank_mesh.h5m has been saved to disk.')
    print('Do not delete this file; it is needed by r2s.py step2.\n')

    print('R2S step1 complete, run ALARA with the command:')
    print('>> alara alara_inp > output.txt')
示例#35
0
def pt_in_vol():
    from pyne import dagmc
    dagmc.load(path)

    # there are 4 volumes; (0,0,.2) is in volume 2
    rets = [dagmc.point_in_volume(x, [0, 0, .2]) for x in range(1, 5)]
    assert_equal(rets, [False, True, False, False])

    # (1.1,0,0) is in volume 3
    rets = [dagmc.point_in_volume(x, [1.1, 0, 0]) for x in range(1, 5)]
    assert_equal(rets, [False, False, True, False])
示例#36
0
def pt_in_vol():
    from pyne import dagmc
    dagmc.load(path)
    
    # there are 4 volumes; (0,0,.2) is in volume 2
    rets = [dagmc.point_in_volume(x, [0, 0, .2]) for x in range(1, 5)]
    assert_equal(rets, [False, True, False, False])

    # (1.1,0,0) is in volume 3
    rets = [dagmc.point_in_volume(x, [1.1, 0, 0]) for x in range(1, 5)]
    assert_equal(rets, [False, False, True, False])
示例#37
0
def discretize_non_square():
    from pyne import dagmc
    dagmc.load(path)

    coords = [0, 1]
    mesh = Mesh(structured=True, structured_coords=[coords, coords, coords])
    assert_raises(ValueError,
                  dagmc.discretize_geom,
                  mesh,
                  num_rays=3,
                  grid=True)
示例#38
0
def pt_in_vol():
    from pyne import dagmc
    dagmc.load(path)

    # there are 4 volumes; (0,0,.2) is in volume 2
    rets1 = [dagmc.point_in_volume(x, [0, 0, .2]) for x in range(1, 5)]

    # (1.1,0,0) is in volume 3
    rets2 = [dagmc.point_in_volume(x, [1.1, 0, 0]) for x in range(1, 5)]

    return [rets1, rets2]
示例#39
0
def failures():
    from pyne import dagmc
    dagmc.load(path)

    # if Exception is raised, then None is returned, else nothing is returned
    # and test will fail
    i = assert_raises(Exception, dagmc.point_in_volume, [100, (0, 0, 0)])
    j = assert_raises(Exception, dagmc.point_in_volume, [1, (0, 0, 0, 0)])
    k = assert_raises(Exception, dagmc.fire_one_ray, [2, (0, 0, 0), 1])

    return [i, j, k]
示例#40
0
def step1():
    config = ConfigParser.ConfigParser()
    config.read(config_filename)

    structured = config.getboolean('general', 'structured')
    meshtal = config.get('step1', 'meshtal')
    tally_num = config.getint('step1', 'tally_num')
    flux_tag = config.get('step1', 'flux_tag')
    decay_times = config.get('step2', 'decay_times').split(',')
    geom = config.get('step1', 'geom')
    reverse = config.getboolean('step1', 'reverse')
    num_rays = config.getint('step1', 'num_rays')
    grid = config.getboolean('step1', 'grid')
    responses = config.get('general', 'responses').split(',')
    wdr_file = config.get('general', 'wdr_file')

    load(geom)

    # get meshtal info from meshtal file
    flux_mesh = resolve_mesh(meshtal, tally_num, flux_tag)

    # create the cell_fracs array before irradiation_steup
    if flux_mesh.structured:
        cell_fracs = discretize_geom(flux_mesh, num_rays=num_rays, grid=grid)
    else:
        cell_fracs = discretize_geom(flux_mesh)

    cell_mats = cell_materials(geom)
    irradiation_setup(flux_mesh,
                      cell_mats,
                      cell_fracs,
                      alara_params_filename,
                      tally_num,
                      num_rays=num_rays,
                      grid=grid,
                      reverse=reverse,
                      output_mesh="activation_responses_step1.h5m",
                      flux_tag=flux_tag,
                      decay_times=decay_times,
                      sub_voxel=False,
                      responses=responses,
                      wdr_file=wdr_file)

    # create a blank mesh for step 2:
    ves = list(flux_mesh.iter_ve())
    for tag in flux_mesh.get_all_tags():
        tag.delete()
    flux_mesh.write_hdf5('blank_mesh.h5m')
    print('The file blank_mesh.h5m has been saved to disk.')
    print(
        'Do not delete this file; it is needed by activation_responses.py step2.\n'
    )
    print('Decay_heat step1 complete, run ALARA with the command:')
    print('>> alara alara_inp > output.txt')
示例#41
0
def discretize_geom_mix():
    from pyne import dagmc
    dagmc.load(path)

    coords = [0, 1]
    coords2 = [0, 2]
    mesh = Mesh(structured=True, structured_coords=[coords2, coords, coords])
    results1 = dagmc.discretize_geom(mesh, num_rays=100, grid=True)

    # To to make sure standard error decreases with increasing rays
    results2 = dagmc.discretize_geom(mesh, num_rays=625, grid=True)

    return [results1, results2]
示例#42
0
def metadata():
    from pyne import dagmc
    dagmc.load(path)
    
    rets = [dagmc.volume_is_graveyard(x) for x in range(1, 5)]
    assert_equal(rets, [True, False, False, False])

    rets = [dagmc.volume_is_implicit_complement(x) for x in range(1, 5)]
    assert_equal(rets, [False, False, False, True])

    md = dagmc.volume_metadata(2)
    assert_equal(md['material'], 5)
    assert_equal(md['rho'], 0.5)
    assert_true(all(x in md for x in ['material', 'rho', 'imp']))
示例#43
0
def discretize_geom_grid():
    from pyne import dagmc
    dagmc.load(path)
    
    coords = [-4, -1, 1, 4]
    mesh = Mesh(structured=True, structured_coords=[coords, coords, coords])
    results = dagmc.discretize_geom(mesh, num_rays=49, grid=True)
    
    assert_equal(len(results), (len(coords) - 1)**3)

    for res in results:
        if res['idx'] != 13:
            assert_equal(res['cell'], 3)
        else:
            assert_equal(res['cell'], 2)

        assert_almost_equal(res['vol_frac'], 1.0)
示例#44
0
def discretize_geom_centers():
    from pyne import dagmc
    dagmc.load(path)

    coords = [0, 1]
    coords2 = [0, 2, 4]
    mesh = Mesh(structured=True, 
                structured_coords=[coords2, coords, coords])
    #  explicitly set to unstructured to trigger the ve centers sampling
    #  method
    mesh.structured = False
    res = dagmc.discretize_geom(mesh)
    assert_array_equal(res["idx"], [0, 1])
    assert_array_equal(res["cell"], [2, 3])
    assert_array_equal(res["vol_frac"], [1.0, 1.0])
    assert_array_equal(res["rel_error"], [1.0, 1.0])

    #  ensure kwargs are not accepted for unstructured mesh
    assert_raises(ValueError, dagmc.discretize_geom, mesh, num_rays=3, grid=True)
示例#45
0
def get_zones_with_void():
    """Test the _get_zones function if a void is present.
    """
    # hdf5 test file
    THIS_DIR = os.path.dirname(os.path.realpath(__file__))
    hdf5 = THIS_DIR + '/files_test_partisn/partisn_test_geom.h5m'
    data_hdf5path = '/materials'
    nuc_hdf5path = '/nucid'
    
    from pyne import dagmc
    dagmc.load(hdf5)
    
    # mesh
    xvals = [-5., 0., 10., 15., 15.1]
    yvals = [-5., 0., 5.]
    zvals = [-5., 0., 5.]
    mesh=Mesh(structured_coords=[xvals, yvals, zvals], structured=True, 
                structured_ordering='xyz')
    # more inputs
    bounds = {'x':xvals, 'y':yvals, 'z':zvals}
    num_rays = 400
    grid = True
    
    voxel_zones, zones = partisn._get_zones(mesh, hdf5, bounds, num_rays, grid)
    
    # expected results
    voxel_zones_expected = np.array([[1, 1, 1, 1],
                                    [2, 2, 2, 2],
                                    [3, 3, 3, 3],
                                    [0, 0, 0, 0]])
    zones_expected = {1:{'vol_frac':[1.0], 'mat':[u'HeliumNatural']}, 
                    2:{'vol_frac':[0.5, 0.5], 'mat':[u'HeliumNatural', u'Mercury']}, 
                    3:{'vol_frac':[1.0], 'mat':[u'Mercury']}}
    
    vz_tf = False
    z_tf = False
    if voxel_zones.all() == voxel_zones_expected.all():
        vz_tf = True
    if zones == zones_expected:
        z_tf = True
    #assert(voxel_zones.all() == voxel_zones_expected.all())
    #assert(zones == zones_expected)
    return [vz_tf, z_tf]
示例#46
0
def discretize_geom_mix():
    from pyne import dagmc
    dagmc.load(path)

    coords = [0, 1]
    coords2 = [0, 2]
    mesh = Mesh(structured=True, 
                structured_coords=[coords2, coords, coords])
    results1 = dagmc.discretize_geom(mesh, num_rays=100, grid=True)

    assert_equal(results1[0]['cell'], 2)
    assert_almost_equal(results1[0]['vol_frac'], 0.5)

    assert_equal(results1[1]['cell'], 3)
    assert_almost_equal(results1[1]['vol_frac'], 0.5)

    
    # To to make sure standard error decreases with increasing rays
    results2 = dagmc.discretize_geom(mesh, num_rays=625, grid=True)
    assert(results2[0]['rel_error'] < results1[0]['rel_error'])
    assert(results2[1]['rel_error'] < results1[1]['rel_error'])
示例#47
0
def one_ray():
    from pyne import dagmc
    dagmc.load(path)
    
    fromcenter = dagmc.fire_one_ray(2, [0, 0, 0], [1, 0, 0])
    assert_almost_equal(fromcenter[1], 1.0)

    fromhalf = dagmc.fire_one_ray(2, [.5, .5, .5], [0, -1, 0])
    assert_almost_equal(fromhalf[1], 1.5)

    # the following is actually a misuse of ray_fire because it should only
    # be called from inside a volume, but at least verify that a ray is
    # lost if it 1) starts outside a volume and 2) does not intersect the
    # volume
    fromoutside = dagmc.fire_one_ray(2, [0, 1.1, 0], [-1, 0, 0])
    assert_equal(fromoutside, None)

    fromvol3 = dagmc.fire_one_ray(3, [0, 1.1, 0], [0, -1, 0])
    assert_almost_equal(fromvol3[1], 0.1)

    fromvol3 = dagmc.fire_one_ray(3, [0, 1.1, 0], [0, 1, 0])
    assert_almost_equal(fromvol3[1], 3.056921938)
示例#48
0
def find_volume():
    from pyne import dagmc
    dagmc.load(path)
    
    vol = dagmc.find_volume([0, 0, 0])
    assert_equal(vol, 2)

    vol = dagmc.find_volume([.9, .9, .9])
    assert_equal(vol, 2)

    # boundary case -- point [1,.1,.1] is on surface between vols 2 and 3
    # the behavior on boundaries will vary with uvw, but ensure that
    # only the two volumes the touch the location are ever returned.
    for uvw in [(1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, -1, 0)]:
        vol = dagmc.find_volume([1, .1, .1], uvw)
        assert_true(vol in (2, 3))

    # boundary case-- exiting volume 3 => in volume 3
    vol = dagmc.find_volume([1, .1, .1], [-1, 0, 0])
    assert_equal(vol, 3)

    vol = dagmc.find_volume([1.1, 0, 0])
    assert_equal(vol, 3)
示例#49
0
def load():
    from pyne import dagmc
    # FIXME laoding causes infor to be printied to stderr (or stdout).
    dagmc.load(path)
示例#50
0
文件: r2s.py 项目: FlanFlanagan/pyne
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)
示例#51
0
def _get_zones(mesh, hdf5, bounds, num_rays, grid):
    """Get the minimum zone definitions for the geometry.
    """
    
    # load the geometry
    from pyne import dagmc
    dagmc.load(hdf5)
    
    # Descretize the geometry and get cell fractions
    dg = dagmc.discretize_geom(mesh, num_rays=num_rays, grid=grid)

    # Reorganize dictionary of each voxel's info with the key the voxel number 
    # and values of cell and volume fraction   
    voxel = {}
    for i in dg:
        idx = i[0]  # voxel number
        if idx not in voxel:
            voxel[idx] = {}
            voxel[idx]['cell'] = []
            voxel[idx]['vol_frac'] = []
        voxel[idx]['cell'].append(i[1])
        voxel[idx]['vol_frac'].append(i[2])

    # get material to cell assignments
    mat_assigns = dagmc.cell_material_assignments(hdf5)

    # Replace cell numbers with materials, eliminating duplicate materials
    # within single zone definition
    zones = {}
    for z in voxel:
        zones[z] = {}
        zones[z]['vol_frac'] = []
        zones[z]['mat'] = []
        for i, cell in enumerate(voxel[z]['cell']):
            if mat_assigns[cell] not in zones[z]['mat']:
                # create new entry
                zones[z]['mat'].append(mat_assigns[cell])
                zones[z]['vol_frac'].append(voxel[z]['vol_frac'][i])
            else:
                # update value that already exists with new volume fraction
                for j, val in enumerate(zones[z]['mat']):
                    if mat_assigns[cell] == val:
                        vol_frac = zones[z]['vol_frac'][j] + voxel[z]['vol_frac'][i]
                        zones[z]['vol_frac'][j] = vol_frac
    
    # Remove vacuum or graveyard from material definition if not vol_frac of 1.0
    skip_array = [['mat:Vacuum'], ['mat:vacuum'], ['mat:Graveyard'], ['mat:graveyard']]
    skip_list = ['mat:Vacuum', 'mat:vacuum', 'mat:Graveyard', 'mat:graveyard']
    zones_compressed = {}
    for z, info in zones.iteritems():
        # check first if the definition is 100% void, keep same if is
        if zones[z]['mat'] in skip_array and zones[z]['vol_frac'] == [1.0]:
            zones_compressed[z] = info
        else:
            # check for partial void
            zones_compressed[z] = {'mat':[], 'vol_frac':[]}
            for i, mat in enumerate(zones[z]['mat']):
                if mat not in skip_list:
                    zones_compressed[z]['mat'].append(mat)
                    zones_compressed[z]['vol_frac'].append(zones[z]['vol_frac'][i])
    
    # Eliminate duplicate zones and assign each voxel a zone number.
    # Assign zone = 0 if vacuum or graveyard and eliminate material definition.
    voxel_zone = {}
    zones_mats = {}
    z = 0
    match = False
    first = True    
    for i, vals in zones_compressed.iteritems():
        # Find if the zone already exists
        for zone, info in zones_mats.iteritems():
            # Iterate through both sets to disregard order
            match_all = np.empty(len(vals['mat']), dtype=bool)
            match_all.fill(False)
            for ii, mat in enumerate(vals['mat']):
                for jj, mat_info in enumerate(info['mat']):
                    if mat == mat_info and np.allclose(np.array(vals['vol_frac'][ii]), \
                                np.array(info['vol_frac'][jj]), rtol=1e-5):
                        match_all[ii] = True
                        break
            if match_all.all() == True:
                match = True
                y = zone
                break
            else:
                match = False
        # Create a new zone if first zone or does not match other zones
        if first or not match:
            # Check that the material is not 100% void (assign zone 0 otherwise)
            if vals['mat'] in skip_array:
                voxel_zone[i] = 0
            else:
                z += 1
                zones_mats[z] = zones_compressed[i]
                voxel_zone[i] = z
                first = False
        else:
            if vals['mat'] in skip_array:
                voxel_zone[i] = 0
            else:
                voxel_zone[i] = y
    
    # Remove any instances of graveyard or vacuum in zone definitions
    zones_novoid = {}
    for z in zones_mats:
        zones_novoid[z] = {'mat':[], 'vol_frac':[]}
        for i, mat in enumerate(zones_mats[z]['mat']):
            if mat not in skip_list:
                name = strip_mat_name(mat)
                zones_novoid[z]['mat'].append(name)
                zones_novoid[z]['vol_frac'].append(zones_mats[z]['vol_frac'][i])
    
    # Put zones into format for PARTISN input
    if 'x' in bounds:
        im = len(bounds['x']) - 1
    else:
        im = 1
    
    if 'y' in bounds:
        jm = len(bounds['y']) - 1
    else:
        jm = 1
    
    if 'z' in bounds:
        km = len(bounds['z']) - 1
    else:
        km = 1

    n = 0
    zones_formatted = np.zeros(shape=(jm*km, im), dtype=int)
    for i in range(im):
        for jk in range(jm*km):
            zones_formatted[jk, i] = voxel_zone[n]
            n += 1
    
    return zones_formatted, zones_novoid
示例#52
0
 def test__load(self):
     # FIXME laoding causes infor to be printied to stderr (or stdout).
     path = os.path.join(os.path.dirname(__file__), 'unitbox.h5m')
     dagmc.load(path)
示例#53
0
            vector.append(float(split_str[5]))
            direction.append(vector)
            # speed
            speed.append(float(split_str[6]))

    

    return xyz,direction,speed


(xyz,direction,speed) = load_input_file("input.txt")

mesh = Mesh(mesh="../geom/conv_pipe_mesh.h5m")

# load dag geometry
load("../geom/conv_pipe_geom.h5m")

# discretise geom onto mesh
cell_fracs = discretize_geom(mesh)

mesh.vol_id = IMeshTag(1,int)
mesh.source_strength = IMeshTag(1,float)
id_list = []
for element in cell_fracs:
    id_list.append(element["cell"])

mesh.vol_id[:]=id_list

# loop along path, use point in volume to determine the vol id 
volumes = get_all_cells(xyz,direction,speed)