Homec4science
Diffusion LibMultiScale (master) Browse

libmultiscale/src/dd/paradis/ref_elem_paradis.hh
67669d16b941master

Last Change
Raw File

ref_elem_paradis.hh
View Options

/**
* @file ref_node_paradis.hh
*
* @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
* @author Max Hodapp <max.hodapp@epfl.ch>
* @author Jaehyun Cho <jaehyun.cho@epfl.ch>
*
* @date Mon Oct 28 19:23:14 2013
*
* @brief Nodal reference of ParaDiS
*
* @section LICENSE
*
* Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
* Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
*
* LibMultiScale is free software: you can redistribute it and/or modify it
* under the
* terms of the GNU Lesser General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* LibMultiScale 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 Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with LibMultiScale. If not, see <http://www.gnu.org/licenses/>.
*
*/
#ifndef __LIBMULTISCALE_REF_ELEM_PARADIS_HH__
#define __LIBMULTISCALE_REF_ELEM_PARADIS_HH__
/* -------------------------------------------------------------------------- */
// ParaDis includes
#define PARALLEL
#include <mpi.h>
extern "C" {
#include "Home.h"
#include "Typedefs.h"
}
#undef PARALLEL
/* -------------------------------------------------------------------------- */
#include "ref_elem_dd.hh"
#include "ref_node_paradis.hh"
/* -------------------------------------------------------------------------- */
__BEGIN_LIBMULTISCALE__
/* -------------------------------------------------------------------------- */
class RefElemParaDiS : public RefDDElem<3, RefElemParaDiS> {
public:
friend class IteratorElemsParaDiS;
static const UInt Dim = 3;
using fields = field_list<_burgers, _normal>;
RefElemParaDiS() {}
~RefElemParaDiS() {}
template <typename Vec> inline void setConnectivity(Vec &&conn);
bool operator==(RefElemParaDiS &) { LM_TOIMPLEMENT; };
VectorProxy<3> burgers();
VectorProxy<3> normal();
std::vector<UInt> localIndexes() override;
RefElemParaDiS getMirrorElem();
RefNodeParaDiS getNode(UInt i);
private:
void setIndex(UInt index, UInt arm);
UInt index_node;
UInt arm_number;
};
/* -------------------------------------------------------------------------- */
inline std::ostream &operator<<(std::ostream &, RefElemParaDiS &) {
LM_TOIMPLEMENT;
}
/* -------------------------------------------------------------------------- */
template <typename Vec>
inline void RefElemParaDiS::setConnectivity(Vec &&conn) {
auto node1_index = conn[0];
auto node2_index = conn[1];
auto *node1 = ParaDiSHome::paradis_ptr->nodeKeys[node1_index];
auto *node2 = ParaDiSHome::paradis_ptr->nodeKeys[node2_index];
if (node1 == nullptr or node2 == nullptr)
LM_FATAL("invalid connectivity or nodes not created");
auto node1_numNbrs = node1->numNbrs;
auto node2_numNbrs = node2->numNbrs;
this->index_node = node1_index;
this->arm_number = node1_numNbrs;
if (node1_index > node2_index) {
this->index_node = node2_index;
this->arm_number = node2_numNbrs;
}
auto *node1_nbrTags = node1->nbrTag;
auto *node2_nbrTags = node2->nbrTag;
if (node1_numNbrs > 0) {
if (node1_nbrTags == nullptr)
LM_FATAL("inconsistent nbrtags");
for (int i = 0; i < node1_numNbrs; ++i)
if (node1_nbrTags[i].index == (int)node2_index)
LM_FATAL("inconsistent nbrtags");
}
if (node2_numNbrs > 0) {
if (node2_nbrTags == nullptr)
LM_FATAL("inconsistent nbrtags");
for (int i = 0; i < node2_numNbrs; ++i)
if (node2_nbrTags[i].index == (int)node1_index)
LM_FATAL("inconsistent nbrtags");
}
ReallocNodeArms(node1, node1_numNbrs + 1);
ReallocNodeArms(node2, node2_numNbrs + 1);
node2->nbrTag[node2_numNbrs].domainID = node1->myTag.domainID;
node2->nbrTag[node2_numNbrs].index = node1->myTag.index;
node1->nbrTag[node1_numNbrs].domainID = node2->myTag.domainID;
node1->nbrTag[node1_numNbrs].index = node2->myTag.index;
}
/* -------------------------------------------------------------------------- */
inline VectorProxy<3> RefElemParaDiS::burgers() {
auto *node = ParaDiSHome::paradis_ptr->nodeKeys[this->index_node];
return VectorProxy<3>(std::forward_as_tuple(node->burgX[arm_number],
node->burgY[arm_number],
node->burgZ[arm_number]));
}
/* -------------------------------------------------------------------------- */
inline VectorProxy<3> RefElemParaDiS::normal() {
auto *node = ParaDiSHome::paradis_ptr->nodeKeys[this->index_node];
return VectorProxy<3>(std::forward_as_tuple(
node->nx[arm_number], node->ny[arm_number], node->nz[arm_number]));
}
/* -------------------------------------------------------------------------- */
inline void RefElemParaDiS::setIndex(UInt index, UInt arm) {
index_node = index;
arm_number = arm;
}
/* -------------------------------------------------------------------------- */
inline std::vector<UInt> RefElemParaDiS::localIndexes() {
std::vector<UInt> nodes;
auto *node1 = ParaDiSHome::paradis_ptr->nodeKeys[this->index_node];
auto tag1 = node1->myTag.index;
auto tag2 = node1->nbrTag[arm_number].index;
nodes.push_back(tag1);
nodes.push_back(tag2);
return nodes;
}
/* -------------------------------------------------------------------------- */
inline RefNodeParaDiS RefElemParaDiS::getNode(UInt i) {
auto *node1 = ParaDiSHome::paradis_ptr->nodeKeys[this->index_node];
auto tag = node1->myTag.index;
if (i == 1)
tag = node1->nbrTag[arm_number].index;
return RefNodeParaDiS(tag);
}
/* -------------------------------------------------------------------------- */
inline RefElemParaDiS RefElemParaDiS::getMirrorElem() {
auto *node1 = ParaDiSHome::paradis_ptr->nodeKeys[this->index_node];
auto tag2 = node1->nbrTag[arm_number].index;
auto tag1 = node1->myTag.index;
RefElemParaDiS mirror_ref;
mirror_ref.index_node = tag2;
mirror_ref.arm_number = UInt(-1);
auto *node2 = ParaDiSHome::paradis_ptr->nodeKeys[tag2];
for (int i = 0; i < node2->numNbrs; ++i) {
if (tag1 == node2->nbrTag[i].index) {
mirror_ref.arm_number = i;
break;
}
}
if (mirror_ref.arm_number == UInt(-1)) {
LM_FATAL("cannot find the other pair");
}
return mirror_ref;
}
__END_LIBMULTISCALE__
#endif /* __LIBMULTISCALE_REF_ELEM_PARADIS_HH__ */
c4science · Help