Contrib/waves2Foam

Valid versions:

NB: The code is only compatible with OpenFoam version 1.5 up to and including svn-revision number 1950.

NB: The code is also compilable on more recent versions of OpenFoam (2.0 and 2.1), however, the solvers are not distributed along with the SVN-repository. Nevertheless, minor changes are needed in order to modify interFoam to get it to work; see below.

Please report on successful applications of the toolbox.

1 waves2Foam

The package is to be used in the modelling of free surface water waves. The package contains the following:

• One library libwaves2Foam. See description below.
• Solver(s) to be used with 1.5 and 1.6+ (see below in section "Compatibility"). The foundation in the solvers is interFoam, where the relaxationZone part of libwaves2Foam has been added to the solver.
• Preprocessing tools used to:
  • setWaveParameters: Sets the wave parameters for a given wave theory based on a set of input variables. E.g. for Airy wave theory, the period, water depth, and magnitude of the gravitational acceleration produces the wave number. The utility goes through all sub-dictionaries in waveProperties file, see below.
  • setWaveField: This utility sets initial conditions in the files U and gamma (v. 1.5)/alpha1 (v. 1.6 and more recent) based on a runTime selectable wave theory.
  • relaxationZoneLayout: Produces an overview of the spatial layout of the relaxation zone.
• Tutorials
• Since setWaveParameters is not working for all wave theories, a set of Matlab® functions are provided for the missing wave theories (Currently: stream function waves and cnoidal first waves).

1.1 Referencing

Whenever used please do make proper referencing to the following journal paper:

@article { jacobsenFuhrmanFredsoe2011,
Author = {Jacobsen, N G and Fuhrman, D R and Freds\o{}e, J},
title = {{ A Wave Generation Toolbox for the Open-Source CFD Library: OpenFoam\textregistered{} } },
Journal = {{ Int. J. Numerl. Meth. Fluids} },
Year = {In print},
Volume = {},
Pages = {},
DOI = {{10.1002/fld.2726} },
}

According to the publisher, the article will not be officially published until ultimo 2012, however, an early view of the article is available at:

http://onlinelibrary.wiley.com/doi/10.1002/fld.2726/abstract

1.2 Ideas / Improvements / Suggestions / Contributions

If you have any ideas on how to improve this toolbox, or if you have developed pieces of code/functionalities, which you think would fit nicely into the framework, then please do not hesitate contacting me, e.g. via the cfd-online forum, where my user name is ngj.

2 Distributed Library

2.1 Overview of Content

Schematics of the code structure in the library

The library libwaves2Foam contains the following functionality:

• A namespace called waveTheories, where the abstract base class, waveTheory, defines the interface for the implementation of free surface water waves. At present the interface requires the definition of the velocity, the surface elevation, and the pressure gradient. It is optional to implement the actual pressure. The set of wave theories presently available is given below.

It is extremely simple to extend the number of implemented wave theories, as long as the needed algebraic expressions are available.

• An abstract base class called setWaveProperties. From this a definition file to each of the wave theories is implemented. These are addressed from the utility setWaveParameters, which sets the needed wave parameters for each wave theory based on a minimum of input parameters. Set below.
• A relaxation framework around the class relaxationZone, where combinations of relaxation techniques and the shape of relaxation zones can be chosen.
• convexPolyhedral This set of files carries out intersection routines between faces/convex polyhedrals and the water surface given in terms of e.g. an algebraic equation such as $\eta=a\sin (\omega t - \mathbf{k}\cdot\mathbf{x})$, where $\eta$ is the water surface elevation, $a$ is the wave amplitude, $\omega$ is the cyclic frequency, $t$ is time, $\mathbf{k}$ is the horizontal wave number vector, and $\mathbf{x}$ is a spatial coordinate. It should be noted that the intersection routine is not implemented in convexPolyhedral, but rather the relaxation zones and boundary conditions is derived from this class, and the virtual methods for the distance function is implemented. These again are based a pointer, namely autoPtr<waveTheories::waveTheory>, hence there is a decoupling of the relaxation zone techniques/boundary conditions and the actual wave theory used in the simulation.
• Furthermore boundary conditions and a class for setting initial conditions are part of the library.

2.2 Available Wave Theories

The library is distributed with the following wave theories

2.2.1 Current-type

