def check_solver(solver, inputs=list_files(max_size=20)):
"""
Prove optimality with comparing solution with control version.
Only for small examples, sorry. For big ones you can call is_valid()
:param task:
:param function(task) solver:
:return:
"""
for fn in inputs:
task = read_input(fn)
solution = solver(task)
if not is_valid(task, solution):
print 'ERROR: solution for {fn} is invalid: {solution}'.format(fn=fn, solution=solution)
continue
control_solution = bruteforce_solver(task)
control_cost = calc_cost(task, control_solution)
cost = calc_cost(task, solution)
if cost != control_cost:
msg = ('ERROR: solution for {fn} has cost={cost}, but optimal is {control_cost}:\n' +
' control:{control_solution}\n' +
' tested: {solution}')
print msg.format(fn=fn, cost=cost, control_cost=control_cost,
control_solution=control_solution, solution=solution)
continue
print 'OK: solution for {fn} is optimal, cost={cost}'.format(fn=fn, cost=cost)
def check_solver(solver, inputs=list_files(max_size=20)):
"""
Prove optimality with comparing solution with control version.
Only for small examples, sorry. For big ones you can call is_valid()
:param task:
:param function(task) solver:
:return:
"""
for fn in inputs:
task = read_input(fn)
solution = solver(task)
if not is_valid(task, solution):
print 'ERROR: solution for {fn} is invalid: {solution}'.format(
fn=fn, solution=solution)
continue
control_solution = bruteforce_solver(task)
control_cost = calc_cost(task, control_solution)
cost = calc_cost(task, solution)
if cost != control_cost:
msg = (
'ERROR: solution for {fn} has cost={cost}, but optimal is {control_cost}:\n'
+ ' control:{control_solution}\n' +
' tested: {solution}')
print msg.format(fn=fn,
cost=cost,
control_cost=control_cost,
control_solution=control_solution,
solution=solution)
continue
print 'OK: solution for {fn} is optimal, cost={cost}'.format(fn=fn,
cost=cost)
def __init__(self, config, climateTS=None):
'''
Sets up the initial spatial grid, time grid, accumulation rate, age, density, mass, stress, and temperature of the model run
:param configName: name of json config file containing model configurations
'''
### load in json config file and parses the user inputs to a dictionary
# with open(configName, "r") as f:
# jsonString = f.read()
# self.c = json.loads(jsonString)
self.c = config
print('Spin run started')
print("physics are", self.c['physRho'])
if 'merging' not in self.c:
self.c['merging'] = False
### create directory to store results. Deletes if it exists already.
# Vincent says we do not want to remove existing directory (preferential flow?) - 4/24/19
if os.path.exists(self.c['resultsFolder']):
dir_exts = [
os.path.splitext(fname)[1]
for fname in os.listdir(self.c['resultsFolder'])
]
dir_unique = list(set(dir_exts))
CFM_exts = ['.json', '.hdf5']
if CFM_exts and all(((elem == ".json") or (elem == '.hdf5'))
for elem in dir_unique):
rmtree(self.c['resultsFolder'])
os.makedirs(self.c['resultsFolder'])
else:
print(
'WARNING: THE DIRECTORY YOU ARE USING CONTAINS NON-CFM FILES'
)
print(
'CFM will delete all files in the results directory with .hdf5 extension'
)
files_in_directory = os.listdir(self.c['resultsFolder'])
filtered_files = [
file for file in files_in_directory
if file.endswith(".hdf5")
]
for file in filtered_files:
path_to_file = os.path.join(self.c['resultsFolder'], file)
os.remove(path_to_file)
else:
os.makedirs(self.c['resultsFolder'])
############################
##### load input files #####
############################
### temperature ###
if climateTS != None:
input_temp = climateTS['TSKIN']
input_bdot = climateTS['BDOT']
input_year_temp = input_year_bdot = climateTS['time']
else:
input_temp, input_year_temp = read_input(
os.path.join(self.c['InputFileFolder'],
self.c['InputFileNameTemp']))
input_bdot, input_year_bdot = read_input(
os.path.join(self.c['InputFileFolder'],
self.c['InputFileNamebdot']))
if input_temp[0] < 0.0:
input_temp = input_temp + K_TO_C
try:
if self.c['spinup_climate_type'] == 'initial':
self.temp0 = input_temp[0]
elif self.c['spinup_climate_type'] == 'mean':
self.temp0 = np.mean(input_temp)
except Exception:
print(
"You should add key 'spinup_climate_type' to the config .json file"
)
print("spinup is based on mean climate of input")
self.temp0 = np.mean(input_temp)
### accumulation rate ###
try:
if self.c['spinup_climate_type'] == 'initial':
self.bdot0 = input_bdot[0]
elif self.c['spinup_climate_type'] == 'mean':
self.bdot0 = np.mean(input_bdot)
except:
self.bdot0 = np.mean(input_bdot)
if 'manual_climate' in self.c:
pass
else:
print(
"Add 'manual_climate' to the json to enable specifying long-term bdot and T"
)
self.c['manual_climate'] = False
if self.c[
'manual_climate']: # If we want to use a manually specified climate for spin up (e.g. known long-term values).
self.temp0 = self.c[
'deepT'] #specify deep T as mean temperature for spin up calculations (compaction,grain growth)
self.bdot0 = self.c[
'bdot_long'] # *1e-3/0.917 #specify long term accumulation as mean accumulation for spin up calculations (compaction,grain growth) + conversion from mmWE/yr to mIE/yr
print('make sure "bdot_long" has units of mIE/yr!')
### could include others, e.g. surface density
############################
############################
### set up model grid ######
############################
self.gridLen = int(
(self.c['H'] - self.c['HbaseSpin']) /
(self.bdot0 / self.c['stpsPerYear'])) # number of grid points
gridHeight = np.linspace(self.c['H'], self.c['HbaseSpin'],
self.gridLen)
self.z = self.c['H'] - gridHeight
self.dz = np.diff(self.z)
self.dz = np.append(self.dz, self.dz[-1])
self.dx = np.ones(self.gridLen)
print('Grid length is', self.gridLen)
############################
############################
### if the regridding module is being used, do the
### initial regridding
############################
# try:
# self.doublegrid = self.c['doublegrid']
# if self.c['doublegrid']:
# self.nodestocombine, self.z, self.dz, self.gridLen, self.dx, self.gridtrack = init_regrid(self)
# except:
# self.doublegrid = False
# print('you should add "doublegrid" to the json')
############################
### get an initial depth/density profile based on H&L analytic solution
############################
# if not self.c['initprofile']: #VV
THL = self.temp0
AHL = self.bdot0
try: #VV use Reeh corrected T
if self.c['ReehCorrectedT'] and self.c['MELT']:
input_snowmelt, input_year_snowmelt = read_input(
os.path.join(self.c['InputFileFolder'],
self.c['InputFileNamemelt'])) #VV
meanmelt = np.mean(
input_snowmelt
) # mean melt per year [mIE/yr] (units are specified in Reeh 2008)
meanacc = self.bdot0 # mean annual accumulation [mIE/yr]
self.SIR = min(
meanmelt, 0.6 * meanacc
) # Reeh 1991 and Reeh 2008 PMAX value is set at 0.6 melt becomes superimposed ice until it reaches 0.6 of annual acc, then runoff
THL = self.temp0 + 26.6 * self.SIR
THL = min(THL, 273.15)
elif (self.c['ReehCorrectedT'] and not self.c['MELT']):
print(
'"ReehCorrectedT" is True but melt is not turned on. That is weird. Exiting.'
)
sys.exit()
except:
print(
'add "ReehCorrectedT" to .json to enable melt-corrected temperature'
)
self.c['ReehCorrectedT'] = False
pass
self.age, self.rho = hl_analytic(self.c['rhos0'], self.z, THL,
AHL) # self.age is in age in seconds
# try:
self.doublegrid = self.c['doublegrid']
if self.c['doublegrid']:
### VV change 09/12/2020: surface node thicker to avoid deepening of transition depth ###
dznew = 917 / self.rho * self.dz #adjust ice equivalent thickness of nodes to a thickness approximated by HL analytic
znew = np.append(0, np.cumsum(dznew)[0:-1]) #adjust z accordingly
icut = np.where(znew > self.c['H'] -
self.c['HbaseSpin'])[0][0] #new lower index
self.z = znew[0:icut] #restrict firn column to domain limits
self.dz = dznew[0:icut] #restrict firn column to domain limits
self.gridLen = len(self.z) #new gridlen
self.dx = np.ones(self.gridLen) #adjust dx
# Recompute HL analytic on the updated profile #
self.age, self.rho = hl_analytic(
self.c['rhos0'], self.z, THL,
AHL) # self.age is in age in seconds
# Doublegrid routine #
self.z, self.dz, self.gridLen, self.dx, self.gridtrack = init_regrid22(
self) #VV grid22
# Recompute HL analytic on the regridded profile #
self.age, self.rho = hl_analytic(
self.c['rhos0'], self.z, THL,
AHL) # self.age is in age in seconds
print('After doublegrid, grid length is ', self.gridLen)
# print('z ', self.z[-5:])
# except:
# self.doublegrid = False
# print('you should add "doublegrid" to the json')
# if self.c['initprofile']: # VV filler values to avoid model blow up if THL and AHL are out of HL calibration range
# self.age = S_PER_YEAR*100*np.ones_like(self.dz) #VV this does not matter as it is rectified when we initialise profie below
# self.rho = 500*np.ones_like(self.dz)#VV this does not matter as it is rectified when we initialise profile
############################
############################
### set up time stepping
if self.c[
'AutoSpinUpTime']: # automatic, based on time that it will take for a parcel to get to 850 kg m^-3
try:
zz = np.min(self.z[self.rho > 850.0])
self.years = int(zz / self.bdot0)
except ValueError:
print("auto spin up error; using spin up time from json")
self.years = self.c[
'yearSpin'] # number of years to spin up for
else: # based on time taken to spin up in the config file.
self.years = self.c['yearSpin'] # number of years to spin up for
dt1 = S_PER_YEAR / self.c['stpsPerYear']
self.stp = int(self.years * S_PER_YEAR / dt1)
self.t = 1.0 / self.c['stpsPerYear'] # years per time step
self.dt = dt1 * np.ones(self.stp)
############################
############################
### Initial and boundary conditions
############################
### Surface temperature for each time step
self.Ts = self.temp0 * np.ones(self.stp)
if self.c[
'SeasonalTcycle']: #impose seasonal temperature cycle of amplitude 'TAmp'
if self.c['SeasonalThemi'] == 'north':
self.Ts = self.Ts - self.c['TAmp'] * (
np.cos(2 * np.pi * np.linspace(0, self.years, self.stp))
) # This is for Greenland
elif self.c['SeasonalThemi'] == 'south':
if self.c['coreless']:
self.Ts = self.Ts + self.c['TAmp'] * (
np.cos(
2 * np.pi * np.linspace(0, self.years, self.stp)) +
0.3 * np.cos(
4 * np.pi * np.linspace(0, self.years, self.stp))
) # Coreless winter, from Orsi
else:
self.Ts = self.Ts + self.c['TAmp'] * (
np.cos(2 * np.pi * np.linspace(0, self.years, self.stp)
)) # This is basic for Antarctica
else:
print(
'You have turned on the SeasonalTcycle, but you do not have'
)
print(
'the hemisphere selected. Exiting. (set to south or north')
sys.exit()
### initial temperature profile
# init_Tz = self.temp0 * np.ones(self.gridLen)
self.T_mean = self.temp0 * np.ones(self.stp)
self.Tz = self.temp0 * np.ones(self.gridLen)
self.T50 = np.mean(self.Tz[self.z < 50])
self.T10m = np.mean(self.T_mean)
if self.c['ReehCorrectedT']:
self.Tz = self.Tz + 26.6 * self.SIR # temperature correction accounting for latent heat, Reeh 1991 (5) Reeh 2008 (16)
self.Tz = np.minimum(self.Tz, 273.15)
self.T_mean = np.mean(self.Tz[self.z < 50])
self.T10m = self.T_mean
try:
ctest = self.c['conductivity']
except:
self.c['conductivity'] = 'Anderson'
### Accumulation rate for each time step
self.bdotSec0 = self.bdot0 / S_PER_YEAR / self.c[
'stpsPerYear'] # accumulation (m I.E. per second)
self.bdotSec = self.bdotSec0 * np.ones(
self.stp) # vector of accumulation at each time step
self.bdot_mean = np.ones_like(self.dz) * self.bdot0
self.bdot_av = self.bdot0 * np.ones(
self.stp) #The long-term mean accumulation rate
### Surface isotope values for each time step
if self.c['isoDiff']:
self.spin = True
self.Isotopes = {} #dictionary of class instances
self.iso_out = {} # outputs for each isotope
self.Isoz = {} # depth profile of each isotope, at each time step
self.Iso_sig2_z = {} # diffusion length profile
self.iso_sig2_out = {}
for isotope in self.c['iso']:
self.Isotopes[isotope] = isotopeDiffusion(
self.spin, self.c, isotope, self.stp, self.z)
### Surface Density
self.rhos0 = self.c['rhos0'] * np.ones(
self.stp
) # could configure this so that user specifies vector of some noise
### initial mass, stress, and mean accumulation rate
self.mass = self.rho * self.dz
self.sigma = self.mass * self.dx * GRAVITY
self.sigma = self.sigma.cumsum(axis=0)
self.mass_sum = self.mass.cumsum(axis=0)
### longitudinal strain rate
if self.c['strain']:
self.du_dx = np.zeros(self.gridLen)
self.du_dx[1:] = self.c['du_dx'] / (S_PER_YEAR)
### initial grain growth (if specified in config file)
if self.c['physGrain']:
# if self.c['calcGrainSize']:
# r02 = surfacegrain(self,0) #VV
# self.r2 = r02 * np.ones(self.gridLen)
# else:
self.r2 = np.linspace(self.c['r2s0'], (6 * self.c['r2s0']),
self.gridLen)
else:
self.r2 = None
### "temperature history" if using Morris physics
if self.c['physRho'] == 'Morris2014':
if 'QMorris' not in self.c:
print('Add "QMorris" to the .json. CFM is setting to 110e3')
self.c['QMorris'] = 110.0e3
# initial temperature history function (units seconds)
self.Hx = np.exp(-1 * self.c['QMorris'] /
(R * self.Tz)) * (self.age + self.dt[0])
self.THist = True
else:
self.THist = False
self.LWC = np.zeros_like(self.z)
self.MELT = False
self.c['LWCheat'] = 'enthalpy'
### values for Goujon physics
if self.c['physRho'] == 'Goujon2003':
self.Gamma_Gou = 0
self.Gamma_old_Gou = 0
self.Gamma_old2_Gou = 0
self.ind1_old = 0
#######################
#######################
try:
if self.c['no_densification']:
print('CAUTION: densification if OFF!')
else:
pass
except:
# print('no_densification not in .json; setting to false')
self.c['no_densification'] = False
state = state.parent
continue
if state.is_all_covered():
solution.store_result(state)
state = state.negate() # try to deselect the current set or rollback to the parent state
continue
if state.get_optimistic_cost() >= solution.best_cost:
if now() > deadline: # we get to this place often enough to stop in time,
# and we get to it not on the each iteration, so we will not check the time too frequently
return solution
state = state.negate() # try to deselect the current set or rollback to the parent state
continue
state = state.next_child()
solution.proven_as_optimal = True # we have not terminated on timeout, so we have explored all the tree
return solution
if __name__ == '__main__':
from reader import read_input
for fn in ['sc_157_0', 'sc_330_0', 'sc_1000_11', 'sc_5000_1', 'sc_10000_5', 'sc_10000_2']:
print '=== {} ==='.format(fn)
task = read_input('sc_45_0')
solution = deep_search(task, timeout=0.5*60)
print solution, solution.metrics
#from profile import run
#run('deep_search(task, timeout=120)', sort=2) # sort - 2 cumtime, 1 - totime
#PART-1: SETUP
#-------------------------------------------------------------------------
writer.write_header()
#CHECK THAT A FILE WAS PROVIDED BY USER
if(len(argv)!=2): raise ValueError("NO INPUT FILE")
#SB=SNOWBALL (i.e DICTIONARY THAT ACCUMULATED EVERYTHING)(SB != sackville baggins)
SB={};
SB['input_file']=argv[1]
##GET RUN PARAMETER
util.get_run_parameters(SB)
#READ INPUT FILES
reader.read_input(SB) #READ INPUT FILE AND ADD INFO TO SB
reader.read_pot_file(SB) #READ NN FILE AND ADD INFO TO SB
reader.read_database(SB); #READ DATABASES AND ADD INFO TO SB
#WRITE POSCAR IF DESIRED
if(SB['dump_poscars']): util.dump_poscars(SB)() #MOVE TO read_data
#COMPUTE NEIGHBORLIST (NBL) AND LSP FOR ALL STRUCTURES
util.compute_all_nbls(SB)
util.compute_all_lsps(SB)
util.partition_data(SB)
if(SB['normalize_gi']):
raise Exception("ERROR: NORMALIZATION OF Gi IS CURRENTLY DISABLED")
util.collect_all_lsp(SB) #MAKE A SINGLE MATRIX WITH ALL GI
util.normalize_lsp(SB)
def __init__(self, configName):
'''
Sets up the initial spatial grid, time grid, accumulation rate, age, density, mass, stress, and temperature of the model run
:param configName: name of json config file containing model configurations
'''
# load in json config file and parses the user inputs to a dictionary
with open(configName, "r") as f:
jsonString = f.read()
self.c = json.loads(jsonString)
print('Spin run started')
print("physics are", self.c['physRho'])
# create directory to store results. Deletes if it exists already.
if os.path.exists(self.c['resultsFolder']):
rmtree(self.c['resultsFolder'])
os.makedirs(self.c['resultsFolder'])
##### load input files #####
### temperature
input_temp, input_year_temp = read_input(self.c['InputFileNameTemp'])
if input_temp[0] < 0.0:
input_temp = input_temp + K_TO_C
self.temp0 = input_temp[0] #Make sure that this is what we want!
# self.temp0 = mean(input_temp[0:12]) #Make sure that this is what we want!
### accumulation rate
input_bdot, input_year_bdot = read_input(self.c['InputFileNamebdot'])
self.bdot0 = input_bdot[0] #Make sure that this is what we want!
### could include others, e.g. surface density
##########
##### set up model grid
self.gridLen = int(
(self.c['H'] - self.c['HbaseSpin']) /
(self.bdot0 / self.c['stpsPerYearSpin'])) # number of grid points
gridHeight = np.linspace(self.c['H'], self.c['HbaseSpin'],
self.gridLen)
self.z = self.c['H'] - gridHeight
self.dz = np.diff(self.z)
self.dz = np.append(self.dz, self.dz[-1])
self.dx = np.ones(self.gridLen)
##### get an initial depth/density profile based on H&L analytic solution
THL = input_temp[0]
AHL = input_bdot[0]
self.age, self.rho = hl_analytic(self.c['rhos0'], self.z, THL,
AHL) # self.age is in age in seconds
###### get initial isotope diffusion length using HL analytical, returns a dictionary with keys "D", "18", "17"
self.iso_sigma = iso_diffusion_vas.Sigma(P = self.c['P_atm'], rho_o = self.c['rhos0'], \
rho_co = self.c['rho_co_iso']).analytical_HL(rho_array = self.rho, T = THL, accum_ice = AHL)
print(self.iso_sigma['D'][0])
print('blablabla')
# plt.figure(1)
# plt.plot(self.z, self.iso_sigma['D'])
# plt.plot(self.z, self.iso_sigma['18'])
# plt.plot(self.z, self.iso_sigma['17'])
# plt.show()
##### set up time stepping
if self.c[
'AutoSpinUpTime']: # automatic, based on time that it will take for a parcel to get to 850 kg m^-3
try:
zz = np.min(self.z[self.rho > 850.0])
self.years = int(zz / self.bdot0)
except ValueError:
print("auto spin up error; using spin up time from json")
self.years = self.c[
'yearSpin'] # number of years to spin up for
else: # based on time taken to spin up in the config file.
self.years = self.c['yearSpin'] # number of years to spin up for
self.dt = S_PER_YEAR / self.c['stpsPerYearSpin']
self.stp = int(self.years * S_PER_YEAR / self.dt)
self.t = 1.0 / self.c['stpsPerYearSpin'] # years per time step
# self.stp = int(self.years * self.c['stpsPerYearSpin']) # total number of time steps, as integer
# self.dt = self.years * S_PER_YEAR / self.stp # size of time steps, seconds
# # self.dts = self.years / self.stp # size of time step, years
# self.t = 1.0 / self.c['stpsPerYearSpin'] # years per time step
# print 'dts', self.dts
# print 't', self.t
#####
### Surface temperature for each time step
self.Ts = self.temp0 * np.ones(self.stp)
self.T_mean = np.mean(self.Ts) # MS 3/7/17: is this what we want?
if self.c[
'SeasonalTcycle']: #impose seasonal temperature cycle of amplitude 'TAmp', including coreless winter (Orsi)
self.Ts = self.Ts + self.c['TAmp'] * (
np.cos(2 * np.pi * np.linspace(0, self.years, self.stp)) +
0.3 * np.cos(4 * np.pi * np.linspace(0, self.years, self.stp)))
# initial temperature profile
init_Tz = input_temp[0] * np.ones(self.gridLen)
### Accumulation rate for each time step
self.bdotSec0 = self.bdot0 / S_PER_YEAR / self.c[
'stpsPerYearSpin'] # accumulation (m I.E. per second)
self.bdotSec = self.bdotSec0 * np.ones(
self.stp) # vector of accumulation at each time step
### Surface isotope values for each time step
if self.c['isoDiff']:
try:
input_iso, input_year_iso = read_input(
self.c['InputFileNameIso'])
del_s0 = input_iso[0]
except:
print(
'No external file for surface isotope values found, but you specified in the config file that isotope diffusion is on. The model will generate its own synthetic isotope data for you.'
)
del_s0 = -50.0
self.del_s = del_s0 * np.ones(self.stp)
init_del_z = del_s0 * np.ones(self.gridLen)
self.del_z = init_del_z
else:
self.del_s = None
init_del_z = None
### Surface Density
self.rhos0 = self.c['rhos0'] * np.ones(self.stp)
# could configure this so that user specifies vector of surface elevation
# could add noise too
### set up initial mass, stress, and mean accumulation rate
self.mass = self.rho * self.dz
self.sigma = self.mass * self.dx * GRAVITY
self.sigma = self.sigma.cumsum(axis=0)
self.mass_sum = self.mass.cumsum(axis=0)
self.bdot_mean = (np.concatenate(
([self.mass_sum[0] / (RHO_I * S_PER_YEAR)], self.mass_sum[1:] /
(self.age[1:] * RHO_I / self.t)))
) * self.c['stpsPerYear'] * S_PER_YEAR
### set up longitudinal strain rate
if self.c['strain']:
self.du_dx = np.zeros(self.gridLen)
self.du_dx[1:] = self.c['du_dx'] / (S_PER_YEAR)
### set up initial temperature grid as well as a class to handle heat/isotope diffusion
# self.diffu = Diffusion(self.z, self.stp, self.gridLen, init_Tz, init_del_z) # is this the best way to do this?
self.Tz = init_Tz
self.T_mean = self.Tz[0]
self.T10m = self.T_mean
### set up initial grain growth (if specified in config file)
if self.c['physGrain']:
if self.c['calcGrainSize']:
r02 = -2.42e-9 * (
self.Ts) + 9.46e-7 # where does this equation come from?
self.r2 = r02 * np.ones(self.gridLen)
else:
self.r2 = np.linspace(self.c['r2s0'], (6 * self.c['r2s0']),
self.gridLen)
else:
self.r2 = None
### set up "temperature history" if using Morris physics
if self.c['physRho'] == 'Morris2014':
# initial temperature history function (units seconds)
self.Hx = np.exp(-110.0e3 / (R * init_Tz)) * (self.age + self.dt)
self.THist = True
else:
self.THist = False
print('Ts', self.Ts[-4:])
print('bdot_s', self.bdotSec[-4:])
print('dt', self.dt)
def __init__(self, spin, config, isotope, stp, z, modeltime=None):
'''
Initialize Isotope diffusion class.
'''
self.c = config
self.isotope = isotope
try:
fn = os.path.splitext(self.c['InputFileNameIso'])
isofile = fn[0] + '_{}'.format(self.isotope) + fn[1]
print(isofile)
if isotope == 'NoDiffusion':
isofile = fn[0] + '_dD' + fn[1]
input_iso, input_year_iso = read_input(
os.path.join(self.c['InputFileFolder'], isofile))
if spin:
if self.c['spinup_climate_type'] == 'initial':
del_s0 = input_iso[0]
elif self.c['spinup_climate_type'] == 'mean':
del_s0 = np.mean(input_iso)
self.del_s = del_s0 * np.ones(stp)
self.del_z = del_s0 * np.ones_like(z)
self.iso_sig2_s = 0 * np.zeros(stp)
self.iso_sig2_z = 0 * np.ones_like(z)
elif not spin:
del_z_init = read_init(self.c['resultsFolder'],
self.c['spinFileName'],
'IsoSpin_{}'.format(self.isotope))
iso_sig2_init = read_init(self.c['resultsFolder'],
self.c['spinFileName'],
'iso_sig2_{}'.format(self.isotope))
self.del_z = del_z_init[1:]
self.iso_sig2_z = iso_sig2_init[1:]
Isf = interpolate.interp1d(
input_year_iso,
input_iso,
self.c['int_type'],
fill_value='extrapolate') # interpolation function
self.del_s = Isf(
modeltime) # isotopes interpolated to modeltime
self.iso_sig2_s = np.zeros(stp)
except:
print(
'No external file for surface isotope values found ({}), but you specified in the config file that isotope diffusion is on. The model will generate its own synthetic isotope data for you.'
.format(self.isotope))
print(
'Double check that file name is correct. New module will add d18O or dD to filename for input.'
)
if spin:
del_s0 = -50.0
print(
'Currently this is -50 per mil, regardless of isotope you choose.'
)
self.del_s = del_s0 * np.ones(stp)
self.del_z = del_s0 * np.ones_like(z)
self.iso_sig2_s = 0 * np.zeros(stp)
self.iso_sig2_z = 0 * np.ones_like(z)
elif not spin:
del_z_init = read_init(self.c['resultsFolder'],
self.c['spinFileName'],
'IsoSpin_{}'.format(self.isotope))
iso_sig2_init = read_init(self.c['resultsFolder'],
self.c['spinFileName'],
'iso_sig2_{}'.format(self.isotope))
self.del_z = del_z_init[1:]
self.iso_sig2_z = iso_sig2_init[1:]
ar1 = 0.9 # red noise memory coefficient
std_rednoise = 2 # red noise standard deviation
self.del_s = std_rednoise * np.random.randn(stp) # white noise
for x in range(1, stp):
self.del_s[x] = self.del_s[x - 1] * ar1 + np.random.randn(
) # create red noise from white
self.del_s = self.del_s - 50
self.iso_sig2_s = np.zeros(stp)
if 'site_pressure' not in self.c:
print('site_pressure is not in .json; defaulting to 1013.25')
self.c['site_pressure'] = 1013.25
def __init__(self, configName):
'''
Sets up the initial spatial grid, time grid, accumulation rate, age, density, mass, stress, and temperature of the model run
:param configName: name of json config file containing model configurations
'''
### load in json config file and parses the user inputs to a dictionary
self.spin=False
with open(configName, "r") as f:
jsonString = f.read()
self.c = json.loads(jsonString)
print('Spin run started')
print("physics are", self.c['physRho'])
try:
print('Merging is:',self.c["merging"])
except Exception:
print('"merging" missing from .json fields')
pass
### create directory to store results. Deletes if it exists already.
# Vincent says we do not want to remove existing (preferential flow?) - 4/24/19
if os.path.exists(self.c['resultsFolder']):
rmtree(self.c['resultsFolder'])
os.makedirs(self.c['resultsFolder'])
############################
##### load input files #####
############################
### temperature
input_temp, input_year_temp = read_input(os.path.join(self.c['InputFileFolder'],self.c['InputFileNameTemp']))
if input_temp[0] < 0.0:
input_temp = input_temp + K_TO_C
try:
if self.c['spinup_climate_type']=='initial':
self.temp0 = input_temp[0]
elif self.c['spinup_climate_type']=='mean':
self.temp0 = np.mean(input_temp)
except Exception:
print("You should add key 'spinup_climate_type' to the config .json file")
print("spinup is based on mean climate of input")
self.temp0 = np.mean(input_temp)
### accumulation rate
input_bdot, input_year_bdot = read_input(os.path.join(self.c['InputFileFolder'],self.c['InputFileNamebdot']))
try:
if self.c['spinup_climate_type']=='initial':
self.bdot0 = input_bdot[0]
elif self.c['spinup_climate_type']=='mean':
self.bdot0 = np.mean(input_bdot)
except:
self.bdot0 = np.mean(input_bdot)
try:
if self.c['manual_climate']: # If we want to use a manually specified climate for spin up (e.g. known long-term values).
self.temp0 = self.c['deepT'] #specify deep T as mean temperature for spin up calculations (compaction,grain growth)
self.bdot0 = self.c['bdot_long']# *1e-3/0.917 #specify long term accumulation as mean accumulation for spin up calculations (compaction,grain growth) + conversion from mmWE/yr to mIE/yr
print('make sure "bdot_long" has units of mIE/yr!')
except Exception:
print("Add 'manual_climate' to the json to enable specifying bdot and T")
# if self.c['initprofile']: #pretty sure that this does not need to depend on init profile?
### Vincent's code
# try:
# if self.c['singleleap'] or self.c['singlenormal']: #VV If we use the initprofile but the input forcing data does not cover an entire year
# self.temp0 = self.c['deepT'] #VV use deep T as mean temperature for spin up calculations (compaction,grain growth)
# self.bdot0 = self.c['bdot_long']*1e-3/0.917 #VV use long term accumulation as mean accumulation for spin up calculations (compaction,grain growth) + conversion from mmWE/yr to mIE/yr
# except Exception:
# print("you are using an initial profile for spinup,")
# print("but you do not have 'singleleap' or 'singlenormal' in the .json")
print('bdot0', self.bdot0)
print('temp0', self.temp0)
### could include others, e.g. surface density
############################
############################
### set up model grid ######
############################
self.gridLen = int((self.c['H'] - self.c['HbaseSpin']) / (self.bdot0 / self.c['stpsPerYearSpin'])) # number of grid points
gridHeight = np.linspace(self.c['H'], self.c['HbaseSpin'], self.gridLen)
self.z = self.c['H'] - gridHeight
self.dz = np.diff(self.z)
self.dz = np.append(self.dz, self.dz[-1])
self.dx = np.ones(self.gridLen)
print('Grid length is', self.gridLen)
############################
############################
### if the regridding module is being used, do the
### initial regridding
############################
try:
self.doublegrid = self.c['doublegrid']
if self.c['doublegrid']:
self.nodestocombine, self.z, self.dz, self.gridLen, self.dx, self.gridtrack = init_regrid(self)
except:
self.doublegrid = False
print('you should add "doublegrid" to the json')
############################
### get an initial depth/density profile based on H&L analytic solution
############################
# if not self.c['initprofile']: #VV
THL = self.temp0
AHL = self.bdot0
try: #VV use Reeh corrected T
if self.c['Reeh91'] and self.c['MELT']:
input_snowmelt, input_year_snowmelt = read_input(os.path.join(self.c['InputFileFolder'],self.c['InputFileNamemelt'])) #VV
meanmelt = np.mean(input_snowmelt) # mean melt per year [mIE/yr] (units are specified in Reeh 2008)
meanacc = self.bdot0 # mean annual accumulation [mIE/yr]
#SIR_step = np.minimum(input_snowmelt,0.6*meanacc) # Reeh 1991 and Reeh 2008 PMAX value is set at 0.6 melt becomes superimposed ice until it reaches 0.6 of annual acc, then runoff
#SIR = np.mean(SIR_step) # annual mean superimposed ice formation
SIR = min(meanmelt,0.6*meanacc)
THL = self.temp0 + 26.6*SIR
THL = min(THL,273.15)
except:
print('add "Reeh91" to .json to enable melt-corrected temperature')
pass
self.age, self.rho = hl_analytic(self.c['rhos0'], self.z, THL, AHL) # self.age is in age in seconds
# elif self.c['initprofile'] == True: # VV we have an initial temperature and density profile
# Just avoid the model to blow up because it has no age and rho variables, real values are given below
# self.age = S_PER_YEAR*100*np.ones_like(self.dz) #VV this does not matter as it is rectified when we initialise profie below
# self.rho = 500*np.ones_like(self.dz)#VV this does not matter as it is rectified when we initialise profile
############################
############################
### set up time stepping
if self.c['AutoSpinUpTime']: # automatic, based on time that it will take for a parcel to get to 850 kg m^-3
try:
zz = np.min(self.z[self.rho > 850.0])
self.years = int(zz / self.bdot0)
except ValueError:
print("auto spin up error; using spin up time from json")
self.years = self.c['yearSpin'] # number of years to spin up for
else: # based on time taken to spin up in the config file.
self.years = self.c['yearSpin'] # number of years to spin up for
self.dt = S_PER_YEAR / self.c['stpsPerYearSpin']
self.stp = int(self.years*S_PER_YEAR/self.dt)
self.t = 1.0 / self.c['stpsPerYearSpin'] # years per time step
############################
############################
### Initial and boundary conditions
############################
### Surface temperature for each time step
self.Ts = self.temp0 * np.ones(self.stp)
if self.c['SeasonalTcycle']: #impose seasonal temperature cycle of amplitude 'TAmp'
if self.c['SeasonalThemi'] == 'north':
self.Ts = self.Ts - self.c['TAmp'] * (np.cos(2 * np.pi * np.linspace(0, self.years, self.stp))) # This is for Greenland
elif self.c['SeasonalThemi'] == 'south':
if self.c['coreless']:
self.Ts = self.Ts + self.c['TAmp'] * (np.cos(2 * np.pi * np.linspace(0, self.years, self.stp)) + 0.3 * np.cos(4 * np.pi * np.linspace(0, self.years, self.stp))) # Coreless winter, from Orsi
else:
self.Ts = self.Ts + self.c['TAmp'] * (np.cos(2 * np.pi * np.linspace(0, self.years, self.stp))) # This is basic for Antarctica
else:
print('You have turned on the SeasonalTcycle, but you do not have')
print('the hemisphere selected. Exiting. (set to south or north')
sys.exit()
### initial temperature profile
# init_Tz = input_temp[0] * np.ones(self.gridLen)
init_Tz = np.mean(self.Ts) * np.ones(self.gridLen)
### Accumulation rate for each time step
self.bdotSec0 = self.bdot0 / S_PER_YEAR / self.c['stpsPerYearSpin'] # accumulation (m I.E. per second)
self.bdotSec = self.bdotSec0 * np.ones(self.stp) # vector of accumulation at each time step
### Surface isotope values for each time step
if self.c['isoDiff']:
try:
input_iso, input_year_iso = read_input(self.c['InputFileNameIso'])
del_s0 = input_iso[0]
except:
print('No external file for surface isotope values found, but you specified in the config file that isotope diffusion is on. The model will generate its own synthetic isotope data for you.')
del_s0 = -50.0
self.del_s = del_s0 * np.ones(self.stp)
init_del_z = del_s0 * np.ones(self.gridLen)
self.del_z = init_del_z
else:
self.del_s = None
init_del_z = None
### Surface Density
self.rhos0 = self.c['rhos0'] * np.ones(self.stp)
# could configure this so that user specifies vector of surface elevation
# could add noise too
### initial mass, stress, and mean accumulation rate
self.mass = self.rho * self.dz
self.sigma = self.mass * self.dx * GRAVITY
self.sigma = self.sigma.cumsum(axis = 0)
self.mass_sum = self.mass.cumsum(axis = 0)
#VVself.bdot_mean = (np.concatenate(([self.mass_sum[0] / (RHO_I * S_PER_YEAR)], self.mass_sum[1:] / (self.age[1:] * RHO_I / self.t)))) * self.c['stpsPerYear'] * S_PER_YEAR
### Mean temperatures and accumulation rates #VV ###
### MS: commented out for now 10/4/18
# if self.c['initprofile']:
# self.T_av = self.c['Ts_long'] * np.ones(self.stp) # If we use initial profile, Ts_long is best guess for Tav
# self.bdot_av = self.c['bdot_long']*1e-3/0.917 * np.ones(self.stp) # If we use initial profile, bdotlong is best guess for bdot_av + conversion from mmWE/yr to mIE/yr
# self.bdot_mean = np.ones_like(self.dz)*self.c['bdot_long']*1e-3/0.917 # Also best guess for bdot_mean
# else:
self.T_av = self.temp0 * np.ones(self.stp) #VV This is to be used instead of T10m
self.bdot_av = self.bdot0* np.ones(self.stp) #VV
self.bdot_mean = (np.concatenate(([self.mass_sum[0] / (RHO_I * S_PER_YEAR)], self.mass_sum[1:] / (self.age[1:] * RHO_I / self.t)))) * self.c['stpsPerYear'] * S_PER_YEAR #VV
### longitudinal strain rate
if self.c['strain']:
self.du_dx = np.zeros(self.gridLen)
self.du_dx[1:] = self.c['du_dx']/(S_PER_YEAR)
### initial temperature grid
self.Tz = init_Tz
self.T_mean = np.mean(self.Tz[self.z<50])
self.T10m = self.T_mean
### VV addition
# print('self.Tz[0:5] no Reeh:',self.Tz[0:5])
#
# ##VV Correction of temperature profile with latent heat release from meltwater, following Reeh 1991 parameterisation ##
# try:
# if self.c['Reeh91'] and self.c['MELT']:
# input_snowmelt, input_year_snowmelt = read_input(os.path.join(self.c['InputFileFolder'],self.c['InputFileNamemelt'])) #VV
# meanmelt = np.mean(input_snowmelt) # mean melt per year [mIE/yr] (units are specified in Reeh 2008)
# meanacc = self.bdot0 # mean annual accumulation [mIE/yr]
# #SIR_step = np.minimum(input_snowmelt,0.6*meanacc) # Reeh 1991 and Reeh 2008 PMAX value is set at 0.6 melt becomes superimposed ice until it reaches 0.6 of annual acc, then runoff
# #SIR = np.mean(SIR_step) # annual mean superimposed ice formation
#
# SIR = min(meanmelt,0.6*meanacc)
#
# self.Tz = init_Tz + 26.6*SIR # Correction of temperatures taking into account latent heat, Reeh 1991 (5) Reeh 2008 (16)
# self.Tz = np.minimum(self.Tz,273.15)
# self.T_mean = np.mean(self.Tz[self.z<50])
# self.T10m = self.T_mean
# print('self.Tz[0:5] Reeh:',self.Tz[0:5])
# except:
# pass
### end VV addition
### initial grain growth (if specified in config file)
if self.c['physGrain']:
if self.c['calcGrainSize']:
r02 = surfacegrain(self,0) #VV
self.r2 = r02 * np.ones(self.gridLen)
else:
self.r2 = np.linspace(self.c['r2s0'], (6 * self.c['r2s0']), self.gridLen)
else:
self.r2 = None
### "temperature history" if using Morris physics
if self.c['physRho']=='Morris2014':
# initial temperature history function (units seconds)
self.Hx = np.exp(-110.0e3/(R*init_Tz))*(self.age+self.dt)
self.THist = True
else:
self.THist = False
self.LWC = np.zeros_like(self.z)
self.MELT = False
def load_strain(self, spin=False):
'''
Load strain rate inputs for spin-up and main run. Depending on the number of data rows in the strain input file, the
input is taken as (1-valued) the divergence rate, (2-valued) the principal horizontal strain rates or (3-valued) the
horizontal strain rate components eps_xx, eps_yy and eps_xy.
Falk Oraschewski, 17.05.2022
:param self:
:param spin:
:return self.eps_eff_hor_2, self.eps_divergence, self.c:
'''
int_type = self.c['int_type']
input_eps, input_year_eps, input_eps_full, input_year_eps_full = read_input(
os.path.join(self.c['InputFileFolder'], self.c['InputFileNameStrain']))
if np.ndim(input_eps) == 1:
if spin:
if self.c['spinup_climate_type'] == 'initial':
self.eps_divergence = input_eps[0] * np.ones(self.gridLen)
else:
self.eps_divergence = np.mean(input_eps) * np.ones(
self.gridLen)
else:
print(
'Single valued strain rate input is taken as horizontal divergence rates. Strain softening is deactivated.'
)
dusf = interpolate.interp1d(input_year_eps,
input_eps,
int_type,
fill_value='extrapolate')
self.eps_divergence = dusf(self.modeltime)
self.c['strain_softening'] = False # Deactivate strain softening
self.eps_eff_hor_2 = np.zeros_like(
self.eps_divergence
) # Create empty effective horizontal strain rate.
elif np.min(np.shape(input_eps)) == 2:
input_eps_1, input_eps_2 = input_eps[0, :], input_eps[1, :]
if spin:
if self.c['spinup_climate_type'] == 'initial':
eps_1 = input_eps_1[0] * np.ones(self.gridLen)
eps_2 = input_eps_2[0] * np.ones(self.gridLen)
else:
print(
'2-valued strain rate input is taken as principal horizontal strain rates.'
)
eps_1 = np.mean(input_eps_1) * np.ones(self.gridLen)
eps_2 = np.mean(input_eps_2) * np.ones(self.gridLen)
else:
d1sf = interpolate.interp1d(input_year_eps,
input_eps_1,
int_type,
fill_value='extrapolate')
d2sf = interpolate.interp1d(input_year_eps,
input_eps_2,
int_type,
fill_value='extrapolate')
eps_1 = d1sf(self.modeltime)
eps_2 = d2sf(self.modeltime)
self.eps_eff_hor_2 = (eps_1**2 + eps_2**2) / 2
self.eps_divergence = -(eps_1 + eps_2)
elif np.min(np.shape(input_eps)) == 3:
input_eps_xx, input_eps_yy, input_eps_xy = input_eps[0, :], input_eps[
1, :], input_eps[2, :]
if spin:
if self.c['spinup_climate_type'] == 'initial':
eps_xx = input_eps_xx[0] * np.ones(self.gridLen)
eps_yy = input_eps_yy[0] * np.ones(self.gridLen)
eps_xy = input_eps_xy[0] * np.ones(self.gridLen)
else:
print(
'3-valued strain rate input is taken as the horizontal components eps_xx, eps_yy and eps_xy in that order.'
)
eps_xx = np.mean(input_eps_xx) * np.ones(self.gridLen)
eps_yy = np.mean(input_eps_yy) * np.ones(self.gridLen)
eps_xy = np.mean(input_eps_xy) * np.ones(self.gridLen)
else:
dxxsf = interpolate.interp1d(input_year_eps,
input_eps_xx,
int_type,
fill_value='extrapolate')
dyysf = interpolate.interp1d(input_year_eps,
input_eps_yy,
int_type,
fill_value='extrapolate')
dxysf = interpolate.interp1d(input_year_eps,
input_eps_xy,
int_type,
fill_value='extrapolate')
eps_xx = dxxsf(self.modeltime)
eps_yy = dyysf(self.modeltime)
eps_xy = dxysf(self.modeltime)
self.eps_eff_hor_2 = (eps_xx**2 + eps_yy**2 + 2 * eps_xy**2) / 2
self.eps_divergence = -(eps_xx + eps_yy)
return self.eps_eff_hor_2, self.eps_divergence, self.c
for item_idx in cand_items:
sets = self.item2sets[item_idx]
sets.remove(cand_idx)
if not sets:
self.is_feasible = False
return # We cant cover the item
def on_sets_chosen(self, sets):
covered_items = set()
for s in sets:
covered_items.update(self.set2items.pop(s))
self.on_items_covered(covered_items)
# Getting info
def is_all_covered(self):
return not self.item2sets
def get_optimistic_cost(self):
return self.estimator.get_optimistic(self)
if __name__ == '__main__':
from reader import read_input
from time import time as now
state = State.from_task(read_input('sc_15_0'))
# st = now()
# state.remove_redundant_sets()
# print now() - st
print(
'Opening a continuous portal to our AI for continuous streaming of input and output.'
)
active = True
elif int(args.stream) == 2:
print(
'Opening a continuous portal to our AI for continuous streaming of input and output.'
)
else:
print('Please specify either -stream 0, -stream 1 or -stream 2.')
exit()
fn = str(args.fn)
print('\n Welcome to DeepXS version Alpha 2\n')
""" MAIN """
#read input
input_data = read_input(fn, array=array)
#pair settings
c1c1_occurences = [0, 1, 5, 6, 7, 11, 12, 13]
n2n2_occurences = [0, 2, 5, 8, 9, 11, 12, 14]
n2c1p_occurences = [0, 3, 6, 8, 10, 11, 13, 14]
n2c1m_occurences = [0, 4, 7, 9, 10, 12, 13, 14]
if int(args.stream) == 0:
#c1c1
for i in c1c1_occurences:
if i == setting:
c1c1_LO_data, c1c1_NLO_data = preprocess_c1c1(input_data,
LO=1,
NLO=1,
array=array)
c1c1_LO_model, c1c1_NLO_model = build_c1c1_AI(
'''
setup_simulation.py
Reads setup.cfg file from current directory, creates necessary directories
and creates the solvers configuration files
'''
import os
import sys
from reader import read_input
if not os.path.exists("./setup.cfg"):
print("Could not find 'setup.cfg' in current directory. Aborting")
sys.exit(1)
for dir_name in ["./input", "./output"]:
if not os.path.exists(dir_name):
os.mkdir(dir_name)
if not os.path.isdir(dir_name):
raise NotADirectoryError(dir_name)
input_file = open("./setup.cfg")
opts, geometry = read_input(input_file)
with open("./solver.cfg", "w") as out:
out.write("# File generated automatically - do not change it\n" +
"# To rebuild the configuration use the setup.cfg file\n" +
"# and rerun the setup_simulation.py distributed\n" +
"# with the package\n\n\n")
for key, value in sorted(opts.items()):
out.write(key + " = " + value + "\n")
def measure_duration(fn, solver=bruteforce_solver):
start_time = now()
solver(read_input(fn))
return now() - start_time
def comp(dbCart, Nx, Ny, nu, rho):
nR = Ny
nTh = Nx
# Read interpolating mesh info
ReTau, Rmax, drp1, compressedMesh = reader.read_input(
'input.txt', 'rotAvg')
xx, yy, theta = disk(Rmax, compressedMesh, ReTau, drp1, nR, nTh)
# re-order x,y
X = np.transpose(xx)
Y = np.transpose(yy)
k = 0
x1 = np.zeros(nTh * nR)
y1 = np.zeros(nTh * nR)
angle = np.array([])
for i in range(0, nR):
a = theta[:, i]
angle = np.concatenate((angle, a), axis=None)
for j in range(0, nTh):
for i in range(0, nR):
x1[k] = X[i, j]
y1[k] = Y[i, j]
k = k + 1
# Transpose the imported data tensors
U = np.transpose(dbCart['U'])
V = np.transpose(dbCart['V'])
W = np.transpose(dbCart['W'])
uu = np.transpose(dbCart['uu'])
uv = np.transpose(dbCart['uv'])
uw = np.transpose(dbCart['uw'])
vv = np.transpose(dbCart['vv'])
vw = np.transpose(dbCart['vw'])
ww = np.transpose(dbCart['ww'])
dUdx = np.transpose(dbCart['dUdx'])
dUdy = np.transpose(dbCart['dUdy'])
dUdz = np.transpose(dbCart['dUdz'])
dVdx = np.transpose(dbCart['dVdx'])
dVdy = np.transpose(dbCart['dVdy'])
dVdz = np.transpose(dbCart['dVdz'])
dWdx = np.transpose(dbCart['dWdx'])
dWdy = np.transpose(dbCart['dWdy'])
dWdz = np.transpose(dbCart['dWdz'])
Pxx = np.transpose(dbCart['Pxx'])
Pxy = np.transpose(dbCart['Pxy'])
Pxz = np.transpose(dbCart['Pxz'])
Pyy = np.transpose(dbCart['Pyy'])
Pyz = np.transpose(dbCart['Pyz'])
Pzz = np.transpose(dbCart['Pzz'])
Dxx = np.transpose(dbCart['Dxx'])
Dxy = np.transpose(dbCart['Dxy'])
Dxz = np.transpose(dbCart['Dxz'])
Dyy = np.transpose(dbCart['Dyy'])
Dyz = np.transpose(dbCart['Dyz'])
Dzz = np.transpose(dbCart['Dzz'])
Cxx = np.transpose(dbCart['Cxx'])
Cxy = np.transpose(dbCart['Cxy'])
Cxz = np.transpose(dbCart['Cxz'])
Cyy = np.transpose(dbCart['Cyy'])
Cyz = np.transpose(dbCart['Cyz'])
Czz = np.transpose(dbCart['Czz'])
Txx = np.transpose(dbCart['Txx'])
Txy = np.transpose(dbCart['Txy'])
Txz = np.transpose(dbCart['Txz'])
Tyy = np.transpose(dbCart['Tyy'])
Tyz = np.transpose(dbCart['Tyz'])
Tzz = np.transpose(dbCart['Tzz'])
VDxx = np.transpose(dbCart['VDxx'])
VDxy = np.transpose(dbCart['VDxy'])
VDxz = np.transpose(dbCart['VDxz'])
VDyy = np.transpose(dbCart['VDyy'])
VDyz = np.transpose(dbCart['VDyz'])
VDzz = np.transpose(dbCart['VDzz'])
PTxx = np.transpose(dbCart['PTxx'])
PTxy = np.transpose(dbCart['PTxy'])
PTxz = np.transpose(dbCart['PTxz'])
PTyy = np.transpose(dbCart['PTyy'])
PTyz = np.transpose(dbCart['PTyz'])
PTzz = np.transpose(dbCart['PTzz'])
PSxx = np.transpose(dbCart['PSxx'])
PSxy = np.transpose(dbCart['PSxy'])
PSxz = np.transpose(dbCart['PSxz'])
PSyy = np.transpose(dbCart['PSyy'])
PSyz = np.transpose(dbCart['PSyz'])
PSzz = np.transpose(dbCart['PSzz'])
uuu = np.transpose(dbCart['uuu'])
uvv = np.transpose(dbCart['uvv'])
uuw = np.transpose(dbCart['uuw'])
uuv = np.transpose(dbCart['uuv'])
uvw = np.transpose(dbCart['uvw'])
uww = np.transpose(dbCart['uww'])
vvv = np.transpose(dbCart['vvv'])
vvw = np.transpose(dbCart['vvw'])
vww = np.transpose(dbCart['vww'])
www = np.transpose(dbCart['www'])
skew_tensor = np.zeros((3, 3, 3))
# Rotation to cylindrical coord.
n2 = -1
n3 = 0
# Initialisation rotated quantities. The variables zz_ are zz after rotation
r1 = np.zeros((nTh, nR))
Ur = np.zeros((nTh, nR))
Ut = np.zeros((nTh, nR))
Uz = np.zeros((nTh, nR))
urur = np.zeros((nTh, nR))
urut = np.zeros((nTh, nR))
uruz = np.zeros((nTh, nR))
utut = np.zeros((nTh, nR))
uzuz = np.zeros((nTh, nR))
utuz = np.zeros((nTh, nR))
dUrdr = np.zeros((nTh, nR))
dUrdt = np.zeros((nTh, nR))
dUrdz = np.zeros((nTh, nR))
dUtdr = np.zeros((nTh, nR))
dUtdt = np.zeros((nTh, nR))
dUtdz = np.zeros((nTh, nR))
dUzdr = np.zeros((nTh, nR))
dUzdt = np.zeros((nTh, nR))
dUzdz = np.zeros((nTh, nR))
Prr = np.zeros((nTh, nR))
Ptt = np.zeros((nTh, nR))
Pzz_ = np.zeros((nTh, nR))
Prt = np.zeros((nTh, nR))
Prz = np.zeros((nTh, nR))
Ptz = np.zeros((nTh, nR))
Drr = np.zeros((nTh, nR))
Dtt = np.zeros((nTh, nR))
Dzz_ = np.zeros((nTh, nR))
Drt = np.zeros((nTh, nR))
Drz = np.zeros((nTh, nR))
Dtz = np.zeros((nTh, nR))
Crr = np.zeros((nTh, nR))
Ctt = np.zeros((nTh, nR))
Czz_ = np.zeros((nTh, nR))
Crt = np.zeros((nTh, nR))
Crz = np.zeros((nTh, nR))
Ctz = np.zeros((nTh, nR))
Trr = np.zeros((nTh, nR))
Ttt = np.zeros((nTh, nR))
Tzz_ = np.zeros((nTh, nR))
Trt = np.zeros((nTh, nR))
Trz = np.zeros((nTh, nR))
Ttz = np.zeros((nTh, nR))
VDrr = np.zeros((nTh, nR))
VDtt = np.zeros((nTh, nR))
VDzz_ = np.zeros((nTh, nR))
VDrt = np.zeros((nTh, nR))
VDrz = np.zeros((nTh, nR))
VDtz = np.zeros((nTh, nR))
PTrr = np.zeros((nTh, nR))
PTtt = np.zeros((nTh, nR))
PTzz_ = np.zeros((nTh, nR))
PTrt = np.zeros((nTh, nR))
PTrz = np.zeros((nTh, nR))
PTtz = np.zeros((nTh, nR))
PSrr = np.zeros((nTh, nR))
PStt = np.zeros((nTh, nR))
PSzz_ = np.zeros((nTh, nR))
PSrt = np.zeros((nTh, nR))
PSrz = np.zeros((nTh, nR))
PStz = np.zeros((nTh, nR))
ururur = np.zeros((nTh, nR))
ututut = np.zeros((nTh, nR))
uzuzuz = np.zeros((nTh, nR))
ururut = np.zeros((nTh, nR))
ururuz = np.zeros((nTh, nR))
urutut = np.zeros((nTh, nR))
ututuz = np.zeros((nTh, nR))
uruzuz = np.zeros((nTh, nR))
utuzuz = np.zeros((nTh, nR))
urutuz = np.zeros((nTh, nR))
for i in range(0, nTh):
n1 = n2 + 1
if (i == 0):
n2 = n1 + nR - 1
else:
n2 = n1 + nR - 1
r1[i, :] = np.sqrt(
np.power(x1[n1:n2 + 1], 2) + np.power(y1[n1:n2 + 1], 2))
# Rotation matrix
R = np.matrix([[math.cos(angle[i]),
math.sin(angle[i]), 0],
[-math.sin(angle[i]),
math.cos(angle[i]), 0], [0, 0, 1]])
for jj in range(0, nR):
# Mean velocities. Tensors of Rank 1.
U_tens = np.matrix([[U[jj, i]], [V[jj, i]], [W[jj, i]]])
prod = R * U_tens
Ur[i, jj] = prod[0]
Ut[i, jj] = prod[1]
Uz[i, jj] = prod[2]
# Reynolds stress tensor. Tensors of Rank 2.
S = np.matrix([[uu[jj, i], uv[jj, i], uw[jj, i]],
[uv[jj, i], vv[jj, i], vw[jj, i]],
[uw[jj, i], vw[jj, i], ww[jj, i]]])
prod = R * S * np.transpose(R)
urur[i, jj] = prod[0, 0]
urut[i, jj] = prod[0, 1]
uruz[i, jj] = prod[0, 2]
utut[i, jj] = prod[1, 1]
uzuz[i, jj] = prod[2, 2]
utuz[i, jj] = prod[1, 2]
# Velocity gradient tensor. Tensor of Rank 2.
S = np.matrix([[dUdx[jj, i], dUdy[jj, i], dUdz[jj, i]],
[dVdx[jj, i], dVdy[jj, i], dVdz[jj, i]],
[dWdx[jj, i], dWdy[jj, i], dWdz[jj, i]]])
prod = R * S * np.transpose(R)
dUrdr[i, jj] = prod[0, 0]
dUrdt[i, jj] = prod[0, 1]
dUrdz[i, jj] = prod[0, 2]
dUtdr[i, jj] = prod[1, 0]
dUtdt[i, jj] = prod[1, 1]
dUtdz[i, jj] = prod[1, 2]
dUzdr[i, jj] = prod[2, 0]
dUzdt[i, jj] = prod[2, 1]
dUzdz[i, jj] = prod[2, 2]
# Production tensor. Tensor of Rank 2.
S = np.matrix([[Pxx[jj, i], Pxy[jj, i], Pxz[jj, i]],
[Pxy[jj, i], Pyy[jj, i], Pyz[jj, i]],
[Pxz[jj, i], Pyz[jj, i], Pzz[jj, i]]])
prod = R * S * np.transpose(R)
Prr[i, jj] = prod[0, 0]
Ptt[i, jj] = prod[1, 1]
Pzz_[i, jj] = prod[2, 2]
Prt[i, jj] = prod[0, 1]
Prz[i, jj] = prod[0, 2]
Ptz[i, jj] = prod[1, 2]
# Dissipation tensor. Tensor of Rank 2.
S = np.matrix([[Dxx[jj, i], Dxy[jj, i], Dxz[jj, i]],
[Dxy[jj, i], Dyy[jj, i], Dyz[jj, i]],
[Dxz[jj, i], Dyz[jj, i], Dzz[jj, i]]])
prod = R * S * np.transpose(R)
Drr[i, jj] = prod[0, 0]
Dtt[i, jj] = prod[1, 1]
Dzz_[i, jj] = prod[2, 2]
Drt[i, jj] = prod[0, 1]
Drz[i, jj] = prod[0, 2]
Dtz[i, jj] = prod[1, 2]
# Mean convection tensor. Tensor of Rank 2.
S = np.matrix([[Cxx[jj, i], Cxy[jj, i], Cxz[jj, i]],
[Cxy[jj, i], Cyy[jj, i], Cyz[jj, i]],
[Cxz[jj, i], Cyz[jj, i], Czz[jj, i]]])
prod = R * S * np.transpose(R)
Crr[i, jj] = prod[0, 0]
Ctt[i, jj] = prod[1, 1]
Czz_[i, jj] = prod[2, 2]
Crt[i, jj] = prod[0, 1]
Crz[i, jj] = prod[0, 2]
Ctz[i, jj] = prod[1, 2]
# Turbulent transport tensor. Tensor of Rank 2.
S = np.matrix([[Txx[jj, i], Txy[jj, i], Txz[jj, i]],
[Txy[jj, i], Tyy[jj, i], Tyz[jj, i]],
[Txz[jj, i], Tyz[jj, i], Tzz[jj, i]]])
prod = R * S * np.transpose(R)
Trr[i, jj] = prod[0, 0]
Ttt[i, jj] = prod[1, 1]
Tzz_[i, jj] = prod[2, 2]
Trt[i, jj] = prod[0, 1]
Trz[i, jj] = prod[0, 2]
Ttz[i, jj] = prod[1, 2]
# Viscous diffusion tensor. Tensor of Rank 2.
S = np.matrix([[VDxx[jj, i], VDxy[jj, i], VDxz[jj, i]],
[VDxy[jj, i], VDyy[jj, i], VDyz[jj, i]],
[VDxz[jj, i], VDyz[jj, i], VDzz[jj, i]]])
prod = R * S * np.transpose(R)
VDrr[i, jj] = prod[0, 0]
VDtt[i, jj] = prod[1, 1]
VDzz_[i, jj] = prod[2, 2]
VDrt[i, jj] = prod[0, 1]
VDrz[i, jj] = prod[0, 2]
VDtz[i, jj] = prod[1, 2]
# Pressure transport tensor. Tensor of Rank 2.
S = np.matrix([[PTxx[jj, i], PTxy[jj, i], PTxz[jj, i]],
[PTxy[jj, i], PTyy[jj, i], PTyz[jj, i]],
[PTxz[jj, i], PTyz[jj, i], PTzz[jj, i]]])
prod = R * S * np.transpose(R)
PTrr[i, jj] = prod[0, 0]
PTtt[i, jj] = prod[1, 1]
PTzz_[i, jj] = prod[2, 2]
PTrt[i, jj] = prod[0, 1]
PTrz[i, jj] = prod[0, 2]
PTtz[i, jj] = prod[1, 2]
# Pressure strain tensor. Tensor of Rank 2.
S = np.matrix([[PSxx[jj, i], PSxy[jj, i], PSxz[jj, i]],
[PSxy[jj, i], PSyy[jj, i], PSyz[jj, i]],
[PSxz[jj, i], PSyz[jj, i], PSzz[jj, i]]])
prod = R * S * np.transpose(R)
PSrr[i, jj] = prod[0, 0]
PStt[i, jj] = prod[1, 1]
PSzz_[i, jj] = prod[2, 2]
PSrt[i, jj] = prod[0, 1]
PSrz[i, jj] = prod[0, 2]
PStz[i, jj] = prod[1, 2]
# Skewness tensor. Tensor of Rank 3.
skew_tensor[:, :,
0] = np.matrix([[uuu[jj, i], uvv[jj, i], uuw[jj, i]],
[uuv[jj, i], uvv[jj, i], uvw[jj, i]],
[uuw[jj, i], uvw[jj, i], uww[jj, i]]])
skew_tensor[:, :,
1] = np.matrix([[uuv[jj, i], uvv[jj, i], uvw[jj, i]],
[uvv[jj, i], vvv[jj, i], vvw[jj, i]],
[uvw[jj, i], vvw[jj, i], vww[jj, i]]])
skew_tensor[:, :,
2] = np.matrix([[uuw[jj, i], uvw[jj, i], uww[jj, i]],
[uvw[jj, i], vvw[jj, i], vww[jj, i]],
[uww[jj, i], vww[jj, i], www[jj, i]]])
aabc = np.zeros((3, 3, 3))
adef = skew_tensor[:, :, :]
for aa in range(0, 3):
for bb in range(0, 3):
for cc in range(0, 3):
for dd in range(0, 3):
for ee in range(0, 3):
for ff in range(0, 3):
aabc[aa, bb, cc] = aabc[
aa, bb,
cc] + R[aa, dd] * R[bb, ee] * R[
cc, ff] * adef[dd, ee, ff]
ururur[i, jj] = aabc[0, 0, 0]
ututut[i, jj] = aabc[1, 1, 1]
uzuzuz[i, jj] = aabc[2, 2, 2]
ururut[i, jj] = aabc[0, 1, 0]
ururuz[i, jj] = aabc[0, 2, 0]
urutut[i, jj] = aabc[1, 1, 0]
ututuz[i, jj] = aabc[1, 2, 1]
uruzuz[i, jj] = aabc[2, 2, 0]
utuzuz[i, jj] = aabc[2, 2, 1]
urutuz[i, jj] = aabc[1, 2, 0]
# Average over the azimuthal direction
# Initialisation averaged quantities.
Ur_m = np.zeros(nR)
Ut_m = np.zeros(nR)
Uz_m = np.zeros(nR)
urur_m = np.zeros(nR)
urut_m = np.zeros(nR)
uruz_m = np.zeros(nR)
utut_m = np.zeros(nR)
uzuz_m = np.zeros(nR)
utuz_m = np.zeros(nR)
dUrdr_m = np.zeros(nR)
dUrdt_m = np.zeros(nR)
dUrdz_m = np.zeros(nR)
dUtdr_m = np.zeros(nR)
dUtdt_m = np.zeros(nR)
dUtdz_m = np.zeros(nR)
dUzdr_m = np.zeros(nR)
dUzdt_m = np.zeros(nR)
dUzdz_m = np.zeros(nR)
Prr_m = np.zeros(nR)
Ptt_m = np.zeros(nR)
Pzz_m = np.zeros(nR)
Prt_m = np.zeros(nR)
Prz_m = np.zeros(nR)
Ptz_m = np.zeros(nR)
Drr_m = np.zeros(nR)
Dtt_m = np.zeros(nR)
Dzz_m = np.zeros(nR)
Drt_m = np.zeros(nR)
Drz_m = np.zeros(nR)
Dtz_m = np.zeros(nR)
Crr_m = np.zeros(nR)
Ctt_m = np.zeros(nR)
Czz_m = np.zeros(nR)
Crt_m = np.zeros(nR)
Crz_m = np.zeros(nR)
Ctz_m = np.zeros(nR)
Trr_m = np.zeros(nR)
Ttt_m = np.zeros(nR)
Tzz_m = np.zeros(nR)
Trt_m = np.zeros(nR)
Trz_m = np.zeros(nR)
Ttz_m = np.zeros(nR)
VDrr_m = np.zeros(nR)
VDtt_m = np.zeros(nR)
VDzz_m = np.zeros(nR)
VDrt_m = np.zeros(nR)
VDrz_m = np.zeros(nR)
VDtz_m = np.zeros(nR)
PTrr_m = np.zeros(nR)
PTtt_m = np.zeros(nR)
PTzz_m = np.zeros(nR)
PTrt_m = np.zeros(nR)
PTrz_m = np.zeros(nR)
PTtz_m = np.zeros(nR)
PSrr_m = np.zeros(nR)
PStt_m = np.zeros(nR)
PSzz_m = np.zeros(nR)
PSrt_m = np.zeros(nR)
PSrz_m = np.zeros(nR)
PStz_m = np.zeros(nR)
ururur_m = np.zeros(nR)
ututut_m = np.zeros(nR)
uzuzuz_m = np.zeros(nR)
ururut_m = np.zeros(nR)
ururuz_m = np.zeros(nR)
urutut_m = np.zeros(nR)
ututuz_m = np.zeros(nR)
uruzuz_m = np.zeros(nR)
utuzuz_m = np.zeros(nR)
urutuz_m = np.zeros(nR)
for j in range(0, nR):
# Mean velocities. Tensors of Rank 1.
Ur_m[j] = np.mean(Ur[:, j])
Ut_m[j] = np.mean(Ut[:, j])
Uz_m[j] = np.mean(Uz[:, j])
# Reynolds stress tensor. Tensors of Rank 2.
urur_m[j] = np.mean(urur[:, j])
urut_m[j] = np.mean(urut[:, j])
uruz_m[j] = np.mean(uruz[:, j])
utut_m[j] = np.mean(utut[:, j])
uzuz_m[j] = np.mean(uzuz[:, j])
utuz_m[j] = np.mean(utuz[:, j])
# Velocity gradient tensor. Tensor of Rank 2.
dUrdr_m[j] = np.mean(dUrdr[:, j])
dUrdt_m[j] = np.mean(dUrdt[:, j])
dUrdz_m[j] = np.mean(dUrdz[:, j])
dUtdr_m[j] = np.mean(dUtdr[:, j])
dUtdt_m[j] = np.mean(dUtdt[:, j])
dUtdz_m[j] = np.mean(dUtdz[:, j])
dUzdr_m[j] = np.mean(dUzdr[:, j])
dUzdt_m[j] = np.mean(dUzdt[:, j])
dUzdz_m[j] = np.mean(dUzdz[:, j])
# Production tensor. Tensor of Rank 2.
Prr_m[j] = np.mean(Prr[:, j])
Ptt_m[j] = np.mean(Ptt[:, j])
Pzz_m[j] = np.mean(Pzz_[:, j])
Prt_m[j] = np.mean(Prt[:, j])
Prz_m[j] = np.mean(Prz[:, j])
Ptz_m[j] = np.mean(Ptz[:, j])
# Dissipation tensor. Tensor of Rank 2.
Drr_m[j] = np.mean(Drr[:, j])
Dtt_m[j] = np.mean(Dtt[:, j])
Dzz_m[j] = np.mean(Dzz_[:, j])
Drt_m[j] = np.mean(Drt[:, j])
Drz_m[j] = np.mean(Drz[:, j])
Dtz_m[j] = np.mean(Dtz[:, j])
# Mean convection tensor. Tensor of Rank 2.
Crr_m[j] = np.mean(Crr[:, j])
Ctt_m[j] = np.mean(Ctt[:, j])
Czz_m[j] = np.mean(Czz_[:, j])
Crt_m[j] = np.mean(Crt[:, j])
Crz_m[j] = np.mean(Crz[:, j])
Ctz_m[j] = np.mean(Ctz[:, j])
# Turbulent transport tensor. Tensor of Rank 2.
Trr_m[j] = np.mean(Trr[:, j])
Ttt_m[j] = np.mean(Ttt[:, j])
Tzz_m[j] = np.mean(Tzz_[:, j])
Trt_m[j] = np.mean(Trt[:, j])
Trz_m[j] = np.mean(Trz[:, j])
Ttz_m[j] = np.mean(Ttz[:, j])
# Viscous diffusion tensor. Tensor of Rank 2.
VDrr_m[j] = np.mean(VDrr[:, j])
VDtt_m[j] = np.mean(VDtt[:, j])
VDzz_m[j] = np.mean(VDzz_[:, j])
VDrt_m[j] = np.mean(VDrt[:, j])
VDrz_m[j] = np.mean(VDrz[:, j])
VDtz_m[j] = np.mean(VDtz[:, j])
# Pressure transport tensor. Tensor of Rank 2.
PTrr_m[j] = np.mean(PTrr[:, j])
PTtt_m[j] = np.mean(PTtt[:, j])
PTzz_m[j] = np.mean(PTzz_[:, j])
PTrt_m[j] = np.mean(PTrt[:, j])
PTrz_m[j] = np.mean(PTrz[:, j])
PTtz_m[j] = np.mean(PTtz[:, j])
# Pressure strain tensor. Tensor of Rank 2.
PSrr_m[j] = np.mean(PSrr[:, j])
PStt_m[j] = np.mean(PStt[:, j])
PSzz_m[j] = np.mean(PSzz_[:, j])
PSrt_m[j] = np.mean(PSrt[:, j])
PSrz_m[j] = np.mean(PSrz[:, j])
PStz_m[j] = np.mean(PStz[:, j])
# Skewness tensor. Tensor of Rank 3.
ururur_m[j] = np.mean(ururur[:, j])
ututut_m[j] = np.mean(ututut[:, j])
uzuzuz_m[j] = np.mean(uzuzuz[:, j])
ururut_m[j] = np.mean(ururut[:, j])
ururuz_m[j] = np.mean(ururuz[:, j])
urutut_m[j] = np.mean(urutut[:, j])
ututuz_m[j] = np.mean(ututuz[:, j])
uruzuz_m[j] = np.mean(uruzuz[:, j])
utuzuz_m[j] = np.mean(utuzuz[:, j])
# Compute TKE budget terms
P_k = 0.5 * (Prr_m + Ptt_m + Pzz_m) # production
T_k = 0.5 * (Trr_m + Ttt_m + Tzz_m) # turbulent transport
PS_k = 0.5 * (PSrr_m + PStt_m + PSzz_m) # pressure-strain
PT_k = 0.5 * (PTrr_m + PTtt_m + PTzz_m) # pressure-transport
Pi_k = (PT_k - PS_k)
VD_k = 0.5 * (VDrr_m + VDtt_m + VDzz_m) # viscous diffusion
D_k = 0.5 * (Drr_m + Dtt_m + Dzz_m) # dissipation
C_k = 0.5 * (Crr_m + Ctt_m + Czz_m) # mean convection
# Write postprocessed results in a file
# make an array of radii
r_ = np.zeros(nR)
for i in range(0, nR):
r_[i] = np.sqrt(np.power(X[i, 0], 2) + np.power(Y[i, 0], 2))
rMax = np.max(r_)
r_ = rMax - r_ #Changing the discrete radius from wall toward center
# Compute uTau
uTau = np.sqrt(-dUzdr_m[-1] * nu)
# method 2
tauW = (Uz_m[-2] - Uz_m[-1]) / (r_[-2] - r_[-1])
uTau2 = np.sqrt(nu * tauW)
ReTau = uTau * rMax / nu
ReTau2 = uTau2 * rMax / nu
print('\n')
print(
'To double check results u_tau and Re_tau are computed with two different methods. '
)
print(
'Method 1: as square root of the product between the averaged field dUzdr at the wall and nu. Retau is obtained from the uTau*rMax/nu.'
)
print(
'Method 2: as square root of nu*tauW, where tauW is computed as finite difference of the averaged field Uz at the wall. Retau is obtained from the uTau*rMax/nu. \n'
)
print('uTau (method1)= ', uTau)
print('uTau (method2)= ', uTau2)
print('Re_tau (method1)= ', ReTau)
print('Re_tau (method2)= ', ReTau2)
# Saving Dict. of rotated and averaged quantities(not scaled)
dbRotAvg = {'Ur':Ur_m, 'Ut':Ut_m, 'Uz':Uz_m, \
'urur':urur_m, 'urut':urut_m, 'uruz':uruz_m, 'utut':utut_m, 'uzuz':uzuz_m, 'utuz':utuz_m, \
'dUrdr':dUrdr_m, 'dUrdt':dUrdt_m, 'dUrdz':dUrdz_m, 'dUtdr':dUtdr_m, 'dUtdt':dUtdt_m, 'dUtdz':dUtdz_m, 'dUzdr':dUzdr_m, 'dUzdt':dUzdt_m, 'dUzdz_m':dUzdz, \
'Prr':Prr_m, 'Ptt':Ptt_m, 'Pzz':Pzz_m, 'Prt':Prt_m, 'Prz':Prz_m, 'Ptz':Ptz_m, \
'Drr':Drr_m, 'Dtt':Dtt_m, 'Dzz':Dzz_m, 'Drt':Drt_m, 'Drz':Drz_m, 'Dtz':Dtz_m, \
'Crr':Crr_m, 'Ctt':Ctt_m, 'Czz':Czz_m, 'Crt':Crt_m, 'Crz':Crz_m, 'Ctz':Ctz_m, \
'Trr':Trr_m, 'Ttt':Ttt_m, 'Tzz':Tzz_m, 'Trt':Trt_m, 'Trz':Trz_m, 'Ttz':Ttz_m, \
'VDrr':VDrr_m, 'VDtt':VDtt_m, 'VDzz':VDzz_m, 'VDrt':VDrt_m, 'VDrz':VDrz_m, 'VDtz':VDtz_m, \
'PTrr':PTrr_m, 'PTtt':PTtt_m, 'PTzz':PTzz_m, 'PTrt':PTrt_m, 'PTrz':PTrz_m, 'PTtz':PTtz_m, \
'PSrr':PSrr_m, 'PStt':PStt_m, 'PSzz':PSzz_m, 'PSrt':PSrt_m, 'PSrz':PSrz_m, 'PStz':PStz_m, \
'ururur':ururur_m, 'ututut':ututut_m, 'uzuzuz':uzuzuz_m, 'ururut':ururut_m, 'ururuz':ururuz_m, 'urutut':urutut_m, 'ututuz':ututuz_m, 'uruzuz':uruzuz_m, 'utuzuz':utuzuz_m, \
'P_k':P_k, 'T_k':T_k, 'PS_k':PS_k, 'PT_k':PT_k, 'Pi_k':Pi_k, 'VD_k':VD_k, 'D_k':D_k, 'C_k':C_k, \
'r':r_, 'nu':nu, 'u_tau': uTau, 'Re_tau':ReTau \
}
# Saving txt file of rotated and averaged quantities
#velocity profiles + derivatives
fileName = 'OUTPUT/turbPipe_meanVelDer.txt'
F = open(fileName, 'w')
F.write("# Postprocessed results of turbulent pipe flow \n")
F.write("# Mean velocity and their derivatives \n")
F.write(
"# ------------------------------------------------------------------\n"
)
F.write("# uTau = %g \n" % uTau)
F.write("# nu = %g \n" % nu)
F.write(
"# ------------------------------------------------------------------\n"
)
F.write(
"# r\t Ur\t Ut\t Uz\t dUrdr\t dUrdt\t dUrdz\t dUtdr\t dUtdt\t dUtdz\t dUzdr\t dUzdt\t dUzdz \n"
)
F.write(
"# ------------------------------------------------------------------\n"
)
for i in range(0, nR):
F.write("%g\t%g\t%g\t%g\t%g\t%g\t%g\t%g\t%g\t%g\t%g\t%g\t%g\t \n" % \
(r_[i], Ur_m[i], Ut_m[i], Uz_m[i], dUrdr_m[i], dUrdt_m[i], dUrdz_m[i], dUtdr_m[i], dUtdt_m[i], dUtdz_m[i], dUzdr_m[i], dUzdt_m[i], dUzdz_m[i]))
F.close()
#Reynolds stress components
fileName = 'OUTPUT/turbPipe_ReStressTens.txt'
F = open(fileName, 'w')
F.write("# Postprocessed results of turbulent pipe flow \n")
F.write("# Reynolds stress components \n")
F.write(
"# ------------------------------------------------------------------\n"
)
F.write("# uTau = %g \n" % uTau)
F.write("# nu = %g \n" % nu)
F.write(
"# ------------------------------------------------------------------\n"
)
F.write("# r\t urp\t urut\t uruz\t utp\t uzp\t utuz \n")
F.write(
"# ------------------------------------------------------------------\n"
)
for i in range(0, nR):
F.write("%g\t%g\t%g\t%g\t %g\t%g\t%g\t \n" % \
(r_[i], np.sqrt(urur_m[i]-Ur_m[i]*Ur_m[i]), urut_m[i]-Ur_m[i]*Ut_m[i], uruz_m[i]-Ur_m[i]*Uz_m[i], np.sqrt(utut_m[i]-Ut_m[i]*Ut_m[i]), \
np.sqrt(abs(uzuz_m[i]-Uz_m[i]*Uz_m[i])), utuz_m[i]-Ut_m[i]*Uz_m[i]) )
F.close()
#TKE budget terms
fileName = 'OUTPUT/turbPipe_kBudgets.txt'
F = open(fileName, 'w')
F.write("# Postprocessed results of turbulent pipe flow \n")
F.write("# TKE budget terms: nondim by multiplying by nu/uTau^4 \n")
F.write(
"# ------------------------------------------------------------------\n"
)
F.write("# uTau = %g \n" % uTau)
F.write("# nu = %g \n" % nu)
F.write(
"# ------------------------------------------------------------------\n"
)
F.write(
"# r+\t P_k+ \t T_k+ \t PS_k+ \t PT_k+ \t VD_k+ \t D_k+ \t C_k+ \n")
F.write(
"# ------------------------------------------------------------------\n"
)
fac = nu / np.power(uTau, 4)
for i in range(0, nR):
F.write("%g\t%g\t%g\t%g\t %g\t%g\t%g\t%g\t \n" % \
(r_[i]*ReTau, P_k[i]*fac, T_k[i]*fac, PS_k[i]*fac, PT_k[i]*fac, VD_k[i]*fac, D_k[i]*fac, C_k[i]*fac) )
F.close()
#budget terms of <urur>
fileName = 'OUTPUT/turbPipe_rrBudgets.txt'
F = open(fileName, 'w')
F.write("# Postprocessed results of turbulent pipe flow \n")
F.write("# budget terms of <urur>: nondim by multiplying by nu/uTau^4 \n")
F.write(
"# ------------------------------------------------------------------\n"
)
F.write("# uTau = %g \n" % uTau)
F.write("# nu = %g \n" % nu)
F.write(
"# ------------------------------------------------------------------\n"
)
F.write(
"# r+\t P_rr+ \t T_rr+ \t PS_rr+ \t PT_rr+ \t VD_rr+ \t D_rr+ \t C_rr+ \n"
)
F.write(
"# ------------------------------------------------------------------\n"
)
for i in range(0, nR):
F.write("%g\t%g\t%g\t%g\t %g\t%g\t%g\t%g \n" % \
(r_[i]*ReTau, Prr_m[i]*fac, Trr_m[i]*fac, PSrr_m[i]*fac, PTrr_m[i]*fac, VDrr_m[i]*fac, Drr_m[i]*fac, Crr_m[i]*fac) )
F.close()
#budget terms of <utut>
fileName = 'OUTPUT/turbPipe_ttBudgets.txt'
F = open(fileName, 'w')
F.write("# Postprocessed results of turbulent pipe flow \n")
F.write("# budget terms of <utut>: nondim by multiplying by nu/uTau^4 \n")
F.write(
"# ------------------------------------------------------------------\n"
)
F.write("# uTau = %g \n" % uTau)
F.write("# nu = %g \n" % nu)
F.write(
"# ------------------------------------------------------------------\n"
)
F.write(
"# r+\t P_tt+ \t T_tt+ \t PS_tt+ \t PT_tt+ \t VD_tt+ \t D_tt+ \t C_tt+ \n"
)
F.write(
"# ------------------------------------------------------------------\n"
)
for i in range(0, nR):
F.write("%g\t%g\t%g\t%g\t %g\t%g\t%g\t%g \n" % \
(r_[i]*ReTau, Ptt_m[i]*fac, Ttt_m[i]*fac, PStt_m[i]*fac, PTtt_m[i]*fac, VDtt_m[i]*fac, Dtt_m[i]*fac, Ctt_m[i]*fac) )
F.close()
#budget terms of <uzuz>
fileName = 'OUTPUT/turbPipe_zzBudgets.txt'
F = open(fileName, 'w')
F.write("# Postprocessed results of turbulent pipe flow \n")
F.write("# budget terms of <uzuz>: nondim by multiplying by nu/uTau^4 \n")
F.write(
"# ------------------------------------------------------------------\n"
)
F.write("# uTau = %g \n" % uTau)
F.write("# nu = %g \n" % nu)
F.write(
"# ------------------------------------------------------------------\n"
)
F.write(
"# r+\t P_zz+ \t T_zz+ \t PS_zz+ \t PT_zz+ \t VD_zz+ \t D_zz+ \t C_zz+ \n"
)
F.write(
"# ------------------------------------------------------------------\n"
)
for i in range(0, nR):
F.write("%g\t%g\t%g\t%g\t %g\t%g\t%g\t%g \n" % \
(r_[i]*ReTau, Pzz_m[i]*fac, Tzz_m[i]*fac, PSzz_m[i]*fac, PTzz_m[i]*fac, VDzz_m[i]*fac, Dzz_m[i]*fac, Czz_m[i]*fac) )
F.close()
#budget terms of <uruz>
fileName = 'OUTPUT/turbPipe_rzBudgets.txt'
F = open(fileName, 'w')
F.write("# Postprocessed results of turbulent pipe flow \n")
F.write("# budget terms of <uruz>: nondim by multiplying by nu/uTau^4 \n")
F.write(
"# ------------------------------------------------------------------\n"
)
F.write("# uTau = %g \n" % uTau)
F.write("# nu = %g \n" % nu)
F.write(
"# ------------------------------------------------------------------\n"
)
F.write(
"# r+\t P_rz+ \t T_rz+ \t PS_rz+ \t PT_rz+ \t VD_rz+ \t D_rz+ \t C_rz+ \n"
)
F.write(
"# ------------------------------------------------------------------\n"
)
for i in range(0, nR):
F.write("%g\t%g\t%g\t%g\t %g\t%g\t%g\t%g \n" % \
(r_[i]*ReTau, Prz_m[i]*fac, Trz_m[i]*fac, PSrz_m[i]*fac, PTrz_m[i]*fac, VDrz_m[i]*fac, Drz_m[i]*fac, Crz_m[i]*fac) )
F.close()
return dbRotAvg
theta[j, i] = th[j]
return xx, yy, theta
if __name__ == "__main__":
# initialise variables
fname = 'int_pos'
wdsize = 8
# little endian
emode = '<'
# big endian
#emode = '<'
# Read interpolating mesh info
Nx, Ny, ReTau, Rmax, drp1, compressedMesh = reader.read_input(
'input.txt', 'pipeInterpMesh')
nR = Ny
nTh = Nx
#
# generate polar mesh over a circular disk
xx, yy, theta = disk(Rmax, compressedMesh, ReTau, drp1, nR, nTh)
# allocate space
ldim = 2 #2D grid
npoints = xx.size
data = pset(ldim, npoints)
print('Allocated {0} points'.format(npoints))
# initialise point positions
def __init__(self, configName):
'''
Sets up the initial spatial grid, time grid, accumulation rate, age, density, mass, stress, and temperature of the model run
:param configName: name of json config file containing model configurations
'''
### load in json config file and parses the user inputs to a dictionary
self.spin=False
with open(configName, "r") as f:
jsonString = f.read()
self.c = json.loads(jsonString)
print('Spin run started')
print("physics are", self.c['physRho'])
try:
print('Merging is:',self.c["merging"])
except Exception:
pass
### create directory to store results. Deletes if it exists already.
if os.path.exists(self.c['resultsFolder']):
rmtree(self.c['resultsFolder'])
os.makedirs(self.c['resultsFolder'])
############################
##### load input files #####
############################
### temperature
input_temp, input_year_temp = read_input(os.path.join(self.c['InputFileFolder'],self.c['InputFileNameTemp']))
if input_temp[0] < 0.0:
input_temp = input_temp + K_TO_C
try:
if self.c['spinup_climate_type']=='initial':
self.temp0 = input_temp[0]
elif self.c['spinup_climate_type']=='mean':
self.temp0 = np.mean(input_temp)
except:
print("You should add key 'spinup_climate_type' to the config .json file")
print("spinup is based on mean climate of input")
self.temp0 = np.mean(input_temp)
# self.temp0 = 270.0
# self.temp0 = mean(input_temp[0:12]) #Make sure that this is what we want!
### accumulation rate
input_bdot, input_year_bdot = read_input(os.path.join(self.c['InputFileFolder'],self.c['InputFileNamebdot']))
try:
if self.c['spinup_climate_type']=='initial':
self.bdot0 = input_bdot[0]
elif self.c['spinup_climate_type']=='mean':
self.bdot0 = np.mean(input_bdot)
except:
self.bdot0 = np.mean(input_bdot)
if self.c['initprofile']:
try:
if self.c['singleleap'] or self.c['singlenormal']: #VV If we use the initprofile but the input forcing data does not cover an entire year
self.temp0 = self.c['deepT'] #VV use deep T as mean temperature for spin up calculations (compaction,grain growth)
self.bdot0 = self.c['bdot_long']*1e-3/0.917 #VV use long term accumulation as mean accumulation for spin up calculations (compaction,grain growth) + conversion from mmWE/yr to mIE/yr
except Exception:
print("you are using an initial profile for spinup,")
print("but you do not have 'singleleap' or 'singlenormal' in the .json")
print('bdot0', self.bdot0)
### could include others, e.g. surface density
############################
############################
### set up model grid ######
############################
self.gridLen = int((self.c['H'] - self.c['HbaseSpin']) / (self.bdot0 / self.c['stpsPerYearSpin'])) # number of grid points
gridHeight = np.linspace(self.c['H'], self.c['HbaseSpin'], self.gridLen)
self.z = self.c['H'] - gridHeight
self.dz = np.diff(self.z)
self.dz = np.append(self.dz, self.dz[-1])
self.dx = np.ones(self.gridLen)
print('Grid length is', self.gridLen)
############################
############################
### if the regridding module is being used, do the
### initial regridding
############################
try:
self.doublegrid = self.c['doublegrid']
if self.c['doublegrid']:
self.nodestocombine, self.z, self.dz, self.gridLen, self.dx, self.gridtrack = init_regrid(self)
except:
self.doublegrid = False
print('you should add "doublegrid" to the json')
############################
### get an initial depth/density profile based on H&L analytic solution
############################
# if self.c['initprofile'] == False: #VV
THL = self.temp0
AHL = self.bdot0
self.age, self.rho = hl_analytic(self.c['rhos0'], self.z, THL, AHL) # self.age is in age in seconds
# elif self.c['initprofile'] == True: # VV we have an initial temperature and density profile
# Just avoid the model to blow up because it has no age and rho variables, real values are given below
# self.age = S_PER_YEAR*100*np.ones_like(self.dz) #VV this does not matter as it is rectified when we initialise profie below
# self.rho = 500*np.ones_like(self.dz)#VV this does not matter as it is rectified when we initialise profile
############################
############################
### set up time stepping
if self.c['AutoSpinUpTime']: # automatic, based on time that it will take for a parcel to get to 850 kg m^-3
try:
zz = np.min(self.z[self.rho > 850.0])
self.years = int(zz / self.bdot0)
except ValueError:
print("auto spin up error; using spin up time from json")
self.years = self.c['yearSpin'] # number of years to spin up for
else: # based on time taken to spin up in the config file.
self.years = self.c['yearSpin'] # number of years to spin up for
self.dt = S_PER_YEAR / self.c['stpsPerYearSpin']
self.stp = int(self.years*S_PER_YEAR/self.dt)
self.t = 1.0 / self.c['stpsPerYearSpin'] # years per time step
############################
############################
### Initial and boundary conditions
############################
### Surface temperature for each time step
self.Ts = self.temp0 * np.ones(self.stp)
if self.c['SeasonalTcycle']: #impose seasonal temperature cycle of amplitude 'TAmp'
# self.Ts = self.Ts + self.c['TAmp'] * (np.cos(2 * np.pi * np.linspace(0, self.years, self.stp )) + 0.3 * np.cos(4 * np.pi * np.linspace(0, self.years, self.stp ))) #Orsi, coreless winter
self.Ts = self.Ts - self.c['TAmp'] * (np.cos(2 * np.pi * np.linspace(0, self.years, self.stp))) # This is basic for Greenland (for Antarctica the it should be a plus instead of minus)
### initial temperature profile
# init_Tz = input_temp[0] * np.ones(self.gridLen)
init_Tz = np.mean(self.Ts) * np.ones(self.gridLen)
### Accumulation rate for each time step
self.bdotSec0 = self.bdot0 / S_PER_YEAR / self.c['stpsPerYearSpin'] # accumulation (m I.E. per second)
self.bdotSec = self.bdotSec0 * np.ones(self.stp) # vector of accumulation at each time step
### Surface isotope values for each time step
if self.c['isoDiff']:
try:
input_iso, input_year_iso = read_input(self.c['InputFileNameIso'])
del_s0 = input_iso[0]
except:
print('No external file for surface isotope values found, but you specified in the config file that isotope diffusion is on. The model will generate its own synthetic isotope data for you.')
del_s0 = -50.0
self.del_s = del_s0 * np.ones(self.stp)
init_del_z = del_s0 * np.ones(self.gridLen)
self.del_z = init_del_z
else:
self.del_s = None
init_del_z = None
### Surface Density
self.rhos0 = self.c['rhos0'] * np.ones(self.stp)
# could configure this so that user specifies vector of surface elevation
# could add noise too
### initial mass, stress, and mean accumulation rate
self.mass = self.rho * self.dz
self.sigma = self.mass * self.dx * GRAVITY
self.sigma = self.sigma.cumsum(axis = 0)
self.mass_sum = self.mass.cumsum(axis = 0)
#VVself.bdot_mean = (np.concatenate(([self.mass_sum[0] / (RHO_I * S_PER_YEAR)], self.mass_sum[1:] / (self.age[1:] * RHO_I / self.t)))) * self.c['stpsPerYear'] * S_PER_YEAR
### Mean temperatures and accumulation rates #VV ###
### MS: commented out for now 10/4/18
# if self.c['initprofile']:
# self.T_av = self.c['Ts_long'] * np.ones(self.stp) # If we use initial profile, Ts_long is best guess for Tav
# self.bdot_av = self.c['bdot_long']*1e-3/0.917 * np.ones(self.stp) # If we use initial profile, bdotlong is best guess for bdot_av + conversion from mmWE/yr to mIE/yr
# self.bdot_mean = np.ones_like(self.dz)*self.c['bdot_long']*1e-3/0.917 # Also best guess for bdot_mean
# else:
self.T_av = self.temp0 * np.ones(self.stp) #VV This is to be used instead of T10m
self.bdot_av = self.bdot0* np.ones(self.stp) #VV
self.bdot_mean = (np.concatenate(([self.mass_sum[0] / (RHO_I * S_PER_YEAR)], self.mass_sum[1:] / (self.age[1:] * RHO_I / self.t)))) * self.c['stpsPerYear'] * S_PER_YEAR #VV
### longitudinal strain rate
if self.c['strain']:
self.du_dx = np.zeros(self.gridLen)
self.du_dx[1:] = self.c['du_dx']/(S_PER_YEAR)
### initial temperature grid
self.Tz = init_Tz
self.T_mean = np.mean(self.Tz[self.z<50])
self.T10m = self.T_mean
### initial grain growth (if specified in config file)
if self.c['physGrain']:
if self.c['calcGrainSize']:
r02 = surfacegrain(self,0) #VV
self.r2 = r02 * np.ones(self.gridLen)
else:
self.r2 = np.linspace(self.c['r2s0'], (6 * self.c['r2s0']), self.gridLen)
else:
self.r2 = None
### "temperature history" if using Morris physics
if self.c['physRho']=='Morris2014':
# initial temperature history function (units seconds)
self.Hx = np.exp(-110.0e3/(R*init_Tz))*(self.age+self.dt)
self.THist = True
else:
self.THist = False
self.LWC = np.zeros_like(self.z)
self.MELT = False
def __init__(self, configName):
'''
Sets up the initial spatial grid, time grid, accumulation rate, age, density, mass, stress, temperature, and diffusivity of the model run
:param configName: name of json config file containing model configurations
'''
# load in json config file and parses the user inputs to a dictionary
with open(configName, "r") as f:
jsonString = f.read()
self.c = json.loads(jsonString)
print("Main run starting")
print("physics are", self.c['physRho'])
### read in initial depth, age, density, temperature from spin-up results
initDepth = read_init(self.c['resultsFolder'], self.c['spinFileName'],
'depthSpin')
initAge = read_init(self.c['resultsFolder'], self.c['spinFileName'],
'ageSpin')
initDensity = read_init(self.c['resultsFolder'],
self.c['spinFileName'], 'densitySpin')
init_drho_dt = read_init(self.c['resultsFolder'],
self.c['spinFileName'], 'drho_dtSpin')
initTemp = read_init(self.c['resultsFolder'], self.c['spinFileName'],
'tempSpin')
### read initial diffusion lengths
init_iso_sigmaD = read_init(self.c['resultsFolder'],
self.c['spinFileName'], 'iso_sigmaD')
init_iso_sigma18 = read_init(self.c['resultsFolder'],
self.c['spinFileName'], 'iso_sigma18')
init_iso_sigma17 = read_init(self.c['resultsFolder'],
self.c['spinFileName'], 'iso_sigma17')
init_iso_dsigma2_dt_D = read_init(self.c['resultsFolder'],
self.c['spinFileName'],
'iso_dsigma2_dt_D')
init_iso_dsigma2_dt_18 = read_init(self.c['resultsFolder'],
self.c['spinFileName'],
'iso_dsigma2_dt_18')
init_iso_dsigma2_dt_17 = read_init(self.c['resultsFolder'],
self.c['spinFileName'],
'iso_dsigma2_dt_17')
### set up the initial age and density of the firn column
self.age = initAge[1:]
self.rho = initDensity[1:]
self.drho_dt = init_drho_dt[1:]
###set up initial diffusion length dictionary as attribute
self.iso_sigma = {
'D': init_iso_sigmaD[1:],
'18': init_iso_sigma18[1:],
'17': init_iso_sigma17[1:]
}
self.iso_dsigma2_dt = {
'D': init_iso_dsigma2_dt_D[1:],
'18': init_iso_dsigma2_dt_18[1:],
'17': init_iso_dsigma2_dt_17[1:]
}
### set up model grid
self.z = initDepth[1:]
self.dz = np.diff(self.z)
self.dz = np.append(self.dz, self.dz[-1])
self.gridLen = np.size(self.z)
self.dx = np.ones(self.gridLen)
### get temperature and accumulation rate from input csv file
input_temp, input_year_temp = read_input(self.c['InputFileNameTemp'])
if input_temp[0] < 0.0:
input_temp = input_temp + K_TO_C
input_bdot, input_year_bdot = read_input(self.c['InputFileNamebdot'])
input_bdot[input_bdot <= 0.0] = 0.01
# if self.c['variable_srho']:
# input_srho, input_year_srho = read_input(self.c['InputFileNamesrho'])
try:
input_snowmelt, input_year_snowmelt = read_input(
self.c['InputFileNamemelt'])
MELT = True
print("Melt is initialized")
except:
MELT = False
print("No melt")
input_snowmelt = None
input_year_snowmelt = None
# year to start and end, from the input file. If inputs have different start/finish, take only the overlapping times
yr_start = max(input_year_temp[0], input_year_bdot[0]) # start year
yr_end = min(input_year_temp[-1], input_year_bdot[-1]) # end year
self.years = (yr_end - yr_start) * 1.0
self.dt = S_PER_YEAR / self.c['stpsPerYear']
print('dt', self.dt / S_PER_YEAR)
self.stp = int(self.years * S_PER_YEAR / self.dt +
1) # total number of time steps, as integer
# self.modeltime = np.linspace(yr_start, yr_end, self.stp + 1) # vector of time of each model step
self.modeltime = np.linspace(yr_start, yr_end, self.stp)
# self.dt = self.years * S_PER_YEAR / self.stp # size of time steps, seconds
self.t = 1.0 / self.c['stpsPerYear'] # years per time step
### Temperature
# self.Ts = np.interp(self.modeltime, input_year_temp, input_temp) # surface temperature interpolated to model time
Tsf = interpolate.interp1d(input_year_temp,
input_temp,
'linear',
fill_value='extrapolate')
self.Ts = Tsf(self.modeltime)
# print len(self.Ts)
# print self.Ts[0:13]
if self.c[
'SeasonalTcycle']: #impose seasonal temperature cycle of amplitude 'TAmp'
self.Ts = self.Ts + self.c['TAmp'] * (
np.cos(2 * np.pi * np.linspace(0, self.years, self.stp)) +
0.3 * np.cos(4 * np.pi * np.linspace(0, self.years, self.stp)))
# print self.Ts[0:13]
### Accumulation
# self.bdot = np.interp(self.modeltime, input_year_bdot, input_bdot) # interpolate accumulation rate to model time ???Should this be nearest?
bsf = interpolate.interp1d(input_year_bdot,
input_bdot,
'linear',
fill_value='extrapolate')
self.bdot = bsf(self.modeltime)
# self.bdotSec = self.bdot / S_PER_YEAR / (self.stp / self.years) # accumulation rate in per second
self.bdotSec = self.bdot / S_PER_YEAR / self.c[
'stpsPerYear'] # accumulation for each time step(per second)
self.iceout = np.mean(
self.bdot
) # this is the rate of ice flow advecting out of the column
### Melt
if MELT:
# self.snowmelt = np.interp(self.modeltime, input_year_snowmelt, input_snowmelt)
ssf = interpolate.interp1d(input_year_snowmelt,
input_snowmelt,
'nearest',
fill_value='extrapolate')
self.snowmelt = ssf(self.modeltime)
self.snowmeltSec = self.snowmelt / S_PER_YEAR / self.c[
'stpsPerYear'] # melt for each time step (per second)
# print [self.modeltime, self.snowmelt]
# raw_input()
##### Isotopes ###########
if self.c['isoDiff']:
init_del_z = read_init(self.c['resultsFolder'],
self.c['spinFileName'], 'IsoSpin')
try:
input_iso, input_year_iso = read_input(
self.c['InputFileNameIso'])
del_s_f = interpolate.interp1d(input_year_iso,
input_iso,
'nearest',
fill_value='extrapolate')
self.del_s = del_s_f(self.modeltime)
# del_s0 = input_iso[0]
except:
print(
'No external file for surface isotope values found, but you specified in the config file that isotope diffusion is on. The model will generate its own synthetic isotope data for you.'
)
# del_s0 = -50.0
ar1 = 0.9 # red noise memory coefficient
std_rednoise = 2 # red noise standard deviation
self.del_s = std_rednoise * np.random.randn(
self.stp) # white noise
for x in range(1, self.stp):
self.del_s[x] = self.del_s[x - 1] * ar1 + np.random.randn(
) # create red noise from white
self.del_s = self.del_s - 50
#impose seasonal isotope cycle
# self.del_s = self.del_s + 5 * (np.cos(2 * np.pi * np.linspace(0, self.years, self.stp )) + 0.3 * np.cos(4 * np.pi * np.linspace(0, self.years, self.stp )))
###########################
try:
if self.c['variable_srho']:
self.rhos0 = np.interp(self.modeltime, input_year_srho,
input_srho)
else:
self.rhos0 = self.c['rhos0'] * np.ones(
self.stp) # density at surface
except:
print("you should alter the json to include variable_srho")
self.rhos0 = self.c['rhos0'] * np.ones(
self.stp) # density at surface
# if MELT:
# self.snowmelt = np.interp(self.modeltime, input_year_snowmelt, input_snowmelt)
# self.snowmeltSec = self.snowmelt / S_PER_YEAR / (self.stp / self.years)
# if MELT:
# self.snowmelt = np.interp(self.modeltime, input_year_snowmelt, input_snowmelt)
# self.snowmeltSec = self.snowmelt / S_PER_YEAR / (self.stp / self.years)
self.rhos0 = self.c['rhos0'] * np.ones(self.stp) # density at surface
self.D_surf = self.c['D_surf'] * np.ones(
self.stp) # layer traking routine (time vector).
self.Dcon = self.c['D_surf'] * np.ones(
self.gridLen) # layer tracking routine (initial depth vector)
# set up vector of times data will be written
# Tind = np.nonzero(selfself.modeltime>=1958.0)[0][0]
self.TWrite = self.modeltime[0::self.c['TWriteInt']]
# self.TWrite_out = self.TWrite
TWlen = len(self.TWrite) #- 1
self.WTracker = 1
# set up initial mass, stress, and mean accumulation rate
self.mass = self.rho * self.dz
self.sigma = self.mass * self.dx * GRAVITY
self.sigma = self.sigma.cumsum(axis=0)
self.mass_sum = self.mass.cumsum(axis=0)
### mean accumulation over the lifetime of the parcel
# self.bdot_mean = np.concatenate(([self.mass_sum[0] / (RHO_I * S_PER_YEAR)], self.mass_sum[1:] / (self.age[1:] * RHO_I / self.t)))
self.bdot_mean = (np.concatenate(
([self.mass_sum[0] / (RHO_I * S_PER_YEAR)], self.mass_sum[1:] /
(self.age[1:] * RHO_I / self.t)))
) * self.c['stpsPerYear'] * S_PER_YEAR
### set up longitudinal strain rate
if self.c['strain']:
self.du_dx = np.zeros(self.gridLen)
self.du_dx[1:] = self.c['du_dx'] / (S_PER_YEAR)
# set up class to handle heat/isotope diffusion using user provided data for initial temperature vector
# self.diffu = Diffusion(self.z, self.stp, self.gridLen, initTemp[1:], init_del_z[1:]) # [1:] because first element is a time stamp
# self.T_mean = self.diffu.T10m # initially the mean temp is the same as the surface temperature
self.Tz = initTemp[1:]
self.T_mean = self.Tz[0]
self.T10m = self.T_mean
### Output list defined here
if self.c['isoDiff']:
self.output_list = ['density', 'drho_dt', 'depth','temperature', \
'age', 'climate', 'iso_sigmaD', 'iso_sigma18', 'iso_sigma17', \
'iso_dsigma2_dt_D', 'iso_dsigma2_dt_18', 'iso_dsigma2_dt_17', 'isotopes']
else:
self.output_list = ['density', 'drho_dt', 'depth','temperature', \
'age', 'climate', 'iso_sigmaD', 'iso_sigma18', 'iso_sigma17', \
'iso_dsigma2_dt_D', 'iso_dsigma2_dt_18', 'iso_dsigma2_dt_17']
print(self.output_list)
if 'density' in self.output_list:
self.rho_out = np.zeros((TWlen + 1, len(self.dz) + 1),
dtype='float32')
self.rho_out[0, :] = np.append(self.modeltime[0], self.rho)
if 'drho_dt' in self.output_list:
self.drho_dt_out = np.zeros((TWlen + 1, len(self.dz) + 1),
dtype='float32')
self.drho_dt_out[0, :] = np.append(self.modeltime[0], self.drho_dt)
if 'temperature' in self.output_list:
self.Tz_out = np.zeros((TWlen + 1, len(self.dz) + 1),
dtype='float32')
self.Tz_out[0, :] = np.append(self.modeltime[0], self.Tz)
if 'age' in self.output_list:
self.age_out = np.zeros((TWlen + 1, len(self.dz) + 1),
dtype='float32')
self.age_out[0, :] = np.append(self.modeltime[0],
self.age / S_PER_YEAR)
if 'depth' in self.output_list:
self.z_out = np.zeros((TWlen + 1, len(self.dz) + 1),
dtype='float32')
self.z_out[0, :] = np.append(self.modeltime[0], self.z)
if 'dcon' in self.output_list:
self.D_out = np.zeros((TWlen + 1, len(self.dz) + 1),
dtype='float32')
self.D_out[0, :] = np.append(self.modeltime[0], self.Dcon)
if 'bdot_mean' in self.output_list:
self.bdot_out = np.zeros((TWlen + 1, len(self.dz) + 1),
dtype='float32')
self.bdot_out[0, :] = np.append(self.modeltime[0], self.bdot_mean)
if 'climate' in self.output_list:
self.Clim_out = np.zeros((TWlen + 1, 3), dtype='float32')
self.Clim_out[0, :] = np.append(
self.modeltime[0],
[self.bdot[0], self.Ts[0]]) # not sure if bdot or bdotSec
if 'compaction_rate' in self.output_list:
self.crate_out = np.zeros((TWlen + 1, len(self.dz) + 1),
dtype='float32')
self.crate_out[0, :] = np.append(self.modeltime[0],
np.zeros(len(self.z)))
if 'iso_sigmaD' in self.output_list:
self.iso_sigmaD_out = np.zeros((TWlen + 1, len(self.dz) + 1),
dtype='float32')
self.iso_sigmaD_out[0, :] = np.append(self.modeltime[0],
self.iso_sigma['D'])
if 'iso_sigma18' in self.output_list:
self.iso_sigma18_out = np.zeros((TWlen + 1, len(self.dz) + 1),
dtype='float32')
self.iso_sigma18_out[0, :] = np.append(self.modeltime[0],
self.iso_sigma['18'])
if 'iso_sigma17' in self.output_list:
self.iso_sigma17_out = np.zeros((TWlen + 1, len(self.dz) + 1),
dtype='float32')
self.iso_sigma17_out[0, :] = np.append(self.modeltime[0],
self.iso_sigma['17'])
if 'iso_dsigma2_dt_D' in self.output_list:
self.iso_dsigma2_dt_D_out = np.zeros((TWlen + 1, len(self.dz) + 1),
dtype='float32')
self.iso_dsigma2_dt_D_out[0, :] = np.append(
self.modeltime[0], self.iso_dsigma2_dt['D'])
if 'iso_dsigma2_dt_18' in self.output_list:
self.iso_dsigma2_dt_18_out = np.zeros(
(TWlen + 1, len(self.dz) + 1), dtype='float32')
self.iso_dsigma2_dt_18_out[0, :] = np.append(
self.modeltime[0], self.iso_dsigma2_dt['18'])
if 'iso_dsigma2_dt_17' in self.output_list:
self.iso_dsigma2_dt_17_out = np.zeros(
(TWlen + 1, len(self.dz) + 1), dtype='float32')
self.iso_dsigma2_dt_17_out[0, :] = np.append(
self.modeltime[0], self.iso_dsigma2_dt['17'])
try:
print('rho_out size (MB):', self.rho_out.nbytes / 1.0e6)
except:
pass
# set up initial grain growth (if specified in config file)
if self.c['physGrain']:
initr2 = read_init(self.c['resultsFolder'], self.c['spinFileName'],
'r2Spin')
self.r2 = initr2[1:]
r20 = self.r2
if 'grainsize' in self.output_list:
self.r2_out = np.zeros((TWlen + 1, len(self.dz) + 1),
dtype='float32')
self.r2_out[0, :] = np.append(self.modeltime[0], self.r2)
else:
self.r2_out = None
else:
self.r2 = None
if self.c['physRho'] == 'Morris2014':
self.THist = True
initHx = read_init(self.c['resultsFolder'], self.c['spinFileName'],
'HxSpin')
self.Hx = initHx[1:]
if 'temp_Hx' in self.output_list:
self.Hx_out = np.zeros((TWlen + 1, len(self.dz) + 1),
dtype='float32')
self.Hx_out[0, :] = np.append(self.modeltime[0], self.Hx)
else:
self.Hx_out = None
else:
self.THist = False
if self.c['isoDiff']:
self.del_z = init_del_z[1:]
if 'isotopes' in self.output_list:
self.iso_out = np.zeros((TWlen + 1, len(self.dz) + 1),
dtype='float32')
self.iso_out[0, :] = np.append(self.modeltime[0], self.del_z)
else:
self.iso_out = None
self.dHAll = []
bcoAgeMart, bcoDepMart, bcoAge815, bcoDep815 = self.update_BCO()
LIZAgeMart, LIZDepMart = self.update_LIZ()
intPhi = self.update_DIP()
self.dHAll.append(0)
dHOut = 0
dHOutC = 0
if 'DIP' in self.output_list:
self.DIP_out = np.zeros((TWlen + 1, 4), dtype='float32')
self.DIP_out[0, :] = np.append(self.modeltime[0],
[intPhi, dHOut, dHOutC])
if 'LIZ' in self.output_list:
self.LIZ_out = np.zeros((TWlen + 1, 3), dtype='float32')
self.LIZ_out[0, :] = np.append(self.modeltime[0],
[LIZAgeMart, LIZDepMart])
if 'BCO' in self.output_list:
self.BCO_out = np.zeros((TWlen + 1, 5), dtype='float32')
self.BCO_out[0, :] = np.append(
self.modeltime[0],
[bcoAgeMart, bcoDepMart, bcoAge815, bcoDep815])
