Merge branch 'master' of git+ssh://scm.gforge.inria.fr//gitroot//scalfmm/scalfmm

Src/Components/FAbstractKernels.hpp

@@ -13,6 +13,7 @@
 
 
 #include "../Utils/FGlobal.hpp"
+#include "../Utils/FDebug.hpp"
 
 /**
 * @author Berenger Bramas (berenger.bramas@inria.fr)
@@ -110,7 +111,9 @@ public:
         */
     virtual void P2PRemote(const FTreeCoordinate& inLeafPosition,
              ContainerClass* const FRestrict targets, const ContainerClass* const FRestrict sources,
-                           ContainerClass* const directNeighborsParticles[27], const int size) { std::cout << "Error, implement P2PRemote!" << std::endl; };
+                           ContainerClass* const directNeighborsParticles[27], const int size) {
+        FDEBUG( FDebug::Controller.write("Warning, P2P remote is used but not implemented!").write(FDebug::Flush) );
+    }
 
 };
 

Src/Core/FFmmAlgorithmSectionTask.hpp

+
+// ===================================================================================
+// Logiciel initial: ScalFmm Version 0.5
+// Co-auteurs : Olivier Coulaud, Bérenger Bramas.
+// Propriétaires : INRIA.
+// Copyright © 2011-2012, diffusé sous les termes et conditions d’une licence propriétaire.
+// Initial software: ScalFmm Version 0.5
+// Co-authors: Olivier Coulaud, Bérenger Bramas.
+// Owners: INRIA.
+// Copyright © 2011-2012, spread under the terms and conditions of a proprietary license.
+// ===================================================================================
+#ifndef FFMMALGORITHMTASK_HPP
+#define FFMMALGORITHMTASK_HPP
+
+
+#include "../Utils/FGlobal.hpp"
+#include "../Utils/FAssertable.hpp"
+#include "../Utils/FDebug.hpp"
+#include "../Utils/FTrace.hpp"
+#include "../Utils/FTic.hpp"
+
+#include "../Containers/FOctree.hpp"
+#include "../Containers/FVector.hpp"
+
+
+/**
+* @author Berenger Bramas (berenger.bramas@inria.fr)
+* @class FFmmAlgorithmSectionTask
+* @brief
+* Please read the license
+*
+* This class is a basic FMM algorithm
+* It just iterates on a tree and call the kernels with good arguments.
+*
+* Of course this class does not deallocate pointer given in arguements.
+*/
+template<class OctreeClass, class ParticleClass, class CellClass, class ContainerClass, class KernelClass, class LeafClass>
+class FFmmAlgorithmSectionTask : protected FAssertable{
+
+    OctreeClass* const tree;       //< The octree to work on
+    KernelClass** kernels;    //< The kernels
+
+    const int MaxThreads;
+
+    const int OctreeHeight;
+
+public:
+    /** The constructor need the octree and the kernels used for computation
+      * @param inTree the octree to work on
+      * @param inKernels the kernels to call
+      * An assert is launched if one of the arguments is null
+      */
+    FFmmAlgorithmSectionTask(OctreeClass* const inTree, KernelClass* const inKernels)
+        : tree(inTree) , kernels(0),
+          MaxThreads(omp_get_max_threads()), OctreeHeight(tree->getHeight())
+    {
+
+        fassert(tree, "tree cannot be null", __LINE__, __FILE__);
+        fassert(inKernels, "kernels cannot be null", __LINE__, __FILE__);
+
+        this->kernels = new KernelClass*[MaxThreads];
+        for(int idxThread = 0 ; idxThread < MaxThreads ; ++idxThread){
+            this->kernels[idxThread] = new KernelClass(*inKernels);
+        }
+
+        FDEBUG(FDebug::Controller << "FFmmAlgorithmSectionTask (Max Thread " << omp_get_max_threads() << ")\n");
+    }
+
+    /** Default destructor */
+    virtual ~FFmmAlgorithmSectionTask(){
+        for(int idxThread = 0 ; idxThread < MaxThreads ; ++idxThread){
+            delete this->kernels[idxThread];
+        }
+        delete [] this->kernels;
+    }
+
+    /**
+      * To execute the fmm algorithm
+      * Call this function to run the complete algorithm
+      */
+    void execute(){
+        FTRACE( FTrace::FFunction functionTrace(__FUNCTION__, "Fmm" , __FILE__ , __LINE__) );
+
+        #pragma omp parallel
+        {
+            #pragma omp sections
+            {
+                #pragma omp section
+                {
+                    bottomPass();
+
+                    upwardPass();
+
+                    transferPass();
+
+                    downardPass();
+                }
+                #pragma omp section
+                {
+                    directPass();
+                }
+            }
+            #pragma omp single
+            {
+                L2PPass();
+            }
+        }
+    }
+
+private:
+    /////////////////////////////////////////////////////////////////////////////
+    // P2M
+    /////////////////////////////////////////////////////////////////////////////
+
+    /** P2M */
+    void bottomPass(){
+        FTRACE( FTrace::FFunction functionTrace(__FUNCTION__, "Fmm" , __FILE__ , __LINE__) );
+        FDEBUG( FDebug::Controller.write("\tStart Bottom Pass\n").write(FDebug::Flush) );
+        FDEBUG(FTic counterTime);
+
+        typename OctreeClass::Iterator octreeIterator(tree);
+
+        // Iterate on leafs
+        octreeIterator.gotoBottomLeft();
+        do{
+            // We need the current cell that represent the leaf
+            // and the list of particles
+            #pragma omp task firstprivate(octreeIterator)
+            {
+                kernels[omp_get_thread_num()]->P2M( octreeIterator.getCurrentCell() , octreeIterator.getCurrentListSrc());
+            }
+        } while(octreeIterator.moveRight());
+
+        #pragma omp taskwait
+
+
+        FDEBUG( FDebug::Controller << "\tFinished (@Bottom Pass (P2M) = "  << counterTime.tacAndElapsed() << "s)\n" );
+    }
+
+    /////////////////////////////////////////////////////////////////////////////
+    // Upward
+    /////////////////////////////////////////////////////////////////////////////
+
+    /** M2M */
+    void upwardPass(){
+        FTRACE( FTrace::FFunction functionTrace(__FUNCTION__, "Fmm" , __FILE__ , __LINE__) );
+        FDEBUG( FDebug::Controller.write("\tStart Upward Pass\n").write(FDebug::Flush); );
+        FDEBUG(FTic counterTime);
+
+        // Start from leal level - 1
+        typename OctreeClass::Iterator octreeIterator(tree);
+        octreeIterator.gotoBottomLeft();
+        octreeIterator.moveUp();
+
+        typename OctreeClass::Iterator avoidGotoLeftIterator(octreeIterator);
+
+        // for each levels
+        for(int idxLevel = OctreeHeight - 2 ; idxLevel > 1 ; --idxLevel ){
+            FDEBUG(FTic counterTimeLevel);
+            // for each cells
+            do{
+                // We need the current cell and the child
+                // child is an array (of 8 child) that may be null
+                #pragma omp task firstprivate(octreeIterator) shared(idxLevel)
+                {
+                    kernels[omp_get_thread_num()]->M2M( octreeIterator.getCurrentCell() , octreeIterator.getCurrentChild(), idxLevel);
+                }
+            } while(octreeIterator.moveRight());
+
+            avoidGotoLeftIterator.moveUp();
+            octreeIterator = avoidGotoLeftIterator;// equal octreeIterator.moveUp(); octreeIterator.gotoLeft();
+
+            #pragma omp taskwait
+            FDEBUG( FDebug::Controller << "\t\t>> Level " << idxLevel << " = "  << counterTimeLevel.tacAndElapsed() << "s\n" );
+        }
+
+
+        FDEBUG( FDebug::Controller << "\tFinished (@Upward Pass (M2M) = "  << counterTime.tacAndElapsed() << "s)\n" );
+    }
+
+    /////////////////////////////////////////////////////////////////////////////
+    // Transfer
+    /////////////////////////////////////////////////////////////////////////////
+
+    /** M2L L2L */
+    void transferPass(){
+        FTRACE( FTrace::FFunction functionTrace(__FUNCTION__, "Fmm" , __FILE__ , __LINE__) );
+
+        FDEBUG( FDebug::Controller.write("\tStart Downward Pass (M2L)\n").write(FDebug::Flush); );
+        FDEBUG(FTic counterTime);
+
+        const CellClass* neighbors[343];
+
+        typename OctreeClass::Iterator octreeIterator(tree);
+        octreeIterator.moveDown();
+
+        typename OctreeClass::Iterator avoidGotoLeftIterator(octreeIterator);
+
+
+        // for each levels
+        for(int idxLevel = 2 ; idxLevel < OctreeHeight ; ++idxLevel ){
+            FDEBUG(FTic counterTimeLevel);
+            // for each cells
+            do{
+                int counter = tree->getInteractionNeighbors(neighbors, octreeIterator.getCurrentGlobalCoordinate(), idxLevel);
+                if(counter){
+                    #pragma omp task firstprivate(octreeIterator, neighbors, counter) shared(idxLevel)
+                    {
+                        kernels[omp_get_thread_num()]->M2L( octreeIterator.getCurrentCell() , neighbors, counter, idxLevel);
+                    }
+                }
+
+            } while(octreeIterator.moveRight());
+
+            avoidGotoLeftIterator.moveDown();
+            octreeIterator = avoidGotoLeftIterator;
+
+            #pragma omp taskwait
+
+            for( int idxThread = 0 ; idxThread < omp_get_num_threads() ; ++idxThread){
+                #pragma omp task
+                {
+                    kernels[idxThread]->finishedLevelM2L(idxLevel);
+                }
+            }
+
+            #pragma omp taskwait
+            FDEBUG( FDebug::Controller << "\t\t>> Level " << idxLevel << " = "  << counterTimeLevel.tacAndElapsed() << "s\n" );
+        }
+
+        FDEBUG( FDebug::Controller << "\tFinished (@Downward Pass (M2L) = "  << counterTime.tacAndElapsed() << "s)\n" );
+    }
+
+    /////////////////////////////////////////////////////////////////////////////
+    // Downward
+    /////////////////////////////////////////////////////////////////////////////
+
+    void downardPass(){ // second L2L
+        FTRACE( FTrace::FFunction functionTrace(__FUNCTION__, "Fmm" , __FILE__ , __LINE__) );
+        FDEBUG( FDebug::Controller.write("\tStart Downward Pass (L2L)\n").write(FDebug::Flush); );
+        FDEBUG(FTic counterTime);
+
+        typename OctreeClass::Iterator octreeIterator(tree);
+        octreeIterator.moveDown();
+
+        typename OctreeClass::Iterator avoidGotoLeftIterator(octreeIterator);
+
+        const int heightMinusOne = OctreeHeight - 1;
+        // for each levels exepted leaf level
+        for(int idxLevel = 2 ; idxLevel < heightMinusOne ; ++idxLevel ){
+            FDEBUG(FTic counterTimeLevel);
+            // for each cells
+            do{
+                #pragma omp task firstprivate(octreeIterator) shared(idxLevel)
+                {
+                    kernels[omp_get_thread_num()]->L2L( octreeIterator.getCurrentCell() , octreeIterator.getCurrentChild(), idxLevel);
+                }
+
+            } while(octreeIterator.moveRight());
+
+            avoidGotoLeftIterator.moveDown();
+            octreeIterator = avoidGotoLeftIterator;
+
+            #pragma omp taskwait
+            FDEBUG( FDebug::Controller << "\t\t>> Level " << idxLevel << " = "  << counterTimeLevel.tacAndElapsed() << "s\n" );
+        }
+
+        FDEBUG( FDebug::Controller << "\tFinished (@Downward Pass (L2L) = "  << counterTime.tacAndElapsed() << "s)\n" );
+    }
+
+
+    /////////////////////////////////////////////////////////////////////////////
+    // Direct
+    /////////////////////////////////////////////////////////////////////////////
+
+    /** P2P */
+    void directPass(){
+        FTRACE( FTrace::FFunction functionTrace(__FUNCTION__, "Fmm" , __FILE__ , __LINE__) );
+        FDEBUG( FDebug::Controller.write("\tStart Direct Pass\n").write(FDebug::Flush); );
+        FDEBUG(FTic counterTime);
+        FDEBUG(FTic computationCounter);
+
+        const int heightMinusOne = OctreeHeight - 1;
+
+        // There is a maximum of 26 neighbors
+        ContainerClass* neighbors[27];
+
+        const int SizeShape = 3*3*3;
+        FVector<typename OctreeClass::Iterator> shapes[SizeShape];
+
+        typename OctreeClass::Iterator octreeIterator(tree);
+        octreeIterator.gotoBottomLeft();
+
+        // for each leafs
+        do{
+            const FTreeCoordinate& coord = octreeIterator.getCurrentGlobalCoordinate();
+            const int shapePosition = (coord.getX()%3)*9 + (coord.getY()%3)*3 + (coord.getZ()%3);
+
+            shapes[shapePosition].push(octreeIterator);
+
+        } while(octreeIterator.moveRight());
+
+        FDEBUG( computationCounter.tic() );
+
+        for( int idxShape = 0 ; idxShape < SizeShape ; ++idxShape){
+            const int nbLeaf = shapes[idxShape].getSize();
+            for(int iterLeaf = 0 ; iterLeaf < nbLeaf ; ++iterLeaf ){
+                typename OctreeClass::Iterator toWork = shapes[idxShape][iterLeaf];
+                #pragma omp task firstprivate(neighbors, toWork)
+                {
+                    const int counter = tree->getLeafsNeighbors(neighbors, toWork.getCurrentGlobalCoordinate(),heightMinusOne);
+                    kernels[omp_get_thread_num()]->P2P(toWork.getCurrentGlobalCoordinate(), toWork.getCurrentListTargets(),
+                                         toWork.getCurrentListSrc(), neighbors, counter);
+                }
+            }
+
+            #pragma omp taskwait
+        }
+
+        FDEBUG( computationCounter.tac() );
+
+
+        FDEBUG( FDebug::Controller << "\tFinished (@Direct Pass (P2P) = "  << counterTime.tacAndElapsed() << "s)\n" );
+        FDEBUG( FDebug::Controller << "\t\t Computation P2P : " << computationCounter.cumulated() << " s\n" );
+    }
+
+    void L2PPass(){
+        FTRACE( FTrace::FFunction functionTrace(__FUNCTION__, "Fmm" , __FILE__ , __LINE__) );
+        FDEBUG( FDebug::Controller.write("\tStart L2P Pass\n").write(FDebug::Flush); );
+        FDEBUG(FTic counterTime);
+
+        typename OctreeClass::Iterator octreeIterator(tree);
+        octreeIterator.gotoBottomLeft();
+
+        // for each leafs
+        do{
+            #pragma omp task firstprivate(octreeIterator)
+            {
+                kernels[omp_get_thread_num()]->L2P(octreeIterator.getCurrentCell(), octreeIterator.getCurrentListTargets());
+            }
+        } while(octreeIterator.moveRight());
+
+        #pragma omp taskwait
+
+        FDEBUG( FDebug::Controller << "\tFinished (@Direct Pass (L2P) = "  << counterTime.tacAndElapsed() << "s)\n" );
+    }
+
+};
+
+
+#endif //FFMMALGORITHMTASK_HPP
+
+

