conmodel.h

Go to the documentation of this file.

#pragma once

#include "conmodelbase.h"
#include "state.h"
#include "convert.h"
#include <vector>
#include <iostream>

namespace models {

    struct State;


    class CONMODEL_EXPORT ConstitutiveModel {
    public:
        virtual String             getName() const=0; 
        virtual String             getPluginName() const { return getName(); }
        virtual String             getFullName() const=0; 
        virtual bool               isNull() const { return false; }
        virtual bool               isModelAdvanced() const { return false; }
        virtual bool               isCreep() const { return false; }
        virtual bool               isLiquefaction() const { return false; }
        virtual UInt               getMinorVersion() const; 
        virtual String             getProperties() const=0; // comma delimited
        virtual String             getStates() const=0;
        virtual Variant            getProperty(UInt index) const=0; 
        virtual void               setProperty(UInt i,const Variant &val,UInt restoreVersion=0) { i;  val;  restoreVersion; setValid(0); }
        virtual bool               isPropertyReadOnly(UInt i) const { i;  return false; }
        virtual bool               isPropertyAdvanced(UInt i) const { i;  return false; }
        virtual void               save(std::ostream &o) const;
        virtual void               restore(std::istream &i,UInt restoreVersion);
        virtual ConstitutiveModel *clone() const=0;
        virtual Double             getConfinedModulus() const=0;
        virtual Double             getShearModulus() const=0;
        virtual Double             getBulkModulus() const=0;
        virtual void               copy(const ConstitutiveModel *mod);
        virtual bool               performMixing() const { return false; }
        virtual void               mixStrain(UByte d,State *s,SymTensor *strains,double *volumes) { d; s; strains; volumes; }
        virtual void               run(UByte d,State *s) { if (!isValid(d)) initialize(d,s); }
        virtual void               mixStress(UByte d,State *s,SymTensor *stresses,double *volumes) { d; s; stresses; volumes; }
        virtual void               initialize(UByte d,State *s) { s; setValid(d); }
        virtual Double             getStressStrengthRatio(const SymTensor &) const { return 10.0; }
        virtual void               scaleProperties(const Double &f,const std::vector<UInt> &v) { f; v; throw std::logic_error("Does not support property scaling"); }
        virtual bool               supportsHystereticDamping() const { return false; }
        virtual bool               supportsStressStrengthRatio() const { return false; }
        virtual bool               supportsPropertyScaling() const { return false; }
        virtual bool               supportsSmallStrainEffect() const { return false; }
        virtual void               destroy() { delete this; }

        ConstitutiveModel(unsigned short option=0);
        virtual ~ConstitutiveModel();
        static UInt getLibraryMinorVersion();
        bool isValid(UByte d) const { return valid_==d; }
        void setValid(UByte d) { valid_ = 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);
        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_); }
#endif

    private:
        static NewFunction    newFunc_;
        static DeleteFunction deleteFunc_;
        Byte           valid_ = 0;
        bool           canFail_ = true;
        unsigned short option_ = 0;

    protected:
        // ensure the same bits for all models
        static const unsigned long shear_now          = 0x001;
        static const unsigned long tension_now        = 0x002;
        static const unsigned long shear_past         = 0x004;
        static const unsigned long tension_past       = 0x008;
        static const unsigned long joint_shear_now    = 0x010;
        static const unsigned long joint_tension_now  = 0x020;
        static const unsigned long joint_shear_past   = 0x040;
        static const unsigned long joint_tension_past = 0x080;
        static const unsigned long volume_now         = 0x100;
        static const unsigned long 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)
        //
        static double cos3t(const double& n11, const double& n22, const double& n33,
                            const double& n12, const double& n31, const double& n23, double *tensornorm=0);
        static double gfunc(const double &c, const double &cos3t, const double &expn=-0.25, double *B=0, double *C=0);
    };

#  define C_M ConstitutiveModel
} // namespace models

// EoF