LCOV - code coverage report
Current view: top level - hemco/HEMCO/src/Shared/NcdfUtil - hco_m_netcdf_io_write.F90 (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 210 0.0 %
Date: 2025-03-13 18:42:46 Functions: 0 21 0.0 %

          Line data    Source code
       1             : ! $Id: m_netcdf_io_write.F90,v 1.1 2009/08/04 14:52:05 bmy Exp $
       2             : !-------------------------------------------------------------------------
       3             : !  NASA/GFSC, SIVO, Code 610.3
       4             : !-------------------------------------------------------------------------
       5             : !BOP
       6             : !
       7             : ! !MODULE:  HCO_m_netcdf_io_write
       8             : !
       9             : ! !INTERFACE:
      10             : !
      11             :       module HCO_m_netcdf_io_write
      12             : !
      13             :       IMPLICIT NONE
      14             :       PRIVATE
      15             : !
      16             : ! !PUBLIC MEMBER FUNCTIONS:
      17             : !
      18             :       ! Public interface
      19             :       PUBLIC :: NcWr
      20             : 
      21             :       ! Private methods overloaded by public interface
      22             :       ! (see below for info about these routines & the arguments they take)
      23             :       INTERFACE NcWr
      24             :          MODULE PROCEDURE Ncwr_Scal_R4
      25             :          MODULE PROCEDURE Ncwr_Scal_R8
      26             :          MODULE PROCEDURE Ncwr_Scal_Int
      27             :          MODULE PROCEDURE Ncwr_1d_R8
      28             :          MODULE PROCEDURE Ncwr_1d_R4
      29             :          MODULE PROCEDURE Ncwr_1d_Int
      30             :          MODULE PROCEDURE Ncwr_1d_Char
      31             :          MODULE PROCEDURE Ncwr_2d_R8
      32             :          MODULE PROCEDURE Ncwr_2d_R4
      33             :          MODULE PROCEDURE Ncwr_2d_Int
      34             :          MODULE PROCEDURE Ncwr_2d_Char
      35             :          MODULE PROCEDURE Ncwr_3d_R8
      36             :          MODULE PROCEDURE Ncwr_3d_R4
      37             :          MODULE PROCEDURE Ncwr_3d_Int
      38             :          MODULE PROCEDURE Ncwr_4d_R8
      39             :          MODULE PROCEDURE Ncwr_4d_R4
      40             :          MODULE PROCEDURE Ncwr_4d_Int
      41             :          MODULE PROCEDURE Ncwr_5d_R8
      42             :          MODULE PROCEDURE Ncwr_5d_R4
      43             :          MODULE PROCEDURE Ncwr_6d_R8
      44             :          MODULE PROCEDURE Ncwr_6d_R4
      45             : 
      46             :       END INTERFACE
      47             : !
      48             : ! !DESCRIPTION: Routines for writing variables in a netCDF file.
      49             : !\\
      50             : !\\
      51             : ! !AUTHOR:
      52             : !  Jules Kouatchou
      53             : !
      54             : ! !REVISION HISTORY:
      55             : !  See https://github.com/geoschem/ncdfutil for complete history
      56             : !EOP
      57             : !-------------------------------------------------------------------------
      58             : 
      59             : CONTAINS
      60             : 
      61             : 
      62             : !-------------------------------------------------------------------------
      63             : !BOP
      64             : !
      65             : ! !IROUTINE: Ncwr_Scal_R4
      66             : !
      67             : ! !INTERFACE:
      68             : !
      69           0 :       subroutine Ncwr_Scal_R4(varwr_scal, ncid, varname)
      70             : !
      71             : ! !USES:
      72             : !
      73             :       use m_do_err_out
      74             : !
      75             :       implicit none
      76             : !
      77             :       include "netcdf.inc"
      78             : !
      79             : ! !INPUT PARAMETERS:
      80             : !!     ncid       : netCDF file id to write variable to
      81             : !!     varname    : netCDF variable name
      82             : !!     varwr_scal : variable to write out
      83             :       integer          , intent(in)   :: ncid
      84             :       character (len=*), intent(in)   :: varname
      85             :       real*4           , intent(in)   :: varwr_scal
      86             : 
      87             : !
      88             : ! !DESCRIPTION: Writes out a netCDF real scalar variable.
      89             : !\\
      90             : !\\
      91             : ! !AUTHOR:
      92             : !  John Tannahill (LLNL) and Jules Kouatchou
      93             : !
      94             : ! !REVISION HISTORY:
      95             : !  See https://github.com/geoschem/ncdfutil for complete history
      96             : !EOP
      97             : !-------------------------------------------------------------------------
      98             : !BOC
      99             : !
     100             : ! !LOCAL VARIABLES:
     101             :       character (len=512) :: err_msg
     102             :       integer             :: ierr
     103             :       integer             :: varid
     104             : !
     105           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
     106             : 
     107           0 :       if (ierr /= NF_NOERR) then
     108             :         err_msg = 'In Ncwr_Scal_R4 #1:  ' // Trim (varname) // &
     109           0 :                  ', ' // Nf_Strerror (ierr)
     110           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
     111             :       end if
     112             : 
     113           0 :       ierr = Nf_Put_Var_Real (ncid, varid, varwr_scal)
     114             : 
     115           0 :       if (ierr /= NF_NOERR) then
     116           0 :         err_msg = 'In Ncwr_Scal+R4 #2:  ' // Nf_Strerror (ierr)
     117           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
     118             :       end if
     119             : 
     120           0 :       end subroutine Ncwr_Scal_R4
     121             : !-------------------------------------------------------------------------
     122             : !BOP
     123             : !
     124             : ! !IROUTINE: Ncwr_Scal_R8
     125             : !
     126             : ! !INTERFACE:
     127             : !
     128           0 :       subroutine Ncwr_Scal_R8 (varwr_scal, ncid, varname)
     129             : !
     130             : ! !USES:
     131             : !
     132             :       use m_do_err_out
     133             : !
     134             :       implicit none
     135             : !
     136             :       include "netcdf.inc"
     137             : !
     138             : ! !INPUT PARAMETERS:
     139             : !!     ncid       : netCDF file id to write variable to
     140             : !!     varname    : netCDF variable name
     141             : !!     varwr_scal : variable to write out
     142             :       integer          , intent(in)   :: ncid
     143             :       character (len=*), intent(in)   :: varname
     144             :       real*8           , intent(in)   :: varwr_scal
     145             : !
     146             : ! !DESCRIPTION: Writes out a netCDF real scalar variable.
     147             : !\\
     148             : !\\
     149             : ! !AUTHOR:
     150             : !  John Tannahill (LLNL) and Jules Kouatchou
     151             : !
     152             : ! !REVISION HISTORY:
     153             : !  See https://github.com/geoschem/ncdfutil for complete history
     154             : !EOP
     155             : !-------------------------------------------------------------------------
     156             : !BOC
     157             : !
     158             : ! !LOCAL VARIABLES:
     159             :       character (len=512) :: err_msg
     160             :       integer             :: ierr
     161             :       integer             :: varid
     162             : !
     163           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
     164             : 
     165           0 :       if (ierr /= NF_NOERR) then
     166             :         err_msg = 'In Ncwr_Scal_R8 #1:  ' // Trim (varname) // &
     167           0 :                  ', ' // Nf_Strerror (ierr)
     168           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
     169             :       end if
     170             : 
     171           0 :       ierr = Nf_Put_Var_Double(ncid, varid, varwr_scal)
     172             : 
     173           0 :       if (ierr /= NF_NOERR) then
     174           0 :         err_msg = 'In Ncwr_Scal_R8 #2:  ' // Nf_Strerror (ierr)
     175           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
     176             :       end if
     177             : 
     178           0 :       end subroutine Ncwr_Scal_R8
     179             : !EOC
     180             : !-------------------------------------------------------------------------
     181             : !BOP
     182             : !
     183             : ! !IROUTINE: Ncwr_Scal_Int
     184             : !
     185             : ! !INTERFACE:
     186             : !
     187           0 :       subroutine Ncwr_Scal_Int (varwr_scali, ncid, varname)
     188             : !
     189             : ! !USES:
     190             : !
     191             :       use m_do_err_out
     192             : !
     193             :       implicit none
     194             : !
     195             :       include "netcdf.inc"
     196             : !
     197             : ! !INPUT PARAMETERS:
     198             : !!    ncid       : netCDF file id to write variable to
     199             : !!    varname    : netCDF variable name
     200             : !!    varwr_scali : integer variable to write out
     201             :       integer          , intent(in)   :: ncid
     202             :       character (len=*), intent(in)   :: varname
     203             :       integer          , intent(in)   :: varwr_scali
     204             : !
     205             : ! !DESCRIPTION: Writes out a netCDF integer scalar variable.
     206             : !\\
     207             : !\\
     208             : ! !AUTHOR:
     209             : !  John Tannahill (LLNL) and Jules Kouatchou
     210             : !
     211             : ! !REVISION HISTORY:
     212             : !  See https://github.com/geoschem/ncdfutil for complete history
     213             : !EOP
     214             : !-------------------------------------------------------------------------
     215             : !BOC
     216             : !
     217             : ! !LOCAL VARIABLES:
     218             :       character (len=512) :: err_msg
     219             :       integer             :: ierr
     220             :       integer             :: varid
     221             : !
     222           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
     223             : 
     224           0 :       if (ierr /= NF_NOERR) then
     225             :         err_msg = 'In Ncwr_Scal_Int #1:  ' // Trim (varname) // &
     226           0 :                   ', ' // Nf_Strerror (ierr)
     227           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
     228             :       end if
     229             : 
     230           0 :       ierr = Nf_Put_Var_Int (ncid, varid, varwr_scali)
     231             : 
     232           0 :       if (ierr /= NF_NOERR) then
     233           0 :         err_msg = 'In Ncwr_Scal_Int #2:  ' // Nf_Strerror (ierr)
     234           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
     235             :       end if
     236             : 
     237           0 :       end subroutine Ncwr_Scal_Int
     238             : !EOC
     239             : !-------------------------------------------------------------------------
     240             : !BOP
     241             : !
     242             : ! !IROUTINE: Ncwr_1d_R8
     243             : !
     244             : ! !INTERFACE:
     245             : !
     246           0 :       subroutine Ncwr_1d_R8 (varwr_1d, ncid, varname, strt1d, cnt1d)
     247             : !
     248             : ! !USES:
     249             : !
     250             :       use m_do_err_out
     251             : !
     252             :       implicit none
     253             : !
     254             :       include "netcdf.inc"
     255             : !
     256             : ! !INPUT PARAMETERS:
     257             : !!    ncid     : netCDF file id to write array output data to
     258             : !!    varname  : netCDF variable name for array
     259             : !!    strt1d   : vector specifying the index in varwr_1d where
     260             : !!               the first of the data values will be written
     261             : !!    cnt1d    : varwr_1d dimension
     262             : !!    varwr_1d : array to write out
     263             :       integer          , intent(in)   :: ncid
     264             :       character (len=*), intent(in)   :: varname
     265             :       integer          , intent(in)   :: strt1d(1)
     266             :       integer          , intent(in)   :: cnt1d (1)
     267             :       real*8           , intent(in)   :: varwr_1d(cnt1d(1))
     268             : !
     269             : ! !DESCRIPTION: Writes out a 1D netCDF real array and does some error
     270             : !  checking.
     271             : !\\
     272             : !\\
     273             : ! !AUTHOR:
     274             : !  John Tannahill (LLNL) and Jules Kouatchou
     275             : !
     276             : ! !REVISION HISTORY:
     277             : !  See https://github.com/geoschem/ncdfutil for complete history
     278             : !EOP
     279             : !-------------------------------------------------------------------------
     280             : !BOC
     281             : !
     282             : ! !LOCAL VARIABLES:
     283             :       character (len=512) :: err_msg
     284             :       integer             :: ierr
     285             :       integer             :: varid
     286             : !
     287           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
     288             : 
     289           0 :       if (ierr /= NF_NOERR) then
     290             :         err_msg = 'In Ncwr_1d_R8 #1:  ' // Trim (varname) // &
     291           0 :                   ', ' // Nf_Strerror (ierr)
     292           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
     293             :       end if
     294             : 
     295           0 :       ierr = Nf_Put_Vara_Double (ncid, varid, strt1d, cnt1d, varwr_1d)
     296             : 
     297           0 :       if (ierr /= NF_NOERR) then
     298           0 :         err_msg = 'In Ncwr_1d_R8 #2:  ' // Nf_Strerror (ierr)
     299           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
     300             :       end if
     301             : 
     302           0 :       end subroutine Ncwr_1d_R8
     303             : !EOC
     304             : !-------------------------------------------------------------------------
     305             : !BOP
     306             : !
     307             : ! !IROUTINE: Ncwr_1d_R4
     308             : !
     309             : ! !INTERFACE:
     310             : !
     311           0 :       subroutine Ncwr_1d_R4 (varwr_1d, ncid, varname, strt1d, cnt1d)
     312             : !
     313             : ! !USES:
     314             : !
     315             :       use m_do_err_out
     316             : !
     317             :       implicit none
     318             : !
     319             :       include "netcdf.inc"
     320             : !
     321             : ! !INPUT PARAMETERS:
     322             : !!    ncid     : netCDF file id to write array output data to
     323             : !!    varname  : netCDF variable name for array
     324             : !!    strt1d   : vector specifying the index in varwr_1d where
     325             : !!               the first of the data values will be written
     326             : !!    cnt1d    : varwr_1d dimension
     327             : !!    varwr_1d : array to write out
     328             :       integer          , intent(in)   :: ncid
     329             :       character (len=*), intent(in)   :: varname
     330             :       integer          , intent(in)   :: strt1d(1)
     331             :       integer          , intent(in)   :: cnt1d (1)
     332             :       real*4           , intent(in)   :: varwr_1d(cnt1d(1))
     333             : !
     334             : ! !DESCRIPTION: Writes out a 1D netCDF real array and does some error
     335             : !  checking.
     336             : !\\
     337             : !\\
     338             : ! !AUTHOR:
     339             : !  John Tannahill (LLNL) and Jules Kouatchou
     340             : !
     341             : ! !REVISION HISTORY:
     342             : !  See https://github.com/geoschem/ncdfutil for complete history
     343             : !EOP
     344             : !-------------------------------------------------------------------------
     345             : !BOC
     346             : !
     347             : ! !LOCAL VARIABLES:
     348             :       character (len=512) :: err_msg
     349             :       integer             :: ierr
     350             :       integer             :: varid
     351             : !
     352           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
     353             : 
     354           0 :       if (ierr /= NF_NOERR) then
     355             :         err_msg = 'In Ncwr_1d_R4 #1:  ' // Trim (varname) // &
     356           0 :                   ', ' // Nf_Strerror (ierr)
     357           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
     358             :       end if
     359             : 
     360           0 :       ierr = Nf_Put_Vara_Real (ncid, varid, strt1d, cnt1d, varwr_1d)
     361             : 
     362           0 :       if (ierr /= NF_NOERR) then
     363           0 :         err_msg = 'In Ncwr_1d_R4 #2:  ' // Nf_Strerror (ierr)
     364           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
     365             :       end if
     366             : 
     367           0 :       end subroutine Ncwr_1d_R4
     368             : !EOC
     369             : !-------------------------------------------------------------------------
     370             : !BOP
     371             : !
     372             : ! !IROUTINE: Ncwr_1d_Int
     373             : !
     374             : ! !INTERFACE:
     375             : !
     376           0 :       subroutine Ncwr_1d_Int (varwr_1di, ncid, varname, strt1d, cnt1d)
     377             : !
     378             : ! !USES:
     379             : !
     380             :       use m_do_err_out
     381             : !
     382             :       implicit none
     383             : !
     384             :       include "netcdf.inc"
     385             : !
     386             : ! !INPUT PARAMETERS:
     387             : !!    ncid     : netCDF file id to write array output data to
     388             : !!    varname  : netCDF variable name for array
     389             : !!    strt1d   : vector specifying the index in varwr_1di where
     390             : !!               the first of the data values will be written
     391             : !!    cnt1d    : varwr_1di dimension
     392             : !!    varwr_1di : intger array to write out
     393             :       integer          , intent(in)   :: ncid
     394             :       character (len=*), intent(in)   :: varname
     395             :       integer          , intent(in)   :: strt1d(1)
     396             :       integer          , intent(in)   :: cnt1d (1)
     397             :       integer          , intent(in)   :: varwr_1di(cnt1d(1))
     398             : !
     399             : ! !DESCRIPTION: Writes out a 1D netCDF integer array and does some error
     400             : ! checking.
     401             : !\\
     402             : !\\
     403             : ! !AUTHOR:
     404             : !  John Tannahill (LLNL) and Jules Kouatchou
     405             : !
     406             : ! !REVISION HISTORY:
     407             : !  See https://github.com/geoschem/ncdfutil for complete history
     408             : !EOP
     409             : !-------------------------------------------------------------------------
     410             : !BOC
     411             : !
     412             : ! !LOCAL VARIABLES:
     413             :       character (len=512) :: err_msg
     414             :       integer             :: ierr
     415             :       integer             :: varid
     416             : !
     417           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
     418             : 
     419           0 :       if (ierr /= NF_NOERR) then
     420             :         err_msg = 'In Ncwr_1d_Int #1:  ' // Trim (varname) // &
     421           0 :                  ', ' // Nf_Strerror (ierr)
     422           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
     423             :       end if
     424             : 
     425           0 :       ierr = Nf_Put_Vara_Int (ncid, varid, strt1d, cnt1d, varwr_1di)
     426             : 
     427           0 :       if (ierr /= NF_NOERR) then
     428           0 :         err_msg = 'In Ncwr_1d_Int #2:  ' // Nf_Strerror (ierr)
     429           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
     430             :       end if
     431             : 
     432           0 :       end subroutine Ncwr_1d_Int
     433             : !EOC
     434             : !-------------------------------------------------------------------------
     435             : !BOP
     436             : !
     437             : ! !IROUTINE: Ncwr_2d_R8
     438             : !
     439             : ! !INTERFACE:
     440             : !
     441           0 :       subroutine Ncwr_2d_R8 (varwr_2d, ncid, varname, strt2d, cnt2d)
     442             : !
     443             : ! !USES:
     444             : !
     445             :       use m_do_err_out
     446             : !
     447             :       implicit none
     448             : !
     449             :       include "netcdf.inc"
     450             : !
     451             : ! !INPUT PARAMETERS:
     452             : !!    ncid     : netCDF file id to write array output data to
     453             : !!    varname  : netCDF variable name for array
     454             : !!    strt2d   : vector specifying the index in varwr_2d where
     455             : !!               the first of the data values will be written
     456             : !!    cnt2d    : varwr_2d dimensions
     457             : !!    varwr_2d : array to write out
     458             :       integer          , intent(in)   :: ncid
     459             :       character (len=*), intent(in)   :: varname
     460             :       integer          , intent(in)   :: strt2d(2)
     461             :       integer          , intent(in)   :: cnt2d (2)
     462             :       real*8           , intent(in)   :: varwr_2d(cnt2d(1), cnt2d(2))
     463             : !
     464             : ! !DESCRIPTION: Writes out a 2D netCDF real array and does some error checking.
     465             : !\\
     466             : !\\
     467             : ! !AUTHOR:
     468             : !  John Tannahill (LLNL) and Jules Kouatchou
     469             : !
     470             : ! !REVISION HISTORY:
     471             : !  See https://github.com/geoschem/ncdfutil for complete history
     472             : !EOP
     473             : !-------------------------------------------------------------------------
     474             : !BOC
     475             : !
     476             : ! !LOCAL VARIABLES:
     477             :       character (len=512) :: err_msg
     478             :       integer             :: ierr
     479             :       integer             :: varid
     480             : !
     481           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
     482             : 
     483           0 :       if (ierr /= NF_NOERR) then
     484             :         err_msg = 'In Ncwr_2d_R8 #1:  ' // Trim (varname) // &
     485           0 :                   ', ' // Nf_Strerror (ierr)
     486           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
     487             :       end if
     488             : 
     489           0 :       ierr = Nf_Put_Vara_Double (ncid, varid, strt2d, cnt2d, varwr_2d)
     490             : 
     491           0 :       if (ierr /= NF_NOERR) then
     492           0 :         err_msg = 'In Ncwr_2d_R8 #2:  ' // Nf_Strerror (ierr)
     493           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
     494             :       end if
     495             : 
     496           0 :       end subroutine Ncwr_2d_R8
     497             : !EOC
     498             : !-------------------------------------------------------------------------
     499             : !BOP
     500             : !
     501             : ! !IROUTINE: Ncwr_2d_R4
     502             : !
     503             : ! !INTERFACE:
     504             : !
     505           0 :       subroutine Ncwr_2d_R4 (varwr_2d, ncid, varname, strt2d, cnt2d)
     506             : !
     507             : ! !USES:
     508             : !
     509             :       use m_do_err_out
     510             : !
     511             :       implicit none
     512             : !
     513             :       include "netcdf.inc"
     514             : !
     515             : ! !INPUT PARAMETERS:
     516             : !!    ncid     : netCDF file id to write array output data to
     517             : !!    varname  : netCDF variable name for array
     518             : !!    strt2d   : vector specifying the index in varwr_2d where
     519             : !!               the first of the data values will be written
     520             : !!    cnt2d    : varwr_2d dimensions
     521             : !!    varwr_2d : array to write out
     522             :       integer          , intent(in)   :: ncid
     523             :       character (len=*), intent(in)   :: varname
     524             :       integer          , intent(in)   :: strt2d(2)
     525             :       integer          , intent(in)   :: cnt2d (2)
     526             :       real*4           , intent(in)   :: varwr_2d(cnt2d(1), cnt2d(2))
     527             : !
     528             : ! !DESCRIPTION: Writes out a 2D netCDF real array and does some error checking.
     529             : !\\
     530             : !\\
     531             : ! !AUTHOR:
     532             : !  John Tannahill (LLNL) and Jules Kouatchou
     533             : !
     534             : ! !REVISION HISTORY:
     535             : !  See https://github.com/geoschem/ncdfutil for complete history
     536             : !EOP
     537             : !-------------------------------------------------------------------------
     538             : !BOC
     539             : !
     540             : ! !LOCAL VARIABLES:
     541             :       character (len=512) :: err_msg
     542             :       integer             :: ierr
     543             :       integer             :: varid
     544             : !
     545           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
     546             : 
     547           0 :       if (ierr /= NF_NOERR) then
     548             :         err_msg = 'In Ncwr_2d_R4 #1:  ' // Trim (varname) // &
     549           0 :                   ', ' // Nf_Strerror (ierr)
     550           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
     551             :       end if
     552             : 
     553           0 :       ierr = Nf_Put_Vara_Real (ncid, varid, strt2d, cnt2d, varwr_2d)
     554             : 
     555           0 :       if (ierr /= NF_NOERR) then
     556           0 :         err_msg = 'In Ncwr_2d_R4 #2:  ' // Nf_Strerror (ierr)
     557           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
     558             :       end if
     559             : 
     560           0 :       end subroutine Ncwr_2d_R4
     561             : !EOC
     562             : !-------------------------------------------------------------------------
     563             : !BOP
     564             : !
     565             : ! !IROUTINE: Ncwr_2d_Int
     566             : !
     567             : ! !INTERFACE:
     568             : !
     569           0 :       subroutine Ncwr_2d_Int (varwr_2di, ncid, varname, strt2d, cnt2d)
     570             : !
     571             : ! !USES:
     572             : !
     573             :       use m_do_err_out
     574             : !
     575             :       implicit none
     576             : !
     577             :       include "netcdf.inc"
     578             : !
     579             : ! !INPUT PARAMETERS:
     580             : !!    ncid     : netCDF file id to write array output data to
     581             : !!    varname  : netCDF variable name for array
     582             : !!    strt2d   : vector specifying the index in varwr_2di where
     583             : !!               the first of the data values will be written
     584             : !!    cnt2d    : varwr_2di dimensions
     585             : !!    varwr_2di : intger array to write out
     586             :       integer          , intent(in)   :: ncid
     587             :       character (len=*), intent(in)   :: varname
     588             :       integer          , intent(in)   :: strt2d(2)
     589             :       integer          , intent(in)   :: cnt2d (2)
     590             :       integer          , intent(in)   :: varwr_2di(cnt2d(1), cnt2d(2))
     591             : !
     592             : ! !DESCRIPTION: Writes out a 2D netCDF integer array and does some error
     593             : !   checking.
     594             : !\\
     595             : !\\
     596             : ! !AUTHOR:
     597             : !  John Tannahill (LLNL) and Jules Kouatchou
     598             : !
     599             : ! !REVISION HISTORY:
     600             : !  See https://github.com/geoschem/ncdfutil for complete history
     601             : !EOP
     602             : !-------------------------------------------------------------------------
     603             : !BOC
     604             : !
     605             : ! !LOCAL VARIABLES:
     606             :       character (len=512) :: err_msg
     607             :       integer             :: ierr
     608             :       integer             :: varid
     609             : !
     610           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
     611             : 
     612           0 :       if (ierr /= NF_NOERR) then
     613             :         err_msg = 'In Ncwr_2d_Int #1:  ' // Trim (varname) //  &
     614           0 :                   ', ' // Nf_Strerror (ierr)
     615           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
     616             :       end if
     617             : 
     618           0 :       ierr = Nf_Put_Vara_Int (ncid, varid, strt2d, cnt2d, varwr_2di)
     619             : 
     620           0 :       if (ierr /= NF_NOERR) then
     621           0 :         err_msg = 'In Ncwr_2d_Int #2:  ' // Nf_Strerror (ierr)
     622           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
     623             :       end if
     624             : 
     625           0 :       end subroutine Ncwr_2d_Int
     626             : !EOC
     627             : !-------------------------------------------------------------------------
     628             : !BOP
     629             : !
     630             : ! !IROUTINE: Ncwr_3d_R8
     631             : !
     632             : ! !INTERFACE:
     633             : !
     634           0 :       subroutine Ncwr_3d_R8 (varwr_3d, ncid, varname, strt3d, cnt3d)
     635             : !
     636             : ! !USES:
     637             : !
     638             :       use m_do_err_out
     639             : !
     640             :       implicit none
     641             : !
     642             :       include "netcdf.inc"
     643             : !
     644             : ! !INPUT PARAMETERS:
     645             : !!    ncid     : netCDF file id to write array output data to
     646             : !!    varname  : netCDF variable name for array
     647             : !!    strt3d   : vector specifying the index in varwr_3d where
     648             : !!               the first of the data values will be written
     649             : !!    cnt3d    : varwr_3d dimensions
     650             : !!    varwr_3d : array to write out
     651             :       integer          , intent(in)   :: ncid
     652             :       character (len=*), intent(in)   :: varname
     653             :       integer          , intent(in)   :: strt3d(3)
     654             :       integer          , intent(in)   :: cnt3d (3)
     655             :       real*8           , intent(in)   :: varwr_3d(cnt3d(1), cnt3d(2), cnt3d(3))
     656             : !
     657             : ! !DESCRIPTION: Writes out a 3D netCDF real array and does some error checking.
     658             : !\\
     659             : !\\
     660             : ! !AUTHOR:
     661             : !  John Tannahill (LLNL) and Jules Kouatchou
     662             : !
     663             : ! !REVISION HISTORY:
     664             : !  See https://github.com/geoschem/ncdfutil for complete history
     665             : !EOP
     666             : !-------------------------------------------------------------------------
     667             : !BOC
     668             : !
     669             : ! !LOCAL VARIABLES:
     670             :       character (len=512) :: err_msg
     671             :       integer             :: ierr
     672             :       integer             :: varid
     673             : !
     674           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
     675             : 
     676           0 :       if (ierr /= NF_NOERR) then
     677             :         err_msg = 'In Ncwr_3d_R8 #1:  ' // Trim (varname) // &
     678           0 :                   ', ' // Nf_Strerror (ierr)
     679           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
     680             :       end if
     681             : 
     682           0 :       ierr = Nf_Put_Vara_Double (ncid, varid, strt3d, cnt3d, varwr_3d)
     683             : 
     684           0 :       if (ierr /= NF_NOERR) then
     685           0 :         err_msg = 'In Ncwr_3d_R8 #2:  ' // Nf_Strerror (ierr)
     686           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
     687             :       end if
     688             : 
     689           0 :       end subroutine Ncwr_3d_R8
     690             : !EOC
     691             : !-------------------------------------------------------------------------
     692             : !BOP
     693             : !
     694             : ! !IROUTINE: Ncwr_3d_R4
     695             : !
     696             : ! !INTERFACE:
     697             : !
     698           0 :       subroutine Ncwr_3d_R4 (varwr_3d, ncid, varname, strt3d, cnt3d)
     699             : !
     700             : ! !USES:
     701             : !
     702             :       use m_do_err_out
     703             : !
     704             :       implicit none
     705             : !
     706             :       include "netcdf.inc"
     707             : !
     708             : ! !INPUT PARAMETERS:
     709             : !!    ncid     : netCDF file id to write array output data to
     710             : !!    varname  : netCDF variable name for array
     711             : !!    strt3d   : vector specifying the index in varwr_3d where
     712             : !!               the first of the data values will be written
     713             : !!    cnt3d    : varwr_3d dimensions
     714             : !!    varwr_3d : array to write out
     715             :       integer          , intent(in)   :: ncid
     716             :       character (len=*), intent(in)   :: varname
     717             :       integer          , intent(in)   :: strt3d(3)
     718             :       integer          , intent(in)   :: cnt3d (3)
     719             :       real*4           , intent(in)   :: varwr_3d(cnt3d(1), cnt3d(2), cnt3d(3))
     720             : !
     721             : ! !DESCRIPTION: Writes out a 3D netCDF real array and does some error checking.
     722             : !\\
     723             : !\\
     724             : ! !AUTHOR:
     725             : !  John Tannahill (LLNL) and Jules Kouatchou
     726             : !
     727             : ! !REVISION HISTORY:
     728             : !  See https://github.com/geoschem/ncdfutil for complete history
     729             : !EOP
     730             : !-------------------------------------------------------------------------
     731             : !BOC
     732             : !
     733             : ! !LOCAL VARIABLES:
     734             :       character (len=512) :: err_msg
     735             :       integer             :: ierr
     736             :       integer             :: varid
     737             : !
     738           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
     739             : 
     740           0 :       if (ierr /= NF_NOERR) then
     741             :         err_msg = 'In Ncwr_3d_R4 #1:  ' // Trim (varname) // &
     742           0 :                   ', ' // Nf_Strerror (ierr)
     743           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
     744             :       end if
     745             : 
     746           0 :       ierr = Nf_Put_Vara_Real (ncid, varid, strt3d, cnt3d, varwr_3d)
     747             : 
     748           0 :       if (ierr /= NF_NOERR) then
     749           0 :         err_msg = 'In Ncwr_3d_R4 #2:  ' // Nf_Strerror (ierr)
     750           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
     751             :       end if
     752             : 
     753           0 :       return
     754             : 
     755             :       end subroutine Ncwr_3d_R4
     756             : !EOC
     757             : !-------------------------------------------------------------------------
     758             : !BOP
     759             : !
     760             : ! !IROUTINE: Ncwr_3d_Int
     761             : !
     762             : ! !INTERFACE:
     763             : !
     764           0 :       subroutine Ncwr_3d_Int (varwr_3di, ncid, varname, strt3d, cnt3d)
     765             : !
     766             : ! !USES:
     767             : !
     768             :       use m_do_err_out
     769             : !
     770             :       implicit none
     771             : !
     772             :       include "netcdf.inc"
     773             : !
     774             : ! !INPUT PARAMETERS:
     775             : !!    ncid     : netCDF file id to write array output data to
     776             : !!    varname  : netCDF variable name for array
     777             : !!    strt3d   : vector specifying the index in varwr_3di where
     778             : !!               the first of the data values will be written
     779             : !!    cnt3d    : varwr_3di dimensions
     780             : !!    varwr_3di : intger array to write out
     781             :       integer          , intent(in)   :: ncid
     782             :       character (len=*), intent(in)   :: varname
     783             :       integer          , intent(in)   :: strt3d(3)
     784             :       integer          , intent(in)   :: cnt3d (3)
     785             :       integer          , intent(in)   :: varwr_3di(cnt3d(1), cnt3d(2), cnt3d(3))
     786             : !
     787             : ! !DESCRIPTION: Writes out a 3D netCDF integer array and does some error
     788             : !  checking.
     789             : !\\
     790             : !\\
     791             : ! !AUTHOR:
     792             : !  John Tannahill (LLNL) and Jules Kouatchou
     793             : !
     794             : ! !REVISION HISTORY:
     795             : !  See https://github.com/geoschem/ncdfutil for complete history
     796             : !EOP
     797             : !-------------------------------------------------------------------------
     798             : !BOC
     799             : !
     800             : ! !LOCAL VARIABLES:
     801             :       character (len=512) :: err_msg
     802             :       integer             :: ierr
     803             :       integer             :: varid
     804             : !
     805           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
     806             : 
     807           0 :       if (ierr /= NF_NOERR) then
     808             :         err_msg = 'In Ncwr_3d_Int #1:  ' // Trim (varname) // &
     809           0 :                   ', ' // Nf_Strerror (ierr)
     810           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
     811             :       end if
     812             : 
     813             : 
     814           0 :       ierr = Nf_Put_Vara_Int (ncid, varid, strt3d, cnt3d, varwr_3di)
     815             : 
     816           0 :       if (ierr /= NF_NOERR) then
     817           0 :         err_msg = 'In Ncwr_3d_Int #2:  ' // Nf_Strerror (ierr)
     818           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
     819             :       end if
     820             : 
     821           0 :       return
     822             : 
     823             :       end subroutine Ncwr_3d_Int
     824             : !EOC
     825             : !-------------------------------------------------------------------------
     826             : !BOP
     827             : !
     828             : ! !IROUTINE: Ncwr_4d_R8
     829             : !
     830             : ! !INTERFACE:
     831             : !
     832           0 :       subroutine Ncwr_4d_R8 (varwr_4d, ncid, varname, strt4d, cnt4d)
     833             : !
     834             : ! !USES:
     835             : !
     836             :       use m_do_err_out
     837             : !
     838             :       implicit none
     839             : !
     840             :       include "netcdf.inc"
     841             : !
     842             : ! !INPUT PARAMETERS:
     843             : !!    ncid     : netCDF file id to write array output data to
     844             : !!    varname  : netCDF variable name for array
     845             : !!    strt4d   : vector specifying the index in varwr_4d where
     846             : !!               the first of the data values will be written
     847             : !!    cnt4d    : varwr_4d dimensions
     848             : !!    varwr_4d : array to write out
     849             :       integer          , intent(in)   :: ncid
     850             :       character (len=*), intent(in)   :: varname
     851             :       integer          , intent(in)   :: strt4d(4)
     852             :       integer          , intent(in)   :: cnt4d (4)
     853             :       real*8           , intent(in)   :: varwr_4d(cnt4d(1), cnt4d(2), &
     854             :                                                   cnt4d(3), cnt4d(4))
     855             : !
     856             : ! !DESCRIPTION: Writes out a 4D netCDF real array and does some error checking.
     857             : !\\
     858             : !\\
     859             : ! !AUTHOR:
     860             : !  John Tannahill (LLNL) and Jules Kouatchou
     861             : !
     862             : ! !REVISION HISTORY:
     863             : !  See https://github.com/geoschem/ncdfutil for complete history
     864             : !EOP
     865             : !-------------------------------------------------------------------------
     866             : !BOC
     867             : !
     868             : ! !LOCAL VARIABLES:
     869             :       character (len=512) :: err_msg
     870             :       integer             :: ierr
     871             :       integer             :: varid
     872             : !
     873           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
     874             : 
     875           0 :       if (ierr /= NF_NOERR) then
     876             :         err_msg = 'In Ncwr_4d_R8 #1:  ' // Trim (varname) // &
     877           0 :                   ', ' // Nf_Strerror (ierr)
     878           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
     879             :       end if
     880             : 
     881             : 
     882           0 :       ierr = Nf_Put_Vara_Double (ncid, varid, strt4d, cnt4d, varwr_4d)
     883             : 
     884           0 :       if (ierr /= NF_NOERR) then
     885           0 :         err_msg = 'In Ncwr_4d_R8 #2:  ' // Nf_Strerror (ierr)
     886           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
     887             :       end if
     888             : 
     889           0 :       end subroutine Ncwr_4d_R8
     890             : !EOC
     891             : !-------------------------------------------------------------------------
     892             : !BOP
     893             : !
     894             : ! !IROUTINE: Ncwr_4d_R4
     895             : !
     896             : ! !INTERFACE:
     897             : !
     898           0 :       subroutine Ncwr_4d_R4 (varwr_4d, ncid, varname, strt4d, cnt4d)
     899             : !
     900             : ! !USES:
     901             : !
     902             :       use m_do_err_out
     903             : !
     904             :       implicit none
     905             : !
     906             :       include "netcdf.inc"
     907             : !
     908             : ! !INPUT PARAMETERS:
     909             : !!    ncid     : netCDF file id to write array output data to
     910             : !!    varname  : netCDF variable name for array
     911             : !!    strt4d   : vector specifying the index in varwr_4d where
     912             : !!               the first of the data values will be written
     913             : !!    cnt4d    : varwr_4d dimensions
     914             : !!    varwr_4d : array to write out
     915             :       integer          , intent(in)   :: ncid
     916             :       character (len=*), intent(in)   :: varname
     917             :       integer          , intent(in)   :: strt4d(4)
     918             :       integer          , intent(in)   :: cnt4d (4)
     919             :       real*4           , intent(in)   :: varwr_4d(cnt4d(1), cnt4d(2), &
     920             :                                                   cnt4d(3), cnt4d(4))
     921             : !
     922             : ! !DESCRIPTION: Writes out a 4D netCDF real array and does some error checking.
     923             : !\\
     924             : !\\
     925             : ! !AUTHOR:
     926             : !  John Tannahill (LLNL) and Jules Kouatchou
     927             : !
     928             : ! !REVISION HISTORY:
     929             : !  See https://github.com/geoschem/ncdfutil for complete history
     930             : !EOP
     931             : !-------------------------------------------------------------------------
     932             : !BOC
     933             : !
     934             : ! !LOCAL VARIABLES:
     935             :       character (len=512) :: err_msg
     936             :       integer             :: ierr
     937             :       integer             :: varid
     938             : !
     939           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
     940             : 
     941           0 :       if (ierr /= NF_NOERR) then
     942             :         err_msg = 'In Ncwr_4d_R4 #1:  ' // Trim (varname) // &
     943           0 :                   ', ' // Nf_Strerror (ierr)
     944           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
     945             :       end if
     946             : 
     947             : 
     948           0 :       ierr = Nf_Put_Vara_Real (ncid, varid, strt4d, cnt4d, varwr_4d)
     949             : 
     950           0 :       if (ierr /= NF_NOERR) then
     951           0 :         err_msg = 'In Ncwr_4d_R4 #2:  ' // Nf_Strerror (ierr)
     952           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
     953             :       end if
     954             : 
     955           0 :       end subroutine Ncwr_4d_R4
     956             : !EOC
     957             : !-------------------------------------------------------------------------
     958             : !BOP
     959             : !
     960             : ! !IROUTINE: Ncwr_3d_Int
     961             : !
     962             : ! !INTERFACE:
     963             : !
     964           0 :       subroutine Ncwr_4d_Int (varwr_4di, ncid, varname, strt4d, cnt4d)
     965             : !
     966             : ! !USES:
     967             : !
     968             :       use m_do_err_out
     969             : !
     970             :       implicit none
     971             : !
     972             :       include "netcdf.inc"
     973             : !
     974             : ! !INPUT PARAMETERS:
     975             : !!    ncid     : netCDF file id to write array output data to
     976             : !!    varname  : netCDF variable name for array
     977             : !!    strt3d   : vector specifying the index in varwr_3di where
     978             : !!               the first of the data values will be written
     979             : !!    cnt3d    : varwr_3di dimensions
     980             : !!    varwr_3di : intger array to write out
     981             :       integer          , intent(in)   :: ncid
     982             :       character (len=*), intent(in)   :: varname
     983             :       integer          , intent(in)   :: strt4d(4)
     984             :       integer          , intent(in)   :: cnt4d (4)
     985             :       integer          , intent(in)   :: varwr_4di(cnt4d(1), cnt4d(2), &
     986             :                                                    cnt4d(3), cnt4d(4))
     987             : !
     988             : ! !DESCRIPTION: Writes out a 3D netCDF integer array and does some error
     989             : !  checking.
     990             : !\\
     991             : !\\
     992             : ! !AUTHOR:
     993             : !  John Tannahill (LLNL) and Jules Kouatchou
     994             : !
     995             : ! !REVISION HISTORY:
     996             : !  See https://github.com/geoschem/ncdfutil for complete history
     997             : !EOP
     998             : !-------------------------------------------------------------------------
     999             : !BOC
    1000             : !
    1001             : ! !LOCAL VARIABLES:
    1002             :       character (len=512) :: err_msg
    1003             :       integer             :: ierr
    1004             :       integer             :: varid
    1005             : !
    1006           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
    1007             : 
    1008           0 :       if (ierr /= NF_NOERR) then
    1009             :         err_msg = 'In Ncwr_4d_Int #1:  ' // Trim (varname) // &
    1010           0 :                   ', ' // Nf_Strerror (ierr)
    1011           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
    1012             :       end if
    1013             : 
    1014             : 
    1015           0 :       ierr = Nf_Put_Vara_Int (ncid, varid, strt4d, cnt4d, varwr_4di)
    1016             : 
    1017           0 :       if (ierr /= NF_NOERR) then
    1018           0 :         err_msg = 'In Ncwr_4d_Int #2:  ' // Nf_Strerror (ierr)
    1019           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
    1020             :       end if
    1021             : 
    1022           0 :       end subroutine Ncwr_4d_Int
    1023             : !EOC
    1024             : !-------------------------------------------------------------------------
    1025             : !BOP
    1026             : !
    1027             : ! !IROUTINE: Ncwr_5d_R8
    1028             : !
    1029             : ! !INTERFACE:
    1030             : !
    1031           0 :       subroutine Ncwr_5d_R8 (varwr_5d, ncid, varname, strt5d, cnt5d)
    1032             : !
    1033             : ! !USES:
    1034             : !
    1035             :       use m_do_err_out
    1036             : !
    1037             :       implicit none
    1038             : !
    1039             :       include "netcdf.inc"
    1040             : !
    1041             : ! !INPUT PARAMETERS:
    1042             : !!    ncid     : netCDF file id to write array output data to
    1043             : !!    varname  : netCDF variable name for array
    1044             : !!    strt5d   : vector specifying the index in varwr_5d where
    1045             : !!               the first of the data values will be written
    1046             : !!    cnt5d    : varwr_5d dimensions
    1047             : !!    varwr_5d : array to write out
    1048             :       integer          , intent(in)   :: ncid
    1049             :       character (len=*), intent(in)   :: varname
    1050             :       integer          , intent(in)   :: strt5d(5)
    1051             :       integer          , intent(in)   :: cnt5d (5)
    1052             :       real*8           , intent(in)   :: varwr_5d(cnt5d(1), cnt5d(2), &
    1053             :                                                   cnt5d(3), cnt5d(4), &
    1054             :                                                   cnt5d(5))
    1055             : !
    1056             : ! !DESCRIPTION: Writes out a 5D netCDF real array and does some error checking.
    1057             : !\\
    1058             : !\\
    1059             : ! !AUTHOR:
    1060             : !  John Tannahill (LLNL) and Jules Kouatchou
    1061             : !
    1062             : ! !REVISION HISTORY:
    1063             : !  See https://github.com/geoschem/ncdfutil for complete history
    1064             : !EOP
    1065             : !-------------------------------------------------------------------------
    1066             : !BOC
    1067             : !
    1068             : ! !LOCAL VARIABLES:
    1069             :       character (len=512) :: err_msg
    1070             :       integer             :: ierr
    1071             :       integer             :: varid
    1072             : !
    1073           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
    1074             : 
    1075           0 :       if (ierr /= NF_NOERR) then
    1076             :         err_msg = 'In Ncwr_5d_R8 #1:  ' // Trim (varname) // &
    1077           0 :                  ', ' // Nf_Strerror (ierr)
    1078           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
    1079             :       end if
    1080             : 
    1081           0 :       ierr = Nf_Put_Vara_Double (ncid, varid, strt5d, cnt5d, varwr_5d)
    1082             : 
    1083           0 :       if (ierr /= NF_NOERR) then
    1084           0 :         err_msg = 'In Ncwr_5d_R8 #2:  ' // Nf_Strerror (ierr)
    1085           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
    1086             :       end if
    1087             : 
    1088           0 :       end subroutine Ncwr_5d_R8
    1089             : !EOC
    1090             : !-------------------------------------------------------------------------
    1091             : !BOP
    1092             : !
    1093             : ! !IROUTINE: Ncwr_5d_R4
    1094             : !
    1095             : ! !INTERFACE:
    1096             : !
    1097           0 :       subroutine Ncwr_5d_R4 (varwr_5d, ncid, varname, strt5d, cnt5d)
    1098             : !
    1099             : ! !USES:
    1100             : !
    1101             :       use m_do_err_out
    1102             : !
    1103             :       implicit none
    1104             : !
    1105             :       include "netcdf.inc"
    1106             : !
    1107             : ! !INPUT PARAMETERS:
    1108             : !!    ncid     : netCDF file id to write array output data to
    1109             : !!    varname  : netCDF variable name for array
    1110             : !!    strt5d   : vector specifying the index in varwr_5d where
    1111             : !!               the first of the data values will be written
    1112             : !!    cnt5d    : varwr_5d dimensions
    1113             : !!    varwr_5d : array to write out
    1114             :       integer          , intent(in)   :: ncid
    1115             :       character (len=*), intent(in)   :: varname
    1116             :       integer          , intent(in)   :: strt5d(5)
    1117             :       integer          , intent(in)   :: cnt5d (5)
    1118             :       real*4           , intent(in)   :: varwr_5d(cnt5d(1), cnt5d(2), &
    1119             :                                                   cnt5d(3), cnt5d(4), &
    1120             :                                                   cnt5d(5))
    1121             : !
    1122             : ! !DESCRIPTION: Writes out a 5D netCDF real array and does some error checking.
    1123             : !\\
    1124             : !\\
    1125             : ! !AUTHOR:
    1126             : !  John Tannahill (LLNL) and Jules Kouatchou
    1127             : !
    1128             : ! !REVISION HISTORY:
    1129             : !  See https://github.com/geoschem/ncdfutil for complete history
    1130             : !EOP
    1131             : !-------------------------------------------------------------------------
    1132             : !BOC
    1133             : !
    1134             : ! !LOCAL VARIABLES:
    1135             :       character (len=512) :: err_msg
    1136             :       integer             :: ierr
    1137             :       integer             :: varid
    1138             : !
    1139           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
    1140             : 
    1141           0 :       if (ierr /= NF_NOERR) then
    1142             :         err_msg = 'In Ncwr_5d_R4 #1:  ' // Trim (varname) // &
    1143           0 :                  ', ' // Nf_Strerror (ierr)
    1144           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
    1145             :       end if
    1146             : 
    1147           0 :       ierr = Nf_Put_Vara_Real (ncid, varid, strt5d, cnt5d, varwr_5d)
    1148             : 
    1149           0 :       if (ierr /= NF_NOERR) then
    1150           0 :         err_msg = 'In Ncwr_5d_R4 #2:  ' // Nf_Strerror (ierr)
    1151           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
    1152             :       end if
    1153             : 
    1154           0 :       end subroutine Ncwr_5d_R4
    1155             : !EOC
    1156             : !-------------------------------------------------------------------------
    1157             : !BOP
    1158             : !
    1159             : ! !IROUTINE: Ncwr_6d_R8
    1160             : !
    1161             : ! !INTERFACE:
    1162             : !
    1163           0 :       subroutine Ncwr_6d_R8 (varwr_6d, ncid, varname, strt6d, cnt6d)
    1164             : !
    1165             : ! !USES:
    1166             : !
    1167             :       use m_do_err_out
    1168             : !
    1169             :       implicit none
    1170             : !
    1171             :       include "netcdf.inc"
    1172             : !
    1173             : ! !INPUT PARAMETERS:
    1174             : !!    ncid     : netCDF file id to write array output data to
    1175             : !!    varname  : netCDF variable name for array
    1176             : !!    strt6d   : vector specifying the index in varwr_6d where
    1177             : !!               the first of the data values will be written
    1178             : !!    cnt6d    : varwr_6d dimensions
    1179             : !!    varwr_6d : array to write out
    1180             :       integer          , intent(in)   :: ncid
    1181             :       character (len=*), intent(in)   :: varname
    1182             :       integer          , intent(in)   :: strt6d(6)
    1183             :       integer          , intent(in)   :: cnt6d (6)
    1184             :       real*8           , intent(in)   :: varwr_6d(cnt6d(1), cnt6d(2), &
    1185             :                                                   cnt6d(3), cnt6d(4), &
    1186             :                                                   cnt6d(5), cnt6d(6))
    1187             : !
    1188             : ! !DESCRIPTION: Writes out a 6D netCDF real array and does some error checking.
    1189             : !\\
    1190             : !\\
    1191             : ! !AUTHOR:
    1192             : !  John Tannahill (LLNL) and Jules Kouatchou
    1193             : !
    1194             : ! !REVISION HISTORY:
    1195             : !  See https://github.com/geoschem/ncdfutil for complete history
    1196             : !EOP
    1197             : !-------------------------------------------------------------------------
    1198             : !BOC
    1199             : !
    1200             : ! !LOCAL VARIABLES:
    1201             :       character (len=512) :: err_msg
    1202             :       integer             :: ierr
    1203             :       integer             :: varid
    1204             : !
    1205           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
    1206             : 
    1207           0 :       if (ierr /= NF_NOERR) then
    1208             :         err_msg = 'In Ncwr_6d_R8 #1:  ' // Trim (varname) // &
    1209           0 :                   ', ' // Nf_Strerror (ierr)
    1210           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
    1211             :       end if
    1212             : 
    1213           0 :       ierr = Nf_Put_Vara_Double (ncid, varid, strt6d, cnt6d, varwr_6d)
    1214             : 
    1215           0 :       if (ierr /= NF_NOERR) then
    1216           0 :         err_msg = 'In Ncwr_6d_R8 #2:  ' // Nf_Strerror (ierr)
    1217           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
    1218             :       end if
    1219             : 
    1220           0 :       end subroutine Ncwr_6d_R8
    1221             : !EOC
    1222             : !-------------------------------------------------------------------------
    1223             : !BOP
    1224             : !
    1225             : ! !IROUTINE: Ncwr_6d_R4
    1226             : !
    1227             : ! !INTERFACE:
    1228             : !
    1229           0 :       subroutine Ncwr_6d_R4 (varwr_6d, ncid, varname, strt6d, cnt6d)
    1230             : !
    1231             : ! !USES:
    1232             : !
    1233             :       use m_do_err_out
    1234             : !
    1235             :       implicit none
    1236             : !
    1237             :       include "netcdf.inc"
    1238             : !
    1239             : ! !INPUT PARAMETERS:
    1240             : !!    ncid     : netCDF file id to write array output data to
    1241             : !!    varname  : netCDF variable name for array
    1242             : !!    strt6d   : vector specifying the index in varwr_6d where
    1243             : !!               the first of the data values will be written
    1244             : !!    cnt6d    : varwr_6d dimensions
    1245             : !!    varwr_6d : array to write out
    1246             :       integer          , intent(in)   :: ncid
    1247             :       character (len=*), intent(in)   :: varname
    1248             :       integer          , intent(in)   :: strt6d(6)
    1249             :       integer          , intent(in)   :: cnt6d (6)
    1250             :       real*4           , intent(in)   :: varwr_6d(cnt6d(1), cnt6d(2), &
    1251             :                                                   cnt6d(3), cnt6d(4), &
    1252             :                                                   cnt6d(5), cnt6d(6))
    1253             : !
    1254             : ! !DESCRIPTION: Writes out a 6D netCDF real array and does some error checking.
    1255             : !\\
    1256             : !\\
    1257             : ! !AUTHOR:
    1258             : !  John Tannahill (LLNL) and Jules Kouatchou
    1259             : !
    1260             : ! !REVISION HISTORY:
    1261             : !  See https://github.com/geoschem/ncdfutil for complete history
    1262             : !EOP
    1263             : !-------------------------------------------------------------------------
    1264             : !BOC
    1265             : !
    1266             : ! !LOCAL VARIABLES:
    1267             :       character (len=512) :: err_msg
    1268             :       integer             :: ierr
    1269             :       integer             :: varid
    1270             : !
    1271           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
    1272             : 
    1273           0 :       if (ierr /= NF_NOERR) then
    1274             :         err_msg = 'In Ncwr_6d_R4 #1:  ' // Trim (varname) // &
    1275           0 :                   ', ' // Nf_Strerror (ierr)
    1276           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
    1277             :       end if
    1278             : 
    1279           0 :       ierr = Nf_Put_Vara_Real (ncid, varid, strt6d, cnt6d, varwr_6d)
    1280             : 
    1281           0 :       if (ierr /= NF_NOERR) then
    1282           0 :         err_msg = 'In Ncwr_6d_R4 #2:  ' // Nf_Strerror (ierr)
    1283           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
    1284             :       end if
    1285             : 
    1286           0 :       end subroutine Ncwr_6d_R4
    1287             : !EOC
    1288             : !-------------------------------------------------------------------------
    1289             : !BOP
    1290             : !
    1291             : ! !IROUTINE: Ncwr_1d_Char
    1292             : !
    1293             : ! !INTERFACE:
    1294             : !
    1295           0 :       subroutine Ncwr_1d_Char (varwr_1dc, ncid, varname, strt1d, cnt1d)
    1296             : !
    1297             : ! !USES:
    1298             : !
    1299             :       use m_do_err_out
    1300             : !
    1301             :       implicit none
    1302             : !
    1303             :       include "netcdf.inc"
    1304             : !
    1305             : ! !INPUT PARAMETERS:
    1306             : !!    ncid     : netCDF file id to write array output data to
    1307             : !!    varname  : netCDF variable name for array
    1308             : !!    strt1d   : vector specifying the index in varwr_1dc where
    1309             : !!               the first of the data values will be written
    1310             : !!    cnt1d    : varwr_1dc dimension
    1311             : !!    varwr_1dc : intger array to write out
    1312             :       integer          , intent(in)   :: ncid
    1313             :       character (len=*), intent(in)   :: varname
    1314             :       integer          , intent(in)   :: strt1d(1)
    1315             :       integer          , intent(in)   :: cnt1d (1)
    1316             :       character (len=1), intent(in)   :: varwr_1dc(cnt1d(1))
    1317             : !
    1318             : ! !DESCRIPTION: Writes out a 1D netCDF character array and does some error
    1319             : !   checking.
    1320             : !\\
    1321             : !\\
    1322             : ! !AUTHOR:
    1323             : !  Jules Kouatchou
    1324             : !
    1325             : ! !REVISION HISTORY:
    1326             : !  See https://github.com/geoschem/ncdfutil for complete history
    1327             : !EOP
    1328             : !-------------------------------------------------------------------------
    1329             : !BOC
    1330             : !
    1331             : ! !LOCAL VARIABLES:
    1332             :       character (len=512) :: err_msg
    1333             :       integer             :: ierr
    1334             :       integer             :: varid
    1335             : !
    1336           0 :       ierr = Nf_Inq_Varid (ncid, varname, varid)
    1337             : 
    1338           0 :       if (ierr /= NF_NOERR) then
    1339             :         err_msg = 'In Ncwr_1d_Char #1:  ' // Trim (varname) // &
    1340           0 :                  ', ' // Nf_Strerror (ierr)
    1341           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
    1342             :       end if
    1343             : 
    1344           0 :       ierr = Nf_Put_Vara_Text (ncid, varid, strt1d, cnt1d, varwr_1dc)
    1345             : 
    1346           0 :       if (ierr /= NF_NOERR) then
    1347           0 :         err_msg = 'In Ncwr_1d_Char #2:  ' // Nf_Strerror (ierr)
    1348           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, varid, 0, 0.0d0, 0.0d0)
    1349             :       end if
    1350             : 
    1351           0 :       end subroutine Ncwr_1d_Char
    1352             : !EOC
    1353             : !-------------------------------------------------------------------------
    1354             : !BOP
    1355             : !
    1356             : ! !IROUTINE: Ncwr_2d_Char
    1357             : !
    1358             : ! !INTERFACE:
    1359             : !
    1360           0 :       subroutine Ncwr_2d_Char (char_2d, ncid, tvarname, strt2d, cnt2d)
    1361             : !
    1362             : ! !USES:
    1363             : !
    1364             :       use m_do_err_out
    1365             : !
    1366             :       implicit none
    1367             : !
    1368             :       include "netcdf.inc"
    1369             : !
    1370             : ! !INPUT PARAMETERS:
    1371             : !!    ncid     : netCDF file id to write text to
    1372             : !!    tvarname : netCDF variable name for text
    1373             : !!    strt2d   : vector specifying the index in char_2d where
    1374             : !!               the first of the data values will be written
    1375             : !!    cnt2d    : char_2d dimensions
    1376             : !!    char_2d  : text to write
    1377             :       integer          , intent(in)   :: ncid
    1378             :       character (len=*), intent(in)   :: tvarname
    1379             :       integer          , intent(in)   :: strt2d(2)
    1380             :       integer          , intent(in)   :: cnt2d (2)
    1381             :       character (len=1), intent(in)   :: char_2d(cnt2d(1), cnt2d(2))
    1382             : !
    1383             : ! !DESCRIPTION: Writes out a 2D netCDF character array and does some error
    1384             : !  checking.
    1385             : !\\
    1386             : !\\
    1387             : ! !AUTHOR:
    1388             : !  John Tannahill (LLNL) and Jules Kouatchou
    1389             : !
    1390             : ! !REVISION HISTORY:
    1391             : !  See https://github.com/geoschem/ncdfutil for complete history
    1392             : !EOP
    1393             : !-------------------------------------------------------------------------
    1394             : !BOC
    1395             : !
    1396             : ! !LOCAL VARIABLES:
    1397             :       character (len=512) :: err_msg
    1398             :       integer             :: ierr
    1399             :       integer             :: tvarid
    1400             : !
    1401           0 :       ierr = Nf_Inq_Varid (ncid, tvarname, tvarid)
    1402             : 
    1403           0 :       if (ierr /= NF_NOERR) then
    1404             :         err_msg = 'In Ncwr_2d_Char #1:  ' // Trim (tvarname) // &
    1405           0 :                   ', ' // Nf_Strerror (ierr)
    1406           0 :         call Do_Err_Out (err_msg, .true., 1, ncid, 0, 0, 0.0d0, 0.0d0)
    1407             :       end if
    1408             : 
    1409             : 
    1410           0 :       ierr = Nf_Put_Vara_Text (ncid, tvarid, strt2d, cnt2d, char_2d)
    1411             : 
    1412           0 :       if (ierr /= NF_NOERR) then
    1413           0 :         err_msg = 'In Ncwr_2d_Char #2:  ' // Nf_Strerror (ierr)
    1414           0 :         call Do_Err_Out (err_msg, .true., 2, ncid, tvarid, 0, 0.0d0, 0.0d0)
    1415             :       end if
    1416             : 
    1417           0 :       end subroutine Ncwr_2d_Char
    1418             : !EOC
    1419             : !------------------------------------------------------------------------
    1420             : end module HCO_m_netcdf_io_write
    1421             : 

Generated by: LCOV version 1.14