text: !STARTOFREGISTRYGENERATEDFILE 'BEMT_Types.f90'
  !
  ! WARNING This file is generated automatically by the FAST registry.
  ! Do not edit.  Your changes to this file will be lost.
  !
  ! FAST Registry (v3.02.00, 23-Jul-2016)
  !*********************************************************************************************************************************
  ! BEMT_Types
  !.................................................................................................................................
  ! This file is part of BEMT.
  !
  ! Copyright (C) 2012-2016 National Renewable Energy Laboratory
  !
  ! Licensed under the Apache License, Version 2.0 (the "License");
  ! you may not use this file except in compliance with the License.
  ! You may obtain a copy of the License at
  !
  !     http://www.apache.org/licenses/LICENSE-2.0
  !
  ! Unless required by applicable law or agreed to in writing, software
  ! distributed under the License is distributed on an "AS IS" BASIS,
  ! WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  ! See the License for the specific language governing permissions and
  ! limitations under the License.
  !
  !
  ! W A R N I N G : This file was automatically generated from the FAST registry.  Changes made to this file may be lost.
  !
  !*********************************************************************************************************************************
  !> This module contains the user-defined types needed in BEMT. It also contains copy, destroy, pack, and
  !! unpack routines associated with each defined data type. This code is automatically generated by the FAST Registry.
  MODULE BEMT_Types
  !---------------------------------------------------------------------------------------------------------------------------------
  USE AirfoilInfo_Types
  USE UnsteadyAero_Types
  USE NWTC_Library
  IMPLICIT NONE
  ! =========  BEMT_InitInputType  =======
    TYPE, PUBLIC :: BEMT_InitInputType
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: chord      !< Chord length at node [m]
      INTEGER(IntKi)  :: numBlades      !< Number of blades [-]
      REAL(ReKi)  :: airDens      !< Air density [kg/m^3]
      REAL(ReKi)  :: kinVisc      !< Kinematic air viscosity [m^2/s]
      INTEGER(IntKi)  :: skewWakeMod      !< Type of skewed-wake correction model [switch] {1=uncoupled, 2=Pitt/Peters, 3=coupled} [-]
      REAL(ReKi)  :: aTol      !< Tolerance for the induction solution [-]
      LOGICAL  :: useTipLoss      !< Use the Prandtl tip-loss model?  [flag] [-]
      LOGICAL  :: useHubLoss      !< Use the Prandtl hub-loss model?  [flag] [-]
      LOGICAL  :: useInduction      !< Include induction in BEMT calculations [flag] { If FALSE then useTanInd will be set to FALSE} [-]
      LOGICAL  :: useTanInd      !< Include tangential induction in BEMT calculations [flag] [-]
      LOGICAL  :: useAIDrag      !< Include the drag term in the axial-induction calculation?  [flag] [-]
      LOGICAL  :: useTIDrag      !< Include the drag term in the tangential-induction calculation?  Ignored if TanInd is False.  [flag] [-]
      INTEGER(IntKi)  :: numBladeNodes      !< Number of blade nodes used in the analysis [-]
      INTEGER(IntKi)  :: numReIterations      !< Number of iterations for finding the Reynolds number [-]
      INTEGER(IntKi)  :: maxIndIterations      !< Maximum number of iterations of induction factor solve [-]
      INTEGER(IntKi) , DIMENSION(:,:), ALLOCATABLE  :: AFindx      !< Index of airfoil data file for blade node location [array of numBladeNodes] [-]
      REAL(ReKi) , DIMENSION(:), ALLOCATABLE  :: zHub      !< Distance to hub for each blade [m]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: zLocal      !< Distance to blade node, measured along the blade [m]
      REAL(ReKi) , DIMENSION(:), ALLOCATABLE  :: zTip      !< Distance to blade tip, measured along the blade [m]
      INTEGER(IntKi)  :: UAMod      !< Model for the dynamic stall equations [1 = Leishman/Beddoes, 2 = Gonzalez, 3 = Minnema] [-]
      LOGICAL  :: UA_Flag      !< logical flag indicating whether to use UnsteadyAero [-]
      LOGICAL  :: Flookup      !< Use table lookup for f' and f''  [-]
      REAL(ReKi)  :: a_s      !< speed of sound [m/s]
    END TYPE BEMT_InitInputType
  ! =======================
  ! =========  BEMT_InitOutputType  =======
    TYPE, PUBLIC :: BEMT_InitOutputType
      TYPE(ProgDesc)  :: Version      !<  [-]
    END TYPE BEMT_InitOutputType
  ! =======================
  ! =========  BEMT_ContinuousStateType  =======
    TYPE, PUBLIC :: BEMT_ContinuousStateType
      REAL(SiKi)  :: DummyContState      !< Remove this variable if you have continuous states [-]
    END TYPE BEMT_ContinuousStateType
  ! =======================
  ! =========  BEMT_DiscreteStateType  =======
    TYPE, PUBLIC :: BEMT_DiscreteStateType
      TYPE(UA_DiscreteStateType)  :: UA      !< states for UnsteadyAero [-]
    END TYPE BEMT_DiscreteStateType
  ! =======================
  ! =========  BEMT_ConstraintStateType  =======
    TYPE, PUBLIC :: BEMT_ConstraintStateType
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: phi      !< angle between the plane of rotation and the direction of the local wind [rad]
    END TYPE BEMT_ConstraintStateType
  ! =======================
  ! =========  BEMT_OtherStateType  =======
    TYPE, PUBLIC :: BEMT_OtherStateType
      TYPE(UA_OtherStateType)  :: UA      !< other states for UnsteadyAero [-]
      LOGICAL , DIMENSION(:,:), ALLOCATABLE  :: UA_Flag      !< logical flag indicating whether to use UnsteadyAero [-]
      LOGICAL , DIMENSION(:,:), ALLOCATABLE  :: ValidPhi      !< set to indicate when there is no valid Phi for this node at this time (temporarially turn off induction when this is false) [-]
      LOGICAL  :: nodesInitialized      !< the node states have been initialized properly [-]
    END TYPE BEMT_OtherStateType
  ! =======================
  ! =========  BEMT_MiscVarType  =======
    TYPE, PUBLIC :: BEMT_MiscVarType
      LOGICAL  :: FirstWarn_M      !< flag so Mach number warning doesn't get repeated forever [-]
      TYPE(UA_MiscVarType)  :: UA      !< misc vars for UnsteadyAero [-]
      TYPE(UA_OutputType)  :: y_UA      !< outputs from UnsteadyAero [-]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: TnInd_op      !< tangential induction at the operating point (for linearization with frozen wake assumption) [-]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: AxInd_op      !< axial induction at the operating point (for linearization) with frozen wake assumption [-]
      LOGICAL  :: UseFrozenWake      !< flag set to determine if frozen values of TnInd_op and AxInd_op should be used for this calculation in the linearization process [-]
    END TYPE BEMT_MiscVarType
  ! =======================
  ! =========  BEMT_ParameterType  =======
    TYPE, PUBLIC :: BEMT_ParameterType
      REAL(DbKi)  :: DT      !< time step [s]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: chord      !< Chord length at node [m]
      INTEGER(IntKi)  :: numBlades      !< Number of blades [-]
      REAL(ReKi)  :: airDens      !< Air density [kg/m^3]
      REAL(ReKi)  :: kinVisc      !< Kinematic air viscosity [m^2/s]
      INTEGER(IntKi)  :: skewWakeMod      !< Type of skewed-wake correction model [switch] {1=uncoupled, 2=Pitt/Peters, 3=coupled} [-]
      REAL(ReKi)  :: aTol      !< Tolerance for the induction solution [-]
      LOGICAL  :: useTipLoss      !< Use the Prandtl tip-loss model?  [flag] [-]
      LOGICAL  :: useHubLoss      !< Use the Prandtl hub-loss model?  [flag] [-]
      LOGICAL  :: useInduction      !< Include induction in BEMT calculations [flag] { If FALSE then useTanInd will be set to FALSE} [-]
      LOGICAL  :: useTanInd      !< Include tangential induction in BEMT calculations [flag] [-]
      LOGICAL  :: useAIDrag      !< Include the drag term in the axial-induction calculation?  [flag] [-]
      LOGICAL  :: useTIDrag      !< Include the drag term in the tangential-induction calculation?  Ignored if TanInd is False.  [flag] [-]
      INTEGER(IntKi)  :: numBladeNodes      !< Number of blade nodes used in the analysis [-]
      INTEGER(IntKi)  :: numReIterations      !< Number of iterations for finding the Reynolds number [-]
      INTEGER(IntKi)  :: maxIndIterations      !< Maximum number of iterations of induction factor solve [-]
      INTEGER(IntKi) , DIMENSION(:,:), ALLOCATABLE  :: AFindx      !< Index of airfoil data file for blade node location [array of numBladeNodes] [-]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: tipLossConst      !< A constant computed during initialization based on B*(zTip-zLocal)/(2*zLocal) [-]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: hubLossConst      !< A constant computed during initialization based on B*(zLocal-zHub)/(2*zHub) [-]
      REAL(ReKi) , DIMENSION(:), ALLOCATABLE  :: zHub      !< Distance to hub for each blade [m]
      TYPE(UA_ParameterType)  :: UA      !< parameters for UnsteadyAero [-]
      LOGICAL  :: UA_Flag      !< logical flag indicating whether to use UnsteadyAero [-]
    END TYPE BEMT_ParameterType
  ! =======================
  ! =========  BEMT_InputType  =======
    TYPE, PUBLIC :: BEMT_InputType
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: theta      !< Twist angle (includes all sources of twist)  [Array of size (NumBlNds,numBlades)] [rad]
      REAL(ReKi)  :: chi0      !< Angle between the vector normal to the rotor plane and the wind vector (e.g., the yaw angle in the case of no tilt) [rad]
      REAL(ReKi) , DIMENSION(:), ALLOCATABLE  :: psi      !< Azimuth angle [rad]
      REAL(ReKi)  :: omega      !< Angular velocity of rotor [rad/s]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: Vx      !< Local axial velocity at node [m/s]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: Vy      !< Local tangential velocity at node [m/s]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: rLocal      !< Radial distance from center-of-rotation to node [m]
    END TYPE BEMT_InputType
  ! =======================
  ! =========  BEMT_OutputType  =======
    TYPE, PUBLIC :: BEMT_OutputType
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: Vrel      !< Total local relative velocity [m/s]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: phi      !< angle between the plane of rotation and the direction of the local wind [rad]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: axInduction      !< axial induction [-]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: tanInduction      !< tangential induction [-]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: Re      !< Reynold's number [-]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: AOA      !< angle of attack [rad]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: Cx      !< normal force coefficient (normal to the plane, not chord) of the jth node in the kth blade [-]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: Cy      !< tangential force coefficient (tangential to the plane, not chord) of the jth node in the kth blade [-]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: Cm      !< pitching moment coefficient of the jth node in the kth blade [-]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: Cl      !< lift coefficient [-]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: Cd      !< drag coefficient [-]
      REAL(ReKi) , DIMENSION(:,:), ALLOCATABLE  :: chi      !< wake skew angle [rad]
    END TYPE BEMT_OutputType
  ! =======================
  CONTAINS
   SUBROUTINE BEMT_CopyInitInput( SrcInitInputData, DstInitInputData, CtrlCode, ErrStat, ErrMsg )
     TYPE(BEMT_InitInputType), INTENT(IN) :: SrcInitInputData
     TYPE(BEMT_InitInputType), INTENT(INOUT) :: DstInitInputData
     INTEGER(IntKi),  INTENT(IN   ) :: CtrlCode
     INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
     CHARACTER(*),    INTENT(  OUT) :: ErrMsg
  ! Local 
     INTEGER(IntKi)                 :: i,j,k
     INTEGER(IntKi)                 :: i1, i1_l, i1_u  !  bounds (upper/lower) for an array dimension 1
     INTEGER(IntKi)                 :: i2, i2_l, i2_u  !  bounds (upper/lower) for an array dimension 2
     INTEGER(IntKi)                 :: ErrStat2
     CHARACTER(ErrMsgLen)           :: ErrMsg2
     CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_CopyInitInput'
  ! 
     ErrStat = ErrID_None
     ErrMsg  = ""
  IF (ALLOCATED(SrcInitInputData%chord)) THEN
    i1_l = LBOUND(SrcInitInputData%chord,1)
    i1_u = UBOUND(SrcInitInputData%chord,1)
    i2_l = LBOUND(SrcInitInputData%chord,2)
    i2_u = UBOUND(SrcInitInputData%chord,2)
    IF (.NOT. ALLOCATED(DstInitInputData%chord)) THEN 
      ALLOCATE(DstInitInputData%chord(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstInitInputData%chord.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstInitInputData%chord = SrcInitInputData%chord
  ENDIF
      DstInitInputData%numBlades = SrcInitInputData%numBlades
      DstInitInputData%airDens = SrcInitInputData%airDens
      DstInitInputData%kinVisc = SrcInitInputData%kinVisc
      DstInitInputData%skewWakeMod = SrcInitInputData%skewWakeMod
      DstInitInputData%aTol = SrcInitInputData%aTol
      DstInitInputData%useTipLoss = SrcInitInputData%useTipLoss
      DstInitInputData%useHubLoss = SrcInitInputData%useHubLoss
      DstInitInputData%useInduction = SrcInitInputData%useInduction
      DstInitInputData%useTanInd = SrcInitInputData%useTanInd
      DstInitInputData%useAIDrag = SrcInitInputData%useAIDrag
      DstInitInputData%useTIDrag = SrcInitInputData%useTIDrag
      DstInitInputData%numBladeNodes = SrcInitInputData%numBladeNodes
      DstInitInputData%numReIterations = SrcInitInputData%numReIterations
      DstInitInputData%maxIndIterations = SrcInitInputData%maxIndIterations
  IF (ALLOCATED(SrcInitInputData%AFindx)) THEN
    i1_l = LBOUND(SrcInitInputData%AFindx,1)
    i1_u = UBOUND(SrcInitInputData%AFindx,1)
    i2_l = LBOUND(SrcInitInputData%AFindx,2)
    i2_u = UBOUND(SrcInitInputData%AFindx,2)
    IF (.NOT. ALLOCATED(DstInitInputData%AFindx)) THEN 
      ALLOCATE(DstInitInputData%AFindx(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstInitInputData%AFindx.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstInitInputData%AFindx = SrcInitInputData%AFindx
  ENDIF
  IF (ALLOCATED(SrcInitInputData%zHub)) THEN
    i1_l = LBOUND(SrcInitInputData%zHub,1)
    i1_u = UBOUND(SrcInitInputData%zHub,1)
    IF (.NOT. ALLOCATED(DstInitInputData%zHub)) THEN 
      ALLOCATE(DstInitInputData%zHub(i1_l:i1_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstInitInputData%zHub.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstInitInputData%zHub = SrcInitInputData%zHub
  ENDIF
  IF (ALLOCATED(SrcInitInputData%zLocal)) THEN
    i1_l = LBOUND(SrcInitInputData%zLocal,1)
    i1_u = UBOUND(SrcInitInputData%zLocal,1)
    i2_l = LBOUND(SrcInitInputData%zLocal,2)
    i2_u = UBOUND(SrcInitInputData%zLocal,2)
    IF (.NOT. ALLOCATED(DstInitInputData%zLocal)) THEN 
      ALLOCATE(DstInitInputData%zLocal(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstInitInputData%zLocal.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstInitInputData%zLocal = SrcInitInputData%zLocal
  ENDIF
  IF (ALLOCATED(SrcInitInputData%zTip)) THEN
    i1_l = LBOUND(SrcInitInputData%zTip,1)
    i1_u = UBOUND(SrcInitInputData%zTip,1)
    IF (.NOT. ALLOCATED(DstInitInputData%zTip)) THEN 
      ALLOCATE(DstInitInputData%zTip(i1_l:i1_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstInitInputData%zTip.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstInitInputData%zTip = SrcInitInputData%zTip
  ENDIF
      DstInitInputData%UAMod = SrcInitInputData%UAMod
      DstInitInputData%UA_Flag = SrcInitInputData%UA_Flag
      DstInitInputData%Flookup = SrcInitInputData%Flookup
      DstInitInputData%a_s = SrcInitInputData%a_s
   END SUBROUTINE BEMT_CopyInitInput
  
   SUBROUTINE BEMT_DestroyInitInput( InitInputData, ErrStat, ErrMsg )
    TYPE(BEMT_InitInputType), INTENT(INOUT) :: InitInputData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
    CHARACTER(*),    PARAMETER :: RoutineName = 'BEMT_DestroyInitInput'
    INTEGER(IntKi)                 :: i, i1, i2, i3, i4, i5 
  ! 
    ErrStat = ErrID_None
    ErrMsg  = ""
  IF (ALLOCATED(InitInputData%chord)) THEN
    DEALLOCATE(InitInputData%chord)
  ENDIF
  IF (ALLOCATED(InitInputData%AFindx)) THEN
    DEALLOCATE(InitInputData%AFindx)
  ENDIF
  IF (ALLOCATED(InitInputData%zHub)) THEN
    DEALLOCATE(InitInputData%zHub)
  ENDIF
  IF (ALLOCATED(InitInputData%zLocal)) THEN
    DEALLOCATE(InitInputData%zLocal)
  ENDIF
  IF (ALLOCATED(InitInputData%zTip)) THEN
    DEALLOCATE(InitInputData%zTip)
  ENDIF
   END SUBROUTINE BEMT_DestroyInitInput
  
   SUBROUTINE BEMT_PackInitInput( ReKiBuf, DbKiBuf, IntKiBuf, Indata, ErrStat, ErrMsg, SizeOnly )
    REAL(ReKi),       ALLOCATABLE, INTENT(  OUT) :: ReKiBuf(:)
    REAL(DbKi),       ALLOCATABLE, INTENT(  OUT) :: DbKiBuf(:)
    INTEGER(IntKi),   ALLOCATABLE, INTENT(  OUT) :: IntKiBuf(:)
    TYPE(BEMT_InitInputType),  INTENT(IN) :: InData
    INTEGER(IntKi),   INTENT(  OUT) :: ErrStat
    CHARACTER(*),     INTENT(  OUT) :: ErrMsg
    LOGICAL,OPTIONAL, INTENT(IN   ) :: SizeOnly
      ! Local variables
    INTEGER(IntKi)                 :: Re_BufSz
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_BufSz
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_BufSz
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i,i1,i2,i3,i4,i5
    LOGICAL                        :: OnlySize ! if present and true, do not pack, just allocate buffers
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_PackInitInput'
   ! buffers to store subtypes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
  
    OnlySize = .FALSE.
    IF ( PRESENT(SizeOnly) ) THEN
      OnlySize = SizeOnly
    ENDIF
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_BufSz  = 0
    Db_BufSz  = 0
    Int_BufSz  = 0
    Int_BufSz   = Int_BufSz   + 1     ! chord allocated yes/no
    IF ( ALLOCATED(InData%chord) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! chord upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%chord)  ! chord
    END IF
        Int_BufSz  = Int_BufSz  + 1  ! numBlades
        Re_BufSz   = Re_BufSz   + 1  ! airDens
        Re_BufSz   = Re_BufSz   + 1  ! kinVisc
        Int_BufSz  = Int_BufSz  + 1  ! skewWakeMod
        Re_BufSz   = Re_BufSz   + 1  ! aTol
        Int_BufSz  = Int_BufSz  + 1  ! useTipLoss
        Int_BufSz  = Int_BufSz  + 1  ! useHubLoss
        Int_BufSz  = Int_BufSz  + 1  ! useInduction
        Int_BufSz  = Int_BufSz  + 1  ! useTanInd
        Int_BufSz  = Int_BufSz  + 1  ! useAIDrag
        Int_BufSz  = Int_BufSz  + 1  ! useTIDrag
        Int_BufSz  = Int_BufSz  + 1  ! numBladeNodes
        Int_BufSz  = Int_BufSz  + 1  ! numReIterations
        Int_BufSz  = Int_BufSz  + 1  ! maxIndIterations
    Int_BufSz   = Int_BufSz   + 1     ! AFindx allocated yes/no
    IF ( ALLOCATED(InData%AFindx) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! AFindx upper/lower bounds for each dimension
        Int_BufSz  = Int_BufSz  + SIZE(InData%AFindx)  ! AFindx
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! zHub allocated yes/no
    IF ( ALLOCATED(InData%zHub) ) THEN
      Int_BufSz   = Int_BufSz   + 2*1  ! zHub upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%zHub)  ! zHub
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! zLocal allocated yes/no
    IF ( ALLOCATED(InData%zLocal) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! zLocal upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%zLocal)  ! zLocal
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! zTip allocated yes/no
    IF ( ALLOCATED(InData%zTip) ) THEN
      Int_BufSz   = Int_BufSz   + 2*1  ! zTip upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%zTip)  ! zTip
    END IF
        Int_BufSz  = Int_BufSz  + 1  ! UAMod
        Int_BufSz  = Int_BufSz  + 1  ! UA_Flag
        Int_BufSz  = Int_BufSz  + 1  ! Flookup
        Re_BufSz   = Re_BufSz   + 1  ! a_s
    IF ( Re_BufSz  .GT. 0 ) THEN 
       ALLOCATE( ReKiBuf(  Re_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating ReKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Db_BufSz  .GT. 0 ) THEN 
       ALLOCATE( DbKiBuf(  Db_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating DbKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Int_BufSz  .GT. 0 ) THEN 
       ALLOCATE( IntKiBuf(  Int_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating IntKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF(OnlySize) RETURN ! return early if only trying to allocate buffers (not pack them)
  
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred = 1
  
    IF ( .NOT. ALLOCATED(InData%chord) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%chord,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%chord,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%chord,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%chord,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%chord)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%chord))-1 ) = PACK(InData%chord,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%chord)
    END IF
        IntKiBuf ( Int_Xferred:Int_Xferred+(1)-1 ) = InData%numBlades
        Int_Xferred   = Int_Xferred   + 1
        ReKiBuf ( Re_Xferred:Re_Xferred+(1)-1 ) = InData%airDens
        Re_Xferred   = Re_Xferred   + 1
        ReKiBuf ( Re_Xferred:Re_Xferred+(1)-1 ) = InData%kinVisc
        Re_Xferred   = Re_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+(1)-1 ) = InData%skewWakeMod
        Int_Xferred   = Int_Xferred   + 1
        ReKiBuf ( Re_Xferred:Re_Xferred+(1)-1 ) = InData%aTol
        Re_Xferred   = Re_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%useTipLoss , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%useHubLoss , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%useInduction , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%useTanInd , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%useAIDrag , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%useTIDrag , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+(1)-1 ) = InData%numBladeNodes
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+(1)-1 ) = InData%numReIterations
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+(1)-1 ) = InData%maxIndIterations
        Int_Xferred   = Int_Xferred   + 1
    IF ( .NOT. ALLOCATED(InData%AFindx) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%AFindx,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%AFindx,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%AFindx,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%AFindx,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%AFindx)>0) IntKiBuf ( Int_Xferred:Int_Xferred+(SIZE(InData%AFindx))-1 ) = PACK(InData%AFindx,.TRUE.)
        Int_Xferred   = Int_Xferred   + SIZE(InData%AFindx)
    END IF
    IF ( .NOT. ALLOCATED(InData%zHub) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%zHub,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%zHub,1)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%zHub)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%zHub))-1 ) = PACK(InData%zHub,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%zHub)
    END IF
    IF ( .NOT. ALLOCATED(InData%zLocal) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%zLocal,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%zLocal,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%zLocal,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%zLocal,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%zLocal)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%zLocal))-1 ) = PACK(InData%zLocal,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%zLocal)
    END IF
    IF ( .NOT. ALLOCATED(InData%zTip) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%zTip,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%zTip,1)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%zTip)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%zTip))-1 ) = PACK(InData%zTip,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%zTip)
    END IF
        IntKiBuf ( Int_Xferred:Int_Xferred+(1)-1 ) = InData%UAMod
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%UA_Flag , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%Flookup , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
        ReKiBuf ( Re_Xferred:Re_Xferred+(1)-1 ) = InData%a_s
        Re_Xferred   = Re_Xferred   + 1
   END SUBROUTINE BEMT_PackInitInput
  
   SUBROUTINE BEMT_UnPackInitInput( ReKiBuf, DbKiBuf, IntKiBuf, Outdata, ErrStat, ErrMsg )
    REAL(ReKi),      ALLOCATABLE, INTENT(IN   ) :: ReKiBuf(:)
    REAL(DbKi),      ALLOCATABLE, INTENT(IN   ) :: DbKiBuf(:)
    INTEGER(IntKi),  ALLOCATABLE, INTENT(IN   ) :: IntKiBuf(:)
    TYPE(BEMT_InitInputType), INTENT(INOUT) :: OutData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
      ! Local variables
    INTEGER(IntKi)                 :: Buf_size
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i
    LOGICAL                        :: mask0
    LOGICAL, ALLOCATABLE           :: mask1(:)
    LOGICAL, ALLOCATABLE           :: mask2(:,:)
    LOGICAL, ALLOCATABLE           :: mask3(:,:,:)
    LOGICAL, ALLOCATABLE           :: mask4(:,:,:,:)
    LOGICAL, ALLOCATABLE           :: mask5(:,:,:,:,:)
    INTEGER(IntKi)                 :: i1, i1_l, i1_u  !  bounds (upper/lower) for an array dimension 1
    INTEGER(IntKi)                 :: i2, i2_l, i2_u  !  bounds (upper/lower) for an array dimension 2
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_UnPackInitInput'
   ! buffers to store meshes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred  = 1
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! chord not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%chord)) DEALLOCATE(OutData%chord)
      ALLOCATE(OutData%chord(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%chord.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%chord)>0) OutData%chord = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%chord))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%chord)
      DEALLOCATE(mask2)
    END IF
        OutData%numBlades = IntKiBuf( Int_Xferred ) 
        Int_Xferred   = Int_Xferred + 1
        OutData%airDens = ReKiBuf( Re_Xferred )
        Re_Xferred   = Re_Xferred + 1
        OutData%kinVisc = ReKiBuf( Re_Xferred )
        Re_Xferred   = Re_Xferred + 1
        OutData%skewWakeMod = IntKiBuf( Int_Xferred ) 
        Int_Xferred   = Int_Xferred + 1
        OutData%aTol = ReKiBuf( Re_Xferred )
        Re_Xferred   = Re_Xferred + 1
        OutData%useTipLoss = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
        OutData%useHubLoss = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
        OutData%useInduction = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
        OutData%useTanInd = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
        OutData%useAIDrag = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
        OutData%useTIDrag = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
        OutData%numBladeNodes = IntKiBuf( Int_Xferred ) 
        Int_Xferred   = Int_Xferred + 1
        OutData%numReIterations = IntKiBuf( Int_Xferred ) 
        Int_Xferred   = Int_Xferred + 1
        OutData%maxIndIterations = IntKiBuf( Int_Xferred ) 
        Int_Xferred   = Int_Xferred + 1
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! AFindx not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%AFindx)) DEALLOCATE(OutData%AFindx)
      ALLOCATE(OutData%AFindx(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%AFindx.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%AFindx)>0) OutData%AFindx = UNPACK( IntKiBuf ( Int_Xferred:Int_Xferred+(SIZE(OutData%AFindx))-1 ), mask2, 0_IntKi )
        Int_Xferred   = Int_Xferred   + SIZE(OutData%AFindx)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! zHub not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%zHub)) DEALLOCATE(OutData%zHub)
      ALLOCATE(OutData%zHub(i1_l:i1_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%zHub.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask1(i1_l:i1_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask1.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask1 = .TRUE. 
        IF (SIZE(OutData%zHub)>0) OutData%zHub = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%zHub))-1 ), mask1, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%zHub)
      DEALLOCATE(mask1)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! zLocal not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%zLocal)) DEALLOCATE(OutData%zLocal)
      ALLOCATE(OutData%zLocal(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%zLocal.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%zLocal)>0) OutData%zLocal = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%zLocal))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%zLocal)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! zTip not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%zTip)) DEALLOCATE(OutData%zTip)
      ALLOCATE(OutData%zTip(i1_l:i1_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%zTip.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask1(i1_l:i1_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask1.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask1 = .TRUE. 
        IF (SIZE(OutData%zTip)>0) OutData%zTip = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%zTip))-1 ), mask1, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%zTip)
      DEALLOCATE(mask1)
    END IF
        OutData%UAMod = IntKiBuf( Int_Xferred ) 
        Int_Xferred   = Int_Xferred + 1
        OutData%UA_Flag = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
        OutData%Flookup = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
        OutData%a_s = ReKiBuf( Re_Xferred )
        Re_Xferred   = Re_Xferred + 1
   END SUBROUTINE BEMT_UnPackInitInput
  
   SUBROUTINE BEMT_CopyInitOutput( SrcInitOutputData, DstInitOutputData, CtrlCode, ErrStat, ErrMsg )
     TYPE(BEMT_InitOutputType), INTENT(IN) :: SrcInitOutputData
     TYPE(BEMT_InitOutputType), INTENT(INOUT) :: DstInitOutputData
     INTEGER(IntKi),  INTENT(IN   ) :: CtrlCode
     INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
     CHARACTER(*),    INTENT(  OUT) :: ErrMsg
  ! Local 
     INTEGER(IntKi)                 :: i,j,k
     INTEGER(IntKi)                 :: ErrStat2
     CHARACTER(ErrMsgLen)           :: ErrMsg2
     CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_CopyInitOutput'
  ! 
     ErrStat = ErrID_None
     ErrMsg  = ""
        CALL NWTC_Library_Copyprogdesc( SrcInitOutputData%Version, DstInitOutputData%Version, CtrlCode, ErrStat2, ErrMsg2 )
           CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg,RoutineName)
           IF (ErrStat>=AbortErrLev) RETURN
   END SUBROUTINE BEMT_CopyInitOutput
  
   SUBROUTINE BEMT_DestroyInitOutput( InitOutputData, ErrStat, ErrMsg )
    TYPE(BEMT_InitOutputType), INTENT(INOUT) :: InitOutputData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
    CHARACTER(*),    PARAMETER :: RoutineName = 'BEMT_DestroyInitOutput'
    INTEGER(IntKi)                 :: i, i1, i2, i3, i4, i5 
  ! 
    ErrStat = ErrID_None
    ErrMsg  = ""
    CALL NWTC_Library_Destroyprogdesc( InitOutputData%Version, ErrStat, ErrMsg )
   END SUBROUTINE BEMT_DestroyInitOutput
  
   SUBROUTINE BEMT_PackInitOutput( ReKiBuf, DbKiBuf, IntKiBuf, Indata, ErrStat, ErrMsg, SizeOnly )
    REAL(ReKi),       ALLOCATABLE, INTENT(  OUT) :: ReKiBuf(:)
    REAL(DbKi),       ALLOCATABLE, INTENT(  OUT) :: DbKiBuf(:)
    INTEGER(IntKi),   ALLOCATABLE, INTENT(  OUT) :: IntKiBuf(:)
    TYPE(BEMT_InitOutputType),  INTENT(IN) :: InData
    INTEGER(IntKi),   INTENT(  OUT) :: ErrStat
    CHARACTER(*),     INTENT(  OUT) :: ErrMsg
    LOGICAL,OPTIONAL, INTENT(IN   ) :: SizeOnly
      ! Local variables
    INTEGER(IntKi)                 :: Re_BufSz
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_BufSz
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_BufSz
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i,i1,i2,i3,i4,i5
    LOGICAL                        :: OnlySize ! if present and true, do not pack, just allocate buffers
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_PackInitOutput'
   ! buffers to store subtypes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
  
    OnlySize = .FALSE.
    IF ( PRESENT(SizeOnly) ) THEN
      OnlySize = SizeOnly
    ENDIF
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_BufSz  = 0
    Db_BufSz  = 0
    Int_BufSz  = 0
     ! Allocate buffers for subtypes, if any (we'll get sizes from these) 
        Int_BufSz   = Int_BufSz + 3  ! Version: size of buffers for each call to pack subtype
        CALL NWTC_Library_Packprogdesc( Re_Buf, Db_Buf, Int_Buf, InData%Version, ErrStat2, ErrMsg2, .TRUE. ) ! Version 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf)) THEN ! Version
           Re_BufSz  = Re_BufSz  + SIZE( Re_Buf  )
           DEALLOCATE(Re_Buf)
        END IF
        IF(ALLOCATED(Db_Buf)) THEN ! Version
           Db_BufSz  = Db_BufSz  + SIZE( Db_Buf  )
           DEALLOCATE(Db_Buf)
        END IF
        IF(ALLOCATED(Int_Buf)) THEN ! Version
           Int_BufSz = Int_BufSz + SIZE( Int_Buf )
           DEALLOCATE(Int_Buf)
        END IF
    IF ( Re_BufSz  .GT. 0 ) THEN 
       ALLOCATE( ReKiBuf(  Re_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating ReKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Db_BufSz  .GT. 0 ) THEN 
       ALLOCATE( DbKiBuf(  Db_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating DbKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Int_BufSz  .GT. 0 ) THEN 
       ALLOCATE( IntKiBuf(  Int_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating IntKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF(OnlySize) RETURN ! return early if only trying to allocate buffers (not pack them)
  
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred = 1
  
        CALL NWTC_Library_Packprogdesc( Re_Buf, Db_Buf, Int_Buf, InData%Version, ErrStat2, ErrMsg2, OnlySize ) ! Version 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Re_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Re_Buf) > 0) ReKiBuf( Re_Xferred:Re_Xferred+SIZE(Re_Buf)-1 ) = Re_Buf
          Re_Xferred = Re_Xferred + SIZE(Re_Buf)
          DEALLOCATE(Re_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
        IF(ALLOCATED(Db_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Db_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Db_Buf) > 0) DbKiBuf( Db_Xferred:Db_Xferred+SIZE(Db_Buf)-1 ) = Db_Buf
          Db_Xferred = Db_Xferred + SIZE(Db_Buf)
          DEALLOCATE(Db_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
        IF(ALLOCATED(Int_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Int_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Int_Buf) > 0) IntKiBuf( Int_Xferred:Int_Xferred+SIZE(Int_Buf)-1 ) = Int_Buf
          Int_Xferred = Int_Xferred + SIZE(Int_Buf)
          DEALLOCATE(Int_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
   END SUBROUTINE BEMT_PackInitOutput
  
   SUBROUTINE BEMT_UnPackInitOutput( ReKiBuf, DbKiBuf, IntKiBuf, Outdata, ErrStat, ErrMsg )
    REAL(ReKi),      ALLOCATABLE, INTENT(IN   ) :: ReKiBuf(:)
    REAL(DbKi),      ALLOCATABLE, INTENT(IN   ) :: DbKiBuf(:)
    INTEGER(IntKi),  ALLOCATABLE, INTENT(IN   ) :: IntKiBuf(:)
    TYPE(BEMT_InitOutputType), INTENT(INOUT) :: OutData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
      ! Local variables
    INTEGER(IntKi)                 :: Buf_size
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i
    LOGICAL                        :: mask0
    LOGICAL, ALLOCATABLE           :: mask1(:)
    LOGICAL, ALLOCATABLE           :: mask2(:,:)
    LOGICAL, ALLOCATABLE           :: mask3(:,:,:)
    LOGICAL, ALLOCATABLE           :: mask4(:,:,:,:)
    LOGICAL, ALLOCATABLE           :: mask5(:,:,:,:,:)
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_UnPackInitOutput'
   ! buffers to store meshes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred  = 1
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Re_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Re_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Re_Buf = ReKiBuf( Re_Xferred:Re_Xferred+Buf_size-1 )
          Re_Xferred = Re_Xferred + Buf_size
        END IF
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Db_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Db_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Db_Buf = DbKiBuf( Db_Xferred:Db_Xferred+Buf_size-1 )
          Db_Xferred = Db_Xferred + Buf_size
        END IF
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Int_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Int_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Int_Buf = IntKiBuf( Int_Xferred:Int_Xferred+Buf_size-1 )
          Int_Xferred = Int_Xferred + Buf_size
        END IF
        CALL NWTC_Library_Unpackprogdesc( Re_Buf, Db_Buf, Int_Buf, OutData%Version, ErrStat2, ErrMsg2 ) ! Version 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf )) DEALLOCATE(Re_Buf )
        IF(ALLOCATED(Db_Buf )) DEALLOCATE(Db_Buf )
        IF(ALLOCATED(Int_Buf)) DEALLOCATE(Int_Buf)
   END SUBROUTINE BEMT_UnPackInitOutput
  
   SUBROUTINE BEMT_CopyContState( SrcContStateData, DstContStateData, CtrlCode, ErrStat, ErrMsg )
     TYPE(BEMT_ContinuousStateType), INTENT(IN) :: SrcContStateData
     TYPE(BEMT_ContinuousStateType), INTENT(INOUT) :: DstContStateData
     INTEGER(IntKi),  INTENT(IN   ) :: CtrlCode
     INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
     CHARACTER(*),    INTENT(  OUT) :: ErrMsg
  ! Local 
     INTEGER(IntKi)                 :: i,j,k
     INTEGER(IntKi)                 :: ErrStat2
     CHARACTER(ErrMsgLen)           :: ErrMsg2
     CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_CopyContState'
  ! 
     ErrStat = ErrID_None
     ErrMsg  = ""
      DstContStateData%DummyContState = SrcContStateData%DummyContState
   END SUBROUTINE BEMT_CopyContState
  
   SUBROUTINE BEMT_DestroyContState( ContStateData, ErrStat, ErrMsg )
    TYPE(BEMT_ContinuousStateType), INTENT(INOUT) :: ContStateData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
    CHARACTER(*),    PARAMETER :: RoutineName = 'BEMT_DestroyContState'
    INTEGER(IntKi)                 :: i, i1, i2, i3, i4, i5 
  ! 
    ErrStat = ErrID_None
    ErrMsg  = ""
   END SUBROUTINE BEMT_DestroyContState
  
   SUBROUTINE BEMT_PackContState( ReKiBuf, DbKiBuf, IntKiBuf, Indata, ErrStat, ErrMsg, SizeOnly )
    REAL(ReKi),       ALLOCATABLE, INTENT(  OUT) :: ReKiBuf(:)
    REAL(DbKi),       ALLOCATABLE, INTENT(  OUT) :: DbKiBuf(:)
    INTEGER(IntKi),   ALLOCATABLE, INTENT(  OUT) :: IntKiBuf(:)
    TYPE(BEMT_ContinuousStateType),  INTENT(IN) :: InData
    INTEGER(IntKi),   INTENT(  OUT) :: ErrStat
    CHARACTER(*),     INTENT(  OUT) :: ErrMsg
    LOGICAL,OPTIONAL, INTENT(IN   ) :: SizeOnly
      ! Local variables
    INTEGER(IntKi)                 :: Re_BufSz
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_BufSz
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_BufSz
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i,i1,i2,i3,i4,i5
    LOGICAL                        :: OnlySize ! if present and true, do not pack, just allocate buffers
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_PackContState'
   ! buffers to store subtypes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
  
    OnlySize = .FALSE.
    IF ( PRESENT(SizeOnly) ) THEN
      OnlySize = SizeOnly
    ENDIF
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_BufSz  = 0
    Db_BufSz  = 0
    Int_BufSz  = 0
        Re_BufSz   = Re_BufSz   + 1  ! DummyContState
    IF ( Re_BufSz  .GT. 0 ) THEN 
       ALLOCATE( ReKiBuf(  Re_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating ReKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Db_BufSz  .GT. 0 ) THEN 
       ALLOCATE( DbKiBuf(  Db_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating DbKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Int_BufSz  .GT. 0 ) THEN 
       ALLOCATE( IntKiBuf(  Int_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating IntKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF(OnlySize) RETURN ! return early if only trying to allocate buffers (not pack them)
  
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred = 1
  
        ReKiBuf ( Re_Xferred:Re_Xferred+(1)-1 ) = InData%DummyContState
        Re_Xferred   = Re_Xferred   + 1
   END SUBROUTINE BEMT_PackContState
  
   SUBROUTINE BEMT_UnPackContState( ReKiBuf, DbKiBuf, IntKiBuf, Outdata, ErrStat, ErrMsg )
    REAL(ReKi),      ALLOCATABLE, INTENT(IN   ) :: ReKiBuf(:)
    REAL(DbKi),      ALLOCATABLE, INTENT(IN   ) :: DbKiBuf(:)
    INTEGER(IntKi),  ALLOCATABLE, INTENT(IN   ) :: IntKiBuf(:)
    TYPE(BEMT_ContinuousStateType), INTENT(INOUT) :: OutData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
      ! Local variables
    INTEGER(IntKi)                 :: Buf_size
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i
    LOGICAL                        :: mask0
    LOGICAL, ALLOCATABLE           :: mask1(:)
    LOGICAL, ALLOCATABLE           :: mask2(:,:)
    LOGICAL, ALLOCATABLE           :: mask3(:,:,:)
    LOGICAL, ALLOCATABLE           :: mask4(:,:,:,:)
    LOGICAL, ALLOCATABLE           :: mask5(:,:,:,:,:)
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_UnPackContState'
   ! buffers to store meshes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred  = 1
        OutData%DummyContState = REAL( ReKiBuf( Re_Xferred ), SiKi) 
        Re_Xferred   = Re_Xferred + 1
   END SUBROUTINE BEMT_UnPackContState
  
   SUBROUTINE BEMT_CopyDiscState( SrcDiscStateData, DstDiscStateData, CtrlCode, ErrStat, ErrMsg )
     TYPE(BEMT_DiscreteStateType), INTENT(IN) :: SrcDiscStateData
     TYPE(BEMT_DiscreteStateType), INTENT(INOUT) :: DstDiscStateData
     INTEGER(IntKi),  INTENT(IN   ) :: CtrlCode
     INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
     CHARACTER(*),    INTENT(  OUT) :: ErrMsg
  ! Local 
     INTEGER(IntKi)                 :: i,j,k
     INTEGER(IntKi)                 :: ErrStat2
     CHARACTER(ErrMsgLen)           :: ErrMsg2
     CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_CopyDiscState'
  ! 
     ErrStat = ErrID_None
     ErrMsg  = ""
        CALL UA_CopyDiscState( SrcDiscStateData%UA, DstDiscStateData%UA, CtrlCode, ErrStat2, ErrMsg2 )
           CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg,RoutineName)
           IF (ErrStat>=AbortErrLev) RETURN
   END SUBROUTINE BEMT_CopyDiscState
  
   SUBROUTINE BEMT_DestroyDiscState( DiscStateData, ErrStat, ErrMsg )
    TYPE(BEMT_DiscreteStateType), INTENT(INOUT) :: DiscStateData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
    CHARACTER(*),    PARAMETER :: RoutineName = 'BEMT_DestroyDiscState'
    INTEGER(IntKi)                 :: i, i1, i2, i3, i4, i5 
  ! 
    ErrStat = ErrID_None
    ErrMsg  = ""
    CALL UA_DestroyDiscState( DiscStateData%UA, ErrStat, ErrMsg )
   END SUBROUTINE BEMT_DestroyDiscState
  
   SUBROUTINE BEMT_PackDiscState( ReKiBuf, DbKiBuf, IntKiBuf, Indata, ErrStat, ErrMsg, SizeOnly )
    REAL(ReKi),       ALLOCATABLE, INTENT(  OUT) :: ReKiBuf(:)
    REAL(DbKi),       ALLOCATABLE, INTENT(  OUT) :: DbKiBuf(:)
    INTEGER(IntKi),   ALLOCATABLE, INTENT(  OUT) :: IntKiBuf(:)
    TYPE(BEMT_DiscreteStateType),  INTENT(IN) :: InData
    INTEGER(IntKi),   INTENT(  OUT) :: ErrStat
    CHARACTER(*),     INTENT(  OUT) :: ErrMsg
    LOGICAL,OPTIONAL, INTENT(IN   ) :: SizeOnly
      ! Local variables
    INTEGER(IntKi)                 :: Re_BufSz
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_BufSz
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_BufSz
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i,i1,i2,i3,i4,i5
    LOGICAL                        :: OnlySize ! if present and true, do not pack, just allocate buffers
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_PackDiscState'
   ! buffers to store subtypes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
  
    OnlySize = .FALSE.
    IF ( PRESENT(SizeOnly) ) THEN
      OnlySize = SizeOnly
    ENDIF
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_BufSz  = 0
    Db_BufSz  = 0
    Int_BufSz  = 0
     ! Allocate buffers for subtypes, if any (we'll get sizes from these) 
        Int_BufSz   = Int_BufSz + 3  ! UA: size of buffers for each call to pack subtype
        CALL UA_PackDiscState( Re_Buf, Db_Buf, Int_Buf, InData%UA, ErrStat2, ErrMsg2, .TRUE. ) ! UA 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf)) THEN ! UA
           Re_BufSz  = Re_BufSz  + SIZE( Re_Buf  )
           DEALLOCATE(Re_Buf)
        END IF
        IF(ALLOCATED(Db_Buf)) THEN ! UA
           Db_BufSz  = Db_BufSz  + SIZE( Db_Buf  )
           DEALLOCATE(Db_Buf)
        END IF
        IF(ALLOCATED(Int_Buf)) THEN ! UA
           Int_BufSz = Int_BufSz + SIZE( Int_Buf )
           DEALLOCATE(Int_Buf)
        END IF
    IF ( Re_BufSz  .GT. 0 ) THEN 
       ALLOCATE( ReKiBuf(  Re_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating ReKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Db_BufSz  .GT. 0 ) THEN 
       ALLOCATE( DbKiBuf(  Db_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating DbKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Int_BufSz  .GT. 0 ) THEN 
       ALLOCATE( IntKiBuf(  Int_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating IntKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF(OnlySize) RETURN ! return early if only trying to allocate buffers (not pack them)
  
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred = 1
  
        CALL UA_PackDiscState( Re_Buf, Db_Buf, Int_Buf, InData%UA, ErrStat2, ErrMsg2, OnlySize ) ! UA 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Re_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Re_Buf) > 0) ReKiBuf( Re_Xferred:Re_Xferred+SIZE(Re_Buf)-1 ) = Re_Buf
          Re_Xferred = Re_Xferred + SIZE(Re_Buf)
          DEALLOCATE(Re_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
        IF(ALLOCATED(Db_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Db_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Db_Buf) > 0) DbKiBuf( Db_Xferred:Db_Xferred+SIZE(Db_Buf)-1 ) = Db_Buf
          Db_Xferred = Db_Xferred + SIZE(Db_Buf)
          DEALLOCATE(Db_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
        IF(ALLOCATED(Int_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Int_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Int_Buf) > 0) IntKiBuf( Int_Xferred:Int_Xferred+SIZE(Int_Buf)-1 ) = Int_Buf
          Int_Xferred = Int_Xferred + SIZE(Int_Buf)
          DEALLOCATE(Int_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
   END SUBROUTINE BEMT_PackDiscState
  
   SUBROUTINE BEMT_UnPackDiscState( ReKiBuf, DbKiBuf, IntKiBuf, Outdata, ErrStat, ErrMsg )
    REAL(ReKi),      ALLOCATABLE, INTENT(IN   ) :: ReKiBuf(:)
    REAL(DbKi),      ALLOCATABLE, INTENT(IN   ) :: DbKiBuf(:)
    INTEGER(IntKi),  ALLOCATABLE, INTENT(IN   ) :: IntKiBuf(:)
    TYPE(BEMT_DiscreteStateType), INTENT(INOUT) :: OutData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
      ! Local variables
    INTEGER(IntKi)                 :: Buf_size
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i
    LOGICAL                        :: mask0
    LOGICAL, ALLOCATABLE           :: mask1(:)
    LOGICAL, ALLOCATABLE           :: mask2(:,:)
    LOGICAL, ALLOCATABLE           :: mask3(:,:,:)
    LOGICAL, ALLOCATABLE           :: mask4(:,:,:,:)
    LOGICAL, ALLOCATABLE           :: mask5(:,:,:,:,:)
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_UnPackDiscState'
   ! buffers to store meshes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred  = 1
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Re_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Re_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Re_Buf = ReKiBuf( Re_Xferred:Re_Xferred+Buf_size-1 )
          Re_Xferred = Re_Xferred + Buf_size
        END IF
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Db_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Db_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Db_Buf = DbKiBuf( Db_Xferred:Db_Xferred+Buf_size-1 )
          Db_Xferred = Db_Xferred + Buf_size
        END IF
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Int_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Int_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Int_Buf = IntKiBuf( Int_Xferred:Int_Xferred+Buf_size-1 )
          Int_Xferred = Int_Xferred + Buf_size
        END IF
        CALL UA_UnpackDiscState( Re_Buf, Db_Buf, Int_Buf, OutData%UA, ErrStat2, ErrMsg2 ) ! UA 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf )) DEALLOCATE(Re_Buf )
        IF(ALLOCATED(Db_Buf )) DEALLOCATE(Db_Buf )
        IF(ALLOCATED(Int_Buf)) DEALLOCATE(Int_Buf)
   END SUBROUTINE BEMT_UnPackDiscState
  
   SUBROUTINE BEMT_CopyConstrState( SrcConstrStateData, DstConstrStateData, CtrlCode, ErrStat, ErrMsg )
     TYPE(BEMT_ConstraintStateType), INTENT(IN) :: SrcConstrStateData
     TYPE(BEMT_ConstraintStateType), INTENT(INOUT) :: DstConstrStateData
     INTEGER(IntKi),  INTENT(IN   ) :: CtrlCode
     INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
     CHARACTER(*),    INTENT(  OUT) :: ErrMsg
  ! Local 
     INTEGER(IntKi)                 :: i,j,k
     INTEGER(IntKi)                 :: i1, i1_l, i1_u  !  bounds (upper/lower) for an array dimension 1
     INTEGER(IntKi)                 :: i2, i2_l, i2_u  !  bounds (upper/lower) for an array dimension 2
     INTEGER(IntKi)                 :: ErrStat2
     CHARACTER(ErrMsgLen)           :: ErrMsg2
     CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_CopyConstrState'
  ! 
     ErrStat = ErrID_None
     ErrMsg  = ""
  IF (ALLOCATED(SrcConstrStateData%phi)) THEN
    i1_l = LBOUND(SrcConstrStateData%phi,1)
    i1_u = UBOUND(SrcConstrStateData%phi,1)
    i2_l = LBOUND(SrcConstrStateData%phi,2)
    i2_u = UBOUND(SrcConstrStateData%phi,2)
    IF (.NOT. ALLOCATED(DstConstrStateData%phi)) THEN 
      ALLOCATE(DstConstrStateData%phi(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstConstrStateData%phi.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstConstrStateData%phi = SrcConstrStateData%phi
  ENDIF
   END SUBROUTINE BEMT_CopyConstrState
  
   SUBROUTINE BEMT_DestroyConstrState( ConstrStateData, ErrStat, ErrMsg )
    TYPE(BEMT_ConstraintStateType), INTENT(INOUT) :: ConstrStateData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
    CHARACTER(*),    PARAMETER :: RoutineName = 'BEMT_DestroyConstrState'
    INTEGER(IntKi)                 :: i, i1, i2, i3, i4, i5 
  ! 
    ErrStat = ErrID_None
    ErrMsg  = ""
  IF (ALLOCATED(ConstrStateData%phi)) THEN
    DEALLOCATE(ConstrStateData%phi)
  ENDIF
   END SUBROUTINE BEMT_DestroyConstrState
  
   SUBROUTINE BEMT_PackConstrState( ReKiBuf, DbKiBuf, IntKiBuf, Indata, ErrStat, ErrMsg, SizeOnly )
    REAL(ReKi),       ALLOCATABLE, INTENT(  OUT) :: ReKiBuf(:)
    REAL(DbKi),       ALLOCATABLE, INTENT(  OUT) :: DbKiBuf(:)
    INTEGER(IntKi),   ALLOCATABLE, INTENT(  OUT) :: IntKiBuf(:)
    TYPE(BEMT_ConstraintStateType),  INTENT(IN) :: InData
    INTEGER(IntKi),   INTENT(  OUT) :: ErrStat
    CHARACTER(*),     INTENT(  OUT) :: ErrMsg
    LOGICAL,OPTIONAL, INTENT(IN   ) :: SizeOnly
      ! Local variables
    INTEGER(IntKi)                 :: Re_BufSz
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_BufSz
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_BufSz
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i,i1,i2,i3,i4,i5
    LOGICAL                        :: OnlySize ! if present and true, do not pack, just allocate buffers
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_PackConstrState'
   ! buffers to store subtypes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
  
    OnlySize = .FALSE.
    IF ( PRESENT(SizeOnly) ) THEN
      OnlySize = SizeOnly
    ENDIF
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_BufSz  = 0
    Db_BufSz  = 0
    Int_BufSz  = 0
    Int_BufSz   = Int_BufSz   + 1     ! phi allocated yes/no
    IF ( ALLOCATED(InData%phi) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! phi upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%phi)  ! phi
    END IF
    IF ( Re_BufSz  .GT. 0 ) THEN 
       ALLOCATE( ReKiBuf(  Re_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating ReKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Db_BufSz  .GT. 0 ) THEN 
       ALLOCATE( DbKiBuf(  Db_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating DbKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Int_BufSz  .GT. 0 ) THEN 
       ALLOCATE( IntKiBuf(  Int_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating IntKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF(OnlySize) RETURN ! return early if only trying to allocate buffers (not pack them)
  
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred = 1
  
    IF ( .NOT. ALLOCATED(InData%phi) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%phi,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%phi,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%phi,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%phi,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%phi)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%phi))-1 ) = PACK(InData%phi,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%phi)
    END IF
   END SUBROUTINE BEMT_PackConstrState
  
   SUBROUTINE BEMT_UnPackConstrState( ReKiBuf, DbKiBuf, IntKiBuf, Outdata, ErrStat, ErrMsg )
    REAL(ReKi),      ALLOCATABLE, INTENT(IN   ) :: ReKiBuf(:)
    REAL(DbKi),      ALLOCATABLE, INTENT(IN   ) :: DbKiBuf(:)
    INTEGER(IntKi),  ALLOCATABLE, INTENT(IN   ) :: IntKiBuf(:)
    TYPE(BEMT_ConstraintStateType), INTENT(INOUT) :: OutData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
      ! Local variables
    INTEGER(IntKi)                 :: Buf_size
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i
    LOGICAL                        :: mask0
    LOGICAL, ALLOCATABLE           :: mask1(:)
    LOGICAL, ALLOCATABLE           :: mask2(:,:)
    LOGICAL, ALLOCATABLE           :: mask3(:,:,:)
    LOGICAL, ALLOCATABLE           :: mask4(:,:,:,:)
    LOGICAL, ALLOCATABLE           :: mask5(:,:,:,:,:)
    INTEGER(IntKi)                 :: i1, i1_l, i1_u  !  bounds (upper/lower) for an array dimension 1
    INTEGER(IntKi)                 :: i2, i2_l, i2_u  !  bounds (upper/lower) for an array dimension 2
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_UnPackConstrState'
   ! buffers to store meshes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred  = 1
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! phi not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%phi)) DEALLOCATE(OutData%phi)
      ALLOCATE(OutData%phi(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%phi.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%phi)>0) OutData%phi = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%phi))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%phi)
      DEALLOCATE(mask2)
    END IF
   END SUBROUTINE BEMT_UnPackConstrState
  
   SUBROUTINE BEMT_CopyOtherState( SrcOtherStateData, DstOtherStateData, CtrlCode, ErrStat, ErrMsg )
     TYPE(BEMT_OtherStateType), INTENT(IN) :: SrcOtherStateData
     TYPE(BEMT_OtherStateType), INTENT(INOUT) :: DstOtherStateData
     INTEGER(IntKi),  INTENT(IN   ) :: CtrlCode
     INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
     CHARACTER(*),    INTENT(  OUT) :: ErrMsg
  ! Local 
     INTEGER(IntKi)                 :: i,j,k
     INTEGER(IntKi)                 :: i1, i1_l, i1_u  !  bounds (upper/lower) for an array dimension 1
     INTEGER(IntKi)                 :: i2, i2_l, i2_u  !  bounds (upper/lower) for an array dimension 2
     INTEGER(IntKi)                 :: ErrStat2
     CHARACTER(ErrMsgLen)           :: ErrMsg2
     CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_CopyOtherState'
  ! 
     ErrStat = ErrID_None
     ErrMsg  = ""
        CALL UA_CopyOtherState( SrcOtherStateData%UA, DstOtherStateData%UA, CtrlCode, ErrStat2, ErrMsg2 )
           CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg,RoutineName)
           IF (ErrStat>=AbortErrLev) RETURN
  IF (ALLOCATED(SrcOtherStateData%UA_Flag)) THEN
    i1_l = LBOUND(SrcOtherStateData%UA_Flag,1)
    i1_u = UBOUND(SrcOtherStateData%UA_Flag,1)
    i2_l = LBOUND(SrcOtherStateData%UA_Flag,2)
    i2_u = UBOUND(SrcOtherStateData%UA_Flag,2)
    IF (.NOT. ALLOCATED(DstOtherStateData%UA_Flag)) THEN 
      ALLOCATE(DstOtherStateData%UA_Flag(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstOtherStateData%UA_Flag.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstOtherStateData%UA_Flag = SrcOtherStateData%UA_Flag
  ENDIF
  IF (ALLOCATED(SrcOtherStateData%ValidPhi)) THEN
    i1_l = LBOUND(SrcOtherStateData%ValidPhi,1)
    i1_u = UBOUND(SrcOtherStateData%ValidPhi,1)
    i2_l = LBOUND(SrcOtherStateData%ValidPhi,2)
    i2_u = UBOUND(SrcOtherStateData%ValidPhi,2)
    IF (.NOT. ALLOCATED(DstOtherStateData%ValidPhi)) THEN 
      ALLOCATE(DstOtherStateData%ValidPhi(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstOtherStateData%ValidPhi.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstOtherStateData%ValidPhi = SrcOtherStateData%ValidPhi
  ENDIF
      DstOtherStateData%nodesInitialized = SrcOtherStateData%nodesInitialized
   END SUBROUTINE BEMT_CopyOtherState
  
   SUBROUTINE BEMT_DestroyOtherState( OtherStateData, ErrStat, ErrMsg )
    TYPE(BEMT_OtherStateType), INTENT(INOUT) :: OtherStateData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
    CHARACTER(*),    PARAMETER :: RoutineName = 'BEMT_DestroyOtherState'
    INTEGER(IntKi)                 :: i, i1, i2, i3, i4, i5 
  ! 
    ErrStat = ErrID_None
    ErrMsg  = ""
    CALL UA_DestroyOtherState( OtherStateData%UA, ErrStat, ErrMsg )
  IF (ALLOCATED(OtherStateData%UA_Flag)) THEN
    DEALLOCATE(OtherStateData%UA_Flag)
  ENDIF
  IF (ALLOCATED(OtherStateData%ValidPhi)) THEN
    DEALLOCATE(OtherStateData%ValidPhi)
  ENDIF
   END SUBROUTINE BEMT_DestroyOtherState
  
   SUBROUTINE BEMT_PackOtherState( ReKiBuf, DbKiBuf, IntKiBuf, Indata, ErrStat, ErrMsg, SizeOnly )
    REAL(ReKi),       ALLOCATABLE, INTENT(  OUT) :: ReKiBuf(:)
    REAL(DbKi),       ALLOCATABLE, INTENT(  OUT) :: DbKiBuf(:)
    INTEGER(IntKi),   ALLOCATABLE, INTENT(  OUT) :: IntKiBuf(:)
    TYPE(BEMT_OtherStateType),  INTENT(IN) :: InData
    INTEGER(IntKi),   INTENT(  OUT) :: ErrStat
    CHARACTER(*),     INTENT(  OUT) :: ErrMsg
    LOGICAL,OPTIONAL, INTENT(IN   ) :: SizeOnly
      ! Local variables
    INTEGER(IntKi)                 :: Re_BufSz
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_BufSz
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_BufSz
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i,i1,i2,i3,i4,i5
    LOGICAL                        :: OnlySize ! if present and true, do not pack, just allocate buffers
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_PackOtherState'
   ! buffers to store subtypes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
  
    OnlySize = .FALSE.
    IF ( PRESENT(SizeOnly) ) THEN
      OnlySize = SizeOnly
    ENDIF
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_BufSz  = 0
    Db_BufSz  = 0
    Int_BufSz  = 0
     ! Allocate buffers for subtypes, if any (we'll get sizes from these) 
        Int_BufSz   = Int_BufSz + 3  ! UA: size of buffers for each call to pack subtype
        CALL UA_PackOtherState( Re_Buf, Db_Buf, Int_Buf, InData%UA, ErrStat2, ErrMsg2, .TRUE. ) ! UA 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf)) THEN ! UA
           Re_BufSz  = Re_BufSz  + SIZE( Re_Buf  )
           DEALLOCATE(Re_Buf)
        END IF
        IF(ALLOCATED(Db_Buf)) THEN ! UA
           Db_BufSz  = Db_BufSz  + SIZE( Db_Buf  )
           DEALLOCATE(Db_Buf)
        END IF
        IF(ALLOCATED(Int_Buf)) THEN ! UA
           Int_BufSz = Int_BufSz + SIZE( Int_Buf )
           DEALLOCATE(Int_Buf)
        END IF
    Int_BufSz   = Int_BufSz   + 1     ! UA_Flag allocated yes/no
    IF ( ALLOCATED(InData%UA_Flag) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! UA_Flag upper/lower bounds for each dimension
        Int_BufSz  = Int_BufSz  + SIZE(InData%UA_Flag)  ! UA_Flag
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! ValidPhi allocated yes/no
    IF ( ALLOCATED(InData%ValidPhi) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! ValidPhi upper/lower bounds for each dimension
        Int_BufSz  = Int_BufSz  + SIZE(InData%ValidPhi)  ! ValidPhi
    END IF
        Int_BufSz  = Int_BufSz  + 1  ! nodesInitialized
    IF ( Re_BufSz  .GT. 0 ) THEN 
       ALLOCATE( ReKiBuf(  Re_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating ReKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Db_BufSz  .GT. 0 ) THEN 
       ALLOCATE( DbKiBuf(  Db_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating DbKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Int_BufSz  .GT. 0 ) THEN 
       ALLOCATE( IntKiBuf(  Int_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating IntKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF(OnlySize) RETURN ! return early if only trying to allocate buffers (not pack them)
  
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred = 1
  
        CALL UA_PackOtherState( Re_Buf, Db_Buf, Int_Buf, InData%UA, ErrStat2, ErrMsg2, OnlySize ) ! UA 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Re_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Re_Buf) > 0) ReKiBuf( Re_Xferred:Re_Xferred+SIZE(Re_Buf)-1 ) = Re_Buf
          Re_Xferred = Re_Xferred + SIZE(Re_Buf)
          DEALLOCATE(Re_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
        IF(ALLOCATED(Db_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Db_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Db_Buf) > 0) DbKiBuf( Db_Xferred:Db_Xferred+SIZE(Db_Buf)-1 ) = Db_Buf
          Db_Xferred = Db_Xferred + SIZE(Db_Buf)
          DEALLOCATE(Db_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
        IF(ALLOCATED(Int_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Int_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Int_Buf) > 0) IntKiBuf( Int_Xferred:Int_Xferred+SIZE(Int_Buf)-1 ) = Int_Buf
          Int_Xferred = Int_Xferred + SIZE(Int_Buf)
          DEALLOCATE(Int_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
    IF ( .NOT. ALLOCATED(InData%UA_Flag) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%UA_Flag,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%UA_Flag,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%UA_Flag,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%UA_Flag,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%UA_Flag)>0) IntKiBuf ( Int_Xferred:Int_Xferred+SIZE(InData%UA_Flag)-1 ) = TRANSFER(PACK( InData%UA_Flag ,.TRUE.), IntKiBuf(1), SIZE(InData%UA_Flag))
        Int_Xferred   = Int_Xferred   + SIZE(InData%UA_Flag)
    END IF
    IF ( .NOT. ALLOCATED(InData%ValidPhi) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%ValidPhi,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%ValidPhi,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%ValidPhi,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%ValidPhi,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%ValidPhi)>0) IntKiBuf ( Int_Xferred:Int_Xferred+SIZE(InData%ValidPhi)-1 ) = TRANSFER(PACK( InData%ValidPhi ,.TRUE.), IntKiBuf(1), SIZE(InData%ValidPhi))
        Int_Xferred   = Int_Xferred   + SIZE(InData%ValidPhi)
    END IF
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%nodesInitialized , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
   END SUBROUTINE BEMT_PackOtherState
  
   SUBROUTINE BEMT_UnPackOtherState( ReKiBuf, DbKiBuf, IntKiBuf, Outdata, ErrStat, ErrMsg )
    REAL(ReKi),      ALLOCATABLE, INTENT(IN   ) :: ReKiBuf(:)
    REAL(DbKi),      ALLOCATABLE, INTENT(IN   ) :: DbKiBuf(:)
    INTEGER(IntKi),  ALLOCATABLE, INTENT(IN   ) :: IntKiBuf(:)
    TYPE(BEMT_OtherStateType), INTENT(INOUT) :: OutData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
      ! Local variables
    INTEGER(IntKi)                 :: Buf_size
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i
    LOGICAL                        :: mask0
    LOGICAL, ALLOCATABLE           :: mask1(:)
    LOGICAL, ALLOCATABLE           :: mask2(:,:)
    LOGICAL, ALLOCATABLE           :: mask3(:,:,:)
    LOGICAL, ALLOCATABLE           :: mask4(:,:,:,:)
    LOGICAL, ALLOCATABLE           :: mask5(:,:,:,:,:)
    INTEGER(IntKi)                 :: i1, i1_l, i1_u  !  bounds (upper/lower) for an array dimension 1
    INTEGER(IntKi)                 :: i2, i2_l, i2_u  !  bounds (upper/lower) for an array dimension 2
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_UnPackOtherState'
   ! buffers to store meshes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred  = 1
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Re_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Re_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Re_Buf = ReKiBuf( Re_Xferred:Re_Xferred+Buf_size-1 )
          Re_Xferred = Re_Xferred + Buf_size
        END IF
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Db_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Db_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Db_Buf = DbKiBuf( Db_Xferred:Db_Xferred+Buf_size-1 )
          Db_Xferred = Db_Xferred + Buf_size
        END IF
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Int_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Int_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Int_Buf = IntKiBuf( Int_Xferred:Int_Xferred+Buf_size-1 )
          Int_Xferred = Int_Xferred + Buf_size
        END IF
        CALL UA_UnpackOtherState( Re_Buf, Db_Buf, Int_Buf, OutData%UA, ErrStat2, ErrMsg2 ) ! UA 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf )) DEALLOCATE(Re_Buf )
        IF(ALLOCATED(Db_Buf )) DEALLOCATE(Db_Buf )
        IF(ALLOCATED(Int_Buf)) DEALLOCATE(Int_Buf)
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! UA_Flag not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%UA_Flag)) DEALLOCATE(OutData%UA_Flag)
      ALLOCATE(OutData%UA_Flag(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%UA_Flag.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%UA_Flag)>0) OutData%UA_Flag = UNPACK( TRANSFER( IntKiBuf ( Int_Xferred:Int_Xferred+(SIZE(OutData%UA_Flag))-1 ), OutData%UA_Flag), mask2,.TRUE.)
        Int_Xferred   = Int_Xferred   + SIZE(OutData%UA_Flag)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! ValidPhi not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%ValidPhi)) DEALLOCATE(OutData%ValidPhi)
      ALLOCATE(OutData%ValidPhi(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%ValidPhi.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%ValidPhi)>0) OutData%ValidPhi = UNPACK( TRANSFER( IntKiBuf ( Int_Xferred:Int_Xferred+(SIZE(OutData%ValidPhi))-1 ), OutData%ValidPhi), mask2,.TRUE.)
        Int_Xferred   = Int_Xferred   + SIZE(OutData%ValidPhi)
      DEALLOCATE(mask2)
    END IF
        OutData%nodesInitialized = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
   END SUBROUTINE BEMT_UnPackOtherState
  
   SUBROUTINE BEMT_CopyMisc( SrcMiscData, DstMiscData, CtrlCode, ErrStat, ErrMsg )
     TYPE(BEMT_MiscVarType), INTENT(IN) :: SrcMiscData
     TYPE(BEMT_MiscVarType), INTENT(INOUT) :: DstMiscData
     INTEGER(IntKi),  INTENT(IN   ) :: CtrlCode
     INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
     CHARACTER(*),    INTENT(  OUT) :: ErrMsg
  ! Local 
     INTEGER(IntKi)                 :: i,j,k
     INTEGER(IntKi)                 :: i1, i1_l, i1_u  !  bounds (upper/lower) for an array dimension 1
     INTEGER(IntKi)                 :: i2, i2_l, i2_u  !  bounds (upper/lower) for an array dimension 2
     INTEGER(IntKi)                 :: ErrStat2
     CHARACTER(ErrMsgLen)           :: ErrMsg2
     CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_CopyMisc'
  ! 
     ErrStat = ErrID_None
     ErrMsg  = ""
      DstMiscData%FirstWarn_M = SrcMiscData%FirstWarn_M
        CALL UA_CopyMisc( SrcMiscData%UA, DstMiscData%UA, CtrlCode, ErrStat2, ErrMsg2 )
           CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg,RoutineName)
           IF (ErrStat>=AbortErrLev) RETURN
        CALL UA_CopyOutput( SrcMiscData%y_UA, DstMiscData%y_UA, CtrlCode, ErrStat2, ErrMsg2 )
           CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg,RoutineName)
           IF (ErrStat>=AbortErrLev) RETURN
  IF (ALLOCATED(SrcMiscData%TnInd_op)) THEN
    i1_l = LBOUND(SrcMiscData%TnInd_op,1)
    i1_u = UBOUND(SrcMiscData%TnInd_op,1)
    i2_l = LBOUND(SrcMiscData%TnInd_op,2)
    i2_u = UBOUND(SrcMiscData%TnInd_op,2)
    IF (.NOT. ALLOCATED(DstMiscData%TnInd_op)) THEN 
      ALLOCATE(DstMiscData%TnInd_op(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstMiscData%TnInd_op.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstMiscData%TnInd_op = SrcMiscData%TnInd_op
  ENDIF
  IF (ALLOCATED(SrcMiscData%AxInd_op)) THEN
    i1_l = LBOUND(SrcMiscData%AxInd_op,1)
    i1_u = UBOUND(SrcMiscData%AxInd_op,1)
    i2_l = LBOUND(SrcMiscData%AxInd_op,2)
    i2_u = UBOUND(SrcMiscData%AxInd_op,2)
    IF (.NOT. ALLOCATED(DstMiscData%AxInd_op)) THEN 
      ALLOCATE(DstMiscData%AxInd_op(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstMiscData%AxInd_op.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstMiscData%AxInd_op = SrcMiscData%AxInd_op
  ENDIF
      DstMiscData%UseFrozenWake = SrcMiscData%UseFrozenWake
   END SUBROUTINE BEMT_CopyMisc
  
   SUBROUTINE BEMT_DestroyMisc( MiscData, ErrStat, ErrMsg )
    TYPE(BEMT_MiscVarType), INTENT(INOUT) :: MiscData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
    CHARACTER(*),    PARAMETER :: RoutineName = 'BEMT_DestroyMisc'
    INTEGER(IntKi)                 :: i, i1, i2, i3, i4, i5 
  ! 
    ErrStat = ErrID_None
    ErrMsg  = ""
    CALL UA_DestroyMisc( MiscData%UA, ErrStat, ErrMsg )
    CALL UA_DestroyOutput( MiscData%y_UA, ErrStat, ErrMsg )
  IF (ALLOCATED(MiscData%TnInd_op)) THEN
    DEALLOCATE(MiscData%TnInd_op)
  ENDIF
  IF (ALLOCATED(MiscData%AxInd_op)) THEN
    DEALLOCATE(MiscData%AxInd_op)
  ENDIF
   END SUBROUTINE BEMT_DestroyMisc
  
   SUBROUTINE BEMT_PackMisc( ReKiBuf, DbKiBuf, IntKiBuf, Indata, ErrStat, ErrMsg, SizeOnly )
    REAL(ReKi),       ALLOCATABLE, INTENT(  OUT) :: ReKiBuf(:)
    REAL(DbKi),       ALLOCATABLE, INTENT(  OUT) :: DbKiBuf(:)
    INTEGER(IntKi),   ALLOCATABLE, INTENT(  OUT) :: IntKiBuf(:)
    TYPE(BEMT_MiscVarType),  INTENT(IN) :: InData
    INTEGER(IntKi),   INTENT(  OUT) :: ErrStat
    CHARACTER(*),     INTENT(  OUT) :: ErrMsg
    LOGICAL,OPTIONAL, INTENT(IN   ) :: SizeOnly
      ! Local variables
    INTEGER(IntKi)                 :: Re_BufSz
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_BufSz
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_BufSz
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i,i1,i2,i3,i4,i5
    LOGICAL                        :: OnlySize ! if present and true, do not pack, just allocate buffers
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_PackMisc'
   ! buffers to store subtypes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
  
    OnlySize = .FALSE.
    IF ( PRESENT(SizeOnly) ) THEN
      OnlySize = SizeOnly
    ENDIF
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_BufSz  = 0
    Db_BufSz  = 0
    Int_BufSz  = 0
        Int_BufSz  = Int_BufSz  + 1  ! FirstWarn_M
     ! Allocate buffers for subtypes, if any (we'll get sizes from these) 
        Int_BufSz   = Int_BufSz + 3  ! UA: size of buffers for each call to pack subtype
        CALL UA_PackMisc( Re_Buf, Db_Buf, Int_Buf, InData%UA, ErrStat2, ErrMsg2, .TRUE. ) ! UA 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf)) THEN ! UA
           Re_BufSz  = Re_BufSz  + SIZE( Re_Buf  )
           DEALLOCATE(Re_Buf)
        END IF
        IF(ALLOCATED(Db_Buf)) THEN ! UA
           Db_BufSz  = Db_BufSz  + SIZE( Db_Buf  )
           DEALLOCATE(Db_Buf)
        END IF
        IF(ALLOCATED(Int_Buf)) THEN ! UA
           Int_BufSz = Int_BufSz + SIZE( Int_Buf )
           DEALLOCATE(Int_Buf)
        END IF
        Int_BufSz   = Int_BufSz + 3  ! y_UA: size of buffers for each call to pack subtype
        CALL UA_PackOutput( Re_Buf, Db_Buf, Int_Buf, InData%y_UA, ErrStat2, ErrMsg2, .TRUE. ) ! y_UA 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf)) THEN ! y_UA
           Re_BufSz  = Re_BufSz  + SIZE( Re_Buf  )
           DEALLOCATE(Re_Buf)
        END IF
        IF(ALLOCATED(Db_Buf)) THEN ! y_UA
           Db_BufSz  = Db_BufSz  + SIZE( Db_Buf  )
           DEALLOCATE(Db_Buf)
        END IF
        IF(ALLOCATED(Int_Buf)) THEN ! y_UA
           Int_BufSz = Int_BufSz + SIZE( Int_Buf )
           DEALLOCATE(Int_Buf)
        END IF
    Int_BufSz   = Int_BufSz   + 1     ! TnInd_op allocated yes/no
    IF ( ALLOCATED(InData%TnInd_op) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! TnInd_op upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%TnInd_op)  ! TnInd_op
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! AxInd_op allocated yes/no
    IF ( ALLOCATED(InData%AxInd_op) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! AxInd_op upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%AxInd_op)  ! AxInd_op
    END IF
        Int_BufSz  = Int_BufSz  + 1  ! UseFrozenWake
    IF ( Re_BufSz  .GT. 0 ) THEN 
       ALLOCATE( ReKiBuf(  Re_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating ReKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Db_BufSz  .GT. 0 ) THEN 
       ALLOCATE( DbKiBuf(  Db_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating DbKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Int_BufSz  .GT. 0 ) THEN 
       ALLOCATE( IntKiBuf(  Int_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating IntKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF(OnlySize) RETURN ! return early if only trying to allocate buffers (not pack them)
  
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred = 1
  
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%FirstWarn_M , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
        CALL UA_PackMisc( Re_Buf, Db_Buf, Int_Buf, InData%UA, ErrStat2, ErrMsg2, OnlySize ) ! UA 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Re_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Re_Buf) > 0) ReKiBuf( Re_Xferred:Re_Xferred+SIZE(Re_Buf)-1 ) = Re_Buf
          Re_Xferred = Re_Xferred + SIZE(Re_Buf)
          DEALLOCATE(Re_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
        IF(ALLOCATED(Db_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Db_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Db_Buf) > 0) DbKiBuf( Db_Xferred:Db_Xferred+SIZE(Db_Buf)-1 ) = Db_Buf
          Db_Xferred = Db_Xferred + SIZE(Db_Buf)
          DEALLOCATE(Db_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
        IF(ALLOCATED(Int_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Int_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Int_Buf) > 0) IntKiBuf( Int_Xferred:Int_Xferred+SIZE(Int_Buf)-1 ) = Int_Buf
          Int_Xferred = Int_Xferred + SIZE(Int_Buf)
          DEALLOCATE(Int_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
        CALL UA_PackOutput( Re_Buf, Db_Buf, Int_Buf, InData%y_UA, ErrStat2, ErrMsg2, OnlySize ) ! y_UA 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Re_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Re_Buf) > 0) ReKiBuf( Re_Xferred:Re_Xferred+SIZE(Re_Buf)-1 ) = Re_Buf
          Re_Xferred = Re_Xferred + SIZE(Re_Buf)
          DEALLOCATE(Re_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
        IF(ALLOCATED(Db_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Db_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Db_Buf) > 0) DbKiBuf( Db_Xferred:Db_Xferred+SIZE(Db_Buf)-1 ) = Db_Buf
          Db_Xferred = Db_Xferred + SIZE(Db_Buf)
          DEALLOCATE(Db_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
        IF(ALLOCATED(Int_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Int_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Int_Buf) > 0) IntKiBuf( Int_Xferred:Int_Xferred+SIZE(Int_Buf)-1 ) = Int_Buf
          Int_Xferred = Int_Xferred + SIZE(Int_Buf)
          DEALLOCATE(Int_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
    IF ( .NOT. ALLOCATED(InData%TnInd_op) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%TnInd_op,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%TnInd_op,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%TnInd_op,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%TnInd_op,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%TnInd_op)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%TnInd_op))-1 ) = PACK(InData%TnInd_op,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%TnInd_op)
    END IF
    IF ( .NOT. ALLOCATED(InData%AxInd_op) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%AxInd_op,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%AxInd_op,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%AxInd_op,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%AxInd_op,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%AxInd_op)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%AxInd_op))-1 ) = PACK(InData%AxInd_op,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%AxInd_op)
    END IF
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%UseFrozenWake , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
   END SUBROUTINE BEMT_PackMisc
  
   SUBROUTINE BEMT_UnPackMisc( ReKiBuf, DbKiBuf, IntKiBuf, Outdata, ErrStat, ErrMsg )
    REAL(ReKi),      ALLOCATABLE, INTENT(IN   ) :: ReKiBuf(:)
    REAL(DbKi),      ALLOCATABLE, INTENT(IN   ) :: DbKiBuf(:)
    INTEGER(IntKi),  ALLOCATABLE, INTENT(IN   ) :: IntKiBuf(:)
    TYPE(BEMT_MiscVarType), INTENT(INOUT) :: OutData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
      ! Local variables
    INTEGER(IntKi)                 :: Buf_size
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i
    LOGICAL                        :: mask0
    LOGICAL, ALLOCATABLE           :: mask1(:)
    LOGICAL, ALLOCATABLE           :: mask2(:,:)
    LOGICAL, ALLOCATABLE           :: mask3(:,:,:)
    LOGICAL, ALLOCATABLE           :: mask4(:,:,:,:)
    LOGICAL, ALLOCATABLE           :: mask5(:,:,:,:,:)
    INTEGER(IntKi)                 :: i1, i1_l, i1_u  !  bounds (upper/lower) for an array dimension 1
    INTEGER(IntKi)                 :: i2, i2_l, i2_u  !  bounds (upper/lower) for an array dimension 2
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_UnPackMisc'
   ! buffers to store meshes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred  = 1
        OutData%FirstWarn_M = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Re_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Re_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Re_Buf = ReKiBuf( Re_Xferred:Re_Xferred+Buf_size-1 )
          Re_Xferred = Re_Xferred + Buf_size
        END IF
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Db_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Db_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Db_Buf = DbKiBuf( Db_Xferred:Db_Xferred+Buf_size-1 )
          Db_Xferred = Db_Xferred + Buf_size
        END IF
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Int_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Int_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Int_Buf = IntKiBuf( Int_Xferred:Int_Xferred+Buf_size-1 )
          Int_Xferred = Int_Xferred + Buf_size
        END IF
        CALL UA_UnpackMisc( Re_Buf, Db_Buf, Int_Buf, OutData%UA, ErrStat2, ErrMsg2 ) ! UA 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf )) DEALLOCATE(Re_Buf )
        IF(ALLOCATED(Db_Buf )) DEALLOCATE(Db_Buf )
        IF(ALLOCATED(Int_Buf)) DEALLOCATE(Int_Buf)
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Re_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Re_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Re_Buf = ReKiBuf( Re_Xferred:Re_Xferred+Buf_size-1 )
          Re_Xferred = Re_Xferred + Buf_size
        END IF
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Db_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Db_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Db_Buf = DbKiBuf( Db_Xferred:Db_Xferred+Buf_size-1 )
          Db_Xferred = Db_Xferred + Buf_size
        END IF
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Int_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Int_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Int_Buf = IntKiBuf( Int_Xferred:Int_Xferred+Buf_size-1 )
          Int_Xferred = Int_Xferred + Buf_size
        END IF
        CALL UA_UnpackOutput( Re_Buf, Db_Buf, Int_Buf, OutData%y_UA, ErrStat2, ErrMsg2 ) ! y_UA 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf )) DEALLOCATE(Re_Buf )
        IF(ALLOCATED(Db_Buf )) DEALLOCATE(Db_Buf )
        IF(ALLOCATED(Int_Buf)) DEALLOCATE(Int_Buf)
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! TnInd_op not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%TnInd_op)) DEALLOCATE(OutData%TnInd_op)
      ALLOCATE(OutData%TnInd_op(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%TnInd_op.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%TnInd_op)>0) OutData%TnInd_op = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%TnInd_op))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%TnInd_op)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! AxInd_op not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%AxInd_op)) DEALLOCATE(OutData%AxInd_op)
      ALLOCATE(OutData%AxInd_op(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%AxInd_op.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%AxInd_op)>0) OutData%AxInd_op = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%AxInd_op))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%AxInd_op)
      DEALLOCATE(mask2)
    END IF
        OutData%UseFrozenWake = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
   END SUBROUTINE BEMT_UnPackMisc
  
   SUBROUTINE BEMT_CopyParam( SrcParamData, DstParamData, CtrlCode, ErrStat, ErrMsg )
     TYPE(BEMT_ParameterType), INTENT(IN) :: SrcParamData
     TYPE(BEMT_ParameterType), INTENT(INOUT) :: DstParamData
     INTEGER(IntKi),  INTENT(IN   ) :: CtrlCode
     INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
     CHARACTER(*),    INTENT(  OUT) :: ErrMsg
  ! Local 
     INTEGER(IntKi)                 :: i,j,k
     INTEGER(IntKi)                 :: i1, i1_l, i1_u  !  bounds (upper/lower) for an array dimension 1
     INTEGER(IntKi)                 :: i2, i2_l, i2_u  !  bounds (upper/lower) for an array dimension 2
     INTEGER(IntKi)                 :: ErrStat2
     CHARACTER(ErrMsgLen)           :: ErrMsg2
     CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_CopyParam'
  ! 
     ErrStat = ErrID_None
     ErrMsg  = ""
      DstParamData%DT = SrcParamData%DT
  IF (ALLOCATED(SrcParamData%chord)) THEN
    i1_l = LBOUND(SrcParamData%chord,1)
    i1_u = UBOUND(SrcParamData%chord,1)
    i2_l = LBOUND(SrcParamData%chord,2)
    i2_u = UBOUND(SrcParamData%chord,2)
    IF (.NOT. ALLOCATED(DstParamData%chord)) THEN 
      ALLOCATE(DstParamData%chord(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstParamData%chord.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstParamData%chord = SrcParamData%chord
  ENDIF
      DstParamData%numBlades = SrcParamData%numBlades
      DstParamData%airDens = SrcParamData%airDens
      DstParamData%kinVisc = SrcParamData%kinVisc
      DstParamData%skewWakeMod = SrcParamData%skewWakeMod
      DstParamData%aTol = SrcParamData%aTol
      DstParamData%useTipLoss = SrcParamData%useTipLoss
      DstParamData%useHubLoss = SrcParamData%useHubLoss
      DstParamData%useInduction = SrcParamData%useInduction
      DstParamData%useTanInd = SrcParamData%useTanInd
      DstParamData%useAIDrag = SrcParamData%useAIDrag
      DstParamData%useTIDrag = SrcParamData%useTIDrag
      DstParamData%numBladeNodes = SrcParamData%numBladeNodes
      DstParamData%numReIterations = SrcParamData%numReIterations
      DstParamData%maxIndIterations = SrcParamData%maxIndIterations
  IF (ALLOCATED(SrcParamData%AFindx)) THEN
    i1_l = LBOUND(SrcParamData%AFindx,1)
    i1_u = UBOUND(SrcParamData%AFindx,1)
    i2_l = LBOUND(SrcParamData%AFindx,2)
    i2_u = UBOUND(SrcParamData%AFindx,2)
    IF (.NOT. ALLOCATED(DstParamData%AFindx)) THEN 
      ALLOCATE(DstParamData%AFindx(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstParamData%AFindx.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstParamData%AFindx = SrcParamData%AFindx
  ENDIF
  IF (ALLOCATED(SrcParamData%tipLossConst)) THEN
    i1_l = LBOUND(SrcParamData%tipLossConst,1)
    i1_u = UBOUND(SrcParamData%tipLossConst,1)
    i2_l = LBOUND(SrcParamData%tipLossConst,2)
    i2_u = UBOUND(SrcParamData%tipLossConst,2)
    IF (.NOT. ALLOCATED(DstParamData%tipLossConst)) THEN 
      ALLOCATE(DstParamData%tipLossConst(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstParamData%tipLossConst.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstParamData%tipLossConst = SrcParamData%tipLossConst
  ENDIF
  IF (ALLOCATED(SrcParamData%hubLossConst)) THEN
    i1_l = LBOUND(SrcParamData%hubLossConst,1)
    i1_u = UBOUND(SrcParamData%hubLossConst,1)
    i2_l = LBOUND(SrcParamData%hubLossConst,2)
    i2_u = UBOUND(SrcParamData%hubLossConst,2)
    IF (.NOT. ALLOCATED(DstParamData%hubLossConst)) THEN 
      ALLOCATE(DstParamData%hubLossConst(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstParamData%hubLossConst.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstParamData%hubLossConst = SrcParamData%hubLossConst
  ENDIF
  IF (ALLOCATED(SrcParamData%zHub)) THEN
    i1_l = LBOUND(SrcParamData%zHub,1)
    i1_u = UBOUND(SrcParamData%zHub,1)
    IF (.NOT. ALLOCATED(DstParamData%zHub)) THEN 
      ALLOCATE(DstParamData%zHub(i1_l:i1_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstParamData%zHub.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstParamData%zHub = SrcParamData%zHub
  ENDIF
        CALL UA_CopyParam( SrcParamData%UA, DstParamData%UA, CtrlCode, ErrStat2, ErrMsg2 )
           CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg,RoutineName)
           IF (ErrStat>=AbortErrLev) RETURN
      DstParamData%UA_Flag = SrcParamData%UA_Flag
   END SUBROUTINE BEMT_CopyParam
  
   SUBROUTINE BEMT_DestroyParam( ParamData, ErrStat, ErrMsg )
    TYPE(BEMT_ParameterType), INTENT(INOUT) :: ParamData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
    CHARACTER(*),    PARAMETER :: RoutineName = 'BEMT_DestroyParam'
    INTEGER(IntKi)                 :: i, i1, i2, i3, i4, i5 
  ! 
    ErrStat = ErrID_None
    ErrMsg  = ""
  IF (ALLOCATED(ParamData%chord)) THEN
    DEALLOCATE(ParamData%chord)
  ENDIF
  IF (ALLOCATED(ParamData%AFindx)) THEN
    DEALLOCATE(ParamData%AFindx)
  ENDIF
  IF (ALLOCATED(ParamData%tipLossConst)) THEN
    DEALLOCATE(ParamData%tipLossConst)
  ENDIF
  IF (ALLOCATED(ParamData%hubLossConst)) THEN
    DEALLOCATE(ParamData%hubLossConst)
  ENDIF
  IF (ALLOCATED(ParamData%zHub)) THEN
    DEALLOCATE(ParamData%zHub)
  ENDIF
    CALL UA_DestroyParam( ParamData%UA, ErrStat, ErrMsg )
   END SUBROUTINE BEMT_DestroyParam
  
   SUBROUTINE BEMT_PackParam( ReKiBuf, DbKiBuf, IntKiBuf, Indata, ErrStat, ErrMsg, SizeOnly )
    REAL(ReKi),       ALLOCATABLE, INTENT(  OUT) :: ReKiBuf(:)
    REAL(DbKi),       ALLOCATABLE, INTENT(  OUT) :: DbKiBuf(:)
    INTEGER(IntKi),   ALLOCATABLE, INTENT(  OUT) :: IntKiBuf(:)
    TYPE(BEMT_ParameterType),  INTENT(IN) :: InData
    INTEGER(IntKi),   INTENT(  OUT) :: ErrStat
    CHARACTER(*),     INTENT(  OUT) :: ErrMsg
    LOGICAL,OPTIONAL, INTENT(IN   ) :: SizeOnly
      ! Local variables
    INTEGER(IntKi)                 :: Re_BufSz
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_BufSz
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_BufSz
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i,i1,i2,i3,i4,i5
    LOGICAL                        :: OnlySize ! if present and true, do not pack, just allocate buffers
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_PackParam'
   ! buffers to store subtypes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
  
    OnlySize = .FALSE.
    IF ( PRESENT(SizeOnly) ) THEN
      OnlySize = SizeOnly
    ENDIF
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_BufSz  = 0
    Db_BufSz  = 0
    Int_BufSz  = 0
        Db_BufSz   = Db_BufSz   + 1  ! DT
    Int_BufSz   = Int_BufSz   + 1     ! chord allocated yes/no
    IF ( ALLOCATED(InData%chord) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! chord upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%chord)  ! chord
    END IF
        Int_BufSz  = Int_BufSz  + 1  ! numBlades
        Re_BufSz   = Re_BufSz   + 1  ! airDens
        Re_BufSz   = Re_BufSz   + 1  ! kinVisc
        Int_BufSz  = Int_BufSz  + 1  ! skewWakeMod
        Re_BufSz   = Re_BufSz   + 1  ! aTol
        Int_BufSz  = Int_BufSz  + 1  ! useTipLoss
        Int_BufSz  = Int_BufSz  + 1  ! useHubLoss
        Int_BufSz  = Int_BufSz  + 1  ! useInduction
        Int_BufSz  = Int_BufSz  + 1  ! useTanInd
        Int_BufSz  = Int_BufSz  + 1  ! useAIDrag
        Int_BufSz  = Int_BufSz  + 1  ! useTIDrag
        Int_BufSz  = Int_BufSz  + 1  ! numBladeNodes
        Int_BufSz  = Int_BufSz  + 1  ! numReIterations
        Int_BufSz  = Int_BufSz  + 1  ! maxIndIterations
    Int_BufSz   = Int_BufSz   + 1     ! AFindx allocated yes/no
    IF ( ALLOCATED(InData%AFindx) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! AFindx upper/lower bounds for each dimension
        Int_BufSz  = Int_BufSz  + SIZE(InData%AFindx)  ! AFindx
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! tipLossConst allocated yes/no
    IF ( ALLOCATED(InData%tipLossConst) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! tipLossConst upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%tipLossConst)  ! tipLossConst
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! hubLossConst allocated yes/no
    IF ( ALLOCATED(InData%hubLossConst) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! hubLossConst upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%hubLossConst)  ! hubLossConst
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! zHub allocated yes/no
    IF ( ALLOCATED(InData%zHub) ) THEN
      Int_BufSz   = Int_BufSz   + 2*1  ! zHub upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%zHub)  ! zHub
    END IF
     ! Allocate buffers for subtypes, if any (we'll get sizes from these) 
        Int_BufSz   = Int_BufSz + 3  ! UA: size of buffers for each call to pack subtype
        CALL UA_PackParam( Re_Buf, Db_Buf, Int_Buf, InData%UA, ErrStat2, ErrMsg2, .TRUE. ) ! UA 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf)) THEN ! UA
           Re_BufSz  = Re_BufSz  + SIZE( Re_Buf  )
           DEALLOCATE(Re_Buf)
        END IF
        IF(ALLOCATED(Db_Buf)) THEN ! UA
           Db_BufSz  = Db_BufSz  + SIZE( Db_Buf  )
           DEALLOCATE(Db_Buf)
        END IF
        IF(ALLOCATED(Int_Buf)) THEN ! UA
           Int_BufSz = Int_BufSz + SIZE( Int_Buf )
           DEALLOCATE(Int_Buf)
        END IF
        Int_BufSz  = Int_BufSz  + 1  ! UA_Flag
    IF ( Re_BufSz  .GT. 0 ) THEN 
       ALLOCATE( ReKiBuf(  Re_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating ReKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Db_BufSz  .GT. 0 ) THEN 
       ALLOCATE( DbKiBuf(  Db_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating DbKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Int_BufSz  .GT. 0 ) THEN 
       ALLOCATE( IntKiBuf(  Int_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating IntKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF(OnlySize) RETURN ! return early if only trying to allocate buffers (not pack them)
  
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred = 1
  
        DbKiBuf ( Db_Xferred:Db_Xferred+(1)-1 ) = InData%DT
        Db_Xferred   = Db_Xferred   + 1
    IF ( .NOT. ALLOCATED(InData%chord) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%chord,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%chord,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%chord,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%chord,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%chord)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%chord))-1 ) = PACK(InData%chord,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%chord)
    END IF
        IntKiBuf ( Int_Xferred:Int_Xferred+(1)-1 ) = InData%numBlades
        Int_Xferred   = Int_Xferred   + 1
        ReKiBuf ( Re_Xferred:Re_Xferred+(1)-1 ) = InData%airDens
        Re_Xferred   = Re_Xferred   + 1
        ReKiBuf ( Re_Xferred:Re_Xferred+(1)-1 ) = InData%kinVisc
        Re_Xferred   = Re_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+(1)-1 ) = InData%skewWakeMod
        Int_Xferred   = Int_Xferred   + 1
        ReKiBuf ( Re_Xferred:Re_Xferred+(1)-1 ) = InData%aTol
        Re_Xferred   = Re_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%useTipLoss , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%useHubLoss , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%useInduction , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%useTanInd , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%useAIDrag , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%useTIDrag , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+(1)-1 ) = InData%numBladeNodes
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+(1)-1 ) = InData%numReIterations
        Int_Xferred   = Int_Xferred   + 1
        IntKiBuf ( Int_Xferred:Int_Xferred+(1)-1 ) = InData%maxIndIterations
        Int_Xferred   = Int_Xferred   + 1
    IF ( .NOT. ALLOCATED(InData%AFindx) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%AFindx,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%AFindx,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%AFindx,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%AFindx,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%AFindx)>0) IntKiBuf ( Int_Xferred:Int_Xferred+(SIZE(InData%AFindx))-1 ) = PACK(InData%AFindx,.TRUE.)
        Int_Xferred   = Int_Xferred   + SIZE(InData%AFindx)
    END IF
    IF ( .NOT. ALLOCATED(InData%tipLossConst) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%tipLossConst,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%tipLossConst,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%tipLossConst,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%tipLossConst,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%tipLossConst)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%tipLossConst))-1 ) = PACK(InData%tipLossConst,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%tipLossConst)
    END IF
    IF ( .NOT. ALLOCATED(InData%hubLossConst) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%hubLossConst,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%hubLossConst,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%hubLossConst,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%hubLossConst,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%hubLossConst)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%hubLossConst))-1 ) = PACK(InData%hubLossConst,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%hubLossConst)
    END IF
    IF ( .NOT. ALLOCATED(InData%zHub) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%zHub,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%zHub,1)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%zHub)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%zHub))-1 ) = PACK(InData%zHub,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%zHub)
    END IF
        CALL UA_PackParam( Re_Buf, Db_Buf, Int_Buf, InData%UA, ErrStat2, ErrMsg2, OnlySize ) ! UA 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Re_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Re_Buf) > 0) ReKiBuf( Re_Xferred:Re_Xferred+SIZE(Re_Buf)-1 ) = Re_Buf
          Re_Xferred = Re_Xferred + SIZE(Re_Buf)
          DEALLOCATE(Re_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
        IF(ALLOCATED(Db_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Db_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Db_Buf) > 0) DbKiBuf( Db_Xferred:Db_Xferred+SIZE(Db_Buf)-1 ) = Db_Buf
          Db_Xferred = Db_Xferred + SIZE(Db_Buf)
          DEALLOCATE(Db_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
        IF(ALLOCATED(Int_Buf)) THEN
          IntKiBuf( Int_Xferred ) = SIZE(Int_Buf); Int_Xferred = Int_Xferred + 1
          IF (SIZE(Int_Buf) > 0) IntKiBuf( Int_Xferred:Int_Xferred+SIZE(Int_Buf)-1 ) = Int_Buf
          Int_Xferred = Int_Xferred + SIZE(Int_Buf)
          DEALLOCATE(Int_Buf)
        ELSE
          IntKiBuf( Int_Xferred ) = 0; Int_Xferred = Int_Xferred + 1
        ENDIF
        IntKiBuf ( Int_Xferred:Int_Xferred+1-1 ) = TRANSFER( InData%UA_Flag , IntKiBuf(1), 1)
        Int_Xferred   = Int_Xferred   + 1
   END SUBROUTINE BEMT_PackParam
  
   SUBROUTINE BEMT_UnPackParam( ReKiBuf, DbKiBuf, IntKiBuf, Outdata, ErrStat, ErrMsg )
    REAL(ReKi),      ALLOCATABLE, INTENT(IN   ) :: ReKiBuf(:)
    REAL(DbKi),      ALLOCATABLE, INTENT(IN   ) :: DbKiBuf(:)
    INTEGER(IntKi),  ALLOCATABLE, INTENT(IN   ) :: IntKiBuf(:)
    TYPE(BEMT_ParameterType), INTENT(INOUT) :: OutData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
      ! Local variables
    INTEGER(IntKi)                 :: Buf_size
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i
    LOGICAL                        :: mask0
    LOGICAL, ALLOCATABLE           :: mask1(:)
    LOGICAL, ALLOCATABLE           :: mask2(:,:)
    LOGICAL, ALLOCATABLE           :: mask3(:,:,:)
    LOGICAL, ALLOCATABLE           :: mask4(:,:,:,:)
    LOGICAL, ALLOCATABLE           :: mask5(:,:,:,:,:)
    INTEGER(IntKi)                 :: i1, i1_l, i1_u  !  bounds (upper/lower) for an array dimension 1
    INTEGER(IntKi)                 :: i2, i2_l, i2_u  !  bounds (upper/lower) for an array dimension 2
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_UnPackParam'
   ! buffers to store meshes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred  = 1
        OutData%DT = DbKiBuf( Db_Xferred ) 
        Db_Xferred   = Db_Xferred + 1
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! chord not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%chord)) DEALLOCATE(OutData%chord)
      ALLOCATE(OutData%chord(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%chord.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%chord)>0) OutData%chord = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%chord))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%chord)
      DEALLOCATE(mask2)
    END IF
        OutData%numBlades = IntKiBuf( Int_Xferred ) 
        Int_Xferred   = Int_Xferred + 1
        OutData%airDens = ReKiBuf( Re_Xferred )
        Re_Xferred   = Re_Xferred + 1
        OutData%kinVisc = ReKiBuf( Re_Xferred )
        Re_Xferred   = Re_Xferred + 1
        OutData%skewWakeMod = IntKiBuf( Int_Xferred ) 
        Int_Xferred   = Int_Xferred + 1
        OutData%aTol = ReKiBuf( Re_Xferred )
        Re_Xferred   = Re_Xferred + 1
        OutData%useTipLoss = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
        OutData%useHubLoss = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
        OutData%useInduction = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
        OutData%useTanInd = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
        OutData%useAIDrag = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
        OutData%useTIDrag = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
        OutData%numBladeNodes = IntKiBuf( Int_Xferred ) 
        Int_Xferred   = Int_Xferred + 1
        OutData%numReIterations = IntKiBuf( Int_Xferred ) 
        Int_Xferred   = Int_Xferred + 1
        OutData%maxIndIterations = IntKiBuf( Int_Xferred ) 
        Int_Xferred   = Int_Xferred + 1
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! AFindx not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%AFindx)) DEALLOCATE(OutData%AFindx)
      ALLOCATE(OutData%AFindx(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%AFindx.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%AFindx)>0) OutData%AFindx = UNPACK( IntKiBuf ( Int_Xferred:Int_Xferred+(SIZE(OutData%AFindx))-1 ), mask2, 0_IntKi )
        Int_Xferred   = Int_Xferred   + SIZE(OutData%AFindx)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! tipLossConst not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%tipLossConst)) DEALLOCATE(OutData%tipLossConst)
      ALLOCATE(OutData%tipLossConst(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%tipLossConst.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%tipLossConst)>0) OutData%tipLossConst = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%tipLossConst))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%tipLossConst)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! hubLossConst not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%hubLossConst)) DEALLOCATE(OutData%hubLossConst)
      ALLOCATE(OutData%hubLossConst(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%hubLossConst.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%hubLossConst)>0) OutData%hubLossConst = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%hubLossConst))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%hubLossConst)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! zHub not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%zHub)) DEALLOCATE(OutData%zHub)
      ALLOCATE(OutData%zHub(i1_l:i1_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%zHub.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask1(i1_l:i1_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask1.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask1 = .TRUE. 
        IF (SIZE(OutData%zHub)>0) OutData%zHub = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%zHub))-1 ), mask1, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%zHub)
      DEALLOCATE(mask1)
    END IF
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Re_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Re_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Re_Buf = ReKiBuf( Re_Xferred:Re_Xferred+Buf_size-1 )
          Re_Xferred = Re_Xferred + Buf_size
        END IF
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Db_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Db_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Db_Buf = DbKiBuf( Db_Xferred:Db_Xferred+Buf_size-1 )
          Db_Xferred = Db_Xferred + Buf_size
        END IF
        Buf_size=IntKiBuf( Int_Xferred )
        Int_Xferred = Int_Xferred + 1
        IF(Buf_size > 0) THEN
          ALLOCATE(Int_Buf(Buf_size),STAT=ErrStat2)
          IF (ErrStat2 /= 0) THEN 
             CALL SetErrStat(ErrID_Fatal, 'Error allocating Int_Buf.', ErrStat, ErrMsg,RoutineName)
             RETURN
          END IF
          Int_Buf = IntKiBuf( Int_Xferred:Int_Xferred+Buf_size-1 )
          Int_Xferred = Int_Xferred + Buf_size
        END IF
        CALL UA_UnpackParam( Re_Buf, Db_Buf, Int_Buf, OutData%UA, ErrStat2, ErrMsg2 ) ! UA 
          CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg, RoutineName)
          IF (ErrStat >= AbortErrLev) RETURN
  
        IF(ALLOCATED(Re_Buf )) DEALLOCATE(Re_Buf )
        IF(ALLOCATED(Db_Buf )) DEALLOCATE(Db_Buf )
        IF(ALLOCATED(Int_Buf)) DEALLOCATE(Int_Buf)
        OutData%UA_Flag = TRANSFER( IntKiBuf( Int_Xferred ), mask0 )
        Int_Xferred   = Int_Xferred + 1
   END SUBROUTINE BEMT_UnPackParam
  
   SUBROUTINE BEMT_CopyInput( SrcInputData, DstInputData, CtrlCode, ErrStat, ErrMsg )
     TYPE(BEMT_InputType), INTENT(IN) :: SrcInputData
     TYPE(BEMT_InputType), INTENT(INOUT) :: DstInputData
     INTEGER(IntKi),  INTENT(IN   ) :: CtrlCode
     INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
     CHARACTER(*),    INTENT(  OUT) :: ErrMsg
  ! Local 
     INTEGER(IntKi)                 :: i,j,k
     INTEGER(IntKi)                 :: i1, i1_l, i1_u  !  bounds (upper/lower) for an array dimension 1
     INTEGER(IntKi)                 :: i2, i2_l, i2_u  !  bounds (upper/lower) for an array dimension 2
     INTEGER(IntKi)                 :: ErrStat2
     CHARACTER(ErrMsgLen)           :: ErrMsg2
     CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_CopyInput'
  ! 
     ErrStat = ErrID_None
     ErrMsg  = ""
  IF (ALLOCATED(SrcInputData%theta)) THEN
    i1_l = LBOUND(SrcInputData%theta,1)
    i1_u = UBOUND(SrcInputData%theta,1)
    i2_l = LBOUND(SrcInputData%theta,2)
    i2_u = UBOUND(SrcInputData%theta,2)
    IF (.NOT. ALLOCATED(DstInputData%theta)) THEN 
      ALLOCATE(DstInputData%theta(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstInputData%theta.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstInputData%theta = SrcInputData%theta
  ENDIF
      DstInputData%chi0 = SrcInputData%chi0
  IF (ALLOCATED(SrcInputData%psi)) THEN
    i1_l = LBOUND(SrcInputData%psi,1)
    i1_u = UBOUND(SrcInputData%psi,1)
    IF (.NOT. ALLOCATED(DstInputData%psi)) THEN 
      ALLOCATE(DstInputData%psi(i1_l:i1_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstInputData%psi.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstInputData%psi = SrcInputData%psi
  ENDIF
      DstInputData%omega = SrcInputData%omega
  IF (ALLOCATED(SrcInputData%Vx)) THEN
    i1_l = LBOUND(SrcInputData%Vx,1)
    i1_u = UBOUND(SrcInputData%Vx,1)
    i2_l = LBOUND(SrcInputData%Vx,2)
    i2_u = UBOUND(SrcInputData%Vx,2)
    IF (.NOT. ALLOCATED(DstInputData%Vx)) THEN 
      ALLOCATE(DstInputData%Vx(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstInputData%Vx.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstInputData%Vx = SrcInputData%Vx
  ENDIF
  IF (ALLOCATED(SrcInputData%Vy)) THEN
    i1_l = LBOUND(SrcInputData%Vy,1)
    i1_u = UBOUND(SrcInputData%Vy,1)
    i2_l = LBOUND(SrcInputData%Vy,2)
    i2_u = UBOUND(SrcInputData%Vy,2)
    IF (.NOT. ALLOCATED(DstInputData%Vy)) THEN 
      ALLOCATE(DstInputData%Vy(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstInputData%Vy.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstInputData%Vy = SrcInputData%Vy
  ENDIF
  IF (ALLOCATED(SrcInputData%rLocal)) THEN
    i1_l = LBOUND(SrcInputData%rLocal,1)
    i1_u = UBOUND(SrcInputData%rLocal,1)
    i2_l = LBOUND(SrcInputData%rLocal,2)
    i2_u = UBOUND(SrcInputData%rLocal,2)
    IF (.NOT. ALLOCATED(DstInputData%rLocal)) THEN 
      ALLOCATE(DstInputData%rLocal(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstInputData%rLocal.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstInputData%rLocal = SrcInputData%rLocal
  ENDIF
   END SUBROUTINE BEMT_CopyInput
  
   SUBROUTINE BEMT_DestroyInput( InputData, ErrStat, ErrMsg )
    TYPE(BEMT_InputType), INTENT(INOUT) :: InputData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
    CHARACTER(*),    PARAMETER :: RoutineName = 'BEMT_DestroyInput'
    INTEGER(IntKi)                 :: i, i1, i2, i3, i4, i5 
  ! 
    ErrStat = ErrID_None
    ErrMsg  = ""
  IF (ALLOCATED(InputData%theta)) THEN
    DEALLOCATE(InputData%theta)
  ENDIF
  IF (ALLOCATED(InputData%psi)) THEN
    DEALLOCATE(InputData%psi)
  ENDIF
  IF (ALLOCATED(InputData%Vx)) THEN
    DEALLOCATE(InputData%Vx)
  ENDIF
  IF (ALLOCATED(InputData%Vy)) THEN
    DEALLOCATE(InputData%Vy)
  ENDIF
  IF (ALLOCATED(InputData%rLocal)) THEN
    DEALLOCATE(InputData%rLocal)
  ENDIF
   END SUBROUTINE BEMT_DestroyInput
  
   SUBROUTINE BEMT_PackInput( ReKiBuf, DbKiBuf, IntKiBuf, Indata, ErrStat, ErrMsg, SizeOnly )
    REAL(ReKi),       ALLOCATABLE, INTENT(  OUT) :: ReKiBuf(:)
    REAL(DbKi),       ALLOCATABLE, INTENT(  OUT) :: DbKiBuf(:)
    INTEGER(IntKi),   ALLOCATABLE, INTENT(  OUT) :: IntKiBuf(:)
    TYPE(BEMT_InputType),  INTENT(IN) :: InData
    INTEGER(IntKi),   INTENT(  OUT) :: ErrStat
    CHARACTER(*),     INTENT(  OUT) :: ErrMsg
    LOGICAL,OPTIONAL, INTENT(IN   ) :: SizeOnly
      ! Local variables
    INTEGER(IntKi)                 :: Re_BufSz
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_BufSz
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_BufSz
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i,i1,i2,i3,i4,i5
    LOGICAL                        :: OnlySize ! if present and true, do not pack, just allocate buffers
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_PackInput'
   ! buffers to store subtypes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
  
    OnlySize = .FALSE.
    IF ( PRESENT(SizeOnly) ) THEN
      OnlySize = SizeOnly
    ENDIF
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_BufSz  = 0
    Db_BufSz  = 0
    Int_BufSz  = 0
    Int_BufSz   = Int_BufSz   + 1     ! theta allocated yes/no
    IF ( ALLOCATED(InData%theta) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! theta upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%theta)  ! theta
    END IF
        Re_BufSz   = Re_BufSz   + 1  ! chi0
    Int_BufSz   = Int_BufSz   + 1     ! psi allocated yes/no
    IF ( ALLOCATED(InData%psi) ) THEN
      Int_BufSz   = Int_BufSz   + 2*1  ! psi upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%psi)  ! psi
    END IF
        Re_BufSz   = Re_BufSz   + 1  ! omega
    Int_BufSz   = Int_BufSz   + 1     ! Vx allocated yes/no
    IF ( ALLOCATED(InData%Vx) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! Vx upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%Vx)  ! Vx
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! Vy allocated yes/no
    IF ( ALLOCATED(InData%Vy) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! Vy upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%Vy)  ! Vy
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! rLocal allocated yes/no
    IF ( ALLOCATED(InData%rLocal) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! rLocal upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%rLocal)  ! rLocal
    END IF
    IF ( Re_BufSz  .GT. 0 ) THEN 
       ALLOCATE( ReKiBuf(  Re_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating ReKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Db_BufSz  .GT. 0 ) THEN 
       ALLOCATE( DbKiBuf(  Db_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating DbKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Int_BufSz  .GT. 0 ) THEN 
       ALLOCATE( IntKiBuf(  Int_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating IntKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF(OnlySize) RETURN ! return early if only trying to allocate buffers (not pack them)
  
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred = 1
  
    IF ( .NOT. ALLOCATED(InData%theta) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%theta,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%theta,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%theta,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%theta,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%theta)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%theta))-1 ) = PACK(InData%theta,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%theta)
    END IF
        ReKiBuf ( Re_Xferred:Re_Xferred+(1)-1 ) = InData%chi0
        Re_Xferred   = Re_Xferred   + 1
    IF ( .NOT. ALLOCATED(InData%psi) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%psi,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%psi,1)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%psi)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%psi))-1 ) = PACK(InData%psi,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%psi)
    END IF
        ReKiBuf ( Re_Xferred:Re_Xferred+(1)-1 ) = InData%omega
        Re_Xferred   = Re_Xferred   + 1
    IF ( .NOT. ALLOCATED(InData%Vx) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Vx,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Vx,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Vx,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Vx,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%Vx)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%Vx))-1 ) = PACK(InData%Vx,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%Vx)
    END IF
    IF ( .NOT. ALLOCATED(InData%Vy) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Vy,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Vy,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Vy,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Vy,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%Vy)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%Vy))-1 ) = PACK(InData%Vy,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%Vy)
    END IF
    IF ( .NOT. ALLOCATED(InData%rLocal) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%rLocal,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%rLocal,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%rLocal,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%rLocal,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%rLocal)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%rLocal))-1 ) = PACK(InData%rLocal,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%rLocal)
    END IF
   END SUBROUTINE BEMT_PackInput
  
   SUBROUTINE BEMT_UnPackInput( ReKiBuf, DbKiBuf, IntKiBuf, Outdata, ErrStat, ErrMsg )
    REAL(ReKi),      ALLOCATABLE, INTENT(IN   ) :: ReKiBuf(:)
    REAL(DbKi),      ALLOCATABLE, INTENT(IN   ) :: DbKiBuf(:)
    INTEGER(IntKi),  ALLOCATABLE, INTENT(IN   ) :: IntKiBuf(:)
    TYPE(BEMT_InputType), INTENT(INOUT) :: OutData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
      ! Local variables
    INTEGER(IntKi)                 :: Buf_size
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i
    LOGICAL                        :: mask0
    LOGICAL, ALLOCATABLE           :: mask1(:)
    LOGICAL, ALLOCATABLE           :: mask2(:,:)
    LOGICAL, ALLOCATABLE           :: mask3(:,:,:)
    LOGICAL, ALLOCATABLE           :: mask4(:,:,:,:)
    LOGICAL, ALLOCATABLE           :: mask5(:,:,:,:,:)
    INTEGER(IntKi)                 :: i1, i1_l, i1_u  !  bounds (upper/lower) for an array dimension 1
    INTEGER(IntKi)                 :: i2, i2_l, i2_u  !  bounds (upper/lower) for an array dimension 2
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_UnPackInput'
   ! buffers to store meshes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred  = 1
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! theta not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%theta)) DEALLOCATE(OutData%theta)
      ALLOCATE(OutData%theta(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%theta.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%theta)>0) OutData%theta = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%theta))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%theta)
      DEALLOCATE(mask2)
    END IF
        OutData%chi0 = ReKiBuf( Re_Xferred )
        Re_Xferred   = Re_Xferred + 1
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! psi not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%psi)) DEALLOCATE(OutData%psi)
      ALLOCATE(OutData%psi(i1_l:i1_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%psi.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask1(i1_l:i1_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask1.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask1 = .TRUE. 
        IF (SIZE(OutData%psi)>0) OutData%psi = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%psi))-1 ), mask1, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%psi)
      DEALLOCATE(mask1)
    END IF
        OutData%omega = ReKiBuf( Re_Xferred )
        Re_Xferred   = Re_Xferred + 1
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! Vx not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%Vx)) DEALLOCATE(OutData%Vx)
      ALLOCATE(OutData%Vx(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%Vx.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%Vx)>0) OutData%Vx = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%Vx))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%Vx)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! Vy not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%Vy)) DEALLOCATE(OutData%Vy)
      ALLOCATE(OutData%Vy(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%Vy.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%Vy)>0) OutData%Vy = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%Vy))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%Vy)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! rLocal not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%rLocal)) DEALLOCATE(OutData%rLocal)
      ALLOCATE(OutData%rLocal(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%rLocal.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%rLocal)>0) OutData%rLocal = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%rLocal))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%rLocal)
      DEALLOCATE(mask2)
    END IF
   END SUBROUTINE BEMT_UnPackInput
  
   SUBROUTINE BEMT_CopyOutput( SrcOutputData, DstOutputData, CtrlCode, ErrStat, ErrMsg )
     TYPE(BEMT_OutputType), INTENT(IN) :: SrcOutputData
     TYPE(BEMT_OutputType), INTENT(INOUT) :: DstOutputData
     INTEGER(IntKi),  INTENT(IN   ) :: CtrlCode
     INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
     CHARACTER(*),    INTENT(  OUT) :: ErrMsg
  ! Local 
     INTEGER(IntKi)                 :: i,j,k
     INTEGER(IntKi)                 :: i1, i1_l, i1_u  !  bounds (upper/lower) for an array dimension 1
     INTEGER(IntKi)                 :: i2, i2_l, i2_u  !  bounds (upper/lower) for an array dimension 2
     INTEGER(IntKi)                 :: ErrStat2
     CHARACTER(ErrMsgLen)           :: ErrMsg2
     CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_CopyOutput'
  ! 
     ErrStat = ErrID_None
     ErrMsg  = ""
  IF (ALLOCATED(SrcOutputData%Vrel)) THEN
    i1_l = LBOUND(SrcOutputData%Vrel,1)
    i1_u = UBOUND(SrcOutputData%Vrel,1)
    i2_l = LBOUND(SrcOutputData%Vrel,2)
    i2_u = UBOUND(SrcOutputData%Vrel,2)
    IF (.NOT. ALLOCATED(DstOutputData%Vrel)) THEN 
      ALLOCATE(DstOutputData%Vrel(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstOutputData%Vrel.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstOutputData%Vrel = SrcOutputData%Vrel
  ENDIF
  IF (ALLOCATED(SrcOutputData%phi)) THEN
    i1_l = LBOUND(SrcOutputData%phi,1)
    i1_u = UBOUND(SrcOutputData%phi,1)
    i2_l = LBOUND(SrcOutputData%phi,2)
    i2_u = UBOUND(SrcOutputData%phi,2)
    IF (.NOT. ALLOCATED(DstOutputData%phi)) THEN 
      ALLOCATE(DstOutputData%phi(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstOutputData%phi.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstOutputData%phi = SrcOutputData%phi
  ENDIF
  IF (ALLOCATED(SrcOutputData%axInduction)) THEN
    i1_l = LBOUND(SrcOutputData%axInduction,1)
    i1_u = UBOUND(SrcOutputData%axInduction,1)
    i2_l = LBOUND(SrcOutputData%axInduction,2)
    i2_u = UBOUND(SrcOutputData%axInduction,2)
    IF (.NOT. ALLOCATED(DstOutputData%axInduction)) THEN 
      ALLOCATE(DstOutputData%axInduction(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstOutputData%axInduction.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstOutputData%axInduction = SrcOutputData%axInduction
  ENDIF
  IF (ALLOCATED(SrcOutputData%tanInduction)) THEN
    i1_l = LBOUND(SrcOutputData%tanInduction,1)
    i1_u = UBOUND(SrcOutputData%tanInduction,1)
    i2_l = LBOUND(SrcOutputData%tanInduction,2)
    i2_u = UBOUND(SrcOutputData%tanInduction,2)
    IF (.NOT. ALLOCATED(DstOutputData%tanInduction)) THEN 
      ALLOCATE(DstOutputData%tanInduction(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstOutputData%tanInduction.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstOutputData%tanInduction = SrcOutputData%tanInduction
  ENDIF
  IF (ALLOCATED(SrcOutputData%Re)) THEN
    i1_l = LBOUND(SrcOutputData%Re,1)
    i1_u = UBOUND(SrcOutputData%Re,1)
    i2_l = LBOUND(SrcOutputData%Re,2)
    i2_u = UBOUND(SrcOutputData%Re,2)
    IF (.NOT. ALLOCATED(DstOutputData%Re)) THEN 
      ALLOCATE(DstOutputData%Re(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstOutputData%Re.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstOutputData%Re = SrcOutputData%Re
  ENDIF
  IF (ALLOCATED(SrcOutputData%AOA)) THEN
    i1_l = LBOUND(SrcOutputData%AOA,1)
    i1_u = UBOUND(SrcOutputData%AOA,1)
    i2_l = LBOUND(SrcOutputData%AOA,2)
    i2_u = UBOUND(SrcOutputData%AOA,2)
    IF (.NOT. ALLOCATED(DstOutputData%AOA)) THEN 
      ALLOCATE(DstOutputData%AOA(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstOutputData%AOA.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstOutputData%AOA = SrcOutputData%AOA
  ENDIF
  IF (ALLOCATED(SrcOutputData%Cx)) THEN
    i1_l = LBOUND(SrcOutputData%Cx,1)
    i1_u = UBOUND(SrcOutputData%Cx,1)
    i2_l = LBOUND(SrcOutputData%Cx,2)
    i2_u = UBOUND(SrcOutputData%Cx,2)
    IF (.NOT. ALLOCATED(DstOutputData%Cx)) THEN 
      ALLOCATE(DstOutputData%Cx(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstOutputData%Cx.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstOutputData%Cx = SrcOutputData%Cx
  ENDIF
  IF (ALLOCATED(SrcOutputData%Cy)) THEN
    i1_l = LBOUND(SrcOutputData%Cy,1)
    i1_u = UBOUND(SrcOutputData%Cy,1)
    i2_l = LBOUND(SrcOutputData%Cy,2)
    i2_u = UBOUND(SrcOutputData%Cy,2)
    IF (.NOT. ALLOCATED(DstOutputData%Cy)) THEN 
      ALLOCATE(DstOutputData%Cy(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstOutputData%Cy.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstOutputData%Cy = SrcOutputData%Cy
  ENDIF
  IF (ALLOCATED(SrcOutputData%Cm)) THEN
    i1_l = LBOUND(SrcOutputData%Cm,1)
    i1_u = UBOUND(SrcOutputData%Cm,1)
    i2_l = LBOUND(SrcOutputData%Cm,2)
    i2_u = UBOUND(SrcOutputData%Cm,2)
    IF (.NOT. ALLOCATED(DstOutputData%Cm)) THEN 
      ALLOCATE(DstOutputData%Cm(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstOutputData%Cm.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstOutputData%Cm = SrcOutputData%Cm
  ENDIF
  IF (ALLOCATED(SrcOutputData%Cl)) THEN
    i1_l = LBOUND(SrcOutputData%Cl,1)
    i1_u = UBOUND(SrcOutputData%Cl,1)
    i2_l = LBOUND(SrcOutputData%Cl,2)
    i2_u = UBOUND(SrcOutputData%Cl,2)
    IF (.NOT. ALLOCATED(DstOutputData%Cl)) THEN 
      ALLOCATE(DstOutputData%Cl(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstOutputData%Cl.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstOutputData%Cl = SrcOutputData%Cl
  ENDIF
  IF (ALLOCATED(SrcOutputData%Cd)) THEN
    i1_l = LBOUND(SrcOutputData%Cd,1)
    i1_u = UBOUND(SrcOutputData%Cd,1)
    i2_l = LBOUND(SrcOutputData%Cd,2)
    i2_u = UBOUND(SrcOutputData%Cd,2)
    IF (.NOT. ALLOCATED(DstOutputData%Cd)) THEN 
      ALLOCATE(DstOutputData%Cd(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstOutputData%Cd.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstOutputData%Cd = SrcOutputData%Cd
  ENDIF
  IF (ALLOCATED(SrcOutputData%chi)) THEN
    i1_l = LBOUND(SrcOutputData%chi,1)
    i1_u = UBOUND(SrcOutputData%chi,1)
    i2_l = LBOUND(SrcOutputData%chi,2)
    i2_u = UBOUND(SrcOutputData%chi,2)
    IF (.NOT. ALLOCATED(DstOutputData%chi)) THEN 
      ALLOCATE(DstOutputData%chi(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
        CALL SetErrStat(ErrID_Fatal, 'Error allocating DstOutputData%chi.', ErrStat, ErrMsg,RoutineName)
        RETURN
      END IF
    END IF
      DstOutputData%chi = SrcOutputData%chi
  ENDIF
   END SUBROUTINE BEMT_CopyOutput
  
   SUBROUTINE BEMT_DestroyOutput( OutputData, ErrStat, ErrMsg )
    TYPE(BEMT_OutputType), INTENT(INOUT) :: OutputData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
    CHARACTER(*),    PARAMETER :: RoutineName = 'BEMT_DestroyOutput'
    INTEGER(IntKi)                 :: i, i1, i2, i3, i4, i5 
  ! 
    ErrStat = ErrID_None
    ErrMsg  = ""
  IF (ALLOCATED(OutputData%Vrel)) THEN
    DEALLOCATE(OutputData%Vrel)
  ENDIF
  IF (ALLOCATED(OutputData%phi)) THEN
    DEALLOCATE(OutputData%phi)
  ENDIF
  IF (ALLOCATED(OutputData%axInduction)) THEN
    DEALLOCATE(OutputData%axInduction)
  ENDIF
  IF (ALLOCATED(OutputData%tanInduction)) THEN
    DEALLOCATE(OutputData%tanInduction)
  ENDIF
  IF (ALLOCATED(OutputData%Re)) THEN
    DEALLOCATE(OutputData%Re)
  ENDIF
  IF (ALLOCATED(OutputData%AOA)) THEN
    DEALLOCATE(OutputData%AOA)
  ENDIF
  IF (ALLOCATED(OutputData%Cx)) THEN
    DEALLOCATE(OutputData%Cx)
  ENDIF
  IF (ALLOCATED(OutputData%Cy)) THEN
    DEALLOCATE(OutputData%Cy)
  ENDIF
  IF (ALLOCATED(OutputData%Cm)) THEN
    DEALLOCATE(OutputData%Cm)
  ENDIF
  IF (ALLOCATED(OutputData%Cl)) THEN
    DEALLOCATE(OutputData%Cl)
  ENDIF
  IF (ALLOCATED(OutputData%Cd)) THEN
    DEALLOCATE(OutputData%Cd)
  ENDIF
  IF (ALLOCATED(OutputData%chi)) THEN
    DEALLOCATE(OutputData%chi)
  ENDIF
   END SUBROUTINE BEMT_DestroyOutput
  
   SUBROUTINE BEMT_PackOutput( ReKiBuf, DbKiBuf, IntKiBuf, Indata, ErrStat, ErrMsg, SizeOnly )
    REAL(ReKi),       ALLOCATABLE, INTENT(  OUT) :: ReKiBuf(:)
    REAL(DbKi),       ALLOCATABLE, INTENT(  OUT) :: DbKiBuf(:)
    INTEGER(IntKi),   ALLOCATABLE, INTENT(  OUT) :: IntKiBuf(:)
    TYPE(BEMT_OutputType),  INTENT(IN) :: InData
    INTEGER(IntKi),   INTENT(  OUT) :: ErrStat
    CHARACTER(*),     INTENT(  OUT) :: ErrMsg
    LOGICAL,OPTIONAL, INTENT(IN   ) :: SizeOnly
      ! Local variables
    INTEGER(IntKi)                 :: Re_BufSz
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_BufSz
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_BufSz
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i,i1,i2,i3,i4,i5
    LOGICAL                        :: OnlySize ! if present and true, do not pack, just allocate buffers
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_PackOutput'
   ! buffers to store subtypes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
  
    OnlySize = .FALSE.
    IF ( PRESENT(SizeOnly) ) THEN
      OnlySize = SizeOnly
    ENDIF
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_BufSz  = 0
    Db_BufSz  = 0
    Int_BufSz  = 0
    Int_BufSz   = Int_BufSz   + 1     ! Vrel allocated yes/no
    IF ( ALLOCATED(InData%Vrel) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! Vrel upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%Vrel)  ! Vrel
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! phi allocated yes/no
    IF ( ALLOCATED(InData%phi) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! phi upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%phi)  ! phi
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! axInduction allocated yes/no
    IF ( ALLOCATED(InData%axInduction) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! axInduction upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%axInduction)  ! axInduction
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! tanInduction allocated yes/no
    IF ( ALLOCATED(InData%tanInduction) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! tanInduction upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%tanInduction)  ! tanInduction
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! Re allocated yes/no
    IF ( ALLOCATED(InData%Re) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! Re upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%Re)  ! Re
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! AOA allocated yes/no
    IF ( ALLOCATED(InData%AOA) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! AOA upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%AOA)  ! AOA
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! Cx allocated yes/no
    IF ( ALLOCATED(InData%Cx) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! Cx upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%Cx)  ! Cx
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! Cy allocated yes/no
    IF ( ALLOCATED(InData%Cy) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! Cy upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%Cy)  ! Cy
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! Cm allocated yes/no
    IF ( ALLOCATED(InData%Cm) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! Cm upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%Cm)  ! Cm
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! Cl allocated yes/no
    IF ( ALLOCATED(InData%Cl) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! Cl upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%Cl)  ! Cl
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! Cd allocated yes/no
    IF ( ALLOCATED(InData%Cd) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! Cd upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%Cd)  ! Cd
    END IF
    Int_BufSz   = Int_BufSz   + 1     ! chi allocated yes/no
    IF ( ALLOCATED(InData%chi) ) THEN
      Int_BufSz   = Int_BufSz   + 2*2  ! chi upper/lower bounds for each dimension
        Re_BufSz   = Re_BufSz   + SIZE(InData%chi)  ! chi
    END IF
    IF ( Re_BufSz  .GT. 0 ) THEN 
       ALLOCATE( ReKiBuf(  Re_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating ReKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Db_BufSz  .GT. 0 ) THEN 
       ALLOCATE( DbKiBuf(  Db_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating DbKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF ( Int_BufSz  .GT. 0 ) THEN 
       ALLOCATE( IntKiBuf(  Int_BufSz  ), STAT=ErrStat2 )
       IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating IntKiBuf.', ErrStat, ErrMsg,RoutineName)
         RETURN
       END IF
    END IF
    IF(OnlySize) RETURN ! return early if only trying to allocate buffers (not pack them)
  
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred = 1
  
    IF ( .NOT. ALLOCATED(InData%Vrel) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Vrel,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Vrel,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Vrel,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Vrel,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%Vrel)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%Vrel))-1 ) = PACK(InData%Vrel,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%Vrel)
    END IF
    IF ( .NOT. ALLOCATED(InData%phi) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%phi,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%phi,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%phi,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%phi,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%phi)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%phi))-1 ) = PACK(InData%phi,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%phi)
    END IF
    IF ( .NOT. ALLOCATED(InData%axInduction) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%axInduction,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%axInduction,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%axInduction,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%axInduction,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%axInduction)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%axInduction))-1 ) = PACK(InData%axInduction,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%axInduction)
    END IF
    IF ( .NOT. ALLOCATED(InData%tanInduction) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%tanInduction,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%tanInduction,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%tanInduction,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%tanInduction,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%tanInduction)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%tanInduction))-1 ) = PACK(InData%tanInduction,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%tanInduction)
    END IF
    IF ( .NOT. ALLOCATED(InData%Re) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Re,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Re,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Re,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Re,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%Re)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%Re))-1 ) = PACK(InData%Re,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%Re)
    END IF
    IF ( .NOT. ALLOCATED(InData%AOA) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%AOA,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%AOA,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%AOA,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%AOA,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%AOA)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%AOA))-1 ) = PACK(InData%AOA,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%AOA)
    END IF
    IF ( .NOT. ALLOCATED(InData%Cx) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Cx,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Cx,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Cx,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Cx,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%Cx)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%Cx))-1 ) = PACK(InData%Cx,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%Cx)
    END IF
    IF ( .NOT. ALLOCATED(InData%Cy) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Cy,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Cy,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Cy,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Cy,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%Cy)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%Cy))-1 ) = PACK(InData%Cy,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%Cy)
    END IF
    IF ( .NOT. ALLOCATED(InData%Cm) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Cm,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Cm,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Cm,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Cm,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%Cm)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%Cm))-1 ) = PACK(InData%Cm,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%Cm)
    END IF
    IF ( .NOT. ALLOCATED(InData%Cl) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Cl,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Cl,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Cl,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Cl,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%Cl)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%Cl))-1 ) = PACK(InData%Cl,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%Cl)
    END IF
    IF ( .NOT. ALLOCATED(InData%Cd) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Cd,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Cd,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%Cd,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%Cd,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%Cd)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%Cd))-1 ) = PACK(InData%Cd,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%Cd)
    END IF
    IF ( .NOT. ALLOCATED(InData%chi) ) THEN
      IntKiBuf( Int_Xferred ) = 0
      Int_Xferred = Int_Xferred + 1
    ELSE
      IntKiBuf( Int_Xferred ) = 1
      Int_Xferred = Int_Xferred + 1
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%chi,1)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%chi,1)
      Int_Xferred = Int_Xferred + 2
      IntKiBuf( Int_Xferred    ) = LBOUND(InData%chi,2)
      IntKiBuf( Int_Xferred + 1) = UBOUND(InData%chi,2)
      Int_Xferred = Int_Xferred + 2
  
        IF (SIZE(InData%chi)>0) ReKiBuf ( Re_Xferred:Re_Xferred+(SIZE(InData%chi))-1 ) = PACK(InData%chi,.TRUE.)
        Re_Xferred   = Re_Xferred   + SIZE(InData%chi)
    END IF
   END SUBROUTINE BEMT_PackOutput
  
   SUBROUTINE BEMT_UnPackOutput( ReKiBuf, DbKiBuf, IntKiBuf, Outdata, ErrStat, ErrMsg )
    REAL(ReKi),      ALLOCATABLE, INTENT(IN   ) :: ReKiBuf(:)
    REAL(DbKi),      ALLOCATABLE, INTENT(IN   ) :: DbKiBuf(:)
    INTEGER(IntKi),  ALLOCATABLE, INTENT(IN   ) :: IntKiBuf(:)
    TYPE(BEMT_OutputType), INTENT(INOUT) :: OutData
    INTEGER(IntKi),  INTENT(  OUT) :: ErrStat
    CHARACTER(*),    INTENT(  OUT) :: ErrMsg
      ! Local variables
    INTEGER(IntKi)                 :: Buf_size
    INTEGER(IntKi)                 :: Re_Xferred
    INTEGER(IntKi)                 :: Db_Xferred
    INTEGER(IntKi)                 :: Int_Xferred
    INTEGER(IntKi)                 :: i
    LOGICAL                        :: mask0
    LOGICAL, ALLOCATABLE           :: mask1(:)
    LOGICAL, ALLOCATABLE           :: mask2(:,:)
    LOGICAL, ALLOCATABLE           :: mask3(:,:,:)
    LOGICAL, ALLOCATABLE           :: mask4(:,:,:,:)
    LOGICAL, ALLOCATABLE           :: mask5(:,:,:,:,:)
    INTEGER(IntKi)                 :: i1, i1_l, i1_u  !  bounds (upper/lower) for an array dimension 1
    INTEGER(IntKi)                 :: i2, i2_l, i2_u  !  bounds (upper/lower) for an array dimension 2
    INTEGER(IntKi)                 :: ErrStat2
    CHARACTER(ErrMsgLen)           :: ErrMsg2
    CHARACTER(*), PARAMETER        :: RoutineName = 'BEMT_UnPackOutput'
   ! buffers to store meshes, if any
    REAL(ReKi),      ALLOCATABLE   :: Re_Buf(:)
    REAL(DbKi),      ALLOCATABLE   :: Db_Buf(:)
    INTEGER(IntKi),  ALLOCATABLE   :: Int_Buf(:)
      !
    ErrStat = ErrID_None
    ErrMsg  = ""
    Re_Xferred  = 1
    Db_Xferred  = 1
    Int_Xferred  = 1
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! Vrel not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%Vrel)) DEALLOCATE(OutData%Vrel)
      ALLOCATE(OutData%Vrel(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%Vrel.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%Vrel)>0) OutData%Vrel = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%Vrel))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%Vrel)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! phi not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%phi)) DEALLOCATE(OutData%phi)
      ALLOCATE(OutData%phi(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%phi.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%phi)>0) OutData%phi = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%phi))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%phi)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! axInduction not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%axInduction)) DEALLOCATE(OutData%axInduction)
      ALLOCATE(OutData%axInduction(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%axInduction.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%axInduction)>0) OutData%axInduction = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%axInduction))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%axInduction)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! tanInduction not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%tanInduction)) DEALLOCATE(OutData%tanInduction)
      ALLOCATE(OutData%tanInduction(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%tanInduction.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%tanInduction)>0) OutData%tanInduction = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%tanInduction))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%tanInduction)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! Re not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%Re)) DEALLOCATE(OutData%Re)
      ALLOCATE(OutData%Re(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%Re.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%Re)>0) OutData%Re = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%Re))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%Re)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! AOA not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%AOA)) DEALLOCATE(OutData%AOA)
      ALLOCATE(OutData%AOA(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%AOA.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%AOA)>0) OutData%AOA = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%AOA))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%AOA)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! Cx not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%Cx)) DEALLOCATE(OutData%Cx)
      ALLOCATE(OutData%Cx(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%Cx.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%Cx)>0) OutData%Cx = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%Cx))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%Cx)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! Cy not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%Cy)) DEALLOCATE(OutData%Cy)
      ALLOCATE(OutData%Cy(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%Cy.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%Cy)>0) OutData%Cy = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%Cy))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%Cy)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! Cm not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%Cm)) DEALLOCATE(OutData%Cm)
      ALLOCATE(OutData%Cm(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%Cm.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%Cm)>0) OutData%Cm = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%Cm))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%Cm)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! Cl not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%Cl)) DEALLOCATE(OutData%Cl)
      ALLOCATE(OutData%Cl(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%Cl.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%Cl)>0) OutData%Cl = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%Cl))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%Cl)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! Cd not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%Cd)) DEALLOCATE(OutData%Cd)
      ALLOCATE(OutData%Cd(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%Cd.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%Cd)>0) OutData%Cd = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%Cd))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%Cd)
      DEALLOCATE(mask2)
    END IF
    IF ( IntKiBuf( Int_Xferred ) == 0 ) THEN  ! chi not allocated
      Int_Xferred = Int_Xferred + 1
    ELSE
      Int_Xferred = Int_Xferred + 1
      i1_l = IntKiBuf( Int_Xferred    )
      i1_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      i2_l = IntKiBuf( Int_Xferred    )
      i2_u = IntKiBuf( Int_Xferred + 1)
      Int_Xferred = Int_Xferred + 2
      IF (ALLOCATED(OutData%chi)) DEALLOCATE(OutData%chi)
      ALLOCATE(OutData%chi(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating OutData%chi.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      ALLOCATE(mask2(i1_l:i1_u,i2_l:i2_u),STAT=ErrStat2)
      IF (ErrStat2 /= 0) THEN 
         CALL SetErrStat(ErrID_Fatal, 'Error allocating mask2.', ErrStat, ErrMsg,RoutineName)
         RETURN
      END IF
      mask2 = .TRUE. 
        IF (SIZE(OutData%chi)>0) OutData%chi = UNPACK(ReKiBuf( Re_Xferred:Re_Xferred+(SIZE(OutData%chi))-1 ), mask2, 0.0_ReKi )
        Re_Xferred   = Re_Xferred   + SIZE(OutData%chi)
      DEALLOCATE(mask2)
    END IF
   END SUBROUTINE BEMT_UnPackOutput
  
  
   SUBROUTINE BEMT_Input_ExtrapInterp(u, t, u_out, t_out, ErrStat, ErrMsg )
  !
  ! This subroutine calculates a extrapolated (or interpolated) Input u_out at time t_out, from previous/future time
  ! values of u (which has values associated with times in t).  Order of the interpolation is given by the size of u
  !
  !  expressions below based on either
  !
  !  f(t) = a
  !  f(t) = a + b * t, or
  !  f(t) = a + b * t + c * t**2
  !
  !  where a, b and c are determined as the solution to
  !  f(t1) = u1, f(t2) = u2, f(t3) = u3  (as appropriate)
  !
  !..................................................................................................................................
  
   TYPE(BEMT_InputType), INTENT(INOUT)  :: u(:) ! Input at t1 > t2 > t3
   REAL(DbKi),                 INTENT(IN   )  :: t(:)           ! Times associated with the Inputs
   TYPE(BEMT_InputType), INTENT(INOUT)  :: u_out ! Input at tin_out
   REAL(DbKi),                 INTENT(IN   )  :: t_out           ! time to be extrap/interp'd to
   INTEGER(IntKi),             INTENT(  OUT)  :: ErrStat         ! Error status of the operation
   CHARACTER(*),               INTENT(  OUT)  :: ErrMsg          ! Error message if ErrStat /= ErrID_None
     ! local variables
   INTEGER(IntKi)                             :: order           ! order of polynomial fit (max 2)
   INTEGER(IntKi)                             :: ErrStat2        ! local errors
   CHARACTER(ErrMsgLen)                       :: ErrMsg2         ! local errors
   CHARACTER(*),    PARAMETER                 :: RoutineName = 'BEMT_Input_ExtrapInterp'
      ! Initialize ErrStat
   ErrStat = ErrID_None
   ErrMsg  = ""
   if ( size(t) .ne. size(u)) then
      CALL SetErrStat(ErrID_Fatal,'size(t) must equal size(u)',ErrStat,ErrMsg,RoutineName)
      RETURN
   endif
   order = SIZE(u) - 1
   IF ( order .eq. 0 ) THEN
     CALL BEMT_CopyInput(u(1), u_out, MESH_UPDATECOPY, ErrStat2, ErrMsg2 )
       CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg,RoutineName)
   ELSE IF ( order .eq. 1 ) THEN
     CALL BEMT_Input_ExtrapInterp1(u(1), u(2), t, u_out, t_out, ErrStat2, ErrMsg2 )
       CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg,RoutineName)
   ELSE IF ( order .eq. 2 ) THEN
     CALL BEMT_Input_ExtrapInterp2(u(1), u(2), u(3), t, u_out, t_out, ErrStat2, ErrMsg2 )
       CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg,RoutineName)
   ELSE 
     CALL SetErrStat(ErrID_Fatal,'size(u) must be less than 4 (order must be less than 3).',ErrStat,ErrMsg,RoutineName)
     RETURN
   ENDIF 
   END SUBROUTINE BEMT_Input_ExtrapInterp
  
  
   SUBROUTINE BEMT_Input_ExtrapInterp1(u1, u2, tin, u_out, tin_out, ErrStat, ErrMsg )
  !
  ! This subroutine calculates a extrapolated (or interpolated) Input u_out at time t_out, from previous/future time
  ! values of u (which has values associated with times in t).  Order of the interpolation is 1.
  !
  !  f(t) = a + b * t, or
  !
  !  where a and b are determined as the solution to
  !  f(t1) = u1, f(t2) = u2
  !
  !..................................................................................................................................
  
   TYPE(BEMT_InputType), INTENT(INOUT)  :: u1    ! Input at t1 > t2
   TYPE(BEMT_InputType), INTENT(INOUT)  :: u2    ! Input at t2 
   REAL(DbKi),         INTENT(IN   )          :: tin(2)   ! Times associated with the Inputs
   TYPE(BEMT_InputType), INTENT(INOUT)  :: u_out ! Input at tin_out
   REAL(DbKi),         INTENT(IN   )          :: tin_out  ! time to be extrap/interp'd to
   INTEGER(IntKi),     INTENT(  OUT)          :: ErrStat  ! Error status of the operation
   CHARACTER(*),       INTENT(  OUT)          :: ErrMsg   ! Error message if ErrStat /= ErrID_None
     ! local variables
   REAL(DbKi)                                 :: t(2)     ! Times associated with the Inputs
   REAL(DbKi)                                 :: t_out    ! Time to which to be extrap/interpd
   CHARACTER(*),                    PARAMETER :: RoutineName = 'BEMT_Input_ExtrapInterp1'
   REAL(DbKi)                                 :: b0       ! temporary for extrapolation/interpolation
   REAL(DbKi)                                 :: c0       ! temporary for extrapolation/interpolation
   REAL(DbKi),ALLOCATABLE,DIMENSION(:)        :: b1       ! temporary for extrapolation/interpolation
   REAL(DbKi),ALLOCATABLE,DIMENSION(:)        :: c1       ! temporary for extrapolation/interpolation
   REAL(DbKi),ALLOCATABLE,DIMENSION(:,:)      :: b2       ! temporary for extrapolation/interpolation
   REAL(DbKi),ALLOCATABLE,DIMENSION(:,:)      :: c2       ! temporary for extrapolation/interpolation
   INTEGER(IntKi)                             :: ErrStat2 ! local errors
   CHARACTER(ErrMsgLen)                       :: ErrMsg2  ! local errors
      ! Initialize ErrStat
   ErrStat = ErrID_None
   ErrMsg  = ""
      ! we'll subtract a constant from the times to resolve some 
      ! numerical issues when t gets large (and to simplify the equations)
   t = tin - tin(1)
   t_out = tin_out - tin(1)
  
     IF ( EqualRealNos( t(1), t(2) ) ) THEN
       CALL SetErrStat(ErrID_Fatal, 't(1) must not equal t(2) to avoid a division-by-zero error.', ErrStat, ErrMsg,RoutineName)
       RETURN
     END IF
  IF (ALLOCATED(u_out%theta) .AND. ALLOCATED(u1%theta)) THEN
    ALLOCATE(b2(SIZE(u_out%theta,1),SIZE(u_out%theta,2) ))
    ALLOCATE(c2(SIZE(u_out%theta,1),SIZE(u_out%theta,2) ))
    b2 = -(u1%theta - u2%theta)/t(2)
    u_out%theta = u1%theta + b2 * t_out
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
    b0 = -(u1%chi0 - u2%chi0)/t(2)
    u_out%chi0 = u1%chi0 + b0 * t_out
  IF (ALLOCATED(u_out%psi) .AND. ALLOCATED(u1%psi)) THEN
    ALLOCATE(b1(SIZE(u_out%psi,1)))
    ALLOCATE(c1(SIZE(u_out%psi,1)))
    b1 = -(u1%psi - u2%psi)/t(2)
    u_out%psi = u1%psi + b1 * t_out
    DEALLOCATE(b1)
    DEALLOCATE(c1)
  END IF ! check if allocated
    b0 = -(u1%omega - u2%omega)/t(2)
    u_out%omega = u1%omega + b0 * t_out
  IF (ALLOCATED(u_out%Vx) .AND. ALLOCATED(u1%Vx)) THEN
    ALLOCATE(b2(SIZE(u_out%Vx,1),SIZE(u_out%Vx,2) ))
    ALLOCATE(c2(SIZE(u_out%Vx,1),SIZE(u_out%Vx,2) ))
    b2 = -(u1%Vx - u2%Vx)/t(2)
    u_out%Vx = u1%Vx + b2 * t_out
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(u_out%Vy) .AND. ALLOCATED(u1%Vy)) THEN
    ALLOCATE(b2(SIZE(u_out%Vy,1),SIZE(u_out%Vy,2) ))
    ALLOCATE(c2(SIZE(u_out%Vy,1),SIZE(u_out%Vy,2) ))
    b2 = -(u1%Vy - u2%Vy)/t(2)
    u_out%Vy = u1%Vy + b2 * t_out
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(u_out%rLocal) .AND. ALLOCATED(u1%rLocal)) THEN
    ALLOCATE(b2(SIZE(u_out%rLocal,1),SIZE(u_out%rLocal,2) ))
    ALLOCATE(c2(SIZE(u_out%rLocal,1),SIZE(u_out%rLocal,2) ))
    b2 = -(u1%rLocal - u2%rLocal)/t(2)
    u_out%rLocal = u1%rLocal + b2 * t_out
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
   END SUBROUTINE BEMT_Input_ExtrapInterp1
  
  
   SUBROUTINE BEMT_Input_ExtrapInterp2(u1, u2, u3, tin, u_out, tin_out, ErrStat, ErrMsg )
  !
  ! This subroutine calculates a extrapolated (or interpolated) Input u_out at time t_out, from previous/future time
  ! values of u (which has values associated with times in t).  Order of the interpolation is 2.
  !
  !  expressions below based on either
  !
  !  f(t) = a + b * t + c * t**2
  !
  !  where a, b and c are determined as the solution to
  !  f(t1) = u1, f(t2) = u2, f(t3) = u3
  !
  !..................................................................................................................................
  
   TYPE(BEMT_InputType), INTENT(INOUT)  :: u1      ! Input at t1 > t2 > t3
   TYPE(BEMT_InputType), INTENT(INOUT)  :: u2      ! Input at t2 > t3
   TYPE(BEMT_InputType), INTENT(INOUT)  :: u3      ! Input at t3
   REAL(DbKi),                 INTENT(IN   )  :: tin(3)    ! Times associated with the Inputs
   TYPE(BEMT_InputType), INTENT(INOUT)  :: u_out     ! Input at tin_out
   REAL(DbKi),                 INTENT(IN   )  :: tin_out   ! time to be extrap/interp'd to
   INTEGER(IntKi),             INTENT(  OUT)  :: ErrStat   ! Error status of the operation
   CHARACTER(*),               INTENT(  OUT)  :: ErrMsg    ! Error message if ErrStat /= ErrID_None
     ! local variables
   REAL(DbKi)                                 :: t(3)      ! Times associated with the Inputs
   REAL(DbKi)                                 :: t_out     ! Time to which to be extrap/interpd
   INTEGER(IntKi)                             :: order     ! order of polynomial fit (max 2)
   REAL(DbKi)                                 :: b0       ! temporary for extrapolation/interpolation
   REAL(DbKi)                                 :: c0       ! temporary for extrapolation/interpolation
   REAL(DbKi),ALLOCATABLE,DIMENSION(:)        :: b1       ! temporary for extrapolation/interpolation
   REAL(DbKi),ALLOCATABLE,DIMENSION(:)        :: c1       ! temporary for extrapolation/interpolation
   REAL(DbKi),ALLOCATABLE,DIMENSION(:,:)      :: b2       ! temporary for extrapolation/interpolation
   REAL(DbKi),ALLOCATABLE,DIMENSION(:,:)      :: c2       ! temporary for extrapolation/interpolation
   INTEGER(IntKi)                             :: ErrStat2 ! local errors
   CHARACTER(ErrMsgLen)                       :: ErrMsg2  ! local errors
   CHARACTER(*),            PARAMETER         :: RoutineName = 'BEMT_Input_ExtrapInterp2'
      ! Initialize ErrStat
   ErrStat = ErrID_None
   ErrMsg  = ""
      ! we'll subtract a constant from the times to resolve some 
      ! numerical issues when t gets large (and to simplify the equations)
   t = tin - tin(1)
   t_out = tin_out - tin(1)
  
     IF ( EqualRealNos( t(1), t(2) ) ) THEN
       CALL SetErrStat(ErrID_Fatal, 't(1) must not equal t(2) to avoid a division-by-zero error.', ErrStat, ErrMsg,RoutineName)
       RETURN
     ELSE IF ( EqualRealNos( t(2), t(3) ) ) THEN
       CALL SetErrStat(ErrID_Fatal, 't(2) must not equal t(3) to avoid a division-by-zero error.', ErrStat, ErrMsg,RoutineName)
       RETURN
     ELSE IF ( EqualRealNos( t(1), t(3) ) ) THEN
       CALL SetErrStat(ErrID_Fatal, 't(1) must not equal t(3) to avoid a division-by-zero error.', ErrStat, ErrMsg,RoutineName)
       RETURN
     END IF
  IF (ALLOCATED(u_out%theta) .AND. ALLOCATED(u1%theta)) THEN
    ALLOCATE(b2(SIZE(u_out%theta,1),SIZE(u_out%theta,2) ))
    ALLOCATE(c2(SIZE(u_out%theta,1),SIZE(u_out%theta,2) ))
    b2 = (t(3)**2*(u1%theta - u2%theta) + t(2)**2*(-u1%theta + u3%theta))/(t(2)*t(3)*(t(2) - t(3)))
    c2 = ( (t(2)-t(3))*u1%theta + t(3)*u2%theta - t(2)*u3%theta ) / (t(2)*t(3)*(t(2) - t(3)))
    u_out%theta = u1%theta + b2 * t_out + c2 * t_out**2
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
    b0 = (t(3)**2*(u1%chi0 - u2%chi0) + t(2)**2*(-u1%chi0 + u3%chi0))/(t(2)*t(3)*(t(2) - t(3)))
    c0 = ( (t(2)-t(3))*u1%chi0 + t(3)*u2%chi0 - t(2)*u3%chi0 ) / (t(2)*t(3)*(t(2) - t(3)))
    u_out%chi0 = u1%chi0 + b0 * t_out + c0 * t_out**2
  IF (ALLOCATED(u_out%psi) .AND. ALLOCATED(u1%psi)) THEN
    ALLOCATE(b1(SIZE(u_out%psi,1)))
    ALLOCATE(c1(SIZE(u_out%psi,1)))
    b1 = (t(3)**2*(u1%psi - u2%psi) + t(2)**2*(-u1%psi + u3%psi))/(t(2)*t(3)*(t(2) - t(3)))
    c1 = ( (t(2)-t(3))*u1%psi + t(3)*u2%psi - t(2)*u3%psi ) / (t(2)*t(3)*(t(2) - t(3)))
    u_out%psi = u1%psi + b1 * t_out + c1 * t_out**2
    DEALLOCATE(b1)
    DEALLOCATE(c1)
  END IF ! check if allocated
    b0 = (t(3)**2*(u1%omega - u2%omega) + t(2)**2*(-u1%omega + u3%omega))/(t(2)*t(3)*(t(2) - t(3)))
    c0 = ( (t(2)-t(3))*u1%omega + t(3)*u2%omega - t(2)*u3%omega ) / (t(2)*t(3)*(t(2) - t(3)))
    u_out%omega = u1%omega + b0 * t_out + c0 * t_out**2
  IF (ALLOCATED(u_out%Vx) .AND. ALLOCATED(u1%Vx)) THEN
    ALLOCATE(b2(SIZE(u_out%Vx,1),SIZE(u_out%Vx,2) ))
    ALLOCATE(c2(SIZE(u_out%Vx,1),SIZE(u_out%Vx,2) ))
    b2 = (t(3)**2*(u1%Vx - u2%Vx) + t(2)**2*(-u1%Vx + u3%Vx))/(t(2)*t(3)*(t(2) - t(3)))
    c2 = ( (t(2)-t(3))*u1%Vx + t(3)*u2%Vx - t(2)*u3%Vx ) / (t(2)*t(3)*(t(2) - t(3)))
    u_out%Vx = u1%Vx + b2 * t_out + c2 * t_out**2
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(u_out%Vy) .AND. ALLOCATED(u1%Vy)) THEN
    ALLOCATE(b2(SIZE(u_out%Vy,1),SIZE(u_out%Vy,2) ))
    ALLOCATE(c2(SIZE(u_out%Vy,1),SIZE(u_out%Vy,2) ))
    b2 = (t(3)**2*(u1%Vy - u2%Vy) + t(2)**2*(-u1%Vy + u3%Vy))/(t(2)*t(3)*(t(2) - t(3)))
    c2 = ( (t(2)-t(3))*u1%Vy + t(3)*u2%Vy - t(2)*u3%Vy ) / (t(2)*t(3)*(t(2) - t(3)))
    u_out%Vy = u1%Vy + b2 * t_out + c2 * t_out**2
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(u_out%rLocal) .AND. ALLOCATED(u1%rLocal)) THEN
    ALLOCATE(b2(SIZE(u_out%rLocal,1),SIZE(u_out%rLocal,2) ))
    ALLOCATE(c2(SIZE(u_out%rLocal,1),SIZE(u_out%rLocal,2) ))
    b2 = (t(3)**2*(u1%rLocal - u2%rLocal) + t(2)**2*(-u1%rLocal + u3%rLocal))/(t(2)*t(3)*(t(2) - t(3)))
    c2 = ( (t(2)-t(3))*u1%rLocal + t(3)*u2%rLocal - t(2)*u3%rLocal ) / (t(2)*t(3)*(t(2) - t(3)))
    u_out%rLocal = u1%rLocal + b2 * t_out + c2 * t_out**2
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
   END SUBROUTINE BEMT_Input_ExtrapInterp2
  
  
   SUBROUTINE BEMT_Output_ExtrapInterp(y, t, y_out, t_out, ErrStat, ErrMsg )
  !
  ! This subroutine calculates a extrapolated (or interpolated) Output y_out at time t_out, from previous/future time
  ! values of y (which has values associated with times in t).  Order of the interpolation is given by the size of y
  !
  !  expressions below based on either
  !
  !  f(t) = a
  !  f(t) = a + b * t, or
  !  f(t) = a + b * t + c * t**2
  !
  !  where a, b and c are determined as the solution to
  !  f(t1) = y1, f(t2) = y2, f(t3) = y3  (as appropriate)
  !
  !..................................................................................................................................
  
   TYPE(BEMT_OutputType), INTENT(INOUT)  :: y(:) ! Output at t1 > t2 > t3
   REAL(DbKi),                 INTENT(IN   )  :: t(:)           ! Times associated with the Outputs
   TYPE(BEMT_OutputType), INTENT(INOUT)  :: y_out ! Output at tin_out
   REAL(DbKi),                 INTENT(IN   )  :: t_out           ! time to be extrap/interp'd to
   INTEGER(IntKi),             INTENT(  OUT)  :: ErrStat         ! Error status of the operation
   CHARACTER(*),               INTENT(  OUT)  :: ErrMsg          ! Error message if ErrStat /= ErrID_None
     ! local variables
   INTEGER(IntKi)                             :: order           ! order of polynomial fit (max 2)
   INTEGER(IntKi)                             :: ErrStat2        ! local errors
   CHARACTER(ErrMsgLen)                       :: ErrMsg2         ! local errors
   CHARACTER(*),    PARAMETER                 :: RoutineName = 'BEMT_Output_ExtrapInterp'
      ! Initialize ErrStat
   ErrStat = ErrID_None
   ErrMsg  = ""
   if ( size(t) .ne. size(y)) then
      CALL SetErrStat(ErrID_Fatal,'size(t) must equal size(y)',ErrStat,ErrMsg,RoutineName)
      RETURN
   endif
   order = SIZE(y) - 1
   IF ( order .eq. 0 ) THEN
     CALL BEMT_CopyOutput(y(1), y_out, MESH_UPDATECOPY, ErrStat2, ErrMsg2 )
       CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg,RoutineName)
   ELSE IF ( order .eq. 1 ) THEN
     CALL BEMT_Output_ExtrapInterp1(y(1), y(2), t, y_out, t_out, ErrStat2, ErrMsg2 )
       CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg,RoutineName)
   ELSE IF ( order .eq. 2 ) THEN
     CALL BEMT_Output_ExtrapInterp2(y(1), y(2), y(3), t, y_out, t_out, ErrStat2, ErrMsg2 )
       CALL SetErrStat(ErrStat2, ErrMsg2, ErrStat, ErrMsg,RoutineName)
   ELSE 
     CALL SetErrStat(ErrID_Fatal,'size(y) must be less than 4 (order must be less than 3).',ErrStat,ErrMsg,RoutineName)
     RETURN
   ENDIF 
   END SUBROUTINE BEMT_Output_ExtrapInterp
  
  
   SUBROUTINE BEMT_Output_ExtrapInterp1(y1, y2, tin, y_out, tin_out, ErrStat, ErrMsg )
  !
  ! This subroutine calculates a extrapolated (or interpolated) Output y_out at time t_out, from previous/future time
  ! values of y (which has values associated with times in t).  Order of the interpolation is 1.
  !
  !  f(t) = a + b * t, or
  !
  !  where a and b are determined as the solution to
  !  f(t1) = y1, f(t2) = y2
  !
  !..................................................................................................................................
  
   TYPE(BEMT_OutputType), INTENT(INOUT)  :: y1    ! Output at t1 > t2
   TYPE(BEMT_OutputType), INTENT(INOUT)  :: y2    ! Output at t2 
   REAL(DbKi),         INTENT(IN   )          :: tin(2)   ! Times associated with the Outputs
   TYPE(BEMT_OutputType), INTENT(INOUT)  :: y_out ! Output at tin_out
   REAL(DbKi),         INTENT(IN   )          :: tin_out  ! time to be extrap/interp'd to
   INTEGER(IntKi),     INTENT(  OUT)          :: ErrStat  ! Error status of the operation
   CHARACTER(*),       INTENT(  OUT)          :: ErrMsg   ! Error message if ErrStat /= ErrID_None
     ! local variables
   REAL(DbKi)                                 :: t(2)     ! Times associated with the Outputs
   REAL(DbKi)                                 :: t_out    ! Time to which to be extrap/interpd
   CHARACTER(*),                    PARAMETER :: RoutineName = 'BEMT_Output_ExtrapInterp1'
   REAL(DbKi)                                 :: b0       ! temporary for extrapolation/interpolation
   REAL(DbKi)                                 :: c0       ! temporary for extrapolation/interpolation
   REAL(DbKi),ALLOCATABLE,DIMENSION(:)        :: b1       ! temporary for extrapolation/interpolation
   REAL(DbKi),ALLOCATABLE,DIMENSION(:)        :: c1       ! temporary for extrapolation/interpolation
   REAL(DbKi),ALLOCATABLE,DIMENSION(:,:)      :: b2       ! temporary for extrapolation/interpolation
   REAL(DbKi),ALLOCATABLE,DIMENSION(:,:)      :: c2       ! temporary for extrapolation/interpolation
   INTEGER(IntKi)                             :: ErrStat2 ! local errors
   CHARACTER(ErrMsgLen)                       :: ErrMsg2  ! local errors
      ! Initialize ErrStat
   ErrStat = ErrID_None
   ErrMsg  = ""
      ! we'll subtract a constant from the times to resolve some 
      ! numerical issues when t gets large (and to simplify the equations)
   t = tin - tin(1)
   t_out = tin_out - tin(1)
  
     IF ( EqualRealNos( t(1), t(2) ) ) THEN
       CALL SetErrStat(ErrID_Fatal, 't(1) must not equal t(2) to avoid a division-by-zero error.', ErrStat, ErrMsg,RoutineName)
       RETURN
     END IF
  IF (ALLOCATED(y_out%Vrel) .AND. ALLOCATED(y1%Vrel)) THEN
    ALLOCATE(b2(SIZE(y_out%Vrel,1),SIZE(y_out%Vrel,2) ))
    ALLOCATE(c2(SIZE(y_out%Vrel,1),SIZE(y_out%Vrel,2) ))
    b2 = -(y1%Vrel - y2%Vrel)/t(2)
    y_out%Vrel = y1%Vrel + b2 * t_out
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%phi) .AND. ALLOCATED(y1%phi)) THEN
    ALLOCATE(b2(SIZE(y_out%phi,1),SIZE(y_out%phi,2) ))
    ALLOCATE(c2(SIZE(y_out%phi,1),SIZE(y_out%phi,2) ))
    b2 = -(y1%phi - y2%phi)/t(2)
    y_out%phi = y1%phi + b2 * t_out
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%axInduction) .AND. ALLOCATED(y1%axInduction)) THEN
    ALLOCATE(b2(SIZE(y_out%axInduction,1),SIZE(y_out%axInduction,2) ))
    ALLOCATE(c2(SIZE(y_out%axInduction,1),SIZE(y_out%axInduction,2) ))
    b2 = -(y1%axInduction - y2%axInduction)/t(2)
    y_out%axInduction = y1%axInduction + b2 * t_out
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%tanInduction) .AND. ALLOCATED(y1%tanInduction)) THEN
    ALLOCATE(b2(SIZE(y_out%tanInduction,1),SIZE(y_out%tanInduction,2) ))
    ALLOCATE(c2(SIZE(y_out%tanInduction,1),SIZE(y_out%tanInduction,2) ))
    b2 = -(y1%tanInduction - y2%tanInduction)/t(2)
    y_out%tanInduction = y1%tanInduction + b2 * t_out
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%Re) .AND. ALLOCATED(y1%Re)) THEN
    ALLOCATE(b2(SIZE(y_out%Re,1),SIZE(y_out%Re,2) ))
    ALLOCATE(c2(SIZE(y_out%Re,1),SIZE(y_out%Re,2) ))
    b2 = -(y1%Re - y2%Re)/t(2)
    y_out%Re = y1%Re + b2 * t_out
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%AOA) .AND. ALLOCATED(y1%AOA)) THEN
    ALLOCATE(b2(SIZE(y_out%AOA,1),SIZE(y_out%AOA,2) ))
    ALLOCATE(c2(SIZE(y_out%AOA,1),SIZE(y_out%AOA,2) ))
    b2 = -(y1%AOA - y2%AOA)/t(2)
    y_out%AOA = y1%AOA + b2 * t_out
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%Cx) .AND. ALLOCATED(y1%Cx)) THEN
    ALLOCATE(b2(SIZE(y_out%Cx,1),SIZE(y_out%Cx,2) ))
    ALLOCATE(c2(SIZE(y_out%Cx,1),SIZE(y_out%Cx,2) ))
    b2 = -(y1%Cx - y2%Cx)/t(2)
    y_out%Cx = y1%Cx + b2 * t_out
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%Cy) .AND. ALLOCATED(y1%Cy)) THEN
    ALLOCATE(b2(SIZE(y_out%Cy,1),SIZE(y_out%Cy,2) ))
    ALLOCATE(c2(SIZE(y_out%Cy,1),SIZE(y_out%Cy,2) ))
    b2 = -(y1%Cy - y2%Cy)/t(2)
    y_out%Cy = y1%Cy + b2 * t_out
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%Cm) .AND. ALLOCATED(y1%Cm)) THEN
    ALLOCATE(b2(SIZE(y_out%Cm,1),SIZE(y_out%Cm,2) ))
    ALLOCATE(c2(SIZE(y_out%Cm,1),SIZE(y_out%Cm,2) ))
    b2 = -(y1%Cm - y2%Cm)/t(2)
    y_out%Cm = y1%Cm + b2 * t_out
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%Cl) .AND. ALLOCATED(y1%Cl)) THEN
    ALLOCATE(b2(SIZE(y_out%Cl,1),SIZE(y_out%Cl,2) ))
    ALLOCATE(c2(SIZE(y_out%Cl,1),SIZE(y_out%Cl,2) ))
    b2 = -(y1%Cl - y2%Cl)/t(2)
    y_out%Cl = y1%Cl + b2 * t_out
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%Cd) .AND. ALLOCATED(y1%Cd)) THEN
    ALLOCATE(b2(SIZE(y_out%Cd,1),SIZE(y_out%Cd,2) ))
    ALLOCATE(c2(SIZE(y_out%Cd,1),SIZE(y_out%Cd,2) ))
    b2 = -(y1%Cd - y2%Cd)/t(2)
    y_out%Cd = y1%Cd + b2 * t_out
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%chi) .AND. ALLOCATED(y1%chi)) THEN
    ALLOCATE(b2(SIZE(y_out%chi,1),SIZE(y_out%chi,2) ))
    ALLOCATE(c2(SIZE(y_out%chi,1),SIZE(y_out%chi,2) ))
    b2 = -(y1%chi - y2%chi)/t(2)
    y_out%chi = y1%chi + b2 * t_out
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
   END SUBROUTINE BEMT_Output_ExtrapInterp1
  
  
   SUBROUTINE BEMT_Output_ExtrapInterp2(y1, y2, y3, tin, y_out, tin_out, ErrStat, ErrMsg )
  !
  ! This subroutine calculates a extrapolated (or interpolated) Output y_out at time t_out, from previous/future time
  ! values of y (which has values associated with times in t).  Order of the interpolation is 2.
  !
  !  expressions below based on either
  !
  !  f(t) = a + b * t + c * t**2
  !
  !  where a, b and c are determined as the solution to
  !  f(t1) = y1, f(t2) = y2, f(t3) = y3
  !
  !..................................................................................................................................
  
   TYPE(BEMT_OutputType), INTENT(INOUT)  :: y1      ! Output at t1 > t2 > t3
   TYPE(BEMT_OutputType), INTENT(INOUT)  :: y2      ! Output at t2 > t3
   TYPE(BEMT_OutputType), INTENT(INOUT)  :: y3      ! Output at t3
   REAL(DbKi),                 INTENT(IN   )  :: tin(3)    ! Times associated with the Outputs
   TYPE(BEMT_OutputType), INTENT(INOUT)  :: y_out     ! Output at tin_out
   REAL(DbKi),                 INTENT(IN   )  :: tin_out   ! time to be extrap/interp'd to
   INTEGER(IntKi),             INTENT(  OUT)  :: ErrStat   ! Error status of the operation
   CHARACTER(*),               INTENT(  OUT)  :: ErrMsg    ! Error message if ErrStat /= ErrID_None
     ! local variables
   REAL(DbKi)                                 :: t(3)      ! Times associated with the Outputs
   REAL(DbKi)                                 :: t_out     ! Time to which to be extrap/interpd
   INTEGER(IntKi)                             :: order     ! order of polynomial fit (max 2)
   REAL(DbKi)                                 :: b0       ! temporary for extrapolation/interpolation
   REAL(DbKi)                                 :: c0       ! temporary for extrapolation/interpolation
   REAL(DbKi),ALLOCATABLE,DIMENSION(:)        :: b1       ! temporary for extrapolation/interpolation
   REAL(DbKi),ALLOCATABLE,DIMENSION(:)        :: c1       ! temporary for extrapolation/interpolation
   REAL(DbKi),ALLOCATABLE,DIMENSION(:,:)      :: b2       ! temporary for extrapolation/interpolation
   REAL(DbKi),ALLOCATABLE,DIMENSION(:,:)      :: c2       ! temporary for extrapolation/interpolation
   INTEGER(IntKi)                             :: ErrStat2 ! local errors
   CHARACTER(ErrMsgLen)                       :: ErrMsg2  ! local errors
   CHARACTER(*),            PARAMETER         :: RoutineName = 'BEMT_Output_ExtrapInterp2'
      ! Initialize ErrStat
   ErrStat = ErrID_None
   ErrMsg  = ""
      ! we'll subtract a constant from the times to resolve some 
      ! numerical issues when t gets large (and to simplify the equations)
   t = tin - tin(1)
   t_out = tin_out - tin(1)
  
     IF ( EqualRealNos( t(1), t(2) ) ) THEN
       CALL SetErrStat(ErrID_Fatal, 't(1) must not equal t(2) to avoid a division-by-zero error.', ErrStat, ErrMsg,RoutineName)
       RETURN
     ELSE IF ( EqualRealNos( t(2), t(3) ) ) THEN
       CALL SetErrStat(ErrID_Fatal, 't(2) must not equal t(3) to avoid a division-by-zero error.', ErrStat, ErrMsg,RoutineName)
       RETURN
     ELSE IF ( EqualRealNos( t(1), t(3) ) ) THEN
       CALL SetErrStat(ErrID_Fatal, 't(1) must not equal t(3) to avoid a division-by-zero error.', ErrStat, ErrMsg,RoutineName)
       RETURN
     END IF
  IF (ALLOCATED(y_out%Vrel) .AND. ALLOCATED(y1%Vrel)) THEN
    ALLOCATE(b2(SIZE(y_out%Vrel,1),SIZE(y_out%Vrel,2) ))
    ALLOCATE(c2(SIZE(y_out%Vrel,1),SIZE(y_out%Vrel,2) ))
    b2 = (t(3)**2*(y1%Vrel - y2%Vrel) + t(2)**2*(-y1%Vrel + y3%Vrel))/(t(2)*t(3)*(t(2) - t(3)))
    c2 = ( (t(2)-t(3))*y1%Vrel + t(3)*y2%Vrel - t(2)*y3%Vrel ) / (t(2)*t(3)*(t(2) - t(3)))
    y_out%Vrel = y1%Vrel + b2 * t_out + c2 * t_out**2
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%phi) .AND. ALLOCATED(y1%phi)) THEN
    ALLOCATE(b2(SIZE(y_out%phi,1),SIZE(y_out%phi,2) ))
    ALLOCATE(c2(SIZE(y_out%phi,1),SIZE(y_out%phi,2) ))
    b2 = (t(3)**2*(y1%phi - y2%phi) + t(2)**2*(-y1%phi + y3%phi))/(t(2)*t(3)*(t(2) - t(3)))
    c2 = ( (t(2)-t(3))*y1%phi + t(3)*y2%phi - t(2)*y3%phi ) / (t(2)*t(3)*(t(2) - t(3)))
    y_out%phi = y1%phi + b2 * t_out + c2 * t_out**2
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%axInduction) .AND. ALLOCATED(y1%axInduction)) THEN
    ALLOCATE(b2(SIZE(y_out%axInduction,1),SIZE(y_out%axInduction,2) ))
    ALLOCATE(c2(SIZE(y_out%axInduction,1),SIZE(y_out%axInduction,2) ))
    b2 = (t(3)**2*(y1%axInduction - y2%axInduction) + t(2)**2*(-y1%axInduction + y3%axInduction))/(t(2)*t(3)*(t(2) - t(3)))
    c2 = ( (t(2)-t(3))*y1%axInduction + t(3)*y2%axInduction - t(2)*y3%axInduction ) / (t(2)*t(3)*(t(2) - t(3)))
    y_out%axInduction = y1%axInduction + b2 * t_out + c2 * t_out**2
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%tanInduction) .AND. ALLOCATED(y1%tanInduction)) THEN
    ALLOCATE(b2(SIZE(y_out%tanInduction,1),SIZE(y_out%tanInduction,2) ))
    ALLOCATE(c2(SIZE(y_out%tanInduction,1),SIZE(y_out%tanInduction,2) ))
    b2 = (t(3)**2*(y1%tanInduction - y2%tanInduction) + t(2)**2*(-y1%tanInduction + y3%tanInduction))/(t(2)*t(3)*(t(2) - t(3)))
    c2 = ( (t(2)-t(3))*y1%tanInduction + t(3)*y2%tanInduction - t(2)*y3%tanInduction ) / (t(2)*t(3)*(t(2) - t(3)))
    y_out%tanInduction = y1%tanInduction + b2 * t_out + c2 * t_out**2
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%Re) .AND. ALLOCATED(y1%Re)) THEN
    ALLOCATE(b2(SIZE(y_out%Re,1),SIZE(y_out%Re,2) ))
    ALLOCATE(c2(SIZE(y_out%Re,1),SIZE(y_out%Re,2) ))
    b2 = (t(3)**2*(y1%Re - y2%Re) + t(2)**2*(-y1%Re + y3%Re))/(t(2)*t(3)*(t(2) - t(3)))
    c2 = ( (t(2)-t(3))*y1%Re + t(3)*y2%Re - t(2)*y3%Re ) / (t(2)*t(3)*(t(2) - t(3)))
    y_out%Re = y1%Re + b2 * t_out + c2 * t_out**2
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%AOA) .AND. ALLOCATED(y1%AOA)) THEN
    ALLOCATE(b2(SIZE(y_out%AOA,1),SIZE(y_out%AOA,2) ))
    ALLOCATE(c2(SIZE(y_out%AOA,1),SIZE(y_out%AOA,2) ))
    b2 = (t(3)**2*(y1%AOA - y2%AOA) + t(2)**2*(-y1%AOA + y3%AOA))/(t(2)*t(3)*(t(2) - t(3)))
    c2 = ( (t(2)-t(3))*y1%AOA + t(3)*y2%AOA - t(2)*y3%AOA ) / (t(2)*t(3)*(t(2) - t(3)))
    y_out%AOA = y1%AOA + b2 * t_out + c2 * t_out**2
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%Cx) .AND. ALLOCATED(y1%Cx)) THEN
    ALLOCATE(b2(SIZE(y_out%Cx,1),SIZE(y_out%Cx,2) ))
    ALLOCATE(c2(SIZE(y_out%Cx,1),SIZE(y_out%Cx,2) ))
    b2 = (t(3)**2*(y1%Cx - y2%Cx) + t(2)**2*(-y1%Cx + y3%Cx))/(t(2)*t(3)*(t(2) - t(3)))
    c2 = ( (t(2)-t(3))*y1%Cx + t(3)*y2%Cx - t(2)*y3%Cx ) / (t(2)*t(3)*(t(2) - t(3)))
    y_out%Cx = y1%Cx + b2 * t_out + c2 * t_out**2
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%Cy) .AND. ALLOCATED(y1%Cy)) THEN
    ALLOCATE(b2(SIZE(y_out%Cy,1),SIZE(y_out%Cy,2) ))
    ALLOCATE(c2(SIZE(y_out%Cy,1),SIZE(y_out%Cy,2) ))
    b2 = (t(3)**2*(y1%Cy - y2%Cy) + t(2)**2*(-y1%Cy + y3%Cy))/(t(2)*t(3)*(t(2) - t(3)))
    c2 = ( (t(2)-t(3))*y1%Cy + t(3)*y2%Cy - t(2)*y3%Cy ) / (t(2)*t(3)*(t(2) - t(3)))
    y_out%Cy = y1%Cy + b2 * t_out + c2 * t_out**2
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%Cm) .AND. ALLOCATED(y1%Cm)) THEN
    ALLOCATE(b2(SIZE(y_out%Cm,1),SIZE(y_out%Cm,2) ))
    ALLOCATE(c2(SIZE(y_out%Cm,1),SIZE(y_out%Cm,2) ))
    b2 = (t(3)**2*(y1%Cm - y2%Cm) + t(2)**2*(-y1%Cm + y3%Cm))/(t(2)*t(3)*(t(2) - t(3)))
    c2 = ( (t(2)-t(3))*y1%Cm + t(3)*y2%Cm - t(2)*y3%Cm ) / (t(2)*t(3)*(t(2) - t(3)))
    y_out%Cm = y1%Cm + b2 * t_out + c2 * t_out**2
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%Cl) .AND. ALLOCATED(y1%Cl)) THEN
    ALLOCATE(b2(SIZE(y_out%Cl,1),SIZE(y_out%Cl,2) ))
    ALLOCATE(c2(SIZE(y_out%Cl,1),SIZE(y_out%Cl,2) ))
    b2 = (t(3)**2*(y1%Cl - y2%Cl) + t(2)**2*(-y1%Cl + y3%Cl))/(t(2)*t(3)*(t(2) - t(3)))
    c2 = ( (t(2)-t(3))*y1%Cl + t(3)*y2%Cl - t(2)*y3%Cl ) / (t(2)*t(3)*(t(2) - t(3)))
    y_out%Cl = y1%Cl + b2 * t_out + c2 * t_out**2
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%Cd) .AND. ALLOCATED(y1%Cd)) THEN
    ALLOCATE(b2(SIZE(y_out%Cd,1),SIZE(y_out%Cd,2) ))
    ALLOCATE(c2(SIZE(y_out%Cd,1),SIZE(y_out%Cd,2) ))
    b2 = (t(3)**2*(y1%Cd - y2%Cd) + t(2)**2*(-y1%Cd + y3%Cd))/(t(2)*t(3)*(t(2) - t(3)))
    c2 = ( (t(2)-t(3))*y1%Cd + t(3)*y2%Cd - t(2)*y3%Cd ) / (t(2)*t(3)*(t(2) - t(3)))
    y_out%Cd = y1%Cd + b2 * t_out + c2 * t_out**2
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
  IF (ALLOCATED(y_out%chi) .AND. ALLOCATED(y1%chi)) THEN
    ALLOCATE(b2(SIZE(y_out%chi,1),SIZE(y_out%chi,2) ))
    ALLOCATE(c2(SIZE(y_out%chi,1),SIZE(y_out%chi,2) ))
    b2 = (t(3)**2*(y1%chi - y2%chi) + t(2)**2*(-y1%chi + y3%chi))/(t(2)*t(3)*(t(2) - t(3)))
    c2 = ( (t(2)-t(3))*y1%chi + t(3)*y2%chi - t(2)*y3%chi ) / (t(2)*t(3)*(t(2) - t(3)))
    y_out%chi = y1%chi + b2 * t_out + c2 * t_out**2
    DEALLOCATE(b2)
    DEALLOCATE(c2)
  END IF ! check if allocated
   END SUBROUTINE BEMT_Output_ExtrapInterp2
  
  END MODULE BEMT_Types
  !ENDOFREGISTRYGENERATEDFILE
  