matrixOperations.h

Go to the documentation of this file.

//********************************************************************************************************
// code:                          ###  ###  #####   ####  ##  ##
//                       ##  ##   ########  ##     ##  ## ##  ##
//                       ##  ##   ## ## ##  ###    ##     ######
//                       ##  ##   ##    ##  ##     ##  ## ##  ##
//                       #####    ##    ##  #####   ####  ##  ##
//                       ##
//
// name:           matrixOperations.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_OPERATIONS_H
#define MUMECH_MATRIX_OPERATIONS_H

#include "elementaryFunctions.h"

namespace mumech {

namespace MatrixOperations
{

// *******************************************************************************************************
// /**                          Operations with tensors of various notations                           **/
// /** @name                       ***   GENERAL TENSOR OPERATIONS   ***                               **/
// ***************************************************|***************************************************

// @{

// *****  PRODUCTS  *****

//void    E = give_TensorTensorProduct (hstrain, hstress, p->nstrain_one());

double giveTTproduct_1is2x2to3and2x2to3_SS  (const double *T1, const double *T2);


void giveIsoTensAndVectorProduct (const double *tens, const double *vec, double *result, int dim);

void giveTVproduct_6is6x6to12and6 (double *result, const double *T, const double *vect);

void giveTVproduct_3is3x3to5and3  (double *result, const double *T, const double *vect);
double giveVTVproduct_1is3and3x3to5and3  (const double *T, const double *vect);
void giveTTproduct_3x3to5is3x3to5and3x3to5 (double *result, const double *T1, const double *T2);



//  energy[pid[lc] = give_TensorTensorProduct (strain[pid][lc], stress[pid][lc], M->P[pid]->nstrain_one());


// *****  OTHER  *****


void giveInverseMatrix (double *mtrx, int n);
void giveInverseMatrix (double **mtrx, int n);
void giveInverseMatrix_core (double **answer, double **mtrx, int n, bool vect);


// *****  PRINT  *****

void printField( double ** field, int n, int m, const char * notice );

void printField( double ** field, int n, int m, int lineBreak, const char * notice );

void printAnisoField( double ** field, int n, int * m, int lineBreak, const char * notice );

void printAnisoField( int ** field, int n, int * m, int lineBreak, const char * notice );

// @}

// *******************************************************************************************************
// /**                          Operations with tensors of various notations                           **/
// /** @name                       ***   GENERAL TENSOR OPERATIONS   ***                               **/
// ***************************************************|***************************************************

// @{

//inline void CopyTensor( double * a, double * b ) { CopyVector( a, b, 9 ); }


void CopyTensorAndReduceToFeep (const double *a, double *b);

void convert2Dtensor_TRtoROW_notation (double *t);
void convert3Dtensor_TFEEPtoROW_notation (double *t);

void convert2Dtensor_TRtoVR_notation (double *t);
void convert3Dtensor_TRtoVR_notation (double *t);


void convert3Dtensor_9ROWto6FEEP_notation (double *t);
void convert2Dtensor_4ROWto3FEEP_notation (double *t);

void copy3Dto2Dtensors_FEEPreduced (const double *a, double *b);

void copy2Dto3Dtensors_FEEPreduced (const double *a, double *b);

void copy3DeshelbyTensor_reduced2full (const double *a, double **b);
void copy2DeshelbyTensor_reduced2full (const double *a, double **b);

void copy3DeshelbyTensor_full2reduced (const double *a, double *b);
void copy3DeshelbyTensor_reduced2full (const double *a, double *b);


void copy2DeshelbyTensor_full2reduced (const double *a, double *b);
void copy2DeshelbyTensor_reduced2full (const double *a, double *b);


inline void giveUnitSMatrixReduced_2d (double *m) { CleanVector(m,  5);  m[0] = m[3] = m[4] = 1.0; }
inline void giveUnitSMatrixReduced_3d (double *m) { CleanVector(m, 12);  m[0] = m[4] = m[8] = m[9] = m[10] = m[11] = 1.0; }

inline void giveUnitSMatrixFull_2d (double *m) { CleanVector(m,  9);  m[0] = m[4] = m[8] = 1.0; }
inline void giveUnitSMatrixFull_3d (double *m) { CleanVector(m, 36);  m[0] = m[7] = m[14] = m[21] = m[28] = m[35] = 1.0; }



void printSMatrixReduced (const double S[12], const char * notice, unsigned flag);


// @}

} // end of namespace MatrixOperaions

} // end of namespace mumech

#endif

/*end of file*/