Beispiel #1
0
 def create_scheme(self):
     s = GasDScheme(
         fluids=['fluid'], solids=[], dim=dim, gamma=gamma,
         kernel_factor=kernel_factor, alpha1=alpha1, alpha2=alpha2,
         beta=beta, adaptive_h_scheme="gsph",
         update_alpha1=True, update_alpha2=True
     )
     s.configure_solver(dt=dt, tf=tf, adaptive_timestep=False)
     return s
Beispiel #2
0
 def create_scheme(self):
     s = GasDScheme(fluids=['fluid'],
                    solids=[],
                    dim=dim,
                    gamma=gamma,
                    kernel_factor=kernel_factor,
                    alpha1=alpha1,
                    alpha2=alpha2,
                    beta=beta)
     s.configure_solver(dt=dt, tf=tf, adaptive_timestep=False, pfreq=50)
     return s
Beispiel #3
0
    def create_scheme(self):
        self.dt = dt
        self.tf = tf

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

        mpm = GasDScheme(fluids=['fluid'],
                         solids=[],
                         dim=dim,
                         gamma=gamma,
                         kernel_factor=1.5,
                         alpha1=1.0,
                         alpha2=0.1,
                         beta=2.0,
                         update_alpha1=True,
                         update_alpha2=True)
        s = SchemeChooser(default='adke', adke=adke, mpm=mpm)
        return s
Beispiel #4
0
    def create_scheme(self):
        self.dt = dt
        self.tf = tf

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

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

        gsph = GSPHScheme(
            fluids=['fluid'], solids=['boundary'], dim=dim, gamma=gamma,
            kernel_factor=1.0,
            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
        )

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

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

        s = SchemeChooser(default='adke', adke=adke, mpm=mpm, gsph=gsph,
                          psph=psph, tsph=tsph)
        return s
Beispiel #5
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
Beispiel #6
0
    def create_scheme(self):
        self.dt = dt
        self.tf = tf
        adke = ADKEScheme(fluids=['fluid'],
                          solids=['boundary'],
                          dim=dim,
                          gamma=gamma,
                          alpha=1,
                          beta=1,
                          k=1.0,
                          eps=0.5,
                          g1=0.2,
                          g2=0.4)

        # Running this will need to implement boundary condtion first.
        mpm = GasDScheme(fluids=['fluid'],
                         solids=[],
                         dim=dim,
                         gamma=gamma,
                         kernel_factor=1.5,
                         alpha1=1.0,
                         alpha2=0.1,
                         beta=2.0,
                         update_alpha1=True,
                         update_alpha2=True)

        s = SchemeChooser(default='adke', adke=adke, mpm=mpm)
        return s
Beispiel #7
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
Beispiel #8
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)

        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)

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

        return s
Beispiel #9
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)

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

        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)

        s = SchemeChooser(default='adke', adke=adke, mpm=mpm, gsph=gsph)
        return s
Beispiel #10
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
        )
        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='mpm', mpm=mpm, psph=psph, tsph=tsph
        )
        return s
Beispiel #11
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
Beispiel #12
0
    def create_scheme(self):
        self.dt = dt
        self.tf = tf
        adke = ADKEScheme(
            fluids=['fluid'], solids=[], dim=dim, gamma=gamma,
            alpha=1, beta=2.0, k=1.0, eps=0.5, g1=0.5, g2=1.0)

        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
        )

        gsph = GSPHScheme(
            fluids=['fluid'], solids=[], dim=dim, gamma=gamma,
            kernel_factor=2.0,
            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
        )

        # PSPH doesn't work with default number of particles due to particle
        # penetration. Reduce the number of particles, say with --nl=1500
        # for this example to work with PSPH scheme.
        psph = PSPHScheme(
            fluids=['fluid'], solids=[], dim=dim, gamma=gamma,
            hfact=1.2
        )

        # TSPH doesn't work with default number of particles due to particle
        # penetration. Reduce the number of particles, say with --nl=1500
        # for this example to work with TSPH scheme.
        tsph = TSPHScheme(
            fluids=['fluid'], solids=[], dim=dim, gamma=gamma,
            hfact=1.2
        )

        s = SchemeChooser(default='adke', adke=adke, mpm=mpm, gsph=gsph,
                          psph=psph, tsph=tsph)
        return s
Beispiel #13
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
Beispiel #15
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
Beispiel #16
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