Panel Class Reference

#include <Panel.h>

Public Member Functions
	Panel (Panel *root, int maximumPanelLevel, Vec3D leftBound, Vec3D rightBound, std::vector< Source * > sources, std::vector< Dipole * > dipoles, NumericalVector<> *squaredFactorials, Box *box)
void	initialise ()
void	computeCoefficients ()
void	createPanels (int dim, std::vector< Source * > &sources, std::vector< Dipole * > &dipoles, Vec3D &leftBoundChild, Vec3D &rightBoundChild, NumericalVector<> *squaredFactorials)
void	findPanelInteractions ()
void	setPanelInteractions ()
void	computeMultipoleExpansion ()
void	translateMultipoleExpansion ()
void	setLocalExpansionZero ()
void	computePartialLocalExpansion ()
void	translateLocalExpansion ()
void	computeLocalExpansion ()
Vec3D	getCentre ()
Panel *	getRoot ()
std::vector< Panel * >	getChilderen ()
std::vector< Panel * >	getNeighbours ()
std::vector< Panel * >	getSecondNeighbours ()
std::vector< Panel * >	getInteractionList ()
std::vector< Source * >	getSources ()
Source *	getSource (int index)
std::vector< Dipole * >	getDipoles ()
std::vector< Multipole * >	getMultipoles ()
std::vector< Sphere * >	getSpheres ()
int	getPanelLevel ()
NumericalVector< std::complex< Mdouble > >	getPartialLocalExpansion ()
NumericalVector< std::complex< Mdouble > >	getLocalExpansion ()

Private Attributes
const int	panelLevel_
Mdouble	dim_
Vec3D	leftBound_
Vec3D	rightBound_
double	size_
Vec3D	centre_
Panel *	root_ = nullptr
std::vector< Panel * >	childeren_
std::vector< Panel * >	neighbours_
std::vector< Panel * >	secondNeighbours_
std::vector< Panel * >	interactionList_
std::vector< Source * >	sources_
std::vector< Dipole * >	dipoles_
std::vector< Multipole * >	multipoles_
std::vector< Sphere * >	spheres_
Box *	box_
Multipole *	multipoleAroundCentre_
LocalExpansion *	partialLocalExpansionAroundCentre_
LocalExpansion *	localExpansionAroundCentre_
NumericalVector< std::complex< Mdouble > >	partialLocalExpansion_
NumericalVector< std::complex< Mdouble > >	localExpansion_

Constructor & Destructor Documentation

Panel()

Panel::Panel	(	Panel *	root,
		int	maximumPanelLevel,
		Vec3D	leftBound,
		Vec3D	rightBound,
		std::vector< Source * >	sources,
		std::vector< Dipole * >	dipoles,
		NumericalVector<> *	squaredFactorials,
		Box *	box
	)

                       :
        panelLevel_(panelLevel),
        leftBound_(leftBound),
        rightBound_(rightBound),
        root_(root),
        sources_(sources),
        dipoles_(dipoles),
        box_(box)
{
    //Initialise the panel characteristics
    // I am using Vec3D, so the size is always constant
/*  if (leftBound.size() != rightBound.size())
    {
        std::cout << "Bounds are not of correct dimensions" << std::endl;
        std::exit(-1);
    }*/
    
    // This code only works for 3D problems, since the maths is significantly different from 2D and 1D
    // The datastructure however allows for 1D and 2D structures,
    // In future 2D support might be added (by a master student?)
    dim_ = 3;
    
    // The panel is a cube with same size in all directions
    // Note this is half the length of a cube side
    size_ = 0.5 * (rightBound.getComponent(0) - leftBound.getComponent(0));
    
    // Determine the centre
    for (int iD = 0; iD < dim_; iD++)
    {
        centre_.setComponent(iD, (leftBound.getComponent(iD) + size_));
    }
    
    //Add panel to the complete box
    box->addPanel(panelLevel, this);
    
    //Set multipole and local expansion coefficients
    multipoleAroundCentre_ = new Multipole(box_->getNumberOfTerms(), squaredFactorials, centre_);
    multipoleAroundCentre_->computeMultipoleExpansion(); // Set vector with zeros to correct length
    partialLocalExpansionAroundCentre_ = new LocalExpansion(box_->getNumberOfTerms(), squaredFactorials, centre_);
    partialLocalExpansionAroundCentre_->initialiseLocalExpansion(); // Set vector with zeros to correct length
    localExpansionAroundCentre_ = new LocalExpansion(box_->getNumberOfTerms(), squaredFactorials, centre_);
    localExpansionAroundCentre_->initialiseLocalExpansion(); // Set vector with zeros to correct length
    
    //Create childeren based on the given dimensions;
    if (panelLevel < box->getMaxLevel()) // final level is obtained if this value is 0
    {
        //Note: For an adaptive grid, add a check to see if this panel contains enough sources to have childeren.
        
        Vec3D leftBoundChild;
        Vec3D rightBoundChild;
        
        createPanels(1, sources, dipoles, leftBoundChild, rightBoundChild, squaredFactorials);
    }
    
}

