ElementBlock.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _ELEMENT_BLOCK_H
#define _ELEMENT_BLOCK_H
 
#include "Point.h"
#include "MatVec.h"
#include <array>
 
 
class ElementBlock
{
public:
  explicit ElementBlock(size_t nenod = 8);
  virtual ~ElementBlock() = default;
 
  void resize(size_t nI, size_t nJ = 1, size_t nK = 1);
 
  void unStructResize(size_t nEl, size_t nPts, size_t nMNPC = 0);
 
  bool setCoor(size_t i, size_t j, Real x);
  bool setCoor(size_t i, const Vec3& X);
  bool setCoor(size_t i, Real x, Real y, Real z)
  { return this->setCoor(i,Vec3(x,y,z)); }
  bool setParams(size_t i, Real u, Real v, Real w = Real(0));
 
  bool setNode(size_t i, int nodeNumb);
  bool endOfElm(size_t& i);
 
  bool addLine(Real x1, Real y1, Real z1, Real x2, Real y2, Real z2);
  size_t addLine(size_t i1, const Vec3& X2, int elmId = -1);
 
  void setElmId(size_t i, int iel) { MINEX[i-1] = iel; }
  int getElmId(size_t i) const { return MINEX[i-1]; }
  size_t getElmIndex(size_t i) const { return i < elmIdx.size() ? elmIdx[i]:i; }
 
  size_t getNoNodes() const { return coord.size(); }
  size_t getNoElms() const { return MINEX.size(); }
  size_t getNoElmNodes() const { return nen; }
  void setNoElmNodes(size_t nenod) { nen = nenod; }
 
  void merge(const ElementBlock* other,
             std::vector<int>& nodeNums, bool uniqNodes = true);
  void merge(const ElementBlock& other, bool uniqNodes = true);
 
  void transform(const Matrix& Tlg);
 
  std::vector<Vec3>::const_iterator begin_XYZ() const { return coord.begin(); }
  std::vector<Vec3>::const_iterator end_XYZ() const { return coord.end(); }
 
  const Vec3& getCoord(size_t i) const { return coord[i]; }
  const Real* getParam(size_t i) const;
 
  const int* getElements() const { return MMNPC.data(); }
  bool getElements(std::vector<int>& mnpc, size_t nenod) const;
 
  utl::Point getCenter(size_t i) const;
  void removeElement(int iel);
 
protected:
  using Prm3 = std::array<Real,3>; 
 
  std::vector<Vec3> coord; 
  std::vector<Prm3> param; 
  std::vector<int>  MMNPC; 
  std::vector<int>  MINEX; 
  size_t            nen;   
 
private:
  std::vector<size_t> elmIdx; 
 
public:
  static double eps; 
};
 
 
class PlaneBlock : public ElementBlock
{
public:
  PlaneBlock(const Vec3& X0, const Vec3& X1, const Vec3& X2);
};
 
 
class CubeBlock : public ElementBlock
{
public:
  CubeBlock(const Vec3& X0, double dX);
};
 
 
class SphereBlock : public ElementBlock
{
public:
  SphereBlock(const Vec3& X0, double R, size_t nTheta = 180, size_t nPhi = 60);
};
 
 
class CylinderBlock : public ElementBlock
{
public:
  CylinderBlock(const Vec3& X0, const Vec3& X1,
                double R, size_t nTheta = 180);
};
 
#endif