Back to home page

MITgcm
 
 

    

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

view on githubraw file Latest commit add29e06 on 2018-01-31 20:35:05 UTC
c7c4b57180 Dimi*0001 #include "OBCS_OPTIONS.h"
                0002 
                0003 C--   File obcs_seaice_sponge.F:
                0004 C--    Contents:
                0005 C--    o OBCS_SEAICE_SPONGE_A
                0006 C--    o OBCS_SEAICE_SPONGE_H
5e26aed318 Dimi*0007 C--    o OBCS_SEAICE_SPONGE_SL
                0008 C--    o OBCS_SEAICE_SPONGE_SN
c7c4b57180 Dimi*0009 
                0010 C---+----1----+----2----+----3----+----4----+----5----+----6----+----7-|--+----|
                0011 
                0012 CStartOfInterface
                0013       SUBROUTINE OBCS_SEAICE_SPONGE_A( myThid )
                0014 C     *==========================================================*
                0015 C     | S/R OBCS_SEAICE_SPONGE_A
                0016 C     | Adds a relaxation term to AREA near Open-Boundaries
                0017 C     *==========================================================*
                0018       IMPLICIT NONE
                0019 
                0020 C     == Global data ==
                0021 #include "SIZE.h"
                0022 #include "EEPARAMS.h"
                0023 #include "PARAMS.h"
                0024 #include "GRID.h"
                0025 #include "DYNVARS.h"
                0026 #include "OBCS_PARAMS.h"
                0027 #include "OBCS_GRID.h"
                0028 #include "OBCS_FIELDS.h"
                0029 #include "OBCS_SEAICE.h"
                0030 #ifdef ALLOW_SEAICE
                0031 # include "SEAICE_SIZE.h"
                0032 # include "SEAICE_PARAMS.h"
                0033 # include "SEAICE.h"
                0034 #endif
                0035 
                0036 C     == Routine arguments ==
                0037       INTEGER myThid
                0038 CEndOfInterface
                0039 
                0040 #if (defined(ALLOW_OBCS) && defined(ALLOW_SEAICE) && defined(ALLOW_OBCS_SEAICE_SPONGE))
                0041 C     == Local variables ==
                0042 C     Loop counters
                0043       INTEGER bi, bj, i, j, isl, jsl
                0044       _RL lambda_obcs
                0045 
                0046       IF ( useSeaiceSponge .AND. seaiceSpongeThickness.NE.0 ) THEN
                0047        DO bj=myByLo(myThid),myByHi(myThid)
                0048         DO bi=myBxLo(myThid),myBxHi(myThid)
                0049 
                0050 C Northern Open Boundary
                0051 # ifdef ALLOW_OBCS_NORTH
                0052          IF ( tileHasOBN(bi,bj) ) THEN
                0053           DO i=1,sNx
                0054            IF ( OB_Jn(i,bi,bj).NE.OB_indexNone ) THEN
                0055             DO jsl= 1,seaiceSpongeThickness
                0056              j=OB_Jn(i,bi,bj)-jsl
                0057              IF ((j.ge.1).and.(j.le.sNy)) THEN
                0058               lambda_obcs = (
                0059      &           float(seaiceSpongeThickness-jsl)*Arelaxobcsbound
5e26aed318 Dimi*0060      &           + float(jsl-1)*Arelaxobcsinner)
                0061      &           / float(seaiceSpongeThickness-1)
c7c4b57180 Dimi*0062               IF (lambda_obcs.ne.0.) THEN
                0063                lambda_obcs = SEAICE_deltaTtherm / lambda_obcs
                0064               ELSE
                0065                lambda_obcs = 0. _d 0
                0066               ENDIF