References Box::addPanel(), box_, centre_, Multipole::computeMultipoleExpansion(), createPanels(), dim_, Vec3D::getComponent(), Box::getNumberOfTerms(), LocalExpansion::initialiseLocalExpansion(), localExpansionAroundCentre_, multipoleAroundCentre_, partialLocalExpansionAroundCentre_, Vec3D::setComponent(), and size_.

Referenced by createPanels().

Member Function Documentation

computeCoefficients()

void Panel::computeCoefficients

(

)

{
    //Start upward pass creating multipole methods and shifting them on parent panels
    box_->upwardPass();
    
    //Start the downward pass
    box_->downwardPass();
}

References box_, Box::downwardPass(), and Box::upwardPass().

computeLocalExpansion()

void Panel::computeLocalExpansion

(

)

{
    localExpansionAroundCentre_->addLocalExpansionCoefficients(
            partialLocalExpansionAroundCentre_->getExpansionCoefficients()
    );
}

References LocalExpansion::addLocalExpansionCoefficients(), LocalExpansion::getExpansionCoefficients(), localExpansionAroundCentre_, and partialLocalExpansionAroundCentre_.

computeMultipoleExpansion()

void Panel::computeMultipoleExpansion

(

)

Source: perform a multipole expansion around the centre of the box

Dipole: perform a multipole expansion around the centre of the box

Multipole: Transfer a multipole in the box to the centre of the box

{
    
    // todo: write this part of the code
    // A source can be expanded around the centre of the panel without translations
    //add(iS->computeMultipoleExpansion();)
    
    for (Dipole* iD : dipoles_)
    {
        //Convert to a multipole
        //todo: This must be done when the actual dipole is made.
        iD->computeMultipoleExpansion();
        
        //Translate multipole to centre of the panel
        multipoleAroundCentre_->addMultipoleCoefficients(iD->TranslateMultipoleExpansionTo(centre_));
        
    }
    
    for (Multipole* iM : multipoles_)
    {
        multipoleAroundCentre_->addMultipoleCoefficients(iM->TranslateMultipoleExpansionTo(centre_));
    }
    
}

References Multipole::addMultipoleCoefficients(), centre_, dipoles_, multipoleAroundCentre_, and multipoles_.

computePartialLocalExpansion()

void Panel::computePartialLocalExpansion

(

)

{
    //For all panels in the interactionlist, add a local expansion of the multipole to the partialLocalExpansion
    for (Panel* panel : interactionList_)
    {
        partialLocalExpansionAroundCentre_->addLocalExpansionCoefficients(
                panel->multipoleAroundCentre_->convertMultipoleToLocal(centre_)
        );
    }
}

References LocalExpansion::addLocalExpansionCoefficients(), centre_, interactionList_, and partialLocalExpansionAroundCentre_.

createPanels()

