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 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 .OR. &
133 (stat_proc == 0 .OR. stat_proc == 2 .OR. stat_proc == 3))
THEN 136 IF (count(this%timerange(:)%timerange == stat_proc_input) == 0)
THEN 138 'no timeranges of the desired statistical processing type '//
t2c(stat_proc)//
' available')
141 CALL volgrid6d_alloc_vol(that)
145 dtmax = maxval(this%timerange(:)%p2, &
146 mask=(this%timerange(:)%timerange == stat_proc))
147 CALL getval(step, asec=dtstep)
151 'stat_proc='//
t2c(stat_proc)//
' dtmax='//
t2c(dtmax)//
' dtstep='//
t2c(dtstep))
154 IF (dtstep <= dtmax)
THEN 156 'recomputing statistically processed data by difference '// &
157 t2c(stat_proc_input)//
':'//
t2c(stat_proc))
158 CALL volgrid6d_recompute_stat_proc_diff(this, that, stat_proc, step, &
159 full_steps, start,
clone)
162 'recomputing statistically processed data by aggregation '// &
163 t2c(stat_proc_input)//
':'//
t2c(stat_proc))
164 CALL volgrid6d_recompute_stat_proc_agg(this, that, stat_proc, step, start, &
165 full_steps, frac_valid,
clone, stat_proc_input)
170 IF ((stat_proc_input == 0 .AND. stat_proc == 1) .OR. &
171 (stat_proc_input == 1 .AND. stat_proc == 0))
THEN 173 'computing statistically processed data by integration/differentiation '// &
174 t2c(stat_proc_input)//
':'//
t2c(stat_proc))
175 CALL volgrid6d_compute_stat_proc_metamorph(this, that, stat_proc_input, &
179 'statistical processing '//
t2c(stat_proc_input)//
':'//
t2c(stat_proc)// &
180 ' not implemented or does not make sense')
186 END SUBROUTINE volgrid6d_compute_stat_proc
231 SUBROUTINE volgrid6d_recompute_stat_proc_agg(this, that, stat_proc, &
232 step, start, full_steps, frac_valid, clone, stat_proc_input)
233 TYPE(volgrid6d),
INTENT(inout) :: this
234 TYPE(volgrid6d),
INTENT(out) :: that
235 INTEGER,
INTENT(in) :: stat_proc
236 TYPE(timedelta),
INTENT(in) :: step
237 TYPE(datetime),
INTENT(in),
OPTIONAL :: start
238 LOGICAL,
INTENT(in),
OPTIONAL :: full_steps
239 REAL,
INTENT(in),
OPTIONAL :: frac_valid
240 LOGICAL,
INTENT(in),
OPTIONAL :: clone
241 INTEGER,
INTENT(in),
OPTIONAL :: stat_proc_input
244 INTEGER i, j, n, n1, ndtr, i3, i6
245 TYPE(arrayof_ttr_mapper),
POINTER :: map_ttr(:,:)
246 INTEGER,
POINTER :: dtratio(:)
249 REAL,
POINTER :: voldatiin(:,:), voldatiout(:,:)
252 NULLIFY(voldatiin, voldatiout)
253 IF (
PRESENT(stat_proc_input))
THEN 254 tri = stat_proc_input
258 IF (
PRESENT(frac_valid))
THEN 259 lfrac_valid = frac_valid
266 CALL volgrid6d_alloc_vol(this)
270 lclone = optio_log(
clone) .OR. .NOT.
ASSOCIATED(this%voldati)
272 CALL init(that, griddim=this%griddim, time_definition=this%time_definition)
273 CALL volgrid6d_alloc(that, dim=this%griddim%dim, ntimerange=1, &
274 nlevel=
SIZE(this%level), nvar=
SIZE(this%var), ini=.false.)
275 that%level = this%level
278 CALL recompute_stat_proc_agg_common(this%time, this%timerange, stat_proc, tri, &
279 step, this%time_definition, that%time, that%timerange, map_ttr, &
280 dtratio=dtratio, start=start, full_steps=full_steps)
282 CALL volgrid6d_alloc_vol(that, decode=
ASSOCIATED(this%voldati))
284 do_otimerange:
DO j = 1,
SIZE(that%timerange)
285 do_otime:
DO i = 1,
SIZE(that%time)
287 DO n1 = 1,
SIZE(dtratio)
288 IF (dtratio(n1) <= 0) cycle
290 DO i6 = 1,
SIZE(this%var)
291 DO i3 = 1,
SIZE(this%level)
292 CALL volgrid_get_vol_2d(that, i3, i, j, i6, voldatiout)
294 DO n = 1, map_ttr(i,j)%arraysize
295 IF (map_ttr(i,j)%array(n)%extra_info == dtratio(n1))
THEN 297 CALL volgrid_get_vol_2d(this, i3, map_ttr(i,j)%array(n)%it, &
298 map_ttr(i,j)%array(n)%itr, i6, voldatiin)
301 voldatiout = voldatiin
303 CALL copy(this%gaid(i3, map_ttr(i,j)%array(n)%it,&
304 map_ttr(i,j)%array(n)%itr,i6), that%gaid(i3,i,j,i6))
306 that%gaid(i3,i,j,i6) = this%gaid(i3, map_ttr(i,j)%array(n)%it, &
307 map_ttr(i,j)%array(n)%itr,i6)
311 SELECT CASE(stat_proc)
313 WHERE(
c_e(voldatiin(:,:)) .AND.
c_e(voldatiout(:,:)))
314 voldatiout(:,:) = voldatiout(:,:) + voldatiin(:,:)
316 voldatiout(:,:) = rmiss
319 WHERE(
c_e(voldatiin(:,:)) .AND.
c_e(voldatiout(:,:)))
320 voldatiout(:,:) = max(voldatiout(:,:), voldatiin(:,:))
322 voldatiout(:,:) = rmiss
325 WHERE(
c_e(voldatiin(:,:)) .AND.
c_e(voldatiout(:,:)))
326 voldatiout(:,:) = min(voldatiout(:,:), voldatiin(:,:))
328 voldatiout(:,:) = rmiss
337 CALL l4f_log(l4f_debug, &
338 'compute_stat_proc_agg, ndtr/dtratio/frac_valid: '// &
339 t2c(ndtr)//
'/'//
t2c(dtratio(n1))//
'/'//
t2c(lfrac_valid))
342 IF (
REAL(ndtr)/
REAL(dtratio(n1)) >= lfrac_valid)
THEN 343 IF (stat_proc == 0)
THEN 344 WHERE(
c_e(voldatiout(:,:)))
345 voldatiout(:,:) = voldatiout(:,:)/ndtr
348 CALL volgrid_set_vol_2d(that, i3, i, j, i6, voldatiout)
350 CALL l4f_log(l4f_debug, &
351 'compute_stat_proc_agg, coding lev/t/tr/var: '// &
357 CALL delete(that%gaid(i3,i,j,i6))
359 CALL init(that%gaid(i3,i,j,i6))
362 CALL l4f_log(l4f_debug, &
363 'compute_stat_proc_agg, skipping lev/t/tr/var: '// &
376 DEALLOCATE(dtratio, map_ttr)
378 END SUBROUTINE volgrid6d_recompute_stat_proc_agg
404 SUBROUTINE volgrid6d_compute_stat_proc_agg(this, that, stat_proc, &
405 step, start, full_steps, max_step, clone)
406 TYPE(volgrid6d),
INTENT(inout) :: this
407 TYPE(volgrid6d),
INTENT(out) :: that
408 INTEGER,
INTENT(in) :: stat_proc
409 TYPE(timedelta),
INTENT(in) :: step
410 TYPE(datetime),
INTENT(in),
OPTIONAL :: start
411 LOGICAL,
INTENT(in),
OPTIONAL :: full_steps
412 TYPE(timedelta),
INTENT(in),
OPTIONAL :: max_step
413 LOGICAL ,
INTENT(in),
OPTIONAL :: clone
416 INTEGER i, j, n, ninp, i3, i6
417 TYPE(arrayof_ttr_mapper),
POINTER :: map_ttr(:,:)
418 TYPE(timedelta) :: lmax_step
420 REAL,
POINTER :: voldatiin(:,:), voldatiout(:,:)
423 NULLIFY(voldatiin, voldatiout)
425 IF (
PRESENT(max_step))
THEN 428 lmax_step = timedelta_max
433 CALL volgrid6d_alloc_vol(this)
437 lclone = optio_log(
clone) .OR. .NOT.
ASSOCIATED(this%voldati)
439 CALL init(that, griddim=this%griddim, time_definition=this%time_definition)
440 CALL volgrid6d_alloc(that, dim=this%griddim%dim, ntimerange=1, &
441 nlevel=
SIZE(this%level), nvar=
SIZE(this%var), ini=.false.)
442 that%level = this%level
445 CALL recompute_stat_proc_agg_common(this%time, this%timerange, stat_proc, tri, &
446 step, this%time_definition, that%time, that%timerange, map_ttr, &
447 start=start, full_steps=full_steps)
449 CALL volgrid6d_alloc_vol(that, decode=
ASSOCIATED(this%voldati))
451 do_otimerange:
DO j = 1,
SIZE(that%timerange)
452 do_otime:
DO i = 1,
SIZE(that%time)
453 ninp = map_ttr(i,j)%arraysize
454 IF (ninp <= 0) cycle do_otime
456 IF (stat_proc == 4)
THEN 457 IF (map_ttr(i,j)%array(1)%extra_info /= 1 .OR. &
458 map_ttr(i,j)%array(ninp)%extra_info /= 2)
THEN 465 IF (map_ttr(i,j)%array(n)%time - map_ttr(i,j)%array(n-1)%time > &
473 DO i6 = 1,
SIZE(this%var)
474 DO i3 = 1,
SIZE(this%level)
475 CALL volgrid_get_vol_2d(that, i3, i, j, i6, voldatiout)
477 IF (stat_proc == 4)
THEN 479 CALL copy(this%gaid(i3, map_ttr(i,j)%array(1)%it,&
480 map_ttr(i,j)%array(1)%itr,i6), that%gaid(i3,i,j,i6))
482 that%gaid(i3,i,j,i6) = this%gaid(i3, map_ttr(i,j)%array(1)%it, &
483 map_ttr(i,j)%array(1)%itr,i6)
486 CALL volgrid_get_vol_2d(this, i3, map_ttr(i,j)%array(ninp)%it, &
487 map_ttr(i,j)%array(ninp)%itr, i6, voldatiin)
488 voldatiout = voldatiin
489 CALL volgrid_get_vol_2d(this, i3, map_ttr(i,j)%array(1)%it, &
490 map_ttr(i,j)%array(1)%itr, i6, voldatiin)
492 WHERE(
c_e(voldatiin(:,:)) .AND.
c_e(voldatiout(:,:)))
493 voldatiout(:,:) = voldatiout(:,:) - voldatiin(:,:)
495 voldatiout(:,:) = rmiss
500 CALL volgrid_get_vol_2d(this, i3, map_ttr(i,j)%array(n)%it, &
501 map_ttr(i,j)%array(n)%itr, i6, voldatiin)
504 voldatiout = voldatiin
506 CALL copy(this%gaid(i3, map_ttr(i,j)%array(n)%it,&
507 map_ttr(i,j)%array(n)%itr,i6), that%gaid(i3,i,j,i6))
509 that%gaid(i3,i,j,i6) = this%gaid(i3, map_ttr(i,j)%array(n)%it, &
510 map_ttr(i,j)%array(n)%itr,i6)
514 SELECT CASE(stat_proc)
516 WHERE(
c_e(voldatiin(:,:)) .AND.
c_e(voldatiout(:,:)))
517 voldatiout(:,:) = voldatiout(:,:) + voldatiin(:,:)
519 voldatiout(:,:) = rmiss
522 WHERE(
c_e(voldatiin(:,:)) .AND.
c_e(voldatiout(:,:)))
523 voldatiout(:,:) = max(voldatiout(:,:), voldatiin(:,:))
525 voldatiout(:,:) = rmiss
528 WHERE(
c_e(voldatiin(:,:)) .AND.
c_e(voldatiout(:,:)))
529 voldatiout(:,:) = min(voldatiout(:,:), voldatiin(:,:))
531 voldatiout(:,:) = rmiss
537 IF (stat_proc == 0)
THEN 538 WHERE(
c_e(voldatiout(:,:)))
539 voldatiout(:,:) = voldatiout(:,:)/ninp
543 CALL volgrid_set_vol_2d(that, i3, i, j, i6, voldatiout)
553 END SUBROUTINE volgrid6d_compute_stat_proc_agg
580 SUBROUTINE volgrid6d_recompute_stat_proc_diff(this, that, stat_proc, step, full_steps, start, clone)
581 TYPE(volgrid6d),
INTENT(inout) :: this
582 TYPE(volgrid6d),
INTENT(out) :: that
583 INTEGER,
INTENT(in) :: stat_proc
584 TYPE(timedelta),
INTENT(in) :: step
585 LOGICAL,
INTENT(in),
OPTIONAL :: full_steps
586 TYPE(datetime),
INTENT(in),
OPTIONAL :: start
587 LOGICAL,
INTENT(in),
OPTIONAL :: clone
588 INTEGER :: i3, i4, i6, i, j, k, l, nitr, steps
589 INTEGER,
ALLOCATABLE :: map_tr(:,:,:,:,:), f(:), keep_tr(:,:,:)
590 REAL,
POINTER :: voldatiin1(:,:), voldatiin2(:,:), voldatiout(:,:)
593 TYPE(vol7d_var),
ALLOCATABLE :: varbufr(:)
597 CALL volgrid6d_alloc_vol(this)
600 lclone = optio_log(
clone) .OR. .NOT.
ASSOCIATED(this%voldati)
602 CALL init(that, griddim=this%griddim, time_definition=this%time_definition)
603 CALL volgrid6d_alloc(that, dim=this%griddim%dim, &
604 nlevel=
SIZE(this%level), nvar=
SIZE(this%var), ini=.false.)
605 that%level = this%level
609 CALL getval(step, asec=steps)
613 CALL recompute_stat_proc_diff_common(this%time, this%timerange, stat_proc, step, &
614 that%time, that%timerange, map_tr, f, keep_tr, &
615 this%time_definition, full_steps, start)
619 CALL volgrid6d_alloc_vol(that, decode=
ASSOCIATED(this%voldati))
621 IF (.NOT.
ASSOCIATED(that%voldati))
THEN 622 ALLOCATE(voldatiin1(this%griddim%dim%nx, this%griddim%dim%ny), &
623 voldatiin2(this%griddim%dim%nx, this%griddim%dim%ny), &
624 voldatiout(this%griddim%dim%nx, this%griddim%dim%ny))
628 DO i4 = 1,
SIZE(this%time)
630 IF (
c_e(keep_tr(i, i4, 2)))
THEN 631 l = keep_tr(i, i4, 1)
632 k = keep_tr(i, i4, 2)
635 'volgrid6d_recompute_stat_proc_diff, good timerange: '//
t2c(f(i))// &
638 DO i6 = 1,
SIZE(this%var)
639 DO i3 = 1,
SIZE(this%level)
640 IF (
c_e(this%gaid(i3,i4,f(i),i6)))
THEN 642 CALL copy(this%gaid(i3,i4,f(i),i6), that%gaid(i3,l,k,i6))
644 that%gaid(i3,l,k,i6) = this%gaid(i3,i4,f(i),i6)
646 IF (
ASSOCIATED(that%voldati))
THEN 647 that%voldati(:,:,i3,l,k,i6) = this%voldati(:,:,i3,i4,f(i),i6)
649 CALL volgrid_get_vol_2d(this, i3, i4, f(i), i6, voldatiout)
650 CALL volgrid_set_vol_2d(that, i3, l, k, i6, voldatiout)
660 ALLOCATE(varbufr(
SIZE(this%var)))
661 DO i6 = 1,
SIZE(this%var)
662 varbufr(i6) =
convert(this%var(i6))
665 DO l = 1,
SIZE(this%time)
667 DO j = 1,
SIZE(this%time)
669 IF (
c_e(map_tr(i,j,k,l,1)))
THEN 670 DO i6 = 1,
SIZE(this%var)
671 DO i3 = 1,
SIZE(this%level)
673 IF (
c_e(this%gaid(i3,j,f(i),i6)) .AND. &
674 c_e(this%gaid(i3,l,f(k),i6)))
THEN 678 CALL copy(this%gaid(i3,l,f(k),i6), &
679 that%gaid(i3,map_tr(i,j,k,l,1),map_tr(i,j,k,l,2),i6))
681 that%gaid(i3,map_tr(i,j,k,l,1),map_tr(i,j,k,l,2),i6) = &
682 this%gaid(i3,l,f(k),i6)
686 CALL volgrid_get_vol_2d(this, i3, l, f(k), i6, voldatiin1)
687 CALL volgrid_get_vol_2d(this, i3, j, f(i), i6, voldatiin2)
688 IF (
ASSOCIATED(that%voldati)) &
689 CALL volgrid_get_vol_2d(that, i3, &
690 map_tr(i,j,k,l,1), map_tr(i,j,k,l,2), i6, voldatiout)
692 IF (stat_proc == 0)
THEN 693 WHERE(
c_e(voldatiin1(:,:)) .AND.
c_e(voldatiin2(:,:)))
695 (voldatiin1(:,:)*this%timerange(f(k))%p2 - &
696 voldatiin2(:,:)*this%timerange(f(i))%p2)/ &
699 voldatiout(:,:) = rmiss
701 ELSE IF (stat_proc == 1 .OR. stat_proc == 4)
THEN 702 WHERE(
c_e(voldatiin1(:,:)) .AND.
c_e(voldatiin2(:,:)))
703 voldatiout(:,:) = voldatiin1(:,:) - voldatiin2(:,:)
705 voldatiout(:,:) = rmiss
707 IF (stat_proc == 1)
THEN 708 CALL vol7d_var_features_posdef_apply(varbufr(i6), voldatiout)
712 CALL volgrid_set_vol_2d(that, i3, &
713 map_tr(i,j,k,l,1), map_tr(i,j,k,l,2), i6, voldatiout)
724 IF (.NOT.
ASSOCIATED(that%voldati))
THEN 725 DEALLOCATE(voldatiin1, voldatiin2, voldatiout)
728 END SUBROUTINE volgrid6d_recompute_stat_proc_diff
758 SUBROUTINE volgrid6d_compute_stat_proc_metamorph(this, that, stat_proc_input, stat_proc, clone)
759 TYPE(volgrid6d),
INTENT(inout) :: this
760 TYPE(volgrid6d),
INTENT(out) :: that
761 INTEGER,
INTENT(in) :: stat_proc_input
762 INTEGER,
INTENT(in) :: stat_proc
763 LOGICAL ,
INTENT(in),
OPTIONAL :: clone
765 INTEGER :: j, i3, i4, i6
766 INTEGER,
POINTER :: map_tr(:)
767 REAL,
POINTER :: voldatiin(:,:), voldatiout(:,:)
768 REAL,
ALLOCATABLE :: int_ratio(:)
771 NULLIFY(voldatiin, voldatiout)
774 CALL volgrid6d_alloc_vol(this)
777 lclone = optio_log(
clone) .OR. .NOT.
ASSOCIATED(this%voldati)
779 IF (.NOT.((stat_proc_input == 0 .AND. stat_proc == 1) .OR. &
780 (stat_proc_input == 1 .AND. stat_proc == 0)))
THEN 783 'compute_stat_proc_metamorph, can only be applied to average->accumulated timerange and viceversa')
786 CALL volgrid6d_alloc_vol(that)
791 CALL init(that, griddim=this%griddim, time_definition=this%time_definition)
792 CALL volgrid6d_alloc(that, dim=this%griddim%dim, ntime=
SIZE(this%time), &
793 nlevel=
SIZE(this%level), nvar=
SIZE(this%var), ini=.false.)
794 that%time = this%time
795 that%level = this%level
798 CALL compute_stat_proc_metamorph_common(stat_proc_input, this%timerange, stat_proc, &
799 that%timerange, map_tr)
802 CALL volgrid6d_alloc_vol(that, decode=
ASSOCIATED(this%voldati))
804 IF (stat_proc == 0)
THEN 805 int_ratio = 1./
REAL(that%timerange(:)%p2)
807 int_ratio =
REAL(that%timerange(:)%p2)
810 DO i6 = 1,
SIZE(this%var)
811 DO j = 1,
SIZE(map_tr)
812 DO i4 = 1,
SIZE(that%time)
813 DO i3 = 1,
SIZE(this%level)
816 CALL copy(this%gaid(i3,i4,map_tr(j),i6), that%gaid(i3,i4,j,i6))
818 that%gaid(i3,i4,map_tr(j),i6) = this%gaid(i3,i4,j,i6)
820 CALL volgrid_get_vol_2d(this, i3, i4, map_tr(j), i6, voldatiin)
821 CALL volgrid_get_vol_2d(that, i3, i4, j, i6, voldatiout)
822 WHERE (
c_e(voldatiin))
823 voldatiout = voldatiin*int_ratio(j)
827 CALL volgrid_set_vol_2d(that, i3, i4, j, i6, voldatiout)
834 END SUBROUTINE volgrid6d_compute_stat_proc_metamorph
850 SUBROUTINE volgrid6d_compute_vert_coord_var(this, level, volgrid_lev)
851 TYPE(volgrid6d),
INTENT(in) :: this
852 TYPE(vol7d_level),
INTENT(in) :: level
853 TYPE(volgrid6d),
INTENT(out) :: volgrid_lev
855 INTEGER :: nlev, i, ii, iii, iiii
856 TYPE(grid_id) :: out_gaid
857 LOGICAL,
ALLOCATABLE :: levmask(:)
858 TYPE(volgrid6d_var) :: lev_var
860 CALL init(volgrid_lev)
861 IF (.NOT.
ASSOCIATED(this%gaid))
THEN 862 CALL l4f_log(l4f_error,
'volgrid6d_compute_vert_coord_var: input volume not allocated')
866 IF (
c_e(level%level2) .AND. level%level1 /= level%level2)
THEN 867 CALL l4f_log(l4f_error,
'volgrid6d_compute_vert_coord_var: requested (mixed) layer type not valid')
872 ALLOCATE(levmask(
SIZE(this%level)))
873 levmask = this%level%level1 == level%level1 .AND. &
874 this%level%level2 == level%level2 .AND.
c_e(this%level%l1)
875 IF (
c_e(level%level2)) levmask = levmask .AND.
c_e(this%level%l2)
876 nlev = count(levmask)
878 CALL l4f_log(l4f_error,
'volgrid6d_compute_vert_coord_var: requested level type not available')
882 out_gaid = grid_id_new()
883 gaidloop:
DO i=1 ,
SIZE(this%gaid,1)
884 DO ii=1 ,
SIZE(this%gaid,2)
885 DO iii=1 ,
SIZE(this%gaid,3)
886 DO iiii=1 ,
SIZE(this%gaid,4)
887 IF (
c_e(this%gaid(i,ii,iii,iiii)))
THEN 888 CALL copy(this%gaid(i,ii,iii,iiii), out_gaid)
898 grid_id_template=out_gaid)
899 IF (.NOT.
c_e(lev_var))
THEN 900 CALL l4f_log(l4f_error,
'volgrid6d_compute_vert_coord_var: no variable corresponds to requested level type')
905 CALL init(volgrid_lev, griddim=this%griddim, &
906 time_definition=this%time_definition)
907 CALL volgrid6d_alloc(volgrid_lev, ntime=
SIZE(this%time), nlevel=nlev, &
908 ntimerange=
SIZE(this%timerange), nvar=1)
910 volgrid_lev%time = this%time
911 volgrid_lev%level = pack(this%level, mask=levmask)
912 volgrid_lev%timerange = this%timerange
913 volgrid_lev%var(1) = lev_var
915 CALL volgrid6d_alloc_vol(volgrid_lev, decode=.true.)
918 IF (
c_e(level%level2))
THEN 919 volgrid_lev%voldati(:,:,i,:,:,:) =
REAL(volgrid_lev%level(i)%l1 + &
920 volgrid_lev%level(i)%l2)* &
921 vol7d_level_to_var_factor(volgrid_lev%level(i))/2.
923 volgrid_lev%voldati(:,:,i,:,:,:) =
REAL(volgrid_lev%level(i)%l1)* &
924 vol7d_level_to_var_factor(volgrid_lev%level(i))
928 IF (
c_e(out_gaid))
THEN 929 DO i=1 ,
SIZE(volgrid_lev%gaid,1)
930 DO ii=1 ,
SIZE(volgrid_lev%gaid,2)
931 DO iii=1 ,
SIZE(volgrid_lev%gaid,3)
932 DO iiii=1 ,
SIZE(volgrid_lev%gaid,4)
933 CALL copy(out_gaid, volgrid_lev%gaid(i,ii,iii,iiii))
941 END SUBROUTINE volgrid6d_compute_vert_coord_var
Costruttore per la classe vol7d_level.
Distruttore per la classe vol7d_level.
Functions that return a trimmed CHARACTER representation of the input variable.
Represent level object in a pretty string.
This module contains functions that are only for internal use of the library.
This module defines an abstract interface to different drivers for access to files containing gridded...
Apply the conversion function this to values.
Classi per la gestione delle coordinate temporali.
This module defines objects and methods for managing data volumes on rectangular georeferenced grids...
Convert a level type to a physical variable.
Restituiscono il valore dell'oggetto nella forma desiderata.
Clone the object, creating a new independent instance of the object exactly equal to the starting one...
Module for basic statistical computations taking into account missing data.
Extension of volgrid6d_class with methods for performing simple statistical operations on entire volu...
Class for managing physical variables in a grib 1/2 fashion.
Emit log message for a category with specific priority.