ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/REPOS_ERICCA/magic/lib/geometrie/src/mg_solution.cpp
Revision: 635
Committed: Fri Jan 16 22:48:47 2015 UTC (10 years, 3 months ago) by francois
File size: 13663 byte(s)
Log Message: 
Generalisation de la projection d'une solution sur un maillage avec gestion d'erreur

File Contents

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