def main(): # Create the application. app = Application() dim = 1 # Create the kernel kernel = CubicSpline(dim=dim) # Create the integrator. integrator = EulerIntegrator(fluid=DummyStepper()) solver = Solver(kernel=kernel, dim=dim, integrator=integrator) solver.set_time_step(0.1) solver.set_final_time(0.1) equations = [TotalMass(dest='fluid', sources=['fluid'])] app.setup( solver=solver, equations=equations, particle_factory=create_particles) # There is no need to write any output as the test below # computes the total mass. solver.set_disable_output(True) app.run() fluid = solver.particles[0] err = fluid.total_mass[0] - 10.0 assert abs(err) < 1e-16, "Error: %s" % err
class TotalMass(Equation): def reduce(self, dst): m = serial_reduce_array(dst.m, op='sum') dst.total_mass[0] = parallel_reduce_array(m, op='sum') class DummyStepper(IntegratorStep): def initialize(self): pass def stage1(self): pass # Create the application. app = Application() dim = 1 # Create the kernel kernel = CubicSpline(dim=dim) # Create the integrator. integrator = EulerIntegrator(fluid=DummyStepper()) solver = Solver(kernel=kernel, dim=dim, integrator=integrator) solver.set_time_step(0.1) solver.set_final_time(0.1) equations = [TotalMass(dest='fluid', sources=['fluid'])] app.setup(solver=solver, equations=equations,
# deviatoric stress initial values add_properties(pa, 's000', 's010', 's020', 's110', 's120', 's220') # standard acceleration variables add_properties(pa, 'arho', 'au', 'av', 'aw', 'ax', 'ay', 'az', 'ae') # initial values add_properties(pa, 'rho0', 'u0', 'v0', 'w0', 'x0', 'y0', 'z0', 'e0') # load balancing properties pa.set_lb_props( pa.properties.keys() ) return [pa,] # create the Application app = Application() # kernel kernel = CubicSpline(dim=2) wdeltap = kernel.kernel(rij=dx, h=hdx*dx) # integrator integrator = PECIntegrator(solid=SolidMechStep()) # Create a solver solver = Solver(kernel=kernel, dim=2, integrator=integrator) # default parameters dt = 1e-8 tf = 5e-5 solver.set_time_step(dt)
fluid.V[:] = 1./volume solid.V[:] = 1./volume # smoothing lengths fluid.h[:] = hdx * dx solid.h[:] = hdx * dx # return the particle list return [fluid, solid] # domain for periodicity domain = DomainManager( xmin=0, xmax=L, ymin=0, ymax=H, periodic_in_x=True,periodic_in_y=True) # Create the application. app = Application(domain=domain) # Create the kernel kernel = Gaussian(dim=2) integrator = PECIntegrator(fluid=TransportVelocityStep()) # Create a solver. solver = Solver(kernel=kernel, dim=2, integrator=integrator, dt=dt, tf=tf) equations = [ # Summation density along with volume summation for the fluid # phase. This is done for all local and remote particles. At the # end of this group, the fluid phase has the correct density
ro = 1000.0 # the geometry generator geom = DamBreak3DGeometry( dx=dx, nboundary_layers=nboundary_layers, hdx=hdx, rho0=ro) h0 = dx * hdx co = 10.0 * geom.get_max_speed(g=9.81) gamma = 7.0 alpha = 0.5 beta = 0.0 B = co*co*ro/gamma # Create the application. app = Application() # Create the kernel kernel = WendlandQuintic(dim=dim) # Setup the integrator. integrator = EPECIntegrator(fluid=WCSPHStep(), boundary=WCSPHStep(), obstacle=WCSPHStep()) # Create a solver. solver = Solver(kernel=kernel, dim=dim, integrator=integrator, tf=tf, dt=dt, adaptive_timestep=True, tdamp=tf/1000.0) # create the equations equations = [
container_width=container_width, container_height=container_height, fluid_column_height=fluid_column_height, fluid_column_width=fluid_column_width, dx=dx, dy=dy, nboundary_layers=1, ro=ro, co=1.0, with_obstacle=False, beta=1.0, nfluid_offset=1, hdx=hdx, iisph=True) def create_particles(**kw): fluid, boundary = geom.create_particles(**kw) boundary.x -= 0.1 boundary.y -= 0.1 return [fluid, boundary] # Create the application. app = Application() # Create the kernel kernel = CubicSpline(dim=2) # Create the Integrator. Currently, PySPH supports multi-stage, # predictor corrector and a TVD-RK3 integrators. integrator = EulerIntegrator(fluid=IISPHStep()) # Create a solver. solver = Solver(kernel=kernel, dim=dim, integrator=integrator, dt=dt, tf=tf, adaptive_timestep=True, fixed_h=False) solver.set_print_freq(10)
# remove particles outside the circle indices = [] for i in range(len(x)): if sqrt(x[i]*x[i] + y[i]*y[i]) - 1 > 1e-10: indices.append(i) pa = get_particle_array_iisph(x=x, y=y, m=m, rho=rho, h=h, p=p, u=u, v=v, name=name) pa.remove_particles(indices) print("Elliptical drop :: %d particles"%(pa.get_number_of_particles())) return [pa,] # Create the application. app = Application() # Set the SPH kernel. The spline based kernels are much more efficient #(but less accurate) than the Gaussian kernel = CubicSpline(dim=2) # Create the Integrator. integrator = EulerIntegrator(fluid=IISPHStep()) # Construct the solver. Use the output_at_times list to specify instants of # time at which the output solution is required. dt = 2e-4; tf = 0.0075 solver = Solver(kernel=kernel, dim=2, integrator=integrator, dt=dt, tf=tf, adaptive_timestep=False, cfl=0.05,