From 799e9fc2289fda4701f751e0c2952a42a87c78b0 Mon Sep 17 00:00:00 2001 From: bramas Date: Wed, 16 Oct 2013 17:44:13 +0200 Subject: [PATCH] update TSM model using enum to enable tsm and index, but should be update and the result are wrong --- Src/Components/FBasicParticleContainer.hpp | 3 +- Src/Components/FParticleType.hpp | 24 ++ Src/Components/FTypedLeaf.hpp | 9 +- Src/Files/FFmaTsmLoader.hpp | 6 +- Src/Files/FRandomLoader.hpp | 6 +- .../P2P/FP2PParticleContainerIndexed.hpp | 5 +- Tests/Kernels/testSphericalTsmAlgorithm.cpp | 6 +- Tests/Utils/testFmmAlgorithmTsm.cpp | 6 +- Tests/Utils/testLoaderFMATsm.cpp | 6 +- UTests/utestRotationDirectTsm.cpp | 240 ++++++++++++++++++ 10 files changed, 292 insertions(+), 19 deletions(-) create mode 100644 Src/Components/FParticleType.hpp create mode 100644 UTests/utestRotationDirectTsm.cpp diff --git a/Src/Components/FBasicParticleContainer.hpp b/Src/Components/FBasicParticleContainer.hpp index 5dc496fc..1c09c260 100755 --- a/Src/Components/FBasicParticleContainer.hpp +++ b/Src/Components/FBasicParticleContainer.hpp @@ -21,6 +21,7 @@ #include "../Utils/FAlignedMemory.hpp" #include "../Utils/FMath.hpp" #include "../Utils/FPoint.hpp" +#include "FParticleType.hpp" /** * @author Berenger Bramas (berenger.bramas@inria.fr) @@ -200,7 +201,7 @@ public: * Push called usually by FTypedLeaf with the isTarget flag in addition */ template - void push(const FPoint& inParticlePosition, const bool /*isTarget*/, Args... args){ + void push(const FPoint& inParticlePosition, const FParticleType /*particleType*/, Args... args){ push(inParticlePosition, args...); } diff --git a/Src/Components/FParticleType.hpp b/Src/Components/FParticleType.hpp new file mode 100644 index 00000000..8edd0d89 --- /dev/null +++ b/Src/Components/FParticleType.hpp @@ -0,0 +1,24 @@ +// =================================================================================== +// Copyright ScalFmm 2011 INRIA, Olivier Coulaud, Bérenger 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". +// =================================================================================== +#ifndef FPARTICLETYPE_HPP +#define FPARTICLETYPE_HPP + +enum FParticleType { + FParticleTypeSource = 0, + FParticleTypeTarget = 1 +}; + +#endif // FPARTICLETYPE_HPP diff --git a/Src/Components/FTypedLeaf.hpp b/Src/Components/FTypedLeaf.hpp index 8f590601..1fc1a65d 100755 --- a/Src/Components/FTypedLeaf.hpp +++ b/Src/Components/FTypedLeaf.hpp @@ -19,6 +19,8 @@ #include "../Utils/FAssertable.hpp" #include "FAbstractLeaf.hpp" +#include "FParticleType.hpp" + /** * @author Berenger Bramas (berenger.bramas@inria.fr) @@ -36,6 +38,7 @@ class FTypedLeaf : public FAbstractLeaf, public FAssertable { ContainerClass targets; //< The targets containers public: + /** Default destructor */ virtual ~FTypedLeaf(){ } @@ -47,9 +50,9 @@ public: * followed by other param given by the user */ template - void push(const FPoint& inParticlePosition, const bool isTarget, Args ... args){ - if(isTarget) targets.push(inParticlePosition, isTarget, args...); - else sources.push(inParticlePosition, isTarget, args...); + void push(const FPoint& inParticlePosition, const FParticleType type, Args ... args){ + if(type == FParticleTypeTarget) targets.push(inParticlePosition, FParticleTypeTarget, args...); + else sources.push(inParticlePosition, FParticleTypeSource, args...); } /** diff --git a/Src/Files/FFmaTsmLoader.hpp b/Src/Files/FFmaTsmLoader.hpp index e372cdcd..4c5356ee 100755 --- a/Src/Files/FFmaTsmLoader.hpp +++ b/Src/Files/FFmaTsmLoader.hpp @@ -23,6 +23,7 @@ #include "../Utils/FGlobal.hpp" #include "FAbstractLoader.hpp" #include "../Utils/FPoint.hpp" +#include "../Components/FParticleType.hpp" /** * @author Berenger Bramas (berenger.bramas@inria.fr) @@ -122,14 +123,15 @@ public: * @warning to work with the loader, particles has to expose a setPosition method * @param the particle to fill */ - void fillParticle(FPoint*const inParticlePositions, FReal*const inPhysicalValue, bool*const inIsTarget){ + void fillParticle(FPoint*const inParticlePositions, FReal*const inPhysicalValue, FParticleType*const particleType){ FReal x,y,z,data; int isTarget; this->file >> x >> y >> z >> data >> isTarget; inParticlePositions->setPosition(x,y,z); *inPhysicalValue = data; - *inIsTarget = isTarget; + if(isTarget) (*particleType) = FParticleTypeTarget; + else (*particleType) = FParticleTypeSource; } }; diff --git a/Src/Files/FRandomLoader.hpp b/Src/Files/FRandomLoader.hpp index 21fce59d..7b59de0e 100755 --- a/Src/Files/FRandomLoader.hpp +++ b/Src/Files/FRandomLoader.hpp @@ -25,6 +25,7 @@ #include "FAbstractLoader.hpp" #include "../Utils/FPoint.hpp" +#include "../Components/FParticleType.hpp" /** * @author Berenger Bramas (berenger.bramas@inria.fr) @@ -114,9 +115,10 @@ public: } - void fillParticle(FPoint*const inParticlePositions, bool*const isTarget){ + void fillParticle(FPoint*const inParticlePositions, FParticleType*const isTarget){ FRandomLoader::fillParticle(inParticlePositions); - (*isTarget) = (FRandomLoader::getRandom() > 0.5 ); + if(FRandomLoader::getRandom() > 0.5 ) (*isTarget) = FParticleTypeTarget; + else (*isTarget) = FParticleTypeSource; } }; diff --git a/Src/Kernels/P2P/FP2PParticleContainerIndexed.hpp b/Src/Kernels/P2P/FP2PParticleContainerIndexed.hpp index 6ec6097b..a74440e4 100644 --- a/Src/Kernels/P2P/FP2PParticleContainerIndexed.hpp +++ b/Src/Kernels/P2P/FP2PParticleContainerIndexed.hpp @@ -4,6 +4,7 @@ #include "../../Containers/FVector.hpp" #include "FP2PParticleContainer.hpp" +#include "../../Components/FParticleType.hpp" class FP2PParticleContainerIndexed : public FP2PParticleContainer { typedef FP2PParticleContainer Parent; @@ -18,8 +19,8 @@ public: } template - void push(const FPoint& inParticlePosition, const bool isTarget, const int index, Args... args){ - Parent::push(inParticlePosition, isTarget, args... ); + void push(const FPoint& inParticlePosition, const FParticleType particleType, const int index, Args... args){ + Parent::push(inParticlePosition, particleType, args... ); indexes.push(index); } diff --git a/Tests/Kernels/testSphericalTsmAlgorithm.cpp b/Tests/Kernels/testSphericalTsmAlgorithm.cpp index f953cb7d..bda26e84 100755 --- a/Tests/Kernels/testSphericalTsmAlgorithm.cpp +++ b/Tests/Kernels/testSphericalTsmAlgorithm.cpp @@ -83,9 +83,9 @@ int main(int argc, char ** argv){ for(int idxPart = 0 ; idxPart < loader.getNumberOfParticles() ; ++idxPart){ FPoint particlePosition; FReal physicalValue = 0.0; - bool isTarget; - loader.fillParticle(&particlePosition,&physicalValue,&isTarget); - tree.insert(particlePosition, isTarget, physicalValue ); + FParticleType particleType; + loader.fillParticle(&particlePosition,&physicalValue,&particleType); + tree.insert(particlePosition, particleType, physicalValue ); } counter.tac(); diff --git a/Tests/Utils/testFmmAlgorithmTsm.cpp b/Tests/Utils/testFmmAlgorithmTsm.cpp index 1355b4f1..5dd9f025 100755 --- a/Tests/Utils/testFmmAlgorithmTsm.cpp +++ b/Tests/Utils/testFmmAlgorithmTsm.cpp @@ -83,10 +83,10 @@ int main(int argc, char ** argv){ { FPoint particlePosition; - bool isTarget; + FParticleType particleType; for(int idxPart = 0 ; idxPart < loader.getNumberOfParticles() ; ++idxPart){ - loader.fillParticle(&particlePosition, &isTarget); - tree.insert(particlePosition, isTarget); + loader.fillParticle(&particlePosition, &particleType); + tree.insert(particlePosition, particleType); } } diff --git a/Tests/Utils/testLoaderFMATsm.cpp b/Tests/Utils/testLoaderFMATsm.cpp index 747150d3..f1fcd19c 100755 --- a/Tests/Utils/testLoaderFMATsm.cpp +++ b/Tests/Utils/testLoaderFMATsm.cpp @@ -72,10 +72,10 @@ int main(int argc, char ** argv ){ FPoint particlePosition; FReal physicalValue = 0.0; - bool isTarget; + FParticleType particleType; for(int idxPart = 0 ; idxPart < loader.getNumberOfParticles() ; ++idxPart){ - loader.fillParticle(&particlePosition,&physicalValue, &isTarget); - tree.insert(particlePosition, isTarget, physicalValue); + loader.fillParticle(&particlePosition,&physicalValue, &particleType); + tree.insert(particlePosition, particleType, physicalValue); } counter.tac(); diff --git a/UTests/utestRotationDirectTsm.cpp b/UTests/utestRotationDirectTsm.cpp new file mode 100644 index 00000000..12152da3 --- /dev/null +++ b/UTests/utestRotationDirectTsm.cpp @@ -0,0 +1,240 @@ + +// =================================================================================== +// Copyright ScalFmm 2011 INRIA, Olivier Coulaud, Bérenger 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". +// =================================================================================== + +#include "../Src/Utils/FGlobal.hpp" + +#include "../Src/Containers/FOctree.hpp" +#include "../Src/Containers/FVector.hpp" + +#include "../Src/Kernels/Rotation/FRotationCell.hpp" +#include "../Src/Kernels/P2P/FP2PParticleContainerIndexed.hpp" + +#include "../Src/Components/FTypedLeaf.hpp" +#include "../Src/Extensions/FExtendCellType.hpp" +#include "../Src/Kernels/Rotation/FRotationKernel.hpp" + +#include "../Src/Files/FRandomLoader.hpp" + +#include "../Src/Core/FFmmAlgorithmThreadTsm.hpp" +#include "../Src/Core/FFmmAlgorithmTsm.hpp" + +#include "FUTester.hpp" + + +/** the test class the rotation and target source model. + * + */ +class TestRotationDirectTsm : public FUTester { + /** The test method to factorize all the test based on different kernels */ + template + void RunTest(){ + // Warning in make test the exec dir it Build/UTests + // Load particles + const int nbSources = 5000; + const int nbTargets = 5000; + + FRandomLoader loader(nbSources + nbTargets); + + Print("Number of particles:"); + Print(loader.getNumberOfParticles()); + + const int NbLevels = 4; + const int SizeSubLevels = 2; + + + struct TestParticle{ + FPoint position; + FReal forces[3]; + FReal physicalValue; + FReal potential; + }; + + TestParticle* const particlesSources = new TestParticle[nbSources]; + TestParticle* const particlesTargets = new TestParticle[nbTargets]; + + // Create octree + OctreeClass tree(NbLevels, SizeSubLevels, loader.getBoxWidth(), loader.getCenterOfBox()); + + const FReal physicalValue = 0.10; + + for(int idxPart = 0 ; idxPart < nbTargets ; ++idxPart){ + FPoint position; + loader.fillParticle(&position); + // put in tree + tree.insert(position, FParticleTypeTarget, idxPart, physicalValue); + // get copy + particlesTargets[idxPart].position = position; + particlesTargets[idxPart].potential = 0.0; + particlesTargets[idxPart].physicalValue = physicalValue; + particlesTargets[idxPart].forces[0] = 0.0; + particlesTargets[idxPart].forces[1] = 0.0; + particlesTargets[idxPart].forces[2] = 0.0; + } + + for(int idxPart = 0 ; idxPart < nbSources ; ++idxPart){ + FPoint position; + loader.fillParticle(&position); + // put in tree + tree.insert(position, FParticleTypeSource, idxPart, physicalValue); + // get copy + particlesSources[idxPart].position = position; + particlesSources[idxPart].physicalValue = physicalValue; + } + + + // Run FMM + Print("Fmm..."); + //KernelClass kernels(NbLevels,loader.getBoxWidth()); + KernelClass kernels(NbLevels,loader.getBoxWidth(), loader.getCenterOfBox()); + FmmClass algo(&tree,&kernels); + algo.execute(); + + // Run direct computation + Print("Direct..."); + for(int idxTarget = 0 ; idxTarget < nbTargets ; ++idxTarget){ + for(int idxOther = 0 ; idxOther < nbSources ; ++idxOther){ + FP2P::NonMutualParticles( + particlesSources[idxOther].position.getX(), particlesSources[idxOther].position.getY(), + particlesSources[idxOther].position.getZ(),particlesSources[idxOther].physicalValue, + particlesTargets[idxTarget].position.getX(), particlesTargets[idxTarget].position.getY(), + particlesTargets[idxTarget].position.getZ(),particlesTargets[idxTarget].physicalValue, + &particlesTargets[idxTarget].forces[0],&particlesTargets[idxTarget].forces[1], + &particlesTargets[idxTarget].forces[2],&particlesTargets[idxTarget].potential); + } + } + + // Compare + Print("Compute Diff..."); + FMath::FAccurater potentialDiff; + FMath::FAccurater fx, fy, fz; + { // Check that each particle has been summed with all other + + tree.forEachLeaf([&](LeafClass* leaf){ + if( leaf->getTargets()->getNbParticles() ){ + const FReal*const potentials = leaf->getTargets()->getPotentials(); + const FReal*const forcesX = leaf->getTargets()->getForcesX(); + const FReal*const forcesY = leaf->getTargets()->getForcesY(); + const FReal*const forcesZ = leaf->getTargets()->getForcesZ(); + const int nbParticlesInLeaf = leaf->getTargets()->getNbParticles(); + const FVector& indexes = leaf->getTargets()->getIndexes(); + + for(int idxPart = 0 ; idxPart < nbParticlesInLeaf ; ++idxPart){ + const int indexPartOrig = indexes[idxPart]; + potentialDiff.add(particlesTargets[indexPartOrig].potential,potentials[idxPart]); + fx.add(particlesTargets[indexPartOrig].forces[0],forcesX[idxPart]); + fy.add(particlesTargets[indexPartOrig].forces[1],forcesY[idxPart]); + fz.add(particlesTargets[indexPartOrig].forces[2],forcesZ[idxPart]); + } + } + }); + } + + delete[] particlesTargets; + delete[] particlesSources; + + // Print for information + Print("Potential diff is = "); + Print(potentialDiff.getL2Norm()); + Print(potentialDiff.getInfNorm()); + Print("Fx diff is = "); + Print(fx.getL2Norm()); + Print(fx.getInfNorm()); + Print("Fy diff is = "); + Print(fy.getL2Norm()); + Print(fy.getInfNorm()); + Print("Fz diff is = "); + Print(fz.getL2Norm()); + Print(fz.getInfNorm()); + + // Assert + const FReal MaximumDiff = FReal(0.0001); + uassert(potentialDiff.getL2Norm() < MaximumDiff); + uassert(potentialDiff.getInfNorm() < MaximumDiff); + uassert(fx.getL2Norm() < MaximumDiff); + uassert(fx.getInfNorm() < MaximumDiff); + uassert(fy.getL2Norm() < MaximumDiff); + uassert(fy.getInfNorm() < MaximumDiff); + uassert(fz.getL2Norm() < MaximumDiff); + uassert(fz.getInfNorm() < MaximumDiff); + } + + /** If memstas is running print the memory used */ + void PostTest() { + if( FMemStats::controler.isUsed() ){ + std::cout << "Memory used at the end " << FMemStats::controler.getCurrentAllocated() << " Bytes (" << FMemStats::controler.getCurrentAllocatedMB() << "MB)\n"; + std::cout << "Max memory used " << FMemStats::controler.getMaxAllocated() << " Bytes (" << FMemStats::controler.getMaxAllocatedMB() << "MB)\n"; + std::cout << "Total memory used " << FMemStats::controler.getTotalAllocated() << " Bytes (" << FMemStats::controler.getTotalAllocatedMB() << "MB)\n"; + } + } + + /////////////////////////////////////////////////////////// + // The tests! + /////////////////////////////////////////////////////////// + + static const int P = 9; + + template + class CustomTypedRotationCell : public FRotationCell

