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 :
|