mg_solution.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mg_solution.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:54 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
 
#include "gestionversion.h"
#include <math.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
 
#include "mg_solution.h"
#include "mg_maillage.h"
#include "ot_mathematique.h"
 
 
#include <stdio.h> // pour la fonction remove() qui remplace DeleteFile
 
 
 
 
 
 
MG_SOLUTION::MG_SOLUTION(MG_MAILLAGE* mai,int nb,char* chemin,int code,std::string nomsol,int entite,int type_solution):MG_IDENTIFICATEUR(),nb_champs(nb),mgmai(mai),nomsolution(nomsol),typeentite(entite),dim_solution(type_solution)
{
    inisolution(chemin,code);
}
 
MG_SOLUTION::MG_SOLUTION(unsigned long num,MG_MAILLAGE* mai,int nb,char* chemin,int code,std::string nomsol,int entite,int type_solution):MG_IDENTIFICATEUR(num),nb_champs(nb),mgmai(mai),nomsolution(nomsol),typeentite(entite),dim_solution(type_solution)
{
    inisolution(chemin,code);
}
 
MG_SOLUTION::~MG_SOLUTION()
{
    delete [] nom_fichier;
    delete [] legende;
    if (in!=NULL) fclose(in);
}
 
 
void MG_SOLUTION::inisolution(char* chemin,int code)
{
  nom_fichier=new char[strlen(chemin)+2];
  legende=new std::string[nb_champs];
  for (int i=0;i<nb_champs;i++)
  {
      char mess[15];
      sprintf(mess,"Champs_%d",i);
      legende[i]=mess ;
  }
  strcpy(nom_fichier,chemin);
  if (code!=0)
    {
        in=fopen(nom_fichier,"wb");
        unsigned long nbele=0;
        if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_NOEUD) nbele=mgmai->get_nb_mg_noeud();
        if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT1) nbele=mgmai->get_nb_mg_segment();
        if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT2) nbele=mgmai->get_nb_mg_triangle()+mgmai->get_nb_mg_quadrangle();
        if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT3) nbele=mgmai->get_nb_mg_tetra()+mgmai->get_nb_mg_hexa();
        if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT1_NOEUD) nbele=mgmai->get_nb_mg_segment();
        if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT2_NOEUD) nbele=mgmai->get_nb_mg_triangle()+mgmai->get_nb_mg_quadrangle();
        if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT3_NOEUD)  nbele=mgmai->get_nb_mg_tetra()+mgmai->get_nb_mg_hexa();
        fwrite(&nbele,sizeof(unsigned long),1,in);
        for (unsigned long i=0;i<nbele+1;i++)
          {
          unsigned long val=0;
          fwrite(&val,sizeof(unsigned long),1,in);
          }
        unsigned long *tab=new unsigned long[nbele+1];  
        unsigned long i=0;
        unsigned long cumul_iter=0;
        if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_NOEUD)
          {
          LISTE_MG_NOEUD::iterator ite;
          for (MG_NOEUD* ele=mgmai->get_premier_noeud(ite);ele;ele=mgmai->get_suivant_noeud(ite))
            {
            tab[i]=cumul_iter;
            unsigned long iter=1*nb_champs*dim_solution;
            for (unsigned long j=0;j<iter;j++)
                {
                double val=0;
                fwrite(&val,sizeof(double),1,in);
                }
            i++;
            cumul_iter=cumul_iter+iter;
            }
                    
          }
        if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT1)
          {
          LISTE_MG_SEGMENT::iterator ite;
          for (MG_SEGMENT* ele=mgmai->get_premier_segment(ite);ele;ele=mgmai->get_suivant_segment(ite))
            {
            tab[i]=cumul_iter;
            unsigned long iter=1*nb_champs*dim_solution;
            for (unsigned long j=0;j<iter;j++)
                {
                double val=0;
                fwrite(&val,sizeof(double),1,in);
                }
            i++;
            cumul_iter=cumul_iter+iter;
            }
                    
          }
        if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT2)
          {
          LISTE_MG_TRIANGLE::iterator itet;
          for (MG_TRIANGLE* ele=mgmai->get_premier_triangle(itet);ele;ele=mgmai->get_suivant_triangle(itet))
            {
            tab[i]=cumul_iter;
            unsigned long iter=1*nb_champs*dim_solution;
            for (unsigned long j=0;j<iter;j++)
                {
                double val=0;
                fwrite(&val,sizeof(double),1,in);
                }
            i++;
            cumul_iter=cumul_iter+iter;
            }
          LISTE_MG_QUADRANGLE::iterator iteq;
          for (MG_QUADRANGLE* ele=mgmai->get_premier_quadrangle(iteq);ele;ele=mgmai->get_suivant_quadrangle(iteq))
            {
            tab[i]=cumul_iter;
            unsigned long iter=1*nb_champs*dim_solution;
            for (unsigned long j=0;j<iter;j++)
                {
                double val=0;
                fwrite(&val,sizeof(double),1,in);
                }
            i++;
            cumul_iter=cumul_iter+iter;
            }
                    
          }
        if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT3)
          {
          LISTE_MG_TETRA::iterator itet;
          for (MG_TETRA* ele=mgmai->get_premier_tetra(itet);ele;ele=mgmai->get_suivant_tetra(itet))
            {
            tab[i]=cumul_iter;
            unsigned long iter=1*nb_champs*dim_solution;
            for (unsigned long j=0;j<iter;j++)
                {
                double val=0;
                fwrite(&val,sizeof(double),1,in);
                }
            i++;
            cumul_iter=cumul_iter+iter;
            }
                    
          LISTE_MG_HEXA::iterator iteh;
          for (MG_HEXA* ele=mgmai->get_premier_hexa(iteh);ele;ele=mgmai->get_suivant_hexa(iteh))
            {
            tab[i]=cumul_iter;
            unsigned long iter=1*nb_champs*dim_solution;
            for (unsigned long j=0;j<iter;j++)
                {
                double val=0;
                fwrite(&val,sizeof(double),1,in);
                }
            i++;
            cumul_iter=cumul_iter+iter;
            }
                    
          }
        if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT3_NOEUD)
          {
          LISTE_MG_TETRA::iterator itet;
          for (MG_TETRA* ele=mgmai->get_premier_tetra(itet);ele;ele=mgmai->get_suivant_tetra(itet))
            {
            tab[i]=cumul_iter;
            unsigned long iter=4*nb_champs*dim_solution;
            for (unsigned long j=0;j<iter;j++)
                {
                double val=0;
                fwrite(&val,sizeof(double),1,in);
                }
            i++;
            cumul_iter=cumul_iter+iter;
            }
          LISTE_MG_HEXA::iterator iteh;
          for (MG_HEXA* ele=mgmai->get_premier_hexa(iteh);ele;ele=mgmai->get_suivant_hexa(iteh))
            {
            tab[i]=cumul_iter;
            unsigned long iter=8*nb_champs*dim_solution;
            for (unsigned long j=0;j<iter;j++)
                {
                double val=0;
                fwrite(&val,sizeof(double),1,in);
                }
            i++;
            cumul_iter=cumul_iter+iter;
            }          
          }
       if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT1_NOEUD)
          {
          LISTE_MG_SEGMENT::iterator ite;
          for (MG_SEGMENT* ele=mgmai->get_premier_segment(ite);ele;ele=mgmai->get_suivant_segment(ite))
            {
            tab[i]=cumul_iter;
            unsigned long iter=2*nb_champs*dim_solution;
            for (unsigned long j=0;j<iter;j++)
                {
                double val=0;
                fwrite(&val,sizeof(double),1,in);
                }
            i++;
            cumul_iter=cumul_iter+iter;
            }
                    
          }
        if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT2_NOEUD)
          {
          LISTE_MG_TRIANGLE::iterator itet;
          for (MG_TRIANGLE* ele=mgmai->get_premier_triangle(itet);ele;ele=mgmai->get_suivant_triangle(itet))
            {
            tab[i]=cumul_iter;
            unsigned long iter=3*nb_champs*dim_solution;
            for (unsigned long j=0;j<iter;j++)
                {
                double val=0;
                fwrite(&val,sizeof(double),1,in);
                }
            i++;
            cumul_iter=cumul_iter+iter;
            }
          LISTE_MG_QUADRANGLE::iterator iteq;
          for (MG_QUADRANGLE* ele=mgmai->get_premier_quadrangle(iteq);ele;ele=mgmai->get_suivant_quadrangle(iteq))
            {
            tab[i]=cumul_iter;
            unsigned long iter=4*nb_champs*dim_solution;
            for (unsigned long j=0;j<iter;j++)
                {
                double val=0;
                fwrite(&val,sizeof(double),1,in);
                }
            i++;
            cumul_iter=cumul_iter+iter;
            }
                           
          }
        tab[nbele]=cumul_iter;
        fseek(in,sizeof(unsigned long),SEEK_SET);
        for (unsigned long i=0;i<nbele+1;i++)
          {
          unsigned long val=0;
          fwrite(&(tab[i]),sizeof(unsigned long),1,in);
          }
        delete [] tab;
        fclose(in);
    }
    in=fopen(nom_fichier,"r+b");
    hash.clear();
    fseek(in,0,SEEK_SET);
    unsigned long nb;
    fread(&nb,sizeof(unsigned long),1,in);
    hash.insert(hash.end(),nb);
    for (unsigned long i=0;i<nb+1;i++)
      {
      unsigned long val;
      fread(&val,sizeof(unsigned long),1,in);
      hash.insert(hash.end(),val);
      }
}
 
 
void MG_SOLUTION::efface(void)
{
    fclose(in);
    remove(nom_fichier);
    in=NULL;
}
 
 
 