, public FExtendCellType{ + }; + + /** Rotation */ + void TestRotation(){ + typedef CustomTypedRotationCell

CellClass; + typedef FP2PParticleContainerIndexed ContainerClass; + + typedef FRotationKernel KernelClass; + + typedef FTypedLeaf LeafClass; + typedef FOctree< CellClass, ContainerClass , LeafClass > OctreeClass; + + typedef FFmmAlgorithmTsm FmmClass; + + RunTest(); + } + + void TestRotationThread(){ + typedef CustomTypedRotationCell

CellClass; + typedef FP2PParticleContainerIndexed ContainerClass; + + typedef FRotationKernel KernelClass; + + typedef FTypedLeaf LeafClass; + typedef FOctree< CellClass, ContainerClass , LeafClass > OctreeClass; + + typedef FFmmAlgorithmThreadTsm FmmClass; + + RunTest(); + } + + /////////////////////////////////////////////////////////// + // Set the tests! + /////////////////////////////////////////////////////////// + + /** set test */ + void SetTests(){ + AddTest(&TestRotationDirectTsm::TestRotation,"Test Rotation Kernel TSM"); + AddTest(&TestRotationDirectTsm::TestRotation,"Test Rotation Kernel TSM thread"); + } +}; + + +// You must do this +TestClass(TestRotationDirectTsm) + + + -- 2.24.1