taux.h

Go to the documentation of this file.

#ifndef MIDAS_AUXILIARY_H
#define MIDAS_AUXILIARY_H

#include "alias.h"

#include "gelib.h"
#include "arrays.h"
#include "librw.h"
#include "gpa.h"
#include "tixy2.h"


namespace midaspace {


template <class T> void TF_GPA_reid    (GPA<T> &list) { for (long i=0; i<list(); i++) { list[i]->set_ID(i);                          } }
template <class T> void TF_GPA_reidoid (GPA<T> &list) { for (long i=0; i<list(); i++) { list[i]->set_ID(i);  list[i]->set_origID(i); } }
template <class T> void TF_GPA_shake_down_reid    (GPA<T> &list) { list.shake_down();  TF_GPA_reid    (list); }
template <class T> void TF_GPA_shake_down_reidoid (GPA<T> &list) { list.shake_down();  TF_GPA_reidoid (list); }


//*  ********************************************************************************************
//*  *** *** *** ***                          CLASS FiLe                          *** *** *** ***
//*  ********************************************************************************************
void filename_decomposition (char *&path, char *&base, char *&suff, const char *name);
void addSRCpriorDESTalloc (char *&dest, const char *src);


//*  ********************************************************************************************
//*  *** *** *** ***                          CLASS FiLe                          *** *** *** ***
//*  ********************************************************************************************
class FiLe
{
 protected:
  femFileFormat format;
  MMprocessing mmp;
  
  bool decomposed;
  
  char *path;
  char *base;
  char *suff;
  char *name;
  
  
 public:
  FiLe (femFileFormat form, const char *mp, const char *fn) {
    format = form;
    if (mp) mmp = MMprocessingStoE (mp);
    else    mmp = MMP_Void;
    
    decomposed = false;
    
    if (fn[0] == '-'  &&  fn[1] == '\0')  name = NULL;
    else                                  name = strdupl (fn);
    path = base = suff = NULL;
  }
  FiLe (femFileFormat form, const char *p, const char *b, const char *s) {
    format = form;
    decomposed = true;
    
    path = strdupl (p);
    base = strdupl (b);
    suff = strdupl (s);
    name = NULL;
  }
  virtual ~FiLe() {
    delete [] name;
    delete [] path;
    delete [] base;
    delete [] suff;
  }
  
  void addGlobPath (const char * globpath)
  {
    if (!globpath)  errol;
    
    if (decomposed) {
      delete [] name;
      if (path) addSRCpriorDESTalloc(path, globpath);
      else      path = strdupl (globpath);
    }
    else {
      if (name) addSRCpriorDESTalloc(name, globpath);
      else      errol;
    }
  }
  
  void set_empty_name_from_base (FiLe *src)
  {
    if (name == NULL)  name = strdupl (src->give_base());
  }
  
  void decompose (void)
  {
    decomposed = true;
    
    filename_decomposition (path, base, suff, name);
    
    delete [] name;
    name = NULL;
  }
  
  void compose (void)
  {
    if (name)  errol;
    if (!base)  errol;
    
    if      ( path && base &&  suff)  name = strdupl (path, base, suff);
    else if (!path && base &&  suff)  name = strdupl (      base, suff);
    else if (!path && base && !suff)  name = strdupl (      base      );
    else    errol;
  }
  
  //void set_IN_resultFF   (femFileFormat  val) { IN_resultFF   = val; }
  //void set_suff (const char* val) {
  //  if (suff) errol;  suff = strdupl (val);
  //  if (!base)  base = strdupl (name);
  //}
  
  const char*   give_path (void) const { if (!decomposed) ((FiLe*)this)->decompose();  return path; }
  const char*   give_base (void) const { if (!decomposed) ((FiLe*)this)->decompose();  return base; }
  const char*   give_suff (void) const { if (!decomposed) ((FiLe*)this)->decompose();  return suff; }
  
  const char*   give_name_or_null (void) const { return ((this->is_empty()) ? NULL : this->give_name()); }
  const char*   give_name (void) const { if (!name)       ((FiLe*)this)->  compose();  return name; }
  femFileFormat give_ff   (void) const { return format; }
  MMprocessing  give_mmp  (void) const { return mmp; }
  
  bool          is_empty  (void) const { return ((name || base) ? false : true); }
};



//*  ********************************************************************************************
//*  *** *** *** ***                    CLASS LocalCoordSystem                    *** *** *** ***
//*  ********************************************************************************************
class LocalCoordSystem
{
 public:
  LocalCoordSystem (void) { }
  virtual ~LocalCoordSystem() { }
  
};


//*  ********************************************************************************************
//*  *** *** *** ***                        CLASS LCS_pure                        *** *** *** ***
//*  ********************************************************************************************
#define COMPV3 ((LCS_pure*)this)->compute_v3();

class LCS_pure : public LocalCoordSystem
{
 private:
  bool v3alloc;
  VectoR v1, v2, v3;
  
 public:
  LCS_pure (void) : LocalCoordSystem ()  { v3alloc = false; }
  virtual ~LCS_pure() { }
  
  const VectoR* n1(void) const {         return &v1; }
  const VectoR* n2(void) const {         return &v2; }
  const VectoR* n3(void) const { COMPV3; return &v3; }
  
  void set_n1 (const VectoR *src) { v1.x = src->x; v1.y = src->y; v1.z = src->z; }
  void set_n2 (const VectoR *src) { v2.x = src->x; v2.y = src->y; v2.z = src->z; }
  void set_n3 (const VectoR *src) { v3.x = src->x; v3.y = src->y; v3.z = src->z; v3alloc = true; }
  
