def evolve(self, dt, *args, **kwargs):
if self.Equilibrium:
self.equilibrium_precrs()
self._Ct = self._C0.copy()
self._Ct_1 = self._C0.copy()
else:
self._Ct_1 = self._Ct.copy()
self.calculate_precrs(dt)
self.t += dt
if self._UseDerivative:
self.dt = dt
self.calculate_source(dt)
self.source_to_file()
self._send_to_lu_17__()
try:
self._CV.run(executable='pre_cit.exe')
except AssertionError:
time.sleep(2.0)
self._CV.run(executable='pre_cit.exe')
self._xsu_mod__()
self.run_transient(self.FluxConvergence)
self._get_power__()
if self.Equilibrium:
self.Equilibrium = False
self.Flux_t_1 = self.Flux_t.copy()
self.Flux_t = MeshFlux(self.__database + '.meshflux', self.Nx, self.Ny,
self.Nz, self._NOG)
return
def _init_flux(self, groups):
self._NOG = groups
self.Flux_t = self.Flux_t_1 = \
MeshFlux(self.__database.replace('S.cdb', '_eq.cdb.meshflux')
, *self.Geom.Cantidad_de_Nodos(), Ng=self._NOG)
self.Nx, self.Ny, self.Nz = self.Flux_t.shape[1:4]
return
def evolve(self, dt, *args, **kwargs):
if self.Equilibrium:
self.equilibrium_precrs()
self._Ct = self._C0.copy()
self._Ct_1 = self._C0.copy()
else:
self._Ct_1 = self._Ct.copy()
self.calculate_precrs(dt)
self.t += dt
if self.__UseDerivative:
self.dt = dt
self.calculate_source(dt)
self.source_to_file()
self.__send_to_lu_17__()
self.__xsu_mod__()
self.run()
self.__get_power__()
if self.Equilibrium:
self.Equilibrium = False
self.Flux_t_1 = self.Flux_t.copy()
self.Flux_t = MeshFlux(self.__database + '.meshflux', self.Nx, self.Ny,
self.Nz, self._NOG)
return
def calculate_precrs(self, dt):
TFlux = MeshFlux(self.__DATABASE + '.meshflux',
*self.__Geom.Cantidad_de_Nodos()[1:4])
self._Ct = PrecCalc(self.__Ct_1,
TFlux,
self.NuFisM,
self.__Geom.Vmesh(),
dt,
LambdaM=self.LambdaM,
BetaM=self.BetaM)
self.__Ct_1 = self._Ct.copy()
self.__Flux_t_1 = TFlux
return
def __init__(self):
super().__init__() # llama a la creación de AerModel
print('- Inicializando Transitorio')
self._C0 = {}
self.__Ct_1 = {}
self._Ct = {}
self.__FILENAME = 'aer.cii'
self.__ROOTFILE = self.__FILENAME[:-4]
self.__DATABASE = self.__ROOTFILE + '_eq.cdb'
self.__Geom = Geometry(self.__FILENAME.replace('.cii', '_geo.ci@'))
self.__NuFis = NuFissionMap()
self.__KM = KineticMap()
self._NOG = 2 # TODO: Sería mejor extraer del ci@?
self.chi_g = [1.0, 0.0] # TODO: Sería mejor extraer del ci@?
self.__Flux_t_1 = self.Flux = MeshFlux(
self.__DATABASE + '.meshflux', *self.__Geom.Cantidad_de_Nodos(),
self._NOG)
Nx, Ny, Nz, _NOG = self.Flux.shape[1:]
self.BetaM = np.empty((1, Nx, Ny, Nz, 6))
self.LambdaM = np.empty((1, Nx, Ny, Nz, 6))
self.NuFisM = np.empty((1, Nx, Ny, Nz, _NOG))
self.VelocityM = np.empty((1, Nx, Ny, Nz, _NOG))
state = 0
static_react = -123.1 # reactividad inicial inicial, no inicial
self.keff = 1 / (1 - static_react / 100000)
self._Q = {}
self.EQUILIBRIUM = True
self.powers = []
for _x in range(Nx):
for _y in range(Ny):
for _z in range(Nz):
meshmaterial = self.__Geom.sc5[_x][_y][_z]
kwargs = {'list_fuels': self.list_fuels, 'time': 0}
self.BetaM[state][_x][_y][_z][:] = \
self.__KM.MapMaterial(meshmaterial, **kwargs)['Beta']
self.LambdaM[state][_x][_y][_z][:] = \
self.__KM.MapMaterial(meshmaterial, **kwargs)['Decays']
self.VelocityM[state][_x][_y][_z][:] = \
self.__KM.MapMaterial(meshmaterial, **kwargs)['Neutron Velocity']
self.NuFisM[state][_x][_y][_z][:] = \
self.__NuFis.MapMaterial(meshmaterial, **kwargs)['XS'][:, 3] / self.keff
def BetaCalculator(FluxFile, Nx, Ny, Nz, Ng, GeometryFile):
Flux = MeshFlux(FluxFile, Nx, Ny, Nz, Ng)
Geo = Geometry(GeometryFile)
chi_p = [1.0, 0.0]
NfMap = Nu_Fission_Map()
KnMap = Kinetic_Map()
FissionRates = np.empty((Nx, Ny, Nz, Ng))
VelocityRates = np.empty((Nx, Ny, Nz, Ng))
OneGroupFlux = np.empty((Nx, Ny, Nz))
OneGroupFiss = np.empty((Nx, Ny, Nz))
DelayedFiss = np.empty((Nx, Ny, Nz))
OneGroupVel = np.empty((Nx, Ny, Nz))
for x in range(Nx):
for y in range(Ny):
for z in range(Nz):
for group in range(Ng):
FissionRates[x, y, z, group] = \
NfMap.MapMaterial(Geo.sc5[x, y, z])['XS'][group, 3] * Flux[0, x, y, z, group] \
* Geo.Vmesh()
VelocityRates[x, y, z, group] = \
KnMap.MapMaterial(Geo.sc5[x, y, z])['Neutron Velocity'][group] * Flux[0, x, y, z, group] \
* Geo.Vmesh()
OneGroupFlux[x, y, z] = Flux[0, x, y, z, :].sum()
OneGroupFiss[x, y, z] = FissionRates[x, y, z, :].sum()
DelayedFiss[x, y, z] = 0.0075 * FissionRates[
x, y, z, :].sum() * Flux[0, x, y, z, :].sum()
# segun otto, esta formula estaría bien, dios sabrá
OneGroupVel[x, y, z] = VelocityRates[x, y, z, :].sum()
Lambda = ((OneGroupVel * OneGroupFlux).sum() /
(OneGroupFiss * OneGroupFlux).sum())
Beta = DelayedFiss.sum() /\
(OneGroupFiss * OneGroupFlux).sum()
return Beta, Lambda
os.chdir('C:\\CUBEM\\')
FILENAME = 'cube.cii'
ROOTFILE = FILENAME[:-4]
DATABASE = ROOTFILE + '_eq.cdb'
Geom = Geometry(FILENAME.replace('.cii', '0.cii'))
NuFis = Nu_Fission_Map()
KM = Kinetic_Map(NPRC=1)
_NOG = 1
NPRC = KM.get_NPRC()
Flux = MeshFlux(DATABASE + '.meshflux', *Geom.Cantidad_de_Nodos(), _NOG)
Nx, Ny, Nz = Flux.shape[1:4]
BetaM = np.empty((1, Nx, Ny, Nz, NPRC))
LambdaM = np.empty((1, Nx, Ny, Nz, NPRC))
NuFisM = np.empty((1, Nx, Ny, Nz, _NOG))
VelocityM = np.empty((1, Nx, Ny, Nz, _NOG))
state = 0
Vmesh = Geom.Vmesh()
# react = grp(ROOTFILE+'.plt')
react = [173.0]
keff = 1 / (1 - react[-1] / 100 / 1000)
# keff = 1.0015
def mainnomain():
os.chdir('D:\\AER\\')
FILENAME = 'aer.cii'
ROOTFILE = FILENAME[:-4]
DATABASE = ROOTFILE + '_eq.cdb'
Geom = Geometry(FILENAME.replace('.cii', '_geo.ci@'))
NuFis = NuFissionMap()
KM = KineticMap()
_NOG = 2
Flux = MeshFlux(DATABASE + '.meshflux', *Geom.Cantidad_de_Nodos(), _NOG)
Nx, Ny, Nz = Flux.shape[1:4]
BetaM = np.empty((1, Nx, Ny, Nz, 1))
LambdaM = np.empty((1, Nx, Ny, Nz, 1))
NuFisM = np.empty((1, Nx, Ny, Nz, _NOG))
VelocityM = np.empty((1, Nx, Ny, Nz, _NOG))
state = 0
Vmesh = Geom.Vmesh()
react = -123.1 # reactividad inicial inicial, no inicial
keff = 1 / (1 - react / 100000)
for _x in range(Nx):
for _y in range(Ny):
for _z in range(Nz):
meshmaterial = Geom.sc5[_x][_y][_z]
KinParam = KM.MapMaterial(meshmaterial) # Obsoleto
BetaM[state][_x][_y][_z][:] = KinParam['Beta']
LambdaM[state][_x][_y][_z][:] = KinParam['Decays']
VelocityM[state][_x][_y][_z][:] = KinParam['Neutron Velocity']
NuFisM[state][_x][_y][_z][:] = NuFis.MapMaterial(
meshmaterial)['XS'][:, 3] / keff
C0 = {}
NPRC = BetaM.shape[-1]
C0[state] = {}
for nx in range(Flux.shape[1]):
C0[state][nx] = {}
for ny in range(Flux.shape[2]):
C0[state][nx][ny] = {}
for nz in range(Flux.shape[3]):
FluxL = [
Flux[state, nx, ny, nz, group]
for group in range(Flux.shape[-1])
]
NuFisL = [
NuFisM[state][nx][ny][nz][group]
for group in range(Flux.shape[-1])
]
Nu_FluxM = [
NuFisL[group] * FluxL[group] * Vmesh
for group in range(Flux.shape[-1])
]
Bet_k = BetaM[state][nx][ny][nz]
Lamb_k = LambdaM[state][nx][ny][nz]
Nu_Flux = sum(Nu_FluxM)
C0[state][nx][ny][nz] = [
Bet_k[prec] * Nu_Flux /
Lamb_k[prec] if Lamb_k[prec] != 0 else 0.0
for prec in range(NPRC)
]
p = re.compile(r'POWER\(WATTS\)\s+([0-9]\.[0-9]{5}E\+[0-9]{2})')
powers = []
Q = {}
EQUILIBRIUM = True
chi_g = [1.0, 0.0]
v1 = 1.25E+7
v2 = 2.50E+5
dt = 0.01
tfinal = 0.5
DATABASE = ROOTFILE + 'S.cdb'
Times = np.arange(0, tfinal + 2 * dt, dt)
FAILED_COMPLETE_TEST = False
DERIVATIVE = True
for t in Times:
if EQUILIBRIUM:
C_t_1 = C0.copy()
C_t = C0.copy()
Flux_t_1 = Flux
else:
TFlux = MeshFlux(DATABASE + '.meshflux', Nx, Ny, Nz, _NOG)
# noinspection PyUnboundLocalVariable
C_t = PrecCalc(C_t_1,
TFlux,
NuFisM,
Vmesh,
dt,
LambdaM=LambdaM,
BetaM=BetaM)
C_t_1 = C_t.copy()
Flux_t_1 = TFlux
for group in range(Flux.shape[-1]):
Q[group] = {}
for state in range(Flux.shape[0]):
Q[group][state] = {}
for nx in range(Flux.shape[1]):
Q[group][state][nx] = {}
for ny in range(Flux.shape[2]):
Q[group][state][nx][ny] = {}
for nz in range(Flux.shape[3]):
_Lmk = LambdaM[state][nx][ny][nz]
_C = C_t[state][nx][ny][nz]
_invV = VelocityM[state, nx, ny, nz, group]
T_1Flux = Flux_t_1[state, nx, ny, nz, group]
Q[group][state][nx][ny][nz] = \
chi_g[group] * sum([_Lmk[prc] * _C[prc] for prc in range(NPRC)]) \
+ _invV / dt * T_1Flux * Vmesh * DERIVATIVE #
with open('source.dat', 'w') as fod:
for group in range(_NOG):
for state in range(Flux.shape[0]):
for nz in range(Flux.shape[3]):
for ny in range(Flux.shape[2]):
for nx in range(Flux.shape[1]):
fod.write('{:15.7E}'.format(
Q[group][state][nx][ny][nz]))
fod.write('\n')
# Ejecución de archivo AQUI
OsArgs = (FILENAME.replace('.cii',
'S.cii'), _NOG, Nx, Ny, Nz, EQUILIBRIUM,
*['{:12.5E}'.format(_d) for _d in [dt * DERIVATIVE, t]])
# PARA HACER UNA PERTURBACION ESCALOR,COLOCAR t=1
# PARA CALCULAR SIN DERIVADA TEMPORAL dt=0
try:
os.system('ExAer.bat ' + ' '.join(map(str, OsArgs)))
fid = open(ROOTFILE + 'S.cio', 'r')
powers.append(float(next(p.finditer(fid.read())).groups()[0]))
print(powers[-1])
fid.close()
if EQUILIBRIUM: EQUILIBRIUM = False
except StopIteration:
FAILED_COMPLETE_TEST = True
break
pass
Normalized_Pow = np.array(powers) / 1E+06
if FAILED_COMPLETE_TEST: Times = [k * dt for k in range(len(powers))]
return
# coding: utf-8
# In[13]:
import sys
sys.path.append('D:\\')
from PyCAR.PyCIT.FT import MeshFlux,MeshPower
import numpy as np
from PyCAR.PyCIT.FT import GroupFlux
from citvappru.SourceCAREM2_1_1 import Geometry,PrecCalc
BetaDir='D:\\Cube\\'
Flux = MeshFlux(BetaDir+'NoobCube1g.cdb.meshflux',Nodosx,Nodosy,Nodosz,Ngrupos)
NPRC = 6
NOGBIB = Flux.shape[-1]
#NuFis=[2.0150E-02]
lmks=[0.0124,0.0306,0.1135,0.3071,1.1905,3.1748]
Betas=[0.0002170,0.0014979,0.0013778,0.0028296,0.0009288,0.0003314,0.0071826]
BetT=Betas[-1]
#valor obtenido de NoobCube2g.cii
keff = 1.00055
keff = 1.0005462
chi_g=[0.999827,0.000173]
#NuFis=[2.8132E-02,3.6287E-02]
NuFis=[2.81322002E-03,3.62874009E-02]
def _init_flux(self):
self.Flux_t = self.Flux_t_1 = \
MeshFlux(self.__database.replace('S.cdb', '_eq.cdb.meshflux')
, self.Nx, self.Ny, self.Nz, self._NOG)
return