def test_illegal_triangles_throw_exceptions(self):
# Calls triangle(0, 0, 0)
self.assertRaises(TriangleError, triangle(0, 0, 0))
self.assertRaises(TriangleError, triangle(3, 4, -5))
self.assertRaises(TriangleError, triangle(1, 1, 3))
self.assertRaises(TriangleError, triangle(2, 5, 2))
def test_isosceles_triangles_have_exactly_two_sides_equal(self):
#self.assertEqual(None, triangle(3,4,4))
self.assertEqual('isosceles', triangle(3, 4, 4))
#self.assertEqual(None, triangle(4,3,4))
self.assertEqual('isosceles', triangle(4, 3, 4))
#self.assertEqual(None, triangle(4,4,3))
self.assertEqual('isosceles', triangle(4, 4, 3))
#self.assertEqual(None, triangle(10,10,2))
self.assertEqual('isosceles', triangle(10, 10, 2))
def test_equilateral_triangles_have_equal_sides(self):
#self.assertEqual(None, triangle(2,2,2))
self.assertEqual('equilateral', triangle(2, 2, 2))
self.assertEqual('equilateral', triangle(10, 10, 10))
#Test Name: SquareShelfLevelsetCalvingSSA2dLevermann
from model import *
from socket import gethostname
from triangle import *
from setmask import *
from parameterize import *
from setflowequation import *
from solve import *
import numpy as np
md=triangle(model(),'../Exp/Square.exp',50000.)
md=setmask(md,'all','')
md=parameterize(md,'../Par/SquareShelf.py')
md=setflowequation(md,'SSA','all')
md.cluster=generic('name',gethostname(),'np',3)
x = md.mesh.x
xmin = min(x)
xmax = max(x)
Lx = (xmax-xmin)
alpha = 2./3.
md.mask.ice_levelset = np.float_((x - alpha*Lx)>0) - np.float_((x - alpha*Lx)<0)
md.timestepping.time_step=10
md.timestepping.final_time=30
#Transient
md.transient.isstressbalance=True
md.transient.ismasstransport=True
md.transient.issmb=True
#Test Name: PigTranSSA2d
from model import *
from socket import gethostname
from triangle import *
from setmask import *
from parameterize import *
from setflowequation import *
from solve import *
md = triangle(model(), '../Exp/Pig.exp', 20000.)
md = setmask(md, '../Exp/PigShelves.exp', '../Exp/PigIslands.exp')
md = parameterize(md, '../Par/Pig.py')
md = setflowequation(md, 'SSA', 'all')
md.cluster = generic('name', gethostname(), 'np', 3)
md = solve(md, 'Transient')
# Fields and tolerances to track changes
field_names = [
'Vx1', 'Vy1', 'Vel1', 'Pressure1', 'Bed1', 'Surface1', 'Thickness1', 'Vx2',
'Vy2', 'Vel2', 'Pressure2', 'Bed2', 'Surface2', 'Thickness2'
]
field_tolerances = [
1e-12, 2e-12, 2e-12, 1e-13, 1e-13, 1e-13, 1e-13, 1e-12, 1e-12, 1e-12,
1e-13, 1e-13, 1e-13, 1e-13
]
field_values=[\
md.results.TransientSolution[0].Vx,\
md.results.TransientSolution[0].Vy,\
md.results.TransientSolution[0].Vel,\
md.results.TransientSolution[0].Pressure,\
md.results.TransientSolution[0].Base,\
def test_scalene_triangles_have_no_equal_sides(self):
self.assertEqual('scalene', triangle(3, 4, 5))
self.assertEqual('scalene', triangle(10, 11, 12))
self.assertEqual('scalene', triangle(5, 4, 2))
def test_isosceles_triangles_have_exactly_two_sides_equal(self):
self.assertEqual('isosceles', triangle(3, 4, 4))
self.assertEqual('isosceles', triangle(4, 3, 4))
self.assertEqual('isosceles', triangle(4, 4, 3))
self.assertEqual('isosceles', triangle(10, 10, 2))
from model import * from socket import gethostname from triangle import * from setmask import * from parameterize import * from setflowequation import * from solve import * """ EISMINT benchmark experiment A """ numlayers = 8 resolution = 50000. #To begin with the numerical model md = triangle(model(), '../Exp/SquareEISMINT750000.exp', resolution) md = setmask(md, '', '') md = parameterize(md, '../Par/RoundSheetEISMINT.py') #We extrude the model to have a 3d model md.extrude(numlayers, 1.) md = setflowequation(md, 'SIA', 'all') #Spc the nodes on the bed pos = np.where(md.mesh.vertexonbase) md.stressbalance.spcvx[pos] = 0. md.stressbalance.spcvy[pos] = 0. md.stressbalance.spcvz[pos] = 0. #Adapt the time steps to the resolution md.timestepping.time_step = 15.
#Test Name: SquareShelfTherStea
from model import *
from socket import gethostname
import numpy as np
from triangle import *
from setmask import *
from parameterize import *
from setflowequation import *
from solve import *
from generic import generic
md = triangle(model(), '../Exp/Square.exp', 180000)
md = setmask(md, 'all', '')
md = parameterize(md, '../Par/SquareShelf.py')
md.extrude(3, 1.)
md = setflowequation(md, 'SSA', 'all')
md.timestepping.time_step = 0
md.cluster = generic('name', gethostname(), 'np', 3)
md = solve(md, 'Thermal')
# Fields and tolerances to track changes
field_names = ['Temperature', 'BasalforcingsGroundediceMeltingRate']
field_tolerances = [1e-13, 5e-6]
field_values = [
md.results.ThermalSolution.Temperature,
md.results.ThermalSolution.BasalforcingsGroundediceMeltingRate
]
#Test Name: 79NorthSurfSlop3d
import numpy as np
from model import *
from socket import gethostname
from triangle import *
from setmask import *
from parameterize import *
from setflowequation import *
from solve import *
md = triangle(model(), '../Exp/79North.exp', 10000.)
md = setmask(md, '../Exp/79NorthShelf.exp', '')
md = parameterize(md, '../Par/79North.py')
md.extrude(5, 1.5)
md = setflowequation(md, 'HO', 'all')
md.cluster = generic('name', gethostname(), 'np', 3)
md = solve(md, 'SurfaceSlope')
#Fields and tolerances to track changes
field_names = ['SurfaceSlopeX', 'SurfaceSlopeY']
field_tolerances = [1e-13, 1e-13]
field_values=[\
md.results.SurfaceSlopeSolution.SurfaceSlopeX,\
md.results.SurfaceSlopeSolution.SurfaceSlopeY,\
]
#Test Name: SquareShelfStressSSA2dRift
from model import *
from socket import gethostname
import numpy as np
from triangle import *
from meshprocessrifts import *
from setmask import *
from parameterize import *
from setflowequation import *
from solve import *
from generic import generic
md=triangle(model(),'../Exp/SquareHole.exp','../Exp/Rifts.exp',50000.)
md=meshprocessrifts(md,'../Exp/Square.exp')
md=setmask(md,'all','')
md=parameterize(md,'../Par/SquareShelf2.py')
md=setflowequation(md,'SSA','all')
md.cluster=generic('name',gethostname(),'np',3)
# rift settings
md.rifts.riftstruct[0]['fill']='Melange'
md.rifts.riftstruct[0]['fraction']=0
md.stressbalance.rift_penalty_lock=2
md.stressbalance.rift_penalty_threshold=0
md.rifts.riftstruct[0]['fractionincrement']=0.1
md=solve(md,'Stressbalance')
# Fields and tolerances to track changes
from setmask import * from parameterize import * from setflowequation import * from paterson import * from solve import * """ This file can be run to check that the melting in simple conduction is correctly modeled. There is no velocity (no advection) the only thermal boundary conditions are an imposed temperature at upper surface and an impose flux at its base. The result must be a linear temperature from the upper to the lower surface with an imposed slope (Geothermal flux). if it is not the case, something is thermal modeling has been changed... """ printingflag = False md = model() md = triangle(md, '../Exp/Square.exp', 100000.) md = setmask(md, '', '') md = parameterize(md, '../Par/SquareThermal.py') md.extrude(3, 2.) md = setflowequation(md, 'HO', 'all') #Some conditions specific to melting test md.initialization.pressure = np.zeros((md.mesh.numberofvertices, 1), int) md.initialization.temperature = 273.15 * np.ones((md.mesh.numberofvertices)) pos = np.nonzero(md.mesh.vertexonsurface)[0] md.thermal.spctemperature[pos] = md.initialization.temperature[pos] md.materials.rheology_B = paterson(md.initialization.temperature) #analytical results #melting heat = geothermal flux #Mb*L*rho=G => Mb=G/L*rho
def main():
print "hello"
lines = [line.strip() for line in open(file_name, "r+")]
for i in range(len(lines)):
line = lines[i]
if "v" == line[0]:
line = str.split(line)
line = line[1:]
for i in range(3):
line[i] = float(line[i])
vertices.append(line)
elif "f" == line[0]:
line = str.split(line)
line = line[1:]
for i in range(3):
line[i] = int(line[i])
faces.append(line)
else:
print "corrupt data"
triangle.vertex = vertices
triangle.face = faces
for i in range(len(faces)):
covered.append(0)
face = faces[i]
triangles.append(triangle(face[0], face[1], face[2], i))
edge_tri = triangle.edge_tri
# t=triangles[0]
# t.f(0.12,0.2,0.1)
# print t.lengths
# print t.new_lengths
# print t.new_lambda
# print np.array(t.angles)*180/np.pi
# print np.array(t.new_angles)*180/np.pi
"""
for tri in triangles:
#pass
#print tri.vertex_numbers
tri.f(0.12,0.2,0.1)
tri.f(0.12,0.2,0.1)
#print tri.new_lambda
#print triangle.v_tri
# print str(tri.tri_number)+': '+str(tri.angles)
#print np.array(tri.new_angles)*180/np.pi
"""
print "###"
print len(vertices)
for key in triangle.edge_tri:
if len(triangle.edge_tri[key]) != 2:
for v in key:
if v not in boundary_vertices:
boundary_vertices.append(v)
else:
pass
####### THIS IS ONLY FOR CONE SINGULARITIES ##########
# boundary_vertices.append(17)
# boundary_vertices.append(44)
######################################################
## this list contains index of internal vertices
triangle.vert_wo_bound = range(len(vertices))
for v in boundary_vertices:
triangle.vert_wo_bound.remove(v)
for v in range(len(vertices)):
if v in corners:
target_angl.append(np.pi / 2)
elif v in boundary_vertices:
target_angl.append(np.pi)
else:
target_angl.append(2 * np.pi)
print boundary_vertices
"""
a=[0, 2, 3, 6, 7, 237]
a_sum=0
for i in a:
tri=triangles[i]
print i
print np.array(tri.angles)*180/np.pi
a_sum+=tri.angl_at_abs_vert(0)
print tri.angl_at_abs_vert(0)*180/np.pi
pArray=np.array([])
for i in range(len(vertices)):
angle_sum=0
for t in triangle.v_tri[i]:
tri=triangles[t]
angle_sum+=tri.angl_at_abs_vert(i)
pArray=np.append(pArray, angle_sum)
print pArray*180/np.pi
""" """
pArray=np.array([])
for i in range(len(vertices)):
angle_sum=0
for t in triangle.v_tri[i]:
tri=triangles[t]
angle_sum+=tri.angl_at_abs_vert(i)
pArray=np.append(pArray, 2*np.pi-angle_sum)
print pArray"""
guess = []
guess2 = []
guess3 = []
for i in range(len(triangle.vert_wo_bound)):
guess.append(0.0)
guess2.append(-10)
guess3.append(100)
"""
guess=[]
for i in range(len(vertices)):
guess.append(0.0)
"""
# energy(guess)
# energy(guess2)
# energy(guess3)
# ePrime(guess)
# print boundary_vertices
# print target_angl
# energy(u_values)
start = 0
if file_name == "face.obj":
start = 600
# tile_nei(triangles[0],(0,1),np.array([0,0,0]),np.array([triangles[0].new_lengths[0],0,0]),-1)
# print triangle.v_tri
# print lenboundary_vertices)
m = optimize.fmin_l_bfgs_b(energy, guess, fprime=ePrime)
print m[0]
cong = open("temp", "w")
cnt = 0
for item in m[0]:
if cnt == 9:
cong.write(str(item) + "\n")
cnt = 0
else:
cong.write(str(item) + " ")
cnt += 1
cong.close()
for tri in triangles:
if tri.new_angles[0] == 0 or tri.new_angles[0] == np.pi:
print "nono"
f = open("temp", "r")
a = f.readlines()
u_values = []
for tens in a:
if tens[0] != "f":
for ones in tens.split():
u_values.append(float(ones))
f.close()
os.system("rm temp")
ePrime(u_values)
tile_not_recursive(
triangles[start],
triangles[start].edges[0],
np.array([0, 0, 0]),
np.array([triangles[start].new_lengths[0], 0, 0]),
-1,
)
while len(current) != 0:
for tri_num in current:
tile_neighbors(triangles[tri_num])
f = open(out_name, "w+")
for tri in triangles:
for i in range(3):
f.write(str(tri.text_coord[i][0]) + "\n")
f.write(str(tri.text_coord[i][1]) + "\n")
f.close()
# t = triangle([-0.206972, 0.0740737, 0.544664],[-0.398695, -0.0740794, 0.501089],\
# [-0.211327, -0.187367, 0.588234])
# print t.vi
# starting triangle: 86
# tile_nei(triangles[0],(0,1),np.array([0,0,0]),np.array([triangles[0].new_lengths[0],0,0]),-1)
# tile_not_recursive(triangles[1013],(484, 558),np.array([0,0,0]),np.array([triangles[1013].new_lengths[0],0,0]),-1)
"""
"""
"""
tile_not_recursive(triangles[238],(209, 210),np.array([0,0,0]),np.array([triangles[238].new_lengths[0],0,0]),-1)
while(len(current) != 0):
for tri_num in current:
tile_neighbors(triangles[tri_num])
f=open('egea_param.txt','w+')
for tri in triangles:
for i in range(3):
f.write(str(tri.text_coord[i][0] * 150)+'\n')
f.write(str(tri.text_coord[i][1] * 150)+'\n')
f.close()
x=[]
y=[]
for tri in triangles:
for i in range(3):
x.append(tri.text_coord[i][0] * 100)
y.append(tri.text_coord[i][1] * 100)
plt.scatter(x,y,marker='+',s=150,linewidths=4 ,c=y, cmap=plt.cm.coolwarm)
plt.show()"""
"""
from socket import gethostname
from triangle import *
from setmask import *
from parameterize import *
from setflowequation import *
from solve import *
"""
This test is a test from the ISMP-HOM Intercomparison project.
Pattyn and Payne 2006
"""
L_list = [80000.]
results = []
for L in L_list:
md = triangle(model(), "../Exp/Square_%d.exp" % L, L / 10.) #size 3*L
md = setmask(md, '', '') #ice sheet test
md = parameterize(md, '../Par/ISMIPC.py')
md.friction.coefficient = np.sqrt(
md.constants.yts *
(1000. + 1000. * np.sin(md.mesh.x * 2. * np.pi / L) *
np.sin(md.mesh.y * 2. * np.pi / L)))
md.extrude(10, 1.)
#Add spc on the borders
pos = np.where(
np.logical_or.reduce(
(md.mesh.x == 0., md.mesh.x == np.max(md.mesh.x), md.mesh.y == 0.,
md.mesh.y == np.max(md.mesh.y))))
md.stressbalance.spcvx[pos] = 0.
md.stressbalance.spcvy[pos] = 0.
def test_scalene_triangles_have_no_equal_sides(self):
#self.assertEqual(None, triangle(3, 4, 5))
self.assertEqual('scalene', triangle(3, 4, 5))
self.assertEqual('scalene', triangle(10, 11, 12))
self.assertEqual('scalene', triangle(5, 4, 2))
def test_equilateral_triangles_have_equal_sides(self):
self.assertEqual('equilateral', triangle(2, 2, 2))
self.assertEqual('equilateral', triangle(10, 10, 10))
from triangle import *
from setmask import *
from parameterize import *
from setflowequation import *
from solve import *
"""
Test on the stressbalance model and the masstransport in 2d
"""
printingflag=False
#tests 3 and 4: using Glen's flow law
md=model()
md=triangle(md,'../Exp/SquareEISMINT.exp',3550.)
md=setmask(md,'all','')
md=parameterize(md,'../Par/SquareEISMINT.py')
md=setflowequation(md,'SSA','all') #SSA's model and 2d
#Impose a non zero velocity on the upper boundary condition (y=max(y))
pos=np.where(md.mesh.y==np.max(md.mesh.y))
heavyside=np.where(np.logical_and(md.mesh.y==np.max(md.mesh.y),((1.+sys.float_info.epsilon)*np.ones((np.size(md.mesh.y)))-((md.mesh.x-100000.)/25000.)**2)>0))
md.stressbalance.spcvy[pos]=np.zeros((np.size(pos)))
md.stressbalance.spcvy[heavyside]=400.*(((md.mesh.x[heavyside]-100000.)/25000.)**2-np.ones((np.size(heavyside))))
#Compute solution for SSA's model
md.cluster=generic('name',gethostname(),'np',8)
md=solve(md,'Stressbalance')
#plot results