  void compute_v3 (void) {
    if (v3alloc) return;
    v3alloc = true;
    v3.beVectProduct( &v1, &v2 );
  }
  void initialize_from (const char *&str, femFileFormat ff);
  //void initialize (const Geometry *geom);
  
  void setup_rotmat_g2l (MatriX *rotmat);
  void setup_rotmat_l2g (MatriX *rotmat);
};

//*  ********************************************************************************************
//*  *** *** *** ***                        CLASS LCS_beam                        *** *** *** ***
//*  ********************************************************************************************
enum LCSdirection { LCSd_Void, LCSd_xy, LCSd_xz };
enum LCStype      { LCSt_Void, LCSt_NodeID, LCSt_NodeProp, LCSt_NodeCoords, LCSt_Vector };
class LCS_beam : public LocalCoordSystem
{
 protected:
  LCSdirection direction;
  LCStype      type;
  long         number;
  Elem3D       array;
  const Point *p;
  
 public:
  LCS_beam (void)                                           : LocalCoordSystem ()  { direction = LCSd_Void;  type = LCSt_Void;  number = -1;   p = NULL; }
  LCS_beam (LCSdirection dir, LCStype typ)                  : LocalCoordSystem ()  { direction = dir;        type = typ;        number = -1;   p = NULL; }
  LCS_beam (LCSdirection dir, LCStype typ, long num)        : LocalCoordSystem ()  { direction = dir;        type = typ;        number = num;  p = NULL; }
  LCS_beam (LCSdirection dir, LCStype typ, const double *a) : LocalCoordSystem ()  { direction = dir;        type = typ;        number = -1;   p = NULL;
    switch (this->type) {
    case LCSt_Vector:  array.scan_xyz(a);  break;
    default: errol;
    }
  }
  virtual ~LCS_beam() { p = NULL; }
  
  void initialize_from (const char *&str, femFileFormat ff);
  void initialize (const Geometry *geom);
  
  const Elem3D* give_vector (void) const {
    if (type == LCSt_Vector)  return &array;
    return NULL;
  }
  
    
  void print_row_OOFEM (FILE *stream, int did, Beam *b) const;
  
};


//*  ********************************************************************************************
//*  *** *** *** ***                  CLASS AdaptivityParameters                  *** *** *** ***
//*  ********************************************************************************************
enum ADPArameters { ADOA_Void, ADPA_ZZ, ADPA_SPR };

class AdaptivityParameters
{
 protected:
  // toto je i v problem.h pro midas adaptivitu; casem to mozna sluc
  ADPArameters  eetype;        // error estimation type
  int norm;                    // 1 = energy norm; 2 = L2 norm
  int SPRboudary;              // 1, 2, 3
  double required_error;       // required_error
  double enlarg;               // adaptivity - 
  double reduct;               // adaptivity - 
  
  double error;  // spoctena chyba
  
  // OOFEM minelemsize 0.05 recoverytype 1
    
 public:
  AdaptivityParameters (void) { eetype = ADOA_Void;  norm = 0;  required_error = 0.1;
    enlarg = 2.0;
    reduct = 0.5;
    error = 0.0;
  }
  AdaptivityParameters (long ee) { eetype = (ADPArameters)ee;  norm = 0;  required_error = 0.1;
    enlarg = 2.0;
    reduct = 0.5;
    error = 0.0;
  }
  virtual ~AdaptivityParameters() { }
  
  void initialize_from (const char *&str, femFileFormat fff);
  void initialize_from (FILE *stream, femFileFormat fff);
  int  initialize_from (char **argv);
  
  //void initialize (const Geometry *geom);
  
  
  void print_row_OOFEM (FILE *stream, int did, Beam *b) const;
  
  ADPArameters  give_eetype        (void) const { return  eetype;         }
  int           give_norm          (void) const { return  norm;           }
  int           give_SPRboudary    (void) const { return  SPRboudary;     }
  double        give_required_error(void) const { return  required_error; }
  double        give_enlarg        (void) const { return  enlarg;         }
  double        give_reduct        (void) const { return  reduct;         }
  double        give_error         (void) const { return  error;          }
  
  void set_error (double val) { error = val; }
};


//*  ********************************************************************************************
//*  *** *** *** ***                      CLASS STDOUTDRIVER                      *** *** *** ***
//*  ********************************************************************************************

#ifdef COLOREDOUT
#define clrout true
#else
#define clrout false
#endif

enum SODenum { SODE_Void, SODE_start_blue_arrow, SODE_row, SODE_end, SODE_end_green_ok, SODE_green_ok };

class StdoutDriver
{
 protected:
  int act;      // actual length of printed row
  int len;      // max length of the row
  
 public:
  StdoutDriver (void) { act = 0; len = 78; }
  virtual ~StdoutDriver() { }
  
  void set_act (int val) { act = val; }
  
  void spaces (int n) const;
  void print_info_message (SODenum flag, const char *format, ...) const;
  void print_info_message_colour (SODenum flag, ETCLR colour, const char *format, ...) const;
  void print_info_time_green_ok (SODenum flag, double sec) const;
  void print_info_message_core (SODenum flag, ETCLR color = ETC_DEFAULT, const char *buffer = NULL) const;
  
};

} // namespace midaspace

#endif // MIDAS_AUXILIARY_H