Back to home page

MITgcm
 
 

    

File indexing completed on 2023-08-03 05:10:31 UTC

view on githubraw file Latest commit 57622776 on 2023-08-02 18:02:22 UTC
95b1be38e5 Jean*0001 #include "RW_OPTIONS.h"
                0002 
                0003 C--  File read_write_rec.F: Routines to handle mid-level I/O interface.
                0004 C--   Contents
                0005 C--   o READ_REC_XY_RS
                0006 C--   o READ_REC_XY_RL
                0007 C--   o READ_REC_XYZ_RS
                0008 C--   o READ_REC_XYZ_RL
                0009 C--   o READ_REC_3D_RS
                0010 C--   o READ_REC_3D_RL
c7a37d6618 Jean*0011 C--   o READ_REC_LEV_RS
                0012 C--   o READ_REC_LEV_RL
95b1be38e5 Jean*0013 C--   o READ_REC_XZ_RS
                0014 C--   o READ_REC_XZ_RL
                0015 C--   o READ_REC_YZ_RS
                0016 C--   o READ_REC_YZ_RL
                0017 
c7a37d6618 Jean*0018 C---+----1----+----2----+----3----+----4----+----5----+----6----+----7-|--+----|
95b1be38e5 Jean*0019 CBOP
                0020 C     !ROUTINE: READ_REC_XY_RS
                0021 C     !INTERFACE:
c7a37d6618 Jean*0022       SUBROUTINE READ_REC_XY_RS( fName,field,iRec,myIter,myThid )
95b1be38e5 Jean*0023 C     !DESCRIPTION: \bv
                0024 C READ_REC_XY_RS is a "front-end" interface to the low-level I/O
                0025 C routines.
                0026 C     \ev
                0027 C     !USES:
                0028       IMPLICIT NONE
                0029 C Global
                0030 #include "SIZE.h"
                0031 #include "EEPARAMS.h"
                0032 #include "PARAMS.h"
                0033 C     !INPUT/OUTPUT PARAMETERS:
                0034 C Arguments
                0035       CHARACTER*(*) fName
57622776fd Jean*0036       _RS field(1-OLx:sNx+OLx,1-OLy:sNy+OLy,nSx,nSy)
95b1be38e5 Jean*0037       INTEGER iRec
                0038       INTEGER myIter
                0039       INTEGER myThid
                0040 
                0041 C Functions
                0042 c     INTEGER ILNBLNK
                0043 
                0044 C     !LOCAL VARIABLES:
                0045 C Local
c7a37d6618 Jean*0046       LOGICAL useCurrentDir
827db6a998 Jean*0047       _RL dummyRL(1)
95b1be38e5 Jean*0048       CHARACTER*(2) fType
                0049       INTEGER nNz
                0050 c     INTEGER IL
                0051 c     CHARACTER*(MAX_LEN_FNAM) fullName
                0052 CEOP
                0053 
                0054 c     IF (myIter.GE.0) THEN
                0055 c      IL=ILNBLNK( fName )
                0056 c      WRITE(fullName,'(2a,i10.10)') fName(1:IL),'.',myIter
                0057 c     ELSE
                0058 c      fullName=fName
                0059 c     ENDIF
                0060 
c7a37d6618 Jean*0061       useCurrentDir = .FALSE.
95b1be38e5 Jean*0062       fType='RS'
                0063       nNz=1
                0064 #ifdef ALLOW_MDSIO
c7a37d6618 Jean*0065       CALL MDS_READ_FIELD(
                0066      I                     fName, readBinaryPrec, useCurrentDir,
                0067      I                     fType, nNz, 1, nNz,
827db6a998 Jean*0068      O                     dummyRL, field,
c7a37d6618 Jean*0069      I                     iRec, myThid )
95b1be38e5 Jean*0070 #endif
                0071       RETURN
                0072       END
                0073 
c7a37d6618 Jean*0074 C---+----1----+----2----+----3----+----4----+----5----+----6----+----7-|--+----|
95b1be38e5 Jean*0075 CBOP
                0076 C     !ROUTINE: READ_REC_XY_RL
                0077 C     !INTERFACE:
c7a37d6618 Jean*0078       SUBROUTINE READ_REC_XY_RL( fName,field,iRec,myIter,myThid )
95b1be38e5 Jean*0079 
                0080 C     !DESCRIPTION: \bv
                0081 C READ_REC_XY_RL is a "front-end" interface to the low-level I/O
                0082 C routines.
                0083 C     \ev
                0084 
                0085 C     !USES:
                0086       IMPLICIT NONE
                0087 C Global
                0088 #include "SIZE.h"
                0089 #include "EEPARAMS.h"
                0090 #include "PARAMS.h"
                0091 
                0092 C     !INPUT/OUTPUT PARAMETERS:
                0093 C Arguments
                0094       CHARACTER*(*) fName
57622776fd Jean*0095       _RL field(1-OLx:sNx+OLx,1-OLy:sNy+OLy,nSx,nSy)
95b1be38e5 Jean*0096       INTEGER iRec
                0097       INTEGER myIter
                0098       INTEGER myThid
                0099 
                0100 C Functions
                0101 c     INTEGER ILNBLNK
                0102 
                0103 C     !LOCAL VARIABLES:
                0104 C Local
c7a37d6618 Jean*0105       LOGICAL useCurrentDir
827db6a998 Jean*0106       _RS dummyRS(1)
95b1be38e5 Jean*0107       CHARACTER*(2) fType
                0108       INTEGER nNz
                0109 c     INTEGER IL
                0110 c     CHARACTER*(MAX_LEN_FNAM) fullName
                0111 CEOP
                0112 
                0113 c     IF (myIter.GE.0) THEN
                0114 c      IL=ILNBLNK( fName )
                0115 c      WRITE(fullName,'(2a,i10.10)') fName(1:IL),'.',myIter
                0116 c     ELSE
                0117 c      fullName=fName
                0118 c     ENDIF
                0119 
c7a37d6618 Jean*0120       useCurrentDir = .FALSE.
95b1be38e5 Jean*0121       fType='RL'
                0122       nNz=1
                0123 #ifdef ALLOW_MDSIO
c7a37d6618 Jean*0124       CALL MDS_READ_FIELD(
                0125      I                     fName, readBinaryPrec, useCurrentDir,
                0126      I                     fType, nNz, 1, nNz,
827db6a998 Jean*0127      O                     field, dummyRS,
c7a37d6618 Jean*0128      I                     iRec, myThid )
95b1be38e5 Jean*0129 #endif
                0130       RETURN
                0131       END
                0132 
c7a37d6618 Jean*0133 C---+----1----+----2----+----3----+----4----+----5----+----6----+----7-|--+----|
95b1be38e5 Jean*0134 CBOP
                0135 C     !ROUTINE: READ_REC_XYZ_RS
                0136 C     !INTERFACE:
c7a37d6618 Jean*0137       SUBROUTINE READ_REC_XYZ_RS( fName,field,iRec,myIter,myThid )
95b1be38e5 Jean*0138 
                0139 C     !DESCRIPTION: \bv
                0140 C READ_REC_XYZ_RS is a "front-end" interface to the low-level I/O
                0141 C routines.
                0142 C     \ev
                0143 
                0144 C     !USES:
                0145       IMPLICIT NONE
                0146 C Global
                0147 #include "SIZE.h"
                0148 #include "EEPARAMS.h"
                0149 #include "PARAMS.h"
                0150 
                0151 C     !INPUT/OUTPUT PARAMETERS:
                0152 C Arguments
                0153       CHARACTER*(*) fName
57622776fd Jean*0154       _RS field(1-OLx:sNx+OLx,1-OLy:sNy+OLy,Nr,nSx,nSy)
95b1be38e5 Jean*0155       INTEGER iRec
                0156       INTEGER myIter
                0157       INTEGER myThid
                0158 
                0159 C Functions
                0160 c     INTEGER ILNBLNK
                0161 
                0162 C     !LOCAL VARIABLES:
                0163 C Local
c7a37d6618 Jean*0164       LOGICAL useCurrentDir
827db6a998 Jean*0165       _RL dummyRL(1)
95b1be38e5 Jean*0166       CHARACTER*(2) fType
                0167       INTEGER nNz
                0168 c     INTEGER IL
                0169 c     CHARACTER*(MAX_LEN_FNAM) fullName
                0170 CEOP
                0171 
                0172 c     IF (myIter.GE.0) THEN
                0173 c      IL=ILNBLNK( fName )
                0174 c      WRITE(fullName,'(2a,i10.10)') fName(1:IL),'.',myIter
                0175 c     ELSE
                0176 c      fullName=fName
                0177 c     ENDIF
                0178 
