mesoface.cpp

Go to the documentation of this file.

//********************************************************************************************************
// code:                          ###  ###  #####   ####  ##  ##
//                       ##  ##   ########  ##     ##  ## ##  ##
//                       ##  ##   ## ## ##  ###    ##     ######
//                       ##  ##   ##    ##  ##     ##  ## ##  ##
//                       #####    ##    ##  #####   ####  ##  ##
//                       ##
//
// name:           mesoface.cpp
// author(s):      Lukas Zrubek, 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.
//********************************************************************************************************

#include "mesoface.h"
#include "meso2d.h"
#include "meso3d.h"
#include "inclusion.h"
#include "mathlib.h"

namespace mumech {


int MesoFace :: ellipsoids_overlap (const Inclusion* inc1, const Inclusion* inc2)
{
  meso3d::ellipsoid_rec first, second;

  fill_ellipsoid_rec (inc1, first);
  meso3d::check_ellipsoid_rec_consistency (first);
  meso3d::transfom_ellipsoid_rec (first);

  fill_ellipsoid_rec (inc2, second);
  meso3d::check_ellipsoid_rec_consistency (second);
  meso3d::transfom_ellipsoid_rec (second);

  return meso3d::check_ellipsoid_ellipsoid_overlap (&first, &second);
}

bool MesoFace :: ellipses_overlap (const Inclusion *inc1, const Inclusion *inc2)
{
  meso2d::ellipse_rec first, second;

  fill_ellipse_rec (inc1, first);
  meso2d::check_ellipse_rec_consistency (first);
  meso2d::transfom_ellipse_rec (first);

  fill_ellipse_rec (inc2, second);
  meso2d::check_ellipse_rec_consistency (second);
  meso2d::transfom_ellipse_rec (second);

  return meso2d::check_ellipse_ellipse_overlap (&first, &second);
}

void MesoFace :: fill_ellipsoid_rec (const Inclusion* inc, meso3d::ellipsoid_rec & L)
{
  // id of ellipsoid
  L.id = inc->id;

  // coordinates of center of ellipsoid in global coordinate system
  L.center.x = inc->origin[0];
  L.center.y = inc->origin[1];
  L.center.z = inc->origin[2];

  // TOTO tady nemusi byt, major, minor a middle nakrmime radkami rotacni matice na inkluzi
  // coordinates of point on the positive major semiaxe
  L.major.x = inc->a[0]; L.major.y = 0.0; L.major.z = 0.0;
  // potreba spocita polohu tohoto bodu v zavislosti na natoceni inkluze
  rotate_point_by_euler_angles_in_313_notation (inc->eAngles, L.major);
  // potreba posunout bod o souradnice stredu inkluze
  L.major.x += inc->origin[0]; L.major.y += inc->origin[1]; L.major.z += inc->origin[2];

  // coordinates of point on the positive middle semiaxe
  // nenacita se => neni treba
  // L.middle.x = 1; L.middle.y = 1; L.middle.z = 1;

  // coordinates of point on half plane given by major axis and positive minor axis
  L.minor.x = 0.0; L.minor.y = 0.0; L.minor.z = inc->a[2];
  // potreba spocita polohu tohoto bodu v zavislosti na natoceni inkluze
  rotate_point_by_euler_angles_in_313_notation (inc->eAngles, L.minor);
  // potreba posunout bod o souradnice stredu inkluze
  L.minor.x += inc->origin[0]; L.minor.y += inc->origin[1]; L.minor.z += inc->origin[2];
  // TOTO

  // size of major semiaxe
  L.max = inc->a[0];
  // size of middle semiaxe
  L.mid = inc->a[1];
  // size of minor semiaxe
  L.min = inc->a[2];

  // msz = mesh size
  // size of internal mesh size
  L.internal_msz = 0.0;
  // size of boundary mesh size
  L.boundary_msz = 0.0;

  L.property = 0; L.interface = 0; L.bc = 0; L.region = 0;
  // L.crack = NULL; // neni nutne, je zakomentovano ve strukture

  return;
}

void MesoFace :: rotate_point_by_euler_angles_in_313_notation (const double * eAngles, meso3d::point_rec & point)
{
  rotate_point_about_Z_axis (eAngles[2], point, COUNTER_CLOCKWISE);
  rotate_point_about_X_axis (eAngles[1], point, COUNTER_CLOCKWISE);
  rotate_point_about_Z_axis (eAngles[0], point, COUNTER_CLOCKWISE);

  return;
}

void MesoFace :: fill_ellipse_rec (const Inclusion *inc, meso2d::ellipse_rec & L)
{
  // id of ellipsoid
  L.id = inc->id;

  // coordinates of center of ellipsoid in global coordinate system
  L.center.x = inc->origin[0];
  L.center.y = inc->origin[1];

  // angle of ellipse
  L.angle = inc->eAngles[0];

  // size of major semiaxe
  L.max = inc->a[0];
  // size of min semiaxe
  L.min = inc->a[1];

  // msz = mesh size
  // size of internal mesh size
  L.internal_msz = 0.0;
  // size of boundary mesh size
  L.boundary_msz = 0.0;

  L.property = 0; L.interface = 0; L.bc = 0;
  // L.crack = NULL; // commented in structure

  return;
}



void MesoFace :: rotate_point_about_X_axis (const double alpha, meso3d::point_rec & point, rotation r)
{
  double Rx[3][3];
  if (r == CLOCKWISE) {
    Rx[0][0] = 1.0; Rx[0][1] = 0.0;          Rx[0][2] = 0.0;
    Rx[1][0] = 0.0; Rx[1][1] = cos (alpha);  Rx[1][2] = sin (alpha);
    Rx[2][0] = 0.0; Rx[2][1] = -sin (alpha); Rx[2][2] = cos (alpha);
  }
  if (r == COUNTER_CLOCKWISE) {
    Rx[0][0] = 1.0; Rx[0][1] = 0.0;         Rx[0][2] = 0.0;
    Rx[1][0] = 0.0; Rx[1][1] = cos (alpha); Rx[1][2] = -sin (alpha);
    Rx[2][0] = 0.0; Rx[2][1] = sin (alpha); Rx[2][2] = cos (alpha);
  }

  double x = point.x, y = point.y, z = point.z;
  point.x = Rx[0][0] * x + Rx[0][1] * y + Rx[0][2] * z;
  point.y = Rx[1][0] * x + Rx[1][1] * y + Rx[1][2] * z;
  point.z = Rx[2][0] * x + Rx[2][1] * y + Rx[2][2] * z;

  return;
}

void MesoFace :: rotate_point_about_Y_axis (const double alpha, meso3d::point_rec & point, rotation r)
{
  double Ry[3][3];
  if (r == CLOCKWISE) {
    Ry[0][0] = cos (alpha); Ry[0][1] = 0.0; Ry[0][2] = -sin (alpha);
    Ry[1][0] = 0.0;        Ry[1][1] = 1.0; Ry[1][2] = 0.0;
    Ry[2][0] = sin (alpha); Ry[2][1] = 0.0; Ry[2][2] = cos (alpha);
  }
  if (r == COUNTER_CLOCKWISE) {
    Ry[0][0] = cos (alpha);  Ry[0][1] = 0.0; Ry[0][2] = sin (alpha);
    Ry[1][0] = 0.0;          Ry[1][1] = 1.0; Ry[1][2] = 0.0;
    Ry[2][0] = -sin (alpha); Ry[2][1] = 0.0; Ry[2][2] = cos (alpha);
  }

  double x = point.x, y = point.y, z = point.z;
  point.x = Ry[0][0] * x + Ry[0][1] * y + Ry[0][2] * z;
  point.y = Ry[1][0] * x + Ry[1][1] * y + Ry[1][2] * z;
  point.z = Ry[2][0] * x + Ry[2][1] * y + Ry[2][2] * z;

  return;
}

void MesoFace :: rotate_point_about_Z_axis (const double alpha, meso3d::point_rec & point, rotation r)
{
  double Rz[3][3];
  if (r == CLOCKWISE) {
    Rz[0][0] = cos (alpha); Rz[0][1] = sin (alpha);  Rz[0][2] = 0.0;
    Rz[1][0] = -sin (alpha); Rz[1][1] = cos (alpha); Rz[1][2] = 0.0;
    Rz[2][0] = 0.0;         Rz[2][1] = 0.0;          Rz[2][2] = 1.0;
  }
  if (r == COUNTER_CLOCKWISE) {
    Rz[0][0] = cos (alpha); Rz[0][1] = -sin (alpha); Rz[0][2] = 0.0;
    Rz[1][0] = sin (alpha); Rz[1][1] = cos (alpha);  Rz[1][2] = 0.0;
    Rz[2][0] = 0.0;         Rz[2][1] = 0.0;          Rz[2][2] = 1.0;
  }

  double x = point.x, y = point.y, z = point.z;
  point.x = Rz[0][0] * x + Rz[0][1] * y + Rz[0][2] * z;
  point.y = Rz[1][0] * x + Rz[1][1] * y + Rz[1][2] * z;
  point.z = Rz[2][0] * x + Rz[2][1] * y + Rz[2][2] * z;

  return;
}



} // end of namespace mumech

/*end of file*/