class TAlm



  Stores spherical harmonic coefficients(SHC) calculated from real data.
  Which means they will have the property a^{*}_{lm} = (-1)^{m}a_{l(-m)}.
  The main point in writing a class to store spherical harmonic
  coefficients from scratch, instead of using Healpix Alm<T> for example,
  is to generate dictionaries easily (I did not try to generated
  dictionaries for Healpix classes) and to inherit from TObject to be able
  to save the objects to ROOT files.

Function Members (Methods)

public:

	TAlm(int J)
	TAlm(const TAlm&)
	~TAlm()
void	Add(const TAlm& alm)
void	Conjugate()
int	GetJmax() const
size_t	GetL() const
complex<double>	operator()(int l, int m) const
complex<double>&	operator()(int l, int m)
TAlm&	operator=(const TAlm&)
void	Scale(double factor)
void	ScaleL(const vector<double>& d)

private:

int	fIndex(size_t l, size_t m) const

Data Members

private:

vector<std::complex<double> >	fAlm	Stores real part
int	fJmax	Maximum number of Scales.
size_t	fL	Band limit: l < fL
size_t	fSize	Size necessary to store data.

Class Charts

Inheritance Chart:

TAlm

Function documentation

void Add(const TAlm& alm)

 Add alm to this

void Conjugate()

 Conjugates harmonic coefficients

void ScaleL(const vector<double>& d)

 Dilate spherical harmonics with vector d, that
 must have the size equal to l band limit.
 Multiplies all elements with a given l by d[l]
 alm(l,m) = d[l]*alm(l,m)

void Scale(double factor)

 Multiplies all elements by factor
 alm(l,m) = factor*alm(l,m)

int fIndex(size_t l, size_t m) const

{return ((l*(l+1) >> 1) + m);}

explicit TAlm(int J)

{ }

std::complex<double> operator()(int l, int m) const

{return fAlm[fIndex(l,m)];}

std::complex<double>& operator()(int l, int m)

{return fAlm[fIndex(l,m)];}

int GetJmax() const

{return fJmax;}

size_t GetL() const

{return fL;}