esuf.h

Go to the documentation of this file.

//********************************************************************************************************
// code:                          ###  ###  #####   ####  ##  ##
//                       ##  ##   ########  ##     ##  ## ##  ##
//                       ##  ##   ## ## ##  ###    ##     ######
//                       ##  ##   ##    ##  ##     ##  ## ##  ##
//                       #####    ##    ##  #####   ####  ##  ##
//                       ##
//
// name:           eshelbySoluUniformField.h
// author(s):      Jan Novak
// language:       C, C++
// license:        This program is free software; you can redistribute it and/or modify
//                 it under the terms of the GNU Lesser General Public License as published by
//                 the Free Software Foundation; either version 2 of the License, or
//                 (at your option) any later version.
//
//                 This program is distributed in the hope that it will be useful,
//                 but WITHOUT ANY WARRANTY; without even the implied warranty of
//                 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//                 GNU Lesser General Public License for more details.
//
//                 You should have received a copy of the GNU Lesser General Public License
//                 along with this program; if not, write to the Free Software
//                 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//********************************************************************************************************
#ifndef MUMECH_ESHELBY_SOLU_UNIFORM_FIELD_H
#define MUMECH_ESHELBY_SOLU_UNIFORM_FIELD_H

#include "types.h"
#include "matrix.h"

namespace mumech {

class MatrixRecord;
class Inclusion;
class InclusionRecord3D;
class Problem;

class eshelbySoluUniformField
{
 protected:
  const InclusionRecord3D *I;
  
  double nu;       
  double _2nu;     
  double _1Plus2nu;
  double _1MinNu;  
  double mult;     
  double MULT;     
  double multTRN;  
  double _1Min2nu; 
  double _2nuMin1; 
  double _3Min4nu; 
  
 public:
  eshelbySoluUniformField (const InclusionRecord3D *i);
  virtual ~eshelbySoluUniformField () {}
  
  
  void giveEshelbyStrainOfOnePoint (Point *point);

  void giveEshelbyFieldsOfOnePoint (Point *point, int lc, int nlc, bool disp, bool strn);
  
  void giveEshelbyDisplacementOfOnePoint (double **globPert_displc, const double *coords, int lc, int nlc);
  
  void giveEshelbyTensor (double S[12], const double eInt[13]);
  
  virtual void giveEshelbyTensorInverse (double SInv[12], const double S[12]);

  virtual void  giveSijkl( double S[36], const double sort_a[3], const double stiffMat[36], int M_partition, int N_partition );
  
  
 protected:

  void giveEshelbyDisplacementUniformField (double displacement[3], const double pertDispTens[18],
                                            const double unifStrain[6]);

  void giveDisplacementPerturbTensor_EXTpoint (Point *point);
  
  void giveDisplacementPerturbTensor_INTpoint (double L[18], const double x[3]);
  
  void giveEshelbyStrainUniformField (double strain[6], const double pertTens[36],
                      const double unifStrain[6]);
  
  void giveStrainPerturbTensor (Point *point);
  
  //********************************************************************************************************
  // description: Function gives a component of the Eshelby tensor
  // last edit:   16. 10. 2009
  //-------------------------------------------------------------------------------------------------------
  // note:        Solution adopted from Toshio Mura's book (1982) and Eshelby article (1957)
  //              @sort_a[3] - sorted ellipsoidal semiaxes (a1>a2>a3)
  //              @eSInt[13] - values of elliptical integrals (potentials)
  //                           always for lambda = 0. Even for external fields !!!
  //              @flag      - Eshelby tensor component S_ijkl
  //********************************************************************************************************
  virtual double eshelbyTensCompUniformField( const double sort_a[3], const double eSInt[13],
                                              double nu, EshelbyTensComponent flag );
  
  //********************************************************************************************************
  // description: Function initialize an 1D array by Eshelby tensor components
  // last edit:   15. 02. 2010
  //-------------------------------------------------------------------------------------------------------
  // note:        Solution adopted from Toshio Mura's book (1982) and Eshelby article  (1957)
  //              @eshTens - pointer to array of Eshelby tensor components S_ijkl
  //              @sort_a[3] - sorted ellipsoidal semiaxes (a1>a2>a3)
  //              @eInt[13] - values of elliptical integrals (potentials)
  //              @nu - Poisson's ratio
  //********************************************************************************************************
  virtual void eshelbyTensUniformField (double eshTens[12], const double sort_a[3], const double eInt[13]);

  //********************************************************************************************************
  // description: Function gives D_ijkl(x) generalized Eshelby's tensor.
  //              Function requiers "constructor2"
  //                D_ijkl is adjusted to mandel notation. The resulting D tensor thus differs from the values in Mura book.
  // last edit:   12. 07. 2010
  //-------------------------------------------------------------------------------------------------------
  // note:        @D[36]     - Perturbation (generalized Eshelby's) tensor to be evaluated and saved
  //              @S[12]     - Eshelby's tensor for internal fields (uniform fields)
  //              @J[13]     - Ferers-Dysons' elliptic integrals
  //              @dJi[9]    - first derivatives of Ferers-Dysons' elliptic integrals Ii
  //              @dJij[27]  - first derivatives of Ferers-Dysons' elliptic integrals Iij
  //              @ddJi[27]  - second derivatives of Ferers-Dysons' elliptic integrals Ii
  //              @ddJij[81] - second derivatives of Ferers-Dysons' elliptic integrals Ii
  //              @sort_a[3] - sorted semiaxes' dimensions
  //              @x[3]      - coordinates of a point
  //              @pos       - position of the pint (_INT_POINT_/_EXT_POINT_)
  //********************************************************************************************************
  virtual void giveDijkl ( double D[36], const double S[12], const double J[13], const double dJi[9],
                           const double dJij[27], const double ddJi[27], const double ddJij[81],
                                                    const double sort_a[3],  const double x[3]);
  
  //********************************************************************************************************
  // description: Function gives S_ijkl(x) position dependent Eshelby's tensor. (This is not
  //              the strain perturbation tensor! Just its part ). The returned members of the
  //              S_ijkl matrix are in tensorial (theoretical) notation!
  //              Function requiers "constructor2"
  // last edit:   12. 07. 2010
  //-------------------------------------------------------------------------------------------------------
  // note:        @S[36]     - Eshelby position dependent tensor
  //              @J[13]     - Ferers-Dysons' elliptic integrals
  //              @sort_a[3] - sorted semiaxes' dimensions
  //              @nu        - Poisson's ratio of the matrix material
  //********************************************************************************************************
  virtual void  giveSijkl( double S[36], const double J[13], const double sort_a[3],
               double nu, bool newFormulation );
  
  void giveLijkEXT (double Lext[18], const double Lint[18], const double dJi[9],
            const double dJij[27], const double sort_a[3], const double x[3]);
  
  void giveLijkINT (double Lint[18], const double J[13], const double sort_a[3], const double x[3]);
  
};//end of class declaration
 
} // end of namespace mumech

#endif

/*end of file*/