Example #1
0
 def create_scheme(self):
     h0 = None
     hdx = None
     wcsph = WCSPHScheme(
         ['fluid'], [], dim=2, rho0=rho0, c0=c0, h0=h0,
         hdx=hdx, nu=None, gamma=7.0, alpha=0.0, beta=0.0
     )
     tvf = TVFScheme(
         ['fluid'], [], dim=2, rho0=rho0, c0=c0, nu=None,
         p0=p0, pb=None, h0=h0
     )
     edac = EDACScheme(
         ['fluid'], [], dim=2, rho0=rho0, c0=c0, nu=None,
         pb=p0, h=h0
     )
     iisph = IISPHScheme(
         fluids=['fluid'], solids=[], dim=2, nu=None,
         rho0=rho0, has_ghosts=True
     )
     crksph = CRKSPHScheme(
         fluids=['fluid'], dim=2, nu=None,
         rho0=rho0, h0=h0, c0=c0, p0=0.0
     )
     gtvf = GTVFScheme(
         fluids=['fluid'], dim=2, rho0=rho0, c0=c0,
         nu=None, h0=None, p0=p0, pref=None
     )
     pcisph = PCISPHScheme(
         fluids=['fluid'], dim=2, rho0=rho0, nu=None
     )
     s = SchemeChooser(
         default='tvf', wcsph=wcsph, tvf=tvf, edac=edac, iisph=iisph,
         crksph=crksph, gtvf=gtvf, pcisph=pcisph
     )
     return s
Example #2
0
    def create_scheme(self):
        gsph = GSPHScheme(
            fluids=['fluid'], solids=[], dim=self.dim,
            gamma=self.gamma, kernel_factor=1.0,
            g1=0., g2=0., rsolver=7, interpolation=1, monotonicity=1,
            interface_zero=True, hybrid=False, blend_alpha=5.0,
            niter=40, tol=1e-6, has_ghosts=True
        )

        mpm = GasDScheme(
            fluids=['fluid'], solids=[], dim=self.dim, gamma=self.gamma,
            kernel_factor=1.2, alpha1=0, alpha2=0,
            beta=2.0, update_alpha1=False, update_alpha2=False,
            has_ghosts=True
        )

        crksph = CRKSPHScheme(
            fluids=['fluid'], dim=self.dim, rho0=0, c0=0, nu=0, h0=0, p0=0,
            gamma=self.gamma, cl=2, has_ghosts=True
        )

        adke = ADKEScheme(
            fluids=['fluid'], solids=[], dim=self.dim, gamma=self.gamma,
            alpha=0, beta=0.0, k=1.5, eps=0.0, g1=0.0, g2=0.0,
            has_ghosts=True)

        s = SchemeChooser(
            default='gsph', gsph=gsph, mpm=mpm, crksph=crksph, adke=adke
        )

        return s
Example #3
0
    def create_scheme(self):
        adke = ADKEScheme(
            fluids=['fluid'], solids=[], dim=dim, gamma=gamma,
            alpha=1, beta=1.0, k=0.3, eps=0.5, g1=0.2, g2=0.4)

        mpm = GasDScheme(
            fluids=['fluid'], solids=[], dim=dim, gamma=gamma,
            kernel_factor=None, alpha1=1.0, alpha2=0.1,
            beta=2.0, update_alpha1=True, update_alpha2=True,
        )
        gsph = GSPHScheme(
            fluids=['fluid'], solids=[], dim=dim, gamma=gamma,
            kernel_factor=None,
            g1=0.2, g2=0.4, rsolver=2, interpolation=1, monotonicity=1,
            interface_zero=True, hybrid=True, blend_alpha=2.0,
            niter=20, tol=1e-6
        )
        crk = CRKSPHScheme(
            fluids=['fluid'], dim=dim, rho0=0, c0=0,
            nu=0, h0=0, p0=0, gamma=gamma, cl=3
        )
        s = SchemeChooser(
            default='adke', adke=adke, mpm=mpm, gsph=gsph, crk=crk
            )
        return s
