# GfsWave

Revision as of 02:24, 15 May 2009; view current revision

### Examples

• "Garden sprinkler effect" in wave model
• ```1 0 GfsWave GfsBox GfsGEdge {} {
Refine 6

# Default time units for wave model is hours
# 120 hours = 5 days
Time { end = 120 }

# Default length units for wave model is km
PhysicalParams { L = 5000 }

# Define some useful functions
Global {
/* gaussian distribution */
static double gaussian (double f, double fmean, double fsigma) {
return exp (-((f - fmean)*(f - fmean))/(2.*fsigma*fsigma));
}
/* cos(theta)^n distribution */
static double costheta (double theta, double thetam, double thetapower) {
double a = cos (theta - thetam);
return a > 0. ? pow (a, thetapower) : 0.;
}
}

# Initialise the wave spectrum
InitWave {} {
/* This function defines the spectral distribution:
* a gaussian in frequency space and
* a cos(theta)^2 distribution in direction space
*/
return gaussian (Frequency, 0.1, 0.02)*
costheta (Direction, 30.*M_PI/180., 2.);
} {
/* This function defines the significant wave height:
* the energy is a gaussian bump in (x,y) space,
* the maximum significant wave height is 2.5
*/
x -= -2000.;
y -= -2000.;
double Hsmax = 2.5;
double E = (Hsmax*Hsmax/16.)*gaussian (sqrt (x*x + y*y), 0., 150.);
return 4.*sqrt (E);
}

AdaptGradient { istep = 1 } { cmax = 0.04 minlevel = MINLEVEL maxlevel = 6 } Hs

OutputTime { istep = 1 } log-MINLEVEL-NTHETA
OutputScalarStats { step = 12 } hs-MINLEVEL-NTHETA { v = Hs }
OutputSimulation { step = 12 } sim-MINLEVEL-NTHETA-%g.gfs
EventScript { step = 12 } { gzip -f sim-*-*-*.gfs }
OutputSimulation { start = end } end-MINLEVEL-NTHETA.gfs
EventScript { start = end } { gzip -f end-*-*.gfs }
OutputPPM { step = 12 } { ppm2mpeg > hs-MINLEVEL-NTHETA.mpg } { v = Hs maxlevel = 7 }
} {
# Number of discretised directions (default is 24)
ntheta = NTHETA
}
```

• Cyclone-generated wave field
• ```1 0 GfsWave GfsBox GfsGEdge {} {
Refine 4

# Run for 48 hours
Time { end = 48 }

# Domain size is 3328 km
PhysicalParams { L = 3328 }

# Define some useful functions
Global {
/* gaussian distribution */
static double gaussian (double f, double fmean, double fsigma) {
return exp (-((f - fmean)*(f - fmean))/(fsigma*fsigma));
}
/* cos(theta)^n distribution */
static double costheta (double theta, double thetam, double thetapower) {
double a = cos (theta - thetam);
return a > 0. ? pow (a, thetapower) : 0.;
}
/* Holland cyclone model */
static double holland(double r, double Rmax, double Vmax) {
if (r < Rmax/1e3) return 0.;
return Vmax*pow(Rmax/r, 2)*exp(2.*(1. - Rmax/r));
}
/* Position of the center of the cyclone */
double ut = 555./24.; /* km/h */
static double xc (double t) {
return 0.;
}
static double yc (double t) {
return 1110. - ut*t;
}
/* Intensity of the cyclone as a function of time */
static double vmax (double t) {
return 50.*(t < 25. ? t/25. : 1.);
}
/* velocity components */
static double ur (double x, double y, double t) {
x -= xc (t);
y -= yc (t);
double r = sqrt (x*x + y*y);
return holland (r, 100., vmax (t))*y/r;
}
static double vr (double x, double y, double t) {
x -= xc (t);
y -= yc (t);
double r = sqrt (x*x + y*y);
return - holland (r, 100., vmax (t))*x/r;
}
}

# Use source terms from WaveWatch III
GModule wavewatch

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

# Adapt the mesh according to the error in significant wave height
AdaptError { istep = 1 } { cmax = 0.1 minlevel = 4 maxlevel = LEVEL c = Hse } Hs
# Adapt the mesh according to the error in the norm of the forcing wind field
AdaptError { istep = 1 } {
cmax = 0.2 minlevel = 4 maxlevel = LEVEL c = Ve
} sqrt(U10*U10 + V10*V10)

# Output time at every timestep
OutputTime { istep = 1 } stderr
# Output simulation size
OutputBalance { istep = 1 } stderr
# Output timing statistics every 100 timesteps
OutputTiming { istep = 100 } stderr

# Output significant wave height to file hs, every quarter of an hour
OutputScalarStats { step = 0.25 } hs { v = Hs }
# Output norm of wind velocity to file vr, every quarter of an hour
OutputScalarStats { step = 0.25 } vr { v = sqrt(U10*U10 + V10*V10) }

# Output simulation to standard output for visualisation with GfsView
OutputSimulation { istep = 10 } stdout
# Output simulation results every 4 hours
OutputSimulation { step = 4 } sim-%g.gfs
# Compress the files to save disk space
EventScript { step = 4 } { gzip -f sim-*.gfs }
# Create movies of significant wave height and level of refinement
OutputPPM { istep = 1 } { ppm2mpeg > hs.mpg } { v = Hs maxlevel = 9 }
OutputPPM { istep = 1 } { ppm2mpeg > level.mpg } { v = Level min = 4 max = LEVEL maxlevel = 9 }

# Create figures at the end of the simulation
EventScript { start = end } {
for i in 12 24 36 48; do
echo "Save hs-\$i.eps { format = EPS }" | gfsview-batch2D sim-\$i.gfs.gz hs.gfv
echo "Save mesh-\$i.eps { format = EPS }" | gfsview-batch2D sim-\$i.gfs.gz mesh.gfv
done
echo "Save shifted.eps { format = EPS }" | gfsview-batch2D sim-48.gfs.gz shifted.gfv
cat <<EOF | gnuplot
set term postscript eps color lw 2 18
set output 'hsmax.eps'
set xlabel 'Time (hours)'
set ylabel 'Amplitude (m or m/s)'
set xtics 0,12,48
set grid
plot 'hs' u 3:11 w l t 'max(Hs)', 'vr' u 3:11 w l t 'max(|U10|)'
EOF
}
} {
# Garden Sprinkler Effect alleviation parameter
alpha_s = ALPHA
}
```