double MG_SOLUTION::lire(int i,int j,int coord,int num_no)
{
    unsigned long nb=hash[0];
    unsigned long pos=hash[i+1];
    unsigned long pospro=hash[i+2];
    int nbval=(pospro-pos)/nb_champs/dim_solution;
    long posval=(nb+2)*sizeof(unsigned long)+(pos+j*dim_solution*nbval+num_no*dim_solution+coord)*sizeof(double);
    fseek(in,posval,SEEK_SET);
    double val;
    fread(&val,sizeof(double),1,in);
    return (val);
}
 
void MG_SOLUTION::ecrire(double val,int i,int j,int coord,int num_no)
{
    unsigned long nb=hash[0];
    unsigned long pos=hash[i+1];
    unsigned long pospro=hash[i+2];
    int nbval=(pospro-pos)/nb_champs/dim_solution;
    long posval=(nb+2)*sizeof(unsigned long)+(pos+j*dim_solution*nbval+num_no*dim_solution+coord)*sizeof(double);
    fseek(in,posval,SEEK_SET);
    fwrite(&val,sizeof(double),1,in);
    fflush(in);
}
 
 
 
int MG_SOLUTION::get_dim_solution(void)
{
return dim_solution;  
}    
 
void MG_SOLUTION::change_legende(int num,std::string val)
{
    legende[num]=val;
}
 
