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 }

• Parallel simulation on four processors

  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 }

• Dam break on complex topography

    Init {} {
	Zb = x*x/8.+cos(M_PI*x)/2.
	P = {
	    double p = x > 0. ? 0.35 : x < -2. ? 1.9 : -1.;
	    return MAX (0., p - Zb);
	}
    }

• Small amplitude solitary wave interacting with a parabolic hump

    Init {} {
	# Parabolic hump
	Zb = 0.8*exp(-5.*(x - 0.9)*(x - 0.9) - 50.*(y - 0.5)*(y - 0.5))
	# Initial free surface and perturbation
	P = (0.05 < x && x < 0.15 ? 1.01 : 1) - Zb
    }

• Cyclone-generated wave field

    Init { istep = 1 } {
        # Wind at 10 metres
        U10 = ur(x, y, t)
        V10 = vr(x, y, t)
    }

• 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 {} {
    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.;
    }
  }

• 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 }

• Translation of an hexagon in a uniform flow

  Init {} { U = 1 T = 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 }

• Oscillations in a parabolic container

    Init {} {
	Zb = h0*(x/a)*(x/a)
	P = MAX (0., h0 + Psi (x, 0.) - Zb)
    }

    Init { istep = 1 } {
	Pt = MAX (0., h0 + Psi (x, t) - Zb)
    }

• Circular dam break on a sphere

    Init {} { P = 0.2 + 1.8*P/LENGTH }

• Circular dam break on a rotating sphere

    Init {} { P = 0.2 + 1.8*P/LENGTH }

• Advection of a cosine bell around the sphere

  Init {} { T = bell(x,y,0) }