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: ')