5e26aed318 Dimi*0067               AREA(i,j,bi,bj) = AREA(i,j,bi,bj)
c7c4b57180 Dimi*0068      &           - maskC(i,j,1,bi,bj) * lambda_obcs
                0069      &           * ( AREA(i,j,bi,bj) - OBNa(i,bi,bj) )
                0070              ENDIF
                0071             ENDDO
                0072            ENDIF
                0073           ENDDO
                0074          ENDIF
                0075 # endif
                0076 
                0077 C Southern Open Boundary
                0078 # ifdef ALLOW_OBCS_SOUTH
                0079          IF ( tileHasOBS(bi,bj) ) THEN
                0080           DO i=1,sNx
                0081            IF ( OB_Js(i,bi,bj).NE.OB_indexNone ) THEN
                0082             DO jsl= 1,seaiceSpongeThickness
                0083              j=OB_Js(i,bi,bj)+jsl
                0084              IF ((j.ge.1).and.(j.le.sNy)) THEN
                0085               lambda_obcs = (
5e26aed318 Dimi*0086      &           float(seaiceSpongeThickness-jsl)*Arelaxobcsbound
                0087      &           + float(jsl-1)*Arelaxobcsinner)
                0088      &           / float(seaiceSpongeThickness-1)
c7c4b57180 Dimi*0089               if (lambda_obcs.ne.0.) then
                0090                lambda_obcs = SEAICE_deltaTtherm / lambda_obcs
                0091               else
                0092                lambda_obcs = 0. _d 0
                0093               endif
                0094               AREA(i,j,bi,bj) = AREA(i,j,bi,bj)
                0095      &           - maskC(i,j,1,bi,bj) * lambda_obcs
                0096      &           * ( AREA(i,j,bi,bj) - OBSa(i,bi,bj) )
                0097              ENDIF
                0098             ENDDO
                0099            ENDIF
                0100           ENDDO
                0101          ENDIF
                0102 # endif
                0103 
                0104 C Eastern Open Boundary
                0105 # ifdef ALLOW_OBCS_EAST
                0106          IF ( tileHasOBE(bi,bj) ) THEN
                0107           DO j=1,sNy
                0108            IF ( OB_Ie(j,bi,bj).NE.OB_indexNone ) THEN
                0109             DO isl= 1,seaiceSpongeThickness
                0110              i=OB_Ie(j,bi,bj)-isl
                0111              IF ((i.ge.1).and.(i.le.sNx)) THEN
                0112               lambda_obcs = (
                0113      &           float(seaiceSpongeThickness-isl)*Arelaxobcsbound
5e26aed318 Dimi*0114      &           + float(isl-1)*Arelaxobcsinner)
                0115      &           / float(seaiceSpongeThickness-1)
c7c4b57180 Dimi*0116               if (lambda_obcs.ne.0.) then
                0117                lambda_obcs = SEAICE_deltaTtherm / lambda_obcs
                0118               else
                0119                lambda_obcs = 0. _d 0
                0120               endif
                0121               AREA(i,j,bi,bj) = AREA(i,j,bi,bj)
                0122      &           - maskC(i,j,1,bi,bj) * lambda_obcs
                0123      &           * ( AREA(i,j,bi,bj) - OBEa(j,bi,bj) )
                0124              ENDIF
                0125             ENDDO
                0126            ENDIF
                0127           ENDDO
                0128          ENDIF
                0129 # endif
                0130 
                0131 C Western Open Boundary
                0132 # ifdef ALLOW_OBCS_WEST
                0133          IF ( tileHasOBW(bi,bj) ) THEN
                0134           DO j=1,sNy
                0135            IF ( OB_Iw(j,bi,bj).NE.OB_indexNone ) THEN
                0136             DO isl= 1,seaiceSpongeThickness
                0137              i=OB_Iw(j,bi,bj)+isl
                0138              IF ((i.ge.1).and.(i.le.sNx)) THEN
                0139               lambda_obcs= (
                0140      &           float(seaiceSpongeThickness-isl)*Arelaxobcsbound
5e26aed318 Dimi*0141      &           + float(isl-1)*Arelaxobcsinner)
                0142      &           / float(seaiceSpongeThickness-1)
c7c4b57180 Dimi*0143               if (lambda_obcs.ne.0.) then
                0144                lambda_obcs = SEAICE_deltaTtherm / lambda_obcs
                0145               else
                0146                lambda_obcs = 0. _d 0
                0147               endif
