pkg/rw/write_rec.F

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