contactmodel.h

Go to the documentation of this file.

#pragma once
// contactmodel.h
 
#include "contactmodel/interface/icontactmodel.h"
#include "contactmodel_global.h"
 
#include "base/src/farray.h"
#include "shared/src/archivestream.h"
// contactmodel.h
#if DIM==2
 #define cmodelsxd cmodels2d
#else
 #define cmodelsxd cmodels3d
#endif
 
#ifndef __GNUC__
#pragma warning(push)
#pragma warning(disable:4251)
#endif
 
namespace itasca {
 class IProgram;
}
 
 
namespace cmodelsxd {
 using namespace itasca;
 using namespace itascaxd;
 class ContactModelState;
 
 static const quint32 ACTIVE_IS = 0x000001; /* active */
 static const quint32 ACTIVATED = 0x000002; /* activated */
 static const quint32 ACTIVE_COULDBE = 0x000004; /* could be */
 
 class ContactModelState {
 public:
 ContactModelState() { }
 virtual ~ContactModelState() {};
 virtual const IProgram * getProgram() const=0;
 bool setActive(bool b=true) { if (b) activeState_ |= ACTIVE_IS; else activeState_ &= ~ACTIVE_IS; return isActive(); }
 bool setCouldBeActive(bool b=true) { if (b) activeState_ |= ACTIVE_COULDBE; else activeState_ &= ~ACTIVE_COULDBE; return couldBeActive(); }
 bool setActivated(bool b=true) { if (b) activeState_ |= ACTIVATED; else activeState_ &= ~ACTIVATED; return activated(); }
 
 bool isActive() const { return activeState_ & ACTIVE_IS; }
 bool isInactive() const { return !isActive(); }
 bool activated() const { return activeState_ & ACTIVATED; }
 bool couldBeActive() const { return activeState_ & ACTIVE_COULDBE; }
 quint32 activeState_ = 0; 
 bool trackEnergy_ = false; 
 };
 
 class CONTACTMODEL_EXPORT ContactModel : public IContactModel
 {
 public:
 ContactModel();
 
 virtual ~ContactModel();
 
 virtual ContactModel *clone() const=0;
 
 virtual bool isOKToDelete() const { return true; }
 
 virtual void archive(ArchiveStream &) {}
 
 virtual void copy(const ContactModel *cm) { cmEvents_ = cm->cmEvents_; }
 
 // IContactModel functions.
 
 IContactModel * getContactModel() override {return this;}
 
 const IContactModel * getContactModel() const override {return this;}
 QString getName() const override =0;
 
 virtual QString getPluginName() const { return getName(); }
 
 QString getProperties() const override =0; // comma delimited
 
 QVariant getProperty(uint i,const IContact *con=0) const override =0;
 
 bool getPropertyGlobal(uint ) const override {return true;}
 
 int isProperty(const QString &c,Qt::CaseSensitivity cs=Qt::CaseInsensitive) const override;
 
 bool setProperty(uint i,const QVariant &v,IContact *con=0) override =0;
 
 bool getPropertyReadOnly(uint) const override { return false; } // Base 1
 bool supportsInheritance(uint) const override { return false; } // Base 1
 bool getInheritance(uint) const override {return false;}
 void setInheritance(uint,bool) override {}
 
 QString getMethods() const override {return QString();} // comma delimited
 
 int isMethod(const QString &c,Qt::CaseSensitivity cs=Qt::CaseInsensitive) const override; // checks the list for a match, returns the integer (>0) if a match is found
 
 QString getMethodArguments(uint) const override {return QString();} // comma delimited
 
 bool setMethod(uint,const QVector<QVariant> &,[[maybe_unused]] IContact*c=0) override {return false;} // Base 1 - returns true if timestep contributions need to be updated
 
 QString getEnergies() const override {return QString();} // comma delimited
 
 int isEnergy(const QString &c,Qt::CaseSensitivity cs=Qt::CaseInsensitive) const override; // checks the list for a match, returns the integer (>0) if a match is found
 
 double getEnergy(uint ) const override {return 0.0;} // Base 1
 
 bool getEnergyAccumulate(uint ) const override {return false;} // Base 1
 
 void setEnergy(uint ,const double &) override {} // Base 1
 
 void activateEnergy() override {}
 
 virtual bool getEnergyActivated() const {return false;} // Returns a boolean indicating if energies have been instanciated
 
 uint getMinorVersion() const override =0;
 void destroy() override { delete this; }
 
 void getSphereList(const IContact *con,std::vector<DVect> *pos,std::vector<double> *rad,std::vector<double> *val) override =0;
#ifdef THREED
 void getDiskList(const IContact *con,std::vector<DVect> *pos,std::vector<DVect> *normal,std::vector<double> *radius,std::vector<double> *val) override =0;
#endif
 void getCylinderList(const IContact *con,std::vector<DVect> *bot,std::vector<DVect> *top,std::vector<double> *radlow,std::vector<double> *radhi,std::vector<double> *val) override =0;
 
 virtual QString getFishCallEvents() const {return QString();}; // comma delimited
 
 void setEventVal(int i,int j);
 
 void setFromParent(const ContactModel *cm);
 
 void setNonForcePropsFrom(IContactModel *) override { };
 
 uint getPropertyIndex(const QString &name,Qt::CaseSensitivity cs=Qt::CaseInsensitive) const;// {name; cs; return 0;}
 
 QString getPropertyName(uint index) const;
 
 // Major version of the contact model
 static uint32 getMajorVersion();
 
 // Memory Allocation Customization
 // Changing this is very dangerous, as the calling program will make assumptions about
 // where memory has been allocated to and from.
 void *operator new(size_t size);
 void *operator new(size_t size,const char *name,const char *file,unsigned line);
 void operator delete(void *v);
 void operator delete(void *v,const char *name,const char *file,unsigned line);
 typedef void *(*NewFunction)(size_t,const char *,const char *,unsigned);
 typedef void (*DeleteFunction)(void *,const char *,const char *,unsigned);
 typedef std::pair<NewFunction,DeleteFunction> AllocFunctions;
 static AllocFunctions setAllocFunctions(AllocFunctions afunc);
 static AllocFunctions getDefaultAllocFunctions();
 static AllocFunctions getAllocFunctions() { return AllocFunctions(newFunc_,deleteFunc_); }
 
 protected:
 static NewFunction newFunc_;
 static DeleteFunction deleteFunc_;
 
 FArray<int,5> cmEvents_; 
 };
} // namespace cmodelsxd
 
#ifndef __GNUC__
#pragma warning(pop)
#endif
 
// EoF