c7a37d6618 Jean*0179       useCurrentDir = .FALSE.
95b1be38e5 Jean*0180       fType='RS'
                0181       nNz=Nr
                0182 #ifdef ALLOW_MDSIO
c7a37d6618 Jean*0183       CALL MDS_READ_FIELD(
                0184      I                     fName, readBinaryPrec, useCurrentDir,
                0185      I                     fType, nNz, 1, nNz,
827db6a998 Jean*0186      O                     dummyRL, field,
c7a37d6618 Jean*0187      I                     iRec, myThid )
95b1be38e5 Jean*0188 #endif
                0189       RETURN
                0190       END
                0191 
c7a37d6618 Jean*0192 C---+----1----+----2----+----3----+----4----+----5----+----6----+----7-|--+----|
95b1be38e5 Jean*0193 CBOP
                0194 C     !ROUTINE: READ_REC_XYZ_RL
                0195 C     !INTERFACE:
c7a37d6618 Jean*0196       SUBROUTINE READ_REC_XYZ_RL( fName,field,iRec,myIter,myThid )
95b1be38e5 Jean*0197 
                0198 C     !DESCRIPTION: \bv
                0199 C READ_REC_XYZ_RL is a "front-end" interface to the low-level I/O
                0200 C routines.
                0201 C     \ev
                0202 
                0203 C     !USES:
                0204       IMPLICIT NONE
                0205 C Global
                0206 #include "SIZE.h"
                0207 #include "EEPARAMS.h"
                0208 #include "PARAMS.h"
                0209 
                0210 C     !INPUT/OUTPUT PARAMETERS:
                0211 C Arguments
                0212       CHARACTER*(*) fName
57622776fd Jean*0213       _RL field(1-OLx:sNx+OLx,1-OLy:sNy+OLy,Nr,nSx,nSy)
95b1be38e5 Jean*0214       INTEGER iRec
                0215       INTEGER myIter
                0216       INTEGER myThid
                0217 
                0218 C Functions
                0219 c     INTEGER ILNBLNK
                0220 
                0221 C     !LOCAL VARIABLES:
                0222 C Local
c7a37d6618 Jean*0223       LOGICAL useCurrentDir
827db6a998 Jean*0224       _RS dummyRS(1)
95b1be38e5 Jean*0225       CHARACTER*(2) fType
                0226       INTEGER nNz
                0227 c     INTEGER IL
                0228 c     CHARACTER*(MAX_LEN_FNAM) fullName
                0229 CEOP
                0230 
                0231 c     IF (myIter.GE.0) THEN
                0232 c      IL=ILNBLNK( fName )
                0233 c      WRITE(fullName,'(2a,i10.10)') fName(1:IL),'.',myIter
                0234 c     ELSE
                0235 c      fullName=fName
                0236 c     ENDIF
                0237 
c7a37d6618 Jean*0238       useCurrentDir = .FALSE.
95b1be38e5 Jean*0239       fType='RL'
                0240       nNz=Nr
                0241 #ifdef ALLOW_MDSIO
c7a37d6618 Jean*0242       CALL MDS_READ_FIELD(
                0243      I                     fName, readBinaryPrec, useCurrentDir,
                0244      I                     fType, nNz, 1, nNz,
827db6a998 Jean*0245      O                     field, dummyRS,
c7a37d6618 Jean*0246      I                     iRec, myThid )
95b1be38e5 Jean*0247 #endif
                0248       RETURN
                0249       END
                0250 
c7a37d6618 Jean*0251 C---+----1----+----2----+----3----+----4----+----5----+----6----+----7-|--+----|
95b1be38e5 Jean*0252 CBOP
                0253 C     !ROUTINE: READ_REC_3D_RS
                0254 C     !INTERFACE:
                0255       SUBROUTINE READ_REC_3D_RS(
                0256      I                           fName, fPrec, nNz,
                0257      O                           field,
                0258      I                           iRec, myIter, myThid )
                0259 
                0260 C     !DESCRIPTION: \bv
                0261 C READ_REC_3D_RS is a "front-end" interface to the low-level I/O routines.
                0262 C  read a full 3D field (nNz levels) from record number "iRec"
                0263 C   in binary file "fName" (precision "fPrec", generally =32 or 64).
                0264 C     \ev
                0265 
                0266 C     !USES:
                0267       IMPLICIT NONE
                0268 C Global
                0269 #include "SIZE.h"
                0270 #include "EEPARAMS.h"
                0271 #include "PARAMS.h"
                0272 
                0273 C     !INPUT/OUTPUT PARAMETERS:
                0274 C Arguments
                0275       CHARACTER*(*) fName
                0276       INTEGER fPrec
                0277       INTEGER nNz
