Skip to content

Boundary and initial conditions

Sub-commands to support the boundary and initial conditions components

Boundary

SIDE

Bases: BaseSubComponent

Boundary over one side of computational domain.

.. code-block:: text

SIDE NORTH|NW|WEST|SW|SOUTH|SE|E|NE CCW|CLOCKWISE

The boundary is one full side of the computational grid (in 1D cases either of the two ends of the 1D-grid).

Note

Should not be used in case of CURVILINEAR grids.

Examples

.. ipython:: python :okwarning:

from rompy_swan.subcomponents.boundary import SIDE
side = SIDE(side="west", direction="ccw")
print(side.render())
Source code in rompy_swan/subcomponents/boundary.py 
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
class SIDE(BaseSubComponent):
    """Boundary over one side of computational domain.

    .. code-block:: text

        SIDE NORTH|NW|WEST|SW|SOUTH|SE|E|NE CCW|CLOCKWISE

    The boundary is one full side of the computational grid (in 1D cases either of the
    two ends of the 1D-grid).

    Note
    ----
    Should not be used in case of CURVILINEAR grids.

    Examples
    --------

    .. ipython:: python
        :okwarning:

        from rompy_swan.subcomponents.boundary import SIDE
        side = SIDE(side="west", direction="ccw")
        print(side.render())

    """

    model_type: Literal["side", "SIDE"] = Field(
        default="side",
        description="Model type discriminator",
    )
    side: Literal["north", "nw", "west", "sw", "south", "se", "east", "ne"] = Field(
        description="The side of the grid to apply the boundary to",
    )
    direction: Literal["ccw", "clockwise"] = Field(
        default="ccw",
        description="The direction to apply the boundary in",
    )

    def cmd(self) -> str:
        repr = f"SIDE {self.side.upper()} {self.direction.upper()} "
        return repr

Attributes

model_type class-attribute instance-attribute 

model_type: Literal['side', 'SIDE'] = Field(default='side', description='Model type discriminator')

side class-attribute instance-attribute 

side: Literal['north', 'nw', 'west', 'sw', 'south', 'se', 'east', 'ne'] = Field(description='The side of the grid to apply the boundary to')

direction class-attribute instance-attribute 

direction: Literal['ccw', 'clockwise'] = Field(default='ccw', description='The direction to apply the boundary in')

Functions

cmd 

cmd() -> str
Source code in rompy_swan/subcomponents/boundary.py 
56
57
58
def cmd(self) -> str:
    repr = f"SIDE {self.side.upper()} {self.direction.upper()} "
    return repr

SEGMENT

Bases: BaseSubComponent

Boundary over a segment defined from points.

.. code-block:: text

SEGMENT XY < [x] [y] >
SEGMENT IJ < [i] [j] >

The segment is defined either by means of a series of points in terms of problem coordinates (XY) or by means of a series of points in terms of grid indices (IJ). The points do not have to include all or coincide with actual grid points.

Examples

.. ipython:: python :okwarning:

from rompy_swan.subcomponents.boundary import SEGMENT
seg = SEGMENT(
    points=dict(
        model_type="xy",
        x=[172, 172, 172, 172.5, 173],
        y=[-41, -40.5, -40, -40, -40],
        fmt="0.2f",
    ),
)
print(seg.render())
seg = SEGMENT(
    points=dict(
        model_type="ij",
        i=[0, 0, 5],
        j=[0, 19, 19],
    ),
)
print(seg.render())
Source code in rompy_swan/subcomponents/boundary.py 
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
class SEGMENT(BaseSubComponent):
    """Boundary over a segment defined from points.

    .. code-block:: text

        SEGMENT XY < [x] [y] >
        SEGMENT IJ < [i] [j] >

    The segment is defined either by means of a series of points in terms of problem
    coordinates (`XY`) or by means of a series of points in terms of grid indices
    (`IJ`). The points do not have to include all or coincide with actual grid points.

    Examples
    --------

    .. ipython:: python
        :okwarning:

        from rompy_swan.subcomponents.boundary import SEGMENT
        seg = SEGMENT(
            points=dict(
                model_type="xy",
                x=[172, 172, 172, 172.5, 173],
                y=[-41, -40.5, -40, -40, -40],
                fmt="0.2f",
            ),
        )
        print(seg.render())
        seg = SEGMENT(
            points=dict(
                model_type="ij",
                i=[0, 0, 5],
                j=[0, 19, 19],
            ),
        )
        print(seg.render())

    """

    model_type: Literal["segment", "SEGMENT"] = Field(
        default="segment",
        description="Model type discriminator",
    )
    points: Union[XY, IJ] = Field(
        description="Points to define the segment",
        discriminator="model_type",
    )

    def cmd(self) -> str:
        return f"SEGMENT {self.points.model_type.upper()} {self.points.render()}"

Attributes

model_type class-attribute instance-attribute 

