ASMs1D.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _ASM_S1D_H
#define _ASM_S1D_H
 
#include "ASMstruct.h"
#include "ASMunstruct.h"
#include "ASM1D.h"
#include "ASMutils.h"
#include "Tensor.h"
 
using TensorVec = std::vector<Tensor>; 
 
namespace Go {
  class SplineCurve;
}
 
 
class ASMs1D : public ASMstruct, public ASMunstruct, public ASM1D
{
public:
  ASMs1D(unsigned char n_s = 1, unsigned char n_f = 1);
  ASMs1D(const ASMs1D& patch, unsigned char n_f = 0);
  virtual ~ASMs1D() {}
 
  Go::SplineCurve* getCurve() const { return curv.get(); }
 
 
  // Methods for model generation
  // ============================
 
  virtual bool read(std::istream&);
  virtual bool write(std::ostream&, int = 0) const;
 
  virtual bool generateFEMTopology();
 
  virtual bool generateOrientedFEModel(const Vec3& Zaxis);
 
  void applyTwist(const RealFunc& twist);
 
  virtual void clear(bool retainGeometry = false);
 
  virtual int getSize(int = 0) const;
 
  virtual Vec3 getCoord(size_t inod) const;
 
  const Tensor& getRotation(size_t inod) const;
 
  virtual bool getElementCoordinates(Matrix& X, int iel, bool = false) const;
 
private:
  bool getElementCoordinates(Matrix& X, const IntVec& mnpc,
                             const Go::SplineCurve* crv) const;
 
public:
  virtual void getNodalCoordinates(Matrix& X, bool = false) const;
 
  virtual bool updateCoords(const Vector& displ);
 
  bool updateRotations(const Vector& displ, bool reInit = false);
  void updateRotations() { prevT = myT; }
 
  virtual Vec3 getElementCenter(int iel) const;
 
  virtual void getBoundaryNodes(int lIndex, IntVec& nodes,
                                int, int thick, int, bool local) const;
 
  virtual int getNodeSetIdx(const std::string& setName) const;
  virtual const IntVec& getNodeSet(int iset) const;
  virtual bool isInNodeSet(int iset, int inod) const;
  virtual int parseNodeSet(const std::string& setName, const char* cset);
 
  virtual std::pair<size_t,double> findClosestNode(const Vec3& X) const;
 
  std::pair<int,double> findElement(const Vec3& X) const;
 
  virtual bool refine(const LR::RefineData& prm, Vectors&);
 
  virtual bool refine(const RealArray& xi);
  virtual bool uniformRefine(int nInsert);
  virtual bool raiseOrder(int ru);
 
  virtual bool createProjectionBasis(bool init);
 
 
  // Various methods for preprocessing of boundary conditions and patch topology
  // ===========================================================================
 
  virtual int constrainNode(double xi, int dof, int code);
  virtual size_t constrainEndLocal(int dir, int dof, int code);
 
  virtual bool connectPatch(int vertex, ASM1D& neighbor, int nvertex,
                            int thick = 1);
 
  virtual void closeBoundaries(int, int basis, int master);
 
 
  // Methods for integration of finite element quantities.
  // These are the main computational methods of the ASM class hierarchy.
  // ====================================================================
 
  virtual bool integrate(Integrand& integrand,
                         GlobalIntegral& glbInt, const TimeDomain& time);
 
  virtual bool integrate(Integrand& integrand, int lIndex,
                         GlobalIntegral& glbInt, const TimeDomain& time);
 
 
  // Post-processing methods
  // =======================
 
  virtual int evalPoint(const double* xi, double* param, Vec3& X) const;
 
  virtual int findElementContaining(const double* param) const;
 
  virtual double findPoint(Vec3& X, double* param) const;
 
  virtual bool tesselate(ElementBlock& grid, const int* npe) const;
 
  virtual bool getSolution(Matrix& sField, const Vector& locSol,
                           const IntVec& nodes) const;
 
