VWAVE

User Subroutine Interface

       subroutine vwave(
C Write  only - 
     1 fWaveSurf, fUnsteadyVel, fFluidAcc, 
     2 fUnsteadyPress, fUnsteadyDPressDZ,
C Read/Write - 
     1 ScaleSteady, ScaleUnsteady,
C Read  only - 
     1 kStep, kInc,
     2 nblock, ndim, nprops, naquaconst, nwindconst, 
     3 nstatevar, nfieldvar, iElemType, iLoadType, sname,
     4 lUpdFluidVar, Coord, Velocity, StateVar, FieldVar, 
     5 DirVec, AquaSteadyConstants, WindConstants,
     6 fSteadyVel, Props, dt, timeTotal, timeStep) 
C
      include 'vaba_param.inc'
C
      parameter ( j_upd_FreeSurf = 0,
     1            j_upd_FluidVarBuoyancy = 1, 
     2            j_upd_FluidVarDrag = 2,
     3            j_upd_FluidVarInertia = 3,
C    The types of distributed loads:
     1            j_lcr_PB  = 51,
     2            j_lcr_DragFDD = 53, j_lcr_DragWDD = 54,
     3            j_lcr_DragFDT = 55, j_lcr_DragFI  = 56,
     4            j_lcr_DragFD1 = 57, j_lcr_DragFD2 = 58,
     5            j_lcr_DragWD1 = 59, j_lcr_DragWD2 = 60,
     6            j_lcr_DragFI1 = 61, j_lcr_DragFI2 = 62,
C    The types of concentrated loads:
     1            j_ccr_TSB = 1002,     j_ccr_DragTFD = 1004,
     2            j_ccr_DragTWD = 1005, j_ccr_DragTSI = 1006 )
C
      dimension Props(nProps), Coord(nblock,ndim),
     1 Velocity(nblock,ndim), StateVar(nblock,nstatevar),
     2 FieldVar(nblock,nfieldvar), DirVec(nblock,ndim),
     3 fWaveSurf(nblock), fFluidAcc(nblock,ndim),
     4 fUnsteadyVel(nblock,ndim), fUnsteadyPress(nblock),
     5 fUnsteadyDPressDZ(nblock), fSteadyVel(nblock,ndim),
     6 AquaSteadyConstants(naquaconst), WindConstants(nwindconst)
C
      character*80 sname
C
C    The following if test and do loop structure illustrates 
C    proper usage of this user subroutine.
C
      if (lUpdFluidVar .eq. j_upd_FreeSurf) then
C     This part is executed at the first call.
C
          do kn = 1,nblock
C            User coding to update fWaveSurf
C            optionally  update StateVar
          end do
C
      else 
C     This part is executed at the second call.
C
         if (lUpdFluidVar .eq. j_upd_FluidVarBuoyancy) then
C        Update variables for buoyancy loads (PB, TSB):
            do kn = 1,nblock
C              user coding to update fUnsteadyPress, fUnsteadyDPressDZ
            end do
C           optionally update multipliers ScaleSteady, ScaleUnsteady 
         else if (lUpdFluidVar .eq. j_upd_FluidVarDrag) then
C        Update variables for drag loads (FDD, FDT, FD1, FD2, TFD):
             do kn = 1, nblock
C              User coding to update fUnsteadyVel 
             end do
C            optionally update multipliers ScaleSteady, ScaleUnsteady 
         else if (lUpdFluidVar .eq. j_upd_FluidVarInertia) then
C        Update variables for inertia loads (FI, FI1, FI2, TSI):
             do kn = 1, nblock
C               User coding to update fFluidAcc
             end do
C            optionally update multipliers ScaleSteady, ScaleUnsteady 
         end if
C
      end if
C
      return
      end

Variables to Be Defined

fWaveSurf(nblock): This array contains the instantaneous fluid free surface elevation at the elemental nodes and is calculated when the flag lUpdFluidVar has the value j_upd_FreeSurf. The incoming array contains the still free-surface elevation value for each node. The nodal values, as seen in the first call, are used to identify the wet portion of an element.
fUnsteadyVel(nblock, ndim): This array contains the unsteady part of the fluid velocity at load integration points and is calculated when the flag lUpdFluidVar has the value j_upd_FluidVarDrag. The incoming array contains zeros.
fFluidAcc(nblock, ndim): This array contains the fluid acceleration at load integration points and is calculated when the flag lUpdFluidVar has the value j_upd_FluidVarInertia. The incoming array contains zeros.
fUnsteadyPress(nblock): This array contains the unsteady part of the fluid pressure at load integration points and is calculated when the flag lUpdFluidVar has the value j_upd_FluidVarBuoyancy. The incoming array contains zeros. The steady part of the pressure is not stored but is calculated by Abaqus/Explicit at each load integration point based on the data provided under the AQUA option and is scaled by the ScaleSteady parameter.
fUnsteadyDPressDZ(nblock): This array contains the unsteady part of the gradient of fluid pressure along elevation at load integration points and is calculated when the flag lUpdFluidVar has the value j_upd_FluidVarBuoyancy. The incoming array contains zeros. Similar to steady pressures, the gradients are not stored but are calculated by Abaqus/Explicit at each load integration point based on the data provided in the fluid variable definition and scaled by the ScaleSteady parameter.

