# -------------------------------------------------------------------------
TESTDIR = "2d3g_simplifiedBWR/"
PROB_NAME = "2d3g_simplifiedBWR_Kr4_FD"
DESCRIPTION = ("Lattice problem.")
forest = RunForest(prob_name=PROB_NAME, description=DESCRIPTION)
# Settings ----------------------------------------------------------------
ALGEBRA = setalgebra(matfree=True,
eig=["Krylov:4:9", 1.e-7, 1000, "FD"],
inner=["Krylov", 1.e-9, 1000, 2])
METHOD = setmethod(mtype='transport', quad=['LevelSymType2', 4])
# METHOD = setmethod(mtype='diffusion')
FE_SETTINGS = dict([('degree', 2), ('n_ref', 1)])
forest.set_settings(method=METHOD,
fe_settings=FE_SETTINGS,
algebra=ALGEBRA)
# Geometry ----------------------------------------------------------------
CORE = dict([
('composed', True),
('name', 'Lattice'),
('nnodes', [1, 1]),
('length', [[14.0], [14.0]]),
('components', [0]),
('boundary', [0, 0, 0, 0]),
])
LATT = dict()
LATT[0] = dict([
('type', 'grid'),
('name', 'assembly'),
('nnodes', [19, 19]),
from prob.runforest import RunForest
from prob.runforest import newpin
from prob.settings import setmethod
if __name__ == "__main__":
# -------------------------------------------------------------------------
TESTDIR = "2dg7_1x1pins/"
PROB_NAME = "2dg7_1x1pins"
DESCRIPTION = ("Lattice problem.")
forest = RunForest(prob_name=PROB_NAME, description=DESCRIPTION)
# Settings ----------------------------------------------------------------
METHOD = setmethod(mtype='transport',quad=['LevelSymType2', 4])
#METHOD = setmethod(mtype='diffusion')
FE_SETTINGS= dict([('degree', 0), ('n_ref', 1)])
forest.set_settings(method=METHOD, fe_settings=FE_SETTINGS)
# Geometry ----------------------------------------------------------------
CORE = dict([
('composed', True),
('name', 'Pin2d'),
('nnodes', [1, 1]),
('length', [[1.26], [1.26]]),
('components', [0]),
('boundary', [0, 0, 0, 0]),
#('boundary', [2, 2, 2, 2]),
])
LATT = dict()
LATT[0] = dict([
('type', 'pin_map'),
('name', 'assembly'),
('nnodes', [1, 1]),
from prob.runforest import newpin
from prob.settings import setmethod, setalgebra
if __name__ == "__main__":
# -------------------------------------------------------------------------
TESTDIR = "2d3g_minicore/"
PROB_NAME = "2d3g_minicore"
DESCRIPTION = ("Mini core problem.")
forest = RunForest(prob_name=PROB_NAME, description=DESCRIPTION)
# Settings ----------------------------------------------------------------
METHOD = setmethod(mtype='transport', quad=['LevelSymType2', 8])
ALGEBRA = setalgebra(matfree=True, eig=["PI", 1.e-3, 1000])
#ALGEBRA = setalgebra(matfree=True, eig=["Krylov:2",1.e-7,1000, "Standard"])
#METHOD = setmethod(mtype='diffusion')
forest.set_settings(method=METHOD, algebra=ALGEBRA)
# Geometry ----------------------------------------------------------------
CORE = dict([
('composed', True),
('name', 'Mini core'),
('nnodes', [3, 3]),
('length', [[5.0, 5.0, 5.0], [5.0, 5.0, 5.0]]),
('components', [[1, 2, 0], [2, 1, 0], [0, 0, 0]]),
('boundary', [2, 0, 2, 0]),
])
LATT = dict()
LATT[0] = dict([
('type', 'pin_map'),
('name', 'moderator'),
('nnodes', [5, 5]),
('components', [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0],
"octave:5> (sf1*sa2 + sf2*s12)/((sa1+s12)*sa2+sa2) \n"
"ans = 1.33292550586827 ?? \n"
"#the formulas for the cross sections are \n"
"SigmaT = 1/(3*D) \n"
"SigmaS_{g,g} = SigmaT - SigmaA_{g->g} + Sum_{h not g}(SigmaS_{g->h}) \n"
"I am not sure now, but it depends on the scattering in and out, as \n"
"they explain here: \n"
"Reactor Physics: Multigroup Diffusion \n"
"prepared by W m . J. Garland, Professor, \n"
"Department of Engineering Physics, \n"
"McMaster University, Hamilton, Ontario, Canada \n"
"http://www.nuceng.ca/ep4d3/text/9-multigroup.pdf.")
forest = RunForest(prob_name=PROB_NAME, description=DESCRIPTION)
# Settings ----------------------------------------------------------------
METHOD = setmethod(mtype='diffusion')
forest.set_settings(method=METHOD)
# Geometry ----------------------------------------------------------------
CORE = dict([('composed', True), ('name', 'GeorgiaTech1D'),
('nnodes', [1]), ('length', [[15.24]]), ('components', [0]),
('boundary', [2, 2])])
LATT = dict()
LATT[0] = dict([('type', 'grid'), ('name', 'assembly'), ('nnodes', [6]),
('components', [0, 0, 0, 0, 0, 0]),
('length', [2.54, 2.54, 2.54, 2.54, 2.54, 2.54])])
forest.set_geometry(dim=1, core=CORE, lattices=LATT)
# Materials ---------------------------------------------------------------
MIX = dict()
MIX[0] = dict([('name', 'moderator'),
('SigmaT', np.array([0.2203944178, 1.1188498224])),
('Chi', np.array([1.0000000000, 0.0000000000])),
('SigmaS',
def test():
"""
>>> PROB_NAME = "1d1g_heter"
>>> forest = RunForest(prob_name=PROB_NAME)
>>> forest_refl = RunForest(prob_name=PROB_NAME+"_refl")
>>> METHOD = setmethod(mtype='transport', dsa=False, quad=['GaussLegendre', 96])
>>> ALGEBRA = setalgebra(matfree=True)
>>> FE_SETTINGS= dict([('degree', 2), ('n_ref', 2)])
>>> forest.set_settings(method=METHOD, fe_settings=FE_SETTINGS, algebra=ALGEBRA)
>>> forest_refl.set_settings(method=METHOD, fe_settings=FE_SETTINGS)
>>> LATT = dict()
>>> LATT[0] = dict([('type', 'grid'), \
('nnodes', [7]), \
('components', [0, 1, 0, 1, 0, 1, 0]), \
('length', [2.7, 2.4, 2.7, 2.4, 2.7, 2.4, 2.7])])
>>> CORE = dict([('composed', True), \
('nnodes', [1]), \
('length', [[18.0]]), \
('components', [0]), \
('boundary', [0, 0])])
>>> forest.set_geometry(dim=1, core=CORE, lattices=LATT)
>>> LATT = dict()
>>> LATT[0] = dict([('type', 'grid'), \
('nnodes', [4]), \
('components', [1, 0, 1, 0]), \
('length', [1.2, 2.7, 2.4, 2.7])])
>>> CORE = dict([('composed', True), \
('nnodes', [1]), \
('length', [[9.0]]), \
('components', [0]), \
('boundary', [2, 0])])
>>> forest_refl.set_geometry(dim=1, core=CORE, lattices=LATT)
>>> MIX = dict()
>>> MIX[0] = dict([('name', 'moderator'), \
('SigmaT', [0.37037000]), \
('Chi', [1.00000000]), \
('SigmaS', [0.33400000]), \
('NuSigF', [0.00000000])])
>>> MIX[1] = dict([('name', 'fuel'), \
('SigmaT', 0.41666700), \
('Chi', 1.00000000), \
('SigmaS', 0.33400000), \
('NuSigF', 0.17800000)])
>>> forest.set_materials(ngroups=1, mix=MIX)
>>> forest_refl.set_materials(ngroups=1, mix=MIX)
>>> forest.run() # doctest: +ELLIPSIS
Running: ...
>>> forest_refl.run() # doctest: +ELLIPSIS
Running: ...
>>> keff = forest.get_keff()
>>> keff_refl = forest_refl.get_keff()
>>> abs(keff-1.16222540417) < 1.e-6
True
>>> abs(keff_refl-1.16222594896) < 1.e-6
True
>>> abs(keff - keff_refl)< 1.e-6
True
"""
# -------------------------------------------------------------------------
TESTDIR = "1d1g_heter/"
PROB_NAME = "1d1g_heter"
DESCRIPTION = ("Seven Regions Heterogeneous 1D Slab \n \n"
"The reference result is keff = 1.16224, and it has \n"
"been obtained from ONEDANT, using an angular \n"
"quadrature order of S96, with 500 fine mesh cells \n"
"in each region and a convergence criterion of \n"
"tol = 1.e-6, as it was reported in: \n \n"
"M. Capilla, CF. Talavera, D. Ginestar, G. Verdu, \n"
"\"A nodal collocation method for the calculation of \n"
"the lambda modes of the P_L equations'; \n"
"Annals of Nuclear Energy, 32, (2005), 1825-1853.")
forest = RunForest(prob_name=PROB_NAME, description=DESCRIPTION)
forest_refl = RunForest(prob_name=PROB_NAME + "_refl",
description=DESCRIPTION)
# Settings ----------------------------------------------------------------
METHOD = setmethod(mtype='transport',
dsa=False,
quad=['GaussLegendre', 96])
#METHOD = setmethod(mtype='transport', quad=['GaussLegendre', 96])
#METHOD = setmethod(mtype='diffusion')
#ALGEBRA = setalgebra(matfree=True)
#ALGEBRA = setalgebra(matfree=True, eig=["PI",1.e-7,1000])
#ALGEBRA = setalgebra(matfree=True, form=,'Standard',eig=["Krylov:1:3",1.e-7,1000], inner=["Krylov",1.e-9,1000,1])
ALGEBRA = setalgebra(matfree=True,
form='Standard',
eig=["Krylov:1:3", 1.e-7, 1000],
mg=["krylov", 1.e-7, 100],
inner=["Krylov", 1.e-9, 1000])
#ALGEBRA = setalgebra(matfree=True, eig=["PI",1.e-7,1000,'Standard'], inner=["Krylov",1.e-9,1000,1])
FE_SETTINGS = dict([('degree', 2), ('n_ref', 2)])
forest.set_settings(method=METHOD,
fe_settings=FE_SETTINGS,
algebra=ALGEBRA)
forest_refl.set_settings(method=METHOD,
fe_settings=FE_SETTINGS,
algebra=ALGEBRA)
# Geometry ----------------------------------------------------------------
LATT = dict()
lenr = 2.7 #1.0/0.371
lenf = 2.4 #1.0/0.415
LATT[0] = dict([('type', 'grid'), ('nnodes', [7]),
('components', [0, 1, 0, 1, 0, 1, 0]),
('length', [lenr, lenf, lenr, lenf, lenr, lenf, lenr])])
CORE = dict([('composed', True), ('nnodes', [1]), ('length', [[18.0]]),
('components', [0]), ('boundary', [0, 0])])
forest.set_geometry(dim=1, core=CORE, lattices=LATT)
# Geometry ----------------------------------------------------------------
LATT = dict()
lenr = 2.7 #1.0/0.371
lenf = 2.4 #1.0/0.415
LATT[0] = dict([('type', 'grid'), ('nnodes', [4]),
('components', [0, 1, 0, 1]),
('length', [lenr, lenf, lenr, lenf / 2])])
CORE = dict([('composed', True), ('nnodes', [1]), ('length', [[9.0]]),
('components', [0]), ('boundary', [0, 2])])
forest_refl.set_geometry(dim=1, core=CORE, lattices=LATT)
# Materials ---------------------------------------------------------------
MIX = dict()
MIX[0] = dict([('name', 'moderator'), ('SigmaT', [0.37037000]),
('Chi', [1.00000000]), ('SigmaS', [0.33400000]),
('NuSigF', [0.00000000])])
MIX[1] = dict([('name', 'fuel'), ('SigmaT', 0.41666700),
('Chi', 1.00000000), ('SigmaS', 0.33400000),
('NuSigF', 0.17800000)])
forest.set_materials(ngroups=1, mix=MIX)
forest_refl.set_materials(ngroups=1, mix=MIX)
# Running forest ----------------------------------------------------------
forest.run()
#forest.memory()
forest_refl.run()
def test():
"""Return the keff of the Reactor
>>> TESTDIR = "2d1g_homog/"
>>> PROB_NAME = "2d1g_homog"
>>> forest = RunForest(prob_name=PROB_NAME)
>>> METHOD = setmethod(mtype='transport', dsa=False, quad=['LevelSymType2', 4])
>>> FE_SETTINGS= dict([('degree', 1), ('n_ref', 2)])
>>> ALGEBRA = setalgebra(matfree=True)
>>> forest.set_settings(method=METHOD, fe_settings=FE_SETTINGS, algebra=ALGEBRA)
>>> CORE = dict([('composed', True), \
('name', 'mini core'), \
('nnodes', [1, 1]), \
('length', [[2.0], [2.0]]), \
('components', [0]), \
('boundary', [0, 0, 2, 2])])
>>> LATT = dict()
>>> LATT[0] = dict([('type', 'grid'), \
('name', 'assembly'), \
('nnodes', [5, 5]), \
('components', [[0, 0, 0, 0, 0], \
[0, 0, 0, 0, 0], \
[0, 0, 0, 0, 0], \
[0, 0, 0, 0, 0], \
[0, 0, 0, 0, 0]]), \
('length', [[0.4]*5, [0.4]*5])])
>>> forest.set_geometry(dim=2, core=CORE, lattices=LATT)
>>> MIX = dict()
>>> MIX[0] = dict([('name', 'fuel'), \
('SigmaT', 1.0000000000), \
('Chi', 1.0000000000), \
('SigmaS', 0.9000000000), \
('NuSigF', 0.2500000000)])
>>> forest.set_materials(ngroups=1, mix=MIX)
>>> forest.run() # doctest: +ELLIPSIS
Running: ...
>>> abs(forest.get_keff()-0.6383561482185065) < 1.e-6
True
"""
# -------------------------------------------------------------------------
TESTDIR = "2d1g_homog/"
PROB_NAME = "2d1g_homog"
DESCRIPTION = (
'Homogeneous slab 10.0 cm (it can be a 2.0 cm or 10.0 cm slab) \n'
'The reference for sn = 96 is keff = 0.662951 (2cm slab) \n'
'The reference for sn = 96 is keff = 2.00193 (10cm slab) \n'
'This problem is provided in the following paper: \n \n'
'M. Capilla, CF. Talavera, D. Ginestar, G. Verdu, \n'
'"A nodal collocation method for the calculation of \n'
'the lambda modes of the P_L equations"; \n'
'Annals of Nuclear Energy, 32, (2005), 1825--1853.')
forest = RunForest(prob_name=PROB_NAME, description=DESCRIPTION)
# Settings ----------------------------------------------------------------
METHOD = setmethod(mtype='transport', dsa=False, quad=['LevelSymType2', 4])
#METHOD = setmethod(mtype='transport',quad=['LevelSymType2', 2])
#METHOD = setmethod(mtype='diffusion')
FE_SETTINGS = dict([('degree', 1), ('n_ref', 1)])
#ALGEBRA = setalgebra(matfree=False)
#ALGEBRA = setalgebra(matfree=True)
ALGEBRA = setalgebra(matfree=True, eig=["PI", 1.e-7, 1000])
#ALGEBRA = setalgebra(matfree=True, eig=["Krylov",1.e-7,1000])
forest.set_settings(method=METHOD,
fe_settings=FE_SETTINGS,
algebra=ALGEBRA)
# Geometry ----------------------------------------------------------------
CORE = dict([('composed', True), ('name', 'mini core'), ('nnodes', [1, 1]),
('length', [[2.0], [2.0]]), ('components', [0]),
('boundary', [0, 0, 0, 0])])
LATT = dict()
LATT[0] = dict([('type', 'grid'), ('name', 'assembly'), ('nnodes', [5, 5]),
('components', [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0],
[0, 0, 0, 0, 0], [0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]]),
('length', [[0.4] * 5, [0.4] * 5])])
forest.set_geometry(dim=2, core=CORE, lattices=LATT)
# Materials ---------------------------------------------------------------
MIX = dict()
MIX[0] = dict([('name', 'fuel'), ('SigmaT', 1.0000000000),
('Chi', 1.0000000000), ('SigmaS', 0.9000000000),
('NuSigF', 0.2500000000)])
forest.set_materials(ngroups=1, mix=MIX)
# Running forest ----------------------------------------------------------
#forest.run()
forest.memory()
('name', 'Core'),
('nnodes', [1]),
('length', [[21.42]]),
('components', [[2]]),
('boundary', [2, 2]),
])
# Renaming files ----------------------------------------------------------
PROB_ASS1 = '1dg7_c5g7_heter_ASS1'
PROB_ASS2 = '1dg7_c5g7_heter_ASS2'
# -------------------------------------------------------------------------
probAss1 = RunForest(prob_name=PROB_ASS1, description=DESCRIPTION)
probAss1.set_materials(ngroups=7, mix=MIX)
probAss1.set_geometry(dim=1, core=COREASS1, lattices=LATT, pins=PIN)
OUTPUT = dict([("homogenize", True)])
probAss1.set_settings(method=METHOD,
fe_settings=FE_SETTINGS,
output=OUTPUT)
# -------------------------------------------------------------------------
probAss2 = RunForest(prob_name=PROB_ASS2, description=DESCRIPTION)
probAss2.set_materials(ngroups=7, mix=MIX)
probAss2.set_geometry(dim=1, core=COREASS2, lattices=LATT, pins=PIN)
probAss2.set_settings(method=METHOD,
fe_settings=FE_SETTINGS,
output=OUTPUT)
# Running forest ----------------------------------------------------------
# -------------------------------------------------------------------------
probAss1.run()
probAss1.clean()
# -------------------------------------------------------------------------
probAss2.run()
probAss2.clean()
def oneDc5g7_noupscattering(pinSize, method, nev=1, ncv=3):
# -------------------------------------------------------------------------
# TESTDIR = "1d7g_c5g7_noupscattering/"
pinSize_str = str(pinSize).replace('.', '')
if method is 'kr':
method_str = 'Krylov:' + str(nev) + ':' + str(ncv)
PROB_NAME = ("1dg7_c5g7_" + method + '_' + pinSize_str + "cm" +
'_nev' + str(nev) + '_ncv' + str(ncv))
else:
method_str = 'PI'
PROB_NAME = "1dg7_c5g7_" + method + '_' + pinSize_str + "cm"
# If out file exists do not do anything
out_file = PROB_NAME + '.out.xml'
if (os.path.isfile(out_file)):
return PROB_NAME
DESCRIPTION = ("One-dimensional heterogeneous version of the c5g7.")
forest = RunForest(prob_name=PROB_NAME, description=DESCRIPTION)
# Settings ----------------------------------------------------------------
METHOD = setmethod(mtype='transport', quad=['GaussLegendre', 16])
#METHOD = setmethod(mtype='diffusion')
FE_SETTINGS = dict([('degree', 2), ('n_ref', 1)])
ALGEBRA = setalgebra(matfree=True,
eig=[method_str, 1.e-7, 1000, "Standard"],
inner=["Krylov", 1.e-9, 1000])
forest.set_settings(method=METHOD,
fe_settings=FE_SETTINGS,
algebra=ALGEBRA)
# Geometry ----------------------------------------------------------------
CORE = dict([
('composed', True),
('name', 'Core'),
('nnodes', [3]),
('length', [[17 * pinSize, 17 * pinSize, 17 * pinSize]]),
('components', [[2, 1, 2]]),
('boundary', [2, 2]),
])
LATT = dict()
LATT[1] = dict([
('type', 'pin_map'),
('name', 'MOX'),
('nnodes', [17]),
('components', [[2, 3, 6, 4, 4, 6, 4, 4, 5, 4, 4, 6, 4, 4, 6, 3, 2]]),
#('components', [[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]]),
('water_gap', [0., 0.]),
('length', [[pinSize] * 17]),
])
LATT[2] = dict([
('type', 'pin_map'),
('name', 'UOX'),
('nnodes', [17]),
('components', [[1, 1, 6, 1, 1, 6, 1, 1, 5, 1, 1, 6, 1, 1, 6, 1, 1]]),
#('components', [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]),
('water_gap', [0., 0.]),
('length', [[pinSize] * 17]),
])
PIN = dict()
PIN[0] = newpin(ptype='box', mat=[0], name='moderator')
PIN[1] = newpin(ptype='pin', mat=[0, 1], fradius=0.54, name='UO2')
PIN[2] = newpin(ptype='pin', mat=[0, 2], fradius=0.54, name='MOX4.3')
PIN[3] = newpin(ptype='pin', mat=[0, 3], fradius=0.54, name='MOX7.0')
PIN[4] = newpin(ptype='pin', mat=[0, 4], fradius=0.54, name='MOX8.7')
PIN[5] = newpin(ptype='pin', mat=[0, 5], fradius=0.54, name='fisschamber')
PIN[6] = newpin(ptype='pin', mat=[0, 6], fradius=0.54, name='guidetube')
forest.set_geometry(dim=1, core=CORE, lattices=LATT, pins=PIN)
# Materials ---------------------------------------------------------------
from get_c5g7_materials import get_c5g7_materials
MIX = get_c5g7_materials()
forest.set_materials(ngroups=7, mix=MIX)
# Running forest ----------------------------------------------------------
forest.run()
forest.clean()
return PROB_NAME
if __name__ == "__main__":
# -------------------------------------------------------------------------
TESTDIR = "1d2g_periodic"
PROB_HOM = "1d2g_periodic_homog"
PROB_HET = "1d2g_periodic_heter"
DESCRIPTION = ("Simplified version of the georgiatech.")
forest_hom = RunForest(prob_name=PROB_HOM, description=DESCRIPTION)
forest_het = RunForest(prob_name=PROB_HET, description=DESCRIPTION)
# Settings ----------------------------------------------------------------
METHOD = setmethod(mtype='transport', quad=['GaussLegendre', 48])
#METHOD = setmethod(mtype='diffusion')
FE_SETTINGS = dict([('degree', 2), ('n_ref', 2)])
OUTPUT = dict([("homogenize", False)])
forest_hom.set_settings(method=METHOD,
fe_settings=FE_SETTINGS,
output=OUTPUT)
forest_het.set_settings(method=METHOD,
fe_settings=FE_SETTINGS,
output=OUTPUT)
# Geometry ----------------------------------------------------------------
CORE_HOM = dict([
('composed', True),
('name', 'Core'),
('nnodes', [2]),
('length', [[15.24, 15.24]]),
('components', [[0, 0]]),
('boundary', [2, 2]),
])
CORE_HET = dict([
('composed', True),