conmodel.h

Go to the documentation of this file.

#pragma once
 
#include "conmodelbase.h"
#include "state.h"
#include "base/src/property.h"
#include <vector>
#include <iostream>
#include "shared/src/vector.h"
 
namespace models {
 
    struct State;
 
 
    class CONMODEL_EXPORT ConstitutiveModel {
    public:
        virtual string             getName() const { throw std::runtime_error("Base method called."); }
        virtual string             getPluginName() const { return getName(); }
        virtual string             getFullName() const { throw std::runtime_error("Base method called."); }
        virtual bool               isNull() const { return false; }
        virtual bool               isModelAdvanced() const { return false; }
        virtual bool               isKGEv() const { return false; }
        virtual bool               isOriented() const { return false; }
        virtual bool isCreep() const { return false; }
        virtual bool isLiquefaction() const { return false; }
        virtual unsigned           getMinorVersion() const;
        virtual string             getProperties() const { throw std::runtime_error("Base method called."); } // comma delimited
        virtual string             getStates() const { throw std::runtime_error("Base method called."); }
        virtual base::Property     getProperty(uint32) const { throw std::runtime_error("Base method called."); } 
        virtual void               setProperty(uint32,const base::Property &,uint32=0) { setValid(0); }
        virtual bool               isPropertyReadOnly(uint32) const { return false; }
        virtual bool               isPropertyAdvanced(uint32) const { return false; }
        virtual void               save(std::ostream &o) const;
        virtual void               restore(std::istream &i,uint32 restoreVersion);
        virtual ConstitutiveModel *clone() const { throw std::runtime_error("Base method called."); }
        virtual double             getConfinedModulus() const { throw std::runtime_error("Base method called."); }
        virtual double             getShearModulus() const { throw std::runtime_error("Base method called."); }
        virtual double             getBulkModulus() const { throw std::runtime_error("Base method called."); }
        virtual void               copy(const ConstitutiveModel *mod);
        virtual bool               performMixing() const { return false; }
        virtual void               mixStrain(uint32,State *,SymTensor *,double *) { }
        virtual void               run(uint32 d,State *s) { if (!isValid(d)) initialize(d,s); }
        virtual void               mixStress(uint32,State *,SymTensor *,double *) {  }
        virtual void               initialize(uint32 d,State *) { setValid(d); }
        virtual double             getStrengthStressRatio(const SymTensor &) const { return 10.0; }
        virtual void               scaleProperties(const double &,const std::vector<uint32> &) { throw std::logic_error("Does not support property scaling"); }
        virtual bool               supportsHystereticDamping() const { return false; }
        virtual bool               supportsStrengthStressRatio() const { return false; }
        virtual bool               supportsPropertyScaling() const { return false; }
        virtual bool               supportsSmallStrainEffect() const { return false; }
        virtual bool               supportsPlaneStress() const { return false; }
        virtual bool               supportsUniaxial() const { return false; }
        virtual void               destroy() { delete this; }
 
        ConstitutiveModel(unsigned short option=0);
        ConstitutiveModel(const ConstitutiveModel &) noexcept;
        const ConstitutiveModel & operator=(const ConstitutiveModel &);
        virtual ~ConstitutiveModel();
 
        void* operator new(size_t size, const char* file, unsigned line);
        void* operator new(size_t size);
        void  operator delete(void* v);
 
        virtual bool               supportsPlasticStrain() const { return false; }
        virtual void getPropertyValues(std::vector<double>*) const {};
        virtual void addToStorage(poly::vector<ConstitutiveModel>*, int = -1) {
            throw std::runtime_error("Base method called.");
        }
        static uint32 getLibraryMinorVersion();
        bool isValid(uint32 d) const { return valid_==to<int8>(d); }
        void setValid(uint32 d) { valid_ = to<int8>(d); }
        bool canFail() const { return canFail_; }
        void setIfCanFail(bool b) { canFail_ = b; }
        std::vector<unsigned short> gEOB() const;
        void                        sEOB(const std::vector<unsigned short> &reply);
        bool                        cEOB() const;
        static void *(* conModelMemoryAlloc)(size_t s);
        static void *(* conModelMemoryAllocDebug)(size_t s,const char *file,uint32 line);
        static void (* conModelMemoryFree)(void *v);
 
        bool isD0(const double& a) const { return std::abs(a) < limits<double>::epsilon(); }
 
    private:
        int8   valid_ = 0;
        bool   canFail_ = true;
        uint16 option_ = 0;
 
    public:
        // ensure the same bits for all models
        static constexpr uint32 shear_now          = 0x001;
        static constexpr uint32 tension_now        = 0x002;
        static constexpr uint32 shear_past         = 0x004;
        static constexpr uint32 tension_past       = 0x008;
        static constexpr uint32 joint_shear_now    = 0x010;
        static constexpr uint32 joint_tension_now  = 0x020;
        static constexpr uint32 joint_shear_past   = 0x040;
        static constexpr uint32 joint_tension_past = 0x080;
        static constexpr uint32 volume_now         = 0x100;
        static constexpr uint32 volume_past        = 0x200;
        // shared frequently used constants
        static constexpr double pi = 3.14159265358979323846264338327950;
        static constexpr double degrad = 0.01745329251994329576923690768488;
        static constexpr double d1d3 = 0.33333333333333333333333333333333;
        static constexpr double d2d3 = 0.66666666666666666666666666666667;
        static constexpr double d4d3 = 1.33333333333333333333333333333333;
        static constexpr double rt6 = 2.44948974278317809819728407470589; // sqrt(6.0)
    };
 
    using CM = ConstitutiveModel;
} // namespace models
 
// EoF