2.2.1.1 Potential current type (uniform velocity distribution from bottom to seaLevel)

+++ Example - setWaveParameters and Running +++
waveType potentialCurrent;
Tsoft    <scalar>;
U        <vector>;

2.2.2 Regular waves

2.2.2.1 Stokes first order wave theory (Airy wave)

+++ Example - setWaveParameters +++
waveType   stokesFirst;
period     <scalar>;
depth      <scalar>;
direction  <vector>;
Tsoft      <scalar>; // Not required

+++ Example - Running +++
waveType   stokesFirst;
height     <scalar>;
omega      <scalar>;
phi        <scalar>;
depth      <scalar>;
waveNumber <vector>;
Tsoft      <scalar>; // Not required

2.2.2.2 First order Stokes standing wave theory

+++ Example - setWaveParameters +++
waveType   stokesFirstStanding;
period     <scalar>;
depth      <scalar>;
direction  <vector>;
Tsoft      <scalar>; // Not required

+++ Example - Running +++
waveType   stokesFirstStanding;
height     <scalar>;  // The height of each wave component
omega      <scalar>;
phi        <scalar>;
depth      <scalar>;
waveNumber <vector>;
Tsoft      <scalar>; // Not required

2.2.2.3 Stokes second order wave theory

+++ Example - setWaveParameters +++
waveType   stokesSecond;
period     <scalar>;
depth      <scalar>;
direction  <vector>;
Tsoft      <scalar>; // Not required

+++ Example - Running +++
waveType   stokesSecond;
height     <scalar>;
omega      <scalar>;
phi        <scalar>;
depth      <scalar>;
waveNumber <vector>;
debug      <bool>;   // If on: Writes to screen, if second order theory is invalid.
Tsoft      <scalar>; // Not required

2.2.2.4 Stokes fifth order wave theory

+++ Example - setWaveParameters +++
waveType    stokesFifth;
height      <scalar>;
period      <scalar>;
depth       <scalar>;
stokesDrift <scalar>;
direction   <vector>;
Tsoft       <scalar>; // Not required

+++ Example - Running +++
waveType    stokesFifth;
height      <scalar>;
omega       <scalar>;
phi         <scalar>;
depth       <scalar>;
waveNumber  <vector>;
Tsoft       <scalar>; // Not required

2.2.2.5 First order cnoidal theory

+++ Example - setWaveParameters +++
waveType    cnoidalFirst;
height      <scalar>;
depth       <scalar>;
period      <scalar>;

+++ Example - Running +++
waveType    cnoidalFirst;
height      <scalar>;
omega       <scalar>;
depth       <scalar>;
direction   <vector>;
m           <scalar>;
length      <scalar>;
celerity    <scalar>;
Tsoft       <scalar>; // Not required

NB: Note, that if the wave is extremely shallow, $m\rightarrow\infty$, so in order not to evaluate $K(m=1)=\infty$, the write precision in the controlDict should be sufficiently high in order to write e.g. 0.9999999999 in stead of 1.0.

2.2.2.6 Stream function wave theory

+++ Example - setWaveParameters +++
// Currently not working

+++ Example - Running +++
waveType   streamFunction;
omega      <scalar>;
depth      <scalar>;
phi        <scalar>;
waveNumber <vector>;
uBar       <scalar>;
N          <scalar>;
A          <scalarField>;
B          <scalarField>;
Tsoft      <scalar>; // Not required
Tstart     <scalar>; // Not required (Default 0.0);
Tend       <scalar>; // Not required (Default GREAT);

2.2.3 Solitary waves

2.2.3.1 Solitary First

+++ Example - setWaveParameters and Running +++
waveType  solitaryFirst;
height    <scalar>;
depth     <scalar>;
direction <vector>;
x0        <vector>;

2.2.4 Irregular waves

2.2.4.1 First order bi-chromatic wave train (wave group)

+++ Example - setWaveParameters +++
waveType    bichromaticFirst;
period1     <scalar>;
period2     <scalar>;
depth       <scalar>;
direction1  <vector>;
direction2  <vector>;
Tsoft       <scalar>; // Not required

+++ Example - Running +++
waveType    bichromaticFirst;
height1     <scalar>;
height2     <scalar>;
omega1      <scalar>;
omega2      <scalar>;
phi1        <scalar>;
phi2        <scalar>;
depth       <scalar>;
waveNumber1 <vector>;
waveNumber2 <vector>;
Tsoft       <scalar>; // Not required