model_type: Literal['segment', 'SEGMENT'] = Field(default='segment', description='Model type discriminator')

points class-attribute instance-attribute 

points: Union[XY, IJ] = Field(description='Points to define the segment', discriminator='model_type')

Functions

cmd 

cmd() -> str
Source code in rompy_swan/subcomponents/boundary.py 
151
152
def cmd(self) -> str:
    return f"SEGMENT {self.points.model_type.upper()} {self.points.render()}"

PAR

Bases: BaseSubComponent

Spectral parameters.

.. code-block:: text

PAR [hs] [per] [dir] [dd]

Examples

.. ipython:: python :okwarning:

from rompy_swan.subcomponents.boundary import PAR
par = PAR(hs=1.5, per=8.1, dir=225)
print(par.render())
Source code in rompy_swan/subcomponents/boundary.py 
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
class PAR(BaseSubComponent):
    """Spectral parameters.

    .. code-block:: text

        PAR [hs] [per] [dir] [dd]

    Examples
    --------

    .. ipython:: python
        :okwarning:

        from rompy_swan.subcomponents.boundary import PAR
        par = PAR(hs=1.5, per=8.1, dir=225)
        print(par.render())

    """

    model_type: Literal["par"] = Field(
        default="par",
        description="Model type discriminator",
    )
    hs: float = Field(
        description="The significant wave height (m)",
        gt=0.0,
    )
    per: float = Field(
        description=(
            "The characteristic period (s) of the energy spectrum (relative "
            "frequency; which is equal to absolute frequency in the absence of "
            "currents); `per` is the value of the peak period if option PEAK is "
            "chosen in command BOUND SHAPE or `per` is the value of the mean period, "
            "if option MEAN was chosen in command BOUND SHAPE."
        ),
        gt=0.0,
    )
    dir: float = Field(
        description=(
            "The peak wave direction thetapeak (degree), constant over frequencies"
        ),
        ge=-360.0,
        le=360.0,
    )
    dd: Optional[float] = Field(
        default=None,
        description=(
            "Coefficient of directional spreading; a `cos^m(θ)` distribution is "
            "assumed. `dd` is interpreted as the directional standard deviation in "
            "degrees, if the option DEGREES is chosen in the command BOUND SHAPE "
            "(SWAN default: 30). `dd` is interpreted as the power `m`, if the option "
            "POWER is chosen in the command BOUND SHAPE (SWAN default: 2)"
        ),
        ge=0.0,
        le=360.0,
    )

    def cmd(self) -> str:
        """Render subcomponent cmd."""
        repr = f"PAR hs={self.hs} per={self.per} dir={self.dir}"
        if self.dd is not None:
            repr += f" dd={self.dd}"
        return repr

Attributes

model_type class-attribute instance-attribute 

model_type: Literal['par'] = Field(default='par', description='Model type discriminator')

hs class-attribute instance-attribute 

hs: float = Field(description='The significant wave height (m)', gt=0.0)

per class-attribute instance-attribute 

per: float = Field(description='The characteristic period (s) of the energy spectrum (relative frequency; which is equal to absolute frequency in the absence of currents); `per` is the value of the peak period if option PEAK is chosen in command BOUND SHAPE or `per` is the value of the mean period, if option MEAN was chosen in command BOUND SHAPE.', gt=0.0)

dir class-attribute instance-attribute 

dir: float = Field(description='The peak wave direction thetapeak (degree), constant over frequencies', ge=-360.0, le=360.0)

dd class-attribute instance-attribute 

dd: Optional[float] = Field(default=None, description='Coefficient of directional spreading; a `cos^m(θ)` distribution is assumed. `dd` is interpreted as the directional standard deviation in degrees, if the option DEGREES is chosen in the command BOUND SHAPE (SWAN default: 30). `dd` is interpreted as the power `m`, if the option POWER is chosen in the command BOUND SHAPE (SWAN default: 2)', ge=0.0, le=360.0)

Functions

cmd 

cmd() -> str

Render subcomponent cmd.

Source code in rompy_swan/subcomponents/boundary.py 
212
213
214
215
216
217
def cmd(self) -> str:
    """Render subcomponent cmd."""
    repr = f"PAR hs={self.hs} per={self.per} dir={self.dir}"
    if self.dd is not None:
        repr += f" dd={self.dd}"
    return repr

CONSTANTPAR

Bases: PAR

Constant spectral parameters.

.. code-block:: text

CONSTANT PAR [hs] [per] [dir] ([dd])

Examples

.. ipython:: python :okwarning:

from rompy_swan.subcomponents.boundary import CONSTANTPAR
par = CONSTANTPAR(hs=1.5, per=8.1, dir=225)
print(par.render())
Source code in rompy_swan/subcomponents/boundary.py 
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
class CONSTANTPAR(PAR):
    """Constant spectral parameters.

    .. code-block:: text

        CONSTANT PAR [hs] [per] [dir] ([dd])

    Examples
    --------

    .. ipython:: python
        :okwarning:

        from rompy_swan.subcomponents.boundary import CONSTANTPAR
        par = CONSTANTPAR(hs=1.5, per=8.1, dir=225)
        print(par.render())

    """

    model_type: Literal["constantpar", "CONSTANTPAR"] = Field(
        default="constantpar",
        description="Model type discriminator",
    )

    def cmd(self) -> str:
        """Render subcomponent cmd."""
        return f"CONSTANT {super().cmd()}"

Attributes

model_type class-attribute instance-attribute 

model_type: Literal['constantpar', 'CONSTANTPAR'] = Field(default='constantpar', description='Model type discriminator')

Functions

cmd 

cmd() -> str

Render subcomponent cmd.

Source code in rompy_swan/subcomponents/boundary.py 
244
245
246
def cmd(self) -> str:
    """Render subcomponent cmd."""
    return f"CONSTANT {super().cmd()}"

VARIABLEPAR

Bases: BaseSubComponent

Variable spectral parameter.

.. code-block:: text

VARIABLE PAR < [len] [hs] [per] [dir] [dd] >

Examples

.. ipython:: python :okwarning:

from rompy_swan.subcomponents.boundary import VARIABLEPAR
par = VARIABLEPAR(
    hs=[1.5, 1.4, 1.1],
    per=[8.1, 8.0, 8.1],
    dir=[225, 226, 228],
    dd=[25, 22, 23],
    len=[0, 0.5, 1.0],
)
print(par.render())
Source code in rompy_swan/subcomponents/boundary.py 
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
class VARIABLEPAR(BaseSubComponent):
    """Variable spectral parameter.

    .. code-block:: text

        VARIABLE PAR < [len] [hs] [per] [dir] [dd] >

    Examples
    --------

    .. ipython:: python
        :okwarning:

        from rompy_swan.subcomponents.boundary import VARIABLEPAR
        par = VARIABLEPAR(
            hs=[1.5, 1.4, 1.1],
            per=[8.1, 8.0, 8.1],
            dir=[225, 226, 228],
            dd=[25, 22, 23],
            len=[0, 0.5, 1.0],
        )
        print(par.render())

    """

    model_type: Literal["variablepar", "VARIABLEPAR"] = Field(
        default="variablepar",
        description="Model type discriminator",
    )
    hs: list[Annotated[float, Field(ge=0.0)]] = Field(
        description="The significant wave height (m)",
    )
    per: list[Annotated[float, Field(ge=0.0)]] = Field(
        description=(
            "The characteristic period (s) of the energy spectrum (relative "
            "frequency; which is equal to absolute frequency in the absence of "
            "currents); `per` is the value of the peak period if option PEAK is "
            "chosen in command BOUND SHAPE or `per` is the value of the mean period, "
            "if option MEAN was chosen in command BOUND SHAPE"
        ),
    )
    dir: list[Annotated[float, Field(ge=-360.0, le=360.0)]] = Field(
        description=(
            "The peak wave direction thetapeak (degrees), constant over frequencies"
        ),
    )
    dd: list[Annotated[float, Field(ge=0.0, le=360.0)]] = Field(
        description=(
            "Coefficient of directional spreading; a $cos^m(θ)$ distribution is "
            "assumed. `dd` is interpreted as the directional standard deviation in "
            "degrees, if the option DEGREES is chosen in the command BOUND SHAPE "
            "(SWAN default: 30). `dd` is interpreted as the power `m`, if the option "
            "POWER is chosen in the command BOUND SHAPE (SWAN default: 2)"
        ),
    )
    dist: list[Annotated[float, Field(ge=0)]] = Field(
        alias="len",
        description=(
            "Is the distance from the first point of the side or segment to the point "
            "along the side or segment for which the incident wave spectrum is "
            "prescribed. Note: these points do no have to coincide with grid points of "
            "the computational grid. `len` is the distance in m or degrees in the case "
            "of spherical coordinates, not in grid steps. The values of `len` should "
            "be given in ascending order. The length along a SIDE is measured in "
            "clockwise or counterclockwise direction, depending on the options CCW or "
            "CLOCKWISE (see above). The option CCW is default. In case of a SEGMENT "
            "the length is measured from the indicated begin point of the segment"
        ),
    )

    @model_validator(mode="after")
    def ensure_equal_size(self) -> "VARIABLEPAR":
        for key in ["hs", "per", "dir", "dd"]:
            if len(getattr(self, key)) != len(self.dist):
                raise ValueError(f"Size of dist and {key} must be the same")
        return self

    def cmd(self) -> str:
        """Render subcomponent cmd."""
        repr = "VARIABLE PAR"
        for dist, hs, per, dir, dd in zip(
            self.dist, self.hs, self.per, self.dir, self.dd
        ):
            repr += f" &\n\tlen={dist} hs={hs} per={per} dir={dir} dd={dd}"
        return repr

