def create_solver(self):
"""Create Solver with min. time step from CFL and viscous step."""
kernel = CubicSpline(dim=3)
integrator = EPECIntegrator(fluid=WCSPHStep(),
walls=WCSPHStep(),
ellipsoid=RK2StepRigidBody())
h = self.hdx * self.dx
dt_cfl = 0.4 * h / (1.1 * self.co)
dt_viscous = 0.125 * h**2 / self.nu
dt = min(dt_viscous, dt_cfl)
print("dt_cfl: %s" % dt_cfl)
print("dt_viscous: %s" % dt_viscous)
print("DT: %s" % dt)
tf = 12
solver = Solver(
kernel=kernel,
dim=3,
integrator=integrator,
dt=dt,
tf=tf,
adaptive_timestep=False,
)
return solver
def create_solver(self):
kernel = WendlandQuintic(dim=dim)
integrator = EPECIntegrator(fluid=WCSPHStep(),
obstacle=RK2StepRigidBody(),
boundary=WCSPHStep())
solver = Solver(kernel=kernel, dim=dim, integrator=integrator,
tf=tf, dt=dt, adaptive_timestep=True, n_damp=0)
return solver
def create_solver(self):
kernel = CubicSpline(dim=2)
integrator = EPECIntegrator(fluid=WCSPHStep(), wall=WCSPHStep())
dt = 5e-4
tf = 4.0
solver = Solver(kernel=kernel,
dim=2,
integrator=integrator,
dt=dt,
tf=tf)
return solver
def create_solver(self):
# Create the kernel
#kernel = Gaussian(dim=3)
kernel = CubicSpline(dim=3)
#kernel = QuinticSpline(dim=3)
integrator = PECIntegrator(tahini=WCSPHStep(), spoon=WCSPHStep())
# Create a solver.
solver = Solver(kernel=kernel, dim=3, integrator=integrator,
tf=tf, dt=dt,
adaptive_timestep=False
)
return solver
def create_solver(self):
print(self.gamma_n)
print(self.dt)
kernel = CubicSpline(dim=dim)
# integrator = EPECIntegrator(ball=RK2StepRigidBody())
integrator = EPECIntegrator(wall=WCSPHStep(),
temp_wall=WCSPHStep(),
fluid=WCSPHStep(),
ball=RK2StepRigidBody())
solver = Solver(kernel=kernel,
dim=dim,
integrator=integrator,
dt=self.dt,
tf=tf,
adaptive_timestep=False)
return solver
def create_solver(self):
kernel = CubicSpline(dim=2)
integrator = EPECIntegrator(fluid=WCSPHStep(),
tank=WCSPHStep(),
cube=RK2StepRigidBody())
dt = 0.125 * self.dx * self.hdx / (self.co * 1.1) / 2.
print("DT: %s" % dt)
tf = 0.5
solver = Solver(kernel=kernel,
dim=2,
integrator=integrator,
dt=dt,
tf=tf,
adaptive_timestep=False)
return solver
def create_solver(self):
kernel = CubicSpline(dim=2)
integrator = EPECIntegrator(fluid=WCSPHStep(), cube=RK2StepRigidBody(),
tank=WCSPHStep())
dt = 1 * 1e-4
print("DT: %s" % dt)
tf = 1
solver = Solver(
kernel=kernel,
dim=2,
integrator=integrator,
dt=dt,
tf=tf,
adaptive_timestep=False, )
return solver
def create_solver(self):
kernel = CubicSpline(dim=3)
if self.options.test:
integrator = PECIntegrator(fluid=WCSPHStep(), boundary=WCSPHStep())
adaptive, n_damp = False, 0
else:
integrator = EPECIntegrator(fluid=WCSPHStep(),
boundary=WCSPHStep())
adaptive, n_damp = True, 0
solver = Solver(dim=dim,
kernel=kernel,
integrator=integrator,
adaptive_timestep=adaptive,
tf=tf,
dt=dt,
n_damp=n_damp)
return solver
def create_solver(self):
# Create the kernel
#kernel = Gaussian(dim=2)
kernel = QuinticSpline(dim=2)
integrator = PECIntegrator(fluid=WCSPHStep())
# Create a solver.
solver = Solver(kernel=kernel, dim=2, integrator=integrator,
tf=tf, dt=dt, output_at_times=output_at_times)
return solver
def create_solver(self):
kernel = CubicSpline(dim=2)
integrator = PECIntegrator(fluid=WCSPHStep())
dt = 5e-6
tf = 0.0076
solver = Solver(kernel=kernel,
dim=2,
integrator=integrator,
dt=dt,
tf=tf)
return solver
def create_solver(self):
kernel = WendlandQuintic(dim=2)
integrator = EPECIntegrator(fluid=WCSPHStep(),
block=RK2StepRigidBody())
solver = Solver(kernel=kernel,
dim=2,
integrator=integrator,
tf=tf,
dt=dt,
adaptive_timestep=False)
return solver
def create_solver(self):
kernel = CubicSpline(dim=2)
integrator = EPECIntegrator(fluid=WCSPHStep())
solver = Solver(kernel=kernel,
dim=2,
integrator=integrator,
dt=self.dt,
tf=self.tf,
pfreq=10)
return solver
def test_invalid_kwarg_raises_error(self):
# Given
x = np.linspace(0, 1, 10)
pa = get_particle_array(name='fluid', x=x)
equations = [SummationDensity(dest='fluid', sources=['fluid'])]
kernel = QuinticSpline(dim=1)
a_eval = AccelerationEval([pa], equations, kernel=kernel)
a_helper = AccelerationEvalCythonHelper(a_eval)
# When/Then
integrator = PECIntegrator(f=WCSPHStep())
self.assertRaises(RuntimeError, IntegratorCythonHelper, integrator,
a_helper)
def create_solver(self):
dim = 3
kernel = CubicSpline(dim=dim)
# kernel = WendlandQuintic(dim=dim)
self.wdeltap = kernel.kernel(rij=dx, h=hdx * dx)
integrator = EPECIntegrator(fluid=WCSPHStep())
solver = Solver(kernel=kernel, dim=dim, integrator=integrator)
dt = 1e-9
tf = 8e-6
solver.set_time_step(dt)
solver.set_final_time(tf)
solver.set_print_freq(100)
return solver
def create_solver(self):
kernel = CubicSpline(dim=2)
integrator = PECIntegrator(fluid=WCSPHStep(),
inlet=InletOutletStep(),
outlet=InletOutletStep())
dt = 0.00005
tf = 20.0
solver = Solver(kernel=kernel,
dim=2,
integrator=integrator,
dt=dt,
tf=tf,
adaptive_timestep=False,
pfreq=20)
return solver
def create_solver(self):
kernel = CubicSpline(dim=3)
integrator = PECIntegrator(fluid=WCSPHStep(),
boundary=OneStageRigidBodyStep())
dt = 0.125 * self.h0 / c0
self.scheme.configure(h0=self.h0, hdx=self.hdx)
solver = Solver(kernel=kernel,
dim=3,
integrator=integrator,
tf=tf,
dt=dt,
adaptive_timestep=True,
fixed_h=False)
return solver
def create_solver(self):
'''
Define solver
'''
kernel = CubicSpline(dim=2) #Gaussian(dim=2) #QuinticSpline(dim=2) #WendlandQuintic(dim=2) )
if self.PST == False:
integrator = PECIntegrator(fluid = WCSPHStep())
elif self.PST == True:
integrator = PECIntegrator(fluid = DPSPHStep())
solver = Solver(
kernel=kernel, dim=2, integrator=integrator, dt=self.dt, tf=self.tf,
pfreq=30
)
return solver
def create_solver(self):
print("Create our own solver.")
kernel = Gaussian(dim=2)
integrator = EPECIntegrator(fluid=WCSPHStep())
dt = 5e-6
tf = 0.0076
solver = Solver(kernel=kernel,
dim=2,
integrator=integrator,
dt=dt,
tf=tf,
adaptive_timestep=True,
cfl=0.3,
n_damp=50,
output_at_times=[0.0008, 0.0038])
return solver
co=co,
with_obstacle=False,
beta=2.0,
nfluid_offset=1,
hdx=hdx)
# Create the application.
app = Application()
# Create the kernel
kernel = WendlandQuintic(dim=2)
# Create the Integrator. Currently, PySPH supports multi-stage,
# predictor corrector and a TVD-RK3 integrators.
integrator = EPECIntegrator(fluid=WCSPHStep(), boundary=WCSPHStep())
# Create a solver. The damping is performed for the first 50 iterations.
solver = Solver(kernel=kernel,
dim=dim,
integrator=integrator,
dt=dt,
tf=tf,
adaptive_timestep=True,
n_damp=50,
fixed_h=False)
# create the equations
equations = [
# Equation of state
