Back to home page

MITgcm
 
 

    

File indexing completed on 2018-03-02 18:42:39 UTC

view on githubraw file Latest commit add29e06 on 2018-01-31 20:35:05 UTC
3221ad5c59 Jean*0001 #include "OBCS_OPTIONS.h"
                0002 
                0003 C---+----1----+----2----+----3----+----4----+----5----+----6----+----7-|--+----|
                0004 CBOP 0
                0005 C     !ROUTINE: OBCS_READ_PICKUP
                0006 
                0007 C     !INTERFACE:
                0008       SUBROUTINE OBCS_READ_PICKUP( myIter, myThid )
                0009 
                0010 C     !DESCRIPTION:
                0011 C     *==========================================================*
                0012 C     | SUBROUTINE OBCS_READ_PICKUP
                0013 C     | o Read open boundary pickup file
                0014 C     *==========================================================*
                0015 C     |   Note: only Orlanski OBC needs pickup files to restart
                0016 C     *==========================================================*
                0017 
                0018 C     !USES:
                0019       IMPLICIT NONE
                0020 C     === Global variables ===
                0021 #include "SIZE.h"
                0022 #include "EEPARAMS.h"
                0023 #include "PARAMS.h"
9b4f2a04e2 Jean*0024 #include "OBCS_PARAMS.h"
                0025 #include "OBCS_FIELDS.h"
3221ad5c59 Jean*0026 #include "ORLANSKI.h"
                0027 
                0028 C     !INPUT/OUTPUT PARAMETERS:
                0029       INTEGER myIter
                0030       INTEGER myThid
                0031 CEOP
                0032 
2c64c37c71 Mart*0033 #if (defined ALLOW_ORLANSKI) || (defined ALLOW_OBCS_STEVENS)
3221ad5c59 Jean*0034 
                0035 C     !LOCAL VARIABLES:
                0036       CHARACTER*(MAX_LEN_FNAM) fn
                0037       CHARACTER*(10) suff
                0038       INTEGER prec
                0039 
                0040       IF ( pickupSuff.EQ.' ' ) THEN
df5a9764ba Jean*0041         IF ( rwSuffixType.EQ.0 ) THEN
                0042           WRITE(suff,'(I10.10)') myIter
                0043         ELSE
                0044           CALL RW_GET_SUFFIX( suff, startTime, myIter, myThid )
                0045         ENDIF
3221ad5c59 Jean*0046       ELSE
                0047         suff = pickupSuff
                0048       ENDIF
                0049       prec = precFloat64
                0050 
58a0264bb8 Jean*0051 C--   Unlike horizontal 2D or 3D IO routines, no thread synchronisation is
                0052 C     done within  Vertical Section IO routines. Since only thread one is
                0053 C     doing IO, we need a barrier here to wait for every one to finish.
                0054       _BARRIER
                0055 