Attributes

model_type class-attribute instance-attribute 

model_type: Literal['variablepar', 'VARIABLEPAR'] = Field(default='variablepar', description='Model type discriminator')

hs class-attribute instance-attribute 

hs: list[Annotated[float, Field(ge=0.0)]] = Field(description='The significant wave height (m)')

per class-attribute instance-attribute 

per: list[Annotated[float, Field(ge=0.0)]] = Field(description='The characteristic period (s) of the energy spectrum (relative frequency; which is equal to absolute frequency in the absence of currents); `per` is the value of the peak period if option PEAK is chosen in command BOUND SHAPE or `per` is the value of the mean period, if option MEAN was chosen in command BOUND SHAPE')

dir class-attribute instance-attribute 

dir: list[Annotated[float, Field(ge=-360.0, le=360.0)]] = Field(description='The peak wave direction thetapeak (degrees), constant over frequencies')

dd class-attribute instance-attribute 

dd: list[Annotated[float, Field(ge=0.0, le=360.0)]] = Field(description='Coefficient of directional spreading; a $cos^m(θ)$ distribution is assumed. `dd` is interpreted as the directional standard deviation in degrees, if the option DEGREES is chosen in the command BOUND SHAPE (SWAN default: 30). `dd` is interpreted as the power `m`, if the option POWER is chosen in the command BOUND SHAPE (SWAN default: 2)')

dist class-attribute instance-attribute 

dist: list[Annotated[float, Field(ge=0)]] = Field(alias='len', description='Is the distance from the first point of the side or segment to the point along the side or segment for which the incident wave spectrum is prescribed. Note: these points do no have to coincide with grid points of the computational grid. `len` is the distance in m or degrees in the case of spherical coordinates, not in grid steps. The values of `len` should be given in ascending order. The length along a SIDE is measured in clockwise or counterclockwise direction, depending on the options CCW or CLOCKWISE (see above). The option CCW is default. In case of a SEGMENT the length is measured from the indicated begin point of the segment')

Functions

ensure_equal_size 

ensure_equal_size() -> VARIABLEPAR
Source code in rompy_swan/subcomponents/boundary.py 
319
320
321
322
323
324
@model_validator(mode="after")
def ensure_equal_size(self) -> "VARIABLEPAR":
    for key in ["hs", "per", "dir", "dd"]:
        if len(getattr(self, key)) != len(self.dist):
            raise ValueError(f"Size of dist and {key} must be the same")
    return self

cmd 

cmd() -> str

Render subcomponent cmd.

Source code in rompy_swan/subcomponents/boundary.py 
326
327
328
329
330
331
332
333
def cmd(self) -> str:
    """Render subcomponent cmd."""
    repr = "VARIABLE PAR"
    for dist, hs, per, dir, dd in zip(
        self.dist, self.hs, self.per, self.dir, self.dd
    ):
        repr += f" &\n\tlen={dist} hs={hs} per={per} dir={dir} dd={dd}"
    return repr

CONSTANTFILE

Bases: BaseSubComponent

Constant file specification.

.. code-block:: text

CONSTANT FILE 'fname' [seq]

There are three types of files:

  • TPAR files containing nonstationary wave parameters
  • files containing stationary or nonstationary 1D spectra (usually from measurements)
  • files containing stationary or nonstationary 2D spectra (from other computer programs or other SWAN runs)

A TPAR file is for only one location; it has the string TPAR on the first line of the file and a number of lines which each contain 5 numbers, i.e.: Time (ISO-notation), Hs, Period (average or peak period depending on the choice given in command BOUND SHAPE), Peak Direction (Nautical or Cartesian, depending on command SET), Directional spread (in degrees or as power of cos depending on the choice given in command BOUND SHAPE).

Note

Example of a TPAR file:

.. code-block:: text

TPAR
19920516.130000 4.2 12. -110. 22.
19920516.180000 4.2 12. -110. 22.
19920517.000000 1.2 8. -110. 22.
19920517.120000 1.4 8.5 -80. 26
19920517.200000 0.9 6.5 -95. 28

Examples

.. ipython:: python :okwarning:

