optimisation/src/detection_flottant.cpp

///////////////////////////////////////////////////////////
/////////////Détection des éléments flottants//////////////
///////////////////version 20090915////////////////////////
////Par Jérémy moureaux & Gilles-Philippe P.Martel/////////
///////////////////////////////////////////////////////////

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <ctime>

#include "bib_0000.h"
#include "bib_m000.h"
#include "bib_m001.h"
#include "element_com.h"
#include "etude_com.h"
#include "gm_com.h"
#include "gn_com.h"
#include "maillage_com.h"
#include "noeuds_com.h"
#include "structure.h"

using namespace std;

int main(int argc, char **argv )
{

        ///////////////////////////////////////////////
        //////////Variables, constantes et/////////////
        /////////paramďż˝tres nďż˝cessaires pour///////////
        /////////la routine d'optimisation/////////////
        ///////////////////////////////////////////////

  o_etude_com       *m_ptr_etude                            ;
  ptr_o_element_com  m_element                              ;
  ptr_o_gm_com       m_gm                                   ;

  char              m_nom_fic_parametre[co_lcc_max_nom_fic] ;
  char              m_nom_fic_etude[co_lcc_max_nom_fic]     ;
  char              m_nom_fic_densite[co_lcc_max_nom_fic]   ;
  char              m_nom_fic_flottant[co_lcc_max_nom_fic]  ;
  char              m_nom_gm[co_lcc_max_nom_gm]             ;
  char              m_nom_fic_mail[co_lcc_max_nom_fic]      ;

  ulong _premier_element   ;         //Numďż˝ro du premier ďż˝lďż˝ment 3D du modďż˝le
  ulong _dernier_element   ;         //nombre d'ďż˝lďż˝ments du modďż˝le
  ulong m_nbr_gm           ;         //Nombre de groupes de mailles du modďż˝le
  ulong m_no_gm            ;         //Numďż˝ro d'un groupe de maille
  ulong _type              ;         //Entier correspondant au type d'ďż˝lďż˝ment
  ulong no_temp            ;
  ulong no_element_face[5] ;
  ulong *no_element_f      ;
  vifl seuil = 0.8         ;         //Seuil pour la visualisation des éléments conservés (0.8 par défaut)
  struct conserver_element *element = (struct conserver_element*) malloc(sizeof(struct conserver_element)*(_dernier_element+1));
  ulong t_etudier[_dernier_element+1];
  ulong temporaire;
  ulong nbr_voi_type_f;
  ulong b;
  ulong c;
  ulong e;
  ulong g;
  ulong i;
  ulong l;
  ulong n;
  ulong t;
  ulong y;
  ulong _no;
  bool verifier;
  bool fini;
  ptr_o_maillage_com  m_maillage; 
  
  //Acquisition des paramďż˝tres de l'ďż˝tude
  for (i=0;i<argc;i++)
          {
          if (strcmp(argv[i],"-fichier")==0) strcpy(m_nom_fic_parametre,argv[i+1]);
          if (strcmp(argv[i],"-seuil")==0) seuil=atof(argv[i+1]);
          }

  FILE* parametres=fopen(m_nom_fic_parametre,"rt");
  char message[100];
  fgets(message,100,parametres);
  sscanf(message,"%s",&m_nom_fic_etude);

  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  //-- initialisation de modules et allocation de l'ďż˝tude ----------------------

  printf( "\n\n-------------------------------------------------------\n" );
  printf(     "-- initialisation des modules -------------------------\n" );

  init_etude_com( ) ;

  printf( "\nfait.\n" );

  printf( "\n-------------------------------------------------------\n" );
  printf(   "-- allocation de l'ďż˝tude ------------------------------\n" );

  m_ptr_etude = (o_etude_com *) NULL;

  m_ptr_etude = new o_etude_com;

  if( m_ptr_etude == (o_etude_com *) NULL ) {

    printf( "\nbobo\n" );

    return( co_probleme );

  }

  printf( "\nfait.\n" );

  char str[80];

  strcpy(str,"./");
  strcat(str,m_nom_fic_etude);
  strcat(str,"1.mail");
  strcpy( &m_nom_fic_mail[0], str);
  strcpy(str,"./");
  strcat(str,m_nom_fic_etude);
  strcat(str,"_densite.txt");
  strcpy( &m_nom_fic_densite[0], str);
  strcpy(str,"./");
  strcat(str,m_nom_fic_etude);
  strcat(str,"_flottant.txt");
  strcpy( &m_nom_fic_flottant[0], str);

  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  //-- dďż˝finition des noms des fichiers maillage et rďż˝sultats ------------------

  printf( "\n-------------------------------------------------------\n" );
  printf(   "--dďż˝finition du nom du fichier .mail\n" );


  if( m_ptr_etude->def_nom_fic( (char *) &m_nom_fic_mail[0] )
                                                     != co_nom_fic_mail ) {

    printf( "\nbobo\n" );

    delete m_ptr_etude;

    return( co_probleme );                                                      // bobo

  }


  printf( "\nfait.\n" );

  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------

  printf( "\n-------------------------------------------------------\n" );
  printf(   "-- rďż˝cupďż˝ration du maillage ---------------------------\n" );

  if( m_ptr_etude->recup_mail( ) != co_pas_de_probleme ) {

    delete m_ptr_etude;

    return( co_probleme );                                                      // bobo

  }

  printf( "\nfait.\n" );


  //Dďż˝termination du numďż˝ro du dernier ďż˝lďż˝ment du maillage
  m_ptr_etude->ren_nbr_elements(&_dernier_element);

  //Dďż˝termination du numďż˝ro du premier ďż˝lďż˝ment du maillage 3D
  for (i=1;i<=_dernier_element;i++)
        {
         m_ptr_etude->ren_element( (ulong)                i         ,
                                 (ptr_o_element_com *)   &m_element );
         m_element->ren_type     (                       &_type     );

        if (_type == co_type_el_aster_TETRA4)
                {
                _premier_element = i;
                break;
                }
        else if (_type == co_type_el_aster_TETRA10)
                {
                _premier_element = i;
                break;
                }
        }

  //Dďż˝termination du nombre de groupes de mailles du maillage
  m_ptr_etude->ren_nbr_gm((ulong *) &m_nbr_gm);


  //Allocation de la mďż˝moire nďż˝cessaire dans les tableaux
  vifl *densite = (vifl*) malloc (sizeof(vifl)*(_dernier_element+1))      ;     //vecteur des variables densitďż˝s pour chaque ďż˝lďż˝ment

  printf("Acquisition du vecteur densite ŕ partir du fichier texte correspondant\n");

  FILE* densite_final=fopen(m_nom_fic_densite,"rt");
  fgets(message,100,densite_final);
  for (i=_premier_element ; i <= _dernier_element ; i++) 
  {
  fgets(message,100,densite_final);
  sscanf(message,"%lu %lf",&no_temp,&densite[i]);
  }


  printf("Debut de la détection des éléments flottants\n");

  for (i=1 ; i <= _dernier_element ; i++) //initialisation de la structure
  {
  element[i].numero=i;
  element[i].conserver= false;
  element[i].etudier = false;
  }

  for (m_no_gm = 1;m_no_gm<=m_nbr_gm;m_no_gm++) // on vient pointer sur le groupe non design
        {
        m_ptr_etude->ren_gm((ulong) m_no_gm, (ptr_o_gm_com *) &m_gm);
        m_gm->ren_nom((char *) &m_nom_gm);
        if (strcmp(m_nom_gm,"GMN2 ")==0)
                {
                break;
                }
        }
  
  for (i=_premier_element ; i <= _dernier_element ; i++) // on conserve les elements de la partie non-design
  {
  if (m_gm -> element_dans_gm(i) == co_oui)
    {
    element[i].conserver = true;
    }
  }

  FILE* fichier = fopen ("non-design.txt","wt");
  for (i=_premier_element ; i <= _dernier_element ; i++)
  {
  if (element[i].conserver == true)
  {
  fprintf(fichier,"%lu\n",i);
}  
}

  fclose(fichier);


  for (i=_premier_element ; i <= _dernier_element ; i++) //on prend le premier element de la partie non design au hasard
  {
  if(element[i].conserver == true)
    {
    temporaire = i;
    break;
    }
  }

  for (i=1 ; i <= _dernier_element ; i++) // on initialise le tableau qui verifie si on a etudier l element
  {
  t_etudier[i] = 0;
  }

  m_ptr_etude -> ren_maillage( (ptr_o_maillage_com *) &m_maillage );
  printf("Recherche des voisins de face commune\n");
  m_maillage -> trouve_voisins_sg2();
  t_etudier[temporaire] = temporaire ;

  fini = false;


do {

  m_ptr_etude -> ren_element (temporaire , &m_element);
  m_element->ren_no((ulong*) &_no);
  m_element -> ren_nbr_voi_type_f (&nbr_voi_type_f);
  amem ((ulong **) &no_element_f , (ulong) nbr_voi_type_f);
  m_element -> ren_voi_type_f (&no_element_f[1]); //on stocke dans un tableau les numeros des voisins avec face commune
  t_etudier[temporaire]=0; // l element temporaire a été étudié , donc on met a 0 pour ne pas le reetudier plus tard
  element[temporaire].etudier = true;

  for (c=1 ; c <= nbr_voi_type_f ; c++) /* on va chercher les voisins ayant une face commune dans le tableau no_element afin de les conserver*/
    {
    g = no_element_f[c];
    if ( densite[g] >= seuil )
      {
      element[g].conserver = true;
      }
    if (element[g].etudier == false && densite[g] >= seuil)
      {
      t_etudier[g] = g; // si l element n a pas deja été étudié, on stocke son numero ds le tableau.
      }
    }


  y = nbr_voi_type_f;
  
  for (l=1 ; l <= y ; l++) // maintenant on etudie tous les voisins a faces communes de l element temporaire
  {
  e = no_element_f[l];
  if ( element[e].etudier == false )
    {
    if ( densite[e] >= seuil )
      {
      element[e].etudier = true;
      t_etudier[e] = 0;
      m_ptr_etude -> ren_element (e , &m_element);
      m_element -> ren_nbr_voi_type_f (&nbr_voi_type_f);
      m_element -> ren_voi_type_f (&no_element_face[1]);

      for (n=1 ; n <= nbr_voi_type_f ; n++)
        {
        t = no_element_face[n];
        if ( densite[t] >= seuil )
          {
          element[t].conserver = true; // on conserve les voisins des voisins de temporaire
          }
        if ( element[t].etudier == false && densite[t] >= seuil )
          {
          t_etudier[t] = t; // si l element n a pas deja été étudié, on stocke son numero ds le tableau.
          }
        }
      }
    }
  }
free(no_element_f);


  verifier = false;

  b=_premier_element;

  do {
  
  if(t_etudier[b] != 0)
    {
    temporaire = t_etudier[b]; // on prend le premier element non etudié sous la main et on lui donne la valeur temporaire pour l etudier
    verifier = true;
    }
  else if ((t_etudier[b] == 0) && (b == _dernier_element)) // si tous les elements du tableau sont nuls
    {
    verifier = true;
    fini = true; // tous les elements on été étudiés (puisque tous nuls dans le tableau) donc on on sort de la grosse boucle
    }
   b=b+1;
  } while (verifier == false);

  }while (fini == false);  

  //ecriture des résultats dans un fichier texte/
  FILE* fichier_final = fopen (m_nom_fic_flottant,"wt");
  for (i=_premier_element ; i <= _dernier_element ; i++)
  {
      if ((element[i].conserver == true) && (densite[i] >= seuil))
      {
      fprintf(fichier_final,"%lu        1\n",i);
      }  
      else
      {
      fprintf(fichier_final,"%lu        0\n",i);
      }
  }
  fclose(fichier_final);

     
  printf("Fin de la détection des éléments flottant");

  printf( "\n\n-------------------------------------------------------\n" );
  printf(     "-- finitialisation des modules ------------------------\n" );

  //LibĂ©ration de la mĂ©moire utilisĂ©e dans les tableaux
  
   free( densite      );

  finit_etude_com( ) ;

  printf( "\nfait.\n" );

  printf( "\nfin.\n\n\n\n\n" );

  return (co_pas_de_probleme);

}