57622776fd Jean*0278       _RS field(1-OLx:sNx+OLx,1-OLy:sNy+OLy,nNz,nSx,nSy)
95b1be38e5 Jean*0279       INTEGER iRec
                0280       INTEGER myIter
                0281       INTEGER myThid
                0282 
                0283 C Functions
                0284 c     INTEGER ILNBLNK
                0285 
                0286 C     !LOCAL VARIABLES:
                0287 C Local
c7a37d6618 Jean*0288       LOGICAL useCurrentDir
827db6a998 Jean*0289       _RL dummyRL(1)
95b1be38e5 Jean*0290       CHARACTER*(2) fType
                0291 c     INTEGER IL
                0292 c     CHARACTER*(MAX_LEN_FNAM) fullName
                0293 CEOP
                0294 
                0295 c     IF (myIter.GE.0) THEN
                0296 c      IL=ILNBLNK( fName )
                0297 c      WRITE(fullName,'(2a,i10.10)') fName(1:IL),'.',myIter
                0298 c     ELSE
                0299 c      fullName=fName
                0300 c     ENDIF
                0301 
c7a37d6618 Jean*0302       useCurrentDir = .FALSE.
95b1be38e5 Jean*0303       fType='RS'
                0304 #ifdef ALLOW_MDSIO
c7a37d6618 Jean*0305       CALL MDS_READ_FIELD(
                0306      I                     fName, fPrec, useCurrentDir,
                0307      I                     fType, nNz, 1, nNz,
827db6a998 Jean*0308      O                     dummyRL, field,
c7a37d6618 Jean*0309      I                     iRec, myThid )
95b1be38e5 Jean*0310 #endif
                0311       RETURN
                0312       END
                0313 
c7a37d6618 Jean*0314 C---+----1----+----2----+----3----+----4----+----5----+----6----+----7-|--+----|
95b1be38e5 Jean*0315 CBOP
                0316 C     !ROUTINE: READ_REC_3D_RL
                0317 C     !INTERFACE:
                0318       SUBROUTINE READ_REC_3D_RL(
                0319      I                           fName, fPrec, nNz,
                0320      O                           field,
                0321      I                           iRec, myIter, myThid )
                0322 
                0323 C     !DESCRIPTION: \bv
                0324 C READ_REC_3D_RL is a "front-end" interface to the low-level I/O routines.
                0325 C  read a full 3D field (nNz levels) from record number "iRec"
                0326 C   in binary file "fName" (precision "fPrec", generally =32 or 64).
                0327 C     \ev
                0328 
                0329 C     !USES:
                0330       IMPLICIT NONE
                0331 C Global
                0332 #include "SIZE.h"
                0333 #include "EEPARAMS.h"
                0334 #include "PARAMS.h"
                0335 
                0336 C     !INPUT/OUTPUT PARAMETERS:
                0337 C Arguments
                0338       CHARACTER*(*) fName
                0339       INTEGER fPrec
                0340       INTEGER nNz
57622776fd Jean*0341       _RL field(1-OLx:sNx+OLx,1-OLy:sNy+OLy,nNz,nSx,nSy)
95b1be38e5 Jean*0342       INTEGER iRec
                0343       INTEGER myIter
                0344       INTEGER myThid
                0345 
                0346 C Functions
                0347 c     INTEGER ILNBLNK
                0348 
                0349 C     !LOCAL VARIABLES:
                0350 C Local
c7a37d6618 Jean*0351       LOGICAL useCurrentDir
827db6a998 Jean*0352       _RS dummyRS(1)
95b1be38e5 Jean*0353       CHARACTER*(2) fType
                0354 c     INTEGER IL
                0355 c     CHARACTER*(MAX_LEN_FNAM) fullName
                0356 CEOP
                0357 
                0358 c     IF (myIter.GE.0) THEN
                0359 c      IL=ILNBLNK( fName )
                0360 c      WRITE(fullName,'(2a,i10.10)') fName(1:IL),'.',myIter
                0361 c     ELSE
                0362 c      fullName=fName
                0363 c     ENDIF
                0364 
