matrix.h

Go to the documentation of this file.

//********************************************************************************************************
// code:                          ###  ###  #####   ####  ##  ##
//                       ##  ##   ########  ##     ##  ## ##  ##
//                       ##  ##   ## ## ##  ###    ##     ######
//                       ##  ##   ##    ##  ##     ##  ## ##  ##
//                       #####    ##    ##  #####   ####  ##  ##
//                       ##
//
// name:           matrix_record.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_MATRIX_RECORD_H
#define MUMECH_MATRIX_RECORD_H

//included libraries
#include "types.h"
#include "elementaryFunctions.h"
#include "matrix_vector.h"


namespace mumech {

class Problem;

class MatrixRecord
{
  friend class Problem;
  friend class InclusionRecord3D;
  
 protected:
  const Problem *P;
  
  double ym;                 
  double pr;                 
  double *origin;            
  int nRS;                   
  double **Remote_strain;    
  
 private:
  double **globHomog_displc;    
  double **globHomog_strain;    
  double **globHomog_stress;    
  
 public:
  double *C;                    
  
 public:
  MatrixRecord (const Problem *p);
  virtual ~MatrixRecord ();
  
  // *** SET ***
  void set_nlc (int n);
  void set_E_nu (double e, double n);
  void set_E_nu_rs (double e, double n, const double *r1) {
    this->set_E_nu(e, n);
    this->set_nlc(1);
    this->set_Remote_strain_for_lc(0, r1);
  }
  
  void set_origin (double x, double y);
  void set_origin (double x, double y, double z);
  void convert_RS_ROWtoFEEP (int lc);
  void set_Remote_strain_for_lc (int lc, const double r1[]);
  bool scan_Remote_strains (FILE *stream);
  bool scan_Remote_strains (const char *stream);
  void set_unit_remote_strain (void);
  bool remote_strain_is_unit (void) const;

  // *** GET ***
  double   E  (void) const { return ym; }
  double   nu (void) const { return pr; }
  const double** remote_strains (void) const { return (const double**)Remote_strain; }
  void giveReducedStiffMatrix (double *answer) const;
  void giveFullStiffMatrix (double *answer) const;
  
  void allocate_nlc_fields (void);
  const double* give_globHomog_Displc (int lc, const double *coords);
  void          give_globHomog_Displc (double *displ, int lc, const double *coords);
  const double* give_globHomog_Strain (int lc);
  void          give_globHomog_Strain (double *strain, int lc);
  const double* give_globHomog_Stress (int lc);
  void          give_globHomog_Stress (double *stress, int lc);
  
  void printYourself (const char *notice = NULL);
  
}; // end of class definition

// ********************************************************************************************************
// **************************   POINT   *******************************************************************
// ********************************************************************************************************
class Point
{
 public:
  double x[3];                 
  double loc_x[3];             
  //double E;                    ///<  Actual Young's modulus.
  //PointPositionFlag position;  ///<  Position flag (_INT_POINT_ / _EXT_POINT_).
  double la;                   
  double eInt[13];             
  double dJi[9];               
  double dJij[27];             
  double ddJi[27];             
  double ddJij[81];            
  double S[12];                
  double D[36];                
  double L[18];                
  //double C[12];                ///<  Actual sotropic stiffness matrix.
  
  int nlc;
  
  double **displacement;       
  double **strain;             
  double **stress;             

  Point ();
  virtual ~Point ();
  
  void set_nlc (const Problem *p, int nlc);
  
};



} // end of namespace mumech

#endif

/*end of file*/