geometry/elementMaps3D.hh

Go to the documentation of this file.

/* Element maps in 3D
 * Geometrical information (coordinates)
 */

#ifndef elementMaps3D_hh
#define elementMaps3D_hh

#include "basics/outputOperator.hh"
#include "basics/typedefs.hh"
#include "basics/vectorsMatrices.hh"
#include "basics/debug.hh"

// debugging
#define geoMapTetrahedron3dAppl_D 0

namespace concepts {

  // ***************************************************************** Map3d **

  class Map3d : public OutputOperator {
  public:
    std::ostream& info(std::ostream& os) const {return os << "Map3d()";};
  };


  // ****************************************************** MapTetrahedron3d **

  class MapTetrahedron3d : public Map3d {
  public:
    MapTetrahedron3d(char* map, Real scX, Real scY, Real scZ);

    MapTetrahedron3d(Real3d vtx0, Real3d vtx1, Real3d vtx2, Real3d vtx3);

    MapTetrahedron3d(const MapTetrahedron3d &map);
    ~MapTetrahedron3d() { delete[] map_; }

    Real3d operator()(Real x, Real y, Real z) const { 
      if (map_)
  return Real3d(map_, scx_ * x, scy_ * y, scz_ * z);
      else {
  Real3d xi(x*(1.0-y)*(1.0-z), y*(1.0-z), z);
  Real3d res(B_ * xi);
  res += b_;
  DEBUGL(geoMapTetrahedron3dAppl_D, '(' << x << ", " << y 
         << ", " << z << ") -> " << xi << " -> " << res);
  return res;
      }
    }

    Real jacobian() const {
      if (map_)
        throw conceptsException(MissingFeature("jacobian not supported"));
      return B_.determinant(); }

    inline MapTetrahedron3d* clone() const {
      return new MapTetrahedron3d(*this);
    };

private:
    uchar* map_;

    uint sz_;

    Real scx_;

    Real scy_;

    Real scz_;

    MapReal3d B_;

    Real3d b_;

    void operator=(const MapTetrahedron3d &);
  };


  // ******************************************************* MapHexahedron3d **

  class MapHexahedron3d : public Map3d {

    uchar* map_;

    uint sz_;

    Real scx_;

    Real scy_;

    Real scz_;

    Real3d *comp_;

    void operator=(const MapHexahedron3d &);

  public:
    MapHexahedron3d(char* map, Real scX, Real scY, Real scZ);

    MapHexahedron3d(const Real3d& vtx0, const Real3d& vtx1, 
        const Real3d& vtx2, const Real3d& vtx3,
        const Real3d& vtx4, const Real3d& vtx5,
        const Real3d& vtx6, const Real3d& vtx7);

    MapHexahedron3d(const MapHexahedron3d &map);
    ~MapHexahedron3d() { delete[] map_;  delete[] comp_; };

    inline Real3d operator()(Real x, Real y, Real z) const { 
      conceptsAssert(x >= 0.0, Assertion());
      conceptsAssert(x <= 1.0, Assertion());
      conceptsAssert(y >= 0.0, Assertion());
      conceptsAssert(y <= 1.0, Assertion());
      conceptsAssert(z >= 0.0, Assertion());
      conceptsAssert(z <= 1.0, Assertion());
      if (map_)
  return Real3d(map_, scx_ * x, scy_ * y, scz_* z);
      else {
  Real3d res(comp_[0]*(x*y*z));
  res += comp_[1]*(x*y);
  res += comp_[2]*(x*z);
  res += comp_[3]*(y*z);
  res += comp_[4]*x;
  res += comp_[5]*y;
  res += comp_[6]*z;
  res += comp_[7];
  return res;
      }
    }

    MapReal3d jacobian(const Real x, const Real y, const Real z) const;

    MapReal3d jacobianInverse(const Real x, const Real y, const Real z) const {
      return jacobian(x, y, z).inverse();
    }

    Real jacobianDeterminant(const Real x, const Real y, const Real z) const {
      return jacobian(x, y, z).determinant();
    }

    MapHexahedron3d* clone() const { return new MapHexahedron3d(*this); }
  };


  // *************************************************** MapParallelepiped3d **

  class MapParallelepiped3d : public Map3d {
  public:
    MapParallelepiped3d(Real3d vtx0, Real3d vtx1, Real3d vtx2, Real3d vtx3);

    MapParallelepiped3d(const MapParallelepiped3d &map);

    Real3d operator()(Real x, Real y, Real z) const {
      Real3d res(B1_*x + B2_*y + B3_*z);
      res += b_;
      return res;
    }

    Real jacobian() const {
      return (B1_ ^ B2_) * B3_;
    }

    inline MapParallelepiped3d* clone() const {
      return new MapParallelepiped3d(*this);
    };

  private:
    Real3d b_;
    Real3d B1_;
    Real3d B2_;
    Real3d B3_;

    void operator=(const MapParallelepiped3d &);
  };

} // namespace concepts

#endif // elementMaps3D_hh