adt_structure.hpp

Go to the documentation of this file.

#pragma once

#include <string>
#include <fstream>
#include <sstream>
#include <cmath>
#include <vector>
#include <algorithm>

#include "./mpi_structure.hpp"
#include "./option_structure.hpp"

using namespace std;

class su2_adtComparePointClass {
private:
  const su2double      *pointCoor;      
  const unsigned short splitDirection;  
  const unsigned short nDim;            
public:
  su2_adtComparePointClass(const su2double      *coor,
                           const unsigned short splitDir,
                           const unsigned short nDimADT);
  ~su2_adtComparePointClass();

  bool operator()(const unsigned long p0,
                  const unsigned long p1) const;
private:
  su2_adtComparePointClass();
};

class su2_adtNodeClass {
public:
  bool          childrenAreTerminal[2];  
  unsigned long children[2];             
  unsigned long centralNodeID;           
  su2double *xMin;  
  su2double *xMax;  
  su2_adtNodeClass();

  ~su2_adtNodeClass();

  su2_adtNodeClass(const su2_adtNodeClass &other);

  su2_adtNodeClass& operator=(const su2_adtNodeClass &other);

private:

  void Copy(const su2_adtNodeClass &other);
};

class su2_adtBaseClass {
protected:
  unsigned long nLeaves;    
  unsigned short nDimADT;   
  bool           isEmpty;   
  vector<su2_adtNodeClass> leaves; 
private:
  vector<su2double> coorMinLeaves; 
  vector<su2double> coorMaxLeaves; 
protected:
  su2_adtBaseClass();

  virtual ~su2_adtBaseClass();  

  void BuildADT(unsigned short  nDim,
                unsigned long   nPoints,
                const su2double *coor);
public:
  bool IsEmpty(void) const;

private:
  su2_adtBaseClass(const su2_adtBaseClass &);

  su2_adtBaseClass& operator=(const su2_adtBaseClass &);
};

class su2_adtPointsOnlyClass : public su2_adtBaseClass {
private:
  vector<unsigned long> frontLeaves;    
  vector<unsigned long> frontLeavesNew; 
  vector<su2double>     coorPoints;    
  vector<unsigned long> localPointIDs; 
  vector<int>           ranksOfPoints; 
public:
  su2_adtPointsOnlyClass(unsigned short      nDim,
                         unsigned long       nPoints,
                         const su2double     *coor,
                         const unsigned long *pointID);

  ~su2_adtPointsOnlyClass();

  void DetermineNearestNode(const su2double *coor,
                            su2double       &dist,
                            unsigned long   &pointID,
                            int             &rankID);
private:
  su2_adtPointsOnlyClass();

  su2_adtPointsOnlyClass(const su2_adtPointsOnlyClass &);

  su2_adtPointsOnlyClass& operator=(const su2_adtPointsOnlyClass &);
};

#include "adt_structure.inl"