c7a37d6618 Jean*0365       useCurrentDir = .FALSE.
95b1be38e5 Jean*0366       fType='RL'
                0367 #ifdef ALLOW_MDSIO
c7a37d6618 Jean*0368       CALL MDS_READ_FIELD(
                0369      I                     fName, fPrec, useCurrentDir,
                0370      I                     fType, nNz, 1, nNz,
827db6a998 Jean*0371      O                     field, dummyRS,
c7a37d6618 Jean*0372      I                     iRec, myThid )
                0373 #endif
                0374       RETURN
                0375       END
                0376 
                0377 C---+----1----+----2----+----3----+----4----+----5----+----6----+----7-|--+----|
                0378 CBOP
                0379 C     !ROUTINE: READ_REC_LEV_RS
                0380 C     !INTERFACE:
                0381       SUBROUTINE READ_REC_LEV_RS(
                0382      I                           fName, fPrec, kSiz, kLo, kHi,
                0383      O                           field,
                0384      I                           iRec, myIter, myThid )
                0385 
                0386 C     !DESCRIPTION: \bv
                0387 C READ_REC_LEV_RS is a "front-end" interface to the low-level I/O routines.
                0388 C  Read a set a consecutive levels (from kLo to kHi) into 3D array (size: kSiz)
                0389 C  from record number "iRec" in binary file "fName" (precision "fPrec",
                0390 C  generally =32 or 64).
                0391 C     \ev
                0392 
                0393 C     !USES:
                0394       IMPLICIT NONE
                0395 C Global
                0396 #include "SIZE.h"
                0397 #include "EEPARAMS.h"
                0398 #include "PARAMS.h"
                0399 
                0400 C     !INPUT/OUTPUT PARAMETERS:
                0401 C Arguments
                0402       CHARACTER*(*) fName
                0403       INTEGER fPrec
                0404       INTEGER kSiz, kLo, kHi
57622776fd Jean*0405       _RS field(1-OLx:sNx+OLx,1-OLy:sNy+OLy,kSiz,nSx,nSy)
c7a37d6618 Jean*0406       INTEGER iRec
                0407       INTEGER myIter
                0408       INTEGER myThid
                0409 
                0410 C Functions
                0411 c     INTEGER ILNBLNK
                0412 
                0413 C     !LOCAL VARIABLES:
                0414 C Local
                0415       LOGICAL useCurrentDir
827db6a998 Jean*0416       _RL dummyRL(1)
c7a37d6618 Jean*0417       CHARACTER*(2) fType
                0418 c     INTEGER IL
                0419 c     CHARACTER*(MAX_LEN_FNAM) fullName
                0420 CEOP
                0421 
                0422 c     IF (myIter.GE.0) THEN
                0423 c      IL=ILNBLNK( fName )
                0424 c      WRITE(fullName,'(2a,i10.10)') fName(1:IL),'.',myIter
                0425 c     ELSE
                0426 c      fullName=fName
                0427 c     ENDIF
                0428 
                0429       useCurrentDir = .FALSE.
                0430       fType='RS'
                0431 #ifdef ALLOW_MDSIO
                0432       CALL MDS_READ_FIELD(
                0433      I                     fName, fPrec, useCurrentDir,
                0434      I                     fType, kSiz, kLo, kHi,
827db6a998 Jean*0435      O                     dummyRL, field,
c7a37d6618 Jean*0436      I                     iRec, myThid )
                0437 #endif
                0438       RETURN
                0439       END
                0440 
                0441 C---+----1----+----2----+----3----+----4----+----5----+----6----+----7-|--+----|
                0442 CBOP
                0443 C     !ROUTINE: READ_REC_LEV_RL
                0444 C     !INTERFACE:
                0445       SUBROUTINE READ_REC_LEV_RL(
                0446      I                           fName, fPrec, kSiz, kLo, kHi,
                0447      O                           field,
                0448      I                           iRec, myIter, myThid )
                0449 
                0450 C     !DESCRIPTION: \bv
                0451 C READ_REC_LEV_RL is a "front-end" interface to the low-level I/O routines.
                0452 C  Read a set a consecutive levels (from kLo to kHi) into 3D array (size: kSiz)
                0453 C  from record number "iRec" in binary file "fName" (precision "fPrec",
                0454 C  generally =32 or 64).
                0455 C     \ev
                0456 
                0457 C     !USES:
                0458       IMPLICIT NONE
                0459 C Global
                0460 #include "SIZE.h"
                0461 #include "EEPARAMS.h"
                0462 #include "PARAMS.h"
                0463 
                0464 C     !INPUT/OUTPUT PARAMETERS:
                0465 C Arguments
                0466       CHARACTER*(*) fName
                0467       INTEGER fPrec
                0468       INTEGER kSiz, kLo, kHi