2.2.4.2 General irregular wave theory

This wave theory reads the needed scalarFields and vectorFields from waveProperties and generates an irregular wave field through superposition of wave components based on linear wave theory. If higher order components are needed, it is suggested to modify the interface to make it generic; e.g. parsing ampEta, ampU, and ampV instead of merely ampEta.

+++ Example - setWaveParameters +++
waveType    irregular;
spectrum    <word>;
N           <label>;
Tsoft       <scalar>;

+++ Example - Running +++
Use setWaveParameters

Furthermore, information requested by the individual spectra are needed. The list of implemented spectra is:

• JONSWAP (Uses frequency stretching to have more frequencies around the peak. Limitations: $f_{low}=0.3f_p$ and $f_{high}=3.0f_p$, where $f_p=1/T_p$)

writeSpectrum <Switch>;
Hs            <scalar>;
Tp            <scalar>;
gamma         <scalar>;
depth         <scalar>;
direction     <vector>;

• Pierson-Moskowitz (Uses frequency stretching to have more frequencies around the peak. Limitations: $f_{low}=0.3f_p$ and $f_{high}=3.0f_p$, where $f_p=1/T_p$)

writeSpectrum <Switch>;
Hs            <scalar>;
Tp            <scalar>;
depth         <scalar>;
direction     <vector>;

The source code is currently being extended in order to allow for the specification of spreading functions for the wave generation of 3-dimensional irregular sea states.

2.2.5 Other

2.2.5.1 combinedWaves, which allows for a combination of any of the above

+++ Example - setWaveParameters and Running +++
waveType            combinedWaves;
combinedWaveNames   <workList>; // A list of names of the other sub-dictionaries without the Coeffs-part

2.3 Relaxation Techniques

Relaxation techniques generally cover the method of removing reflected or internally generated wave components adjacent to vertical boundaries. One method is currently fully functioning and the framework have been made ready for another type. Both of these are a part of the overall relaxation framework, which is implemented into relaxationZone. The latter is the one implemented into the solvers to add the relaxation functionalities. The relaxation methods are:

2.3.1 Explicit Relaxation

The explicit relaxation techniques is performed before the momentum equation is solved in the following manner:

$\mathbf{u} = (1-w)\mathbf{u}_{target}+w\mathbf{u}_{computed}$

$\alpha = (1-w)\alpha_{target}+w\alpha_{computed}$

where $w\in[0,\,1]$ is a weigthing function. One particular method is implemented, however, everything is done with runTime-selection, so it should be rather easy to make another method and test it.

Interface:

void relaxationZone::correct()

2.3.2 Numerical Beach

The numerical beach considers the addition of an artificial viscosity into the momentum equation.

A framework has been made ready with runTime selection, however, presently only a dummy-beach is implemented, which does not alter the artificial viscosity from the default value of 0.0. The numerical beach has direct access to the local distance function, $\sigma$, in the relaxation zone, thus it ought to be straight forward to implement a given method.

Interface:

tmp<volScalarField> relaxationZone::numericalBeach()

2.3.3 Relaxation Shapes

Relaxation shapes defines the shape and relaxation direction of the relaxation zone. The available shapes and their input format are

2.3.3.1 Rectangular

relaxationZone
{
    relaxationShape Rectangular;

    relaxType   INLET;
    startX      (90 90 0);
    endX        (100 100 0);
    orientation (0 1 0);
}

Generates a rectangular relaxation zone, which primary axis in the plane is along orientation. If the target solution is wanted in startX, then relaxType should read INLET. If the target solution is wanted in endX, then relaxType should read OUTLET. It holds for the inner product $(\mathbf{x}_{end}-\mathbf{x}_{start})\boldsymbol{\cdot}\mathbf{e}_{orientation}>0$.

2.3.3.2 Cylindrical

relaxationZone
{
    relaxationShape Cylindrical;
   
    centre   (70 70 0);
    rInner   15;
    rOuter   25;
}

Generates a cylindrical relaxation zone, where the target solution is enforced along the outer radii.

2.3.3.3 SemiCylindrical

relaxationZone
{
    relaxationShape SemiCylindrical;
    
    centre             (30 30 0);
    rInner             5;
    rOuter             25;
    zeroAngleDirection (1 0 0);
    angleStart         45;
    angleEnd           220;
}

