TiedInterfaceMng.cc

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* TiedInterfaceMng.cc                                         (C) 2000-2023 */
/*                                                                           */
/* Tied interface manager.                                                   */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/mesh/TiedInterfaceMng.h"
#include "arcane/mesh/DynamicMesh.h"
#include "arcane/mesh/FaceFamily.h"
 
#include "arcane/mesh/TiedInterface.h"
 
#include "arcane/core/XmlNode.h"
#include "arcane/core/IMesh.h"
#include "arcane/core/ISubDomain.h"
#include "arcane/core/ICaseDocument.h"
#include "arcane/core/CaseNodeNames.h"
#include "arcane/core/IParallelMng.h"
#include "arcane/core/IMeshPartitionConstraintMng.h"
#include "arcane/core/IMeshUtilities.h"
#include "arcane/core/ArcaneException.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::mesh
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
TiedInterfaceMng::
TiedInterfaceMng(DynamicMesh* mesh)
: TraceAccessor(mesh->traceMng())
, m_mesh(mesh)
, m_sub_domain(mesh->subDomain())
, m_name(mesh->name())
, m_tied_interface_items_info(VariableBuildInfo(m_sub_domain, m_name + "TiedInterfaceItemsInfo"))
, m_tied_interface_nodes_iso(VariableBuildInfo(m_sub_domain, m_name + "TiedInterfaceNodesIso"))
, m_tied_interface_face_groups(VariableBuildInfo(m_sub_domain, m_name + "TiedInterfaceFaceGroups"))
, m_tied_constraint(0)
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
TiedInterfaceMng::
~TiedInterfaceMng()
{
  // m_tied_constraint is destroyed by the mesh constraint manager
  m_tied_constraint = 0;
 
  _deleteTiedInterfaces();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TiedInterfaceMng::
computeTiedInterfaces(const XmlNode& mesh_node)
{
  ICaseDocument* doc = subDomain()->caseDocument();
  CaseNodeNames* cnn = doc->caseNodeNames();
  String tied_interfaces_name = cnn->tied_interfaces;
  String tied_interface_not_structured_name = cnn->tied_interfaces_not_structured;
  String tied_interfaces_planar_tolerance = cnn->tied_interfaces_planar_tolerance;
  String semi_conform_name = cnn->tied_interfaces_semi_conform;
  String name_attribute = cnn->tied_interfaces_slave;
  XmlNode tied_interface_elem = mesh_node.child(tied_interfaces_name);
  XmlNodeList child_list = tied_interface_elem.children(semi_conform_name);
  bool has_error = false;
 
  IParallelMng* pm = m_mesh->parallelMng();
  bool is_parallel = pm->isParallel();
  UniqueArray<FaceGroup> interfaces_group;
  UniqueArray<bool> is_structured_list;
  UniqueArray<Real> planar_tolerance_list;
  FaceFamily& face_family = m_mesh->trueFaceFamily();
  for (auto& i : child_list) {
    XmlNode group_attr = i.attr(name_attribute);
    if (group_attr.null()) {
      error() << "Attribute '" << name_attribute << "' missing";
      has_error = true;
      continue;
    }
    String group_name = i.attrValue(name_attribute);
    FaceGroup face_group = face_family.findGroup(group_name);
    if (face_group.null()) {
      error() << "Can't find the interface '" << group_name << "'";
      has_error = true;
      continue;
    }
    if (interfaces_group.contains(face_group)) {
      error() << "The group '" << group_name << "' is already present in list of tied interfaces.";
      has_error = true;
      continue;
    }
    interfaces_group.add(face_group);
 
    bool is_not_structured = i.attr(tied_interface_not_structured_name).valueAsBoolean();
    info() << "** NOT STRUCTURED? = " << is_not_structured;
    is_structured_list.add(!is_not_structured);
    XmlNode tolerance_node = i.attr(tied_interfaces_planar_tolerance);
    if (tolerance_node.null()) {
      planar_tolerance_list.add(0.);
    }
    else {
      planar_tolerance_list.add(tolerance_node.valueAsReal());
    }
  }
  if (has_error)
    fatal() << "Can't determine the tied interfaces";
 
  // If no tied interface is specified in the dataset,
  // search for a face group named SOUDURE or SOUDURES
  // and consider it a weld interface in that case
  {
    FaceGroup g1 = face_family.findGroup("SOUDURE");
    if (g1.null())
      g1 = face_family.findGroup("SOUDURES");
    if (!g1.null()) {
      // Only add the group if it is not already in the list
      if (!interfaces_group.contains(g1)) {
        info() << "Add automatically the group '" << g1.name() << "' to the list of tied interfaces";
        interfaces_group.add(g1);
        is_structured_list.add(true);
        planar_tolerance_list.add(0.0);
      }
      else {
        info() << "built-in group " << g1.name() << " already in list of tied interfaces";
      }
    }
  }
  Integer nb_interface = interfaces_group.size();
  IItemFamily* cell_family = m_mesh->cellFamily();
  if (nb_interface != 0) {
    // In parallel, cells must be migrated so that the cells
    // on both sides of an interface face are in the same subdomain.
    // In parallel, first recalculate the owners, perform
    // the exchange, and finally calculate the projections
    if (is_parallel) {
      VariableItemInt32& cells_owner = cell_family->itemsNewOwner();
      ENUMERATE_ITEM (iitem, cell_family->allItems()) {
        cells_owner[iitem] = (*iitem).owner();
      }
      //for( Integer i=0, is=interfaces_group.size(); i<is; ++i ){
      //FaceGroup face_group = interfaces_group[i];
      TiedInterface::PartitionConstraintBase* c = TiedInterface::createConstraint(m_mesh, interfaces_group);
      m_tied_constraint = c;
      IMeshPartitionConstraintMng* pcmng = m_mesh->partitionConstraintMng();
      pcmng->addConstraint(c);
      pcmng->computeAndApplyConstraints();
      //}
      cells_owner.synchronize();
      m_mesh->utilities()->changeOwnersFromCells();
      m_mesh->setDynamic(true);
      m_mesh->exchangeItems();
      // Indicates that the initial partitioning has been performed
      c->setInitialRepartition(false);
    }
    for (Integer i = 0, is = interfaces_group.size(); i < is; ++i) {
      FaceGroup face_group = interfaces_group[i];
      info() << " Semi-conform interface name=" << face_group.name();
      TiedInterface* tied_interface = new TiedInterface(m_mesh);
      if (planar_tolerance_list[i] > 0)
        tied_interface->setPlanarTolerance(planar_tolerance_list[i]);
      tied_interface->build(face_group, is_structured_list[i]);
      //if (is_structured_list[i]){
      //_applyTiedInterfaceStructuration(tied_interface);
      //}
      m_true_tied_interfaces.add(tied_interface);
      m_tied_interfaces.add(tied_interface);
      face_family.applyTiedInterface(tied_interface);
    }
 
    face_family.endUpdate();
    face_family.prepareForDump();
  }
  prepareTiedInterfacesForDump();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TiedInterfaceMng::
prepareTiedInterfacesForDump()
{
  Integer nb_tied_interface = m_tied_interfaces.count();
  m_tied_interface_face_groups.resize(nb_tied_interface * 2);
 
  Integer total_nb_node = 0;
  Integer total_nb_face = 0;
  Integer nb_tied_node_per_interface = 0;
  Integer nb_tied_face_per_interface = 0;
  for (Integer i = 0; i < nb_tied_interface; ++i) {
    ITiedInterface* ti = m_tied_interfaces[i];
 
    TiedInterfaceNodeList nodes = ti->tiedNodes();
    nb_tied_node_per_interface += nodes.dim1Size();
    for (Integer zz = 0, zs = nodes.dim1Size(); zz < zs; ++zz)
      total_nb_node += nodes[zz].size();
 
    TiedInterfaceFaceList faces = ti->tiedFaces();
    nb_tied_face_per_interface += faces.dim1Size();
    for (Integer zz = 0, zs = faces.dim1Size(); zz < zs; ++zz)
      total_nb_face += faces[zz].size();
  }
 
  Integer items_info_size = total_nb_node + total_nb_face +
  nb_tied_node_per_interface + nb_tied_face_per_interface + nb_tied_interface * 2;
 
  Integer nodes_iso_size = total_nb_node;
 
  m_tied_interface_items_info.resize(items_info_size);
  m_tied_interface_nodes_iso.resize(nodes_iso_size);
 
  Integer items_info_index = 0;
  Integer nodes_iso_index = 0;
  for (Integer i = 0; i < nb_tied_interface; ++i) {
    ITiedInterface* ti = m_tied_interfaces[i];
 
    TiedInterfaceNodeList nodes = ti->tiedNodes();
    Integer nb_node = nodes.dim1Size();
    m_tied_interface_items_info[items_info_index] = nb_node;
    ++items_info_index;
    for (Integer zz = 0; zz < nb_node; ++zz) {
      Integer nb_node2 = nodes[zz].size();
      m_tied_interface_items_info[items_info_index] = nb_node2;
      ++items_info_index;
    }
 
    for (Integer zz = 0; zz < nb_node; ++zz) {
      Integer nb_node2 = nodes[zz].size();
      for (Integer zz2 = 0; zz2 < nb_node2; ++zz2) {
        m_tied_interface_items_info[items_info_index] = nodes[zz][zz2].node().uniqueId().asInt64();
        ++items_info_index;
        m_tied_interface_nodes_iso[nodes_iso_index] = nodes[zz][zz2].isoCoordinates();
        ++nodes_iso_index;
      }
    }
 
    TiedInterfaceFaceList faces = ti->tiedFaces();
    Integer nb_face = faces.dim1Size();
    m_tied_interface_items_info[items_info_index] = nb_face;
    ++items_info_index;
    for (Integer zz = 0; zz < nb_face; ++zz) {
      Integer nb_face2 = faces[zz].size();
      m_tied_interface_items_info[items_info_index] = nb_face2;
      ++items_info_index;
    }
 
    for (Integer zz = 0; zz < nb_face; ++zz) {
      Integer nb_face2 = faces[zz].size();
      for (Integer zz2 = 0; zz2 < nb_face2; ++zz2) {
        m_tied_interface_items_info[items_info_index] = faces[zz][zz2].face().uniqueId().asInt64();
        ++items_info_index;
      }
    }
  }
  debug() << "ITEMS_INFO_INDEX=" << items_info_index << " N=" << items_info_size;
  debug() << "NODES_ISO_INDEX=" << nodes_iso_index << " N=" << nodes_iso_size;
  if (nodes_iso_index != nodes_iso_size)
    throw InternalErrorException(A_FUNCINFO, "Bad size for 'nodes_iso_index'");
  if (items_info_index != items_info_size)
    throw InternalErrorException(A_FUNCINFO, "Bad size for 'items_info_index'");
  for (Integer i = 0; i < nb_tied_interface; ++i) {
    ITiedInterface* ti = m_tied_interfaces[i];
    m_tied_interface_face_groups[(i * 2)] = ti->masterInterfaceName();
    m_tied_interface_face_groups[(i * 2) + 1] = ti->slaveInterfaceName();
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TiedInterfaceMng::
readTiedInterfacesFromDump()
{
  _deleteTiedInterfaces();
  Integer nb_tied_interface = m_tied_interface_face_groups.size() / 2;
 
  Integer items_info_index = 0;
  Integer nodes_iso_index = 0;
 
  IItemFamily* node_family = m_mesh->nodeFamily();
  FaceFamily& face_family = m_mesh->trueFaceFamily();
  NodeInfoListView nodes_internal(node_family);
  FaceInfoListView faces_internal(&face_family);
  UniqueArray<TiedNode> nodes;
  UniqueArray<TiedFace> faces;
 
  for (Integer i = 0; i < nb_tied_interface; ++i) {
    TiedInterface* tied_interface = new TiedInterface(m_mesh);
    String master_group_name = m_tied_interface_face_groups[(i * 2)];
    String slave_group_name = m_tied_interface_face_groups[(i * 2) + 1];
    tied_interface->reload(&face_family, master_group_name, slave_group_name);
    FaceGroup master_group = tied_interface->masterInterface();
    FaceGroup slave_group = tied_interface->slaveInterface();
    m_tied_interfaces.add(tied_interface);
    m_true_tied_interfaces.add(tied_interface);
 
    Integer nb_node = arcaneCheckArraySize(m_tied_interface_items_info[items_info_index]);
    ++items_info_index;
    IntegerUniqueArray items_size(nb_node);
    for (Integer zz = 0; zz < nb_node; ++zz) {
      Integer nb_node2 = arcaneCheckArraySize(m_tied_interface_items_info[items_info_index]);
      ++items_info_index;
      items_size[zz] = nb_node2;
    }
    tied_interface->resizeNodes(items_size);
    Int32UniqueArray local_ids;
    for (Integer zz = 0; zz < nb_node; ++zz) {
      Integer nb_node2 = items_size[zz];
      nodes.clear();
      local_ids.resize(nb_node2);
      Int64ConstArrayView unique_ids(nb_node2, &m_tied_interface_items_info[items_info_index]);
      node_family->itemsUniqueIdToLocalId(local_ids, unique_ids, true);
      items_info_index += nb_node2;
 
      for (Integer zz2 = 0; zz2 < nb_node2; ++zz2) {
        Node node(nodes_internal[local_ids[zz2]]);
        nodes.add(TiedNode(zz2, node, m_tied_interface_nodes_iso[nodes_iso_index]));
        ++nodes_iso_index;
      }
      tied_interface->setNodes(zz, nodes);
    }
 
    Integer nb_face = arcaneCheckArraySize(m_tied_interface_items_info[items_info_index]);
    ++items_info_index;
    items_size.resize(nb_face);
    for (Integer zz = 0; zz < nb_face; ++zz) {
      Integer nb_face2 = arcaneCheckArraySize(m_tied_interface_items_info[items_info_index]);
      ++items_info_index;
      items_size[zz] = nb_face2;
    }
    tied_interface->resizeFaces(items_size);
    UniqueArray<TiedFace> faces2;
    for (Integer zz = 0; zz < nb_face; ++zz) {
      Integer nb_face2 = items_size[zz];
      faces2.clear();
      local_ids.resize(nb_face2);
      Int64ConstArrayView unique_ids(nb_face2, &m_tied_interface_items_info[items_info_index]);
      face_family.itemsUniqueIdToLocalId(local_ids, unique_ids, true);
      items_info_index += nb_face2;
      for (Integer zz2 = 0; zz2 < nb_face2; ++zz2) {
        Face face(faces_internal[local_ids[zz2]]);
        faces2.add(TiedFace(zz2, face));
      }
      tied_interface->setFaces(zz, faces2);
    }
    info() << "Read interface nb_face=" << nb_face << " nb_node=" << nb_node;
  }
 
  // Rebuild constraints if necessary
  if (!m_tied_constraint) {
    info() << "Rebuilding tied interface constraints";
    UniqueArray<FaceGroup> interface_groups;
    for (Integer i = 0, n = m_true_tied_interfaces.size(); i < n; ++i)
      interface_groups.add(m_true_tied_interfaces[i]->slaveInterface());
 
    Integer nb_interface = interface_groups.size();
    if (nb_interface != 0) {
      TiedInterface::PartitionConstraintBase* c = TiedInterface::createConstraint(m_mesh, interface_groups);
      m_tied_constraint = c;
      IMeshPartitionConstraintMng* pcmng = m_mesh->partitionConstraintMng();
      pcmng->addConstraint(c);
      // Indicates that the initial partitioning has been performed
      c->setInitialRepartition(false);
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TiedInterfaceMng::
_applyTiedInterfaceStructuration(TiedInterface* tied_interface)
{
  // Assumes the interface is structured MxN.
  // To find M, iterate through the list of tied nodes and detect
  // when a node has an iso.y coordinate lower than that of the
  // previous node. This means we are changing lines in
  // the structure.
  // Once MxN is known, normalize the iso coordinates so that
  // they correspond to this structure
 
  TiedInterfaceNodeList nodes = tied_interface->tiedNodes();
  for (Integer zz = 0, zs = nodes.dim1Size(); zz < zs; ++zz) {
    Integer current_nb_node = nodes[zz].size();
    Real old_y = -10.0;
    Integer computed_m = 0;
    for (Integer i = 0; i < current_nb_node; ++i) {
      Real2 iso_val = nodes[zz][i].isoCoordinates();
      info() << "ISO zz=" << zz << " i=" << i << " v=" << iso_val << " old=" << old_y;
      if (iso_val.y > old_y) {
        ++computed_m;
      }
      else {
        info() << "COMPUTED M = " << computed_m;
        computed_m = 0;
      }
      old_y = iso_val.y;
    }
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void TiedInterfaceMng::
_deleteTiedInterfaces()
{
  for (Integer i = 0, is = m_tied_interfaces.count(); i < is; ++i)
    delete m_tied_interfaces[i];
  m_tied_interfaces.clear();
  m_true_tied_interfaces.clear();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::mesh
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/