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