snl_fei_Constraint.hpp

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*    Copyright 2005 Sandia Corporation.                              */
/*    Under the terms of Contract DE-AC04-94AL85000, there is a       */
/*    non-exclusive license for use of this work by or on behalf      */
/*    of the U.S. Government.  Export of this program may require     */
/*    a license from the United States Government.                    */
/*--------------------------------------------------------------------*/
 
#ifndef _snl_fei_Constraint_hpp_
#define _snl_fei_Constraint_hpp_
 
#include <fei_macros.hpp>
#include <fei_fwd.hpp>
#include <fei_VectorSpace.hpp>
#include <snl_fei_RecordCollection.hpp>
 
#include <vector>
 
namespace snl_fei {
 
  template<class RecordType>
  class Constraint {
  public:
    Constraint(int id=0, bool isPenaltyConstr=false);
 
    Constraint(int id,
               int constraintIDType,
               bool isSlave,
               bool isPenaltyConstr,
               int numIDs,
               const int* idTypes,
               const int* IDs,
               const int* fieldIDs,
               int offsetOfSlave,
               int offsetIntoSlaveField,
               const double* weights,
               double rhsValue,
               fei::VectorSpace* vspace);
 
    virtual ~Constraint();
 
    int getConstraintID() const { return( constraintID_ ); }
 
    void setConstraintID(int id) { constraintID_ = id; }
 
    int getIDType() const { return( idType_ ); }
 
    snl_fei::RecordCollection* getRecordCollection() { return recordCollection_; }
 
    void setIDType(int idType) { idType_ = idType; }
 
    bool isPenalty() const { return( isPenalty_ ); }
 
    void setIsPenalty(bool isPenaltyConstr) { isPenalty_ = isPenaltyConstr; }
 
    int getEqnNumber() const { return( eqnNumber_ ); }
 
    void setEqnNumber(int eqn) { eqnNumber_ = eqn; }
 
    int getBlkEqnNumber() const { return( blkEqnNumber_ ); }
 
    void setBlkEqnNumber(int blkEqn) { blkEqnNumber_ = blkEqn; }
 
 
    RecordType getSlave() { return getRecordCollection()->getRecordWithLocalID(slave_); }
 
    void setSlave(int slv) { slave_ = slv; }
 
    int getSlaveFieldID() const { return( slaveField_ ); }
 
    void setSlaveFieldID(int f) { slaveField_ = f; }
 
    int getOffsetIntoSlaveField() const { return( offsetIntoSlaveField_ ); }
 
    void setOffsetIntoSlaveField(int offset) { offsetIntoSlaveField_ = offset; }
 
 
    std::vector<int>& getMasters() { return( masters_ ); }
 
    std::vector<int>& getMasterIDTypes() { return( masterIDTypes_ ); }
 
    std::vector<snl_fei::RecordCollection*>& getMasterRecordCollections() { return masterRecordCollections_; }
 
    std::vector<int>& getMasterFieldIDs() { return( masterFields_ ); }
 
    std::vector<double>& getMasterWeights() { return( masterWeights_ ); }
 
 
    double getRHSValue() const { return( rhsValue_ ); }
 
    void setRHSValue(double rhs) { rhsValue_ = rhs; }
 
    bool operator!=(const Constraint<RecordType>& rhs);
 
    bool structurallySame(const Constraint<RecordType>& rhs);
 
  private:
    Constraint(const Constraint<RecordType>& src);
    Constraint<RecordType>& operator=(const Constraint<RecordType>& src);
 
    int constraintID_;
    int idType_;
    snl_fei::RecordCollection* recordCollection_;
    bool isPenalty_;
 
    int eqnNumber_;
    int blkEqnNumber_;
 
    int slave_;
    int slaveField_;
    int offsetIntoSlaveField_;
 
    std::vector<int> masters_;
    std::vector<int> masterIDTypes_;
    std::vector<snl_fei::RecordCollection*> masterRecordCollections_;
    std::vector<int> masterFields_;
    std::vector<double> masterWeights_;
 
    double rhsValue_;
 
  };//class Constraint
} //namespace snl_fei
 
#include <snl_fei_Constraint.hpp>
 
//----------------------------------------------------------------------------
template<class RecordType>
inline snl_fei::Constraint<RecordType>::Constraint(int id, bool isPenaltyConstr)
  : constraintID_(id),
    idType_(0),
    recordCollection_(NULL),
    isPenalty_(isPenaltyConstr),
    eqnNumber_(-1),
    blkEqnNumber_(-1),
    slave_(),
    slaveField_(0),
    offsetIntoSlaveField_(0),
    masters_(),
    masterIDTypes_(),
    masterRecordCollections_(),
    masterFields_(),
    masterWeights_(),
    rhsValue_(0.0)
{
}
 
//----------------------------------------------------------------------------
template<class RecordType>
inline snl_fei::Constraint<RecordType>::Constraint(int id,
                                            int constraintIDType,
                                            bool isSlave,
                                            bool isPenaltyConstr,
                                            int numIDs,
                                            const int* idTypes,
                                            const int* IDs,
                                            const int* fieldIDs,
                                            int offsetOfSlave,
                                            int offsetIntoSlaveField,
                                            const double* weights,
                                            double rhsValue,
                                            fei::VectorSpace* vspace)
  : constraintID_(id),
    idType_(constraintIDType),
    recordCollection_(NULL),
    isPenalty_(isPenaltyConstr),
    eqnNumber_(-1),
    blkEqnNumber_(-1), 
    slave_(),
    slaveField_(0),
    offsetIntoSlaveField_(offsetIntoSlaveField),
    masters_(),
    masterIDTypes_(),
    masterRecordCollections_(),
    masterFields_(),
    masterWeights_(),
    rhsValue_(rhsValue)
{
}
 
