ot_parametres.cpp

Aller à la documentation de ce fichier.

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       ot_parametres.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:54:00 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include <stdio.h>
#include <string.h>
#include <iostream>
#include "ot_parametres.h"
#include "ot_chaine.h"
#include "ot_tenseur.h"
 
 
 
 
 
 
 
 
 
 
 
 
OT_PARAMETRES::OT_PARAMETRES()
{
}
 
OT_PARAMETRES::OT_PARAMETRES(OT_PARAMETRES &mdd)
{
    int taille=nom_param.size();
    for (int i=0;i<taille;i++)
    {
        nom_param.insert(nom_param.end(),mdd.nom_param[i]);
        valeur_param.insert(valeur_param.end(),mdd.valeur_param[i]);
        aide_param.insert(aide_param.end(),mdd.aide_param[i]);
        type_param.insert(type_param.end(),mdd.type_param[i]);
    }
}
 
 
OT_PARAMETRES::~OT_PARAMETRES()
{
}
 
 
void OT_PARAMETRES::ajouter(std::string chaine,double valeur,int typep,std::string aide)
{
    int res=get_num_param(chaine);
    if (res==-1)
          {
          nom_param.insert(nom_param.end(),chaine);
          char mess[255];
          sprintf(mess,"%lf",valeur);
          valeur_param.insert(valeur_param.end(),mess);
          aide_param.insert(aide_param.end(),aide);
          type_param.insert(type_param.end(),typep);
          }
    else 
          {
          char mess[255];
          sprintf(mess,"%lf",valeur);
          valeur_param[res]=mess;
          if (aide.length()>aide_param[res].length()) aide_param[res]=aide;
          }
}
 
void OT_PARAMETRES::ajouter(std::string chaine,OT_TENSEUR& tens, int typep, std::string aide)
{
int res=get_num_param(chaine);
if (res==-1)
    {
        nom_param.insert(nom_param.end(),chaine);
        std::string chainetmp="";
    int dim1=tens.Get_NbRows();
    int dim2=tens.Get_NbCols();
    char mess[255];
    sprintf(mess,"%d;%d;",dim1,dim2);
    chainetmp=chainetmp+mess+";";
    for (int i=0;i<dim1;i++)
        for (int j=0;j<dim2;j++)
            {
            char mess[255];
            sprintf(mess,"%lf",tens(i,j).get_x());
            chainetmp=chainetmp+mess+";";
            }
          valeur_param.insert(valeur_param.end(),chainetmp);
          aide_param.insert(aide_param.end(),aide);
          type_param.insert(type_param.end(),typep);
          }
    else 
          {
          std::string chainetmp="";
    int dim1=tens.Get_NbRows();
    int dim2=tens.Get_NbCols();
    char mess[255];
    sprintf(mess,"%d;%d;",dim1,dim2);
    chainetmp=chainetmp+mess+";";
    for (int i=0;i<dim1;i++)
        for (int j=0;j<dim2;j++)
            {
            char mess[255];
            sprintf(mess,"%lf",tens(i,j).get_x());
            chainetmp=chainetmp+mess+";";
            } 
          if (aide.length()>aide_param[res].length()) aide_param[res]=aide;
          }
}
 
 
 
void OT_PARAMETRES::ajouter(std::string chaine,std::vector<double> &valeur,int typep,std::string aide)
{
    int res=get_num_param(chaine);
    if (res==-1)
          {
          nom_param.insert(nom_param.end(),chaine);
          std::string chainetmp="";
      for (int i=0;i<valeur.size();i++)
            {
            char mess[255];
            sprintf(mess,"%lf",valeur[i]);
            chainetmp=chainetmp+mess;
            if (i!=valeur.size()-1) chainetmp=chainetmp+";" ;   
            }
          valeur_param.insert(valeur_param.end(),chainetmp);
          aide_param.insert(aide_param.end(),aide);
          type_param.insert(type_param.end(),typep);
          }
    else 
          {
          std::string chainetmp="";
      for (int i=0;i<valeur.size();i++)
            {
            char mess[255];
            sprintf(mess,"%lf",valeur[i]);
            chainetmp=chainetmp+mess;
            if (i!=valeur.size()-1) chainetmp=chainetmp+";" ;   
            }
          valeur_param[res]=chainetmp;
          if (aide.length()>aide_param[res].length()) aide_param[res]=aide;
          }
}
 
