Commit 36d535b7 authored by COULAUD Olivier's avatar COULAUD Olivier
Browse files

Remove warnings (nummptr, unsigned int)

Add Adaptive Chebyshev sym  kernel (P2M and M2M)
parent 838fe08a
......@@ -36,11 +36,16 @@
template <class CellClass, class LeafClass>
class FAdaptCell : public FBasicCell {
public:
struct FExtACell {
class FExtACell {
public:
FAdaptCell<CellClass, LeafClass> * cell ;
int level ; //< Level in the octree of cell
FExtACell() { cell=nullptr ; level =-1 ; } ;
int getLevel() { return level;}
int getLevel() const { return level;}
};
protected:
// Global Index of the cell in the octree (This id is unique)
long int gID;
......@@ -52,14 +57,14 @@ protected:
//
// Lists
//
FExtACell adaptiveParent ; //< adaptive Parent of the cell
FVector<FExtACell> adaptiveChild ; //< list of adaptive child of the cell
FExtACell adaptiveParent ; //< adaptive Parent of the cell
FVector<FExtACell> adaptiveChild ; //< list of adaptive child of the cell
FVector<LeafClass*> leaves ; //< list of leaf child of the cell
//
//
CellClass * trueFMMCell ; //<a pointer on the cell that contains Multipole and local values
public:
FAdaptCell(): gID(-1), nbP(0), adaptive(false),sminMCriteria(false),trueFMMCell(nullptr) {
FAdaptCell(): gID(-1), nbP(0), adaptive(false),sminMCriteria(false),trueFMMCell(new CellClass) {
}
/** Default destructor */
virtual ~FAdaptCell(){
......@@ -147,7 +152,14 @@ public:
FExtACell* getAdaptiveChild(const int i) {
return &this->adaptiveChild[0];
}
const FVector<FExtACell> getAdaptiveChild() const{
return this->adaptiveChild;
}
//
//
CellClass* getKernelCell(){
return trueFMMCell ;
}
//
//! Add the adaptive child of the cell
void addLeafptr( LeafClass * leaf) {
......@@ -162,9 +174,10 @@ public:
return this->leaves[i];
}
//! Return the number of leaves
LeafClass* getLeaf(const int i ) const {
const LeafClass* getLeaf(const int i ) const {
return this->leaves[i];
}
/** Make it like the beginning */
void resetToInitialState(){
//this->dataDown = 0;
......@@ -188,8 +201,26 @@ public:
// buffer >> dataDown >> dataUp >> nbP;
}
/** Get Multipole */
FReal* getMultipole(const int inRhs){
return this->trueFMMCell->getMultipole(inRhs);
}
/** Get Local */
FReal* getLocal(const int inRhs){
return this->trueFMMCell->getLocal(inRhs);
}
/** Get Multipole */
const FReal* getMultipole(const int inRhs) const
{ return this->trueFMMCell->getMultipole(inRhs);
}
/** Get Local */
const FReal* getLocal(const int inRhs) const{
return this->trueFMMCell->getLocal(inRhs);
}
// void resetToInitialState(){
// return this->trueFMMCell->resetToInitialState();
// }
/////////////////////////////////////////////////
/** Serialize only up data in a buffer */
......
#ifndef FADAPTCHEBSYMKERNEL_HPP
#define FADAPTCHEBSYMKERNEL_HPP
// ===================================================================================
// Copyright ScalFmm 2011 INRIA,
// This software is a computer program whose purpose is to compute the FMM.
//
// This software is governed by the CeCILL-C and LGPL licenses and
// abiding by the rules of distribution of free software.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public and CeCILL-C Licenses for more details.
// "http://www.cecill.info".
// "http://www.gnu.org/licenses".
// ===================================================================================
#include "Utils/FGlobal.hpp"
#include "Utils/FTrace.hpp"
#include "Kernels/Chebyshev/FChebSymKernel.hpp"
class FTreeCoordinate;
// for verbosity only!!!
//#define COUNT_BLOCKED_INTERACTIONS
// if timings should be logged
//#define LOG_TIMINGS
/**
* @author O. Coulaud
* @class FAdaptChebSymKernel
* @brief
* Please read the license
*
* This kernels implement the Chebyshev interpolation based FMM operators
* exploiting the symmetries in the far-field. It implements all interfaces
* (P2P, P2M, M2M, M2L, L2L, L2P) which are required by the FFmmAlgorithm and
* FFmmAlgorithmThread.
*
* @tparam CellClass Type of cell
* @tparam ContainerClass Type of container to store particles
* @tparam MatrixKernelClass Type of matrix kernel function
* @tparam ORDER Chebyshev interpolation order
*/
template < class CellClass, class ContainerClass, class MatrixKernelClass, int ORDER, int NVALS = 1>
class FAdaptChebSymKernel
: public FChebSymKernel<CellClass, ContainerClass, MatrixKernelClass, ORDER, NVALS>
{
typedef FChebSymKernel<CellClass, ContainerClass, MatrixKernelClass, ORDER, NVALS> KernelBaseClass;
#ifdef LOG_TIMINGS
FTic time;
FReal t_m2l_1, t_m2l_2, t_m2l_3;
#endif
public:
/**
* The constructor initializes all constant attributes and it reads the
* precomputed and compressed M2L operators from a binary file (an
* runtime_error is thrown if the required file is not valid).
*/
FAdaptChebSymKernel(const int inTreeHeight,
const FReal inBoxWidth,
const FPoint& inBoxCenter)
: KernelBaseClass(inTreeHeight, inBoxWidth, inBoxCenter)
{
#ifdef LOG_TIMINGS
t_m2l_1 = FReal(0.);
t_m2l_2 = FReal(0.);
t_m2l_3 = FReal(0.);
#endif
}
/** Copy constructor */
FAdaptChebSymKernel(const FAdaptChebSymKernel& other)
: KernelBaseClass(other)
{ }
/** Destructor */
~FAdaptChebSymKernel()
{
this->~KernelBaseClass() ;
#ifdef LOG_TIMINGS
std::cout << "- Permutation took " << t_m2l_1 << "s"
<< "\n- GEMMT and GEMM took " << t_m2l_2 << "s"
<< "\n- Unpermutation took " << t_m2l_3 << "s"
<< std::endl;
#endif
}
void P2MAdapt(CellClass* const ParentCell, const int &level)
{
const FPoint LeafCellCenter(KernelBaseClass::getLeafCellCenter(ParentCell->getCoordinate()));
const FReal BoxWidth = KernelBaseClass::BoxWidthLeaf*FMath::pow(2.0,KernelBaseClass::TreeHeight-level);
//
for(int i = 0 ; i <ParentCell->getLeavesSize(); ++i ){
//
for(int idxRhs = 0 ; idxRhs < NVALS ; ++idxRhs){
KernelBaseClass::Interpolator->applyP2M(LeafCellCenter, BoxWidth,
ParentCell->getMultipole(idxRhs), ParentCell->getLeaf(i)->getSrc());
}
}
}
void M2MAdapt(CellClass* const FRestrict ParentCell, const int &TreeLevel, const int &numberOfM2M,
const int * FRestrict ChildLevel , const CellClass*const FRestrict *const FRestrict ChildCells)
{
for(int idxRhs = 0 ; idxRhs < NVALS ; ++idxRhs){
// // apply Sy
// FBlas::scal(nnodes*2, FReal(0.), ParentCell->getMultipole(idxRhs));
// for (unsigned int ChildIndex=0; ChildIndex < 8; ++ChildIndex){
// if (ChildCells[ChildIndex]){
// AbstractBaseClass::Interpolator->applyM2M(ChildIndex, ChildCells[ChildIndex]->getMultipole(idxRhs), ParentCell->getMultipole(idxRhs));
// }
// }
}
}
void M2L(CellClass* const FRestrict TargetCell,
const CellClass* SourceCells[343],
const int /*NumSourceCells*/,
const int TreeLevel)
{
}
void L2L(const CellClass* const FRestrict ParentCell,
CellClass* FRestrict *const FRestrict ChildCells,
const int /*TreeLevel*/)
{
// for(int idxRhs = 0 ; idxRhs < NVALS ; ++idxRhs){
// // apply Sx
// for (unsigned int ChildIndex=0; ChildIndex < 8; ++ChildIndex){
// if (ChildCells[ChildIndex]){
// AbstractBaseClass::Interpolator->applyL2L(ChildIndex, ParentCell->getLocal(idxRhs), ChildCells[ChildIndex]->getLocal(idxRhs));
// }
// }
// }
}
void L2P(const CellClass* const LeafCell,
ContainerClass* const TargetParticles)
{
KernelBaseClass::L2P(LeafCell,TargetParticles) ;
}
// void P2P(const FTreeCoordinate& /* LeafCellCoordinate */, // needed for periodic boundary conditions
// ContainerClass* const FRestrict TargetParticles,
// const ContainerClass* const FRestrict /*SourceParticles*/,
// ContainerClass* const NeighborSourceParticles[27],
// const int /* size */)
// {
// DirectInteractionComputer<MatrixKernelClass::Identifier, NVALS>::P2P(TargetParticles,NeighborSourceParticles);
// }
//
//
// void P2PRemote(const FTreeCoordinate& /*inPosition*/,
// ContainerClass* const FRestrict inTargets, const ContainerClass* const FRestrict /*inSources*/,
// ContainerClass* const inNeighbors[27], const int /*inSize*/){
// DirectInteractionComputer<MatrixKernelClass::Identifier, NVALS>::P2PRemote(inTargets,inNeighbors,27);
// }
};
#endif //FADAPTCHEBSYMKERNELS_HPP
// [--END--]
......@@ -16,6 +16,7 @@
#ifndef FADAPTSEQALGORITHM_HPP
#define FADAPTSEQALGORITHM_HPP
#include <array>
#include "Utils/FGlobal.hpp"
#include "Utils/FAssert.hpp"
#include "Utils/FLog.hpp"
......@@ -41,8 +42,8 @@
template<class OctreeClass, class CellClass, class ContainerClass, class KernelClass, class LeafClass>
class FAdaptSeqAlgorithm : public FAbstractAlgorithm {
OctreeClass* const tree; //< The octree to work on
KernelClass* const kernels; //< The kernels
OctreeClass* const tree; //< The octree to work on
KernelClass* const kernels; //< The kernels
const int OctreeHeight;
......@@ -105,9 +106,12 @@ private:
// and the list of particles
FLOG(computationCounter.tic());
if( !octreeIterator.getCurrentCell()->isSminMCriteria()){
auto * currentCell = octreeIterator.getCurrentCell() ;
//
std::cout << " P2M operator on cell " <<octreeIterator.getCurrentCell()->getGlobalId() <<std::endl;
// kernels->P2M( octreeIterator.getCurrentCell() , octreeIterator.getCurrentListSrc());
std::cout << " P2M operator on cell " <<currentCell->getGlobalId() <<std::endl;
// Classical P2M operator
kernels->P2M( currentCell, octreeIterator.getCurrentListSrc());
}
FLOG(computationCounter.tac());
} while(octreeIterator.moveRight());
......@@ -138,6 +142,10 @@ private:
for(int idxLevel = OctreeHeight - 2 ; idxLevel > 1 ; --idxLevel ){
FLOG(FTic counterTimeLevel);
std::cout << " Level "<<idxLevel<<std::endl;
//
std::array<int,8> m2m_child_level{ {0,0,0,0,0,0,0,0}} ;
// std::array<KernelClass*,8> m2m_child_cell{ {nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr}},
CellClass* m2m_child_cell[8] = {nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr};
// for each cells
do{
......@@ -146,24 +154,36 @@ private:
FLOG(computationCounter.tic());
//
if(octreeIterator.getCurrentCell()->isadaptive() && !octreeIterator.getCurrentCell()->isSminMCriteria() ){
m2m_child_level.fill(-1) ;
// adaptive cell and enough work
// Need only adaptive child !!!!!
const auto * v =octreeIterator.getCurrentCell()->getadaptiveChild() ;
// M2MAdapt(*octreeIterator.getCurrentCell(), idxLevel,nb_fils,fils_level[],fils_cell[]);
if (octreeIterator.getCurrentCell()->sizeofadaptiveChild()> 0 ){
for (int i=0; i < v->getSize() ; ++i){
if (! v->operator [](i).cell->isSminMCriteria() ){
std::cout << " M2M operator to do between " <<octreeIterator.getCurrentCell()->getGlobalId() <<" and "
<< v->operator [](i).cell->getGlobalId() << std::endl;
auto * currentCell = octreeIterator.getCurrentCell() ;
// auto currentKCell = currentCell->getKernelCell();
int nbM2M =0;
//
for(int i=0 ; i<8 ; ++i){
m2m_child_cell[i] =nullptr ;
}
if (currentCell->sizeofadaptiveChild()> 0 ){
const auto & cellChild = currentCell->getAdaptiveChild() ;
for (int i=0; i < cellChild.getSize() ; ++i){
if (! cellChild[i].cell->isSminMCriteria() ){
m2m_child_level[nbM2M] = cellChild[i].getLevel();
std::cout << " M2M operator to do between " <<currentCell->getGlobalId() <<" and "
<< cellChild[i].cell->getGlobalId() << std::endl;
nbM2M++ ;
}
else {
std::cout << " P2M operator to do between " <<octreeIterator.getCurrentCell()->getGlobalId() <<" and "
<< v->operator [](i).cell->getGlobalId() << std::endl;
}
}
}
// this->M2MAdapt(*octreeIterator.getCurrentCell(), idxLevel,nb_fils,fils_level[],fils_cell[]);
//kernels->M2M( octreeIterator.getCurrentCell() , octreeIterator.getCurrentChild(), idxLevel);
std::cout << " P2M operator to do between " <<currentCell->getGlobalId() <<" and "
<< cellChild[i].cell->getGlobalId() << std::endl;
kernels->P2MAdapt( currentCell, idxLevel );
} //end if
} // end loop
kernels->M2MAdapt(currentCell, idxLevel, nbM2M,m2m_child_level.data(),m2m_child_cell);
} // end if cell adaptive
// Build Multipolaire vectors
}
FLOG(computationCounter.tac());
} while(octreeIterator.moveRight());
......@@ -291,7 +311,7 @@ private:
typename OctreeClass::Iterator avoidGotoLeftIterator(octreeIterator);
const int heightMinusOne = OctreeHeight - 1;
// const int heightMinusOne = OctreeHeight - 1;
// for each levels exepted leaf level
// for(int idxLevel = 2 ; idxLevel < heightMinusOne ; ++idxLevel ){
for(int idxLevel = 3 ; idxLevel < OctreeHeight ; ++idxLevel ){
......
......@@ -455,7 +455,7 @@ public:
}
else{
FReal * val = dataToRead.getPtrFirstData();
for (int i = 0 ; i <dataToRead.getReadDataNumber(); ++i){
for (unsigned int i = 0 ; i <dataToRead.getReadDataNumber(); ++i){
(*this->file) >>*val;
++val;
}
......
......@@ -42,7 +42,7 @@ public:
* @param inNumberOfCells total number of cells in the interval (should be <= inEndingIndex-inEndingIndex)
*/
FGroupOfCells(const MortonIndex inStartingIndex, const MortonIndex inEndingIndex, const int inNumberOfCells)
: memoryBuffer(0), blockHeader(0), blockIndexesTable(0), blockCells(0) {
: memoryBuffer(nullptr), blockHeader(nullptr), blockIndexesTable(nullptr), blockCells(nullptr) {
// Find the number of cell to allocate in the blocks
const int blockIndexesTableSize = int(inEndingIndex-inStartingIndex);
FAssertLF(inNumberOfCells <= blockIndexesTableSize);
......@@ -114,13 +114,13 @@ public:
/** Return the address of the cell if it exists (or NULL) */
CellClass* getCell(const MortonIndex inIndex){
if( exists(inIndex) ) return &blockCells[blockIndexesTable[inIndex-blockHeader->startingIndex]];
else return 0;
else return nullptr;
}
/** Return the address of the cell if it exists (or NULL) */
const CellClass* getCell(const MortonIndex inIndex) const {
if( exists(inIndex) ) return &blockCells[blockIndexesTable[inIndex-blockHeader->startingIndex]];
else return 0;
else return nullptr;
}
/** Allocate a new cell by calling its constructor */
......
......@@ -62,7 +62,7 @@ public:
* @param inNumberOfLeaves total number of leaves in the interval (should be <= inEndingIndex-inEndingIndex)
*/
FGroupOfParticles(const MortonIndex inStartingIndex, const MortonIndex inEndingIndex, const int inNumberOfLeaves, const int inNbParticles)
: memoryBuffer(0), blockHeader(0), blockIndexesTable(0), leafHeader(0), nbParticlesInGroup(inNbParticles),
: memoryBuffer(nullptr), blockHeader(nullptr), blockIndexesTable(nullptr), leafHeader(nullptr), nbParticlesInGroup(inNbParticles),
positionOffset(0), attributeOffset(0) {
memset(particlePosition, 0, sizeof(particlePosition));
memset(particleAttributes, 0, sizeof(particleAttributes));
......
......@@ -72,7 +72,7 @@ public:
*/
template<class OctreeClass>
FGroupTree(const int inTreeHeight, const int inNbElementsPerBlock, OctreeClass*const inOctreeSrc)
: treeHeight(inTreeHeight), nbElementsPerBlock(inNbElementsPerBlock), cellBlocksPerLevel(0),
: treeHeight(inTreeHeight), nbElementsPerBlock(inNbElementsPerBlock), cellBlocksPerLevel(nullptr),
boxCenter(inOctreeSrc->getBoxCenter()), boxCorner(inOctreeSrc->getBoxCenter(),-(inOctreeSrc->getBoxWidth()/2)),
boxWidth(inOctreeSrc->getBoxWidth()), boxWidthAtLeafLevel(inOctreeSrc->getBoxWidth()/FReal(1<<inTreeHeight)){
cellBlocksPerLevel = new std::list<CellGroupClass*>[treeHeight];
......@@ -191,7 +191,7 @@ public:
template<class ParticleContainer>
FGroupTree(const int inTreeHeight, const FReal inBoxWidth, const FPoint& inBoxCenter,
const int inNbElementsPerBlock, ParticleContainer* inParticlesContainer, const bool particlesAreSorted = false):
treeHeight(inTreeHeight),nbElementsPerBlock(inNbElementsPerBlock),cellBlocksPerLevel(0),
treeHeight(inTreeHeight),nbElementsPerBlock(inNbElementsPerBlock),cellBlocksPerLevel(nullptr),
boxCenter(inBoxCenter), boxCorner(inBoxCenter,-(inBoxWidth/2)), boxWidth(inBoxWidth),
boxWidthAtLeafLevel(inBoxWidth/FReal(1<<inTreeHeight)){
......
// ===================================================================================
// Copyright ScalFmm 2011 INRIA, Olivier Coulaud, Bérenger Bramas, Matthias Messner
// Copyright ScalFmm 2011 INRIA, Olivier Coulaud, Berenger Bramas, Matthias Messner
// olivier.coulaud@inria.fr, berenger.bramas@inria.fr
// This software is a computer program whose purpose is to compute the FMM.
//
......
// ===================================================================================
// Copyright ScalFmm 2011 INRIA, Olivier Coulaud, Bérenger Bramas, Matthias Messner
// Copyright ScalFmm 2011 INRIA,
// olivier.coulaud@inria.fr, berenger.bramas@inria.fr
// This software is a computer program whose purpose is to compute the FMM.
//
......@@ -34,10 +34,12 @@
template <int ORDER, int NRHS = 1, int NLHS = 1, int NVALS = 1>
class FChebCell : public FBasicCell
{
// nnodes = ORDER^3
// we multiply by 2 because we store the Multipole expansion end the compressed one.
static const int VectorSize = TensorTraits<ORDER>::nnodes * 2;
FReal multipole_exp[NRHS * NVALS * VectorSize]; //< Multipole expansion
FReal local_exp[NLHS * NVALS * VectorSize]; //< Local expansion
FReal local_exp[NLHS * NVALS * VectorSize]; //< Local expansion
public:
FChebCell(){
......
......@@ -17,12 +17,12 @@
#define FCHEBINTERPOLATOR_HPP
#include "./../Interpolation/FInterpMapping.hpp"
#include "./../Interpolation/FInterpMatrixKernel.hpp" //PB
#include "./FChebTensor.hpp"
#include "./FChebRoots.hpp"
#include "../Interpolation/FInterpMapping.hpp"
#include "../Interpolation/FInterpMatrixKernel.hpp" //PB
#include "FChebTensor.hpp"
#include "FChebRoots.hpp"
#include "../../Utils/FBlas.hpp"
#include "Utils/FBlas.hpp"
......
#ifndef FCHEBSYMKERNEL_HPP
#define FCHEBSYMKERNEL_HPP
// [--License--]
#include "../../Utils/FGlobal.hpp"
#include "../../Utils/FTrace.hpp"
#include "../../Utils/FSmartPointer.hpp"
#include "./FAbstractChebKernel.hpp"
#include "./FChebInterpolator.hpp"
// ===================================================================================
// Copyright ScalFmm 2011 INRIA, Olivier Coulaud, Berenger Bramas, Matthias Messner
// olivier.coulaud@inria.fr, berenger.bramas@inria.fr
// Copyright ScalFmm 2011 INRIA,
// This software is a computer program whose purpose is to compute the FMM.
//
// This software is governed by the CeCILL-C and LGPL licenses and
......@@ -23,7 +14,14 @@
// "http://www.cecill.info".
// "http://www.gnu.org/licenses".
// ===================================================================================
#include "./FChebSymM2LHandler.hpp"
#include "Utils/FGlobal.hpp"
#include "Utils/FTrace.hpp"
#include "Utils/FSmartPointer.hpp"
#include "FAbstractChebKernel.hpp"
#include "FChebInterpolator.hpp"
#include "FChebSymM2LHandler.hpp"
class FTreeCoordinate;
......@@ -172,7 +170,7 @@ public:
void P2M(CellClass* const LeafCell,
const ContainerClass* const SourceParticles)
const ContainerClass* const SourceParticles/*, const int level = AbstractBaseClass::TreeHeight*/)
{
// apply Sy
const FPoint LeafCellCenter(AbstractBaseClass::getLeafCellCenter(LeafCell->getCoordinate()));
......@@ -189,10 +187,11 @@ public:
const int /*TreeLevel*/)
{
for(int idxRhs = 0 ; idxRhs < NVALS ; ++idxRhs){
// apply Sy
FBlas::scal(nnodes*2, FReal(0.), ParentCell->getMultipole(idxRhs));
// Reset to zero the Parent expansion
// FBlas::scal(nnodes*2, FReal(0.), ParentCell->getMultipole(idxRhs));
for (unsigned int ChildIndex=0; ChildIndex < 8; ++ChildIndex){
if (ChildCells[ChildIndex]){
// apply Sy
if (ChildCells[ChildIndex]){
AbstractBaseClass::Interpolator->applyM2M(ChildIndex, ChildCells[ChildIndex]->getMultipole(idxRhs), ParentCell->getMultipole(idxRhs));
}
}
......
......@@ -76,7 +76,7 @@ int main(int argc, char* argv[])
// allocate 343 pointers to K, but only 16 are actually filled
FReal** K = new FReal* [343];
for (unsigned int t=0; t<343; ++t) K[t] = NULL;
for (unsigned int t=0; t<343; ++t) K[t] = nullptr;
{
unsigned int counter = 0;
......
......@@ -26,8 +26,9 @@
#include "Components/FSimpleIndexedLeaf.hpp"
#include "Kernels/P2P/FP2PParticleContainerIndexed.hpp"
//
#include "Kernels/Rotation/FRotationKernel.hpp"
#include "Kernels/Rotation/FRotationCell.hpp"
#include "Kernels/Interpolation/FInterpMatrixKernel.hpp"
#include "Kernels/Chebyshev/FChebCell.hpp"
#include "AdaptiveTree/FAdaptChebSymKernel.hpp"
//
#include "Containers/FOctree.hpp"
//
......@@ -90,12 +91,14 @@ int main(int argc, char ** argv){
const unsigned int P =8;
//
typedef FP2PParticleContainerIndexed<> ContainerClass;
typedef FSimpleIndexedLeaf<ContainerClass> LeafClass;
typedef FRotationCell<P> KernelCellClass;
typedef FSimpleIndexedLeaf<ContainerClass> LeafClass;
typedef FChebCell<P> KernelCellClass;
//
typedef FAdaptCell<KernelCellClass,LeafClass> CellClass;
typedef FOctree<CellClass, ContainerClass, LeafClass > OctreeClass;
typedef FRotationKernel< KernelCellClass, ContainerClass , P> KernelClass;
typedef FAdaptCell<KernelCellClass,LeafClass> CellClass;
typedef FOctree<CellClass, ContainerClass, LeafClass > OctreeClass;
typedef FInterpMatrixKernelR MatrixKernelClass;
typedef FAdaptChebSymKernel<CellClass,ContainerClass,MatrixKernelClass,P> KernelClass;
//
typedef FAdaptSeqAlgorithm<OctreeClass,CellClass,ContainerClass,KernelClass,LeafClass> FmmClass;
//
......@@ -203,7 +206,7 @@ int main(int argc, char ** argv){
//
// -----------------------------------------------------
//
/*
//
// Set Global id for tulip export
//
......@@ -260,6 +263,8 @@ int main(int argc, char ** argv){
std::cout << " Level " <<octreeIterator.level() <<std::endl;
}while(octreeIterator.moveUp() );
//
*/
return 0;
}
......
......@@ -264,7 +264,6 @@ class TestChebyshevDirect : public FUTester<TestChebyshevDirect> {
/** TestChebSymKernel */
void TestChebSymKernel(){