Exemple #1
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
Exemple #2
0
    def create_scheme(self):
        gsph = GSPHScheme(fluids=['fluid'],
                          solids=[],
                          dim=self.dim,
                          gamma=self.gamma,
                          kernel_factor=1.,
                          g1=0.,
                          g2=0.,
                          rsolver=3,
                          interpolation=1,
                          monotonicity=1,
                          interface_zero=True,
                          hybrid=False,
                          blend_alpha=5.0,
                          niter=200,
                          tol=1e-6)

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

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

        s = SchemeChooser(default='gsph', gsph=gsph, psph=psph, tsph=tsph)

        return s
Exemple #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
Exemple #4
0
 def create_scheme(self):
     wcsph = WCSPHScheme(['fluid'], [],
                         dim=2,
                         rho0=self.ro,
                         c0=self.co,
                         h0=self.dx * self.hdx,
                         hdx=self.hdx,
                         gamma=7.0,
                         alpha=0.1,
                         beta=0.0)
     iisph = IISPHScheme(['fluid'], [], dim=2, rho0=self.ro)
     dpsph = DeltaPlusScheme(
         fluids=['fluid'],
         solids=[],
         dim=2,
         rho0=self.ro,
         c0=self.co,
         nu=0.0,
         p0=self.p0,
         hdx=0.0,
         dx=0.0,
         h0=0.0,
         dt=0.0,
     )
     s = SchemeChooser(default='dpsph',
                       dpsph=dpsph,
                       wcsph=wcsph,
                       iisph=iisph)
     return s
Exemple #5
0
 def create_scheme(self):
     wcsph = WCSPHScheme(['fluid'], ['wall', 'cube'], dim=2, rho0=ro,
                         h0=0.03, hdx=1.3, hg_correction=True, c0=co,
                         gy=-9.81, alpha=alp, gamma=gamma, update_h=True)
     edac = EDACScheme(['fluid'], ['wall', 'cube'], dim=2, rho0=ro, c0=co,
                       alpha=alp, nu=0.0, h=0.03, gy=-9.81, clamp_p=True)
     return SchemeChooser(default='wcsph', wcsph=wcsph, edac=edac)
Exemple #6
0
 def create_scheme(self):
     dpsph = DeltaPlusScheme(
         fluids=['fluid'], solids=['solid'], dim=2, rho0=rho0, c0=c0, 
         nu=0.0, p0=p0, hdx=0.0, dx=0.0, h0=0.0, dt=0.0,
     )
     s = SchemeChooser(default='dpsph', dpsph=dpsph)
     return s
Exemple #7
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
Exemple #8
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
Exemple #9
0
 def create_scheme(self):
     aha = AdamiHuAdamsScheme(['fluid'], ['dam'],
                              dim=2,
                              rho0=ro,
                              c0=co,
                              alpha=alp,
                              gy=-9.81,
                              nu=0.0,
                              h0=0.03,
                              gamma=1.0)
     wcsph = WCSPHScheme(['fluid'], ['dam'],
                         dim=2,
                         rho0=ro,
                         c0=co,
                         h0=0.03,
                         hdx=1.3,
                         hg_correction=True,
                         gy=-9.81,
                         alpha=alp,
                         gamma=gamma,
                         update_h=True)
     edac = EDACScheme(['fluid'], ['dam'],
                       dim=2,
                       rho0=ro,
                       c0=co,
                       gy=-9.81,
                       alpha=0.0,
                       nu=0.0,
                       h=0.03,
                       clamp_p=True)
     return SchemeChooser(default='wcsph', wcsph=wcsph, aha=aha, edac=edac)
