vel = -0.00025; surcharge=-20.e3; # surcharge equals to the initial vertical stress of the RVE packing
dim = 2; B = 0.05; L = 0.6; H = 0.4;
mydomain = ReadGmsh('footing.msh',numDim=dim,integrationOrder=2) # read Gmsh mesh with 6-node triangle element (2500 tri6); each element has 3 Gauss points
k = kronecker(mydomain)
numg = 3*2500; # number of Gauss points
nump = 16; # number of processes in multiprocessing
packNo=list(range(0,numg,50))
prob = MultiScale(domain=mydomain,ng=numg,np=nump,random=False,rtol=1e-2,usePert=False,pert=-2.e-5,verbose=False)
disp = Vector(0.,Solution(mydomain))
t=0
stress = prob.getCurrentStress()
proj = Projector(mydomain)
sig = proj(stress)
sig_bounda = interpolate(sig,FunctionOnBoundary(mydomain))
traction = matrix_mult(sig_bounda,mydomain.getNormal())
x = mydomain.getX()
bx = FunctionOnBoundary(mydomain).getX()
footingBase = whereZero(bx[1]-sup(bx[1]))*whereNonPositive(bx[0]-B)
tractFoot = traction*footingBase
forceFoot = integrate(tractFoot,where=FunctionOnBoundary(mydomain))
lengthFoot = integrate(footingBase,where=FunctionOnBoundary(mydomain))
fout=file('./result/bearing.dat','w')
fout.write('0 '+str(forceFoot[0])+' '+str(forceFoot[1])+' '+str(lengthFoot)+'\n')
# Dirichlet BC, rollers at left and right, fixties at bottom, rigid and rough footing
Dbc = whereZero(x[0])*[1,0]+whereZero(x[0]-sup(x[0]))*[1,0]+whereZero(x[1]-inf(x[1]))*[1,1]+whereZero(x[1]-sup(x[1]))*whereNonPositive(x[0]-B)*[1,1]
Vbc = whereZero(x[0])*[0,0]+whereZero(x[0]-sup(x[0]))*[0,0]+whereZero(x[1]-inf(x[1]))*[0,0]+whereZero(x[1]-sup(x[1]))*whereNonPositive(x[0]-B)*[0,vel]
def wavesolver2d(domain,
h,
tend,
lam,
mu,
rho,
U0,
xc,
savepath,
output="vtk"):
from esys.escript.linearPDEs import LinearPDE
x = domain.getX()
# ... open new PDE ...
mypde = LinearPDE(domain)
#mypde.setSolverMethod(LinearPDE.LUMPING)
mypde.setSymmetryOn()
kmat = kronecker(domain)
mypde.setValue(D=kmat * rho)
# define small radius around point xc
# Lsup(x) returns the maximum value of the argument x
src_radius = 50 #2*Lsup(domain.getSize())
print("src_radius = ", src_radius)
dunit = numpy.array([0., 1.]) # defines direction of point source
# ... set initial values ....
n = 0
# initial value of displacement at point source is constant (U0=0.01)
# for first two time steps
u = U0 * (cos(length(x - xc) * 3.1415 / src_radius) +
1) * whereNegative(length(x - xc) - src_radius) * dunit
u_m1 = u
t = 0
u_pot = cbphones(domain, u, [[0, 500], [250, 500], [400, 500]], 2)
u_pc_x1 = u_pot[0, 0]
u_pc_y1 = u_pot[0, 1]
u_pc_x2 = u_pot[1, 0]
u_pc_y2 = u_pot[1, 1]
u_pc_x3 = u_pot[2, 0]
u_pc_y3 = u_pot[2, 1]
# open file to save displacement at point source
u_pc_data = open(os.path.join(savepath, 'U_pc.out'), 'w')
u_pc_data.write("%f %f %f %f %f %f %f\n" %
(t, u_pc_x1, u_pc_y1, u_pc_x2, u_pc_y2, u_pc_x3, u_pc_y3))
# while t<tend:
while t < 1.:
# ... get current stress ....
t = 1.
##OLD WAY
break
g = grad(u)
stress = lam * trace(g) * kmat + mu * (g + transpose(g))
### ... get new acceleration ....
#mypde.setValue(X=-stress)
#a=mypde.getSolution()
### ... get new displacement ...
#u_p1=2*u-u_m1+h*h*a
###NEW WAY
mypde.setValue(X=-stress * (h * h), Y=(rho * 2 * u - rho * u_m1))
u_p1 = mypde.getSolution()
# ... shift displacements ....
u_m1 = u
u = u_p1
#stress =
t += h
n += 1
print(n, "-th time step t ", t)
u_pot = cbphones(domain, u, [[300., 200.], [500., 200.], [750., 200.]],
2)
# print "u at point charge=",u_pc
u_pc_x1 = u_pot[0, 0]
u_pc_y1 = u_pot[0, 1]
u_pc_x2 = u_pot[1, 0]
u_pc_y2 = u_pot[1, 1]
u_pc_x3 = u_pot[2, 0]
u_pc_y3 = u_pot[2, 1]
# save displacements at point source to file for t > 0
u_pc_data.write(
"%f %f %f %f %f %f %f\n" %
(t, u_pc_x1, u_pc_y1, u_pc_x2, u_pc_y2, u_pc_x3, u_pc_y3))
# ... save current acceleration in units of gravity and displacements
#saveVTK(os.path.join(savepath,"usoln.%i.vtu"%n),acceleration=length(a)/9.81,
#displacement = length(u), tensor = stress, Ux = u[0] )
if output == "vtk":
saveVTK(os.path.join(savepath, "tonysol.%i.vtu" % n),
output1=length(u),
tensor=stress)
else:
quT = qu.toListOfTuples()
#Projector is used to smooth the data.
proj = Projector(mymesh)
smthT = proj(T)
#move data to a regular grid for plotting
xi, yi, zi = toRegGrid(smthT, mymesh, 200, 200, width, depth)
# contour the gridded data,
# select colour
pl.matplotlib.pyplot.autumn()
pl.clf()
# contour temperature
CS = pl.contour(xi, yi, zi, 5, linewidths=0.5, colors='k')
# labels and formatting
pl.clabel(CS, inline=1, fontsize=8)
pl.title("Heat Refraction across a clinal structure.")
pl.xlabel("Horizontal Displacement (m)")
pl.ylabel("Depth (m)")
pl.legend()
if getMPIRankWorld() == 0: #check for MPI processing
pl.savefig(
os.path.join(saved_path, "heatrefraction001_cont.png"))
u_pc_data.close()
h = Lsup(mesh.getSize())
numDim = mesh.getDim()
smooth = h * 2.0 # SMOOTHING PARAMETER FOR THE TRANSITION ACROSS THE INTERFACE
### DEFINITION OF THE PDE ###
velocityPDE = LinearPDE(mesh, numEquations=numDim)
advectPDE = LinearPDE(mesh)
advectPDE.setReducedOrderOn()
advectPDE.setValue(D=1.0)
advectPDE.setSolverMethod(solver=LinearPDE.DIRECT)
reinitPDE = LinearPDE(mesh, numEquations=1)
reinitPDE.setReducedOrderOn()
reinitPDE.setSolverMethod(solver=LinearPDE.LUMPING)
my_proj = Projector(mesh)
### BOUNDARY CONDITIONS ###
xx = mesh.getX()[0]
yy = mesh.getX()[1]
zz = mesh.getX()[2]
top = whereZero(zz - l1)
bottom = whereZero(zz)
left = whereZero(xx)
right = whereZero(xx - l0)
front = whereZero(yy)
back = whereZero(yy - l0)
b_c = (bottom + top) * [1.0, 1.0, 1.0] + (left + right) * [1.0, 0.0, 0.0] + (
front + back) * [0.0, 1.0, 0.0]
velocityPDE.setValue(q=b_c)
u, u_t = prob.solve(damp=damp)
# update maximum kinetic energy
Ek = integrate(length(u_t)**2*rho)/2.
# write data at selected timesteps
if t%tWrite == 0:
# check quasi-static state
while Ek > rtol or Ek <0:
u, u_t = prob.solve(damp=0.99,dynRelax=True)
Ek = integrate(length(u_t)**2*rho)/2.
print t, Ek
# get stress at (n) timesteps
stress = prob.getCurrentStress()
dom = prob.getDomain()
proj = Projector(dom)
# project Gauss point value to nodal value
sig = proj(stress)
# interpolate to stress at the boundary
sig_bounda = interpolate(sig,FunctionOnBoundary(dom))
# compute boundary traction by s_ij*n_j
traction = matrix_mult(sig_bounda,dom.getNormal())
# get mask for boundary nodes on the bottom
botSurf = whereZero(bx[1])
# traction at the bottom
tractBot = traction*botSurf
# resultant force at the bottom
forceBot = integrate(tractBot,where=FunctionOnBoundary(dom))
# length of the bottom surface
lengthBot = integrate(botSurf,where=FunctionOnBoundary(dom))
# write stress at the bottom surface
x[0]) + whereZero(x[0] - mx)
###############################################ESCRIPT PDE CONSTRUCTION
mypde = LinearPDE(domain)
mypde.setValue(A=kro, Y=4. * 3.1415 * G * rhoe, q=q, r=0.)
mypde.setSymmetryOn()
sol = mypde.getSolution()
g_field = grad(sol) #The gravitational acceleration g.
g_fieldz = g_field * [0, 1] #The vertical component of the g field.
gz = length(g_fieldz) #The magnitude of the vertical component.
# Save the output to file.
saveVTK(os.path.join(save_path,"ex10d.vtu"),\
grav_pot=sol,g_field=g_field,g_fieldz=g_fieldz,gz=gz,rho=rhoe)
################################################MODEL SIZE SAMPLING
smoother = Projector(domain) #Function smoother.
z = 1000. #Distance of profile from source.
sol_angz = [] #Array for analytic gz
sol_anx = [] #Array for x
#calculate analytic gz and x location.
for x in range(int(-mx / 2.), int(mx / 2.), 10):
sol_angz.append(analytic_gz(x, z, R, rho))
sol_anx.append(x + mx / 2)
#save analytic solution
pl.savetxt(os.path.join(save_path, "ex10d_as.asc"), sol_angz)
sol_escgz = [] #Array for escript solution for gz
#calculate the location of the profile in the domain
for i in range(0, len(sol_anx)):
sol_escgz.append([sol_anx[i], my / 2. - z])
###########################################################GET SOLUTION
T=mypde.getSolution()
print("PDE has been solved ...")
##################################################REGRIDDING & PLOTTING
xi, yi, zi = toRegGrid(T, nx=50, ny=50)
pl.matplotlib.pyplot.autumn()
pl.contourf(xi,yi,zi,10)
pl.xlabel("Horizontal Displacement (m)")
pl.ylabel("Depth (m)")
pl.savefig(os.path.join(save_path,"Tcontour.png"))
print("Solution has been plotted ...")
##########################################################VISUALISATION
# calculate gradient of solution for quiver plot
#Projector is used to smooth the data.
proj=Projector(domain)
#move data to a regular grid for plotting
xi,yi,zi = toRegGrid(T,200,200)
cut=int(len(xi)//2)
pl.clf()
pl.plot(zi[:,cut],yi)
pl.title("Temperature Depth Profile")
pl.xlabel("Temperature (K)")
pl.ylabel("Depth (m)")
pl.savefig(os.path.join(save_path,"tdp.png"))
pl.clf()
# Heat flow depth profile.
# grid the data.
qu=proj(-kappa*grad(T))
xiq,yiq,ziq = toRegGrid(qu[1],50,50)