5e26aed318 Dimi*0148               AREA(i,j,bi,bj) = AREA(i,j,bi,bj)
c7c4b57180 Dimi*0149      &           - maskC(i,j,1,bi,bj) * lambda_obcs
                0150      &           * ( AREA(i,j,bi,bj) - OBWa(j,bi,bj) )
                0151              ENDIF
                0152             ENDDO
                0153            ENDIF
                0154           ENDDO
                0155          ENDIF
                0156 # endif
                0157 
                0158         ENDDO
                0159        ENDDO
                0160       ENDIF
                0161 
                0162 #endif /* ALLOW_OBCS & ALLOW_SEAICE & ALLOW_OBCS_SEAICE_SPONGE */
                0163 
                0164       RETURN
                0165       END
                0166 
                0167 C---+----1----+----2----+----3----+----4----+----5----+----6----+----7-|--+----|
                0168 
                0169 CStartOfInterface
                0170       SUBROUTINE OBCS_SEAICE_SPONGE_H( myThid )
                0171 C     *==========================================================*
                0172 C     | S/R OBCS_SEAICE_SPONGE_H
                0173 C     | Adds a relaxation term to HEFF near Open-Boundaries
                0174 C     *==========================================================*
                0175       IMPLICIT NONE
                0176 
                0177 C     == Global data ==
                0178 #include "SIZE.h"
                0179 #include "EEPARAMS.h"
                0180 #include "PARAMS.h"
                0181 #include "GRID.h"
                0182 #include "DYNVARS.h"
                0183 #include "OBCS_PARAMS.h"
                0184 #include "OBCS_GRID.h"
                0185 #include "OBCS_FIELDS.h"
                0186 #include "OBCS_SEAICE.h"
                0187 #ifdef ALLOW_SEAICE
                0188 # include "SEAICE_SIZE.h"
                0189 # include "SEAICE_PARAMS.h"
                0190 # include "SEAICE.h"
                0191 #endif
                0192 
                0193 C     == Routine arguments ==
                0194       INTEGER myThid
                0195 CEndOfInterface
                0196 
                0197 #if (defined(ALLOW_OBCS) && defined(ALLOW_SEAICE) && defined(ALLOW_OBCS_SEAICE_SPONGE))
                0198 C     == Local variables ==
                0199 C     Loop counters
                0200       INTEGER bi, bj, i, j, isl, jsl
                0201       _RL lambda_obcs
                0202 
                0203       IF ( useSeaiceSponge .AND. seaiceSpongeThickness.NE.0 ) THEN
                0204        DO bj=myByLo(myThid),myByHi(myThid)
                0205         DO bi=myBxLo(myThid),myBxHi(myThid)
                0206 
                0207 C Northern Open Boundary
                0208 # ifdef ALLOW_OBCS_NORTH
                0209          IF ( tileHasOBN(bi,bj) ) THEN
                0210           DO i=1,sNx
                0211            IF ( OB_Jn(i,bi,bj).NE.OB_indexNone ) THEN
                0212             DO jsl= 1,seaiceSpongeThickness
                0213              j=OB_Jn(i,bi,bj)-jsl
                0214              IF ((j.ge.1).and.(j.le.sNy)) THEN
                0215               lambda_obcs = (
                0216      &           float(seaiceSpongeThickness-jsl)*Hrelaxobcsbound
5e26aed318 Dimi*0217      &           + float(jsl-1)*Hrelaxobcsinner)
                0218      &           / float(seaiceSpongeThickness-1)
c7c4b57180 Dimi*0219               IF (lambda_obcs.ne.0.) THEN
                0220                lambda_obcs = SEAICE_deltaTtherm / lambda_obcs
                0221               ELSE
                0222                lambda_obcs = 0. _d 0
                0223               ENDIF
