Commit 1aaea58d authored by Quentin Khan's avatar Quentin Khan

Fix test_FAdaptiveSequential

parent f27c7591
......@@ -50,12 +50,20 @@ namespace test_count_data {
struct multipole_t {
std::size_t dummy = 0;
std::size_t up = 0;
std::size_t P2M_count = 0; // one if leaf
std::size_t M2M_count = 0; // one per child, 0 if leaf
std::size_t M2P_count = 0; // one per x-item list
} m_data;
/// Local development particle interaction count
struct local_expansion_t {
std::size_t down = 0;
std::size_t dummy = 0;
std::size_t M2L_count = 0; // one per v-list item
std::size_t L2L_count = 0; // one per child, 0 if leaf
std::size_t L2P_count = 0; // one if leaf
std::size_t P2L_count = 0; // one per w-list item
} l_data;
};
......@@ -139,6 +147,7 @@ struct FCountKernel {
mtx.unlock();
leaf_multipole->dummy += 1;
leaf_multipole->up += source_particle_container->size();
leaf_multipole->P2M_count += 1;
leaf_multipole->dummy -= 1;
}
......@@ -156,6 +165,7 @@ struct FCountKernel {
for(std::size_t idx = 0 ; idx < child_count ; ++idx) {
if(child_multipoles[idx]) {
node_multipole->up += child_multipoles[idx]->up;
node_multipole->M2M_count += 1;
if(child_multipoles[idx]->dummy) {
std::cerr << "P2M/M2M parallelism overlap... lvl:" << node_symbolic_data->getLevel() << "\n";
std::cerr << child_multipoles[idx]->dummy << '\n';
......@@ -180,13 +190,14 @@ struct FCountKernel {
for(int idx = 0 ; idx < v_item_data_size ; ++idx) {
if(v_item_multipoles[idx]) {
node_local_expansion->down += v_item_multipoles[idx]->up;
node_local_expansion->M2L_count += 1;
}
}
}
template<class Symb>
void L2L(const typename CellClass::local_expansion_t* const node_local_exp,
void L2L(typename CellClass::local_expansion_t* const node_local_exp,
const Symb* const /*node_symbolic_data*/,
typename CellClass::local_expansion_t** const child_local_exps,
const Symb* const /*child_symbolic_data*/[])
......@@ -197,6 +208,7 @@ struct FCountKernel {
for(std::size_t idx = 0 ; idx < child_count ; ++idx) {
if(child_local_exps[idx]) {
child_local_exps[idx]->down += node_local_exp->down;
node_local_exp->L2L_count += 1;
}
}
......@@ -211,18 +223,20 @@ struct FCountKernel {
mtx.lock();
this->call_count["P2L"] += 1;
mtx.unlock();
node_local_expansion->P2L_count += 1;
node_local_expansion->down += source_particle_container->size();
}
template<class Symb>
void L2P(const typename CellClass::local_expansion_t* const leaf_local_exp,
void L2P(typename CellClass::local_expansion_t* const leaf_local_exp,
const Symb* const /* target_symbolic_data */,
ContainerClass* const target_particle_container)
{
mtx.lock();
this->call_count["L2P"] += 1;
mtx.unlock();
leaf_local_exp->L2P_count += 1;
for(auto&& particle_ref_tuple : *target_particle_container) {
std::get<particle_t::COUNT>(particle_ref_tuple) += leaf_local_exp->down;
}
......@@ -230,7 +244,7 @@ struct FCountKernel {
template<class Symb>
void M2P(const typename CellClass::multipole_t* const node_multipole,
void M2P(typename CellClass::multipole_t* const node_multipole,
const Symb* const /* node_symbolic_data */,
ContainerClass* const target_particle_container,
const Symb* const /* leaf_symbolic_data */)
......@@ -238,6 +252,7 @@ struct FCountKernel {
mtx.lock();
this->call_count["M2P"] += 1;
mtx.unlock();
node_multipole->M2P_count += 1;
for(auto&& particle_ref_tuple : *target_particle_container) {
std::get<particle_t::COUNT>(particle_ref_tuple) += node_multipole->up;
}
......
......@@ -29,6 +29,15 @@
#include "FCountKernel.hpp"
/**
* \brief Expected P2P count for a node
*
* Computes the maximum P2P interaction count for given node.
*
* \warning For an adaptive tree, this count is not the exact interaction
* count. Some nodes that are counted here may not exist in the actual tree.
*/
template<typename node_t>
std::size_t expected_P2P(node_t* node) {
std::size_t index = node->getIndex();
......@@ -50,7 +59,7 @@ std::size_t expected_P2P(node_t* node) {
template<typename node_t>
std::size_t expected_P2M(node_t* node) {
if(node->is_leaf())
if(node->is_leaf() && node->getParticleContainer()->size() != 0)
return 1;
else
return 0;
......@@ -65,19 +74,25 @@ std::size_t expected_M2M(node_t* node) {
}
}
/**
* \brief Expected M2L count for a node
*
* Computes the maximum M2L interaction count that given node can have.
*
* \warning For an adaptive tree, this count is not the exact interaction
* count. Some nodes that are counted here may not exist in the actual tree.
*/
template<typename node_t>
std::size_t expected_M2L(node_t* node, bool v = false) {
std::size_t expected_M2L(node_t* node) {
std::size_t index = node->getIndex();
std::size_t depth = node->getLevel();
int min = 0;
int max = (int)std::pow(2,depth);
int max = 1 << depth;
FTreeCoordinate coord(index);
if(v)
std::cout << min << " " << max << " " << coord << " " << index << " ";
std::size_t count = 0;
for(int i = std::max(min, coord[0]-2-(coord[0]%2)) ;
......@@ -93,9 +108,6 @@ std::size_t expected_M2L(node_t* node, bool v = false) {
(j < coord[1] - 1 || j > coord[1] + 1) ||
(k < coord[2] - 1 || k > coord[2] + 1)) {
if(v)
std::cout << '('<< i << ", " << j << ", "<< k << ')';
++count;
}
}
......@@ -115,7 +127,7 @@ std::size_t expected_L2L(node_t* node) {
template<typename node_t>
std::size_t expected_L2P(node_t* node) {
if(node->is_leaf()) {
if(node->is_leaf() && node->getParticleContainer()->size() != 0) {
return 1;
} else {
return 0;
......@@ -152,15 +164,16 @@ void test_particle_count(tree_t& tree, const position_vector_t& position_vector)
}
template<typename tree_t, typename kernel_t>
void test_P2M(tree_t& tree, kernel_t& kernel) {
void test_P2M(tree_t& tree, kernel_t&) {
// Assert that all particles have the right count attribute
for(auto&& node : tree.post_order_walk()) {
auto leaf = &node;
if(kernel.call_count["P2M"] != expected_P2M(leaf)) {
auto* leaf = &node;
if(leaf->getData()->getMultipoleData().P2M_count != expected_P2M(leaf)) {
std::cout << "error-P2M "
<< &(leaf->getData()->getMultipoleData()) << " "
<< leaf->getIndex() << " "
<< FTreeCoordinate(leaf->getIndex()) << " "
<< kernel.call_count["P2M"] << " "
<< leaf->getData()->getMultipoleData().P2M_count << " "
<< expected_P2M(leaf)
<< std::endl;
}
......@@ -172,12 +185,12 @@ template<typename tree_t, typename kernel_t>
void test_M2M(tree_t& tree, kernel_t& kernel) {
// Assert that all particles have the right count attribute
for(auto&& node : tree.post_order_walk()) {
auto leaf = &node;
if(kernel.call_count["M2M"] != expected_M2M(leaf)) {
auto n = &node;
if(n->getData()->getMultipoleData().M2M_count != expected_M2M(n)) {
std::cout << "error-M2M "
<< leaf->getIndex() << " "
<< n->getIndex() << " "
<< kernel.call_count["M2M"] << " "
<< expected_M2M(leaf)
<< expected_M2M(n)
<< std::endl;
}
}
......@@ -205,12 +218,12 @@ template<typename tree_t, typename kernel_t>
void test_L2L(tree_t& tree, kernel_t& kernel) {
// Assert that all particles have the right count attribute
for(auto&& node : tree.in_order_walk()) {
auto leaf = &node;
if(kernel.call_count["L2L"] != expected_L2L(leaf)) {
auto n = &node;
if(n->getData()->getLocalExpansionData().L2L_count != expected_L2L(n)) {
std::cout << "error-L2L "
<< leaf->getIndex() << " "
<< n->getIndex() << " "
<< kernel.call_count["L2L"] << " "
<< expected_L2L(leaf)
<< expected_L2L(n)
<< std::endl;
}
}
......@@ -221,7 +234,7 @@ void test_L2P(tree_t& tree, kernel_t& kernel) {
// Assert that all particles have the right count attribute
for(auto&& node : tree.in_order_walk()) {
auto leaf = &node;
if(kernel.call_count["L2P"] != expected_L2P(leaf)) {
if(leaf->getData()->getLocalExpansionData().L2P_count != expected_L2P(leaf)) {
std::cout << "error-L2P "
<< leaf->getIndex() << " "
<< kernel.call_count["L2P"] << " "
......@@ -277,10 +290,10 @@ int main() {
fmm_algo.run();
test_P2P(tree, kernel);
// test_P2P(tree, kernel); // TODO error, kernel count total P2P, function tests for node P2P
test_P2M(tree, kernel);
test_M2M(tree, kernel);
test_M2L(tree, kernel);
// test_M2L(tree, kernel);
test_L2L(tree, kernel);
test_L2P(tree, kernel);
test_particle_count(tree, position_vect);
......
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