homogenization.h

Go to the documentation of this file.

//********************************************************************************************************
// code:                          ###  ###  #####   ####  ##  ##
//                       ##  ##   ########  ##     ##  ## ##  ##
//                       ##  ##   ## ## ##  ###    ##     ######
//                       ##  ##   ##    ##  ##     ##  ## ##  ##
//                       #####    ##    ##  #####   ####  ##  ##
//                       ##
// name:           homogenization.h
// author(s):      Jan Vorel, Ladislav Svoboda
// 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_HOMOGENIZATION_H
#define MUMECH_HOMOGENIZATION_H

#include "gelib.h"
#include "inclusion.h"


namespace mumech {

enum ProblemType { PT_Void, PT_1D, PT_2D, PT_3D };

class Problem;
class Mesh;

class Homogenization
{
 protected:
  long id;                
  Problem *P;             
  double volume;          
  double bb1[3];          
  double bb2[3];          
  bool *inside;           

 public:
  Homogenization (long i, Problem *p);
  virtual ~Homogenization ();
  
  virtual void giveHomogenizedStiffnessMatrix( double* answer ) = 0;
  virtual const char *giveClassName() { return "Homogenization"; }
  virtual const HomogenizationType giveClassID() { return HT_Void; }
  
  void set_boundingBox (double x1, double y1, double x2, double y2);
  void set_boundingBox (double x1, double y1, double z1, double x2, double y2, double z2);
  void set_boundingBox (const double *p1, const double *p2);

  const double* give_bb1 (void) const { return bb1; }
  const double* give_bb2 (void) const { return bb2; }

  double giveTotalVolumeFractionOfInclusions (void) const;

  void find_inclusions_in_BB (void);


 protected:
  Problem* giveProblem() { return P; }
  
  // /**   @name Functions to approach Problem Properties   **/
  // @{
  int giveNumberOfInclusions() const;
  ProblemType giveProblemType() const;
  int giveSizeOfSymVector();
  int giveSizeOfReducedMatrix();
  int giveSizeOfFullMatrix();
  double giveTotalVolume() const;
  // @}

  // /**   @name Functions to approach Inclusion Properties   **/
  // @{
  void giveFullEshelbyMatrixOfInclusion( double** answer, const long inclusionNumber );
  void giveReducedEshelbyMatrixOfInclusion( double* answer, const long inclusionNumber );
  void giveFullStiffnessMatrixOfInclusion( double* answer, const long inclusionNumber );
  void giveReducedStiffnessMatrixOfInclusion( double* answer, const long inclusionNumber );
  double giveVolumeFractionOfInclusion( const long inclusionNumber );
  void giveTransformationMatrixStressStrainG2L( double* answer, const long inclusionNumber );
  void giveTransformationMatrixStressStrainL2G( double* answer, const long inclusionNumber );
  void giveFullMatrixInGCSFromFullMatrixInLCS(double* answer, double* ALoc, const long inclusionNumber );
  void giveFullMatrixInLCSFromFullMatrixInGCS(double* answer, double* AGlob, const long inclusionNumber );
  void giveFullMatrixInGCSFromReducedMatrixInLCS( double* answer, double* ALoc, const long inclusionNumber );
  // @}
  
  // /**   @name General Functions   **/
  // @{
  void giveInverseOfReducedMatrix( double* answer, const double* rM, ProblemType pT );
  void giveReducedUnitMatrix( double* answer, ProblemType pT );
  void giveFullUnitMatrix( double* answer, ProblemType pT );
  void giveProductOfReducedMatrices( double* answer, double* A, double* B, ProblemType pT );
  void giveFullMatrixFromReducedMatrix( double* answer, const double* A, ProblemType pT );
  void giveProductOfRegularMatrixReducedMatrix( double* answer, double* A, double* redB , int n, ProblemType pT );
  void giveProductOfReducedMatrixRegularMatrix( double* answer, double* redA, double* B, ProblemType pT, int n );
  // @}
  
};

} // end of namespace mumech

#endif

/*end of file*/