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
#	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	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 * <