void Panel::createPanels	(	int	dim,
		std::vector< Source * > &	sources,
		std::vector< Dipole * > &	dipoles,
		Vec3D &	leftBoundChild,
		Vec3D &	rightBoundChild,
		NumericalVector<> *	squaredFactorials
	)

{
    std::vector<Source*> sourcesChild;
    std::vector<Dipole*> dipolesChild;
    
    
    for (int iSide = 0; iSide < 2; ++iSide)
    {
        //Determine the x boundaries
        leftBoundChild.setComponent(dim - 1, (leftBound_.getComponent(dim - 1) + size_ * iSide));
        rightBoundChild.setComponent(dim - 1, (leftBoundChild.getComponent(dim - 1) + size_));
        
        //Determine the sources in this domain
        for (Source* iS : sources)
        {
            if ((iS->getLocation().getComponent(dim - 1) > leftBoundChild.getComponent(dim - 1)) &&
                (iS->getLocation().getComponent(dim - 1) <= rightBoundChild.getComponent(dim - 1)))
            {
                sourcesChild.push_back(iS);
            }
        }
        
        //Determine the dipoles in this domain
        for (Dipole* iD : dipoles)
        {
            if ((iD->getLocation().getComponent(dim - 1) > leftBoundChild.getComponent(dim - 1)) &&
                (iD->getLocation().getComponent(dim - 1) <= rightBoundChild.getComponent(dim - 1)))
            {
                dipolesChild.push_back(iD);
            }
        }
        
        if (dim != dim_)
        {
            createPanels(dim + 1, sourcesChild, dipolesChild, leftBoundChild, rightBoundChild, squaredFactorials);
        }
        else
        {
            //Create childeren
/*          std::cout << "Creating a child with bounds: " << std::endl;
            std::cout << "In x-direction: " << std::endl;
            std::cout << "Left bound: " << leftBoundChild[0] << " and right bound: " << rightBoundChild[0] << std::endl;
            std::cout << "In y-direction: " << std::endl;
            std::cout << "Left bound: " << leftBoundChild[1] << " and right bound: " << rightBoundChild[1] << std::endl;
            std::cout << "In z-direction: " << std::endl;
            std::cout << "Left bound: " << leftBoundChild[2] << " and right bound: " << rightBoundChild[2] << std::endl;
            std::cout << "Child contains " << sourcesChild.size() << " sources" << std::endl;
            std::cout << "==============" << std::endl;*/
            Panel* child = new Panel(this, panelLevel_ + 1, leftBoundChild, rightBoundChild, sourcesChild, dipolesChild,
                                     squaredFactorials, box_);
            childeren_.push_back(child);
            
            //reset leftBoundChild and rightBoundChild
        }
        sourcesChild.clear();
    }
}

References box_, childeren_, dim_, Vec3D::getComponent(), leftBound_, Panel(), panelLevel_, Vec3D::setComponent(), and size_.

Referenced by Panel().

findPanelInteractions()

void Panel::findPanelInteractions

(

)

{
    if (getRoot() == nullptr)
    {
        //nothing happens
    }
    else
    {
        //Crate the links between panels
        this->setPanelInteractions();
    }
    
    //Initialise child panels
    for (Panel* iP : childeren_)
    {
        iP->findPanelInteractions();
    }
}

References childeren_, getRoot(), and setPanelInteractions().

Referenced by initialise().

getCentre()

Vec3D Panel::getCentre ( )

inline

    {
        return centre_;
    }

References centre_.

getChilderen()

std::vector<Panel*> Panel::getChilderen ( )

inline

    {
        return childeren_;
    }

References childeren_.

Referenced by setPanelInteractions().

getDipoles()

std::vector<Dipole*> Panel::getDipoles ( )

inline

    {
        return dipoles_;
    }

References dipoles_.

getInteractionList()

std::vector<Panel*> Panel::getInteractionList ( )

inline

    {
        return interactionList_;
    }

References interactionList_.

getLocalExpansion()

NumericalVector<std::complex<Mdouble> > Panel::getLocalExpansion ( )

inline

    {
        return localExpansion_;
    }

References localExpansion_.

getMultipoles()