5e26aed318 Dimi*0224               HEFF(i,j,bi,bj) = HEFF(i,j,bi,bj)
c7c4b57180 Dimi*0225      &           - maskC(i,j,1,bi,bj) * lambda_obcs
                0226      &           * ( HEFF(i,j,bi,bj) - OBNh(i,bi,bj) )
                0227              ENDIF
                0228             ENDDO
                0229            ENDIF
                0230           ENDDO
                0231          ENDIF
                0232 # endif
                0233 
                0234 C Southern Open Boundary
                0235 # ifdef ALLOW_OBCS_SOUTH
                0236          IF ( tileHasOBS(bi,bj) ) THEN
                0237           DO i=1,sNx
                0238            IF ( OB_Js(i,bi,bj).NE.OB_indexNone ) THEN
                0239             DO jsl= 1,seaiceSpongeThickness
                0240              j=OB_Js(i,bi,bj)+jsl
                0241              IF ((j.ge.1).and.(j.le.sNy)) THEN
                0242               lambda_obcs = (
5e26aed318 Dimi*0243      &           float(seaiceSpongeThickness-jsl)*Hrelaxobcsbound
                0244      &           + float(jsl-1)*Hrelaxobcsinner)
                0245      &           / float(seaiceSpongeThickness-1)
c7c4b57180 Dimi*0246               if (lambda_obcs.ne.0.) then
                0247                lambda_obcs = SEAICE_deltaTtherm / lambda_obcs
                0248               else
                0249                lambda_obcs = 0. _d 0
                0250               endif
                0251               HEFF(i,j,bi,bj) = HEFF(i,j,bi,bj)
                0252      &           - maskC(i,j,1,bi,bj) * lambda_obcs
                0253      &           * ( HEFF(i,j,bi,bj) - OBSh(i,bi,bj) )
                0254              ENDIF
                0255             ENDDO
                0256            ENDIF
                0257           ENDDO
                0258          ENDIF
                0259 # endif
                0260 
                0261 C Eastern Open Boundary
                0262 # ifdef ALLOW_OBCS_EAST
                0263          IF ( tileHasOBE(bi,bj) ) THEN
                0264           DO j=1,sNy
                0265            IF ( OB_Ie(j,bi,bj).NE.OB_indexNone ) THEN
                0266             DO isl= 1,seaiceSpongeThickness
                0267              i=OB_Ie(j,bi,bj)-isl
                0268              IF ((i.ge.1).and.(i.le.sNx)) THEN
                0269               lambda_obcs = (
                0270      &           float(seaiceSpongeThickness-isl)*Hrelaxobcsbound
5e26aed318 Dimi*0271      &           + float(isl-1)*Hrelaxobcsinner)
                0272      &           / float(seaiceSpongeThickness-1)
c7c4b57180 Dimi*0273               if (lambda_obcs.ne.0.) then
                0274                lambda_obcs = SEAICE_deltaTtherm / lambda_obcs
                0275               else
                0276                lambda_obcs = 0. _d 0
                0277               endif
                0278               HEFF(i,j,bi,bj) = HEFF(i,j,bi,bj)
                0279      &           - maskC(i,j,1,bi,bj) * lambda_obcs