Generates a semi-cylindrical relaxation zone, where the target solution is enforced along the outer radii. In addition the user needs to specify the direction of primary axis in the unit circle, zeroAngleDirection. The two angles, angleStart and angleEnd, must be in the interval $[-180^\circ,\,+180^\circ]$.

3 Applications

3.1 waveFoam

waveFoam is based on the original implementation of interFoam. Modifications are made to make it possible to use the relaxation zone framework with the solver.

3.2 waveFoam - How to Modify interFoam

For more recent versions of OpenFoam, the toolbox is not straightforward applicable, as the user (for the time being), needs to create waveFoam him-/herself from interFoam. Here are the necessary steps:

• Copy the files, which belong to interFoam into a new folder. E.g. disregard all files related to the derived multiphase solvers. Rename interFoam.C to waveFoam.C

• Add the following line in waveFoam.C

#include "relaxationZone.H"

• Inside main in waveFoam.C add the following two lines just below #include "initContinuityErrs.H" and above createFields.H

#include "readGravitationalAcceleration.H"
#include "readWaveProperties.H"

• After the line in waveFoam.C stating #include "alphaEqnSubCycle.H" add

relaxing.correct();

• Furthermore in createFields.H, one should delete the line stating

#include "readGravitationalAcceleration.H"

• And add the following at the very bottom

relaxationZone relaxing(mesh, U, alpha1);

• The output should be placed in FOAM_USER_APPBIN, so modify Make/files so it reads

waveFoam.C

EXE = $(FOAM_USER_APPBIN)/waveFoam

• In order to make it compilable one should add the following in Make/options under EXE_INC:

-DOFVERSION=<Replace brackets with the first two digits in the OF-version number> \
-I./../../../../src/lnInclude

• and similar below the EXE_LIBS part:

-L$(FOAM_USER_LIBBIN) \
-lwaves2Foam

• Do remember to add the necessary "\" in Make/options for it to read the additional lines.

3.3 waveDyMFoam - How to couple waves2Foam with dynamic mesh motion

Step-by-step guide about how to couple the CFD ToolBox waves2Foam with dynamic mesh motion

1. Copy the folder of solver interDyMFoam in the wave2Foam solver folder for version which you use, for example, for version 1.7.1:

cp -r $WM_PROJECT_DIR/applications/solvers/multiphase/interFoam/interDyMFoam $WM_PROJECT_USER_DIR/applications/solvers/waves2Foam/applications/solvers/solvers17/waveFoam/

2. Now modify the name of copied folder to waveDyMFoam (or whatever name you want... but it looks fine):

cd $WM_PROJECT_USER_DIR/applications/solvers/waves2Foam/applications/solvers/solvers17/waveFoam
mv interDyMFoam/ waveDyMFoam

3. Clean the compiled solver and modify the name of C file:

cd waveDyMFoam
wclean
mv interDyMFoam.C waveDyMFoam.C

4. Now we must follow the guidelines in section 3.2 (but with some difference, as for example, we don’t need modify createFields.H since it’s read from one level-up):

• Add the following line in waveDyMFoam.C

#include "relaxationZone.H"

• Inside main in waveDyMFoam.C add the following two lines just below #include "initContinuityErrs.H" and above createFields.H

#include "readGravitationalAcceleration.H"
#include "readWaveProperties.H"

• After the line in waveDyMFoam.C stating #include "alphaEqnSubCycle.H" add

relaxing.correct();

5. Now we need set properly the Make files. First, open and modify ‘Make/files’:

waveDyMFoam.C

EXE = $(FOAM_USER_APPBIN)/waveDyMFoam

6. And in ‘Make/options’ do:

• After -I$(LIB_SRC)/dynamicFvMesh/lnInclude \ add:

-I./../../../../../src/lnInclude

• And add the following lines at the very bottom

-L$(FOAM_USER_LIBBIN) \
-lwaves2Foam

• REMEMBER to add the two new needed \ at the end of lines:

-I$(LIB_SRC)/meshTools/lnInclude
-ltopoChangerFvMesh

7. At main directory, compile the new solver typing:

wmake

8. It’s done ;)

This tutorial section is an adaptation to wiki from:

https://sites.google.com/site/jordimuela/openfoam/how-to-couple-waves2foam-with-dynamic-mesh-motion

