Skip to content

GitLab

Commit 3b1d2118 authored by BRAMAS Berenger's avatar BRAMAS Berenger
Browse files

Change the kernel interface to have more efficient iteration in sparse fmm

parent f1c82ed0
Expand all Hide whitespace changes
Inline Side-by-side
Src/Adaptive/FAdaptChebSymKernel.hpp
View file @ 3b1d2118
......@@ -320,7 +320,7 @@ public:
}
void P2P(ContainerClass* target, const ContainerClass* sources) override {
ContainerClass* sourcesArray[27] = { const_cast<ContainerClass*> (sources) };
ContainerClass* sourcesArray[1] = { const_cast<ContainerClass*> (sources) };
DirectInteractionComputer<FReal, MatrixKernelClass::NCMP, NVALS>::template P2PRemote(target,sourcesArray,1,MatrixKernel);
}
......
Src/Adaptive/FAdaptiveKernelWrapper.hpp
View file @ 3b1d2118
......@@ -174,10 +174,12 @@ public:
* Else we have to perform M2L or P2L.
*/
void M2L(FAdaptiveCell<CellClass, ContainerClass>* const FRestrict local,
const FAdaptiveCell<CellClass, ContainerClass>* distantNeighbors[343],
const int /*size*/, const int inLevel) override {
const FAdaptiveCell<CellClass, ContainerClass>* distantNeighbors[],
const int positions[],
const int size, const int inLevel) override {
// In case usual M2L can be done
const CellClass* normalDistantNeighbors[343];
const CellClass* normalDistantNeighbors[189];
int normalPositions[189];
int normalSize = 0;
// The current Adaptive cell
FAdaptiveCell<CellClass, ContainerClass>* currentAdaptiveCell = nullptr;
......@@ -187,7 +189,7 @@ public:
currentAdaptiveCell = local;
currentAdaptiveLevel = inLevel;
// Then we may have some M2L to do
memset(normalDistantNeighbors, 0, 343*sizeof(CellClass*));
memset(normalDistantNeighbors, 0, 189*sizeof(CellClass*));
}
else{
// Else we are working with a lower cell
......@@ -195,77 +197,77 @@ public:
currentAdaptiveLevel= local->getSubAdaptiveLevel();
}
for(int idxNeigh = 0 ; idxNeigh < 343 ; ++idxNeigh){
if(distantNeighbors[idxNeigh]){
// If the current cell is Adaptive and the neighbor too
if(distantNeighbors[idxNeigh]->isAdaptive() && local->isAdaptive()){
if(distantNeighbors[idxNeigh]->hasDevelopment() && currentAdaptiveCell->hasDevelopment()){
// If both have development than we can use usual M2L
normalDistantNeighbors[idxNeigh] = distantNeighbors[idxNeigh]->getRealCell();
normalSize += 1;
}
else if(currentAdaptiveCell->hasDevelopment()){
// If only current cell has development the neighbor has particles
for(int idxLeafSrc = 0 ; idxLeafSrc < distantNeighbors[idxNeigh]->getNbSubLeaves() ; ++idxLeafSrc){
kernel.P2L(currentAdaptiveCell->getRealCell(), currentAdaptiveLevel, distantNeighbors[idxNeigh]->getSubLeaf(idxLeafSrc));
}
}
else if(distantNeighbors[idxNeigh]->hasDevelopment()){
// If only current cell has particles the neighbor has development
for(int idxLeafTgt = 0 ; idxLeafTgt < currentAdaptiveCell->getNbSubLeaves() ; ++idxLeafTgt){
kernel.M2P(distantNeighbors[idxNeigh]->getRealCell(), currentAdaptiveLevel, currentAdaptiveCell->getSubLeaf(idxLeafTgt));
}
}
else{
// If both have particles
for(int idxLeafTgt = 0 ; idxLeafTgt < currentAdaptiveCell->getNbSubLeaves() ; ++idxLeafTgt){
for(int idxLeafSrc = 0 ; idxLeafSrc < distantNeighbors[idxNeigh]->getNbSubLeaves() ; ++idxLeafSrc){
kernel.P2P(currentAdaptiveCell->getSubLeaf(idxLeafTgt), distantNeighbors[idxNeigh]->getSubLeaf(idxLeafSrc));
}
}
}
}
else{
const FAdaptiveCell<CellClass, ContainerClass>* lowerAdaptiveCell = distantNeighbors[idxNeigh];
int lowerAdaptiveLevel = inLevel;
// If we need to look at lower level to find the Adaptive cell
if(!distantNeighbors[idxNeigh]->isAdaptive()){
lowerAdaptiveCell = distantNeighbors[idxNeigh]->getSubAdaptiveCell();
lowerAdaptiveLevel = distantNeighbors[idxNeigh]->getSubAdaptiveLevel();
}
for(int idxNeighExisting = 0 ; idxNeighExisting < size ; ++idxNeighExisting){
const int idxNeigh = positions[idxNeighExisting];
// If the current cell is Adaptive and the neighbor too
if(distantNeighbors[idxNeighExisting]->isAdaptive() && local->isAdaptive()){
if(distantNeighbors[idxNeighExisting]->hasDevelopment() && currentAdaptiveCell->hasDevelopment()){
// If both have development than we can use usual M2L
normalDistantNeighbors[normalSize] = distantNeighbors[idxNeighExisting]->getRealCell();
normalPositions[normalSize] = idxNeigh;
normalSize += 1;
}
else if(currentAdaptiveCell->hasDevelopment()){
// If only current cell has development the neighbor has particles
for(int idxLeafSrc = 0 ; idxLeafSrc < distantNeighbors[idxNeighExisting]->getNbSubLeaves() ; ++idxLeafSrc){
kernel.P2L(currentAdaptiveCell->getRealCell(), currentAdaptiveLevel, distantNeighbors[idxNeighExisting]->getSubLeaf(idxLeafSrc));
}
}
else if(distantNeighbors[idxNeighExisting]->hasDevelopment()){
// If only current cell has particles the neighbor has development
for(int idxLeafTgt = 0 ; idxLeafTgt < currentAdaptiveCell->getNbSubLeaves() ; ++idxLeafTgt){
kernel.M2P(distantNeighbors[idxNeighExisting]->getRealCell(), currentAdaptiveLevel, currentAdaptiveCell->getSubLeaf(idxLeafTgt));
}
}
else{
// If both have particles
for(int idxLeafTgt = 0 ; idxLeafTgt < currentAdaptiveCell->getNbSubLeaves() ; ++idxLeafTgt){
for(int idxLeafSrc = 0 ; idxLeafSrc < distantNeighbors[idxNeighExisting]->getNbSubLeaves() ; ++idxLeafSrc){
kernel.P2P(currentAdaptiveCell->getSubLeaf(idxLeafTgt), distantNeighbors[idxNeighExisting]->getSubLeaf(idxLeafSrc));
}
}
}
}
else{
const FAdaptiveCell<CellClass, ContainerClass>* lowerAdaptiveCell = distantNeighbors[idxNeighExisting];
int lowerAdaptiveLevel = inLevel;
// If we need to look at lower level to find the Adaptive cell
if(!distantNeighbors[idxNeighExisting]->isAdaptive()){
lowerAdaptiveCell = distantNeighbors[idxNeighExisting]->getSubAdaptiveCell();
lowerAdaptiveLevel = distantNeighbors[idxNeighExisting]->getSubAdaptiveLevel();
}
if(lowerAdaptiveCell->hasDevelopment() && currentAdaptiveCell->hasDevelopment()){
// We are doing a M2L with distant interaction
kernel.M2L(currentAdaptiveCell->getRealCell(), currentAdaptiveLevel,
lowerAdaptiveCell->getRealCell(), lowerAdaptiveLevel);
}
else if(currentAdaptiveCell->hasDevelopment()){
// If only current cell has development the neighbor has particles
for(int idxLeafSrc = 0 ; idxLeafSrc < lowerAdaptiveCell->getNbSubLeaves() ; ++idxLeafSrc){
kernel.P2L(currentAdaptiveCell->getRealCell(), currentAdaptiveLevel, lowerAdaptiveCell->getSubLeaf(idxLeafSrc));
}
}
else if(lowerAdaptiveCell->hasDevelopment()){
// If only current cell has particles the neighbor has development
for(int idxLeafTgt = 0 ; idxLeafTgt < currentAdaptiveCell->getNbSubLeaves() ; ++idxLeafTgt){
kernel.M2P(lowerAdaptiveCell->getRealCell(), lowerAdaptiveLevel, currentAdaptiveCell->getSubLeaf(idxLeafTgt));
}
}
else{
// If both have particles
for(int idxLeafTgt = 0 ; idxLeafTgt < currentAdaptiveCell->getNbSubLeaves() ; ++idxLeafTgt){
for(int idxLeafSrc = 0 ; idxLeafSrc < lowerAdaptiveCell->getNbSubLeaves() ; ++idxLeafSrc){
kernel.P2P(currentAdaptiveCell->getSubLeaf(idxLeafTgt), lowerAdaptiveCell->getSubLeaf(idxLeafSrc));
}
}
}
}
if(lowerAdaptiveCell->hasDevelopment() && currentAdaptiveCell->hasDevelopment()){
// We are doing a M2L with distant interaction
kernel.M2L(currentAdaptiveCell->getRealCell(), currentAdaptiveLevel,
lowerAdaptiveCell->getRealCell(), lowerAdaptiveLevel);
}
else if(currentAdaptiveCell->hasDevelopment()){
// If only current cell has development the neighbor has particles
for(int idxLeafSrc = 0 ; idxLeafSrc < lowerAdaptiveCell->getNbSubLeaves() ; ++idxLeafSrc){
kernel.P2L(currentAdaptiveCell->getRealCell(), currentAdaptiveLevel, lowerAdaptiveCell->getSubLeaf(idxLeafSrc));
}
}
else if(lowerAdaptiveCell->hasDevelopment()){
// If only current cell has particles the neighbor has development
for(int idxLeafTgt = 0 ; idxLeafTgt < currentAdaptiveCell->getNbSubLeaves() ; ++idxLeafTgt){
kernel.M2P(lowerAdaptiveCell->getRealCell(), lowerAdaptiveLevel, currentAdaptiveCell->getSubLeaf(idxLeafTgt));
}
}
else{
// If both have particles
for(int idxLeafTgt = 0 ; idxLeafTgt < currentAdaptiveCell->getNbSubLeaves() ; ++idxLeafTgt){
for(int idxLeafSrc = 0 ; idxLeafSrc < lowerAdaptiveCell->getNbSubLeaves() ; ++idxLeafSrc){
kernel.P2P(currentAdaptiveCell->getSubLeaf(idxLeafTgt), lowerAdaptiveCell->getSubLeaf(idxLeafSrc));
}
}
}
}
}
// If we work on the current cell and it has development
if(normalSize){
kernel.M2L(local->getRealCell(), normalDistantNeighbors, normalSize, inLevel);
kernel.M2L(local->getRealCell(), normalDistantNeighbors, normalPositions, normalSize, inLevel);
}
}
......@@ -341,15 +343,15 @@ public:
/** This is a normal P2P */
void P2P(const FTreeCoordinate& inLeafPosition,
ContainerClass* const FRestrict targets, const ContainerClass* const FRestrict sources,
ContainerClass* const directNeighborsParticles[27], const int size) override {
kernel.P2P(inLeafPosition, targets, sources, directNeighborsParticles, size);
ContainerClass* const directNeighborsParticles[], const int positions[], const int size) override {
kernel.P2P(inLeafPosition, targets, sources, directNeighborsParticles, positions, size);
}
/** This is a normal P2P */
void P2PRemote(const FTreeCoordinate& inLeafPosition,
ContainerClass* const FRestrict targets, const ContainerClass* const FRestrict sources,
ContainerClass* const directNeighborsParticles[27], const int size) override {
kernel.P2PRemote(inLeafPosition, targets, sources, directNeighborsParticles, size);
ContainerClass* const directNeighborsParticles[], const int positions[], const int size) override {
kernel.P2PRemote(inLeafPosition, targets, sources, directNeighborsParticles, positions, size);
}
};
......
Src/Adaptive/FAdaptivePrintKernel.hpp
View file @ 3b1d2118
......@@ -34,12 +34,10 @@ public:
}
}
void M2L(CellClass* const FRestrict local, const CellClass* interactions[], const int counter, const int level) override {
void M2L(CellClass* const FRestrict local, const CellClass* interactions[], const int /*positions*/[], const int counter, const int level) override {
std::cout << "Usual] M2L Idx = " << local->getMortonIndex() << " at level " << level << " with\n";
for(int idxInter = 0 ; idxInter < 8 ; ++idxInter){
if(interactions[idxInter]){
for(int idxInter = 0 ; idxInter < counter ; ++idxInter){
std::cout << "\t Idx " << interactions[idxInter]->getMortonIndex() << "\n";
}
}
}
......@@ -58,23 +56,19 @@ public:
void P2P(const FTreeCoordinate& ,
ContainerClass* const FRestrict targets, const ContainerClass* const FRestrict ,
ContainerClass* const neighs[27], const int ) override {
ContainerClass* const neighs[], const int /*positions*/[], const int size) override {
std::cout << "Usual] P2P @" << targets << " has " << targets->getNbParticles() << " with\n";
for(int idxNeigh = 0 ; idxNeigh < 27 ; ++idxNeigh){
if(neighs[idxNeigh]){
for(int idxNeigh = 0 ; idxNeigh < size ; ++idxNeigh){
std::cout << "\t @" << neighs[idxNeigh]<< " has " << neighs[idxNeigh]->getNbParticles() << "\n";
}
}
}
void P2PRemote(const FTreeCoordinate& ,
ContainerClass* const FRestrict targets, const ContainerClass* const FRestrict ,
ContainerClass* const neighs[27], const int ) override {
ContainerClass* const neighs[], const int /*positions*/[], const int size) override {
std::cout << "Usual] P2P remote @" << targets << " has " << targets->getNbParticles() << " with\n";
for(int idxNeigh = 0 ; idxNeigh < 27 ; ++idxNeigh){
if(neighs[idxNeigh]){
for(int idxNeigh = 0 ; idxNeigh < size ; ++idxNeigh){
std::cout << "\t @" << neighs[idxNeigh]<< " has " << neighs[idxNeigh]->getNbParticles() << "\n";
}
}
}
......
Src/BalanceTree/FChebSymCostKernel.hpp
View file @ 3b1d2118
......@@ -197,7 +197,7 @@ public:
}
void P2M(CellClass* const cell, const ContainerClass* const SourceParticles) {
void P2M(CellClass* const cell, const ContainerClass* const SourceParticles) override {
FSize tmpCost = countFlopsP2M(SourceParticles->getNbParticles());
flopsP2M += tmpCost;
cell->addCost(tmpCost);
......@@ -208,7 +208,7 @@ public:
void M2M(CellClass* const FRestrict cell,
const CellClass*const FRestrict *const FRestrict ChildCells,
const int /*TreeLevel*/) {
const int /*TreeLevel*/) override {
FSize flops = 0;
for (unsigned int ChildIndex=0; ChildIndex < 8; ++ChildIndex)
if (ChildCells[ChildIndex]) flops += countFlopsM2MorL2L();
......@@ -221,17 +221,18 @@ public:
void M2L(CellClass* const FRestrict cell,
const CellClass* SourceCells[343],
const int /* not needed */,
const int /* TreeLevel */)
const CellClass* /*SourceCells*/[],
const int positions[],
const int size,
const int /* TreeLevel */) override
{
FSize flops = 0;
// count how ofter each of the 16 interactions is used
memset(countExp, 0, sizeof(int) * 343);
for (unsigned int idx=0; idx<343; ++idx)
if (SourceCells[idx]) countExp[SymHandler->pindices[idx]]++;
for (int idx=0; idx<size; ++idx)
countExp[SymHandler->pindices[positions[idx]]]++;
// multiply (mat-mat-mul)
for (unsigned int pidx=0; pidx<343; ++pidx)
for (int pidx=0; pidx<343; ++pidx)
if (countExp[pidx])
flops += countFlopsM2L(countExp[pidx], SymHandler->LowRank[pidx])
+ countExp[pidx]*nnodes;
......@@ -243,7 +244,7 @@ public:
void L2L(const CellClass* const FRestrict /* not needed */,
CellClass* FRestrict *const FRestrict ChildCells,
const int /* TreeLevel*/) {
const int /* TreeLevel*/) override {
FSize flops = 0;
FSize tmpCost = 0;
for (unsigned int ChildIndex=0; ChildIndex < 8; ++ChildIndex)
......@@ -260,7 +261,7 @@ public:
void L2P(const CellClass* const cell,
ContainerClass* const TargetParticles) {
ContainerClass* const TargetParticles) override {
//// 1.a) apply Sx
//flopsL2P += countFlopsP2MorL2P(TargetParticlesParticles->getNbParticles()) + TargetParticles->getNbParticles();
//// 1.b) apply Px (grad Sx)
......@@ -281,8 +282,9 @@ public:
void P2P(const FTreeCoordinate& LeafCellCoordinate, // needed for periodic boundary conditions
ContainerClass* const FRestrict TargetParticles,
const ContainerClass* const FRestrict SourceParticles,
ContainerClass* const NeighborSourceParticles[27],
const int /* size */) {
ContainerClass* const NeighborSourceParticles[],
const int positions[],
const int size) override {
FSize tmpCost = 0;
FSize srcPartCount = SourceParticles->getNbParticles();
FSize tgtPartCount = TargetParticles->getNbParticles();
......@@ -290,13 +292,11 @@ public:
if ( TargetParticles != SourceParticles ) {
tmpCost += countFlopsP2P() * tgtPartCount * srcPartCount;
for ( unsigned int idx = 0; idx < 27; ++idx ) {
if (NeighborSourceParticles[idx]) {
for ( int idx = 0; idx < size; ++idx ) {
tmpCost +=
countFlopsP2P()
* tgtPartCount
* NeighborSourceParticles[idx]->getNbParticles();
}
* NeighborSourceParticles[idx]->getNbParticles();
}
} else {
tmpCost +=
......@@ -304,15 +304,13 @@ public:
* ((tgtPartCount * tgtPartCount
+ tgtPartCount)
/ 2);
for (unsigned int idx=0; idx<=13; ++idx)
for (int idx=0; idx < size && positions[idx]<=13; ++idx)
{
if (NeighborSourceParticles[idx]) {
tmpCost +=
countFlopsP2Pmutual()
* tgtPartCount
* NeighborSourceParticles[idx]->getNbParticles();
}
}
}
flopsP2P += tmpCost;
......
Src/BalanceTree/FDumbCostKernel.hpp
View file @ 3b1d2118
......@@ -113,7 +113,7 @@ public:
// delete [] _countExp;
}
void P2M(CellClass* const cell, const ContainerClass* const SourceParticles) {
void P2M(CellClass* const cell, const ContainerClass* const SourceParticles) override {
FSize tmpCost = SourceParticles->getNbParticles();
flopsP2M += tmpCost;
cell->addCost(tmpCost);
......@@ -123,7 +123,7 @@ public:
void M2M(CellClass* const FRestrict cell,
const CellClass* const FRestrict* const FRestrict ChildrenCells,
const int /*TreeLevel*/) {
const int /*TreeLevel*/) override {
FSize flops = 0;
for ( unsigned int childIdx = 0; childIdx < 8; ++childIdx )
if ( ChildrenCells[childIdx] )
......@@ -135,16 +135,15 @@ public:
void M2L(CellClass* const FRestrict cell,
const CellClass* SourceCells[343],
const int /* not needed */,
const int /* TreeLevel */) {
const CellClass* /*SourceCells*/[],
const int /*positions*/[],
const int size,
const int /* TreeLevel */) override {
FSize flops = 0;
// count how often each of the 16 interactions is used
memset(_countExp, 0, sizeof(int) * 343);
for (unsigned int idx = 0; idx < 343; ++idx) {
if ( SourceCells[idx] ) {
flops += 1;
}
memset(_countExp, 0, sizeof(int) * 343);
for (int idx = 0; idx < size; ++idx) {
flops += 1;
}
flopsM2L += flops;
......@@ -155,7 +154,7 @@ public:
void L2L(const CellClass* const FRestrict /* not needed */,
CellClass* FRestrict *const FRestrict ChildCells,
const int /* TreeLevel*/) {
const int /* TreeLevel*/) override {
FSize flops = 0;
FSize tmpCost = 0;
for (unsigned int childIdx = 0; childIdx < 8; ++childIdx ) {
......@@ -173,7 +172,7 @@ public:
void L2P(const CellClass* const cell,
ContainerClass* const TargetParticles) {
ContainerClass* const TargetParticles) override {
FSize tmpCost = TargetParticles->getNbParticles();
flopsL2P += tmpCost;
cell->addCost(tmpCost);
......@@ -185,8 +184,9 @@ public:
void P2P(const FTreeCoordinate& LeafCellCoordinate, // needed for periodic boundary conditions
ContainerClass* const FRestrict TargetParticles,
const ContainerClass* const FRestrict SourceParticles,
ContainerClass* const NeighborSourceParticles[27],
const int /* size */) {
ContainerClass* const /*NeighborSourceParticles*/[],
const int /*positions*/[],
const int size) override {
FSize srcPartCount = SourceParticles->getNbParticles();
FSize tgtPartCount = TargetParticles->getNbParticles();
......
Src/BalanceTree/FFmmAlgorithmThreadBalanced.hpp
View file @ 3b1d2118
......@@ -320,19 +320,21 @@ protected:
// Cell count in zone (for this level)
int zoneCellCount = costzones.at(threadNum).at(level).second;
// Array for cell neighbours
const CellClass* neighbours[343];
const CellClass* neighbours[342];
int neighborPositions[342];
// Call M2L kernel on cells
while(zoneCellCount-- > 0) {
const int counter =
tree->getInteractionNeighbors(
neighbours,
neighbours, neighborPositions,
zoneIterator.getCurrentGlobalCoordinate(),
level);
if(counter)
myThreadkernels->M2L(
zoneIterator.getCurrentCell(),
neighbours,
neighborPositions,
counter,
level);
zoneIterator.moveRight();
......@@ -439,7 +441,8 @@ protected:
// Cell count in zone (for this level)
int zoneCellCount;
// Cell neighbours
ContainerClass* neighbours[27];
ContainerClass* neighbours[26];
int neighborPositions[26];
// Cell data
LeafData leafdata;
......@@ -474,7 +477,7 @@ protected:
if( p2pEnabled ) {
// needs the current particles and neighbours particles
const int counter =
tree->getLeafsNeighbors(neighbours,
tree->getLeafsNeighbors(neighbours,neighborPositions,
leafdata.cell->getCoordinate(),
OctreeHeight - 1); // Leaf level
......@@ -482,6 +485,7 @@ protected:
leafdata.targets,
leafdata.sources,
neighbours,
neighborPositions,
counter);
}
......
Src/Components/FAbstractKernels.hpp
View file @ 3b1d2118
......@@ -63,11 +63,25 @@ public:
* M2L
* Multipole to local
* @param local the element to fill using distant neighbors
* @param distantNeighbors is an array containing fathers's direct neighbors's child - direct neigbors
* @param distantNeighbors is an array containing fathers's direct neighbors's child - direct neigbors (max 189)
* @param neighborPositions the relative position of the neighbor (between O and 342)
* @param size the number of neighbors
* @param inLevel the current level of the computation
*
* @code // the code was:
* @code for(int idxNeigh = 0 ; idxNeigh < 343 ; ++idxNeigh){
* @code if(distantNeighbors[idxNeigh]){
* @code ...
* @code }
* @code }
* @code // Now it must be :
* @code for(int idxExistingNeigh = 0 ; idxExistingNeigh < size ; ++idxExistingNeigh){
* @code const int idxNeigh = neighborPositions[idxExistingNeigh]
* @code distantNeighbors[idxExistingNeigh]...
* @code }
*/
virtual void M2L(CellClass* const FRestrict local, const CellClass* distantNeighbors[343],
virtual void M2L(CellClass* const FRestrict local, const CellClass* distantNeighbors[],
const int neighborPositions[],
const int size, const int inLevel) = 0;
......@@ -113,12 +127,14 @@ public:
* @param inLeafPosition tree coordinate of the leaf
* @param targets current boxe targets particles
* @param sources current boxe sources particles (can be == to targets)
* @param directNeighborsParticles the particles from direct neighbors (this is an array of list)
* @param directNeighborsParticles the particles from direct neighbors (this is an array of list) max length = 26
* @param neighborPositions the relative position of the neighbors (between O and 25) max length = 26
* @param size the number of direct neighbors
*/
virtual void P2P(const FTreeCoordinate& inLeafPosition,
ContainerClass* const FRestrict targets, const ContainerClass* const FRestrict sources,
ContainerClass* const directNeighborsParticles[27], const int size) = 0;
ContainerClass* const directNeighborsParticles[], const int neighborPositions[],
const int size) = 0;
/**
* P2P
......@@ -126,7 +142,8 @@ public:
* @param inLeafPosition tree coordinate of the leaf
* @param targets current boxe targets particles
* @param sources current boxe sources particles (can be == to targets)
* @param directNeighborsParticles the particles from direct neighbors (this is an array of list)
* @param directNeighborsParticles the particles from direct neighbors (this is an array of list) max length = 26
* @param neighborPositions the relative position of the neighbors (between 0 and 25) max length = 26
* @param size the number of direct neighbors
*
* This method is called by the MPI algorithm with leaves from other hosts.
......@@ -135,7 +152,8 @@ public:
*/
virtual void P2PRemote(const FTreeCoordinate& /*inLeafPosition*/,
ContainerClass* const FRestrict /*targets*/, const ContainerClass* const FRestrict /*sources*/,
ContainerClass* const /*directNeighborsParticles*/[27], const int /*size*/) {
ContainerClass* const /*directNeighborsParticles*/[],
const int /*neighborPositions*/[], const int /*size*/) {
FLOG( FLog::Controller.write("Warning, P2P remote is used but not implemented!").write(FLog::Flush) );
}
......
Src/Components/FBasicKernels.hpp
View file @ 3b1d2118
......@@ -35,42 +35,43 @@ public:
}
/** Do nothing */
virtual void P2M(CellClass* const , const ContainerClass* const ) {
virtual void P2M(CellClass* const /*targetCell*/, const ContainerClass* const /*sourceParticles*/) override {
}
/** Do nothing */
virtual void M2M(CellClass* const FRestrict , const CellClass*const FRestrict *const FRestrict , const int ) {
virtual void M2M(CellClass* const FRestrict /*parentCell*/, const CellClass*const FRestrict *const FRestrict /*children*/, const int /*level*/) override {
}
/** Do nothing */
virtual void M2L(CellClass* const FRestrict , const CellClass* [], const int , const int ) {
virtual void M2L(CellClass* const FRestrict /*targetLocal*/, const CellClass* /*sourceMultipoles*/[],
const int /*relativePostions*/[], const int /*nbInteractions*/, const int /*level*/) override {
}
/** Do nothing */
virtual void L2L(const CellClass* const FRestrict , CellClass* FRestrict *const FRestrict , const int ) {
virtual void L2L(const CellClass* const FRestrict /*parentCell*/, CellClass* FRestrict *const FRestrict /*children*/, const int /*level*/) override {
}
/** Do nothing */
virtual void L2P(const CellClass* const , ContainerClass* const ){
virtual void L2P(const CellClass* const /*sourceCell*/, ContainerClass* const /*targetPaticles*/) override {
}
/** Do nothing */
virtual void P2P(const FTreeCoordinate& ,
ContainerClass* const FRestrict , const ContainerClass* const FRestrict ,
ContainerClass* const [27], const int ){
virtual void P2P(const FTreeCoordinate& /*treeCoord*/,
ContainerClass* const FRestrict /*targetParticles*/, const ContainerClass* const FRestrict /*sourceParticles*/,
ContainerClass* const /*neigbhorsParticles*/[], const int /*neighborPositions*/[], const int /*nbNeighbors*/) override {
}
/** Do nothing */
virtual void P2PRemote(const FTreeCoordinate& ,
ContainerClass* const FRestrict , const ContainerClass* const FRestrict ,
ContainerClass* const [27], const int ){
virtual void P2PRemote(const FTreeCoordinate& /*treeCoord*/,
ContainerClass* const FRestrict /*targetParticles*/, const ContainerClass* const FRestrict /*sourceParticles*/,
ContainerClass* const /*neigbhorsParticles*/[], const int /*neighborPositions*/[], const int /*nbNeighbors*/) override {
}
......