LabRPS Documentation - User contributions [en]

Std DependencyGraph

2025-03-01T21:09:31Z

LabRPS: Created page with "{{TOCright}} == Description == The Dependency graph view displays the dependencies between objects in the active document in a graph. As opposed to the Tree view, objects are listed in reverse chronological order, with the first created object at the bottom. It can be useful in analyzing a LabRPS document and locating forks in a tree. The dependency graph is for now purely a visualization tool, therefore it cannot be edited. It a..."

{{TOCright}}

== Description ==

The [[Dependency graph view|Dependency graph view]] displays the dependencies between objects in the active document in a graph. As opposed to the [[Tree_view|Tree view]], objects are listed in reverse chronological order, with the first created object at the bottom. It can be useful in analyzing a LabRPS document and locating forks in a tree. The dependency graph is for now purely a visualization tool, therefore it cannot be edited. It automatically updates if changes are made to the document. The [[Dependency graph view|Dependency graph view]] is a component of the LabRPS [[interface]]. By default it shows nothing.

[[Image:DependencyGraphView_example.png|800px]]

{{Caption|Example of a dependency graph with simulation of wind velocity having a mean wind profile and a wind spectrum.}}

==Installation==

To have the graph displayed in the dependency graph view, a third-party software named [https://graphviz.org/ Graphviz] needs to be installed. If you do not have it pre-installed or it is installed in an unconventional location, LabRPS will display the following dialog:

[[File:LabRPS-0.1-missing-Graphviz-error-dialogue.png]]

===Windows===

Download the '''graphviz-2.xx''' installer from the [https://graphviz.org/download/#windows Graphviz Download page] and launch it to install it. Some older versions seem to have issues displaying the graph; version 2.38 and newer are known to be reliable. You can find all graphviz releases on [https://gitlab.com/graphviz/graphviz/-/releases Gitlab].

===macOS===

You can install Graphviz using [https://brew.sh/ Homebrew] if you have macOS Big Sur (11) (or higher). While installing Homebrew, don't get nervous, if macOS asks you to install updates, e.g. for the Xcode commandline tools. These updates are performed later by the installation process.

{{Code|lang=text|code=
brew install graphviz
}}

This installs the Graphviz binaries under {{FileName|/usr/local/bin}} for macOS on Intel, or {{FileName|/opt/homebrew}} for macOS on Apple Silicon/ARM. LabRPS should automatically find these locations. If the Graphviz program is not found you will be asked to specify a path. Unfortunately we can't navigate directly to the program in the file dialog. There are two options: You can use the key combination Cmd+Shift+. to show hidden items. Or you can use the key combination Cmd+Shift+G to get an input field for the path. Enter one of these paths in the [https://en.wikipedia.org/wiki/Terminal_(macOS) Terminal]:

{{Code|lang=text|code=
/usr/local/bin
}}

or:

{{Code|lang=text|code=
/opt/homebrew/bin
}}

and confirm the input field and the file selection dialog.

In case the Graphviz binaries are installed in a non-standard location try to find the program with the command:

{{Code|lang=text|code=
type dot
}}

It will output something like:

{{Code|lang=text|code=
dot is /usr/local/bin/dot
}}

And you can tell LabRPS to look in that directory.

If you don't have macOS Big Sur (11) (or higher) Homebrew might not work, but you can use [https://www.macports.org/index.php MacPorts] instead. Just download the [https://www.macports.org/install.php appropriate version for your OS]. Once the installation is complete, enter this command in the [https://en.wikipedia.org/wiki/Terminal_(macOS) Terminal]:

{{Code|lang=text|code=
sudo port install graphviz
}}

Enter your password and wait while the dependencies are downloaded and installed (it can take some time).

The Graphviz binaries may be under {{FileName|/usr/local/bin}} or {{FileName|/opt/local/bin/dot}}. LabRPS may automatically find the Graphviz program with the file dialog that, if not enter this command:

{{Code|lang=text|code=
type dot
}}

It will output something like:

{{Code|lang=text|code=
dot is /opt/local/bin/dot
}}

And you can tell LabRPS to look in that directory as explained before.

It is also possible to make the opt directory visible with this command:

{{Code|lang=text|code=
defaults write com.apple.finder AppleShowAllFiles YES;
}}

then:

{{Code|lang=text|code=
killall Finder /System/Library/CoreServices/Finder.app;
}}

Therefore you can tell LabRPS to follow this path. It has been successfully tested on macOS 10.13 (High Sierra).

===Linux===

On most Linux distributions (Debian/Ubuntu, Fedora, OpenSUSE), you just need to install the Graphviz package from the repositories. However, similar to the macOS, in cases where the Graphviz binaries are installed in a non-standard location, try to find the program with the command:

{{Code|lang=text|code=
type dot
}}

It may output something like

{{Code|lang=text|code=
dot is /usr/local/bin/dot
}}

And therefore you can point LabRPS to look in that directory.

==Save==

You can save a dependency graph:
# Make sure the Dependency graph view is active.
# Select the {{MenuCommand|File → [[Std_Save|Save]]}} or {{MenuCommand|File → [[Std_SaveAs|Save As]]}} option from the menu.
# Enter a filename and select the file type (*.gv, *.png, *.bmp, *.gif, *.jpg, *.svg or *.pdf).
# Press the {{Button|Save}} button.

==General principles==

* The graph shows objects in reverse chronological order.
* The direction of arrows showing dependencies should always point down. An arrow pointing up indicates a cyclic dependency, an issue that needs to be resolved.
* Objects can have dependencies to multiple parents.
* A [[Std_Group|Group]] is displayed as a single element linked to its content.

{{Std_Base_navi}}
{{Userdocnavi}}

Simulation Models

2025-02-17T22:52:55Z

LabRPS:

{{Docnav
|[[Tutorials|Tutorials]]
|[[Plugins|Plugins]]
}}

{{TOCright}}

Here is a list of simulation models (methods) selected from various journal articles. The models presented here have been implemented in LabRPS and are available through either the [[Std_AddonMgr|Addon Manager]] or the [https://github.com/LabRPS/LabRPS-plugins plugin repository]. Please note that these models may be official plugins from the LabRPS team or community-contributed plugins.

{| class="wikitable sortable" width="100%"
|-
! No
! Model
! Title
! Year
! Phenomenon

|-
| 1
| [[Plugin_WindLab#George_Deodatis_Simulation_Method_1996|George Deodatis]]
| [https://doi.org/10.1061/(ASCE)0733-9399(1996)122:8(778) Simulation of Ergodic Multivariate Stochastic Processes]
| 1996
| Wind Velocity

|-
| 2
| [[Plugin_WindLab_DeodatisAndShinozuka1991|Masanobu Shinozuka and George Deodatis]]
| [https://doi.org/10.1115/1.3119501 Simulation of Stochastic Processes by Spectral Representation]
| 1991
| Wind Velocity

|}

{{Docnav
|[[Tutorials|Tutorials]]
|[[Plugins|Plugins]]
}}

{{Userdocnavi}}
[[Category:Tutorials]]

Simulation Models

2025-02-17T22:52:07Z

LabRPS:

{{Docnav
|[[Tutorials|Tutorials]]
|[[Plugins|Plugins]]
}}

{{TOCright}}

Here is a list of simulation models (methods) selected from various journal articles. The models presented here have been implemented in LabRPS and are available through either the [[Std_AddonMgr|Addon Manager]] or the [https://github.com/LabRPS/LabRPS-plugins plugin repository]. Please note that these models may be official plugins from the LabRPS team or community-contributed plugins.

{| class="wikitable sortable" width="100%"
|-
! No
! Model
! Title
! Year
! Phenomenon

|-
| 1
| [[Plugin_WindLab#George_Deodatis_Simulation_Method_1996|George Deodatis]]
| [https://doi.org/10.1061/(ASCE)0733-9399(1996)122:8(778) Simulation of Ergodic Multivariate Stochastic Processes]
| 1996
| Random Wind Velocity

|-
| 2
| [[Plugin_WindLab_DeodatisAndShinozuka1991|Masanobu Shinozuka and George Deodatis]]
| [https://doi.org/10.1115/1.3119501 Simulation of Stochastic Processes by Spectral Representation]
| 1991
| Random Wind Velocity

|}

{{Docnav
|[[Tutorials|Tutorials]]
|[[Plugins|Plugins]]
}}

{{Userdocnavi}}
[[Category:Tutorials]]

2025-02-15T21:13:48Z

LabRPS:

2025-02-08T16:03:13Z

LabRPS:

{{Plugin
|Name=SeaLab Plugin
|Description=This plugin implements various SeaLab features.
|Author=Koffi Daniel
|Version=1.0
|Date=2024-04-15
|Features= [[#Horizontal_Uniform_Distribution|Horizontal Uniform Distribution]], [[#Vertical_Uniform_Distribution|Vertical Uniform Distribution]], [[#Uniform_Distribution|Uniform Distribution]], [[#Grid_Points|Grid Points]], [[#General_Distribution|General Distribution]], [[#Import_Simulation_Points_from_File|Import Simulation Points from File]], [[#Uniform_Random_Phases|Uniform Random Phases]], [[#Uniform_Random_Phases_Import|Uniform Random Phases Import]], [[#Double_Index_Frequency_Discretization|Double Index Frequency Discretization]], [[#Single_Index_Frequency_Discretization|Single Index Frequency Discretization]], [[#Zerva_Frequency_Discretization|Zerva Frequency Discretization]], [[#Cholesky_Decomposition|Cholesky Decomposition]], [[#Pierson_Moskowitz_Spectrum_1964|Pierson Moskowitz Spectrum (1964)]], [[#Jonswap_Spectrum_1974|Jonswap Spectrum (1974)]], [[#Gaussian_Swell_Spectrum|Gaussian Swell Spectrum]], [[#Ochi_Hubble_Spectrum|Ochi-Hubble Spectrum]], [[#Torsethaugen_Spectrum|Torsethaugen Spectrum]],[[#Bretschneider_Spectrum|Bretschneider Spectrum]], [[#ISSC_Spectrum|ISSC Spectrum]], [[#ITTC_Spectrum|ITTC Spectrum]], [[#Scott_Spectrum|Scott Spectrum]], [[#WEN_Spectrum|WEN Spectrum]], [[#Cos2s_Directional_Spreading_Function|Cos2s Directional Spreading Function]], [[#Cosine_Squared_Directional_Spreading_Function|Cosine Squared Directional Spreading Function]], [[#Hasselmann_Directional_Spreading_Function|Hasselmann Directional Spreading Function]]

|RPSVersion=All
}}
You can find the source code of this plugin on the following Github repository: [https://github.com/LabRPS/LabRPS-plugins/tree/master/SeaLab/SeaLabPlugin Get the code here!]. This plugin is one of the official plugins provided by LabRPS. It provides very useful features (tools) for the simulation of random sea elevations. Plugins are very easy to create in LabRPS, therefore, anyone can develop plugin for any random phenomenon in LabRPS. Go to this [[Plugin_Creation|page]] to see how to create new plugin for LabRPS. You can get quick assistance from LabRPS community by sending your concern to the [https://labrps.com/boards community forum].

== Horizontal Uniform Distribution ==

This feature provides an efficient method to distribute random sea elevations simulation points uniformly in space. It allows users to generate a set of points within a 3D spatial domain, ensuring that the points are evenly distributed along a horizontal line that is parallel to one of the coordinate system axis. This uniform distribution is critical in certain simulation methods. For <math>n</math> simulation points <math>(P_1,P_2,P_3,...,P_n)</math>, the distance <math>d_{jk}</math> between points <math>P_j</math> and <math>P_k</math> must be given by the following formula:

<math>d_{jk} = s\times|j-k|</math>

where <math>s</math> is the even space between any two adjacent points.

=== Properties ===

* {{PropertyData|FirstPoint}}: This is a point in 3D space representing the first point the distribution will start from.
* {{PropertyData|Spacing}}: This is the even space between any two adjacent points in the distribution.

=== Scripting ===

{{Code|code=
import SeaLab
import GeneralToolsGui
import SeaLabObjects
from LabRPS import Vector as vec
import numpy
import LabRPS

def compute():
installResuslt = SeaLab.installPlugin("SeaLabPlugin")

doc = LabRPS.ActiveDocument
if not doc:
doc = LabRPS.newDocument()

# create SeaLab simulation called "Simulation"
sim = SeaLabObjects.makeSimulation(doc, "Simulation")

# check if the simulation sucessfully created
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "Horizontal Distribution"
featureGroup = "Location Distribution"

# create the feature
newFeature= SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not newFeature:
LabRPS.Console.PrintError("Error on creating the feature.\n")
return None

# let's set the first point of the distribution (x =0, y = 0, z = 80m)
newFeature.FirstPoint = vec(0,0,80000)

# let's set the spacing (s = 10m)
newFeature.Spacing = '10m'

# compute the simulation points coordinates. SeaLab will internally use the "newFeature" feature.
simPoints = sim.computeLocationCoordinateMatrixP3()

# now you can convert the coordinate matrix to numpy array and use it for any other purposes
arr = numpy.asarray(simPoints)

# you can also show the result in a table, pass False as last argument to the function to ask
# LabRPS to only show the data without plotting them
GeneralToolsGui.GeneralToolsPyTool.showArray(sim.getSimulationData().numberOfSpatialPosition, 4, simPoints, False)

compute()

}}
[[#top| Back to the Top ]]

== Vertical Uniform Distribution ==

This feature provides an efficient method to distribute random sea elevations simulation points uniformly in space. It allows users to generate a set of points within a 3D spatial domain, ensuring that the points are evenly distributed along a vertical line. This uniform distribution is critical in certain simulation methods. For <math>n</math> simulation points <math>(P_1,P_2,P_3,...,P_n)</math>, the distance <math>d_{jk}</math> between points <math>P_j</math> and <math>P_k</math> must be given by the following formula:

<math>d_{jk} = s\times|j-k|</math>

where <math>s</math> is the even space between any two adjacent points.

=== Properties ===

* {{PropertyData|LowestPoint}}: This is a point in 3D space representing the lowest point the distribution will start from. In many applications, this point should not be lower than 10 meters.
* {{PropertyData|Spacing}}: This is the even space between any two adjacent points in the distribution.

=== Scripting ===

{{Code|code=
import SeaLab
import GeneralToolsGui
import SeaLabObjects
from LabRPS import Vector as vec
import numpy
import LabRPS

def compute():
installResuslt = SeaLab.installPlugin("SeaLabPlugin")

doc = LabRPS.ActiveDocument
if not doc:
doc = LabRPS.newDocument()

# create SeaLab simulation called "Simulation"
sim = SeaLabObjects.makeSimulation(doc, "Simulation")

# check if the simulation sucessfully created
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "Vertical Distribution"
featureGroup = "Location Distribution"

# create the feature
newFeature= SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not newFeature:
LabRPS.Console.PrintError("Error on creating the feature.\n")
return None

# let's set the first point of the distribution (x =0, y = 0, z = 30m)
newFeature.LowestPoint = vec(0,0,30000)

# let's set the spacing (s = 10m)
newFeature.Spacing = '10m'

# compute the simulation points coordinates. SeaLab will internally use the "newFeature" feature.
simPoints = sim.computeLocationCoordinateMatrixP3()

# now you can convert the coordinate matrix to numpy array and use it for any other purposes
arr = numpy.asarray(simPoints)

# you can also show the result in a table, pass False as last argument to the function to ask
# LabRPS to only show the data without plotting them
GeneralToolsGui.GeneralToolsPyTool.showArray(sim.getSimulationData().numberOfSpatialPosition, 4, simPoints, False)

compute()

}}
[[#top| Back to the Top ]]

== Uniform Distribution ==

This feature may be seen as a general form of the horizontal and the vertical distribution features. It allows users to generate a set of points within a 3D spatial domain, ensuring that the points are evenly distributed along a line parallel to one of the coordinate system axis. For <math>n</math> simulation points <math>(P_1,P_2,P_3,...,P_n)</math>, the distance <math>d_{jk}</math> between points <math>P_j</math> and <math>P_k</math> must be given by the following formula:

<math>d_{jk} = s\times|j-k|</math>

where <math>s</math> is the even space between any two adjacent points.

=== Properties ===

* {{PropertyData|FirstPoint}}: This is a point in 3D space representing the first point the distribution will start from. This should be the lowest point in case the distribution is parallel to the vertical axis and should not be lower than 10 meters in many application.
* {{PropertyData|Spacing}}: This is the even space between any two adjacent points in the distribution.
* {{PropertyData|Direction}}: Its value can be X, Y or Z. This is the axis the points distribution is parallel to.

=== Scripting ===

This feature can be used to produce vertical distribution as we did before in the Vertical Distribution feature.

{{Code|code=
import SeaLab
import GeneralToolsGui
import SeaLabObjects
from LabRPS import Vector as vec
import numpy
import LabRPS

def compute():
installResuslt = SeaLab.installPlugin("SeaLabPlugin")

doc = LabRPS.ActiveDocument
if not doc:
doc = LabRPS.newDocument()

# create SeaLab simulation called "Simulation"
sim = SeaLabObjects.makeSimulation(doc, "Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "Uniform Distribution"
featureGroup = "Location Distribution"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
unifSimPoints= SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not unifSimPoints:
LabRPS.Console.PrintError("Error on creating the uniform points feature.\n")
return None

# set the direction of the distribution to be vertical
unifSimPoints.Direction= 'Z'

# let's set the first point of the distribution (x =0, y = 0, z = 30m)
unifSimPoints.FirstPoint = vec(0,0,30000) # This is the lowest point in this case (Direction = 'Z')

# let's set the spacing (s = 10m)
unifSimPoints.Spacing = '10m'

# compute the simulation points coordinates. SeaLab will internally use the "unifSimPoints" feature.
simPoints = sim.computeLocationCoordinateMatrixP3()

# now you can convert the coordinate matrix to numpy array and use it for any other purposes
arr = numpy.asarray(simPoints)

# you can also show the result in a table, pass False as last argument to the function to ask
# LabRPS to only show the data without plotting them
GeneralToolsGui.GeneralToolsPyTool.showArray(sim.getSimulationData().numberOfSpatialPosition, 4, simPoints, False)

compute()

}}

[[#top| Back to the Top ]]

== Grid Points ==

This feature allows users to generate a set of grid points within a 3D spatial domain, ensuring that the points are evenly distributed in a plane parallel to one of the coordinate system planes (XY Plane, YZ Plane, XZ Plane).

=== Properties ===

* {{PropertyData|Spacing1}}: This is the points spacing along one of the axis forming the plane.
* {{PropertyData|Spacing2}}: This is the points spacing along the second axis.
* {{PropertyData|Length1}}: This is the length within points are distributed along one of the axis forming the plane.
* {{PropertyData|Length2}}: This is the length within points are distributed along the second axis.
* {{PropertyData|CenterPoint}}: This is the center of the grid around which the points are generated. It is a 3D point.
* {{PropertyData|NumberOfPoints}}: This is the resulting total number of points in the grid. This is a read only property for internal use. User cannot change its value directly.

=== Scripting ===

The following script shows how this feature can be created and used.

{{Code|code=
import SeaLab
import GeneralToolsGui
import SeaLabObjects
from LabRPS import Vector as vec
import LabRPS
import numpy
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

def compute():
# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "Grid Points"
featureGroup = "Location Distribution"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
unifSimPoints= SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not unifSimPoints:
LabRPS.Console.PrintError("Error on creating the uniform points feature.\n")
return None

# set the plan the points grid is parallel to
unifSimPoints.LocationPlan= 'YZ Plane'

# let's set the center point of the distribution (x =0, y = 0, z = 0)
unifSimPoints.CenterPoint = vec(0,0,0)

# let's set the spacing1 (s1 = 10m)
unifSimPoints.Spacing1 = '10m'

# let's set the spacing2 (s2 = 10m)
unifSimPoints.Spacing2 = '10m'

# let's set the length1 (l1 = 200m)
unifSimPoints.Length1= '200m'

# let's set the length2 (l2 = 200m)
unifSimPoints.Length2= '200m'

# compute the simulation points coordinates. SeaLab will internally use the "unifSimPoints" feature.
simPoints = sim.computeLocationCoordinateMatrixP3()

# now you can convert the coordinate matrix to numpy array and use it for any other purposes
arr = numpy.asarray(simPoints)

# Example 3D points
x = arr[:,1]
y = arr[:,2]
z = arr[:,3]

# you can also show the result in a table, pass False as last argument to the function to ask
# LabRPS to only show the data without plotting them
GeneralToolsGui.GeneralToolsPyTool.showArray(sim.getSimulationData().numberOfSpatialPosition, 4, simPoints, False)

# Create a figure
fig = plt.figure()

# Add 3D axes
ax = fig.add_subplot(111, projection='3d')

# Plot points
ax.scatter(x, y, z, color='blue')

# Hide all axes and labels
ax.set_axis_off()

# Set the title
ax.set_title('3D Plotting of Points')

# Show the plot
plt.show()

compute()

}}
[[#top| Back to the Top ]]

== General Distribution ==

When the simulation points distribution is more general and does not follow any of the previous uniform distribution, this feature can be used. This feature allows users to input simulation points one by one using their coordinates based on the vector dialog shown below:

[[Image:SeaLab_Tutorial001_Pic005_SeaLab_Feat_Locations_2.png|400px]]

=== Properties ===

* {{PropertyData|Locations}}: This is a list holding the simulation points

=== Scripting ===

The following script shows how this feature can be created and used.

{{Code|code=
import SeaLab
import GeneralToolsGui
import SeaLabObjects
from LabRPS import Vector as vec
import LabRPS
import numpy

def compute():
installResuslt = SeaLab.installPlugin("SeaLabPlugin")

doc = LabRPS.ActiveDocument
if not doc:
doc = LabRPS.newDocument()

# create SeaLab simulation called "Simulation"
sim = SeaLabObjects.makeSimulation(doc, "Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "General Distribution"
featureGroup = "Location Distribution"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
genSimPoints= SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not genSimPoints:
LabRPS.Console.PrintError("Error on creating the uniform points feature.\n")
return None

# create the simulation points by their coordinates
v1 = vec(0, 0, 35000)
v2 = vec(0, 0, 40000)
v3 = vec(0, 0, 140000)

# add the points to the locations
genSimPoints.Locations = [v1, v2, v3]

# compute the simulation points coordinates. SeaLab will internally use the "genSimPoints" feature
simPoints = sim.computeLocationCoordinateMatrixP3()

# now you can convert the coordinate matrix to numpy array and use it for any other purposes
arr = numpy.asarray(simPoints)

# you can also show the result in a table, pass False as last argument to the function to ask
# LabRPS to only show the data without plotting them
GeneralToolsGui.GeneralToolsPyTool.showArray(sim.getSimulationData().numberOfSpatialPosition, 4, simPoints, False)

compute()

}}
[[#top| Back to the Top ]]

== Import Simulation Points from File ==

When the simulation points are stored in a file, this feature can be used. The feature allows users to import simulation points coordinates from file. Note that, for now only tab separated text file is supported and the file is expected to have number of rows and number of columns which are number of simulation points and four, respectively.

[[Image:SeaLab_Tutorial001_Pic006_SeaLab_Feat_Locations_1.png|400px]]

=== Properties ===

* {{PropertyData|FilePath}}: This is the path to the file.

=== Scripting ===

The following script shows how this feature can be created and used.

{{Code|code=
import SeaLab
import GeneralToolsGui
import SeaLabObjects
from LabRPS import Vector as vec
import LabRPS
import numpy

def compute():
installResuslt = SeaLab.installPlugin("SeaLabPlugin")

doc = LabRPS.ActiveDocument
if not doc:
doc = LabRPS.newDocument()

# create SeaLab simulation called "Simulation"
sim = SeaLabObjects.makeSimulation(doc, "Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "Import Simulation Points from File"
featureGroup = "Location Distribution"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
simPoints= SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not simPoints:
LabRPS.Console.PrintError("Error on creating the simulation points feature.\n")
return None

# set the direction of the distribution to be vertical
simPoints.FilePath = "D:/Points.txt"

# compute the simulation points coordinates. SeaLab will internally use the "simPoints" feature.
importedSimPoints = sim.computeLocationCoordinateMatrixP3()

# now you can convert the coordinate matrix to numpy array and use it for any other purposes
arr = numpy.asarray(importedSimPoints )

# you can also show the result in a table, pass False as last argument to the function to ask
# LabRPS to only show the data without plotting them
GeneralToolsGui.GeneralToolsPyTool.showArray(sim.getSimulationData().numberOfSpatialPosition, 4, importedSimPoints, False)

compute()

}}
[[#top| Back to the Top ]]

== Uniform Random Phases ==

In the simulation of random sea elevations, one common technique is to represent the random sea elevations as a sum of multiple sinusoidal components in the frequency domain. Each of these components is associated with a random phase, which determines the position of the sine wave relative to time. By assigning uniform random phases to each frequency component, the resulting time series will have random characteristics, while still adhering to the desired spectral properties, such as a specific power spectral density (PSD) or turbulence spectrum. The feature generate <math>n</math> sequences <math>(\phi_{1l}, \phi_{2l}, \phi_{3l},..., \phi_{nl}; l = 1, 2, 3, ..., N)</math> of independent random phase angles
uniformly distributed over the interval <math>[0, 2\pi]</math> by default.

=== Properties ===

* {{PropertyData|MinimumValue}}: The minimum value that can be generated
* {{PropertyData|MaximumValue}}: The maximum value that can be generated

=== Scripting ===

The following script shows how this feature can be created and used.

{{Code|code=
import SeaLab
import SeaLabObjects
from LabRPS import Vector as vec
import numpy

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
# abord the computation

featureType = "Uniform Random Phases"
featureGroup = "Randomness Provider"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
randomness = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not randomness:
LabRPS.Console.PrintError("Error on creating the randomness feature.\n")
# abord the computation

randomness.MinimumValue = 0
randomness.MaximumValue = 6.28

# generate random phase angle
randomnessMatrix = sim.generateRandomMatrixFP()

# now you can convert the coordinate matrix to numpy array and use it for any other purposes
arr = numpy.asarray(randomnessMatrix)

}}
[[#top| Back to the Top ]]

== Uniform Random Phases Import ==

When the simulation numbers are stored in a file, this feature can be used. The feature allows users to import random numbers from file. Note that, for now only tab separated text file is supported and the file is expected to have number of rows and number of columns which are number of frequency increments and number of simulation points, respectively.

=== Properties ===

* {{PropertyData|FilePath}}: This is the path to the file.

=== Scripting ===

The following script shows how this feature can be created and used.

{{Code|code=
import SeaLab
import SeaLabObjects
from LabRPS import Vector as vec
import numpy

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
# abord the computation

featureType = "Uniform Random Phases Import"
featureGroup = "Randomness Provider"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
randomness = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not randomness:
LabRPS.Console.PrintError("Error on creating the randomness feature.\n")
# abord the computation

randomness.FilePath = "myfolderpath/myfile.txt"

# generate random phase angle
randomnessMatrix = sim.generateRandomMatrixFP()

# now you can convert the coordinate matrix to numpy array and use it for any other purposes
arr = numpy.asarray(randomnessMatrix)

}}
[[#top| Back to the Top ]]

== Single Index Frequency Discretization ==

This feature allows to discretize continuous frequency according to the following formula:

<math>\omega_{l} = l\Delta\omega; \quad l = 1, 2, 3, ..., N</math>.

where:
* <math>\Delta\omega</math> is the frequency increment,
* <math>N</math> is the number of frequency increments,

=== Scripting ===

The following script shows how this feature can be created and used.

{{Code|code=
import SeaLab
import SeaLabObjects
from LabRPS import Vector as vec
import numpy

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
# abord the computation

featureType = "Single Index Frequency Discretization"
featureGroup = "Frequency Distribution"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
frequency = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not frequency:
LabRPS.Console.PrintError("Error on creating the frequency feature.\n")
# abord the computation

# compute the freqency distribution
frequencyMatrix = sim.computeFrequenciesMatrixFP()

# now you can convert the coordinate matrix to numpy array and use it for any other purposes
arr = numpy.asarray(frequencyMatrix)

}}
[[#top| Back to the Top ]]

== Double Index Frequency Discretization ==

This feature allows to discretize continuous frequency according to the following formula:

<math>\omega_{ml} = (l-1)\Delta\omega + \frac{m}{n}\Delta\omega; \quad m = 1, 2, 3, ..., n; \quad l = 1, 2, 3, ..., N</math>.

where:
* <math>\Delta\omega</math> is the frequency increment,
* <math>n</math> is the number of simulation points,
* <math>N</math> is the number of frequency increments,

=== Scripting ===

The following script shows how this feature can be created and used.

{{Code|code=
import SeaLab
import SeaLabObjects
from LabRPS import Vector as vec
import numpy

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
# abord the computation

featureType = "Double Index Frequency Discretization"
featureGroup = "Frequency Distribution"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
frequency = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not frequency:
LabRPS.Console.PrintError("Error on creating the frequency feature.\n")
# abord the computation

# compute the freqency distribution
frequencyMatrix = sim.computeFrequenciesMatrixFP()

# now you can convert the coordinate matrix to numpy array and use it for any other purposes
arr = numpy.asarray(frequencyMatrix)

}}
[[#top| Back to the Top ]]

== Zerva Frequency Discretization ==

This feature allow to discretize continuous frequency according to the following formula:

<math>\omega_{l} = (1+\frac{l}{2})\Delta\omega;\quad l = 1, 2, 3, ..., N</math>,

where:
* <math>\Delta\omega</math> is the frequency increment,
* <math>N</math> is the number of frequency increments,

=== Scripting ===

The following script shows how this feature can be created and used.

{{Code|code=
import SeaLab
import SeaLabObjects
from LabRPS import Vector as vec
import numpy

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
# abord the computation

featureType = "Zerva Frequency Discretization"
featureGroup = "Frequency Distribution"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
frequency = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not frequency:
LabRPS.Console.PrintError("Error on creating the frequency feature.\n")
# abord the computation

# compute the freqency distribution
frequencyMatrix = sim.computeFrequenciesMatrixFP()

# now you can convert the coordinate matrix to numpy array and use it for any other purposes
arr = numpy.asarray(frequencyMatrix)

}}
[[#top| Back to the Top ]]

== Cholesky Decomposition ==

This feature performs the [https://en.wikipedia.org/wiki/Cholesky_decomposition Cholesky decomposition] of a positive Hermitian power spectrum matrix and returns the lower triangular matrix (L) of the decomposition. The Cholesky decomposition is a numerical method used to decompose a positive-definite matrix into the product of a lower triangular matrix and its conjugate transpose. Specifically, for a matrix
A, the decomposition is given by:

<math display=block>\mathbf{A} = \mathbf{L L}^{*},</math>

<math display=block> L_{j,j} = \sqrt{ A_{j,j} - \sum_{k=1}^{j-1} L_{j,k}^*L_{j,k} }, </math>

<math display=block> L_{i,j} = \frac{1}{L_{j,j}} \left( A_{i,j} - \sum_{k=1}^{j-1} L_{j,k}^* L_{i,k} \right) \quad \text{for } i>j. </math>

where <math>L</math> is a [https://en.wikipedia.org/wiki/Triangular_matrix lower triangular matrix] with real and positive diagonal entries, and <math>L^*</math> denotes the [https://en.wikipedia.org/wiki/Conjugate_transpose conjugate transpose] of <math>L</math>.

The feature is optimized for performance and can handle large matrices efficiently using <math>O(n^3)</math> computational complexity in the worst case. It checks if the input matrix is indeed positive-definite and Hermitian before performing the decomposition and raises an error if the matrix does not meet these conditions. The feature belong to the [[RPS_Feature_Group#PSD_Decomposition_Method|PSD Decomposition Method]] feature group.

=== Feature Dependency ===
The features required by this feature are summarized as follows:

* A [[RPS_Feature_Group#Location_Distribution| simulation points feature]]
* A [[RPS_Feature_Group#Frequency_Distribution| frequency discretization feature]]
* A [[SeaLab_Feature#Spectrum| spectrum feature]]

=== Scripting ===

The feature can be used from the python console as follows:

{{Code|code=
import SeaLab
import GeneralToolsGui
import SeaLabObjects
from LabRPS import Vector as vec
import LabRPS
import numpy

def compute():
installResuslt = SeaLab.installPlugin("SeaLabPlugin")

doc = LabRPS.ActiveDocument
if not doc:
doc = LabRPS.newDocument()

# create SeaLab simulation called "Simulation"
sim = SeaLabObjects.makeSimulation(doc, "Simulation")

# check if the simulation sucessfully created
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "Cholesky Decomposition"
featureGroup = "Spectrum Decomposition Method"

# create the feature
decomposedPSD = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not decomposedPSD :
LabRPS.Console.PrintError("Error on creating the spectrum decomposition method.\n")
return None

# get the active simulation points feature and compute the simulation points coordinates
simPoints = sim.computeLocationCoordinateMatrixP3()

if not simPoints :
LabRPS.Console.PrintError("Make sure you have an active location disttribution in the simulation with at least 3 simulation points.\n")
return None

# use a vector to represent a simulation point based on its coordinates
v1 = vec(simPoints[0][1], simPoints[0][2], simPoints[0][3])
v2 = vec(simPoints[1][1], simPoints[1][2], simPoints[1][3])
v3 = vec(simPoints[2][1], simPoints[2][2], simPoints[2][3])

# This feature is used to decompose power spectrum matrices which may vary in time. Let's assume that
# the active power spectrun density function in this example is stationary. Meanning it is not varying in time.
#Then, we use time instant of 0 second.
time = 0.0

# compute the decomposed cross spectrum between points 1 and 3, at time instant of 0 second and for all frequency
# increments. Note that when the following code is run, SeaLab will try to identify the active frequency distribution,
# the active power spectrum feature, the active coherence function feature and others. If SeaLab fails to find any
# of these dependency features, the computation will fails and specific error messages will be sent to the report view.
psd13 = sim.computeDecomposedCrossSpectrumVectorF(v1, v3, time)

# psd13 can be converted to numpy vector and be used for some other purposes.
arr = numpy.asarray(psd13)

compute()
}}
[[#top| Back to the Top ]]

== Pierson Moskowitz Spectrum 1964 ==

Various idealized spectra are used to answer the question in oceanography and ocean engineering. Perhaps the simplest is that proposed by Pierson and Moskowitz 1964. They assumed that if the wind blew steadily for a long time over a large area, the waves would come into equilibrium with the wind. This is the concept of a fully developed sea (a sea produced by winds blowing steadily over hundreds of miles for several days).Here, a long time is roughly ten-thousand wave periods, and a "large area" is roughly five-thousand wave-lengths on a side. ([https://wikiwaves.org/Ocean-Wave_Spectra#Pierson-Moskowitz_Spectrum source]):

<math>S(\omega) = \frac{5}{16}H^2_s\omega^4_p\omega^{-5}\mbox{exp}\left [ -\frac{5}{4}\left ( \frac{\omega}{\omega_p} \right )^{-4} \right ]</math>

=== Feature Dependency ===
The features required by this feature are summarized as follows:

* A [[RPS_Feature_Group#Location_Distribution| simulation points feature]]
* A [[RPS_Feature_Group#Frequency_Distribution| frequency discretization feature]]

=== Properties ===

* {{PropertyData|SignificantWaveHeight}}: The significant wave height.
* {{PropertyData|PeakPeriod}}: The peak period.

=== Scripting ===

The feature can be used from the python console as follows:

{{Code|code=
import SeaLab
import SeaLabObjects
import GeneralToolsGui
import LabRPS
from LabRPS import Vector as vec

# Before you run this code, you should first have created a document with a SeaLab simulation with
# active simulation points and frequency distribution
def compute():

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "Pierson Moskowitz Spectrum (1964)"
featureGroup = "Frequency Spectrum"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
spectrum = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not spectrum:
LabRPS.Console.PrintError("Error on creating the spectrum function feature.\n")
return None

sim.MaxFrequency = '0.04 1/s'
sim.NumberOfFrequency = 1024
sim.FrequencyIncrement = sim.MaxFrequency/sim.NumberOfFrequency
sim.setActiveFeature(spectrum)

# For this example we shall compute the cross spectrum matrix at time instant of 0 second and for the frequency value of 0.25 rad/s.
time = 0.0

# compute the simulation points coordinates
simPoints = sim.computeLocationCoordinateMatrixP3()

if not simPoints :
LabRPS.Console.PrintError("Make sure you have an active location disttribution in the simulation with at least 3 simulation points.\n")
return None

# let pick the first simulation point
v1 = vec(simPoints[0][1], simPoints[0][2], simPoints[0][3])
# compute the spectrum vector at time instant of 0 second
# Note that when the following code is run, SeaLab will try to identify the active locations distribution, the active frequency discretization,
# If SeaLab fails to find these dependency features, the computation will fails and specific error messages will be sent to the report view.
spectrums = sim.computeAutoFrequencySpectrumVectorF(v1, time)

# show the results
GeneralToolsGui.GeneralToolsPyTool.showArray(len(spectrums), len(spectrums[0]), spectrums)
LabRPS.ActiveDocument.recompute()

compute()
}}
[[#top| Back to the Top ]]

== Jonswap Spectrum 1974 ==

Hasselmann et al. 1973, after analyzing data collected during the Joint North Sea Wave Observation Project JONSWAP, found that the wave spectrum is never fully developed. It continues to develop through non-linear, wave-wave interactions even for very long times and distances. Hence an extra and somewhat artificial factor was added to the Pierson-Moskowitz spectrum in order to improve the fit to their measurements. The JONSWAP spectrum is thus a Pierson-Moskowitz spectrum multiplied by an extra peak enhancement factor <math>\gamma ^r</math> ([https://wikiwaves.org/Ocean-Wave_Spectra#JONSWAP_Spectrum source]):

<math>S(\omega) = \frac{5}{16}A_{\gamma}H^2_s\omega^4_p\omega^{-5}\mbox{exp}\left [ -\frac{5}{4}\left ( \frac{\omega}{\omega_p} \right )^{-4} \right ]\gamma^r </math>

where:

<math>A_{\gamma} = 1 - 0.287 \times ln\left ( \gamma \right ) \quad \mbox{is a normalizing factor} </math>

<math>r = \mbox{exp}\left [ -\frac{1}{2}\left ( \frac{\omega-\omega_p}{\sigma\omega_p} \right )^{2} \right ]</math>

<math>\sigma =
\begin{cases}
\sigma_1, & \mbox{for } \omega \le \omega_p \\
\\
\sigma_2, & \mbox{for } \omega > \omega_p
\end{cases}
</math>
=== Feature Dependency ===
The features required by this feature are summarized as follows:

* A [[RPS_Feature_Group#Location_Distribution| simulation points feature]]
* A [[RPS_Feature_Group#Frequency_Distribution| frequency discretization feature]]

=== Properties ===

* {{PropertyData|SignificantWaveHeight}}: The significant wave height.
* {{PropertyData|PeakPeriod}}: The peak period.
* {{PropertyData|AutoGamma}}: Whether to automatically compute gamma or not.
* {{PropertyData|AutoSigma}}: Whether to automatically compute sigma or not.
* {{PropertyData|Gamma}}: The value of shape parameter gamma.
* {{PropertyData|Sigma1}}: The width of spectral peak sigma 1.
* {{PropertyData|Sigma2}}: The width of spectral peak sigam 2.

=== Scripting ===

The feature can be used from the python console as follows:

{{Code|code=
import SeaLab
import SeaLabObjects
import GeneralToolsGui
import LabRPS
from LabRPS import Vector as vec

# Before you run this code, you should first have created a document with a SeaLab simulation with
# active simulation points and frequency distribution
def compute():

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "Jonswap Spectrum (1974)"
featureGroup = "Frequency Spectrum"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
spectrum = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not spectrum:
LabRPS.Console.PrintError("Error on creating the spectrum function feature.\n")
return None

sim.MaxFrequency = '0.04 1/s'
sim.NumberOfFrequency = 1024
sim.FrequencyIncrement = sim.MaxFrequency/sim.NumberOfFrequency
sim.setActiveFeature(spectrum)

# For this example we shall compute the cross spectrum matrix at time instant of 0 second and for the frequency value of 0.25 rad/s.
time = 0.0

# compute the simulation points coordinates
simPoints = sim.computeLocationCoordinateMatrixP3()

if not simPoints :
LabRPS.Console.PrintError("Make sure you have an active location disttribution in the simulation with at least 3 simulation points.\n")
return None

# let pick the first simulation point
v1 = vec(simPoints[0][1], simPoints[0][2], simPoints[0][3])
# compute the spectrum vector at time instant of 0 second
# Note that when the following code is run, SeaLab will try to identify the active locations distribution, the active frequency discretization,
# If SeaLab fails to find these dependency features, the computation will fails and specific error messages will be sent to the report view.
spectrums = sim.computeAutoFrequencySpectrumVectorF(v1, time)

# show the results
GeneralToolsGui.GeneralToolsPyTool.showArray(len(spectrums), len(spectrums[0]), spectrums)
LabRPS.ActiveDocument.recompute()

compute()
}}
[[#top| Back to the Top ]]

== Gaussian Swell Spectrum ==

The Gaussian swell spectrum is based on the normal (or Gaussian) probability density function and is defined as ([https://www.orcina.com/webhelp/OrcaFlex/Content/html/Waves,Wavespectra.htm source]):

<math>S(\omega) = \left ( \frac{H_c}{4} \right )^2\frac{1}{\sigma\sqrt{2\pi}}\mbox{exp}\left [ -\frac{\left ( \omega -\omega_p \right )^2}{2\sigma^2} \right ]</math>

=== Feature Dependency ===
The features required by this feature are summarized as follows:

* A [[RPS_Feature_Group#Location_Distribution| simulation points feature]]
* A [[RPS_Feature_Group#Frequency_Distribution| frequency discretization feature]]

=== Properties ===

* {{PropertyData|SignificantWaveHeight}}: The significant wave height.
* {{PropertyData|PeakFrequency}}: The peak frequency.
* {{PropertyData|Sigma}}: The width of spectral peak sigma.

=== Scripting ===

The feature can be used from the python console as follows:

{{Code|code=
import SeaLab
import SeaLabObjects
import GeneralToolsGui
import LabRPS
from LabRPS import Vector as vec

# Before you run this code, you should first have created a document with a SeaLab simulation with
# active simulation points and frequency distribution
def compute():

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "Gaussian Swell Spectrum"
featureGroup = "Frequency Spectrum"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
spectrum = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not spectrum:
LabRPS.Console.PrintError("Error on creating the spectrum function feature.\n")
return None

sim.MaxFrequency = '0.04 1/s'
sim.NumberOfFrequency = 1024
sim.FrequencyIncrement = sim.MaxFrequency/sim.NumberOfFrequency
sim.setActiveFeature(spectrum)

# For this example we shall compute the cross spectrum matrix at time instant of 0 second and for the frequency value of 0.25 rad/s.
time = 0.0

# compute the simulation points coordinates
simPoints = sim.computeLocationCoordinateMatrixP3()

if not simPoints :
LabRPS.Console.PrintError("Make sure you have an active location disttribution in the simulation with at least 3 simulation points.\n")
return None

# let pick the first simulation point
v1 = vec(simPoints[0][1], simPoints[0][2], simPoints[0][3])
# compute the spectrum vector at time instant of 0 second
# Note that when the following code is run, SeaLab will try to identify the active locations distribution, the active frequency discretization,
# If SeaLab fails to find these dependency features, the computation will fails and specific error messages will be sent to the report view.
spectrums = sim.computeAutoFrequencySpectrumVectorF(v1, time)

# show the results
GeneralToolsGui.GeneralToolsPyTool.showArray(len(spectrums), len(spectrums[0]), spectrums)
LabRPS.ActiveDocument.recompute()

compute()
}}
[[#top| Back to the Top ]]

== Ochi Hubble Spectrum ==

The Ochi-Hubble spectrum allows double-peaked spectra to be set up, enabling you to represent sea states that include both a remotely generated swell and a local wind generated sea. See the Ochi-Hubble paper for full details. ([https://www.orcina.com/webhelp/OrcaFlex/Content/html/Waves,Wavespectra.htm source]):

<math>S(\omega) = \sum_{j=1}^2 \left\{ \frac{\left(\frac{4\lambda_j+1}{4}\right)^{\lambda_j} \omega_{\mathrm{m}_j}^{4\lambda_j}H_{\mathrm{s}_j}^2}{4\Gamma(\lambda_j)} \right\}
\omega^{-(4\lambda_j+1)}
\exp\left\{ -\left(\frac{4\lambda_j+1}{4}\right) \left(\frac{\omega}{\omega_{\mathrm{m}_j}}\right)^{-4} \right\} </math>

where:

=== Feature Dependency ===
The features required by this feature are summarized as follows:

* A [[RPS_Feature_Group#Location_Distribution| simulation points feature]]
* A [[RPS_Feature_Group#Frequency_Distribution| frequency discretization feature]]

=== Properties ===

* {{PropertyData|PeakShape1}}: The peak shape of the first peak.
* {{PropertyData|PeakShape2}}: The peak shape of the second peak.
* {{PropertyData|PeakFrequency1}}: The peak frequency of the first peak.
* {{PropertyData|PeakFrequency2}}: The peak frequency of the second peak.
* {{PropertyData|SignificantWaveHeight1}}: The significant wave height of the first peak.
* {{PropertyData|SignificantWaveHeight2}}: The significant wave height of the second peak.
* {{PropertyData|AutoPara}}: Whether to automatically compute the six previous parameter.
* {{PropertyData|SignificantWaveHeight}}: The significant wave height used the calculate those six parameters in case of automatic parameters calculation .

=== Scripting ===

The feature can be used from the python console as follows:

{{Code|code=
import SeaLab
import SeaLabObjects
import GeneralToolsGui
import LabRPS
from LabRPS import Vector as vec

# Before you run this code, you should first have created a document with a SeaLab simulation with
# active simulation points and frequency distribution
def compute():

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "Ochi-Hubble spectrum"
featureGroup = "Frequency Spectrum"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
spectrum = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not spectrum:
LabRPS.Console.PrintError("Error on creating the spectrum function feature.\n")
return None

sim.MaxFrequency = '0.04 1/s'
sim.NumberOfFrequency = 1024
sim.FrequencyIncrement = sim.MaxFrequency/sim.NumberOfFrequency
sim.setActiveFeature(spectrum)

# For this example we shall compute the cross spectrum matrix at time instant of 0 second and for the frequency value of 0.25 rad/s.
time = 0.0

# compute the simulation points coordinates
simPoints = sim.computeLocationCoordinateMatrixP3()

if not simPoints :
LabRPS.Console.PrintError("Make sure you have an active location disttribution in the simulation with at least 3 simulation points.\n")
return None

# let pick the first simulation point
v1 = vec(simPoints[0][1], simPoints[0][2], simPoints[0][3])
# compute the spectrum vector at time instant of 0 second
# Note that when the following code is run, SeaLab will try to identify the active locations distribution, the active frequency discretization,
# If SeaLab fails to find these dependency features, the computation will fails and specific error messages will be sent to the report view.
spectrums = sim.computeAutoFrequencySpectrumVectorF(v1, time)

# show the results
GeneralToolsGui.GeneralToolsPyTool.showArray(len(spectrums), len(spectrums[0]), spectrums)
LabRPS.ActiveDocument.recompute()

compute()
}}
[[#top| Back to the Top ]]

== Torsethaugen Spectrum ==

The Torsethaugen spectrum is another two-peaked spectrum, more suited to North Sea application than Ochi-Hubble. The spectrum is defined by two user input parameters, <math>H_s</math> and <math>T_p (= 1/f_m)</math>. In order to define the spectrum we must first define a number of other terms ([https://www.orcina.com/webhelp/OrcaFlex/Content/html/Waves,Wavespectra.htm source]):

<math>
\begin{array}{lcl}
a_1 = 0.5 \\
a_2 = 0.3 \\
a_3 = 6 \\
a_{10} = 0.7 \\
a_{20} = 0.6 \\
b_1 = 2\ \textrm{s} \\
G_0 = 3.26 \\
k_g = 35 \\
k_1 = 0.0016 \\
k_2 = 0.286 \\
k_3 = \frac{k_2}{k_1^{1/3}} \\
k_f = k_3 g^{-1/2} \\
F_e = 370,000\ \textrm{m} \\
a_f = k_f F_e^{1/6} \\
T_{pf} = a_f H_s^{1/3} \\
a_e = 2\ \textrm{sm}^{-1/2} \\
T_l = a_e H_s^{1/2} \\
T_u = 25\ \textrm{s} \\
\epsilon_l = \frac{T_{pf} - T_p}{T_{pf} - T_l} \\
\epsilon_u = \frac{T_p - T_{pf}}{T_u - T_{pf}} \\
\end{array}
</math>

Note:
<math> \mbox{If }\epsilon_l < 0 \mbox{ then } \epsilon_l \mbox{ is set to 0. If } \epsilon_l > 1 \mbox{ then } \epsilon_l \mbox{ is set to 1. Likewise for } \epsilon_u.\\</math>

For wind dominated sea, <math>T_p \le T_{pf}</math>, we define:

<math>
\begin{array}{lcl}
R_w = (1 - a_{10}) \exp\{-(\epsilon_l/a_1)^2\} + a_{10} \\
H_1 = R_w H_s \\
T_{p1} = T_p \\
s_p = \frac{2\pi}{g}\frac{H_1}{T_{p1}^2} \\
\gamma = k_g s_p^{6/7} \\
H_2 = (1 - R_w^2)^{1/2} H_s \\
T_{p2} = T_{pf} + b_1 \\
\end{array}
</math>

For swell dominated sea, <math>T_p > T_{pf}</math>, we define:

<math>
\begin{array}{lcl}
R_s = (1 - a_{20}) \exp(-(\epsilon_u/a_2)^2) + a_{20} \\
H_1 = R_s H_s \\
T_{p1} = T_p \\
s_f = \frac{2\pi}{g}\frac{H_s}{T_{pf}^2} \\
\gamma_f = k_g s_f^{6/7} \\
\gamma = \gamma_f (1 + a_3 \epsilon_u) \\
H_2 = (1 - R_s^2)^{1/2} H_s \\
T_{p2} = a_f H_2^{1/3} \\
\end{array}
</math>

Note:
If <math>\gamma < 1</math> then <math>\gamma</math> is set to 1.

These two branches of the formulation define <math>H_1, H_2, T_{p1}, T_{p2}</math> and <math>\gamma</math> which are then used to define the spectrum as

<math>S(f) = \sum_{j=1}^2 E_j S_{jn}(f_{jn})</math>

where:

<math>
\begin{array}{lcl}
j = 1\ \textrm{is the primary sea system} \\
j = 2\ \textrm{is the secondary sea system} \\
f_{1n} = f T_{p1} \\
f_{2n} = f T_{p2} \\
\sigma =
\begin{cases}
0.07 \quad \mbox{for } f_{1n} \le 1 \\
0.09 \quad \mbox{for } f_{1n} \gt 1 \\
\end{cases} \\
E_1 = (1/16) H_1^2 T_{p1} \\
E_2 = (1/16) H_2^2 T_{p2} \\
A_\gamma = \frac{1 + 1.1 \log_e(\gamma)^{1.19}}{\gamma} \\
S_{1n}(f_{1n}) = G_0 A_\gamma f_{1n}^{-4} \exp(-f_{1n}^{-4}) \gamma^{\exp\{-(1/2\sigma^2) (f_{1n} - 1)^2\}} \\
S_{2n}(f_{2n}) = G_0 f_{2n}^{-4} \exp(-f_{2n}^{-4}) \\
\end{array}
</math>
=== Feature Dependency ===
The features required by this feature are summarized as follows:

* A [[RPS_Feature_Group#Location_Distribution| simulation points feature]]
* A [[RPS_Feature_Group#Frequency_Distribution| frequency discretization feature]]

=== Properties ===

* {{PropertyData|SignificantWaveHeight}}: The significant wave height.
* {{PropertyData|PeakPeriod}}: The peak period.
* {{PropertyData|AutoGamma}}: Whether to automatically compute gamma or not.
* {{PropertyData|AutoSigma}}: Whether to automatically compute sigma or not.
* {{PropertyData|Gamma}}: The value of shape parameter gamma.
* {{PropertyData|Sigma1}}: The width of spectral peak sigma 1.
* {{PropertyData|Sigma2}}: The width of spectral peak sigam 2.
* {{PropertyData|DoublePeaks}}: Whether double peaks or not.

=== Scripting ===

The feature can be used from the python console as follows:

{{Code|code=
import SeaLab
import SeaLabObjects
import GeneralToolsGui
import LabRPS
from LabRPS import Vector as vec

# Before you run this code, you should first have created a document with a SeaLab simulation with
# active simulation points and frequency distribution
def compute():

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "Torsethaugen Spectrum"
featureGroup = "Frequency Spectrum"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
spectrum = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not spectrum:
LabRPS.Console.PrintError("Error on creating the spectrum function feature.\n")
return None

sim.MaxFrequency = '0.04 1/s'
sim.NumberOfFrequency = 1024
sim.FrequencyIncrement = sim.MaxFrequency/sim.NumberOfFrequency
sim.setActiveFeature(spectrum)

# For this example we shall compute the cross spectrum matrix at time instant of 0 second and for the frequency value of 0.25 rad/s.
time = 0.0

# compute the simulation points coordinates
simPoints = sim.computeLocationCoordinateMatrixP3()

if not simPoints :
LabRPS.Console.PrintError("Make sure you have an active location disttribution in the simulation with at least 3 simulation points.\n")
return None

# let pick the first simulation point
v1 = vec(simPoints[0][1], simPoints[0][2], simPoints[0][3])
# compute the spectrum vector at time instant of 0 second
# Note that when the following code is run, SeaLab will try to identify the active locations distribution, the active frequency discretization,
# If SeaLab fails to find these dependency features, the computation will fails and specific error messages will be sent to the report view.
spectrums = sim.computeAutoFrequencySpectrumVectorF(v1, time)

# show the results
GeneralToolsGui.GeneralToolsPyTool.showArray(len(spectrums), len(spectrums[0]), spectrums)
LabRPS.ActiveDocument.recompute()

compute()
}}
[[#top| Back to the Top ]]

== Bretschneider Spectrum ==

The Bretschneider Spectrum is a two-parameter spectral model based on the assumption that the waves are narrow-banded with the wave characteristics following the Rayleigh distribution:

<math>S(\omega) = C_1\times H^2_s\left ( \frac{\omega^4_0}{\omega^5} \right )\mbox{exp}\left [ C_2\left ( \frac{\omega_0}{\omega} \right )^2 \right ]</math>

=== Feature Dependency ===
The features required by this feature are summarized as follows:

* A [[RPS_Feature_Group#Location_Distribution| simulation points feature]]
* A [[RPS_Feature_Group#Frequency_Distribution| frequency discretization feature]]

=== Properties ===

* {{PropertyData|SignificantWaveHeight}}: The significant wave height.
* {{PropertyData|SignificantWavePeriod}}: The significant wave period defined as the average period of the significant waves.
* {{PropertyData|Constant1}}: A constant (0.2107 by default).
* {{PropertyData|Constant2}}: A constant (-0.8429 by default).

=== Scripting ===

The feature can be used from the python console as follows:

{{Code|code=
import SeaLab
import SeaLabObjects
import GeneralToolsGui
import LabRPS
from LabRPS import Vector as vec

# Before you run this code, you should first have created a document with a SeaLab simulation with
# active simulation points and frequency distribution
def compute():

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "Bretschneider Spectrum"
featureGroup = "Frequency Spectrum"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
spectrum = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not spectrum:
LabRPS.Console.PrintError("Error on creating the spectrum function feature.\n")
return None

sim.MaxFrequency = '0.04 1/s'
sim.NumberOfFrequency = 1024
sim.FrequencyIncrement = sim.MaxFrequency/sim.NumberOfFrequency
sim.setActiveFeature(spectrum)

# For this example we shall compute the cross spectrum matrix at time instant of 0 second and for the frequency value of 0.25 rad/s.
time = 0.0

# compute the simulation points coordinates
simPoints = sim.computeLocationCoordinateMatrixP3()

if not simPoints :
LabRPS.Console.PrintError("Make sure you have an active location disttribution in the simulation with at least 3 simulation points.\n")
return None

# let pick the first simulation point
v1 = vec(simPoints[0][1], simPoints[0][2], simPoints[0][3])
# compute the spectrum vector at time instant of 0 second
# Note that when the following code is run, SeaLab will try to identify the active locations distribution, the active frequency discretization,
# If SeaLab fails to find these dependency features, the computation will fails and specific error messages will be sent to the report view.
spectrums = sim.computeAutoFrequencySpectrumVectorF(v1, time)

# show the results
GeneralToolsGui.GeneralToolsPyTool.showArray(len(spectrums), len(spectrums[0]), spectrums)
LabRPS.ActiveDocument.recompute()

compute()
}}
[[#top| Back to the Top ]]

== ISSC Spectrum ==

The International Ship Structures Congress (1964) suggested slight modification of the Bretschneider spectrum given as:

<math>S(\omega) = C_1\times H^2_s\left ( \frac{\omega^4_0}{\omega^5} \right )\mbox{exp}\left [ C_2\left ( \frac{\omega_0}{\omega} \right )^2 \right ]</math>

=== Feature Dependency ===
The features required by this feature are summarized as follows:

* A [[RPS_Feature_Group#Location_Distribution| simulation points feature]]
* A [[RPS_Feature_Group#Frequency_Distribution| frequency discretization feature]]

=== Properties ===

* {{PropertyData|SignificantWaveHeight}}: The significant wave height.
* {{PropertyData|SignificantWavePeriod}}: The significant wave period defined as the average period of the significant waves.
* {{PropertyData|Constant1}}: A constant (0.3123 by default).
* {{PropertyData|Constant2}}: A constant (-1.2489 by default).

=== Scripting ===

The feature can be used from the python console as follows:

{{Code|code=
import SeaLab
import SeaLabObjects
import GeneralToolsGui
import LabRPS
from LabRPS import Vector as vec

# Before you run this code, you should first have created a document with a SeaLab simulation with
# active simulation points and frequency distribution
def compute():

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "ISSC Spectrum"
featureGroup = "Frequency Spectrum"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
spectrum = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not spectrum:
LabRPS.Console.PrintError("Error on creating the spectrum function feature.\n")
return None

sim.MaxFrequency = '0.04 1/s'
sim.NumberOfFrequency = 1024
sim.FrequencyIncrement = sim.MaxFrequency/sim.NumberOfFrequency
sim.setActiveFeature(spectrum)

# For this example we shall compute the cross spectrum matrix at time instant of 0 second and for the frequency value of 0.25 rad/s.
time = 0.0

# compute the simulation points coordinates
simPoints = sim.computeLocationCoordinateMatrixP3()

if not simPoints :
LabRPS.Console.PrintError("Make sure you have an active location disttribution in the simulation with at least 3 simulation points.\n")
return None

# let pick the first simulation point
v1 = vec(simPoints[0][1], simPoints[0][2], simPoints[0][3])
# compute the spectrum vector at time instant of 0 second
# Note that when the following code is run, SeaLab will try to identify the active locations distribution, the active frequency discretization,
# If SeaLab fails to find these dependency features, the computation will fails and specific error messages will be sent to the report view.
spectrums = sim.computeAutoFrequencySpectrumVectorF(v1, time)

# show the results
GeneralToolsGui.GeneralToolsPyTool.showArray(len(spectrums), len(spectrums[0]), spectrums)
LabRPS.ActiveDocument.recompute()

compute()
}}
[[#top| Back to the Top ]]

== ITTC Spectrum ==

The Pierson Moskowitz spectrum was modified in the International Towing Tank Conference (1966, 1969,1972) given as:

<math>S(\omega) = \alpha g^2\omega^{-5}\mbox{exp}\left ( -\frac{4\alpha g^2\omega^{-4}}{H^2_s} \right )</math>

=== Feature Dependency ===
The features required by this feature are summarized as follows:

* A [[RPS_Feature_Group#Location_Distribution| simulation points feature]]
* A [[RPS_Feature_Group#Frequency_Distribution| frequency discretization feature]]

=== Properties ===

* {{PropertyData|SignificantWaveHeight}}: The significant wave height.
* {{PropertyData|PhillipsConstant}}:The Phillips Constant (0.0081 by default).

=== Scripting ===

The feature can be used from the python console as follows:

{{Code|code=
import SeaLab
import SeaLabObjects
import GeneralToolsGui
import LabRPS
from LabRPS import Vector as vec

# Before you run this code, you should first have created a document with a SeaLab simulation with
# active simulation points and frequency distribution
def compute():

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "ITTC Spectrum"
featureGroup = "Frequency Spectrum"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
spectrum = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not spectrum:
LabRPS.Console.PrintError("Error on creating the spectrum function feature.\n")
return None

sim.MaxFrequency = '0.04 1/s'
sim.NumberOfFrequency = 1024
sim.FrequencyIncrement = sim.MaxFrequency/sim.NumberOfFrequency
sim.setActiveFeature(spectrum)

# For this example we shall compute the cross spectrum matrix at time instant of 0 second and for the frequency value of 0.25 rad/s.
time = 0.0

# compute the simulation points coordinates
simPoints = sim.computeLocationCoordinateMatrixP3()

if not simPoints :
LabRPS.Console.PrintError("Make sure you have an active location disttribution in the simulation with at least 3 simulation points.\n")
return None

# let pick the first simulation point
v1 = vec(simPoints[0][1], simPoints[0][2], simPoints[0][3])
# compute the spectrum vector at time instant of 0 second
# Note that when the following code is run, SeaLab will try to identify the active locations distribution, the active frequency discretization,
# If SeaLab fails to find these dependency features, the computation will fails and specific error messages will be sent to the report view.
spectrums = sim.computeAutoFrequencySpectrumVectorF(v1, time)

# show the results
GeneralToolsGui.GeneralToolsPyTool.showArray(len(spectrums), len(spectrums[0]), spectrums)
LabRPS.ActiveDocument.recompute()

compute()
}}
[[#top| Back to the Top ]]

== Scott Spectrum ==

The Pierson Moskowitz spectrum was modified in the International Towing Tank Conference (1966, 1969,1972) given as:

<math>S(\omega) = 0.214 H^2_s\mbox{exp}\left [ -\frac{1}{0.065}\left ( \frac{\omega-\omega_p}{ \omega-\omega_p +0.26} \right )^{1/2} \right ], \quad \mbox{for } -0.26<\omega-\omega_p < 1.65 \mbox{ and } 0 \mbox{ elsewhere.}</math>

=== Feature Dependency ===
The features required by this feature are summarized as follows:

* A [[RPS_Feature_Group#Location_Distribution| simulation points feature]]
* A [[RPS_Feature_Group#Frequency_Distribution| frequency discretization feature]]

=== Properties ===

* {{PropertyData|SignificantWaveHeight}}: the significant wave height.
* {{PropertyData|PeakFrequency}} the peak frequency of the spectrum.

=== Scripting ===

The feature can be used from the python console as follows:

{{Code|code=
import SeaLab
import SeaLabObjects
import GeneralToolsGui
import LabRPS
from LabRPS import Vector as vec

# Before you run this code, you should first have created a document with a SeaLab simulation with
# active simulation points and frequency distribution
def compute():

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "Scott Spectrum"
featureGroup = "Frequency Spectrum"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
spectrum = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not spectrum:
LabRPS.Console.PrintError("Error on creating the spectrum function feature.\n")
return None

sim.MaxFrequency = '0.04 1/s'
sim.NumberOfFrequency = 1024
sim.FrequencyIncrement = sim.MaxFrequency/sim.NumberOfFrequency
sim.setActiveFeature(spectrum)

# For this example we shall compute the cross spectrum matrix at time instant of 0 second and for the frequency value of 0.25 rad/s.
time = 0.0

# compute the simulation points coordinates
simPoints = sim.computeLocationCoordinateMatrixP3()

if not simPoints :
LabRPS.Console.PrintError("Make sure you have an active location disttribution in the simulation with at least 3 simulation points.\n")
return None

# let pick the first simulation point
v1 = vec(simPoints[0][1], simPoints[0][2], simPoints[0][3])
# compute the spectrum vector at time instant of 0 second
# Note that when the following code is run, SeaLab will try to identify the active locations distribution, the active frequency discretization,
# If SeaLab fails to find these dependency features, the computation will fails and specific error messages will be sent to the report view.
spectrums = sim.computeAutoFrequencySpectrumVectorF(v1, time)

# show the results
GeneralToolsGui.GeneralToolsPyTool.showArray(len(spectrums), len(spectrums[0]), spectrums)
LabRPS.ActiveDocument.recompute()

compute()
}}
[[#top| Back to the Top ]]

== WEN Spectrum ==

WEN spectrum is the wave spectrum of China offshore. It can describe the different stages of wind wave growth and adapt to different water depths:

<math>S(\omega) = \frac{m_0p}{\omega_w}\mbox{exp}\left \{ -95\left [ ln\frac{p \left ( 5.813− 5.137\eta \right )}{\left ( 6.77− 1.088p+0.013p^2 \right )\left ( 1.307− 1.426\eta \right )} \right ]\left ( \frac{\omega}{\omega_0} - 1\right )^{12/5} \right \}, \quad \mbox{for } 0 \le \omega \le 1.15\omega_w</math>

<math>S(\omega) = \frac{m_0}{\omega_w} \frac{\left ( 6.77− 1.088p+0.013p^2 \right )\left ( 1.307− 1.426\eta \right )}{ 5.813− 5.137\eta} \left ( \frac{1.15\omega_w}{\omega} \right )^m, \quad \mbox{for } \omega \ge 1.15\omega_w</math>

=== Feature Dependency ===
The features required by this feature are summarized as follows:

* A [[RPS_Feature_Group#Location_Distribution| simulation points feature]]
* A [[RPS_Feature_Group#Frequency_Distribution| frequency discretization feature]]

=== Properties ===

* {{PropertyData|SignificantWaveHeight}}: the significant wave height.
* {{PropertyData|SignificantWavePeriod}} significant wave period defined as the average period of the significant waves.
* {{PropertyData|DepthParameter}}: The depth parameter taken between 0 and 0.5.
* {{PropertyData|TenMetersHeightMeanWindSpeed}} the mean wind speed at 10 meters above ground.

=== Scripting ===

The feature can be used from the python console as follows:

{{Code|code=
import SeaLab
import SeaLabObjects
import GeneralToolsGui
import LabRPS
from LabRPS import Vector as vec

# Before you run this code, you should first have created a document with a SeaLab simulation with
# active simulation points and frequency distribution
def compute():

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "WEN Spectrum"
featureGroup = "Frequency Spectrum"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
spectrum = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not spectrum:
LabRPS.Console.PrintError("Error on creating the spectrum function feature.\n")
return None

sim.MaxFrequency = '4 1/s'
sim.NumberOfFrequency = 1024
sim.FrequencyIncrement = sim.MaxFrequency/sim.NumberOfFrequency
sim.setActiveFeature(spectrum)

# For this example we shall compute the cross spectrum matrix at time instant of 0 second and for the frequency value of 0.25 rad/s.
time = 0.0

# compute the simulation points coordinates
simPoints = sim.computeLocationCoordinateMatrixP3()

if not simPoints :
LabRPS.Console.PrintError("Make sure you have an active location disttribution in the simulation with at least 3 simulation points.\n")
return None

# let pick the first simulation point
v1 = vec(simPoints[0][1], simPoints[0][2], simPoints[0][3])
# compute the spectrum vector at time instant of 0 second
# Note that when the following code is run, SeaLab will try to identify the active locations distribution, the active frequency discretization,
# If SeaLab fails to find these dependency features, the computation will fails and specific error messages will be sent to the report view.
spectrums = sim.computeAutoFrequencySpectrumVectorF(v1, time)

# show the results
GeneralToolsGui.GeneralToolsPyTool.showArray(len(spectrums), len(spectrums[0]), spectrums)
LabRPS.ActiveDocument.recompute()

compute()
}}
[[#top| Back to the Top ]]

== Cos2s Directional Spreading Function ==

The Cos2s directional spreading function is based on the cosine function with a spreading parameter which does not vary with frequency:

<math>D(\theta) = \frac{\Gamma^2\left ( s+1\right )}{\Gamma\left ( 2s+1\right )}\mbox{cos}^{2s}\left ( \frac{\theta -\theta_0}{2} \right )</math>

=== Feature Dependency ===
The features required by this feature are summarized as follows:

* A [[RPS_Feature_Group#Location_Distribution| simulation points feature]]
* A [[RPS_Feature_Group#Frequency_Distribution| frequency discretization feature]]

=== Properties ===

* {{PropertyData|PrincipalWaveDirection}}: The angle defining the principal direction in which the wave is propagating.
* {{PropertyData|SpreadingExponent}} :The spreading exponent.

=== Scripting ===

The feature can be used from the python console as follows:

{{Code|code=
import SeaLab
import SeaLabObjects
import GeneralToolsGui
import LabRPS
from LabRPS import Vector as vec

# Before you run this code, you should first have created a document with a SeaLab simulation with
# active simulation points and frequency distribution
def compute():

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "Cos2s Directional Spreading Function"
featureGroup = "Directional Spreading Function"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
spreading = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not spreading:
LabRPS.Console.PrintError("Error on creating the spreading function feature.\n")
return None

sim.MinDirection = '-90 deg'
sim.MaxDirection = '90 deg'
sim.NumberOfDirectionIncrements = 1024
sim.DirectionIncrement = (sim.MaxDirection-sim.MinDirection)/sim.NumberOfDirectionIncrements
sim.setActiveFeature(spreading)

# For this example we shall compute the spreading function for the frequency value of 0.25 rad/s.
frequency = 0.04 #hz

# compute the simulation points coordinates
simPoints = sim.computeLocationCoordinateMatrixP3()

if not simPoints :
LabRPS.Console.PrintError("Make sure you have an active location disttribution in the simulation with at least one simulation point.\n")
return None

# let pick the first simulation point
v1 = vec(simPoints[0][1], simPoints[0][2], simPoints[0][3])
# compute the spreading function vector for a frequency of 0.24 rad/s
# Note that when the following code is run, SeaLab will try to identify the active locations distribution, the active frequency discretization,
# If SeaLab fails to find these dependency features, the computation will fails and specific error messages will be sent to the report view.
spreadings = sim.computeDirectionalSpreadingFunctionVectorD(v1, frequency)

# show the results
GeneralToolsGui.GeneralToolsPyTool.showArray(len(spreadings), len(spreadings[0]), spreadings)
LabRPS.ActiveDocument.recompute()

compute()
}}
[[#top| Back to the Top ]]

== Cosine Squared Directional Spreading Function ==

The cosine squared directional spreading function assumes that spreading is proportional to <math>(cos 0)^2</math>. It does not vary with frequency:

<math>D(\theta) = \left ( \frac{2}{\pi} \right )\mbox{cos}^{2}\left ( \theta \right )</math>

=== Feature Dependency ===
The features required by this feature are summarized as follows:

* A [[RPS_Feature_Group#Location_Distribution| simulation points feature]]
* A [[RPS_Feature_Group#Frequency_Distribution| frequency discretization feature]]

=== Scripting ===

The feature can be used from the python console as follows:

{{Code|code=
import SeaLab
import SeaLabObjects
import GeneralToolsGui
import LabRPS
from LabRPS import Vector as vec

# Before you run this code, you should first have created a document with a SeaLab simulation with
# active simulation points and frequency distribution
def compute():

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "Cosine Squared Directional Spreading Function"
featureGroup = "Directional Spreading Function"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
spreading = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not spreading:
LabRPS.Console.PrintError("Error on creating the spreading function feature.\n")
return None

sim.MinDirection = '-90 deg'
sim.MaxDirection = '90 deg'
sim.NumberOfDirectionIncrements = 1024
sim.DirectionIncrement = (sim.MaxDirection-sim.MinDirection)/sim.NumberOfDirectionIncrements
sim.setActiveFeature(spreading)

# For this example we shall compute the spreading function for the frequency value of 0.25 rad/s.
frequency = 0.04 #hz

# compute the simulation points coordinates
simPoints = sim.computeLocationCoordinateMatrixP3()

if not simPoints :
LabRPS.Console.PrintError("Make sure you have an active location disttribution in the simulation with at least one simulation point.\n")
return None

# let pick the first simulation point
v1 = vec(simPoints[0][1], simPoints[0][2], simPoints[0][3])
# compute the spreading function vector for a frequency of 0.24 rad/s
# Note that when the following code is run, SeaLab will try to identify the active locations distribution, the active frequency discretization,
# If SeaLab fails to find these dependency features, the computation will fails and specific error messages will be sent to the report view.
spreadings = sim.computeDirectionalSpreadingFunctionVectorD(v1, frequency)

# show the results
GeneralToolsGui.GeneralToolsPyTool.showArray(len(spreadings), len(spreadings[0]), spreadings)
LabRPS.ActiveDocument.recompute()

compute()
}}
[[#top| Back to the Top ]]

== Mitsuyasu Directional Spreading Function ==

Mitsuyasu et al. (1975) propose the following directional spreading function:

<math>D(\theta, \omega) = \frac{2^{2s-1}}{\pi}\frac{\Gamma^2\left ( s+1\right )}{\Gamma\left ( 2s+1\right )}\left | \mbox{cos}\left ( \frac{\theta}{2} \right )\right |^{2s} </math>

where:

<math>s =
\begin{cases}
s_m\left ( \frac{\omega}{\omega_m} \right )^5, & \mbox{for } \omega \le \omega_m \\
\\
s_m\left ( \frac{\omega}{\omega_m} \right )^{-2.5}, & \mbox{for } \omega > \omega_m
\end{cases}
</math>

<math>s_m = 11.5\left ( \frac{\omega_mU}{g} \right )^{-2.5}</math>

=== Feature Dependency ===
The features required by this feature are summarized as follows:

* A [[RPS_Feature_Group#Location_Distribution| simulation points feature]]
* A [[RPS_Feature_Group#Frequency_Distribution| frequency discretization feature]]

=== Properties ===

* {{PropertyData|ModalFrequency}}: The modal frequency.
* {{PropertyData|TenMeterHeightmeanWindSpeed}} : The mean wind speed at 10 meters above aground.

=== Scripting ===

The feature can be used from the python console as follows:

{{Code|code=
import SeaLab
import SeaLabObjects
import GeneralToolsGui
import LabRPS
from LabRPS import Vector as vec

# Before you run this code, you should first have created a document with a SeaLab simulation with
# active simulation points and frequency distribution
def compute():

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "Mitsuyasu Directional Spreading Function"
featureGroup = "Directional Spreading Function"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
spreading = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not spreading:
LabRPS.Console.PrintError("Error on creating the spreading function feature.\n")
return None

spreading.ModalFrequency = '0.004 1/s'
sim.MinDirection = '-90 deg'
sim.MaxDirection = '90 deg'
sim.NumberOfDirectionIncrements = 1024
sim.DirectionIncrement = (sim.MaxDirection-sim.MinDirection)/sim.NumberOfDirectionIncrements
sim.setActiveFeature(spreading)

# For this example we shall compute the spreading function for the frequency value of 0.25 rad/s.
frequency = 0.004 #hz

# compute the simulation points coordinates
simPoints = sim.computeLocationCoordinateMatrixP3()

if not simPoints :
LabRPS.Console.PrintError("Make sure you have an active location disttribution in the simulation with at least one simulation point.\n")
return None

# let pick the first simulation point
v1 = vec(simPoints[0][1], simPoints[0][2], simPoints[0][3])
# compute the spreading function vector for a frequency of 0.24 rad/s
# Note that when the following code is run, SeaLab will try to identify the active locations distribution, the active frequency discretization,
# If SeaLab fails to find these dependency features, the computation will fails and specific error messages will be sent to the report view.
spreadings = sim.computeDirectionalSpreadingFunctionVectorD(v1, frequency)

# show the results
GeneralToolsGui.GeneralToolsPyTool.showArray(len(spreadings), len(spreadings[0]), spreadings)
LabRPS.ActiveDocument.recompute()

compute()
}}
[[#top| Back to the Top ]]

== Hasselmann Directional Spreading Function ==

From analysis of measured data, Hasselmann et al. (1980) propose the following directional spreading function:

<math>D(\theta, \omega) = \frac{2^{2s-1}}{\pi}\frac{\Gamma^2\left ( s+1\right )}{\Gamma\left ( 2s+1\right )}\left | \mbox{cos}\left ( \frac{\theta}{2} \right )\right |^{2s} </math>

where:

<math>s =
\begin{cases}
6.97\left ( \frac{\omega}{\omega_m} \right )^{4.06}, & \mbox{for } \omega \le 1.05\omega_m \\
\\
9.77\left ( \frac{\omega}{\omega_m} \right )^{\mu}, & \mbox{for } \omega > 1.05\omega_m
\end{cases}
</math>

<math>s_m = -2.33-1.45\left ( \frac{\omega_mU}{g} -1.17\right )</math>

=== Feature Dependency ===
The features required by this feature are summarized as follows:

* A [[RPS_Feature_Group#Location_Distribution| simulation points feature]]
* A [[RPS_Feature_Group#Frequency_Distribution| frequency discretization feature]]

=== Properties ===

* {{PropertyData|ModalFrequency}}: The modal frequency.
* {{PropertyData|MeanWindSpeed}} : The mean wind speed.
* {{PropertyData|WaveCelerity}} : The wave celerity corresponding to the modal frequency.

=== Scripting ===

The feature can be used from the python console as follows:

{{Code|code=
import SeaLab
import SeaLabObjects
import GeneralToolsGui
import LabRPS
from LabRPS import Vector as vec

# Before you run this code, you should first have created a document with a SeaLab simulation with
# active simulation points and frequency distribution
def compute():

# get an existing SeaLab simulation called "Simulation"
sim = SeaLab.getSimulation("Simulation")

# check if the simulation does really exist
if not sim:
LabRPS.Console.PrintError("The simulation does not exist.\n")
return None

featureType = "Hasselmann Directional Spreading Function"
featureGroup = "Directional Spreading Function"

# create the feature and add it to the existing simulation (you may refer to the SeaLab Workbench page in
# case you don't understand the next line)
spreading = SeaLabObjects.makeFeature("MyNewFeature", sim.Name, featureType, featureGroup)

# check if the created feature is good
if not spreading:
LabRPS.Console.PrintError("Error on creating the spreading function feature.\n")
return None

spreading.ModalFrequency = '0.004 1/s'
sim.MinDirection = '-90 deg'
sim.MaxDirection = '90 deg'
sim.NumberOfDirectionIncrements = 1024
sim.DirectionIncrement = (sim.MaxDirection-sim.MinDirection)/sim.NumberOfDirectionIncrements
sim.setActiveFeature(spreading)

# For this example we shall compute the spreading function for the frequency value of 0.25 rad/s.
frequency = 0.04 #hz

# compute the simulation points coordinates
simPoints = sim.computeLocationCoordinateMatrixP3()

if not simPoints :
LabRPS.Console.PrintError("Make sure you have an active location disttribution in the simulation with at least one simulation point.\n")
return None

# let pick the first simulation point
v1 = vec(simPoints[0][1], simPoints[0][2], simPoints[0][3])
# compute the spreading function vector for a frequency of 0.24 rad/s
# Note that when the following code is run, SeaLab will try to identify the active locations distribution, the active frequency discretization,
# If SeaLab fails to find these dependency features, the computation will fails and specific error messages will be sent to the report view.
spreadings = sim.computeDirectionalSpreadingFunctionVectorD(v1, frequency)

# show the results
GeneralToolsGui.GeneralToolsPyTool.showArray(len(spreadings), len(spreadings[0]), spreadings)
LabRPS.ActiveDocument.recompute()

compute()
}}
[[#top| Back to the Top ]]