from rompy_swan.subcomponents.boundary import CONSTANTFILE
par = CONSTANTFILE(fname="tpar.txt")
print(par.render())
Source code in rompy_swan/subcomponents/boundary.py 
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
class CONSTANTFILE(BaseSubComponent):
    """Constant file specification.

    .. code-block:: text

        CONSTANT FILE 'fname' [seq]

    There are three types of files:

    - TPAR files containing nonstationary wave parameters
    - files containing stationary or nonstationary 1D spectra
      (usually from measurements)
    - files containing stationary or nonstationary 2D spectra
      (from other computer programs or other SWAN runs)

    A TPAR file is for only one location; it has the string TPAR on the first
    line of the file and a number of lines which each contain 5 numbers, i.e.:
    Time (ISO-notation), Hs, Period (average or peak period depending on the
    choice given in command BOUND SHAPE), Peak Direction (Nautical or Cartesian,
    depending on command SET), Directional spread (in degrees or as power of cos
    depending on the choice given in command BOUND SHAPE).

    Note
    ----
    Example of a TPAR file:

    .. code-block:: text

        TPAR
        19920516.130000 4.2 12. -110. 22.
        19920516.180000 4.2 12. -110. 22.
        19920517.000000 1.2 8. -110. 22.
        19920517.120000 1.4 8.5 -80. 26
        19920517.200000 0.9 6.5 -95. 28

    Examples
    --------

    .. ipython:: python
        :okwarning:

        from rompy_swan.subcomponents.boundary import CONSTANTFILE
        par = CONSTANTFILE(fname="tpar.txt")
        print(par.render())

    """

    model_type: Literal["constantfile", "CONSTANTFILE"] = Field(
        default="constantfile",
        description="Model type discriminator",
    )
    fname: str = Field(
        description="Name of the file containing the boundary condition.",
        max_length=36,
    )
    seq: Optional[int] = Field(
        default=None,
        description=(
            "sequence number of geographic location in the file (see Appendix D); "
            "useful for files which contain spectra for more than one location. "
            "Note: a TPAR file always contains only one location so in this case "
            "`seq` must always be 1"
        ),
        ge=1,
    )

    def cmd(self) -> str:
        """Render subcomponent cmd."""
        repr = f"CONSTANT FILE fname='{self.fname}'"
        if self.seq is not None:
            repr += f" seq={self.seq}"
        return repr

Attributes

model_type class-attribute instance-attribute 

model_type: Literal['constantfile', 'CONSTANTFILE'] = Field(default='constantfile', description='Model type discriminator')

fname class-attribute instance-attribute 

fname: str = Field(description='Name of the file containing the boundary condition.', max_length=36)

seq class-attribute instance-attribute 

seq: Optional[int] = Field(default=None, description='sequence number of geographic location in the file (see Appendix D); useful for files which contain spectra for more than one location. Note: a TPAR file always contains only one location so in this case `seq` must always be 1', ge=1)

Functions

cmd 

cmd() -> str

Render subcomponent cmd.

Source code in rompy_swan/subcomponents/boundary.py 
402
403
404
405
406
407
def cmd(self) -> str:
    """Render subcomponent cmd."""
    repr = f"CONSTANT FILE fname='{self.fname}'"
    if self.seq is not None:
        repr += f" seq={self.seq}"
    return repr

VARIABLEFILE

Bases: BaseSubComponent

Variable file specification.

.. code-block:: text

VARIABLE FILE < [len] 'fname' [seq] >

There are three types of files:

  • TPAR files containing nonstationary wave parameters
  • files containing stationary or nonstationary 1D spectra (usually from measurements)
  • files containing stationary or nonstationary 2D spectra (from other computer programs or other SWAN runs)

A TPAR file is for only one location; it has the string TPAR on the first line of the file and a number of lines which each contain 5 numbers, i.e.: Time (ISO-notation), Hs, Period (average or peak period depending on the choice given in command BOUND SHAPE), Peak Direction (Nautical or Cartesian, depending on command SET), Directional spread (in degrees or as power of cos depending on the choice given in command BOUND SHAPE).

Note

Example of a TPAR file:

.. code-block:: text

TPAR
19920516.130000 4.2 12. -110. 22.
19920516.180000 4.2 12. -110. 22.
19920517.000000 1.2 8. -110. 22.
19920517.120000 1.4 8.5 -80. 26
19920517.200000 0.9 6.5 -95. 28

Examples

.. ipython:: python :okwarning:

from rompy_swan.subcomponents.boundary import VARIABLEFILE
par = VARIABLEFILE(
    fname=["tpar1.txt", "tpar2.txt", "tpar3.txt"],
    len=[0.0, 0.5, 1.0],
)
print(par.render())
Source code in rompy_swan/subcomponents/boundary.py 
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
class VARIABLEFILE(BaseSubComponent):
    """Variable file specification.

    .. code-block:: text

        VARIABLE FILE < [len] 'fname' [seq] >

    There are three types of files:

    - TPAR files containing nonstationary wave parameters
    - files containing stationary or nonstationary 1D spectra
      (usually from measurements)
    - files containing stationary or nonstationary 2D spectra
      (from other computer programs or other SWAN runs)

    A TPAR file is for only one location; it has the string TPAR on the first
    line of the file and a number of lines which each contain 5 numbers, i.e.:
    Time (ISO-notation), Hs, Period (average or peak period depending on the
    choice given in command BOUND SHAPE), Peak Direction (Nautical or Cartesian,
    depending on command SET), Directional spread (in degrees or as power of cos
    depending on the choice given in command BOUND SHAPE).

    Note
    ----
    Example of a TPAR file:

    .. code-block:: text

        TPAR
        19920516.130000 4.2 12. -110. 22.
        19920516.180000 4.2 12. -110. 22.
        19920517.000000 1.2 8. -110. 22.
        19920517.120000 1.4 8.5 -80. 26
        19920517.200000 0.9 6.5 -95. 28

    Examples
    --------

    .. ipython:: python
        :okwarning:

        from rompy_swan.subcomponents.boundary import VARIABLEFILE
        par = VARIABLEFILE(
            fname=["tpar1.txt", "tpar2.txt", "tpar3.txt"],
            len=[0.0, 0.5, 1.0],
        )
        print(par.render())

    """

    model_type: Literal["variablefile", "VARIABLEFILE"] = Field(
        default="variablefile",
        description="Model type discriminator",
    )
    fname: list[Annotated[str, Field(max_length=36)]] = Field(
        description="Names of the files containing the boundary condition",
    )
    seq: Optional[list[Annotated[int, Field(ge=1)]]] = Field(
        default=None,
        description=(
            "sequence number of geographic location in the file (see Appendix D); "
            "useful for files which contain spectra for more than one location. "
            "Note: a TPAR file always contains only one location so in this case "
            "[seq] must always be 1."
        ),
    )
    dist: list[Annotated[float, Field(ge=0)]] = Field(
        alias="len",
        description=(
            "Is the distance from the first point of the side or segment to the point "
            "along the side or segment for which the incident wave spectrum is "
            "prescribed. Note: these points do no have to coincide with grid points "
            "of the computational grid. [len] is the distance in m or degrees in the "
            "case of spherical coordinates, not in grid steps. The values of `len` "
            "should be given in ascending order. The length along a SIDE is measured "
            "in clockwise or counterclockwise direction, depending on the options CCW "
            "or CLOCKWISE (see above). The option CCW is default. In case of a "
            "SEGMENT the length is measured from the indicated begin point of the "
            "segment."
        ),
    )

    @model_validator(mode="after")
    def ensure_equal_size(self) -> "VARIABLEFILE":
        for key in ["fname", "seq"]:
            attr = getattr(self, key)
            if attr is not None and len(attr) != len(self.dist):
                raise ValueError(f"Size of dist and {key} must be the same")
        if self.seq is None:
            self.seq = [1] * len(self.dist)
        return self

    def cmd(self) -> str:
        """Render subcomponent cmd."""
        repr = "VARIABLE FILE"
        for dist, fname, seq in zip(self.dist, self.fname, self.seq):
            repr += f" &\n\tlen={dist} fname='{fname}' seq={seq}"
        return repr

Attributes

model_type class-attribute instance-attribute 

model_type: Literal['variablefile', 'VARIABLEFILE'] = Field(default='variablefile', description='Model type discriminator')

fname class-attribute instance-attribute 

fname: list[Annotated[str, Field(max_length=36)]] = Field(description='Names of the files containing the boundary condition')

seq class-attribute instance-attribute 

seq: Optional[list[Annotated[int, Field(ge=1)]]] = Field(default=None, description='sequence number of geographic location in the file (see Appendix D); useful for files which contain spectra for more than one location. Note: a TPAR file always contains only one location so in this case [seq] must always be 1.')

dist class-attribute instance-attribute 

dist: list[Annotated[float, Field(ge=0)]] = Field(alias='len', description='Is the distance from the first point of the side or segment to the point along the side or segment for which the incident wave spectrum is prescribed. Note: these points do no have to coincide with grid points of the computational grid. [len] is the distance in m or degrees in the case of spherical coordinates, not in grid steps. The values of `len` should be given in ascending order. The length along a SIDE is measured in clockwise or counterclockwise direction, depending on the options CCW or CLOCKWISE (see above). The option CCW is default. In case of a SEGMENT the length is measured from the indicated begin point of the segment.')

Functions

ensure_equal_size 

ensure_equal_size() -> VARIABLEFILE
Source code in rompy_swan/subcomponents/boundary.py 
492
493
494
495
496
497
498
499
500
@model_validator(mode="after")
def ensure_equal_size(self) -> "VARIABLEFILE":
    for key in ["fname", "seq"]:
        attr = getattr(self, key)
        if attr is not None and len(attr) != len(self.dist):
            raise ValueError(f"Size of dist and {key} must be the same")
    if self.seq is None:
        self.seq = [1] * len(self.dist)
    return self

cmd 

cmd() -> str

Render subcomponent cmd.

Source code in rompy_swan/subcomponents/boundary.py 
502
503
504
505
506
507
def cmd(self) -> str:
    """Render subcomponent cmd."""
    repr = "VARIABLE FILE"
    for dist, fname, seq in zip(self.dist, self.fname, self.seq):
        repr += f" &\n\tlen={dist} fname='{fname}' seq={seq}"
    return repr