Exemple #10
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
Exemple #11
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
Exemple #12
0
 def create_scheme(self):
     wcsph = WCSPHScheme(
         ['fluid'], ['boundary'], dim=2, rho0=ro, c0=co,
         h0=h, hdx=1.3, gy=-9.81, alpha=alpha, beta=beta,
         gamma=gamma, hg_correction=True, update_h=True
     )
     aha = AdamiHuAdamsScheme(
         fluids=['fluid'], solids=['boundary'], dim=2, c0=co, nu=nu,
         rho0=ro, h0=h, p0=0.0, gy=-g, gamma=1.0, tdamp=0.0, alpha=alpha
     )
     edac = EDACScheme(
         fluids=['fluid'], solids=['boundary'], dim=2, c0=co, nu=nu,
         rho0=ro, h=h, pb=0.0, gy=-g, eps=0.0, clamp_p=True
     )
     iisph = IISPHScheme(
         fluids=['fluid'], solids=['boundary'], dim=2, nu=nu,
         rho0=ro, gy=-g
     )
     gtvf = GTVFScheme(
         fluids=['fluid'], solids=['boundary'], dim=2, nu=nu,
         rho0=ro, gy=-g, h0=None, c0=co, pref=None
     )
     sisph = SISPHScheme(
         fluids=['fluid'], solids=['boundary'], dim=2, nu=nu,
         c0=co, rho0=ro, alpha=0.05, gy=-g, pref=ro*co**2,
         internal_flow=False, hg_correction=True, gtvf=True, symmetric=True
     )
     s = SchemeChooser(default='wcsph', wcsph=wcsph, aha=aha, edac=edac,
                       iisph=iisph, gtvf=gtvf, sisph=sisph)
     return s
Exemple #13
0
 def create_scheme(self):
     wcsph = WCSPHScheme(['fluid'], ['wall', 'paddle', 'obstacle'],
                         dim=2,
                         rho0=ro,
                         c0=co,
                         h0=0.01,
                         hdx=1.3,
                         gy=-9.81,
                         hg_correction=True,
                         alpha=alp,
                         gamma=gamma,
                         update_h=True)
     edac = EDACScheme(['fluid'], ['wall', 'paddle', 'obstacle'],
                       dim=2,
                       rho0=ro,
                       c0=co,
                       gy=-9.81,
                       alpha=alp,
                       nu=0.0,
                       h=0.01,
                       clamp_p=True)
     aha = AdamiHuAdamsScheme(['fluid'], ['wall', 'paddle', 'obstacle'],
                              dim=2,
                              rho0=ro,
                              h0=0.01,
                              gamma=1.0,
                              alpha=alp,
                              gy=-9.81,
                              nu=0.0,
                              c0=co)
     return SchemeChooser(default='wcsph', aha=aha, wcsph=wcsph, edac=edac)
Exemple #14
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
Exemple #15
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)
     s = SchemeChooser(default='tvf', wcsph=wcsph, tvf=tvf, edac=edac)
     return s
Exemple #16
0
 def create_scheme(self):
     wcsph = WCSPHScheme(
         ['fluid'], [], dim=2, rho0=self.ro, c0=self.co,
         h0=self.dx*self.hdx, hdx=self.hdx, gamma=7.0, alpha=0.1, beta=0.0
     )
     iisph = IISPHScheme(
         ['fluid'], [], dim=2, rho0=self.ro
     )
     s = SchemeChooser(default='wcsph', wcsph=wcsph, iisph=iisph)
     return s
Exemple #17
0
 def create_scheme(self):
     rbs = RigidBodyScheme(rigid_bodies=['body'],
                           boundaries=None,
                           dim=3,
                           orientation="quaternion",
                           principal_moi=True,
                           kn=self.kn,
                           mu=self.mu,
                           en=self.en)
     s = SchemeChooser(default='rbs', rbs=rbs)
     return s