Variables That Can Be Updated

The fluid variables—such as velocity, acceleration, pressure, and pressure gradient along elevation—used in load calculations are split in steady and unsteady parts. The following real variables scale each of those parts:

ScaleSteady: This variable is used by Abaqus/Explicit to scale the steady part of the fluid variables. For drag loads this variable is the amplitude value provided for this purpose on the load data line as explained in Abaqus/Aqua Analysis. For all other loads its incoming value is one. The user can optionally update this variable.
ScaleUnsteady: This variable is used by Abaqus/Explicit to scale the unsteady part of the fluid variables. The user is expected to define unscaled values for unsteady fluid variables. For drag loads this variable is the amplitude value provided for this purpose on the load data line, as explained in Abaqus/Aqua Analysis. For all other loads its incoming value is one. The user can optionally update this variable.

Variables Passed in for Information

kStep: Step number.
kInc: Increment number.
nblock: Number of nodes or load integration points, where the wave effects are to be computed.
ndim: Dimension of the problem (two- or three-dimensional problem).
nprops: The number of properties (real numbers) for the user-defined wave.
naquaconst: The number of fluid property constants in the fluid variable definition.
nwindconst: The number of constants included in the wind velocity profile.
nstatevar: The number of state variables for the user-defined wave, which is specified using the DEPVAR parameter.
nfieldvar: The number of field variables available on the element set on which the load is applied. At the first call the field variables will be available at nodes, and at the second call they will be available at the load integration points.
iElemType: An integer indicating the type of element these points belong to: 1 for line elements, 2 for surface elements, and 3 for solid elements. This integer is used to interpret the value of the direction vector (DirVec) provided at each point.
iLoadType: An integer indicating the type of Abaqus/Aqua load for which the wave kinematics are calculated. The parameters j_lcr_PB to j_ccr_TSI indicate the values by which the load types can be identified.
sname: The name of the element set on which the load is applied.
lUpdFluidVar: This integer flag is used to update different fluid variables. The flag acquires known values as declared in the list of parameters. This flag provides information regarding which variables are to be updated on each call. When the subroutine is called with lUpdFluidVar having a value of j_upd_FreeSurf, only the free surface elevation at each point is updated; otherwise, different sets of fluid variables are updated depending on different values of lUpdFluidVar, as explained in the subroutine structure above.
Coord(nblock,ndim): This array contains the global coordinates of all points in their current configuration at the start of the time increment.
Velocity(nblock,ndim): This array contains the structural velocities of all points at the mid-increment time level of the previous increment.
StateVar(nblock,nstatevar): This array contains the user-defined solution-dependent state variables at all points. The state variables can optionally be updated during the first call, when the flag lUpdFluidVar has a value of j_upd_FreeSurf. At the second call the incoming values are interpolated values at the integration points and are read-only.
FieldVar(nblock,nfieldvar): This array contains the field variables at the load integration points at the start of the time increment.
DirVec(nblock,ndim): This array contains the direction vectors at the load integration points at the start of the time increment. For points lying on line elements, it is the tangent vector in the current configuration. For points lying on surface elements or solid faces, it is the surface-normal vector, pointing outward in the current configuration. The type of elements with which the points are associated can be found using the integer variable iElemType. The magnitude of this vector is the outer diameter for line elements under distributed loads (PB, FDD, WDD, FDT, FI), transitional section area for line elements under transitional distributed loads (FD1, FD2, WD1, WD2, FI1, FI2), and the nodal surface area for points under concentrated loads (TSB, TFD, TWD, TSI) or points lying on surface elements or solid faces.
fSteadyVel(nblock,ndim): The incoming array contains the steady fluid velocity.
AquaSteadyConstants(naquaconst): The user-specified fluid property constants in the fluid variable definition.
WindConstants(nwindconst): The user-specified constants in the wind profile definition. In the absence of a wind profile, all values are zeros.
Props(nprops): This real array contains properties for the user-defined wave, as listed on the data lines.
dt: The time increment.
timeTotal: The total time at the beginning of the increment over all steps.
timeStep: The step time at the beginning of the increment within the step.