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
#	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	picher	219
57	picher	217	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	picher	219
70	picher	217	bool verifier;
71			bool fini;
72	picher	219
73	picher	217	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	picher	219	struct conserver_element element = (struct conserver_element) malloc(sizeof(struct conserver_element)*(_dernier_element+1));
212			ulong t_etudier[_dernier_element+1];
213
214	picher	217	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 * <