SymmElasticityTensor.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "SymmTensor.h"
 
#include "MaterialProperty.h"
 
#include "libmesh/vector_value.h"
 
#include <vector>
 
class SymmElasticityTensor
{
public:
  SymmElasticityTensor(const bool constant = false);
 
  void constant(bool c) { _constant = c; }
 
  virtual ~SymmElasticityTensor() {}
 
  void copyValues(SymmElasticityTensor & rhs) const
  {
    for (unsigned i(0); i < 21; ++i)
    {
      rhs._val[i] = _val[i];
    }
  }
 
  void calculate(unsigned int qp);
 
  virtual void multiply(const SymmTensor & x, SymmTensor & b) const;
  SymmTensor operator*(const SymmTensor & x) const;
  SymmElasticityTensor operator*(Real x) const;
 
  virtual Real stiffness(const unsigned int i,
                         const unsigned int j,
                         const RealGradient & test,
                         const RealGradient & phi) const;
 
  SymmElasticityTensor operator+(const SymmElasticityTensor & rhs) const
  {
    SymmElasticityTensor t = *this;
 
    t += rhs;
 
    return t;
  }
 
  void operator+=(const SymmElasticityTensor & rhs)
  {
    for (unsigned i(0); i < 21; ++i)
    {
      _val[i] += rhs._val[i];
    }
  }
 
  void operator-=(const SymmElasticityTensor & rhs)
  {
    for (unsigned i(0); i < 21; ++i)
    {
      _val[i] -= rhs._val[i];
    }
  }
 
  void operator*=(Real rhs)
  {
    for (unsigned i(0); i < 21; ++i)
    {
      _val[i] *= rhs;
    }
  }
 
  void operator/=(Real rhs)
  {
    for (unsigned i(0); i < 21; ++i)
    {
      _val[i] /= rhs;
    }
  }
 
  void zero()
  {
    for (unsigned i(0); i < 21; ++i)
    {
      _val[i] = 0;
    }
  }
 
  void convertFrom9x9(const ColumnMajorMatrix & cmm);
  void convertFrom6x6(const ColumnMajorMatrix & cmm);
 
  ColumnMajorMatrix columnMajorMatrix9x9() const;
  ColumnMajorMatrix columnMajorMatrix6x6() const;
 
  void form9x9Rotation(const ColumnMajorMatrix & R_3x3, ColumnMajorMatrix & R_9x9) const;
  void rotateFromGlobalToLocal(const ColumnMajorMatrix & R);
  void rotateFromLocalToGlobal(const ColumnMajorMatrix & R);
 
  virtual void adjustForCracking(const RealVectorValue & crack_flags);
  virtual void adjustForCrackingWithShearRetention(const RealVectorValue & crack_flags);
 
  virtual SymmElasticityTensor calculateDerivative(unsigned int qp, unsigned int i);
 
  friend std::ostream & operator<<(std::ostream & stream, const SymmElasticityTensor & obj);
 
  void fillFromInputVector(std::vector<Real> input, bool all);
 
  Real sum_3x3() const;
  RealGradient sum_3x1() const;
 
  /*
   * @return the value of the tensor given the index supplied.
   */
  Real valueAtIndex(int i) const;
 
protected:
  bool _constant;
 
  bool _values_computed;
 
  virtual void calculateEntries(unsigned int qp);
 
  Real _val[21]; // 6 in first row (column)
                 // 5 in second
                 // 4 in third
                 // 3 in fourth
                 // 2 in fifth
                 // 1 in sixth
 
  template <class T>
  friend void dataStore(std::ostream &, T &, void *);
 
  template <class T>
  friend void dataLoad(std::istream &, T &, void *);
};
 
template <>
void dataStore(std::ostream &, SymmElasticityTensor &, void *);
 
template <>
void dataLoad(std::istream &, SymmElasticityTensor &, void *);