std::vector<Multipole*> Panel::getMultipoles ( )

inline

    {
        return multipoles_;
    }

References multipoles_.

getNeighbours()

std::vector<Panel*> Panel::getNeighbours ( )

inline

    {
        return neighbours_;
    }

References neighbours_.

Referenced by setPanelInteractions().

getPanelLevel()

int Panel::getPanelLevel ( )

inline

    {
        return panelLevel_;
    }

References panelLevel_.

getPartialLocalExpansion()

NumericalVector<std::complex<Mdouble> > Panel::getPartialLocalExpansion ( )

inline

    {
        return partialLocalExpansion_;
    }

References partialLocalExpansion_.

getRoot()

Panel* Panel::getRoot ( )

inline

    {
        return root_;
    }

References root_.

Referenced by findPanelInteractions().

getSecondNeighbours()

std::vector<Panel*> Panel::getSecondNeighbours ( )

inline

    {
        return secondNeighbours_;
    }

References secondNeighbours_.

Referenced by setPanelInteractions().

getSource()

Source* Panel::getSource ( int  index )

inline

    {
        return sources_[index];
    }

References sources_.

getSources()

std::vector<Source*> Panel::getSources ( )

inline

    {
        return sources_;
    }

References sources_.

getSpheres()

std::vector<Sphere*> Panel::getSpheres ( )

inline

    {
        return spheres_;
    }

References spheres_.

initialise()

void Panel::initialise

(

)

{
    //Create neighbour list and interaction list
    findPanelInteractions();
    
}

References findPanelInteractions().

setLocalExpansionZero()

void Panel::setLocalExpansionZero

(

)

{
    //Note: nothing has to be done here, the current implementation initialises all local expansions with 0.
}

setPanelInteractions()

void Panel::setPanelInteractions

(

)

{
    //Childeren of a parent are always a neighbour of eachother
    //Note: by definition, a panel is always a neighbour of itself
    for (Panel* iC : root_->getChilderen())
    {
        neighbours_.push_back(iC);
    }
    
    //For all the neighbours of the parent of this panel
    for (Panel* iN : root_->getNeighbours())
    {
        //For all their childeren, check if the childeren are a neighbour or a second neighbour of this panel
        // Note that all second neighbour panels are also childeren of these paretn neighbours
        for (Panel* iC : iN->getChilderen())
        {
            //Compute distance between the centre of the current panel and possible neighbour panel
            Mdouble distance = Vec3D::getDistance(iC->getCentre(), this->getCentre());
            
            //Check if the possible neighbour panel is close enough
            if (distance < 3.0 * size_) //warning: slight hack. I assume all sides are equally long
            {
                neighbours_.push_back(iC);
                //std::cout << "A neighbour has been created with a centre around: (" << iC->getCentre()[0] << "," << iC->getCentre()[1] << ")" << std::endl;
                //std::cout << "Current panel has centre: (" << this->getCentre()[0] << "," << this->getCentre()[1] << ")" << std::endl;
                //std::cout << "===============" << std::endl;
            }
            else if (distance < 6.0 * size_)
            {
                secondNeighbours_.push_back(iC);
            }
            else
            {
                // If it is not a neighbour or nearest neighbour, it belongs to the interactionlist group
                interactionList_.push_back(iC);
                //std::cout << "A panel is added to the interactionlist with a centre around: (" << iC->getCentre()[0] << "," << iC->getCentre()[1] << ")" << std::endl;
                //std::cout << "Current panel has centre: (" << this->getCentre()[0] << "," << this->getCentre()[1] << ")" << std::endl;
                //std::cout << "===============" << std::endl;
            }
        }
    }
    
    // All childeren of the second nearest neighbour of the current panel's parent, are in the interactionlist
    for (Panel* iN : root_->getSecondNeighbours())
    {
        for (Panel* iC : iN->getChilderen())
        {
            secondNeighbours_.push_back(iC);
        }
    }
}

References getChilderen(), Vec3D::getDistance(), getNeighbours(), getSecondNeighbours(), interactionList_, neighbours_, root_, secondNeighbours_, and size_.

