applications/solvers/solidMechanics/deprecatedSolvers/materialModels/fvPatchFields/cohesiveLaw/cohesiveLawFvPatchVectorField.C

   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 Description
  25
  26 \*---------------------------------------------------------------------------*/
  27
  28 #include "cohesiveLawFvPatchVectorField.H"
  29 #include "addToRunTimeSelectionTable.H"
  30 #include "volFields.H"
  31 #include "rheologyModel.H"
  32
  33 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  34
  35 namespace Foam
  36 {
  37
  38 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  39
  40 cohesiveLawFvPatchVectorField::cohesiveLawFvPatchVectorField
  41 (
  42     const fvPatch& p,
  43     const DimensionedField<vector, volMesh>& iF
  44 )
  45 :
  46     fixedGradientFvPatchVectorField(p, iF),
  47     cohesiveLawPtr_(NULL),
  48     relaxationFactor_(1.0),
  49     traction_(p.size(), vector::zero)
  50 {}
  51
  52
  53 cohesiveLawFvPatchVectorField::cohesiveLawFvPatchVectorField
  54 (
  55     const fvPatch& p,
  56     const DimensionedField<vector, volMesh>& iF,
  57     const dictionary& dict
  58 )
  59 :
  60     fixedGradientFvPatchVectorField(p, iF),
  61     cohesiveLawPtr_
  62     (
  63         cohesiveLaw::New(dict.lookup("cohesiveLaw"), dict).ptr()
  64     ),
  65     relaxationFactor_(readScalar(dict.lookup("relaxationFactor"))),
  66     traction_(p.size(), vector::zero)
  67 {
  68     fvPatchVectorField::operator=(patchInternalField());
  69     gradient() = vector::zero;
  70 }
  71
  72
  73 cohesiveLawFvPatchVectorField::cohesiveLawFvPatchVectorField
  74 (
  75     const cohesiveLawFvPatchVectorField& cpf
  76 )
  77 :
  78     fixedGradientFvPatchVectorField(cpf),
  79     cohesiveLawPtr_(cpf.cohesiveLawPtr_->clone().ptr()),
  80     relaxationFactor_(cpf.relaxationFactor_),
  81     traction_(cpf.traction_)
  82 {}
  83
  84
  85 cohesiveLawFvPatchVectorField::cohesiveLawFvPatchVectorField
  86 (
  87     const cohesiveLawFvPatchVectorField& cpf,
  88     const fvPatch& p,
  89     const DimensionedField<vector, volMesh>& iF,
  90     const fvPatchFieldMapper& mapper
  91 )
  92 :
  93     fixedGradientFvPatchVectorField(cpf, p, iF, mapper),
  94     cohesiveLawPtr_(cpf.cohesiveLawPtr_->clone().ptr()),
  95     relaxationFactor_(cpf.relaxationFactor_),
  96     traction_(cpf.traction_, mapper)
  97 {}
  98
  99
 100 cohesiveLawFvPatchVectorField::cohesiveLawFvPatchVectorField
 101 (
 102     const cohesiveLawFvPatchVectorField& cpf,
 103     const DimensionedField<vector, volMesh>& iF
 104 )
 105 :
 106     fixedGradientFvPatchVectorField(cpf, iF),
 107     cohesiveLawPtr_(cpf.cohesiveLawPtr_->clone().ptr()),
 108     relaxationFactor_(cpf.relaxationFactor_),
 109     traction_(cpf.traction_)
 110 {}
 111
 112
 113 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 114
 115 const cohesiveLaw& cohesiveLawFvPatchVectorField::law() const
 116 {
 117     if (!cohesiveLawPtr_)
 118     {
 119         FatalErrorIn
 120         (
 121             "const cohesiveLaw& cohesiveLawFvPatchVectorField::law() const"
 122         )   << "Law pointer not set" << abort(FatalError);
 123     }
 124
 125     return *cohesiveLawPtr_;
 126 }
 127
 128
 129 void cohesiveLawFvPatchVectorField::autoMap
 130 (
 131     const fvPatchFieldMapper& m
 132 )
 133 {
 134     if (cohesiveLawPtr_ == NULL)
 135     {
 136         FatalErrorIn("cohesiveFvPatchVectorField::autoMap")
 137             << "NULL cohesive law"
 138             << abort(FatalError);
 139     }
 140
 141     fixedGradientFvPatchVectorField::autoMap(m);
 142
 143     traction_.autoMap(m);
 144 }
 145
 146
 147 // Reverse-map the given fvPatchField onto this fvPatchField
 148 void cohesiveLawFvPatchVectorField::rmap
 149 (
 150     const fvPatchVectorField& ptf,
 151     const labelList& addr
 152 )
 153 {
 154     fixedGradientFvPatchVectorField::rmap(ptf, addr);
 155
 156     const cohesiveLawFvPatchVectorField& dmptf =
 157         refCast<const cohesiveLawFvPatchVectorField>(ptf);
 158
 159     // No need to grab the cohesive zone pointer more than once
 160     if (!cohesiveLawPtr_)
 161     {
 162         cohesiveLawPtr_ = dmptf.cohesiveLawPtr_->clone().ptr();
 163
 164         relaxationFactor_ = dmptf.relaxationFactor_;
 165     }
 166
 167     traction_.rmap(dmptf.traction_, addr);
 168 }
 169
 170
 171 // Update the coefficients associated with the patch field
 172 void cohesiveLawFvPatchVectorField::updateCoeffs()
 173 {
 174     if (updated())
 175     {
 176         return;
 177     }
 178
 179     // Looking up rheology
 180
 181     const fvPatchField<scalar>& mu =
 182         patch().lookupPatchField<volScalarField, scalar>("mu");
 183
 184     const fvPatchField<scalar>& lambda =
 185       patch().lookupPatchField<volScalarField, scalar>("lambda");
 186
 187     vectorField n = patch().nf();
 188
 189     const fvPatchField<tensor>& gradU =
 190         patch().lookupPatchField<volTensorField, tensor>("grad(U)");
 191
 192     // Patch displacement
 193     const vectorField& U = *this;
 194
 195     // Patch stress
 196     tensorField sigma = mu*(gradU + gradU.T()) + I*(lambda*tr(gradU));
 197
 198     // Normal stress component
 199     scalarField sigmaN = (n & (n & sigma));
 200
 201     scalarField delta = -(n & U);
 202
 203     label sizeByTwo = patch().size()/2;
 204
 205     for(label i = 0; i < sizeByTwo; i++)
 206     {
 207         scalar tmp = delta[i];
 208         delta[i] += delta[sizeByTwo + i];
 209         delta[sizeByTwo + i] += tmp;
 210     }
 211
 212     forAll (traction_, faceI)
 213     {
 214         if (delta[faceI] < 0)
 215         {
 216             // Return from traction to symmetryPlane??
 217             traction_[faceI] = law().sigmaMax().value()*n[faceI];
 218         }
 219         else if(delta[faceI] > law().deltaC().value())
 220         {
 221             // Traction free
 222             traction_[faceI] = vector::zero;
 223         }
 224         else
 225         {
 226             // Calculate cohesive traction from cohesive zone model
 227             traction_[faceI] = law().traction(delta[faceI])*n[faceI];
 228         }
 229     }
 230
 231     gradient() =
 232     (
 233         traction_
 234       - (n & (mu*gradU.T() - (mu + lambda)*gradU))
 235       - n*lambda*tr(gradU)
 236     )/(2.0*mu + lambda);
 237
 238     fixedGradientFvPatchVectorField::updateCoeffs();
 239 }
 240
 241
 242 // Write
 243 void cohesiveLawFvPatchVectorField::write(Ostream& os) const
 244 {
 245     fvPatchVectorField::write(os);
 246     traction_.writeEntry("traction", os);
 247     os.writeKeyword("cohesiveLaw") << law().type()
 248         << token::END_STATEMENT << nl;
 249     os.writeKeyword("relaxationFactor") << relaxationFactor_
 250         << token::END_STATEMENT << nl;
 251     law().writeDict(os);
 252     writeEntry("value", os);
 253 }
 254
 255
 256 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 257
 258 makePatchTypeField(fvPatchVectorField, cohesiveLawFvPatchVectorField);
 259
 260 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 261
 262 } // End namespace Foam
 263
 264 // ************************************************************************* //