ASMLRSpline.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _ASM_LR_SPLINE_H
#define _ASM_LR_SPLINE_H
 
#include "ASMbase.h"
#include "ASMunstruct.h"
#include "ThreadGroups.h"
 
#include "GoTools/geometry/BsplineBasis.h"
 
 
namespace LR 
{
  class Basisfunction;
  class LRSpline;
 
  int extendControlPoints(LRSpline* basis, const Vector& v,
                          int nf, int ofs = 0);
 
  void contractControlPoints(LRSpline* basis, Vector& v,
                             int nf, int ofs = 0);
 
  void getGaussPointParameters(const LRSpline* spline, RealArray& uGP,
                               int d, int nGauss, int iel, const double* xi);
 
  void generateThreadGroups(ThreadGroups& threadGroups,
                            const LRSpline* lr,
                            const std::vector<LRSpline*>& addConstraints = {});
 
  void createMNPC(const LR::LRSpline* basis, IntMat& result);
}
 
 
class ASMLRSpline : public ASMbase, public ASMunstruct
{
protected:
  ASMLRSpline(unsigned char n_p, unsigned char n_s, unsigned char n_f);
  ASMLRSpline(const ASMLRSpline& patch, unsigned char n_f);
 
public:
  virtual ~ASMLRSpline() {}
 
  virtual bool empty() const { return geomB == nullptr; }
 
  virtual bool getParameterDomain(Real2DMat&, IntVec*) const;
 
  const LR::LRSpline* getRefinementBasis() const { return refB.get(); }
 
  virtual bool refine(const LR::RefineData& prm, Vectors& sol);
 
  using ASMbase::evalSolution;
  virtual LR::LRSpline* evalSolution(const IntegrandBase& integrand) const = 0;
 
  static Go::BsplineBasis getBezierBasis(int p,
                                         double start = -1.0, double end = 1.0);
 
  IntVec getFunctionsForElements(const IntVec& elements,
                                 bool globalId = false) const;
  void getFunctionsForElements(IntSet& functions, const IntVec& elements,
                               bool globalId = true) const;
 
  static void Sort(int u, int v, int orient,
                   std::vector<LR::Basisfunction*>& functions);
 
  virtual IntVec getBoundaryCovered(const IntSet& nodes) const;
 
  IntVec getOverlappingNodes(const IntSet& nodes, int dir = 7) const;
 
  IntVec getOverlappingNodes(int node, int dir = 7) const
  {
    return this->getOverlappingNodes(IntSet(&node,(&node)+1),dir);
  }
 
  virtual bool transferGaussPtVars(const LR::LRSpline* oldBasis,
                                   const RealArray& oldVar, RealArray& newVar,
                                   int nGauss) const = 0;
  virtual bool transferGaussPtVarsN(const LR::LRSpline* oldBasis,
                                    const RealArray& oldVar, RealArray& newVar,
                                    int nGauss) const = 0;
  virtual bool transferCntrlPtVars(const LR::LRSpline* oldBasis,
                                   RealArray& newVar, int nGauss) const = 0;
  bool transferCntrlPtVars(LR::LRSpline* oldBasis,
                           const RealArray& oldVar, RealArray& newVar,
                           int nGauss, int nf = 1) const;
 
  virtual std::pair<size_t,double> findClosestNode(const Vec3& X) const;
 
  virtual Vec3 getElementCenter(int iel) const;
 
  virtual void getNoIntPoints(size_t& nPt, size_t& nIPt);
 
  virtual void swapProjectionBasis();
 
protected:
  bool doRefine(const LR::RefineData& prm, LR::LRSpline* lrspline);
 
  using ASMbase::evalPoint;
  virtual int evalPoint(int iel, const double* param, Vec3& X) const = 0;
 
  static bool checkThreadGroups(const IntMat& groups,
                                const std::vector<const LR::LRSpline*>& bases,
                                const LR::LRSpline* threadBasis);
 
  std::shared_ptr<LR::LRSpline> geomB;  
  std::shared_ptr<LR::LRSpline> projB;  
  std::shared_ptr<LR::LRSpline> projB2; 
  std::shared_ptr<LR::LRSpline> refB;   
 
  ThreadGroups threadGroups; 
  ThreadGroups projThreadGroups; 
  ThreadGroups proj2ThreadGroups; 
};
 
#endif