MPC.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _MPC_H
#define _MPC_H
 
#include <map>
#include <vector>
#include <iostream>
 
 
class MPC
{
public:
 
  struct DOF
  {
    DOF() : node(0), dof(0), coeff(Real(0)), nextc(nullptr) {}
 
    DOF(int n, int d, Real c) : node(n), dof(d), coeff(c), nextc(nullptr) {}
 
    friend std::ostream& operator<<(std::ostream& s, const DOF& dof)
    {
      int ivar = (dof.dof-1) / 3;
      int idof = (dof.dof+2) % 3;
      return s << (ivar < 1 ? 'u' : char('q'+ivar)) << '_'
               << char('x'+idof) <<" in node "<< dof.node;
    }
 
    friend bool operator==(const DOF& a, const DOF& b)
    {
      return a.node == b.node && a.dof == b.dof;
    }
 
    int  node;  
    int  dof;   
    Real coeff; 
    MPC* nextc; 
  };
 
  MPC(int n, int d, Real s = Real(0)) : slave(n,d,s) { iceq = -1; }
 
  void addMaster(const DOF& dof, Real tol = Real(1.0e-8));
  void addMaster(int n, int d, Real c = Real(1), Real tol = Real(1.0e-8))
  {
    this->addMaster(DOF(n,d,c),tol);
  }
 
  void updateMaster(size_t pos, Real c)
  {
    if (pos < master.size())
      master[pos].coeff = c;
  }
 
  void updateMaster(size_t pos, MPC* m)
  {
    if (pos < master.size())
      master[pos].nextc = m;
  }
 
  void removeMaster(size_t pos)
  {
    if (pos < master.size())
      master.erase(master.begin()+pos);
  }
 
  bool isChained() const
  {
    for (const DOF& mdof : master)
      if (mdof.nextc) return true;
    return false;
  }
 
  bool merge(const MPC* mpc);
 
  int renumberNodes(const std::map<int,int>& old2new, bool msg = false);
 
  void shiftNodes(int nshift);
 
  void addOffset(Real offset) { slave.coeff += offset; }
 
  void setSlaveCoeff(Real c0) { slave.coeff = c0; }
 
  const DOF& getSlave() const          { return slave; }
  const DOF& getMaster(size_t i) const { return master[i]; }
 
  size_t getNoMaster(bool recursive = false) const;
 
  friend std::ostream& operator<<(std::ostream& s, const MPC& mpc);
 
protected:
  void printMaster(std::ostream& os) const;
 
public:
  int iceq; 
 
private:
  DOF              slave;  
  std::vector<DOF> master; 
};
 
#endif