guilhem_lavaux/cosmotool
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Implemented power spectrum support in Euclidian/Healpix

Browse source
This commit is contained in:
Guilhem Lavaux 2012-11-10 17:35:27 -05:00
parent db6831e594
commit cc7996175c
5 changed files with 178 additions and 16 deletions
Download patch file Download diff file Expand all files Collapse all files

23
src/fourier/base_types.hpp
View file

@ -24,14 +24,17 @@ namespace CosmoTool
typedef Eigen::Map<VecType, Eigen::Aligned> MapType;
typedef Eigen::Map<VecType const, Eigen::Aligned> ConstMapType;
typedef FourierMap<std::complex<T> > FourierMapType;
typedef boost::shared_ptr<FourierMapType> FourierMapPtr;
virtual boost::shared_ptr<FourierMapType>
virtual FourierMapPtr
newRandomFourier(gsl_rng *rng, const FourierMapType& like_map) const = 0;
virtual void mul(FourierMap<std::complex<T> >& m) const = 0;
virtual void mul(FourierMapType& m) const = 0;
virtual void mul_sqrt(FourierMapType& m) const = 0;
virtual void mul_inv(FourierMapType& m) const = 0;
virtual void mul_inv_sqrt(FourierMapType& m) const = 0;
};
template<typename T>
class FourierMap
{
@ -60,6 +63,12 @@ namespace CosmoTool
return ConstMapType(data(), size());
}
FourierMap<T>& operator=(const FourierMap<T>& m)
{
eigen() = m.eigen();
return *this;
}
void sqrt()
{
MapType m = eigen();
@ -130,6 +139,14 @@ namespace CosmoTool
virtual void synthesis_conjugate() = 0;
};
template<typename T>
class MapUtilityFunction
{
typedef SpectrumFunction<T> Spectrum;
typedef Spectrum *Spectrum_ptr;
typedef FourierMap<std::complex<T> > FMap;
typedef Spectrum_ptr (*SpectrumFromMap)(const FMap& m);
};
};

66
src/fourier/euclidian.hpp
View file

@ -30,6 +30,9 @@ namespace CosmoTool
ptr_map newRandomFourier(gsl_rng *rng, const FourierMapType& like_map) const;
void mul(FourierMap<std::complex<T> >& m) const;
void mul_sqrt(FourierMap<std::complex<T> >& m) const;
void mul_inv(FourierMap<std::complex<T> >& m) const;
void mul_inv_sqrt(FourierMap<std::complex<T> >& m) const;
};
template<typename T>
@ -140,7 +143,7 @@ namespace CosmoTool
double k2 = 0;
for (int q = 0; q < ik.size(); q++)
{
int dk = ik;
int dk = ik[q];
if (dk > dims[q]/2)
dk = dk - dims[q];
@ -349,18 +352,21 @@ namespace CosmoTool
EuclidianSpectrum_1D<T>::newRandomFourier(gsl_rng *rng, const FourierMapType& like_map) const
{
typedef EuclidianFourierMapComplex<T> MapT;
typedef typename EuclidianSpectrum_1D<T>::ptr_map ptr_map;
typedef typename MapT::DimArray DimArray;
MapT& m_c = dynamic_cast<MapT&>(like_map);
MapT *rand_map = m_c.mimick();
std::complex<T> *d = rand_map->data();
const MapT& m_c = dynamic_cast<const MapT&>(like_map);
ptr_map ret_map = ptr_map(m_c.mimick());
MapT& rand_map = dynamic_cast<MapT&>(*ret_map.get());
std::complex<T> *d = rand_map.data();
long idx;
const DimArray& dims = rand_map->getDims();
const DimArray& dims = rand_map.getDims();
long plane_size;
for (long p = 1; p < m_c.size(); p++)
{
double A_k = std::sqrt(0.5*f(rand_map->get_K(p)));
double A_k = std::sqrt(0.5*f(rand_map.get_K(p)));
d[p] = std::complex<T>(gsl_ran_gaussian(rng, A_k),
gsl_ran_gaussian(rng, A_k));
}
@ -372,7 +378,7 @@ namespace CosmoTool
if (dims.size() == 1)
{
d[idx] = std::complex<T>(d[idx].real() + d[idx].imag(), 0);
return boost::shared_ptr<EuclidianSpectrum_1D<T>::FourierMapType>(rand_map);
return ret_map;
}
plane_size = 1;
@ -391,6 +397,7 @@ namespace CosmoTool
}
long q = dims[0];
d[q] = std::complex<T>(d[q].real() + d[q].imag());
return ret_map;
}
template<typename T>
@ -400,8 +407,51 @@ namespace CosmoTool
std::complex<T> *d = m.data();
for (long p = 0; p < m_c.size(); p++)
d[p] *= f(m.get_K(p));
d[p] *= f(m_c.get_K(p));
}
template<typename T>
void EuclidianSpectrum_1D<T>::mul_sqrt(FourierMap<std::complex<T> >& m) const
{
EuclidianFourierMapComplex<T>& m_c = dynamic_cast<EuclidianFourierMapComplex<T>&>(m);
std::complex<T> *d = m.data();
for (long p = 0; p < m_c.size(); p++)
d[p] *= std::sqrt(f(m_c.get_K(p)));
}
template<typename T>
void EuclidianSpectrum_1D<T>::mul_inv(FourierMap<std::complex<T> >& m) const
{
EuclidianFourierMapComplex<T>& m_c = dynamic_cast<EuclidianFourierMapComplex<T>&>(m);
std::complex<T> *d = m.data();
for (long p = 0; p < m_c.size(); p++)
{
T A = f(m_c.get_K(p));
if (A==0)
d[p] = 0;
else
d[p] /= A;
}
}
template<typename T>
void EuclidianSpectrum_1D<T>::mul_inv_sqrt(FourierMap<std::complex<T> >& m) const
{
EuclidianFourierMapComplex<T>& m_c = dynamic_cast<EuclidianFourierMapComplex<T>&>(m);
std::complex<T> *d = m.data();
for (long p = 0; p < m_c.size(); p++)
{
T A = std::sqrt(f(m_c.get_K(p)));
if (A == 0)
d[p] = 0;
else
d[p] /= A;
}
}
};
#endif

