diff --git a/src/scheme/RusanovEulerianCompositeSolver.cpp b/src/scheme/RusanovEulerianCompositeSolver.cpp
index 953ab6ec6d9f726fb561671553805c706c309c2c..8f189d32ff348063c69cac24ff89f56ea444bb25 100644
--- a/src/scheme/RusanovEulerianCompositeSolver.cpp
+++ b/src/scheme/RusanovEulerianCompositeSolver.cpp
@@ -35,9 +35,13 @@ class RusanovEulerianCompositeSolver
class InflowListBoundaryCondition;
class OutflowBoundaryCondition;
class NeumannBoundaryCondition;
+ class NeumannflatBoundaryCondition;
- using BoundaryCondition = std::
- variant<SymmetryBoundaryCondition, InflowListBoundaryCondition, OutflowBoundaryCondition, NeumannBoundaryCondition>;
+ using BoundaryCondition = std::variant<SymmetryBoundaryCondition,
+ InflowListBoundaryCondition,
+ OutflowBoundaryCondition,
+ NeumannflatBoundaryCondition,
+ NeumannBoundaryCondition>;
using BoundaryConditionList = std::vector<BoundaryCondition>;
@@ -51,6 +55,20 @@ class RusanovEulerianCompositeSolver
bool is_valid_boundary_condition = true;
switch (bc_descriptor->type()) {
+ case IBoundaryConditionDescriptor::Type::neumann: {
+ if constexpr (Dimension == 2) {
+ bc_list.emplace_back(
+ NeumannBoundaryCondition(getMeshFlatNodeBoundary(mesh, bc_descriptor->boundaryDescriptor()),
+ getMeshFlatFaceBoundary(mesh, bc_descriptor->boundaryDescriptor())));
+ } else {
+ static_assert(Dimension == 3);
+ bc_list.emplace_back(
+ NeumannBoundaryCondition(getMeshFlatNodeBoundary(mesh, bc_descriptor->boundaryDescriptor()),
+ getMeshFlatEdgeBoundary(mesh, bc_descriptor->boundaryDescriptor()),
+ getMeshFlatFaceBoundary(mesh, bc_descriptor->boundaryDescriptor())));
+ }
+ break;
+ }
case IBoundaryConditionDescriptor::Type::symmetry: {
if constexpr (Dimension == 2) {
bc_list.emplace_back(
@@ -122,8 +140,20 @@ class RusanovEulerianCompositeSolver
break;
}
case IBoundaryConditionDescriptor::Type::outflow: {
- std::cout << "outflow not implemented yet\n";
+ if constexpr (Dimension == 2) {
+ bc_list.emplace_back(
+ OutflowBoundaryCondition(getMeshNodeBoundary(mesh, bc_descriptor->boundaryDescriptor()),
+ getMeshFaceBoundary(mesh, bc_descriptor->boundaryDescriptor())));
+ } else {
+ static_assert(Dimension == 3);
+ bc_list.emplace_back(
+ OutflowBoundaryCondition(getMeshNodeBoundary(mesh, bc_descriptor->boundaryDescriptor()),
+ getMeshEdgeBoundary(mesh, bc_descriptor->boundaryDescriptor()),
+ getMeshFaceBoundary(mesh, bc_descriptor->boundaryDescriptor())));
+ }
break;
+ // std::cout << "outflow not implemented yet\n";
+ // break;
}
default: {
is_valid_boundary_condition = false;
@@ -140,6 +170,18 @@ class RusanovEulerianCompositeSolver
}
public:
+ void _applyNeumannBoundaryCondition(const BoundaryConditionList& bc_list,
+ const MeshType& mesh,
+ NodeValuePerCell<Rp>& stateNode,
+ EdgeValuePerCell<Rp>& stateEdge,
+ FaceValuePerCell<Rp>& stateFace) const;
+
+ void _applyNeumannflatBoundaryCondition(const BoundaryConditionList& bc_list,
+ const MeshType& mesh,
+ NodeValuePerCell<Rp>& stateNode,
+ EdgeValuePerCell<Rp>& stateEdge,
+ FaceValuePerCell<Rp>& stateFace) const;
+
void _applyInflowBoundaryCondition(const BoundaryConditionList& bc_list,
const MeshType& mesh,
NodeValuePerCell<Rp>& stateNode,
@@ -152,12 +194,6 @@ class RusanovEulerianCompositeSolver
EdgeValuePerCell<Rp>& stateEdge,
FaceValuePerCell<Rp>& stateFace) const;
- void _applyWallBoundaryCondition(const BoundaryConditionList& bc_list,
- const MeshType& mesh,
- NodeValuePerCell<Rp>& stateNode,
- EdgeValuePerCell<Rp>& stateEdge,
- FaceValuePerCell<Rp>& stateFace) const;
-
void _applySymmetricBoundaryCondition(const BoundaryConditionList& bc_list,
const MeshType& mesh,
NodeValuePerCell<Rp>& stateNode,
@@ -293,7 +329,7 @@ class RusanovEulerianCompositeSolver
Flux_rhoAtCellEdge[j][l][dim] = StateAtEdge[j][l][0] * StateAtEdge[j][l][dim];
}
});
-*/
+ */
NodeValuePerCell<Rdxd> Flux_qtmvtAtCellNode{p_mesh->connectivity()}; // = rhoUtensUPlusPid; // rhoUtensU + Pid;
EdgeValuePerCell<Rdxd> Flux_qtmvtAtCellEdge{p_mesh->connectivity()}; // = rhoUtensUPlusPid; // rhoUtensU + Pid;
FaceValuePerCell<Rdxd> Flux_qtmvtAtCellFace{p_mesh->connectivity()}; // = rhoUtensUPlusPid; // rhoUtensU + Pid;
@@ -321,7 +357,7 @@ class RusanovEulerianCompositeSolver
Flux_qtmvtAtCellEdge[j][l][dim] = StateAtEdge[j][l][0] * StateAtEdge[j][l][dim];
}
});
-*/
+ */
// parallel_for(
// p_mesh->numberOfCells(), PUGS_LAMBDA(CellId j) {
// Flux_qtmvtAtCellNode[j] = Flux_qtmvtAtCellEdge[j] = Flux_qtmvtAtCellFace[j] = Flux_qtmvt[j];
@@ -550,10 +586,9 @@ class RusanovEulerianCompositeSolver
for (size_t l = 0; l < cell_to_node.size(); ++l) {
const NodeId& node = cell_to_node[l];
+ const auto& node_to_cell = node_to_cell_matrix[node];
const auto& node_local_number_in_its_cells = node_local_numbers_in_their_cells.itemArray(node);
- const auto& node_to_cell = node_to_cell_matrix[node];
-
const Rd& Cjr_loc = Cjr(j, l);
Rp statediff(zero);
@@ -612,10 +647,9 @@ class RusanovEulerianCompositeSolver
for (size_t l = 0; l < cell_to_face.size(); ++l) {
const FaceId& face = cell_to_face[l];
+ const auto& face_to_cell = face_to_cell_matrix[face];
const auto& face_local_number_in_its_cells = face_local_numbers_in_their_cells.itemArray(face);
- const auto& face_to_cell = face_to_cell_matrix[face];
-
const Rd& Cjf_loc = Cjf(j, l);
Rp statediff(zero);
@@ -649,8 +683,8 @@ class RusanovEulerianCompositeSolver
FaceValue<double> MaxErrorConservationFace(p_mesh->connectivity());
MaxErrorConservationFace.fill(0.);
// const auto& mesh_data = MeshDataManager::instance().getMeshData(*p_mesh);
- auto xl = mesh_data.xl();
- auto Nl = mesh_data.Nl();
+ // auto xl = mesh_data.xl();
+ // auto Nl = mesh_data.Nl();
parallel_for(
p_mesh->numberOfFaces(), PUGS_LAMBDA(FaceId l) {
@@ -677,8 +711,8 @@ class RusanovEulerianCompositeSolver
}
});
std::cout << " Max Error Face " << max(MaxErrorConservationFace) << "\n";
- if (max(MaxErrorConservationFace) > 1e-3)
- throw UnexpectedError("Pb conservation Face");
+ // if (max(MaxErrorConservationFace) > 1e-3)
+ // throw UnexpectedError("Pb conservation Face");
}
if constexpr (Dimension == 3) {
@@ -737,10 +771,9 @@ class RusanovEulerianCompositeSolver
for (size_t l = 0; l < cell_to_edge.size(); ++l) {
const EdgeId& edge = cell_to_edge[l];
+ const auto& edge_to_cell = edge_to_cell_matrix[edge];
const auto& edge_local_number_in_its_cells = edge_local_numbers_in_their_cells.itemArray(edge);
- const auto& edge_to_cell = edge_to_cell_matrix[edge];
-
const Rd& Cje_loc = Cje(j, l);
Rp statediff(zero);
@@ -955,6 +988,127 @@ class RusanovEulerianCompositeSolver<Mesh<3>>::NeumannBoundaryCondition
;
}
};
+template <MeshConcept MeshType>
+class RusanovEulerianCompositeSolver<MeshType>::NeumannflatBoundaryCondition
+{
+};
+template <>
+class RusanovEulerianCompositeSolver<Mesh<2>>::NeumannflatBoundaryCondition
+{
+ public:
+ using Rd = TinyVector<Dimension, double>;
+
+ private:
+ const MeshFlatNodeBoundary<MeshType> m_mesh_flat_node_boundary;
+ const MeshFlatFaceBoundary<MeshType> m_mesh_flat_face_boundary;
+
+ public:
+ const Rd&
+ outgoingNormal() const
+ {
+ return m_mesh_flat_node_boundary.outgoingNormal();
+ }
+
+ size_t
+ numberOfNodes() const
+ {
+ return m_mesh_flat_node_boundary.nodeList().size();
+ }
+
+ size_t
+ numberOfFaces() const
+ {
+ return m_mesh_flat_face_boundary.faceList().size();
+ }
+
+ const Array<const NodeId>&
+ nodeList() const
+ {
+ return m_mesh_flat_node_boundary.nodeList();
+ }
+
+ const Array<const FaceId>&
+ faceList() const
+ {
+ return m_mesh_flat_face_boundary.faceList();
+ }
+
+ NeumannflatBoundaryCondition(const MeshFlatNodeBoundary<MeshType>& mesh_flat_node_boundary,
+ const MeshFlatFaceBoundary<MeshType>& mesh_flat_face_boundary)
+ : m_mesh_flat_node_boundary(mesh_flat_node_boundary), m_mesh_flat_face_boundary(mesh_flat_face_boundary)
+ {
+ ;
+ }
+
+ ~NeumannflatBoundaryCondition() = default;
+};
+
+template <>
+class RusanovEulerianCompositeSolver<Mesh<3>>::NeumannflatBoundaryCondition
+{
+ public:
+ using Rd = TinyVector<Dimension, double>;
+
+ private:
+ const MeshFlatNodeBoundary<MeshType> m_mesh_flat_node_boundary;
+ const MeshFlatEdgeBoundary<MeshType> m_mesh_flat_edge_boundary;
+ const MeshFlatFaceBoundary<MeshType> m_mesh_flat_face_boundary;
+
+ public:
+ const Rd&
+ outgoingNormal() const
+ {
+ return m_mesh_flat_node_boundary.outgoingNormal();
+ }
+
+ size_t
+ numberOfNodes() const
+ {
+ return m_mesh_flat_node_boundary.nodeList().size();
+ }
+
+ size_t
+ numberOfEdges() const
+ {
+ return m_mesh_flat_edge_boundary.edgeList().size();
+ }
+
+ size_t
+ numberOfFaces() const
+ {
+ return m_mesh_flat_face_boundary.faceList().size();
+ }
+
+ const Array<const NodeId>&
+ nodeList() const
+ {
+ return m_mesh_flat_node_boundary.nodeList();
+ }
+
+ const Array<const EdgeId>&
+ edgeList() const
+ {
+ return m_mesh_flat_edge_boundary.edgeList();
+ }
+
+ const Array<const FaceId>&
+ faceList() const
+ {
+ return m_mesh_flat_face_boundary.faceList();
+ }
+
+ NeumannflatBoundaryCondition(const MeshFlatNodeBoundary<MeshType>& mesh_flat_node_boundary,
+ const MeshFlatEdgeBoundary<MeshType>& mesh_flat_edge_boundary,
+ const MeshFlatFaceBoundary<MeshType>& mesh_flat_face_boundary)
+ : m_mesh_flat_node_boundary(mesh_flat_node_boundary),
+ m_mesh_flat_edge_boundary(mesh_flat_edge_boundary),
+ m_mesh_flat_face_boundary(mesh_flat_face_boundary)
+ {
+ ;
+ }
+
+ ~NeumannflatBoundaryCondition() = default;
+};
template <>
class RusanovEulerianCompositeSolver<Mesh<2>>::SymmetryBoundaryCondition
@@ -1236,6 +1390,106 @@ class RusanovEulerianCompositeSolver<MeshType>::OutflowBoundaryCondition
{
};
+template <>
+class RusanovEulerianCompositeSolver<Mesh<2>>::OutflowBoundaryCondition
+{
+ using Rd = TinyVector<Dimension, double>;
+
+ private:
+ const MeshNodeBoundary m_mesh_node_boundary;
+ const MeshFaceBoundary m_mesh_face_boundary;
+
+ public:
+ size_t
+ numberOfNodes() const
+ {
+ return m_mesh_node_boundary.nodeList().size();
+ }
+
+ size_t
+ numberOfFaces() const
+ {
+ return m_mesh_face_boundary.faceList().size();
+ }
+
+ const Array<const NodeId>&
+ nodeList() const
+ {
+ return m_mesh_node_boundary.nodeList();
+ }
+
+ const Array<const FaceId>&
+ faceList() const
+ {
+ return m_mesh_face_boundary.faceList();
+ }
+
+ OutflowBoundaryCondition(const MeshNodeBoundary& mesh_node_boundary, const MeshFaceBoundary& mesh_face_boundary)
+ : m_mesh_node_boundary(mesh_node_boundary), m_mesh_face_boundary(mesh_face_boundary)
+ {
+ ;
+ }
+};
+
+template <>
+class RusanovEulerianCompositeSolver<Mesh<3>>::OutflowBoundaryCondition
+{
+ using Rd = TinyVector<Dimension, double>;
+
+ private:
+ const MeshNodeBoundary m_mesh_node_boundary;
+ const MeshEdgeBoundary m_mesh_edge_boundary;
+ const MeshFaceBoundary m_mesh_face_boundary;
+
+ public:
+ size_t
+ numberOfNodes() const
+ {
+ return m_mesh_node_boundary.nodeList().size();
+ }
+ size_t
+ numberOfEdges() const
+ {
+ return m_mesh_edge_boundary.edgeList().size();
+ }
+
+ size_t
+ numberOfFaces() const
+ {
+ return m_mesh_face_boundary.faceList().size();
+ }
+
+ const Array<const NodeId>&
+ nodeList() const
+ {
+ return m_mesh_node_boundary.nodeList();
+ }
+
+ const Array<const EdgeId>&
+ edgeList() const
+ {
+ return m_mesh_edge_boundary.edgeList();
+ }
+
+ const Array<const FaceId>&
+ faceList() const
+ {
+ return m_mesh_face_boundary.faceList();
+ }
+
+ OutflowBoundaryCondition(const MeshNodeBoundary& mesh_node_boundary,
+ const MeshEdgeBoundary& mesh_edge_boundary,
+ const MeshFaceBoundary& mesh_face_boundary)
+ : m_mesh_node_boundary(mesh_node_boundary),
+
+ m_mesh_edge_boundary(mesh_edge_boundary),
+
+ m_mesh_face_boundary(mesh_face_boundary)
+ {
+ ;
+ }
+};
+
std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
std::shared_ptr<const DiscreteFunctionVariant>,
std::shared_ptr<const DiscreteFunctionVariant>>
@@ -1299,7 +1553,107 @@ RusanovEulerianCompositeSolver<MeshType>::_applyOutflowBoundaryCondition(const B
[&](auto&& bc) {
using T = std::decay_t<decltype(bc)>;
if constexpr (std::is_same_v<OutflowBoundaryCondition, T>) {
- throw NormalError("Not implemented");
+ std::cout << " Traitement Outflow \n";
+ // const Rd& normal = bc.outgoingNormal();
+ /*
+ const auto& node_to_cell_matrix = mesh.connectivity().nodeToCellMatrix();
+ const auto& face_to_cell_matrix = mesh.connectivity().faceToCellMatrix();
+
+ const auto& node_local_numbers_in_their_cells = mesh.connectivity().nodeLocalNumbersInTheirCells();
+ const auto& face_local_numbers_in_their_cells = mesh.connectivity().faceLocalNumbersInTheirCells();
+ // const auto& face_cell_is_reversed = mesh.connectivity().cellFaceIsReversed();
+
+ const auto& face_list = bc.faceList();
+ const auto& node_list = bc.nodeList();
+
+ const auto xj = mesh.xj();
+ const auto xr = mesh.xr();
+ const auto xf = mesh.xl();
+ const auto xe = mesh.xe();
+
+ for (size_t i_node = 0; i_node < node_list.size(); ++i_node) {
+ const NodeId node_id = node_list[i_node];
+
+ const auto& node_cell_list = node_to_cell_matrix[node_id];
+ // Assert(face_cell_list.size() == 1);
+ const auto& node_local_number_in_its_cells = node_local_numbers_in_their_cells.itemArray(node_id);
+
+ for (size_t i_cell = 0; i_cell < node_cell_list.size(); ++i_cell) {
+ CellId node_cell_id = node_cell_list[i_cell];
+ size_t node_local_number_in_cell = node_local_number_in_its_cells[i_cell];
+
+ for (size_t dim = 0; dim < Dimension + 2; ++dim)
+ stateNode[node_cell_id][node_local_number_in_cell][dim] += vectorSym[dim];
+
+ Rd vectorSym(zero);
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ vectorSym[dim] = stateNode[node_cell_id][node_local_number_in_cell][1 + dim];
+
+ Rdxd MatriceProj(identity);
+ MatriceProj -= tensorProduct(normal, normal);
+ vectorSym = MatriceProj * vectorSym;
+
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ stateNode[node_cell_id][node_local_number_in_cell][dim + 1] = vectorSym[dim];
+ // stateNode[node_cell_id][node_local_number_in_cell][dim] = 0; // node_array_list[i_node][dim];
+ }
+ }
+
+ for (size_t i_face = 0; i_face < face_list.size(); ++i_face) {
+ const FaceId face_id = face_list[i_face];
+
+ const auto& face_cell_list = face_to_cell_matrix[face_id];
+ Assert(face_cell_list.size() == 1);
+
+ CellId face_cell_id = face_cell_list[0];
+ size_t face_local_number_in_cell = face_local_numbers_in_their_cells(face_id, 0);
+
+ Rd vectorSym(zero);
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ vectorSym[dim] = stateEdge[face_cell_id][face_local_number_in_cell][1 + dim];
+
+ Rdxd MatriceProj(identity);
+ MatriceProj -= tensorProduct(normal, normal);
+ vectorSym = MatriceProj * vectorSym;
+
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ stateFace[face_cell_id][face_local_number_in_cell][dim + 1] = vectorSym[dim];
+ }
+
+ if constexpr (Dimension == 3) {
+ const auto& edge_to_cell_matrix = mesh.connectivity().edgeToCellMatrix();
+
+ const auto& edge_local_numbers_in_their_cells = mesh.connectivity().edgeLocalNumbersInTheirCells();
+
+ const auto& edge_list = bc.edgeList();
+
+ for (size_t i_edge = 0; i_edge < edge_list.size(); ++i_edge) {
+ const EdgeId edge_id = edge_list[i_edge];
+
+ const auto& edge_cell_list = edge_to_cell_matrix[edge_id];
+ // Assert(face_cell_list.size() == 1);
+ const auto& edge_local_number_in_its_cells = edge_local_numbers_in_their_cells.itemArray(edge_id);
+
+ for (size_t i_cell = 0; i_cell < edge_cell_list.size(); ++i_cell) {
+ CellId edge_cell_id = edge_cell_list[i_cell];
+ size_t edge_local_number_in_cell = edge_local_number_in_its_cells[i_cell];
+
+ Rd vectorSym(zero);
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ vectorSym[dim] = stateEdge[edge_cell_id][edge_local_number_in_cell][1 + dim];
+
+ Rdxd MatriceProj(identity);
+ MatriceProj -= tensorProduct(normal, normal);
+ vectorSym = MatriceProj * vectorSym;
+
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ stateEdge[edge_cell_id][edge_local_number_in_cell][dim + 1] = vectorSym[dim];
+ }
+ }
+
+ // throw NormalError("Not implemented");
+ }
+ */// throw NormalError("Not implemented");
}
},
boundary_condition);
@@ -1416,6 +1770,110 @@ RusanovEulerianCompositeSolver<MeshType>::_applySymmetricBoundaryCondition(const
}
}
+template <MeshConcept MeshType>
+void
+RusanovEulerianCompositeSolver<MeshType>::_applyNeumannflatBoundaryCondition(const BoundaryConditionList& bc_list,
+ const MeshType& mesh,
+ NodeValuePerCell<Rp>& stateNode,
+ EdgeValuePerCell<Rp>& stateEdge,
+ FaceValuePerCell<Rp>& stateFace) const
+{
+ for (const auto& boundary_condition : bc_list) {
+ std::visit(
+ [&](auto&& bc) {
+ using T = std::decay_t<decltype(bc)>;
+ if constexpr (std::is_same_v<NeumannflatBoundaryCondition, T>) {
+ // MeshData<MeshType>& mesh_data = MeshDataManager::instance().getMeshData(mesh);
+ std::cout << " Traitement WALL \n";
+ const Rd& normal = bc.outgoingNormal();
+
+ const auto& node_to_cell_matrix = mesh.connectivity().nodeToCellMatrix();
+ const auto& face_to_cell_matrix = mesh.connectivity().faceToCellMatrix();
+
+ const auto& node_local_numbers_in_their_cells = mesh.connectivity().nodeLocalNumbersInTheirCells();
+ const auto& face_local_numbers_in_their_cells = mesh.connectivity().faceLocalNumbersInTheirCells();
+ // const auto& face_cell_is_reversed = mesh.connectivity().cellFaceIsReversed();
+
+ const auto& face_list = bc.faceList();
+ const auto& node_list = bc.nodeList();
+
+ for (size_t i_node = 0; i_node < node_list.size(); ++i_node) {
+ const NodeId node_id = node_list[i_node];
+
+ const auto& node_cell_list = node_to_cell_matrix[node_id];
+ // Assert(face_cell_list.size() == 1);
+ const auto& node_local_number_in_its_cells = node_local_numbers_in_their_cells.itemArray(node_id);
+
+ for (size_t i_cell = 0; i_cell < node_cell_list.size(); ++i_cell) {
+ CellId node_cell_id = node_cell_list[i_cell];
+ size_t node_local_number_in_cell = node_local_number_in_its_cells[i_cell];
+
+ Rd vectorSym(zero);
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ vectorSym[dim] = stateNode[node_cell_id][node_local_number_in_cell][1 + dim];
+
+ vectorSym -= dot(vectorSym, normal) * normal;
+
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ stateNode[node_cell_id][node_local_number_in_cell][dim + 1] = vectorSym[dim];
+ // stateNode[node_cell_id][node_local_number_in_cell][dim] = 0; // node_array_list[i_node][dim];
+ }
+ }
+
+ for (size_t i_face = 0; i_face < face_list.size(); ++i_face) {
+ const FaceId face_id = face_list[i_face];
+
+ const auto& face_cell_list = face_to_cell_matrix[face_id];
+ Assert(face_cell_list.size() == 1);
+
+ CellId face_cell_id = face_cell_list[0];
+ size_t face_local_number_in_cell = face_local_numbers_in_their_cells(face_id, 0);
+
+ Rd vectorSym(zero);
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ vectorSym[dim] = stateEdge[face_cell_id][face_local_number_in_cell][1 + dim];
+
+ vectorSym -= dot(vectorSym, normal) * normal;
+
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ stateFace[face_cell_id][face_local_number_in_cell][dim + 1] = vectorSym[dim];
+ }
+
+ if constexpr (Dimension == 3) {
+ const auto& edge_to_cell_matrix = mesh.connectivity().edgeToCellMatrix();
+
+ const auto& edge_local_numbers_in_their_cells = mesh.connectivity().edgeLocalNumbersInTheirCells();
+
+ const auto& edge_list = bc.edgeList();
+
+ for (size_t i_edge = 0; i_edge < edge_list.size(); ++i_edge) {
+ const EdgeId edge_id = edge_list[i_edge];
+
+ const auto& edge_cell_list = edge_to_cell_matrix[edge_id];
+ // Assert(face_cell_list.size() == 1);
+ const auto& edge_local_number_in_its_cells = edge_local_numbers_in_their_cells.itemArray(edge_id);
+
+ for (size_t i_cell = 0; i_cell < edge_cell_list.size(); ++i_cell) {
+ CellId edge_cell_id = edge_cell_list[i_cell];
+ size_t edge_local_number_in_cell = edge_local_number_in_its_cells[i_cell];
+
+ Rd vectorSym(zero);
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ vectorSym[dim] = stateEdge[edge_cell_id][edge_local_number_in_cell][1 + dim];
+
+ vectorSym -= dot(vectorSym, normal) * normal;
+
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ stateEdge[edge_cell_id][edge_local_number_in_cell][dim + 1] = vectorSym[dim];
+ }
+ }
+ }
+ }
+ },
+ boundary_condition);
+ }
+}
+
template <MeshConcept MeshType>
void
RusanovEulerianCompositeSolver<MeshType>::_applyInflowBoundaryCondition(const BoundaryConditionList& bc_list,
diff --git a/src/scheme/RusanovEulerianCompositeSolver_v2.cpp b/src/scheme/RusanovEulerianCompositeSolver_v2.cpp
index 3bfe9a8770bd2c319fe8f3a6c09152bbcc3dc006..cd3d407cb8840d594a8341ca196759a40e57b9bb 100644
--- a/src/scheme/RusanovEulerianCompositeSolver_v2.cpp
+++ b/src/scheme/RusanovEulerianCompositeSolver_v2.cpp
@@ -35,9 +35,13 @@ class RusanovEulerianCompositeSolver_v2
class InflowListBoundaryCondition;
class OutflowBoundaryCondition;
class NeumannBoundaryCondition;
+ class NeumannflatBoundaryCondition;
- using BoundaryCondition = std::
- variant<SymmetryBoundaryCondition, InflowListBoundaryCondition, OutflowBoundaryCondition, NeumannBoundaryCondition>;
+ using BoundaryCondition = std::variant<SymmetryBoundaryCondition,
+ InflowListBoundaryCondition,
+ OutflowBoundaryCondition,
+ NeumannflatBoundaryCondition,
+ NeumannBoundaryCondition>;
using BoundaryConditionList = std::vector<BoundaryCondition>;
@@ -51,6 +55,20 @@ class RusanovEulerianCompositeSolver_v2
bool is_valid_boundary_condition = true;
switch (bc_descriptor->type()) {
+ case IBoundaryConditionDescriptor::Type::neumann: {
+ if constexpr (Dimension == 2) {
+ bc_list.emplace_back(
+ NeumannBoundaryCondition(getMeshFlatNodeBoundary(mesh, bc_descriptor->boundaryDescriptor()),
+ getMeshFlatFaceBoundary(mesh, bc_descriptor->boundaryDescriptor())));
+ } else {
+ static_assert(Dimension == 3);
+ bc_list.emplace_back(
+ NeumannBoundaryCondition(getMeshFlatNodeBoundary(mesh, bc_descriptor->boundaryDescriptor()),
+ getMeshFlatEdgeBoundary(mesh, bc_descriptor->boundaryDescriptor()),
+ getMeshFlatFaceBoundary(mesh, bc_descriptor->boundaryDescriptor())));
+ }
+ break;
+ }
case IBoundaryConditionDescriptor::Type::symmetry: {
if constexpr (Dimension == 2) {
bc_list.emplace_back(
@@ -122,8 +140,20 @@ class RusanovEulerianCompositeSolver_v2
break;
}
case IBoundaryConditionDescriptor::Type::outflow: {
- std::cout << "outflow not implemented yet\n";
+ if constexpr (Dimension == 2) {
+ bc_list.emplace_back(
+ OutflowBoundaryCondition(getMeshNodeBoundary(mesh, bc_descriptor->boundaryDescriptor()),
+ getMeshFaceBoundary(mesh, bc_descriptor->boundaryDescriptor())));
+ } else {
+ static_assert(Dimension == 3);
+ bc_list.emplace_back(
+ OutflowBoundaryCondition(getMeshNodeBoundary(mesh, bc_descriptor->boundaryDescriptor()),
+ getMeshEdgeBoundary(mesh, bc_descriptor->boundaryDescriptor()),
+ getMeshFaceBoundary(mesh, bc_descriptor->boundaryDescriptor())));
+ }
break;
+ // std::cout << "outflow not implemented yet\n";
+ // break;
}
default: {
is_valid_boundary_condition = false;
@@ -140,6 +170,18 @@ class RusanovEulerianCompositeSolver_v2
}
public:
+ void _applyNeumannBoundaryCondition(const BoundaryConditionList& bc_list,
+ const MeshType& mesh,
+ NodeValuePerCell<Rp>& stateNode,
+ EdgeValuePerCell<Rp>& stateEdge,
+ FaceValuePerCell<Rp>& stateFace) const;
+
+ void _applyNeumannflatBoundaryCondition(const BoundaryConditionList& bc_list,
+ const MeshType& mesh,
+ NodeValuePerCell<Rp>& stateNode,
+ EdgeValuePerCell<Rp>& stateEdge,
+ FaceValuePerCell<Rp>& stateFace) const;
+
void _applyInflowBoundaryCondition(const BoundaryConditionList& bc_list,
const MeshType& mesh,
NodeValuePerCell<Rp>& stateNode,
@@ -237,6 +279,7 @@ class RusanovEulerianCompositeSolver_v2
_applyInflowBoundaryCondition(bc_list, *p_mesh, StateAtNode, StateAtEdge, StateAtFace);
//_applyOutflowBoundaryCondition(bc_list, *p_mesh, StateAtNode, StateAtEdge, StateAtFace);
_applySymmetricBoundaryCondition(bc_list, *p_mesh, StateAtNode, StateAtEdge, StateAtFace);
+ _applyNeumannflatBoundaryCondition(bc_list, *p_mesh, StateAtNode, StateAtEdge, StateAtFace);
//
// Construction du flux .. ok pour l'ordre 1
@@ -752,6 +795,8 @@ class RusanovEulerianCompositeSolver_v2<Mesh<2>>::NeumannBoundaryCondition
private:
const MeshNodeBoundary m_mesh_node_boundary;
const MeshFaceBoundary m_mesh_face_boundary;
+ // const MeshFlatNodeBoundary<MeshType> m_mesh_flat_node_boundary;
+ // const MeshFlatFaceBoundary<MeshType> m_mesh_flat_face_boundary;
public:
size_t
@@ -844,6 +889,128 @@ class RusanovEulerianCompositeSolver_v2<Mesh<3>>::NeumannBoundaryCondition
}
};
+template <MeshConcept MeshType>
+class RusanovEulerianCompositeSolver_v2<MeshType>::NeumannflatBoundaryCondition
+{
+};
+template <>
+class RusanovEulerianCompositeSolver_v2<Mesh<2>>::NeumannflatBoundaryCondition
+{
+ public:
+ using Rd = TinyVector<Dimension, double>;
+
+ private:
+ const MeshFlatNodeBoundary<MeshType> m_mesh_flat_node_boundary;
+ const MeshFlatFaceBoundary<MeshType> m_mesh_flat_face_boundary;
+
+ public:
+ const Rd&
+ outgoingNormal() const
+ {
+ return m_mesh_flat_node_boundary.outgoingNormal();
+ }
+
+ size_t
+ numberOfNodes() const
+ {
+ return m_mesh_flat_node_boundary.nodeList().size();
+ }
+
+ size_t
+ numberOfFaces() const
+ {
+ return m_mesh_flat_face_boundary.faceList().size();
+ }
+
+ const Array<const NodeId>&
+ nodeList() const
+ {
+ return m_mesh_flat_node_boundary.nodeList();
+ }
+
+ const Array<const FaceId>&
+ faceList() const
+ {
+ return m_mesh_flat_face_boundary.faceList();
+ }
+
+ NeumannflatBoundaryCondition(const MeshFlatNodeBoundary<MeshType>& mesh_flat_node_boundary,
+ const MeshFlatFaceBoundary<MeshType>& mesh_flat_face_boundary)
+ : m_mesh_flat_node_boundary(mesh_flat_node_boundary), m_mesh_flat_face_boundary(mesh_flat_face_boundary)
+ {
+ ;
+ }
+
+ ~NeumannflatBoundaryCondition() = default;
+};
+
+template <>
+class RusanovEulerianCompositeSolver_v2<Mesh<3>>::NeumannflatBoundaryCondition
+{
+ public:
+ using Rd = TinyVector<Dimension, double>;
+
+ private:
+ const MeshFlatNodeBoundary<MeshType> m_mesh_flat_node_boundary;
+ const MeshFlatEdgeBoundary<MeshType> m_mesh_flat_edge_boundary;
+ const MeshFlatFaceBoundary<MeshType> m_mesh_flat_face_boundary;
+
+ public:
+ const Rd&
+ outgoingNormal() const
+ {
+ return m_mesh_flat_node_boundary.outgoingNormal();
+ }
+
+ size_t
+ numberOfNodes() const
+ {
+ return m_mesh_flat_node_boundary.nodeList().size();
+ }
+
+ size_t
+ numberOfEdges() const
+ {
+ return m_mesh_flat_edge_boundary.edgeList().size();
+ }
+
+ size_t
+ numberOfFaces() const
+ {
+ return m_mesh_flat_face_boundary.faceList().size();
+ }
+
+ const Array<const NodeId>&
+ nodeList() const
+ {
+ return m_mesh_flat_node_boundary.nodeList();
+ }
+
+ const Array<const EdgeId>&
+ edgeList() const
+ {
+ return m_mesh_flat_edge_boundary.edgeList();
+ }
+
+ const Array<const FaceId>&
+ faceList() const
+ {
+ return m_mesh_flat_face_boundary.faceList();
+ }
+
+ NeumannflatBoundaryCondition(const MeshFlatNodeBoundary<MeshType>& mesh_flat_node_boundary,
+ const MeshFlatEdgeBoundary<MeshType>& mesh_flat_edge_boundary,
+ const MeshFlatFaceBoundary<MeshType>& mesh_flat_face_boundary)
+ : m_mesh_flat_node_boundary(mesh_flat_node_boundary),
+ m_mesh_flat_edge_boundary(mesh_flat_edge_boundary),
+ m_mesh_flat_face_boundary(mesh_flat_face_boundary)
+ {
+ ;
+ }
+
+ ~NeumannflatBoundaryCondition() = default;
+};
+
template <MeshConcept MeshType>
class RusanovEulerianCompositeSolver_v2<MeshType>::SymmetryBoundaryCondition
{
@@ -1129,6 +1296,106 @@ class RusanovEulerianCompositeSolver_v2<MeshType>::OutflowBoundaryCondition
{
};
+template <>
+class RusanovEulerianCompositeSolver_v2<Mesh<2>>::OutflowBoundaryCondition
+{
+ using Rd = TinyVector<Dimension, double>;
+
+ private:
+ const MeshNodeBoundary m_mesh_node_boundary;
+ const MeshFaceBoundary m_mesh_face_boundary;
+
+ public:
+ size_t
+ numberOfNodes() const
+ {
+ return m_mesh_node_boundary.nodeList().size();
+ }
+
+ size_t
+ numberOfFaces() const
+ {
+ return m_mesh_face_boundary.faceList().size();
+ }
+
+ const Array<const NodeId>&
+ nodeList() const
+ {
+ return m_mesh_node_boundary.nodeList();
+ }
+
+ const Array<const FaceId>&
+ faceList() const
+ {
+ return m_mesh_face_boundary.faceList();
+ }
+
+ OutflowBoundaryCondition(const MeshNodeBoundary& mesh_node_boundary, const MeshFaceBoundary& mesh_face_boundary)
+ : m_mesh_node_boundary(mesh_node_boundary), m_mesh_face_boundary(mesh_face_boundary)
+ {
+ ;
+ }
+};
+
+template <>
+class RusanovEulerianCompositeSolver_v2<Mesh<3>>::OutflowBoundaryCondition
+{
+ using Rd = TinyVector<Dimension, double>;
+
+ private:
+ const MeshNodeBoundary m_mesh_node_boundary;
+ const MeshEdgeBoundary m_mesh_edge_boundary;
+ const MeshFaceBoundary m_mesh_face_boundary;
+
+ public:
+ size_t
+ numberOfNodes() const
+ {
+ return m_mesh_node_boundary.nodeList().size();
+ }
+ size_t
+ numberOfEdges() const
+ {
+ return m_mesh_edge_boundary.edgeList().size();
+ }
+
+ size_t
+ numberOfFaces() const
+ {
+ return m_mesh_face_boundary.faceList().size();
+ }
+
+ const Array<const NodeId>&
+ nodeList() const
+ {
+ return m_mesh_node_boundary.nodeList();
+ }
+
+ const Array<const EdgeId>&
+ edgeList() const
+ {
+ return m_mesh_edge_boundary.edgeList();
+ }
+
+ const Array<const FaceId>&
+ faceList() const
+ {
+ return m_mesh_face_boundary.faceList();
+ }
+
+ OutflowBoundaryCondition(const MeshNodeBoundary& mesh_node_boundary,
+ const MeshEdgeBoundary& mesh_edge_boundary,
+ const MeshFaceBoundary& mesh_face_boundary)
+ : m_mesh_node_boundary(mesh_node_boundary),
+
+ m_mesh_edge_boundary(mesh_edge_boundary),
+
+ m_mesh_face_boundary(mesh_face_boundary)
+ {
+ ;
+ }
+};
+
std::tuple<std::shared_ptr<const DiscreteFunctionVariant>,
std::shared_ptr<const DiscreteFunctionVariant>,
std::shared_ptr<const DiscreteFunctionVariant>>
@@ -1189,7 +1456,107 @@ RusanovEulerianCompositeSolver_v2<MeshType>::_applyOutflowBoundaryCondition(cons
[&](auto&& bc) {
using T = std::decay_t<decltype(bc)>;
if constexpr (std::is_same_v<OutflowBoundaryCondition, T>) {
- throw NormalError("Not implemented");
+ std::cout << " Traitement Outflow \n";
+ // const Rd& normal = bc.outgoingNormal();
+ /*
+ const auto& node_to_cell_matrix = mesh.connectivity().nodeToCellMatrix();
+ const auto& face_to_cell_matrix = mesh.connectivity().faceToCellMatrix();
+
+ const auto& node_local_numbers_in_their_cells = mesh.connectivity().nodeLocalNumbersInTheirCells();
+ const auto& face_local_numbers_in_their_cells = mesh.connectivity().faceLocalNumbersInTheirCells();
+ // const auto& face_cell_is_reversed = mesh.connectivity().cellFaceIsReversed();
+
+ const auto& face_list = bc.faceList();
+ const auto& node_list = bc.nodeList();
+
+ const auto xj = mesh.xj();
+ const auto xr = mesh.xr();
+ const auto xf = mesh.xl();
+ const auto xe = mesh.xe();
+
+ for (size_t i_node = 0; i_node < node_list.size(); ++i_node) {
+ const NodeId node_id = node_list[i_node];
+
+ const auto& node_cell_list = node_to_cell_matrix[node_id];
+ // Assert(face_cell_list.size() == 1);
+ const auto& node_local_number_in_its_cells = node_local_numbers_in_their_cells.itemArray(node_id);
+
+ for (size_t i_cell = 0; i_cell < node_cell_list.size(); ++i_cell) {
+ CellId node_cell_id = node_cell_list[i_cell];
+ size_t node_local_number_in_cell = node_local_number_in_its_cells[i_cell];
+
+ for (size_t dim = 0; dim < Dimension + 2; ++dim)
+ stateNode[node_cell_id][node_local_number_in_cell][dim] += vectorSym[dim];
+
+ Rd vectorSym(zero);
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ vectorSym[dim] = stateNode[node_cell_id][node_local_number_in_cell][1 + dim];
+
+ Rdxd MatriceProj(identity);
+ MatriceProj -= tensorProduct(normal, normal);
+ vectorSym = MatriceProj * vectorSym;
+
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ stateNode[node_cell_id][node_local_number_in_cell][dim + 1] = vectorSym[dim];
+ // stateNode[node_cell_id][node_local_number_in_cell][dim] = 0; // node_array_list[i_node][dim];
+ }
+ }
+
+ for (size_t i_face = 0; i_face < face_list.size(); ++i_face) {
+ const FaceId face_id = face_list[i_face];
+
+ const auto& face_cell_list = face_to_cell_matrix[face_id];
+ Assert(face_cell_list.size() == 1);
+
+ CellId face_cell_id = face_cell_list[0];
+ size_t face_local_number_in_cell = face_local_numbers_in_their_cells(face_id, 0);
+
+ Rd vectorSym(zero);
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ vectorSym[dim] = stateEdge[face_cell_id][face_local_number_in_cell][1 + dim];
+
+ Rdxd MatriceProj(identity);
+ MatriceProj -= tensorProduct(normal, normal);
+ vectorSym = MatriceProj * vectorSym;
+
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ stateFace[face_cell_id][face_local_number_in_cell][dim + 1] = vectorSym[dim];
+ }
+
+ if constexpr (Dimension == 3) {
+ const auto& edge_to_cell_matrix = mesh.connectivity().edgeToCellMatrix();
+
+ const auto& edge_local_numbers_in_their_cells = mesh.connectivity().edgeLocalNumbersInTheirCells();
+
+ const auto& edge_list = bc.edgeList();
+
+ for (size_t i_edge = 0; i_edge < edge_list.size(); ++i_edge) {
+ const EdgeId edge_id = edge_list[i_edge];
+
+ const auto& edge_cell_list = edge_to_cell_matrix[edge_id];
+ // Assert(face_cell_list.size() == 1);
+ const auto& edge_local_number_in_its_cells = edge_local_numbers_in_their_cells.itemArray(edge_id);
+
+ for (size_t i_cell = 0; i_cell < edge_cell_list.size(); ++i_cell) {
+ CellId edge_cell_id = edge_cell_list[i_cell];
+ size_t edge_local_number_in_cell = edge_local_number_in_its_cells[i_cell];
+
+ Rd vectorSym(zero);
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ vectorSym[dim] = stateEdge[edge_cell_id][edge_local_number_in_cell][1 + dim];
+
+ Rdxd MatriceProj(identity);
+ MatriceProj -= tensorProduct(normal, normal);
+ vectorSym = MatriceProj * vectorSym;
+
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ stateEdge[edge_cell_id][edge_local_number_in_cell][dim + 1] = vectorSym[dim];
+ }
+ }
+
+ // throw NormalError("Not implemented");
+ }
+ */
}
},
boundary_condition);
@@ -1306,6 +1673,110 @@ RusanovEulerianCompositeSolver_v2<MeshType>::_applySymmetricBoundaryCondition(co
}
}
+template <MeshConcept MeshType>
+void
+RusanovEulerianCompositeSolver_v2<MeshType>::_applyNeumannflatBoundaryCondition(const BoundaryConditionList& bc_list,
+ const MeshType& mesh,
+ NodeValuePerCell<Rp>& stateNode,
+ EdgeValuePerCell<Rp>& stateEdge,
+ FaceValuePerCell<Rp>& stateFace) const
+{
+ for (const auto& boundary_condition : bc_list) {
+ std::visit(
+ [&](auto&& bc) {
+ using T = std::decay_t<decltype(bc)>;
+ if constexpr (std::is_same_v<NeumannflatBoundaryCondition, T>) {
+ // MeshData<MeshType>& mesh_data = MeshDataManager::instance().getMeshData(mesh);
+ std::cout << " Traitement WALL \n";
+ const Rd& normal = bc.outgoingNormal();
+
+ const auto& node_to_cell_matrix = mesh.connectivity().nodeToCellMatrix();
+ const auto& face_to_cell_matrix = mesh.connectivity().faceToCellMatrix();
+
+ const auto& node_local_numbers_in_their_cells = mesh.connectivity().nodeLocalNumbersInTheirCells();
+ const auto& face_local_numbers_in_their_cells = mesh.connectivity().faceLocalNumbersInTheirCells();
+ // const auto& face_cell_is_reversed = mesh.connectivity().cellFaceIsReversed();
+
+ const auto& face_list = bc.faceList();
+ const auto& node_list = bc.nodeList();
+
+ for (size_t i_node = 0; i_node < node_list.size(); ++i_node) {
+ const NodeId node_id = node_list[i_node];
+
+ const auto& node_cell_list = node_to_cell_matrix[node_id];
+ // Assert(face_cell_list.size() == 1);
+ const auto& node_local_number_in_its_cells = node_local_numbers_in_their_cells.itemArray(node_id);
+
+ for (size_t i_cell = 0; i_cell < node_cell_list.size(); ++i_cell) {
+ CellId node_cell_id = node_cell_list[i_cell];
+ size_t node_local_number_in_cell = node_local_number_in_its_cells[i_cell];
+
+ Rd vectorSym(zero);
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ vectorSym[dim] = stateNode[node_cell_id][node_local_number_in_cell][1 + dim];
+
+ vectorSym -= dot(vectorSym, normal) * normal;
+
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ stateNode[node_cell_id][node_local_number_in_cell][dim + 1] = vectorSym[dim];
+ // stateNode[node_cell_id][node_local_number_in_cell][dim] = 0; // node_array_list[i_node][dim];
+ }
+ }
+
+ for (size_t i_face = 0; i_face < face_list.size(); ++i_face) {
+ const FaceId face_id = face_list[i_face];
+
+ const auto& face_cell_list = face_to_cell_matrix[face_id];
+ Assert(face_cell_list.size() == 1);
+
+ CellId face_cell_id = face_cell_list[0];
+ size_t face_local_number_in_cell = face_local_numbers_in_their_cells(face_id, 0);
+
+ Rd vectorSym(zero);
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ vectorSym[dim] = stateEdge[face_cell_id][face_local_number_in_cell][1 + dim];
+
+ vectorSym -= dot(vectorSym, normal) * normal;
+
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ stateFace[face_cell_id][face_local_number_in_cell][dim + 1] = vectorSym[dim];
+ }
+
+ if constexpr (Dimension == 3) {
+ const auto& edge_to_cell_matrix = mesh.connectivity().edgeToCellMatrix();
+
+ const auto& edge_local_numbers_in_their_cells = mesh.connectivity().edgeLocalNumbersInTheirCells();
+
+ const auto& edge_list = bc.edgeList();
+
+ for (size_t i_edge = 0; i_edge < edge_list.size(); ++i_edge) {
+ const EdgeId edge_id = edge_list[i_edge];
+
+ const auto& edge_cell_list = edge_to_cell_matrix[edge_id];
+ // Assert(face_cell_list.size() == 1);
+ const auto& edge_local_number_in_its_cells = edge_local_numbers_in_their_cells.itemArray(edge_id);
+
+ for (size_t i_cell = 0; i_cell < edge_cell_list.size(); ++i_cell) {
+ CellId edge_cell_id = edge_cell_list[i_cell];
+ size_t edge_local_number_in_cell = edge_local_number_in_its_cells[i_cell];
+
+ Rd vectorSym(zero);
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ vectorSym[dim] = stateEdge[edge_cell_id][edge_local_number_in_cell][1 + dim];
+
+ vectorSym -= dot(vectorSym, normal) * normal;
+
+ for (size_t dim = 0; dim < Dimension; ++dim)
+ stateEdge[edge_cell_id][edge_local_number_in_cell][dim + 1] = vectorSym[dim];
+ }
+ }
+ }
+ }
+ },
+ boundary_condition);
+ }
+}
+
template <MeshConcept MeshType>
void
RusanovEulerianCompositeSolver_v2<MeshType>::_applyInflowBoundaryCondition(const BoundaryConditionList& bc_list,
@@ -1377,10 +1848,11 @@ RusanovEulerianCompositeSolver_v2<MeshType>::_applyInflowBoundaryCondition(const
for (size_t i_edge = 0; i_edge < edge_list.size(); ++i_edge) {
const EdgeId edge_id = edge_list[i_edge];
- const auto& edge_cell_list = edge_to_cell_matrix[edge_id];
- // Assert(face_cell_list.size() == 1);
+ const auto& edge_cell_list = edge_to_cell_matrix[edge_id];
const auto& edge_local_number_in_its_cells = edge_local_numbers_in_their_cells.itemArray(edge_id);
+ // Assert(face_cell_list.size() == 1);
+
for (size_t i_cell = 0; i_cell < edge_cell_list.size(); ++i_cell) {
CellId edge_cell_id = edge_cell_list[i_cell];
size_t edge_local_number_in_cell = edge_local_number_in_its_cells[i_cell];