def _multiply(self, x, **kwargs): ## > applies the operator to a given field ## convolve (forward) x_ = self.apply_PSF(x.val) x_ *= self.exposure if (self.mask_out_pixels.status): x_ *= self.mask ## return data vector return field(self.target, val=x_, target=self.target)
def _adjoint_multiply( self, x, **kwargs): ## > applies the adjoint operator to a given field x_ = self.domain.enforce_shape(x.val) ## convolve (backward) if (self.mask_out_pixels.status): x_ *= self.mask x_ *= self.exposure x_ = self.apply_PSF(x_) ## return signal field return field(self.domain, val=x_, target=kwargs.get("target", None))
def power_forward_conversion_lm(k_space, p, mean=0): """ This function is designed to convert a theoretical/statistical power spectrum of a Gaussian field to the theoretical power spectrum of the exponentiated field. The function only works for power spectra defined for lm_spaces Parameters ---------- k_space : nifty.rg_space, a regular grid space with the attribute `Fourier = True` p : np.array, the power spectrum of the Gaussian field. Needs to have the same number of entries as `k_space.get_power_indices()[0]` m : float, *optional* specifies the mean of the Gaussian field (default: 0). Returns ------- p1 : np.array, the power spectrum of the exponentiated Gaussian field. References ---------- .. [#] M. Greiner and T.A. Ensslin, "Log-transforming the matter power spectrum"; `arXiv:1312.1354 <http://arxiv.org/abs/1312.1354>`_ """ m = mean klen = k_space.get_power_indices()[0] C_0_Omega = field(k_space, val=0) C_0_Omega.val[:len(klen)] = p * sqrt(2 * klen + 1) / sqrt(4 * pi) C_0_Omega = C_0_Omega.transform() C_0_0 = (p * (2 * klen + 1) / (4 * pi)).sum() exC = exp(C_0_Omega + C_0_0 + 2 * m) Z = exC.transform() spec = Z.val[:len(klen)] spec = spec * sqrt(4 * pi) / sqrt(2 * klen + 1) spec = np.real(spec) if (np.any(spec < 0.)): spec = spec * (spec > 0.) about.warnings.cprint("WARNING: negative modes set to zero.") return spec
def power_forward_conversion_lm(k_space,p,mean=0): """ This function is designed to convert a theoretical/statistical power spectrum of a Gaussian field to the theoretical power spectrum of the exponentiated field. The function only works for power spectra defined for lm_spaces Parameters ---------- k_space : nifty.rg_space, a regular grid space with the attribute `Fourier = True` p : np.array, the power spectrum of the Gaussian field. Needs to have the same number of entries as `k_space.get_power_indices()[0]` m : float, *optional* specifies the mean of the Gaussian field (default: 0). Returns ------- p1 : np.array, the power spectrum of the exponentiated Gaussian field. References ---------- .. [#] M. Greiner and T.A. Ensslin, "Log-transforming the matter power spectrum"; `arXiv:1312.1354 <http://arxiv.org/abs/1312.1354>`_ """ m = mean klen = k_space.get_power_indices()[0] C_0_Omega = field(k_space,val=0) C_0_Omega.val[:len(klen)] = p*sqrt(2*klen+1)/sqrt(4*pi) C_0_Omega = C_0_Omega.transform() C_0_0 = (p*(2*klen+1)/(4*pi)).sum() exC = exp(C_0_Omega+C_0_0+2*m) Z = exC.transform() spec = Z.val[:len(klen)] spec = spec*sqrt(4*pi)/sqrt(2*klen+1) spec = np.real(spec) if(np.any(spec<0.)): spec = spec*(spec>0.) about.warnings.cprint("WARNING: negative modes set to zero.") return spec
def load_demo(demodirectory): """ Loads all objects relevant for the D3PO demonstration Parameters ---------- demodirectory : string Directory whereto the demo files are located. Raises ------ IOError If one of the demo files is missing. Retrurns -------- R : convulotion_operator Response operaotr of the D3PO demonstration. d : field Data vector of the D3PO demonstration. """ ## check workspace dd = os.path.realpath(demodirectory) if (os.path.exists(dd)): try: ## load arrays events = np.genfromtxt(os.path.join(dd, "demo_events.txt")) kernel = np.genfromtxt(os.path.join(dd, "demo_kernel.txt")) exposure = np.genfromtxt(os.path.join(dd, "demo_exposure.txt")) mask = np.genfromtxt(os.path.join(dd, "demo_mask.txt")) except (IOError): raise IOError( about._errors.cstring( "ERROR: demo source files not found in '" + dd + "'.")) else: raise IOError(about._errors.cstring("ERROR: '" + dd + "' nonexisting.")) ## set response x_space = rg_space(events.shape[::-1]) R = convolution_operator(x_space, kernel, exposure, mask, den=True, target=None) ## set data d = field(R.target, val=events, target=R.target) ## return argument tuple return R, d
def power_forward_conversion_rg(k_space,p,mean=0,bare=True): """ This function is designed to convert a theoretical/statistical power spectrum of a Gaussian field to the theoretical power spectrum of the exponentiated field. The function only works for power spectra defined for rg_spaces Parameters ---------- k_space : nifty.rg_space, a regular grid space with the attribute `Fourier = True` p : np.array, the power spectrum of the Gaussian field. Needs to have the same number of entries as `k_space.get_power_indices()[0]` mean : float, *optional* specifies the mean of the Gaussian field (default: 0). bare : bool, *optional* whether `p` is the bare power spectrum or not (default: True). Returns ------- p1 : np.array, the power spectrum of the exponentiated Gaussian field. References ---------- .. [#] M. Greiner and T.A. Ensslin, "Log-transforming the matter power spectrum"; `arXiv:1312.1354 <http://arxiv.org/abs/1312.1354>`_ """ pindex = k_space.get_power_indices()[2] spec = power_operator(k_space,spec=p,bare=bare).get_power(bare=False) S_x = field(k_space,val=spec[pindex]).transform() S_0 = k_space.calc_weight(spec[pindex],1).sum() pf = exp(S_x+S_0+2*mean) p1 = sqrt(pf.power()) if(bare==True): return power_operator(k_space,spec=p1,bare=False).get_power(bare=True).real else: return p1.real
def power_backward_conversion_rg(k_space,p,mean=None,bare=True): """ This function is designed to convert a theoretical/statistical power spectrum of a log-normal field to the theoretical power spectrum of the underlying Gaussian field. The function only works for power spectra defined for rg_spaces Parameters ---------- k_space : nifty.rg_space, a regular grid space with the attribute `Fourier = True` p : np.array, the power spectrum of the log-normal field. Needs to have the same number of entries as `k_space.get_power_indices()[0]` mean : float, *optional* specifies the mean of the log-normal field. If `mean` is not specified the function will use the monopole of the power spectrum. If it is specified the function will NOT use the monopole of the spectrum (default: None). WARNING: a mean that is too low can violate positive definiteness of the log-normal field. In this case the function produces an error. bare : bool, *optional* whether `p` is the bare power spectrum or not (default: True). Returns ------- mean : float, the recovered mean of the underlying Gaussian distribution. p1 : np.array, the power spectrum of the underlying Gaussian field, where the monopole has been set to zero. Eventual monopole power has been shifted to the mean. References ---------- .. [#] M. Greiner and T.A. Ensslin, "Log-transforming the matter power spectrum"; `arXiv:1312.1354 <http://arxiv.org/abs/1312.1354>`_ """ pindex = k_space.get_power_indices()[2] V = k_space.vol.prod()**(-1) mono_ind = np.where(pindex==0) spec = power_operator(k_space,spec=p,bare=bare).get_power(bare=False) if(mean is None): mean = 0. else: spec[0] = 0. pf = field(k_space,val=spec[pindex]).transform()+mean**2 if(np.any(pf.val<0.)): raise ValueError(about._errors.cstring("ERROR: spectrum or mean incompatible with positive definiteness.\n Try increasing the mean.")) return None p1 = sqrt(log(pf).power()) p1[0] = (log(pf)).transform()[mono_ind][0] p2 = 0.5*V*log(k_space.calc_weight(spec[pindex],1).sum()+mean**2) logmean = 1/V * (p1[0]-p2) p1[0] = 0. if(np.any(p1<0.)): raise ValueError(about._errors.cstring("ERROR: spectrum or mean incompatible with positive definiteness.\n Try increasing the mean.")) return None if(bare==True): return logmean.real,power_operator(k_space,spec=p1,bare=False).get_power(bare=True).real else: return logmean.real,p1.real
def power_backward_conversion_lm(k_space, p, mean=None): """ This function is designed to convert a theoretical/statistical power spectrum of a log-normal field to the theoretical power spectrum of the underlying Gaussian field. The function only works for power spectra defined for lm_spaces Parameters ---------- k_space : nifty.rg_space, a regular grid space with the attribute `Fourier = True` p : np.array, the power spectrum of the log-normal field. Needs to have the same number of entries as `k_space.get_power_indices()[0]` mean : float, *optional* specifies the mean of the log-normal field. If `mean` is not specified the function will use the monopole of the power spectrum. If it is specified the function will NOT use the monopole of the spectrum. (default: None) WARNING: a mean that is too low can violate positive definiteness of the log-normal field. In this case the function produces an error. Returns ------- mean : float, the recovered mean of the underlying Gaussian distribution. p1 : np.array, the power spectrum of the underlying Gaussian field, where the monopole has been set to zero. Eventual monopole power has been shifted to the mean. References ---------- .. [#] M. Greiner and T.A. Ensslin, "Log-transforming the matter power spectrum"; `arXiv:1312.1354 <http://arxiv.org/abs/1312.1354>`_ """ p = np.copy(p) if (mean is not None): p[0] = 4 * pi * mean**2 klen = k_space.get_power_indices()[0] C_0_Omega = field(k_space, val=0) C_0_Omega.val[:len(klen)] = p * sqrt(2 * klen + 1) / sqrt(4 * pi) C_0_Omega = C_0_Omega.transform() if (np.any(C_0_Omega.val < 0.)): raise ValueError( about._errors.cstring( "ERROR: spectrum or mean incompatible with positive definiteness.\n Try increasing the mean." )) return None lC = log(C_0_Omega) Z = lC.transform() spec = Z.val[:len(klen)] mean = (spec[0] - 0.5 * sqrt(4 * pi) * log( (p * (2 * klen + 1) / (4 * pi)).sum())) / sqrt(4 * pi) spec[0] = 0. spec = spec * sqrt(4 * pi) / sqrt(2 * klen + 1) spec = np.real(spec) if (np.any(spec < 0.)): spec = spec * (spec > 0.) about.warnings.cprint("WARNING: negative modes set to zero.") return mean.real, spec
def power_backward_conversion_lm(k_space,p,mean=None): """ This function is designed to convert a theoretical/statistical power spectrum of a log-normal field to the theoretical power spectrum of the underlying Gaussian field. The function only works for power spectra defined for lm_spaces Parameters ---------- k_space : nifty.rg_space, a regular grid space with the attribute `Fourier = True` p : np.array, the power spectrum of the log-normal field. Needs to have the same number of entries as `k_space.get_power_indices()[0]` mean : float, *optional* specifies the mean of the log-normal field. If `mean` is not specified the function will use the monopole of the power spectrum. If it is specified the function will NOT use the monopole of the spectrum. (default: None) WARNING: a mean that is too low can violate positive definiteness of the log-normal field. In this case the function produces an error. Returns ------- mean : float, the recovered mean of the underlying Gaussian distribution. p1 : np.array, the power spectrum of the underlying Gaussian field, where the monopole has been set to zero. Eventual monopole power has been shifted to the mean. References ---------- .. [#] M. Greiner and T.A. Ensslin, "Log-transforming the matter power spectrum"; `arXiv:1312.1354 <http://arxiv.org/abs/1312.1354>`_ """ p = np.copy(p) if(mean is not None): p[0] = 4*pi*mean**2 klen = k_space.get_power_indices()[0] C_0_Omega = field(k_space,val=0) C_0_Omega.val[:len(klen)] = p*sqrt(2*klen+1)/sqrt(4*pi) C_0_Omega = C_0_Omega.transform() if(np.any(C_0_Omega.val<0.)): raise ValueError(about._errors.cstring("ERROR: spectrum or mean incompatible with positive definiteness.\n Try increasing the mean.")) return None lC = log(C_0_Omega) Z = lC.transform() spec = Z.val[:len(klen)] mean = (spec[0]-0.5*sqrt(4*pi)*log((p*(2*klen+1)/(4*pi)).sum()))/sqrt(4*pi) spec[0] = 0. spec = spec*sqrt(4*pi)/sqrt(2*klen+1) spec = np.real(spec) if(np.any(spec<0.)): spec = spec*(spec>0.) about.warnings.cprint("WARNING: negative modes set to zero.") return mean.real,spec
problem = d3po.problem(R, demo_config, "./d3po_demo/") ## solve problem problem.solve(d) ## define nice HE = ncmap.he() HE.set_bad([0, 0, 0, 1]) ## fix zero event pixels nice = {"vmin": 1, "vmax": 144, "cmap": HE, "norm": "log"} ## get results s, u, rho_s, rho_u = problem.get(s=True, u=True, rho_s=True, rho_u=True) ## nicely plot results field(R.domain, val=d.val).plot(title="(raw) photon observation", unit="counts", **nice) rho_s.plot(title="diffuse photon flux", unit="counts/pixel", **nice) field(R.domain, val=R.apply_PSF(rho_u.val)).plot( title="(reconvolved) point-like flux", unit="counts/pixel", **nice) ## plot response properties #e = field(R.domain) #e[e.dim(split=True)[0]//2,e.dim(split=True)[1]//2] = 10 #field(R.domain,val=R.apply_PSF(e)).plot(title="convolution kernel",vmin=0,vmax=1,cmap=pl.cm.gray_r) #field(R.domain,val=R.exposure).plot(title="exposure mask",vmin=0,vmax=1,cmap=pl.cm.gray) #field(R.domain,val=R.mask).plot(title="binary mask",vmin=0,vmax=1,cmap=pl.cm.gray) ## plot D123PO #l = problem.get(lmbda=True) #field(R.domain,val=l.val).plot(title="(reproduced) noiseless observation",unit="counts",**nice)