Attention une mise à jour du serveur va être effectuée le lundi 17 mai entre 13h et 13h30. Cette mise à jour va générer une interruption du service de quelques minutes.

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

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 */