SAM.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _SAM_H
#define _SAM_H
 
#include "MatVec.h"
#include <set>
#include <map>
 
class SystemMatrix;
class SystemVector;
 
using IntVec = std::vector<int>; 
using IntSet = std::set<int>;    
 
 
class SAM
{
public:
  SAM();
  virtual ~SAM();
 
  void print(std::ostream& os) const;
 
  template<class T> void printVector(T& os, const RealArray& vec,
                                     const char* heading = nullptr) const
  {
    if (heading)
      os <<"\n"<< heading <<":";
    for (int inod = 1; inod <= nnod; inod++)
      for (int jdof = madof[inod-1]; jdof < madof[inod]; jdof++)
        if (utl::trunc(vec[jdof-1]) != Real(0))
        {
          os <<"\nNode "<< inod <<":";
          for (int idof = madof[inod-1]; idof < madof[inod]; idof++)
            os <<" "<< utl::trunc(vec[idof-1]);
          break;
        }
    os << std::endl;
  }
 
  int getNoElms() const { return nel; }
  int getNoNodes(char dofType = 'A') const;
  int getNoDOFs() const { return ndof; }
  int getNoSpecifiedDOFs() const { return nspdof; }
  int getNoConstraints() const { return nceq; }
  int getNoEquations() const { return neq; }
  IntSet getEquations(char dType, int dof = 0) const;
  const int* getMADOF() const { return madof; }
  const int* getMEQN() const { return meqn; }
 
  void getDofCouplings(IntVec& irow, IntVec& jcol) const;
  void getDofCouplings(std::vector<IntSet>& dofc) const;
 
  bool assembleSystem(SystemMatrix& sysK, SystemVector& sysRHS,
                      const Matrix& eK, int iel = 0,
                      RealArray* reactionForces = nullptr) const;
 
  bool assembleSystem(SystemMatrix& sysM, const Matrix& eM, int iel = 0) const;
 
  bool assembleSystem(SystemVector& sysRHS,
                      const Matrix& eK, int iel = 0,
                      RealArray* reactionForces = nullptr) const;
 
  bool assembleSystem(SystemVector& sysRHS,
                      const RealArray& eS, int iel = 0,
                      RealArray* reactionForces = nullptr) const;
 
  bool assembleSystem(SystemVector& sysRHS,
                      const Real* nS, int inod = 0,
                      RealArray* reactionForces = nullptr) const;
 
  bool assembleSystem(SystemVector& sysRHS, Real S,
                      const std::pair<int,int>& dof) const;
 
  void addToRHS(SystemVector& sysRHS, const RealArray& S) const;
 
  bool getElmNodes(IntVec& mnpc, int iel) const;
  bool getElmEqns(IntVec& meen, int iel, size_t nedof = 0) const;
  void getUniqueEqns(IntSet& meen, int iel) const;
 
  bool getNodeEqns(IntVec& mnen, int inod) const;
 
  char getNodeType(int inod) const
  { return inod-- > 0 && inod < (int)nodeType.size() ? nodeType[inod] : ' '; }
 
  std::pair<int,int> getNodeDOFs(int inod) const;
 
  std::pair<int,int> getNodeAndLocalDof(int idof, bool eqno = false) const;
 
  int getEquation(int inod, int ldof) const;
 
  Real getDofVal(const RealArray& dofVec, int inod, int ldof) const;
 
  virtual bool expandSolution(const SystemVector& solVec,
                              Vector& dofVec, Real scaleSD = Real(1)) const;
 
  bool expandVector(const Vector& solVec, Vector& dofVec) const;
 
  bool getSolVec(RealArray& solVec, const RealArray& dofVec) const;
 
  bool applyDirichlet(Vector& dofVec) const;
 
  virtual Real dot(const Vector& x, const Vector& y, char dofType = 'D') const;
  Real norm2(const Vector& x, char dofType = 'D') const
  { return sqrt(this->dot(x,x,dofType)); }
  virtual Real normL2(const Vector& x, char dofType = 'D') const;
  virtual Real normInf(const Vector& x, size_t& comp, char dofType = 'D') const;
 
  virtual Real normReact(const RealArray& u, const RealArray& rf) const;
  Real getReaction(int dir, const RealArray& rf,
                   const IntVec* nodes = nullptr) const;
  bool haveReaction(int dir, const IntVec* nodes = nullptr) const;
  bool getNodalReactions(int inod, const RealArray& rf, RealArray& nrf) const;
 
  virtual bool merge(const SAM*, const std::map<int,int>*) { return false; }
 
protected:
  bool initSystemEquations();
 
  void assembleRHS(Real* RHS, Real value, int ieq) const;
 
  void assembleReactions(RealArray& rf, const RealArray& eS, int iel) const;
 
  bool expandVector(const Real* solVec, Vector& dofVec, Real scaleSD) const;
 
  void printStatusCodes(std::ostream& os) const;
  void printCEQ(std::ostream& os, int iceq) const;
  void printMEQN(std::ostream& os) const;
 
private:
  int mpar[50]; 
 
protected:
  // The following parameters are pointers to specific locations in MPAR
  int& nnod;   
  int& nel;    
  int& ndof;   
  int& nspdof; 
  int& nceq;   
  int& neq;    
  int& nmmnpc; 
  int& nmmceq; 
 
  // The standard %SAM arrays (see K. Bell's reports for detailed explanation).
  // We are using plane C-pointers for these items such that they more easily
  // can be passed directly as arguments to FORTRAN subroutines.
  int*  mpmnpc; 
  int*  mmnpc;  
  int*  madof;  
  int*  msc;    
  int*  mpmceq; 
  int*  mmceq;  
  Real* ttcc;   
  int*  minex;  
  int*  meqn;   
 
  std::vector<char> nodeType; 
  std::vector<char> dof_type; 
 
  friend class DenseMatrix;
  friend class SPRMatrix;
  friend class SparseMatrix;
  friend class DiagMatrix;
  friend class PETScMatrix;
  friend class SystemMatrix;
};
 
#endif