std::string MG_SOLUTION::get_legende(int num)
{
    return legende[num];
}
 
int MG_SOLUTION::get_nb_champ(void)
{
    return nb_champs;
}
 
MG_MAILLAGE* MG_SOLUTION::get_maillage(void)
{
    return mgmai;
}
 
double MG_SOLUTION::get_legende_min(int num)
{
    return solmin[num];
}
 
double MG_SOLUTION::get_legende_max(int num)
{
    return solmax[num];
}
 
void MG_SOLUTION::active_solution(int num)
{
    int nb;
    for (int j=0;j<9;j++)
      {
      solmax[j]=-1e308;
      solmin[j]=1e308;
      }
    int i=0;
    if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_NOEUD)
    {
        LISTE_MG_NOEUD::iterator it;
        for (MG_NOEUD* no=mgmai->get_premier_noeud(it);no!=NULL;no=mgmai->get_suivant_noeud(it))
        {
            for (int k=0;k<dim_solution;k++)
            {
              double val=lire(i,num,k);
              no->change_solution(val,k);
              if (val<solmin[k]) solmin[k]=val;
              if (val>solmax[k]) solmax[k]=val;
            }
            i++;
        }
    }
    if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT1)
    {
        LISTE_MG_SEGMENT::iterator it;
        for (MG_SEGMENT* seg=mgmai->get_premier_segment(it);seg!=NULL;seg=mgmai->get_suivant_segment(it))
        {
            for (int k=0;k<dim_solution;k++)
              {
              double val=lire(i,num,k);
              seg->change_solution(val,k);
              if (val<solmin[k]) solmin[k]=val;
              if (val>solmax[k]) solmax[k]=val;
              }
            i++;
        }
    }
    if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT2)
    {
        LISTE_MG_TRIANGLE::iterator it;
        for (MG_TRIANGLE* tri=mgmai->get_premier_triangle(it);tri!=NULL;tri=mgmai->get_suivant_triangle(it))
        {
            for (int k=0;k<dim_solution;k++)
              {
              double val=lire(i,num,k);
              tri->change_solution(val,k);
              if (val<solmin[k]) solmin[k]=val;
              if (val>solmax[k]) solmax[k]=val;
              }
            i++;
        }
        LISTE_MG_QUADRANGLE::iterator it2;
        for (MG_QUADRANGLE* quad=mgmai->get_premier_quadrangle(it2);quad!=NULL;quad=mgmai->get_suivant_quadrangle(it2))
        {
            for (int k=0;k<dim_solution;k++)
              {
                double val=lire(i,num,k);
                quad->change_solution(val,k);
                if (val<solmin[k]) solmin[k]=val;
                if (val>solmax[k]) solmax[k]=val;
              }
            i++;
        }
    }
    if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT3)
    {
        LISTE_MG_TETRA::iterator it;
        for (MG_TETRA* tet=mgmai->get_premier_tetra(it);tet!=NULL;tet=mgmai->get_suivant_tetra(it))
        {
           for (int k=0;k<dim_solution;k++)
                {
                 double val=lire(i,num,k);
                 tet->change_solution(val,k);
                 if (val<solmin[k]) solmin[k]=val;
                 if (val>solmax[k]) solmax[k]=val;
                }
            i++;
        }
        LISTE_MG_HEXA::iterator it2;
        for (MG_HEXA* hex=mgmai->get_premier_hexa(it2);hex!=NULL;hex=mgmai->get_suivant_hexa(it2))
        {
            for (int k=0;k<dim_solution;k++)
              {
              double val=lire(i,num,k);
              hex->change_solution(val,k);
              if (val<solmin[k]) solmin[k]=val;
              if (val>solmax[k]) solmax[k]=val;
              }
            i++;
        }
    }
    for (int k=0;k<dim_solution;k++)
     if (OPERATEUR::egal(fabs(solmin[k]-solmax[k]),0.,1e-10)==1)
        solmax[k]=solmin[k]+1e-10;
}
 
std::string MG_SOLUTION::get_nom(void)
{
    return nomsolution;
}
std::string MG_SOLUTION::get_nom_fichier(void)
{
    return nom_fichier;
}
void MG_SOLUTION::enregistrer(std::ostream& o,double version)
{
    o << "%" << get_id() << "=SOLUTION(" << typeentite << "," << dim_solution  << "," << nomsolution << ",$" << mgmai->get_id() << "," << nb_champs << "," << nom_fichier << ",(";
    for (int i=0;i<nb_champs;i++)
    {
        o << legende[i];
        if (i!=nb_champs-1) o<<",";
        else o<<")";
    }
 
 
    o << ");" << std::endl;
}
 
void MG_SOLUTION::get_fichier_dependant(std::vector<std::string> &liste_fichier)
{
    
}
 
int MG_SOLUTION::get_entite_solution(void)
{
    return typeentite;
}
 
 
 
std::ostream& operator << (std::ostream& o,MG_SOLUTION& sol)
{
    sol.enregistrer(o,MAGIC_VERSION_FICHIER_DOUBLE);
    return o;
}