#include <LocalExpansion.h>

Public Member Functions
	LocalExpansion (int p, NumericalVector<> *squaredFactorials, Vec3D location)

virtual	~LocalExpansion ()

void	initialiseLocalExpansion ()

NumericalVector< std::complex< Mdouble > >	translateLocalExpansion (Vec3D location)

void	addLocalExpansionCoefficients (NumericalVector< std::complex< Mdouble >> localExpansionCoefficients)

NumericalVector< std::complex< Mdouble > >	getExpansionCoefficients ()

Private Attributes
int	p_

NumericalVector *	squaredFactorials_

Vec3D	location_

NumericalVector< std::complex< Mdouble > >	localExpansionCoefficients_

Constructor & Destructor Documentation

◆ LocalExpansion()

LocalExpansion::LocalExpansion	(	int	p,
		NumericalVector<> *	squaredFactorials,
		Vec3D	location
	)

                                                                                           :
         p_(p),
         squaredFactorials_(squaredFactorials),
         location_(location)
 {
 }

◆ ~LocalExpansion()

LocalExpansion::~LocalExpansion ( )

virtualdefault

Member Function Documentation

◆ addLocalExpansionCoefficients()

void LocalExpansion::addLocalExpansionCoefficients ( NumericalVector< std::complex< Mdouble >> localExpansionCoefficients )

 {
     if (localExpansionCoefficients.size() > localExpansionCoefficients_.size())
     {
         logger(ERROR, "Multipole expansion coefficient sizes are not correct.");
     }
     
     localExpansionCoefficients_ += localExpansionCoefficients;
     
 }

References ERROR, localExpansionCoefficients_, and logger.

Referenced by Panel::computeLocalExpansion(), and Panel::computePartialLocalExpansion().

◆ getExpansionCoefficients()

NumericalVector<std::complex<Mdouble> > LocalExpansion::getExpansionCoefficients ( )

inline

     {
         return localExpansionCoefficients_;
     }

References localExpansionCoefficients_.

Referenced by Panel::computeLocalExpansion().

◆ initialiseLocalExpansion()

void LocalExpansion::initialiseLocalExpansion ( )

 {
     size_t nTerms = 0.5 * (p_ + 1) * (2 * p_ + 2);
     localExpansionCoefficients_(nTerms);
 }

References localExpansionCoefficients_, and p_.

Referenced by Panel::Panel().

◆ translateLocalExpansion()

NumericalVector< std::complex< Mdouble > > LocalExpansion::translateLocalExpansion ( Vec3D location )

 {
     int nTerms = 0.5 * (p_ + 1) * (2 * p_ + 2);
     NumericalVector<std::complex<Mdouble>> translatedLocalExpansionCoefficients(nTerms);
     //std::cout << "size: " << nTerms << std::endl;
     
     //compute angles and distance in new framework
     //todo: fix this rubble with quaternions
     Mdouble rho = 1.0;
     Mdouble alpha = 1.0;
     Mdouble beta = 1.0;
     
     
     //Compute translated local expansion coefficients
     NumericalVector<std::complex<Mdouble>> sphericalHarmonics = sphericalHarmonics::sphericalHarmonics(p_, alpha, beta);
     
     for (int j = 0; j <= p_; j++)
     {
         for (int k = -j; k <= j; k++)
         {
             std::complex<Mdouble> result = {0.0, 0.0};
             int location = j * j + (k + j);
             for (int n = j; n <= p_; n++)
             {
                 for (int m = (k - j + n); m <= (k - n + j); m++)
                 {
                     int location_O = n * n + (m + n);
                     int location_A1 = (n - j) * (n - j) + ((m - k) + (n - j));
                     int location_A2 = location;
                     int location_Y = location_A1;
                     int location_A3 = location_O;
                     std::complex<Mdouble> J = std::pow(constants::i, std::abs(m) - std::abs(m - k) - std::abs(k));
                     /*              std::cout << "location_A1: " << location_O << std::endl;
                                     std::cout << "locationExpansion: " << localExpansionCoefficients_[location_O] << std::endl;
                                     std::cout << "A1: " << (*squaredFactorials_)(location_A1) << std::endl;
                                     std::cout << "A2: " << (*squaredFactorials_)(location_A2) << std::endl;
                                     std::cout << "A3: " << (*squaredFactorials_)(location_A3) << std::endl;
                                     std::cout << "Spherical: " << sphericalHarmonics[location_Y] << std::endl;*/
                     //\todo TW note: a warning says += cannot be done here
                     result += localExpansionCoefficients_[location_O] * J * (*squaredFactorials_)(location_A1) *
                               (*squaredFactorials_)(location_A2) * sphericalHarmonics[location_Y] *
                               std::pow(rho, n - j) / (std::pow(-1, n + j) * (*squaredFactorials_)(location_A3));
                 }
             }
             //std::cout << "location: " << location << std::endl;
             translatedLocalExpansionCoefficients[location] = result;
         }
     }
     return translatedLocalExpansionCoefficients;
 }