src/solidModels/constitutiveModel/constitutiveModel.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend is free software: you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation, either version 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     constitutiveModel
  26
  27 Description
  28     Class in charge of constitutive laws and mechanical properties
  29
  30 SourceFiles
  31     constitutiveModel.C
  32
  33 Author
  34     Philip Cardiff UCD
  35     philip.cardiff@gmail.com
  36
  37 \*---------------------------------------------------------------------------*/
  38
  39 #ifndef constitutiveModel_H
  40 #define constitutiveModel_H
  41
  42 #include "IOdictionary.H"
  43 #include "plasticityStressReturn.H"
  44 #include "typeInfo.H"
  45 #include "runTimeSelectionTables.H"
  46 #include "volFields.H"
  47 #include "tmp.H"
  48 #include "rheologyLaw.H"
  49 #include "cohesiveLaw.H"
  50 #include "Switch.H"
  51 #include "fvc.H"
  52 #include "IOReferencer.H"
  53
  54 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  55
  56 namespace Foam
  57 {
  58
  59 // forward declaration
  60 class solidInterface;
  61
  62 /*---------------------------------------------------------------------------*\
  63                         Class constitutiveModel Declaration
  64 \*---------------------------------------------------------------------------*/
  65
  66 class constitutiveModel
  67 :
  68   public IOdictionary
  69 {
  70     // Private data
  71
  72         //- Reference to stress field
  73         const volSymmTensorField& sigma_;
  74
  75         //- Rheology law
  76         autoPtr<rheologyLaw> rheologyLawPtr_;
  77
  78         //- Cohesive dictionary and law
  79         IOdictionary* cohesiveDictPtr_;
  80         autoPtr<cohesiveLaw> cohesiveLawPtr_;
  81
  82         //- Plane stress
  83         Switch planeStress_;
  84
  85         //- Run-time selectable solidInterface method for correct
  86         //  discretisation on bi-material interfaces
  87         IOReferencer<solidInterface>* solidInterfacePtr_;
  88
  89         // if solidInterface is on/off
  90         bool solidInterfaceActive_;
  91
  92         //- Run-time selectable method to calculate DEpsilonP
  93         //- eg radial return
  94         autoPtr<plasticityStressReturn> plasticityStressReturnPtr_;
  95
  96
  97 private:
  98
  99     // Private Member Functions
 100
 101         //- Disallow default bitwise copy construct
 102         constitutiveModel(const constitutiveModel&);
 103
 104         //- Disallow default bitwise assignment
 105         void operator=(const constitutiveModel&);
 106
 107
 108 public:
 109
 110     //- Runtime type information
 111     TypeName("constitutiveModel");
 112
 113
 114     // Constructors
 115
 116         //- Construct from components
 117         constitutiveModel
 118         (
 119             const volSymmTensorField& sigma,
 120             const volVectorField& U
 121         );
 122
 123
 124     // Destructor
 125
 126         virtual ~constitutiveModel();
 127
 128
 129     // Member Functions
 130
 131         // Access
 132
 133         //- If plasticity is active
 134         bool plasticityActive() const
 135         {
 136             if (plasticityStressReturnPtr_.valid())
 137             {
 138                 return plasticityStressReturnPtr_->plasticityActive();
 139             }
 140
 141             return false;
 142         }
 143
 144         //- If visco effects are active
 145         bool viscoActive() const
 146         {
 147             return rheologyLawPtr_->viscoActive();
 148         }
 149
 150         //- Return reference to stress field
 151         const volSymmTensorField& sigma() const
 152         {
 153             return sigma_;
 154         }
 155
 156         //- Return true for plane stress
 157         const Switch& planeStress() const
 158         {
 159             return planeStress_;
 160         }
 161
 162         //- Return rheology law
 163         const rheologyLaw& law() const
 164         {
 165             return rheologyLawPtr_();
 166         }
 167
 168         //- Return cohesive law
 169         const cohesiveLaw& cohLaw() const
 170         {
 171             return cohesiveLawPtr_();
 172         }
 173
 174         //- Return density
 175         tmp<volScalarField> rho() const
 176         {
 177             return rheologyLawPtr_->rho();
 178         }
 179
 180         tmp<volScalarField> rho(scalar t) const
 181         {
 182             return rheologyLawPtr_->rho(t);
 183         }
 184
 185         //- Return first Lame's coefficient
 186         tmp<volScalarField> mu() const;
 187         tmp<volScalarField> mu(scalar t) const;
 188         tmp<volScalarField> mu(const volScalarField& epsilonEq) const;
 189         tmp<surfaceScalarField> muf() const;
 190
 191         //- Return second Lame's coefficient
 192         tmp<volScalarField> lambda() const;
 193         tmp<volScalarField> lambda(scalar t) const;
 194         tmp<volScalarField> lambda(const volScalarField& epsilonEq) const;
 195         tmp<surfaceScalarField> lambdaf() const;
 196
 197         //- Return threeK
 198         tmp<volScalarField> threeK() const;
 199         tmp<surfaceScalarField> threeKf() const;
 200
 201         //- Return yield stress
 202         tmp<volScalarField> sigmaY() const
 203         {
 204             return rheologyLawPtr_->sigmaY();
 205         }
 206
 207         //- Return yield stress
 208         scalar sigmaY(const scalar epsilonPEq, const label cellID) const
 209         {
 210             return rheologyLawPtr_->sigmaY(epsilonPEq, cellID);
 211         }
 212
 213         //- Return plastic modulus
 214         tmp<volScalarField> Ep() const
 215         {
 216             return rheologyLawPtr_->Ep();
 217         }
 218         tmp<volScalarField> Ep(const volScalarField& epsilonEq) const
 219         {
 220             return rheologyLawPtr_->Ep(epsilonEq);
 221         }
 222
 223         //- Return plastic strain increment
 224         const volSymmTensorField& DEpsilonP() const;
 225
 226         //- orthotropic tensorial diffusivity
 227         //- Note: this is not the bulk modulus
 228         tmp<volDiagTensorField> K() const;
 229         tmp<surfaceDiagTensorField> Kf() const;
 230
 231         //- fourth order elastic stiffness tensor
 232         tmp<volSymmTensor4thOrderField> C() const;
 233         tmp<surfaceSymmTensor4thOrderField> Cf() const;
 234
 235         //- Correct plastic strain increment
 236         virtual void correct();
 237
 238         //- Return reference to solidInterface
 239         virtual const solidInterface& solInterface() const
 240         {
 241             return solidInterfacePtr_->operator()();
 242         }
 243
 244         //- Return access to solidInterface
 245         virtual solidInterface& solInterface()
 246         {
 247             return solidInterfacePtr_->operator()();
 248         }
 249
 250         //- Return true if solidInterface is active
 251         virtual bool solidInterfaceActive()
 252         {
 253             return solidInterfaceActive_;
 254         }
 255
 256         //- Update yield stress
 257         void updateYieldStress();
 258
 259         //- Read plasticityProperties dictionary
 260         virtual bool read();
 261 };
 262
 263 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 264
 265 } // End namespace Foam
 266
 267 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 268
 269 #endif
 270
 271 // ************************************************************************* //