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 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 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 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(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 = ((dim[0]**2)/12.) + dy**2 Iy = ((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 = (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 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 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 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 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)
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)
dim = (dimx, dimy) coords = ctr VCG = dim[1] / 2. width = opts.width mass = opts.mass volume = float(dimx * dimy * width) density = float(mass / volume) inertia = opts.caisson_inertia / mass / width # --- Shape properties setup caisson = st.Rectangle(domain, dim=dim, coords=coords) xc1, yc1 = caisson.vertices[0][0], caisson.vertices[0][1] xc2, yc2 = caisson.vertices[1][0], caisson.vertices[1][1] # --- Body properties setup caisson2D = bd.RigidBody(shape=caisson, substeps=20) free_x = np.array(opts.free_x) free_r = np.array(opts.free_r) caisson2D.setMass(mass) caisson2D.setConstraints(free_x=free_x, free_r=free_r) rotation = np.radians(opts.rotation_angle) caisson.rotate(rotation) caisson2D.It = inertia caisson2D.setNumericalScheme(scheme=opts.scheme) caisson2D.setRecordValues(filename='caisson2D', all_values=True) ############################################################################################################################################################################################################## # Tank ######################################################################################################################################################################################################### tank = st.Tank2D(domain, tank_dim)
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)
width = opts.width # The 3rd dimension mass = opts.mass #kg volume = float(dimx * dimy * width) density = float(mass / volume) #kg/m3 I = mass * (dimx**2. + dimy**2.) / 12. # It=(dimx**2.+dimy**2.)/12. # --- Shape properties setup caisson = st.Rectangle(domain, dim=dim, coords=coords) caisson.vertices[0][0] = xc1 caisson.vertices[0][1] = yc1 caisson.vertices[1][0] = xc2 caisson.vertices[1][1] = yc2 # --- Body properties setup caisson2D = bd.CaissonBody(shape=caisson, substeps=20) free_x = (0.0, 0.0, 0.0) # Translational DOFs free_r = (0.0, 0.0, 0.0) # Rotational DOFs m_static = opts.m_static # Static friction m_dynamic = opts.m_dynamic # Dynamic friction if opts.movingDomain == True: free_x = (1.0, 1.0, 0.0) # Translational DOFs if opts.overturning == True: free_r = (0.0, 0.0, 1.0) # Rotational DOFs caisson2D.setMass(mass) caisson2D.setConstraints(free_x=free_x, free_r=free_r) caisson2D.setFriction(friction=opts.friction, m_static=m_static, m_dynamic=m_dynamic, tolerance=he / (float(10**6)), grainSize=opts.d50)
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(dt/substeps) Ix = ((dim[0]**2)/12.) Iy = ((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 = Fx/abs(Fx+eps), 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 = (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 = (Fh - Cx*vx0 - Kx*ux0) / mass , (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(dt/substeps) Ix = ((dim[0]**2)/12.) Iy = ((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 = Fx/abs(Fx+eps), 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 = (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 = (Fh - Cx*vx0 - Kx*ux0) / mass , (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(dt/substeps) Ix = ((dim[0]**2)/12.) Iy = ((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 = Fx/abs(Fx+eps), 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 = (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 = (Fh - Cx*vx0 - Kx*ux0) / mass , (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)
##################### Shape Geometry & Characteristics ############################### # --- Circle b = 2.0 * opts.radius h = 2.0 * opts.radius # --- Circle Setup circle = st.Circle(domain=domain, radius=opts.radius, coords=(0.5, opts.tank_dim[1] / 2), barycenter=(0.5, opts.tank_dim[1] / 2), nPoints=opts.nPoints) # --- Body properties setup circle2D = bd.RigidBody(shape=circle) circle2D.setMass(mass=opts.mass) I = (3.14 * (opts.radius**4) / 2.) * opts.mass circle2D.It = I / opts.mass / opts.width circle2D.setConstraints(free_x=opts.free_x, free_r=opts.free_r) circle2D.setNumericalScheme(scheme=opts.scheme) circle2D.inputMotion(InputMotion=opts.InputMotion, At=opts.At, Tt=opts.Tt) circle2D.setRecordValues(filename='circle2D', all_values=True) # --- Spring setup #circle2D.setSprings(springs=opts.springs, K=[opts.Kx, opts.Ky, 0.0, Krot], C=[opts.Cx, opts.Cy, 0.0, opts.Crot]) ################################ Turbulance ################################
coords = ctr VCG = dim[1]/2. width = opts.width mass = opts.mass volume = float(dimx*dimy*width) density = float(mass/volume) inertia = opts.paddle_inertia/mass/width # --- Shape properties setup paddle = st.Rectangle(domain, dim=dim, coords=coords) xc1, yc1 = paddle.vertices[0][0], paddle.vertices[0][1] xc2, yc2 = paddle.vertices[1][0], paddle.vertices[1][1] # --- Body properties setup paddle2D = bd.PaddleBody(shape=paddle, substeps=20) paddle2D.setConstraints(free_x=opts.free_x, free_r=opts.free_r) paddle2D.setRecordValues(filename='paddle2D', all_values=True) paddle2D.inputMotion(InputMotion=opts.InputMotion, At=opts.stroke*np.array(opts.free_x), Tt=opts.period*np.array(opts.free_x), rampStart=rampS, rampEnd=rampE, Tend=Tpaddle) ############################################################################################################################################################################################################## # Tank ######################################################################################################################################################################################################### obstacle = [ [ [9.21,0.], [9.64,0.216], [9.84,0.216],