Commit b8583357 authored by BLANCHARD Pierre's avatar BLANCHARD Pierre

Introduced the concept of extended bounding box in UniformTensorial kernel...

Introduced the concept of extended bounding box in UniformTensorial kernel (ONLY supported for NON_HOMOGENEOUS matrix kernels yet).
parent fef929b9
......@@ -59,8 +59,8 @@ protected: // PB for OptiDis
unsigned int node_ids[nnodes][3];
// 8 Non-leaf (i.e. M2M/L2L) interpolators
// 1 per level if box is extended
// TODO only 1 is required for all levels if extension is 0
// x1 per level if box is extended
// only 1 is required for all levels if extension is 0
FReal*** ChildParentInterpolator;
// Tree height (needed by M2M/L2L if cell width is extended)
......
......@@ -59,6 +59,9 @@ protected:
const FReal BoxWidth;
/// Width of a leaf cell box
const FReal BoxWidthLeaf;
/// Extension of the box width ( same for all level! )
const FReal BoxWidthExtension;
/// Parameter to pass to matrix kernel (material specific or anything)
const double MatParam;
......@@ -83,13 +86,17 @@ public:
FAbstractUnifKernel(const int inTreeHeight,
const FReal inBoxWidth,
const FPoint& inBoxCenter,
const FReal inBoxWidthExtension = 0.0,
const double inMatParam = 0.0)
: Interpolator(new InterpolatorClass()),
: Interpolator(new InterpolatorClass(inTreeHeight,
inBoxWidth,
inBoxWidthExtension)),
MatrixKernel(new MatrixKernelClass(inMatParam)),
TreeHeight(inTreeHeight),
BoxCorner(inBoxCenter - inBoxWidth / FReal(2.)),
BoxWidth(inBoxWidth),
BoxWidthLeaf(BoxWidth / FReal(FMath::pow(2, inTreeHeight - 1))),
BoxWidthExtension(inBoxWidthExtension),
MatParam(inMatParam)
{
/* empty */
......
......@@ -49,7 +49,19 @@ class FUnifInterpolator : FNoCopyable
typedef FUnifTensor<ORDER> TensorType;
unsigned int node_ids[nnodes][3];
FReal* ChildParentInterpolator[8];
// 8 Non-leaf (i.e. M2M/L2L) interpolators
// x1 per level if box is extended
// only 1 is required for all levels if extension is 0
FReal*** ChildParentInterpolator;
// Tree height (needed by M2M/L2L if cell width is extended)
const int TreeHeight;
// Root cell width (only used by M2M/L2L)
const FReal RootCellWidth;
// Cell width extension (only used by M2M/L2L, kernel handles extension for P2M/L2P)
const FReal CellWidthExtension;
// permutations (only needed in the tensor product interpolation case)
unsigned int perm[3][nnodes];
......@@ -95,29 +107,30 @@ class FUnifInterpolator : FNoCopyable
* S which is precomputed and reused for all M2M and L2L operations, ie for
* all non leaf inter/anterpolations.
*/
void initTensorM2MandL2L()
void initTensorM2MandL2L(const int TreeLevel, const FReal ParentWidth)
{
FPoint ParentRoots[nnodes];
FReal ChildCoords[3][ORDER];
const FReal ParentWidth(2.);
const FPoint ParentCenter(0., 0., 0.);
FUnifTensor<ORDER>::setRoots(ParentCenter, ParentWidth, ParentRoots);
FPoint ChildCenter;
const FReal ChildWidth(1.);
// Ratio of extended cell widths (definition: child ext / parent ext)
const FReal ExtendedCellRatio =
FReal(FReal(ParentWidth)/FReal(2.) + CellWidthExtension) / FReal(ParentWidth + CellWidthExtension);
// Child cell width
const FReal ChildWidth(2.*ExtendedCellRatio);
// loop: child cells
for (unsigned int child=0; child<8; ++child) {
// set child info
FUnifTensor<ORDER>::setRelativeChildCenter(child, ChildCenter);
FUnifTensor<ORDER>::setRelativeChildCenter(child, ChildCenter, ExtendedCellRatio);
FUnifTensor<ORDER>::setPolynomialsRoots(ChildCenter, ChildWidth, ChildCoords);
// allocate memory
ChildParentInterpolator[child] = new FReal [3 * ORDER*ORDER];
assembleInterpolator(ORDER, ChildCoords[0], ChildParentInterpolator[child]);
assembleInterpolator(ORDER, ChildCoords[1], ChildParentInterpolator[child] + 1 * ORDER*ORDER);
assembleInterpolator(ORDER, ChildCoords[2], ChildParentInterpolator[child] + 2 * ORDER*ORDER);
ChildParentInterpolator[TreeLevel][child] = new FReal [3 * ORDER*ORDER];
assembleInterpolator(ORDER, ChildCoords[0], ChildParentInterpolator[TreeLevel][child]);
assembleInterpolator(ORDER, ChildCoords[1], ChildParentInterpolator[TreeLevel][child] + 1 * ORDER*ORDER);
assembleInterpolator(ORDER, ChildCoords[2], ChildParentInterpolator[TreeLevel][child] + 2 * ORDER*ORDER);
}
......@@ -141,15 +154,51 @@ public:
/**
* Constructor: Initialize the Lagrange polynomials at the equispaced
* roots/interpolation point
*
* PB: Input parameters ONLY affect the computation of the M2M/L2L ops.
* These parameters are ONLY required in the context of extended bbox.
* If no M2M/L2L is required then the interpolator can be built with
* the default ctor.
*/
explicit FUnifInterpolator()
explicit FUnifInterpolator(const int inTreeHeight=3,
const FReal inRootCellWidth=FReal(1.),
const FReal inCellWidthExtension=FReal(0.))
: TreeHeight(inTreeHeight),
RootCellWidth(inRootCellWidth),
CellWidthExtension(inCellWidthExtension)
{
// initialize root node ids
TensorType::setNodeIds(node_ids);
// initialize interpolation operator for M2M and L2L (non leaf operations)
//this -> initM2MandL2L(); // non tensor-product interpolation
this -> initTensorM2MandL2L(); // tensor-product interpolation
// allocate 8 arrays per level
ChildParentInterpolator = new FReal**[TreeHeight];
for (unsigned int l=0; l<TreeHeight; ++l){
ChildParentInterpolator[l] = new FReal*[8];
for (unsigned int c=0; c<8; ++c)
ChildParentInterpolator[l][c]=nullptr;
}
// Set number of non-leaf ios that actually need to be computed
unsigned int reducedTreeHeight; // = 2 + nb of computed nl ios
if(CellWidthExtension==0.) // if no cell extension, then ...
reducedTreeHeight = 3; // cmp only 1 non-leaf io
else
reducedTreeHeight = TreeHeight; // cmp 1 non-leaf io per level
// Init non-leaf interpolators
FReal CellWidth = RootCellWidth / FReal(2.); // at level 1
CellWidth /= FReal(2.); // at level 2
for (unsigned int l=2; l<reducedTreeHeight; ++l) {
//this -> initM2MandL2L(l,CellWidth); // non tensor-product interpolation
this -> initTensorM2MandL2L(l,CellWidth); // tensor-product interpolation
// update cell width
CellWidth /= FReal(2.); // at level l+1
}
}
......@@ -158,8 +207,10 @@ public:
*/
~FUnifInterpolator()
{
for (unsigned int child=0; child<8; ++child)
delete [] ChildParentInterpolator[child];
for (unsigned int l=0; l<TreeHeight; ++l)
for (unsigned int child=0; child<8; ++child)
if(ChildParentInterpolator[l][child] != nullptr)
delete [] ChildParentInterpolator[l][child];
}
......@@ -294,24 +345,25 @@ public:
// PB: Multidim version handled in kernel !
void applyM2M(const unsigned int ChildIndex,
const FReal *const ChildExpansion,
FReal *const ParentExpansion) const
FReal *const ParentExpansion,
const unsigned int TreeLevel = 2) const
{
FReal Exp[nnodes], PermExp[nnodes];
// ORDER*ORDER*ORDER * (2*ORDER-1)
FBlas::gemtm(ORDER, ORDER, ORDER*ORDER, FReal(1.),
ChildParentInterpolator[ChildIndex], ORDER,
ChildParentInterpolator[TreeLevel][ChildIndex], ORDER,
const_cast<FReal*>(ChildExpansion), ORDER, PermExp, ORDER);
for (unsigned int n=0; n<nnodes; ++n) Exp[n] = PermExp[perm[1][n]];
// ORDER*ORDER*ORDER * (2*ORDER-1)
FBlas::gemtm(ORDER, ORDER, ORDER*ORDER, FReal(1.),
ChildParentInterpolator[ChildIndex] + 2 * ORDER*ORDER, ORDER,
ChildParentInterpolator[TreeLevel][ChildIndex] + 2 * ORDER*ORDER, ORDER,
Exp, ORDER, PermExp, ORDER);
for (unsigned int n=0; n<nnodes; ++n) Exp[perm[1][n]] = PermExp[perm[2][n]];
// ORDER*ORDER*ORDER * (2*ORDER-1)
FBlas::gemtm(ORDER, ORDER, ORDER*ORDER, FReal(1.),
ChildParentInterpolator[ChildIndex] + 1 * ORDER*ORDER, ORDER,
ChildParentInterpolator[TreeLevel][ChildIndex] + 1 * ORDER*ORDER, ORDER,
Exp, ORDER, PermExp, ORDER);
for (unsigned int n=0; n<nnodes; ++n) ParentExpansion[perm[2][n]] += PermExp[n];
......@@ -320,24 +372,25 @@ public:
void applyL2L(const unsigned int ChildIndex,
const FReal *const ParentExpansion,
FReal *const ChildExpansion) const
FReal *const ChildExpansion,
const unsigned int TreeLevel = 2) const
{
FReal Exp[nnodes], PermExp[nnodes];
// ORDER*ORDER*ORDER * (2*ORDER-1)
FBlas::gemm(ORDER, ORDER, ORDER*ORDER, FReal(1.),
ChildParentInterpolator[ChildIndex], ORDER,
ChildParentInterpolator[TreeLevel][ChildIndex], ORDER,
const_cast<FReal*>(ParentExpansion), ORDER, PermExp, ORDER);
for (unsigned int n=0; n<nnodes; ++n) Exp[n] = PermExp[perm[1][n]];
// ORDER*ORDER*ORDER * (2*ORDER-1)
FBlas::gemm(ORDER, ORDER, ORDER*ORDER, FReal(1.),
ChildParentInterpolator[ChildIndex] + 2 * ORDER*ORDER, ORDER,
ChildParentInterpolator[TreeLevel][ChildIndex] + 2 * ORDER*ORDER, ORDER,
Exp, ORDER, PermExp, ORDER);
for (unsigned int n=0; n<nnodes; ++n) Exp[perm[1][n]] = PermExp[perm[2][n]];
// ORDER*ORDER*ORDER * (2*ORDER-1)
FBlas::gemm(ORDER, ORDER, ORDER*ORDER, FReal(1.),
ChildParentInterpolator[ChildIndex] + 1 * ORDER*ORDER, ORDER,
ChildParentInterpolator[TreeLevel][ChildIndex] + 1 * ORDER*ORDER, ORDER,
Exp, ORDER, PermExp, ORDER);
for (unsigned int n=0; n<nnodes; ++n) ChildExpansion[perm[2][n]] += PermExp[n];
......
......@@ -87,11 +87,13 @@ public:
FUnifTensorialKernel(const int inTreeHeight,
const FReal inBoxWidth,
const FPoint& inBoxCenter,
const FReal inBoxWidthExtension,
const double inMatParam = 0.0)
: FAbstractUnifKernel< CellClass, ContainerClass, MatrixKernelClass, ORDER, NVALS>(inTreeHeight,inBoxWidth,inBoxCenter,inMatParam),
: FAbstractUnifKernel< CellClass, ContainerClass, MatrixKernelClass, ORDER, NVALS>(inTreeHeight,inBoxWidth,inBoxCenter,inBoxWidthExtension,inMatParam),
M2LHandler(AbstractBaseClass::MatrixKernel.getPtr(),
inTreeHeight,
inBoxWidth)
inBoxWidth,
inBoxWidthExtension)
{ }
......@@ -99,11 +101,13 @@ public:
const ContainerClass* const SourceParticles)
{
const FPoint LeafCellCenter(AbstractBaseClass::getLeafCellCenter(LeafCell->getCoordinate()));
const FReal ExtendedLeafCellWidth(AbstractBaseClass::BoxWidthLeaf
+ AbstractBaseClass::BoxWidthExtension);
for(int idxV = 0 ; idxV < NVALS ; ++idxV){
// 1) apply Sy
AbstractBaseClass::Interpolator->applyP2M(LeafCellCenter, AbstractBaseClass::BoxWidthLeaf,
AbstractBaseClass::Interpolator->applyP2M(LeafCellCenter, ExtendedLeafCellWidth,
LeafCell->getMultipole(idxV*nRhs), SourceParticles);
for(int idxRhs = 0 ; idxRhs < nRhs ; ++idxRhs){
......@@ -121,7 +125,7 @@ public:
void M2M(CellClass* const FRestrict ParentCell,
const CellClass*const FRestrict *const FRestrict ChildCells,
const int /*TreeLevel*/)
const int TreeLevel)
{
for(int idxV = 0 ; idxV < NVALS ; ++idxV){
for(int idxRhs = 0 ; idxRhs < nRhs ; ++idxRhs){
......@@ -132,8 +136,10 @@ public:
FBlas::scal(AbstractBaseClass::nnodes, FReal(0.), ParentCell->getMultipole(idxMul));
for (unsigned int ChildIndex=0; ChildIndex < 8; ++ChildIndex){
if (ChildCells[ChildIndex]){
AbstractBaseClass::Interpolator->applyM2M(ChildIndex, ChildCells[ChildIndex]->getMultipole(idxMul),
ParentCell->getMultipole(idxMul));
AbstractBaseClass::Interpolator->applyM2M(ChildIndex,
ChildCells[ChildIndex]->getMultipole(idxMul),
ParentCell->getMultipole(idxMul),
TreeLevel/*Cell width extension specific*/);
}
}
// 2) Apply Discete Fourier Transform
......@@ -150,7 +156,8 @@ public:
const int TreeLevel)
{
const FReal CellWidth(AbstractBaseClass::BoxWidth / FReal(FMath::pow(2, TreeLevel)));
const FReal scale(AbstractBaseClass::MatrixKernel.getPtr()->getScaleFactor(CellWidth));
const FReal ExtendedCellWidth(CellWidth + AbstractBaseClass::BoxWidthExtension);
const FReal scale(AbstractBaseClass::MatrixKernel.getPtr()->getScaleFactor(ExtendedCellWidth));
for(int idxV = 0 ; idxV < NVALS ; ++idxV){
for (int idxLhs=0; idxLhs < nLhs; ++idxLhs){
......@@ -187,7 +194,7 @@ public:
void L2L(const CellClass* const FRestrict ParentCell,
CellClass* FRestrict *const FRestrict ChildCells,
const int /*TreeLevel*/)
const int TreeLevel)
{
for(int idxV = 0 ; idxV < NVALS ; ++idxV){
for(int idxLhs = 0 ; idxLhs < nLhs ; ++idxLhs){
......@@ -198,7 +205,10 @@ public:
// 2) apply Sx
for (unsigned int ChildIndex=0; ChildIndex < 8; ++ChildIndex){
if (ChildCells[ChildIndex]){
AbstractBaseClass::Interpolator->applyL2L(ChildIndex, ParentCell->getLocal(idxLoc), ChildCells[ChildIndex]->getLocal(idxLoc));
AbstractBaseClass::Interpolator->applyL2L(ChildIndex,
ParentCell->getLocal(idxLoc),
ChildCells[ChildIndex]->getLocal(idxLoc),
TreeLevel/*Cell width extension specific*/);
}
}
}
......@@ -209,6 +219,8 @@ public:
ContainerClass* const TargetParticles)
{
const FPoint LeafCellCenter(AbstractBaseClass::getLeafCellCenter(LeafCell->getCoordinate()));
const FReal ExtendedLeafCellWidth(AbstractBaseClass::BoxWidthLeaf
+ AbstractBaseClass::BoxWidthExtension);
for(int idxV = 0 ; idxV < NVALS ; ++idxV){
for(int idxLhs = 0 ; idxLhs < nLhs ; ++idxLhs){
......@@ -220,11 +232,11 @@ public:
}
// 2.a) apply Sx
AbstractBaseClass::Interpolator->applyL2P(LeafCellCenter, AbstractBaseClass::BoxWidthLeaf,
AbstractBaseClass::Interpolator->applyL2P(LeafCellCenter, ExtendedLeafCellWidth,
LeafCell->getLocal(idxV*nLhs), TargetParticles);
// 2.b) apply Px (grad Sx)
AbstractBaseClass::Interpolator->applyL2PGradient(LeafCellCenter, AbstractBaseClass::BoxWidthLeaf,
AbstractBaseClass::Interpolator->applyL2PGradient(LeafCellCenter, ExtendedLeafCellWidth,
LeafCell->getLocal(idxV*nLhs), TargetParticles);
}// NVALS
......
......@@ -38,6 +38,7 @@ PB: Compute() does not belong to the M2LHandler like it does in the Chebyshev ke
template <int ORDER, class MatrixKernelClass>
static void Compute(const MatrixKernelClass *const MatrixKernel,
const FReal CellWidth,
const FReal CellWidthExtension,
FComplexe** &FC)
{
// dimensions of operators
......@@ -56,7 +57,8 @@ static void Compute(const MatrixKernelClass *const MatrixKernel,
// interpolation points of source (Y) and target (X) cell
FPoint X[nnodes], Y[nnodes];
// set roots of target cell (X)
FUnifTensor<order>::setRoots(FPoint(0.,0.,0.), CellWidth, X);
const FReal ExtendedCellWidth(CellWidth+CellWidthExtension);
FUnifTensor<order>::setRoots(FPoint(0.,0.,0.), ExtendedCellWidth, X);
// allocate memory and compute 316 m2l operators
FReal** _C;
......@@ -92,7 +94,7 @@ static void Compute(const MatrixKernelClass *const MatrixKernel,
if (abs(i)>1 || abs(j)>1 || abs(k)>1) {
// set roots of source cell (Y)
const FPoint cy(CellWidth*FReal(i), CellWidth*FReal(j), CellWidth*FReal(k));
FUnifTensor<order>::setRoots(cy, CellWidth, Y);
FUnifTensor<order>::setRoots(cy, ExtendedCellWidth, Y);
// evaluate m2l operator
unsigned int ido=0;
for(unsigned int l=0; l<2*order-1; ++l)
......@@ -193,6 +195,8 @@ class FUnifTensorialM2LHandler<ORDER,MatrixKernelClass,HOMOGENEOUS> : FNoCopyabl
/// M2L Operators (stored in Fourier space for each component of tensor)
FSmartPointer< FComplexe*,FSmartArrayMemory> FC;
const FReal CellWidthExtension; //<! extension of cells width
/// Utils
typedef FUnifTensor<ORDER> TensorType;
unsigned int node_diff[nnodes*nnodes];
......@@ -215,8 +219,9 @@ class FUnifTensorialM2LHandler<ORDER,MatrixKernelClass,HOMOGENEOUS> : FNoCopyabl
public:
FUnifTensorialM2LHandler(const MatrixKernelClass *const MatrixKernel, const unsigned int, const FReal)
: opt_rc(rc/2+1), Dft()
FUnifTensorialM2LHandler(const MatrixKernelClass *const MatrixKernel, const unsigned int, const FReal, const FReal inCellWidthExtension)
: CellWidthExtension(inCellWidthExtension),
Dft(), opt_rc(rc/2+1)
{
// init DFT
const int steps[dimfft] = {rc};
......@@ -253,8 +258,11 @@ public:
if (FC[d]) throw std::runtime_error("M2L operator already set");
// Compute matrix of interactions
// reference cell width is arbitrarly set to 2.
// but it NEEDS to match the numerator of the scale factor in matrix kernel!
// Therefore box width extension is not yet supported for homog kernels
const FReal ReferenceCellWidth = FReal(2.);
Compute<order>(MatrixKernel,ReferenceCellWidth,FC);
Compute<order>(MatrixKernel,ReferenceCellWidth, 0., FC);
// Compute memory usage
unsigned long sizeM2L = 343*ncmp*opt_rc*sizeof(FComplexe);
......@@ -361,9 +369,11 @@ class FUnifTensorialM2LHandler<ORDER,MatrixKernelClass,NON_HOMOGENEOUS> : FNoCop
/// M2L Operators (stored in Fourier space for each component and each level)
FSmartPointer< FComplexe**,FSmartArrayMemory> FC;
/// Homogeneity specific variables
const unsigned int TreeHeight;
const FReal RootCellWidth;
const FReal CellWidthExtension; //<! extension of cells width
/// Utils
typedef FUnifTensor<ORDER> TensorType;
......@@ -387,10 +397,11 @@ class FUnifTensorialM2LHandler<ORDER,MatrixKernelClass,NON_HOMOGENEOUS> : FNoCop
public:
FUnifTensorialM2LHandler(const MatrixKernelClass *const MatrixKernel, const unsigned int inTreeHeight, const FReal inRootCellWidth)
FUnifTensorialM2LHandler(const MatrixKernelClass *const MatrixKernel, const unsigned int inTreeHeight, const FReal inRootCellWidth, const FReal inCellWidthExtension)
: TreeHeight(inTreeHeight),
RootCellWidth(inRootCellWidth),
opt_rc(rc/2+1), Dft()
RootCellWidth(inRootCellWidth),
CellWidthExtension(inCellWidthExtension),
Dft(), opt_rc(rc/2+1)
{
// init DFT
const int steps[dimfft] = {rc};
......@@ -434,7 +445,7 @@ public:
// check if already set
for (unsigned int d=0; d<ncmp; ++d)
if (FC[l][d]) throw std::runtime_error("M2L operator already set");
Compute<order>(MatrixKernel,CellWidth,FC[l]);
Compute<order>(MatrixKernel,CellWidth,CellWidthExtension,FC[l]);
CellWidth /= FReal(2.); // at level l+1
}
......
......@@ -171,6 +171,20 @@ int main(int argc, char* argv[])
// accuracy
const unsigned int ORDER = 6 ;
// set box width extension
// ... either deduce from element size
const FReal LeafCellWidth = FReal(loader.getBoxWidth()) / FReal(FMath::pow(2.,TreeHeight-1));
const FReal ElementSize = LeafCellWidth / FReal(3.);
const FReal BoxWidthExtension = ElementSize; // depends on type of element
// ... or set to arbitrary value (0. means no extension)
// const FReal BoxWidthExtension = FReal(0.);
std::cout << "LeafCellWidth=" << LeafCellWidth
<< ", BoxWidthExtension=" << BoxWidthExtension <<std::endl;
// stop execution if interactions are homog and box extension is required
if(MatrixKernelClass::Type==HOMOGENEOUS && BoxWidthExtension>0.)
throw std::runtime_error("Extension of box width is not yet supported for homogeneous kernels! Work-around: artificially set Type to NON_HOMOGENEOUS.");
typedef FP2PParticleContainerIndexed<NRHS,NLHS> ContainerClass;
......@@ -217,7 +231,7 @@ int main(int argc, char* argv[])
{ // -----------------------------------------------------
std::cout << "\nLagrange/Uniform grid FMM (ORDER="<< ORDER << ") ... " << std::endl;
time.tic();
KernelClass kernels(TreeHeight, loader.getBoxWidth(), loader.getCenterOfBox(),CoreWidth);
KernelClass kernels(TreeHeight, loader.getBoxWidth(), loader.getCenterOfBox(),BoxWidthExtension,CoreWidth);
FmmClass algorithm(&tree, &kernels);
algorithm.execute();
time.tac();
......
......@@ -25,27 +25,27 @@
#include <stdlib.h>
#include <time.h>
#include "../../Src/Utils/FTic.hpp"
#include "../../Src/Utils/FMath.hpp"
#include "../../Src/Utils/FBlas.hpp"
#include "Utils/FTic.hpp"
#include "Utils/FMath.hpp"
#include "Utils/FBlas.hpp"
#include "../../Src/Containers/FVector.hpp"
#include "Containers/FVector.hpp"
#include "../../Src/Utils/FAssert.hpp"
#include "../../Src/Utils/FPoint.hpp"
#include "Utils/FAssert.hpp"
#include "Utils/FPoint.hpp"
#include "../../Src/Kernels/Uniform/FUnifInterpolator.hpp"
#include "../../Src/Kernels/Interpolation/FInterpMatrixKernel.hpp"
#include "../../Src/Kernels/Uniform/FUnifTensor.hpp"
#include "Kernels/Uniform/FUnifInterpolator.hpp"
#include "Kernels/Interpolation/FInterpMatrixKernel.hpp"
#include "Kernels/Uniform/FUnifTensor.hpp"
// Check DFT
#include "../../Src/Utils/FDft.hpp"
#include "../../Src/Utils/FComplexe.hpp"
#include "Utils/FDft.hpp"
#include "Utils/FComplexe.hpp"
#include "../../Src/Kernels/P2P/FP2PParticleContainer.hpp"
#include "../../Src/Components/FSimpleLeaf.hpp"
#include "Kernels/P2P/FP2PParticleContainer.hpp"
#include "Components/FSimpleLeaf.hpp"
......
......@@ -25,27 +25,27 @@
#include <stdlib.h>
#include <time.h>
#include "../../Src/Utils/FTic.hpp"
#include "../../Src/Utils/FMath.hpp"
#include "../../Src/Utils/FBlas.hpp"
#include "Utils/FTic.hpp"
#include "Utils/FMath.hpp"
#include "Utils/FBlas.hpp"
#include "../../Src/Containers/FVector.hpp"
#include "Containers/FVector.hpp"
#include "../../Src/Utils/FAssert.hpp"
#include "../../Src/Utils/FPoint.hpp"
#include "Utils/FAssert.hpp"
#include "Utils/FPoint.hpp"
#include "../../Src/Kernels/Uniform/FUnifInterpolator.hpp"
#include "../../Src/Kernels/Interpolation/FInterpMatrixKernel.hpp"
#include "../../Src/Kernels/Uniform/FUnifTensor.hpp"
#include "Kernels/Uniform/FUnifInterpolator.hpp"
#include "Kernels/Interpolation/FInterpMatrixKernel.hpp"
#include "Kernels/Uniform/FUnifTensor.hpp"
// Check DFT
#include "../../Src/Utils/FDft.hpp"
#include "../../Src/Utils/FComplexe.hpp"
#include "Utils/FDft.hpp"
#include "Utils/FComplexe.hpp"
#include "../../Src/Kernels/P2P/FP2PParticleContainer.hpp"
#include "../../Src/Components/FSimpleLeaf.hpp"
#include "Kernels/P2P/FP2PParticleContainer.hpp"
#include "Components/FSimpleLeaf.hpp"
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment