sphericalHarmonics Namespace Reference

Functions
NumericalVector	associatedLegendrePolynomials (int n, Mdouble x)
NumericalVector< std::complex< Mdouble > >	sphericalHarmonics (int p, Mdouble theta, Mdouble phi)
NumericalVector	computeSquaredFactorialValues (int p)

Function Documentation

associatedLegendrePolynomials()

NumericalVector sphericalHarmonics::associatedLegendrePolynomials	(	int	n,
		Mdouble	x
	)

{
    //Given n and m, we only have to compute P_n^(|m|)
    //The function will return all these P values for theta
    std::size_t nTerms = 0.5 * (n + 1) * (n + 2);
    NumericalVector<> polynomials(nTerms);
    
    size_t location_current;
    size_t location_previous;
    Mdouble temp;
    
    polynomials(0) = 1; //P_0^0 = 1;
    for (int l = 1; l <= n; l++)
    {
        //first compute P_l^l
        location_current = 0.5 * (l + 1) * (l + 2) - 1;
        location_previous = location_current - (l + 1);
        polynomials(location_current) = -(2.0 * (l - 1.0) + 1.0) * std::sqrt(1.0 - x * x) *
                                        polynomials(location_previous); // Recursive formula from wiki
        
        //second, compute P_l^(l-1) based on P_(l-1)^(l-1)
        polynomials(location_current - 1) =
                x * (2.0 * (l - 1) + 1) * polynomials(location_previous); // Recursive formula from wiki
    }
    
    //thirdly, compute other values
    for (int l = 2; l <= n; l++)
    {
        for (int m = (l - 2); m >= 0; m--)
        {
            location_current = (0.5 * (l + 1) * (l + 2) - 1) - l + m;
            temp = polynomials(location_current + 2) +
                   2.0 * (m + 1) * x / sqrt(1 - x * x) * polynomials(location_current + 1);
            polynomials(location_current) = temp / ((m - l) * (l + m + 1)); // variation on greengard eqn 3.34 from wiki
        }
    }
    
    
    return polynomials;
}

References n.

Referenced by sphericalHarmonics().

computeSquaredFactorialValues()

NumericalVector sphericalHarmonics::computeSquaredFactorialValues

(

int

p

)

{
    std::size_t nTerms = 0.5 * (p + 1) * (2 * p + 2);
    NumericalVector<> squaredFactorials(nTerms);
    
    for (int n = 0; n <= p; n++)
    {
        for (int m = -n; m <= n; m++)
        {
            std::size_t location = n * n + (m + n); //(n^2 is begin of Y_n)
            int fact1 = mathsFunc::factorial(n - m);
            int fact2 = mathsFunc::factorial(n + m);
            Mdouble fact = fact1 * fact2;
            squaredFactorials(location) = std::pow(-1.0, n) / std::sqrt(fact);
        }
    }
    
    return squaredFactorials;
}

References mathsFunc::factorial(), and n.

sphericalHarmonics()

NumericalVector< std::complex< Mdouble > > sphericalHarmonics::sphericalHarmonics	(	int	p,
		Mdouble	theta,
		Mdouble	phi
	)

{
    std::size_t nTerms = 0.5 * (p + 1) * (2 * p + 2);
    NumericalVector<std::complex<Mdouble>> Y(nTerms);
    NumericalVector<> polynomials = associatedLegendrePolynomials(p, std::cos(theta));
    
    //Compute the spherical harmonics
    for (int n = 0; n <= p; n++)
    {
        for (int mt = -n; mt <= n; mt++)
        {
            Mdouble m = mt;
            Mdouble m_abs = std::abs(mt);
            std::size_t location_current = n * n + (m + n); //n^2 is begin of Y_n^-n
            std::size_t location_polynomial = 0.5 * n * (n + 1) + m_abs;
            int fact1 = mathsFunc::factorial(n - m_abs);
            int fact2 = mathsFunc::factorial(n + m_abs);
            Mdouble fact = 1.0 * fact1 / fact2;
            std::complex<Mdouble> value =
                    std::sqrt(fact) * polynomials(location_polynomial) * std::exp(constants::i * m * phi);
            Y(location_current) = value;
        }
    }
    return Y;
}

References associatedLegendrePolynomials(), mathsFunc::cos(), mathsFunc::exp(), mathsFunc::factorial(), constants::i, n, and Y.

Referenced by Multipole::convertMultipoleToLocal(), LocalExpansion::translateLocalExpansion(), and Multipole::TranslateMultipoleExpansionTo().