def get_force(self):
"""
Build and return an object for mdeling the force (derived form the abstract class force)
"""
print("")
self.force = None
if self.force_name == "gravity" :
self.force = gr.Gravity( self.pset.size , self.pset.dim , Consts=float(self.force_const) )
print( " setup - force - Type: Gravity " )
print( " setup - force - G: %e " % float(self.force_const) )
elif self.force_name == "linear_spring" :
self.force = ls.LinearSpring( self.pset.size , self.pset.dim , Consts=self.force_const )
print( " setup - force - Type: Linear spring " )
print( " setup - force - K: %e " % float(self.force_const) )
elif self.force_name == "constant_force" :
fv = read_str_list( self.force_vector )
self.force = cf.ConstForce( self.pset.size , dim=self.pset.dim , u_force=fv )
print( " setup - force - Type: Constant " )
print( " setup - force - Vect: %e %e %e " % ( float(fv[0]) , float(fv[1]) , float(fv[2]) ) )
self.force.set_masses( self.pset.M )
return self.force
def build_animation(self):
self.steps = 6000
dt = 0.004
self.ip = 1
self.pset = ps.ParticlesSet(2, 3)
self.pset.M[:] = 1.0
self.pset.V[:] = 0.0
self.pset.X[0, :] = 0.0
self.pset.X[1, :] = 1.0 / np.sqrt(3)
ci = np.array([0])
cx = np.array([0.0, 0.0, 0.0])
costrs = csx.ConstrainedX(self.pset)
costrs.add_x_constraint(ci, cx)
self.t = np.zeros((self.steps))
self.x = np.zeros((self.steps, self.pset.dim))
self.xn = np.zeros((self.steps, self.pset.dim))
spring = ls.LinearSpring(self.pset.size, self.pset.dim, Consts=1.0)
damp = da.Damping(self.pset.size, self.pset.dim, Consts=0.5)
multi = mf.MultipleForce(self.pset.size)
multi.append_force(spring)
multi.append_force(damp)
multi.set_masses(self.pset.M)
self.odes = dict()
self.odes["Euler "] = els.EulerSolverConstrained(
multi, self.pset, dt, costrs)
self.odes["Runge Kutta"] = rks.RungeKuttaSolverConstrained(
multi, self.pset, dt, costrs)
self.odes["Leap Frog "] = lps.LeapfrogSolverConstrained(
multi, self.pset, dt, costrs)
self.odes["MidPoint "] = mps.MidpointSolverConstrained(
multi, self.pset, dt, costrs)
self.odes["Verlet "] = svs.StormerVerletSolverConstrained(
multi, self.pset, dt, costrs)
def build_animation(self):
self.steps = 6000
dt = 0.004
self.ip = 1
self.pset = ps.ParticlesSet(2, 3)
self.pset.M[:] = 1.0
self.pset.V[:] = 0.0
self.pset.X[0, :] = 0.0
self.pset.X[1, :] = 1.0 / np.sqrt(3)
ci = np.array([0])
cx = np.array([0.0, 0.0, 0.0])
costrs = csx.ConstrainedX(self.pset)
costrs.add_x_constraint(ci, cx)
self.t = np.zeros((self.steps))
self.x = np.zeros((self.steps, self.pset.dim))
self.xn = np.zeros((self.steps, self.pset.dim))
spring = ls.LinearSpring(self.pset.size, self.pset.dim, Consts=1.0)
spring.set_masses(self.pset.M)
self.odes = dict()
self.odes["Euler "] = asc.EulerSolverConstrained(
spring, self.pset, dt, costrs)
self.odes["Runge Kutta"] = rkc.RungeKuttaSolverConstrained(
spring, self.pset, dt, costrs)
self.odes["Leap Frog "] = lpc.LeapfrogSolverConstrained(
spring, self.pset, dt, costrs)
self.odes["MidPoint "] = mdc.MidpointSolverConstrained(
spring, self.pset, dt, costrs)
self.odes["Verlet "] = svc.StormerVerletSolverConstrained(
spring, self.pset, dt, costrs)
def springs():
"""
Springs demo
"""
dt = 0.02
steps = 1000000
G = 0.5
pset = ps.ParticlesSet(3, 3, label=True)
pset.label[0] = "1"
pset.label[1] = "2"
pset.label[2] = "3"
pset.X[:] = np.array([
[2.0, 4.0, 1.0], # 1
[-2.0, -2.0, 1.0], # 2
[3.0, -3.0, 2.0] # 3
])
pset.M[:] = np.array([[1.0], [1.0], [1.5]])
pset.V[:] = np.array([[0., 0., 0.], [0., 0, 0.], [0., 0, 0.]])
springs = ls.LinearSpring(pset.size, Consts=G)
constf = cf.ConstForce(pset.size, u_force=[0, 0, -1.5])
drag = dr.Drag(pset.size, Consts=0.2)
mlf = mf.MultipleForce(pset.size, 3)
mlf.append_force(springs)
#mlf.append_force( constf )
#mlf.append_force( drag )
pot = epe.ElasticPotentialEnergy(pset, springs)
ken = ke.KineticEnergy(pset, springs)
tot = te.TotalEnergy(ken, pot)
#
pot.update_measure()
ken.update_measure()
tot.update_measure()
#
#print( "Potential = %f " % pot.value() )
#print( "Kinetic = %f " % ken.value() )
#P = mm.MomentumParticles( pset , subset=np.array([1,2]) , model="part_by_part")
#
#P.update_measure()
#
#print( P.value() )
bound = rb.ReboundBoundary(bound=(-10, 10))
pset.set_boundary(bound)
mlf.set_masses(pset.M)
springs.set_masses(pset.M)
springs.update_force(pset)
mlf.update_force(pset)
#solver = rks.RungeKuttaSolver( springs , pset , dt )
solver = rks.RungeKuttaSolver(mlf, pset, dt)
pset.enable_log(True, log_max_size=1000)
a = aogl.AnimatedGl()
a.trajectory = True
a.trajectory_step = 1
a.ode_solver = solver
a.pset = pset
a.steps = steps
a.add_measure(ken)
a.add_measure(pot)
a.add_measure(tot)
a.build_animation()
a.start()
return