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 uint32             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();
        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;
 
#ifndef DOXYGEN
        // 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);
        using NewFunction = void *(*)(size_t, const char *, const char *, unsigned);
        using DeleteFunction = void (*)(void *, const char *, const char *, unsigned);
        typedef std::pair<NewFunction,DeleteFunction> MemoryAllocationFunctions;
        static MemoryAllocationFunctions setMemoryAllocationFunctions(MemoryAllocationFunctions afunc);
        static MemoryAllocationFunctions getDefaultMemoryAllocationFunctions();
        static MemoryAllocationFunctions getMemoryAllocationFunctions() { return MemoryAllocationFunctions(newFunc_,deleteFunc_); }
#endif
 
        bool isD0(const double& a) const { return std::abs(a) <= limits<double>::epsilon(); }
 
    private:
 
        static NewFunction    newFunc_;
        static DeleteFunction deleteFunc_;
 
        int8   valid_ = 0;
        bool   canFail_ = true;
        uint16 option_ = 0;
 
    public:
        // ensure the same bits for all models
        static const uint32 shear_now          = 0x001;
        static const uint32 tension_now        = 0x002;
        static const uint32 shear_past         = 0x004;
        static const uint32 tension_past       = 0x008;
        static const uint32 joint_shear_now    = 0x010;
        static const uint32 joint_tension_now  = 0x020;
        static const uint32 joint_shear_past   = 0x040;
        static const uint32 joint_tension_past = 0x080;
        static const uint32 volume_now         = 0x100;
        static const 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)
    };
 
#  define C_M ConstitutiveModel
} // namespace models
 
// EoF