    def __initialize_noise_cascades(self):
        """
        Initialize the noise cascade with identical noise for all AR(n) steps
        We also need to return the mean and standard deviations of the noise
        for the recombination of the noise before advecting it.
        """
        self.__state.precip_noise_cascades = np.zeros(
            self.__state.precip_cascades.shape
        )
        self.__state.precip_mean_noise = np.zeros(
            (self.__config.n_ens_members, self.__config.n_cascade_levels)
        )
        self.__state.precip_std_noise = np.zeros(
            (self.__config.n_ens_members, self.__config.n_cascade_levels)
        )
        if self.__config.noise_method:
            for j in range(self.__config.n_ens_members):
                epsilon = self.__params.noise_generator(
                    self.__params.perturbation_generator,
                    randstate=self.__state.randgen_precip[j],
                    fft_method=self.__params.fft_objs[j],
                    domain=self.__config.domain,
                )
                epsilon_decomposed = self.__params.decomposition_method(
                    epsilon,
                    self.__params.bandpass_filter,
                    fft_method=self.__params.fft_objs[j],
                    input_domain=self.__config.domain,
                    output_domain=self.__config.domain,
                    compute_stats=True,
                    normalize=True,
                    compact_output=True,
                )
                self.__state.precip_mean_noise[j] = epsilon_decomposed["means"]
                self.__state.precip_std_noise[j] = epsilon_decomposed["stds"]
                for i in range(self.__config.n_cascade_levels):
                    epsilon_temp = epsilon_decomposed["cascade_levels"][i]
                    epsilon_temp *= self.__params.noise_std_coeffs[i]
                    for n in range(self.__config.ar_order):
                        self.__state.precip_noise_cascades[j][i][n] = epsilon_temp
                epsilon_decomposed = None
                epsilon_temp = None
Initialize the noise cascade with identical noise for all AR(n) steps
We also need to return the mean and standard deviations of the noise
for the recombination of the noise before advecting it.
pysteps/blending/steps.py