102 SUBROUTINE volgrid6d_compute_stat_proc(this, that, stat_proc_input, stat_proc, &
103 step, start, full_steps, frac_valid, max_step, weighted, clone)
104 TYPE(volgrid6d),
INTENT(inout) :: this
105 TYPE(volgrid6d),
INTENT(out) :: that
106 INTEGER,
INTENT(in) :: stat_proc_input
107 INTEGER,
INTENT(in) :: stat_proc
108 TYPE(timedelta),
INTENT(in) :: step
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
120 CALL l4f_category_log(this%category, l4f_info, &
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
128 CALL l4f_category_log(this%category, l4f_error, &
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
135 CALL l4f_category_log(this%category, l4f_info, &
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, &
141 CALL l4f_category_log(this%category, l4f_error, &
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
148 CALL l4f_category_log(this%category, l4f_warn, &
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)
161 CALL l4f_category_log(this%category, l4f_debug, &
162 'stat_proc='//
t2c(stat_proc)//
' dtmax='//
t2c(dtmax)//
' dtstep='//
t2c(dtstep))
165 IF (dtstep < dtmax)
THEN
166 CALL l4f_category_log(this%category, l4f_info, &
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)
172 CALL l4f_category_log(this%category, l4f_info, &
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)
228 TYPE(volgrid6d),
INTENT(inout) :: this
229 TYPE(volgrid6d),
INTENT(out) :: that
230 INTEGER,
INTENT(in) :: stat_proc
231 TYPE(timedelta),
INTENT(in) :: step
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
239 TYPE(arrayof_ttr_mapper),
POINTER :: map_ttr(:,:)
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)
624 CALL l4f_category_log(this%category, l4f_debug, &
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
772 CALL l4f_category_log(this%category, l4f_warn, &
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)
887 lev_var =
convert(vol7d_var_new(btable=vol7d_level_to_var(level)), &
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)* &
911 vol7d_level_to_var_factor(volgrid_lev%level(i))/2.
913 volgrid_lev%voldati(:,:,i,:,:,:) = real(volgrid_lev%level(i)%l1)* &
914 vol7d_level_to_var_factor(volgrid_lev%level(i))
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
Distruttori per le 2 classi.
Restituiscono il valore dell'oggetto nella forma desiderata.
Costruttori per le classi datetime e timedelta.
Functions that return a trimmed CHARACTER representation of the input variable.
Restituiscono il valore dell'oggetto in forma di stringa stampabile.
Make a deep copy, if possible, of the grid identifier.
Apply the conversion function this to values.
Classi per la gestione delle coordinate temporali.
This module defines an abstract interface to different drivers for access to files containing gridded...
Module for basic statistical computations taking into account missing data.
This module contains functions that are only for internal use of the library.
Extension of volgrid6d_class with methods for performing simple statistical operations on entire volu...
This module defines objects and methods for managing data volumes on rectangular georeferenced grids.
Class for managing physical variables in a grib 1/2 fashion.
Class for expressing an absolute time value.
Class for expressing a relative time interval.
Derived type associated to a block/message/record/band of gridded data coming from a file-like object...
Derived type defining a dynamically extensible array of TYPE(ttr_mapper) elements.
Object describing a rectangular, homogeneous gridded dataset.
Definition of a physical variable in grib coding style.