Panel.h

Go to the documentation of this file.

// This file is part of the MercuryDPM project (https://www.mercurydpm.org).
// Copyright (c), The MercuryDPM Developers Team. All rights reserved.
// License: BSD 3-Clause License; see the LICENSE file in the root directory.
 
#ifndef PANEL_H_
#define PANEL_H_
 
#include <vector>
#include "Dipole.h"
#include "LocalExpansion.h"
#include "Math/NumericalVector.h"
#include "Math/Vector.h"
#include "Multipole.h"
#include "Source.h"
 
class Panel;
 
#include "Sphere.h"
 
class Box;
 
class Panel
{
public:
    Panel(Panel* root,
          int maximumPanelLevel,
          Vec3D leftBound,
          Vec3D rightBound,
          std::vector<Source*> sources,
          std::vector<Dipole*> dipoles,
          NumericalVector<>* squaredFactorials,
          Box* box);
    
    //Data structure functions
    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();
    
    //Functions used for the upward pass
    void computeMultipoleExpansion();
    
    void translateMultipoleExpansion();
    
    //Functions used for the downward pass
    void setLocalExpansionZero(); //In the current implementation this function is not used
    void computePartialLocalExpansion();
    
    void translateLocalExpansion();
    
    
    //Functions that need to be removed or shift to another topic
    void computeLocalExpansion();
    
    
    //Getters
    Vec3D getCentre()
    {
        return centre_;
    }
    
    Panel* getRoot()
    {
        return root_;
    }
    
    std::vector<Panel*> getChilderen()
    {
        return childeren_;
    }
    
    std::vector<Panel*> getNeighbours()
    {
        return neighbours_;
    }
    
    std::vector<Panel*> getSecondNeighbours()
    {
        return secondNeighbours_;
    }
    
    std::vector<Panel*> getInteractionList()
    {
        return interactionList_;
    }
    
    std::vector<Source*> getSources()
    {
        return sources_;
    }
    
    Source* getSource(int index)
    {
        return sources_[index];
    }
    
    std::vector<Dipole*> getDipoles()
    {
        return dipoles_;
    }
    
    std::vector<Multipole*> getMultipoles()
    {
        return multipoles_;
    }
    
    std::vector<Sphere*> getSpheres()
    {
        return spheres_;
    }
    
    int getPanelLevel()
    {
        return panelLevel_;
    }
    
    NumericalVector<std::complex<Mdouble>> getPartialLocalExpansion()
    {
        return partialLocalExpansion_;
    }
    
    NumericalVector<std::complex<Mdouble>> getLocalExpansion()
    {
        return localExpansion_;
    }
 
private:
    //Panel characteristics
    const int panelLevel_;    //The level at which the panel is living. This panel has no children when panelLevel = 1
    Mdouble dim_;            //dimension of the problem space
    Vec3D leftBound_;        // Left and bottom bounds
    Vec3D rightBound_;        // Right and top bounds
    double size_;            // the half of the width and length of the panel
    Vec3D centre_;            // Centre of the panel
    
    //Data structures
    Panel* root_ = nullptr;                    //Root of the current panel
    std::vector<Panel*> childeren_;            //List of children which have the current panel as root.
    std::vector<Panel*> neighbours_;        //List of neighbours
    std::vector<Panel*> secondNeighbours_;  //List of second neighbours.
    std::vector<Panel*> interactionList_;    //List of interaction panels
    
    //Multipole structures
    std::vector<Source*> sources_;            //List of sources contained within this panel.
    std::vector<Dipole*> dipoles_;            //List of dipoles contained within this panel.
    std::vector<Multipole*> multipoles_;    //List of multipoles contained within this panel.
    
    //For fluid calculation
    std::vector<Sphere*> spheres_;            //For the finest level of panels this vector contains the spheres within that panel
    
    // Mother of all pointers
    Box* box_;                                //Pointer to the data structure sorted per level
    
    //Computational values
    // todo: sort out this mess
    Multipole* multipoleAroundCentre_;
    LocalExpansion* partialLocalExpansionAroundCentre_;
    LocalExpansion* localExpansionAroundCentre_;
    NumericalVector<std::complex<Mdouble>> partialLocalExpansion_;
    NumericalVector<std::complex<Mdouble>> localExpansion_;
};
 
 
#endif /* PANEL_H_ */