Euclidian3Geometry.h

// -*- 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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Euclidian3Geometry.h                                        (C) 2000-2020 */
/*                                                                           */
/* Euclidean geometric calculations in 3D.                                   */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_GEOMETRY_EUCLIDIAN_EUCLIDIAN3GEOMETRY_H
#define ARCANE_GEOMETRY_EUCLIDIAN_EUCLIDIAN3GEOMETRY_H
/*---------------------------------------------------------------------------*/
 
#include "arcane/geometry/IGeometry.h"
#include "arcane/core/ArcaneTypes.h"
#include "arcane/core/MeshVariable.h"
#include "arcane/core/VariableTypedef.h"
#include "arcane/core/MathUtils.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Numerics
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class Euclidian3Geometry
: public IGeometry
{
 public:
 
  Euclidian3Geometry(const VariableNodeReal3& coords)
  : m_coords(coords)
  {}
 
  virtual ~Euclidian3Geometry() {}


  Real3 computeCenter(const ItemWithNodes& item);


  Real3 computeOrientedMeasure(const ItemWithNodes& item);

  Real computeMeasure(const ItemWithNodes& item);


  Real computeLength(const ItemWithNodes& item);


  Real computeArea(const ItemWithNodes& item);


  Real computeVolume(const ItemWithNodes& item);

  Real3 computeSurfaceCenter(Integer n, const Real3* coords);

  Real3 computeOrientedArea(Integer n, const Real3* coords);

  Real computeLength(const Real3& m, const Real3& n);

 
 public:

  struct IComputeLine
  {
    IComputeLine(Euclidian3Geometry* geom)
    : m_geom(geom)
    , m_coords(geom->m_coords)
    {}
    virtual ~IComputeLine() {}
    virtual void computeOrientedMeasureAndCenter(const ItemWithNodes& item, Real3& orientation, Real3& center) = 0;
    Euclidian3Geometry* m_geom;
    const VariableNodeReal3& m_coords;
  };
 
  struct ComputeLine2 : public IComputeLine
  {
    ComputeLine2(Euclidian3Geometry* geom)
    : IComputeLine(geom)
    {}
    void computeOrientedMeasureAndCenter(const ItemWithNodes& item, Real3& orientation, Real3& center);
  };
 
  struct IComputeSurface
  {
    IComputeSurface(Euclidian3Geometry* geom)
    : m_geom(geom)
    , m_coords(geom->m_coords)
    {}
    virtual ~IComputeSurface() {}
    virtual void computeOrientedMeasureAndCenter(const ItemWithNodes& item, Real3& orientation, Real3& center) = 0;
    Euclidian3Geometry* m_geom;
    const VariableNodeReal3& m_coords;
  };
 
  struct ComputeTriangle3
  : public IComputeSurface
  {
    ComputeTriangle3(Euclidian3Geometry* geom)
    : IComputeSurface(geom)
    {}
    void computeOrientedMeasureAndCenter(const ItemWithNodes& item, Real3& orientation, Real3& center);
  };
 
  struct ComputeQuad4 : public IComputeSurface
  {
    ComputeQuad4(Euclidian3Geometry* geom)
    : IComputeSurface(geom)
    {}
    void computeOrientedMeasureAndCenter(const ItemWithNodes& item, Real3& orientation, Real3& center);
  };
 
  struct ComputePentagon5 : public IComputeSurface
  {
    ComputePentagon5(Euclidian3Geometry* geom)
    : IComputeSurface(geom)
    {}
    void computeOrientedMeasureAndCenter(const ItemWithNodes& item, Real3& orientation, Real3& center);
  };
 
  struct ComputeHexagon6 : public IComputeSurface
  {
    ComputeHexagon6(Euclidian3Geometry* geom)
    : IComputeSurface(geom)
    {}
    void computeOrientedMeasureAndCenter(const ItemWithNodes& item, Real3& orientation, Real3& center);
  };
 
  struct IComputeVolume
  {
    IComputeVolume(Euclidian3Geometry* geom)
    : m_geom(geom)
    , m_coords(geom->m_coords)
    {}
    virtual ~IComputeVolume() {}
    virtual void computeOrientedMeasureAndCenter(const ItemWithNodes& item, Real& measure, Real3& center) = 0;
    virtual void computeVolumeArea(const ItemWithNodes& item, Real& area) = 0;
    Euclidian3Geometry* m_geom;
    const VariableNodeReal3& m_coords;
  };
 
  struct ComputeTetraedron4 : public IComputeVolume
  {
    ComputeTetraedron4(Euclidian3Geometry* geom)
    : IComputeVolume(geom)
    {}
    void computeOrientedMeasureAndCenter(const ItemWithNodes& item, Real& measure, Real3& center);
    void computeVolumeArea(const ItemWithNodes& item, Real& area);
  };
 
  struct ComputeHeptaedron10 : public IComputeVolume
  {
    ComputeHeptaedron10(Euclidian3Geometry* geom)
    : IComputeVolume(geom)
    {}
    void computeOrientedMeasureAndCenter(const ItemWithNodes& item, Real& measure, Real3& center)
    {
      ARCANE_UNUSED(item);
      ARCANE_UNUSED(measure);
      ARCANE_UNUSED(center);
      ARCANE_THROW(NotImplementedException, "");
    }
    void computeVolumeArea(const ItemWithNodes& item, Real& area)
    {
      ARCANE_UNUSED(item);
      ARCANE_UNUSED(area);
      ARCANE_THROW(NotImplementedException, "");
    }
  };
 
  struct ComputeOctaedron12
  : public IComputeVolume
  {
    ComputeOctaedron12(Euclidian3Geometry* geom)
    : IComputeVolume(geom)
    {}
    void computeOrientedMeasureAndCenter(const ItemWithNodes& item, Real& measure, Real3& center)
    {
      ARCANE_UNUSED(item);
      ARCANE_UNUSED(measure);
      ARCANE_UNUSED(center);
      ARCANE_THROW(NotImplementedException, "");
    }
    void computeVolumeArea(const ItemWithNodes& item, Real& area)
    {
      ARCANE_UNUSED(item);
      ARCANE_UNUSED(area);
      ARCANE_THROW(NotImplementedException, "");
    }
  };
 
  struct ComputeGenericVolume : public IComputeVolume
  {
    ComputeGenericVolume(Euclidian3Geometry* geom)
    : IComputeVolume(geom)
    {}
    void computeOrientedMeasureAndCenter(const ItemWithNodes& item, Real& measure, Real3& center);
    void computeVolumeArea(const ItemWithNodes& item, Real& area);
  };
 
  typedef ComputeGenericVolume ComputePyramid5;
  typedef ComputeGenericVolume ComputePentaedron6;
  typedef ComputeGenericVolume ComputeHexaedron8;
  typedef ComputeGenericVolume ComputeHemiHexa7;
  typedef ComputeGenericVolume ComputeHemiHexa6;
  typedef ComputeGenericVolume ComputeHemiHexa5;
  typedef ComputeGenericVolume ComputeAntiWedgeLeft6;
  typedef ComputeGenericVolume ComputeAntiWedgeRight6;
  typedef ComputeGenericVolume ComputeDiTetra5;

  static inline Real3 computeTriangleNormal(const Real3& n0, const Real3& n1, const Real3& n2)
  {
    return math::vecMul(n1 - n0, n2 - n0) / 2.0;
  }
 
  static inline Real computeTriangleSurface(const Real3& n0, const Real3& n1, const Real3& n2)
  {
    return math::normeR3(computeTriangleNormal(n0, n1, n2));
  }
 
  static inline Real3 computeTriangleCenter(const Real3& n0, const Real3& n1, const Real3& n2)
  {
    return (n0 + n1 + n2) / 3.0;
  }
 
  static inline Real computeTetraedronVolume(const Real3& n0, const Real3& n1, const Real3& n2, const Real3& n3)
  {
    return math::mixteMul(n1 - n0, n2 - n0, n3 - n0) / 6.0;
  }
 
  static inline Real3 computeTetraedronCenter(const Real3& n0, const Real3& n1, const Real3& n2, const Real3& n3)
  {
    return 0.25 * (n0 + n1 + n2 + n3);
  }
 
  static inline Real3 computeQuadrilateralCenter(const Real3& n0, const Real3& n1, const Real3& n2, const Real3& n3)
  {
    const Real s0 = computeTriangleSurface(n0, n1, n2);
    const Real s1 = computeTriangleSurface(n0, n2, n3);
    const Real s2 = computeTriangleSurface(n1, n2, n3);
    const Real s3 = computeTriangleSurface(n0, n1, n3);
    return (s0 * computeTriangleCenter(n0, n1, n2) +
            s1 * computeTriangleCenter(n0, n2, n3) +
            s2 * computeTriangleCenter(n1, n2, n3) +
            s3 * computeTriangleCenter(n0, n1, n3)) /
    (s0 + s1 + s2 + s3);
  }
 
  static inline Real3 computePentagonalCenter(const Real3& n0, const Real3& n1, const Real3& n2, const Real3& n3, const Real3& n4)
  {
    const Real s0 = computeTriangleSurface(n4, n0, n1);
    const Real s1 = computeTriangleSurface(n0, n1, n2);
    const Real s2 = computeTriangleSurface(n1, n2, n3);
    const Real s3 = computeTriangleSurface(n2, n3, n4);
    const Real s4 = computeTriangleSurface(n3, n4, n0);
    const Real s5 = computeTriangleSurface(n0, n2, n3);
    const Real s6 = computeTriangleSurface(n1, n3, n4);
    const Real s7 = computeTriangleSurface(n2, n4, n0);
    const Real s8 = computeTriangleSurface(n3, n0, n1);
    const Real s9 = computeTriangleSurface(n4, n1, n2);
 
    return (2 * (s0 * computeTriangleCenter(n4, n0, n1) + s1 * computeTriangleCenter(n0, n1, n2) + s2 * computeTriangleCenter(n1, n2, n3) + s3 * computeTriangleCenter(n2, n3, n4) + s4 * computeTriangleCenter(n3, n4, n0)) +
            s5 * computeTriangleCenter(n0, n2, n3) +
            s6 * computeTriangleCenter(n1, n3, n4) +
            s7 * computeTriangleCenter(n2, n4, n0) +
            s8 * computeTriangleCenter(n3, n0, n1) +
            s9 * computeTriangleCenter(n4, n1, n2)) /
    (2 * (s0 + s1 + s2 + s3 + s4) + s5 + s6 + s7 + s8 + s9);
  }
 
  static inline Real3 computeHexagonalCenter(const Real3& n0, const Real3& n1, const Real3& n2, const Real3& n3, const Real3& n4, const Real3& n5)
  {
    const Real s0 = computeTriangleSurface(n0, n1, n5);
    const Real s1 = computeTriangleSurface(n1, n2, n3);
    const Real s2 = computeTriangleSurface(n3, n4, n5);
    const Real s3 = computeTriangleSurface(n1, n3, n5);
    const Real s4 = computeTriangleSurface(n0, n1, n2);
    const Real s5 = computeTriangleSurface(n2, n3, n4);
    const Real s6 = computeTriangleSurface(n4, n5, n0);
    const Real s7 = computeTriangleSurface(n0, n2, n4);
 
    return (s0 * computeTriangleCenter(n0, n1, n5) +
            s1 * computeTriangleCenter(n1, n2, n3) +
            s2 * computeTriangleCenter(n3, n4, n5) +
            s3 * computeTriangleCenter(n1, n3, n5) +
            s4 * computeTriangleCenter(n0, n1, n2) +
            s5 * computeTriangleCenter(n2, n3, n4) +
            s6 * computeTriangleCenter(n4, n5, n0) +
            s7 * computeTriangleCenter(n0, n2, n4)) /
    (s0 + s1 + s2 + s3 + s4 + s5 + s6 + s7);
  }
 
 protected:
 
  const VariableNodeReal3& m_coords;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane::Numerics
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif