taux.cpp

Go to the documentation of this file.

#include "taux.h"

#include "geometry.h"
#include "point.h"

#include "arrays.h"


namespace midaspace {



//* ********************************************************************************************
//* *** *** *** ***                          CLASS FiLe                          *** *** *** ***
//* ********************************************************************************************
void filename_decomposition (char *&path, char *&base, char *&suff, const char *name)
{
  if (path || base || suff)  errol;
  
  const char *p;
  
  p = strrchr(name, DIRSEPARATOR);
  if (p) {
    path = new char[p-name+2];
    strncpy (path, name, p-name+1);
    path[p-name+1] = '\0';
    p++;
  }
  else  p = name;
  
  name = p;
  p = strchr(name,'.');
  if (p) {
    base = new char[p-name+1];
    strncpy (base, name, p-name);
    base[p-name] = '\0';
    
    suff = new char[strlen(p)+1];
    strcpy (suff, p);
  }
  else {
    base = new char[strlen(name)+1];
    strcpy (base, name);
  }
}

void addSRCpriorDESTalloc (char *&dest, const char *src)
{
  char *aux = strdupl (src, dest);
  delete [] dest;
  dest = aux;
}


//*  ********************************************************************************************
//*  *** *** *** ***                        CLASS LCS_pure                        *** *** *** ***
//*  ********************************************************************************************
void LCS_pure :: initialize_from (const char *&str, femFileFormat ff)
{
  if (ff == FFF_OOFEM) {
    SP_scan_expected_number_exit (str, 6, "6");
    if (!v1.scan_xyz(str)) errol;
    if (!v2.scan_xyz(str)) errol;
    v3alloc = false;
  }
  else errol;
}

void LCS_pure :: setup_rotmat_g2l (MatriX *rotmat)
{
  COMPV3;
  
  rotmat->copy_to_row_1(&v1);
  rotmat->copy_to_row_2(&v2);
  rotmat->copy_to_row_3(&v3);
}
void LCS_pure :: setup_rotmat_l2g (MatriX *rotmat)
{
  COMPV3;
  
  rotmat->copy_to_col_1(&v1);
  rotmat->copy_to_col_2(&v2);
  rotmat->copy_to_col_3(&v3);
}

//*  ********************************************************************************************
//*  *** *** *** ***                        CLASS LCS_beam                        *** *** *** ***
//*  ********************************************************************************************
void LCS_beam :: initialize (const Geometry *geom)
{
  if (p)  _errorr("mismatch in refNode");
  
  const GPA<Point> *points = geom->give_Pjnts();
  
  switch (this->type) {
  case LCSt_NodeID:
    if ( number > (*points)())  _errorr("refnode id is greather then number of all nodes");
    if ( number == 0)  this->type = LCSt_Void;
    else               p = (*points)[number-1];
    break;
  case LCSt_NodeProp:
    if ( number < 1 )  errol;
    for (long i=0; i<(*points)(); i++)
      if ((*points)[i]->has_mproperty(number)) {
    if (p)  _errorr("node with property %d is not unique");
    else  p = (*points)[i];
      }
    break;
  case LCSt_NodeCoords: _errorr("zatim neni implementovano");  break;
  case LCSt_Vector:     break;
  default: errol;
  }
  
  if (p) {
    const Node *n = dynamic_cast<const Node *>(p);
    if (n) {
      // check if reference node is in all domains
      // je to zde natvrdo, predpoklada se, ze u paralelnich versi je refnode natolik dulezity aby byl vsude
      long numdom =  n->Msh()->give_NumDomains();
      
      if (n->Msh()->give_Parallel())
    for (long did=0; did<numdom; did++)
      ((Node*)n)->add_me_to_domain (did);
      
    }
  }
}

void LCS_beam :: initialize_from (const char *&str, femFileFormat ff)
{
  if (ff == FFF_OOFEM) {
    SP_scan_number (str, number);
    direction = LCSd_xy;
    if (number == -1) {
      type = LCSt_Vector;
      SP_scan_expected_word_exit (str, "rnlcs", "rnlcs word is expected", CASE);
      SP_scan_expected_word_exit (str, "3", "the 3 is expected", CASE);
      array.scan_xyz (str);
    }
    else {
      type = LCSt_NodeID;
      if (number < 0) _errorr("error");
    }
  }
  else if (ff == FFF_MIDAS) {
    char WORD[255];
    SP_scan_word (str, WORD);
    if      (STRCMP(WORD, "xy") == 0)  direction = LCSd_xy;
    else if (STRCMP(WORD, "xz") == 0)  direction = LCSd_xz;
    else _errorr2("wrong keyword xy xz is supposed, not %s", WORD);
    
    while (SP_scan_word (str, WORD))
      if      (STRCMP(WORD, "nodeID"    ) == 0)  { type = LCSt_NodeID;     SP_scan_number (str, number); }
      else if (STRCMP(WORD, "nodeProp"  ) == 0)  { type = LCSt_NodeProp;   SP_scan_number (str, number); }
      else if (STRCMP(WORD, "nodeCoords") == 0)  { type = LCSt_NodeCoords; SP_scan_expected_number_exit (str, 3, "3");  array.scan_xyz(str); }
      else if (STRCMP(WORD, "vector"    ) == 0)  { type = LCSt_Vector;     SP_scan_expected_number_exit (str, 3, "3");  array.scan_xyz(str); }
      else _errorr2("wrong keyword in refnode input %s", WORD);
  }
  else errol;
}

void LCS_beam :: print_row_OOFEM (FILE *stream, int did, Beam *b) const
{
  const Node *n = dynamic_cast<const Node *>(p);
  if (p && n == NULL) {
    if (type==LCSt_NodeProp && (dynamic_cast<const Vertex*>(p) != NULL)) {
      ((LCS_beam*)this)->p = n = ((const Mesh*)b->give_Geom())->give_Node_with_prop (p->give_ID()+1, true); // (number, true);
    }
    else errol;
  }
  
  if (direction == LCSd_xz) {
    if (type != LCSt_Vector) _errorr("");
    VectoR x, y;
    x.beP2P( b->give_point(0)->give_coords(), b->give_point(1)->give_coords() );
    y.beVectProduct(&x, (VectoR*)&array);
    fprintf (stream, " -1 rnlcs 3 % .6g % .6g % .6g", y.x, y.y, y.z);
  }
  else if (direction == LCSd_xy) {
    if (p)  fprintf (stream, " %ld", n->give_lid_id(did) + 1 );
    else    fprintf (stream, " -1 rnlcs 3 % .6g % .6g % .6g", array.x, array.y, array.z);
  }
  else  errol;
}



//* ********************************************************************************************
//* *** *** *** ***                  CLASS AdaptivityParameters                  *** *** *** ***
//* ********************************************************************************************
void AdaptivityParameters :: initialize_from (const char *&str, femFileFormat fff)
{
  if (fff == FFF_MIDAS  ||  fff == FFF_OOFEM) {
    char W[255];
    long auxl;
    
    while (SP_scan_word (str, W)) {
      if      (strcmp(W, "type")     == 0) { SP_scan_number(str, auxl);  eetype = (ADPArameters)auxl; }
      else if (strcmp(W, "accuracy") == 0)   SP_scan_number(str, required_error);
      //else if (strcmp(W, "enlarg")   == 0)   SP_scan_number(str, adapt_enlarg);
      //else if (strcmp(W, "reduct")   == 0)   SP_scan_number(str, adapt_reduct);
      else _errorr2 ("Unsupported key word in problem analysis line adaptivity \"%s\"", W);
    }
  }
}

void AdaptivityParameters :: initialize_from (FILE *stream, femFileFormat fff)
{
  if (fff == FFF_SIFEL) {
    fscanf (stream, "%lf %lf %lf", &required_error, &enlarg, &reduct);
  }
}

int AdaptivityParameters :: initialize_from (char **argv)
{
  norm           = atol(argv[0]);
  required_error = atof(argv[1]);
  SPRboudary     = atol(argv[2]);
  return 3;
}

//* ********************************************************************************************
//* *** *** *** ***                      CLASS STDOUTDRIVER                      *** *** *** ***
//* ********************************************************************************************
void StdoutDriver :: spaces (int n) const
{
  while (n-- >= 0) fprintf (stdout," ");
}


void StdoutDriver :: print_info_message (SODenum flag, const char *format, ...) const
{
  char buffer[100];
  va_list args;
  
  va_start(args, format);
  vsprintf(buffer, format, args);
  va_end(args);
  
  this->print_info_message_core (flag, ETC_DEFAULT, buffer);
}

void StdoutDriver :: print_info_message_colour (SODenum flag, ETCLR colour, const char *format, ...) const
{
  char buffer[100];
  va_list args;
  
  va_start(args, format);
  vsprintf(buffer, format, args);
  va_end(args);
  
  this->print_info_message_core (flag, colour, buffer);
}

void StdoutDriver :: print_info_time_green_ok (SODenum flag, double sec) const
{
  if (flag !=  SODE_end_green_ok)  errol;
  
  int hod = (int)sec/3600;  sec -= hod*3600;
  int min = (int)sec/60;    sec -= min*60;
  
  char buffer[15];
  sprintf (buffer, "%2d:%02d:%05.2f ", hod, min, sec);
  
  this->print_info_message_core (flag, ETC_DEFAULT, buffer);
}

void StdoutDriver :: print_info_message_core (SODenum flag, ETCLR color, const char *buffer) const
{
  int buflen;
  if (buffer)  buflen = strlen(buffer);
  else {       buflen = 0;
    if (flag != SODE_green_ok) errol;
  }
  
  int actt = act;
  switch (flag){
  case SODE_start_blue_arrow:
    if (clrout)  CHANGE_CONSOLE_COLOUR(stdout, TC_B_CYAN );   fprintf (stdout, " -> ");
    if (clrout)  change_console_colour(stdout, color     );   fprintf (stdout, "%s", buffer);
    if (clrout)  CHANGE_CONSOLE_COLOUR(stdout, TC_DEFAULT);
    actt += 4 + buflen;
    break;
  case SODE_row:
    if (clrout)  change_console_colour(stdout, color     );   fprintf (stdout, "%s\n", buffer);
    if (clrout)  CHANGE_CONSOLE_COLOUR(stdout, TC_DEFAULT);
    actt = 0;
    break;
  case SODE_end:
    ;                                                         spaces (len - actt - buflen);
    if (clrout)  change_console_colour(stdout, color     );   fprintf (stdout, "%s\n", buffer);
    if (clrout)  CHANGE_CONSOLE_COLOUR(stdout, TC_DEFAULT);
    actt = 0;
    break;
  case SODE_end_green_ok:
    ;                                                         spaces (len - actt - buflen - 4);
    if (clrout)  change_console_colour(stdout, color     );   fprintf (stdout, "%s", buffer);
    if (clrout)  CHANGE_CONSOLE_COLOUR(stdout, TC_D_GREEN);   fprintf (stdout, "  ok\n");
    if (clrout)  CHANGE_CONSOLE_COLOUR(stdout, TC_DEFAULT);
    actt = 0;
    break;
  case SODE_green_ok:
    ;                                                         spaces (len - actt - 2);
    if (clrout)  CHANGE_CONSOLE_COLOUR(stdout, TC_D_GREEN);   fprintf (stdout, "ok\n");
    if (clrout)  CHANGE_CONSOLE_COLOUR(stdout, TC_DEFAULT);
    actt = 0;
    break;
  default: _errorr ("Unknown type of flag in function print_info_message");
  }
  
  ((StdoutDriver*)this)->set_act(actt);
}

//  this->sodriver()->print_info_message (SODE_start_blue_arrow, "Detection");

//  this->sodriver()->print_info_message (SODE_row, " ------------------------------------------------------------------------------");

//  this->sodriver()->print_info_message_core (SODE_green_ok);


} // namespace midaspace