4 Utilities

4.1 Pre-processing

4.1.1 setWaveParameters

This utility runs through every sub-dictionary (SD) in the dictionary waveProperties. A pointer to a derived class of setWaveProperties is generated for each SD; the pointer is based on the entry waveType. If the necessary input is available, any additional wave parameter, which is needed in the simulation is written to SD.

4.1.2 relaxationZoneLayout

A tool for visualising the relaxation fields in the computational domain. It also depicts the orientation of the relaxation zone. A tutorial is availabel.

4.1.3 setWaveField

This utility sets the initial condition in the computational domain. The entry initializationName in waveProperties defines which sub-dictionary is used for initialising the wave field.

NB! Note that the ramp-up factor is multiplied onto the expressions also during initialization of the computational domain. Hence, in order not to get a horizontal water surface and stagnant water, the parameter Tsoft should be given a value of 0.0; Tsoft is typically set to the wave period as default and is not required by most of the wave theories.

4.2 Post-processing / Run-Time Processing

4.2.1 surfaceElevation

This utility is a specialisation of the OpenFoam/src/sampling/sampledSet/sampledSets in such a way that the sampled (scalar) quantity is integrated along a line defined in the file surfaceElevationDict. The utility is intended to by used as a post-processing utility, where the void ratio field is integrated along a vertical line, which yields the location of the free surface.

Since it is a specialisation of the native sample-utility, it runs both in serial and parallel modes. The two calls are as

surfaceElevation [-latestTime] [-time ranges]
mpirun -np NPROCS surfaceElevation -parallel [-latestTime] [-time ranges]

4.2.1.1 Input File

An example of the input file is placed in applications/utilities/postProcessing/surfaceElevation. The rules are the same as for sampleDict, however, it only makes sense to sample the void ratio field, e.g. gamma or alpha1.

The utility only considers scalar fields.

4.2.1.2 Output File

The output file is placed in surfaceElevation/startTime/surfaceElevation.dat, and it contains all the sampled data for all sampled time steps. The formatting is as follows:

Time lineName0 lineName1 lineName2 // Merely some string references
-1   x0        x1        x2        // The x-coordinates of the first point on the sampling line. -1 has no meaning.
-2   y0        y1        y2        // The y-coordinates of the first point on the sampling line. -2 has no meaning. 
-3   z0        z1        z2        // The y-coordinates of the first point on the sampling line. -3 has no meaning.
0.0  eta0      eta1      eta2      // The elevation for Time = 0.0 s
0.1  eta0      eta1      eta2      // The elevation for Time = 0.1 s
0.2  eta0      eta1      eta2      // The elevation for Time = 0.2 s
0.3  eta0      eta1      eta2      // The elevation for Time = 0.3 s
0.4  eta0      eta1      eta2      // The elevation for Time = 0.4 s
0.5  eta0      eta1      eta2      // The elevation for Time = 0.5 s

4.2.1.3 Why -1e15 ?

The value -1e15 is written to the output file under the following circumstances:

• The number of points along the integration line is less than 2.
• Both the top and the bottom integration points are either 0 or 1 within a tolerance of 0.0001. -1e15 is preferred as this suggests the integration line to be fully inside or outside of the water column.

4.2.1.4 Used as FunctionObject

The utility can also be used as a functionObject. The tutorial waveFlume includes an example on how to use it.

In this mode a couple of additional time controls has been implemented into surfaceElevation. These are

samplingStartTime <scalar>; // Default value: 0.0

This stalls the sampling of the interface location until the specified starting time is exceeded.

surfaceSampleDeltaT <scalar>; // Default value: -1.0

This value only has an effect, if it is strictly larger than 0.0. It modifies the output time for the sampling, so it is not control by neither a constant number of time steps nor the global output time. This allows for a sub-time step output of the surface elevation and thus saves disk space. This delta time does not feed back into the global setting of the time step, thus the output is only at intervals of approximately surfaceSampleDeltaT, where the accuracy obviously increases with decreasing deltaT / surfaceSampleDeltaT. So forth this ratio exceeds 1, one or more outputs is simply omitted.

For optimal uses of the surfaceSampleDeltaT, it is also recommended to specify the following

outputControl timeStep;
outputInterval 1;

4.2.1.5 Compatibility

