def __init__(self, factor1='0', factor2='0', answer='0', operator='+'): #因子1 self.factor1 = Factors(factor1) #因子2 self.factor2 = Factors(factor2) #结果 self.answer = Factors(answer) #符号 self.operator = Operators(operator) #是否为等式 if self.operator.val() == 1: if self.factor1.val() + self.factor2.val() == self.answer.val(): self.equal = True else: self.equal = False elif self.operator.val() == 2: if self.factor1.val() - self.factor2.val() == self.answer.val(): self.equal = True else: self.equal = False else: if self.factor1.val() * self.factor2.val() == self.answer.val(): self.equal = True else: self.equal = False
def IntermolecularIneffectiveCollision(self, mole, oldMol1, oldMol2, index1, index2): operator = Operators() newMol1, newMol2 = operator.Intermolecular(oldMol1, oldMol2) pe1 = CRO().CalculatePE(mole, newMol1) pe2 = CRO().CalculatePE(mole, newMol2) e_inter = 0 gamma4 = random.uniform(0, 1) mole.numHit[index1] = mole.numHit[index1] + 1 mole.numHit[index2] = mole.numHit[index2] + 1 e_inter = (mole.PE1[index1] + mole.PE1[index2] + mole.KE1[index1] + mole.KE1[index2]) - (pe1 + pe2) if (e_inter >= 0): mole.moleculeTable[index1] = newMol1 mole.moleculeTable[index2] = newMol2 mole.PE1[index1] = pe1 mole.PE1[index2] = pe2 mole.KE1[index1] = e_inter * gamma4 mole.KE1[index2] = e_inter * (1 - gamma4) if (mole.PE1[index1] < mole.minPE[index1]): mole.minStruct[index1] = mole.moleculeTable[index1] mole.minPE[index1] = mole.PE1[index1] mole.minHit[index1] = mole.numHit[index1] # endif if (mole.PE1[index2] < mole.minPE[index2]): mole.minStruct[index2] = mole.moleculeTable[index2] mole.minPE[index2] = mole.PE1[index2] mole.minHit[index2] = mole.numHit[index2]
def __init__(self,param,grid): self.list_param=['forcing','noslip','timestepping','diffusion','Kdiff', 'forcing_module','gravity','isisland', 'customized','custom_module','additional_tracer'] param.copy(self,self.list_param) # for potential energy self.list_param=['xr','yr','nh','Lx','msk','area','mpitools'] grid.copy(self,self.list_param) # for variables param.varname_list=['vorticity','psi','u','v','buoyancy'] param.tracer_list=['vorticity','buoyancy'] param.whosetspsi=('vorticity') if hasattr(self,'additional_tracer'): for k in range(len(self.additional_tracer)): trac=self.additional_tracer[k] param.varname_list.append(trac) param.tracer_list.append(trac) print('Tracers are :',param.tracer_list) param.sizevar =[grid.nyl,grid.nxl] self.var = Var(param) self.source = zeros(param.sizevar) # for operators self.ope = Operators(param,grid) # for timescheme self.tscheme = Timescheme(param,self.var.state) self.tscheme.set(self.dynamics, self.timestepping) if self.forcing: try: f = import_module(self.forcing_module) except: print('module %s for forcing cannot be found'%self.forcing_module) print('make sure file **%s.py** exists'%self.forcing_module) exit(0) self.forc = f.Forcing(param,grid) self.diags={} if self.customized: try: f = import_module(self.custom_module) print(f) self.extrastep = f.Step(param,grid) except: print('module %s for forcing cannot be found'%self.custom_module) print('make sure file **%s.py** exists'%self.custom_module) exit(0)
def __init__(self, param, grid): self.list_param = ['forcing', 'noslip', 'timestepping', 'forcing_module', 'additional_tracer', 'myrank', 'gravity', 'diffusion', 'Kdiff', 'f0'] param.copy(self, self.list_param) # for potential energy self.list_param = ['xr', 'yr', 'nh', 'Lx', 'msk', 'area', 'mpitools', 'dx'] grid.copy(self, self.list_param) # for variables param.varname_list = ['vorticity', 'psi', 'u', 'v', 'buoyancy', 'V', 'qE'] param.tracer_list = ['vorticity', 'buoyancy', 'V'] param.whosetspsi = ('vorticity') if hasattr(self, 'additional_tracer'): for k in range(len(self.additional_tracer)): trac = self.additional_tracer[k] param.varname_list.append(trac) param.tracer_list.append(trac) param.sizevar = [grid.nyl, grid.nxl] self.var = Var(param) # for operators self.ope = Operators(param, grid) # for timescheme self.tscheme = Timescheme(param, self.var.state) if self.forcing: if self.forcing_module == 'embedded': print('Warning: check that you have indeed added the forcing to the model') print('Right below the line : model = f2d.model') print('you should have the line: model.forc = Forcing(param, grid)') pass else: try: f = import_module(self.forcing_module) except ImportError: print('module %s for forcing cannot be found' % self.forcing_module) print('make sure file **%s.py** exists' % self.forcing_module) sys.exit(0) self.forc = f.Forcing(param, grid) self.diags = {}
def _infix_to_posfix_part_two(input): output = Queue() operator_stack = [] bracket_count = 0 grouped_operators = '' for c in input: if represents_int(c) and bracket_count == 0: output.put(int(c)) elif bracket_count > 0 or Operators(c) == Operators.OPEN_BRACKET: # push all values grouped together and recursively solve grouped_operators += c is_number = represents_int(c) if not is_number and Operators(c) == Operators.OPEN_BRACKET: bracket_count += 1 elif not is_number and Operators(c) == Operators.CLOSE_BRACKET: bracket_count -= 1 # if last close bracket solve and treat as operator if bracket_count == 0: output.put( evaluate_equation_part_two(grouped_operators[1:-1])) grouped_operators = '' elif len(operator_stack) > 0: # peek at last operator to determine precedence level last_operator = operator_stack[-1] current_operator = Operators(c) # addition is evaluated before multiplication _check_operator(output, operator_stack, current_operator, last_operator) else: operator_stack.append(Operators(c)) for val in operator_stack[::-1]: output.put(val) return output
def __init__(self, param, grid): self.list_param = [ 'forcing', 'diffusion', 'Kdiff', 'noslip', 'timestepping', 'beta', 'Rd', 'forcing_module' ] param.copy(self, self.list_param) # for diagnostics self.list_param = ['yr', 'nh', 'msk', 'area', 'mpitools'] grid.copy(self, self.list_param) # for variables param.varname_list = ('pv1', 'psi1', 'u1', 'v1', 'pv2', 'psi2', 'u2', 'v2') param.sizevar = [grid.nyl, grid.nxl] self.var = Var(param) self.source = zeros(param.sizevar) # self.ipva = self.var.varname_list.index('pvanom') # self.ipv = self.var.varname_list.index('pv') # self.ivor = self.var.varname_list.index('vorticity') # self.ipsi = self.var.varname_list.index('psi') # background pv self.pvback = self.beta * (grid.yr - grid.Ly * .5) * grid.msk # for operators param.tracer_list = ['pv1', 'pv2'] param.whosetspsi = ('pvanom') param.qgoperator = True self.ope = Operators(param, grid) # for timescheme self.tscheme = Timescheme(param, self.var.state) self.dx0 = self.tscheme.dx0 self.kt = 0 if self.forcing: try: f = import_module(self.forcing_module) except: print('module %s for forcing cannot be found' % self.forcing_module) print('make sure file **%s.py** exists' % self.forcing_module) exit(0) self.forc = f.Forcing(param, grid) self.diags = {} self.tscheme.set(self.dynamics, self.timestepping)
def __init__(self, config=None): self.config = config self.config.de = self self.size = self.config.size self.dimensions = self.config.dimensions self.population = Population(config=config) self.operators = Operators(config=config) self.config.population = self.population
def _infix_to_posfix_part_one(input): output = Queue() operator_stack = [] bracket_count = 0 grouped_operators = '' for c in input: if represents_int(c) and bracket_count == 0: output.put(int(c)) elif bracket_count > 0 or Operators(c) == Operators.OPEN_BRACKET: # push all values grouped together and recursively solve grouped_operators += c is_number = represents_int(c) if not is_number and Operators(c) == Operators.OPEN_BRACKET: bracket_count += 1 elif not is_number and Operators(c) == Operators.CLOSE_BRACKET: bracket_count -= 1 # if last close bracket solve and treat as operator if bracket_count == 0: output.put( evaluate_equation_part_one(grouped_operators[1:-1])) grouped_operators = '' elif len(operator_stack) > 0: # equal precedence output.put(operator_stack.pop()) operator_stack.append(Operators(c)) else: operator_stack.append(Operators(c)) for val in operator_stack[::-1]: output.put(val) return output
def __init__(self, param, grid): self.list_param = ['forcing', 'noslip', 'timestepping'] param.copy(self, self.list_param) # for variables param.varname_list = ('vorticity', 'psi', 'u', 'v', 'buoyancy', 'V') param.sizevar = [grid.nyl, grid.nxl] self.var = Var(param) # for operators param.tracer_list = ['vorticity', 'buoyancy', 'V'] param.whosetspsi = ('vorticity') self.ope = Operators(param, grid) # for timescheme self.tscheme = Timescheme(param, self.var.state)
def Decomposition(self,mole,oldMol,index,shiftcost,flowcost,N): operator = Operators() newMol1, newMol2 = operator.Decomposition(oldMol) #print('DEcom ',newMol1,'\n',newMol2) pe1 = CRO().CalculatePE(newMol1,shiftcost,flowcost,N) pe2 = CRO().CalculatePE(newMol2,shiftcost,flowcost,N) mole.moleculeTable.append(newMol1) mole.moleculeTable.append(newMol2) #print(mole.moleculeTable) mole.PE.append(pe1) mole.PE.append(pe2) e_dec = 0 gamma1 = 0 gamma2 = 0 gamma3 = 0 gamma1 = random.uniform(0,1) gamma2 = random.uniform(0,1) if ((mole.PE[index] + mole.KE1[index]) >= (pe1+pe2)): e_dec = (mole.PE[index] + mole.KE1[index]) - (pe1 + pe2) else: e_dec = (mole.PE[index] + mole.KE1[index]) + gamma1 * gamma2 * self.buffer - (pe1 + pe2) # endif mole.KE1.append(e_dec * gamma3) if (e_dec>=0): self.buffer = self.buffer * (1 -( gamma1*gamma2)) gamma3 = random.uniform(0,1) #mole.moleculeTable[index] = newMol1 #mole.PE[index] = pe1 mole.KE1[index] = e_dec * gamma3 #mole.numHit[index] = 0 #mole.minHit[index] = 0 #mole.minStruct[index] = newMol1 #mole.minPE[index] = pe1 #mole.moleculeTable.append(newMol1) #mole.PE.append(pe1) #mole.KE1.append(e_dec * gamma3) mole.numHit.append(0) mole.minHit.append(0) mole.minStruct.append(newMol1) mole.minPE.append(pe1)
def OnwallIneffectiveCollision(self, mole, oldMol, index): operator = Operators() newMol = operator.OnWall(oldMol) PEnew = CRO().CalculatePE(mole, newMol) KEnew = 0.0 mole.numHit[index] = mole.numHit[index] + 1 t = mole.PE1[index] + mole.KE1[index] if (t >= PEnew): a = (random.uniform(0, 1) * (1 - self.KELossRate)) + self.KELossRate KEnew = (mole.PE1[index] - PEnew + mole.KE1[index]) * a mole.moleculeTable[index] = newMol mole.PE1[index] = PEnew mole.KE1[index] = KEnew if (mole.PE1[index] < mole.minPE[index]): mole.minStruct[index] = mole mole.minPE[index] = mole.PE1[index] mole.minHit[index] = mole.numHit[index]
def Synthesis (self,mole,oldMol1,oldMol2,index1,index2,shiftcost,flowcost,N): operator = Operators() newMol = operator.Synthesis(oldMol1, oldMol2) #print('EI j ',newMol) pe_new = CRO().CalculatePE(newMol,shiftcost,flowcost,N) mole.moleculeTable.append(newMol) mole.PE.append(pe_new) mole.KE1.append(pe_new) if((mole.PE[index1]+mole.PE[index2] + mole.KE1[index1]+mole.KE1[index2])>=pe_new): ke_new = (mole.PE[index1] + mole.PE[index2] + mole.KE1[index1] + mole.KE1[index2]) - pe_new mole.KE1.append(ke_new) #del mole.moleculeTable[index1] #del mole.PE[index1] #del mole.KE1[index1] #del mole.numHit[index1] #del mole.minHit[index1] #del mole.minStruct[index1] #del mole.minPE[index1] if(index2>=index1): # position of index2 is decreased by 1 index2 = index2 -1 #mole.moleculeTable.append(newMol) #mole.PE.append(pe_new) mole.KE1.append(ke_new) mole.numHit.append(0) mole.minHit.append(0) mole.minStruct.append(newMol) mole.minPE.append(pe_new) else: mole.numHit[index1] = mole.numHit[index1] + 1 mole.numHit[index1] = mole.numHit[index1] + 1
def Decomposition(self, mole, oldMol, index): operator = Operators() newMol1, newMol2 = operator.Decomposition(oldMol) pe1 = CRO().CalculatePE(mole, newMol1) pe2 = CRO().CalculatePE(mole, newMol2) e_dec = 0 gamma1 = 0 gamma2 = 0 gamma3 = 0 gamma1 = random.uniform(0, 1) gamma2 = random.uniform(0, 1) if ((mole.PE1[index] + mole.KE1[index]) >= (pe1 + pe2)): e_dec = (mole.PE1[index] + mole.KE1[index]) - (pe1 + pe2) else: e_dec = (mole.PE1[index] + mole.KE1[index] ) + gamma1 * gamma2 * self.buffer - (pe1 + pe2) # endif if (e_dec >= 0): self.buffer = self.buffer * (1 - (gamma1 * gamma2)) gamma3 = random.uniform(0, 1) mole.moleculeTable[index] = newMol1 mole.PE1[index] = pe1 mole.KE1[index] = e_dec * gamma3 mole.numHit[index] = 0 mole.minHit[index] = 0 mole.minStruct[index] = newMol1 mole.minPE[index] = pe1 mole.moleculeTable.append(newMol1) mole.PE1.append(pe1) mole.KE1.append(e_dec * gamma3) mole.numHit.append(0) mole.minHit.append(0) mole.minStruct.append(newMol1) mole.minPE.append(pe1) else: mole.numHit[index] = mole.numHit[index] + 1
def helmholtz(self, u, v, w): ''' break a vector into solenoidal & dilatational parts ''' Nx = self.para.Nx Ny = self.para.Ny Nz = self.para.Nz dx = self.para.dx dz = self.para.dz.reshape([-1,1]) dy = self.para.dy.reshape([-1,1,1]) hx = self.para.hx hz = self.para.hz.reshape([-1,1]) hy = self.para.hy.reshape([-1,1,1]) dy = self.para.dy.reshape([-1,1,1]) hy = self.para.hy.reshape([-1,1,1]) opt = Operators(self.para) # compute divergence and rotation of the vector field phi = opt.divergence(u,v,w) xi1, xi2, xi3 = opt.rotation(u,v,w) # implement homogeneous BC phi[[0,-1]] = 0 xi1[[0,-1]] = 0 xi2[[0,-1]] = 0 xi3[[0,-1]] = 0 # solve poisson equations with Dirichlet BC for xi2 and Neumann BC for others phi = self.poisson(phi) xi1 = self.poisson(-xi1) xi2 = self.poisson(-xi2, bcoef=1) xi3 = self.poisson(-xi3) # interpolate xi to staggered grids xi1[:,:,1:] = .5/hx[1:] * (xi1[:,:,1:]*dx[:-1] + xi1[:,:,:-1]*dx[1:]) xi3[:,1:] = .5/hz[1:] * (xi3[:,1:] *dz[:-1] + xi3[:,:-1] *dz[1:]) xi2[1:] = .5/hy[1:] * (xi2[1:] *dy[:-1] + xi2[:-1] *dy[1:]) xi1[:,:,0] = 0 xi3[:,0] = 0 xi2[0] = 0 # return Us (centered), Ud (staggered), xi (staggered), phi (centered) return opt.rotation(xi1,xi2,xi3), opt.gradient(phi), (xi1,xi2,xi3), phi
def Synthesis(self, mole, oldMol1, oldMol2, index1, index2): operator = Operators() newMol = operator.Synthesis(oldMol1, oldMol2) pe_new = CRO().CalculatePE(mole, newMol) if ((mole.PE1[index1] + mole.PE1[index2] + mole.KE1[index1] + mole.KE1[index2]) >= pe_new): ke_new = (mole.PE1[index1] + mole.PE1[index2] + mole.KE1[index1] + mole.KE1[index2]) - pe_new del mole.moleculeTable[index1] del mole.PE1[index1] del mole.KE1[index1] del mole.numHit[index1] del mole.minHit[index1] del mole.minStruct[index1] del mole.minPE[index1] if (index2 >= index1): # position of index2 is decreased by 1 index2 = index2 - 1 del mole.moleculeTable[index2] del mole.PE1[index2] del mole.KE1[index2] del mole.numHit[index2] del mole.minHit[index2] del mole.minStruct[index2] del mole.minPE[index2] mole.moleculeTable.append(newMol) mole.PE1.append(pe_new) mole.KE1.append(ke_new) mole.numHit.append(0) mole.minHit.append(0) mole.minStruct.append(newMol) mole.minPE.append(pe_new) else: mole.numHit[index1] = mole.numHit[index1] + 1 mole.numHit[index1] = mole.numHit[index1] + 1
def __init__(self, param, grid): self.list_param = ['timestepping', 'diffusion', 'Kdiff'] param.copy(self, self.list_param) self.list_grid = ['msk', 'nh', 'area', 'mpitools'] grid.copy(self, self.list_grid) # for variables param.varname_list = ['tracer', 'psi', 'u', 'v', 'vorticity'] param.sizevar = [grid.nyl, grid.nxl] self.var = Var(param) # for operators param.tracer_list = ['tracer'] param.whosetspsi = ('tracer') self.ope = Operators(param, grid) # for timescheme self.tscheme = Timescheme(param, self.var.state) self.tscheme.set(self.advection, self.timestepping) self.diags = {}
def OnwallIneffectiveCollision(self,mole,oldMol, index,shiftcost,flowcost,N): operator = Operators() newMol = operator.OnWall(oldMol) PEnew = CRO().CalculatePE(newMol,shiftcost,flowcost,N) KEnew = 0.0 #mole.numHit[index] = mole.numHit[index] + 1 t = mole.PE[index] + mole.KE1[index] if (t>=PEnew): a = (random.uniform(0,1) * (1-self.KELossRate))+self.KELossRate #KEnew = (mole.PE[index] - PEnew + mole.KE[index])*a ''' #mole.KE1[index] = KEnew if(mole.PE[index]<mole.minPE[index]): mole.minStruct.append(mole) #mole.minPE[index] = mole.PE[index] #mole.minHit[index] = mole.numHit[index] #endif ''' mole.moleculeTable.append(newMol) mole.KE1.append(KEnew) #print(mole.moleculeTable) mole.PE.append(PEnew) mole.KE1.append(KEnew)
def Mol(self, sequence, popSize, initialKE, minStem): self.sequence = sequence dotplot = population.Checkerboard(sequence) self.stemTable = population.FindDiagonal(sequence, dotplot, minStem) self.infoTable = self.stemTable[:] # Copying the varible to keep original one # print(self.infoTable,'before') # RepairKHP operator Op = Operators() self.infoTable = Op.RepairKHP(self.infoTable) # print(self.infoTable,'after') self.molecules, self.stemPool, self.infoEnergy, self.moleculeEnergy, self.moleculeTable, self.basePairs, self.infoTable, self.moleculeShort, self.elements = population.GenerateMolecule( sequence, len(sequence), popSize, self.infoTable) #population.PrintInfo(molecule,stemPool,infoEnergy,moleculeEnergy) self.PE = self.moleculeEnergy self.PE1 = self.moleculeEnergy for i in range(len(self.moleculeTable)): self.KE.append(initialKE) self.KE1.append(initialKE) self.numHit.append(0) self.minStruct.append(self.moleculeTable[i]) self.minPE.append(self.moleculeEnergy[i]) self.minHit.append(0) #endfor #end #endclass #%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% # IMPORTANT #%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% # Need to uniquify: moleculeTable
def IntermolecularIneffectiveCollision(self,mole,oldMol1,oldMol2,index1,index2,shiftcost,flowcost,N): operator = Operators() newMol1, newMol2 = operator.Intermolecular(oldMol1, oldMol2) pe1 = CRO().CalculatePE(newMol1,shiftcost,flowcost,N) pe2 = CRO().CalculatePE(newMol2,shiftcost,flowcost,N) e_inter = 0 gamma4 = random.uniform(0,1) #print ('Intermoleculer newMoll', newMol1) mole.moleculeTable.append(newMol1) mole.moleculeTable.append(newMol2) mole.PE.append(pe1) mole.PE.append(pe2) #print('PE Check',mole.PE) #print ('Intermoleculer Table', mole.moleculeTable) #mole.numHit[index1] = mole.numHit[index1] + 1 #mole.numHit[index2] = mole.numHit[index2] + 1 e_inter = (mole.PE[index1] + mole.PE[index2] + mole.KE1[index1] + mole.KE1[index2]) - (pe1 + pe2) mole.KE1.append(e_inter * gamma4) mole.KE1.append(e_inter * (1-gamma4)) if (e_inter>=0): #mole.moleculeTable[index1] = newMol1 #mole.moleculeTable[index2] = newMol2 #mole.moleculeTable.append(newMol1) #mole.moleculeTable.append(newMol2) #mole.PE[index1] = pe1 #mole.PE[index2] = pe2 #mole.KE1[index1] = e_inter * gamma4 #mole.KE1[index2] = e_inter * (1 - gamma4) '''
MEANING = [{"low": 0., "high": 0.}, {"none": 0., "some": 0., "every": 0.}] FUZZY_VARS = [ FuzzyVar(["low", "high"], { "low": lambda x: 20 - x**3 / 2, "high": lambda x: x**3 / 5. }), FuzzyVar( ["none", "some", "every"], { "none": lambda x: 1. if x <= 0. else 0., "some": lambda x: cos(x * pi) * sin(x * pi), "every": lambda x: 1. if x == 1. else 0. }) ] OP = Operators(0.5, 0.5, 0.5) def calculate_base_meaning(meaning_list: List[Dict[str, float]]) -> NoReturn: for idx, var in enumerate(FUZZY_VARS): for name in var.values: meaning_list[idx][name] = var.get_meaning(name, BASE_VALUES[idx]) calculate_base_meaning(MEANING) # print(MEANING) A = VAR_DICT["A"] B = VAR_DICT["B"] FUZZY_RULES = [
def __init__(self, param, grid): self.list_param = [ 'forcing', 'noslip', 'timestepping', 'alphaT', 'betaS', 'diffusion', 'Kdiff', 'myrank', 'forcing_module', 'gravity', 'isisland', 'customized', 'custom_module', 'additional_tracer' ] param.copy(self, self.list_param) # for potential energy self.list_param = ['xr', 'yr', 'nh', 'Lx', 'msk', 'area', 'mpitools'] grid.copy(self, self.list_param) # for variables param.varname_list = [ 'vorticity', 'psi', 'u', 'v', 'density', 'danom', 'T', 'S' ] param.tracer_list = ['vorticity', 'T', 'S'] param.whosetspsi = ('vorticity') if hasattr(self, 'additional_tracer'): for k in range(len(self.additional_tracer)): trac = self.additional_tracer[k] param.varname_list.append(trac) param.tracer_list.append(trac) self.varname_list = param.varname_list param.sizevar = [grid.nyl, grid.nxl] self.var = Var(param) dref = self.var.get('density').copy() self.dref = dref self.source = np.zeros(param.sizevar) # for operators self.ope = Operators(param, grid) # for timescheme self.tscheme = Timescheme(param, self.var.state) self.tscheme.set(self.dynamics, self.timestepping) if self.forcing: if self.forcing_module == 'embedded': print( 'Warning: check that you have indeed added the forcing to the model' ) print('Right below the line : model = f2d.model') print( 'you should have the line: model.forc = Forcing(param, grid)' ) pass else: try: f = import_module(self.forcing_module) except ImportError: print('module %s for forcing cannot be found' % self.forcing_module) print('make sure file **%s.py** exists' % self.forcing_module) sys.exit(0) self.forc = f.Forcing(param, grid) self.diags = {} if self.customized: try: f = import_module(self.custom_module) print(f) self.extrastep = f.Step(param, grid) except ImportError: print('module %s for forcing cannot be found' % self.custom_module) print('make sure file **%s.py** exists' % self.custom_module) exit(0)
def __init__(self, param, grid): self.list_param = [ 'forcing', 'noslip', 'timestepping', 'diffusion', 'Kdiff', 'myrank', 'forcing_module', 'gravity', 'isisland', 'customized', 'custom_module', 'additional_tracer' ] param.copy(self, self.list_param) # for potential energy self.list_param = ['xr', 'yr', 'nh', 'Lx', 'msk', 'area', 'mpitools'] grid.copy(self, self.list_param) # for variables param.varname_list = [ 'vorticity', 'psi', 'u', 'v', 'buoyancy', 'banom' ] param.tracer_list = ['vorticity', 'buoyancy'] param.whosetspsi = ('vorticity') if hasattr(self, 'additional_tracer'): for k in range(len(self.additional_tracer)): trac = self.additional_tracer[k] param.varname_list.append(trac) param.tracer_list.append(trac) param.sizevar = [grid.nyl, grid.nxl] self.var = Var(param) bref = self.var.get('buoyancy').copy() self.bref = bref self.source = np.zeros(param.sizevar) # for operators self.ope = Operators(param, grid) # for timescheme self.tscheme = Timescheme(param, self.var.state) self.tscheme.set(self.dynamics, self.timestepping) if self.forcing: if self.forcing_module == 'embedded': self.msg_forcing = ( 'To make Fluid2d aware of your embedded forcing\n' + 'you need to add in the user script \n' + 'model.forc = Forcing(param, grid)\n' + 'right below the line: model = f2d.model') pass else: try: f = import_module(self.forcing_module) except ImportError: print('module %s for forcing cannot be found' % self.forcing_module) print('make sure file **%s.py** exists' % self.forcing_module) exit(0) self.forc = f.Forcing(param, grid) self.diags = {} if self.customized: try: f = import_module(self.custom_module) print(f) self.extrastep = f.Step(param, grid) except ImportError: print('module %s for forcing cannot be found' % self.custom_module) print('make sure file **%s.py** exists' % self.custom_module) exit(0)
def __init__(self, param, grid): self.list_param = [ 'forcing', 'diffusion', 'Kdiff', 'timestepping', 'ageostrophic', 'forcing_module', 'geometry' ] param.copy(self, self.list_param) # for diagnostics self.list_param = ['yr', 'nh', 'msk', 'area', 'mpitools'] grid.copy(self, self.list_param) assert grid.geometry == "perio", "SQG imposes a biperiodic domain" assert param.ageostrophic == False, "Ageostrophic velocity not yet tested" # for variables param.varname_list = ['pv', 'psi', 'u', 'v', 'vorticity'] if param.ageostrophic: # TODO: not yet tested for SQG param.varname_list += ['ua', 'va'] param.sizevar = [grid.nyl, grid.nxl] self.var = Var(param) self.source = np.zeros(param.sizevar) self.ipv = self.var.varname_list.index('pv') self.ivor = self.var.varname_list.index('vorticity') self.ipsi = self.var.varname_list.index('psi') # for operators param.tracer_list = ['pv'] if param.ageostrophic: param.tracer_list += ['ua', 'va'] param.whosetspsi = ('pv') param.sqgoperator = True self.ope = Operators(param, grid) # for timescheme self.tscheme = Timescheme(param, self.var.state) self.dx0 = self.tscheme.dx0 self.kt = 0 if self.forcing: if self.forcing_module == 'embedded': print( 'Warning: check that you have indeed added the forcing to the model' ) print('Right below the line : model = f2d.model') print( 'you should have the line: model.forc = Forcing(param, grid)' ) pass else: try: f = import_module(self.forcing_module) except ImportError: print('module %s for forcing cannot be found' % self.forcing_module) print('make sure file **%s.py** exists' % self.forcing_module) sys.exit(0) self.forc = f.Forcing(param, grid) self.diags = {} self.tscheme.set(self.dynamics, self.timestepping)
def __init__(self, param, grid): self.list_param = [ 'forcing', 'noslip', 'timestepping', 'diffusion', 'Kdiff', 'forcing_module', 'additional_tracer', 'enforce_momentum', 'var_to_save', 'customized', 'custom_module', 'spongelayer' ] param.copy(self, self.list_param) # for diagnostics self.list_param = [ 'yr', 'nh', 'msk', 'area', 'mpitools', 'dx', 'xr', 'yr', 'r2', 'x0', 'y0', 'x2', 'y2', 'isisland', 'Lx', 'ny' ] grid.copy(self, self.list_param) # for variables param.varname_list = ['vorticity', 'psi', 'u', 'v', 'source'] # ,'tauw','wshear'] param.tracer_list = ['vorticity'] param.whosetspsi = ('vorticity') if 'tauw' in self.var_to_save: param.varname_list.append('tauw') if 'wshear' in self.var_to_save: param.varname_list.append('wshear') if hasattr(self, 'additional_tracer'): for k in range(len(self.additional_tracer)): trac = self.additional_tracer[k] param.varname_list.append(trac) param.tracer_list.append(trac) param.sizevar = [grid.nyl, grid.nxl] self.var = Var(param) self.work = np.zeros(param.sizevar) # for timing the code self.timers = Timers(param) # for operators self.ope = Operators(param, grid) # for timescheme self.tscheme = Timescheme(param, self.var.state) self.tscheme.set(self.dynamics, self.timestepping) if self.forcing: if self.forcing_module == 'embedded': print( 'Warning: check that you have indeed added the forcing to the model' ) print('Right below the line : model = f2d.model') print( 'you should have the line: model.forc = Forcing(param, grid)' ) pass else: try: f = import_module(self.forcing_module) except ImportError: print('module %s for forcing cannot be found' % self.forcing_module) print('make sure file **%s.py** exists' % self.forcing_module) exit(0) self.forc = f.Forcing(param, grid) if self.spongelayer: # sponge layer zone [0 = full sponge, 1 = no sponge] self.spongemsk = (1 - (1 + np.tanh( (self.xr - self.Lx) / 0.1)) * 0.5) self.diags = {} if self.customized: try: f = import_module(self.custom_module) self.extrastep = f.Step(param, grid) except ImportError: print('module %s for forcing cannot be found' % self.custom_module) print('make sure file **%s.py** exists' % self.custom_module) exit(0)
def __init__(self, param, grid): self.list_param = ['forcing', 'diffusion', 'Kdiff', 'noslip', 'timestepping', 'beta', 'Rd', 'ageostrophic', 'bottom_torque', 'forcing_module'] param.copy(self, self.list_param) # for diagnostics self.list_param = ['yr', 'nh', 'msk', 'area', 'mpitools', 'isisland'] grid.copy(self, self.list_param) # for variables param.varname_list = ['pv', 'psi', 'u', 'v', 'pvanom', 'vorticity'] if param.bottom_torque: param.varname_list += ['btorque'] if param.ageostrophic: param.varname_list += ['ua', 'va'] param.sizevar = [grid.nyl, grid.nxl] self.var = Var(param) self.source = np.zeros(param.sizevar) self.ipva = self.var.varname_list.index('pvanom') self.ipv = self.var.varname_list.index('pv') self.ivor = self.var.varname_list.index('vorticity') self.ipsi = self.var.varname_list.index('psi') # background pv self.pvback = self.beta*(grid.yr-grid.Ly*.5)*grid.msk # for operators param.tracer_list = ['pv'] if param.bottom_torque: param.tracer_list += ['btorque'] if param.ageostrophic: param.tracer_list += ['ua', 'va'] param.whosetspsi = ('pvanom') param.qgoperator = True self.ope = Operators(param, grid) # for timescheme self.tscheme = Timescheme(param, self.var.state) self.dx0 = self.tscheme.dx0 self.kt = 0 if self.forcing: if self.forcing_module == 'embedded': print('Warning: check that you have indeed added the forcing to the model') print('Right below the line : model = f2d.model') print('you should have the line: model.forc = Forcing(param, grid)') pass else: try: f = import_module(self.forcing_module) except ImportError: print('module %s for forcing cannot be found' % self.forcing_module) print('make sure file **%s.py** exists' % self.forcing_module) sys.exit(0) self.forc = f.Forcing(param, grid) self.diags = {} self.tscheme.set(self.dynamics, self.timestepping)
def get_Q(self, u, v, w): ''' compute Q = -1/2 * \nabla \dot N where N(u) = \nabla \dot (uu) ''' Nx = self.para.Nx Ny = self.para.Ny Nz = self.para.Nz dx = self.para.dx dz = self.para.dz.reshape([-1,1]) dy = self.para.dy.reshape([-1,1,1]) hx = self.para.hx hz = self.para.hz.reshape([-1,1]) hy = self.para.hy.reshape([-1,1,1]) uu, vv, ww = (np.empty([Ny+1, Nz+1, Nx+1]) for _ in range(3)) uv, vw, wu = (np.empty([Ny+1, Nz+1, Nx+1]) for _ in range(3)) N1, N2, N3 = (np.zeros([Ny+1, Nz+1, Nx+1]) for _ in range(3)) im, ic, ip = np.arange(Nx-1), np.arange(1,Nx), np.arange(2,Nx+1) km, kc, kp = np.arange(Nz-1), np.arange(1,Nz), np.arange(2,Nz+1) jm, jc, jp = np.arange(Ny-1), np.arange(1,Ny), np.arange(2,Ny+1) ## compute 2nd order terms # normal terms on cell centers uu[:,:,ic] = .25 * (u[:,:,ic] + u[:,:,ip])**2 # on cell centers ww[:,kc] = .25 * (w[:,kc] + w[:,kp] )**2 # on cell centers vv[jc] = .25 * (v[jc] + v[jp] )**2 # on cell centers # boundaries of normal terms uu[:,:,[0,-1]] = uu[:,:,[-2,1]] # periodic u boundary ww[:,[0,-1]] = ww[:,[-2,1]] # periodic w boundary vv[[0,-1]] = (hy[1]/dy[1] * (v[1]-v[2]) + .5 * (v[1]+v[2]))**2, \ (hy[-1]/dy[-2] * (v[-1]-v[-2]) + .5 * (v[-1]+v[-2]))**2 # linear extrapolation of v # cross terms on edges uv[1:] = .5/hy[1:] * (u[1:] *dy[:-1] + u[:-1] *dy[1:]) # on z-edges uv[:,:,1:] *= .5/hx[1:] * (v[:,:,1:]*dx[:-1] + v[:,:,:-1]*dx[1:]) vw[:,1:] = .5/hz[1:] * (v[:,1:] *dz[:-1] + v[:,:-1] *dz[1:]) # on x-edges vw[1:] *= .5/hy[1:] * (w[1:] *dy[:-1] + w[:-1] *dy[1:]) wu[:,:,1:] = .5/hx[1:] * (w[:,:,1:]*dx[:-1] + w[:,:,:-1]*dx[1:]) # on y-edges wu[:,1:] *= .5/hz[1:] * (u[:,1:] *dz[:-1] + u[:,:-1] *dz[1:]) ## compute the convection operator N(u) = \nabla \dot (uu) # 3 components of N on staggered grids N1[:,:,1:] += (uu[:,:,1:] - uu[:,:,:-1]) / hx[1:] N1[:,kc] += (wu[:,kp] - wu[:,kc] ) / dz[kc] N1[jc] += (uv[jp] - uv[jc] ) / dy[jc] N2[:,:,ic] += (uv[:,:,ip] - uv[:,:,ic]) / dx[ic] N2[:,kc] += (vw[:,kp] - vw[:,kc] ) / dz[kc] N2[1:] += (vv[1:] - vv[:-1] ) / hy[1:] N3[:,:,ic] += (wu[:,:,ip] - wu[:,:,ic]) / dx[ic] N3[:,1:] += (ww[:,1:] - ww[:,:-1] ) / hz[1:] N3[jc] += (vw[jp] - vw[jc] ) / dy[jc] # boundaries of N # N1, N3 on yc[0] are automatically zero N1[:,[0,-1]] = N1[:,[-2,1]] N2[:,[0,-1]] = N2[:,[-2,1]] N2[:,:,[0,-1]] = N2[:,:,[-2,1]] N3[:,:,[0,-1]] = N3[:,:,[-2,1]] ## Q = -1/2 * \nabla \dot N, the returned result's boundary not handled return -.5 * Operators(self.para).divergence(N1,N2,N3)
def __init__(self, param, grid): self.list_param = [ 'forcing', 'noslip', 'timestepping', 'diffusion', 'Kdiff', 'myrank', 'forcing_module', 'gravity', 'isisland', 'customized', 'custom_module', 'additional_tracer' ] param.copy(self, self.list_param) # for potential energy self.list_param = ['xr', 'yr', 'nh', 'Lx', 'msk', 'area', 'mpitools'] grid.copy(self, self.list_param) # for variables param.varname_list = [ 'vorticity', 'psi', 'u', 'v', 'buoyancy', 'banom' ] param.tracer_list = ['vorticity', 'buoyancy'] param.whosetspsi = ('vorticity') if hasattr(self, 'additional_tracer'): for k in range(len(self.additional_tracer)): trac = self.additional_tracer[k] param.varname_list.append(trac) param.tracer_list.append(trac) param.sizevar = [grid.nyl, grid.nxl] self.var = Var(param) bref = self.var.get('buoyancy').copy() self.bref = bref self.source = np.zeros(param.sizevar) # for operators self.ope = Operators(param, grid) # for timescheme self.tscheme = Timescheme(param, self.var.state) self.tscheme.set(self.dynamics, self.timestepping) if self.forcing: if hasattr(self, 'forcing_module'): f = import_module(self.forcing_module) self.forc = f.Forcing(param, grid) else: if self.myrank == 0: print('-' * 50) print('did not find an external forcing module') print( 'make sure file you define a class Forcing() in your script' ) print('and that you attach it.') print( 'You should have the following line before f2d.loop()') print('model.forc = Forcing(param, grid)') self.diags = {} if self.customized: try: f = import_module(self.custom_module) print(f) self.extrastep = f.Step(param, grid) except ImportError: print('module %s for forcing cannot be found' % self.custom_module) print('make sure file **%s.py** exists' % self.custom_module) exit(0)