Skip to content
Snippets Groups Projects
Commit 6e7378c1 authored by chantrait's avatar chantrait
Browse files

implementation of Serializers in 1D and set mpi destination rank in the language

parent 9020b02a
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
src/language/modules/CouplageModule.cpp
+ 18
− 36
View file @ 6e7378c1
......@@ -11,7 +11,7 @@
#include <mesh/Connectivity.hpp>
#include <mesh/Mesh.hpp>
#include <mesh/MeshNodeBoundary.hpp>
#include <mesh/MeshNodeZone.hpp>
#include <mesh/MeshNodeInterface.hpp>
#include <scheme/DirichletBoundaryConditionDescriptor.hpp>
#include <scheme/DiscreteFunctionVariant.hpp>
#include <scheme/FixedBoundaryConditionDescriptor.hpp>
......@@ -25,50 +25,32 @@
CouplageModule::CouplageModule()
{
this->_addBuiltinFunction("serialize_new",
this->_addBuiltinFunction("serialize",
std::function(
[](std::shared_ptr<const IMesh> i_mesh,
const std::vector<std::shared_ptr<const IZoneDescriptor>>& i_zone_list) -> void {
for (const auto& i_zone : i_zone_list) {
const int tag = 10;
using MeshType = Mesh<Connectivity<2>>;
const std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
auto mesh_node_zone = getMeshNodeZone(*p_mesh, *i_zone);
std::cout << "\033[01;31m"
<< "mesh_node_zone" << mesh_node_zone << "\033[00;00m" << std::endl;
/* for (size_t i_ref_node_list = 0; */
/* i_ref_node_list < */
/* mesh->connectivity().template numberOfRefItemList<ItemType::edge>(); */
/* ++i_ref_node_list) { */
/* const auto& ref_node_list = */
/* mesh->connectivity().template refItemList<ItemType::edge>(i_ref_node_list);
*/
/* const RefId& ref = ref_node_list.refId(); */
/* if (ref == i_zone) { */
/* return ref_node_list; */
/* } */
/* } */
}
return;
const std::vector<std::shared_ptr<const IInterfaceDescriptor>>& i_interface_list)
-> void {
const int tag = 20;
return Serializer().apply(i_mesh, i_interface_list, tag);
}));
this->_addBuiltinFunction("serialize", std::function([](std::shared_ptr<const IMesh> mesh) -> void {
const int tag = 10;
return Serializer().apply(mesh, tag);
this->_addBuiltinFunction("serialize", std::function([](std::shared_ptr<const IMesh> mesh, const int64_t dest,
const int64_t tag) -> void {
return Serializer().apply(mesh, dest, tag);
}));
this->_addBuiltinFunction("serialize", std::function([](const std::shared_ptr<const IBoundaryDescriptor>& boundary,
std::shared_ptr<const IMesh> mesh, int64_t location) -> void {
const int tag = 100;
return Serializer().apply(boundary, mesh, location, tag);
std::shared_ptr<const IMesh> mesh, int64_t location,
const int64_t dest, const int64_t tag) -> void {
std::cout << "\033[01;32m"
<< "dest: " << dest << "\ntag: " << tag << "\033[00;00m" << std::endl;
return Serializer().apply(boundary, mesh, location, dest, tag);
}));
this->_addBuiltinFunction("serialize_field",
std::function([](const std::shared_ptr<const IBoundaryDescriptor>& boundary,
const std::shared_ptr<const DiscreteFunctionVariant>& field) -> void {
std::function([](const std::shared_ptr<const DiscreteFunctionVariant>& field) -> void {
const int tag = 300;
return Serializer().apply(boundary, field, tag);
return Serializer().apply(field, tag);
}));
this->_addBuiltinFunction("serialize_field",
......@@ -81,7 +63,7 @@ CouplageModule::CouplageModule()
this->_addBuiltinFunction("cpl_change_mesh_position",
std::function([](std::shared_ptr<const IMesh> mesh) -> std::shared_ptr<const IMesh> {
const int tag = -1;
const int tag = 400;
return Serializer().change_mesh_position(mesh, tag);
}));
......
src/mesh/CMakeLists.txt
+ 0
− 1
View file @ 6e7378c1
......@@ -36,7 +36,6 @@ add_library(
MeshLineFaceBoundary.cpp
MeshLineNodeBoundary.cpp
MeshNodeBoundary.cpp
MeshNodeZone.cpp
MeshNodeInterface.cpp
MeshRandomizer.cpp
MeshSmoother.cpp
......
src/mesh/MeshNodeZone.cpp deleted 100644 → 0
+ 0
− 42
View file @ 9020b02a
#include <mesh/MeshNodeZone.hpp>
#include <mesh/Connectivity.hpp>
#include <mesh/Mesh.hpp>
#include <utils/Messenger.hpp>
template <size_t Dimension>
MeshNodeZone<Dimension>::MeshNodeZone(const Mesh<Connectivity<Dimension>>&, const RefNodeList& ref_node_list)
: m_node_list(ref_node_list.list()), m_zone_name(ref_node_list.refId().tagName())
{}
template <size_t Dimension>
// MeshNodeZone<Dimension>
int
getMeshNodeZone(const Mesh<Connectivity<Dimension>>& mesh, const IZoneDescriptor& zone_descriptor)
{
for (size_t i_ref_edge_list = 0; i_ref_edge_list < mesh.connectivity().template numberOfRefItemList<ItemType::edge>();
++i_ref_edge_list) {
const auto& ref_edge_list = mesh.connectivity().template refItemList<ItemType::edge>(i_ref_edge_list);
const RefId& ref = ref_edge_list.refId();
if (ref == zone_descriptor) {
std::cout << "\033[01;31m"
<< "ref" << ref << "\033[00;00m" << std::endl;
return 1;
/* return MeshNodeZone<Dimension>{mesh, ref_node_list}; */
}
}
std::ostringstream ost;
ost << "cannot find node set with name \"" << rang::fgB::red << zone_descriptor << rang::style::reset << '\"';
throw NormalError(ost.str());
}
/* template MeshNodeZone<1> getMeshNodeZone(const Mesh<Connectivity<1>>&, const IZoneDescriptor&); */
/* template MeshNodeZone<2> getMeshNodeZone(const Mesh<Connectivity<2>>&, const IZoneDescriptor&); */
/* template MeshNodeZone<3> getMeshNodeZone(const Mesh<Connectivity<3>>&, const IZoneDescriptor&); */
template int getMeshNodeZone(const Mesh<Connectivity<1>>&, const IZoneDescriptor&);
template int getMeshNodeZone(const Mesh<Connectivity<2>>&, const IZoneDescriptor&);
template int getMeshNodeZone(const Mesh<Connectivity<3>>&, const IZoneDescriptor&);
src/mesh/MeshNodeZone.hpp deleted 100644 → 0
+ 0
− 53
View file @ 9020b02a
#ifndef MESH_NODE_ZONE_HPP
#define MESH_NODE_ZONE_HPP
#include <mesh/IZoneDescriptor.hpp>
#include <mesh/RefItemList.hpp>
#include <utils/Array.hpp>
template <size_t Dimension>
class Connectivity;
template <typename ConnectivityType>
class Mesh;
template <size_t Dimension>
class [[nodiscard]] MeshNodeZone // clazy:exclude=copyable-polymorphic
{
protected:
Array<const NodeId> m_node_list;
std::string m_zone_name;
public:
template <size_t MeshDimension>
friend MeshNodeZone<MeshDimension> getMeshNodeZone(const Mesh<Connectivity<MeshDimension>>& mesh,
const IZoneDescriptor& zone_descriptor);
MeshNodeZone& operator=(const MeshNodeZone&) = default;
MeshNodeZone& operator=(MeshNodeZone&&) = default;
const Array<const NodeId>&
nodeList() const
{
return m_node_list;
}
protected:
MeshNodeZone(const Mesh<Connectivity<Dimension>>& mesh, const RefNodeList& ref_node_list);
public:
MeshNodeZone(const MeshNodeZone&) = default;
MeshNodeZone(MeshNodeZone&&) = default;
MeshNodeZone() = default;
virtual ~MeshNodeZone() = default;
};
/* template <size_t Dimension> */
/* MeshNodeZone<Dimension> getMeshNodeZone(const Mesh<Connectivity<Dimension>>& mesh, */
/* const IZoneDescriptor& zone_descriptor); */
template <size_t Dimension>
int getMeshNodeZone(const Mesh<Connectivity<Dimension>>& mesh, const IZoneDescriptor& zone_descriptor);
#endif // MESH_NODE_ZONE_HPP
src/utils/CMakeLists.txt
+ 2
− 3
View file @ 6e7378c1
......@@ -18,8 +18,7 @@ add_library(
SignalManager.cpp
SLEPcWrapper.cpp
Serializer.cpp
Socket.cpp
)
Socket.cpp)
target_link_libraries(
PugsUtils
......
src/utils/Serializer.cpp
+ 164
− 10
View file @ 6e7378c1
......@@ -11,14 +11,36 @@ Serializer::~Serializer() = default;
// MESH
void
Serializer::apply(std::shared_ptr<const IMesh> i_mesh, const int tag)
Serializer::apply(std::shared_ptr<const IMesh> i_mesh, const int dest, const int tag)
{
auto costo = parallel::Messenger::getInstance().myCoupling;
const int dest = costo->myGlobalSize() - 1;
std::vector<int> shape;
std::vector<double> pts;
switch (i_mesh->dimension()) {
case 1: {
using MeshType = Mesh<Connectivity<1>>;
const std::shared_ptr mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
using Rd = TinyVector<MeshType::Dimension>;
const NodeValue<const Rd>& xr = mesh->xr();
Array<TinyVector<1>> positions(mesh->numberOfNodes());
parallel_for(
mesh->numberOfNodes(), PUGS_LAMBDA(NodeId r) {
for (unsigned short i = 0; i < MeshType::Dimension; ++i) {
positions[r][i] = xr[r][i];
}
});
pts.resize(mesh->numberOfNodes() * MeshType::Dimension);
for (unsigned short r = 0; r < mesh->numberOfNodes(); ++r) {
for (unsigned short j = 0; j < MeshType::Dimension; ++j) {
pts[MeshType::Dimension * r + j] = positions[r][j];
}
}
shape.resize(3);
shape[0] = mesh->numberOfNodes();
shape[1] = i_mesh->dimension();
shape[2] = 0;
break;
}
case 2: {
......@@ -43,7 +65,7 @@ Serializer::apply(std::shared_ptr<const IMesh> i_mesh, const int tag)
shape.resize(3);
shape[0] = mesh->numberOfNodes();
shape[1] = 2;
shape[1] = i_mesh->dimension();
shape[2] = 0;
break;
}
......@@ -71,7 +93,7 @@ Serializer::apply(std::shared_ptr<const IMesh> i_mesh, const int tag)
shape.resize(3);
shape[0] = mesh->numberOfNodes();
shape[1] = 3;
shape[1] = i_mesh->dimension();
shape[2] = 0;
break;
}
......@@ -87,10 +109,10 @@ void
Serializer::apply(const std::shared_ptr<const IBoundaryDescriptor>& boundary,
std::shared_ptr<const IMesh> i_mesh,
const int location,
const int dest,
const int tag)
{
auto costo = parallel::Messenger::getInstance().myCoupling;
const int dest = costo->myGlobalSize() - 1;
std::vector<int> shape;
std::vector<double> pts;
std::cout << "\033[01;31m"
......@@ -102,6 +124,42 @@ Serializer::apply(const std::shared_ptr<const IBoundaryDescriptor>& boundary,
<< "\033[00;00m" << std::endl;
switch (i_mesh->dimension()) {
case 1: {
using MeshType = Mesh<Connectivity<1>>;
const std::shared_ptr mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
using MeshDataType = MeshData<1>;
MeshDataType& mesh_data = MeshDataManager::instance().getMeshData(*mesh);
/* const ItemValue<const Rd>& xl = mesh_data.xl(); */
const auto xl = mesh_data.xl();
Array<TinyVector<1>> fpositions(mesh->numberOfFaces());
parallel_for(
mesh->numberOfFaces(), PUGS_LAMBDA(FaceId l) {
for (unsigned short i = 0; i < MeshType::Dimension; ++i) {
fpositions[l][i] = xl[l][i];
}
/* for (unsigned short i = MeshType::Dimension; i < 3; ++i) { */
/* positions[r][i] = 0; */
/* } */
});
MeshFaceBoundary<1> mesh_face_boundary = getMeshFaceBoundary(*mesh, *boundary);
/* mesh_face_boundary.faceList() */
const auto face_list = mesh_face_boundary.faceList();
pts.resize(face_list.size() * MeshType::Dimension);
for (size_t i_face = 0; i_face < face_list.size(); ++i_face) {
const FaceId face_id = face_list[i_face];
for (unsigned short j = 0; j < MeshType::Dimension; ++j) {
pts[MeshType::Dimension * i_face + j] = fpositions[face_id][j];
}
/* std::cout << "\033[01;31m" << pts[2 * r] << "; " << pts[2 * r + 1] << "\033[00;00m" << std::endl; */
}
shape.resize(3);
shape[0] = face_list.size();
shape[1] = i_mesh->dimension();
shape[2] = 0;
break;
}
case 2: {
......@@ -191,6 +249,39 @@ Serializer::apply(const std::shared_ptr<const IBoundaryDescriptor>& boundary,
<< "\033[00;00m" << std::endl;
switch (i_mesh->dimension()) {
case 1: {
using MeshType = Mesh<Connectivity<1>>;
const std::shared_ptr mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
/* const ItemValue<const Rd>& xl = mesh_data.xl(); */
const auto xr = mesh->xr();
Array<TinyVector<1>> positions(mesh->numberOfNodes());
parallel_for(
mesh->numberOfNodes(), PUGS_LAMBDA(NodeId r) {
for (unsigned short i = 0; i < MeshType::Dimension; ++i) {
positions[r][i] = xr[r][i];
}
/* for (unsigned short i = MeshType::Dimension; i < 3; ++i) { */
/* positions[r][i] = 0; */
/* } */
});
MeshNodeBoundary<1> mesh_node_boundary = getMeshNodeBoundary(*mesh, *boundary);
/* mesh_face_boundary.faceList() */
const auto node_list = mesh_node_boundary.nodeList();
pts.resize(node_list.size() * MeshType::Dimension);
for (size_t i_node = 0; i_node < node_list.size(); ++i_node) {
const NodeId node_id = node_list[i_node];
for (unsigned short j = 0; j < MeshType::Dimension; ++j) {
pts[MeshType::Dimension * i_node + j] = positions[node_id][j];
}
/* std::cout << "\033[01;31m" << pts[2 * r] << "; " << pts[2 * r + 1] << "\033[00;00m" << std::endl; */
}
shape.resize(3);
shape[0] = node_list.size();
shape[1] = i_mesh->dimension();
shape[2] = 0;
break;
}
case 2: {
......@@ -276,6 +367,66 @@ Serializer::apply(const std::shared_ptr<const IBoundaryDescriptor>& boundary,
/* parallel::Messenger::getInstance().myCoupling->recvData(recv, src, tag + 1); */
}
void
Serializer::apply(std::shared_ptr<const IMesh> i_mesh,
const std::vector<std::shared_ptr<const IInterfaceDescriptor>>& i_interface_list,
const int tag)
{
auto costo = parallel::Messenger::getInstance().myCoupling;
const int dest = costo->myGlobalSize() - 1;
std::vector<int> shape;
std::vector<double> data;
switch (i_mesh->dimension()) {
case 1: {
throw NotImplementedError("1D not implemented");
break;
}
case 2: {
using MeshType = Mesh<Connectivity<2>>;
const std::shared_ptr p_mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
for (const auto& i_interface : i_interface_list) {
auto node_interface = getMeshNodeInterface(*p_mesh, *i_interface);
auto node_list = node_interface.nodeList();
data.resize(node_list.size() * MeshType::Dimension);
const auto xr = p_mesh->xr();
Array<TinyVector<2>> positions(p_mesh->numberOfNodes());
parallel_for(
p_mesh->numberOfNodes(), PUGS_LAMBDA(NodeId r) {
for (unsigned short i = 0; i < MeshType::Dimension; ++i) {
positions[r][i] = xr[r][i];
}
/* for (unsigned short i = MeshType::Dimension; i < 3; ++i) { */
/* positions[r][i] = 0; */
/* } */
});
for (size_t i_node = 0; i_node < node_list.size(); ++i_node) {
const NodeId node_id = node_list[i_node];
for (unsigned short i_dim = 0; i_dim < MeshType::Dimension; ++i_dim) {
data[i_node * MeshType::Dimension + i_dim] = positions[node_id][i_dim];
}
}
shape.resize(3);
shape[0] = node_list.size();
shape[1] = 2;
shape[2] = 0;
costo->sendData(shape, data, dest, tag);
}
break;
}
case 3: {
throw NotImplementedError("3D not implemented");
break;
}
}
}
// Field at node
void
Serializer::apply(std::shared_ptr<const IMesh> i_mesh,
......@@ -334,9 +485,7 @@ Serializer::apply(std::shared_ptr<const IMesh> i_mesh,
// Field (faces)
void
Serializer::apply(const std::shared_ptr<const IBoundaryDescriptor>& boundary,
const std::shared_ptr<const DiscreteFunctionVariant>& field,
const int tag)
Serializer::apply(const std::shared_ptr<const DiscreteFunctionVariant>& field, const int tag)
{
const std::shared_ptr i_mesh = getCommonMesh({field});
if (not i_mesh) {
......@@ -466,5 +615,10 @@ Serializer::change_mesh_position(std::shared_ptr<const IMesh> i_mesh, const int
return std::make_shared<MeshType>(given_mesh->shared_connectivity(), new_xr);
}
default: {
throw NormalError("Must not pass here");
}
}
}
#endif // PUGS_HAS_COSTO
src/utils/Serializer.hpp
+ 7
− 3
View file @ 6e7378c1
......@@ -11,6 +11,7 @@
#include <mesh/MeshDataManager.hpp>
#include <mesh/MeshFaceBoundary.hpp>
#include <mesh/MeshFlatFaceBoundary.hpp>
#include <mesh/MeshNodeInterface.hpp>
#include <scheme/DirichletBoundaryConditionDescriptor.hpp>
#include <scheme/DiscreteFunctionUtils.hpp>
#include <scheme/NeumannBoundaryConditionDescriptor.hpp>
......@@ -37,10 +38,11 @@ class Serializer
};
Serializer();
~Serializer();
void apply(std::shared_ptr<const IMesh> i_mesh, const int tag);
void apply(std::shared_ptr<const IMesh> i_mesh, const int dest, const int tag);
void apply(const std::shared_ptr<const IBoundaryDescriptor>& boundary,
std::shared_ptr<const IMesh> i_mesh,
const int location,
const int dest,
const int tag);
void apply(std::shared_ptr<const IMesh> i_mesh,
......@@ -48,10 +50,12 @@ class Serializer
const std::shared_ptr<const ItemValueVariant>& field,
const int tag);
void apply(const std::shared_ptr<const IBoundaryDescriptor>& boundary,
const std::shared_ptr<const DiscreteFunctionVariant>& field,
void apply(std::shared_ptr<const IMesh> i_mesh,
const std::vector<std::shared_ptr<const IInterfaceDescriptor>>& i_interface_list,
const int tag);
void apply(const std::shared_ptr<const DiscreteFunctionVariant>& field, const int tag);
std::shared_ptr<const IMesh> change_mesh_position(std::shared_ptr<const IMesh> i_mesh, const int tag);
};
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please to comment