contactmodelmechanical.h

Go to the documentation of this file.

#pragma once
// contactmodelmechanical.h
#include "contactmodel.h"
#include "contactmodel/interface/icontactmodelmechanical.h"
#include "shared/src/vector.h"
 
#ifndef __GNUC__
#pragma warning(push)
#pragma warning(disable : 4251)
#endif
 
namespace itascaxd {
    class IContactMechanical;
    class IContactThermal;
    class IContactFluid;
} // namespace itascaxd
 
namespace cmodelsxd {
    using namespace itasca;
    using namespace itascaxd;
 
    class ContactModelThermalState;
    class ContactModelFluidState;
    class ContactModelMechanicalState : public ContactModelState {
      public:
        ContactModelMechanicalState() {}
        ~ContactModelMechanicalState() override{};
        virtual const IContactMechanical* getMechanicalContact() const = 0;
        virtual const IContact* getContact() const = 0;
        
        DVect relativeTranslationalIncrement_ = DVect(0.0);     
        CAxes  axes_;                                           
        DAVect relativeAngularIncrement_ =      DAVect(0.0);    
        DVect2 end1Curvature_ =                 DVect2(0.0);    
        DVect2 end2Curvature_ =                 DVect2(0.0);    
        double inertialMass_ =                  0.0;            
        double gap_ =                           0.0;            
        double maxConvergence_ =                0.0;            
        double end1Volume_ =                    0.0;            
        double end2Volume_ =                    0.0;            
#ifdef THREED
        std::array<double,6> end1Stress_ = {0,0,0,0,0,0};       
        std::array<double,6> end2Stress_ = {0,0,0,0,0,0};       
#else
        std::array<double,3> end1Stress_ = {0,0,0};             
        std::array<double,3> end2Stress_ = {0,0,0};             
#endif        
        bool canFail_ =                         true;           
    };
    class ContactModelMechanicalState : public ContactModelState {…};
 
    class CONTACTMODEL_EXPORT ContactModelMechanical : public ContactModel,
                                                       public IContactModelMechanical {
      public:
        ContactModelMechanical();
 
        ~ContactModelMechanical() override;
        
        int      getIndex() const override { throw Exception("Not at this level"); };
        void     setIndex(int) override { throw Exception("Not at this level");};
        double   getActivityDistance() const override { throw Exception("Not at this level");};
        void     resetForcesAndMoments() override { throw Exception("Not at this level");};
        void     setForce(const DVect &,IContact *) override {throw Exception("Not at this level");};
        void     setArea(const double &) override {throw Exception("Not at this level");};
        double   getArea() const override {throw Exception("Not at this level");};
            
 
        static const char* getPluginPrefix() { return "contactmodelmechanical"; }
 
        static const char* getPluginDirectory() { return "contactmodels/mechanical"; }
 
        //  IContactModel overrides
 
        bool isOKToDelete() const override { return true; }
 
        // IContactModelMechanical functions.
 
        ContactModel* getContactModel() override { return this; }
 
        const ContactModel* getContactModel() const override { return this; }
 
        virtual bool checkActivity(const double&) { return false; }
 
        bool isSliding() const override { return false; }
 
        bool isBonded() const override { return false; }
 
        void unbond() override {}
 
        bool hasNormal() const override { return false; };
 
        DVect3 getNormal() const override { return DVect3(0.0); }
 
        void setPorePressure(const double&) override {
            throw Exception("The contact model does not support pore pressures.");
        }
        void setPorePressure(const double&) override  {…}
 
        void propagateStateInformation(IContactModelMechanical*,
            [[maybe_unused]] const CAxes& n = CAxes(),
            [[maybe_unused]] const CAxes& l = CAxes()) override {}
        void propagateStateInformation(IContactModelMechanical*, {…}
 
        virtual bool endPropertyUpdated(const QString& name, const IContactMechanical* c) = 0;
 
        virtual bool validate(ContactModelMechanicalState* state, const double& timestep) = 0;
 
        virtual bool forceDisplacementLaw(
            ContactModelMechanicalState* state, const double& timestep) = 0;
 
        virtual bool thermalCoupling(ContactModelMechanicalState*, ContactModelThermalState*,
            IContactThermal*, const double&) {
            return false;
        }
        virtual bool thermalCoupling(ContactModelMechanicalState*, ContactModelThermalState*, {…}
 
        virtual DVect2 getTimestepLimits(ContactModelMechanicalState*, const double&) const {
            return DVect2(0.0, limits<double>::max());
        }
        virtual DVect2 getTimestepLimits(ContactModelMechanicalState*, const double&) const  {…}
 
        virtual DVect2 getEffectiveTranslationalStiffness() const { return DVect2(0.0, 0.0); }
 
        virtual DAVect getEffectiveRotationalStiffness() const { return DAVect(0.0); }
 
        void getSphereList(const IContact*, std::vector<DVect>*, std::vector<double>*,
            std::vector<double>*) override {}
        void getSphereList(const IContact*, std::vector<DVect>*, std::vector<double>*, {…}
#ifdef THREED
 
        void getDiskList(const IContact*, std::vector<DVect>*, std::vector<DVect>*,
            std::vector<double>*, std::vector<double>*) override {}
#endif
 
        void getCylinderList(const IContact*, std::vector<DVect>*, std::vector<DVect>*,
            std::vector<double>*, std::vector<double>*, std::vector<double>*) override {}
        void getCylinderList(const IContact*, std::vector<DVect>*, std::vector<DVect>*, {…}
 
        virtual DVect getForce() const { return DVect(0.0); }
 
        virtual DAVect getMomentOn1(const IContactMechanical*) const { return DAVect(0.0); }
 
        virtual DAVect getMomentOn2(const IContactMechanical*) const { return DAVect(0.0); }
        
        virtual DAVect getModelMomentOn1() const { return DAVect(0.0); }
        
        virtual DAVect getModelMomentOn2() const { return DAVect(0.0); }
 
        ContactModelMechanical *clone() const override { throw Exception("Must be reimplemented."); }
        
        ContactModelMechanical(const ContactModelMechanical &) noexcept { }
        const ContactModelMechanical & operator=(const ContactModelMechanical &) { return *this; }
        virtual void addToStorage(poly::vector<ContactModelMechanical> *,int = -1) { throw std::runtime_error("Base method called."); }
        
    };
    class CONTACTMODEL_EXPORT ContactModelMechanical : public ContactModel, {…};
} // namespace cmodelsxd
 
#ifndef __GNUC__
#pragma warning(pop)
#endif
 
// EoF