57622776fd Jean*0469       _RL field(1-OLx:sNx+OLx,1-OLy:sNy+OLy,kSiz,nSx,nSy)
c7a37d6618 Jean*0470       INTEGER iRec
                0471       INTEGER myIter
                0472       INTEGER myThid
                0473 
                0474 C Functions
                0475 c     INTEGER ILNBLNK
                0476 
                0477 C     !LOCAL VARIABLES:
                0478 C Local
                0479       LOGICAL useCurrentDir
827db6a998 Jean*0480       _RS dummyRS(1)
c7a37d6618 Jean*0481       CHARACTER*(2) fType
                0482 c     INTEGER IL
                0483 c     CHARACTER*(MAX_LEN_FNAM) fullName
                0484 CEOP
                0485 
                0486 c     IF (myIter.GE.0) THEN
                0487 c      IL=ILNBLNK( fName )
                0488 c      WRITE(fullName,'(2a,i10.10)') fName(1:IL),'.',myIter
                0489 c     ELSE
                0490 c      fullName=fName
                0491 c     ENDIF
                0492 
                0493       useCurrentDir = .FALSE.
                0494       fType='RL'
                0495 #ifdef ALLOW_MDSIO
                0496       CALL MDS_READ_FIELD(
                0497      I                     fName, fPrec, useCurrentDir,
                0498      I                     fType, kSiz, kLo, kHi,
827db6a998 Jean*0499      O                     field, dummyRS,
c7a37d6618 Jean*0500      I                     iRec, myThid )
95b1be38e5 Jean*0501 #endif
                0502       RETURN
                0503       END
                0504 
c7a37d6618 Jean*0505 C---+----1----+----2----+----3----+----4----+----5----+----6----+----7-|--+----|
95b1be38e5 Jean*0506 CBOP
                0507 C     !ROUTINE: READ_REC_XZ_RS
                0508 C     !INTERFACE:
827db6a998 Jean*0509       SUBROUTINE READ_REC_XZ_RS(
                0510      I                           fName, fPrec, nNz,
                0511      O                           field,
                0512      I                           iRec, myIter, myThid )
95b1be38e5 Jean*0513 
                0514 C     !DESCRIPTION: \bv
                0515 C READ_REC_XZ_RS is a "front-end" interface to the low-level I/O
                0516 C routines.
                0517 C     \ev
                0518 
                0519 C     !USES:
                0520       IMPLICIT NONE
                0521 C Global
                0522 #include "SIZE.h"
                0523 #include "EEPARAMS.h"
                0524 #include "PARAMS.h"
                0525 C     !INPUT/OUTPUT PARAMETERS:
                0526 C Arguments
                0527       CHARACTER*(*) fName
827db6a998 Jean*0528       INTEGER fPrec
                0529       INTEGER nNz
57622776fd Jean*0530       _RS field(1-OLx:sNx+OLx,nNz,nSx,nSy)
95b1be38e5 Jean*0531       INTEGER iRec
                0532       INTEGER myIter
                0533       INTEGER myThid
                0534 
                0535 C Functions
                0536 c     INTEGER ILNBLNK
                0537 
                0538 C     !LOCAL VARIABLES:
                0539 C Local
827db6a998 Jean*0540       LOGICAL useCurrentDir
                0541       _RL dummyRL(1)
95b1be38e5 Jean*0542       CHARACTER*(2) fType
                0543 c     INTEGER IL
                0544 c     CHARACTER*(MAX_LEN_FNAM) fullName
                0545 CEOP
                0546 
                0547 c     IF (myIter.GE.0) THEN
                0548 c      IL=ILNBLNK( fName )
                0549 c      WRITE(fullName,'(2a,i10.10)') fName(1:IL),'.',myIter
                0550 c     ELSE
                0551 c      fullName=fName
                0552 c     ENDIF
                0553 
827db6a998 Jean*0554       useCurrentDir = .FALSE.
95b1be38e5 Jean*0555       fType='RS'
                0556 #ifdef ALLOW_MDSIO