2c64c37c71 Mart*0056 #ifdef ALLOW_ORLANSKI
3221ad5c59 Jean*0057 #ifdef ALLOW_OBCS_NORTH
                0058       IF ( useOrlanskiNorth ) THEN
                0059 C     READ N and S OB storage and phase speed arrays
                0060         WRITE(fn,'(2A)') 'pickup_orlanskiN.',suff
                0061         CALL READ_REC_XZ_RL(fn,prec,Nr,UN_STORE_1, 1,myIter,myThid)
                0062         CALL READ_REC_XZ_RL(fn,prec,Nr,UN_STORE_2, 2,myIter,myThid)
                0063         CALL READ_REC_XZ_RL(fn,prec,Nr,UN_STORE_3, 3,myIter,myThid)
                0064         CALL READ_REC_XZ_RL(fn,prec,Nr,UN_STORE_4, 4,myIter,myThid)
                0065         CALL READ_REC_XZ_RL(fn,prec,Nr,VN_STORE_1, 5,myIter,myThid)
                0066         CALL READ_REC_XZ_RL(fn,prec,Nr,VN_STORE_2, 6,myIter,myThid)
                0067         CALL READ_REC_XZ_RL(fn,prec,Nr,VN_STORE_3, 7,myIter,myThid)
                0068         CALL READ_REC_XZ_RL(fn,prec,Nr,VN_STORE_4, 8,myIter,myThid)
                0069         CALL READ_REC_XZ_RL(fn,prec,Nr,TN_STORE_1, 9,myIter,myThid)
                0070         CALL READ_REC_XZ_RL(fn,prec,Nr,TN_STORE_2,10,myIter,myThid)
                0071         CALL READ_REC_XZ_RL(fn,prec,Nr,TN_STORE_3,11,myIter,myThid)
                0072         CALL READ_REC_XZ_RL(fn,prec,Nr,TN_STORE_4,12,myIter,myThid)
                0073         CALL READ_REC_XZ_RL(fn,prec,Nr,SN_STORE_1,13,myIter,myThid)
                0074         CALL READ_REC_XZ_RL(fn,prec,Nr,SN_STORE_2,14,myIter,myThid)
                0075         CALL READ_REC_XZ_RL(fn,prec,Nr,SN_STORE_3,15,myIter,myThid)
                0076         CALL READ_REC_XZ_RL(fn,prec,Nr,SN_STORE_4,16,myIter,myThid)
                0077         CALL READ_REC_XZ_RL(fn,prec,Nr, CVEL_UN , 17,myIter,myThid)
                0078         CALL READ_REC_XZ_RL(fn,prec,Nr, CVEL_VN , 18,myIter,myThid)
                0079         CALL READ_REC_XZ_RL(fn,prec,Nr, CVEL_TN , 19,myIter,myThid)
                0080         CALL READ_REC_XZ_RL(fn,prec,Nr, CVEL_SN , 20,myIter,myThid)
                0081 #ifdef ALLOW_NONHYDROSTATIC
                0082        IF ( nonHydrostatic ) THEN
                0083         CALL READ_REC_XZ_RL(fn,prec,Nr,WN_STORE_1,21,myIter,myThid)
                0084         CALL READ_REC_XZ_RL(fn,prec,Nr,WN_STORE_2,22,myIter,myThid)
                0085         CALL READ_REC_XZ_RL(fn,prec,Nr,WN_STORE_3,23,myIter,myThid)
                0086         CALL READ_REC_XZ_RL(fn,prec,Nr,WN_STORE_4,24,myIter,myThid)
                0087         CALL READ_REC_XZ_RL(fn,prec,Nr, CVEL_WN , 25,myIter,myThid)
                0088         CALL READ_REC_XZ_RL(fn,prec,Nr, OBNw    , 26,myIter,myThid)
                0089        ENDIF
                0090 #endif
                0091       ENDIF
                0092 #endif /* ALLOW_OBCS_NORTH */
                0093 
                0094 #ifdef ALLOW_OBCS_SOUTH
                0095       IF ( useOrlanskiSouth ) THEN
                0096         WRITE(fn,'(2A)') 'pickup_orlanskiS.',suff
                0097         CALL READ_REC_XZ_RL(fn,prec,Nr,US_STORE_1, 1,myIter,myThid)
                0098         CALL READ_REC_XZ_RL(fn,prec,Nr,US_STORE_2, 2,myIter,myThid)
                0099         CALL READ_REC_XZ_RL(fn,prec,Nr,US_STORE_3, 3,myIter,myThid)
                0100         CALL READ_REC_XZ_RL(fn,prec,Nr,US_STORE_4, 4,myIter,myThid)
                0101         CALL READ_REC_XZ_RL(fn,prec,Nr,VS_STORE_1, 5,myIter,myThid)
                0102         CALL READ_REC_XZ_RL(fn,prec,Nr,VS_STORE_2, 6,myIter,myThid)
                0103         CALL READ_REC_XZ_RL(fn,prec,Nr,VS_STORE_3, 7,myIter,myThid)
                0104         CALL READ_REC_XZ_RL(fn,prec,Nr,VS_STORE_4, 8,myIter,myThid)
                0105         CALL READ_REC_XZ_RL(fn,prec,Nr,TS_STORE_1, 9,myIter,myThid)
                0106         CALL READ_REC_XZ_RL(fn,prec,Nr,TS_STORE_2,10,myIter,myThid)
                0107         CALL READ_REC_XZ_RL(fn,prec,Nr,TS_STORE_3,11,myIter,myThid)
                0108         CALL READ_REC_XZ_RL(fn,prec,Nr,TS_STORE_4,12,myIter,myThid)
                0109         CALL READ_REC_XZ_RL(fn,prec,Nr,SS_STORE_1,13,myIter,myThid)
                0110         CALL READ_REC_XZ_RL(fn,prec,Nr,SS_STORE_2,14,myIter,myThid)
                0111         CALL READ_REC_XZ_RL(fn,prec,Nr,SS_STORE_3,15,myIter,myThid)
                0112         CALL READ_REC_XZ_RL(fn,prec,Nr,SS_STORE_4,16,myIter,myThid)
                0113         CALL READ_REC_XZ_RL(fn,prec,Nr, CVEL_US , 17,myIter,myThid)
                0114         CALL READ_REC_XZ_RL(fn,prec,Nr, CVEL_VS , 18,myIter,myThid)
                0115         CALL READ_REC_XZ_RL(fn,prec,Nr, CVEL_TS , 19,myIter,myThid)
                0116         CALL READ_REC_XZ_RL(fn,prec,Nr, CVEL_SS , 20,myIter,myThid)
                0117 #ifdef ALLOW_NONHYDROSTATIC
                0118        IF ( nonHydrostatic ) THEN
                0119         CALL READ_REC_XZ_RL(fn,prec,Nr,WS_STORE_1,21,myIter,myThid)
                0120         CALL READ_REC_XZ_RL(fn,prec,Nr,WS_STORE_2,22,myIter,myThid)
                0121         CALL READ_REC_XZ_RL(fn,prec,Nr,WS_STORE_3,23,myIter,myThid)
                0122         CALL READ_REC_XZ_RL(fn,prec,Nr,WS_STORE_4,24,myIter,myThid)
                0123         CALL READ_REC_XZ_RL(fn,prec,Nr, CVEL_WS , 25,myIter,myThid)
                0124         CALL READ_REC_XZ_RL(fn,prec,Nr, OBSw    , 26,myIter,myThid)
                0125        ENDIF
                0126 #endif
                0127       ENDIF
                0128 #endif /* ALLOW_OBCS_SOUTH */
                0129 
                0130 C     READ E and W OB storage and phase speed arrays
                0131 #ifdef ALLOW_OBCS_EAST
                0132       IF ( useOrlanskiEast ) THEN
                0133         WRITE(fn,'(2A)') 'pickup_orlanskiE.',suff
                0134         CALL READ_REC_YZ_RL(fn,prec,Nr,UE_STORE_1, 1,myIter,myThid)
                0135         CALL READ_REC_YZ_RL(fn,prec,Nr,UE_STORE_2, 2,myIter,myThid)
                0136         CALL READ_REC_YZ_RL(fn,prec,Nr,UE_STORE_3, 3,myIter,myThid)
                0137         CALL READ_REC_YZ_RL(fn,prec,Nr,UE_STORE_4, 4,myIter,myThid)
                0138         CALL READ_REC_YZ_RL(fn,prec,Nr,VE_STORE_1, 5,myIter,myThid)
                0139         CALL READ_REC_YZ_RL(fn,prec,Nr,VE_STORE_2, 6,myIter,myThid)
                0140         CALL READ_REC_YZ_RL(fn,prec,Nr,VE_STORE_3, 7,myIter,myThid)
                0141         CALL READ_REC_YZ_RL(fn,prec,Nr,VE_STORE_4, 8,myIter,myThid)
                0142         CALL READ_REC_YZ_RL(fn,prec,Nr,TE_STORE_1, 9,myIter,myThid)
                0143         CALL READ_REC_YZ_RL(fn,prec,Nr,TE_STORE_2,10,myIter,myThid)
                0144         CALL READ_REC_YZ_RL(fn,prec,Nr,TE_STORE_3,11,myIter,myThid)
                0145         CALL READ_REC_YZ_RL(fn,prec,Nr,TE_STORE_4,12,myIter,myThid)
                0146         CALL READ_REC_YZ_RL(fn,prec,Nr,SE_STORE_1,13,myIter,myThid)
                0147         CALL READ_REC_YZ_RL(fn,prec,Nr,SE_STORE_2,14,myIter,myThid)
                0148         CALL READ_REC_YZ_RL(fn,prec,Nr,SE_STORE_3,15,myIter,myThid)
                0149         CALL READ_REC_YZ_RL(fn,prec,Nr,SE_STORE_4,16,myIter,myThid)
                0150         CALL READ_REC_YZ_RL(fn,prec,Nr, CVEL_UE , 17,myIter,myThid)
                0151         CALL READ_REC_YZ_RL(fn,prec,Nr, CVEL_VE , 18,myIter,myThid)
                0152         CALL READ_REC_YZ_RL(fn,prec,Nr, CVEL_TE , 19,myIter,myThid)
                0153         CALL READ_REC_YZ_RL(fn,prec,Nr, CVEL_SE , 20,myIter,myThid)
                0154 #ifdef ALLOW_NONHYDROSTATIC
                0155        IF ( nonHydrostatic ) THEN
                0156         CALL READ_REC_YZ_RL(fn,prec,Nr,WE_STORE_1,21,myIter,myThid)
                0157         CALL READ_REC_YZ_RL(fn,prec,Nr,WE_STORE_2,22,myIter,myThid)
                0158         CALL READ_REC_YZ_RL(fn,prec,Nr,WE_STORE_3,23,myIter,myThid)
                0159         CALL READ_REC_YZ_RL(fn,prec,Nr,WE_STORE_4,24,myIter,myThid)
                0160         CALL READ_REC_YZ_RL(fn,prec,Nr, CVEL_WE , 25,myIter,myThid)
                0161         CALL READ_REC_YZ_RL(fn,prec,Nr, OBEw    , 26,myIter,myThid)
                0162        ENDIF
                0163 #endif
                0164       ENDIF
                0165 #endif /* ALLOW_OBCS_EAST */
                0166 
                0167 #ifdef ALLOW_OBCS_WEST
                0168       IF ( useOrlanskiWest ) THEN
                0169         WRITE(fn,'(2A)') 'pickup_orlanskiW.',suff
                0170         CALL READ_REC_YZ_RL(fn,prec,Nr,UW_STORE_1, 1,myIter,myThid)
                0171         CALL READ_REC_YZ_RL(fn,prec,Nr,UW_STORE_2, 2,myIter,myThid)
                0172         CALL READ_REC_YZ_RL(fn,prec,Nr,UW_STORE_3, 3,myIter,myThid)
                0173         CALL READ_REC_YZ_RL(fn,prec,Nr,UW_STORE_4, 4,myIter,myThid)
                0174         CALL READ_REC_YZ_RL(fn,prec,Nr,VW_STORE_1, 5,myIter,myThid)
                0175         CALL READ_REC_YZ_RL(fn,prec,Nr,VW_STORE_2, 6,myIter,myThid)
                0176         CALL READ_REC_YZ_RL(fn,prec,Nr,VW_STORE_3, 7,myIter,myThid)
                0177         CALL READ_REC_YZ_RL(fn,prec,Nr,VW_STORE_4, 8,myIter,myThid)
                0178         CALL READ_REC_YZ_RL(fn,prec,Nr,TW_STORE_1, 9,myIter,myThid)
                0179         CALL READ_REC_YZ_RL(fn,prec,Nr,TW_STORE_2,10,myIter,myThid)
                0180         CALL READ_REC_YZ_RL(fn,prec,Nr,TW_STORE_3,11,myIter,myThid)
                0181         CALL READ_REC_YZ_RL(fn,prec,Nr,TW_STORE_4,12,myIter,myThid)
                0182         CALL READ_REC_YZ_RL(fn,prec,Nr,SW_STORE_1,13,myIter,myThid)
                0183         CALL READ_REC_YZ_RL(fn,prec,Nr,SW_STORE_2,14,myIter,myThid)
                0184         CALL READ_REC_YZ_RL(fn,prec,Nr,SW_STORE_3,15,myIter,myThid)
                0185         CALL READ_REC_YZ_RL(fn,prec,Nr,SW_STORE_4,16,myIter,myThid)
                0186         CALL READ_REC_YZ_RL(fn,prec,Nr, CVEL_UW , 17,myIter,myThid)
                0187         CALL READ_REC_YZ_RL(fn,prec,Nr, CVEL_VW , 18,myIter,myThid)
                0188         CALL READ_REC_YZ_RL(fn,prec,Nr, CVEL_TW , 19,myIter,myThid)
                0189         CALL READ_REC_YZ_RL(fn,prec,Nr, CVEL_SW , 20,myIter,myThid)
                0190 #ifdef ALLOW_NONHYDROSTATIC
                0191        IF ( nonHydrostatic ) THEN
                0192         CALL READ_REC_YZ_RL(fn,prec,Nr,WW_STORE_1,21,myIter,myThid)
                0193         CALL READ_REC_YZ_RL(fn,prec,Nr,WW_STORE_2,22,myIter,myThid)
                0194         CALL READ_REC_YZ_RL(fn,prec,Nr,WW_STORE_3,23,myIter,myThid)
                0195         CALL READ_REC_YZ_RL(fn,prec,Nr,WW_STORE_4,24,myIter,myThid)
                0196         CALL READ_REC_YZ_RL(fn,prec,Nr, CVEL_WW , 25,myIter,myThid)
                0197         CALL READ_REC_YZ_RL(fn,prec,Nr, OBWw    , 26,myIter,myThid)
                0198        ENDIF
                0199 #endif
                0200       ENDIF
                0201 #endif /* ALLOW_OBCS_WEST */
                0202 
                0203 C     Fill in edge regions
                0204 c      _EXCH_XZ_RL(UN_STORE_1 , myThid)
                0205 C      same with 2,3,4
                0206 C      same with VN_STORE_n, TN_STORE_n, SN_STORE_n, with n=1,2,3,4
                0207 C      same with XS_STORE_n, XE_STORE_N, XW_STORE_n, with X=U,V,T,S & n=1,2,3,4
                0208 
                0209 c      _EXCH_XZ_RL(CVEL_UN , myThid)
                0210 C      same with CVEL_VN,  CVEL_TN,  CVEL_SN
                0211 C      same with CVEL_XS,  CVEL_XE,  CVEL_XW, with X=U,V,T,S
                0212 c#ifdef ALLOW_NONHYDROSTATIC
                0213 c      _EXCH_XZ_RL(WN_STORE_1 , myThid)
                0214 C      same with 2,3,4
                0215 C      same with WE_STORE_n, WE_STORE_n, WW_STORE_n, with n=1,2,3,4
                0216 c      _EXCH_XZ_RL(CVEL_WN , myThid)
                0217 C      same with CVEL_WS,  CVEL_WE,  CVEL_WW
                0218 c#endif