Initial conditions

DEFAULT

Bases: BaseSubComponent

Default initial conditions.

.. code-block:: text

DEFAULT

The initial spectra are computed from the local wind velocities, using the deep-water growth curve of Kahma and Calkoen (1992), cut off at values of significant wave height and peak frequency from Pierson and Moskowitz (1964). The average (over the model area) spatial step size is used as fetch with local wind. The shape of the spectrum is default JONSWAP with a cos2-directional distribution (options are available: see command BOUND SHAPE).

Examples

.. ipython:: python :okwarning:

from rompy_swan.subcomponents.boundary import DEFAULT
init = DEFAULT()
print(init.render())
Source code in rompy_swan/subcomponents/boundary.py 
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
class DEFAULT(BaseSubComponent):
    """Default initial conditions.

    .. code-block:: text

        DEFAULT

    The initial spectra are computed from the local wind velocities, using the
    deep-water growth curve of Kahma and Calkoen (1992), cut off at values of
    significant wave height and peak frequency from Pierson and Moskowitz (1964).
    The average (over the model area) spatial step size is used as fetch with local
    wind. The shape of the spectrum is default JONSWAP with a cos2-directional
    distribution (options are available: see command BOUND SHAPE).

    Examples
    --------

    .. ipython:: python
        :okwarning:

        from rompy_swan.subcomponents.boundary import DEFAULT
        init = DEFAULT()
        print(init.render())

    """

    model_type: Literal["default", "DEFAULT"] = Field(
        default="default",
        description="Model type discriminator",
    )

Attributes

model_type class-attribute instance-attribute 

model_type: Literal['default', 'DEFAULT'] = Field(default='default', description='Model type discriminator')

ZERO

Bases: BaseSubComponent

Zero initial conditions.

.. code-block:: text

ZERO

The initial spectral densities are all 0; note that if waves are generated in the model only by wind, waves can become non-zero only by the presence of the ”A” term in the growth model; see the keyword AGROW in command GEN3.

Examples

.. ipython:: python :okwarning:

from rompy_swan.subcomponents.boundary import ZERO
init = ZERO()
print(init.render())
Source code in rompy_swan/subcomponents/boundary.py 
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
class ZERO(BaseSubComponent):
    """Zero initial conditions.

    .. code-block:: text

        ZERO

    The initial spectral densities are all 0; note that if waves are generated in the
    model only by wind, waves can become non-zero only by the presence of the
    ”A” term in the growth model; see the keyword AGROW in command GEN3.

    Examples
    --------

    .. ipython:: python
        :okwarning:

        from rompy_swan.subcomponents.boundary import ZERO
        init = ZERO()
        print(init.render())

    """

    model_type: Literal["zero", "ZERO"] = Field(
        default="zero",
        description="Model type discriminator",
    )

Attributes

model_type class-attribute instance-attribute 

model_type: Literal['zero', 'ZERO'] = Field(default='zero', description='Model type discriminator')

HOTSINGLE

Bases: BaseSubComponent

Hotstart single initial conditions.

.. code-block:: text

HOTSTART SINGLE fname='fname' FREE|UNFORMATTED

Initial wave field is read from file; this file was generated in a previous SWAN run by means of the HOTFILE command. If the previous run was nonstationary, the time found on the file will be assumed to be the initial time of computation. It can also be used for stationary computation as first guess. The computational grid (both in geographical space and in spectral space) must be identical to the one in the run in which the initial wave field was computed

Input will be read from a single (concatenated) hotfile. In the case of a previous parallel MPI run, the concatenated hotfile can be created from a set of multiple hotfiles using the program hcat.exe, see Implementation Manual.

Examples

.. ipython:: python :okwarning:

from rompy_swan.subcomponents.boundary import HOTSINGLE
init = HOTSINGLE(fname="hotstart.swn", format="free")
print(init.render())
Source code in rompy_swan/subcomponents/boundary.py 
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
class HOTSINGLE(BaseSubComponent):
    """Hotstart single initial conditions.

    .. code-block:: text

        HOTSTART SINGLE fname='fname' FREE|UNFORMATTED

    Initial wave field is read from file; this file was generated in a previous SWAN
    run by means of the HOTFILE command. If the previous run was nonstationary,
    the time found on the file will be assumed to be the initial time of computation. It
    can also be used for stationary computation as first guess. The computational grid
    (both in geographical space and in spectral space) must be identical to the one in
    the run in which the initial wave field was computed

    Input will be read from a single (concatenated) hotfile. In the case of a previous
    parallel MPI run, the concatenated hotfile can be created from a set of multiple
    hotfiles using the program hcat.exe, see Implementation Manual.

    Examples
    --------

    .. ipython:: python
        :okwarning:

        from rompy_swan.subcomponents.boundary import HOTSINGLE
        init = HOTSINGLE(fname="hotstart.swn", format="free")
        print(init.render())

    """

    model_type: Literal["hotsingle", "HOTSINGLE"] = Field(
        default="hotsingle",
        description="Model type discriminator",
    )
    fname: str = Field(
        description="Name of the file containing the initial wave field",
        max_length=36,
    )
    format: Literal["free", "unformatted"] = Field(
        default="free",
        description=(
            "Format of the file containing the initial wave field. "
            "FREE: free format, UNFORMATTED: binary format"
        ),
    )

    def cmd(self) -> str:
        """Render subcomponent cmd."""
        return f"HOTSTART SINGLE fname='{self.fname}' {self.format.upper()}"