Example #4
0
    def create_scheme(self):
        self.tf = tf
        adke = ADKEScheme(
            fluids=['fluid'], solids=[], dim=dim, gamma=gamma,
            alpha=0, beta=0, k=1.5, eps=0., g1=0., g2=0.,
            has_ghosts=True)

        mpm = GasDScheme(
            fluids=['fluid'], solids=[], dim=dim, gamma=gamma,
            kernel_factor=kernel_factor, alpha1=0, alpha2=0,
            beta=beta, has_ghosts=True
        )

        crksph = CRKSPHScheme(
            fluids=['fluid'], dim=dim, rho0=0, c0=0, nu=0, h0=0, p0=0,
            gamma=gamma, cl=2, has_ghosts=True
        )

        gsph = GSPHScheme(
            fluids=['fluid'], solids=[], dim=dim, gamma=gamma,
            kernel_factor=1.,
            g1=0., g2=0., rsolver=7, interpolation=1, monotonicity=1,
            interface_zero=True, hybrid=False, blend_alpha=5.0,
            niter=40, tol=1e-6, has_ghosts=True
        )

        psph = PSPHScheme(
            fluids=['fluid'], solids=[], dim=dim, gamma=gamma,
            hfact=kernel_factor
        )

        tsph = TSPHScheme(
            fluids=['fluid'], solids=[], dim=dim, gamma=gamma,
            hfact=kernel_factor
        )

        s = SchemeChooser(
            default='gsph', adke=adke, mpm=mpm, gsph=gsph, crksph=crksph,
            psph=psph, tsph=tsph
        )
        return s
Example #5
0
    def create_scheme(self):
        self.dt = dt
        self.tf = tf
        adke = ADKEScheme(fluids=['fluid'],
                          solids=[],
                          dim=dim,
                          gamma=gamma,
                          alpha=1,
                          beta=1.0,
                          k=1.0,
                          eps=0.8,
                          g1=0.2,
                          g2=0.4,
                          has_ghosts=True)

        mpm = GasDScheme(fluids=['fluid'],
                         solids=[],
                         dim=dim,
                         gamma=gamma,
                         kernel_factor=1.2,
                         alpha1=1.0,
                         alpha2=0.1,
                         beta=2.0,
                         update_alpha1=True,
                         update_alpha2=True,
                         has_ghosts=True)

        gsph = GSPHScheme(fluids=['fluid'],
                          solids=[],
                          dim=dim,
                          gamma=gamma,
                          kernel_factor=1.0,
                          g1=0.2,
                          g2=0.4,
                          rsolver=2,
                          interpolation=1,
                          monotonicity=1,
                          interface_zero=True,
                          hybrid=False,
                          blend_alpha=2.0,
                          niter=20,
                          tol=1e-6,
                          has_ghosts=True)

        crk = CRKSPHScheme(fluids=['fluid'],
                           dim=dim,
                           rho0=0,
                           c0=0,
                           nu=0,
                           h0=0,
                           p0=0,
                           gamma=gamma,
                           cl=4,
                           cq=1,
                           eta_crit=0.2,
                           has_ghosts=True)

        # Use 400 particles
        psph = PSPHScheme(fluids=['fluid'],
                          solids=[],
                          dim=dim,
                          gamma=gamma,
                          hfact=1.2)

        # Use 400 particles
        tsph = TSPHScheme(fluids=['fluid'],
                          solids=[],
                          dim=dim,
                          gamma=gamma,
                          hfact=1.2)

        s = SchemeChooser(default='gsph',
                          gsph=gsph,
                          adke=adke,
                          mpm=mpm,
                          crksph=crk,
                          psph=psph,
                          tsph=tsph)
        return s
    def create_scheme(self):
        crk = CRKSPHScheme(fluids=['fluid'],
                           dim=2,
                           rho0=0,
                           c0=0,
                           nu=0,
                           h0=0,
                           p0=0,
                           gamma=gamma,
                           cl=2,
                           has_ghosts=True)

        adke = ADKEScheme(fluids=['fluid'],
                          solids=[],
                          dim=dim,
                          gamma=gamma,
                          alpha=0.1,
                          beta=0.1,
                          k=1.2,
                          eps=0.1,
                          g1=0.1,
                          g2=0.2,
                          has_ghosts=True)

        mpm = GasDScheme(fluids=['fluid'],
                         solids=[],
                         dim=dim,
                         gamma=gamma,
                         kernel_factor=1.2,
                         alpha1=1.0,
                         alpha2=0.1,
                         beta=2.0,
                         update_alpha1=True,
                         update_alpha2=True,
                         has_ghosts=True)

        gsph = GSPHScheme(fluids=['fluid'],
                          solids=[],
                          dim=dim,
                          gamma=gamma,
                          kernel_factor=1.5,
                          g1=0.2,
                          g2=0.4,
                          rsolver=2,
                          interpolation=1,
                          monotonicity=2,
                          interface_zero=True,
                          hybrid=False,
                          blend_alpha=2.0,
                          niter=40,
                          tol=1e-6,
                          has_ghosts=True)
        psph = PSPHScheme(fluids=['fluid'],
                          solids=[],
                          dim=dim,
                          gamma=gamma,
                          hfact=1.2)
        tsph = TSPHScheme(fluids=['fluid'],
                          solids=[],
                          dim=dim,
                          gamma=gamma,
                          hfact=1.2)
        s = SchemeChooser(default='crksph',
                          crksph=crk,
                          gsph=gsph,
                          adke=adke,
                          mpm=mpm,
                          psph=psph,
                          tsph=tsph)

        return s