  virtual bool evalSolution(Matrix& sField, const Vector& locSol,
                            const int* npe, int, bool) const;
 
  virtual bool evalSolution(Matrix& sField, const Vector& locSol,
                            const RealArray* gpar, bool = true,
                            int deriv = 0, int = 0) const;
 
  virtual bool evalProjSolution(Matrix& sField, const Vector& locSol,
                                const int* npe, int) const;
 
  using ASMbase::evaluate;
  virtual bool evaluate(const FunctionBase* func, RealArray& vec,
                        int, double time) const;
 
  virtual bool evalSolution(Matrix& sField, const IntegrandBase& integrand,
                            const int* npe = nullptr, char project = 0) const;
 
  Go::SplineCurve* projectSolution(const IntegrandBase& integrand) const;
  virtual Go::GeomObject* evalSolution(const IntegrandBase& integrand) const;
 
  virtual Fields* getProjectedFields(const Vector& coefs, size_t = 0) const;
 
  virtual bool evalSolution(Matrix& sField, const IntegrandBase& integrand,
                            const RealArray* gpar, bool = true) const;
 
  virtual bool getGridParameters(RealArray& prm, int nSegSpan) const;
 
  virtual void evaluateBasis(double u, double, double, Vector& N) const;
  void extractBasis(double u, Vector& N) const;
  void extractBasis(double u, Vector& N, Matrix& dNdu) const;
  void extractBasis(double u, Vector& N, Matrix& dNdu, Matrix3D& d2Ndu2) const;
  void extractBasis(double u, Vector& N, Matrix& dNdu,
                    Matrix3D& d2Ndu2, Matrix4D& d3Ndu3) const;
 
protected:
 
  // Internal utility methods
  // ========================
 
  virtual void findBoundaryElms(IntVec& elms, int lIndex, int = 0) const;
 
  virtual bool assembleL2matrices(SystemMatrix& A, SystemVector& B,
                                  const L2Integrand& integrand,
                                  bool continuous) const;
 
  virtual bool initLocalElementAxes(const Vec3& Zaxis);
 
  bool connectBasis(ASMs1D& neighbor, int slave, int master, int thick = 1);
 
  bool getGrevilleParameters(RealArray& prm) const;
 
  double getKnotSpan(int i) const;
 
  virtual void getElementBorders(int iel, double* u) const;
 
  double getElementEnds(int i, std::vector<Vec3>& XC) const;
 
  bool getElementNodalRotations(TensorVec& T, size_t iel) const;
 
  Tensor getLocal2Global(double u) const;
 
public:
  static void scatterInd(int p1, int start, IntVec& index);
 
  virtual bool getOrder(int& p1, int& p2, int& p3) const;
 
  virtual bool getSize(int& n1, int& n2, int& n3, int basis) const;
 
  virtual bool getNoStructElms(int& n1, int& n2, int& n3) const;
 
  virtual size_t getNoNodes(int basis = 0) const;
  virtual size_t getNoProjectionNodes() const;
 
  virtual bool getParameterDomain(Real2DMat& u, IntVec* corners) const;
 
  virtual void getElmConnectivities(IntMat& neigh,
                                    int basis = ASM::INTEGRATION_BASIS) const;
 
  virtual IntMat getElmNodes(int basis) const;
 
private:
  static void createMNPC(const Go::SplineCurve* crv, IntMat& MNPC);
 
protected:
  std::shared_ptr<Go::SplineCurve> curv; 
  std::shared_ptr<Go::SplineCurve> proj; 
 
  std::map<size_t,size_t> xnMap; 
  std::map<size_t,size_t> nxMap; 
 
  IntMat projMNPC; 
  IntVec projMLGE; 
 
  const TensorVec& elmCS;  
  const TensorVec& nodalT; 
 
  TensorVec myCS;  
  TensorVec myT;   
  TensorVec prevT; 
 
  std::vector<ASM::NodeSet> nodeSets; 
 
private:
  bool updatedT; 
};
 
#endif