#include <Box.h>

Public Member Functions
	Box (int maxLevel, int nTerms)

void	addPanel (int level, Panel *panel)

void	upwardPass ()

void	downwardPass ()

void	computeFlow (int k)

int	getMaxLevel ()

int	getNrPanelsOnLevel (int level)

int	getNumberOfTerms ()

Private Attributes
int	maxLevel_

int	p_

std::vector< std::vector< Panel * > >	levels_

std::vector< Sphere * >	spheres_

Constructor & Destructor Documentation

◆ Box()

Box::Box	(	int	maxLevel,
		int	nTerms
	)

                                  : maxLevel_(maxLevel), p_(nTerms)
 {
     for (int iL = 0; iL <= maxLevel; iL++)
     {
         std::vector<Panel*>* boxLevel = new std::vector<Panel*>;
         levels_.push_back(*boxLevel);
     }
 }

References levels_.

Member Function Documentation

◆ addPanel()

void Box::addPanel	(	int	level,
		Panel *	panel
	)

 {
     levels_[level].push_back(panel);
 }

References levels_.

Referenced by Panel::Panel().

◆ computeFlow()

void Box::computeFlow ( int k )

 {
     //***************************************
     //*         Initialise spheres          *
     //***************************************
     
     // The first step is to add dipoles with correct location and strengths in the domain
     // All dipoles in the domain are now expanded into multipoles
     logger(INFO, "Initialising spheres");
     upwardPass();
     downwardPass();
     
     //For all panels on the finest level
     //for (Panel* panel : levels_[maxLevel_])
     //{
         //For all dipoles on the finest level
         //for (Dipole* iD : panel->getDipoles())
         //{
             // Add a multipole in the domain
             //Multipole* multipole = new Multipole(iD->getP, iD->getSquaredFactorials, iD->getLocation());
             //panel->multipoles_.push_back(multipole);
  
             // Construct a sphere
             //Sphere* sphere = new Sphere(panel, iD->getLocation(), iD, multipole);
  
             // Add the sphere to the list of spheres and to the panel list
             //spheres_.push_back(sphere);
             //spheres_.push_back(sphere);
         //}
     //}
     
     //***********************************
     //*     Compue Mirror Multipoles    *
     //***********************************
     
     
     // Compute k order mirrors
     for (int i = 1; k <= i; i++)
     {
         //For all panels on the finest level
         for (Panel* panel : levels_[maxLevel_])
         {
             // For all spheres: add a new multipole to the centre of a sphere to compensate
             for (Sphere* sphere : panel->getSpheres())
             {
                 std::vector<std::complex<Mdouble>> localExpansionAroundSphere;
                 //Vec3D sphereCentre = sphere->getLocation();
                 
                 // Compute panel local expansion around sphere
                 //localExpansionAroundSphere = panel->localExpansionAroundCentre_->translateLocalExpansion(sphereCentre);
                 
                 // Compute other sphere local expansion around sphere
                 for (Sphere* sphereOther: spheres_)
                 {
                     if (sphereOther != sphere)
                     {
                         // todo: implement this shizzle
                         //localExpansionAroundSphere += sphereOther->multipole_->convertMultipoleToLocal(sphereCentre);
                     }
                 }
                 // Compute multipole
                 size_t nTerms = (p_ + 1) * (p_ + 1);
                 NumericalVector<std::complex<Mdouble>> multipoleExpansionCoefficients(nTerms);
                 //for (int n = 0; n <= p_; n++)
                 //{
                     //for (int m = -n; m <= n; m++)
                     //{
                         //int location = n * n + (m + n);
                         //multipoleExpansionCoefficients[location] = localExpansionAroundSphere[0]*n/(n+1)*std::pow(sphere->getRadius,2n+1);
                     //}
                 //}
                 //sphere->multipole_->setExpansionCoefficients(multipoleExpansionCoefficients);
             }
         }
         
         //Perform and upward and downward pass to compute the new coefficients
         upwardPass();
         downwardPass();
     }
     
     
 }

References downwardPass(), i, INFO, k, levels_, logger, maxLevel_, p_, spheres_, and upwardPass().

◆ downwardPass()

void Box::downwardPass ( )

 {
     logger(INFO, "============================\n"
                  "Starting the downward pass.\n", Flusher::NO_FLUSH);
     //Set the first part of the local expansion to zero: everything is in the interaction list or closer
     NumericalVector<std::complex<Mdouble>> localExpansionCoefficients;
     for (Panel* panel: levels_[1])
     {
         panel->setLocalExpansionZero();
     }
     
     // Compute all local expansions for intermediate levels
     for (int iL = 1; iL < maxLevel_; iL++)
     {
         logger(INFO, "Computing nearby Local Expansions on level %.\n", iL, Flusher::NO_FLUSH);
         for (Panel* panel: levels_[iL])
         {
             panel->computePartialLocalExpansion();
             panel->computeLocalExpansion();
             
         }
         
         logger(INFO, "Translating local expansions to children\n", Flusher::NO_FLUSH);
         for (Panel* panel: levels_[iL])
         {
             panel->translateLocalExpansion();
         }
     }
     
     // Compute local expansions for the remaining  interaction list on the finest level
     logger(INFO, "Computing nearby local expansions on finest level\n", Flusher::NO_FLUSH);
     for (Panel* panel : levels_[maxLevel_])
     {
         panel->computePartialLocalExpansion();
         panel->computeLocalExpansion();
     }
     
     logger(INFO, "Finished downward pass.");
 }

References INFO, levels_, logger, maxLevel_, and NO_FLUSH.

Referenced by Panel::computeCoefficients(), and computeFlow().

◆ getMaxLevel()

int Box::getMaxLevel ( )

inline

     {
         return maxLevel_;
     }

References maxLevel_.

◆ getNrPanelsOnLevel()

int Box::getNrPanelsOnLevel ( int level )

inline

Todo:: some ints here should be unsigned long

     {
         return levels_[level].size();
     }

References levels_.

◆ getNumberOfTerms()

int Box::getNumberOfTerms ( )

inline

     {
         return p_;
     }

References p_.

Referenced by Panel::Panel().

◆ upwardPass()

void Box::upwardPass ( )

 {
     // Perform a multipole expansion about the centre of all panels located on the finest mesh
     logger(INFO, "============================\n"
                  "Starting the upward pass\n"
                  "Computing multipole expansion on finest level\n", Flusher::NO_FLUSH);
     for (Panel* panel: levels_[maxLevel_])
     {
         panel->computeMultipoleExpansion();
     }
     
     // Perform an upward pass, each level combine the previous level multipole expansions by shifting them to the centre of the current panel
     for (int iL = maxLevel_ - 1; iL >= 0; iL--)
     {
         logger(INFO, "Shifting multipole expansions on level %.\n", iL, Flusher::NO_FLUSH);
         for (Panel* panel: levels_[iL])
         {
             panel->translateMultipoleExpansion();
         }
     }
     logger(INFO, "Finished upward pass.");
     
 }