//----------------------------------------------------------------------------
namespace snl_fei {
template<>
inline snl_fei::Constraint<fei::Record<int>*>::Constraint(int id,
                                            int constraintIDType,
                                            bool isSlave,
                                            bool isPenaltyConstr,
                                            int numIDs,
                                            const int* idTypes,
                                            const int* IDs,
                                            const int* fieldIDs,
                                            int offsetOfSlave,
                                            int offsetIntoSlaveField,
                                            const double* weights,
                                            double rhsValue,
                                            fei::VectorSpace* vspace)
  : constraintID_(id),
    idType_(constraintIDType),
    recordCollection_(NULL),
    isPenalty_(isPenaltyConstr),
    eqnNumber_(-1),
    blkEqnNumber_(-1), 
    slave_(),
    slaveField_(0),
    offsetIntoSlaveField_(offsetIntoSlaveField),
    masters_(),
    masterIDTypes_(),
    masterRecordCollections_(),
    masterFields_(),
    masterWeights_(),
    rhsValue_(rhsValue)
{
  int weightsOffset = 0;
  snl_fei::RecordCollection* recordCollection = NULL;
  vspace->getRecordCollection(idType_, recordCollection);
  recordCollection_ = recordCollection;
  for(int i=0; i<numIDs; ++i) {
    vspace->getRecordCollection(idTypes[i],recordCollection);
    masterRecordCollections_.push_back(recordCollection);
 
    vspace->addDOFs(fieldIDs[i], idTypes[i], 1, &(IDs[i]));
    int rec_local_id = recordCollection->getLocalID(IDs[i]);
    fei::Record<int>* rec = recordCollection->getRecordWithLocalID(rec_local_id);
    
    unsigned fieldSize = vspace->getFieldSize(fieldIDs[i]);
 
    if (isSlave && i == offsetOfSlave) {
      rec->hasSlaveDof(true);
      setSlave(rec_local_id);
      setSlaveFieldID(fieldIDs[i]);
      setOffsetIntoSlaveField(offsetIntoSlaveField);
      weightsOffset += fieldSize;
    }
    else {
      getMasters().push_back(rec_local_id);
      getMasterIDTypes().push_back(idTypes[i]);
      getMasterFieldIDs().push_back(fieldIDs[i]);
 
      if (weights != NULL) {
        for(unsigned j=0; j<fieldSize; ++j) {
          masterWeights_.push_back(weights[weightsOffset++]);
        }
      }
    }
  }
}
 
}//namespace snl_fei
 
//----------------------------------------------------------------------------
template<class RecordType>
inline snl_fei::Constraint<RecordType>::Constraint(const Constraint<RecordType>& src)
  : constraintID_(-1),
    idType_(0),
    isPenalty_(false),
    eqnNumber_(-1),
    blkEqnNumber_(-1), 
    slave_(),
    slaveField_(0),
    offsetIntoSlaveField_(0),
    masters_(),
    masterIDTypes_(),
    masterRecordCollections_(),
    masterFields_(),
    masterWeights_(),
    rhsValue_(0.0)
{
}
 
//----------------------------------------------------------------------------
template<class RecordType>
inline snl_fei::Constraint<RecordType>::~Constraint()
{
}
 
//----------------------------------------------------------------------------
template<class RecordType>
inline bool snl_fei::Constraint<RecordType>::operator!=(const snl_fei::Constraint<RecordType>& rhs)
{
  if (constraintID_ != rhs.constraintID_ ||
      idType_ != rhs.idType_ ||
      isPenalty_ != rhs.isPenalty_ ||
      eqnNumber_ != rhs.eqnNumber_ ||
      blkEqnNumber_ != rhs.blkEqnNumber_ ||
      slaveField_ != rhs.slaveField_ ||
      offsetIntoSlaveField_ != rhs.offsetIntoSlaveField_ ||
      rhsValue_ != rhs.rhsValue_) {
    return( true );
  }
 
  if (masters_ != rhs.masters_) return(true);
 
  if (masterIDTypes_ != rhs.masterIDTypes_) return(true);
 
  if (masterFields_ != rhs.masterFields_) return(true);
 
  if (masterWeights_ != rhs.masterWeights_) return(true);
 
  return(false);
}
 
//----------------------------------------------------------------------------
template<class RecordType>
inline bool snl_fei::Constraint<RecordType>::structurallySame(const Constraint<RecordType>& rhs)
{
  if (constraintID_ != rhs.constraintID_ ||
      idType_ != rhs.idType_ ||
      isPenalty_ != rhs.isPenalty_ ||
      eqnNumber_ != rhs.eqnNumber_ ||
      blkEqnNumber_ != rhs.blkEqnNumber_ ||
      slaveField_ != rhs.slaveField_ ||
      offsetIntoSlaveField_ != rhs.offsetIntoSlaveField_) {
    return( false );
  }
 
  if (masters_ != rhs.masters_) return(false);
 
  if (masterIDTypes_ != rhs.masterIDTypes_) return(false);
 
  if (masterFields_ != rhs.masterFields_) return(false);
 
  return(true);
}
 
#endif // _snl_fei_Constraint_hpp_