diff --git a/Tests/noDist/testAdaptiveSymChebFMM.cpp b/Tests/noDist/testAdaptiveSymChebFMM.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d9f07d05ccb138dbb2c4ce77bdd4dc6c346253bd
--- /dev/null
+++ b/Tests/noDist/testAdaptiveSymChebFMM.cpp
@@ -0,0 +1,224 @@
+// ===================================================================================
+// 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.
+//
+// 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".
+// ===================================================================================
+
+// ==== CMAKE =====
+// @FUSE_BLAS
+// ================
+
+#include <iostream>
+#include <cstdio>
+
+
+#include "Utils/FParameters.hpp"
+#include "Utils/FTic.hpp"
+
+#include "Containers/FOctree.hpp"
+//#include "Containers/FVector.hpp"
+
+//#include "Components/FSimpleLeaf.hpp"
+
+#include "Utils/FPoint.hpp"
+
+#include "Files/FFmaGenericLoader.hpp"
+#include "Files/FRandomLoader.hpp"
+
+#include "Components/FBasicKernels.hpp"
+#include "Components/FSimpleIndexedLeaf.hpp"
+#include "Kernels/P2P/FP2PParticleContainerIndexed.hpp"
+
+#include "Kernels/Interpolation/FInterpMatrixKernel.hpp"
+#include "Kernels/Chebyshev/FChebCell.hpp"
+
+#include "AdaptiveTree/FAdaptChebSymKernel.hpp"
+#include "Adaptative/FAdaptiveCell.hpp"
+#include "Adaptative/FAdaptiveKernelWrapper.hpp"
+#include "Adaptative/FAbstractAdaptiveKernel.hpp"
+//
+#include "Kernels/Interpolation/FInterpMatrixKernel.hpp"
+#include "Kernels/Chebyshev/FChebCell.hpp"
+#include "AdaptiveTree/FAdaptChebSymKernel.hpp"
+#include "AdaptiveTree/FAdaptTools.hpp"
+//
+//
+#include "Core/FFmmAlgorithm.hpp"
+//#include "Core/FFmmAlgorithmThread.hpp"
+//#include "Core/FFmmAlgorithmTask.hpp"
+
+/** This program show an example of use of the fmm basic algo
+ * it also check that each particles is impacted each other particles
+ */
+
+void usage() {
+ std::cout << "Driver to obtain statistics on the octree" << std::endl;
+ std::cout << "Options "<< std::endl
+ << " -help to see the parameters " << std::endl
+ << " -depth the depth of the octree "<< std::endl
+ << " -subdepth specifies the size of the sub octree " << std::endl
+ << " -fin name specifies the name of the particle distribution" << std::endl
+ << " -sM s_min^M threshold for Multipole (l+1)^2 for Spherical harmonics"<<std::endl
+ << " -sL s_min^L threshold for Local (l+1)^2 for Spherical harmonics"<<std::endl;
+}
+// Simply create particles and try the kernels
+int main(int argc, char ** argv){
+ //
+ // accuracy
+ const unsigned int P = 3 ;
+ // typedef FTestCell CellClass;
+ // typedef FAdaptiveTestKernel< CellClass, ContainerClass > KernelClass;
+ typedef FChebCell<P> CellClass;
+ typedef FP2PParticleContainerIndexed<> ContainerClass;
+ typedef FSimpleIndexedLeaf<ContainerClass> LeafClass;
+ typedef FInterpMatrixKernelR MatrixKernelClass;
+ //
+ typedef FAdaptiveChebSymKernel<CellClass,ContainerClass,MatrixKernelClass,P> KernelClass;
+ //
+ //
+ typedef FAdaptiveCell< CellClass, ContainerClass > CellWrapperClass;
+ typedef FAdaptiveKernelWrapper< KernelClass, CellClass, ContainerClass > KernelWrapperClass;
+ typedef FOctree< CellWrapperClass, ContainerClass , LeafClass > OctreeClass;
+
+ // FFmmAlgorithmTask FFmmAlgorithmThread
+ typedef FFmmAlgorithm<OctreeClass, CellWrapperClass, ContainerClass, KernelWrapperClass, LeafClass > FmmClass;
+
+ ///////////////////////What we do/////////////////////////////
+ std::cout << ">> This executable has to be used to test the FMM algorithm.\n";
+ //////////////////////////////////////////////////////////////
+ //
+ const int NbLevels = FParameters::getValue(argc,argv,"-depth", 7);
+ const int SizeSubLevels = FParameters::getValue(argc,argv,"subdepth", 3);
+ const int sminM = FParameters::getValue(argc,argv,"-sM", P*P*P);
+ const int sminL = FParameters::getValue(argc,argv,"-sL", P*P*P);
+ //
+
+
+ FTic counter;
+
+ //////////////////////////////////////////////////////////////////////////////////
+ // Not Random Loader
+ //////////////////////////////////////////////////////////////////////////////////
+ const std::string fileName(FParameters::getStr(argc,argv,"-fin", "../Data/prolate50.fma"));
+ FFmaGenericLoader loader(fileName);
+ const long int NbPart = loader.getNumberOfParticles() ;
+ // Random Loader
+ //const int NbPart = FParameters::getValue(argc,argv,"-nb", 2000000);
+ // FRandomLoader loader(NbPart, 1, FPoint(0.5,0.5,0.5), 1);
+ //////////////////////////////////////////////////////////////////////////////////
+
+ OctreeClass tree(NbLevels, SizeSubLevels, loader.getBoxWidth(), loader.getCenterOfBox());
+
+ //////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////
+
+ std::cout << "Creating & Inserting " << NbPart << " particles ..." << std::endl;
+ std::cout << "\tHeight : " << NbLevels << " \t sub-height : " << SizeSubLevels << std::endl;
+ std::cout << " criteria SM: "<< sminM <<std::endl
+ << " criteria SL: "<< sminL <<std::endl <<std::endl;
+ //
+ {
+ counter.tic();
+ FReal L= loader.getBoxWidth();
+ FmaRParticle* particles= new FmaRParticle[NbPart];
+ FPoint minPos(L,L,L), maxPos(-L,-L,-L);
+ //
+ loader.fillParticle(particles,NbPart);
+
+ for(int idxPart = 0 ; idxPart < NbPart; ++idxPart){
+ const FPoint PP(particles[idxPart].getPosition() ) ;
+ //
+ minPos.setX(FMath::Min(minPos.getX(),PP.getX())) ;
+ minPos.setY(FMath::Min(minPos.getY(),PP.getY())) ;
+ minPos.setZ(FMath::Min(minPos.getZ(),PP.getZ())) ;
+ maxPos.setX(FMath::Max(maxPos.getX(),PP.getX())) ;
+ maxPos.setY(FMath::Max(maxPos.getY(),PP.getY())) ;
+ maxPos.setZ(FMath::Max(maxPos.getZ(),PP.getZ())) ;
+ //
+ tree.insert(PP, idxPart, particles[idxPart].getPhysicalValue());
+ }
+
+
+ counter.tac();
+ std::cout << "Data are inside the box delimited by "<<std::endl
+ << " Min corner: "<< minPos<<std::endl
+ << " Max corner: "<< maxPos<<std::endl <<std::endl;
+ std::cout << "Done " << "(@Creating and Inserting Particles = " << counter.elapsed() << " s)." << std::endl;
+ }
+ //////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////
+
+ std::cout << "Working on particles ..." << std::endl;
+ counter.tic();
+
+ KernelWrapperClass kernels(NbLevels, loader.getBoxWidth(), loader.getCenterOfBox());; // FTestKernels FBasicKernels
+ FmmClass algo(&tree,&kernels); //FFmmAlgorithm FFmmAlgorithmThread
+ algo.execute();
+
+ counter.tac();
+ std::cout << "Done " << "(@Algorithm = " << counter.elapsed() << " s)." << std::endl;
+
+ OctreeClass::Iterator octreeIterator(&tree);
+ std::ofstream file("aa.tree", std::ofstream::out );
+
+ //
+ ////////////////////////////////////////////////////////////////////
+ // Export adaptive tree in our format
+ ////////////////////////////////////////////////////////////////////
+ //
+ // -----------------------------------------------------
+ //
+ //
+ // Set Global id
+ //
+ long int idCell = setGlobalID(tree);
+ //////////////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////////////
+
+ tree.forEachCellLeaf([&](CellWrapperClass* cell, LeafClass* leaf){
+ std::cout << cell->getGlobalId( ) << " Nb particles "<< leaf->getSrc()->getNbParticles()<<std::endl;
+ });
+
+ octreeIterator.gotoTop() ; // here we are at level 1 (first child)
+ // octreeIterator.moveDown() ;
+ octreeIterator.gotoLeft();
+ // octreeIterator.moveDown() ; // We are at the levell 2
+ std::cout << " Number of Cells: " << idCell <<std::endl;
+ //
+ std::cout << "Top of the octree " << octreeIterator.level() << std::endl ;
+ for(int idxLevel = 1; idxLevel < NbLevels ; ++idxLevel){
+ file << std::endl << "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$"<< std::endl;
+ file << " Level " << idxLevel <<" Level "<< octreeIterator.level()<< " -- leave level " << std::boolalpha << octreeIterator.isAtLeafLevel() << std::endl;
+ do{
+ if(octreeIterator.getCurrentCell()->hasDevelopment()){
+ file <<*(octreeIterator.getCurrentCell())<< std::endl ;
+ }
+ } while(octreeIterator.moveRight());
+ octreeIterator.moveDown() ;
+ octreeIterator.gotoLeft();
+ }
+ std::cout << " END " << std::endl;
+
+ // Check
+ octreeIterator.gotoBottomLeft();
+ do {
+ std::cout << " Level " <<octreeIterator.level() <<std::endl;
+ }while(octreeIterator.moveUp() );
+ std::cout << " RETURN 0 " << std::endl;
+
+ return 0;
+}
+
+
+
+