2c64c37c71 Mart*0219 #endif /* ALLOW_ORLANSKI */
                0220 
                0221 #ifdef ALLOW_OBCS_STEVENS
                0222 #ifdef ALLOW_OBCS_NORTH
                0223       IF ( useStevensNorth ) THEN
                0224         WRITE(fn,'(2A)') 'pickup_stevensN.',suff
                0225         CALL READ_REC_XZ_RL(fn,prec,Nr,OBNvStevens, 1,myIter,myThid)
b1353a35da Mart*0226         CALL READ_REC_XZ_RL(fn,prec,Nr,OBNtStevens, 2,myIter,myThid)
                0227         CALL READ_REC_XZ_RL(fn,prec,Nr,OBNsStevens, 3,myIter,myThid)
2c64c37c71 Mart*0228       ENDIF
                0229 #endif /* ALLOW_OBCS_NORTH */
                0230 
                0231 #ifdef ALLOW_OBCS_SOUTH
                0232       IF ( useStevensSouth ) THEN
                0233         WRITE(fn,'(2A)') 'pickup_stevensS.',suff
                0234         CALL READ_REC_XZ_RL(fn,prec,Nr,OBSvStevens, 1,myIter,myThid)
b1353a35da Mart*0235         CALL READ_REC_XZ_RL(fn,prec,Nr,OBStStevens, 2,myIter,myThid)
                0236         CALL READ_REC_XZ_RL(fn,prec,Nr,OBSsStevens, 3,myIter,myThid)