Attributes

model_type class-attribute instance-attribute 

model_type: Literal['hotsingle', 'HOTSINGLE'] = Field(default='hotsingle', description='Model type discriminator')

fname class-attribute instance-attribute 

fname: str = Field(description='Name of the file containing the initial wave field', max_length=36)

format class-attribute instance-attribute 

format: Literal['free', 'unformatted'] = Field(default='free', description='Format of the file containing the initial wave field. FREE: free format, UNFORMATTED: binary format')

Functions

cmd 

cmd() -> str

Render subcomponent cmd.

Source code in rompy_swan/subcomponents/boundary.py 
617
618
619
def cmd(self) -> str:
    """Render subcomponent cmd."""
    return f"HOTSTART SINGLE fname='{self.fname}' {self.format.upper()}"

HOTMULTIPLE

Bases: BaseSubComponent

Hotstart multiple initial conditions.

.. code-block:: text

HOTSTART MULTIPLE fname='fname' FREE|UNFORMATTED

Initial wave field is read from file; this file was generated in a previous SWAN run by means of the HOTFILE command. If the previous run was nonstationary, the time found on the file will be assumed to be the initial time of computation. It can also be used for stationary computation as first guess. The computational grid (both in geographical space and in spectral space) must be identical to the one in the run in which the initial wave field was computed

Input will be read from multiple hotfiles obtained from a previous parallel MPI run. The number of files equals the number of processors. Hence, for the present run the same number of processors must be chosen.

Examples

.. ipython:: python :okwarning:

from rompy_swan.subcomponents.boundary import HOTMULTIPLE
init = HOTMULTIPLE(fname="hotstart.swn", format="free")
print(init.render())
Source code in rompy_swan/subcomponents/boundary.py 
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
class HOTMULTIPLE(BaseSubComponent):
    """Hotstart multiple initial conditions.

    .. code-block:: text

        HOTSTART MULTIPLE fname='fname' FREE|UNFORMATTED

    Initial wave field is read from file; this file was generated in a previous SWAN
    run by means of the HOTFILE command. If the previous run was nonstationary,
    the time found on the file will be assumed to be the initial time of computation. It
    can also be used for stationary computation as first guess. The computational grid
    (both in geographical space and in spectral space) must be identical to the one in
    the run in which the initial wave field was computed

    Input will be read from multiple hotfiles obtained from a previous parallel MPI run.
    The number of files equals the number of processors. Hence, for the present run the
    same number of processors must be chosen.

    Examples
    --------

    .. ipython:: python
        :okwarning:

        from rompy_swan.subcomponents.boundary import HOTMULTIPLE
        init = HOTMULTIPLE(fname="hotstart.swn", format="free")
        print(init.render())

    """

    model_type: Literal["hotmultiple", "HOTMULTIPLE"] = Field(
        default="hotmultiple",
        description="Model type discriminator",
    )
    fname: str = Field(
        description="Name of the file containing the initial wave field",
        max_length=36,
    )
    format: Literal["free", "unformatted"] = Field(
        default="free",
        description=(
            "Format of the file containing the initial wave field. "
            "FREE: free format, UNFORMATTED: binary format"
        ),
    )

    def cmd(self) -> str:
        """Render subcomponent cmd."""
        return f"HOTSTART MULTIPLE fname='{self.fname}' {self.format.upper()}"

Attributes

model_type class-attribute instance-attribute 

model_type: Literal['hotmultiple', 'HOTMULTIPLE'] = Field(default='hotmultiple', description='Model type discriminator')

fname class-attribute instance-attribute 

fname: str = Field(description='Name of the file containing the initial wave field', max_length=36)

format class-attribute instance-attribute 

format: Literal['free', 'unformatted'] = Field(default='free', description='Format of the file containing the initial wave field. FREE: free format, UNFORMATTED: binary format')

Functions

cmd 

cmd() -> str

Render subcomponent cmd.

Source code in rompy_swan/subcomponents/boundary.py 
668
669
670
def cmd(self) -> str:
    """Render subcomponent cmd."""
    return f"HOTSTART MULTIPLE fname='{self.fname}' {self.format.upper()}"