src/HEXABLOCK/HexVector.cxx

   1
   2 // C++ : Gestion des vecteurs
   3
   4 // Copyright (C) 2009-2023  CEA, EDF
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 #include "HexVector.hxx"
  23 #include "HexXmlWriter.hxx"
  24
  25 BEGIN_NAMESPACE_HEXA
  26
  27 // ======================================================== Constructeur
  28 Vector::Vector (Document* doc, double dx, double dy, double dz)
  29       : EltBase (doc, EL_VECTOR)
  30 {
  31     v_dx = dx;
  32     v_dy = dy;
  33     v_dz = dz;
  34 }
  35 // ======================================================== Constructeur bis
  36 Vector::Vector (Vector* lautre)
  37       : EltBase (lautre->el_root)
  38 {
  39     v_dx = lautre -> v_dx;
  40     v_dy = lautre -> v_dy;
  41     v_dz = lautre -> v_dz;
  42 }
  43
  44 // ======================================================== calculNormale
  45 // === Calcule un vecteur orthogonal et norme
  46 int Vector::calculNormale (double& nx, double& ny, double& nz)
  47 {
  48     double epsil = (v_dx * v_dx + v_dy * v_dy + v_dz * v_dz)*1e-6;
  49     int    forme = 2000;
  50     if  (v_dx > epsil || v_dx < -epsil) forme += 100;
  51     if  (v_dy > epsil || v_dy < -epsil) forme +=  10;
  52     if  (v_dz > epsil || v_dz < -epsil) forme +=   1;
  53
  54     nx = ny = nz = 0;
  55     switch (forme)
  56        {
  57                              // dx=dy=dz=0 : retour vecteur i + erreur
  58        case 2000 : nx = 1;
  59                    return HERR;
  60                              // dx = 0 : on prend le vecteur i
  61        case 2001 :
  62        case 2010 :
  63        case 2011 : nx = 1;
  64                    return HOK;
  65                              // dy = 0 : on prend le vecteur j
  66        case 2100 :
  67        case 2101 : ny = 1;
  68                    return HOK;
  69                              // dz = 0 : on prend le vecteur k
  70        case 2110 : nz = 1;
  71                    return HOK;
  72                              // dx, dy, dy non nuls : cas general;
  73        default :;
  74        }
  75
  76    double norme = sqrt (v_dx*v_dx + v_dy*v_dy);
  77    nx =  v_dy / norme;
  78    ny = -v_dx / norme;
  79    return HOK;
  80 }
  81 // ========================================================= saveXml
  82 void Vector::saveXml (XmlWriter* xml)
  83 {
  84    char buffer[12], coord[80];
  85
  86    sprintf (coord, "%g %g %g", v_dx, v_dy, v_dz);
  87
  88    xml->openMark     ("Vector");
  89    xml->addAttribute ("id",    getName (buffer));
  90    xml->addAttribute ("coord", coord);
  91    if (el_name!=buffer)
  92        xml->addAttribute ("name", el_name);
  93    xml->closeMark ();
  94 }
  95 // ========================================================= getAngleX
  96 double Vector::getAngleX ()
  97 {
  98    static const double Epsilon = 1e-6;
  99
 100    double norme = getNorm ();
 101    if (norme < Epsilon)
 102       return 0.0;
 103
 104    double kos = v_dx / norme;
 105    double deg = acos(kos) * 180.0 / M_PI;
 106    return deg;
 107 }
 108 // ===================================================== getCoord
 109 double Vector::getCoord (int dir)
 110 {
 111    double val = 0;
 112    switch (dir)
 113           {
 114           case dir_x : val = v_dx;
 115                break;
 116           case dir_y : val = v_dy;
 117                break;
 118           case dir_z : val = v_dz;
 119                break;
 120           }
 121    return val;
 122 }
 123 // ===================================================== renormer
 124 int Vector::renormer()
 125 {
 126    double dn = getNorm ();
 127    if (dn < 1e-30)
 128       return HERR;
 129
 130    v_dx /= dn;
 131    v_dy /= dn;
 132    v_dz /= dn;
 133
 134    return HOK;
 135 }
 136 // ===================================================== vectoriel
 137 void Vector::vectoriel (Vector* a, Vector*b)
 138 {
 139    v_dx =   a->v_dy * b->v_dz - b->v_dy * a->v_dz;
 140    v_dy =   a->v_dz * b->v_dx - b->v_dz * a->v_dx;
 141    v_dz =   a->v_dx * b->v_dy - b->v_dx * a->v_dy;
 142 }
 143
 144 // ===================================================== getCoord
 145 double* Vector::getCoord (double coord[])
 146 {
 147    coord [dir_x] = v_dx;
 148    coord [dir_y] = v_dy;
 149    coord [dir_z] = v_dz;
 150    return coord;
 151 }
 152 // ===================================================== getUnitVector
 153 int Vector::getUnitVector (double coord[])
 154 {
 155    coord [dir_x] = v_dx;
 156    coord [dir_y] = v_dy;
 157    coord [dir_z] = v_dz;
 158    int ier  = normer_vecteur (coord);
 159    return ier;
 160 }
 161 // ===================================================== multiplier
 162 void Vector::multiplier (double scalaire)
 163 {
 164    v_dx *= scalaire;
 165    v_dy *= scalaire;
 166    v_dz *= scalaire;
 167 }
 168 // ===================================================== dump
 169 void Vector::dump ()
 170 {
 171    printf ("Vector ");
 172    printName (" = ");
 173    if (NOT isHere ())
 174       {
 175       printf ("(*** deleted ***)\n");
 176       return;
 177       }
 178
 179    printf ("(%g, %g, %g)\n", v_dx,v_dy,v_dz);
 180 }
 181
 182 END_NAMESPACE_HEXA