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

#pragma warning(push)
#pragma warning(disable:4251)

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(): activeState_(0),trackEnergy_(false) { }
        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_;                      
        bool trackEnergy_;                         
    };
    
    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.
        
        virtual IContactModel *       getContactModel() {return this;}
        
        virtual const IContactModel * getContactModel() const {return this;}
        virtual QString               getName() const=0;
        
        virtual QString               getPluginName() const { return getName(); }
        
        virtual QString               getProperties() const=0; // comma delimited

        virtual QVariant              getProperty(uint i,const IContact *con=0) const=0; 
 
        virtual bool                  getPropertyGlobal(uint ) const {return true;}

        virtual int                   isProperty(const QString &c,Qt::CaseSensitivity cs=Qt::CaseInsensitive) const;

        virtual bool                  setProperty(uint i,const QVariant &v,IContact *con=0)=0;

        virtual bool                  getPropertyReadOnly(uint) const { return false; } // Base 1
        virtual bool                  supportsInheritance(uint) const { return false; } // Base 1
        virtual bool                  getInheritance(uint) const {return false;} 
        virtual void                  setInheritance(uint,bool) {}
    
        virtual QString               getMethods() const {return QString();}                                                      // comma delimited
        
        virtual int                   isMethod(const QString &c,Qt::CaseSensitivity cs=Qt::CaseInsensitive) const;                // checks the list for a match, returns the integer (>0) if a match is found
        
        virtual QString               getMethodArguments(uint) const {return QString();}                                          // comma delimited
        
        virtual bool                  setMethod(uint,const QVector<QVariant> &,IContact*c=0) {c;return false;}                      // Base 1 - returns true if timestep contributions need to be updated
    
        virtual QString               getEnergies() const {return QString();}                                                     // comma delimited
        
        virtual int                   isEnergy(const QString &c,Qt::CaseSensitivity cs=Qt::CaseInsensitive) const;                // checks the list for a match, returns the integer (>0) if a match is found
        
        virtual double                getEnergy(uint ) const {return 0.0;}                                                        // Base 1
        
        virtual bool                  getEnergyAccumulate(uint ) const {return false;}                                            // Base 1
        
        virtual void                  setEnergy(uint ,const double &) {}                                                          // Base 1    
        
        virtual void                  activateEnergy() {}
        
        virtual bool                  getEnergyActivated() const {return false;}  // Returns a boolean indicating if energies have been instanciated
        
        virtual uint                  getMinorVersion() const=0;
        virtual void                  destroy() { delete this; }
    
        virtual void getSphereList(const IContact *con,std::vector<DVect> *pos,std::vector<double> *rad,std::vector<double> *val)=0;
#ifdef THREED
        virtual void getDiskList(const IContact *con,std::vector<DVect> *pos,std::vector<DVect> *normal,std::vector<double> *radius,std::vector<double> *val)=0;
#endif
        virtual 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)=0;
        
        virtual QString               getFishCallEvents() const {return QString();};         // comma delimited

        void                          setEventVal(int i,int j);
        
        void                          setFromParent(const ContactModel *cm);
        
        virtual void                  setNonForcePropsFrom(IContactModel *) { };
        
        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 UInt                   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

#pragma warning(pop)

// EoF