mtu/src/mg_solution.cpp

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  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,VERSIONFICHIER);
    return o;
}


Revision:	1158
Committed:	Thu Jun 13 22:18:49 2024 UTC (11 months, 1 week ago) by francois
File size:	13815 byte(s)
Log Message:	compatibilité Ubuntu 22.04 Suppression des refeences à Windows Ajout d'une banière
#	User	Rev	Content
1	francois	1158	//####//------------------------------------------------------------
2			//####//------------------------------------------------------------
3			//####// MAGiC
4			//####// Jean Christophe Cuilliere et Vincent FRANCOIS
5			//####// Departement de Genie Mecanique - UQTR
6			//####//------------------------------------------------------------
7			//####// MAGIC est un projet de recherche de l equipe ERICCA
8			//####// du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
9			//####// http://www.uqtr.ca/ericca
10			//####// http://www.uqtr.ca/
11			//####//------------------------------------------------------------
12			//####//------------------------------------------------------------
13			//####//
14			//####// mg_solution.cpp
15			//####//
16			//####//------------------------------------------------------------
17			//####//------------------------------------------------------------
18			//####// COPYRIGHT 2000-2024
19			//####// jeu 13 jun 2024 11:58:54 EDT
20			//####//------------------------------------------------------------
21			//####//------------------------------------------------------------
22	francois	283
23
24			#include "gestionversion.h"
25			#include <math.h>
26			#include <iostream>
27			#include <stdlib.h>
28			#include <string.h>
29
30			#include "mg_solution.h"
31			#include "mg_maillage.h"
32			#include "ot_mathematique.h"
33
34
35			#include <stdio.h> // pour la fonction remove() qui remplace DeleteFile
36
37
38
39
40
41
42	francois	377	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)
43	francois	283	{
44	francois	377	inisolution(chemin,code);
45	francois	283	}
46
47	francois	377	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)
48	francois	283	{
49	francois	377	inisolution(chemin,code);
50	francois	283	}
51
52			MG_SOLUTION::~MG_SOLUTION()
53			{
54			delete [] nom_fichier;
55			delete [] legende;
56			if (in!=NULL) fclose(in);
57			}
58
59	francois	377
60			void MG_SOLUTION::inisolution(char* chemin,int code)
61			{
62			nom_fichier=new char[strlen(chemin)+2];
63			legende=new std::string[nb_champs];
64			for (int i=0;i<nb_champs;i++)
65			{
66			char mess[15];
67			sprintf(mess,"Champs_%d",i);
68			legende[i]=mess ;
69			}
70			strcpy(nom_fichier,chemin);
71			if (code!=0)
72			{
73			in=fopen(nom_fichier,"wb");
74			unsigned long nbele=0;
75			if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_NOEUD) nbele=mgmai->get_nb_mg_noeud();
76			if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT1) nbele=mgmai->get_nb_mg_segment();
77			if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT2) nbele=mgmai->get_nb_mg_triangle()+mgmai->get_nb_mg_quadrangle();
78			if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT3) nbele=mgmai->get_nb_mg_tetra()+mgmai->get_nb_mg_hexa();
79			if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT1_NOEUD) nbele=mgmai->get_nb_mg_segment();
80			if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT2_NOEUD) nbele=mgmai->get_nb_mg_triangle()+mgmai->get_nb_mg_quadrangle();
81			if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT3_NOEUD) nbele=mgmai->get_nb_mg_tetra()+mgmai->get_nb_mg_hexa();
82			fwrite(&nbele,sizeof(unsigned long),1,in);
83			for (unsigned long i=0;i<nbele+1;i++)
84			{
85			unsigned long val=0;
86			fwrite(&val,sizeof(unsigned long),1,in);
87			}
88			unsigned long *tab=new unsigned long[nbele+1];
89			unsigned long i=0;
90			unsigned long cumul_iter=0;
91			if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_NOEUD)
92			{
93			LISTE_MG_NOEUD::iterator ite;
94			for (MG_NOEUD* ele=mgmai->get_premier_noeud(ite);ele;ele=mgmai->get_suivant_noeud(ite))
95			{
96			tab[i]=cumul_iter;
97			unsigned long iter=1nb_champsdim_solution;
98			for (unsigned long j=0;j<iter;j++)
99			{
100			double val=0;
101			fwrite(&val,sizeof(double),1,in);
102			}
103			i++;
104			cumul_iter=cumul_iter+iter;
105			}
106
107			}
108			if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT1)
109			{
110			LISTE_MG_SEGMENT::iterator ite;
111			for (MG_SEGMENT* ele=mgmai->get_premier_segment(ite);ele;ele=mgmai->get_suivant_segment(ite))
112			{
113			tab[i]=cumul_iter;
114			unsigned long iter=1nb_champsdim_solution;
115			for (unsigned long j=0;j<iter;j++)
116			{
117			double val=0;
118			fwrite(&val,sizeof(double),1,in);
119			}
120			i++;
121			cumul_iter=cumul_iter+iter;
122			}
123
124			}
125			if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT2)
126			{
127			LISTE_MG_TRIANGLE::iterator itet;
128			for (MG_TRIANGLE* ele=mgmai->get_premier_triangle(itet);ele;ele=mgmai->get_suivant_triangle(itet))
129			{
130			tab[i]=cumul_iter;
131			unsigned long iter=1nb_champsdim_solution;
132			for (unsigned long j=0;j<iter;j++)
133			{
134			double val=0;
135			fwrite(&val,sizeof(double),1,in);
136			}
137			i++;
138			cumul_iter=cumul_iter+iter;
139			}
140			LISTE_MG_QUADRANGLE::iterator iteq;
141			for (MG_QUADRANGLE* ele=mgmai->get_premier_quadrangle(iteq);ele;ele=mgmai->get_suivant_quadrangle(iteq))
142			{
143			tab[i]=cumul_iter;
144			unsigned long iter=1nb_champsdim_solution;
145			for (unsigned long j=0;j<iter;j++)
146			{
147			double val=0;
148			fwrite(&val,sizeof(double),1,in);
149			}
150			i++;
151			cumul_iter=cumul_iter+iter;
152			}
153
154			}
155			if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT3)
156			{
157			LISTE_MG_TETRA::iterator itet;
158			for (MG_TETRA* ele=mgmai->get_premier_tetra(itet);ele;ele=mgmai->get_suivant_tetra(itet))
159			{
160			tab[i]=cumul_iter;
161			unsigned long iter=1nb_champsdim_solution;
162			for (unsigned long j=0;j<iter;j++)
163			{
164			double val=0;
165			fwrite(&val,sizeof(double),1,in);
166			}
167			i++;
168			cumul_iter=cumul_iter+iter;
169			}
170
171			LISTE_MG_HEXA::iterator iteh;
172			for (MG_HEXA* ele=mgmai->get_premier_hexa(iteh);ele;ele=mgmai->get_suivant_hexa(iteh))
173			{
174			tab[i]=cumul_iter;
175			unsigned long iter=1nb_champsdim_solution;
176			for (unsigned long j=0;j<iter;j++)
177			{
178			double val=0;
179			fwrite(&val,sizeof(double),1,in);
180			}
181			i++;
182			cumul_iter=cumul_iter+iter;
183			}
184
185			}
186			if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT3_NOEUD)
187			{
188			LISTE_MG_TETRA::iterator itet;
189			for (MG_TETRA* ele=mgmai->get_premier_tetra(itet);ele;ele=mgmai->get_suivant_tetra(itet))
190			{
191			tab[i]=cumul_iter;
192			unsigned long iter=4nb_champsdim_solution;
193			for (unsigned long j=0;j<iter;j++)
194			{
195			double val=0;
196			fwrite(&val,sizeof(double),1,in);
197			}
198			i++;
199			cumul_iter=cumul_iter+iter;
200			}
201			LISTE_MG_HEXA::iterator iteh;
202			for (MG_HEXA* ele=mgmai->get_premier_hexa(iteh);ele;ele=mgmai->get_suivant_hexa(iteh))
203			{
204			tab[i]=cumul_iter;
205			unsigned long iter=8nb_champsdim_solution;
206			for (unsigned long j=0;j<iter;j++)
207			{
208			double val=0;
209			fwrite(&val,sizeof(double),1,in);
210			}
211			i++;
212			cumul_iter=cumul_iter+iter;
213			}
214			}
215			if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT1_NOEUD)
216			{
217			LISTE_MG_SEGMENT::iterator ite;
218			for (MG_SEGMENT* ele=mgmai->get_premier_segment(ite);ele;ele=mgmai->get_suivant_segment(ite))
219			{
220			tab[i]=cumul_iter;
221			unsigned long iter=2nb_champsdim_solution;
222			for (unsigned long j=0;j<iter;j++)
223			{
224			double val=0;
225			fwrite(&val,sizeof(double),1,in);
226			}
227			i++;
228			cumul_iter=cumul_iter+iter;
229			}
230
231			}
232			if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT2_NOEUD)
233			{
234			LISTE_MG_TRIANGLE::iterator itet;
235			for (MG_TRIANGLE* ele=mgmai->get_premier_triangle(itet);ele;ele=mgmai->get_suivant_triangle(itet))
236			{
237			tab[i]=cumul_iter;
238			unsigned long iter=3nb_champsdim_solution;
239			for (unsigned long j=0;j<iter;j++)
240			{
241			double val=0;
242			fwrite(&val,sizeof(double),1,in);
243			}
244			i++;
245			cumul_iter=cumul_iter+iter;
246			}
247			LISTE_MG_QUADRANGLE::iterator iteq;
248			for (MG_QUADRANGLE* ele=mgmai->get_premier_quadrangle(iteq);ele;ele=mgmai->get_suivant_quadrangle(iteq))
249			{
250			tab[i]=cumul_iter;
251			unsigned long iter=4nb_champsdim_solution;
252			for (unsigned long j=0;j<iter;j++)
253			{
254			double val=0;
255			fwrite(&val,sizeof(double),1,in);
256			}
257			i++;
258			cumul_iter=cumul_iter+iter;
259			}
260
261			}
262			tab[nbele]=cumul_iter;
263			fseek(in,sizeof(unsigned long),SEEK_SET);
264			for (unsigned long i=0;i<nbele+1;i++)
265			{
266			unsigned long val=0;
267			fwrite(&(tab[i]),sizeof(unsigned long),1,in);
268			}
269			delete [] tab;
270			fclose(in);
271			}
272			in=fopen(nom_fichier,"r+b");
273			hash.clear();
274			fseek(in,0,SEEK_SET);
275			unsigned long nb;
276			fread(&nb,sizeof(unsigned long),1,in);
277			hash.insert(hash.end(),nb);
278			for (unsigned long i=0;i<nb+1;i++)
279			{
280			unsigned long val;
281			fread(&val,sizeof(unsigned long),1,in);
282			hash.insert(hash.end(),val);
283			}
284			}
285
286
287	francois	283	void MG_SOLUTION::efface(void)
288			{
289			fclose(in);
290			remove(nom_fichier);
291			in=NULL;
292			}
293
294	francois	377
295
296			double MG_SOLUTION::lire(int i,int j,int coord,int num_no)
297	francois	283	{
298	francois	377	unsigned long nb=hash[0];
299			unsigned long pos=hash[i+1];
300			unsigned long pospro=hash[i+2];
301			int nbval=(pospro-pos)/nb_champs/dim_solution;
302			long posval=(nb+2)sizeof(unsigned long)+(pos+jdim_solutionnbval+num_nodim_solution+coord)*sizeof(double);
303			fseek(in,posval,SEEK_SET);
304	francois	283	double val;
305	francois	377	fread(&val,sizeof(double),1,in);
306	francois	283	return (val);
307			}
308
309	francois	377	void MG_SOLUTION::ecrire(double val,int i,int j,int coord,int num_no)
310	francois	283	{
311	francois	377	unsigned long nb=hash[0];
312			unsigned long pos=hash[i+1];
313			unsigned long pospro=hash[i+2];
314			int nbval=(pospro-pos)/nb_champs/dim_solution;
315			long posval=(nb+2)sizeof(unsigned long)+(pos+jdim_solutionnbval+num_nodim_solution+coord)*sizeof(double);
316			fseek(in,posval,SEEK_SET);
317	francois	283	fwrite(&val,sizeof(double),1,in);
318			fflush(in);
319			}
320
321
322	francois	377
323			int MG_SOLUTION::get_dim_solution(void)
324			{
325			return dim_solution;
326			}
327
328	francois	283	void MG_SOLUTION::change_legende(int num,std::string val)
329			{
330			legende[num]=val;
331			}
332
333			std::string MG_SOLUTION::get_legende(int num)
334			{
335			return legende[num];
336			}
337
338			int MG_SOLUTION::get_nb_champ(void)
339			{
340			return nb_champs;
341			}
342
343			MG_MAILLAGE* MG_SOLUTION::get_maillage(void)
344			{
345			return mgmai;
346			}
347
348	francois	377	double MG_SOLUTION::get_legende_min(int num)
349	francois	283	{
350	francois	377	return solmin[num];
351	francois	283	}
352
353	francois	377	double MG_SOLUTION::get_legende_max(int num)
354	francois	283	{
355	francois	377	return solmax[num];
356	francois	283	}
357
358			void MG_SOLUTION::active_solution(int num)
359			{
360			int nb;
361	francois	377	for (int j=0;j<9;j++)
362			{
363			solmax[j]=-1e308;
364			solmin[j]=1e308;
365			}
366	francois	283	int i=0;
367	francois	375	if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_NOEUD)
368	francois	283	{
369			LISTE_MG_NOEUD::iterator it;
370			for (MG_NOEUD* no=mgmai->get_premier_noeud(it);no!=NULL;no=mgmai->get_suivant_noeud(it))
371			{
372	francois	377	for (int k=0;k<dim_solution;k++)
373			{
374			double val=lire(i,num,k);
375			no->change_solution(val,k);
376			if (val<solmin[k]) solmin[k]=val;
377			if (val>solmax[k]) solmax[k]=val;
378			}
379	francois	283	i++;
380			}
381			}
382	francois	375	if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT1)
383	francois	283	{
384			LISTE_MG_SEGMENT::iterator it;
385			for (MG_SEGMENT* seg=mgmai->get_premier_segment(it);seg!=NULL;seg=mgmai->get_suivant_segment(it))
386			{
387	francois	377	for (int k=0;k<dim_solution;k++)
388			{
389			double val=lire(i,num,k);
390			seg->change_solution(val,k);
391			if (val<solmin[k]) solmin[k]=val;
392			if (val>solmax[k]) solmax[k]=val;
393			}
394	francois	283	i++;
395			}
396			}
397	francois	375	if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT2)
398	francois	283	{
399			LISTE_MG_TRIANGLE::iterator it;
400			for (MG_TRIANGLE* tri=mgmai->get_premier_triangle(it);tri!=NULL;tri=mgmai->get_suivant_triangle(it))
401			{
402	francois	377	for (int k=0;k<dim_solution;k++)
403			{
404			double val=lire(i,num,k);
405			tri->change_solution(val,k);
406			if (val<solmin[k]) solmin[k]=val;
407			if (val>solmax[k]) solmax[k]=val;
408			}
409	francois	283	i++;
410			}
411	francois	308	LISTE_MG_QUADRANGLE::iterator it2;
412			for (MG_QUADRANGLE* quad=mgmai->get_premier_quadrangle(it2);quad!=NULL;quad=mgmai->get_suivant_quadrangle(it2))
413			{
414	francois	377	for (int k=0;k<dim_solution;k++)
415			{
416			double val=lire(i,num,k);
417			quad->change_solution(val,k);
418			if (val<solmin[k]) solmin[k]=val;
419			if (val>solmax[k]) solmax[k]=val;
420			}
421	francois	308	i++;
422			}
423	francois	283	}
424	francois	375	if (typeentite==MAGIC::ENTITE_SOLUTION::ENTITE_ELEMENT3)
425	francois	283	{
426			LISTE_MG_TETRA::iterator it;
427			for (MG_TETRA* tet=mgmai->get_premier_tetra(it);tet!=NULL;tet=mgmai->get_suivant_tetra(it))
428			{
429	francois	377	for (int k=0;k<dim_solution;k++)
430			{
431			double val=lire(i,num,k);
432			tet->change_solution(val,k);
433			if (val<solmin[k]) solmin[k]=val;
434			if (val>solmax[k]) solmax[k]=val;
435			}
436	francois	283	i++;
437			}
438	francois	308	LISTE_MG_HEXA::iterator it2;
439			for (MG_HEXA* hex=mgmai->get_premier_hexa(it2);hex!=NULL;hex=mgmai->get_suivant_hexa(it2))
440			{
441	francois	377	for (int k=0;k<dim_solution;k++)
442			{
443			double val=lire(i,num,k);
444			hex->change_solution(val,k);
445			if (val<solmin[k]) solmin[k]=val;
446			if (val>solmax[k]) solmax[k]=val;
447			}
448	francois	308	i++;
449			}
450	francois	283	}
451	francois	377	for (int k=0;k<dim_solution;k++)
452			if (OPERATEUR::egal(fabs(solmin[k]-solmax[k]),0.,1e-10)==1)
453			solmax[k]=solmin[k]+1e-10;
454	francois	283	}
455
456			std::string MG_SOLUTION::get_nom(void)
457			{
458			return nomsolution;
459			}
460	francois	326	std::string MG_SOLUTION::get_nom_fichier(void)
461			{
462			return nom_fichier;
463			}
464	francois	763	void MG_SOLUTION::enregistrer(std::ostream& o,double version)
465	francois	283	{
466	francois	377	o << "%" << get_id() << "=SOLUTION(" << typeentite << "," << dim_solution << "," << nomsolution << ",$" << mgmai->get_id() << "," << nb_champs << "," << nom_fichier << ",(";
467	francois	283	for (int i=0;i<nb_champs;i++)
468			{
469			o << legende[i];
470			if (i!=nb_champs-1) o<<",";
471			else o<<")";
472			}
473
474
475			o << ");" << std::endl;
476			}
477
478	francois	910	void MG_SOLUTION::get_fichier_dependant(std::vector<std::string> &liste_fichier)
479			{
480
481			}
482
483	francois	635	int MG_SOLUTION::get_entite_solution(void)
484	francois	283	{
485			return typeentite;
486			}
487
488
489
490			std::ostream& operator << (std::ostream& o,MG_SOLUTION& sol)
491			{
492	francois	763	sol.enregistrer(o,VERSIONFICHIER);
493	francois	283	return o;
494			}
495
496