libsim  Versione 7.2.6

◆ volgrid6d_compute_stat_proc()

subroutine volgrid6d_class_compute::volgrid6d_compute_stat_proc ( type(volgrid6d), intent(inout)  this,
type(volgrid6d), intent(out)  that,
integer, intent(in)  stat_proc_input,
integer, intent(in)  stat_proc,
type(timedelta), intent(in)  step,
type(datetime), intent(in), optional  start,
logical, intent(in), optional  full_steps,
real, intent(in), optional  frac_valid,
type(timedelta), intent(in), optional  max_step,
logical, intent(in), optional  weighted,
logical, intent(in), optional  clone 
)

General-purpose method for computing a statistical processing on data in a volgrid6d object already processed with the same statistical processing, on a different time interval specified by step and start.

This method tries to apply all the suitable specialized statistical processing methods according to the input and output statistical processing requested. The argument stat_proc_input determines which data will be processed, while the stat_proc argument determines the type of statistical process to be applied and which will be owned by output data.

The possible combinations are:

  • stat_proc_input = 254

    • stat_proc = 0 average instantaneous observations
    • stat_proc = 2 compute maximum of instantaneous observations
    • stat_proc = 3 compute minimum of instantaneous observations
    • stat_proc = 4 compute difference of instantaneous observations

    processing is computed on longer time intervals by aggregation, see the description of volgrid6d_compute_stat_proc_agg()

  • stat_proc_input = *

    • stat_proc = 254 consider statistically processed values as instantaneous without any extra processing

    see the description of volgrid6d_decompute_stat_proc()

  • stat_proc_input = 0, 1, 2, 3, 4, 200

    • stat_proc = stat_proc_input recompute input data on different intervals

    the same statistical processing is applied to obtain data processed on a different interval, either longer, by aggregation, or shorter, by differences, see the description of volgrid6d_recompute_stat_proc_agg() and volgrid6d_recompute_stat_proc_diff() respectively; it is also possible to provide stat_proc_input /= stat_proc, but it has to be used with care.

  • stat_proc_input = 0

    • stat_proc = 1

    a time-averaged rate or flux is transformed into a time-integrated value (sometimes called accumulated) on the same interval by multiplying the values by the length of the time interval in seconds, keeping constant all the rest, including the variable; the unit of the variable implicitly changes accordingly, this is supported officially in grib2 standard, in the other cases it is a forcing of the standards.

  • stat_proc_input = 1

    • stat_proc = 0

    a time-integrated value (sometimes called accumulated) is transformed into a time-averaged rate or flux on the same interval by dividing the values by the length of the time interval in seconds, see also the previous description of the opposite computation.

If a particular statistical processing cannot be performed on the input data, the program continues with a warning and, if requested, the input data is passed over to the volume specified by the other argument, in order to allow continuation of processing. All the other parameters are passed over to the specifical statistical processing methods and are documented there.

Parametri
[in,out]thisvolume providing data to be recomputed, it is not modified by the method, apart from performing a volgrid6d_alloc_vol on it
[out]thatoutput volume which will contain the recomputed data
[in]stat_proc_inputtype of statistical processing of data that has to be processed (from grib2 table), only data having timerange of this type will be processed, the actual statistical processing performed and which will appear in the output volume, is however determined by stat_proc argument
[in]stat_proctype of statistical processing to be recomputed (from grib2 table), data in output volume that will have a timerange of this type
[in]steplength of the step over which the statistical processing is performed
[in]startstart of statistical processing interval
[in]full_stepsif .TRUE. apply processing only on intervals starting at a forecast time or a reference time modulo step
[in]frac_validminimum fraction of valid data required for considering acceptable a recomputed value, default=1.
[in]weightedif provided and .TRUE., the statistical process is computed, if possible, by weighting every value with a weight proportional to its validity interval
[in]cloneif provided and .TRUE. , clone the gaid's from this to that

Definizione alla linea 300 del file volgrid6d_class_compute.F90.

302  IF (lclone) THEN
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))
305  ELSE
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)
308  ENDIF
309 
310  ELSE ! second or more time
311  SELECT CASE(stat_proc)
312  CASE (0, 200, 1, 4) ! average, vectorial mean, accumulation, difference
313  WHERE(c_e(voldatiin(:,:)) .AND. c_e(voldatiout(:,:)))
314  voldatiout(:,:) = voldatiout(:,:) + voldatiin(:,:)
315  ELSEWHERE
316  voldatiout(:,:) = rmiss
317  END WHERE
318  CASE(2) ! maximum
319  WHERE(c_e(voldatiin(:,:)) .AND. c_e(voldatiout(:,:)))
320  voldatiout(:,:) = max(voldatiout(:,:), voldatiin(:,:))
321  ELSEWHERE
322  voldatiout(:,:) = rmiss
323  END WHERE
324  CASE(3) ! minimum
325  WHERE(c_e(voldatiin(:,:)) .AND. c_e(voldatiout(:,:)))
326  voldatiout(:,:) = min(voldatiout(:,:), voldatiin(:,:))
327  ELSEWHERE
328  voldatiout(:,:) = rmiss
329  END WHERE
330  END SELECT
331 
332  ENDIF ! first time
333  ENDIF ! dtratio(n1)
334  ENDDO ! ttr
335 
336 #ifdef DEBUG
337  CALL l4f_log(l4f_debug, &
338  'compute_stat_proc_agg, ndtr/dtratio/frac_valid: '// &
339  t2c(ndtr)//'/'//t2c(dtratio(n1))//'/'//t2c(lfrac_valid))
340 #endif
341  IF (ndtr > 0) THEN ! why this condition was not here before?
342  IF (real(ndtr)/real(dtratio(n1)) >= lfrac_valid) THEN ! success
343  IF (stat_proc == 0) THEN ! average
344  WHERE(c_e(voldatiout(:,:)))
345  voldatiout(:,:) = voldatiout(:,:)/ndtr
346  END WHERE
347  ENDIF
348  CALL volgrid_set_vol_2d(that, i3, i, j, i6, voldatiout)
349 #ifdef DEBUG
350  CALL l4f_log(l4f_debug, &
351  'compute_stat_proc_agg, coding lev/t/tr/var: '// &
352  t2c(i3)//'/'//t2c(i)//'/'//t2c(j)//'/'//t2c(i6))
353 #endif
354  ELSE
355 ! must nullify the output gaid here, otherwise an incomplete field will be output
356  IF (lclone) THEN
357  CALL delete(that%gaid(i3,i,j,i6))
358  ELSE
359  CALL init(that%gaid(i3,i,j,i6)) ! grid_id lacks a nullify method
360  ENDIF
361 #ifdef DEBUG
362  CALL l4f_log(l4f_debug, &
363  'compute_stat_proc_agg, skipping lev/t/tr/var: '// &
364  t2c(i3)//'/'//t2c(i)//'/'//t2c(j)//'/'//t2c(i6))
365 #endif
366  ENDIF
367  ENDIF ! ndtr > 0
368 
369  ENDDO ! level
370  ENDDO ! var
371  ENDDO ! dtratio
372  CALL delete(map_ttr(i,j))
373  ENDDO do_otime
374 ENDDO do_otimerange
375 
376 DEALLOCATE(dtratio, map_ttr)
377 
378 END SUBROUTINE volgrid6d_recompute_stat_proc_agg
379 
380 

Generated with Doxygen.