volgrid6d_compute_stat_proc volgrid6d_compute_stat_proc_agg volgrid6d_compute_stat_proc_metamorph volgrid6d_compute_vert_coord_var volgrid6d_recompute_stat_proc_agg volgrid6d_recompute_stat_proc_diff

volgrid6d_recompute_stat_proc_diff() subroutine volgrid6d_class_compute::volgrid6d_recompute_stat_proc_diff ( type(volgrid6d), intent(inout)  this, type(volgrid6d), intent(out)  that, integer, intent(in)  stat_proc, type(timedelta), intent(in)  step, logical, intent(in), optional  full_steps, type(datetime), intent(in), optional  start, logical, intent(in), optional  clone  ) Specialized method for statistically processing a set of data already processed with the same statistical processing, on a different time interval. This method performs statistical processing by difference of different intervals. Data with both analysis/observation or forecast timerange are processed. The output that volgrid6d object contains elements from the original volume this satisfying the conditions timerange (vol7d_timerange_class::vol7d_timerange::timerange) of type stat_proc any p1 (analysis/observation or forecast) p2 > 0 (processing interval non null, non instantaneous data) and equal to a multiplier of step if full_steps is .TRUE. Output data will have timerange of type stat_proc and p2 = step. The supported statistical processing methods (parameter stat_proc) are: 0 average 1 accumulation 4 difference Input volume may have any value of thistime_definition, and that value will be conserved in the output volume. Parametri [in,out] this volume providing data to be recomputed, it is not modified by the method, apart from performing a volgrid6d_alloc_vol on it [out] that output volume which will contain the recomputed data [in] stat_proc type of statistical processing to be recomputed (from grib2 table), only data having timerange of this type will be recomputed and will appear in the output volume [in] step length of the step over which the statistical processing is performed [in] full_steps if provided and .TRUE., process only data having processing interval (p2) equal to a multiple of step [in] start if provided, together with full_steps, processes data on intervals starting at start +- an integer amount of step intervals [in] clone if provided and .TRUE. , clone the gaid's from this to that Definizione alla linea 779 del file volgrid6d_class_compute.F90. ! overwriting fields lclone = optio_log(clone) .OR. .NOT.ASSOCIATED(this%voldati) IF (.NOT.((stat_proc_input == 0 .AND. stat_proc == 1) .OR. & (stat_proc_input == 1 .AND. stat_proc == 0))) THEN CALL l4f_category_log(this%category, l4f_warn, & 'compute_stat_proc_metamorph, can only be applied to average->accumulated timerange and viceversa') ! return an empty volume, without signaling error CALL init(that) CALL volgrid6d_alloc_vol(that) RETURN ENDIF ! initialise the output volume CALL init(that, griddim=this%griddim, time_definition=this%time_definition) CALL volgrid6d_alloc(that, dim=this%griddim%dim, ntime=SIZE(this%time), & nlevel=SIZE(this%level), nvar=SIZE(this%var), ini=.false.) that%time = this%time that%level = this%level that%var = this%var CALL compute_stat_proc_metamorph_common(stat_proc_input, this%timerange, stat_proc, & that%timerange, map_tr) ! complete the definition of the output volume CALL volgrid6d_alloc_vol(that, decode=ASSOCIATED(this%voldati)) IF (stat_proc == 0) THEN ! average -> integral int_ratio = 1./REAL(that%timerange(:)%p2) ELSE ! cumulation int_ratio = REAL(that%timerange(:)%p2) ENDIF DO i6 = 1, SIZE(this%var) DO j = 1, SIZE(map_tr) DO i4 = 1, SIZE(that%time) DO i3 = 1, SIZE(this%level) IF (lclone) THEN CALL copy(this%gaid(i3,i4,map_tr(j),i6), that%gaid(i3,i4,j,i6)) ELSE that%gaid(i3,i4,map_tr(j),i6) = this%gaid(i3,i4,j,i6) ENDIF CALL volgrid_get_vol_2d(this, i3, i4, map_tr(j), i6, voldatiin) CALL volgrid_get_vol_2d(that, i3, i4, j, i6, voldatiout) WHERE (c_e(voldatiin)) voldatiout = voldatiin*int_ratio(j) ELSEWHERE voldatiout = rmiss END WHERE CALL volgrid_set_vol_2d(that, i3, i4, j, i6, voldatiout) ENDDO ENDDO ENDDO ENDDO END SUBROUTINE volgrid6d_compute_stat_proc_metamorph SUBROUTINE volgrid6d_compute_vert_coord_var(this, level, volgrid_lev) TYPE(volgrid6d),INTENT(in) :: this TYPE(vol7d_level),INTENT(in) :: level TYPE(volgrid6d),INTENT(out) :: volgrid_lev INTEGER :: nlev, i, ii, iii, iiii TYPE(grid_id) :: out_gaid LOGICAL,ALLOCATABLE :: levmask(:) TYPE(volgrid6d_var) :: lev_var CALL init(volgrid_lev) ! initialise to null IF (.NOT.ASSOCIATED(this%gaid)) THEN CALL l4f_log(l4f_error, 'volgrid6d_compute_vert_coord_var: input volume not allocated') RETURN ENDIF ! if layer, both surfaces must be of the same type IF (c_e(level%level2) .AND. level%level1 /= level%level2) THEN CALL l4f_log(l4f_error, 'volgrid6d_compute_vert_coord_var: requested (mixed) layer type not valid') RETURN ENDIF ! look for valid levels to be converted to vars ALLOCATE(levmask(SIZE(this%level))) levmask = this%level%level1 == level%level1 .AND. & this%level%level2 == level%level2 .AND. c_e(this%level%l1) IF (c_e(level%level2)) levmask = levmask .AND. c_e(this%level%l2) nlev = count(levmask) IF (nlev == 0) THEN CALL l4f_log(l4f_error, 'volgrid6d_compute_vert_coord_var: requested level type not available') RETURN ENDIF out_gaid = grid_id_new() gaidloop: DO i=1 ,SIZE(this%gaid,1) DO ii=1 ,SIZE(this%gaid,2) DO iii=1 ,SIZE(this%gaid,3) DO iiii=1 ,SIZE(this%gaid,4) IF (c_e(this%gaid(i,ii,iii,iiii))) THEN ! conserve first valid gaid CALL copy(this%gaid(i,ii,iii,iiii), out_gaid) EXIT gaidloop ENDIF ENDDO ENDDO ENDDO ENDDO gaidloop ! look for variable corresponding to level lev_var = convert(vol7d_var_new(btable=vol7d_level_to_var(level)), & grid_id_template=out_gaid) IF (.NOT.c_e(lev_var)) THEN CALL l4f_log(l4f_error, 'volgrid6d_compute_vert_coord_var: no variable corresponds to requested level type') RETURN ENDIF ! prepare output volume CALL init(volgrid_lev, griddim=this%griddim, & time_definition=this%time_definition) !, categoryappend=categoryappend) CALL volgrid6d_alloc(volgrid_lev, ntime=SIZE(this%time), nlevel=nlev, & ntimerange=SIZE(this%timerange), nvar=1) ! fill metadata volgrid_lev%time = this%time volgrid_lev%level = pack(this%level, mask=levmask) volgrid_lev%timerange = this%timerange volgrid_lev%var(1) = lev_var CALL volgrid6d_alloc_vol(volgrid_lev, decode=.true.) ! fill data DO i = 1, nlev IF (c_e(level%level2)) THEN volgrid_lev%voldati(:,:,i,:,:,:) = REAL(volgrid_lev%level(i)%l1 + & volgrid_lev%level(i)%l2)* & vol7d_level_to_var_factor(volgrid_lev%level(i))/2. ELSE volgrid_lev%voldati(:,:,i,:,:,:) = REAL(volgrid_lev%level(i)%l1)* & vol7d_level_to_var_factor(volgrid_lev%level(i)) ENDIF