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_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 768 del file volgrid6d_class_compute.F90. INTEGER,POINTER :: map_tr(:) REAL,POINTER :: voldatiin(:,:), voldatiout(:,:) REAL,ALLOCATABLE :: int_ratio(:) LOGICAL :: lclone NULLIFY(voldatiin, voldatiout) ! be safe CALL volgrid6d_alloc_vol(this) ! when volume is not decoded it is better to clone anyway to avoid ! 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 !> Method for building a volume containing the vertical coordinate as !! a variable. !! This method produces a volgrid6d volume, derived from \a this, !! containing a single variable, horizontally constant, on the same !! input levels, which describes the vertical coordinate in the form !! of a physical variable. The grid, time and timerange metadata are !! the same as for the original volume. Only a single vertical level !! type, the one matching the \a level argument, is converted to a !! variable. The \a level argument can also indicate the layer between !! two surfaces of the same type, in that case the variable !! representing the vertical coordinate will be set to the value of !! the midpoint between the two layers. If something goes wrong, !! e.g. no level matches \a level argument or the level canot be !! converted to a physical value, an empty volume is returned. SUBROUTINE volgrid6d_compute_vert_coord_var(this, level, volgrid_lev) TYPE(volgrid6d),INTENT(in) :: this !< volume with the vertical levels TYPE(vol7d_level),INTENT(in) :: level !< vertical level to be converted to variable, only the type(s) of level are used not the value(s) TYPE(volgrid6d),INTENT(out) :: volgrid_lev !< output volume with the variable describing the vertical coordinate 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.)