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).

Src/Kernels/Chebyshev/FChebInterpolator.hpp

@@ -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)

Src/Kernels/Uniform/FAbstractUnifKernel.hpp

@@ -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 */

Src/Kernels/Uniform/FUnifInterpolator.hpp

@@ -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 l=0; l<TreeHeight; ++l) 
       for (unsigned int child=0; child<8; ++child)
-      delete [] ChildParentInterpolator[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];

Src/Kernels/Uniform/FUnifTensorialKernel.hpp

@@ -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

Src/Kernels/Uniform/FUnifTensorialM2LHandler.hpp

@@ -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()
+      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 
 		}
 

Tests/Kernels/testUnifTensorialAlgorithm.cpp

@@ -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();

Tests/Utils/testUnifInterpolator.cpp

@@ -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"
 
 
 

Tests/Utils/testUnifTensorialInterpolator.cpp

@@ -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"