def extrude(self,md): # {{{
self.element_equation=project3d(md,'vector',self.element_equation,'type','element')
self.vertex_equation=project3d(md,'vector',self.vertex_equation,'type','node')
self.borderSSA=project3d(md,'vector',self.borderSSA,'type','node')
self.borderHO=project3d(md,'vector',self.borderHO,'type','node')
self.borderFS=project3d(md,'vector',self.borderFS,'type','node')
return self
def extrude(self, md): # {{{
self.mantle_viscosity = project3d(md, 'vector', self.mantle_viscosity,
'type', 'node')
self.lithosphere_thickness = project3d(md, 'vector',
self.lithosphere_thickness,
'type', 'node')
return self
def extrude(self, md): # {{{
self.vx = project3d(md, 'vector', self.vx, 'type', 'node')
self.vy = project3d(md, 'vector', self.vy, 'type', 'node')
self.vz = project3d(md, 'vector', self.vz, 'type', 'node')
self.vel = project3d(md, 'vector', self.vel, 'type', 'node')
self.temperature = project3d(md, 'vector', self.temperature, 'type',
'node')
self.waterfraction = project3d(md, 'vector', self.waterfraction,
'type', 'node')
self.watercolumn = project3d(md, 'vector', self.watercolumn, 'type',
'node')
self.sediment_head = project3d(md, 'vector', self.sediment_head,
'type', 'node', 'layer', 1)
self.epl_head = project3d(md, 'vector', self.epl_head, 'type', 'node',
'layer', 1)
self.epl_thickness = project3d(md, 'vector', self.epl_thickness,
'type', 'node', 'layer', 1)
#Lithostatic pressure by default
# self.pressure=md.constants.g*md.materials.rho_ice*(md.geometry.surface[:,0]-md.mesh.z)
#self.pressure=md.constants.g*md.materials.rho_ice*(md.geometry.surface-md.mesh.z.reshape(-1,))
if np.ndim(md.geometry.surface) == 2:
print(
'Reshaping md.geometry.surface for you convenience but you should fix it in you files'
)
self.pressure = md.constants.g * md.materials.rho_ice * (
md.geometry.surface.reshape(-1, ) - md.mesh.z)
else:
self.pressure = md.constants.g * md.materials.rho_ice * (
md.geometry.surface - md.mesh.z)
return self
def extrude(self, md): # {{{
self.ice_levelset = project3d(md, 'vector', self.ice_levelset, 'type',
'node')
self.groundedice_levelset = project3d(md, 'vector',
self.groundedice_levelset,
'type', 'node')
return self
def extrude(self,md): # {{{
if self.isd18opd: self.temperatures_presentday=project3d(md,'vector',self.temperatures_presentday,'type','node')
if self.isd18opd: self.precipitations_presentday=project3d(md,'vector',self.precipitations_presentday,'type','node')
self.s0p=project3d(md,'vector',self.s0p,'type','node')
self.s0t=project3d(md,'vector',self.s0t,'type','node')
return self
def extrude(self,md): # {{{
self.spcsediment_head=project3d(md,'vector',self.spcsediment_head,'type','node','layer',1)
self.sediment_transmitivity=project3d(md,'vector',self.sediment_transmitivity,'type','node','layer',1)
self.basal_moulin_input=project3d(md,'vector',self.basal_moulin_input,'type','node','layer',1)
if self.isefficientlayer==1 :
self.spcepl_head=project3d(md,'vector',self.spcepl_head,'type','node','layer',1)
self.mask_eplactive_node=project3d(md,'vector',self.mask_eplactive_node,'type','node','layer',1)
return self
def extrude(self, md): # {{{
self.coefficient = project3d(md, 'vector', self.coefficient, 'type',
'node', 'layer', 1)
self.coefficientcoulomb = project3d(md, 'vector',
self.coefficientcoulomb, 'type',
'node', 'layer', 1)
self.p = project3d(md, 'vector', self.p, 'type', 'element')
self.q = project3d(md, 'vector', self.q, 'type', 'element')
return self
def extrude(self, md): # {{{
self.spcvx = project3d(md, 'vector', self.spcvx, 'type', 'node')
self.spcvy = project3d(md, 'vector', self.spcvy, 'type', 'node')
self.spcvz = project3d(md, 'vector', self.spcvz, 'type', 'node')
self.referential = project3d(md, 'vector', self.referential, 'type',
'node')
self.loadingforce = project3d(md, 'vector', self.loadingforce, 'type',
'node')
return self
def extrude(self, md): # {{{
self.surface = project3d(md, 'vector', self.surface, 'type', 'node')
self.thickness = project3d(md, 'vector', self.thickness, 'type',
'node')
self.hydrostatic_ratio = project3d(md, 'vector',
self.hydrostatic_ratio, 'type',
'node')
self.base = project3d(md, 'vector', self.base, 'type', 'node')
self.bed = project3d(md, 'vector', self.bed, 'type', 'node')
return self
def extrude(self, md): # {{{
self.groundedice_melting_rate = project3d(
md, 'vector', self.groundedice_melting_rate, 'type', 'node',
'layer', 1)
self.floatingice_melting_rate = project3d(
md, 'vector', self.floatingice_melting_rate, 'type', 'node',
'layer', 1)
self.geothermalflux = project3d(md, 'vector', self.geothermalflux,
'type', 'node', 'layer',
1) #bedrock only gets geothermal flux
return self
def extrude(self, md): # {{{
self.vx = project3d(md, 'vector', self.vx, 'type', 'node')
self.vy = project3d(md, 'vector', self.vy, 'type', 'node')
self.vz = project3d(md, 'vector', self.vz, 'type', 'node')
self.vel = project3d(md, 'vector', self.vel, 'type', 'node')
self.temperature = project3d(md, 'vector', self.temperature, 'type',
'node')
self.waterfraction = project3d(md, 'vector', self.waterfraction,
'type', 'node')
self.watercolumn = project3d(md, 'vector', self.watercolumn, 'type',
'node')
self.sediment_head = project3d(md, 'vector', self.sediment_head,
'type', 'node', 'layer', 1)
self.epl_head = project3d(md, 'vector', self.epl_head, 'type', 'node',
'layer', 1)
self.epl_thickness = project3d(md, 'vector', self.epl_thickness,
'type', 'node', 'layer', 1)
#Lithostatic pressure by default
self.pressure = md.constants.g * md.materials.rho_ice * (
md.geometry.surface - md.mesh.z.reshape(-1, 1))
return self
def extrude(self, md): # {{{
self.spctemperature = project3d(md, 'vector', self.spctemperature,
'type', 'node', 'layer',
md.mesh.numberoflayers, 'padding',
np.nan)
if isinstance(md.initialization.temperature, np.ndarray) and np.size(
md.initialization.temperature,
axis=0) == md.mesh.numberofvertices:
self.spctemperature = float('NaN') * np.ones(
(md.mesh.numberofvertices))
pos = np.where(md.mesh.vertexonsurface)[0]
self.spctemperature[pos] = md.initialization.temperature[
pos] #impose observed temperature on surface
return self
def extrude(self, md): # {{{
self.vx_obs = project3d(md, 'vector', self.vx_obs, 'type', 'node')
self.vy_obs = project3d(md, 'vector', self.vy_obs, 'type', 'node')
self.vel_obs = project3d(md, 'vector', self.vel_obs, 'type', 'node')
self.thickness_obs = project3d(md, 'vector', self.thickness_obs,
'type', 'node')
if not numpy.any(numpy.isnan(self.cost_functions_coefficients)):
self.cost_functions_coefficients = project3d(
md, 'vector', self.cost_functions_coefficients, 'type', 'node')
if not numpy.any(numpy.isnan(self.min_parameters)):
self.min_parameters = project3d(md, 'vector', self.min_parameters,
'type', 'node')
if not numpy.any(numpy.isnan(self.max_parameters)):
self.max_parameters = project3d(md, 'vector', self.max_parameters,
'type', 'node')
return self
def extrude(self, md): # {{{
self.partition = project3d(md, 'vector',
numpy.transpose(self.partition), 'type',
'node')
return self
def extrude(self,md): # {{{
if not (self.isdelta18o and self.ismungsm):
self.precipitation=project3d(md,'vector',self.precipitation,'type','node')
self.monthlytemperatures=project3d(md,'vector',self.monthlytemperatures,'type','node')
if self.isdelta18o: self.temperatures_lgm=project3d(md,'vector',self.temperatures_lgm,'type','node')
if self.isdelta18o: self.temperatures_presentday=project3d(md,'vector',self.temperatures_presentday,'type','node')
if self.isdelta18o: self.precipitations_presentday=project3d(md,'vector',self.precipitations_presentday,'type','node')
if self.isdelta18o: self.precipitations_lgm=project3d(md,'vector',self.precipitations_lgm,'type','node')
if self.ismungsm: self.temperatures_lgm=project3d(md,'vector',self.temperatures_lgm,'type','node')
if self.ismungsm: self.temperatures_presentday=project3d(md,'vector',self.temperatures_presentday,'type','node')
if self.ismungsm: self.precipitations_presentday=project3d(md,'vector',self.precipitations_presentday,'type','node')
if self.ismungsm: self.precipitations_lgm=project3d(md,'vector',self.precipitations_lgm,'type','node')
self.s0p=project3d(md,'vector',self.s0p,'type','node')
self.s0t=project3d(md,'vector',self.s0t,'type','node')
return self
def extrude(self,md): # {{{
self.spclevelset=project3d(md,'vector',self.spclevelset,'type','node')
self.calvingrate=project3d(md,'vector',self.calvingrate,'type','node')
self.meltingrate=project3d(md,'vector',self.meltingrate,'type','node')
return self
def extrude(self, md): # {{{
self.spclevelset = project3d(md, 'vector', self.spclevelset, 'type',
'node')
return self
def extrude(self, md): # {{{
self.D = project3d(md, 'vector', self.D, 'type', 'node')
self.spcdamage = project3d(md, 'vector', self.spcdamage, 'type',
'node')
return self
def extrude(md, *args): # {{{
"""
EXTRUDE - vertically extrude a 2d mesh
vertically extrude a 2d mesh and create corresponding 3d mesh.
The vertical distribution can:
- follow a polynomial law
- follow two polynomial laws, one for the lower part and one for the upper part of the mesh
- be discribed by a list of coefficients (between 0 and 1)
Usage:
md=extrude(md,numlayers,extrusionexponent)
md=extrude(md,numlayers,lowerexponent,upperexponent)
md=extrude(md,listofcoefficients)
Example:
md=extrude(md,15,1.3);
md=extrude(md,15,1.3,1.2);
md=extrude(md,[0 0.2 0.5 0.7 0.9 0.95 1])
See also: MODELEXTRACT, COLLAPSE
"""
#some checks on list of arguments
if len(args) > 3 or len(args) < 1:
raise RuntimeError("extrude error message")
#Extrude the mesh
if len(args) == 1: #list of coefficients
clist = args[0]
if any(clist < 0) or any(clist > 1):
raise TypeError(
"extrusioncoefficients must be between 0 and 1")
clist.extend([0., 1.])
clist.sort()
extrusionlist = list(set(clist))
numlayers = len(extrusionlist)
elif len(args) == 2: #one polynomial law
if args[1] <= 0:
raise TypeError("extrusionexponent must be >=0")
numlayers = args[0]
extrusionlist = (np.arange(0.,
float(numlayers - 1) + 1., 1.) /
float(numlayers - 1))**args[1]
elif len(args) == 3: #two polynomial laws
numlayers = args[0]
lowerexp = args[1]
upperexp = args[2]
if args[1] <= 0 or args[2] <= 0:
raise TypeError(
"lower and upper extrusionexponents must be >=0")
lowerextrusionlist = (np.arange(
0., 1. + 2. / float(numlayers - 1),
2. / float(numlayers - 1)))**lowerexp / 2.
upperextrusionlist = (np.arange(
0., 1. + 2. / float(numlayers - 1),
2. / float(numlayers - 1)))**upperexp / 2.
extrusionlist = np.unique(
np.concatenate((lowerextrusionlist, 1. - upperextrusionlist)))
if numlayers < 2:
raise TypeError("number of layers should be at least 2")
if md.mesh.__class__.__name__ == 'mesh3dprisms':
raise TypeError(
"Cannot extrude a 3d mesh (extrude cannot be called more than once)"
)
#Initialize with the 2d mesh
mesh2d = md.mesh
md.mesh = mesh3dprisms()
md.mesh.x = mesh2d.x
md.mesh.y = mesh2d.y
md.mesh.elements = mesh2d.elements
md.mesh.numberofelements = mesh2d.numberofelements
md.mesh.numberofvertices = mesh2d.numberofvertices
md.mesh.lat = mesh2d.lat
md.mesh.long = mesh2d.long
md.mesh.epsg = mesh2d.epsg
md.mesh.vertexonboundary = mesh2d.vertexonboundary
md.mesh.vertexconnectivity = mesh2d.vertexconnectivity
md.mesh.elementconnectivity = mesh2d.elementconnectivity
md.mesh.average_vertex_connectivity = mesh2d.average_vertex_connectivity
md.mesh.extractedvertices = mesh2d.extractedvertices
md.mesh.extractedelements = mesh2d.extractedelements
x3d = np.empty((0))
y3d = np.empty((0))
z3d = np.empty((0)) #the lower node is on the bed
thickness3d = md.geometry.thickness #thickness and bed for these nodes
bed3d = md.geometry.base
#Create the new layers
for i in xrange(numlayers):
x3d = np.concatenate((x3d, md.mesh.x))
y3d = np.concatenate((y3d, md.mesh.y))
#nodes are distributed between bed and surface accordingly to the given exponent
z3d = np.concatenate(
(z3d, (bed3d + thickness3d * extrusionlist[i]).reshape(-1)))
number_nodes3d = np.size(
x3d) #number of 3d nodes for the non extruded part of the mesh
#Extrude elements
elements3d = np.empty((0, 6), int)
for i in xrange(numlayers - 1):
elements3d = np.vstack(
(elements3d,
np.hstack(
(md.mesh.elements + i * md.mesh.numberofvertices,
md.mesh.elements + (i + 1) * md.mesh.numberofvertices)))
) #Create the elements of the 3d mesh for the non extruded part
number_el3d = np.size(
elements3d,
axis=0) #number of 3d nodes for the non extruded part of the mesh
#Keep a trace of lower and upper nodes
lowervertex = np.nan * np.ones(number_nodes3d, int)
uppervertex = np.nan * np.ones(number_nodes3d, int)
lowervertex[md.mesh.numberofvertices:] = np.arange(
1, (numlayers - 1) * md.mesh.numberofvertices + 1)
uppervertex[:(numlayers - 1) * md.mesh.numberofvertices] = np.arange(
md.mesh.numberofvertices + 1, number_nodes3d + 1)
md.mesh.lowervertex = lowervertex
md.mesh.uppervertex = uppervertex
#same for lower and upper elements
lowerelements = np.nan * np.ones(number_el3d, int)
upperelements = np.nan * np.ones(number_el3d, int)
lowerelements[md.mesh.numberofelements:] = np.arange(
1, (numlayers - 2) * md.mesh.numberofelements + 1)
upperelements[:(numlayers - 2) * md.mesh.numberofelements] = np.arange(
md.mesh.numberofelements + 1,
(numlayers - 1) * md.mesh.numberofelements + 1)
md.mesh.lowerelements = lowerelements
md.mesh.upperelements = upperelements
#Save old mesh
md.mesh.x2d = md.mesh.x
md.mesh.y2d = md.mesh.y
md.mesh.elements2d = md.mesh.elements
md.mesh.numberofelements2d = md.mesh.numberofelements
md.mesh.numberofvertices2d = md.mesh.numberofvertices
#Build global 3d mesh
md.mesh.elements = elements3d
md.mesh.x = x3d
md.mesh.y = y3d
md.mesh.z = z3d
md.mesh.numberofelements = number_el3d
md.mesh.numberofvertices = number_nodes3d
md.mesh.numberoflayers = numlayers
#Ok, now deal with the other fields from the 2d mesh:
#bedinfo and surface info
md.mesh.vertexonbase = project3d(
md, 'vector', np.ones(md.mesh.numberofvertices2d, bool), 'type',
'node', 'layer', 1)
md.mesh.vertexonsurface = project3d(
md, 'vector', np.ones(md.mesh.numberofvertices2d, bool), 'type',
'node', 'layer', md.mesh.numberoflayers)
md.mesh.vertexonboundary = project3d(md, 'vector',
md.mesh.vertexonboundary, 'type',
'node')
#lat long
md.mesh.lat = project3d(md, 'vector', md.mesh.lat, 'type', 'node')
md.mesh.long = project3d(md, 'vector', md.mesh.long, 'type', 'node')
md.geometry.extrude(md)
md.friction.extrude(md)
md.inversion.extrude(md)
md.smb.extrude(md)
md.initialization.extrude(md)
md.flowequation.extrude(md)
md.stressbalance.extrude(md)
md.thermal.extrude(md)
md.masstransport.extrude(md)
# Calving variables
md.hydrology.extrude(md)
md.levelset.extrude(md)
md.calving.extrude(md)
#connectivity
md.mesh.elementconnectivity = np.tile(md.mesh.elementconnectivity,
(numlayers - 1, 1))
md.mesh.elementconnectivity[np.nonzero(
md.mesh.elementconnectivity == 0)] = -sys.maxint - 1
if not np.isnan(md.mesh.elementconnectivity).all():
for i in xrange(1, numlayers - 1):
md.mesh.elementconnectivity[i*md.mesh.numberofelements2d:(i+1)*md.mesh.numberofelements2d,:] \
=md.mesh.elementconnectivity[i*md.mesh.numberofelements2d:(i+1)*md.mesh.numberofelements2d,:]+md.mesh.numberofelements2d
md.mesh.elementconnectivity[np.nonzero(
md.mesh.elementconnectivity < 0)] = 0
md.materials.extrude(md)
md.damage.extrude(md)
md.gia.extrude(md)
md.mask.extrude(md)
md.qmu.extrude(md)
md.basalforcings.extrude(md)
#increase connectivity if less than 25:
if md.mesh.average_vertex_connectivity <= 25:
md.mesh.average_vertex_connectivity = 100
return md
def extrude(self, md): # {{{
self.rheology_B = project3d(md, 'vector', self.rheology_B, 'type',
'node')
self.rheology_n = project3d(md, 'vector', self.rheology_n, 'type',
'element')
return self
def extrude(self, md): # {{{
self.spcthickness = project3d(md, 'vector', self.spcthickness, 'type',
'node')
return self
def extrude(self, md): # {{{
self.mass_balance = project3d(md, 'vector', self.mass_balance, 'type',
'node')
return self