void OT_PARAMETRES::ajouter(std::string chaine,std::vector<std::string> &valeur,int typep,std::string aide)
{
    int res=get_num_param(chaine);
    if (res==-1)
          {
          nom_param.insert(nom_param.end(),chaine);
          std::string chainetmp="";
      for (int i=0;i<valeur.size();i++)
            {
            char mess[255];
            sprintf(mess,"%s",valeur[i].c_str());
            chainetmp=chainetmp+mess;
            if (i!=valeur.size()-1) chainetmp=chainetmp+";" ;   
            }
          valeur_param.insert(valeur_param.end(),chainetmp);
          aide_param.insert(aide_param.end(),aide);
          type_param.insert(type_param.end(),typep);
          }
    else 
          {
          std::string chainetmp="";
      for (int i=0;i<valeur.size();i++)
            {
            char mess[255];
            sprintf(mess,"%s",valeur[i].c_str());
            chainetmp=chainetmp+mess;
            if (i!=valeur.size()-1) chainetmp=chainetmp+";" ;   
            }
          valeur_param[res]=chainetmp;
          if (aide.length()>aide_param[res].length()) aide_param[res]=aide;
          }
}
 
void OT_PARAMETRES::ajouter(std::string chaine,std::string valeurstring,int typep,std::string aide)
{
    int res=get_num_param(chaine);
    if (res==-1)
          {
          nom_param.insert(nom_param.end(),chaine);
          valeur_param.insert(valeur_param.end(),valeurstring);
          aide_param.insert(aide_param.end(),aide);
          type_param.insert(type_param.end(),typep);
          } 
    else 
          {
          valeur_param[res]=valeurstring;
          if (aide.length()>aide_param[res].length()) aide_param[res]=aide;
          }
          
}
 
void OT_PARAMETRES::enregistrer(char *nom)
{
    FILE* in=fopen(nom,"wt");
    int taille=nom_param.size();
    for (int i=0;i<taille;i++)
        fprintf(in,"%s = %s       //%s\n",nom_param[i].c_str(),valeur_param[i].c_str(),aide_param[i].c_str());
    taille=params.size();
    for (int i=0;i<taille;i++)
        fprintf(in,"-> %s\n",params[i].c_str());
    fclose(in);
}
 
int OT_PARAMETRES::lire(char *nom)
{
    FILE* in=fopen(nom,"rt");
     if (in==NULL)
     {
       std::cerr << "*** OT_PARAMETRES::lire : Erreur de lecture du fichier (" << nom <<")  ***" << std::endl;
       return 0;
     }
    while (!feof(in))
    {
        char chaine[4000];
        char* res=fgets(chaine,4000,in);
        if (!feof(in))
        {
            char nom[255],c;
            char nom2[255];
            nom2[0]=0;
            int nb=sscanf(chaine,"%s %s",nom,nom2);
            if (nb==2)
              if (strcmp(nom,"->")==0) 
                {
                lire(nom2);
        ajouter(nom2);
                continue;
                }
            nb=sscanf(chaine,"%s %c %s",nom,&c,nom2);
            if (nb!=3) continue;
            double val;
            char *aide=strstr(chaine,"//");
            if (aide==NULL) aide=chaine+strlen(chaine)-1; else aide=aide+2;
            for (int i=0;i<strlen(aide);i++)
              if (aide[i]=='\n') aide[i]=0;
            int num=sscanf(nom2,"%lf",&val);
            if (num==1) ajouter(nom,nom2,DOUBLE,aide);
            else ajouter(nom,nom2,STRING,aide);
        }
    }
    fclose(in);
    return 1; // return OK;
}
 
void OT_PARAMETRES::ajouter(std::string chaine)
{
params.push_back(chaine);
}
 