//* [ FreSOP - base ] ********************************* optimisation_topo.cpp * <
Revision:	217
Committed:	Tue Nov 10 18:24:50 2009 UTC (15 years, 6 months ago) by picher
File size:	11427 byte(s)
Log Message:	Ajout d'une procedure de detection et suppression des elements flottants pour les resultats d'optimisation topologique
#	User	Rev	Content
1	picher	217	///////////////////////////////////////////////////////////
2			/////////////Détection des éléments flottants//////////////
3			///////////////////version 20090915////////////////////////
4			////Par Jérémy moureaux & Gilles-Philippe P.Martel/////////
5			///////////////////////////////////////////////////////////
6
7			#include <iostream>
8			#include <stdio.h>
9			#include <stdlib.h>
10			#include <string.h>
11			#include <math.h>
12			#include <ctime>
13
14			#include "bib_0000.h"
15			#include "bib_m000.h"
16			#include "bib_m001.h"
17			#include "element_com.h"
18			#include "etude_com.h"
19			#include "gm_com.h"
20			#include "gn_com.h"
21			#include "maillage_com.h"
22			#include "noeuds_com.h"
23			#include "structure.h"
24
25			using namespace std;
26
27			int main(int argc, char **argv )
28			{
29
30			///////////////////////////////////////////////
31			//////////Variables, constantes et/////////////
32			/////////paramďż˝tres nďż˝cessaires pour///////////
33			/////////la routine d'optimisation/////////////
34			///////////////////////////////////////////////
35
36			o_etude_com *m_ptr_etude ;
37			ptr_o_element_com m_element ;
38			ptr_o_gm_com m_gm ;
39
40			char m_nom_fic_parametre[co_lcc_max_nom_fic] ;
41			char m_nom_fic_etude[co_lcc_max_nom_fic] ;
42			char m_nom_fic_densite[co_lcc_max_nom_fic] ;
43			char m_nom_fic_flottant[co_lcc_max_nom_fic] ;
44			char m_nom_gm[co_lcc_max_nom_gm] ;
45			char m_nom_fic_mail[co_lcc_max_nom_fic] ;
46
47			ulong _premier_element ; //Numďż˝ro du premier ďż˝lďż˝ment 3D du modďż˝le
48			ulong _dernier_element ; //nombre d'ďż˝lďż˝ments du modďż˝le
49			ulong m_nbr_gm ; //Nombre de groupes de mailles du modďż˝le
50			ulong m_no_gm ; //Numďż˝ro d'un groupe de maille
51			ulong _type ; //Entier correspondant au type d'ďż˝lďż˝ment
52			ulong no_temp ;
53			ulong no_element_face[5] ;
54			ulong *no_element_f ;
55			vifl seuil = 0.8 ; //Seuil pour la visualisation des éléments conservés (0.8 par défaut)
56			struct conserver_element element = (struct conserver_element) malloc(sizeof(struct conserver_element)*(_dernier_element+1));
57			ulong t_etudier[_dernier_element+1];
58			ulong temporaire;
59			ulong nbr_voi_type_f;
60			ulong b;
61			ulong c;
62			ulong e;
63			ulong g;
64			ulong i;
65			ulong l;
66			ulong n;
67			ulong t;
68			ulong y;
69			ulong _no;
70			bool verifier;
71			bool fini;
72			ptr_o_maillage_com m_maillage;
73
74			//Acquisition des paramďż˝tres de l'ďż˝tude
75			for (i=0;i<argc;i++)
76			{
77			if (strcmp(argv[i],"-fichier")==0) strcpy(m_nom_fic_parametre,argv[i+1]);
78			if (strcmp(argv[i],"-seuil")==0) seuil=atof(argv[i+1]);
79			}
80
81			FILE* parametres=fopen(m_nom_fic_parametre,"rt");
82			char message[100];
83			fgets(message,100,parametres);
84			sscanf(message,"%s",&m_nom_fic_etude);
85
86			//----------------------------------------------------------------------------
87			//----------------------------------------------------------------------------
88			//-- initialisation de modules et allocation de l'ďż˝tude ----------------------
89
90			printf( "\n\n-------------------------------------------------------\n" );
91			printf( "-- initialisation des modules -------------------------\n" );
92
93			init_etude_com( ) ;
94
95			printf( "\nfait.\n" );
96
97			printf( "\n-------------------------------------------------------\n" );
98			printf( "-- allocation de l'ďż˝tude ------------------------------\n" );
99
100			m_ptr_etude = (o_etude_com *) NULL;
101
102			m_ptr_etude = new o_etude_com;
103
104			if( m_ptr_etude == (o_etude_com *) NULL ) {
105
106			printf( "\nbobo\n" );
107
108			return( co_probleme );
109
110			}
111
112			printf( "\nfait.\n" );
113
114			char str[80];
115
116			strcpy(str,"./");
117			strcat(str,m_nom_fic_etude);
118			strcat(str,"1.mail");
119			strcpy( &m_nom_fic_mail[0], str);
120			strcpy(str,"./");
121			strcat(str,m_nom_fic_etude);
122			strcat(str,"_densite.txt");
123			strcpy( &m_nom_fic_densite[0], str);
124			strcpy(str,"./");
125			strcat(str,m_nom_fic_etude);
126			strcat(str,"_flottant.txt");
127			strcpy( &m_nom_fic_flottant[0], str);
128
129			//----------------------------------------------------------------------------
130			//----------------------------------------------------------------------------
131			//-- dďż˝finition des noms des fichiers maillage et rďż˝sultats ------------------
132
133			printf( "\n-------------------------------------------------------\n" );
134			printf( "--dďż˝finition du nom du fichier .mail\n" );
135
136
137			if( m_ptr_etude->def_nom_fic( (char *) &m_nom_fic_mail[0] )
138			!= co_nom_fic_mail ) {
139
140			printf( "\nbobo\n" );
141
142			delete m_ptr_etude;
143
144			return( co_probleme ); // bobo
145
146			}
147
148
149			printf( "\nfait.\n" );
150
151			//----------------------------------------------------------------------------
152			//----------------------------------------------------------------------------
153
154			printf( "\n-------------------------------------------------------\n" );
155			printf( "-- rďż˝cupďż˝ration du maillage ---------------------------\n" );
156
157			if( m_ptr_etude->recup_mail( ) != co_pas_de_probleme ) {
158
159			delete m_ptr_etude;
160
161			return( co_probleme ); // bobo
162
163			}
164
165			printf( "\nfait.\n" );
166
167
168			//Dďż˝termination du numďż˝ro du dernier ďż˝lďż˝ment du maillage
169			m_ptr_etude->ren_nbr_elements(&_dernier_element);
170
171			//Dďż˝termination du numďż˝ro du premier ďż˝lďż˝ment du maillage 3D
172			for (i=1;i<=_dernier_element;i++)
173			{
174			m_ptr_etude->ren_element( (ulong) i ,
175			(ptr_o_element_com *) &m_element );
176			m_element->ren_type ( &_type );
177
178			if (_type == co_type_el_aster_TETRA4)
179			{
180			_premier_element = i;
181			break;
182			}
183			else if (_type == co_type_el_aster_TETRA10)
184			{
185			_premier_element = i;
186			break;
187			}
188			}
189
190			//Dďż˝termination du nombre de groupes de mailles du maillage
191			m_ptr_etude->ren_nbr_gm((ulong *) &m_nbr_gm);
192
193
194			//Allocation de la mďż˝moire nďż˝cessaire dans les tableaux
195			vifl densite = (vifl) malloc (sizeof(vifl)*(_dernier_element+1)) ; //vecteur des variables densitďż˝s pour chaque ďż˝lďż˝ment
196
197			printf("Acquisition du vecteur densite ŕ partir du fichier texte correspondant\n");
198
199			FILE* densite_final=fopen(m_nom_fic_densite,"rt");
200			fgets(message,100,densite_final);
201			for (i=_premier_element ; i <= _dernier_element ; i++)
202			{
203			fgets(message,100,densite_final);
204			sscanf(message,"%lu %lf",&no_temp,&densite[i]);
205			}
206
207
208			printf("Debut de la détection des éléments flottants\n");
209
210			for (i=1 ; i <= _dernier_element ; i++) //initialisation de la structure
211			{
212			element[i].numero=i;
213			element[i].conserver= false;
214			element[i].etudier = false;
215			}
216
217			for (m_no_gm = 1;m_no_gm<=m_nbr_gm;m_no_gm++) // on vient pointer sur le groupe non design
218			{
219			m_ptr_etude->ren_gm((ulong) m_no_gm, (ptr_o_gm_com *) &m_gm);
220			m_gm->ren_nom((char *) &m_nom_gm);
221			if (strcmp(m_nom_gm,"GMN2 ")==0)
222			{
223			break;
224			}
225			}
226
227			for (i=_premier_element ; i <= _dernier_element ; i++) // on conserve les elements de la partie non-design
228			{
229			if (m_gm -> element_dans_gm(i) == co_oui)
230			{
231			element[i].conserver = true;
232			}
233			}
234
235			FILE* fichier = fopen ("non-design.txt","wt");
236			for (i=_premier_element ; i <= _dernier_element ; i++)
237			{
238			if (element[i].conserver == true)
239			{
240			fprintf(fichier,"%lu\n",i);
241			}
242			}
243
244			fclose(fichier);
245
246
247			for (i=_premier_element ; i <= _dernier_element ; i++) //on prend le premier element de la partie non design au hasard
248			{
249			if(element[i].conserver == true)
250			{
251			temporaire = i;
252			break;
253			}
254			}
255
256			for (i=1 ; i <= _dernier_element ; i++) // on initialise le tableau qui verifie si on a etudier l element
257			{
258			t_etudier[i] = 0;
259			}
260
261			m_ptr_etude -> ren_maillage( (ptr_o_maillage_com *) &m_maillage );
262			printf("Recherche des voisins de face commune\n");
263			m_maillage -> trouve_voisins_sg2();
264			t_etudier[temporaire] = temporaire ;
265
266			fini = false;
267
268
269			do {
270
271			m_ptr_etude -> ren_element (temporaire , &m_element);
272			m_element->ren_no((ulong*) &_no);
273			m_element -> ren_nbr_voi_type_f (&nbr_voi_type_f);
274			amem ((ulong **) &no_element_f , (ulong) nbr_voi_type_f);
275			m_element -> ren_voi_type_f (&no_element_f[1]); //on stocke dans un tableau les numeros des voisins avec face commune
276			t_etudier[temporaire]=0; // l element temporaire a été étudié , donc on met a 0 pour ne pas le reetudier plus tard
277			element[temporaire].etudier = true;
278
279			for (c=1 ; c <= nbr_voi_type_f ; c++) /* on va chercher les voisins ayant une face commune dans le tableau no_element afin de les conserver*/
280			{
281			g = no_element_f[c];
282			if ( densite[g] >= seuil )
283			{
284			element[g].conserver = true;
285			}
286			if (element[g].etudier == false && densite[g] >= seuil)
287			{
288			t_etudier[g] = g; // si l element n a pas deja été étudié, on stocke son numero ds le tableau.
289			}
290			}
291
292
293			y = nbr_voi_type_f;
294
295			for (l=1 ; l <= y ; l++) // maintenant on etudie tous les voisins a faces communes de l element temporaire
296			{
297			e = no_element_f[l];
298			if ( element[e].etudier == false )
299			{
300			if ( densite[e] >= seuil )
301			{
302			element[e].etudier = true;
303			t_etudier[e] = 0;
304			m_ptr_etude -> ren_element (e , &m_element);
305			m_element -> ren_nbr_voi_type_f (&nbr_voi_type_f);
306			m_element -> ren_voi_type_f (&no_element_face[1]);
307
308			for (n=1 ; n <= nbr_voi_type_f ; n++)
309			{
310			t = no_element_face[n];
311			if ( densite[t] >= seuil )
312			{
313			element[t].conserver = true; // on conserve les voisins des voisins de temporaire
314			}
315			if ( element[t].etudier == false && densite[t] >= seuil )
316			{
317			t_etudier[t] = t; // si l element n a pas deja été étudié, on stocke son numero ds le tableau.
318			}
319			}
320			}
321			}
322			}
323			free(no_element_f);
324
325
326			verifier = false;
327
328			b=_premier_element;
329
330			do {
331
332			if(t_etudier[b] != 0)
333			{
334			temporaire = t_etudier[b]; // on prend le premier element non etudié sous la main et on lui donne la valeur temporaire pour l etudier
335			verifier = true;
336			}
337			else if ((t_etudier[b] == 0) && (b == _dernier_element)) // si tous les elements du tableau sont nuls
338			{
339			verifier = true;
340			fini = true; // tous les elements on été étudiés (puisque tous nuls dans le tableau) donc on on sort de la grosse boucle
341			}
342			b=b+1;
343			} while (verifier == false);
344
345			}while (fini == false);
346
347			//ecriture des résultats dans un fichier texte/
348			FILE* fichier_final = fopen (m_nom_fic_flottant,"wt");
349			for (i=_premier_element ; i <= _dernier_element ; i++)
350			{
351			if ((element[i].conserver == true) && (densite[i] >= seuil))
352			{
353			fprintf(fichier_final,"%lu 1\n",i);
354			}
355			else
356			{
357			fprintf(fichier_final,"%lu 0\n",i);
358			}
359			}
360			fclose(fichier_final);
361
362
363			printf("Fin de la détection des éléments flottant");
364
365			printf( "\n\n-------------------------------------------------------\n" );
366			printf( "-- finitialisation des modules ------------------------\n" );
367
368			//LibĂ©ration de la mĂ©moire utilisĂ©e dans les tableaux
369
370			free( densite );
371
372			finit_etude_com( ) ;
373
374			printf( "\nfait.\n" );
375
376			printf( "\nfin.\n\n\n\n\n" );
377
378			return (co_pas_de_probleme);
379
380			}
381
382			//* [ FreSOP - base ] ********************************* optimisation_topo.cpp * <