This utility has been tested for compatibility with OF-1.6, OF-1.7, OF-2.0 and OF-2.1.

The utility does not compile with OF-1.5.

5 waveProperties File

The file: waveProperties is to be placed in constant and must contain the following:

seaLevel 0.0; // Defines the still water level

wind (0.0 0.0 0.0); // Defines the velocity in the air part. Not needed. Default value:= vector::zero.

relaxationNames ( <word0> <word1> ); // The list of names of the relaxation zones used in the simulation

initializationName <wordN>; // Used by setWaveField and is the sub-dictionary, 
                            // which defines what wave theory to use for initialization

Furthermore, sub-dictionaries are needed for every boundary, which uses any of the boundary conditions:

waveAlphaFvPatchScalarField    (type: waveAlpha)
wavePressureFvPatchScalarField (type: wavePressure)
waveVelocityFvPatchVectorField (type: waveVelocity)

and for all of the relaxationNames and the initializationName. The name of the sub-dictionaries are e.g.

<word0>+Coeffs

Please note that if an boundary called inlet uses one or several of the boundary conditions, then it is allowed for instance to have a relaxation zone called inlet in order not to duplicate the input.

An example of a combined boundary and relaxation zone input is given here, where Stokes first order wave theory (Airy wave) is the input

inletCoeffs
{
   // Wave type to be used at boundary "inlet" and in relaxation zone "inlet"
   waveType    stokesFirst;  
    
   // Ramp time of 2 s
   // Foam::sin(2 * mathematicalConstant::pi / (4.0 * Tsoft_) * Foam::min(Tsoft_, runTime.time().value() ))
   // and explicitly "1" for Tsoft = 0
   Tsoft       2;

   // Water depth at the boundary and in the relaxation zone
   depth       0.400000;

   // Cyclic wave frequency
   omega       3.141593;

   // Phase shift in the wave
   phi         0.000000;

   // Wave number vector, k. 
   waveNumber  (1.70048 0.0 0.0);

   // Wave height
   height      0.1;
    
   // Specifications on the relaxation zone shape and relaxation scheme
   relaxationZone
   {
       relaxationScheme Spatial;
       relaxationShape  Rectangular;
       beachType        Empty;
   
       startX           (0 0.0 -1);
       endX             (5 0.0  1);
       orientation      (1.0 0.0 0.0);
   }
};

6 Tutorials

6.1 Relaxation Zone Layout

• Name: tutorials/relaxationZoneLayout
• Utility: relaxationZoneLayout
• Description: This tutorial will show how to use the utility to obtain a visual on the relaxation zones. This could be helpful to detect potential problems in the setup.

6.2 Wave Flume

• Name: tutorials/waveFoam/waveFlume
• Solver: waveFoam
• Description: This tutorial will show the user how to use the constant/waveProperties dictionary to set-up the wave properties, relaxation zones and initialization specifications.

6.3 Standing Wave

• Name: tutorials/waveFoam/standingWave
• Solver: waveFoam
• Description: This tutorial shows how to handle wave generation and a fully reflecting sea wall utilising the relaxation zone technique.

6.4 3D Wave Flume with a Seawall

An example of the surface elevation with waves from 3 directions onto a vertical structure.

• Name: tutorials/waveFoam/3Dwaves
• Solver: waveFoam
• Description: This tutorial shows the use of relaxation zones in 3 dimensions. There are 3 inlet relaxation zones and one outlet relaxation zone. In the middle of the wave tank there is a vertical internal wall on which the waves are reflected. The waves, which are generated in the 3 inlet relaxation zones, have different directions relative to the $x$-axis.

NB: Some reflection does occur on the wall perpendicular to the wave outlet.

6.5 Periodic Solitary

• Name: tutorials/waveFoam/periodicSolitary
• Solver: waveFoam
• Description: This tutorial uses the method for initialising a wave profile, which is different from a flat water surface with a sea-level, which differs from 0 m. The computational domain is cyclic in the direction of wave propagation and the initial field is a solitary wave.

NB: In the simulation a portion of the wave propagates in the opposite direction of the actual wave propagation. It is considered to be due to the fact that the solitary wave theory does not fulfil the non-linear wave problem accurately enough, which is why a part of the wave energy is reflected on the wave itself. It has been tested to initialise with and without the analytical expression for the excess pressure, however, it does not make a difference. Experimental evidence of this behaviour is reported in .