82
src/fourier/healpix.hpp
View file

@ -32,8 +32,13 @@ namespace CosmoTool
const T *data() const { return &cls[0]; }
long size() const { return cls.size(); }
ptr_map newRandomFourier(gsl_rng *rng, const FourierMapType& like_map) const = 0;
};
ptr_map newRandomFourier(gsl_rng *rng, const FourierMapType& like_map) const;
void mul(FourierMapType& m) const;
void mul_sqrt(FourierMapType& m) const;
void mul_inv(FourierMapType& m) const;
void mul_inv_sqrt(FourierMapType& m) const;
};
template<typename T>
class HealpixFourierMap: public FourierMap<T>
@ -248,13 +253,13 @@ namespace CosmoTool
long lmaxGen = std::min(cls.size()-1, alms.Lmax());
std::complex<T> *new_data = new_alms->data();
for (long l = 0; l < lmaxGen; l++)
for (long l = 0; l <= lmaxGen; l++)
{
double Al = std::sqrt(cls[l]);
new_data[alms.index(l,0)] = gsl_ran_gaussian(rng, Al);
Al *= M_SQRT1_2;
for (long m = 1; m < alms.Mmax(); m++)
for (long m = 1; m <= std::min(l,alms.Mmax()); m++)
{
std::complex<T>& c = new_data[alms.index(l,m)];
c.real() = gsl_ran_gaussian(rng, Al);
@ -263,6 +268,75 @@ namespace CosmoTool
}
return r;
}
template<typename T>
void HealpixSpectrum<T>::mul(FourierMapType& like_map) const
{
HealpixFourierALM<T>& alms = dynamic_cast<HealpixFourierALM<T>&>(like_map);
std::complex<T> *data = alms.data();
for (long l = 0; l <= alms.Lmax(); l++)
{
double Al = cls[l];
for (long m = 0; m <= std::min(l,alms.Mmax()); m++)
{
data[alms.index(l,m)] *= Al;
}
}
}
template<typename T>
void HealpixSpectrum<T>::mul_sqrt(FourierMapType& like_map) const
{
HealpixFourierALM<T>& alms = dynamic_cast<const HealpixFourierALM<T>&>(like_map);
std::complex<T> *data = alms.data();
for (long l = 0; l <= alms.Lmax(); l++)
{
double Al = std::sqrt(cls[l]);
for (long m = 0; m <= std::min(l,alms.Mmax()); m++)
{
data[alms.index(l,m)] *= Al;
}
}
}
template<typename T>
void HealpixSpectrum<T>::mul_inv(FourierMapType& like_map) const
{
HealpixFourierALM<T>& alms = dynamic_cast<HealpixFourierALM<T>&>(like_map);
std::complex<T> *data = alms.data();
for (long l = 0; l <= alms.Lmax(); l++)
{
double Al = (cls[l] <= 0) ? 0 : (1/cls[l]);
for (long m = 0; m <= std::min(l,alms.Mmax()); m++)
{
data[alms.index(l,m)] *= Al;
}
}
}
template<typename T>
void HealpixSpectrum<T>::mul_inv_sqrt(FourierMapType& like_map) const
{
HealpixFourierALM<T>& alms = dynamic_cast<HealpixFourierALM<T>&>(like_map);
std::complex<T> *data = alms.data();
for (long l = 0; l <= alms.Lmax(); l++)
{
double Al = (cls[l] <= 0) ? 0 : std::sqrt(1/cls[l]);
for (long m = 0; m <= std::min(l,alms.Mmax()); m++)
{
data[alms.index(l,m)] *= Al;
}
}
}
};
#endif