gtool5 Fortran 90/95 Library 1.0.0-rc5
日本語
Loading...
Searching...
No Matches
Public Member Functions | List of all members
gtool_historyauto_internal::averagereduce Interface Reference

Public Member Functions

subroutine averagereducereal1 (array, space_average, weight1, array_avr)
 
subroutine averagereducereal2 (array, space_average, weight1, weight2, array_avr)
 
subroutine averagereducereal3 (array, space_average, weight1, weight2, weight3, array_avr)
 
subroutine averagereducereal4 (array, space_average, weight1, weight2, weight3, weight4, array_avr)
 
subroutine averagereducereal5 (array, space_average, weight1, weight2, weight3, weight4, weight5, array_avr)
 
subroutine averagereducereal6 (array, space_average, weight1, weight2, weight3, weight4, weight5, weight6, array_avr)
 
subroutine averagereducereal7 (array, space_average, weight1, weight2, weight3, weight4, weight5, weight6, weight7, array_avr)
 
subroutine averagereducedouble1 (array, space_average, weight1, array_avr)
 
subroutine averagereducedouble2 (array, space_average, weight1, weight2, array_avr)
 
subroutine averagereducedouble3 (array, space_average, weight1, weight2, weight3, array_avr)
 
subroutine averagereducedouble4 (array, space_average, weight1, weight2, weight3, weight4, array_avr)
 
subroutine averagereducedouble5 (array, space_average, weight1, weight2, weight3, weight4, weight5, array_avr)
 
subroutine averagereducedouble6 (array, space_average, weight1, weight2, weight3, weight4, weight5, weight6, array_avr)
 
subroutine averagereducedouble7 (array, space_average, weight1, weight2, weight3, weight4, weight5, weight6, weight7, array_avr)
 
subroutine averagereduceint1 (array, space_average, weight1, array_avr)
 
subroutine averagereduceint2 (array, space_average, weight1, weight2, array_avr)
 
subroutine averagereduceint3 (array, space_average, weight1, weight2, weight3, array_avr)
 
subroutine averagereduceint4 (array, space_average, weight1, weight2, weight3, weight4, array_avr)
 
subroutine averagereduceint5 (array, space_average, weight1, weight2, weight3, weight4, weight5, array_avr)
 
subroutine averagereduceint6 (array, space_average, weight1, weight2, weight3, weight4, weight5, weight6, array_avr)
 
subroutine averagereduceint7 (array, space_average, weight1, weight2, weight3, weight4, weight5, weight6, weight7, array_avr)
 

Detailed Description

Definition at line 344 of file gtool_historyauto_internal.f90.

Member Function/Subroutine Documentation

◆ averagereducedouble1()

