def __init__(self, iplot=False, angle=10, pickleName='thHeat.pickle'): """ :param iplot: a boolean to toggle the plots on/off :type iplot: bool :param angle: the integration angle in degrees :type angle: float :pickleName: calculations a """ angle = angle * np.pi / 180 if os.path.exists('tInitAvg'): file = open('tInitAvg', 'r') tstart = float(file.readline()) file.close() logFiles = scanDir('log.*') tags = [] for lg in logFiles: nml = MagicSetup(quiet=True, nml=lg) if nml.start_time > tstart: if os.path.exists('bLayersR.%s' % nml.tag): tags.append(nml.tag) if len(tags) == 0: tags = [nml.tag] print('Only 1 tag: %s' % tags) MagicSetup.__init__(self, quiet=True, nml=logFiles[-1]) a = AvgField() self.nuss = a.nuss else: logFiles = scanDir('log.*') MagicSetup.__init__(self, quiet=True, nml=logFiles[-1]) if not os.path.exists(pickleName): # reading ATmov k = 0 for tag in tags: file = 'ATmov.%s' % tag if os.path.exists(file): if k == 0: m = Movie(file=file, iplot=False) print(file) else: m += Movie(file=file, iplot=False) print(file) k += 1 # reading AHF_mov kk = 0 for tag in tags: file = 'AHF_mov.%s' % tag if os.path.exists(file): if kk == 0: m1 = Movie(file=file, iplot=False) print(file) else: m1 += Movie(file=file, iplot=False) print(file) kk += 1 self.tempmean = m.data[0, ...].mean(axis=0) self.tempstd = m.data[0, ...].std(axis=0) self.colat = m.theta if kk > 0: # i.e. at least one AHF_mov file has been found self.fluxmean = m1.data[0, ...].mean(axis=0) self.fluxstd = m1.data[0, ...].std(axis=0) else: self.fluxmean = rderavg(self.tempmean, eta=self.radratio, exclude=False, spectral=False) self.fluxstd = rderavg(self.tempstd, eta=self.radratio, exclude=False, spectral=False) # Pickle saving file = open(pickleName, 'wb') pickle.dump([self.colat, self.tempmean, self.tempstd,\ self.fluxmean, self.fluxstd], file) file.close() else: file = open(pickleName, 'r') dat = pickle.load(file) if len(dat) == 5: self.colat, self.tempmean, self.tempstd, \ self.fluxmean, self.fluxstd = dat else: self.colat, self.tempmean, self.fluxmean = dat self.fluxstd = np.zeros_like(self.fluxmean) self.tempstd = np.zeros_like(self.fluxmean) file.close() self.ri = self.radratio/(1.-self.radratio) self.ro = 1./(1.-self.radratio) self.ntheta, self.nr = self.tempmean.shape self.radius = chebgrid(self.nr-1, self.ro, self.ri) th2D = np.zeros((self.ntheta, self.nr), dtype=self.radius.dtype) #self.colat = np.linspace(0., np.pi, self.ntheta) for i in range(self.ntheta): th2D[i, :] = self.colat[i] self.temprmmean = 0.5*simps(self.tempmean*np.sin(th2D), th2D, axis=0) self.temprmstd = 0.5*simps(self.tempstd*np.sin(th2D), th2D, axis=0) sinTh = np.sin(self.colat) d1 = matder(self.nr-1, self.ro, self.ri) # Conducting temperature profile (Boussinesq only!) self.tcond = self.ri*self.ro/self.radius-self.ri+self.temprmmean[0] self.fcond = -self.ri*self.ro/self.radius**2 self.nusstopmean = self.fluxmean[:, 0] / self.fcond[0] self.nussbotmean = self.fluxmean[:, -1] / self.fcond[-1] self.nusstopstd = self.fluxstd[:, 0] / self.fcond[0] self.nussbotstd = self.fluxstd[:, -1] / self.fcond[-1] # Close to the equator mask2D = (th2D>=np.pi/2.-angle/2.)*(th2D<=np.pi/2+angle/2.) mask = (self.colat>=np.pi/2.-angle/2.)*(self.colat<=np.pi/2+angle/2.) fac = 1./simps(sinTh[mask], self.colat[mask]) self.nussBotEq = fac*simps(self.nussbotmean[mask]*sinTh[mask], self.colat[mask]) self.nussTopEq = fac*simps(self.nusstopmean[mask]*sinTh[mask], self.colat[mask]) sinC = sinTh.copy() sinC[~mask] = 0. fac = 1./simps(sinC, self.colat) tempC = self.tempmean.copy() tempC[~mask2D] = 0. self.tempEqmean = fac*simps(tempC*np.sin(th2D), th2D, axis=0) tempC = self.tempstd.copy() tempC[~mask2D] = 0. self.tempEqstd = fac*simps(tempC*np.sin(th2D), th2D, axis=0) dtempEq = np.dot(d1, self.tempEqmean) self.betaEq = dtempEq[self.nr/2] # 45\deg inclination mask2D = (th2D>=np.pi/4.-angle/2.)*(th2D<=np.pi/4+angle/2.) mask = (self.colat>=np.pi/4.-angle/2.)*(self.colat<=np.pi/4+angle/2.) fac = 1./simps(np.sin(self.colat[mask]), self.colat[mask]) nussBot45NH = fac*simps(self.nussbotmean[mask]*sinTh[mask], self.colat[mask]) nussTop45NH = fac*simps(self.nusstopmean[mask]*sinTh[mask], self.colat[mask]) sinC = sinTh.copy() sinC[~mask] = 0. fac = 1./simps(sinC, self.colat) tempC = self.tempmean.copy() tempC[~mask2D] = 0. temp45NH = fac*simps(tempC*np.sin(th2D), th2D, axis=0) mask2D = (th2D>=3.*np.pi/4.-angle/2.)*(th2D<=3.*np.pi/4+angle/2.) mask = (self.colat>=3.*np.pi/4.-angle/2.)*(self.colat<=3.*np.pi/4+angle/2.) fac = 1./simps(np.sin(self.colat[mask]), self.colat[mask]) nussBot45SH = fac*simps(self.nussbotmean[mask]*sinTh[mask], self.colat[mask]) nussTop45SH = fac*simps(self.nusstopmean[mask]*sinTh[mask], self.colat[mask]) sinC = sinTh.copy() sinC[~mask] = 0. fac = 1./simps(sinC, self.colat) tempC = self.tempmean.copy() tempC[~mask2D] = 0. temp45SH = fac*simps(tempC*np.sin(th2D), th2D, axis=0) self.nussTop45 = 0.5*(nussTop45NH+nussTop45SH) self.nussBot45 = 0.5*(nussBot45NH+nussBot45SH) self.temp45 = 0.5*(temp45NH+temp45SH) dtemp45 = np.dot(d1, self.temp45) self.beta45 = dtemp45[self.nr/2] # Polar regions mask2D = (th2D<=angle/2.) mask = (self.colat<=angle/2.) fac = 1./simps(np.sin(self.colat[mask]), self.colat[mask]) nussBotPoNH = fac*simps(self.nussbotmean[mask]*sinTh[mask], self.colat[mask]) nussTopPoNH = fac*simps(self.nusstopmean[mask]*sinTh[mask], self.colat[mask]) sinC = sinTh.copy() sinC[~mask] = 0. fac = 1./simps(sinC, self.colat) tempC = self.tempmean.copy() tempC[~mask2D] = 0. tempPolNHmean = fac*simps(tempC*np.sin(th2D), th2D, axis=0) tempC = self.tempstd.copy() tempC[~mask2D] = 0. tempPolNHstd = fac*simps(tempC*np.sin(th2D), th2D, axis=0) mask2D = (th2D>=np.pi-angle/2.) mask = (self.colat>=np.pi-angle/2.) fac = 1./simps(np.sin(self.colat[mask]), self.colat[mask]) nussBotPoSH = fac*simps(self.nussbotmean[mask]*sinTh[mask], self.colat[mask]) nussTopPoSH = fac*simps(self.nusstopmean[mask]*sinTh[mask], self.colat[mask]) sinC = sinTh.copy() sinC[~mask] = 0. fac = 1./simps(sinC, self.colat) tempC = self.tempmean.copy() tempC[~mask2D] = 0. tempPolSHmean = fac*simps(tempC*np.sin(th2D), th2D, axis=0) tempC = self.tempstd.copy() tempC[~mask2D] = 0. tempPolSHstd = fac*simps(tempC*np.sin(th2D), th2D, axis=0) self.nussBotPo = 0.5*(nussBotPoNH+nussBotPoSH) self.nussTopPo = 0.5*(nussTopPoNH+nussTopPoSH) self.tempPolmean = 0.5*(tempPolNHmean+tempPolSHmean) self.tempPolstd= 0.5*(tempPolNHstd+tempPolSHstd) dtempPol = np.dot(d1, self.tempPolmean) self.betaPol = dtempPol[self.nr/2] # Inside and outside TC angleTC = np.arcsin(self.ri/self.ro) mask2D = (th2D<=angleTC) mask = (self.colat<=angleTC) fac = 1./simps(np.sin(self.colat[mask]), self.colat[mask]) nussITC_NH = fac*simps(self.nusstopmean[mask]*sinTh[mask], self.colat[mask]) mask2D = (th2D>=np.pi-angleTC) mask = (self.colat>=np.pi-angleTC) fac = 1./simps(np.sin(self.colat[mask]), self.colat[mask]) nussITC_SH = fac*simps(self.nusstopmean[mask]*sinTh[mask], self.colat[mask]) self.nussITC = 0.5*(nussITC_NH+nussITC_SH) mask2D = (th2D>=angleTC)*(th2D<=np.pi-angleTC) mask = (self.colat>=angleTC)*(self.colat<=np.pi-angleTC) fac = 1./simps(sinTh[mask], self.colat[mask]) self.nussOTC = fac*simps(self.nusstopmean[mask]*sinTh[mask], self.colat[mask]) if iplot: self.plot() print(self)
def MagicCheck(tstart=None): """ This function is used to compute several sanity checks that can be evaluated if the power.TAG and some spectra have been produced in the current directory. If in addition the tInitAvg file is also there in the directory it averages only from this starting time. >>> MagicCheck(tstart=10.) """ if os.path.exists('tInitAvg'): file = open('tInitAvg', 'r') tstart = float(file.readline().strip('\n')) file.close() if tstart is None: tstart = 0. ts = MagicTs(field='power', all=True, iplot=False) ts1 = MagicTs(field='dtE', all=True, iplot=False) mask = (ts.time >= tstart) # Not super accurate if n_log_step changed but better that nothing n_steps = len(ts.time[mask]) * ts.n_log_step dEdt = ts.buoPower + ts.buoPower_chem + ts.ohmDiss + ts.viscDiss # Power balance: buoPower_avg = avgField(ts.time[mask], ts.buoPower[mask]) buoPower_chem_avg = avgField(ts.time[mask], ts.buoPower_chem[mask]) ohmDiss_avg = avgField(ts.time[mask], ts.ohmDiss[mask]) viscDiss_avg = avgField(ts.time[mask], ts.viscDiss[mask]) ratio = 100*abs(buoPower_avg+buoPower_chem_avg+ohmDiss_avg+viscDiss_avg) / \ (buoPower_avg+buoPower_chem_avg) print(bcolors.BOLD + bcolors.UNDERLINE + 'Power balance:' + bcolors.ENDC) print('Power injected : {:.5e}'.format(buoPower_avg + buoPower_chem_avg)) print('Power dissipated : {:.5e}'.format(-ohmDiss_avg - viscDiss_avg)) st = 'Power mis-balance: {:.3f} %%'.format(ratio) if ratio <= 0.5: print(bcolors.OKGREEN + st + bcolors.ENDC) elif ratio > 0.5 and ratio <= 1.: print(bcolors.MODERATE + st + bcolors.ENDC) elif ratio > 1.: print(bcolors.WARNING + st + bcolors.ENDC) # Spikes catcher in the time series of power/dEdt print('\n' + bcolors.BOLD + bcolors.UNDERLINE + 'Time resolution:' + bcolors.ENDC) absdEdt_avg = avgField(ts1.time[mask], abs(ts1.dEdt[mask])) field = abs(dEdt[mask] - ts1.dEdt[mask]) mask_spike = (field >= absdEdt_avg) l_spikes = False if mask_spike.any(): l_spikes = True if l_spikes: print(bcolors.MODERATE + 'Sudden variations detected in power balance!' + bcolors.ENDC) ones = np.ones_like(ts.time[mask]) ones[~mask_spike] = 0. ttot_spikes = np.trapz(ones, ts.time[mask]) ttot = ts.time[-1] - ts.time[0] ratio = ttot_spikes / ttot print(' -Time fraction with spikes: {:.3f} %%'.format(100. * ratio)) largest = abs(field).max() / absdEdt_avg st = ' -Largest event : {:.2f} <|dE/dt|>'.format(largest) if largest > 10: print(bcolors.WARNING + st + bcolors.ENDC) else: print(bcolors.MODERATE + st + bcolors.ENDC) else: print(bcolors.OKGREEN + 'Power balance clean!' + bcolors.ENDC) # Timestep change occurence files = scanDir('timestep.*') if len(files) > 0: ts = MagicTs(field='timestep', iplot=False, all=True) mask = (ts.time >= tstart) ddt = np.diff(ts.time[mask]) ddt_neq_zero = (ddt != 0.) ddt = ddt[ddt_neq_zero] print('\nNumber of time step changes : {}'.format(len(ddt))) print('Number of iterations : {}'.format(n_steps)) freq = int(float(n_steps) / float(len(ddt))) print('Average number of iterations with fixed time step size: {}'. format(freq)) time = ts.time[mask][1:][ddt_neq_zero] dt = ts.dt[mask][1:][ddt_neq_zero] dtMean = avgField(time, dt) mask_changes = (ddt <= 50 * dtMean) ones = np.ones_like(time) ones[~mask_changes] = 0. ttot_changes = np.sum(ones * ddt) fast_change_ratio = 100 * ttot_changes / (time[-1] - time[0]) st = 'Fraction of time with frequent timestep changes (< 50 steps): {:.2f} %%'.format( fast_change_ratio) if fast_change_ratio < 2: print(bcolors.OKGREEN + st + bcolors.ENDC) elif fast_change_ratio >= 2 and fast_change_ratio <= 10: print(bcolors.MODERATE + st + bcolors.ENDC) print(bcolors.MODERATE + 'Maybe increase Courant factors!' + bcolors.ENDC) else: print(bcolors.WARNING + st + bcolors.ENDC) print(bcolors.WARNING + 'Probably increase Courant factors!' + bcolors.ENDC) # Dissipation lengthscales ts = MagicTs(field='par', all=True, iplot=False) mask = (ts.time >= tstart) lbDiss_avg = avgField(ts.time[mask], ts.lbDiss[mask]) lvDiss_avg = avgField(ts.time[mask], ts.lvDiss[mask]) ri = ts.radratio / (1. - ts.radratio) ro = 1. / (1. - ts.radratio) dmean = 0.5 * (ri + ro) lTrunc = dmean * np.pi / ts.l_max print('\n' + bcolors.BOLD + bcolors.UNDERLINE + 'Angular resolution:' + bcolors.ENDC) print('Viscous dissipation scale: {:.3e}'.format(lvDiss_avg)) print('Ohmic dissipation scale : {:.3e}'.format(lbDiss_avg)) st = 'Angular truncation : {:.3e}'.format(lTrunc) lMin = min(lvDiss_avg, lbDiss_avg) ellMin = int(np.pi * dmean / lMin) nphi = int(3. * ellMin) if lTrunc < lMin: print(bcolors.OKGREEN + st + bcolors.ENDC) elif lTrunc >= lMin and lTrunc < 1.5 * lMin: print(bcolors.MODERATE + st + bcolors.WARNING) st = 'You might need l_max={}, N_phi={}'.format(ellMin, nphi) print(bcolors.MODERATE + st + bcolors.WARNING) else: print(bcolors.WARNING + st + bcolors.WARNING) st = 'You might need l_max={}, N_phi={}'.format(ellMin, nphi) print(bcolors.WARNING + st + bcolors.WARNING) # Spectra dats = scanDir('kin_spec_ave.*') if len(dats) > 0: ave = True else: ave = False sp = MagicSpectrum(field='kin', iplot=False, ave=ave, quiet=True) ekin_l = sp.ekin_poll + sp.ekin_torl ratio = ekin_l.max() / ekin_l[-2] sp = MagicSpectrum(field='mag', iplot=False, ave=ave, quiet=True) emag_l = sp.emag_poll + sp.emag_torl ratio_mag = emag_l[2:].max() / emag_l[-2] ratio_cmb = sp.emagcmb_l[2:].max() / sp.emagcmb_l[-2] st = 'Vol. kin. energy spectra (largest/smallest): {:.2e}'.format(ratio) st_mag = 'Vol. mag. energy spectra (largest/smallest): {:.2e}'.format( ratio_mag) st_cmb = 'CMB mag. energy spectra (largest/smallest) : {:.2e}'.format( ratio_cmb) if ratio > 100: print(bcolors.OKGREEN + st + bcolors.ENDC) elif ratio <= 100 and ratio > 50: print(bcolors.MODERATE + st + bcolors.ENDC) else: print(bcolors.WARNING + st + bcolors.ENDC) if ratio_mag > 100: print(bcolors.OKGREEN + st_mag + bcolors.ENDC) elif ratio_mag <= 100 and ratio_mag > 50: print(bcolors.MODERATE + st_mag + bcolors.ENDC) else: print(bcolors.WARNING + st_mag + bcolors.ENDC) if ratio_cmb > 100: print(bcolors.OKGREEN + st_cmb + bcolors.ENDC) elif ratio_cmb <= 100 and ratio_cmb > 50: print(bcolors.MODERATE + st_cmb + bcolors.ENDC) else: print(bcolors.WARNING + st_cmb + bcolors.ENDC) # determine the relevant tags logs = scanDir('log.*') tags = [] for lg in logs: stp = MagicSetup(nml=lg, quiet=True) if stp.start_time >= tstart and os.path.exists('eKinR.{}'.format( stp.tag)): tags.append(stp.tag) if len(tags) > 0: rad = MagicRadial(field='eKinR', iplot=False, quiet=True, tags=tags) else: rad = MagicRadial(field='eKinR', iplot=False, quiet=True) # Number of points in viscous BL print('\n' + bcolors.BOLD + bcolors.UNDERLINE + 'Radial resolution:' + bcolors.ENDC) if rad.ktopv != 1 and rad.kbotv != 1: eKR = rad.ekin_pol + rad.ekin_tor else: eKR = rad.ekin_pol ind = argrelextrema(eKR, np.greater)[0] ntop = ind[0] + 1 nbot = len(eKR) - ind[-1] nmin = min(nbot, ntop) st_bot = 'Number of points in bottom viscous B.L.: {}'.format(nbot) st_top = 'Number of points in top viscous B.L. : {}'.format(ntop) if nbot >= 10: print(bcolors.OKGREEN + st_bot + bcolors.ENDC) elif nbot >= 5 and nbot < 10: print(bcolors.MODERATE + st_bot + bcolors.ENDC) else: print(bcolors.WARNING + st_bot + bcolors.ENDC) if ntop >= 10: print(bcolors.OKGREEN + st_top + bcolors.ENDC) elif ntop >= 5 and ntop < 10: print(bcolors.MODERATE + st_top + bcolors.ENDC) else: print(bcolors.WARNING + st_top + bcolors.ENDC) # Number of points in thermal BL if len(tags) > 0: rad = MagicRadial(field='heatR', iplot=False, quiet=True, tags=tags) else: rad = MagicRadial(field='heatR', iplot=False, quiet=True) if rad.ktops == 1: ind = argrelextrema(rad.entropy_SD, np.greater)[0] ntop = ind[0] + 1 st_top = 'Number of points in top thermal B.L. : {}'.format(ntop) if ntop >= 10: print(bcolors.OKGREEN + st_top + bcolors.ENDC) elif ntop >= 5 and ntop < 10: print(bcolors.MODERATE + st_top + bcolors.ENDC) else: print(bcolors.WARNING + st_top + bcolors.ENDC) if rad.kbots == 1: ind = argrelextrema(rad.entropy_SD, np.greater)[0] nbot = len(rad.radius) - ind[-1] st_bot = 'Number of points in bottom thermal B.L.: {}'.format(nbot) if nbot >= 10: print(bcolors.OKGREEN + st_bot + bcolors.ENDC) elif nbot >= 5 and nbot < 10: print(bcolors.MODERATE + st_bot + bcolors.ENDC) else: print(bcolors.WARNING + st_bot + bcolors.ENDC)
def __init__(self, iplot=False, quiet=False): """ :param iplot: display the result when set to True (default False) :type iplot: bool :param quiet: less verbose when set to True (default is False) :type quiet: bool """ if os.path.exists('tInitAvg'): file = open('tInitAvg', 'r') tstart = float(file.readline()) file.close() logFiles = scanDir('log.*') tags = [] for lg in logFiles: nml = MagicSetup(quiet=True, nml=lg) if nml.start_time > tstart: if os.path.exists('bLayersR.{}'.format(nml.tag)): tags.append(nml.tag) if len(tags) > 0: print(tags) else: tags = None MagicSetup.__init__(self, quiet=True, nml=logFiles[-1]) a = AvgField(model=json_model, write=False) self.nuss = 0.5 * (a.topnuss_av + a.botnuss_av) self.reynolds = a.rm_av e2fluct = a.ekin_pol_av + a.ekin_tor_av - a.ekin_pol_axi_av - a.ekin_tor_axi_av else: logFiles = scanDir('log.*') MagicSetup.__init__(self, quiet=True, nml=logFiles[-1]) tags = None self.nuss = 1. self.reynolds = 1. e2fluct = 1. par = MagicRadial(field='bLayersR', iplot=False, tags=tags) self.varS = abs(par.entropy_SD) self.ss = par.entropy if os.path.exists('tInitAvg'): logFiles = scanDir('log.*', tfix=1409827718.0) # Workaround for code mistake before this time tfix = 1409827718.0 tagsFix = [] for lg in logFiles: nml = MagicSetup(quiet=True, nml=lg) if nml.start_time > tstart: if os.path.exists('bLayersR.{}'.format(nml.tag)): tagsFix.append(nml.tag) if len(tagsFix) > 0: print('Fix temp. tags', tagsFix) parFix = MagicRadial(field='bLayersR', iplot=False, tags=tagsFix) self.varS = abs(parFix.entropy_SD) self.ss = parFix.entropy self.tags = tagsFix self.uh = par.uh self.duh = par.duhdr self.rad = par.radius self.ro = self.rad[0] self.ri = self.rad[-1] vol_oc = 4. / 3. * np.pi * (self.ro**3 - self.ri**3) self.rey_fluct = np.sqrt(2. * e2fluct / vol_oc) self.reh = 4. * np.pi * intcheb(self.rad**2 * self.uh, len(self.rad) - 1, self.ri, self.ro) / (4. / 3. * np.pi * (self.ro**3 - self.ri**3)) # Thermal dissipation boundary layer if hasattr(par, 'dissS'): self.dissS = par.dissS self.epsT = -4. * np.pi * intcheb(self.rad**2 * self.dissS, len(self.rad) - 1, self.ro, self.ri) self.epsTR = 4. * np.pi * self.rad**2 * self.dissS ind = getMaxima(-abs(self.epsTR - self.epsT)) try: self.dissTopS = self.ro - self.rad[ind[0]] self.dissBotS = self.rad[ind[-1]] - self.ri self.dissEpsTbl, self.dissEpsTbulk = integBulkBc( self.rad, self.epsTR, self.ri, self.ro, self.dissBotS, self.dissTopS) except IndexError: self.dissTopS = self.ro self.dissBotS = self.ri self.dissEpsTbl, self.dissEpsTbulk = 0., 0. print('thDiss bl, bulk', self.dissEpsTbl / self.epsT, self.dissEpsTbulk / self.epsT) # First way of defining the thermal boundary layers: with var(S) #rThLayer = getMaxima(self.rad, self.varS) ind = argrelextrema(self.varS, np.greater)[0] if len(ind) != 0: self.bcTopVarS = self.ro - self.rad[ind[0]] self.bcBotVarS = self.rad[ind[-1]] - self.ri else: self.bcTopVarS = 1. self.bcBotVarS = 1. if hasattr(self, 'epsT'): self.varSEpsTbl, self.varSEpsTbulk = integBulkBc( self.rad, self.epsTR, self.ri, self.ro, self.bcBotVarS, self.bcTopVarS) print('var(S) bl, bulk', self.varSEpsTbl / self.epsT, self.varSEpsTbulk / self.epsT) # Second way of defining the thermal boundary layers: intersection of the slopes d1 = matder(len(self.rad) - 1, self.ro, self.ri) self.ttm = 3.*intcheb(self.ss*self.rad**2, len(self.rad)-1, self.ri, self.ro) \ /(self.ro**3-self.ri**3) dsdr = np.dot(d1, self.ss) self.beta = dsdr[len(dsdr) // 2] print('beta={:.2f}'.format(self.beta)) self.slopeTop = dsdr[2] * (self.rad - self.ro) + self.ss[0] self.slopeBot = dsdr[-1] * (self.rad - self.ri) + self.ss[-1] self.dtdrm = dsdr[len(self.ss) // 2] tmid = self.ss[len(self.ss) // 2] self.slopeMid = self.dtdrm * (self.rad - self.rad[len(self.rad) // 2]) + tmid self.bcTopSlope = (tmid - self.ss[0]) / (self.dtdrm - dsdr[2]) self.bcBotSlope = -(tmid - self.ss[-1]) / (self.dtdrm - dsdr[-1]) # 2nd round with a more accurate slope bSlope = dsdr[self.rad <= self.ri + self.bcBotSlope / 4.].mean() tSlope = dsdr[self.rad >= self.ro - self.bcTopSlope / 4.].mean() self.slopeBot = bSlope * (self.rad - self.ri) + self.ss[-1] self.slopeTop = tSlope * (self.rad - self.ro) + self.ss[0] #self.bcTopSlope = -(self.ttm-self.ss[0])/tSlope self.bcTopSlope = -(tmid-self.dtdrm*self.rad[len(self.rad)//2] - self.ss[0] \ + tSlope*self.ro)/(self.dtdrm-tSlope) self.bcBotSlope = -(tmid-self.dtdrm*self.rad[len(self.rad)//2] - self.ss[-1] \ + bSlope*self.ri)/(self.dtdrm-bSlope) self.dto = tSlope * (self.bcTopSlope - self.ro) + self.ss[0] self.dti = bSlope * (self.bcBotSlope - self.ri) + self.ss[-1] self.dto = self.dto - self.ss[0] self.dti = self.ss[-1] - self.dti self.bcTopSlope = self.ro - self.bcTopSlope self.bcBotSlope = self.bcBotSlope - self.ri if hasattr(self, 'epsT'): self.slopeEpsTbl, self.slopeEpsTbulk = integBulkBc( self.rad, self.epsTR, self.ri, self.ro, self.bcBotSlope, self.bcTopSlope) print('slopes bl, bulk', self.slopeEpsTbl / self.epsT, self.slopeEpsTbulk / self.epsT) self.vi = a.viscDissR_av self.buo = a.buoPowerR_av self.epsV = -intcheb(self.vi, len(self.rad) - 1, self.ro, self.ri) ind = getMaxima(-abs(self.vi - self.epsV)) if len(ind) > 2: for i in ind: if self.vi[i - 1] - self.epsV > 0 and self.vi[ i + 1] - self.epsV < 0: self.dissTopV = self.ro - self.rad[i] elif self.vi[i - 1] - self.epsV < 0 and self.vi[ i + 1] - self.epsV > 0: self.dissBotV = self.rad[i] - self.ri else: self.dissTopV = self.ro - self.rad[ind[0]] self.dissBotV = self.rad[ind[-1]] - self.ri try: self.dissEpsVbl, self.dissEpsVbulk = integBulkBc( self.rad, self.vi, self.ri, self.ro, self.dissBotV, self.dissTopV) except AttributeError: self.dissTopV = 0. self.dissBotV = 0. self.dissEpsVbl = 0. self.dissEpsVbulk = 0. print('visc Diss bl, bulk', self.dissEpsVbl / self.epsV, self.dissEpsVbulk / self.epsV) # First way of defining the viscous boundary layers: with duhdr #rViscousLayer = getMaxima(self.rad, self.duh) if self.kbotv == 1 and self.ktopv == 1: ind = argrelextrema(self.duh, np.greater)[0] if len(ind) == 0: self.bcTopduh = 1. self.bcBotduh = 1. else: if ind[0] < 4: self.bcTopduh = self.ro - self.rad[ind[1]] else: self.bcTopduh = self.ro - self.rad[ind[0]] if len(self.rad) - ind[-1] < 4: self.bcBotduh = self.rad[ind[-2]] - self.ri else: self.bcBotduh = self.rad[ind[-1]] - self.ri self.slopeTopU = 0. self.slopeBotU = 0. self.uhTopSlope = 0. self.uhBotSlope = 0. self.slopeEpsUbl = 0. self.slopeEpsUbulk = 0. self.uhBot = 0. self.uhTop = 0. else: ind = argrelextrema(self.uh, np.greater)[0] if len(ind) == 1: ind = argrelextrema(self.uh, np.greater_equal)[0] if len(ind) == 0: self.bcTopduh = 1. self.bcBotduh = 1. else: if ind[0] < 4: self.bcTopduh = self.ro - self.rad[ind[1]] else: self.bcTopduh = self.ro - self.rad[ind[0]] if len(self.rad) - ind[-1] < 4: self.bcBotduh = self.rad[ind[-2]] - self.ri else: self.bcBotduh = self.rad[ind[-1]] - self.ri self.uhTop = self.uh[self.rad == self.ro - self.bcTopduh][0] self.uhBot = self.uh[self.rad == self.ri + self.bcBotduh][0] self.bcBotduh, self.bcTopduh, self.uhBot, self.uhTop = \ getAccuratePeaks(self.rad, self.uh, self.uhTop, \ self.uhBot, self.ri, self.ro) duhdr = np.dot(d1, self.uh) #1st round mask = (self.rad >= self.ro - self.bcTopduh / 4) * (self.rad < self.ro) slopeT = duhdr[mask].mean() mask = (self.rad <= self.ri + self.bcBotduh / 4) * (self.rad > self.ri) slopeB = duhdr[mask].mean() self.slopeTopU = slopeT * (self.rad - self.ro) + self.uh[0] self.slopeBotU = slopeB * (self.rad - self.ri) + self.uh[-1] self.uhTopSlope = -self.uhTop / slopeT self.uhBotSlope = self.uhBot / slopeB #2nd round mask = (self.rad >= self.ro - self.uhTopSlope / 4.) * (self.rad < self.ro) slopeT = duhdr[mask].mean() mask = (self.rad <= self.ri + self.uhBotSlope / 4) * (self.rad > self.ri) slopeB = duhdr[mask].mean() self.uhTopSlope = -self.uhTop / slopeT self.uhBotSlope = self.uhBot / slopeB self.slopeEpsUbl, self.slopeEpsUbulk = integBulkBc( self.rad, self.vi, self.ri, self.ro, self.uhBotSlope, self.uhTopSlope) self.uhEpsVbl, self.uhEpsVbulk = integBulkBc(self.rad, self.vi, self.ri, self.ro, self.bcBotduh, self.bcTopduh) print('uh bl, bulk', self.uhEpsVbl / self.epsV, self.uhEpsVbulk / self.epsV) # Convective Rol in the thermal boundary Layer ekinNas = a.ekin_polR_av + a.ekin_torR_av - a.ekin_pol_axiR_av - a.ekin_tor_axiR_av ReR = np.sqrt(2. * abs(ekinNas) / self.rad**2 / (4. * np.pi)) self.dl = a.dlVcR_av RolC = ReR * self.ek / self.dl y = RolC[self.rad >= self.ro - self.bcTopSlope] x = self.rad[self.rad >= self.ro - self.bcTopSlope] try: self.rolTop = simps(3. * y * x**2, x) / (self.ro**3 - (self.ro - self.bcTopSlope)**3) except IndexError: self.rolTop = 0. self.rolbl, self.rolbulk = integBulkBc(self.rad, 4. * np.pi * RolC * self.rad**2, self.ri, self.ro, self.bcBotSlope, self.bcTopSlope, normed=True) self.rebl, self.rebulk = integBulkBc(self.rad, 4. * np.pi * ReR * self.rad**2, self.ri, self.ro, self.bcBotSlope, self.bcTopSlope, normed=True) self.lengthbl, self.lengthbulk = integBulkBc(self.rad, self.dl * 4. * np.pi * self.rad**2, self.ri, self.ro, self.bcBotSlope, self.bcTopSlope, normed=True) self.rehbl, self.rehbulk = integBulkBc(self.rad, self.uh * 4. * np.pi * self.rad**2, self.ri, self.ro, self.bcBotduh, self.bcTopduh, normed=True) y = RolC[self.rad <= self.ri + self.bcBotSlope] x = self.rad[self.rad <= self.ri + self.bcBotSlope] self.rolBot = simps(3. * y * x**2, x) / ( (self.ri + self.bcBotSlope)**3 - self.ri**3) print('reynols bc, reynolds bulk', self.rebl, self.rebulk) print('reh bc, reh bulk', self.rehbl, self.rehbulk) print('rolbc, rolbulk, roltop, rolbot', self.rolbl, self.rolbulk, self.rolBot, self.rolTop) self.dl[0] = 0. self.dl[-1] = 0. self.lBot, self.lTop = integBotTop(self.rad, 4. * np.pi * self.rad**2 * self.dl, self.ri, self.ro, self.bcBotSlope, self.bcTopSlope, normed=True) uhbm, utbm = integBotTop(self.rad, 4. * np.pi * self.uh, self.ri, self.ro, self.bcBotSlope, self.bcTopSlope, normed=True) # Convective Rol in the thermal boundary Layer if len(scanDir('perpParR.*')) != 0: tags = [] for lg in logFiles: nml = MagicSetup(quiet=True, nml=lg) if nml.start_time > tstart: if os.path.exists('perpParR.{}'.format(nml.tag)): tags.append(nml.tag) perpPar = MagicRadial(field='perpParR', iplot=False, tags=tags) eperpNas = perpPar.Eperp - perpPar.Eperp_axi eparNas = perpPar.Epar - perpPar.Epar_axi RePerpNas = np.sqrt(2. * abs(eperpNas)) ReParNas = np.sqrt(2. * abs(eparNas)) RePerp = np.sqrt(2. * abs(perpPar.Eperp)) RePar = np.sqrt(2. * abs(perpPar.Epar)) self.reperpbl, self.reperpbulk = integBulkBc(self.rad, 4. * np.pi * RePerp * self.rad**2, self.ri, self.ro, self.bcBotSlope, self.bcTopSlope, normed=True) self.reparbl, self.reparbulk = integBulkBc(self.rad, 4. * np.pi * RePar * self.rad**2, self.ri, self.ro, self.bcBotSlope, self.bcTopSlope, normed=True) self.reperpnasbl, self.reperpnasbulk = integBulkBc( self.rad, 4. * np.pi * RePerpNas * self.rad**2, self.ri, self.ro, self.bcBotSlope, self.bcTopSlope, normed=True) self.reparnasbl, self.reparnasbulk = integBulkBc( self.rad, 4. * np.pi * ReParNas * self.rad**2, self.ri, self.ro, self.bcBotSlope, self.bcTopSlope, normed=True) else: self.reperpbl = 0. self.reperpbulk = 0. self.reparbl = 0. self.reparbulk = 0. self.reperpnasbl = 0. self.reperpnasbulk = 0. self.reparnasbl = 0. self.reparnasbulk = 0. if iplot: self.plot() if not quiet: print(self)
from magic import MagicSetup import glob import os ''' This script is used to reorder a directory in which the output files from MagIC have lost their original writing time. It will sort the log files and then touch all the output files to recreate a consistent series. ''' logFiles = sorted(glob.glob('log.*')) # Determine the last log lastLog = logFiles[-1] restarted_from = [] for log in logFiles: stp = MagicSetup(nml=log, quiet=True) if stp.l_start_file == 'T': l_start_file = True else: l_start_file = False if l_start_file: tag = stp.tag lst = stp.start_file.split('.') oldtag = ''.join(lst[1:]) if os.path.exists('log.' + oldtag): # all logFile exists restarted_from.append('log.' + oldtag) diff = list(set(logFiles) - set(restarted_from)) if len(diff) == 1: lastLog = diff[0] else: x = raw_input('Enter last tag: ')