Exemple #18
0
 def create_scheme(self):
     wcsph = WCSPHScheme(['fluid'], ['boundary'],
                         dim=2,
                         rho0=ro,
                         c0=co,
                         h0=h,
                         hdx=1.3,
                         gy=-9.81,
                         alpha=alpha,
                         beta=beta,
                         gamma=gamma,
                         hg_correction=True,
                         update_h=True)
     aha = AdamiHuAdamsScheme(fluids=['fluid'],
                              solids=['boundary'],
                              dim=2,
                              c0=co,
                              nu=nu,
                              rho0=ro,
                              h0=h,
                              p0=0.0,
                              gy=-g,
                              gamma=1.0,
                              tdamp=0.0,
                              alpha=alpha)
     edac = EDACScheme(fluids=['fluid'],
                       solids=['boundary'],
                       dim=2,
                       c0=co,
                       nu=nu,
                       rho0=ro,
                       h=h,
                       pb=0.0,
                       gy=-g,
                       eps=0.0,
                       clamp_p=True)
     iisph = IISPHScheme(fluids=['fluid'],
                         solids=['boundary'],
                         dim=2,
                         nu=nu,
                         rho0=ro,
                         gy=-g)
     s = SchemeChooser(default='wcsph',
                       wcsph=wcsph,
                       aha=aha,
                       edac=edac,
                       iisph=iisph)
     return s
Exemple #19
0
def test_scheme_chooser_does_not_clobber_default():

    # When
    wcsph = WCSPHScheme(
        ['f'],
        ['b'],
        dim=2,
        rho0=1.0,
        c0=10.0,
        h0=0.1,
        hdx=1.3,
        alpha=0.2,
        beta=0.1,
    )
    edac = EDACScheme(fluids=['f'],
                      solids=['b'],
                      dim=2,
                      c0=10.0,
                      nu=0.001,
                      rho0=1.0,
                      h=0.1,
                      alpha=0.0,
                      pb=0.0)
    s = SchemeChooser(default='wcsph', wcsph=wcsph, edac=edac)
    p = ArgumentParser(conflict_handler="resolve")
    s.add_user_options(p)
    opts = p.parse_args([])

    # When
    s.consume_user_options(opts)

    # Then
    assert s.scheme.alpha == 0.2
    assert s.scheme.beta == 0.1

    # When
    opts = p.parse_args(['--alpha', '0.3', '--beta', '0.4'])
    s.consume_user_options(opts)

    # Then
    assert s.scheme.alpha == 0.3
    assert s.scheme.beta == 0.4
    def create_scheme(self):
        '''Other scheme can be added here'''
        h0 = nu = None
        self.iom = self._create_inlet_outlet_manager()

        edac = EDACScheme(['fluid'], ['solid'],
                          dim=2,
                          rho0=rho,
                          c0=c0,
                          h=h0,
                          pb=None,
                          nu=nu,
                          alpha=0.2,
                          inlet_outlet_manager=self.iom,
                          inviscid_solids=['wall'])

        s = SchemeChooser(default='edac', edac=edac)

        return s
Exemple #21
0
    def create_scheme(self):
        gsph = GSPHScheme(fluids=['fluid'],
                          solids=[],
                          dim=dim,
                          gamma=gamma,
                          kernel_factor=1.5,
                          g1=0.25,
                          g2=0.5,
                          rsolver=2,
                          interpolation=1,
                          monotonicity=1,
                          interface_zero=True,
                          hybrid=False,
                          blend_alpha=2.0,
                          niter=40,
                          tol=1e-6)

        s = SchemeChooser(default='gsph', gsph=gsph)
        return s
Exemple #22
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
Exemple #23
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
Exemple #24
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
Exemple #25
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
Exemple #26
0
 def create_scheme(self):
     tvf = TVFScheme(['fluid'], ['solid'],
                     dim=2,
                     rho0=rho0,
                     c0=c0,
                     nu=None,
                     p0=p0,
                     pb=p0,
                     h0=hdx)
     edac = EDACScheme(
         fluids=['fluid'],
         solids=['solid'],
         dim=2,
         c0=c0,
         rho0=rho0,
         nu=0.0,
         pb=p0,
         eps=0.0,
         h=0.0,
     )
     s = SchemeChooser(default='tvf', tvf=tvf, edac=edac)
     return s
Exemple #27
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
Exemple #28
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
Exemple #29
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
    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