6.6 Square Pile in Cylindrical Domain

The surface elevation around a square pile in a constant and unidirectional current. The gray area is the relaxation zone.

• Name: tutorials/waveFoam/squarePile
• Solver: waveFoam
• Description: This tutorial shows how to use the cylindrical relaxation zone. A unidirectional current is the target function all the way around, hence one relaxation zone acts as both generation and absorption. The relaxation zone removes the internally generated surface disturbances. It could be interesting to have it tested for ships waves. Alternatively, a better shape for that purpose, e.g. an elliptical relaxation zone shape could be implemented.

NB: Generating waves in the computational domain in this tutorial will give bad results. This is a direct consequence of the huge variation in cells per wave length depending on the location in the domain and not the relaxation method! Particular attention should be given to circular domains with waves.

7 Compatibility

The toolbox has been tested successfully with the following releases of OpenFoam:

• 1.5.x
• 1.5-dev
• 1.6.x (Notice, that the release solves for total pressure, and the pressure boundary condition is given in excess pressure. It ought not change anything, however, it has not been tested)
• 1.6-ext
• 1.7.1

Because of considerable changes in the source code of OpenFoam between version 1.5 and 1.6, there exist a solvers15 and a solvers directory. Please also note that throughout the code, pre-processor choice are made based on the argument OFVERSION, which is given as

OFVERSION=`echo $WM_PROJECT_VERSION | sed -e 's/\./\n/g' -e 's/-/\n/' | grep "[0-9]" | head -2 | tr -d '\n'`

which strips anything but the first two numbers from $WM_PROJECT_VERSION.

Furthermore note, that the dev/ext branches has an additional library called liblduSolvers.so, hence in the Allwmake script, linking to this particular library is stripped from all solvers, if $WM_PROJECT_VERSION contain neither of the strings dev and ext. Moving to these versions it is henceforth recommended to make a clean checkout.

8 Development / On-going and Future

• In connection with each of the wave theories in src/waveTheories/, there should be a corresponding file in src/setWaveProperties/, which computes all of the necessary properties based on a minimum number of inputs, e.g. have height, $H$, water depth, $h$, and wave period, $T$.

This work is still ongoing, hence for those waves missing a property-file, the pre-processing tool setWaveParameters will fail.

• Tests with other outlet boundary types
• The pressure gradient points in the direction of the boundary face, irrespectively of the fact that it should be corrected for the angle between wave propagation and the direction of the boundary face.
• The pressure gradient is not implemented in all of the wave theories - returns instead $\partial p/\partial n = 0.0$.

9 Download and Installation

9.1 Dependencies

Besides the standard dependencies in OpenFoam, waves2Foam also depend on Gnu Scientific Library (GSL). This is needed for two reasons:

• In the cnoidal wave theory one has to evaluate Jacobian elliptic functions and complete elliptic integrals. These are not natively available in OpenFoam.
• A pre-processing tool, which is currently being developed, computes the needed wave parameters giving the minimal number of input parameters. This quickly results in a set of $N$ non-linear sets of equations in $N$ unknowns. For this purpose GSL is currently being used.

GSL can e.g. be downloaded using the following commands

Ubuntu: sudo apt-get install libgsl0-dev
Fedora: sudo yum install gsl-devel
Suse:   sudo zypper install gsl-devel

Please be aware that the location for GSL might differ between OS's, hence the include paths in the options-files could be wrong. If you have successfully installed GSL and the compilation complains over missing header files or libraries, this is the first place to look.

9.2 SVN on SourceForge

The toolbox is available through the OpenFoam-Extend SourceForge SVN. Check out the code in the following manner:

svn co https://openfoam-extend.svn.sourceforge.net/svnroot/openfoam-extend/trunk/Breeder_1.6/other/waves2Foam

9.3 Installation

• Install GSL as described above
• Obtain the source code via SVN as described above
• Execute the Allwmake script in the folder waves2Foam

10 History