void OT_PARAMETRES::get_valeur(std::string chaine, class OT_TENSEUR& tens)
{
    int taille=nom_param.size();
    for (int i=0;i<taille;i++)
    {
        std::string valtmp=nom_param[i];
        if (valtmp==chaine)
        {
            OT_CHAINE opc;
            int dim1,dim2;
            std::vector<std::string> tab=opc.split(valeur_param[i],';');
            sscanf(tab[0].c_str(),"%d",&dim1);
            sscanf(tab[1].c_str(),"%d",&dim2);
            tens.reinit(dim1,dim2);
            for (int i=0;i<dim1;i++)
                for (int j=0;j<dim2;j++)
                    {
                    double val;
                    sscanf(tab[i*dim2+j+2].c_str(),"%lf",&val);
                    tens(i,j)=val;    
                    }
            
        }
 
    }
    return;
 
    
}
 
 
double OT_PARAMETRES::get_valeur(std::string chaine,int num)
{
    int taille=nom_param.size();
    for (int i=0;i<taille;i++)
    {
        std::string valtmp=nom_param[i];
        if (valtmp==chaine)
        {
            OT_CHAINE opc;
            std::vector<std::string> tab=opc.split(valeur_param[i],';');
            double val;
            sscanf(tab[num].c_str(),"%lf",&val);
            return val;
        }
 
    }
    return 0.;
}
 
void OT_PARAMETRES::change_valeur(std::string chaine,double val,int num)
{
    int taille=nom_param.size();
    for (int i=0;i<taille;i++)
    {
        std::string valtmp=nom_param[i];
        if (valtmp==chaine)
        {
         OT_CHAINE opc;
         std::vector<std::string> tab=opc.split(valeur_param[i],';');
         char mess[255];
             sprintf(mess,"%lf",val);
             tab[num]=mess;
         valeur_param[i]="";
         for (int j=0;j<tab.size();j++)
            {
            valeur_param[i]=valeur_param[i]+tab[j];
            if (i!=tab.size()-1) 
                valeur_param[i]=valeur_param[i]+";";
            
            }
        }
 
    }
}
 
void OT_PARAMETRES::change_valeur(std::string chaine,std::string val,int num)
{
    int taille=nom_param.size();
    for (int i=0;i<taille;i++)
    {
        std::string valtmp=nom_param[i];
        if (valtmp==chaine)
        {
         OT_CHAINE opc;
         std::vector<std::string> tab=opc.split(valeur_param[i],';');
         tab[num]=val;
         valeur_param[i]="";
         for (int j=0;j<tab.size();j++)
            {
            valeur_param[i]=valeur_param[i]+tab[j];
            if (i!=tab.size()-1) 
                valeur_param[i]=valeur_param[i]+";";
            
            }
        }
 
    }
}
 
int OT_PARAMETRES::get_num_param(std::string chaine)
{
    int taille=nom_param.size();
    for (int i=0;i<taille;i++)
    {
        std::string valtmp=nom_param[i];
        if (valtmp==chaine)
        {
            return i;
        }
 
    }
    return -1;
}
 
 
std::string OT_PARAMETRES::get_nom(std::string chaine,int num)
{
    int taille=nom_param.size();
    for (int i=0;i<taille;i++)
    {
        std::string valtmp=nom_param[i];
        if (valtmp==chaine)
        {
            OT_CHAINE opc;
            std::vector<std::string> tab=opc.split(valeur_param[i],';');
            return tab[num];
        }
 
    }
    return "";
}
 
int OT_PARAMETRES::get_type(std::string chaine)
{
    int taille=nom_param.size();
    for (int i=0;i<taille;i++)
    {
        std::string valtmp=nom_param[i];
        if (valtmp==chaine)
        {
            return type_param[i];
        }
 
    }
    return 0;
}
double OT_PARAMETRES::get_valeur(int num)
{
    double val;
    sscanf(valeur_param[num].c_str(),"%lf",&val);
    return val;
}
 
std::string OT_PARAMETRES::get_nom(int num)
{
    return nom_param[num];
}
 
int OT_PARAMETRES::get_type(int num)
{
    return type_param[num];
}
int OT_PARAMETRES::get_nb(void)
{
    return nom_param.size();
}
 
 
void OT_PARAMETRES::vide(void)
{
    nom_param.clear();
    valeur_param.clear();
    aide_param.clear();
    type_param.clear();
    params.clear();
}