Src/Kernels/Spherical/FAbstractSphericalKernel.hpp

@@ -853,9 +853,9 @@ public:
       */
     void directInteractionMutual(ParticleClass*const FRestrict target, ParticleClass*const FRestrict source){
 
-        FReal dx = -(target->getPosition().getX() - source->getPosition().getX());
-        FReal dy = -(target->getPosition().getY() - source->getPosition().getY());
-        FReal dz = -(target->getPosition().getZ() - source->getPosition().getZ());
+        FReal dx = source->getPosition().getX() - target->getPosition().getX();
+        FReal dy = source->getPosition().getY() - target->getPosition().getY();
+        FReal dz = source->getPosition().getZ() - target->getPosition().getZ();
 
         FReal inv_square_distance = FReal(1.0) / (dx*dx + dy*dy + dz*dz);
         FReal inv_distance = FMath::Sqrt(inv_square_distance);
@@ -880,9 +880,9 @@ public:
       */
     void directInteraction(ParticleClass*const FRestrict target, const ParticleClass& source){
 
-        FReal dx = -(target->getPosition().getX() - source.getPosition().getX());
-        FReal dy = -(target->getPosition().getY() - source.getPosition().getY());
-        FReal dz = -(target->getPosition().getZ() - source.getPosition().getZ());
+        FReal dx = source.getPosition().getX() - target->getPosition().getX();
+        FReal dy = source.getPosition().getY() - target->getPosition().getY();
+        FReal dz = source.getPosition().getZ() - target->getPosition().getZ();
 
         FReal inv_square_distance = FReal(1.0) / (dx*dx + dy*dy + dz*dz);
         FReal inv_distance = FMath::Sqrt(inv_square_distance);

Tests/testSphericalAlgorithm.cpp → Tests/Kernels/testSphericalAlgorithm.cpp

@@ -14,22 +14,22 @@
 #include <cstdio>
 #include <cstdlib>
 
-#include "../Src/Utils/FTic.hpp"
-#include "../Src/Utils/FParameters.hpp"
+#include "../../Src/Utils/FTic.hpp"
+#include "../../Src/Utils/FParameters.hpp"
 
-#include "../Src/Containers/FOctree.hpp"
-#include "../Src/Containers/FVector.hpp"
+#include "../../Src/Containers/FOctree.hpp"
+#include "../../Src/Containers/FVector.hpp"
 
-#include "../Src/Core/FFmmAlgorithm.hpp"
-#include "../Src/Core/FFmmAlgorithmThread.hpp"
-#include "../Src/Core/FFmmAlgorithmTask.hpp"
+#include "../../Src/Core/FFmmAlgorithm.hpp"
+#include "../../Src/Core/FFmmAlgorithmThread.hpp"
+#include "../../Src/Core/FFmmAlgorithmTask.hpp"
 
-#include "../Src/Kernels/Spherical/FSphericalKernel.hpp"
-#include "../Src/Kernels/Spherical/FSphericalCell.hpp"
-#include "../Src/Kernels/Spherical/FSphericalParticle.hpp"
-#include "../Src/Components/FSimpleLeaf.hpp"
+#include "../../Src/Kernels/Spherical/FSphericalKernel.hpp"
+#include "../../Src/Kernels/Spherical/FSphericalCell.hpp"
+#include "../../Src/Kernels/Spherical/FSphericalParticle.hpp"
+#include "../../Src/Components/FSimpleLeaf.hpp"
 
-#include "../Src/Files/FFmaLoader.hpp"
+#include "../../Src/Files/FFmaLoader.hpp"
 
 
 /** This program show an example of use of

Tests/testSphericalBlasAlgorithm.cpp → Tests/Kernels/testSphericalBlasAlgorithm.cpp

@@ -18,24 +18,24 @@
 #include <cstdio>
 #include <cstdlib>
 
-#include "../Src/Utils/FTic.hpp"
-#include "../Src/Utils/FParameters.hpp"
+#include "../../Src/Utils/FTic.hpp"
+#include "../../Src/Utils/FParameters.hpp"
 
-#include "../Src/Containers/FOctree.hpp"
-#include "../Src/Containers/FVector.hpp"
+#include "../../Src/Containers/FOctree.hpp"
+#include "../../Src/Containers/FVector.hpp"
 
-#include "../Src/Core/FFmmAlgorithm.hpp"
-#include "../Src/Core/FFmmAlgorithmThread.hpp"
-#include "../Src/Core/FFmmAlgorithmTask.hpp"
+#include "../../Src/Core/FFmmAlgorithm.hpp"
+#include "../../Src/Core/FFmmAlgorithmThread.hpp"
+#include "../../Src/Core/FFmmAlgorithmTask.hpp"
 
-#include "../Src/Components/FSimpleLeaf.hpp"
+#include "../../Src/Components/FSimpleLeaf.hpp"
 
-#include "../Src/Kernels/Spherical/FSphericalKernel.hpp"
-#include "../Src/Kernels/Spherical/FSphericalBlasKernel.hpp"
-#include "../Src/Kernels/Spherical/FSphericalCell.hpp"
-#include "../Src/Kernels/Spherical/FSphericalParticle.hpp"
+#include "../../Src/Kernels/Spherical/FSphericalKernel.hpp"
+#include "../../Src/Kernels/Spherical/FSphericalBlasKernel.hpp"
+#include "../../Src/Kernels/Spherical/FSphericalCell.hpp"
+#include "../../Src/Kernels/Spherical/FSphericalParticle.hpp"
 
-#include "../Src/Files/FFmaScanfLoader.hpp"
+#include "../../Src/Files/FFmaScanfLoader.hpp"
 
 /** This program show an example of use of
   * the fmm blas algo

Tests/testSphericalBlockBlasAlgorithm.cpp → Tests/Kernels/testSphericalBlockBlasAlgorithm.cpp

@@ -18,24 +18,24 @@
 #include <cstdio>
 #include <cstdlib>
 
-#include "../Src/Utils/FTic.hpp"
-#include "../Src/Utils/FParameters.hpp"
+#include "../../Src/Utils/FTic.hpp"
+#include "../../Src/Utils/FParameters.hpp"
 
-#include "../Src/Containers/FOctree.hpp"
-#include "../Src/Containers/FVector.hpp"
+#include "../../Src/Containers/FOctree.hpp"
+#include "../../Src/Containers/FVector.hpp"
 
-#include "../Src/Core/FFmmAlgorithm.hpp"
-#include "../Src/Core/FFmmAlgorithmThread.hpp"
-#include "../Src/Core/FFmmAlgorithmTask.hpp"
+#include "../../Src/Core/FFmmAlgorithm.hpp"
+#include "../../Src/Core/FFmmAlgorithmThread.hpp"
+#include "../../Src/Core/FFmmAlgorithmTask.hpp"
 
-#include "../Src/Components/FSimpleLeaf.hpp"
-#include "../Src/Components/FBasicCell.hpp"
+#include "../../Src/Components/FSimpleLeaf.hpp"
+#include "../../Src/Components/FBasicCell.hpp"
 
-#include "../Src/Kernels/Spherical/FSphericalBlockBlasKernel.hpp"
-#include "../Src/Kernels/Spherical/FSphericalParticle.hpp"
-#include "../Src/Kernels/Spherical/FSphericalCell.hpp"
+#include "../../Src/Kernels/Spherical/FSphericalBlockBlasKernel.hpp"
+#include "../../Src/Kernels/Spherical/FSphericalParticle.hpp"
+#include "../../Src/Kernels/Spherical/FSphericalCell.hpp"
 
-#include "../Src/Files/FFmaScanfLoader.hpp"
+#include "../../Src/Files/FFmaScanfLoader.hpp"
 
 /** This program show an example of use of
   * the fmm basic algo

Tests/testSphericalEwalAlgorithm.cpp → Tests/Kernels/testSphericalEwalAlgorithm.cpp

@@ -14,20 +14,20 @@
 #include <cstdio>
 #include <cstdlib>
 
-#include "../Src/Utils/FTic.hpp"
-#include "../Src/Utils/FParameters.hpp"
+#include "../../Src/Utils/FTic.hpp"
+#include "../../Src/Utils/FParameters.hpp"
 
-#include "../Src/Containers/FOctree.hpp"
-#include "../Src/Containers/FVector.hpp"
+#include "../../Src/Containers/FOctree.hpp"
+#include "../../Src/Containers/FVector.hpp"
 
-#include "../Src/Core/FFmmAlgorithmPeriodic.hpp"
+#include "../../Src/Core/FFmmAlgorithmPeriodic.hpp"
 
-#include "../Src/Kernels/Spherical/FSphericalKernel.hpp"
-#include "../Src/Kernels/Spherical/FSphericalCell.hpp"
-#include "../Src/Kernels/Spherical/FSphericalParticle.hpp"
+#include "../../Src/Kernels/Spherical/FSphericalKernel.hpp"
+#include "../../Src/Kernels/Spherical/FSphericalCell.hpp"
+#include "../../Src/Kernels/Spherical/FSphericalParticle.hpp"
 
-#include "../Src/Files/FEwalLoader.hpp"
-#include "../Src/Components/FSimpleLeaf.hpp"
+#include "../../Src/Files/FEwalLoader.hpp"
+#include "../../Src/Components/FSimpleLeaf.hpp"
 
 /** Ewal particle is used in the gadget program
   * here we try to make the same simulation

Tests/testSphericalGalaxyCsv.cpp → Tests/Kernels/testSphericalGalaxyCsv.cpp

@@ -14,26 +14,26 @@
 #include <cstdio>
 #include <cstdlib>
 
-#include "../Src/Utils/FTic.hpp"
-#include "../Src/Utils/FParameters.hpp"
+#include "../../Src/Utils/FTic.hpp"
+#include "../../Src/Utils/FParameters.hpp"
 
-#include "../Src/Containers/FOctree.hpp"
-#include "../Src/Containers/FVector.hpp"
+#include "../../Src/Containers/FOctree.hpp"
+#include "../../Src/Containers/FVector.hpp"
 
-#include "../Src/Core/FFmmAlgorithm.hpp"
-#include "../Src/Core/FFmmAlgorithmThread.hpp"
+#include "../../Src/Core/FFmmAlgorithm.hpp"
+#include "../../Src/Core/FFmmAlgorithmThread.hpp"
 
-#include "../Src/Kernels/Spherical/FSphericalKernel.hpp"
-#include "../Src/Kernels/Spherical/FSphericalCell.hpp"
-#include "../Src/Kernels/Spherical/FSphericalParticle.hpp"
+#include "../../Src/Kernels/Spherical/FSphericalKernel.hpp"
+#include "../../Src/Kernels/Spherical/FSphericalCell.hpp"
+#include "../../Src/Kernels/Spherical/FSphericalParticle.hpp"
 
-#include "../Src/Extensions/FExtendVelocity.hpp"
+#include "../../Src/Extensions/FExtendVelocity.hpp"
 
-#include "../Src/Files/FTreeCsvSaver.hpp"
-#include "../Src/Files/FFmaLoader.hpp"
-#include "../Src/Arranger/FOctreeArranger.hpp"
+#include "../../Src/Files/FTreeCsvSaver.hpp"
+#include "../../Src/Files/FFmaLoader.hpp"
+#include "../../Src/Arranger/FOctreeArranger.hpp"
 
-#include "../Src/Components/FSimpleLeaf.hpp"
+#include "../../Src/Components/FSimpleLeaf.hpp"
 
 class FmmVeloParticle : public FSphericalParticle, public FExtendVelocity {
 };

Tests/testSphericalProcAlgorithm.cpp → Tests/Kernels/testSphericalProcAlgorithm.cpp

@@ -13,26 +13,26 @@
 // @FUSE_MPI
 // ================
 
-#include "../Src/Utils/FTic.hpp"
-#include "../Src/Utils/FMpi.hpp"
-#include "../Src/Utils/FParameters.hpp"
-#include "../Src/Utils/FMath.hpp"
+#include "../../Src/Utils/FTic.hpp"
+#include "../../Src/Utils/FMpi.hpp"
+#include "../../Src/Utils/FParameters.hpp"
+#include "../../Src/Utils/FMath.hpp"