New data files
Showing
File added
| // =================================================================================== | ||
| // 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 "ScalFmmConfig.h" | ||
| #include "Utils/FGlobal.hpp" | ||
| #include "Containers/FOctree.hpp" | ||
| #include "Files/FFmaGenericLoader.hpp" | ||
| #include "Core/FFmmAlgorithmThread.hpp" | ||
| #include "FUTester.hpp" | ||
| #include "Components/FSimpleLeaf.hpp" | ||
| #include "Kernels/Chebyshev/FChebCell.hpp" | ||
| #include "Kernels/Interpolation/FInterpMatrixKernel.hpp" | ||
| #include "Kernels/Chebyshev/FChebKernel.hpp" | ||
| #include "Kernels/Chebyshev/FChebSymKernel.hpp" | ||
| #include "Kernels/P2P/FP2PParticleContainerIndexed.hpp" | ||
| /* | ||
| In this test we compare the Chebyschev fmm results and the direct results. | ||
| */ | ||
| /** the test class | ||
| * | ||
| */ | ||
| class TestChebyshevDirect : public FUTester<TestChebyshevDirect> { | ||
| /////////////////////////////////////////////////////////// | ||
| // The tests! | ||
| /////////////////////////////////////////////////////////// | ||
| template <class CellClass, class ContainerClass, class KernelClass, class MatrixKernelClass, | ||
| class LeafClass, class OctreeClass, class FmmClass> | ||
| void RunTest() { | ||
| // | ||
| #ifdef _OPENMP | ||
| std::cout << "\n>> Using " << omp_get_max_threads() << " threads.\n" << std::endl; | ||
| #else | ||
| std::cout << "\n>> OpenMP test !!!\n" << std::endl; | ||
| exit(EXIT_FAILURE); | ||
| #endif | ||
| // | ||
| // Load particles | ||
| // | ||
| if(sizeof(FReal) == sizeof(float) ) { | ||
| std::cerr << "No input data available for Float "<< std::endl; | ||
| exit(EXIT_FAILURE); | ||
| } | ||
| const std::string parFile( (sizeof(FReal) == sizeof(float))? | ||
| "Test/DirectFloatbfma": | ||
| "UTest/DirectDouble.bfma"); | ||
| // | ||
| std::string filename(SCALFMMDataPath+parFile); | ||
| // | ||
| FFmaGenericLoader loader(filename); | ||
| Print("Number of particles:"); | ||
| Print(loader.getNumberOfParticles()); | ||
| const int NbLevels = 4; | ||
| const int SizeSubLevels = 2; | ||
| // Create octree | ||
| FSize nbParticles = loader.getNumberOfParticles() ; | ||
| FmaR8W8Particle* const particles = new FmaR8W8Particle[nbParticles]; | ||
| loader.fillParticle(particles,nbParticles); | ||
| // | ||
| // Insert particle in the tree | ||
| // | ||
| OctreeClass tree(NbLevels, SizeSubLevels, loader.getBoxWidth(), loader.getCenterOfBox()); | ||
| for(int idxPart = 0 ; idxPart < loader.getNumberOfParticles() ; ++idxPart){ | ||
| tree.insert(particles[idxPart].position , idxPart, particles[idxPart].physicalValue ); | ||
| } | ||
| // | ||
| ///////////////////////////////////////////////////////////////////////////////////////////////// | ||
| // Run FMM computation | ||
| ///////////////////////////////////////////////////////////////////////////////////////////////// | ||
| Print("Fmm..."); | ||
| KernelClass kernels(NbLevels, loader.getBoxWidth(), loader.getCenterOfBox()); | ||
| FmmClass algo(&tree,&kernels); | ||
| algo.execute(); | ||
| //0 | ||
| FReal energy= 0.0 , energyD = 0.0 ; | ||
| ///////////////////////////////////////////////////////////////////////////////////////////////// | ||
| // Compute direct energy | ||
| ///////////////////////////////////////////////////////////////////////////////////////////////// | ||
| for(int idx = 0 ; idx < loader.getNumberOfParticles() ; ++idx){ | ||
| energyD += particles[idx].potential*particles[idx].physicalValue ; | ||
| } | ||
| ///////////////////////////////////////////////////////////////////////////////////////////////// | ||
| // 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){ | ||
| const FReal*const potentials = leaf->getTargets()->getPotentials(); | ||
| const FReal*const physicalValues = leaf->getTargets()->getPhysicalValues(); | ||
| 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<int>& indexes = leaf->getTargets()->getIndexes(); | ||
| for(int idxPart = 0 ; idxPart < nbParticlesInLeaf ; ++idxPart){ | ||
| const int indexPartOrig = indexes[idxPart]; | ||
| potentialDiff.add(particles[indexPartOrig].potential,potentials[idxPart]); | ||
| fx.add(particles[indexPartOrig].forces[0],forcesX[idxPart]); | ||
| fy.add(particles[indexPartOrig].forces[1],forcesY[idxPart]); | ||
| fz.add(particles[indexPartOrig].forces[2],forcesZ[idxPart]); | ||
| energy += potentials[idxPart]*physicalValues[idxPart]; | ||
| } | ||
| }); | ||
| } | ||
| delete[] particles; | ||
| // Print for information | ||
| Print("Potential diff is = "); | ||
| printf(" Pot L2Norm %e\n",potentialDiff.getL2Norm()); | ||
| printf(" Pot RL2Norm %e\n",potentialDiff.getRelativeL2Norm()); | ||
| printf(" Pot RMSError %e\n",potentialDiff.getRMSError()); | ||
| Print("Fx diff is = "); | ||
| printf(" Fx L2Norm %e\n",fx.getL2Norm()); | ||
| printf(" Fx RL2Norm %e\n",fx.getRelativeL2Norm()); | ||
| printf(" Fx RMSError %e\n",fx.getRMSError()); | ||
| Print("Fy diff is = "); | ||
| printf(" Fy L2Norm %e\n",fy.getL2Norm()); | ||
| printf(" Fy RL2Norm %e\n",fy.getRelativeL2Norm()); | ||
| printf(" Fy RMSError %e\n",fy.getRMSError()); | ||
| Print("Fz diff is = "); | ||
| printf(" Fz L2Norm %e\n",fz.getL2Norm()); | ||
| printf(" Fz RL2Norm %e\n",fz.getRelativeL2Norm()); | ||
| printf(" Fz RMSError %e\n",fz.getRMSError()); | ||
| FReal L2error = (fx.getRelativeL2Norm()*fx.getRelativeL2Norm() + fy.getRelativeL2Norm()*fy.getRelativeL2Norm() + fz.getRelativeL2Norm() *fz.getRelativeL2Norm() ); | ||
| printf(" Total L2 Force Error= %e\n",FMath::Sqrt(L2error)) ; | ||
| < |