102 SUBROUTINE volgrid6d_compute_stat_proc(this, that, stat_proc_input, stat_proc, &
103 step, start, full_steps, frac_valid, max_step, weighted,
clone)
106 INTEGER,
INTENT(in) :: stat_proc_input
107 INTEGER,
INTENT(in) :: stat_proc
109 type(datetime),
INTENT(in),
OPTIONAL :: start
110 LOGICAL,
INTENT(in),
OPTIONAL :: full_steps
111 REAL,
INTENT(in),
OPTIONAL :: frac_valid
112 type(
timedelta),
INTENT(in),
OPTIONAL :: max_step
113 LOGICAL,
INTENT(in),
OPTIONAL :: weighted
114 LOGICAL ,
INTENT(in),
OPTIONAL ::
clone
116 INTEGER :: dtmax, dtstep
119 IF (stat_proc_input == 254)
THEN
121 'computing statistical processing by aggregation '//&
124 CALL volgrid6d_compute_stat_proc_agg(this, that, stat_proc, &
125 step, start, full_steps, max_step,
clone)
127 ELSE IF (stat_proc == 254)
THEN
129 'statistical processing to instantaneous data not implemented for gridded fields')
132 ELSE IF (stat_proc_input /= stat_proc)
THEN
133 IF ((stat_proc_input == 0 .AND. stat_proc == 1) .OR. &
134 (stat_proc_input == 1 .AND. stat_proc == 0))
THEN
136 'computing statistically processed data by integration/differentiation '// &
137 t2c(stat_proc_input)//
':'//
t2c(stat_proc))
138 CALL volgrid6d_compute_stat_proc_metamorph(this, that, stat_proc_input, &
142 'statistical processing '//
t2c(stat_proc_input)//
':'//
t2c(stat_proc)// &
143 ' not implemented or does not make sense')
147 ELSE IF (count(this%timerange(:)%timerange == stat_proc) == 0)
THEN
149 'no timeranges of the desired statistical processing type '//
t2c(stat_proc)//
' available')
152 CALL volgrid6d_alloc_vol(that)
156 dtmax = maxval(this%timerange(:)%p2, &
157 mask=(this%timerange(:)%timerange == stat_proc))
158 CALL
getval(step, asec=dtstep)
162 'stat_proc='//
t2c(stat_proc)//
' dtmax='//
t2c(dtmax)//
' dtstep='//
t2c(dtstep))
165 IF (dtstep < dtmax)
THEN
167 'recomputing statistically processed data by difference '// &
168 t2c(stat_proc_input)//
':'//
t2c(stat_proc))
169 CALL volgrid6d_recompute_stat_proc_diff(this, that, stat_proc, step, &
170 full_steps, start,
clone)
173 'recomputing statistically processed data by aggregation '// &
174 t2c(stat_proc_input)//
':'//
t2c(stat_proc))
175 CALL volgrid6d_recompute_stat_proc_agg(this, that, stat_proc, step, start, &
176 full_steps, frac_valid,
clone)
181 END SUBROUTINE volgrid6d_compute_stat_proc
226 SUBROUTINE volgrid6d_recompute_stat_proc_agg(this, that, stat_proc, &
227 step, start, full_steps, frac_valid,
clone)
230 INTEGER,
INTENT(in) :: stat_proc
232 type(datetime),
INTENT(in),
OPTIONAL :: start
233 LOGICAL,
INTENT(in),
OPTIONAL :: full_steps
234 REAL,
INTENT(in),
OPTIONAL :: frac_valid
235 LOGICAL,
INTENT(in),
OPTIONAL ::
clone
238 INTEGER i, j, n, n1, ndtr, i3, i6
240 INTEGER,
POINTER :: dtratio(:)
243 REAL,
POINTER :: voldatiin(:,:), voldatiout(:,:)
246 nullify(voldatiin, voldatiout)
248 IF (present(frac_valid))
THEN
249 lfrac_valid = frac_valid
256 CALL volgrid6d_alloc_vol(this)
260 lclone = optio_log(
clone) .OR. .NOT.
ASSOCIATED(this%voldati)
262 CALL
init(that, griddim=this%griddim, time_definition=this%time_definition)
263 CALL volgrid6d_alloc(that, dim=this%griddim%dim, ntimerange=1, &
264 nlevel=
SIZE(this%level), nvar=
SIZE(this%var), ini=.false.)
265 that%level = this%level
268 CALL recompute_stat_proc_agg_common(this%time, this%timerange, stat_proc, tri, &
269 step, this%time_definition, that%time, that%timerange, map_ttr, &
270 dtratio=dtratio, start=start, full_steps=full_steps)
272 CALL volgrid6d_alloc_vol(that, decode=
ASSOCIATED(this%voldati))
274 do_otimerange:
DO j = 1,
SIZE(that%timerange)
275 do_otime:
DO i = 1,
SIZE(that%time)
277 DO n1 = 1,
SIZE(dtratio)
278 IF (dtratio(n1) <= 0) cycle
280 DO i6 = 1,
SIZE(this%var)
281 DO i3 = 1,
SIZE(this%level)
282 CALL volgrid_get_vol_2d(that, i3, i, j, i6, voldatiout)
284 DO n = 1, map_ttr(i,j)%arraysize
285 IF (map_ttr(i,j)%array(n)%extra_info == dtratio(n1))
THEN
287 CALL volgrid_get_vol_2d(this, i3, map_ttr(i,j)%array(n)%it, &
288 map_ttr(i,j)%array(n)%itr, i6, voldatiin)
291 voldatiout = voldatiin
293 CALL
copy(this%gaid(i3, map_ttr(i,j)%array(n)%it,&
294 map_ttr(i,j)%array(n)%itr,i6), that%gaid(i3,i,j,i6))
296 that%gaid(i3,i,j,i6) = this%gaid(i3, map_ttr(i,j)%array(n)%it, &
297 map_ttr(i,j)%array(n)%itr,i6)
301 SELECT CASE(stat_proc)
303 WHERE(
c_e(voldatiin(:,:)) .AND.
c_e(voldatiout(:,:)))
304 voldatiout(:,:) = voldatiout(:,:) + voldatiin(:,:)
306 voldatiout(:,:) = rmiss
309 WHERE(
c_e(voldatiin(:,:)) .AND.
c_e(voldatiout(:,:)))
310 voldatiout(:,:) = max(voldatiout(:,:), voldatiin(:,:))
312 voldatiout(:,:) = rmiss
315 WHERE(
c_e(voldatiin(:,:)) .AND.
c_e(voldatiout(:,:)))
316 voldatiout(:,:) = min(voldatiout(:,:), voldatiin(:,:))
318 voldatiout(:,:) = rmiss
327 CALL l4f_log(l4f_debug, &
328 'compute_stat_proc_agg, ndtr/dtratio/frac_valid: '// &
329 t2c(ndtr)//
'/'//
t2c(dtratio(n1))//
'/'//
t2c(lfrac_valid))
332 IF (
REAL(ndtr)/
REAL(dtratio(n1)) >= lfrac_valid) then
333 IF (stat_proc == 0)
THEN
334 WHERE(
c_e(voldatiout(:,:)))
335 voldatiout(:,:) = voldatiout(:,:)/ndtr
338 CALL volgrid_set_vol_2d(that, i3, i, j, i6, voldatiout)
340 CALL l4f_log(l4f_debug, &
341 'compute_stat_proc_agg, coding lev/t/tr/var: '// &
347 CALL
delete(that%gaid(i3,i,j,i6))
349 CALL
init(that%gaid(i3,i,j,i6))
352 CALL l4f_log(l4f_debug, &
353 'compute_stat_proc_agg, skipping lev/t/tr/var: '// &
366 DEALLOCATE(dtratio, map_ttr)
368 END SUBROUTINE volgrid6d_recompute_stat_proc_agg
394 SUBROUTINE volgrid6d_compute_stat_proc_agg(this, that, stat_proc, &
395 step, start, full_steps, max_step,
clone)
398 INTEGER,
INTENT(in) :: stat_proc
400 type(datetime),
INTENT(in),
OPTIONAL :: start
401 LOGICAL,
INTENT(in),
OPTIONAL :: full_steps
402 type(
timedelta),
INTENT(in),
OPTIONAL :: max_step
403 LOGICAL ,
INTENT(in),
OPTIONAL ::
clone
406 INTEGER i, j, n, ninp, i3, i6
410 REAL,
POINTER :: voldatiin(:,:), voldatiout(:,:)
413 nullify(voldatiin, voldatiout)
415 IF (present(max_step))
THEN
418 lmax_step = timedelta_max
423 CALL volgrid6d_alloc_vol(this)
427 lclone = optio_log(
clone) .OR. .NOT.
ASSOCIATED(this%voldati)
429 CALL
init(that, griddim=this%griddim, time_definition=this%time_definition)
430 CALL volgrid6d_alloc(that, dim=this%griddim%dim, ntimerange=1, &
431 nlevel=
SIZE(this%level), nvar=
SIZE(this%var), ini=.false.)
432 that%level = this%level
435 CALL recompute_stat_proc_agg_common(this%time, this%timerange, stat_proc, tri, &
436 step, this%time_definition, that%time, that%timerange, map_ttr, &
437 start=start, full_steps=full_steps)
439 CALL volgrid6d_alloc_vol(that, decode=
ASSOCIATED(this%voldati))
441 do_otimerange:
DO j = 1,
SIZE(that%timerange)
442 do_otime:
DO i = 1,
SIZE(that%time)
443 ninp = map_ttr(i,j)%arraysize
444 IF (ninp <= 0) cycle do_otime
446 IF (stat_proc == 4)
THEN
447 IF (map_ttr(i,j)%array(1)%extra_info /= 1 .OR. &
448 map_ttr(i,j)%array(ninp)%extra_info /= 2)
THEN
455 IF (map_ttr(i,j)%array(n)%time - map_ttr(i,j)%array(n-1)%time > &
463 DO i6 = 1,
SIZE(this%var)
464 DO i3 = 1,
SIZE(this%level)
465 CALL volgrid_get_vol_2d(that, i3, i, j, i6, voldatiout)
467 IF (stat_proc == 4)
THEN
469 CALL
copy(this%gaid(i3, map_ttr(i,j)%array(1)%it,&
470 map_ttr(i,j)%array(1)%itr,i6), that%gaid(i3,i,j,i6))
472 that%gaid(i3,i,j,i6) = this%gaid(i3, map_ttr(i,j)%array(1)%it, &
473 map_ttr(i,j)%array(1)%itr,i6)
476 CALL volgrid_get_vol_2d(this, i3, map_ttr(i,j)%array(ninp)%it, &
477 map_ttr(i,j)%array(ninp)%itr, i6, voldatiin)
478 voldatiout = voldatiin
479 CALL volgrid_get_vol_2d(this, i3, map_ttr(i,j)%array(1)%it, &
480 map_ttr(i,j)%array(1)%itr, i6, voldatiin)
482 WHERE(
c_e(voldatiin(:,:)) .AND.
c_e(voldatiout(:,:)))
483 voldatiout(:,:) = voldatiout(:,:) - voldatiin(:,:)
485 voldatiout(:,:) = rmiss
490 CALL volgrid_get_vol_2d(this, i3, map_ttr(i,j)%array(n)%it, &
491 map_ttr(i,j)%array(n)%itr, i6, voldatiin)
494 voldatiout = voldatiin
496 CALL
copy(this%gaid(i3, map_ttr(i,j)%array(n)%it,&
497 map_ttr(i,j)%array(n)%itr,i6), that%gaid(i3,i,j,i6))
499 that%gaid(i3,i,j,i6) = this%gaid(i3, map_ttr(i,j)%array(n)%it, &
500 map_ttr(i,j)%array(n)%itr,i6)
504 SELECT CASE(stat_proc)
506 WHERE(
c_e(voldatiin(:,:)) .AND.
c_e(voldatiout(:,:)))
507 voldatiout(:,:) = voldatiout(:,:) + voldatiin(:,:)
509 voldatiout(:,:) = rmiss
512 WHERE(
c_e(voldatiin(:,:)) .AND.
c_e(voldatiout(:,:)))
513 voldatiout(:,:) = max(voldatiout(:,:), voldatiin(:,:))
515 voldatiout(:,:) = rmiss
518 WHERE(
c_e(voldatiin(:,:)) .AND.
c_e(voldatiout(:,:)))
519 voldatiout(:,:) = min(voldatiout(:,:), voldatiin(:,:))
521 voldatiout(:,:) = rmiss
527 IF (stat_proc == 0)
THEN
528 WHERE(
c_e(voldatiout(:,:)))
529 voldatiout(:,:) = voldatiout(:,:)/ninp
533 CALL volgrid_set_vol_2d(that, i3, i, j, i6, voldatiout)
543 END SUBROUTINE volgrid6d_compute_stat_proc_agg
570 SUBROUTINE volgrid6d_recompute_stat_proc_diff(this, that, stat_proc, step, full_steps, start, clone)
573 INTEGER,
INTENT(in) :: stat_proc
575 LOGICAL,
INTENT(in),
OPTIONAL :: full_steps
576 type(datetime),
INTENT(in),
OPTIONAL :: start
577 LOGICAL,
INTENT(in),
OPTIONAL ::
clone
578 INTEGER :: i3, i4, i6, i, j, k, l, nitr, steps
579 INTEGER,
ALLOCATABLE :: map_tr(:,:,:,:,:), f(:), keep_tr(:,:,:)
580 REAL,
POINTER :: voldatiin1(:,:), voldatiin2(:,:), voldatiout(:,:)
583 TYPE(vol7d_var),
ALLOCATABLE :: varbufr(:)
587 CALL volgrid6d_alloc_vol(this)
590 lclone = optio_log(
clone) .OR. .NOT.
ASSOCIATED(this%voldati)
592 CALL
init(that, griddim=this%griddim, time_definition=this%time_definition)
593 CALL volgrid6d_alloc(that, dim=this%griddim%dim, &
594 nlevel=
SIZE(this%level), nvar=
SIZE(this%var), ini=.false.)
595 that%level = this%level
599 CALL
getval(step, asec=steps)
603 CALL recompute_stat_proc_diff_common(this%time, this%timerange, stat_proc, step, &
604 that%time, that%timerange, map_tr, f, keep_tr, &
605 this%time_definition, full_steps, start)
609 CALL volgrid6d_alloc_vol(that, decode=
ASSOCIATED(this%voldati))
611 IF (.NOT.
ASSOCIATED(that%voldati))
THEN
612 ALLOCATE(voldatiin1(this%griddim%dim%nx, this%griddim%dim%ny), &
613 voldatiin2(this%griddim%dim%nx, this%griddim%dim%ny), &
614 voldatiout(this%griddim%dim%nx, this%griddim%dim%ny))
618 DO i4 = 1,
SIZE(this%time)
620 IF (
c_e(keep_tr(i, i4, 2)))
THEN
621 l = keep_tr(i, i4, 1)
622 k = keep_tr(i, i4, 2)
625 'volgrid6d_recompute_stat_proc_diff, good timerange: '//
t2c(f(i))// &
628 DO i6 = 1,
SIZE(this%var)
629 DO i3 = 1,
SIZE(this%level)
630 IF (
c_e(this%gaid(i3,i4,f(i),i6)))
THEN
632 CALL
copy(this%gaid(i3,i4,f(i),i6), that%gaid(i3,l,k,i6))
634 that%gaid(i3,l,k,i6) = this%gaid(i3,i4,f(i),i6)
636 IF (
ASSOCIATED(that%voldati))
THEN
637 that%voldati(:,:,i3,l,k,i6) = this%voldati(:,:,i3,i4,f(i),i6)
639 CALL volgrid_get_vol_2d(this, i3, i4, f(i), i6, voldatiout)
640 CALL volgrid_set_vol_2d(that, i3, l, k, i6, voldatiout)
650 ALLOCATE(varbufr(
SIZE(this%var)))
651 DO i6 = 1,
SIZE(this%var)
652 varbufr(i6) =
convert(this%var(i6))
655 DO l = 1,
SIZE(this%time)
657 DO j = 1,
SIZE(this%time)
659 IF (
c_e(map_tr(i,j,k,l,1)))
THEN
660 DO i6 = 1,
SIZE(this%var)
661 DO i3 = 1,
SIZE(this%level)
663 IF (
c_e(this%gaid(i3,j,f(i),i6)) .AND. &
664 c_e(this%gaid(i3,l,f(k),i6)))
THEN
668 CALL
copy(this%gaid(i3,l,f(k),i6), &
669 that%gaid(i3,map_tr(i,j,k,l,1),map_tr(i,j,k,l,2),i6))
671 that%gaid(i3,map_tr(i,j,k,l,1),map_tr(i,j,k,l,2),i6) = &
672 this%gaid(i3,l,f(k),i6)
676 CALL volgrid_get_vol_2d(this, i3, l, f(k), i6, voldatiin1)
677 CALL volgrid_get_vol_2d(this, i3, j, f(i), i6, voldatiin2)
678 IF (
ASSOCIATED(that%voldati)) &
679 CALL volgrid_get_vol_2d(that, i3, &
680 map_tr(i,j,k,l,1), map_tr(i,j,k,l,2), i6, voldatiout)
682 IF (stat_proc == 0)
THEN
683 WHERE(
c_e(voldatiin1(:,:)) .AND.
c_e(voldatiin2(:,:)))
685 (voldatiin1(:,:)*this%timerange(f(k))%p2 - &
686 voldatiin2(:,:)*this%timerange(f(i))%p2)/ &
689 voldatiout(:,:) = rmiss
691 ELSE IF (stat_proc == 1 .OR. stat_proc == 4)
THEN
692 WHERE(
c_e(voldatiin1(:,:)) .AND.
c_e(voldatiin2(:,:)))
693 voldatiout(:,:) = voldatiin1(:,:) - voldatiin2(:,:)
695 voldatiout(:,:) = rmiss
697 IF (stat_proc == 1)
THEN
698 CALL vol7d_var_features_posdef_apply(varbufr(i6), voldatiout)
702 CALL volgrid_set_vol_2d(that, i3, &
703 map_tr(i,j,k,l,1), map_tr(i,j,k,l,2), i6, voldatiout)
714 IF (.NOT.
ASSOCIATED(that%voldati))
THEN
715 DEALLOCATE(voldatiin1, voldatiin2, voldatiout)
718 END SUBROUTINE volgrid6d_recompute_stat_proc_diff
748 SUBROUTINE volgrid6d_compute_stat_proc_metamorph(this, that, stat_proc_input, stat_proc, clone)
751 INTEGER,
INTENT(in) :: stat_proc_input
752 INTEGER,
INTENT(in) :: stat_proc
753 LOGICAL ,
INTENT(in),
OPTIONAL ::
clone
755 INTEGER :: j, i3, i4, i6
756 INTEGER,
POINTER :: map_tr(:)
757 REAL,
POINTER :: voldatiin(:,:), voldatiout(:,:)
758 REAL,
ALLOCATABLE :: int_ratio(:)
761 nullify(voldatiin, voldatiout)
764 CALL volgrid6d_alloc_vol(this)
767 lclone = optio_log(
clone) .OR. .NOT.
ASSOCIATED(this%voldati)
769 IF (.NOT.((stat_proc_input == 0 .AND. stat_proc == 1) .OR. &
770 (stat_proc_input == 1 .AND. stat_proc == 0)))
THEN
773 'compute_stat_proc_metamorph, can only be applied to average->accumulated timerange and viceversa')
776 CALL volgrid6d_alloc_vol(that)
781 CALL
init(that, griddim=this%griddim, time_definition=this%time_definition)
782 CALL volgrid6d_alloc(that, dim=this%griddim%dim, ntime=
SIZE(this%time), &
783 nlevel=
SIZE(this%level), nvar=
SIZE(this%var), ini=.false.)
784 that%time = this%time
785 that%level = this%level
788 CALL compute_stat_proc_metamorph_common(stat_proc_input, this%timerange, stat_proc, &
789 that%timerange, map_tr)
792 CALL volgrid6d_alloc_vol(that, decode=
ASSOCIATED(this%voldati))
794 IF (stat_proc == 0)
THEN
795 int_ratio = 1./
REAL(that%timerange(:)%p2)
797 int_ratio =
REAL(that%timerange(:)%p2)
800 DO i6 = 1,
SIZE(this%var)
801 DO j = 1,
SIZE(map_tr)
802 DO i4 = 1,
SIZE(that%time)
803 DO i3 = 1,
SIZE(this%level)
806 CALL
copy(this%gaid(i3,i4,map_tr(j),i6), that%gaid(i3,i4,j,i6))
808 that%gaid(i3,i4,map_tr(j),i6) = this%gaid(i3,i4,j,i6)
810 CALL volgrid_get_vol_2d(this, i3, i4, map_tr(j), i6, voldatiin)
811 CALL volgrid_get_vol_2d(that, i3, i4, j, i6, voldatiout)
812 WHERE (
c_e(voldatiin))
813 voldatiout = voldatiin*int_ratio(j)
817 CALL volgrid_set_vol_2d(that, i3, i4, j, i6, voldatiout)
824 END SUBROUTINE volgrid6d_compute_stat_proc_metamorph
840 SUBROUTINE volgrid6d_compute_vert_coord_var(this, level, volgrid_lev)
842 type(vol7d_level),
INTENT(in) :: level
843 type(
volgrid6d),
INTENT(out) :: volgrid_lev
845 INTEGER :: nlev, i, ii, iii, iiii
847 LOGICAL,
ALLOCATABLE :: levmask(:)
850 CALL
init(volgrid_lev)
851 IF (.NOT.
ASSOCIATED(this%gaid))
THEN
852 CALL l4f_log(l4f_error,
'volgrid6d_compute_vert_coord_var: input volume not allocated')
856 IF (
c_e(level%level2) .AND. level%level1 /= level%level2)
THEN
857 CALL l4f_log(l4f_error,
'volgrid6d_compute_vert_coord_var: requested (mixed) layer type not valid')
862 ALLOCATE(levmask(
SIZE(this%level)))
863 levmask = this%level%level1 == level%level1 .AND. &
864 this%level%level2 == level%level2 .AND.
c_e(this%level%l1)
865 IF (
c_e(level%level2)) levmask = levmask .AND.
c_e(this%level%l2)
866 nlev = count(levmask)
868 CALL l4f_log(l4f_error,
'volgrid6d_compute_vert_coord_var: requested level type not available')
872 out_gaid = grid_id_new()
873 gaidloop:
DO i=1 ,
SIZE(this%gaid,1)
874 DO ii=1 ,
SIZE(this%gaid,2)
875 DO iii=1 ,
SIZE(this%gaid,3)
876 DO iiii=1 ,
SIZE(this%gaid,4)
877 IF (
c_e(this%gaid(i,ii,iii,iiii)))
THEN
878 CALL
copy(this%gaid(i,ii,iii,iiii), out_gaid)
888 grid_id_template=out_gaid)
889 IF (.NOT.
c_e(lev_var))
THEN
890 CALL l4f_log(l4f_error,
'volgrid6d_compute_vert_coord_var: no variable corresponds to requested level type')
895 CALL
init(volgrid_lev, griddim=this%griddim, &
896 time_definition=this%time_definition)
897 CALL volgrid6d_alloc(volgrid_lev, ntime=
SIZE(this%time), nlevel=nlev, &
898 ntimerange=
SIZE(this%timerange), nvar=1)
900 volgrid_lev%time = this%time
901 volgrid_lev%level = pack(this%level, mask=levmask)
902 volgrid_lev%timerange = this%timerange
903 volgrid_lev%var(1) = lev_var
905 CALL volgrid6d_alloc_vol(volgrid_lev, decode=.true.)
908 IF (
c_e(level%level2))
THEN
909 volgrid_lev%voldati(:,:,i,:,:,:) =
REAL(volgrid_lev%level(i)%l1 + &
910 volgrid_lev%level(i)%l2)* &
913 volgrid_lev%voldati(:,:,i,:,:,:) =
REAL(volgrid_lev%level(i)%l1)* &
918 IF (
c_e(out_gaid))
THEN
919 DO i=1 ,
SIZE(volgrid_lev%gaid,1)
920 DO ii=1 ,
SIZE(volgrid_lev%gaid,2)
921 DO iii=1 ,
SIZE(volgrid_lev%gaid,3)
922 DO iiii=1 ,
SIZE(volgrid_lev%gaid,4)
923 CALL
copy(out_gaid, volgrid_lev%gaid(i,ii,iii,iiii))
931 END SUBROUTINE volgrid6d_compute_vert_coord_var
Classi per la gestione delle coordinate temporali.
Functions that return a trimmed CHARACTER representation of the input variable.
Derived type associated to a block/message/record/band of gridded data coming from a file-like object...
Definition of a physical variable in grib coding style.
This module defines an abstract interface to different drivers for access to files containing gridded...
Object describing a rectangular, homogeneous gridded dataset.
Apply the conversion function this to values.
Return the conversion factor for multiplying the level value when converting to variable.
Convert a level type to a physical variable.
Module for basic statistical computations taking into account missing data.
This module defines objects and methods for managing data volumes on rectangular georeferenced grids...
Distruttori per le 2 classi.
Restituiscono il valore dell'oggetto in forma di stringa stampabile.
Restituiscono il valore dell'oggetto nella forma desiderata.
Costruttori per le classi datetime e timedelta.
Copy an object, creating a fully new instance.
Class for expressing a relative time interval.
Class for managing physical variables in a grib 1/2 fashion.
Clone the object, creating a new independent instance of the object exactly equal to the starting one...
This module contains functions that are only for internal use of the library.
Definisce una variabile meteorologica osservata o un suo attributo.
Extension of volgrid6d_class with methods for performing simple statistical operations on entire volu...
Emit log message for a category with specific priority.
Derived type defining a dynamically extensible array of TYPE(ttr_mapper) elements.