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)