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