Referenced by findPanelInteractions().

translateLocalExpansion()

void Panel::translateLocalExpansion

(

)

{
    for (Panel* iC : childeren_)
    {
        Vec3D centreChild = iC->getCentre();
        iC->localExpansionAroundCentre_->addLocalExpansionCoefficients(
                localExpansionAroundCentre_->translateLocalExpansion(centreChild)
        );
    }
}

References childeren_, localExpansionAroundCentre_, and LocalExpansion::translateLocalExpansion().

translateMultipoleExpansion()

void Panel::translateMultipoleExpansion

(

)

{
    // Extract the multipole of all the childeren
    for (Panel* iC : childeren_)
    {
        //Translate the multipole in the center of the child to the centre of the current panel
        //And then add it to the multipole in the centre of the current panel
        multipoleAroundCentre_->addMultipoleCoefficients(
                iC->multipoleAroundCentre_->TranslateMultipoleExpansionTo(centre_)
        );
    }
}

References Multipole::addMultipoleCoefficients(), centre_, childeren_, and multipoleAroundCentre_.

Member Data Documentation

box_

Box* Panel::box_

private

Referenced by computeCoefficients(), createPanels(), and Panel().

centre_

Vec3D Panel::centre_

private

Referenced by computeMultipoleExpansion(), computePartialLocalExpansion(), getCentre(), Panel(), and translateMultipoleExpansion().

childeren_

std::vector<Panel*> Panel::childeren_

private

Referenced by createPanels(), findPanelInteractions(), getChilderen(), translateLocalExpansion(), and translateMultipoleExpansion().

dim_

Mdouble Panel::dim_

private

Referenced by createPanels(), and Panel().

dipoles_

std::vector<Dipole*> Panel::dipoles_

private

Referenced by computeMultipoleExpansion(), and getDipoles().

interactionList_

std::vector<Panel*> Panel::interactionList_

private

Referenced by computePartialLocalExpansion(), getInteractionList(), and setPanelInteractions().

leftBound_

Vec3D Panel::leftBound_

private

Referenced by createPanels().

localExpansion_

NumericalVector<std::complex<Mdouble> > Panel::localExpansion_

private

Referenced by getLocalExpansion().

localExpansionAroundCentre_

LocalExpansion* Panel::localExpansionAroundCentre_

private

Referenced by computeLocalExpansion(), Panel(), and translateLocalExpansion().

multipoleAroundCentre_

Multipole* Panel::multipoleAroundCentre_

private

Referenced by computeMultipoleExpansion(), Panel(), and translateMultipoleExpansion().

multipoles_

std::vector<Multipole*> Panel::multipoles_

private

Referenced by computeMultipoleExpansion(), and getMultipoles().

neighbours_

std::vector<Panel*> Panel::neighbours_

private

Referenced by getNeighbours(), and setPanelInteractions().

panelLevel_

const int Panel::panelLevel_

private

Referenced by createPanels(), and getPanelLevel().

partialLocalExpansion_

NumericalVector<std::complex<Mdouble> > Panel::partialLocalExpansion_

private

Referenced by getPartialLocalExpansion().

partialLocalExpansionAroundCentre_

LocalExpansion* Panel::partialLocalExpansionAroundCentre_

private

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

rightBound_

Vec3D Panel::rightBound_

private

root_

Panel* Panel::root_ = nullptr

private

Referenced by getRoot(), and setPanelInteractions().

secondNeighbours_

std::vector<Panel*> Panel::secondNeighbours_

private

Referenced by getSecondNeighbours(), and setPanelInteractions().

size_

double Panel::size_

private

Referenced by createPanels(), Panel(), and setPanelInteractions().

sources_

std::vector<Source*> Panel::sources_

private

Referenced by getSource(), and getSources().

spheres_

std::vector<Sphere*> Panel::spheres_

private

Referenced by getSpheres().

---

The documentation for this class was generated from the following files:

• Panel.h
• Panel.cc