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 // ========================================================= calc_milieu
 115 void calc_milieu  (double pta[], double ptb[], double milieu[])
 116 {
 117    milieu [dir_x] = (ptb [dir_x] + pta [dir_x])/2.0;
 118    milieu [dir_y] = (ptb [dir_y] + pta [dir_y])/2.0;
 119    milieu [dir_z] = (ptb [dir_z] + pta [dir_z])/2.0;
 120 }
 121 // ========================================================= normer_vecteur
 122 int normer_vecteur (double vect[])
 123 {
 124    double dn = calc_norme (vect);
 125    if (dn < 1e-30)
 126       return HERR;
 127
 128    vect [dir_x] /= dn;
 129    vect [dir_y] /= dn;
 130    vect [dir_z] /= dn;
 131    return HOK;
 132 }
 133 // ========================================================= prod_vectoriel
 134 double* prod_vectoriel (double v1[], double v2[], double prod[])
 135 {
 136    prod [dir_x] = v1[dir_y] * v2[dir_z] - v2[dir_y] * v1[dir_z];
 137    prod [dir_y] = v1[dir_z] * v2[dir_x] - v2[dir_z] * v1[dir_x];
 138    prod [dir_z] = v1[dir_x] * v2[dir_y] - v2[dir_x] * v1[dir_y];
 139
 140    return prod;
 141 }
 142 // ====================================================== carre
 143 double carre (double val)
 144 {
 145    return val*val;
 146 }
 147 // ====================================================== same_coords
 148 bool same_coords (double* pa, double* pb, double epsilon2)
 149 {
 150
 151    double d2 = carre (pb[dir_x]-pa[dir_x]) + carre (pb[dir_y]-pa[dir_y])
 152              + carre (pb[dir_z]-pa[dir_z]);
 153    return d2 < epsilon2;
 154 }
 155 // ========================================================= prod_mixte
 156 double prod_mixte (double vi[], double vj[], double vk[])
 157 {
 158    double pmixte = 0;
 159
 160    for (int nc=0 ; nc<DIM3 ; nc++)
 161        {
 162        int nc1 = (nc + 1) MODULO DIM3;
 163        int nc2 = (nc + 2) MODULO DIM3;
 164        pmixte +=  vk[nc] * (vi [nc1] * vj [nc2] - vj [nc1] * vi [nc2]);
 165        }
 166
 167    return pmixte;
 168 }
 169 // ========================================================= fatal_error
 170 void fatal_error (cpchar format, cpchar info1, cpchar info2)
 171 {
 172    char     buffer [240];
 173    sprintf (buffer, format, info1, info2);
 174    printf ("****\n");
 175    printf ("**** %s\n", buffer);
 176    printf ("****\n");
 177 #ifdef NO_CASCADE
 178    printf ("                ............ Erreur fatale\n");
 179    exit (94);
 180 #endif
 181    printf ("\n");
 182 }
 183 static int current_option = NOTHING;
 184 // ====================================================== special_option
 185 bool special_option ()
 186 {
 187    if (current_option == NOTHING)
 188       {
 189       cpchar rep = getenv ("HEXA_OPTION");
 190       if (rep!=NULL)
 191           current_option = atoi (rep);
 192       current_option = std::max (current_option, 0);
 193       }
 194    return current_option > 0;
 195 }
 196 // ====================================================== set_special_option
 197 void set_special_option (bool opt)
 198 {
 199    current_option = opt ? 1 : 0;
 200 }
 201 // ====================================================== sizeof_file
 202 int sizeof_file (cpchar filename)
 203 {
 204    struct stat status;
 205
 206    int ier = stat  (filename, &status);
 207    if (ier == HOK)
 208       return status.st_size;
 209    else
 210       return NOTHING;
 211 }
 212 // ====================================================== read_file
 213 char* read_file (cpchar filename, int& size)
 214 {
 215    size = 0;
 216
 217    struct stat status;
 218    int ier = stat  (filename, &status);
 219    if (ier != HOK)
 220       return  NULL;
 221
 222    FILE* fic = fopen (filename, "r");
 223    if (fic == NULL)
 224       return  NULL;
 225
 226    int   lgalloc = status.st_size;
 227    char* buffer  = (char*) malloc (lgalloc+1);
 228    if (buffer == NULL)
 229       return  NULL;
 230
 231    for (int car = fgetc (fic) ; car!=EOF && size<lgalloc ; car = fgetc(fic))
 232        buffer [size++] = car;
 233    fclose (fic);
 234
 235    printf ("read_file : lgalloc=%d, size=%d\n", lgalloc, size);
 236    buffer [size++] = EOS;
 237    return buffer;
 238 }
 239 // ====================================================== get_time
 240 cpchar get_time (string& buffer)
 241 {
 242    char   quand[24];
 243    time_t tps;
 244    time (&tps);
 245    struct tm *temps = localtime (&tps);
 246
 247    sprintf (quand, "%d/%02d/%02d %02d:%02d:%02d",
 248             1900 + temps->tm_year, temps->tm_mon+1, temps->tm_mday,
 249             temps->tm_hour, temps->tm_min, temps->tm_sec);
 250
 251     buffer = quand;
 252     return buffer.c_str();
 253 }
 254 END_NAMESPACE_HEXA