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)
  
  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");

  struct conserver_element *element = (struct conserver_element*) malloc(sizeof(struct conserver_element)*(_dernier_element+1));
  ulong t_etudier[_dernier_element+1];

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