GfsInit

From Gerris

GfsInit can be used to set initial conditions for a set of variables.

The syntax in parameter files is:

[ GfsGenericInit ] { V1 = [ GfsFunction ] V2 = [ GfsFunction ] … }

where V1, V2,… are variable names.

If the variables do not already exist at the time of initialisation, they are created.

Examples

• B\'enard--von K\'arm\'an Vortex Street for flow around a cylinder at Re=160

  Init {} { U = 1 }

• Vortex street around a "heated" cylinder

  Init {} { U = 1 }

• Turbulent air flow around RV Tangaroa

  Init {} { U = 1. }

• Lunar tides in Cook Strait, New Zealand

    Init {} {
        A_amp = AM2.gts
        B_amp = BM2.gts
    }

    Init { istep = 1 } {
        U = U/(1. + dt*Velocity*4e-4/H)
        V = V/(1. + dt*Velocity*4e-4/H)
    }

• Air-water flow around a Series 60 cargo ship

    Init {} { U = FROUDE }

• Convergence of the Poisson solver

  Init {} {
    Div = {
      int k = 3, l = 3;
      return -M_PI*M_PI*(k*k + l*l)*sin (M_PI*k*x)*sin (M_PI*l*y);
    }
  }

• Convergence with a refined circle

  Init {} {
    Div = {
      int k = 3, l = 3;
      return -M_PI*M_PI*(k*k + l*l)*sin (M_PI*k*x)*sin (M_PI*l*y);
    }
  }

• Convergence of the Poisson solver with solid boundaries

  Init {} {
    Div = {
      int k = 3, l = 3;
      return -M_PI*M_PI*(k*k + l*l)*sin (M_PI*k*x)*sin (M_PI*l*y);
    }
  }

• Star-shaped solid boundary with refinement

    Init {} {
        Div = {
            int k = 3, l = 3;
            return -M_PI*M_PI*(k*k + l*l)*sin (M_PI*k*x)*sin (M_PI*l*y);
        }
    }

• Star-shaped solid boundary

    Init {} {
        Div = {
            int k = 3, l = 3;
            return -M_PI*M_PI*(k*k + l*l)*sin (M_PI*k*x)*sin (M_PI*l*y);
        }
    }

• Thin wall at box boundary

  Init {} {
    Div = {
      int k = 3, l = 3;
      x = (x - 0.5)/2.;
      y = (y + 0.5)/2.;
      return -M_PI*M_PI*(k*k + l*l)*sin (M_PI*k*x)*sin (M_PI*l*y);
    }
  }

• Poisson solution in a dumbbell-shaped domain

  Init {} { Div = y }

• Convergence of the Godunov advection scheme

  Init {} {
    U = -8.*y
    V = 8.*x
    T = {
      double r2 = x*x + y*y; 
      double coeff = 20. + 20000.*r2*r2*r2*r2;
      return (1. + cos(20.*x)*cos(20.*y))*exp(-coeff*r2)/2.;
    }
  }

• Time-reversed VOF advection in a shear flow

    Init {} {
        U = sin((x + 0.5)*M_PI)*cos((y + 0.5)*M_PI)
        V = -cos((x + 0.5)*M_PI)*sin((y + 0.5)*M_PI)
    }

    Init { start = 2.5 } { U = -U V = -V }

• Time-reversed advection with curvature-based refinement

    Init {} {
        U = sin((x + 0.5)*M_PI)*cos((y + 0.5)*M_PI)
        V = -cos((x + 0.5)*M_PI)*sin((y + 0.5)*M_PI)
    }

    Init { start = 2.5 } { U = -U V = -V }

• Estimation of the numerical viscosity

  Init {} {
    U = (- cos (2.*M_PI*x)*sin (2.*M_PI*y))
    V = (sin (2.*M_PI*x)*cos (2.*M_PI*y))
  }

• Estimation of the numerical viscosity with refined box

  Init {} {
    U = (- cos (8.*M_PI*x)*sin (8.*M_PI*y))
    V = (sin (8.*M_PI*x)*cos (8.*M_PI*y))
  }

• Convergence for a simple periodic problem

  Init {} {
    U = (1. - 2.*cos (2.*M_PI*x)*sin (2.*M_PI*y))
    V = (1. + 2.*sin (2.*M_PI*x)*cos (2.*M_PI*y))
  }

• Potential flow around a sphere

    Init {} {
	U = U0
	Phi = {
	    double r = sqrt (cx*cx + cy*cy);
	    return U0*A0*A0*A0*cx/(2.*r*r*r);
	}
    }

• Viscous flow past a sphere

    Init {} { U = U0 }

• Mass conservation

    Init {} { U = 1 }

• Mass conservation with solid boundary

    Init {} { U = 1 }

• Momentum conservation for large density ratios

    Init {} { U = T }

• Hydrostatic balance with quadratic pressure profile

    Init {} { rho = (cy + 0.5) }

• Convergence of a potential flow solution

    Init {} { U = 1 }

• Flow through a divergent channel

    Init {} { U = 1 }

• Potential flow around a thin plate

  Init {} { U = 1 }

• Circular droplet in equilibrium

  Init {} { Tref = T }

• Axisymmetric spherical droplet in equilibrium

  Init {} { Tref = T }

• Geostrophic adjustment

  Init {} {
    # e-folding radius = 100 km
    # umax = 0.5 m/s = sqrt(200)*exp(-1/2)
    U = (5.667583815e-4*200.*y*exp (-100.*(x*x + y*y)))
    V = (- 5.667583815e-4*200.*x*exp (-100.*(x*x + y*y)))
    P = (5.667583815e-4*exp (-100.*(x*x + y*y)))
    H = 1
  }

• Geostrophic adjustment on a beta-plane

  Init {} {
    # e-folding radius = 100 km
    # umax = 0.5 m/s = sqrt(200)*exp(-1/2)
    U = (5.667583815e-4*200.*y*exp (-100.*(x*x + y*y)))
    V = (- 5.667583815e-4*200.*x*exp (-100.*(x*x + y*y)))
    P = (5.667583815e-4*exp (-100.*(x*x + y*y)))
    H = 1
  }

• Coastally-trapped waves

  Init {} {
    P = pwave(cx, cy, 0)
    U = uwave(x, y)
    V = vwave(x, y)
    H = 1
  }

• Coastally-trapped waves with adaptive refinement

  Init {} {
    P = pwave(cx, cy, 0)
    U = uwave(x, y)
    V = vwave(x, y)
    H = 1
  }

• Gravity waves in a realistic ocean basin

    Init {} { P = 1e-2*x }