homogenizationMethods.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_METHODS_H
#define MUMECH_HOMOGENIZATION_METHODS_H

//included libraries
#include "homogenization.h"


namespace mumech {


class Dilute : public Homogenization
{
 public:
  Dilute(long i, Problem *p) : Homogenization(i,p) {}
  virtual ~Dilute(){}
  
  virtual void giveHomogenizedStiffnessMatrix( double* answer );
  virtual const char *giveClassName() { return "Dilute"; }
  virtual const HomogenizationType giveClassID() { return HT_Dilute; }
  
 protected:
  void giveDiluteReducedConcentrationFactorOfInclusionInLC( double* answer, double* matrix_inclStiffmat,
                                                            double* matrixStiffMat, double* matrixComplMat, const long inclusionNumber );
  void giveFullDiluteConcentrationFactorOfInclusionInLC( double* answer, double* matrix_inclStiffmat,
                                                         double* matrixStiffMat, double* matrixComplMat, const long inclusionNumber );

  
}; // end of class Dilute


class MoriTanaka : public Dilute
{
 public:
  MoriTanaka(long i, Problem *p) : Dilute(i,p) {}
  virtual ~MoriTanaka(){}
  
  virtual void giveHomogenizedStiffnessMatrix( double* answer );
  virtual const char *giveClassName() { return "MoriTanaka"; }
  virtual const HomogenizationType giveClassID() { return HT_MoriTanaka; }
  
}; // end of class MoriTanaka


class ReussBound : public Homogenization
{
 public:
  ReussBound(long i, Problem *p) : Homogenization(i,p) {}
  virtual ~ReussBound(){}

  virtual void giveHomogenizedStiffnessMatrix( double* answer );
  virtual const char *giveClassName() { return "ReussBound"; }
  virtual const HomogenizationType giveClassID() { return HT_ReussBound; }

}; // end of class ReussBound


class VoightBound : public Homogenization
{
 public:
  VoightBound(long i, Problem *p) : Homogenization(i,p) {}
  virtual ~VoightBound(){}

  virtual void giveHomogenizedStiffnessMatrix( double* answer );
  virtual const char *giveClassName() { return "VoightBound"; }
  virtual const HomogenizationType giveClassID() { return HT_VoightBound; }

}; // end of class VoightBound


class RegGrid : public Homogenization
{
 private:
  const Mesh *mesh;

 public:
  RegGrid (long i, Problem *p) : Homogenization (i,p) { mesh = NULL; }
  virtual ~RegGrid () { mesh = NULL; }
  
  virtual void giveHomogenizedStiffnessMatrix( double* answer );
  virtual const char *giveClassName() { return "RegularGrid"; }
  virtual const HomogenizationType giveClassID() { return HT_RegGrid; }

  void set_mesh (const Mesh *val) { mesh = val; }
  
}; // end of class RegGrid


class DifferentialScheme : public Dilute
{
 public:
  DifferentialScheme(long i, Problem *p) : Dilute(i,p) {}
  virtual ~DifferentialScheme(){}

  virtual void giveHomogenizedStiffnessMatrix( double* answer );
  virtual const char *giveClassName() { return "DifferentialScheme"; }
  virtual const HomogenizationType giveClassID() { return HT_DifferentialScheme; }

private:
  static bool ascendingSort(Inclusion *first, Inclusion *second) { return first->give_volume() < second->give_volume(); }
  static bool descendingSort(Inclusion *first, Inclusion *second) { return first->give_volume() > second->give_volume(); }

}; // end of class DifferentialScheme

} // end of namespace mumech

#endif

/*end of file*/