def testCalculate_init(self):
from proteus import Domain
from proteus.mprans import SpatialTools as mst
from proteus.mprans.BodyDynamics import PaddleBody
domain2D = Domain.PlanarStraightLineGraphDomain()
pos = np.array([2.0, 0.1 , 0.0])
dim = (0.3, 1.)
paddle = mst.Rectangle(domain=domain2D, dim=dim, coords=[pos[0], pos[1]])
PB=PaddleBody(paddle,substeps=20)
PB.calculate_init()
npt.assert_equal(PB.position,[pos[0],0.,0.])
npt.assert_equal(PB.last_position,[pos[0],0.,0.])
npt.assert_equal(PB.rotation,np.eye(3))
npt.assert_equal(PB.last_rotation,np.eye(3))
from proteus.mprans.BodyDynamics import getEulerAngles
npt.assert_equal(PB.rotation_euler,getEulerAngles(PB.rotation))
npt.assert_equal(PB.last_rotation_euler,getEulerAngles(PB.last_rotation))
npt.assert_equal(PB.cV_init,np.array([(1.85,-0.4),
(2.15,-0.4),
(2.15,0.6),
(1.85,0.6)]))
npt.assert_equal(PB.cV,np.array([(1.85,-0.4),
(2.15,-0.4),
(2.15,0.6),
(1.85,0.6)]))
npt.assert_equal(PB.cV_last,np.array([(1.85,-0.4),
(2.15,-0.4),
(2.15,0.6),
(1.85,0.6)]))
def testPaddleMotion(self):
from proteus import Domain
from proteus.mprans import SpatialTools as mst
from proteus.mprans.BodyDynamics import PaddleBody
domain2D = Domain.PlanarStraightLineGraphDomain()
pos = np.array([2.0, 0.1 , 0.0])
dim = (0.3, 1.)
paddle = mst.Rectangle(domain=domain2D, dim=dim, coords=[pos[0], pos[1]])
PB=PaddleBody(paddle,substeps=20)
PB.calculate_init()
At = [1.,0.,0.]
Ar = [0.1,0.,0.]
Tt = Tr = [0.5,0.,0.]
rampS = 0.1
rampE = 0.1
Tend = 2.
PB.inputMotion(InputMotion=True, pivot=None,
At=At, Tt=Tt,
Ar=Ar, Tr=Tr,
rampStart=rampS, rampEnd =rampE, Tend = Tend)
# tersting initial ramp
times= [0.04, 0.95 ,1.93]
for tt in times:
ramp = min(1.,tt/rampS,(Tend-tt)/rampE)
getVars = PB.imposeSinusoidalMotion(tt=tt)
disp = ramp*np.array(At)*np.sin(2*np.pi/Tt[0]*tt)
rot = ramp*np.array(Ar)*np.sin(2*np.pi/Tt[0]*tt)
disp = disp - (PB.last_position - PB.init_barycenter)
npt.assert_equal(disp,getVars[0])
npt.assert_equal(rot,getVars[1])
def tank2d(L=[1.0, 1.0, 1.0], fileprefix=None):
boundaries = [
'left', 'right', 'bottom', 'top', 'front', 'back', 'obstacle'
]
boundaryTags = dict([(key, i + 1) for (i, key) in enumerate(boundaries)])
vertices = [
[0.0, 0.0], #0
[L[0], 0.0], #1
[L[0], L[1]], #2
[0.0, L[1]]
] #3
vertexFlags = [
boundaryTags['left'], boundaryTags['right'], boundaryTags['right'],
boundaryTags['left']
]
segments = [[0, 1], [1, 2], [2, 3], [3, 0]]
segmentFlags = [
boundaryTags['front'], boundaryTags['right'], boundaryTags['back'],
boundaryTags['left']
]
regions = [[0.5 * L[0], 0.5 * L[1]]]
regionFlags = [1.0]
domain = Domain.PlanarStraightLineGraphDomain(fileprefix=fileprefix,
vertices=vertices,
vertexFlags=vertexFlags,
segments=segments,
segmentFlags=segmentFlags,
regions=regions,
regionFlags=regionFlags)
#go ahead and add a boundary tags member
domain.boundaryTags = boundaryTags
return domain
def testGetInertia(self):
from proteus import Domain
from proteus import SpatialTools as st
from proteus.mprans import SpatialTools as mst
from proteus.mprans import BodyDynamics as bd
# parameters
domain2D = Domain.PlanarStraightLineGraphDomain()
pos = np.array([1.0, 1.0, 0.0])
dim = (0.3, 0.385)
dt, substeps = 0.001, 20
caisson = mst.Rectangle(domain=domain2D, dim=dim, coords=[pos[0], pos[1]])
caisson2D = bd.CaissonBody(shape=caisson, substeps=substeps)
mst.assembleDomain(domain2D)
c2d = caisson2D
c2d.nd = 2
mass = c2d.mass = 50.0
pivot = np.array([(caisson.vertices[0][0]+caisson.vertices[1][0])*0.5, caisson.vertices[0][1], 0.0])
d = dx, dy, dz = pivot - caisson.barycenter
# inertia transformation with different pivot
Ix = (old_div((dim[0]**2),12.)) + dy**2
Iy = (old_div((dim[1]**2),12.)) + dx**2
It = Ix + Iy
I = It*mass
I1 = c2d.getInertia(vec=(0.,0.,1.), pivot=pivot)
npt.assert_equal(I, I1)
def testOverturningModule(self):
from proteus import Domain
from proteus import SpatialTools as st
from proteus.mprans import SpatialTools as mst
from proteus.mprans import BodyDynamics as bd
# parameters
domain2D = Domain.PlanarStraightLineGraphDomain()
pos = np.array([1.0, 1.0, 0.0])
dim = (0.3, 0.385)
dt, substeps = 0.001, 20
caisson = mst.Rectangle(domain=domain2D, dim=dim, coords=[pos[0], pos[1]])
caisson2D = bd.CaissonBody(shape=caisson, substeps=substeps)
mst.assembleDomain(domain2D)
c2d = caisson2D
c2d.nd = 2
dt_sub = c2d.dt_sub = float(old_div(dt,substeps))
Krot = 200000.
Crot = 2000.
c2d.Krot, c2d.Crot = Krot, Crot
c2d.substeps, c2d.dt, c2d.ang_acc = substeps, dt, c2d.getAngularAcceleration()
c2d.setFriction(friction=True, m_static=0.0, m_dynamic=0.0, tolerance=0.000001, grainSize=0.02)
rotation, last_rotation = c2d.Shape.coords_system, c2d.Shape.coords_system
ang_vel, last_ang_vel = np.array([0., 0., 0.]), np.array([0., 0., 0.])
F = Fx, Fy, Fz = np.array([200., -300., 0.0])
M = np.array([0., 0., 10.0])
init_barycenter, last_position = pos, pos
c2d.F, c2d.M, c2d.init_barycenter, c2d.last_position = F, M, init_barycenter, last_position
eps = 10.**-30
mass = c2d.mass = 50.0
# moment and inertia transformations
pivot = c2d.pivot_friction = np.array([(caisson.vertices[0][0]+caisson.vertices[1][0])*0.5, caisson.vertices[0][1], 0.0])
barycenter = caisson.barycenter
distance = dx, dy, dz = pivot - barycenter
Mpivot = np.array([0., 0., dx*Fy-dy*Fx]) # Moment calculated in pivot
Mp = M - Mpivot # Moment transformation through the new pivot
Ix = (old_div((dim[0]**2),12.)) + dy**2
Iy = (old_div((dim[1]**2),12.)) + dx**2
It = Ix + Iy
I = It*mass
c2d.springs = True
# runge-kutta calculation
c2d.scheme = 'Runge_Kutta'
rz0, vrz0 = atan2(last_rotation[0,1], last_rotation[0,0]), last_ang_vel[2]
arz0 = old_div((Mp[2] - Crot*vrz0 - Krot*rz0), I)
rz, vrz, arz = bd.runge_kutta(rz0, vrz0, arz0, dt_sub, substeps, Mp[2], Krot, Crot, I, False)
# calculation with bodydynamics mopdule
c2d.cV_init = c2d.cV = c2d.cV_last = caisson.vertices
c2d.inertia = c2d.getInertia(pivot=pivot)
c2d.overturning_module(dt)
# test
ang_disp = rz - rz0
npt.assert_equal(c2d.ang_disp[2], ang_disp)
npt.assert_equal(c2d.ang_vel[2], vrz)
npt.assert_equal(c2d.ang_acc[2], arz)
def cylinder2d(height=1.0,
length=1.0,
radius=0.25,
center=[0.5, 0.5],
n_points_on_obstacle=10,
cross_section=circular_cross_section):
#enumerate the boundaries so we can supply integer flags for vertices and segments
boundaries = ['upstream', 'downstream', 'bottom', 'top', 'obstacle']
boundaryTags = dict([(key, i + 1) for (i, key) in enumerate(boundaries)])
#now work around the domain from (0.0,0.0) going counterclockwise building vertices and segments (and flags)
vertices = [[0.0, 0.0], [length, 0.0], [length, height], [0.0, height]]
vertexFlags = [
boundaryTags['bottom'], boundaryTags['bottom'], boundaryTags['top'],
boundaryTags['top']
]
segments = [[0, 1], [1, 2], [2, 3], [3, 0]]
segmentFlags = [
boundaryTags['bottom'], boundaryTags['downstream'],
boundaryTags['top'], boundaryTags['upstream']
]
#now do the vertices and segments on the cylinder
theta = 0.0
pb = cross_section(center, radius, theta)
vertices.append([pb[0], pb[1]])
vertexFlags.append(boundaryTags['obstacle'])
for gb in range(1, n_points_on_obstacle):
theta = float(gb) / float(n_points_on_obstacle) * 2.0 * math.pi
pb = cross_section(center, radius, theta)
vertices.append([pb[0], pb[1]])
vertexFlags.append(boundaryTags['obstacle'])
nv = len(vertices)
segments.append((nv - 2, nv - 1))
segmentFlags.append(boundaryTags['obstacle'])
segments.append((nv - 1, nv - n_points_on_obstacle))
segmentFlags.append(boundaryTags['obstacle'])
#done with vertices and segments
#holes
holes = [center]
#regions (just pick a point inside to indicate the flow region)
regions = [[
vertices[0][0] + length * 1.0e-8, vertices[0][1] + length * 1.0e-8
]]
regionFlags = [1]
#construct domain object
domain = Domain.PlanarStraightLineGraphDomain(vertices=vertices,
vertexFlags=vertexFlags,
segments=segments,
segmentFlags=segmentFlags,
holes=holes,
regions=regions,
regionFlags=regionFlags)
#go ahead and add a boundary tags member
domain.boundaryTags = boundaryTags
return domain
def testStoreLastValues(self):
from proteus import Domain
from proteus.mprans import SpatialTools as st
from proteus.mprans import BodyDynamics as bd
domain = Domain.PlanarStraightLineGraphDomain()
pos = np.array([1.0, 1.0, 0.0])
rot = np.array([ [1.,0.,0.], [0.,1.,0.], [0.,0.,1.] ])
dim=(0.3, 0.385)
caisson = st.Rectangle(domain, dim=dim, coords=[pos[0], pos[1]])
caisson2D = bd.RigidBody(shape=caisson)
st.assembleDomain(domain)
c2d = caisson2D
nd = 2
anglez = radians(5.0)
rotz = np.array([ [ cos(anglez), sin(anglez), 0.0 ],
[ -sin(anglez), cos(anglez), 0.0 ],
[ 0.0, 0.0, 1.0 ] ])
c2d.calculate_init()
# Imposing values on rigid body's parameters
c2d.position = np.array([2.0, 3.0, 0.0])
c2d.velocity = np.array([0.5, -0.3, 0.0])
c2d.acceleration = np.array([0.1, 0.2, 0.0])
c2d.rotation = rotz
c2d.rotation_euler = bd.getEulerAngles(rotz)
c2d.ang_disp = np.array([0.0, 0.0, 0.001])
c2d.ang_vel = np.array([0.0, 0.0, -0.003])
c2d.ang_acc = np.array([0.0, 0.0, 0.005])
c2d.F = np.array([100.0, -300.0, 0.0])
c2d.M = np.array([0.0, 0.0, 50.0])
c2d.pivot = c2d.barycenter
c2d.ux = 0.5
c2d.uy = 0.05
c2d.uz = 0.0
c2d._store_last_values()
npt.assert_equal(c2d.position, c2d.last_position)
npt.assert_equal(c2d.velocity, c2d.last_velocity)
npt.assert_equal(c2d.acceleration, c2d.last_acceleration)
npt.assert_equal(c2d.rotation, c2d.last_rotation)
npt.assert_equal(c2d.rotation_euler, c2d.last_rotation_euler)
npt.assert_equal(c2d.ang_disp, c2d.last_ang_disp)
npt.assert_equal(c2d.ang_vel, c2d.last_ang_vel)
npt.assert_equal(c2d.ang_acc, c2d.last_ang_acc)
npt.assert_equal(c2d.F, c2d.last_F)
npt.assert_equal(c2d.M, c2d.last_M)
npt.assert_equal(c2d.pivot, c2d.last_pivot)
npt.assert_equal(c2d.ux, c2d.last_ux)
npt.assert_equal(c2d.uy, c2d.last_uy)
npt.assert_equal(c2d.uz, c2d.last_uz)
def build_PSLG():
"""
build PlanarStraightLineGraph and return
"""
from proteus import Domain
v, s, vf, sf, btags = build_vertices_and_segments()
domain = Domain.PlanarStraightLineGraphDomain(vertices=v,
segments=s,
vertexFlags=vf,
segmentFlags=sf)
domain.boundaryTags = btags
return domain
def testGetDisplacement(self):
from proteus import Domain
from proteus import SpatialTools as st
from proteus.mprans import SpatialTools as mst
from proteus.mprans import BodyDynamics as bd
# parameters
domain2D = Domain.PlanarStraightLineGraphDomain()
pos = np.array([1.0, 1.0, 0.0])
dim = (0.3, 0.385)
caisson = mst.Rectangle(domain=domain2D,
dim=dim,
coords=[pos[0], pos[1]])
caisson2D = bd.RigidBody(shape=caisson)
mst.assembleDomain(domain2D)
c2d = caisson2D
c2d.nd = 2
Ix = ((dim[0]**2) / 12.)
Iy = ((dim[1]**2) / 12.)
It = Ix + Iy
mass = 50.0
c2d.mass, c2d.It = mass, It
Kx, Ky, Kz = K = [200000., 250000., 0.0]
Cx, Cy, Cz = C = [2000., 4000., 0.0]
c2d.Kx, c2d.Ky, c2d.Kz, c2d.Cx, c2d.Cy, c2d.Cz = Kx, Ky, Kz, Cx, Cy, Cz
init_barycenter, last_position, last_velocity = pos, pos * 2.0, np.array(
[0.05, 0.07, 0.0])
c2d.init_barycenter, c2d.last_position, c2d.last_velocity = init_barycenter, last_position, last_velocity
Fx, Fy, Fz = F = np.array([200., 300., 0.0])
dt, substeps = 0.001, 50
dt_sub = c2d.dt_sub = float(dt / substeps)
c2d.F, c2d.substeps, c2d.dt, c2d.acceleration = F, substeps, dt, c2d.getAcceleration(
)
# runge-kutta calculation
c2d.scheme = 'Runge_Kutta'
u0 = ux0, uy0, uz0 = last_position - init_barycenter
v0 = vx0, vy0, vz0 = last_velocity
a0 = ax0, ay0, az0 = (F - C * v0 - K * u0) / mass
for ii in range(substeps):
ux, vx, ax = bd.runge_kutta(ux0, vx0, ax0, dt_sub, substeps, Fx,
Kx, Cx, mass, False)
uy, vy, ay = bd.runge_kutta(uy0, vy0, ay0, dt_sub, substeps, Fy,
Ky, Cy, mass, False)
uz, vz, az = bd.runge_kutta(uz0, vz0, az0, dt_sub, substeps, Fz,
Kz, Cz, mass, False)
h = hx, hy, hz = [ux - ux0, uy - uy0, uz - uz0]
c2d.h = c2d.getDisplacement(dt)
npt.assert_equal(c2d.h, h)
def testStep(self):
from proteus import Domain
from proteus import SpatialTools as st
from proteus.mprans import SpatialTools as mst
from proteus.mprans import BodyDynamics as bd
# parameters
domain2D = Domain.PlanarStraightLineGraphDomain()
pos = np.array([1.0, 1.0, 0.0])
dim = (0.3, 0.385)
caisson = mst.Rectangle(domain=domain2D,
dim=dim,
coords=[pos[0], pos[1]])
caisson2D = bd.RigidBody(shape=caisson)
mst.assembleDomain(domain2D)
c2d = caisson2D
nd = c2d.nd = 2
Ix = ((dim[0]**2) / 12.)
Iy = ((dim[1]**2) / 12.)
It = Ix + Iy
mass = 50.0
I = mass * It
c2d.mass, c2d.It = mass, It
init_barycenter, last_position, last_velocity, last_rotation, last_ang_vel = pos, pos * 2.0, np.array(
[0.05, 0.07,
0.0]), np.array([0.0, 0.0, 0.0001]), np.array([0., 0., 0.0000002])
c2d.init_barycenter, c2d.last_position, c2d.last_velocity, c2d.last_rotation, c2d.last_ang_vel = init_barycenter, last_position, last_velocity, last_rotation, last_ang_vel
F = Fx, Fy, Fz = np.array([200., 300., 0.0])
M = Mx, My, Mz = np.array([0., 0., 50.0])
dt, substeps = 0.001, 20
dt_sub = c2d.dt_sub = float(dt / substeps)
c2d.F, c2d.substeps, c2d.dt, c2d.acceleration = F, substeps, dt, c2d.getAcceleration(
)
c2d.InputMotion = False
c2d.scheme = 'Forward_Euler'
h, tra_velocity = bd.forward_euler(last_position, last_velocity,
F / mass, dt)
rot, rot_velocity = bd.forward_euler(last_rotation, last_ang_vel,
M / I, dt)
if rot[2] < 0.0: rot[2] = -rot[2]
# 2d calculation
caisson.translate(h[:nd]), caisson.rotate(rot[2])
posTra1, rot1 = caisson.barycenter, caisson.coords_system
# 2d from bodydynamics
caisson.translate(-h[:nd]), caisson.rotate(-rot[2])
c2d.step(dt)
posTra2, rot2 = c2d.position, c2d.rotation[:nd, :nd]
npt.assert_allclose(posTra1, posTra2, atol=1e-10)
npt.assert_allclose(rot1, rot2, atol=1e-10)
def test_gmsh_generation_2D(self):
domain = Domain.PlanarStraightLineGraphDomain()
domain.vertices = [[0., 0., 0.], [5., 0., 0.], [5., 5., 0.],
[0., 5., 0.]]
domain.segments = [[0, 1], [1, 2], [2, 3], [3, 0]]
domain.facets = [[[0, 1, 2, 3]]]
domain.writeGeo('gmsh_mesh_test_2D', he_max=0.1)
gmsh_cmd = "gmsh {0:s} -v 10 -2 -o {1:s} -format msh".format(
domain.geofile + ".geo", domain.geofile + ".msh")
check_call(gmsh_cmd, shell=True)
MeshTools.msh2simplex(domain.geofile, nd=2)
with open('gmsh_mesh_test_2D.node', 'r') as nodefile:
npt.assert_equal(nodefile.readline(), '3425 2 0 1\n')
with open('gmsh_mesh_test_2D.edge', 'r') as edgefile:
npt.assert_equal(edgefile.readline(), '10072 1\n')
with open('gmsh_mesh_test_2D.ele', 'r') as elefile:
npt.assert_equal(elefile.readline(), '6648 3 1\n')
def testGetAngularAcceleration(self):
from proteus import Domain
from proteus.mprans import SpatialTools as st
from proteus.mprans import BodyDynamics as bd
domain = Domain.PlanarStraightLineGraphDomain()
pos = np.array([1.0, 1.0, 0.0])
rot = np.array([ [1.,0.,0.], [0.,1.,0.], [0.,0.,1.] ])
dim=(0.3, 0.385)
caisson = st.Rectangle(domain, dim=dim, coords=[pos[0], pos[1]])
caisson2D = bd.RigidBody(shape=caisson)
st.assembleDomain(domain)
c2d = caisson2D
F = np.array([100.0, -200.0, 10.0])
mass = 150.0
acceleration = old_div(F,mass)
c2d.F = F
c2d.mass = mass
c2d.acceleration = c2d.getAcceleration()
npt.assert_equal(c2d.acceleration, acceleration)
def testCalculateInit(self):
from proteus import Domain
from proteus.mprans import SpatialTools as st
from proteus.mprans import BodyDynamics as bd
domain = Domain.PlanarStraightLineGraphDomain()
pos = np.array([1.0, 1.0, 0.0])
rot = np.array([ [1.,0.,0.], [0.,1.,0.], [0.,0.,1.] ])
dim=(0.3, 0.385)
caisson = st.Rectangle(domain, dim=dim, coords=[pos[0], pos[1]])
caisson2D = bd.RigidBody(shape=caisson)
st.assembleDomain(domain)
c2d = caisson2D
nd = 2
angle = bd.getEulerAngles(rot)
c2d.calculate_init()
npt.assert_equal(c2d.position, pos)
npt.assert_equal(c2d.last_position, pos)
npt.assert_equal(c2d.rotation, rot)
npt.assert_equal(c2d.last_rotation, rot)
npt.assert_equal(c2d.rotation_euler, angle)
npt.assert_equal(c2d.last_rotation_euler, angle)
rho_0 = 998.2
nu_0 = 1.004e-6
# Air
rho_1 = 1.205
nu_1 = 1.500e-5
g = [0., -9.81, 0.]
# ****************** #
# ***** GAUGES ***** #
# ****************** #
# *************************** #
# ***** DOMAIN AND MESH ***** #
# ****************** #******* #
domain = Domain.PlanarStraightLineGraphDomain()
# ----- TANK ----- #
boundaryOrientations = {
'y-': np.array([0., -1., 0.]),
'x+': np.array([+1., 0., 0.]),
'y+': np.array([0., +1., 0.]),
'x-': np.array([-1., 0., 0.]),
'airvent': np.array([-1., 0., 0.]),
}
boundaryTags = {
'y-': 1,
'x+': 2,
'y+': 3,
'x-': 4,
'airvent': 5,
boundaryTags['bottom'],
boundaryTags['top'],
boundaryTags['top']]
segments=[[0,1],
[1,2],
[2,3],
[3,0]]
segmentFlags=[boundaryTags['bottom'],
boundaryTags['right'],
boundaryTags['top'],
boundaryTags['left']]
regions=[[1.2 ,0.6]]
regionFlags=[1]
domain = Domain.PlanarStraightLineGraphDomain(vertices=vertices,
vertexFlags=vertexFlags,
segments=segments,
segmentFlags=segmentFlags,
regions=regions,
regionFlags=regionFlags)
#go ahead and add a boundary tags member
domain.boundaryTags = boundaryTags
domain.writePoly("mesh")
domain.writePLY("mesh")
domain.writeAsymptote("mesh")
triangleOptions="VApq30Dena%8.8f" % ((he**2)/2.0,)
logEvent("""Mesh generated using: tetgen -%s %s""" % (triangleOptions,domain.polyfile+".poly"))
# Time stepping
T=3.0
dt_fixed = 0.01
dt_init = min(0.1*dt_fixed,0.001)
runCFL=0.9
quad_order = 2 * pDegree_ncls + 1
# parallel partitioning info #
from proteus import MeshTools
partitioningType = MeshTools.MeshParallelPartitioningTypes.node
# Create mesh #
nn = nnx = (2**ct.refinement) * 10 + 1
nny = nnx
nnz = 1
he = 1.0 / (nnx - 1.0)
box = Domain.RectangularDomain(L=(1.0, 1.0), x=(0.0, 0.0), name="box")
box.writePoly("box")
if ct.unstructured:
domain = Domain.PlanarStraightLineGraphDomain(fileprefix="box")
domain.boundaryTags = box.boundaryTags
bt = domain.boundaryTags
triangleOptions = "pAq30Dena%8.8f" % (0.5 * he**2, )
else:
domain = box
# REDISTANCING #
redist_Newton = True
onlyVOF = False
# SMOOTHING FACTORS # (eps)
epsFactHeaviside = epsFactDirac = epsFact_vof = 1.5
epsFactRedistance = 0.33
epsFactDiffusion = 10.0
def symmetric2D(L= 1.0,
H = 1.0,
r = 0.5,
DX = 0.2):
boundaries = ['left', 'right', 'front', 'back', 'obstacle']
boundaryFlags=dict([(key,i+1) for i,key in enumerate(boundaries)])
left_nPoints = int(math.ceil((H-r)/DX))
top_nPoints = int(math.ceil(L/DX))
right_nPoints = int(math.ceil(H/DX))
bottom_nPoints = int(math.ceil((L-r)/DX))
DX_left = (H-r)/float(left_nPoints)
DX_top = L/float(top_nPoints)
DX_right = H/float(right_nPoints)
DX_bottom = (L-r)/float(bottom_nPoints)
vertices0 = [(0.0, r)]
vertexFlags0 = [boundaryFlags['obstacle']]
segments0 = []
segmentFlags0 = []
grain_centers = [(0.0,0.0)] #[(0.2,0.2)]
radius = r
# left
for i in range(1,left_nPoints):
vertices0.append((0.0, r+i*DX_left))
vertexFlags0.append(0)
# top
for i in range(0,top_nPoints+1):
vertices0.append((i*DX_top, H))
vertexFlags0.append(boundaryFlags['back'])
# right
for i in range(1, right_nPoints+1):
vertices0.append((L, H-i*DX_right))
vertexFlags0.append(boundaryFlags['right'])
# bottom
for i in range(1, bottom_nPoints):
vertices0.append((L-i*DX_bottom, 0.0))
vertexFlags0.append(0)
arclength= 0.5*math.pi*r
nPoints_cyl = int(math.ceil(arclength/DX))
#DX_cyl = arclength/float(nPoints_cyl)
# cyl
for i in range(nPoints_cyl):
vertices0.append((r*math.cos(float(i)/float(nPoints_cyl)*0.5*math.pi),r*math.sin(float(i)/float(nPoints_cyl)*0.5*math.pi)))
vertexFlags0.append(boundaryFlags['obstacle'])
for sN in range(len(vertices0)-1):
segments0.append([sN,sN+1])
if (vertices0[sN][0] == 0.0 and vertices0[sN+1][0] == 0.0):
segmentFlags0.append(0)
elif (vertices0[sN][0] == L and vertices0[sN+1][0] == L):
segmentFlags0.append(boundaryFlags['right'])
elif (vertices0[sN][1] == 0.0 and vertices0[sN+1][1] == 0.0):
segmentFlags0.append(0)
elif (vertices0[sN][1] == H and vertices0[sN+1][1] == H):
segmentFlags0.append(boundaryFlags['back'])
else:
segmentFlags0.append(boundaryFlags['obstacle'])
segments0.append([len(vertices0)-1,0])
segmentFlags0.append(boundaryFlags['obstacle'])
regions0=[[L-1.0e-8,
H-1.0e-8]]
regionFlags0=[0]
domain0 = Domain.PlanarStraightLineGraphDomain(vertices=vertices0,
vertexFlags=vertexFlags0,
segments=segments0,
segmentFlags=segmentFlags0,
holes=[],
regions=regions0,
regionFlags=regionFlags0)
section_name = "top_right"
domain0.writePoly(section_name)
triangleOptions = "pAq30.0Dena%f" % (.5*DX**2)
os.system("triangle " + section_name + ".poly -" + triangleOptions)
nodes = open(section_name + ".1.node", 'r')
edges = open(section_name + ".1.edge", 'r')
vertices = []
vertexFlags = []
segments = []
segmentFlags = []
a = nodes.readline().split()
nodeCount =int(a[0])
for i in range(1, nodeCount+1):
b= nodes.readline().split()
vertices.append((float(b[1]),float(b[2])))
if int(b[3])==1:
vertexFlags.append(0)
else:
vertexFlags.append(int(b[3]))
nodes.close()
a = edges.readline().split()
nodeCount =int(a[0])
for i in range(1, nodeCount+1):
b= edges.readline().split()
segments.append([int(b[1])-1,int(b[2])-1])
if int(b[3])==1:
segmentFlags.append(0)
else:
segmentFlags.append(int(b[3]))
edges.close()
groups=[]
vertices_hold = copy.copy(vertices)
for i,v in enumerate(vertices_hold):
groups.append([i])
if v[1]==0.0:
groups[i].append(i)
else:
vertices.append((v[0],-v[1]))
if vertexFlags[i] == boundaryFlags['back']:
vertexFlags.append(boundaryFlags['front'])
else:
vertexFlags.append(vertexFlags[i])
groups[i].append(len(vertices)-1)
segments_hold = copy.copy(segments)
for i,s in enumerate(segments_hold):
sN = [groups[s[0]][1], groups[s[1]][1]]
if sN not in segments:
segments.append(sN)
if segmentFlags[i]==boundaryFlags['back']:
segmentFlags.append(boundaryFlags['front'])
else:
segmentFlags.append(segmentFlags[i])
###
groups=[]
vertices_hold = copy.copy(vertices)
for i,v in enumerate(vertices_hold):
groups.append([i])
if v[0]==0.0:
groups[i].append(i)
else:
vertices.append((-v[0],v[1]))
if vertexFlags[i] == boundaryFlags['right']:
vertexFlags.append(boundaryFlags['left'])
else:
vertexFlags.append(vertexFlags[i])
groups[i].append(len(vertices)-1)
segments_hold = copy.copy(segments)
for i,s in enumerate(segments_hold):
sN = [groups[s[0]][1], groups[s[1]][1]]
if sN not in segments:
segments.append(sN)
if segmentFlags[i]==boundaryFlags['right']:
segmentFlags.append(boundaryFlags['left'])
else:
segmentFlags.append(segmentFlags[i])
###
vertices2=[]
for v in vertices:
vertices2.append((v[0]+L, v[1]+H))
domain = Domain.PlanarStraightLineGraphDomain(vertices=vertices2,
vertexFlags=vertexFlags,
segments=segments,
segmentFlags=segmentFlags,
holes=[(L,H)],
regions=regions0,
regionFlags=regionFlags0)
domain.boundaryFlags = boundaryFlags
return domain
def build_PSLG():
"""
build PlanarStraightLineGraph and return
"""
from proteus import Domain
v, s, vf, sf, btags = build_vertices_and_segments()
domain = Domain.PlanarStraightLineGraphDomain(vertices=v,
segments=s,
vertexFlags=vf,
segmentFlags=sf)
domain.boundaryTags = btags
return domain
if __name__ == "__main__":
from proteus import Domain
v, s, vf, sf, btags = build_vertices_and_segments()
domain = Domain.PlanarStraightLineGraphDomain(vertices=v,
segments=s,
vertexFlags=vf,
segmentFlags=sf)
fileprefix = 'jet_domain'
domain.writePoly(fileprefix)
domain.writeGeo(fileprefix)
generate_blockMeshDict_2d(width=1.0, filename='test_blockMeshDict_2d')
def cylinder2D(L=2.5, H=0.41, C=(0.2, 0.2), r=0.05, points_on_grain=10):
"""
makes the cylinder2d domain.
"""
domain_vertices = [(0.0, 0.0), (0.0, H), (L, H), (L, 0.0)]
vertices = []
vertexFlags = []
segments = []
segmentFlags = []
grain_centers = [C] #[(0.2,0.2)]
radius = r
boundaries = ['left', 'right', 'front', 'back', 'obstacle']
boundaryFlags = dict([(key, i + 1) for i, key in enumerate(boundaries)])
for v, p in enumerate(domain_vertices):
if (p[0] == 0.0):
vertices.append([p[0], p[1]])
vertexFlags.append(boundaryFlags['left'])
elif (p[0] == L):
vertices.append([p[0], p[1]])
vertexFlags.append(boundaryFlags['right'])
elif (p[1] == 0.0):
vertices.append([p[0], p[1]])
vertexFlags.append(boundaryFlags['front'])
elif (p[1] == H):
vertexFlags.append(boundaryFlags['back'])
vertices.append([p[0], p[1]])
else:
exit
for sN in range(len(domain_vertices) - 1):
segments.append([sN, sN + 1])
if (domain_vertices[sN][0] == 0.0
and domain_vertices[sN + 1][0] == 0.0):
segmentFlags.append(boundaryFlags['left'])
elif (domain_vertices[sN][0] == L and domain_vertices[sN + 1][0] == L):
segmentFlags.append(boundaryFlags['right'])
elif (domain_vertices[sN][1] == 0.0
and domain_vertices[sN + 1][1] == 0.0):
segmentFlags.append(boundaryFlags['front'])
elif (domain_vertices[sN][1] == H and domain_vertices[sN + 1][1] == H):
segmentFlags.append(boundaryFlags['back'])
else:
exit
segments.append([len(domain_vertices) - 1, 0])
if (domain_vertices[segments[-1][0]][0] == 0.0
and domain_vertices[segments[-1][1]][0] == 0.0):
segmentFlags.append(boundaryFlags['left'])
if (domain_vertices[segments[-1][0]][0] == L
and domain_vertices[segments[-1][1]][0] == L):
segmentFlags.append(boundaryFlags['right'])
if (domain_vertices[segments[-1][0]][1] == 0.0
and domain_vertices[segments[-1][1]][1] == 0.0):
segmentFlags.append(boundaryFlags['front'])
if (domain_vertices[segments[-1][0]][1] == H
and domain_vertices[segments[-1][1]][1] == H):
segmentFlags.append(boundaryFlags['back'])
vStart = len(domain_vertices)
sStart = len(segments)
for g, c in enumerate(grain_centers):
for gb in range(points_on_grain):
vertices.append([
c[0] + radius *
math.sin(float(gb) / float(points_on_grain) * 2.0 * math.pi),
c[1] + radius *
math.cos(float(gb) / float(points_on_grain) * 2.0 * math.pi)
])
vertexFlags.append(boundaryFlags['obstacle'])
for rb in range(len(grain_centers)):
for gb in range(points_on_grain - 1):
segments.append([
sStart + points_on_grain * rb + gb,
sStart + points_on_grain * rb + gb + 1
])
segmentFlags.append(boundaryFlags['obstacle'])
segments.append([
sStart + points_on_grain * rb + points_on_grain - 1,
sStart + points_on_grain * rb
])
segmentFlags.append(boundaryFlags['obstacle'])
regions = [[vertices[0][0] + 1.0e-8, vertices[0][1] + 1.0e-8]]
regionFlags = [1]
domain = Domain.PlanarStraightLineGraphDomain(vertices=vertices,
vertexFlags=vertexFlags,
segments=segments,
segmentFlags=segmentFlags,
holes=grain_centers,
regions=regions,
regionFlags=regionFlags)
#go ahead and add a boundary tags member
domain.boundaryFlags = boundaryFlags
return domain
def beach_erosion_board_2d(domainHeightPad=2.0,
inflowLength=2.0,
beachLength=4.48,
beachSlope=0.1,
h_c=0.054,
h_s=0.081,
s=3.0,
B=0.0896,
s_2=-0.2,
backStepFraction=0.25,
outflowLength=0.5):
"""
generate waves and runup on WES beach erosion board embankment
units should be meters by default
z=0 beach slope
(1/10) 1/s slope 1/s_2 slope
|--------|----------------|-----------|-------|-----------|-----|
0 x_bs x_be x_se x_ce x_bse L
x_bs = inflow pad (2 [m] default),
z(x) = 0, [0,x_bs]
x_be = x_bs + beachLength (4.48 [m])
z(x) = 0.0 + (x-x_bs)beachSlope, [x_bs,x_be]
x_se = x_be + (h_c + h_s)*s, h_c and h_s from Sitanggang Lynnett report
z(x) = (x-x_be)1/s + z(x_be), [x_be,x_se]
x_ce = x_se + B [m]
z(x) = z(x_se), [x_se,x_ce]
x_bse= x_ce + (h_c + h_s)*backStepFraction*s_2
z(x) = z(x_ce) + (x-x_ce)*1/s_2 [x_ce,x_bse]
x_L = x_bse + outflowLength [m]
z(x) = z(x_bse), [x_bse,L]
total domain height = z(x_se) + domainHeightPad
"""
#describe bathymetry as above
x_0 = 0.0
x_bs = x_0 + inflowLength
x_be = x_bs + beachLength
x_se = x_be + (h_c + h_s) * s
x_ce = x_se + B
x_bse = x_ce + (h_c + h_s) * backStepFraction * abs(s_2)
def bathymetry(x):
if x[0] <= x_bs: return 0.0
if x[0] <= x_be: return 0.0 + (x[0] - x_bs) * beachSlope
if x[0] <= x_se: return bathymetry([x_be]) + (x[0] - x_be) / s
if x[0] <= x_ce: return bathymetry([x_se])
if x[0] <= x_bse: return bathymetry([x_ce]) + (x[0] - x_ce) / s_2
return bathymetry([x_bse])
def bathymetryGrad(x):
if x[0] <= x_bs: return (0.0, )
if x[0] <= x_be: return (beachSlope, ) #beach slope
if x[0] <= x_se: return (1.0 / s, )
if x[0] <= x_ce: return (0.0, )
if x[0] <= x_bse: return (1. / s_2, )
return (0.0, )
x_L = x_bse + outflowLength
z_L = bathymetry([x_se]) + domainHeightPad
L = [x_L, z_L]
xpoints = [x_0, x_bs, x_be, x_se, x_ce, x_bse, x_L]
zpoints = [bathymetry([x]) for x in xpoints]
bathymetryPoints = [[x, z] for x, z in zip(xpoints, zpoints)]
backHeight = bathymetry([x_bse])
#have to assume points in correct order
#pad for inflow outflow
pSW = bathymetryPoints[0]
pSE = bathymetryPoints[-1]
#now get top corners of domain
minY = 0.0
pNW = [pSW[0], minY + z_L]
pNE = [pSE[0], minY + z_L]
#check vertical coordinates
tmp = sorted(bathymetryPoints, cmp=lambda x, y: int(x[1] - y[1]))
assert minY <= tmp[0][
1], "found point below proposed block floor minY=%s tmp[0]= " % (
minY, tmp[0])
assert minY + z_L > tmp[-1][
1], "found point above proposed block ceiling maxnY=%s tmp[-1]= " % (
minY + z_L, tmp[-1])
vertices = [p for p in bathymetryPoints]
#start with NW corner and work way around
#left
vertices.insert(0, pNW)
#not needed if no pad vertices.insert(1,pSW)
#add midpoint to make sure some points are inflow labelled
#inflow is on bottom
#vertices.insert(2,[pSW[0]+0.5*inflowLength,pSW[1]])
#vertices.insert(3,[pSW[0]+inflowLength,pSW[1]])
#
#vertices.append([bathymetryPoints[-1][0]+outflowPad-0.5*outflowLength,bathymetryPoints[-1][1]])
#right
#vertices.append(pSE)
vertices.append(pNE)
nvertices = len(vertices)
segmentLabels = {
'left': 1,
'bottom': 2,
'right': 3,
'top': 4,
'inflow': 5,
'outflow': 6
}
segments = []
segmentFlags = []
segments.append([0, 1])
segmentFlags.append(segmentLabels['left'])
#segments.append([1,2])
#segmentFlags.append(segmentLabels['inflow'])
#segments.append([2,3])
#segmentFlags.append(segmentLabels['inflow'])
for i in range(1, nvertices - 1):
segments.append([i, i + 1])
segmentFlags.append(segmentLabels['bottom'])
#segments.append([nvertices-4,nvertices-3])
#segmentFlags.append(segmentLabels['outflow'])
#segments.append([nvertices-3,nvertices-2])
#segmentFlags.append(segmentLabels['outflow'])
segments.append([nvertices - 2, nvertices - 1])
segmentFlags.append(segmentLabels['right'])
segments.append([nvertices - 1, 0])
segmentFlags.append(segmentLabels['top'])
print vertices, "s", segments, "sF", segmentFlags
domain = Domain.PlanarStraightLineGraphDomain(vertices=vertices,
segments=segments,
segmentFlags=segmentFlags)
domain.backHeight = backHeight
domain.x_0 = x_0
domain.x_be = x_be
domain.x_bs = x_bs
domain.x_se = x_se
domain.x_ce = x_ce
domain.x_bse = x_bse
domain.inflowLength = inflowLength
domain.beachLength = beachLength
domain.s = s
domain.B = B
domain.s_2 = s_2
domain.h_c = h_c
domain.h_s = h_s
domain.bathymetry = bathymetry
domain.bathymetryGrad = bathymetryGrad
#go ahead and add a boundary tags member
domain.boundaryTags = segmentLabels
return domain
def symmetric2D(box=(1.0,0.41),
L= 0.15,
H = 0.15,
r = 0.05,
C = (0.15,0.15),
DX = 0.01,
refinement_length=0.5,
DX_coarse = 0.02):
boundaries = ['left', 'right', 'front', 'back', 'obstacle']
boundaryFlags=dict([(key,i+1) for i,key in enumerate(boundaries)])
left_nPoints = int(math.ceil(old_div((H-r),DX)))
top_nPoints = int(math.ceil(old_div(L,DX)))
right_nPoints = int(math.ceil(old_div(H,DX)))
bottom_nPoints = int(math.ceil(old_div((L-r),DX)))
DX_left = old_div((H-r),float(left_nPoints))
DX_top = old_div(L,float(top_nPoints))
DX_right = old_div(H,float(right_nPoints))
DX_bottom = old_div((L-r),float(bottom_nPoints))
vertices0 = [(0.0, r)]
vertexFlags0 = [boundaryFlags['obstacle']]
segments0 = []
segmentFlags0 = []
grain_centers = [(0.0,0.0)] #[(0.2,0.2)]
radius = r
# left
for i in range(1,left_nPoints):
vertices0.append((0.0, r+i*DX_left))
vertexFlags0.append(0)
# top
for i in range(0,top_nPoints+1):
vertices0.append((i*DX_top, H))
vertexFlags0.append(boundaryFlags['back'])
top_right=len(vertices0)-1
# right
for i in range(1, right_nPoints+1):
vertices0.append((L, H-i*DX_right))
vertexFlags0.append(boundaryFlags['right'])
# bottom
for i in range(1, bottom_nPoints):
vertices0.append((L-i*DX_bottom, 0.0))
vertexFlags0.append(0)
arclength= 0.5*math.pi*r
nPoints_cyl = int(math.ceil(old_div(arclength,DX)))
#DX_cyl = arclength/float(nPoints_cyl)
nPoints_cyl = max([nPoints_cyl,10])
# cyl
for i in range(nPoints_cyl):
vertices0.append((r*math.cos(float(i)/float(nPoints_cyl)*0.5*math.pi),r*math.sin(float(i)/float(nPoints_cyl)*0.5*math.pi)))
vertexFlags0.append(boundaryFlags['obstacle'])
for sN in range(len(vertices0)-1):
segments0.append([sN,sN+1])
if (vertices0[sN][0] == 0.0 and vertices0[sN+1][0] == 0.0):
segmentFlags0.append(0)
elif (vertices0[sN][0] == L and vertices0[sN+1][0] == L):
segmentFlags0.append(boundaryFlags['right'])
elif (vertices0[sN][1] == 0.0 and vertices0[sN+1][1] == 0.0):
segmentFlags0.append(0)
elif (vertices0[sN][1] == H and vertices0[sN+1][1] == H):
segmentFlags0.append(boundaryFlags['back'])
else:
segmentFlags0.append(boundaryFlags['obstacle'])
segments0.append([len(vertices0)-1,0])
segmentFlags0.append(boundaryFlags['obstacle'])
regions0=[[L-1.0e-8,
H-1.0e-8]]
regionFlags0=[0]
domain0 = Domain.PlanarStraightLineGraphDomain(vertices=vertices0,
vertexFlags=vertexFlags0,
segments=segments0,
segmentFlags=segmentFlags0,
holes=[],
regions=regions0,
regionFlags=regionFlags0)
section_name = "top_right"
domain0.writePoly(section_name)
triangleOptions = "pAq30.0Dena%f" % (.5*DX**2)
os.system("triangle " + section_name + ".poly -" + triangleOptions)
nodes = open(section_name + ".1.node", 'r')
edges = open(section_name + ".1.edge", 'r')
vertices = []
vertexFlags = []
segments = []
segmentFlags = []
a = nodes.readline().split()
nodeCount =int(a[0])
for i in range(1, nodeCount+1):
b= nodes.readline().split()
vertices.append((float(b[1]),float(b[2])))
if int(b[3])==1:
vertexFlags.append(0)
else:
vertexFlags.append(int(b[3]))
nodes.close()
a = edges.readline().split()
nodeCount =int(a[0])
for i in range(1, nodeCount+1):
b= edges.readline().split()
segments.append([int(b[1])-1,int(b[2])-1])
if int(b[3])==1:
segmentFlags.append(0)
else:
segmentFlags.append(int(b[3]))
edges.close()
groups=[]
vertices_hold = copy.copy(vertices)
for i,v in enumerate(vertices_hold):
groups.append([i])
if v[1]==0.0:
groups[i].append(i)
else:
vertices.append((v[0],-v[1]))
if vertexFlags[i] == boundaryFlags['back']:
vertexFlags.append(boundaryFlags['front'])
else:
vertexFlags.append(vertexFlags[i])
groups[i].append(len(vertices)-1)
segments_hold = copy.copy(segments)
for i,s in enumerate(segments_hold):
sN = [groups[s[0]][1], groups[s[1]][1]]
if sN not in segments:
segments.append(sN)
if segmentFlags[i]==boundaryFlags['back']:
segmentFlags.append(boundaryFlags['front'])
else:
segmentFlags.append(segmentFlags[i])
###
groups_hold = copy.copy(groups)
groups=[]
vertices_hold = copy.copy(vertices)
for i,v in enumerate(vertices_hold):
groups.append([i])
if v[0]==0.0:
groups[i].append(i)
else:
vertices.append((-v[0],v[1]))
if vertexFlags[i] == boundaryFlags['right']:
vertexFlags.append(boundaryFlags['left'])
else:
vertexFlags.append(vertexFlags[i])
groups[i].append(len(vertices)-1)
segments_hold = copy.copy(segments)
for i,s in enumerate(segments_hold):
sN = [groups[s[0]][1], groups[s[1]][1]]
if sN not in segments:
segments.append(sN)
if segmentFlags[i]==boundaryFlags['right']:
segmentFlags.append(boundaryFlags['left'])
else:
segmentFlags.append(segmentFlags[i])
###
vertices2=[]
for v in vertices:
vertices2.append((v[0]+C[0], v[1]+C[1]))
for i,v in enumerate(vertexFlags):
if v == boundaryFlags['back']:
vertexFlags[i] = 0
elif v == boundaryFlags['right']:
if vertices2[i][1]<1.0e-8:
vertexFlags[i]=boundaryFlags['front']
else:
vertexFlags[i] = 0
for i,s in enumerate(segmentFlags):
if s == boundaryFlags['back']:
segmentFlags[i] = 0
elif s == boundaryFlags['right']:
segmentFlags[i] = 0
v =len(vertices2)
vertices2.append((0.0, box[1]))
vertexFlags.append(boundaryFlags['left'])
vertices2.append((refinement_length, box[1]))
vertexFlags.append(boundaryFlags['back'])
vertices2.append((box[0], box[1]))
vertexFlags.append(boundaryFlags['right'])
vertices2.append((box[0], 0.0))
vertexFlags.append(boundaryFlags['right'])
vertices2.append((refinement_length, 0.0))
vertexFlags.append(boundaryFlags['front'])
segments.append([groups[top_right][1], v])
segmentFlags.append(boundaryFlags['left'])
segments.append([v, v+1])
segmentFlags.append(boundaryFlags['back'])
segments.append([v+1, v+2])
segmentFlags.append(boundaryFlags['back'])
segments.append([v+2, v+3])
segmentFlags.append(boundaryFlags['right'])
segments.append([v+3, v+4])
segmentFlags.append(boundaryFlags['front'])
segments.append([v+4,groups_hold[top_right][1]])
segmentFlags.append(boundaryFlags['front'])
segments.append([v+1,v+4])
segmentFlags.append(0)
regions0 = [[vertices2[v][0]+1.0e-8, vertices2[v][1]-1.0e-8],
[vertices2[v+2][0]-1.0e-8, vertices2[v+2][1]-1.0e-8]]
regionFlags0=[0,0]
regionConstraints = [0.5*DX**2, 0.5*DX_coarse**2]
domain = Domain.PlanarStraightLineGraphDomain(vertices=vertices2,
vertexFlags=vertexFlags,
segments=segments,
segmentFlags=segmentFlags,
holes=[C],
regions=regions0,
regionFlags=regionFlags0,
regionConstraints=regionConstraints)
domain.boundaryFlags = boundaryFlags
return domain
def testFrictionModule(self):
from proteus import Domain
from proteus import SpatialTools as st
from proteus.mprans import SpatialTools as mst
from proteus.mprans import BodyDynamics as bd
#########################
# 1st case #
#########################
# When sliding is true and caisson already experiences plastic displacements
# parameters
domain2D = Domain.PlanarStraightLineGraphDomain()
pos = np.array([1.0, 1.0, 0.0])
dim = (0.3, 0.385)
dt, substeps = 0.001, 20
caisson = mst.Rectangle(domain=domain2D, dim=dim, coords=[pos[0], pos[1]])
caisson2D = bd.CaissonBody(shape=caisson, substeps=substeps)
mst.assembleDomain(domain2D)
c2d = caisson2D
c2d.nd = 2
dt_sub = c2d.dt_sub = float(old_div(dt,substeps))
Ix = (old_div((dim[0]**2),12.))
Iy = (old_div((dim[1]**2),12.))
It = Ix + Iy
mass = 50.0
c2d.mass, c2d.It = mass, It
K = Kx, Ky, Kz = [200000., 250000., 0.0]
C = Cx, Cy, Cz = [2000., 4000., 0.0]
c2d.Kx, c2d.Ky, c2d.Kz, c2d.Cx, c2d.Cy, c2d.Cz = Kx, Ky, Kz, Cx, Cy, Cz
c2d.substeps, c2d.dt, c2d.acceleration = substeps, dt, c2d.getAcceleration()
m_static, m_dynamic = 0.6, 0.4
c2d.setFriction(friction=True, m_static=m_static, m_dynamic=m_dynamic, tolerance=0.000001, grainSize=0.02)
# sliding == True. dynamic sign and dynamic friction
F = Fx, Fy, Fz = np.array([200., -300., 0.0])
disp = np.array([0.001, 0.001, 0.0])
init_barycenter, last_position, last_velocity = pos, pos+disp, np.array([0.05, 0.07, 0.0])
c2d.last_uxEl = pos[0]+disp[0]-init_barycenter[0]
c2d.F, c2d.init_barycenter, c2d.last_position, c2d.last_velocity = F, init_barycenter, last_position, last_velocity
eps = 10.**-30
sign_static, sign_dynamic = old_div(Fx,abs(Fx+eps)), old_div(last_velocity[0],abs(last_velocity[0]+eps))
c2d.sliding, sign, m = True, sign_dynamic, m_dynamic
# vertical calculation and frictional force
uy0, vy0 = (last_position[1] - init_barycenter[1]), last_velocity[1]
ay0 = old_div((Fy - Cy*vy0 - Ky*uy0), mass)
uy, vy, ay = bd.runge_kutta(uy0, vy0, ay0, dt_sub, substeps, Fy, Ky, Cy, mass, False)
Rx = -Kx*(last_position[0]-init_barycenter[0])
Ry = -Ky*uy
Ftan = -sign*abs(Ry)*m
if Ftan == 0.0:
Ftan = -sign*abs(Fy)*m
# runge-kutta calculation
c2d.scheme = 'Runge_Kutta'
ux0, uz0 = last_position[0] - init_barycenter[0], last_position[2] - init_barycenter[2]
vx0, vz0 = last_velocity[0], last_velocity[2]
Fh = Fx+Ftan
Kx, Cx = 0.0, 0.0
ax0, az0 = old_div((Fh - Cx*vx0 - Kx*ux0), mass) , old_div((Fz - Cz*vz0 - Kz*uz0), mass)
ux, vx, ax = bd.runge_kutta(ux0, vx0, ax0, dt_sub, substeps, Fh, Kx, Cx, mass, True)
uz, vz, az = bd.runge_kutta(uz0, vz0, az0, dt_sub, substeps, Fz, Kz, Cz, mass, False)
# bodydynamics calculation
c2d.friction_module(dt)
# tests
npt.assert_equal(c2d.ux, ux)
EL1, PL1 = 0.0, 1.0 # elastic and plastic motion parameters
npt.assert_equal(c2d.EL, EL1)
npt.assert_equal(c2d.PL, PL1)
#########################
# 2nd case #
#########################
# When sliding is false but the caisson starts to experience sliding motion
# parameters
domain2D = Domain.PlanarStraightLineGraphDomain()
pos = np.array([1.0, 1.0, 0.0])
dim = (0.3, 0.385)
dt, substeps = 0.001, 20
caisson = mst.Rectangle(domain=domain2D, dim=dim, coords=[pos[0], pos[1]])
caisson2D = bd.CaissonBody(shape=caisson, substeps=substeps)
mst.assembleDomain(domain2D)
c2d = caisson2D
c2d.nd = 2
dt_sub = c2d.dt_sub = float(old_div(dt,substeps))
Ix = (old_div((dim[0]**2),12.))
Iy = (old_div((dim[1]**2),12.))
It = Ix + Iy
mass = 50.0
c2d.mass, c2d.It = mass, It
K = Kx, Ky, Kz = [200000., 250000., 0.0]
C = Cx, Cy, Cz = [2000., 4000., 0.0]
c2d.Kx, c2d.Ky, c2d.Kz, c2d.Cx, c2d.Cy, c2d.Cz = Kx, Ky, Kz, Cx, Cy, Cz
c2d.substeps, c2d.dt, c2d.acceleration = substeps, dt, c2d.getAcceleration()
m_static, m_dynamic = 0.6, 0.4
c2d.setFriction(friction=True, m_static=m_static, m_dynamic=m_dynamic, tolerance=0.000001, grainSize=0.02)
# sliding == False. static sign and static friction
F = Fx, Fy, Fz = np.array([200., -300., 0.0])
disp = np.array([0.001, 0.001, 0.0])
init_barycenter, last_position, last_velocity = pos, pos+disp, np.array([0.05, 0.07, 0.0])
c2d.last_uxEl = pos[0]+disp[0]-init_barycenter[0]
c2d.F, c2d.init_barycenter, c2d.last_position, c2d.last_velocity = F, init_barycenter, last_position, last_velocity
eps = 10.**-30
sign_static, sign_dynamic = old_div(Fx,abs(Fx+eps)), old_div(last_velocity[0],abs(last_velocity[0]+eps))
c2d.sliding, sign, m = False, sign_static, m_static
# vertical calculation and frictional force
uy0, vy0 = (last_position[1] - init_barycenter[1]), last_velocity[1]
ay0 = old_div((Fy - Cy*vy0 - Ky*uy0), mass)
uy, vy, ay = bd.runge_kutta(uy0, vy0, ay0, dt_sub, substeps, Fy, Ky, Cy, mass, False)
Rx = -Kx*(last_position[0]-init_barycenter[0])
Ry = -Ky*uy
Ftan = -sign*abs(Ry)*m
if Ftan == 0.0:
Ftan = -sign*abs(Fy)*m
# runge-kutta calculation
c2d.scheme = 'Runge_Kutta'
ux0, uz0 = last_position[0] - init_barycenter[0], last_position[2] - init_barycenter[2]
vx0, vz0 = last_velocity[0], last_velocity[2]
Fh = Fx+Ftan
Kx, Cx = 0.0, 0.0
ax0, az0 = old_div((Fh - Cx*vx0 - Kx*ux0), mass) , old_div((Fz - Cz*vz0 - Kz*uz0), mass)
ux, vx, ax = bd.runge_kutta(ux0, vx0, ax0, dt_sub, substeps, Fh, Kx, Cx, mass, True)
uz, vz, az = bd.runge_kutta(uz0, vz0, az0, dt_sub, substeps, Fz, Kz, Cz, mass, False)
# bodydynamics calculation
c2d.friction_module(dt)
# tests
npt.assert_equal(c2d.ux, ux)
EL1, PL1 = 0.0, 1.0 # elastic and plastic motion parameters
npt.assert_equal(c2d.EL, EL1)
npt.assert_equal(c2d.PL, PL1)
#########################
# 3rd case #
#########################
# When caisson experiences vibration motion
# parameters
domain2D = Domain.PlanarStraightLineGraphDomain()
pos = np.array([1.0, 1.0, 0.0])
dim = (0.3, 0.385)
dt, substeps = 0.001, 20
caisson = mst.Rectangle(domain=domain2D, dim=dim, coords=[pos[0], pos[1]])
caisson2D = bd.CaissonBody(shape=caisson, substeps=substeps)
mst.assembleDomain(domain2D)
c2d = caisson2D
c2d.nd = 2
dt_sub = c2d.dt_sub = float(old_div(dt,substeps))
Ix = (old_div((dim[0]**2),12.))
Iy = (old_div((dim[1]**2),12.))
It = Ix + Iy
mass = 50.0
c2d.mass, c2d.It = mass, It
K = Kx, Ky, Kz = [200000., 250000., 0.0]
C = Cx, Cy, Cz = [2000., 4000., 0.0]
c2d.Kx, c2d.Ky, c2d.Kz, c2d.Cx, c2d.Cy, c2d.Cz = Kx, Ky, Kz, Cx, Cy, Cz
c2d.substeps, c2d.dt, c2d.acceleration = substeps, dt, c2d.getAcceleration()
m_static, m_dynamic = 0.6, 0.4
c2d.setFriction(friction=True, m_static=m_static, m_dynamic=m_dynamic, tolerance=0.000001, grainSize=0.02)
# sliding == False. static sign and static friction. Kx and Cx different from 0!
F = Fx, Fy, Fz = np.array([200., -300., 0.0])
disp = np.array([0.00001, 0.00001, 0.0])
init_barycenter, last_position, last_velocity = pos, pos+disp, np.array([0.05, 0.07, 0.0])
c2d.last_uxEl = pos[0]+disp[0]-init_barycenter[0]
c2d.F, c2d.init_barycenter, c2d.last_position, c2d.last_velocity = F, init_barycenter, last_position, last_velocity
eps = 10.**-30
sign_static, sign_dynamic = old_div(Fx,abs(Fx+eps)), old_div(last_velocity[0],abs(last_velocity[0]+eps))
c2d.sliding, sign, m = False, sign_static, m_static
# vertical calculation and frictional force
uy0, vy0 = (last_position[1] - init_barycenter[1]), last_velocity[1]
ay0 = old_div((Fy - Cy*vy0 - Ky*uy0), mass)
uy, vy, ay = bd.runge_kutta(uy0, vy0, ay0, dt_sub, substeps, Fy, Ky, Cy, mass, False)
Rx = -Kx*(last_position[0]-init_barycenter[0])
Ry = -Ky*uy
Ftan = -sign*abs(Ry)*m
if Ftan == 0.0:
Ftan = -sign*abs(Fy)*m
# runge-kutta calculation
c2d.scheme = 'Runge_Kutta'
ux0, uz0 = last_position[0] - init_barycenter[0], last_position[2] - init_barycenter[2]
vx0, vz0 = last_velocity[0], last_velocity[2]
Fh = Fx
ax0, az0 = old_div((Fh - Cx*vx0 - Kx*ux0), mass) , old_div((Fz - Cz*vz0 - Kz*uz0), mass)
ux, vx, ax = bd.runge_kutta(ux0, vx0, ax0, dt_sub, substeps, Fh, Kx, Cx, mass, True)
uz, vz, az = bd.runge_kutta(uz0, vz0, az0, dt_sub, substeps, Fz, Kz, Cz, mass, False)
# bodydynamics calculation
c2d.friction_module(dt)
# tests
npt.assert_equal(c2d.ux, ux)
EL1, PL1 = 1.0, 0.0 # elastic and plastic motion parameters
npt.assert_equal(c2d.EL, EL1)
npt.assert_equal(c2d.PL, PL1)
def testGetInertia(self):
from proteus import Domain
from proteus import SpatialTools as st
from proteus.mprans import SpatialTools as mst
from proteus.mprans import BodyDynamics as bd
# 2d case
domain2D = Domain.PlanarStraightLineGraphDomain()
pos = np.array([1.0, 1.0, 0.0])
dim = (0.3, 0.385)
caisson = mst.Rectangle(domain=domain2D, dim=dim, coords=[pos[0], pos[1]])
caisson2D = bd.RigidBody(shape=caisson)
mst.assembleDomain(domain2D)
c2d = caisson2D
c2d.nd = 2
Ix = (old_div((dim[0]**2),12.))
Iy = (old_div((dim[1]**2),12.))
It = Ix + Iy
mass = 50.0
I1 = It*mass
c2d.mass = mass
c2d.It = It
I2 = c2d.getInertia()
npt.assert_equal(I1, I2)
# 3d case
pos, dim, caisson = [], [], []
domain3D = Domain.PiecewiseLinearComplexDomain()
pos = np.array([0.0, 0.0, 0.0])
dim = (0.3, 0.385, 0.4)
angle = radians(10.)
Ix = (old_div((dim[0]**2),12.))
Iy = (old_div((dim[1]**2),12.))
Iz = (old_div((dim[2]**2),12.))
It = np.array([ [Iz + Iy, 0.0, 0.0],
[0.0, Ix + Iz, 0.0],
[0.0, 0.0, Ix + Iy] ])
mass = 50.0
# rotational axis and versors
ax, ay, az = axis = np.array([1., 1., 1.])
mod = np.sqrt((ax**2)+(ay**2)+(az**2))
axis_ver = (old_div(axis,mod))
# shape
caisson = mst.Cuboid(domain=domain3D, dim=dim, coords=[pos[0], pos[1], pos[2]])
caisson.rotate(rot=angle, axis=axis)
coords_system = caisson.coords_system
caisson3D = bd.RigidBody(shape=caisson)
mst.assembleDomain(domain3D)
# rotational operator for inertia calculation on an arbitrary axis
rotx, roty, rotz = np.dot(axis_ver, np.linalg.inv(coords_system))
rot = np.array([ [(rotx**2), rotx*roty, rotx*rotz],
[roty*rotx, (roty**2), roty*rotz],
[rotz*rotx, rotz*roty, (rotz**2)] ])
#inertia = np.einsum('ij,ij->', mass*It, rot)
inertia = np.sum(mass*It*rot)
# testing from BodyDynamics
c3d = caisson3D
c3d.nd = 3
c3d.mass = mass
c3d.It = It
c3d.coords_system = coords_system
I = c3d.getInertia(vec=axis)
npt.assert_equal(I, inertia)
