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    */
    
    // Enumerator for the model information system
    enum InfoTypes {ScalarInfo=1,TextInfo,VectorInfo};
 
    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 ContactModelState {…};
 
    class CONTACTMODEL_EXPORT ContactModel : public IContactModel
    {
    public:
        ContactModel();
 
        virtual ~ContactModel();
 
        virtual ContactModel *clone() const  { throw Exception("Not at this level"); }
 
        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 { throw Exception("Not at this level"); }
 
        virtual QString               getPluginName() const { return getName(); }
 
        QString               getProperties() const override  { throw Exception("Not at this level"); } // comma delimited
 
        QVariant              getProperty([[maybe_unused]]uint i,[[maybe_unused]]const IContact *con=0) const override  { throw Exception("Not at this level"); }
 
        bool                  getPropertyGlobal(uint ) const override {return true;}
 
        int                   isProperty(const QString &c,Qt::CaseSensitivity cs=Qt::CaseInsensitive) const override;
 
        bool                  setProperty([[maybe_unused]]uint i,[[maybe_unused]]const QVariant &v,[[maybe_unused]]IContact *con=0) override  { throw Exception("Not at this level"); }
 
        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  { throw Exception("Not at this level"); }
        void                  destroy() override { delete this; }
 
        void getSphereList(const IContact *,std::vector<DVect> *,std::vector<double> *,std::vector<double> *) override  { throw Exception("Not at this level"); }
#ifdef THREED
        void getDiskList(const IContact *,std::vector<DVect> *,std::vector<DVect> *,std::vector<double> *,std::vector<double> *) override  { throw Exception("Not at this level"); }
#endif
        void getCylinderList(const IContact *,std::vector<DVect> *,std::vector<DVect> *,std::vector<double> *,std::vector<double> *,std::vector<double> *) override  { throw Exception("Not at this level"); }
 
        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 *file,unsigned line);
        void  operator delete(void *v);
        void  operator delete(void *v,const char *file,unsigned line);
        typedef void *(*NewFunction)(size_t,const char *,unsigned);
        typedef void (*DeleteFunction)(void *,const char *,unsigned);
        typedef std::pair<NewFunction,DeleteFunction> AllocFunctions;
        static AllocFunctions setAllocFunctions(AllocFunctions afunc);
        static AllocFunctions getDefaultAllocFunctions();
        static AllocFunctions getAllocFunctions() { return AllocFunctions(newFunc_,deleteFunc_); }
        
        // Used to efficiently get properties from the contact model for the object pane.
        // List of properties for the object pane, comma separated.
        // All properties will be cast to doubles for comparison. No other comparisons
        // are supported. This may not be the same as the entire property list.
        // Return property name and type for plotting.
        virtual void objectPropsTypes(std::vector<std::pair<QString,InfoTypes>> *) const { }
        // All properties cast to doubles - this is what can be compared. 
        virtual void objectPropValues(std::vector<double> *,const IContact *) const { }
 
    protected:
        static NewFunction    newFunc_;
        static DeleteFunction deleteFunc_;
 
        FArray<int,5>         cmEvents_;  
    };
    class CONTACTMODEL_EXPORT ContactModel : public IContactModel {…};
} // namespace cmodelsxd
 
#ifndef __GNUC__
#pragma warning(pop)
#endif
 
// EoF