subroutine gtool_historyauto_internal::averagereduce::averagereducedouble1 ( real(dp), dimension(:), intent(in), target  array,
logical, dimension(1), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 2629 of file gtool_historyauto_internal.f90.

2635 implicit none
2636 real(DP), intent(in), target:: array(:)
2637 logical, intent(in):: space_average(1)
2638 real(DP), intent(in):: weight1(:)
2639
2640 real(DP), pointer:: array_avr(:) ! (out)
2641
2642 real(DP), pointer:: array_avr_work(:)
2643
2644 real(DP), pointer:: array_avr_work1(:)
2645
2646
2647 integer:: array_shape(1)
2648 integer:: i, dim_size
2649 real(DP):: weight_sum
2650 continue
2651
2652 array_shape = shape( array )
2653 array_avr_work => array
2654
2655
2656
2657
2658 if ( space_average(1) ) then
2659 dim_size = array_shape(1)
2660 array_shape(1) = 1
2661 allocate( array_avr_work1( array_shape(1) &
2662
2663 & ) )
2664 array_avr_work1 = 0.0_dp
2665 weight_sum = 0.0_dp
2666 do i = 1, dim_size
2667 array_avr_work1(1) = array_avr_work1(1) + array_avr_work(i) * weight1(i)
2668 weight_sum = weight_sum + weight1(i)
2669 end do
2670 array_avr_work1 = array_avr_work1 / weight_sum
2671 array_avr_work => array_avr_work1
2672 end if
2673
2674
2675
2676
2677
2678
2679
2680 allocate( array_avr( array_shape(1) &
2681
2682 & ) )
2683
2684 array_avr = array_avr_work
2685
2686 nullify( array_avr_work )
2687
2688 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
2689
2690

◆ averagereducedouble2()

subroutine gtool_historyauto_internal::averagereduce::averagereducedouble2 ( real(dp), dimension(:,:), intent(in), target  array,
logical, dimension(2), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
real(dp), dimension(:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 2722 of file gtool_historyauto_internal.f90.

2730 implicit none
2731 real(DP), intent(in), target:: array(:,:)
2732 logical, intent(in):: space_average(2)
2733 real(DP), intent(in):: weight1(:)
2734
2735 real(DP), intent(in):: weight2(:)
2736
2737 real(DP), pointer:: array_avr(:,:) ! (out)
2738
2739 real(DP), pointer:: array_avr_work(:,:)
2740
2741 real(DP), pointer:: array_avr_work1(:,:)
2742
2743 real(DP), pointer:: array_avr_work2(:,:)
2744
2745
2746 integer:: array_shape(2)
2747 integer:: i, dim_size
2748 real(DP):: weight_sum
2749 continue
2750
2751 array_shape = shape( array )
2752 array_avr_work => array
2753
2754
2755
2756
2757 if ( space_average(1) ) then
2758 dim_size = array_shape(1)
2759 array_shape(1) = 1
2760 allocate( array_avr_work1( array_shape(1) &
2761 & , array_shape(2) &
2762
2763 & ) )
2764 array_avr_work1 = 0.0_dp
2765 weight_sum = 0.0_dp
2766 do i = 1, dim_size
2767 array_avr_work1(1,:) = array_avr_work1(1,:) + array_avr_work(i,:) * weight1(i)
2768 weight_sum = weight_sum + weight1(i)
2769 end do
2770 array_avr_work1 = array_avr_work1 / weight_sum
2771 array_avr_work => array_avr_work1
2772 end if
2773
2774
2775
2776 if ( space_average(2) ) then
2777 dim_size = array_shape(2)
2778 array_shape(2) = 1
2779 allocate( array_avr_work2( array_shape(1) &
2780 & , array_shape(2) &
2781
2782 & ) )
2783 array_avr_work2 = 0.0_dp
2784 weight_sum = 0.0_dp
2785 do i = 1, dim_size
2786 array_avr_work2(:,1) = array_avr_work2(:,1) + array_avr_work(:,i) * weight2(i)
2787 weight_sum = weight_sum + weight2(i)
2788 end do
2789 array_avr_work2 = array_avr_work2 / weight_sum
2790 array_avr_work => array_avr_work2
2791 end if
2792
2793
2794
2795
2796
2797
2798
2799 allocate( array_avr( array_shape(1) &
2800 & , array_shape(2) &
2801
2802 & ) )
2803
2804 array_avr = array_avr_work
2805
2806 nullify( array_avr_work )
2807
2808 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
2809
2810 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
2811
2812

◆ averagereducedouble3()

subroutine gtool_historyauto_internal::averagereduce::averagereducedouble3 ( real(dp), dimension(:,:,:), intent(in), target  array,
logical, dimension(3), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
real(dp), dimension(:), intent(in)  weight3,
real(dp), dimension(:,:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 2844 of file gtool_historyauto_internal.f90.

2854 implicit none
2855 real(DP), intent(in), target:: array(:,:,:)
2856 logical, intent(in):: space_average(3)
2857 real(DP), intent(in):: weight1(:)
2858
2859 real(DP), intent(in):: weight2(:)
2860
2861 real(DP), intent(in):: weight3(:)
2862
2863 real(DP), pointer:: array_avr(:,:,:) ! (out)
2864
2865 real(DP), pointer:: array_avr_work(:,:,:)
2866
2867 real(DP), pointer:: array_avr_work1(:,:,:)
2868
2869 real(DP), pointer:: array_avr_work2(:,:,:)
2870
2871 real(DP), pointer:: array_avr_work3(:,:,:)
2872
2873
2874 integer:: array_shape(3)
2875 integer:: i, dim_size
2876 real(DP):: weight_sum
2877 continue
2878
2879 array_shape = shape( array )
2880 array_avr_work => array
2881
2882
2883
2884
2885 if ( space_average(1) ) then
2886 dim_size = array_shape(1)
2887 array_shape(1) = 1
2888 allocate( array_avr_work1( array_shape(1) &
2889 & , array_shape(2) &
2890
2891 & , array_shape(3) &
2892
2893 & ) )
2894 array_avr_work1 = 0.0_dp
2895 weight_sum = 0.0_dp
2896 do i = 1, dim_size
2897 array_avr_work1(1,:,:) = array_avr_work1(1,:,:) + array_avr_work(i,:,:) * weight1(i)
2898 weight_sum = weight_sum + weight1(i)
2899 end do
2900 array_avr_work1 = array_avr_work1 / weight_sum
2901 array_avr_work => array_avr_work1
2902 end if
2903
2904
2905
2906 if ( space_average(2) ) then
2907 dim_size = array_shape(2)
2908 array_shape(2) = 1
2909 allocate( array_avr_work2( array_shape(1) &
2910 & , array_shape(2) &
2911
2912 & , array_shape(3) &
2913
2914 & ) )
2915 array_avr_work2 = 0.0_dp
2916 weight_sum = 0.0_dp
2917 do i = 1, dim_size
2918 array_avr_work2(:,1,:) = array_avr_work2(:,1,:) + array_avr_work(:,i,:) * weight2(i)
2919 weight_sum = weight_sum + weight2(i)
2920 end do
2921 array_avr_work2 = array_avr_work2 / weight_sum
2922 array_avr_work => array_avr_work2
2923 end if
2924
2925
2926
2927 if ( space_average(3) ) then
2928 dim_size = array_shape(3)
2929 array_shape(3) = 1
2930 allocate( array_avr_work3( array_shape(1) &
2931 & , array_shape(2) &
2932
2933 & , array_shape(3) &
2934
2935 & ) )
2936 array_avr_work3 = 0.0_dp
2937 weight_sum = 0.0_dp
2938 do i = 1, dim_size
2939 array_avr_work3(:,:,1) = array_avr_work3(:,:,1) + array_avr_work(:,:,i) * weight3(i)
2940 weight_sum = weight_sum + weight3(i)
2941 end do
2942 array_avr_work3 = array_avr_work3 / weight_sum
2943 array_avr_work => array_avr_work3
2944 end if
2945
2946
2947
2948
2949
2950
2951
2952 allocate( array_avr( array_shape(1) &
2953 & , array_shape(2) &
2954
2955 & , array_shape(3) &
2956
2957 & ) )
2958
2959 array_avr = array_avr_work
2960
2961 nullify( array_avr_work )
2962
2963 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
2964
2965 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
2966
2967 if ( associated( array_avr_work3 ) ) deallocate( array_avr_work3 )
2968
2969

◆ averagereducedouble4()

subroutine gtool_historyauto_internal::averagereduce::averagereducedouble4 ( real(dp), dimension(:,:,:,:), intent(in), target  array,
logical, dimension(4), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
real(dp), dimension(:), intent(in)  weight3,
real(dp), dimension(:), intent(in)  weight4,
real(dp), dimension(:,:,:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 3001 of file gtool_historyauto_internal.f90.

3013 implicit none
3014 real(DP), intent(in), target:: array(:,:,:,:)
3015 logical, intent(in):: space_average(4)
3016 real(DP), intent(in):: weight1(:)
3017
3018 real(DP), intent(in):: weight2(:)
3019
3020 real(DP), intent(in):: weight3(:)
3021
3022 real(DP), intent(in):: weight4(:)
3023
3024 real(DP), pointer:: array_avr(:,:,:,:) ! (out)
3025
3026 real(DP), pointer:: array_avr_work(:,:,:,:)
3027
3028 real(DP), pointer:: array_avr_work1(:,:,:,:)
3029
3030 real(DP), pointer:: array_avr_work2(:,:,:,:)
3031
3032 real(DP), pointer:: array_avr_work3(:,:,:,:)
3033
3034 real(DP), pointer:: array_avr_work4(:,:,:,:)
3035
3036
3037 integer:: array_shape(4)
3038 integer:: i, dim_size
3039 real(DP):: weight_sum
3040 continue
3041
3042 array_shape = shape( array )
3043 array_avr_work => array
3044
3045
3046
3047
3048 if ( space_average(1) ) then
3049 dim_size = array_shape(1)
3050 array_shape(1) = 1
3051 allocate( array_avr_work1( array_shape(1) &
3052 & , array_shape(2) &
3053
3054 & , array_shape(3) &
3055
3056 & , array_shape(4) &
3057
3058 & ) )
3059 array_avr_work1 = 0.0_dp
3060 weight_sum = 0.0_dp
3061 do i = 1, dim_size
3062 array_avr_work1(1,:,:,:) = array_avr_work1(1,:,:,:) + array_avr_work(i,:,:,:) * weight1(i)
3063 weight_sum = weight_sum + weight1(i)
3064 end do
3065 array_avr_work1 = array_avr_work1 / weight_sum
3066 array_avr_work => array_avr_work1
3067 end if
3068
3069
3070
3071 if ( space_average(2) ) then
3072 dim_size = array_shape(2)
3073 array_shape(2) = 1
3074 allocate( array_avr_work2( array_shape(1) &
3075 & , array_shape(2) &
3076
3077 & , array_shape(3) &
3078
3079 & , array_shape(4) &
3080
3081 & ) )
3082 array_avr_work2 = 0.0_dp
3083 weight_sum = 0.0_dp
3084 do i = 1, dim_size
3085 array_avr_work2(:,1,:,:) = array_avr_work2(:,1,:,:) + array_avr_work(:,i,:,:) * weight2(i)
3086 weight_sum = weight_sum + weight2(i)
3087 end do
3088 array_avr_work2 = array_avr_work2 / weight_sum
3089 array_avr_work => array_avr_work2
3090 end if
3091
3092
3093
3094 if ( space_average(3) ) then
3095 dim_size = array_shape(3)
3096 array_shape(3) = 1
3097 allocate( array_avr_work3( array_shape(1) &
3098 & , array_shape(2) &
3099
3100 & , array_shape(3) &
3101
3102 & , array_shape(4) &
3103
3104 & ) )
3105 array_avr_work3 = 0.0_dp
3106 weight_sum = 0.0_dp
3107 do i = 1, dim_size
3108 array_avr_work3(:,:,1,:) = array_avr_work3(:,:,1,:) + array_avr_work(:,:,i,:) * weight3(i)
3109 weight_sum = weight_sum + weight3(i)
3110 end do
3111 array_avr_work3 = array_avr_work3 / weight_sum
3112 array_avr_work => array_avr_work3
3113 end if
3114
3115
3116
3117 if ( space_average(4) ) then
3118 dim_size = array_shape(4)
3119 array_shape(4) = 1
3120 allocate( array_avr_work4( array_shape(1) &
3121 & , array_shape(2) &
3122
3123 & , array_shape(3) &
3124
3125 & , array_shape(4) &
3126
3127 & ) )
3128 array_avr_work4 = 0.0_dp
3129 weight_sum = 0.0_dp
3130 do i = 1, dim_size
3131 array_avr_work4(:,:,:,1) = array_avr_work4(:,:,:,1) + array_avr_work(:,:,:,i) * weight4(i)
3132 weight_sum = weight_sum + weight4(i)
3133 end do
3134 array_avr_work4 = array_avr_work4 / weight_sum
3135 array_avr_work => array_avr_work4
3136 end if
3137
3138
3139
3140
3141
3142
3143
3144 allocate( array_avr( array_shape(1) &
3145 & , array_shape(2) &
3146
3147 & , array_shape(3) &
3148
3149 & , array_shape(4) &
3150
3151 & ) )
3152
3153 array_avr = array_avr_work
3154
3155 nullify( array_avr_work )
3156
3157 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
3158
3159 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
3160
3161 if ( associated( array_avr_work3 ) ) deallocate( array_avr_work3 )
3162
3163 if ( associated( array_avr_work4 ) ) deallocate( array_avr_work4 )
3164
3165

◆ averagereducedouble5()

subroutine gtool_historyauto_internal::averagereduce::averagereducedouble5 ( real(dp), dimension(:,:,:,:,:), intent(in), target  array,
logical, dimension(5), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
real(dp), dimension(:), intent(in)  weight3,
real(dp), dimension(:), intent(in)  weight4,
real(dp), dimension(:), intent(in)  weight5,
real(dp), dimension(:,:,:,:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 3197 of file gtool_historyauto_internal.f90.

3211 implicit none
3212 real(DP), intent(in), target:: array(:,:,:,:,:)
3213 logical, intent(in):: space_average(5)
3214 real(DP), intent(in):: weight1(:)
3215
3216 real(DP), intent(in):: weight2(:)
3217
3218 real(DP), intent(in):: weight3(:)
3219
3220 real(DP), intent(in):: weight4(:)
3221
3222 real(DP), intent(in):: weight5(:)
3223
3224 real(DP), pointer:: array_avr(:,:,:,:,:) ! (out)
3225
3226 real(DP), pointer:: array_avr_work(:,:,:,:,:)
3227
3228 real(DP), pointer:: array_avr_work1(:,:,:,:,:)
3229
3230 real(DP), pointer:: array_avr_work2(:,:,:,:,:)
3231
3232 real(DP), pointer:: array_avr_work3(:,:,:,:,:)
3233
3234 real(DP), pointer:: array_avr_work4(:,:,:,:,:)
3235
3236 real(DP), pointer:: array_avr_work5(:,:,:,:,:)
3237
3238
3239 integer:: array_shape(5)
3240 integer:: i, dim_size
3241 real(DP):: weight_sum
3242 continue
3243
3244 array_shape = shape( array )
3245 array_avr_work => array
3246
3247
3248
3249
3250 if ( space_average(1) ) then
3251 dim_size = array_shape(1)
3252 array_shape(1) = 1
3253 allocate( array_avr_work1( array_shape(1) &
3254 & , array_shape(2) &
3255
3256 & , array_shape(3) &
3257
3258 & , array_shape(4) &
3259
3260 & , array_shape(5) &
3261
3262 & ) )
3263 array_avr_work1 = 0.0_dp
3264 weight_sum = 0.0_dp
3265 do i = 1, dim_size
3266 array_avr_work1(1,:,:,:,:) = array_avr_work1(1,:,:,:,:) + array_avr_work(i,:,:,:,:) * weight1(i)
3267 weight_sum = weight_sum + weight1(i)
3268 end do
3269 array_avr_work1 = array_avr_work1 / weight_sum
3270 array_avr_work => array_avr_work1
3271 end if
3272
3273
3274
3275 if ( space_average(2) ) then
3276 dim_size = array_shape(2)
3277 array_shape(2) = 1
3278 allocate( array_avr_work2( array_shape(1) &
3279 & , array_shape(2) &
3280
3281 & , array_shape(3) &
3282
3283 & , array_shape(4) &
3284
3285 & , array_shape(5) &
3286
3287 & ) )
3288 array_avr_work2 = 0.0_dp
3289 weight_sum = 0.0_dp
3290 do i = 1, dim_size
3291 array_avr_work2(:,1,:,:,:) = array_avr_work2(:,1,:,:,:) + array_avr_work(:,i,:,:,:) * weight2(i)
3292 weight_sum = weight_sum + weight2(i)
3293 end do
3294 array_avr_work2 = array_avr_work2 / weight_sum
3295 array_avr_work => array_avr_work2
3296 end if
3297
3298
3299
3300 if ( space_average(3) ) then
3301 dim_size = array_shape(3)
3302 array_shape(3) = 1
3303 allocate( array_avr_work3( array_shape(1) &
3304 & , array_shape(2) &
3305
3306 & , array_shape(3) &
3307
3308 & , array_shape(4) &
3309
3310 & , array_shape(5) &
3311
3312 & ) )
3313 array_avr_work3 = 0.0_dp
3314 weight_sum = 0.0_dp
3315 do i = 1, dim_size
3316 array_avr_work3(:,:,1,:,:) = array_avr_work3(:,:,1,:,:) + array_avr_work(:,:,i,:,:) * weight3(i)
3317 weight_sum = weight_sum + weight3(i)
3318 end do
3319 array_avr_work3 = array_avr_work3 / weight_sum
3320 array_avr_work => array_avr_work3
3321 end if
3322
3323
3324
3325 if ( space_average(4) ) then
3326 dim_size = array_shape(4)
3327 array_shape(4) = 1
3328 allocate( array_avr_work4( array_shape(1) &
3329 & , array_shape(2) &
3330
3331 & , array_shape(3) &
3332
3333 & , array_shape(4) &
3334
3335 & , array_shape(5) &
3336
3337 & ) )
3338 array_avr_work4 = 0.0_dp
3339 weight_sum = 0.0_dp
3340 do i = 1, dim_size
3341 array_avr_work4(:,:,:,1,:) = array_avr_work4(:,:,:,1,:) + array_avr_work(:,:,:,i,:) * weight4(i)
3342 weight_sum = weight_sum + weight4(i)
3343 end do
3344 array_avr_work4 = array_avr_work4 / weight_sum
3345 array_avr_work => array_avr_work4
3346 end if
3347
3348
3349
3350 if ( space_average(5) ) then
3351 dim_size = array_shape(5)
3352 array_shape(5) = 1
3353 allocate( array_avr_work5( array_shape(1) &
3354 & , array_shape(2) &
3355
3356 & , array_shape(3) &
3357
3358 & , array_shape(4) &
3359
3360 & , array_shape(5) &
3361
3362 & ) )
3363 array_avr_work5 = 0.0_dp
3364 weight_sum = 0.0_dp
3365 do i = 1, dim_size
3366 array_avr_work5(:,:,:,:,1) = array_avr_work5(:,:,:,:,1) + array_avr_work(:,:,:,:,i) * weight5(i)
3367 weight_sum = weight_sum + weight5(i)
3368 end do
3369 array_avr_work5 = array_avr_work5 / weight_sum
3370 array_avr_work => array_avr_work5
3371 end if
3372
3373
3374
3375
3376
3377
3378
3379 allocate( array_avr( array_shape(1) &
3380 & , array_shape(2) &
3381
3382 & , array_shape(3) &
3383
3384 & , array_shape(4) &
3385
3386 & , array_shape(5) &
3387
3388 & ) )
3389
3390 array_avr = array_avr_work
3391
3392 nullify( array_avr_work )
3393
3394 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
3395
3396 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
3397
3398 if ( associated( array_avr_work3 ) ) deallocate( array_avr_work3 )
3399
3400 if ( associated( array_avr_work4 ) ) deallocate( array_avr_work4 )
3401
3402 if ( associated( array_avr_work5 ) ) deallocate( array_avr_work5 )
3403
3404

◆ averagereducedouble6()

subroutine gtool_historyauto_internal::averagereduce::averagereducedouble6 ( real(dp), dimension(:,:,:,:,:,:), intent(in), target  array,
logical, dimension(6), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
real(dp), dimension(:), intent(in)  weight3,
real(dp), dimension(:), intent(in)  weight4,
real(dp), dimension(:), intent(in)  weight5,
real(dp), dimension(:), intent(in)  weight6,
real(dp), dimension(:,:,:,:,:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 3436 of file gtool_historyauto_internal.f90.

3452 implicit none
3453 real(DP), intent(in), target:: array(:,:,:,:,:,:)
3454 logical, intent(in):: space_average(6)
3455 real(DP), intent(in):: weight1(:)
3456
3457 real(DP), intent(in):: weight2(:)
3458
3459 real(DP), intent(in):: weight3(:)
3460
3461 real(DP), intent(in):: weight4(:)
3462
3463 real(DP), intent(in):: weight5(:)
3464
3465 real(DP), intent(in):: weight6(:)
3466
3467 real(DP), pointer:: array_avr(:,:,:,:,:,:) ! (out)
3468
3469 real(DP), pointer:: array_avr_work(:,:,:,:,:,:)
3470
3471 real(DP), pointer:: array_avr_work1(:,:,:,:,:,:)
3472
3473 real(DP), pointer:: array_avr_work2(:,:,:,:,:,:)
3474
3475 real(DP), pointer:: array_avr_work3(:,:,:,:,:,:)
3476
3477 real(DP), pointer:: array_avr_work4(:,:,:,:,:,:)
3478
3479 real(DP), pointer:: array_avr_work5(:,:,:,:,:,:)
3480
3481 real(DP), pointer:: array_avr_work6(:,:,:,:,:,:)
3482
3483
3484 integer:: array_shape(6)
3485 integer:: i, dim_size
3486 real(DP):: weight_sum
3487 continue
3488
3489 array_shape = shape( array )
3490 array_avr_work => array
3491
3492
3493
3494
3495 if ( space_average(1) ) then
3496 dim_size = array_shape(1)
3497 array_shape(1) = 1
3498 allocate( array_avr_work1( array_shape(1) &
3499 & , array_shape(2) &
3500
3501 & , array_shape(3) &
3502
3503 & , array_shape(4) &
3504
3505 & , array_shape(5) &
3506
3507 & , array_shape(6) &
3508
3509 & ) )
3510 array_avr_work1 = 0.0_dp
3511 weight_sum = 0.0_dp
3512 do i = 1, dim_size
3513 array_avr_work1(1,:,:,:,:,:) = array_avr_work1(1,:,:,:,:,:) + array_avr_work(i,:,:,:,:,:) * weight1(i)
3514 weight_sum = weight_sum + weight1(i)
3515 end do
3516 array_avr_work1 = array_avr_work1 / weight_sum
3517 array_avr_work => array_avr_work1
3518 end if
3519
3520
3521
3522 if ( space_average(2) ) then
3523 dim_size = array_shape(2)
3524 array_shape(2) = 1
3525 allocate( array_avr_work2( array_shape(1) &
3526 & , array_shape(2) &
3527
3528 & , array_shape(3) &
3529
3530 & , array_shape(4) &
3531
3532 & , array_shape(5) &
3533
3534 & , array_shape(6) &
3535
3536 & ) )
3537 array_avr_work2 = 0.0_dp
3538 weight_sum = 0.0_dp
3539 do i = 1, dim_size
3540 array_avr_work2(:,1,:,:,:,:) = array_avr_work2(:,1,:,:,:,:) + array_avr_work(:,i,:,:,:,:) * weight2(i)
3541 weight_sum = weight_sum + weight2(i)
3542 end do
3543 array_avr_work2 = array_avr_work2 / weight_sum
3544 array_avr_work => array_avr_work2
3545 end if
3546
3547
3548
3549 if ( space_average(3) ) then
3550 dim_size = array_shape(3)
3551 array_shape(3) = 1
3552 allocate( array_avr_work3( array_shape(1) &
3553 & , array_shape(2) &
3554
3555 & , array_shape(3) &
3556
3557 & , array_shape(4) &
3558
3559 & , array_shape(5) &
3560
3561 & , array_shape(6) &
3562
3563 & ) )
3564 array_avr_work3 = 0.0_dp
3565 weight_sum = 0.0_dp
3566 do i = 1, dim_size
3567 array_avr_work3(:,:,1,:,:,:) = array_avr_work3(:,:,1,:,:,:) + array_avr_work(:,:,i,:,:,:) * weight3(i)
3568 weight_sum = weight_sum + weight3(i)
3569 end do
3570 array_avr_work3 = array_avr_work3 / weight_sum
3571 array_avr_work => array_avr_work3
3572 end if
3573
3574
3575
3576 if ( space_average(4) ) then
3577 dim_size = array_shape(4)
3578 array_shape(4) = 1
3579 allocate( array_avr_work4( array_shape(1) &
3580 & , array_shape(2) &
3581
3582 & , array_shape(3) &
3583
3584 & , array_shape(4) &
3585
3586 & , array_shape(5) &
3587
3588 & , array_shape(6) &
3589
3590 & ) )
3591 array_avr_work4 = 0.0_dp
3592 weight_sum = 0.0_dp
3593 do i = 1, dim_size
3594 array_avr_work4(:,:,:,1,:,:) = array_avr_work4(:,:,:,1,:,:) + array_avr_work(:,:,:,i,:,:) * weight4(i)
3595 weight_sum = weight_sum + weight4(i)
3596 end do
3597 array_avr_work4 = array_avr_work4 / weight_sum
3598 array_avr_work => array_avr_work4
3599 end if
3600
3601
3602
3603 if ( space_average(5) ) then
3604 dim_size = array_shape(5)
3605 array_shape(5) = 1
3606 allocate( array_avr_work5( array_shape(1) &
3607 & , array_shape(2) &
3608
3609 & , array_shape(3) &
3610
3611 & , array_shape(4) &
3612
3613 & , array_shape(5) &
3614
3615 & , array_shape(6) &
3616
3617 & ) )
3618 array_avr_work5 = 0.0_dp
3619 weight_sum = 0.0_dp
3620 do i = 1, dim_size
3621 array_avr_work5(:,:,:,:,1,:) = array_avr_work5(:,:,:,:,1,:) + array_avr_work(:,:,:,:,i,:) * weight5(i)
3622 weight_sum = weight_sum + weight5(i)
3623 end do
3624 array_avr_work5 = array_avr_work5 / weight_sum
3625 array_avr_work => array_avr_work5
3626 end if
3627
3628
3629
3630 if ( space_average(6) ) then
3631 dim_size = array_shape(6)
3632 array_shape(6) = 1
3633 allocate( array_avr_work6( array_shape(1) &
3634 & , array_shape(2) &
3635
3636 & , array_shape(3) &
3637
3638 & , array_shape(4) &
3639
3640 & , array_shape(5) &
3641
3642 & , array_shape(6) &
3643
3644 & ) )
3645 array_avr_work6 = 0.0_dp
3646 weight_sum = 0.0_dp
3647 do i = 1, dim_size
3648 array_avr_work6(:,:,:,:,:,1) = array_avr_work6(:,:,:,:,:,1) + array_avr_work(:,:,:,:,:,i) * weight6(i)
3649 weight_sum = weight_sum + weight6(i)
3650 end do
3651 array_avr_work6 = array_avr_work6 / weight_sum
3652 array_avr_work => array_avr_work6
3653 end if
3654
3655
3656
3657
3658
3659
3660
3661 allocate( array_avr( array_shape(1) &
3662 & , array_shape(2) &
3663
3664 & , array_shape(3) &
3665
3666 & , array_shape(4) &
3667
3668 & , array_shape(5) &
3669
3670 & , array_shape(6) &
3671
3672 & ) )
3673
3674 array_avr = array_avr_work
3675
3676 nullify( array_avr_work )
3677
3678 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
3679
3680 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
3681
3682 if ( associated( array_avr_work3 ) ) deallocate( array_avr_work3 )
3683
3684 if ( associated( array_avr_work4 ) ) deallocate( array_avr_work4 )
3685
3686 if ( associated( array_avr_work5 ) ) deallocate( array_avr_work5 )
3687
3688 if ( associated( array_avr_work6 ) ) deallocate( array_avr_work6 )
3689
3690

◆ averagereducedouble7()

subroutine gtool_historyauto_internal::averagereduce::averagereducedouble7 ( real(dp), dimension(:,:,:,:,:,:,:), intent(in), target  array,
logical, dimension(7), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
real(dp), dimension(:), intent(in)  weight3,
real(dp), dimension(:), intent(in)  weight4,
real(dp), dimension(:), intent(in)  weight5,
real(dp), dimension(:), intent(in)  weight6,
real(dp), dimension(:), intent(in)  weight7,
real(dp), dimension(:,:,:,:,:,:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 3722 of file gtool_historyauto_internal.f90.

3740 implicit none
3741 real(DP), intent(in), target:: array(:,:,:,:,:,:,:)
3742 logical, intent(in):: space_average(7)
3743 real(DP), intent(in):: weight1(:)
3744
3745 real(DP), intent(in):: weight2(:)
3746
3747 real(DP), intent(in):: weight3(:)
3748
3749 real(DP), intent(in):: weight4(:)
3750
3751 real(DP), intent(in):: weight5(:)
3752
3753 real(DP), intent(in):: weight6(:)
3754
3755 real(DP), intent(in):: weight7(:)
3756
3757 real(DP), pointer:: array_avr(:,:,:,:,:,:,:) ! (out)
3758
3759 real(DP), pointer:: array_avr_work(:,:,:,:,:,:,:)
3760
3761 real(DP), pointer:: array_avr_work1(:,:,:,:,:,:,:)
3762
3763 real(DP), pointer:: array_avr_work2(:,:,:,:,:,:,:)
3764
3765 real(DP), pointer:: array_avr_work3(:,:,:,:,:,:,:)
3766
3767 real(DP), pointer:: array_avr_work4(:,:,:,:,:,:,:)
3768
3769 real(DP), pointer:: array_avr_work5(:,:,:,:,:,:,:)
3770
3771 real(DP), pointer:: array_avr_work6(:,:,:,:,:,:,:)
3772
3773 real(DP), pointer:: array_avr_work7(:,:,:,:,:,:,:)
3774
3775
3776 integer:: array_shape(7)
3777 integer:: i, dim_size
3778 real(DP):: weight_sum
3779 continue
3780
3781 array_shape = shape( array )
3782 array_avr_work => array
3783
3784
3785
3786
3787 if ( space_average(1) ) then
3788 dim_size = array_shape(1)
3789 array_shape(1) = 1
3790 allocate( array_avr_work1( array_shape(1) &
3791 & , array_shape(2) &
3792
3793 & , array_shape(3) &
3794
3795 & , array_shape(4) &
3796
3797 & , array_shape(5) &
3798
3799 & , array_shape(6) &
3800
3801 & , array_shape(7) &
3802
3803 & ) )
3804 array_avr_work1 = 0.0_dp
3805 weight_sum = 0.0_dp
3806 do i = 1, dim_size
3807 array_avr_work1(1,:,:,:,:,:,:) = array_avr_work1(1,:,:,:,:,:,:) + array_avr_work(i,:,:,:,:,:,:) * weight1(i)
3808 weight_sum = weight_sum + weight1(i)
3809 end do
3810 array_avr_work1 = array_avr_work1 / weight_sum
3811 array_avr_work => array_avr_work1
3812 end if
3813
3814
3815
3816 if ( space_average(2) ) then
3817 dim_size = array_shape(2)
3818 array_shape(2) = 1
3819 allocate( array_avr_work2( array_shape(1) &
3820 & , array_shape(2) &
3821
3822 & , array_shape(3) &
3823
3824 & , array_shape(4) &
3825
3826 & , array_shape(5) &
3827
3828 & , array_shape(6) &
3829
3830 & , array_shape(7) &
3831
3832 & ) )
3833 array_avr_work2 = 0.0_dp
3834 weight_sum = 0.0_dp
3835 do i = 1, dim_size
3836 array_avr_work2(:,1,:,:,:,:,:) = array_avr_work2(:,1,:,:,:,:,:) + array_avr_work(:,i,:,:,:,:,:) * weight2(i)
3837 weight_sum = weight_sum + weight2(i)
3838 end do
3839 array_avr_work2 = array_avr_work2 / weight_sum
3840 array_avr_work => array_avr_work2
3841 end if
3842
3843
3844
3845 if ( space_average(3) ) then
3846 dim_size = array_shape(3)
3847 array_shape(3) = 1
3848 allocate( array_avr_work3( array_shape(1) &
3849 & , array_shape(2) &
3850
3851 & , array_shape(3) &
3852
3853 & , array_shape(4) &
3854
3855 & , array_shape(5) &
3856
3857 & , array_shape(6) &
3858
3859 & , array_shape(7) &
3860
3861 & ) )
3862 array_avr_work3 = 0.0_dp
3863 weight_sum = 0.0_dp
3864 do i = 1, dim_size
3865 array_avr_work3(:,:,1,:,:,:,:) = array_avr_work3(:,:,1,:,:,:,:) + array_avr_work(:,:,i,:,:,:,:) * weight3(i)
3866 weight_sum = weight_sum + weight3(i)
3867 end do
3868 array_avr_work3 = array_avr_work3 / weight_sum
3869 array_avr_work => array_avr_work3
3870 end if
3871
3872
3873
3874 if ( space_average(4) ) then
3875 dim_size = array_shape(4)
3876 array_shape(4) = 1
3877 allocate( array_avr_work4( array_shape(1) &
3878 & , array_shape(2) &
3879
3880 & , array_shape(3) &
3881
3882 & , array_shape(4) &
3883
3884 & , array_shape(5) &
3885
3886 & , array_shape(6) &
3887
3888 & , array_shape(7) &
3889
3890 & ) )
3891 array_avr_work4 = 0.0_dp
3892 weight_sum = 0.0_dp
3893 do i = 1, dim_size
3894 array_avr_work4(:,:,:,1,:,:,:) = array_avr_work4(:,:,:,1,:,:,:) + array_avr_work(:,:,:,i,:,:,:) * weight4(i)
3895 weight_sum = weight_sum + weight4(i)
3896 end do
3897 array_avr_work4 = array_avr_work4 / weight_sum
3898 array_avr_work => array_avr_work4
3899 end if
3900
3901
3902
3903 if ( space_average(5) ) then
3904 dim_size = array_shape(5)
3905 array_shape(5) = 1
3906 allocate( array_avr_work5( array_shape(1) &
3907 & , array_shape(2) &
3908
3909 & , array_shape(3) &
3910
3911 & , array_shape(4) &
3912
3913 & , array_shape(5) &
3914
3915 & , array_shape(6) &
3916
3917 & , array_shape(7) &
3918
3919 & ) )
3920 array_avr_work5 = 0.0_dp
3921 weight_sum = 0.0_dp
3922 do i = 1, dim_size
3923 array_avr_work5(:,:,:,:,1,:,:) = array_avr_work5(:,:,:,:,1,:,:) + array_avr_work(:,:,:,:,i,:,:) * weight5(i)
3924 weight_sum = weight_sum + weight5(i)
3925 end do
3926 array_avr_work5 = array_avr_work5 / weight_sum
3927 array_avr_work => array_avr_work5
3928 end if
3929
3930
3931
3932 if ( space_average(6) ) then
3933 dim_size = array_shape(6)
3934 array_shape(6) = 1
3935 allocate( array_avr_work6( array_shape(1) &
3936 & , array_shape(2) &
3937
3938 & , array_shape(3) &
3939
3940 & , array_shape(4) &
3941
3942 & , array_shape(5) &
3943
3944 & , array_shape(6) &
3945
3946 & , array_shape(7) &
3947
3948 & ) )
3949 array_avr_work6 = 0.0_dp
3950 weight_sum = 0.0_dp
3951 do i = 1, dim_size
3952 array_avr_work6(:,:,:,:,:,1,:) = array_avr_work6(:,:,:,:,:,1,:) + array_avr_work(:,:,:,:,:,i,:) * weight6(i)
3953 weight_sum = weight_sum + weight6(i)
3954 end do
3955 array_avr_work6 = array_avr_work6 / weight_sum
3956 array_avr_work => array_avr_work6
3957 end if
3958
3959
3960
3961 if ( space_average(7) ) then
3962 dim_size = array_shape(7)
3963 array_shape(7) = 1
3964 allocate( array_avr_work7( array_shape(1) &
3965 & , array_shape(2) &
3966
3967 & , array_shape(3) &
3968
3969 & , array_shape(4) &
3970
3971 & , array_shape(5) &
3972
3973 & , array_shape(6) &
3974
3975 & , array_shape(7) &
3976
3977 & ) )
3978 array_avr_work7 = 0.0_dp
3979 weight_sum = 0.0_dp
3980 do i = 1, dim_size
3981 array_avr_work7(:,:,:,:,:,:,1) = array_avr_work7(:,:,:,:,:,:,1) + array_avr_work(:,:,:,:,:,:,i) * weight7(i)
3982 weight_sum = weight_sum + weight7(i)
3983 end do
3984 array_avr_work7 = array_avr_work7 / weight_sum
3985 array_avr_work => array_avr_work7
3986 end if
3987
3988
3989
3990
3991
3992
3993
3994 allocate( array_avr( array_shape(1) &
3995 & , array_shape(2) &
3996
3997 & , array_shape(3) &
3998
3999 & , array_shape(4) &
4000
4001 & , array_shape(5) &
4002
4003 & , array_shape(6) &
4004
4005 & , array_shape(7) &
4006
4007 & ) )
4008
4009 array_avr = array_avr_work
4010
4011 nullify( array_avr_work )
4012
4013 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
4014
4015 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
4016
4017 if ( associated( array_avr_work3 ) ) deallocate( array_avr_work3 )
4018
4019 if ( associated( array_avr_work4 ) ) deallocate( array_avr_work4 )
4020
4021 if ( associated( array_avr_work5 ) ) deallocate( array_avr_work5 )
4022
4023 if ( associated( array_avr_work6 ) ) deallocate( array_avr_work6 )
4024
4025 if ( associated( array_avr_work7 ) ) deallocate( array_avr_work7 )
4026
4027

◆ averagereduceint1()

subroutine gtool_historyauto_internal::averagereduce::averagereduceint1 ( integer, dimension(:), intent(in), target  array,
logical, dimension(1), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
integer, dimension(:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 4059 of file gtool_historyauto_internal.f90.

4065 implicit none
4066 integer, intent(in), target:: array(:)
4067 logical, intent(in):: space_average(1)
4068 real(DP), intent(in):: weight1(:)
4069
4070 integer, pointer:: array_avr(:) ! (out)
4071
4072 integer, pointer:: array_avr_work(:)
4073
4074 integer, pointer:: array_avr_work1(:)
4075
4076
4077 integer:: array_shape(1)
4078 integer:: i, dim_size
4079 real(DP):: weight_sum
4080 continue
4081
4082 array_shape = shape( array )
4083 array_avr_work => array
4084
4085
4086
4087
4088 if ( space_average(1) ) then
4089 dim_size = array_shape(1)
4090 array_shape(1) = 1
4091 allocate( array_avr_work1( array_shape(1) &
4092
4093 & ) )
4094 array_avr_work1 = 0
4095 weight_sum = 0.0_dp
4096 do i = 1, dim_size
4097 array_avr_work1(1) = int( &
4098 & real(array_avr_work1(1), kind=dp) + &
4099 & real(array_avr_work(i), kind=dp) * weight1(i), &
4100 & kind=kind(array_avr_work1) )
4101 weight_sum = weight_sum + weight1(i)
4102 end do
4103 array_avr_work1 = int( &
4104 & real(array_avr_work1, kind=dp) / weight_sum, &
4105 & kind=kind(array_avr_work1) )
4106 array_avr_work => array_avr_work1
4107 end if
4108
4109
4110
4111
4112
4113
4114
4115 allocate( array_avr( array_shape(1) &
4116
4117 & ) )
4118
4119 array_avr = array_avr_work
4120
4121 nullify( array_avr_work )
4122
4123 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
4124
4125

◆ averagereduceint2()

subroutine gtool_historyauto_internal::averagereduce::averagereduceint2 ( integer, dimension(:,:), intent(in), target  array,
logical, dimension(2), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
integer, dimension(:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 4157 of file gtool_historyauto_internal.f90.

4165 implicit none
4166 integer, intent(in), target:: array(:,:)
4167 logical, intent(in):: space_average(2)
4168 real(DP), intent(in):: weight1(:)
4169
4170 real(DP), intent(in):: weight2(:)
4171
4172 integer, pointer:: array_avr(:,:) ! (out)
4173
4174 integer, pointer:: array_avr_work(:,:)
4175
4176 integer, pointer:: array_avr_work1(:,:)
4177
4178 integer, pointer:: array_avr_work2(:,:)
4179
4180
4181 integer:: array_shape(2)
4182 integer:: i, dim_size
4183 real(DP):: weight_sum
4184 continue
4185
4186 array_shape = shape( array )
4187 array_avr_work => array
4188
4189
4190
4191
4192 if ( space_average(1) ) then
4193 dim_size = array_shape(1)
4194 array_shape(1) = 1
4195 allocate( array_avr_work1( array_shape(1) &
4196 & , array_shape(2) &
4197
4198 & ) )
4199 array_avr_work1 = 0
4200 weight_sum = 0.0_dp
4201 do i = 1, dim_size
4202 array_avr_work1(1,:) = int( &
4203 & real(array_avr_work1(1,:), kind=dp) + &
4204 & real(array_avr_work(i,:), kind=dp) * weight1(i), &
4205 & kind=kind(array_avr_work1) )
4206 weight_sum = weight_sum + weight1(i)
4207 end do
4208 array_avr_work1 = int( &
4209 & real(array_avr_work1, kind=dp) / weight_sum, &
4210 & kind=kind(array_avr_work1) )
4211 array_avr_work => array_avr_work1
4212 end if
4213
4214
4215
4216 if ( space_average(2) ) then
4217 dim_size = array_shape(2)
4218 array_shape(2) = 1
4219 allocate( array_avr_work2( array_shape(1) &
4220 & , array_shape(2) &
4221
4222 & ) )
4223 array_avr_work2 = 0
4224 weight_sum = 0.0_dp
4225 do i = 1, dim_size
4226 array_avr_work2(:,1) = int( &
4227 & real(array_avr_work2(:,1), kind=dp) + &
4228 & real(array_avr_work(:,i), kind=dp) * weight2(i), &
4229 & kind=kind(array_avr_work2) )
4230 weight_sum = weight_sum + weight2(i)
4231 end do
4232 array_avr_work2 = int( &
4233 & real(array_avr_work2, kind=dp) / weight_sum, &
4234 & kind=kind(array_avr_work2) )
4235 array_avr_work => array_avr_work2
4236 end if
4237
4238
4239
4240
4241
4242
4243
4244 allocate( array_avr( array_shape(1) &
4245 & , array_shape(2) &
4246
4247 & ) )
4248
4249 array_avr = array_avr_work
4250
4251 nullify( array_avr_work )
4252
4253 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
4254
4255 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
4256
4257

◆ averagereduceint3()

subroutine gtool_historyauto_internal::averagereduce::averagereduceint3 ( integer, dimension(:,:,:), intent(in), target  array,
logical, dimension(3), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
real(dp), dimension(:), intent(in)  weight3,
integer, dimension(:,:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 4289 of file gtool_historyauto_internal.f90.

4299 implicit none
4300 integer, intent(in), target:: array(:,:,:)
4301 logical, intent(in):: space_average(3)
4302 real(DP), intent(in):: weight1(:)
4303
4304 real(DP), intent(in):: weight2(:)
4305
4306 real(DP), intent(in):: weight3(:)
4307
4308 integer, pointer:: array_avr(:,:,:) ! (out)
4309
4310 integer, pointer:: array_avr_work(:,:,:)
4311
4312 integer, pointer:: array_avr_work1(:,:,:)
4313
4314 integer, pointer:: array_avr_work2(:,:,:)
4315
4316 integer, pointer:: array_avr_work3(:,:,:)
4317
4318
4319 integer:: array_shape(3)
4320 integer:: i, dim_size
4321 real(DP):: weight_sum
4322 continue
4323
4324 array_shape = shape( array )
4325 array_avr_work => array
4326
4327
4328
4329
4330 if ( space_average(1) ) then
4331 dim_size = array_shape(1)
4332 array_shape(1) = 1
4333 allocate( array_avr_work1( array_shape(1) &
4334 & , array_shape(2) &
4335
4336 & , array_shape(3) &
4337
4338 & ) )
4339 array_avr_work1 = 0
4340 weight_sum = 0.0_dp
4341 do i = 1, dim_size
4342 array_avr_work1(1,:,:) = int( &
4343 & real(array_avr_work1(1,:,:), kind=dp) + &
4344 & real(array_avr_work(i,:,:), kind=dp) * weight1(i), &
4345 & kind=kind(array_avr_work1) )
4346 weight_sum = weight_sum + weight1(i)
4347 end do
4348 array_avr_work1 = int( &
4349 & real(array_avr_work1, kind=dp) / weight_sum, &
4350 & kind=kind(array_avr_work1) )
4351 array_avr_work => array_avr_work1
4352 end if
4353
4354
4355
4356 if ( space_average(2) ) then
4357 dim_size = array_shape(2)
4358 array_shape(2) = 1
4359 allocate( array_avr_work2( array_shape(1) &
4360 & , array_shape(2) &
4361
4362 & , array_shape(3) &
4363
4364 & ) )
4365 array_avr_work2 = 0
4366 weight_sum = 0.0_dp
4367 do i = 1, dim_size
4368 array_avr_work2(:,1,:) = int( &
4369 & real(array_avr_work2(:,1,:), kind=dp) + &
4370 & real(array_avr_work(:,i,:), kind=dp) * weight2(i), &
4371 & kind=kind(array_avr_work2) )
4372 weight_sum = weight_sum + weight2(i)
4373 end do
4374 array_avr_work2 = int( &
4375 & real(array_avr_work2, kind=dp) / weight_sum, &
4376 & kind=kind(array_avr_work2) )
4377 array_avr_work => array_avr_work2
4378 end if
4379
4380
4381
4382 if ( space_average(3) ) then
4383 dim_size = array_shape(3)
4384 array_shape(3) = 1
4385 allocate( array_avr_work3( array_shape(1) &
4386 & , array_shape(2) &
4387
4388 & , array_shape(3) &
4389
4390 & ) )
4391 array_avr_work3 = 0
4392 weight_sum = 0.0_dp
4393 do i = 1, dim_size
4394 array_avr_work3(:,:,1) = int( &
4395 & real(array_avr_work3(:,:,1), kind=dp) + &
4396 & real(array_avr_work(:,:,i), kind=dp) * weight3(i), &
4397 & kind=kind(array_avr_work3) )
4398 weight_sum = weight_sum + weight3(i)
4399 end do
4400 array_avr_work3 = int( &
4401 & real(array_avr_work3, kind=dp) / weight_sum, &
4402 & kind=kind(array_avr_work3) )
4403 array_avr_work => array_avr_work3
4404 end if
4405
4406
4407
4408
4409
4410
4411
4412 allocate( array_avr( array_shape(1) &
4413 & , array_shape(2) &
4414
4415 & , array_shape(3) &
4416
4417 & ) )
4418
4419 array_avr = array_avr_work
4420
4421 nullify( array_avr_work )
4422
4423 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
4424
4425 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
4426
4427 if ( associated( array_avr_work3 ) ) deallocate( array_avr_work3 )
4428
4429

◆ averagereduceint4()

subroutine gtool_historyauto_internal::averagereduce::averagereduceint4 ( integer, dimension(:,:,:,:), intent(in), target  array,
logical, dimension(4), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
real(dp), dimension(:), intent(in)  weight3,
real(dp), dimension(:), intent(in)  weight4,
integer, dimension(:,:,:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 4461 of file gtool_historyauto_internal.f90.

4473 implicit none
4474 integer, intent(in), target:: array(:,:,:,:)
4475 logical, intent(in):: space_average(4)
4476 real(DP), intent(in):: weight1(:)
4477
4478 real(DP), intent(in):: weight2(:)
4479
4480 real(DP), intent(in):: weight3(:)
4481
4482 real(DP), intent(in):: weight4(:)
4483
4484 integer, pointer:: array_avr(:,:,:,:) ! (out)
4485
4486 integer, pointer:: array_avr_work(:,:,:,:)
4487
4488 integer, pointer:: array_avr_work1(:,:,:,:)
4489
4490 integer, pointer:: array_avr_work2(:,:,:,:)
4491
4492 integer, pointer:: array_avr_work3(:,:,:,:)
4493
4494 integer, pointer:: array_avr_work4(:,:,:,:)
4495
4496
4497 integer:: array_shape(4)
4498 integer:: i, dim_size
4499 real(DP):: weight_sum
4500 continue
4501
4502 array_shape = shape( array )
4503 array_avr_work => array
4504
4505
4506
4507
4508 if ( space_average(1) ) then
4509 dim_size = array_shape(1)
4510 array_shape(1) = 1
4511 allocate( array_avr_work1( array_shape(1) &
4512 & , array_shape(2) &
4513
4514 & , array_shape(3) &
4515
4516 & , array_shape(4) &
4517
4518 & ) )
4519 array_avr_work1 = 0
4520 weight_sum = 0.0_dp
4521 do i = 1, dim_size
4522 array_avr_work1(1,:,:,:) = int( &
4523 & real(array_avr_work1(1,:,:,:), kind=dp) + &
4524 & real(array_avr_work(i,:,:,:), kind=dp) * weight1(i), &
4525 & kind=kind(array_avr_work1) )
4526 weight_sum = weight_sum + weight1(i)
4527 end do
4528 array_avr_work1 = int( &
4529 & real(array_avr_work1, kind=dp) / weight_sum, &
4530 & kind=kind(array_avr_work1) )
4531 array_avr_work => array_avr_work1
4532 end if
4533
4534
4535
4536 if ( space_average(2) ) then
4537 dim_size = array_shape(2)
4538 array_shape(2) = 1
4539 allocate( array_avr_work2( array_shape(1) &
4540 & , array_shape(2) &
4541
4542 & , array_shape(3) &
4543
4544 & , array_shape(4) &
4545
4546 & ) )
4547 array_avr_work2 = 0
4548 weight_sum = 0.0_dp
4549 do i = 1, dim_size
4550 array_avr_work2(:,1,:,:) = int( &
4551 & real(array_avr_work2(:,1,:,:), kind=dp) + &
4552 & real(array_avr_work(:,i,:,:), kind=dp) * weight2(i), &
4553 & kind=kind(array_avr_work2) )
4554 weight_sum = weight_sum + weight2(i)
4555 end do
4556 array_avr_work2 = int( &
4557 & real(array_avr_work2, kind=dp) / weight_sum, &
4558 & kind=kind(array_avr_work2) )
4559 array_avr_work => array_avr_work2
4560 end if
4561
4562
4563
4564 if ( space_average(3) ) then
4565 dim_size = array_shape(3)
4566 array_shape(3) = 1
4567 allocate( array_avr_work3( array_shape(1) &
4568 & , array_shape(2) &
4569
4570 & , array_shape(3) &
4571
4572 & , array_shape(4) &
4573
4574 & ) )
4575 array_avr_work3 = 0
4576 weight_sum = 0.0_dp
4577 do i = 1, dim_size
4578 array_avr_work3(:,:,1,:) = int( &
4579 & real(array_avr_work3(:,:,1,:), kind=dp) + &
4580 & real(array_avr_work(:,:,i,:), kind=dp) * weight3(i), &
4581 & kind=kind(array_avr_work3) )
4582 weight_sum = weight_sum + weight3(i)
4583 end do
4584 array_avr_work3 = int( &
4585 & real(array_avr_work3, kind=dp) / weight_sum, &
4586 & kind=kind(array_avr_work3) )
4587 array_avr_work => array_avr_work3
4588 end if
4589
4590
4591
4592 if ( space_average(4) ) then
4593 dim_size = array_shape(4)
4594 array_shape(4) = 1
4595 allocate( array_avr_work4( array_shape(1) &
4596 & , array_shape(2) &
4597
4598 & , array_shape(3) &
4599
4600 & , array_shape(4) &
4601
4602 & ) )
4603 array_avr_work4 = 0
4604 weight_sum = 0.0_dp
4605 do i = 1, dim_size
4606 array_avr_work4(:,:,:,1) = int( &
4607 & real(array_avr_work4(:,:,:,1), kind=dp) + &
4608 & real(array_avr_work(:,:,:,i), kind=dp) * weight4(i), &
4609 & kind=kind(array_avr_work4) )
4610 weight_sum = weight_sum + weight4(i)
4611 end do
4612 array_avr_work4 = int( &
4613 & real(array_avr_work4, kind=dp) / weight_sum, &
4614 & kind=kind(array_avr_work4) )
4615 array_avr_work => array_avr_work4
4616 end if
4617
4618
4619
4620
4621
4622
4623
4624 allocate( array_avr( array_shape(1) &
4625 & , array_shape(2) &
4626
4627 & , array_shape(3) &
4628
4629 & , array_shape(4) &
4630
4631 & ) )
4632
4633 array_avr = array_avr_work
4634
4635 nullify( array_avr_work )
4636
4637 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
4638
4639 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
4640
4641 if ( associated( array_avr_work3 ) ) deallocate( array_avr_work3 )
4642
4643 if ( associated( array_avr_work4 ) ) deallocate( array_avr_work4 )
4644
4645

◆ averagereduceint5()

subroutine gtool_historyauto_internal::averagereduce::averagereduceint5 ( integer, dimension(:,:,:,:,:), intent(in), target  array,
logical, dimension(5), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
real(dp), dimension(:), intent(in)  weight3,
real(dp), dimension(:), intent(in)  weight4,
real(dp), dimension(:), intent(in)  weight5,
integer, dimension(:,:,:,:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 4677 of file gtool_historyauto_internal.f90.

4691 implicit none
4692 integer, intent(in), target:: array(:,:,:,:,:)
4693 logical, intent(in):: space_average(5)
4694 real(DP), intent(in):: weight1(:)
4695
4696 real(DP), intent(in):: weight2(:)
4697
4698 real(DP), intent(in):: weight3(:)
4699
4700 real(DP), intent(in):: weight4(:)
4701
4702 real(DP), intent(in):: weight5(:)
4703
4704 integer, pointer:: array_avr(:,:,:,:,:) ! (out)
4705
4706 integer, pointer:: array_avr_work(:,:,:,:,:)
4707
4708 integer, pointer:: array_avr_work1(:,:,:,:,:)
4709
4710 integer, pointer:: array_avr_work2(:,:,:,:,:)
4711
4712 integer, pointer:: array_avr_work3(:,:,:,:,:)
4713
4714 integer, pointer:: array_avr_work4(:,:,:,:,:)
4715
4716 integer, pointer:: array_avr_work5(:,:,:,:,:)
4717
4718
4719 integer:: array_shape(5)
4720 integer:: i, dim_size
4721 real(DP):: weight_sum
4722 continue
4723
4724 array_shape = shape( array )
4725 array_avr_work => array
4726
4727
4728
4729
4730 if ( space_average(1) ) then
4731 dim_size = array_shape(1)
4732 array_shape(1) = 1
4733 allocate( array_avr_work1( array_shape(1) &
4734 & , array_shape(2) &
4735
4736 & , array_shape(3) &
4737
4738 & , array_shape(4) &
4739
4740 & , array_shape(5) &
4741
4742 & ) )
4743 array_avr_work1 = 0
4744 weight_sum = 0.0_dp
4745 do i = 1, dim_size
4746 array_avr_work1(1,:,:,:,:) = int( &
4747 & real(array_avr_work1(1,:,:,:,:), kind=dp) + &
4748 & real(array_avr_work(i,:,:,:,:), kind=dp) * weight1(i), &
4749 & kind=kind(array_avr_work1) )
4750 weight_sum = weight_sum + weight1(i)
4751 end do
4752 array_avr_work1 = int( &
4753 & real(array_avr_work1, kind=dp) / weight_sum, &
4754 & kind=kind(array_avr_work1) )
4755 array_avr_work => array_avr_work1
4756 end if
4757
4758
4759
4760 if ( space_average(2) ) then
4761 dim_size = array_shape(2)
4762 array_shape(2) = 1
4763 allocate( array_avr_work2( array_shape(1) &
4764 & , array_shape(2) &
4765
4766 & , array_shape(3) &
4767
4768 & , array_shape(4) &
4769
4770 & , array_shape(5) &
4771
4772 & ) )
4773 array_avr_work2 = 0
4774 weight_sum = 0.0_dp
4775 do i = 1, dim_size
4776 array_avr_work2(:,1,:,:,:) = int( &
4777 & real(array_avr_work2(:,1,:,:,:), kind=dp) + &
4778 & real(array_avr_work(:,i,:,:,:), kind=dp) * weight2(i), &
4779 & kind=kind(array_avr_work2) )
4780 weight_sum = weight_sum + weight2(i)
4781 end do
4782 array_avr_work2 = int( &
4783 & real(array_avr_work2, kind=dp) / weight_sum, &
4784 & kind=kind(array_avr_work2) )
4785 array_avr_work => array_avr_work2
4786 end if
4787
4788
4789
4790 if ( space_average(3) ) then
4791 dim_size = array_shape(3)
4792 array_shape(3) = 1
4793 allocate( array_avr_work3( array_shape(1) &
4794 & , array_shape(2) &
4795
4796 & , array_shape(3) &
4797
4798 & , array_shape(4) &
4799
4800 & , array_shape(5) &
4801
4802 & ) )
4803 array_avr_work3 = 0
4804 weight_sum = 0.0_dp
4805 do i = 1, dim_size
4806 array_avr_work3(:,:,1,:,:) = int( &
4807 & real(array_avr_work3(:,:,1,:,:), kind=dp) + &
4808 & real(array_avr_work(:,:,i,:,:), kind=dp) * weight3(i), &
4809 & kind=kind(array_avr_work3) )
4810 weight_sum = weight_sum + weight3(i)
4811 end do
4812 array_avr_work3 = int( &
4813 & real(array_avr_work3, kind=dp) / weight_sum, &
4814 & kind=kind(array_avr_work3) )
4815 array_avr_work => array_avr_work3
4816 end if
4817
4818
4819
4820 if ( space_average(4) ) then
4821 dim_size = array_shape(4)
4822 array_shape(4) = 1
4823 allocate( array_avr_work4( array_shape(1) &
4824 & , array_shape(2) &
4825
4826 & , array_shape(3) &
4827
4828 & , array_shape(4) &
4829
4830 & , array_shape(5) &
4831
4832 & ) )
4833 array_avr_work4 = 0
4834 weight_sum = 0.0_dp
4835 do i = 1, dim_size
4836 array_avr_work4(:,:,:,1,:) = int( &
4837 & real(array_avr_work4(:,:,:,1,:), kind=dp) + &
4838 & real(array_avr_work(:,:,:,i,:), kind=dp) * weight4(i), &
4839 & kind=kind(array_avr_work4) )
4840 weight_sum = weight_sum + weight4(i)
4841 end do
4842 array_avr_work4 = int( &
4843 & real(array_avr_work4, kind=dp) / weight_sum, &
4844 & kind=kind(array_avr_work4) )
4845 array_avr_work => array_avr_work4
4846 end if
4847
4848
4849
4850 if ( space_average(5) ) then
4851 dim_size = array_shape(5)
4852 array_shape(5) = 1
4853 allocate( array_avr_work5( array_shape(1) &
4854 & , array_shape(2) &
4855
4856 & , array_shape(3) &
4857
4858 & , array_shape(4) &
4859
4860 & , array_shape(5) &
4861
4862 & ) )
4863 array_avr_work5 = 0
4864 weight_sum = 0.0_dp
4865 do i = 1, dim_size
4866 array_avr_work5(:,:,:,:,1) = int( &
4867 & real(array_avr_work5(:,:,:,:,1), kind=dp) + &
4868 & real(array_avr_work(:,:,:,:,i), kind=dp) * weight5(i), &
4869 & kind=kind(array_avr_work5) )
4870 weight_sum = weight_sum + weight5(i)
4871 end do
4872 array_avr_work5 = int( &
4873 & real(array_avr_work5, kind=dp) / weight_sum, &
4874 & kind=kind(array_avr_work5) )
4875 array_avr_work => array_avr_work5
4876 end if
4877
4878
4879
4880
4881
4882
4883
4884 allocate( array_avr( array_shape(1) &
4885 & , array_shape(2) &
4886
4887 & , array_shape(3) &
4888
4889 & , array_shape(4) &
4890
4891 & , array_shape(5) &
4892
4893 & ) )
4894
4895 array_avr = array_avr_work
4896
4897 nullify( array_avr_work )
4898
4899 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
4900
4901 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
4902
4903 if ( associated( array_avr_work3 ) ) deallocate( array_avr_work3 )
4904
4905 if ( associated( array_avr_work4 ) ) deallocate( array_avr_work4 )
4906
4907 if ( associated( array_avr_work5 ) ) deallocate( array_avr_work5 )
4908
4909

◆ averagereduceint6()

subroutine gtool_historyauto_internal::averagereduce::averagereduceint6 ( integer, dimension(:,:,:,:,:,:), intent(in), target  array,
logical, dimension(6), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
real(dp), dimension(:), intent(in)  weight3,
real(dp), dimension(:), intent(in)  weight4,
real(dp), dimension(:), intent(in)  weight5,
real(dp), dimension(:), intent(in)  weight6,
integer, dimension(:,:,:,:,:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 4941 of file gtool_historyauto_internal.f90.

4957 implicit none
4958 integer, intent(in), target:: array(:,:,:,:,:,:)
4959 logical, intent(in):: space_average(6)
4960 real(DP), intent(in):: weight1(:)
4961
4962 real(DP), intent(in):: weight2(:)
4963
4964 real(DP), intent(in):: weight3(:)
4965
4966 real(DP), intent(in):: weight4(:)
4967
4968 real(DP), intent(in):: weight5(:)
4969
4970 real(DP), intent(in):: weight6(:)
4971
4972 integer, pointer:: array_avr(:,:,:,:,:,:) ! (out)
4973
4974 integer, pointer:: array_avr_work(:,:,:,:,:,:)
4975
4976 integer, pointer:: array_avr_work1(:,:,:,:,:,:)
4977
4978 integer, pointer:: array_avr_work2(:,:,:,:,:,:)
4979
4980 integer, pointer:: array_avr_work3(:,:,:,:,:,:)
4981
4982 integer, pointer:: array_avr_work4(:,:,:,:,:,:)
4983
4984 integer, pointer:: array_avr_work5(:,:,:,:,:,:)
4985
4986 integer, pointer:: array_avr_work6(:,:,:,:,:,:)
4987
4988
4989 integer:: array_shape(6)
4990 integer:: i, dim_size
4991 real(DP):: weight_sum
4992 continue
4993
4994 array_shape = shape( array )
4995 array_avr_work => array
4996
4997
4998
4999
5000 if ( space_average(1) ) then
5001 dim_size = array_shape(1)
5002 array_shape(1) = 1
5003 allocate( array_avr_work1( array_shape(1) &
5004 & , array_shape(2) &
5005
5006 & , array_shape(3) &
5007
5008 & , array_shape(4) &
5009
5010 & , array_shape(5) &
5011
5012 & , array_shape(6) &
5013
5014 & ) )
5015 array_avr_work1 = 0
5016 weight_sum = 0.0_dp
5017 do i = 1, dim_size
5018 array_avr_work1(1,:,:,:,:,:) = int( &
5019 & real(array_avr_work1(1,:,:,:,:,:), kind=dp) + &
5020 & real(array_avr_work(i,:,:,:,:,:), kind=dp) * weight1(i), &
5021 & kind=kind(array_avr_work1) )
5022 weight_sum = weight_sum + weight1(i)
5023 end do
5024 array_avr_work1 = int( &
5025 & real(array_avr_work1, kind=dp) / weight_sum, &
5026 & kind=kind(array_avr_work1) )
5027 array_avr_work => array_avr_work1
5028 end if
5029
5030
5031
5032 if ( space_average(2) ) then
5033 dim_size = array_shape(2)
5034 array_shape(2) = 1
5035 allocate( array_avr_work2( array_shape(1) &
5036 & , array_shape(2) &
5037
5038 & , array_shape(3) &
5039
5040 & , array_shape(4) &
5041
5042 & , array_shape(5) &
5043
5044 & , array_shape(6) &
5045
5046 & ) )
5047 array_avr_work2 = 0
5048 weight_sum = 0.0_dp
5049 do i = 1, dim_size
5050 array_avr_work2(:,1,:,:,:,:) = int( &
5051 & real(array_avr_work2(:,1,:,:,:,:), kind=dp) + &
5052 & real(array_avr_work(:,i,:,:,:,:), kind=dp) * weight2(i), &
5053 & kind=kind(array_avr_work2) )
5054 weight_sum = weight_sum + weight2(i)
5055 end do
5056 array_avr_work2 = int( &
5057 & real(array_avr_work2, kind=dp) / weight_sum, &
5058 & kind=kind(array_avr_work2) )
5059 array_avr_work => array_avr_work2
5060 end if
5061
5062
5063
5064 if ( space_average(3) ) then
5065 dim_size = array_shape(3)
5066 array_shape(3) = 1
5067 allocate( array_avr_work3( array_shape(1) &
5068 & , array_shape(2) &
5069
5070 & , array_shape(3) &
5071
5072 & , array_shape(4) &
5073
5074 & , array_shape(5) &
5075
5076 & , array_shape(6) &
5077
5078 & ) )
5079 array_avr_work3 = 0
5080 weight_sum = 0.0_dp
5081 do i = 1, dim_size
5082 array_avr_work3(:,:,1,:,:,:) = int( &
5083 & real(array_avr_work3(:,:,1,:,:,:), kind=dp) + &
5084 & real(array_avr_work(:,:,i,:,:,:), kind=dp) * weight3(i), &
5085 & kind=kind(array_avr_work3) )
5086 weight_sum = weight_sum + weight3(i)
5087 end do
5088 array_avr_work3 = int( &
5089 & real(array_avr_work3, kind=dp) / weight_sum, &
5090 & kind=kind(array_avr_work3) )
5091 array_avr_work => array_avr_work3
5092 end if
5093
5094
5095
5096 if ( space_average(4) ) then
5097 dim_size = array_shape(4)
5098 array_shape(4) = 1
5099 allocate( array_avr_work4( array_shape(1) &
5100 & , array_shape(2) &
5101
5102 & , array_shape(3) &
5103
5104 & , array_shape(4) &
5105
5106 & , array_shape(5) &
5107
5108 & , array_shape(6) &
5109
5110 & ) )
5111 array_avr_work4 = 0
5112 weight_sum = 0.0_dp
5113 do i = 1, dim_size
5114 array_avr_work4(:,:,:,1,:,:) = int( &
5115 & real(array_avr_work4(:,:,:,1,:,:), kind=dp) + &
5116 & real(array_avr_work(:,:,:,i,:,:), kind=dp) * weight4(i), &
5117 & kind=kind(array_avr_work4) )
5118 weight_sum = weight_sum + weight4(i)
5119 end do
5120 array_avr_work4 = int( &
5121 & real(array_avr_work4, kind=dp) / weight_sum, &
5122 & kind=kind(array_avr_work4) )
5123 array_avr_work => array_avr_work4
5124 end if
5125
5126
5127
5128 if ( space_average(5) ) then
5129 dim_size = array_shape(5)
5130 array_shape(5) = 1
5131 allocate( array_avr_work5( array_shape(1) &
5132 & , array_shape(2) &
5133
5134 & , array_shape(3) &
5135
5136 & , array_shape(4) &
5137
5138 & , array_shape(5) &
5139
5140 & , array_shape(6) &
5141
5142 & ) )
5143 array_avr_work5 = 0
5144 weight_sum = 0.0_dp
5145 do i = 1, dim_size
5146 array_avr_work5(:,:,:,:,1,:) = int( &
5147 & real(array_avr_work5(:,:,:,:,1,:), kind=dp) + &
5148 & real(array_avr_work(:,:,:,:,i,:), kind=dp) * weight5(i), &
5149 & kind=kind(array_avr_work5) )
5150 weight_sum = weight_sum + weight5(i)
5151 end do
5152 array_avr_work5 = int( &
5153 & real(array_avr_work5, kind=dp) / weight_sum, &
5154 & kind=kind(array_avr_work5) )
5155 array_avr_work => array_avr_work5
5156 end if
5157
5158
5159
5160 if ( space_average(6) ) then
5161 dim_size = array_shape(6)
5162 array_shape(6) = 1
5163 allocate( array_avr_work6( array_shape(1) &
5164 & , array_shape(2) &
5165
5166 & , array_shape(3) &
5167
5168 & , array_shape(4) &
5169
5170 & , array_shape(5) &
5171
5172 & , array_shape(6) &
5173
5174 & ) )
5175 array_avr_work6 = 0
5176 weight_sum = 0.0_dp
5177 do i = 1, dim_size
5178 array_avr_work6(:,:,:,:,:,1) = int( &
5179 & real(array_avr_work6(:,:,:,:,:,1), kind=dp) + &
5180 & real(array_avr_work(:,:,:,:,:,i), kind=dp) * weight6(i), &
5181 & kind=kind(array_avr_work6) )
5182 weight_sum = weight_sum + weight6(i)
5183 end do
5184 array_avr_work6 = int( &
5185 & real(array_avr_work6, kind=dp) / weight_sum, &
5186 & kind=kind(array_avr_work6) )
5187 array_avr_work => array_avr_work6
5188 end if
5189
5190
5191
5192
5193
5194
5195
5196 allocate( array_avr( array_shape(1) &
5197 & , array_shape(2) &
5198
5199 & , array_shape(3) &
5200
5201 & , array_shape(4) &
5202
5203 & , array_shape(5) &
5204
5205 & , array_shape(6) &
5206
5207 & ) )
5208
5209 array_avr = array_avr_work
5210
5211 nullify( array_avr_work )
5212
5213 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
5214
5215 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
5216
5217 if ( associated( array_avr_work3 ) ) deallocate( array_avr_work3 )
5218
5219 if ( associated( array_avr_work4 ) ) deallocate( array_avr_work4 )
5220
5221 if ( associated( array_avr_work5 ) ) deallocate( array_avr_work5 )
5222
5223 if ( associated( array_avr_work6 ) ) deallocate( array_avr_work6 )
5224
5225

◆ averagereduceint7()

subroutine gtool_historyauto_internal::averagereduce::averagereduceint7 ( integer, dimension(:,:,:,:,:,:,:), intent(in), target  array,
logical, dimension(7), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
real(dp), dimension(:), intent(in)  weight3,
real(dp), dimension(:), intent(in)  weight4,
real(dp), dimension(:), intent(in)  weight5,
real(dp), dimension(:), intent(in)  weight6,
real(dp), dimension(:), intent(in)  weight7,
integer, dimension(:,:,:,:,:,:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 5257 of file gtool_historyauto_internal.f90.

5275 implicit none
5276 integer, intent(in), target:: array(:,:,:,:,:,:,:)
5277 logical, intent(in):: space_average(7)
5278 real(DP), intent(in):: weight1(:)
5279
5280 real(DP), intent(in):: weight2(:)
5281
5282 real(DP), intent(in):: weight3(:)
5283
5284 real(DP), intent(in):: weight4(:)
5285
5286 real(DP), intent(in):: weight5(:)
5287
5288 real(DP), intent(in):: weight6(:)
5289
5290 real(DP), intent(in):: weight7(:)
5291
5292 integer, pointer:: array_avr(:,:,:,:,:,:,:) ! (out)
5293
5294 integer, pointer:: array_avr_work(:,:,:,:,:,:,:)
5295
5296 integer, pointer:: array_avr_work1(:,:,:,:,:,:,:)
5297
5298 integer, pointer:: array_avr_work2(:,:,:,:,:,:,:)
5299
5300 integer, pointer:: array_avr_work3(:,:,:,:,:,:,:)
5301
5302 integer, pointer:: array_avr_work4(:,:,:,:,:,:,:)
5303
5304 integer, pointer:: array_avr_work5(:,:,:,:,:,:,:)
5305
5306 integer, pointer:: array_avr_work6(:,:,:,:,:,:,:)
5307
5308 integer, pointer:: array_avr_work7(:,:,:,:,:,:,:)
5309
5310
5311 integer:: array_shape(7)
5312 integer:: i, dim_size
5313 real(DP):: weight_sum
5314 continue
5315
5316 array_shape = shape( array )
5317 array_avr_work => array
5318
5319
5320
5321
5322 if ( space_average(1) ) then
5323 dim_size = array_shape(1)
5324 array_shape(1) = 1
5325 allocate( array_avr_work1( array_shape(1) &
5326 & , array_shape(2) &
5327
5328 & , array_shape(3) &
5329
5330 & , array_shape(4) &
5331
5332 & , array_shape(5) &
5333
5334 & , array_shape(6) &
5335
5336 & , array_shape(7) &
5337
5338 & ) )
5339 array_avr_work1 = 0
5340 weight_sum = 0.0_dp
5341 do i = 1, dim_size
5342 array_avr_work1(1,:,:,:,:,:,:) = int( &
5343 & real(array_avr_work1(1,:,:,:,:,:,:), kind=dp) + &
5344 & real(array_avr_work(i,:,:,:,:,:,:), kind=dp) * weight1(i), &
5345 & kind=kind(array_avr_work1) )
5346 weight_sum = weight_sum + weight1(i)
5347 end do
5348 array_avr_work1 = int( &
5349 & real(array_avr_work1, kind=dp) / weight_sum, &
5350 & kind=kind(array_avr_work1) )
5351 array_avr_work => array_avr_work1
5352 end if
5353
5354
5355
5356 if ( space_average(2) ) then
5357 dim_size = array_shape(2)
5358 array_shape(2) = 1
5359 allocate( array_avr_work2( array_shape(1) &
5360 & , array_shape(2) &
5361
5362 & , array_shape(3) &
5363
5364 & , array_shape(4) &
5365
5366 & , array_shape(5) &
5367
5368 & , array_shape(6) &
5369
5370 & , array_shape(7) &
5371
5372 & ) )
5373 array_avr_work2 = 0
5374 weight_sum = 0.0_dp
5375 do i = 1, dim_size
5376 array_avr_work2(:,1,:,:,:,:,:) = int( &
5377 & real(array_avr_work2(:,1,:,:,:,:,:), kind=dp) + &
5378 & real(array_avr_work(:,i,:,:,:,:,:), kind=dp) * weight2(i), &
5379 & kind=kind(array_avr_work2) )
5380 weight_sum = weight_sum + weight2(i)
5381 end do
5382 array_avr_work2 = int( &
5383 & real(array_avr_work2, kind=dp) / weight_sum, &
5384 & kind=kind(array_avr_work2) )
5385 array_avr_work => array_avr_work2
5386 end if
5387
5388
5389
5390 if ( space_average(3) ) then
5391 dim_size = array_shape(3)
5392 array_shape(3) = 1
5393 allocate( array_avr_work3( array_shape(1) &
5394 & , array_shape(2) &
5395
5396 & , array_shape(3) &
5397
5398 & , array_shape(4) &
5399
5400 & , array_shape(5) &
5401
5402 & , array_shape(6) &
5403
5404 & , array_shape(7) &
5405
5406 & ) )
5407 array_avr_work3 = 0
5408 weight_sum = 0.0_dp
5409 do i = 1, dim_size
5410 array_avr_work3(:,:,1,:,:,:,:) = int( &
5411 & real(array_avr_work3(:,:,1,:,:,:,:), kind=dp) + &
5412 & real(array_avr_work(:,:,i,:,:,:,:), kind=dp) * weight3(i), &
5413 & kind=kind(array_avr_work3) )
5414 weight_sum = weight_sum + weight3(i)
5415 end do
5416 array_avr_work3 = int( &
5417 & real(array_avr_work3, kind=dp) / weight_sum, &
5418 & kind=kind(array_avr_work3) )
5419 array_avr_work => array_avr_work3
5420 end if
5421
5422
5423
5424 if ( space_average(4) ) then
5425 dim_size = array_shape(4)
5426 array_shape(4) = 1
5427 allocate( array_avr_work4( array_shape(1) &
5428 & , array_shape(2) &
5429
5430 & , array_shape(3) &
5431
5432 & , array_shape(4) &
5433
5434 & , array_shape(5) &
5435
5436 & , array_shape(6) &
5437
5438 & , array_shape(7) &
5439
5440 & ) )
5441 array_avr_work4 = 0
5442 weight_sum = 0.0_dp
5443 do i = 1, dim_size
5444 array_avr_work4(:,:,:,1,:,:,:) = int( &
5445 & real(array_avr_work4(:,:,:,1,:,:,:), kind=dp) + &
5446 & real(array_avr_work(:,:,:,i,:,:,:), kind=dp) * weight4(i), &
5447 & kind=kind(array_avr_work4) )
5448 weight_sum = weight_sum + weight4(i)
5449 end do
5450 array_avr_work4 = int( &
5451 & real(array_avr_work4, kind=dp) / weight_sum, &
5452 & kind=kind(array_avr_work4) )
5453 array_avr_work => array_avr_work4
5454 end if
5455
5456
5457
5458 if ( space_average(5) ) then
5459 dim_size = array_shape(5)
5460 array_shape(5) = 1
5461 allocate( array_avr_work5( array_shape(1) &
5462 & , array_shape(2) &
5463
5464 & , array_shape(3) &
5465
5466 & , array_shape(4) &
5467
5468 & , array_shape(5) &
5469
5470 & , array_shape(6) &
5471
5472 & , array_shape(7) &
5473
5474 & ) )
5475 array_avr_work5 = 0
5476 weight_sum = 0.0_dp
5477 do i = 1, dim_size
5478 array_avr_work5(:,:,:,:,1,:,:) = int( &
5479 & real(array_avr_work5(:,:,:,:,1,:,:), kind=dp) + &
5480 & real(array_avr_work(:,:,:,:,i,:,:), kind=dp) * weight5(i), &
5481 & kind=kind(array_avr_work5) )
5482 weight_sum = weight_sum + weight5(i)
5483 end do
5484 array_avr_work5 = int( &
5485 & real(array_avr_work5, kind=dp) / weight_sum, &
5486 & kind=kind(array_avr_work5) )
5487 array_avr_work => array_avr_work5
5488 end if
5489
5490
5491
5492 if ( space_average(6) ) then
5493 dim_size = array_shape(6)
5494 array_shape(6) = 1
5495 allocate( array_avr_work6( array_shape(1) &
5496 & , array_shape(2) &
5497
5498 & , array_shape(3) &
5499
5500 & , array_shape(4) &
5501
5502 & , array_shape(5) &
5503
5504 & , array_shape(6) &
5505
5506 & , array_shape(7) &
5507
5508 & ) )
5509 array_avr_work6 = 0
5510 weight_sum = 0.0_dp
5511 do i = 1, dim_size
5512 array_avr_work6(:,:,:,:,:,1,:) = int( &
5513 & real(array_avr_work6(:,:,:,:,:,1,:), kind=dp) + &
5514 & real(array_avr_work(:,:,:,:,:,i,:), kind=dp) * weight6(i), &
5515 & kind=kind(array_avr_work6) )
5516 weight_sum = weight_sum + weight6(i)
5517 end do
5518 array_avr_work6 = int( &
5519 & real(array_avr_work6, kind=dp) / weight_sum, &
5520 & kind=kind(array_avr_work6) )
5521 array_avr_work => array_avr_work6
5522 end if
5523
5524
5525
5526 if ( space_average(7) ) then
5527 dim_size = array_shape(7)
5528 array_shape(7) = 1
5529 allocate( array_avr_work7( array_shape(1) &
5530 & , array_shape(2) &
5531
5532 & , array_shape(3) &
5533
5534 & , array_shape(4) &
5535
5536 & , array_shape(5) &
5537
5538 & , array_shape(6) &
5539
5540 & , array_shape(7) &
5541
5542 & ) )
5543 array_avr_work7 = 0
5544 weight_sum = 0.0_dp
5545 do i = 1, dim_size
5546 array_avr_work7(:,:,:,:,:,:,1) = int( &
5547 & real(array_avr_work7(:,:,:,:,:,:,1), kind=dp) + &
5548 & real(array_avr_work(:,:,:,:,:,:,i), kind=dp) * weight7(i), &
5549 & kind=kind(array_avr_work7) )
5550 weight_sum = weight_sum + weight7(i)
5551 end do
5552 array_avr_work7 = int( &
5553 & real(array_avr_work7, kind=dp) / weight_sum, &
5554 & kind=kind(array_avr_work7) )
5555 array_avr_work => array_avr_work7
5556 end if
5557
5558
5559
5560
5561
5562
5563
5564 allocate( array_avr( array_shape(1) &
5565 & , array_shape(2) &
5566
5567 & , array_shape(3) &
5568
5569 & , array_shape(4) &
5570
5571 & , array_shape(5) &
5572
5573 & , array_shape(6) &
5574
5575 & , array_shape(7) &
5576
5577 & ) )
5578
5579 array_avr = array_avr_work
5580
5581 nullify( array_avr_work )
5582
5583 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
5584
5585 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
5586
5587 if ( associated( array_avr_work3 ) ) deallocate( array_avr_work3 )
5588
5589 if ( associated( array_avr_work4 ) ) deallocate( array_avr_work4 )
5590
5591 if ( associated( array_avr_work5 ) ) deallocate( array_avr_work5 )
5592
5593 if ( associated( array_avr_work6 ) ) deallocate( array_avr_work6 )
5594
5595 if ( associated( array_avr_work7 ) ) deallocate( array_avr_work7 )
5596
5597

◆ averagereducereal1()

subroutine gtool_historyauto_internal::averagereduce::averagereducereal1 ( real, dimension(:), intent(in), target  array,
logical, dimension(1), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real, dimension(:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 1143 of file gtool_historyauto_internal.f90.

1149 implicit none
1150 real, intent(in), target:: array(:)
1151 logical, intent(in):: space_average(1)
1152 real(DP), intent(in):: weight1(:)
1153
1154 real, pointer:: array_avr(:) ! (out)
1155
1156 real, pointer:: array_avr_work(:)
1157
1158 real, pointer:: array_avr_work1(:)
1159
1160
1161 integer:: array_shape(1)
1162 integer:: i, dim_size
1163 real(DP):: weight_sum
1164 continue
1165
1166 array_shape = shape( array )
1167 array_avr_work => array
1168
1169
1170
1171
1172 if ( space_average(1) ) then
1173 dim_size = array_shape(1)
1174 array_shape(1) = 1
1175 allocate( array_avr_work1( array_shape(1) &
1176
1177 & ) )
1178 array_avr_work1 = 0.0
1179 weight_sum = 0.0_dp
1180 do i = 1, dim_size
1181 array_avr_work1(1) = array_avr_work1(1) + &
1182 & array_avr_work(i) * real(weight1(i), kind=kind(array_avr_work1))
1183 weight_sum = weight_sum + weight1(i)
1184 end do
1185 array_avr_work1 = array_avr_work1 / &
1186 & real(weight_sum, kind=kind(array_avr_work1))
1187 array_avr_work => array_avr_work1
1188 end if
1189
1190
1191
1192
1193
1194
1195
1196 allocate( array_avr( array_shape(1) &
1197
1198 & ) )
1199
1200 array_avr = array_avr_work
1201
1202 nullify( array_avr_work )
1203
1204 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
1205
1206

◆ averagereducereal2()

subroutine gtool_historyauto_internal::averagereduce::averagereducereal2 ( real, dimension(:,:), intent(in), target  array,
logical, dimension(2), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
real, dimension(:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 1238 of file gtool_historyauto_internal.f90.

1246 implicit none
1247 real, intent(in), target:: array(:,:)
1248 logical, intent(in):: space_average(2)
1249 real(DP), intent(in):: weight1(:)
1250
1251 real(DP), intent(in):: weight2(:)
1252
1253 real, pointer:: array_avr(:,:) ! (out)
1254
1255 real, pointer:: array_avr_work(:,:)
1256
1257 real, pointer:: array_avr_work1(:,:)
1258
1259 real, pointer:: array_avr_work2(:,:)
1260
1261
1262 integer:: array_shape(2)
1263 integer:: i, dim_size
1264 real(DP):: weight_sum
1265 continue
1266
1267 array_shape = shape( array )
1268 array_avr_work => array
1269
1270
1271
1272
1273 if ( space_average(1) ) then
1274 dim_size = array_shape(1)
1275 array_shape(1) = 1
1276 allocate( array_avr_work1( array_shape(1) &
1277 & , array_shape(2) &
1278
1279 & ) )
1280 array_avr_work1 = 0.0
1281 weight_sum = 0.0_dp
1282 do i = 1, dim_size
1283 array_avr_work1(1,:) = array_avr_work1(1,:) + &
1284 & array_avr_work(i,:) * real(weight1(i), kind=kind(array_avr_work1))
1285 weight_sum = weight_sum + weight1(i)
1286 end do
1287 array_avr_work1 = array_avr_work1 / &
1288 & real(weight_sum, kind=kind(array_avr_work1))
1289 array_avr_work => array_avr_work1
1290 end if
1291
1292
1293
1294 if ( space_average(2) ) then
1295 dim_size = array_shape(2)
1296 array_shape(2) = 1
1297 allocate( array_avr_work2( array_shape(1) &
1298 & , array_shape(2) &
1299
1300 & ) )
1301 array_avr_work2 = 0.0
1302 weight_sum = 0.0_dp
1303 do i = 1, dim_size
1304 array_avr_work2(:,1) = array_avr_work2(:,1) + &
1305 & array_avr_work(:,i) * real(weight2(i), kind=kind(array_avr_work2))
1306 weight_sum = weight_sum + weight2(i)
1307 end do
1308 array_avr_work2 = array_avr_work2 / &
1309 & real(weight_sum, kind=kind(array_avr_work2))
1310 array_avr_work => array_avr_work2
1311 end if
1312
1313
1314
1315
1316
1317
1318
1319 allocate( array_avr( array_shape(1) &
1320 & , array_shape(2) &
1321
1322 & ) )
1323
1324 array_avr = array_avr_work
1325
1326 nullify( array_avr_work )
1327
1328 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
1329
1330 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
1331
1332

◆ averagereducereal3()

subroutine gtool_historyauto_internal::averagereduce::averagereducereal3 ( real, dimension(:,:,:), intent(in), target  array,
logical, dimension(3), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
real(dp), dimension(:), intent(in)  weight3,
real, dimension(:,:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 1364 of file gtool_historyauto_internal.f90.

1374 implicit none
1375 real, intent(in), target:: array(:,:,:)
1376 logical, intent(in):: space_average(3)
1377 real(DP), intent(in):: weight1(:)
1378
1379 real(DP), intent(in):: weight2(:)
1380
1381 real(DP), intent(in):: weight3(:)
1382
1383 real, pointer:: array_avr(:,:,:) ! (out)
1384
1385 real, pointer:: array_avr_work(:,:,:)
1386
1387 real, pointer:: array_avr_work1(:,:,:)
1388
1389 real, pointer:: array_avr_work2(:,:,:)
1390
1391 real, pointer:: array_avr_work3(:,:,:)
1392
1393
1394 integer:: array_shape(3)
1395 integer:: i, dim_size
1396 real(DP):: weight_sum
1397 continue
1398
1399 array_shape = shape( array )
1400 array_avr_work => array
1401
1402
1403
1404
1405 if ( space_average(1) ) then
1406 dim_size = array_shape(1)
1407 array_shape(1) = 1
1408 allocate( array_avr_work1( array_shape(1) &
1409 & , array_shape(2) &
1410
1411 & , array_shape(3) &
1412
1413 & ) )
1414 array_avr_work1 = 0.0
1415 weight_sum = 0.0_dp
1416 do i = 1, dim_size
1417 array_avr_work1(1,:,:) = array_avr_work1(1,:,:) + &
1418 & array_avr_work(i,:,:) * real(weight1(i), kind=kind(array_avr_work1))
1419 weight_sum = weight_sum + weight1(i)
1420 end do
1421 array_avr_work1 = array_avr_work1 / &
1422 & real(weight_sum, kind=kind(array_avr_work1))
1423 array_avr_work => array_avr_work1
1424 end if
1425
1426
1427
1428 if ( space_average(2) ) then
1429 dim_size = array_shape(2)
1430 array_shape(2) = 1
1431 allocate( array_avr_work2( array_shape(1) &
1432 & , array_shape(2) &
1433
1434 & , array_shape(3) &
1435
1436 & ) )
1437 array_avr_work2 = 0.0
1438 weight_sum = 0.0_dp
1439 do i = 1, dim_size
1440 array_avr_work2(:,1,:) = array_avr_work2(:,1,:) + &
1441 & array_avr_work(:,i,:) * real(weight2(i), kind=kind(array_avr_work2))
1442 weight_sum = weight_sum + weight2(i)
1443 end do
1444 array_avr_work2 = array_avr_work2 / &
1445 & real(weight_sum, kind=kind(array_avr_work2))
1446 array_avr_work => array_avr_work2
1447 end if
1448
1449
1450
1451 if ( space_average(3) ) then
1452 dim_size = array_shape(3)
1453 array_shape(3) = 1
1454 allocate( array_avr_work3( array_shape(1) &
1455 & , array_shape(2) &
1456
1457 & , array_shape(3) &
1458
1459 & ) )
1460 array_avr_work3 = 0.0
1461 weight_sum = 0.0_dp
1462 do i = 1, dim_size
1463 array_avr_work3(:,:,1) = array_avr_work3(:,:,1) + &
1464 & array_avr_work(:,:,i) * real(weight3(i), kind=kind(array_avr_work3))
1465 weight_sum = weight_sum + weight3(i)
1466 end do
1467 array_avr_work3 = array_avr_work3 / &
1468 & real(weight_sum, kind=kind(array_avr_work3))
1469 array_avr_work => array_avr_work3
1470 end if
1471
1472
1473
1474
1475
1476
1477
1478 allocate( array_avr( array_shape(1) &
1479 & , array_shape(2) &
1480
1481 & , array_shape(3) &
1482
1483 & ) )
1484
1485 array_avr = array_avr_work
1486
1487 nullify( array_avr_work )
1488
1489 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
1490
1491 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
1492
1493 if ( associated( array_avr_work3 ) ) deallocate( array_avr_work3 )
1494
1495

◆ averagereducereal4()

subroutine gtool_historyauto_internal::averagereduce::averagereducereal4 ( real, dimension(:,:,:,:), intent(in), target  array,
logical, dimension(4), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
real(dp), dimension(:), intent(in)  weight3,
real(dp), dimension(:), intent(in)  weight4,
real, dimension(:,:,:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 1527 of file gtool_historyauto_internal.f90.

1539 implicit none
1540 real, intent(in), target:: array(:,:,:,:)
1541 logical, intent(in):: space_average(4)
1542 real(DP), intent(in):: weight1(:)
1543
1544 real(DP), intent(in):: weight2(:)
1545
1546 real(DP), intent(in):: weight3(:)
1547
1548 real(DP), intent(in):: weight4(:)
1549
1550 real, pointer:: array_avr(:,:,:,:) ! (out)
1551
1552 real, pointer:: array_avr_work(:,:,:,:)
1553
1554 real, pointer:: array_avr_work1(:,:,:,:)
1555
1556 real, pointer:: array_avr_work2(:,:,:,:)
1557
1558 real, pointer:: array_avr_work3(:,:,:,:)
1559
1560 real, pointer:: array_avr_work4(:,:,:,:)
1561
1562
1563 integer:: array_shape(4)
1564 integer:: i, dim_size
1565 real(DP):: weight_sum
1566 continue
1567
1568 array_shape = shape( array )
1569 array_avr_work => array
1570
1571
1572
1573
1574 if ( space_average(1) ) then
1575 dim_size = array_shape(1)
1576 array_shape(1) = 1
1577 allocate( array_avr_work1( array_shape(1) &
1578 & , array_shape(2) &
1579
1580 & , array_shape(3) &
1581
1582 & , array_shape(4) &
1583
1584 & ) )
1585 array_avr_work1 = 0.0
1586 weight_sum = 0.0_dp
1587 do i = 1, dim_size
1588 array_avr_work1(1,:,:,:) = array_avr_work1(1,:,:,:) + &
1589 & array_avr_work(i,:,:,:) * real(weight1(i), kind=kind(array_avr_work1))
1590 weight_sum = weight_sum + weight1(i)
1591 end do
1592 array_avr_work1 = array_avr_work1 / &
1593 & real(weight_sum, kind=kind(array_avr_work1))
1594 array_avr_work => array_avr_work1
1595 end if
1596
1597
1598
1599 if ( space_average(2) ) then
1600 dim_size = array_shape(2)
1601 array_shape(2) = 1
1602 allocate( array_avr_work2( array_shape(1) &
1603 & , array_shape(2) &
1604
1605 & , array_shape(3) &
1606
1607 & , array_shape(4) &
1608
1609 & ) )
1610 array_avr_work2 = 0.0
1611 weight_sum = 0.0_dp
1612 do i = 1, dim_size
1613 array_avr_work2(:,1,:,:) = array_avr_work2(:,1,:,:) + &
1614 & array_avr_work(:,i,:,:) * real(weight2(i), kind=kind(array_avr_work2))
1615 weight_sum = weight_sum + weight2(i)
1616 end do
1617 array_avr_work2 = array_avr_work2 / &
1618 & real(weight_sum, kind=kind(array_avr_work2))
1619 array_avr_work => array_avr_work2
1620 end if
1621
1622
1623
1624 if ( space_average(3) ) then
1625 dim_size = array_shape(3)
1626 array_shape(3) = 1
1627 allocate( array_avr_work3( array_shape(1) &
1628 & , array_shape(2) &
1629
1630 & , array_shape(3) &
1631
1632 & , array_shape(4) &
1633
1634 & ) )
1635 array_avr_work3 = 0.0
1636 weight_sum = 0.0_dp
1637 do i = 1, dim_size
1638 array_avr_work3(:,:,1,:) = array_avr_work3(:,:,1,:) + &
1639 & array_avr_work(:,:,i,:) * real(weight3(i), kind=kind(array_avr_work3))
1640 weight_sum = weight_sum + weight3(i)
1641 end do
1642 array_avr_work3 = array_avr_work3 / &
1643 & real(weight_sum, kind=kind(array_avr_work3))
1644 array_avr_work => array_avr_work3
1645 end if
1646
1647
1648
1649 if ( space_average(4) ) then
1650 dim_size = array_shape(4)
1651 array_shape(4) = 1
1652 allocate( array_avr_work4( array_shape(1) &
1653 & , array_shape(2) &
1654
1655 & , array_shape(3) &
1656
1657 & , array_shape(4) &
1658
1659 & ) )
1660 array_avr_work4 = 0.0
1661 weight_sum = 0.0_dp
1662 do i = 1, dim_size
1663 array_avr_work4(:,:,:,1) = array_avr_work4(:,:,:,1) + &
1664 & array_avr_work(:,:,:,i) * real(weight4(i), kind=kind(array_avr_work4))
1665 weight_sum = weight_sum + weight4(i)
1666 end do
1667 array_avr_work4 = array_avr_work4 / &
1668 & real(weight_sum, kind=kind(array_avr_work4))
1669 array_avr_work => array_avr_work4
1670 end if
1671
1672
1673
1674
1675
1676
1677
1678 allocate( array_avr( array_shape(1) &
1679 & , array_shape(2) &
1680
1681 & , array_shape(3) &
1682
1683 & , array_shape(4) &
1684
1685 & ) )
1686
1687 array_avr = array_avr_work
1688
1689 nullify( array_avr_work )
1690
1691 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
1692
1693 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
1694
1695 if ( associated( array_avr_work3 ) ) deallocate( array_avr_work3 )
1696
1697 if ( associated( array_avr_work4 ) ) deallocate( array_avr_work4 )
1698
1699

◆ averagereducereal5()

subroutine gtool_historyauto_internal::averagereduce::averagereducereal5 ( real, dimension(:,:,:,:,:), intent(in), target  array,
logical, dimension(5), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
real(dp), dimension(:), intent(in)  weight3,
real(dp), dimension(:), intent(in)  weight4,
real(dp), dimension(:), intent(in)  weight5,
real, dimension(:,:,:,:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 1731 of file gtool_historyauto_internal.f90.

1745 implicit none
1746 real, intent(in), target:: array(:,:,:,:,:)
1747 logical, intent(in):: space_average(5)
1748 real(DP), intent(in):: weight1(:)
1749
1750 real(DP), intent(in):: weight2(:)
1751
1752 real(DP), intent(in):: weight3(:)
1753
1754 real(DP), intent(in):: weight4(:)
1755
1756 real(DP), intent(in):: weight5(:)
1757
1758 real, pointer:: array_avr(:,:,:,:,:) ! (out)
1759
1760 real, pointer:: array_avr_work(:,:,:,:,:)
1761
1762 real, pointer:: array_avr_work1(:,:,:,:,:)
1763
1764 real, pointer:: array_avr_work2(:,:,:,:,:)
1765
1766 real, pointer:: array_avr_work3(:,:,:,:,:)
1767
1768 real, pointer:: array_avr_work4(:,:,:,:,:)
1769
1770 real, pointer:: array_avr_work5(:,:,:,:,:)
1771
1772
1773 integer:: array_shape(5)
1774 integer:: i, dim_size
1775 real(DP):: weight_sum
1776 continue
1777
1778 array_shape = shape( array )
1779 array_avr_work => array
1780
1781
1782
1783
1784 if ( space_average(1) ) then
1785 dim_size = array_shape(1)
1786 array_shape(1) = 1
1787 allocate( array_avr_work1( array_shape(1) &
1788 & , array_shape(2) &
1789
1790 & , array_shape(3) &
1791
1792 & , array_shape(4) &
1793
1794 & , array_shape(5) &
1795
1796 & ) )
1797 array_avr_work1 = 0.0
1798 weight_sum = 0.0_dp
1799 do i = 1, dim_size
1800 array_avr_work1(1,:,:,:,:) = array_avr_work1(1,:,:,:,:) + &
1801 & array_avr_work(i,:,:,:,:) * real(weight1(i), kind=kind(array_avr_work1))
1802 weight_sum = weight_sum + weight1(i)
1803 end do
1804 array_avr_work1 = array_avr_work1 / &
1805 & real(weight_sum, kind=kind(array_avr_work1))
1806 array_avr_work => array_avr_work1
1807 end if
1808
1809
1810
1811 if ( space_average(2) ) then
1812 dim_size = array_shape(2)
1813 array_shape(2) = 1
1814 allocate( array_avr_work2( array_shape(1) &
1815 & , array_shape(2) &
1816
1817 & , array_shape(3) &
1818
1819 & , array_shape(4) &
1820
1821 & , array_shape(5) &
1822
1823 & ) )
1824 array_avr_work2 = 0.0
1825 weight_sum = 0.0_dp
1826 do i = 1, dim_size
1827 array_avr_work2(:,1,:,:,:) = array_avr_work2(:,1,:,:,:) + &
1828 & array_avr_work(:,i,:,:,:) * real(weight2(i), kind=kind(array_avr_work2))
1829 weight_sum = weight_sum + weight2(i)
1830 end do
1831 array_avr_work2 = array_avr_work2 / &
1832 & real(weight_sum, kind=kind(array_avr_work2))
1833 array_avr_work => array_avr_work2
1834 end if
1835
1836
1837
1838 if ( space_average(3) ) then
1839 dim_size = array_shape(3)
1840 array_shape(3) = 1
1841 allocate( array_avr_work3( array_shape(1) &
1842 & , array_shape(2) &
1843
1844 & , array_shape(3) &
1845
1846 & , array_shape(4) &
1847
1848 & , array_shape(5) &
1849
1850 & ) )
1851 array_avr_work3 = 0.0
1852 weight_sum = 0.0_dp
1853 do i = 1, dim_size
1854 array_avr_work3(:,:,1,:,:) = array_avr_work3(:,:,1,:,:) + &
1855 & array_avr_work(:,:,i,:,:) * real(weight3(i), kind=kind(array_avr_work3))
1856 weight_sum = weight_sum + weight3(i)
1857 end do
1858 array_avr_work3 = array_avr_work3 / &
1859 & real(weight_sum, kind=kind(array_avr_work3))
1860 array_avr_work => array_avr_work3
1861 end if
1862
1863
1864
1865 if ( space_average(4) ) then
1866 dim_size = array_shape(4)
1867 array_shape(4) = 1
1868 allocate( array_avr_work4( array_shape(1) &
1869 & , array_shape(2) &
1870
1871 & , array_shape(3) &
1872
1873 & , array_shape(4) &
1874
1875 & , array_shape(5) &
1876
1877 & ) )
1878 array_avr_work4 = 0.0
1879 weight_sum = 0.0_dp
1880 do i = 1, dim_size
1881 array_avr_work4(:,:,:,1,:) = array_avr_work4(:,:,:,1,:) + &
1882 & array_avr_work(:,:,:,i,:) * real(weight4(i), kind=kind(array_avr_work4))
1883 weight_sum = weight_sum + weight4(i)
1884 end do
1885 array_avr_work4 = array_avr_work4 / &
1886 & real(weight_sum, kind=kind(array_avr_work4))
1887 array_avr_work => array_avr_work4
1888 end if
1889
1890
1891
1892 if ( space_average(5) ) then
1893 dim_size = array_shape(5)
1894 array_shape(5) = 1
1895 allocate( array_avr_work5( array_shape(1) &
1896 & , array_shape(2) &
1897
1898 & , array_shape(3) &
1899
1900 & , array_shape(4) &
1901
1902 & , array_shape(5) &
1903
1904 & ) )
1905 array_avr_work5 = 0.0
1906 weight_sum = 0.0_dp
1907 do i = 1, dim_size
1908 array_avr_work5(:,:,:,:,1) = array_avr_work5(:,:,:,:,1) + &
1909 & array_avr_work(:,:,:,:,i) * real(weight5(i), kind=kind(array_avr_work5))
1910 weight_sum = weight_sum + weight5(i)
1911 end do
1912 array_avr_work5 = array_avr_work5 / &
1913 & real(weight_sum, kind=kind(array_avr_work5))
1914 array_avr_work => array_avr_work5
1915 end if
1916
1917
1918
1919
1920
1921
1922
1923 allocate( array_avr( array_shape(1) &
1924 & , array_shape(2) &
1925
1926 & , array_shape(3) &
1927
1928 & , array_shape(4) &
1929
1930 & , array_shape(5) &
1931
1932 & ) )
1933
1934 array_avr = array_avr_work
1935
1936 nullify( array_avr_work )
1937
1938 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
1939
1940 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
1941
1942 if ( associated( array_avr_work3 ) ) deallocate( array_avr_work3 )
1943
1944 if ( associated( array_avr_work4 ) ) deallocate( array_avr_work4 )
1945
1946 if ( associated( array_avr_work5 ) ) deallocate( array_avr_work5 )
1947
1948

◆ averagereducereal6()

subroutine gtool_historyauto_internal::averagereduce::averagereducereal6 ( real, dimension(:,:,:,:,:,:), intent(in), target  array,
logical, dimension(6), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
real(dp), dimension(:), intent(in)  weight3,
real(dp), dimension(:), intent(in)  weight4,
real(dp), dimension(:), intent(in)  weight5,
real(dp), dimension(:), intent(in)  weight6,
real, dimension(:,:,:,:,:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 1980 of file gtool_historyauto_internal.f90.

1996 implicit none
1997 real, intent(in), target:: array(:,:,:,:,:,:)
1998 logical, intent(in):: space_average(6)
1999 real(DP), intent(in):: weight1(:)
2000
2001 real(DP), intent(in):: weight2(:)
2002
2003 real(DP), intent(in):: weight3(:)
2004
2005 real(DP), intent(in):: weight4(:)
2006
2007 real(DP), intent(in):: weight5(:)
2008
2009 real(DP), intent(in):: weight6(:)
2010
2011 real, pointer:: array_avr(:,:,:,:,:,:) ! (out)
2012
2013 real, pointer:: array_avr_work(:,:,:,:,:,:)
2014
2015 real, pointer:: array_avr_work1(:,:,:,:,:,:)
2016
2017 real, pointer:: array_avr_work2(:,:,:,:,:,:)
2018
2019 real, pointer:: array_avr_work3(:,:,:,:,:,:)
2020
2021 real, pointer:: array_avr_work4(:,:,:,:,:,:)
2022
2023 real, pointer:: array_avr_work5(:,:,:,:,:,:)
2024
2025 real, pointer:: array_avr_work6(:,:,:,:,:,:)
2026
2027
2028 integer:: array_shape(6)
2029 integer:: i, dim_size
2030 real(DP):: weight_sum
2031 continue
2032
2033 array_shape = shape( array )
2034 array_avr_work => array
2035
2036
2037
2038
2039 if ( space_average(1) ) then
2040 dim_size = array_shape(1)
2041 array_shape(1) = 1
2042 allocate( array_avr_work1( array_shape(1) &
2043 & , array_shape(2) &
2044
2045 & , array_shape(3) &
2046
2047 & , array_shape(4) &
2048
2049 & , array_shape(5) &
2050
2051 & , array_shape(6) &
2052
2053 & ) )
2054 array_avr_work1 = 0.0
2055 weight_sum = 0.0_dp
2056 do i = 1, dim_size
2057 array_avr_work1(1,:,:,:,:,:) = array_avr_work1(1,:,:,:,:,:) + &
2058 & array_avr_work(i,:,:,:,:,:) * real(weight1(i), kind=kind(array_avr_work1))
2059 weight_sum = weight_sum + weight1(i)
2060 end do
2061 array_avr_work1 = array_avr_work1 / &
2062 & real(weight_sum, kind=kind(array_avr_work1))
2063 array_avr_work => array_avr_work1
2064 end if
2065
2066
2067
2068 if ( space_average(2) ) then
2069 dim_size = array_shape(2)
2070 array_shape(2) = 1
2071 allocate( array_avr_work2( array_shape(1) &
2072 & , array_shape(2) &
2073
2074 & , array_shape(3) &
2075
2076 & , array_shape(4) &
2077
2078 & , array_shape(5) &
2079
2080 & , array_shape(6) &
2081
2082 & ) )
2083 array_avr_work2 = 0.0
2084 weight_sum = 0.0_dp
2085 do i = 1, dim_size
2086 array_avr_work2(:,1,:,:,:,:) = array_avr_work2(:,1,:,:,:,:) + &
2087 & array_avr_work(:,i,:,:,:,:) * real(weight2(i), kind=kind(array_avr_work2))
2088 weight_sum = weight_sum + weight2(i)
2089 end do
2090 array_avr_work2 = array_avr_work2 / &
2091 & real(weight_sum, kind=kind(array_avr_work2))
2092 array_avr_work => array_avr_work2
2093 end if
2094
2095
2096
2097 if ( space_average(3) ) then
2098 dim_size = array_shape(3)
2099 array_shape(3) = 1
2100 allocate( array_avr_work3( array_shape(1) &
2101 & , array_shape(2) &
2102
2103 & , array_shape(3) &
2104
2105 & , array_shape(4) &
2106
2107 & , array_shape(5) &
2108
2109 & , array_shape(6) &
2110
2111 & ) )
2112 array_avr_work3 = 0.0
2113 weight_sum = 0.0_dp
2114 do i = 1, dim_size
2115 array_avr_work3(:,:,1,:,:,:) = array_avr_work3(:,:,1,:,:,:) + &
2116 & array_avr_work(:,:,i,:,:,:) * real(weight3(i), kind=kind(array_avr_work3))
2117 weight_sum = weight_sum + weight3(i)
2118 end do
2119 array_avr_work3 = array_avr_work3 / &
2120 & real(weight_sum, kind=kind(array_avr_work3))
2121 array_avr_work => array_avr_work3
2122 end if
2123
2124
2125
2126 if ( space_average(4) ) then
2127 dim_size = array_shape(4)
2128 array_shape(4) = 1
2129 allocate( array_avr_work4( array_shape(1) &
2130 & , array_shape(2) &
2131
2132 & , array_shape(3) &
2133
2134 & , array_shape(4) &
2135
2136 & , array_shape(5) &
2137
2138 & , array_shape(6) &
2139
2140 & ) )
2141 array_avr_work4 = 0.0
2142 weight_sum = 0.0_dp
2143 do i = 1, dim_size
2144 array_avr_work4(:,:,:,1,:,:) = array_avr_work4(:,:,:,1,:,:) + &
2145 & array_avr_work(:,:,:,i,:,:) * real(weight4(i), kind=kind(array_avr_work4))
2146 weight_sum = weight_sum + weight4(i)
2147 end do
2148 array_avr_work4 = array_avr_work4 / &
2149 & real(weight_sum, kind=kind(array_avr_work4))
2150 array_avr_work => array_avr_work4
2151 end if
2152
2153
2154
2155 if ( space_average(5) ) then
2156 dim_size = array_shape(5)
2157 array_shape(5) = 1
2158 allocate( array_avr_work5( array_shape(1) &
2159 & , array_shape(2) &
2160
2161 & , array_shape(3) &
2162
2163 & , array_shape(4) &
2164
2165 & , array_shape(5) &
2166
2167 & , array_shape(6) &
2168
2169 & ) )
2170 array_avr_work5 = 0.0
2171 weight_sum = 0.0_dp
2172 do i = 1, dim_size
2173 array_avr_work5(:,:,:,:,1,:) = array_avr_work5(:,:,:,:,1,:) + &
2174 & array_avr_work(:,:,:,:,i,:) * real(weight5(i), kind=kind(array_avr_work5))
2175 weight_sum = weight_sum + weight5(i)
2176 end do
2177 array_avr_work5 = array_avr_work5 / &
2178 & real(weight_sum, kind=kind(array_avr_work5))
2179 array_avr_work => array_avr_work5
2180 end if
2181
2182
2183
2184 if ( space_average(6) ) then
2185 dim_size = array_shape(6)
2186 array_shape(6) = 1
2187 allocate( array_avr_work6( array_shape(1) &
2188 & , array_shape(2) &
2189
2190 & , array_shape(3) &
2191
2192 & , array_shape(4) &
2193
2194 & , array_shape(5) &
2195
2196 & , array_shape(6) &
2197
2198 & ) )
2199 array_avr_work6 = 0.0
2200 weight_sum = 0.0_dp
2201 do i = 1, dim_size
2202 array_avr_work6(:,:,:,:,:,1) = array_avr_work6(:,:,:,:,:,1) + &
2203 & array_avr_work(:,:,:,:,:,i) * real(weight6(i), kind=kind(array_avr_work6))
2204 weight_sum = weight_sum + weight6(i)
2205 end do
2206 array_avr_work6 = array_avr_work6 / &
2207 & real(weight_sum, kind=kind(array_avr_work6))
2208 array_avr_work => array_avr_work6
2209 end if
2210
2211
2212
2213
2214
2215
2216
2217 allocate( array_avr( array_shape(1) &
2218 & , array_shape(2) &
2219
2220 & , array_shape(3) &
2221
2222 & , array_shape(4) &
2223
2224 & , array_shape(5) &
2225
2226 & , array_shape(6) &
2227
2228 & ) )
2229
2230 array_avr = array_avr_work
2231
2232 nullify( array_avr_work )
2233
2234 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
2235
2236 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
2237
2238 if ( associated( array_avr_work3 ) ) deallocate( array_avr_work3 )
2239
2240 if ( associated( array_avr_work4 ) ) deallocate( array_avr_work4 )
2241
2242 if ( associated( array_avr_work5 ) ) deallocate( array_avr_work5 )
2243
2244 if ( associated( array_avr_work6 ) ) deallocate( array_avr_work6 )
2245
2246

◆ averagereducereal7()

subroutine gtool_historyauto_internal::averagereduce::averagereducereal7 ( real, dimension(:,:,:,:,:,:,:), intent(in), target  array,
logical, dimension(7), intent(in)  space_average,
real(dp), dimension(:), intent(in)  weight1,
real(dp), dimension(:), intent(in)  weight2,
real(dp), dimension(:), intent(in)  weight3,
real(dp), dimension(:), intent(in)  weight4,
real(dp), dimension(:), intent(in)  weight5,
real(dp), dimension(:), intent(in)  weight6,
real(dp), dimension(:), intent(in)  weight7,
real, dimension(:,:,:,:,:,:,:), pointer  array_avr 
)

Reduce array by weighted average.

Dimensions specified as .true. in space_average are averaged using weights weight1 – weight7. The number of dimensions of array_avr does not decrease. Instead, the size of averaged dimensions becomes 1.

Parameters
[in]arrayInput data array.
[in]space_averageFlags for averaging each dimension.
[in]weightWeights for averaging.
[out]array_avrAveraged output array.

Definition at line 2278 of file gtool_historyauto_internal.f90.

2296 implicit none
2297 real, intent(in), target:: array(:,:,:,:,:,:,:)
2298 logical, intent(in):: space_average(7)
2299 real(DP), intent(in):: weight1(:)
2300
2301 real(DP), intent(in):: weight2(:)
2302
2303 real(DP), intent(in):: weight3(:)
2304
2305 real(DP), intent(in):: weight4(:)
2306
2307 real(DP), intent(in):: weight5(:)
2308
2309 real(DP), intent(in):: weight6(:)
2310
2311 real(DP), intent(in):: weight7(:)
2312
2313 real, pointer:: array_avr(:,:,:,:,:,:,:) ! (out)
2314
2315 real, pointer:: array_avr_work(:,:,:,:,:,:,:)
2316
2317 real, pointer:: array_avr_work1(:,:,:,:,:,:,:)
2318
2319 real, pointer:: array_avr_work2(:,:,:,:,:,:,:)
2320
2321 real, pointer:: array_avr_work3(:,:,:,:,:,:,:)
2322
2323 real, pointer:: array_avr_work4(:,:,:,:,:,:,:)
2324
2325 real, pointer:: array_avr_work5(:,:,:,:,:,:,:)
2326
2327 real, pointer:: array_avr_work6(:,:,:,:,:,:,:)
2328
2329 real, pointer:: array_avr_work7(:,:,:,:,:,:,:)
2330
2331
2332 integer:: array_shape(7)
2333 integer:: i, dim_size
2334 real(DP):: weight_sum
2335 continue
2336
2337 array_shape = shape( array )
2338 array_avr_work => array
2339
2340
2341
2342
2343 if ( space_average(1) ) then
2344 dim_size = array_shape(1)
2345 array_shape(1) = 1
2346 allocate( array_avr_work1( array_shape(1) &
2347 & , array_shape(2) &
2348
2349 & , array_shape(3) &
2350
2351 & , array_shape(4) &
2352
2353 & , array_shape(5) &
2354
2355 & , array_shape(6) &
2356
2357 & , array_shape(7) &
2358
2359 & ) )
2360 array_avr_work1 = 0.0
2361 weight_sum = 0.0_dp
2362 do i = 1, dim_size
2363 array_avr_work1(1,:,:,:,:,:,:) = array_avr_work1(1,:,:,:,:,:,:) + &
2364 & array_avr_work(i,:,:,:,:,:,:) * real(weight1(i), kind=kind(array_avr_work1))
2365 weight_sum = weight_sum + weight1(i)
2366 end do
2367 array_avr_work1 = array_avr_work1 / &
2368 & real(weight_sum, kind=kind(array_avr_work1))
2369 array_avr_work => array_avr_work1
2370 end if
2371
2372
2373
2374 if ( space_average(2) ) then
2375 dim_size = array_shape(2)
2376 array_shape(2) = 1
2377 allocate( array_avr_work2( array_shape(1) &
2378 & , array_shape(2) &
2379
2380 & , array_shape(3) &
2381
2382 & , array_shape(4) &
2383
2384 & , array_shape(5) &
2385
2386 & , array_shape(6) &
2387
2388 & , array_shape(7) &
2389
2390 & ) )
2391 array_avr_work2 = 0.0
2392 weight_sum = 0.0_dp
2393 do i = 1, dim_size
2394 array_avr_work2(:,1,:,:,:,:,:) = array_avr_work2(:,1,:,:,:,:,:) + &
2395 & array_avr_work(:,i,:,:,:,:,:) * real(weight2(i), kind=kind(array_avr_work2))
2396 weight_sum = weight_sum + weight2(i)
2397 end do
2398 array_avr_work2 = array_avr_work2 / &
2399 & real(weight_sum, kind=kind(array_avr_work2))
2400 array_avr_work => array_avr_work2
2401 end if
2402
2403
2404
2405 if ( space_average(3) ) then
2406 dim_size = array_shape(3)
2407 array_shape(3) = 1
2408 allocate( array_avr_work3( array_shape(1) &
2409 & , array_shape(2) &
2410
2411 & , array_shape(3) &
2412
2413 & , array_shape(4) &
2414
2415 & , array_shape(5) &
2416
2417 & , array_shape(6) &
2418
2419 & , array_shape(7) &
2420
2421 & ) )
2422 array_avr_work3 = 0.0
2423 weight_sum = 0.0_dp
2424 do i = 1, dim_size
2425 array_avr_work3(:,:,1,:,:,:,:) = array_avr_work3(:,:,1,:,:,:,:) + &
2426 & array_avr_work(:,:,i,:,:,:,:) * real(weight3(i), kind=kind(array_avr_work3))
2427 weight_sum = weight_sum + weight3(i)
2428 end do
2429 array_avr_work3 = array_avr_work3 / &
2430 & real(weight_sum, kind=kind(array_avr_work3))
2431 array_avr_work => array_avr_work3
2432 end if
2433
2434
2435
2436 if ( space_average(4) ) then
2437 dim_size = array_shape(4)
2438 array_shape(4) = 1
2439 allocate( array_avr_work4( array_shape(1) &
2440 & , array_shape(2) &
2441
2442 & , array_shape(3) &
2443
2444 & , array_shape(4) &
2445
2446 & , array_shape(5) &
2447
2448 & , array_shape(6) &
2449
2450 & , array_shape(7) &
2451
2452 & ) )
2453 array_avr_work4 = 0.0
2454 weight_sum = 0.0_dp
2455 do i = 1, dim_size
2456 array_avr_work4(:,:,:,1,:,:,:) = array_avr_work4(:,:,:,1,:,:,:) + &
2457 & array_avr_work(:,:,:,i,:,:,:) * real(weight4(i), kind=kind(array_avr_work4))
2458 weight_sum = weight_sum + weight4(i)
2459 end do
2460 array_avr_work4 = array_avr_work4 / &
2461 & real(weight_sum, kind=kind(array_avr_work4))
2462 array_avr_work => array_avr_work4
2463 end if
2464
2465
2466
2467 if ( space_average(5) ) then
2468 dim_size = array_shape(5)
2469 array_shape(5) = 1
2470 allocate( array_avr_work5( array_shape(1) &
2471 & , array_shape(2) &
2472
2473 & , array_shape(3) &
2474
2475 & , array_shape(4) &
2476
2477 & , array_shape(5) &
2478
2479 & , array_shape(6) &
2480
2481 & , array_shape(7) &
2482
2483 & ) )
2484 array_avr_work5 = 0.0
2485 weight_sum = 0.0_dp
2486 do i = 1, dim_size
2487 array_avr_work5(:,:,:,:,1,:,:) = array_avr_work5(:,:,:,:,1,:,:) + &
2488 & array_avr_work(:,:,:,:,i,:,:) * real(weight5(i), kind=kind(array_avr_work5))
2489 weight_sum = weight_sum + weight5(i)
2490 end do
2491 array_avr_work5 = array_avr_work5 / &
2492 & real(weight_sum, kind=kind(array_avr_work5))
2493 array_avr_work => array_avr_work5
2494 end if
2495
2496
2497
2498 if ( space_average(6) ) then
2499 dim_size = array_shape(6)
2500 array_shape(6) = 1
2501 allocate( array_avr_work6( array_shape(1) &
2502 & , array_shape(2) &
2503
2504 & , array_shape(3) &
2505
2506 & , array_shape(4) &
2507
2508 & , array_shape(5) &
2509
2510 & , array_shape(6) &
2511
2512 & , array_shape(7) &
2513
2514 & ) )
2515 array_avr_work6 = 0.0
2516 weight_sum = 0.0_dp
2517 do i = 1, dim_size
2518 array_avr_work6(:,:,:,:,:,1,:) = array_avr_work6(:,:,:,:,:,1,:) + &
2519 & array_avr_work(:,:,:,:,:,i,:) * real(weight6(i), kind=kind(array_avr_work6))
2520 weight_sum = weight_sum + weight6(i)
2521 end do
2522 array_avr_work6 = array_avr_work6 / &
2523 & real(weight_sum, kind=kind(array_avr_work6))
2524 array_avr_work => array_avr_work6
2525 end if
2526
2527
2528
2529 if ( space_average(7) ) then
2530 dim_size = array_shape(7)
2531 array_shape(7) = 1
2532 allocate( array_avr_work7( array_shape(1) &
2533 & , array_shape(2) &
2534
2535 & , array_shape(3) &
2536
2537 & , array_shape(4) &
2538
2539 & , array_shape(5) &
2540
2541 & , array_shape(6) &
2542
2543 & , array_shape(7) &
2544
2545 & ) )
2546 array_avr_work7 = 0.0
2547 weight_sum = 0.0_dp
2548 do i = 1, dim_size
2549 array_avr_work7(:,:,:,:,:,:,1) = array_avr_work7(:,:,:,:,:,:,1) + &
2550 & array_avr_work(:,:,:,:,:,:,i) * real(weight7(i), kind=kind(array_avr_work7))
2551 weight_sum = weight_sum + weight7(i)
2552 end do
2553 array_avr_work7 = array_avr_work7 / &
2554 & real(weight_sum, kind=kind(array_avr_work7))
2555 array_avr_work => array_avr_work7
2556 end if
2557
2558
2559
2560
2561
2562
2563
2564 allocate( array_avr( array_shape(1) &
2565 & , array_shape(2) &
2566
2567 & , array_shape(3) &
2568
2569 & , array_shape(4) &
2570
2571 & , array_shape(5) &
2572
2573 & , array_shape(6) &
2574
2575 & , array_shape(7) &
2576
2577 & ) )
2578
2579 array_avr = array_avr_work
2580
2581 nullify( array_avr_work )
2582
2583 if ( associated( array_avr_work1 ) ) deallocate( array_avr_work1 )
2584
2585 if ( associated( array_avr_work2 ) ) deallocate( array_avr_work2 )
2586
2587 if ( associated( array_avr_work3 ) ) deallocate( array_avr_work3 )
2588
2589 if ( associated( array_avr_work4 ) ) deallocate( array_avr_work4 )
2590
2591 if ( associated( array_avr_work5 ) ) deallocate( array_avr_work5 )
2592
2593 if ( associated( array_avr_work6 ) ) deallocate( array_avr_work6 )
2594
2595 if ( associated( array_avr_work7 ) ) deallocate( array_avr_work7 )
2596
2597
The documentation for this interface was generated from the following file:
Generated on Fri May 29 2026 05:34:32 for gtool5 Fortran 90/95 Library by doxygen 1.9.8