827db6a998 Jean*0557       CALL MDS_READ_SEC_XZ(
                0558      I                      fName, fPrec, useCurrentDir,
57622776fd Jean*0559      I                      fType, nNz, 1, nNz,
827db6a998 Jean*0560      O                      dummyRL, field,
                0561      I                      iRec, myThid )
95b1be38e5 Jean*0562 #endif
                0563       RETURN
                0564       END
                0565 
c7a37d6618 Jean*0566 C---+----1----+----2----+----3----+----4----+----5----+----6----+----7-|--+----|
95b1be38e5 Jean*0567 CBOP
                0568 C     !ROUTINE: READ_REC_XZ_RL
                0569 C     !INTERFACE:
827db6a998 Jean*0570       SUBROUTINE READ_REC_XZ_RL(
                0571      I                           fName, fPrec, nNz,
                0572      O                           field,
                0573      I                           iRec, myIter, myThid )
95b1be38e5 Jean*0574 
                0575 C     !DESCRIPTION: \bv
                0576 C READ_REC_XZ_RL is a "front-end" interface to the low-level I/O
                0577 C routines.
                0578 C     \ev
                0579 
                0580 C     !USES:
                0581       IMPLICIT NONE
                0582 C Global
                0583 #include "SIZE.h"
                0584 #include "EEPARAMS.h"
                0585 #include "PARAMS.h"
                0586 
                0587 C     !INPUT/OUTPUT PARAMETERS:
                0588 C Arguments
                0589       CHARACTER*(*) fName
827db6a998 Jean*0590       INTEGER fPrec
                0591       INTEGER nNz
57622776fd Jean*0592       _RL field(1-OLx:sNx+OLx,nNz,nSx,nSy)
95b1be38e5 Jean*0593       INTEGER iRec
                0594       INTEGER myIter
                0595       INTEGER myThid
                0596 
                0597 C Functions
                0598 c     INTEGER ILNBLNK
                0599 
                0600 C     !LOCAL VARIABLES:
                0601 C Local
827db6a998 Jean*0602       LOGICAL useCurrentDir
                0603       _RS dummyRS(1)
95b1be38e5 Jean*0604       CHARACTER*(2) fType
                0605 c     INTEGER IL
                0606 c     CHARACTER*(MAX_LEN_FNAM) fullName
                0607 CEOP
                0608 
                0609 c     IF (myIter.GE.0) THEN
                0610 c      IL=ILNBLNK( fName )
                0611 c      WRITE(fullName,'(2a,i10.10)') fName(1:IL),'.',myIter
                0612 c     ELSE
                0613 c      fullName=fName
                0614 c     ENDIF
                0615 
827db6a998 Jean*0616       useCurrentDir = .FALSE.
95b1be38e5 Jean*0617       fType='RL'
                0618 #ifdef ALLOW_MDSIO
827db6a998 Jean*0619       CALL MDS_READ_SEC_XZ(
                0620      I                      fName, fPrec, useCurrentDir,
57622776fd Jean*0621      I                      fType, nNz, 1, nNz,
827db6a998 Jean*0622      O                      field, dummyRS,
                0623      I                      iRec, myThid )
95b1be38e5 Jean*0624 #endif
                0625       RETURN
                0626       END
                0627 
c7a37d6618 Jean*0628 C---+----1----+----2----+----3----+----4----+----5----+----6----+----7-|--+----|
95b1be38e5 Jean*0629 CBOP
                0630 C     !ROUTINE: READ_REC_YZ_RS
                0631 C     !INTERFACE:
827db6a998 Jean*0632       SUBROUTINE READ_REC_YZ_RS(
                0633      I                           fName, fPrec, nNz,
                0634      O                           field,
                0635      I                           iRec, myIter, myThid )
95b1be38e5 Jean*0636 
                0637 C     !DESCRIPTION: \bv
                0638 C READ_REC_YZ_RS is a "front-end" interface to the low-level I/O
                0639 C routines.
                0640 C     \ev
                0641 
                0642 C     !USES:
                0643       IMPLICIT NONE
                0644 C Global
                0645 #include "SIZE.h"
                0646 #include "EEPARAMS.h"
                0647 #include "PARAMS.h"
                0648 
                0649 C     !INPUT/OUTPUT PARAMETERS:
                0650 C Arguments
                0651       CHARACTER*(*) fName
827db6a998 Jean*0652       INTEGER fPrec
                0653       INTEGER nNz
