src/HEXABLOCK/hexa_utils.cxx

   1
   2 // C++ : Fonctions utilitaires de Hexa
   3
   4 // Copyright (C) 2009-2013  CEA/DEN, EDF R&D
   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.
  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
  23 #include "hexa_base.hxx"
  24
  25 #include <cstdlib>
  26 #include <cmath>
  27 #include <ctime>
  28 #include <sys/stat.h>
  29
  30 BEGIN_NAMESPACE_HEXA
  31
  32
  33 // ========================================================= niv_debug
  34 int niv_debug ()
  35 {
  36    static int debug_level = NOTHING;
  37    if (debug_level == NOTHING)
  38       {
  39       cpchar rep = getenv ("HEXA_DB");
  40       if (rep!=NULL)
  41           debug_level = atoi (rep);
  42       debug_level = std::max (debug_level, 0);
  43       }
  44    return debug_level;
  45 }
  46 // ========================================================= on_debug
  47 bool on_debug ()
  48 {
  49    return niv_debug () > 0;
  50 }
  51 // ========================================================= in_test
  52 bool in_test ()
  53 {
  54    static int test_level = NOTHING;
  55    if (test_level == NOTHING)
  56       {
  57       cpchar rep = getenv ("HEXA_TEST");
  58       if (rep!=NULL)
  59           test_level = atoi (rep);
  60       test_level = std::max (test_level, 0);
  61       }
  62    return test_level > 0;
  63
  64 }
  65 // ======================================================== set_minus
  66 void set_minus (string& chaine)
  67 {
  68    int lg = chaine.size();
  69    for (int nc=0 ; nc<lg ; nc++)
  70        chaine [lg] = tolower (chaine[lg]);
  71 }
  72 // ======================================================== get_temp_name
  73 pchar get_temp_name (cpchar format, pchar nomfic)
  74 {
  75    int nro = 0;
  76    while (true)
  77          {
  78          nro ++;
  79          sprintf (nomfic, format, nro);
  80
  81          struct stat buffer;
  82          int rep = stat (nomfic, &buffer);
  83          if (rep<0)
  84             return nomfic;
  85          }
  86 }
  87 // ========================================================= prod_scalaire
  88 double prod_scalaire (double v1[], double v2[])
  89 {
  90    double prod = v1[dir_x]*v2[dir_x] + v1[dir_y]*v2[dir_y]
  91                                      + v1[dir_z]*v2[dir_z];
  92    return prod;
  93 }
  94 // ========================================================= calc_norme
  95 double calc_norme (double vect[])
  96 {
  97     double norme = vect[dir_x]*vect[dir_x] + vect[dir_y]*vect[dir_y]
  98                                            + vect[dir_z]*vect[dir_z];
  99     return sqrt (norme);
 100 }
 101 // ======================================================== calc_distance
 102 double calc_distance  (double v1[], double v2[])
 103 {
 104    Real3 vv = { v2[dir_x]-v1[dir_x], v2[dir_y]-v1[dir_y], v2[dir_z]-v1[dir_z] };
 105    return calc_norme (vv);
 106 }
 107 // ========================================================= calc_vecteur
 108 void calc_vecteur  (double pta[], double ptb[], double vab[])
 109 {
 110    vab [dir_x] = ptb [dir_x] - pta [dir_x];
 111    vab [dir_y] = ptb [dir_y] - pta [dir_y];
 112    vab [dir_z] = ptb [dir_z] - pta [dir_z];
 113 }
 114 // ========================================================= copy_vecteur
 115 void copy_vecteur  (double va[], double vb[])
 116 {
 117    vb [dir_x] = va [dir_x];
 118    vb [dir_y] = va [dir_y];
 119    vb [dir_z] = va [dir_z];
 120 }
 121 // ========================================================= calc_milieu
 122 void calc_milieu  (double pta[], double ptb[], double milieu[])
 123 {
 124    milieu [dir_x] = (ptb [dir_x] + pta [dir_x])/2.0;
 125    milieu [dir_y] = (ptb [dir_y] + pta [dir_y])/2.0;
 126    milieu [dir_z] = (ptb [dir_z] + pta [dir_z])/2.0;
 127 }
 128 // ========================================================= normer_vecteur
 129 int normer_vecteur (double vect[])
 130 {
 131    double dn = calc_norme (vect);
 132    if (dn < 1e-30)
 133       return HERR;
 134
 135    vect [dir_x] /= dn;
 136    vect [dir_y] /= dn;
 137    vect [dir_z] /= dn;
 138    return HOK;
 139 }
 140 // ========================================================= prod_vectoriel
 141 double* prod_vectoriel (double v1[], double v2[], double prod[])
 142 {
 143    prod [dir_x] = v1[dir_y] * v2[dir_z] - v2[dir_y] * v1[dir_z];
 144    prod [dir_y] = v1[dir_z] * v2[dir_x] - v2[dir_z] * v1[dir_x];
 145    prod [dir_z] = v1[dir_x] * v2[dir_y] - v2[dir_x] * v1[dir_y];
 146
 147    return prod;
 148 }
 149 // ====================================================== carre
 150 double carre (double val)
 151 {
 152    return val*val;
 153 }
 154 // ====================================================== same_coords
 155 bool same_coords (double* pa, double* pb, double epsilon2)
 156 {
 157    double d2 = carre (pb[dir_x]-pa[dir_x]) + carre (pb[dir_y]-pa[dir_y])
 158              + carre (pb[dir_z]-pa[dir_z]);
 159    return d2 < epsilon2;
 160 }
 161 // ========================================================= prod_mixte
 162 double prod_mixte (double vi[], double vj[], double vk[])
 163 {
 164    double pmixte = 0;
 165
 166    for (int nc=0 ; nc<DIM3 ; nc++)
 167        {
 168        int nc1 = (nc + 1) MODULO DIM3;
 169        int nc2 = (nc + 2) MODULO DIM3;
 170        pmixte +=  vk[nc] * (vi [nc1] * vj [nc2] - vj [nc1] * vi [nc2]);
 171        }
 172
 173    return pmixte;
 174 }
 175 // ========================================================= fatal_error
 176 void fatal_error (cpchar format, cpchar info1, cpchar info2)
 177 {
 178    char     buffer [240];
 179    sprintf (buffer, format, info1, info2);
 180    printf ("****\n");
 181    printf ("**** %s\n", buffer);
 182    printf ("****\n");
 183 #ifdef NO_CASCADE
 184    printf ("                ............ Erreur fatale\n");
 185    exit (94);
 186 #endif
 187    printf ("\n");
 188 }
 189 static int current_option = NOTHING;
 190 // ====================================================== special_option
 191 bool special_option ()
 192 {
 193    if (current_option == NOTHING)
 194       {
 195       cpchar rep = getenv ("HEXA_OPTION");
 196       if (rep!=NULL)
 197           current_option = atoi (rep);
 198       current_option = std::max (current_option, 0);
 199       }
 200    return current_option > 0;
 201 }
 202 // ====================================================== set_special_option
 203 void set_special_option (bool opt)
 204 {
 205    current_option = opt ? 1 : 0;
 206 }
 207 // ====================================================== sizeof_file
 208 int sizeof_file (cpchar filename)
 209 {
 210    struct stat status;
 211
 212    int ier = stat  (filename, &status);
 213    if (ier == HOK)
 214       return status.st_size;
 215    else
 216       return NOTHING;
 217 }
 218 // ====================================================== read_file
 219 char* read_file (cpchar filename, int& size)
 220 {
 221    size = 0;
 222
 223    struct stat status;
 224    int ier = stat  (filename, &status);
 225    if (ier != HOK)
 226       return  NULL;
 227
 228    FILE* fic = fopen (filename, "r");
 229    if (fic == NULL)
 230       return  NULL;
 231
 232    int   lgalloc = status.st_size;
 233    char* buffer  = (char*) malloc (lgalloc+1);
 234    if (buffer == NULL)
 235       return  NULL;
 236
 237    for (int car = fgetc (fic) ; car!=EOF && size<lgalloc ; car = fgetc(fic))
 238        buffer [size++] = car;
 239    fclose (fic);
 240
 241    printf ("read_file : lgalloc=%d, size=%d\n", lgalloc, size);
 242    buffer [size++] = EOS;
 243    return buffer;
 244 }
 245 // ====================================================== get_time
 246 cpchar get_time (string& buffer)
 247 {
 248    char   quand[24];
 249    time_t tps;
 250    time (&tps);
 251    struct tm *temps = localtime (&tps);
 252
 253    sprintf (quand, "%d/%02d/%02d %02d:%02d:%02d",
 254             1900 + temps->tm_year, temps->tm_mon+1, temps->tm_mday,
 255             temps->tm_hour, temps->tm_min, temps->tm_sec);
 256
 257     buffer = quand;
 258     return buffer.c_str();
 259 }
 260 // ======================================================== requals
 261 bool requals (const double v1, const double v2)
 262 {
 263    static const double Epsilon = 1e-6;
 264    return v1 >= v2 - Epsilon && v1 <= v2 + Epsilon;
 265 }
 266 // ======================================================== requals
 267 bool requals (const double* lun, const double* lautre)
 268 {
 269    return    lun!=NULL && lautre!=NULL     && requals (lun [0], lautre [0])
 270           && requals (lun [1], lautre [1]) && requals (lun [2], lautre [2]) ;
 271 }
 272 END_NAMESPACE_HEXA