5e26aed318 Dimi*0280      &           * ( HEFF(i,j,bi,bj) - OBEh(j,bi,bj) )
c7c4b57180 Dimi*0281              ENDIF
                0282             ENDDO
                0283            ENDIF
                0284           ENDDO
                0285          ENDIF
                0286 # endif
                0287 
                0288 C Western Open Boundary
                0289 # ifdef ALLOW_OBCS_WEST
                0290          IF ( tileHasOBW(bi,bj) ) THEN
                0291           DO j=1,sNy
                0292            IF ( OB_Iw(j,bi,bj).NE.OB_indexNone ) THEN
                0293             DO isl= 1,seaiceSpongeThickness
                0294              i=OB_Iw(j,bi,bj)+isl
                0295              IF ((i.ge.1).and.(i.le.sNx)) THEN
                0296               lambda_obcs= (
                0297      &           float(seaiceSpongeThickness-isl)*Hrelaxobcsbound
5e26aed318 Dimi*0298      &           + float(isl-1)*Hrelaxobcsinner)
                0299      &           / float(seaiceSpongeThickness-1)
                0300               if (lambda_obcs.ne.0.) then
                0301                lambda_obcs = SEAICE_deltaTtherm / lambda_obcs
                0302               else
                0303                lambda_obcs = 0. _d 0
                0304               endif
                0305               HEFF(i,j,bi,bj) = HEFF(i,j,bi,bj)
                0306      &           - maskC(i,j,1,bi,bj) * lambda_obcs
                0307      &           * ( HEFF(i,j,bi,bj) - OBWh(j,bi,bj) )
                0308              ENDIF
                0309             ENDDO
                0310            ENDIF
                0311           ENDDO
                0312          ENDIF
                0313 # endif
                0314 
                0315         ENDDO
                0316        ENDDO
                0317       ENDIF
                0318 
                0319 #endif /* ALLOW_OBCS & ALLOW_SEAICE & ALLOW_OBCS_SEAICE_SPONGE */
                0320 
                0321       RETURN
                0322       END
                0323 
                0324 C---+----1----+----2----+----3----+----4----+----5----+----6----+----7-|--+----|
                0325 
                0326 CStartOfInterface
                0327       SUBROUTINE OBCS_SEAICE_SPONGE_SL( myThid )
                0328 C     *==========================================================*
                0329 C     | S/R OBCS_SEAICE_SPONGE_SL
                0330 C     | Adds a relaxation term to HSALT near Open-Boundaries
                0331 C     *==========================================================*
                0332       IMPLICIT NONE
                0333 
                0334 C     == Global data ==
                0335 #include "SIZE.h"
                0336 #include "EEPARAMS.h"
                0337 #include "PARAMS.h"
                0338 #include "GRID.h"
                0339 #include "DYNVARS.h"
                0340 #include "OBCS_PARAMS.h"
                0341 #include "OBCS_GRID.h"
                0342 #include "OBCS_FIELDS.h"
                0343 #include "OBCS_SEAICE.h"
                0344 #ifdef ALLOW_SEAICE
                0345 # include "SEAICE_SIZE.h"
                0346 # include "SEAICE_PARAMS.h"
                0347 # include "SEAICE.h"
                0348 #endif
                0349 
                0350 C     == Routine arguments ==
                0351       INTEGER myThid
                0352 CEndOfInterface
                0353 
                0354 #if (defined(ALLOW_OBCS) && defined(ALLOW_SEAICE) && defined(ALLOW_OBCS_SEAICE_SPONGE) && defined(SEAICE_VARIABLE_SALINITY))
                0355 C     == Local variables ==
                0356 C     Loop counters
                0357       INTEGER bi, bj, i, j, isl, jsl
                0358       _RL lambda_obcs
                0359 
                0360       IF ( useSeaiceSponge .AND. seaiceSpongeThickness.NE.0 ) THEN
                0361        DO bj=myByLo(myThid),myByHi(myThid)
                0362         DO bi=myBxLo(myThid),myBxHi(myThid)
                0363 
                0364 C Northern Open Boundary
                0365 # ifdef ALLOW_OBCS_NORTH
                0366          IF ( tileHasOBN(bi,bj) ) THEN
                0367           DO i=1,sNx
                0368            IF ( OB_Jn(i,bi,bj).NE.OB_indexNone ) THEN
                0369             DO jsl= 1,seaiceSpongeThickness
                0370              j=OB_Jn(i,bi,bj)-jsl
                0371              IF ((j.ge.1).and.(j.le.sNy)) THEN
                0372               lambda_obcs = (
                0373      &           float(seaiceSpongeThickness-jsl)*SLrelaxobcsbound
                0374      &           + float(jsl-1)*SLrelaxobcsinner)
                0375      &           / float(seaiceSpongeThickness-1)
                0376               IF (lambda_obcs.ne.0.) THEN
                0377                lambda_obcs = SEAICE_deltaTtherm / lambda_obcs
                0378               ELSE
                0379                lambda_obcs = 0. _d 0
                0380               ENDIF
                0381               HSALT(i,j,bi,bj) = HSALT(i,j,bi,bj)
                0382      &           - maskC(i,j,1,bi,bj) * lambda_obcs
                0383      &           * ( HSALT(i,j,bi,bj) - OBNsl(i,bi,bj) )
                0384              ENDIF
                0385             ENDDO
                0386            ENDIF
                0387           ENDDO
                0388          ENDIF
                0389 # endif
                0390 
                0391 C Southern Open Boundary
                0392 # ifdef ALLOW_OBCS_SOUTH
                0393          IF ( tileHasOBS(bi,bj) ) THEN
                0394           DO i=1,sNx
                0395            IF ( OB_Js(i,bi,bj).NE.OB_indexNone ) THEN
                0396             DO jsl= 1,seaiceSpongeThickness
                0397              j=OB_Js(i,bi,bj)+jsl
                0398              IF ((j.ge.1).and.(j.le.sNy)) THEN
                0399               lambda_obcs = (
                0400      &           float(seaiceSpongeThickness-jsl)*SLrelaxobcsbound
                0401      &           + float(jsl-1)*SLrelaxobcsinner)
                0402      &           / float(seaiceSpongeThickness-1)
                0403               if (lambda_obcs.ne.0.) then
                0404                lambda_obcs = SEAICE_deltaTtherm / lambda_obcs
                0405               else
                0406                lambda_obcs = 0. _d 0
                0407               endif
                0408               HSALT(i,j,bi,bj) = HSALT(i,j,bi,bj)
                0409      &           - maskC(i,j,1,bi,bj) * lambda_obcs
                0410      &           * ( HSALT(i,j,bi,bj) - OBSsl(i,bi,bj) )
                0411              ENDIF
                0412             ENDDO
                0413            ENDIF
                0414           ENDDO
                0415          ENDIF
                0416 # endif
                0417 
                0418 C Eastern Open Boundary
                0419 # ifdef ALLOW_OBCS_EAST
                0420          IF ( tileHasOBE(bi,bj) ) THEN
                0421           DO j=1,sNy
                0422            IF ( OB_Ie(j,bi,bj).NE.OB_indexNone ) THEN
                0423             DO isl= 1,seaiceSpongeThickness
                0424              i=OB_Ie(j,bi,bj)-isl
                0425              IF ((i.ge.1).and.(i.le.sNx)) THEN
                0426               lambda_obcs = (
                0427      &           float(seaiceSpongeThickness-isl)*SLrelaxobcsbound
                0428      &           + float(isl-1)*SLrelaxobcsinner)
                0429      &           / float(seaiceSpongeThickness-1)
                0430               if (lambda_obcs.ne.0.) then
                0431                lambda_obcs = SEAICE_deltaTtherm / lambda_obcs
                0432               else
                0433                lambda_obcs = 0. _d 0
                0434               endif
                0435               HSALT(i,j,bi,bj) = HSALT(i,j,bi,bj)
                0436      &           - maskC(i,j,1,bi,bj) * lambda_obcs
                0437      &           * ( HSALT(i,j,bi,bj) - OBEsl(j,bi,bj) )
                0438              ENDIF
                0439             ENDDO
                0440            ENDIF
                0441           ENDDO
                0442          ENDIF
                0443 # endif
                0444 
                0445 C Western Open Boundary
                0446 # ifdef ALLOW_OBCS_WEST
                0447          IF ( tileHasOBW(bi,bj) ) THEN
                0448           DO j=1,sNy
                0449            IF ( OB_Iw(j,bi,bj).NE.OB_indexNone ) THEN
                0450             DO isl= 1,seaiceSpongeThickness
                0451              i=OB_Iw(j,bi,bj)+isl
                0452              IF ((i.ge.1).and.(i.le.sNx)) THEN
                0453               lambda_obcs= (
                0454      &           float(seaiceSpongeThickness-isl)*SLrelaxobcsbound
                0455      &           + float(isl-1)*SLrelaxobcsinner)
                0456      &           / float(seaiceSpongeThickness-1)
                0457               if (lambda_obcs.ne.0.) then
                0458                lambda_obcs = SEAICE_deltaTtherm / lambda_obcs
                0459               else
                0460                lambda_obcs = 0. _d 0
                0461               endif
                0462               HSALT(i,j,bi,bj) = HSALT(i,j,bi,bj)
                0463      &           - maskC(i,j,1,bi,bj) * lambda_obcs
                0464      &           * ( HSALT(i,j,bi,bj) - OBWsl(j,bi,bj) )
                0465              ENDIF
                0466             ENDDO
                0467            ENDIF
                0468           ENDDO
                0469          ENDIF
                0470 # endif
                0471 
                0472         ENDDO
                0473        ENDDO
                0474       ENDIF
                0475 
                0476 #endif /* ALLOW_OBCS & ALLOW_SEAICE & ALLOW_OBCS_SEAICE_SPONGE & SEAICE_VARIABLE_SALINITY */
                0477 
                0478       RETURN
                0479       END
                0480 
                0481 C---+----1----+----2----+----3----+----4----+----5----+----6----+----7-|--+----|
                0482 
                0483 CStartOfInterface
                0484       SUBROUTINE OBCS_SEAICE_SPONGE_SN( myThid )
                0485 C     *==========================================================*
                0486 C     | S/R OBCS_SEAICE_SPONGE_SN
                0487 C     | Adds a relaxation term to HSNOW near Open-Boundaries
                0488 C     *==========================================================*
                0489       IMPLICIT NONE
                0490 
                0491 C     == Global data ==
                0492 #include "SIZE.h"
                0493 #include "EEPARAMS.h"
                0494 #include "PARAMS.h"
                0495 #include "GRID.h"
                0496 #include "DYNVARS.h"
                0497 #include "OBCS_PARAMS.h"
                0498 #include "OBCS_GRID.h"
                0499 #include "OBCS_FIELDS.h"
                0500 #include "OBCS_SEAICE.h"
                0501 #ifdef ALLOW_SEAICE
                0502 # include "SEAICE_SIZE.h"
                0503 # include "SEAICE_PARAMS.h"
                0504 # include "SEAICE.h"
                0505 #endif
                0506 
                0507 C     == Routine arguments ==
                0508       INTEGER myThid
                0509 CEndOfInterface
                0510 
                0511 #if (defined(ALLOW_OBCS) && defined(ALLOW_SEAICE) && defined(ALLOW_OBCS_SEAICE_SPONGE))
                0512 C     == Local variables ==
                0513 C     Loop counters
                0514       INTEGER bi, bj, i, j, isl, jsl
                0515       _RL lambda_obcs
                0516 
                0517       IF ( useSeaiceSponge .AND. seaiceSpongeThickness.NE.0 ) THEN
                0518        DO bj=myByLo(myThid),myByHi(myThid)
                0519         DO bi=myBxLo(myThid),myBxHi(myThid)
                0520 
                0521 C Northern Open Boundary
                0522 # ifdef ALLOW_OBCS_NORTH
                0523          IF ( tileHasOBN(bi,bj) ) THEN
                0524           DO i=1,sNx
                0525            IF ( OB_Jn(i,bi,bj).NE.OB_indexNone ) THEN
                0526             DO jsl= 1,seaiceSpongeThickness
                0527              j=OB_Jn(i,bi,bj)-jsl
                0528              IF ((j.ge.1).and.(j.le.sNy)) THEN
                0529               lambda_obcs = (
                0530      &           float(seaiceSpongeThickness-jsl)*SNrelaxobcsbound
                0531      &           + float(jsl-1)*SNrelaxobcsinner)
                0532      &           / float(seaiceSpongeThickness-1)
                0533               IF (lambda_obcs.ne.0.) THEN
                0534                lambda_obcs = SEAICE_deltaTtherm / lambda_obcs
                0535               ELSE
                0536                lambda_obcs = 0. _d 0
                0537               ENDIF
                0538               HSNOW(i,j,bi,bj) = HSNOW(i,j,bi,bj)
                0539      &           - maskC(i,j,1,bi,bj) * lambda_obcs
                0540      &           * ( HSNOW(i,j,bi,bj) - OBNsn(i,bi,bj) )
                0541              ENDIF
                0542             ENDDO
                0543            ENDIF
                0544           ENDDO
                0545          ENDIF
                0546 # endif
                0547 
                0548 C Southern Open Boundary
                0549 # ifdef ALLOW_OBCS_SOUTH
                0550          IF ( tileHasOBS(bi,bj) ) THEN
                0551           DO i=1,sNx
                0552            IF ( OB_Js(i,bi,bj).NE.OB_indexNone ) THEN
                0553             DO jsl= 1,seaiceSpongeThickness
                0554              j=OB_Js(i,bi,bj)+jsl
                0555              IF ((j.ge.1).and.(j.le.sNy)) THEN
                0556               lambda_obcs = (
                0557      &           float(seaiceSpongeThickness-jsl)*SNrelaxobcsbound
                0558      &           + float(jsl-1)*SNrelaxobcsinner)
                0559      &           / float(seaiceSpongeThickness-1)
                0560               if (lambda_obcs.ne.0.) then
                0561                lambda_obcs = SEAICE_deltaTtherm / lambda_obcs
                0562               else
                0563                lambda_obcs = 0. _d 0
                0564               endif
                0565               HSNOW(i,j,bi,bj) = HSNOW(i,j,bi,bj)
                0566      &           - maskC(i,j,1,bi,bj) * lambda_obcs
                0567      &           * ( HSNOW(i,j,bi,bj) - OBSsn(i,bi,bj) )
                0568              ENDIF
                0569             ENDDO
                0570            ENDIF
                0571           ENDDO
                0572          ENDIF
                0573 # endif
                0574 
                0575 C Eastern Open Boundary
                0576 # ifdef ALLOW_OBCS_EAST
                0577          IF ( tileHasOBE(bi,bj) ) THEN
                0578           DO j=1,sNy
                0579            IF ( OB_Ie(j,bi,bj).NE.OB_indexNone ) THEN
                0580             DO isl= 1,seaiceSpongeThickness
                0581              i=OB_Ie(j,bi,bj)-isl
                0582              IF ((i.ge.1).and.(i.le.sNx)) THEN
                0583               lambda_obcs = (
                0584      &           float(seaiceSpongeThickness-isl)*SNrelaxobcsbound
                0585      &           + float(isl-1)*SNrelaxobcsinner)
                0586      &           / float(seaiceSpongeThickness-1)
                0587               if (lambda_obcs.ne.0.) then
                0588                lambda_obcs = SEAICE_deltaTtherm / lambda_obcs
                0589               else
                0590                lambda_obcs = 0. _d 0
                0591               endif
                0592               HSNOW(i,j,bi,bj) = HSNOW(i,j,bi,bj)
                0593      &           - maskC(i,j,1,bi,bj) * lambda_obcs
                0594      &           * ( HSNOW(i,j,bi,bj) - OBEsn(j,bi,bj) )
                0595              ENDIF
                0596             ENDDO
                0597            ENDIF
                0598           ENDDO
                0599          ENDIF
                0600 # endif
                0601 
                0602 C Western Open Boundary
                0603 # ifdef ALLOW_OBCS_WEST
                0604          IF ( tileHasOBW(bi,bj) ) THEN
                0605           DO j=1,sNy
                0606            IF ( OB_Iw(j,bi,bj).NE.OB_indexNone ) THEN
                0607             DO isl= 1,seaiceSpongeThickness
                0608              i=OB_Iw(j,bi,bj)+isl
                0609              IF ((i.ge.1).and.(i.le.sNx)) THEN
                0610               lambda_obcs= (
                0611      &           float(seaiceSpongeThickness-isl)*SNrelaxobcsbound
                0612      &           + float(isl-1)*SNrelaxobcsinner)
                0613      &           / float(seaiceSpongeThickness-1)
c7c4b57180 Dimi*0614               if (lambda_obcs.ne.0.) then
                0615                lambda_obcs = SEAICE_deltaTtherm / lambda_obcs
                0616               else
                0617                lambda_obcs = 0. _d 0
                0618               endif
5e26aed318 Dimi*0619               HSNOW(i,j,bi,bj) = HSNOW(i,j,bi,bj)
c7c4b57180 Dimi*0620      &           - maskC(i,j,1,bi,bj) * lambda_obcs
5e26aed318 Dimi*0621      &           * ( HSNOW(i,j,bi,bj) - OBWsn(j,bi,bj) )
c7c4b57180 Dimi*0622              ENDIF
                0623             ENDDO
                0624            ENDIF
                0625           ENDDO
                0626          ENDIF
                0627 # endif
                0628 
                0629         ENDDO
                0630        ENDDO
                0631       ENDIF
                0632 
                0633 #endif /* ALLOW_OBCS & ALLOW_SEAICE & ALLOW_OBCS_SEAICE_SPONGE */
                0634 
                0635       RETURN
                0636       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!