Example #7
0
    def create_scheme(self):
        mpm = GasDScheme(fluids=['fluid'],
                         solids=[],
                         dim=dim,
                         gamma=gamma,
                         kernel_factor=kernel_factor,
                         alpha1=alpha1,
                         alpha2=alpha2,
                         beta=beta,
                         adaptive_h_scheme="mpm",
                         update_alpha1=True,
                         update_alpha2=True,
                         has_ghosts=True)

        crksph = CRKSPHScheme(fluids=['fluid'],
                              dim=2,
                              rho0=0,
                              c0=0,
                              nu=0,
                              h0=0,
                              p0=0,
                              gamma=gamma,
                              cl=2,
                              has_ghosts=True)

        gsph = GSPHScheme(fluids=['fluid'],
                          solids=[],
                          dim=dim,
                          gamma=gamma,
                          kernel_factor=1.5,
                          g1=0.25,
                          g2=0.5,
                          rsolver=7,
                          interpolation=1,
                          monotonicity=2,
                          interface_zero=True,
                          hybrid=False,
                          blend_alpha=2.0,
                          niter=40,
                          tol=1e-6,
                          has_ghosts=True)

        adke = ADKEScheme(fluids=['fluid'],
                          solids=[],
                          dim=dim,
                          gamma=gamma,
                          alpha=1,
                          beta=1,
                          k=1.0,
                          eps=0.8,
                          g1=0.5,
                          g2=0.5,
                          has_ghosts=True)

        psph = PSPHScheme(fluids=['fluid'],
                          solids=[],
                          dim=dim,
                          gamma=gamma,
                          hfact=1.2)

        tsph = TSPHScheme(fluids=['fluid'],
                          solids=[],
                          dim=dim,
                          gamma=gamma,
                          hfact=1.2)

        s = SchemeChooser(default='crksph',
                          crksph=crksph,
                          mpm=mpm,
                          adke=adke,
                          gsph=gsph,
                          psph=psph,
                          tsph=tsph)
        s.configure_solver(dt=dt, tf=tf, adaptive_timestep=False)
        return s
Example #8
0
    def create_scheme(self):
        self.dt = dt
        self.tf = tf

        adke = ADKEScheme(fluids=['fluid'],
                          solids=[],
                          dim=dim,
                          gamma=gamma,
                          alpha=1,
                          beta=1,
                          k=1.0,
                          eps=0.8,
                          g1=0.5,
                          g2=0.5,
                          has_ghosts=True)

        mpm = GasDScheme(fluids=['fluid'],
                         solids=[],
                         dim=dim,
                         gamma=gamma,
                         kernel_factor=kernel_factor,
                         alpha1=alpha1,
                         alpha2=alpha2,
                         beta=beta,
                         max_density_iterations=1000,
                         density_iteration_tolerance=1e-4,
                         has_ghosts=True)

        gsph = GSPHScheme(fluids=['fluid'],
                          solids=[],
                          dim=dim,
                          gamma=gamma,
                          kernel_factor=1.5,
                          g1=0.25,
                          g2=0.5,
                          rsolver=2,
                          interpolation=1,
                          monotonicity=2,
                          interface_zero=True,
                          hybrid=False,
                          blend_alpha=2.0,
                          niter=40,
                          tol=1e-6,
                          has_ghosts=True)

        crksph = CRKSPHScheme(fluids=['fluid'],
                              dim=dim,
                              rho0=0,
                              c0=0,
                              nu=0,
                              h0=0,
                              p0=0,
                              gamma=gamma,
                              cl=2,
                              has_ghosts=True)

        psph = PSPHScheme(fluids=['fluid'],
                          solids=[],
                          dim=dim,
                          gamma=gamma,
                          hfact=kernel_factor)

        tsph = TSPHScheme(fluids=['fluid'],
                          solids=[],
                          dim=dim,
                          gamma=gamma,
                          hfact=kernel_factor)

        s = SchemeChooser(default='adke',
                          adke=adke,
                          mpm=mpm,
                          gsph=gsph,
                          crksph=crksph,
                          psph=psph,
                          tsph=tsph)
        return s