RodContactModel.h

Go to the documentation of this file.

 
#pragma once
 
#include <jem/base/Object.h>
 
#include "misc/Line3D.h"
#include "models/LatticeModel.h"
#include "models/SpecialCosseratRodModel.h"
#include <jem/base/Array.h>
#include <jem/base/Error.h>
#include <jem/base/System.h>
#include <jem/util/Event.h>
#include <jem/util/Properties.h>
#include <jive/Array.h>
#include <jive/algebra/MatrixBuilder.h>
#include <jive/algebra/NullMatrixBuilder.h>
#include <jive/app/Names.h>
#include <jive/fem/ElementSet.h>
#include <jive/implict/Names.h>
#include <jive/model/Actions.h>
#include <jive/model/Model.h>
#include <jive/model/ModelFactory.h>
#include <jive/model/StateVector.h>
#include <jive/util/Assignable.h>
#include <jive/util/DofSpace.h>
#include <jive/util/FuncUtils.h>
#include <jive/util/XTable.h>
 
using jem::ALL;
using jem::newInstance;
using jem::Ref;
using jive::idx_t;
using jive::IdxMatrix;
using jive::IdxVector;
using jive::Matrix;
using jive::Properties;
using jive::String;
using jive::Vector;
using jive::algebra::MatrixBuilder;
using jive::algebra::NullMatrixBuilder;
using jive::fem::ElementSet;
using jive::fem::NodeSet;
using jive::model::ActionParams;
using jive::model::Actions;
using jive::model::Model;
using jive::model::StateVector;
using jive::util::Assignable;
using jive::util::DofSpace;
using jive::util::FuncUtils;
using jive::util::XTable;
 
//-----------------------------------------------------------------------
//   class RodContactModel
//-----------------------------------------------------------------------
 
class RodContactModel : public Model
{
 
 public:
  JEM_DECLARE_CLASS(RodContactModel, Model);
 
  static const char *TYPE_NAME;        
  static const char *PENALTY_PROP;     
  static const char *PENALTY_STS_PROP; 
  static const char *PENALTY_NTS_PROP; 
  static const char *RADIUS_PROP;      
  static const char *VERBOSE_PROP;     
 
  explicit RodContactModel(const String &name,
                           const Properties &conf,
                           const Properties &props,
                           const Properties &globdat);
 
  virtual bool takeAction(const String &action,
                          const Properties &params,
                          const Properties &globdat) override;
 
  static Ref<Model> makeNew(const String &name,
                            const Properties &conf,
                            const Properties &props,
                            const Properties &globdat);
 
  static void declare();
 
 protected:
  virtual void findContacts_(IdxVector &elementsA,
                             IdxVector &elementsB,
                             const Vector &disp) const;
 
  void getElementBoxes_(Matrix &elemBoxMin,
                        Matrix &elemBoxMax,
                        const Vector &disp) const;
 
  virtual void findPossibleBeams_(IdxVector &beamsA,
                                  IdxVector &beamsB,
                                  const Matrix &elemBoxMin,
                                  const Matrix &elemBoxMax) const;
 
  virtual void findPossibleElements_(IdxVector &elemsA,
                                     IdxVector &elemsB,
                                     const idx_t &beamA,
                                     const idx_t &beamB,
                                     const Matrix &elemBoxMin,
                                     const Matrix &elemBoxMax) const;
 
  virtual void computeContacts_(MatrixBuilder &mbld,
                                const Vector &fint,
                                const IdxVector &elementsA,
                                const IdxVector &elementsB,
                                const Vector &disp);
 
  virtual void computeBlacklist_(const IdxVector &elementsA,
                                 const IdxVector &elementsB,
                                 const Vector &disp);
 
  virtual bool filterBlacklist_(const idx_t elementsA,
                                const idx_t elementsB) const;
 
  virtual void findClosestPoints_(double &uA,
                                  double &uB,
                                  const Matrix &possA,
                                  const Matrix &possB) const;
 
  virtual double getClosestPoint_(const Vector &posS,
                                  const Matrix &possM) const;
 
  virtual bool computeSTS_(Vector &f_contrib,
                           Matrix &k_contrib,
                           const Matrix &possA,
                           const Matrix &possB,
                           const double uA,
                           const double uB) const;
 
  virtual bool computeNTS_(Vector &f_contrib,
                           Matrix &k_contrib,
                           const Vector &possS,
                           const Matrix &possM,
                           const double uM) const;
 
  bool nodeInRod_(const idx_t inode, const idx_t iRod) const;
 
  void updNodeDofs_() const;
 
  void invalidateNodeDofs_();
 
 private:
  Assignable<NodeSet> allNodes_;            
  Assignable<ElementSet> allElems_;         
  Array<Assignable<ElementGroup>> rodList_; 
  Array<IdxVector> rodNodes_;               
  IdxMatrix nodeRods_;                      
  mutable IdxMatrix nodeDofs_;              
  mutable bool nodeDofsValid_;              
  Ref<DofSpace> dofs_;                      
  Ref<Line3D> shape_;                       
 
  IdxVector blacklistA_; 
  IdxVector blacklistB_; 
 
  ArrayBuffer<idx_t> contactsA_; 
  ArrayBuffer<idx_t> contactsB_; 
 
  Ref<Function> updCond_; 
 
  double penaltySTS_; 
  double penaltyNTS_; 
  double radius_;     
  bool verbose_;      
};