• 2012-06-08 12:09:21: (r1967) Added some post-processing utilities to be used in matlab and modified the misc/matlab file structure. Minor bug-fix in generateStreamFile.m so the output file is consistent with the format in waves2Foam.
• 2012-05-16 10:44:43: (r1966) Corrected bug in matlab script for stream function theory (previous results correct, if the program could finalise!)
• 2012-05-15 12:01:18: (r1965) Additional output time control for the surfaceElevation utility. Especially needed under functionObject functionality
• 2012-05-10 14:37:47: (r1961) Added a optional starting time for the surface elevation sampling
• 2012-05-09 14:18:23: (r1960) Added phase-lag (phi_) in streamFunction.C
• 2012-05-03 13:22:43: (r1953) Added functionObject functionality for sampledSurfaceElevation. Included in the tutorial waveFlume.
• 2012-05-02 10:11:01: (r1952) Modification to Allwmake and src/Allwmake so "sed" also works under Mac OSX.
• 2012-04-30 21:28:20: (r1951) Added a post-processing utility, which can be used to extract the surface elevation. As of now, version 1.5 is no longer supported.
• 2012-04-11 10:13:10: (r1947) Bug in Allwmake script
• 2012-03-26 21:45:20: (r1945) Changed the way setWaveProperties output irregular wave properties. Adjusted irregular waveTheory accordingly.
• 2012-03-17 15:56:02: (r1944) Solved bug in convexPolyhedral. Furthermore added an addition relaxation shape (semiCircular)
• 2012-03-13 16:13:42: (r1943) Minor changes
• 2012-02-19 14:45:14: (r1940) Added the possibility of a wind vector, which is constant in space and time.
• 2012-01-29 19:15:41: (r1938) Changed the Make/files and Make/options to have the output files in FOAM_USER_LIBBIN and FOAM_USER_APPBIN.
• 2012-01-28 15:55:34: (r1937) Added a Pierson-Moskowitz spectrum
• 2012-01-27 13:28:00: (r1936) Added framework for irregular wave spectra - properties and wave theory
• 2012-01-24 13:20:58: (r1935) Small changes to src/Make/files and the overall Allwmake script in order to avoid the recompilation of waves2Foam on non-dev/ext versions of OF
• 2012-01-19 16:50:48: (r1934) Modified the code, so PI can be used both in pre- and post-2.0 versions of OpenFoam. It is replaced by PI_(4.0*atan(1.0)) a few neccesary places as a protected member variable.
• 2011-12-04 20:07:35: (r1932) Added a tutorial showing how to generate a standing wave from a fully reflecting sea wall
• 2011-11-22 10:02:44: (r1929) Added a tutorial utilising the cylindrical relaxation zone
• 2011-11-19 01:01:19: (r1928) Added "waveFoam" for 1.7, modified Allwmake script and added necessary files to tutorials due to above change.
• 2011-11-16 19:22:22: (r1937) setWaveParameters now also works for cnoidalFirst
• 2011-11-14 20:04:08: (r1926) Added matlab tools for cnoidal and stream function waves
• 2011-11-14 17:52:52: (r1925) Added a 3D wave tank tutorial
• 2011-11-10 11:30:30: (r1923) Initial release of waves2Foam - all files

11 Also Used in These Works

• Bredmose, H. and Jacobsen, N. G. (2010). Breaking Wave Impacts on Offshore Wind Turbine Foundations: Focused Wave Groups and CFD. Proceedings of the 29th ASME International Conference on Ocean, Offshore and Arctic Engineering, Shanghai, China, 3, 397-404
• Bredmose, H. and Jacobsen, N. G. (2011). Vertical wave impacts on offshore wind turbine inspection platforms. Proceedings of the 30th ASME International Conference on Ocean, Offshore and Arctic Engineering, Rotterdam, The Netherlands (on CD)
• Jacobsen, N. G. (2011). A Full Hydro- and Morphodynamic Description of Breaker Bar Development. Ph.D. Thesis. DCAMM Special Report no. S136, Technical University of Denmark, Deparment of Mechanical Engineering. Available at [1], [2] or [3]
• Jacobsen, N. G. and Fredsøe, J (2011). A Full Hydrodynamic Modelling of 2D Breaker Bar Development. Proceedings to Coastal Sediments, Miami, Florida, U.S.A.
• Paulsen, B. T., Bredmose, H. and Bingham, H. B. (2012). Accurate computation of wave loads on a bottom fixed circular cylinder. International Workshop on Water Waves and Floating Bodies, Copenhagen, Denmark (http://www.iwwwfb.org)

12 References

---

--NGJ 20:10, 04 December 2011 (CET)