Line data Source code
1 : !-------------------------------------------------------------------------------
2 : !
3 : ! WARNING: USE OF THIS MODULE WITHIN CAM IS DEPRECATED. ALL
4 : ! HANDLING OF NETCDF FILES SHOULD ULTIMATELY BE DONE
5 : ! BY PIO, OR FOR PORTABLE CODE, SHOULD CONTACT THE
6 : ! NETCDF F90 INTERFACE DIRECTLY.
7 : !
8 : ! DO NOT USE THIS MODULE.
9 : !
10 : !-------------------------------------------------------------------------------
11 :
12 : module wrap_nf
13 : use shr_kind_mod, only: r8 => shr_kind_r8, r4 => shr_kind_r4
14 : use cam_abortutils, only: endrun
15 : use cam_logfile, only: iulog
16 : use netcdf
17 :
18 : !-------------------------------------------------------------------------------
19 : !
20 : ! Purpose:
21 : !
22 : ! Wrapper routines for the netCDF library for input and output data.
23 : !
24 : ! Author: Jim Rosinski
25 : !
26 : ! $Id$
27 : !
28 : !-------------------------------------------------------------------------------
29 :
30 :
31 : contains
32 : !===============================================================================
33 :
34 : !===============================================================================
35 :
36 0 : subroutine wrap_redef (nfid)
37 : implicit none
38 :
39 : integer, intent(in):: nfid
40 :
41 : integer ret ! NetCDF return code
42 :
43 0 : ret = nf90_redef (nfid)
44 0 : if (ret/=NF90_NOERR) call handle_error (ret)
45 :
46 0 : end subroutine wrap_redef
47 : !===============================================================================
48 :
49 0 : subroutine wrap_enddef (nfid)
50 : implicit none
51 :
52 :
53 : integer, intent(in):: nfid
54 :
55 : integer ret ! NetCDF return code
56 :
57 0 : ret = nf90_enddef (nfid)
58 0 : if (ret/=NF90_NOERR) call handle_error (ret)
59 :
60 0 : end subroutine wrap_enddef
61 :
62 0 : subroutine wrap_create (path, cmode, ncid)
63 : implicit none
64 : !-------------------------------------------------------------------------------
65 : !
66 : ! Purpose:
67 : !
68 : ! Create a netCDF file for reading and/or writing
69 : !
70 : !-------------------------------------------------------------------------------
71 :
72 : character*(*), intent(in):: path
73 : integer, intent(in):: cmode
74 : integer, intent(out):: ncid
75 :
76 : integer ret ! NetCDF return code
77 :
78 0 : ret = nf90_create (path, cmode, ncid)
79 0 : if (ret/=NF90_NOERR) call handle_error (ret)
80 :
81 0 : end subroutine wrap_create
82 :
83 : !===============================================================================
84 :
85 0 : subroutine wrap_inq_unlimdim (nfid, dimid)
86 : implicit none
87 : !-------------------------------------------------------------------------------
88 : !
89 : ! Purpose:
90 : !
91 : ! Get dimid for the unlimited dimension.
92 : !
93 : !-------------------------------------------------------------------------------
94 : integer, intent(in):: nfid
95 : integer, intent(out):: dimid
96 :
97 : integer ret ! NetCDF return code
98 :
99 0 : ret = nf90_inquire(nfid, unlimitedDimId=dimid)
100 0 : if (ret/=NF90_NOERR) call handle_error (ret)
101 0 : end subroutine wrap_inq_unlimdim
102 :
103 0 : subroutine wrap_inq_dim (nfid, dimid, dimname, dimlen)
104 : implicit none
105 : !-------------------------------------------------------------------------------
106 : !
107 : ! Purpose:
108 : !
109 : ! Gets dimension name for a given dimension id
110 : !
111 : !-------------------------------------------------------------------------------
112 : integer, intent(in):: nfid
113 : integer, intent(in):: dimid
114 : integer, intent(out):: dimlen
115 : character*(*), intent(out):: dimname
116 :
117 : integer ret ! NetCDF return code
118 :
119 0 : ret = nf90_inquire_dimension (nfid, dimid, dimname, dimlen)
120 0 : if (ret/=NF90_NOERR) call handle_error (ret)
121 :
122 0 : end subroutine wrap_inq_dim
123 :
124 0 : subroutine wrap_inq_nvars (nfid, nvars)
125 : !-------------------------------------------------------------------------------
126 : !
127 : ! Purpose:
128 : !
129 : ! Gets number of variables in file
130 : !
131 : !-------------------------------------------------------------------------------
132 : implicit none
133 :
134 : integer, intent(in):: nfid
135 : integer, intent(out):: nvars
136 :
137 : integer ret ! NetCDF return code
138 :
139 0 : ret = nf90_inquire (nfid, nvars)
140 0 : if (ret/=NF90_NOERR) call handle_error (ret)
141 :
142 0 : end subroutine wrap_inq_nvars
143 :
144 0 : subroutine wrap_inq_ndims (nfid, ndims)
145 : implicit none
146 : !-------------------------------------------------------------------------------
147 : !
148 : ! Purpose:
149 : !
150 : ! Gets number of dimensions in file
151 : !
152 : !-------------------------------------------------------------------------------
153 : integer, intent(in):: nfid
154 : integer, intent(out):: ndims
155 :
156 : integer ret ! NetCDF return code
157 :
158 0 : ret = nf90_inquire(nfid, ndims)
159 0 : if (ret/=NF90_NOERR) call handle_error (ret)
160 :
161 0 : end subroutine wrap_inq_ndims
162 :
163 : !===============================================================================
164 :
165 0 : subroutine wrap_inq_dimid (nfid, dimname, dimid)
166 : implicit none
167 : !-------------------------------------------------------------------------------
168 : !
169 : ! Purpose:
170 : !
171 : ! Gets the dimension id
172 : !
173 : !-------------------------------------------------------------------------------
174 :
175 : integer, intent(in):: nfid
176 : integer, intent(out):: dimid
177 : character*(*), intent(in):: dimname
178 :
179 : integer ret ! NetCDF return code
180 :
181 0 : ret = nf90_inq_dimid (nfid, dimname, dimid)
182 0 : if(ret==NF90_NOERR) return
183 0 : if (ret/=NF90_EBADDIM) call handle_error (ret)
184 0 : dimid=-1 ! do not exist on bad dim. This allows the user to check for dims that may not
185 : ! be in the file
186 : end subroutine wrap_inq_dimid
187 :
188 : !===============================================================================
189 :
190 0 : subroutine wrap_inq_dimlen (nfid, dimid, dimlen)
191 : implicit none
192 : !-------------------------------------------------------------------------------
193 : !
194 : ! Purpose:
195 : !
196 : ! Gets the dimension length for a given dimension
197 : !
198 : !-------------------------------------------------------------------------------
199 :
200 : integer, intent(in):: nfid
201 : integer, intent(in):: dimid
202 : integer, intent(out):: dimlen
203 :
204 : integer ret ! NetCDF return code
205 :
206 0 : ret = nf90_inquire_dimension (nfid, dimid, len=dimlen)
207 0 : if (ret/=NF90_NOERR) call handle_error (ret)
208 0 : end subroutine wrap_inq_dimlen
209 :
210 : !===============================================================================
211 :
212 0 : subroutine wrap_inq_vardimid (nfid, varid, dimids)
213 : !-------------------------------------------------------------------------------
214 : !
215 : ! Purpose:
216 : !
217 : ! Returns the dimension Id's from a variable
218 : !
219 : !-------------------------------------------------------------------------------
220 : implicit none
221 :
222 : integer, intent(in):: nfid
223 : integer, intent(in):: varid
224 : integer, intent(out):: dimids(:)
225 :
226 : integer ret ! NetCDF return code
227 :
228 0 : ret = nf90_inquire_variable (nfid, varid, dimids=dimids)
229 0 : if (ret/=NF90_NOERR) call handle_error (ret)
230 0 : end subroutine wrap_inq_vardimid
231 :
232 : !===============================================================================
233 :
234 0 : subroutine wrap_inq_varndims (nfid, varid, ndims)
235 : !-------------------------------------------------------------------------------
236 : !
237 : ! Purpose:
238 : !
239 : ! Returns the dimension Id's from a variable
240 : !
241 : !-------------------------------------------------------------------------------
242 : implicit none
243 :
244 : integer, intent(in):: nfid
245 : integer, intent(in):: varid
246 : integer, intent(out):: ndims
247 :
248 : integer ret ! NetCDF return code
249 :
250 0 : ret = nf90_inquire_variable (nfid, varid, ndims=ndims)
251 0 : if (ret/=NF90_NOERR) call handle_error (ret)
252 0 : end subroutine wrap_inq_varndims
253 :
254 : !===============================================================================
255 :
256 0 : subroutine wrap_inq_varid (nfid, varname, varid, abort)
257 : !-------------------------------------------------------------------------------
258 : !
259 : ! Purpose:
260 : !
261 : ! Returns the variable ID
262 : !
263 : !-------------------------------------------------------------------------------
264 : implicit none
265 :
266 : integer, intent(in):: nfid
267 : integer, intent(out):: varid
268 : character*(*), intent(in):: varname
269 : logical, optional :: abort
270 :
271 : integer ret ! NetCDF return code
272 : logical :: call_endrun
273 :
274 0 : ret = nf90_inq_varid (nfid, varname, varid)
275 0 : if (ret/=NF90_NOERR ) then
276 0 : call_endrun = .true.
277 0 : if ( present(abort) ) then
278 0 : call_endrun = abort
279 : endif
280 :
281 0 : if ( call_endrun ) then
282 0 : write(iulog,*)'wrap_inq_varid: id for ',trim(varname),' not found'
283 0 : call handle_error (ret)
284 : else
285 0 : varid = -1
286 : endif
287 : end if
288 0 : end subroutine wrap_inq_varid
289 :
290 : !===============================================================================
291 :
292 0 : subroutine wrap_inq_var (nfid, varid, varname, xtype, ndims, &
293 0 : dimids, natts)
294 : !-------------------------------------------------------------------------------
295 : !
296 : ! Purpose:
297 : !
298 : ! Returns the variable name, type, number of dimensions, dimension ID's, and number of attributes
299 : !
300 : !-------------------------------------------------------------------------------
301 : implicit none
302 :
303 : integer, intent(in):: nfid
304 : integer, intent(in):: varid
305 : integer, intent(out):: xtype
306 : integer, intent(out):: ndims
307 : integer, intent(out):: dimids(:)
308 : integer, intent(out):: natts
309 : character*(*), intent(out):: varname
310 :
311 : integer ret ! NetCDF return code
312 :
313 : ret = nf90_inquire_variable (nfid, varid, varname, xtype, ndims, dimids, &
314 0 : natts)
315 0 : if (ret/=NF90_NOERR) call handle_error (ret)
316 0 : end subroutine wrap_inq_var
317 :
318 : !===============================================================================
319 :
320 0 : subroutine wrap_inq_varname (nfid, varid, varname)
321 : !-------------------------------------------------------------------------------
322 : !
323 : ! Purpose:
324 : !
325 : ! Returns the variable name from the dimension ID
326 : !
327 : !-------------------------------------------------------------------------------
328 : implicit none
329 :
330 : integer ret ! NetCDF return code
331 :
332 : integer, intent(in):: nfid
333 : integer, intent(in):: varid
334 : character*(*), intent(out):: varname
335 :
336 0 : ret = nf90_inquire_variable(nfid, varid, varname)
337 0 : if (ret/=NF90_NOERR) call handle_error (ret)
338 0 : end subroutine wrap_inq_varname
339 :
340 : !===============================================================================
341 :
342 0 : subroutine wrap_get_att_text (nfid, varid, attname, atttext)
343 : !-------------------------------------------------------------------------------
344 : !
345 : ! Purpose:
346 : !
347 : ! Returns the attribute text from the given variable ID and attribute name
348 : !
349 : !-------------------------------------------------------------------------------
350 : implicit none
351 :
352 : integer, intent(in):: nfid
353 : integer, intent(in):: varid
354 : character*(*), intent(in):: attname
355 : character*(*), intent(out):: atttext
356 :
357 : integer ret ! NetCDF return code
358 :
359 0 : ret = nf90_get_att(nfid, varid, attname, atttext)
360 0 : if (ret/=NF90_NOERR) then
361 0 : write(iulog,*)'WRAP_GET_ATT_TEXT: error reading attribute '//trim(attname)
362 0 : call handle_error (ret)
363 : endif
364 0 : end subroutine wrap_get_att_text
365 :
366 : !===============================================================================
367 :
368 0 : subroutine wrap_put_att_text (nfid, varid, attname, atttext)
369 : !-------------------------------------------------------------------------------
370 : !
371 : ! Purpose:
372 : !
373 : ! Puts the given attribute text to variable ID.
374 : !
375 : ! This routine violates the convetion that the wrapper codes take an identical
376 : ! set of arguments as the netcdf library code. The length of the character
377 : ! argument is computed inside the wrapper.
378 : !
379 : !-------------------------------------------------------------------------------
380 : implicit none
381 :
382 : integer, intent(in):: nfid
383 : integer, intent(in):: varid
384 : character*(*), intent(in):: attname
385 : character*(*), intent(in):: atttext
386 :
387 : integer ret ! NetCDF return code
388 : integer siz
389 :
390 0 : ret = nf90_put_att(nfid, varid, attname, atttext)
391 0 : if (ret/=NF90_NOERR) call handle_error (ret)
392 0 : end subroutine wrap_put_att_text
393 :
394 : !===============================================================================
395 :
396 0 : subroutine wrap_put_att_realx (nfid, varid, attname, xtype, len, &
397 0 : attval)
398 : !-------------------------------------------------------------------------------
399 : !
400 : ! Purpose:
401 : !
402 : ! Puts the given real attribute to the variable id
403 : !
404 : !-------------------------------------------------------------------------------
405 : implicit none
406 :
407 : integer , intent(in):: nfid
408 : integer , intent(in):: varid
409 : integer , intent(in):: xtype
410 : integer , intent(in):: len
411 : character*(*) , intent(in):: attname
412 : real(r8) , intent(in):: attval(len)
413 :
414 : integer ret ! NetCDF return code
415 :
416 0 : ret = nf90_put_att(nfid, varid, attname, attval)
417 0 : if (ret/=NF90_NOERR) call handle_error (ret)
418 0 : end subroutine wrap_put_att_realx
419 : !===============================================================================
420 :
421 0 : subroutine wrap_def_dim (nfid, dimname, len, dimid)
422 : !-------------------------------------------------------------------------------
423 : !
424 : ! Purpose:
425 : !
426 : ! Defines the input dimension
427 : !
428 : !-------------------------------------------------------------------------------
429 : implicit none
430 : integer, intent(in):: nfid
431 : integer, intent(in):: len
432 : integer, intent(out):: dimid
433 : character*(*), intent(in):: dimname
434 :
435 : integer ret ! NetCDF return code
436 :
437 0 : ret = nf90_def_dim (nfid, dimname, len, dimid)
438 0 : if (ret/=NF90_NOERR) call handle_error (ret)
439 0 : end subroutine wrap_def_dim
440 :
441 : !===============================================================================
442 :
443 0 : subroutine wrap_def_var (nfid, name, xtype, nvdims, vdims, varid)
444 : !-------------------------------------------------------------------------------
445 : !
446 : ! Purpose:
447 : !
448 : ! Defines the given variable
449 : !
450 : !-------------------------------------------------------------------------------
451 : implicit none
452 :
453 : integer, intent(in):: nfid
454 : integer, intent(in)::xtype
455 : integer, intent(in)::nvdims
456 : integer, intent(out)::varid
457 : integer, intent(in):: vdims(nvdims)
458 : character*(*), intent(in):: name
459 :
460 : integer ret ! NetCDF return code
461 :
462 0 : ret = nf90_def_var(nfid, name, xtype, vdims, varid)
463 0 : if (ret/=NF90_NOERR) call handle_error (ret)
464 0 : end subroutine wrap_def_var
465 :
466 : !===============================================================================
467 :
468 0 : subroutine wrap_get_var_realx (nfid, varid, arr)
469 : !-------------------------------------------------------------------------------
470 : !
471 : ! Purpose:
472 : !
473 : ! Gets the given real variable from a input file
474 : !
475 : !-------------------------------------------------------------------------------
476 : implicit none
477 :
478 : integer, intent(in):: nfid
479 : integer, intent(in):: varid
480 : real(r8), intent(out):: arr(:)
481 :
482 : integer ret ! NetCDF return code
483 :
484 0 : ret = nf90_get_var (nfid, varid, arr)
485 0 : if (ret/=NF90_NOERR) then
486 0 : write(iulog,*)'WRAP_GET_VAR_REALX: error reading varid =', varid
487 0 : call handle_error (ret)
488 : end if
489 0 : end subroutine wrap_get_var_realx
490 :
491 : !===============================================================================
492 :
493 0 : subroutine wrap_get_var_real4 (nfid, varid, arr)
494 : !-------------------------------------------------------------------------------
495 : !
496 : ! Purpose:
497 : !
498 : ! Gets the given real variable from a input file
499 : !
500 : !-------------------------------------------------------------------------------
501 : implicit none
502 :
503 : integer, intent(in):: nfid
504 : integer, intent(in):: varid
505 : real(r4), intent(out):: arr(:)
506 :
507 : integer ret ! NetCDF return code
508 :
509 0 : ret = nf90_get_var (nfid, varid, arr)
510 0 : if (ret/=NF90_NOERR) then
511 0 : write(iulog,*)'WRAP_GET_VAR_REAL4: error reading varid =', varid
512 0 : call handle_error (ret)
513 : end if
514 0 : end subroutine wrap_get_var_real4
515 :
516 : !===============================================================================
517 :
518 0 : subroutine wrap_get_scalar_realx (nfid, varid, x)
519 : !-------------------------------------------------------------------------------
520 : !
521 : ! Purpose:
522 : !
523 : ! Gets the given real variable from a input file
524 : !
525 : !-------------------------------------------------------------------------------
526 : implicit none
527 :
528 : integer, intent(in):: nfid
529 : integer, intent(in):: varid
530 : real(r8), intent(out):: x
531 :
532 : integer ret ! NetCDF return code
533 :
534 0 : ret = nf90_get_var (nfid, varid, x)
535 0 : if (ret/=NF90_NOERR) then
536 0 : write(iulog,*)'WRAP_GET_SCALAR_REALX: error reading varid =', varid
537 0 : call handle_error (ret)
538 : end if
539 0 : end subroutine wrap_get_scalar_realx
540 :
541 : !===============================================================================
542 :
543 0 : subroutine wrap_get_var_int (nfid, varid, arr)
544 : !-------------------------------------------------------------------------------
545 : !
546 : ! Purpose:
547 : !
548 : ! Gets the given integer variable from a input file
549 : !
550 : !-------------------------------------------------------------------------------
551 : implicit none
552 :
553 : integer, intent(in):: nfid
554 : integer, intent(in):: varid
555 : integer, intent(out):: arr(:)
556 :
557 : integer ret ! NetCDF return code
558 :
559 0 : ret = nf90_get_var (nfid, varid, arr)
560 0 : if (ret/=NF90_NOERR) then
561 0 : write(iulog,*)'WRAP_GET_VAR_INT: error reading varid =', varid
562 0 : call handle_error (ret)
563 : end if
564 0 : end subroutine wrap_get_var_int
565 :
566 : !===============================================================================
567 :
568 0 : subroutine wrap_get_scalar_int (nfid, varid, x)
569 : !-------------------------------------------------------------------------------
570 : !
571 : ! Purpose:
572 : !
573 : ! Gets the given integer variable from a input file
574 : !
575 : !-------------------------------------------------------------------------------
576 : implicit none
577 :
578 : integer, intent(in):: nfid
579 : integer, intent(in):: varid
580 : integer, intent(out):: x
581 :
582 : integer ret ! NetCDF return code
583 :
584 0 : ret = nf90_get_var (nfid, varid, x)
585 0 : if (ret/=NF90_NOERR) then
586 0 : write(iulog,*)'WRAP_GET_SCALAR_INT: error reading varid =', varid
587 0 : call handle_error (ret)
588 : end if
589 0 : end subroutine wrap_get_scalar_int
590 :
591 : !===============================================================================
592 :
593 0 : subroutine wrap_get_vara_realx (nfid, varid, start, count, arr)
594 : !-------------------------------------------------------------------------------
595 : !
596 : ! Purpose:
597 : !
598 : ! Gets a range of the given real variable from a input file
599 : !
600 : !-------------------------------------------------------------------------------
601 : implicit none
602 :
603 : integer, intent(in):: nfid
604 : integer, intent(in)::varid
605 : integer, intent(in)::start(:)
606 : integer, intent(in)::count(:)
607 : real(r8), intent(out):: arr(:)
608 :
609 : integer ret ! NetCDF return code
610 :
611 0 : ret = nf90_get_var (nfid, varid, arr, start, count)
612 0 : if (ret/=NF90_NOERR) then
613 0 : write(iulog,*)'WRAP_GET_VARA_REALX: error reading varid =', varid
614 0 : call handle_error (ret)
615 : end if
616 0 : end subroutine wrap_get_vara_realx
617 :
618 : !===============================================================================
619 :
620 0 : subroutine wrap_get_vara_int (nfid, varid, start, count, arr)
621 : !-------------------------------------------------------------------------------
622 : !
623 : ! Purpose:
624 : !
625 : ! Gets a range of the given integer variable from a input file.
626 : !
627 : !-------------------------------------------------------------------------------
628 : implicit none
629 :
630 : integer, intent(in):: nfid
631 : integer, intent(in):: varid
632 : integer, intent(in):: start(:)
633 : integer, intent(in):: count(:)
634 : integer, intent(out):: arr(:)
635 :
636 : integer ret ! NetCDF return code
637 :
638 0 : ret = nf90_get_var (nfid, varid, arr, start, count)
639 0 : if (ret/=NF90_NOERR) then
640 0 : write(iulog,*)'WRAP_GET_VARA_INT: error reading varid =', varid
641 0 : call handle_error (ret)
642 : end if
643 0 : end subroutine wrap_get_vara_int
644 :
645 : !===============================================================================
646 :
647 0 : subroutine wrap_get_vara_text (nfid, varid, start, count, text)
648 : !-------------------------------------------------------------------------------
649 : !
650 : ! Purpose:
651 : !
652 : ! Gets a range of the given text variable to input file.
653 : !
654 : !-------------------------------------------------------------------------------
655 : implicit none
656 :
657 : integer, intent(in):: nfid
658 : integer, intent(in):: varid
659 : integer, intent(in):: start(:)
660 : integer, intent(in):: count(:)
661 : character(len=*), intent(out):: text(:)
662 :
663 : integer ret ! NetCDF return code
664 :
665 0 : ret = nf90_get_var (nfid, varid, text, start, count)
666 0 : if (ret/=NF90_NOERR) call handle_error (ret)
667 0 : end subroutine wrap_get_vara_text
668 :
669 : !===============================================================================
670 :
671 0 : subroutine wrap_open (path, omode, ncid)
672 : !-------------------------------------------------------------------------------
673 : !
674 : ! Purpose:
675 : !
676 : ! Open a netCDF file
677 : !
678 : !-------------------------------------------------------------------------------
679 : implicit none
680 :
681 : character*(*), intent(in):: path
682 : integer, intent(in):: omode
683 : integer, intent(out):: ncid
684 :
685 : integer ret ! NetCDF return code
686 :
687 0 : ret = nf90_open (path, omode, ncid)
688 0 : if (ret/=NF90_NOERR) then
689 0 : write(iulog,*)'WRAP_OPEN: nf90_open failed for file ',path
690 0 : call handle_error (ret)
691 : end if
692 0 : end subroutine wrap_open
693 :
694 : !===============================================================================
695 :
696 0 : subroutine wrap_close (ncid)
697 : !-------------------------------------------------------------------------------
698 : !
699 : ! Purpose:
700 : !
701 : ! Close netCDF file
702 : !
703 : !-------------------------------------------------------------------------------
704 : implicit none
705 :
706 : integer, intent(in):: ncid
707 :
708 : integer ret ! NetCDF return code
709 :
710 0 : ret = nf90_close (ncid)
711 0 : if (ret/=NF90_NOERR) then
712 0 : write(iulog,*)'WRAP_CLOSE: nf90_close failed for id ',ncid
713 0 : call handle_error (ret)
714 : end if
715 0 : end subroutine wrap_close
716 :
717 : !===============================================================================
718 :
719 0 : subroutine wrap_put_var_int (nfid, varid, arr)
720 : !-------------------------------------------------------------------------------
721 : !
722 : ! Purpose:
723 : !
724 : ! Put a integer variable on output file.
725 : !
726 : !-------------------------------------------------------------------------------
727 : implicit none
728 :
729 : integer, intent(in):: nfid
730 : integer, intent(in):: varid
731 : integer, intent(in):: arr(:)
732 :
733 : integer ret ! NetCDF return code
734 :
735 0 : ret = nf90_put_var (nfid, varid, arr)
736 0 : if (ret/=NF90_NOERR) call handle_error (ret)
737 0 : end subroutine wrap_put_var_int
738 :
739 : !===============================================================================
740 :
741 0 : subroutine wrap_put_var1_int (nfid, varid, index, ival)
742 : !-------------------------------------------------------------------------------
743 : !
744 : ! Purpose:
745 : !
746 : ! Put a variable on output file at a given index.
747 : !
748 : !-------------------------------------------------------------------------------
749 : implicit none
750 :
751 : integer, intent(in):: nfid
752 : integer, intent(in):: varid
753 : integer, intent(in):: index(:)
754 : integer, intent(in):: ival
755 :
756 : integer ret ! NetCDF return code
757 :
758 0 : ret = nf90_put_var (nfid, varid, ival, index)
759 0 : if (ret/=NF90_NOERR) call handle_error (ret)
760 0 : end subroutine wrap_put_var1_int
761 :
762 : !===============================================================================
763 :
764 0 : subroutine wrap_put_vara_int (nfid, varid, start, count, arr)
765 : !-------------------------------------------------------------------------------
766 : !
767 : ! Purpose:
768 : !
769 : ! Put a range of a integer variable on a output file.
770 : !
771 : !-------------------------------------------------------------------------------
772 : implicit none
773 :
774 : integer, intent(in):: nfid
775 : integer, intent(in):: varid
776 : integer, intent(in):: start(:)
777 : integer, intent(in):: count(:)
778 : integer, intent(in):: arr(:)
779 :
780 : integer ret ! NetCDF return code
781 :
782 0 : ret = nf90_put_var (nfid, varid, arr, start, count)
783 0 : if (ret/=NF90_NOERR) call handle_error (ret)
784 0 : end subroutine wrap_put_vara_int
785 :
786 : !===============================================================================
787 :
788 0 : subroutine wrap_put_vara_text (nfid, varid, start, count, text)
789 : !-------------------------------------------------------------------------------
790 : !
791 : ! Purpose:
792 : !
793 : ! Put a range of the given text variable to output file.
794 : !
795 : !-------------------------------------------------------------------------------
796 : implicit none
797 :
798 : integer, intent(in):: nfid
799 : integer, intent(in):: varid
800 : integer, intent(in):: start(:)
801 : integer, intent(in):: count(:)
802 : character(len=*), intent(in):: text(:)
803 :
804 : integer ret ! NetCDF return code
805 :
806 0 : ret = nf90_put_var (nfid, varid, text, start, count)
807 0 : if (ret/=NF90_NOERR) call handle_error (ret)
808 0 : end subroutine wrap_put_vara_text
809 :
810 : !===============================================================================
811 :
812 0 : subroutine wrap_put_var1_realx (nfid, varid, index, val)
813 : !-------------------------------------------------------------------------------
814 : !
815 : ! Purpose:
816 : !
817 : ! Put the given real variable to output file at given index.
818 : !
819 : !-------------------------------------------------------------------------------
820 : implicit none
821 :
822 : integer, intent(in):: nfid
823 : integer, intent(in):: varid
824 : integer, intent(in):: index(:)
825 : real(r8), intent(in):: val
826 :
827 : integer ret ! NetCDF return code
828 :
829 0 : ret = nf90_put_var (nfid, varid, val, index)
830 0 : if (ret/=NF90_NOERR) call handle_error (ret)
831 0 : end subroutine wrap_put_var1_realx
832 :
833 : !===============================================================================
834 :
835 0 : subroutine wrap_put_vara_realx (nfid, varid, start, count, arr)
836 : !-------------------------------------------------------------------------------
837 : !
838 : ! Purpose:
839 : !
840 : ! Output the given portion of the real array.
841 : !
842 : !-------------------------------------------------------------------------------
843 : implicit none
844 :
845 : integer, intent(in):: nfid
846 : integer, intent(in):: varid
847 : integer, intent(in):: start(:)
848 : integer, intent(in):: count(:)
849 : real(r8), intent(in):: arr(:)
850 :
851 : integer ret ! NetCDF return code
852 0 : ret = nf90_put_var (nfid, varid, arr, start, count)
853 0 : if (ret/=NF90_NOERR) call handle_error (ret)
854 0 : end subroutine wrap_put_vara_realx
855 :
856 : !===============================================================================
857 :
858 0 : subroutine wrap_put_vara_real (nfid, varid, start, count, arr)
859 : !-------------------------------------------------------------------------------
860 : !
861 : ! Purpose:
862 : !
863 : ! Output the given portion of the real array.
864 : !
865 : !-------------------------------------------------------------------------------
866 : implicit none
867 :
868 : integer, intent(in):: nfid
869 : integer, intent(in):: varid
870 : integer, intent(in):: start(:)
871 : integer, intent(in):: count(:)
872 : real(r4), intent(in):: arr(:)
873 :
874 : integer ret ! NetCDF return code
875 0 : ret = nf90_put_var (nfid, varid, arr, start, count)
876 0 : if (ret/=NF90_NOERR) call handle_error (ret)
877 0 : end subroutine wrap_put_vara_real
878 :
879 : !===============================================================================
880 :
881 0 : subroutine wrap_put_var_realx (nfid, varid, arr)
882 : !-------------------------------------------------------------------------------
883 : !
884 : ! Purpose:
885 : !
886 : ! Put the given real variable to output file.
887 : !
888 : !-------------------------------------------------------------------------------
889 : implicit none
890 :
891 : integer, intent(in):: nfid
892 : integer, intent(in):: varid
893 : real(r8), intent(in):: arr(:)
894 :
895 : integer ret ! NetCDF return code
896 :
897 0 : ret = nf90_put_var (nfid, varid, arr)
898 0 : if (ret/=NF90_NOERR) call handle_error (ret)
899 0 : end subroutine wrap_put_var_realx
900 :
901 : !===============================================================================
902 :
903 0 : subroutine handle_error(ret)
904 : !-------------------------------------------------------------------------------
905 : !
906 : ! Purpose:
907 : !
908 : ! Handle netCDF errors.
909 : !
910 : !-------------------------------------------------------------------------------
911 :
912 : implicit none
913 :
914 : integer, intent(in):: ret
915 :
916 0 : write(iulog,*)nf90_strerror(ret)
917 0 : call endrun ('HANDLE_ERROR')
918 0 : end subroutine handle_error
919 :
920 : !===============================================================================
921 : end module wrap_nf
|