2c64c37c71 Mart*0237       ENDIF
                0238 #endif /* ALLOW_OBCS_SOUTH */
                0239 
                0240 #ifdef ALLOW_OBCS_EAST
                0241       IF ( useStevensEast ) THEN
                0242         WRITE(fn,'(2A)') 'pickup_stevensE.',suff
                0243         CALL READ_REC_YZ_RL(fn,prec,Nr,OBEuStevens, 1,myIter,myThid)
b1353a35da Mart*0244         CALL READ_REC_YZ_RL(fn,prec,Nr,OBEtStevens, 2,myIter,myThid)
                0245         CALL READ_REC_YZ_RL(fn,prec,Nr,OBEsStevens, 3,myIter,myThid)
2c64c37c71 Mart*0246       ENDIF
                0247 #endif /* ALLOW_OBCS_EAST */
                0248 
                0249 #ifdef ALLOW_OBCS_WEST
                0250       IF ( useStevensWest ) THEN
                0251         WRITE(fn,'(2A)') 'pickup_stevensW.',suff
                0252         CALL READ_REC_YZ_RL(fn,prec,Nr,OBWuStevens, 1,myIter,myThid)
b1353a35da Mart*0253         CALL READ_REC_YZ_RL(fn,prec,Nr,OBWtStevens, 2,myIter,myThid)
                0254         CALL READ_REC_YZ_RL(fn,prec,Nr,OBWsStevens, 3,myIter,myThid)
2c64c37c71 Mart*0255       ENDIF
                0256 #endif /* ALLOW_OBCS_WEST */
                0257 #endif /* ALLOW_OBCS_STEVENS */
3221ad5c59 Jean*0258 
58a0264bb8 Jean*0259 C--   Every one wait for thread 1 to finish (see comment @ the top)
                0260       _BARRIER
                0261 
2c64c37c71 Mart*0262 #endif /* ALLOW_ORLANSKI or ALLOW_OBCS_STEVENS */
3221ad5c59 Jean*0263       RETURN
                0264       END
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated from https://github.com/MITgcm/MITgcm by the 2.2.1-MITgcm-0.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!