57622776fd Jean*0654       _RS field(1-OLy:sNy+OLy,nNz,nSx,nSy)
95b1be38e5 Jean*0655       INTEGER iRec
                0656       INTEGER myIter
                0657       INTEGER myThid
                0658 
                0659 C Functions
                0660 c     INTEGER ILNBLNK
                0661 
                0662 C     !LOCAL VARIABLES:
                0663 C Local
827db6a998 Jean*0664       LOGICAL useCurrentDir
                0665       _RL dummyRL(1)
95b1be38e5 Jean*0666       CHARACTER*(2) fType
                0667 c     INTEGER IL
                0668 c     CHARACTER*(MAX_LEN_FNAM) fullName
                0669 CEOP
                0670 
                0671 c     IF (myIter.GE.0) THEN
                0672 c      IL=ILNBLNK( fName )
                0673 c      WRITE(fullName,'(2a,i10.10)') fName(1:IL),'.',myIter
                0674 c     ELSE
                0675 c      fullName=fName
                0676 c     ENDIF
                0677 
827db6a998 Jean*0678       useCurrentDir = .FALSE.
95b1be38e5 Jean*0679       fType='RS'
                0680 #ifdef ALLOW_MDSIO
827db6a998 Jean*0681       CALL MDS_READ_SEC_YZ(
                0682      I                      fName, fPrec, useCurrentDir,
57622776fd Jean*0683      I                      fType, nNz, 1, nNz,
827db6a998 Jean*0684      O                      dummyRL, field,
                0685      I                      iRec, myThid )
95b1be38e5 Jean*0686 #endif
                0687       RETURN
                0688       END
                0689 
c7a37d6618 Jean*0690 C---+----1----+----2----+----3----+----4----+----5----+----6----+----7-|--+----|
95b1be38e5 Jean*0691 CBOP
                0692 C     !ROUTINE: READ_REC_YZ_RL
                0693 C     !INTERFACE:
827db6a998 Jean*0694       SUBROUTINE READ_REC_YZ_RL(
                0695      I                           fName, fPrec, nNz,
                0696      O                           field,
                0697      I                           iRec, myIter, myThid )
95b1be38e5 Jean*0698 
                0699 C     !DESCRIPTION: \bv
                0700 C READ_REC_YZ_RL is a "front-end" interface to the low-level I/O
                0701 C routines.
                0702 C     \ev
                0703 
                0704 C     !USES:
                0705       IMPLICIT NONE
                0706 C Global
                0707 #include "SIZE.h"
                0708 #include "EEPARAMS.h"
                0709 #include "PARAMS.h"
                0710 
                0711 C     !INPUT/OUTPUT PARAMETERS:
                0712 C Arguments
                0713       CHARACTER*(*) fName
827db6a998 Jean*0714       INTEGER fPrec
                0715       INTEGER nNz
57622776fd Jean*0716       _RL field(1-OLy:sNy+OLy,nNz,nSx,nSy)
95b1be38e5 Jean*0717       INTEGER iRec
                0718       INTEGER myIter
                0719       INTEGER myThid
                0720 
                0721 C Functions
                0722 c     INTEGER ILNBLNK
                0723 
                0724 C     !LOCAL VARIABLES:
                0725 C Local
827db6a998 Jean*0726       LOGICAL useCurrentDir
                0727       _RS dummyRS(1)
95b1be38e5 Jean*0728       CHARACTER*(2) fType
                0729 c     INTEGER IL
                0730 c     CHARACTER*(MAX_LEN_FNAM) fullName
                0731 CEOP
                0732 
                0733 c     IF (myIter.GE.0) THEN
                0734 c      IL=ILNBLNK( fName )
                0735 c      WRITE(fullName,'(2a,i10.10)') fName(1:IL),'.',myIter
                0736 c     ELSE
                0737 c      fullName=fName
                0738 c     ENDIF
                0739 
827db6a998 Jean*0740       useCurrentDir = .FALSE.
95b1be38e5 Jean*0741       fType='RL'
                0742 #ifdef ALLOW_MDSIO
827db6a998 Jean*0743       CALL MDS_READ_SEC_YZ(
                0744      I                      fName, fPrec, useCurrentDir,
57622776fd Jean*0745      I                      fType, nNz, 1, nNz,
827db6a998 Jean*0746      O                      field, dummyRS,
                0747      I                      iRec, myThid )
95b1be38e5 Jean*0748 #endif
                0749       RETURN
                0750       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!