Skip to content
Snippets Groups Projects
Commit 0f05e69e authored by Christophe Geuzaine's avatar Christophe Geuzaine
Browse files

Suppressed Post_Simplex structure

parent d47527ab
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Common/Views.cpp
+ 53
− 106
View file @ 0f05e69e
/* $Id: Views.cpp,v 1.6 2000-11-26 21:34:22 geuzaine Exp $ */
/* $Id: Views.cpp,v 1.7 2000-11-27 10:58:18 geuzaine Exp $ */
#include "Gmsh.h"
#include "Views.h"
......@@ -10,7 +10,8 @@ Post_View *ActualView;
extern Context_T CTX ;
static int ActualViewNum=0;
static int ActualViewNum=0;
static int NbPoints, NbLines, NbTriangles, NbTetrahedra;
/* ------------------------------------------------------------------------ */
/* V i e w s */
......@@ -27,6 +28,8 @@ int fcmpPostViewDuplicateOf(const void *v1, const void *v2){
void BeginView(int allocate){
ActualView = (Post_View*)Malloc(sizeof(Post_View));
NbPoints = NbLines = NbTriangles = NbTetrahedra = 0;
ActualView->NbSP = ActualView->NbVP = ActualView->NbTP = 0;
ActualView->NbSL = ActualView->NbVL = ActualView->NbTL = 0;
ActualView->NbST = ActualView->NbVT = ActualView->NbTT = 0;
......@@ -38,33 +41,25 @@ void BeginView(int allocate){
ActualView->SP = List_Create(100,1000,sizeof(double));
ActualView->VP = List_Create(100,1000,sizeof(double));
ActualView->TP = List_Create(100,1000,sizeof(double));
ActualView->Points = List_Create(100,1000,sizeof(Post_Simplex));
ActualView->SL = List_Create(100,1000,sizeof(double));
ActualView->VL = List_Create(100,1000,sizeof(double));
ActualView->TL = List_Create(100,1000,sizeof(double));
ActualView->Lines = List_Create(100,1000,sizeof(Post_Simplex));
ActualView->ST = List_Create(100,1000,sizeof(double));
ActualView->VT = List_Create(100,1000,sizeof(double));
ActualView->TT = List_Create(100,1000,sizeof(double));
ActualView->Triangles = List_Create(100,1000,sizeof(Post_Simplex));
ActualView->SS = List_Create(100,1000,sizeof(double));
ActualView->VS = List_Create(100,1000,sizeof(double));
ActualView->TS = List_Create(100,1000,sizeof(double));
ActualView->Tetrahedra = List_Create(100,1000,sizeof(Post_Simplex));
}
else{
ActualView->Time = NULL;
ActualView->SP = NULL; ActualView->VP = NULL; ActualView->TP = NULL;
ActualView->Points = NULL;
ActualView->SL = NULL; ActualView->VL = NULL; ActualView->TL = NULL;
ActualView->Lines = NULL;
ActualView->ST = NULL; ActualView->VT = NULL; ActualView->TT = NULL;
ActualView->Triangles = NULL;
ActualView->SS = NULL; ActualView->VS = NULL; ActualView->TS = NULL;
ActualView->Tetrahedra = NULL;
}
ActualView->Changed = 1;
......@@ -108,20 +103,20 @@ void EndView(int AddInUI, int Number, char *FileName, char *Name,
if(ActualView->NbSP){
nb = List_Nbr(ActualView->SP) / ActualView->NbSP ;
for(i = 0 ; i < List_Nbr(ActualView->SP) ; i+=nb)
AddView_ScalarSimplex(0, (double*)List_Pointer(ActualView->SP,i),
nb-3, (double*)List_Pointer(ActualView->SP,i+3));
Stat_ScalarSimplex(0, (double*)List_Pointer(ActualView->SP,i),
nb-3, (double*)List_Pointer(ActualView->SP,i+3));
}
if(ActualView->NbVP){
nb = List_Nbr(ActualView->VP) / ActualView->NbVP ;
for(i = 0 ; i < List_Nbr(ActualView->VP) ; i+=nb)
AddView_VectorSimplex(0, (double*)List_Pointer(ActualView->VP,i),
nb-3, (double*)List_Pointer(ActualView->VP,i+3));
Stat_VectorSimplex(0, (double*)List_Pointer(ActualView->VP,i),
nb-3, (double*)List_Pointer(ActualView->VP,i+3));
}
if(ActualView->NbTP){
nb = List_Nbr(ActualView->TP) / ActualView->NbTP ;
for(i = 0 ; i < List_Nbr(ActualView->TP) ; i+=nb)
AddView_TensorSimplex(0, (double*)List_Pointer(ActualView->TP,i),
nb-3, (double*)List_Pointer(ActualView->TP,i+3));
Stat_TensorSimplex(0, (double*)List_Pointer(ActualView->TP,i),
nb-3, (double*)List_Pointer(ActualView->TP,i+3));
}
// Lines
......@@ -129,20 +124,20 @@ void EndView(int AddInUI, int Number, char *FileName, char *Name,
if(ActualView->NbSL){
nb = List_Nbr(ActualView->SL) / ActualView->NbSL ;
for(i = 0 ; i < List_Nbr(ActualView->SL) ; i+=nb)
AddView_ScalarSimplex(1, (double*)List_Pointer(ActualView->SL,i),
nb-6, (double*)List_Pointer(ActualView->SL,i+6));
Stat_ScalarSimplex(1, (double*)List_Pointer(ActualView->SL,i),
nb-6, (double*)List_Pointer(ActualView->SL,i+6));
}
if(ActualView->NbVL){
nb = List_Nbr(ActualView->VL) / ActualView->NbVL ;
for(i = 0 ; i < List_Nbr(ActualView->VL) ; i+=nb)
AddView_VectorSimplex(1, (double*)List_Pointer(ActualView->VL,i),
nb-6, (double*)List_Pointer(ActualView->VL,i+6));
Stat_VectorSimplex(1, (double*)List_Pointer(ActualView->VL,i),
nb-6, (double*)List_Pointer(ActualView->VL,i+6));
}
if(ActualView->NbTL){
nb = List_Nbr(ActualView->TL) / ActualView->NbTL ;
for(i = 0 ; i < List_Nbr(ActualView->TL) ; i+=nb)
AddView_TensorSimplex(1, (double*)List_Pointer(ActualView->TL,i),
nb-6, (double*)List_Pointer(ActualView->TL,i+6));
Stat_TensorSimplex(1, (double*)List_Pointer(ActualView->TL,i),
nb-6, (double*)List_Pointer(ActualView->TL,i+6));
}
// Triangles
......@@ -150,20 +145,20 @@ void EndView(int AddInUI, int Number, char *FileName, char *Name,
if(ActualView->NbST){
nb = List_Nbr(ActualView->ST) / ActualView->NbST ;
for(i = 0 ; i < List_Nbr(ActualView->ST) ; i+=nb)
AddView_ScalarSimplex(2, (double*)List_Pointer(ActualView->ST,i),
nb-9, (double*)List_Pointer(ActualView->ST,i+9));
Stat_ScalarSimplex(2, (double*)List_Pointer(ActualView->ST,i),
nb-9, (double*)List_Pointer(ActualView->ST,i+9));
}
if(ActualView->NbVT){
nb = List_Nbr(ActualView->VT) / ActualView->NbVT ;
for(i = 0 ; i < List_Nbr(ActualView->VT) ; i+=nb)
AddView_VectorSimplex(2, (double*)List_Pointer(ActualView->VT,i),
nb-9, (double*)List_Pointer(ActualView->VT,i+9));
Stat_VectorSimplex(2, (double*)List_Pointer(ActualView->VT,i),
nb-9, (double*)List_Pointer(ActualView->VT,i+9));
}
if(ActualView->NbTT){
nb = List_Nbr(ActualView->TT) / ActualView->NbTT ;
for(i = 0 ; i < List_Nbr(ActualView->TT) ; i+=nb)
AddView_TensorSimplex(2, (double*)List_Pointer(ActualView->TT,i),
nb-9, (double*)List_Pointer(ActualView->TT,i+9));
Stat_TensorSimplex(2, (double*)List_Pointer(ActualView->TT,i),
nb-9, (double*)List_Pointer(ActualView->TT,i+9));
}
// Tetrahedra
......@@ -171,20 +166,20 @@ void EndView(int AddInUI, int Number, char *FileName, char *Name,
if(ActualView->NbSS){
nb = List_Nbr(ActualView->SS) / ActualView->NbSS ;
for(i = 0 ; i < List_Nbr(ActualView->SS) ; i+=nb)
AddView_ScalarSimplex(3, (double*)List_Pointer(ActualView->SS,i),
nb-12, (double*)List_Pointer(ActualView->SS,i+12));
Stat_ScalarSimplex(3, (double*)List_Pointer(ActualView->SS,i),
nb-12, (double*)List_Pointer(ActualView->SS,i+12));
}
if(ActualView->NbVS){
nb = List_Nbr(ActualView->VS) / ActualView->NbVS ;
for(i = 0 ; i < List_Nbr(ActualView->VS) ; i+=nb)
AddView_VectorSimplex(3, (double*)List_Pointer(ActualView->VS,i),
nb-12, (double*)List_Pointer(ActualView->VS,i+12));
Stat_VectorSimplex(3, (double*)List_Pointer(ActualView->VS,i),
nb-12, (double*)List_Pointer(ActualView->VS,i+12));
}
if(ActualView->NbTS){
nb = List_Nbr(ActualView->TS) / ActualView->NbTS ;
for(i = 0 ; i < List_Nbr(ActualView->TS) ; i+=nb)
AddView_TensorSimplex(3, (double*)List_Pointer(ActualView->TS,i),
nb-12, (double*)List_Pointer(ActualView->TS,i+12));
Stat_TensorSimplex(3, (double*)List_Pointer(ActualView->TS,i),
nb-12, (double*)List_Pointer(ActualView->TS,i+12));
}
// Dummy time values if using old parsed format...
......@@ -254,20 +249,11 @@ void FreeView(Post_View *v){
if(free && !v->Links){
Msg(DEBUG, " ->Freeing View");
List_Delete(v->Time);
List_Delete(v->SP); List_Delete(v->VP); List_Delete(v->TP);
List_Delete(v->Points);
List_Delete(v->SL); List_Delete(v->VL); List_Delete(v->TL);
List_Delete(v->Lines);
List_Delete(v->ST); List_Delete(v->VT); List_Delete(v->TT);
List_Delete(v->Triangles);
List_Delete(v->SS); List_Delete(v->VS); List_Delete(v->TS);
List_Delete(v->Tetrahedra);
}
}
......@@ -301,68 +287,52 @@ void CopyViewOptions(Post_View *src, Post_View *dest){
}
/* ------------------------------------------------------------------------ */
/* S c a l a r S i m p l e x */
/* S t a t _ X X X S i m p l e x */
/* ------------------------------------------------------------------------ */
void AddView_ScalarSimplex(int dim, double *coord, int N, double *v){
Post_Simplex S;
void Stat_ScalarSimplex(int dim, double *coord, int N, double *V){
int i,nbnod;
S.Type = DRAW_POST_SCALAR;
S.Dimension = dim;
double *X, *Y, *Z;
switch(dim){
case 0 : nbnod = 1 ; break; // point
case 1 : nbnod = 2 ; break; // line
case 2 : nbnod = 3 ; break; // triangle
case 3 : nbnod = 4 ; break; // tetrahedron
case 0 : nbnod = 1 ; NbPoints++; break;
case 1 : nbnod = 2 ; NbLines++; break;
case 2 : nbnod = 3 ; NbTriangles++; break;
case 3 : nbnod = 4 ; NbTetrahedra++; break;
}
S.X = &coord[0] ; S.Y = &coord[nbnod] ; S.Z = &coord[2*nbnod] ; S.V = v ;
X = &coord[0] ; Y = &coord[nbnod] ; Z = &coord[2*nbnod] ;
if(!List_Nbr(ActualView->Points) && !List_Nbr(ActualView->Lines) &&
!List_Nbr(ActualView->Triangles) && !List_Nbr(ActualView->Tetrahedra)){
ActualView->Min = S.V[0];
ActualView->Max = S.V[0];
if(NbPoints == 1 && NbLines == 1 && NbTriangles == 1 && NbTetrahedra == 1){
ActualView->Min = V[0];
ActualView->Max = V[0];
ActualView->NbTimeStep = N/nbnod;
}
else if(N/nbnod < ActualView->NbTimeStep)
ActualView->NbTimeStep = N/nbnod ;
for(i=0 ; i<N ; i++){
if(S.V[i] < ActualView->Min) ActualView->Min = S.V[i] ;
if(S.V[i] > ActualView->Max) ActualView->Max = S.V[i] ;
if(V[i] < ActualView->Min) ActualView->Min = V[i] ;
if(V[i] > ActualView->Max) ActualView->Max = V[i] ;
}
switch(dim){
case 0 : List_Add(ActualView->Points,&S); break;
case 1 : List_Add(ActualView->Lines,&S); break;
case 2 : List_Add(ActualView->Triangles,&S); break;
case 3 : List_Add(ActualView->Tetrahedra,&S); break;
}
}
void AddView_VectorSimplex(int dim, double *coord, int N, double *v){
Post_Simplex S;
void Stat_VectorSimplex(int dim, double *coord, int N, double *V){
double l0;
int nbnod, i;
S.Type = DRAW_POST_VECTOR;
S.Dimension = dim;
double *X, *Y, *Z;
switch(dim){
case 0 : nbnod = 1 ; break; // point
case 1 : nbnod = 2 ; break; // line
case 2 : nbnod = 3 ; break; // triangle
case 3 : nbnod = 4 ; break; // tetrahedron
case 0 : nbnod = 1 ; NbPoints++; break;
case 1 : nbnod = 2 ; NbLines++; break;
case 2 : nbnod = 3 ; NbTriangles++; break;
case 3 : nbnod = 4 ; NbTetrahedra++; break;
}
S.X = &coord[0] ; S.Y = &coord[nbnod] ; S.Z = &coord[2*nbnod] ; S.V = v ;
X = &coord[0] ; Y = &coord[nbnod] ; Z = &coord[2*nbnod] ;
if(!List_Nbr(ActualView->Points) && !List_Nbr(ActualView->Lines) &&
!List_Nbr(ActualView->Triangles) && !List_Nbr(ActualView->Tetrahedra)){
l0 = sqrt(DSQR(S.V[0])+DSQR(S.V[1])+DSQR(S.V[2]));
if(NbPoints == 1 && NbLines == 1 && NbTriangles == 1 && NbTetrahedra == 1){
l0 = sqrt(DSQR(V[0])+DSQR(V[1])+DSQR(V[2]));
ActualView->Min = l0;
ActualView->Max = l0;
ActualView->NbTimeStep = N/(3*nbnod) ;
......@@ -371,22 +341,15 @@ void AddView_VectorSimplex(int dim, double *coord, int N, double *v){
ActualView->NbTimeStep = N/(3*nbnod) ;
for(i=0 ; i<N ; i+=3){
l0 = sqrt(DSQR(S.V[i])+DSQR(S.V[i+1])+DSQR(S.V[i+2]));
l0 = sqrt(DSQR(V[i])+DSQR(V[i+1])+DSQR(V[i+2]));
if(l0 < ActualView->Min) ActualView->Min = l0 ;
if(l0 > ActualView->Max) ActualView->Max = l0 ;
}
ActualView->ScalarOnly = 0;
switch(dim){
case 0 : List_Add(ActualView->Points,&S); break;
case 1 : List_Add(ActualView->Lines,&S); break;
case 2 : List_Add(ActualView->Triangles,&S); break;
case 3 : List_Add(ActualView->Tetrahedra,&S); break;
}
}
void AddView_TensorSimplex(int dim, double *coord, int N, double *v){
void Stat_TensorSimplex(int dim, double *coord, int N, double *v){
Msg(ERROR, "Tensor Field Views not Implemented Yet");
}
......@@ -446,10 +409,6 @@ void Read_View(FILE *file, char *filename){
ActualView->Time = List_CreateFromFile(nbtimestep, sizeof(double), file, format);
if((nb = ActualView->NbSP + ActualView->NbVP + ActualView->NbTP))
ActualView->Points = List_Create(nb,1,sizeof(Post_Simplex));
else
ActualView->Points = NULL ;
nb = ActualView->NbSP ?
ActualView->NbSP * nbtimestep + ActualView->NbSP * 3 : 0 ;
ActualView->SP = List_CreateFromFile(nb, sizeof(double), file, format);
......@@ -460,10 +419,6 @@ void Read_View(FILE *file, char *filename){
ActualView->NbTP * nbtimestep * 9 + ActualView->NbTP * 3 : 0 ;
ActualView->TP = List_CreateFromFile(nb, sizeof(double), file, format);
if((nb = ActualView->NbSL + ActualView->NbVL + ActualView->NbTL))
ActualView->Lines = List_Create(nb,1,sizeof(Post_Simplex));
else
ActualView->Lines = NULL ;
nb = ActualView->NbSL ?
ActualView->NbSL * nbtimestep * 2 + ActualView->NbSL * 6 : 0 ;
ActualView->SL = List_CreateFromFile(nb, sizeof(double), file, format);
......@@ -474,10 +429,6 @@ void Read_View(FILE *file, char *filename){
ActualView->NbTL * nbtimestep * 2 * 9 + ActualView->NbTL * 6 : 0 ;
ActualView->TL = List_CreateFromFile(nb, sizeof(double), file, format);
if((nb = ActualView->NbST + ActualView->NbVT + ActualView->NbTT))
ActualView->Triangles = List_Create(nb,1,sizeof(Post_Simplex));
else
ActualView->Triangles = NULL ;
nb = ActualView->NbST ?
ActualView->NbST * nbtimestep * 3 + ActualView->NbST * 9 : 0 ;
ActualView->ST = List_CreateFromFile(nb, sizeof(double), file, format);
......@@ -488,10 +439,6 @@ void Read_View(FILE *file, char *filename){
ActualView->NbTT * nbtimestep * 3 * 9 + ActualView->NbTT * 9 : 0 ;
ActualView->TT = List_CreateFromFile(nb, sizeof(double), file, format);
if((nb = ActualView->NbSS + ActualView->NbVS + ActualView->NbTS))
ActualView->Tetrahedra = List_Create(nb,1,sizeof(Post_Simplex));
else
ActualView->Tetrahedra = NULL ;
nb = ActualView->NbSS ?
ActualView->NbSS * nbtimestep * 4 + ActualView->NbSS * 12 : 0 ;
ActualView->SS = List_CreateFromFile(nb, sizeof(double), file, format);
......
Common/Views.h
+ 12
− 23
View file @ 0f05e69e
/* $Id: Views.h,v 1.6 2000-11-26 15:43:45 geuzaine Exp $ */
/* $Id: Views.h,v 1.7 2000-11-27 10:58:18 geuzaine Exp $ */
#ifndef _VIEWS_H_
#define _VIEWS_H_
#include "Const.h"
typedef struct{
int Dimension, Type;
double *X, *Y, *Z, *V;
}Post_Simplex;
#include "ColorTable.h"
typedef struct{
......@@ -18,14 +12,14 @@ typedef struct{
/* the data */
List_T *Time;
int NbSP, NbVP, NbTP;
List_T *SP, *VP, *TP, *Points; // points
int NbSL, NbVL, NbTL;
List_T *SL, *VL, *TL, *Lines; // lines
int NbST, NbVT, NbTT;
List_T *ST, *VT, *TT, *Triangles; // triangles
int NbSS, NbVS, NbTS;
List_T *SS, *VS, *TS, *Tetrahedra; // tetrahedra
int NbPoints, NbSP, NbVP, NbTP;
List_T *SP, *VP, *TP; // points
int NbLines, NbSL, NbVL, NbTL;
List_T *SL, *VL, *TL; // lines
int NbTriangles, NbST, NbVT, NbTT;
List_T *ST, *VT, *TT; // triangles
int NbTetrahedra, NbSS, NbVS, NbTS;
List_T *SS, *VS, *TS; // tetrahedra
int NbTimeStep, ScalarOnly;
double Min, Max;
......@@ -45,11 +39,6 @@ typedef struct{
int (*GIFV) (double min, double max, int nb, double value);
}Post_View;
/* Type (The keys are important!) */
#define DRAW_POST_SCALAR 1
#define DRAW_POST_VECTOR 3
#define DRAW_POST_TENSOR 9
/* IntervalsType */
#define DRAW_POST_ISO 1
#define DRAW_POST_CONTINUOUS 2
......@@ -89,9 +78,9 @@ void FreeView(Post_View *v);
void Read_View(FILE *file, char *filename);
void CopyViewOptions(Post_View *src, Post_View *dest);
void AddView_ScalarSimplex(int dim, double *coord, int N, double *v);
void AddView_VectorSimplex(int dim, double *coord, int N, double *v);
void AddView_TensorSimplex(int dim, double *coord, int N, double *v);
void Stat_ScalarSimplex(int dim, double *coord, int N, double *v);
void Stat_VectorSimplex(int dim, double *coord, int N, double *v);
void Stat_TensorSimplex(int dim, double *coord, int N, double *v);
int BGMWithView (Post_View *ErrView);
int CreateBGM(Post_View *ErrView, int OptiMethod, double Degree,
......
Graphics/Draw.h
+ 37
− 9
View file @ 0f05e69e
/* $Id: Draw.h,v 1.6 2000-11-26 15:43:46 geuzaine Exp $ */
/* $Id: Draw.h,v 1.7 2000-11-27 10:58:54 geuzaine Exp $ */
#ifndef _DRAW_H_
#define _DRAW_H_
......@@ -73,13 +73,41 @@ void Draw_Simplex_Volume (void *a, void *b);
void Draw_Hexahedron_Volume (void *a, void *b);
void Draw_Prism_Volume (void *a, void *b);
void Draw_Post_Tetrahedron (Post_View * View, Post_Simplex * s,
double ValMin, double ValMax, double Raise[3][5]);
void Draw_Post_Triangle (Post_View * View, Post_Simplex * t,
double ValMin, double ValMax, double Raise[3][5]);
void Draw_Post_Line (Post_View * View, Post_Simplex * l,
double ValMin, double ValMax, double Raise[3][5]);
void Draw_Post_Point (Post_View * View, Post_Simplex * p,
double ValMin, double ValMax, double Raise[3][5]);
void Draw_ScalarPoint(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V);
void Draw_VectorPoint(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V);
void Draw_TensorPoint(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V);
void Draw_ScalarLine(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V);
void Draw_VectorLine(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V);
void Draw_TensorLine(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V);
void Draw_ScalarTriangle(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V);
void Draw_VectorTriangle(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V);
void Draw_TensorTriangle(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V);
void Draw_ScalarTetrahedron(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V);
void Draw_VectorTetrahedron(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V);
void Draw_TensorTetrahedron(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V);
#endif
Graphics/Post.cpp
+ 126
− 27
View file @ 0f05e69e
/* $Id: Post.cpp,v 1.5 2000-11-26 15:43:46 geuzaine Exp $ */
/* $Id: Post.cpp,v 1.6 2000-11-27 10:58:54 geuzaine Exp $ */
#include "Gmsh.h"
#include "GmshUI.h"
......@@ -79,15 +79,15 @@ void RaiseFill(int i, double Val, double ValMin, double Raise[3][5]){
------------------------------------------------------------------------ */
void Draw_Post (void) {
int i,j,k,n;
int iView,i,j,k,nb;
double ValMin,ValMax,AbsMax;
Post_View *v;
if(!Post_ViewList) return;
for(i=0 ; i<List_Nbr(Post_ViewList) ; i++){
for(iView=0 ; iView<List_Nbr(Post_ViewList) ; iView++){
v = (Post_View*)List_Pointer(Post_ViewList,i);
v = (Post_View*)List_Pointer(Post_ViewList,iView);
if(v->Visible){
......@@ -100,7 +100,7 @@ void Draw_Post (void) {
if(CTX.display_lists){
if(glIsList(v->Num)) glDeleteLists(v->Num,1);
//Msg(INFO, "New Display List");
// Msg(INFO, "New Display List");
glNewList(v->Num, GL_COMPILE_AND_EXECUTE);
}
......@@ -111,7 +111,7 @@ void Draw_Post (void) {
InitNoShading();
}
/* force this */
// force this
if(v->IntervalsType == DRAW_POST_CONTINUOUS)
glShadeModel(GL_SMOOTH);
......@@ -138,29 +138,128 @@ void Draw_Post (void) {
RaiseFactor[j] = v->Raise[j] / AbsMax ;
for(k=0;k<5;k++) Raise[j][k] = 0. ;
}
if((n = List_Nbr(v->Tetrahedra)))
for(j=0 ; j<n ; j++)
Draw_Post_Tetrahedron(v, (Post_Simplex*)List_Pointer(v->Tetrahedra,j),
ValMin, ValMax, Raise);
//if(there is alpha)List_Sort(v->Triangles, fcmpTriangle);
if((n = List_Nbr(v->Triangles)))
for(j=0 ; j<n ; j++)
Draw_Post_Triangle(v, (Post_Simplex*)List_Pointer(v->Triangles,j),
ValMin, ValMax, Raise);
// Points
if(v->NbSP){
nb = List_Nbr(v->SP) / v->NbSP ;
for(i = 0 ; i < List_Nbr(v->SP) ; i+=nb)
Draw_ScalarPoint(v, ValMin, ValMax, Raise,
(double*)List_Pointer_Fast(v->SP,i),
(double*)List_Pointer_Fast(v->SP,i+1),
(double*)List_Pointer_Fast(v->SP,i+2),
(double*)List_Pointer_Fast(v->SP,i+3));
}
if(v->NbVP){
nb = List_Nbr(v->VP) / v->NbVP ;
for(i = 0 ; i < List_Nbr(v->VP) ; i+=nb)
Draw_VectorPoint(v, ValMin, ValMax, Raise,
(double*)List_Pointer_Fast(v->VP,i),
(double*)List_Pointer_Fast(v->VP,i+1),
(double*)List_Pointer_Fast(v->VP,i+2),
(double*)List_Pointer_Fast(v->VP,i+3));
}
if(v->NbTP){
nb = List_Nbr(v->TP) / v->NbTP ;
for(i = 0 ; i < List_Nbr(v->TP) ; i+=nb)
Draw_TensorPoint(v, ValMin, ValMax, Raise,
(double*)List_Pointer_Fast(v->TP,i),
(double*)List_Pointer_Fast(v->TP,i+1),
(double*)List_Pointer_Fast(v->TP,i+2),
(double*)List_Pointer_Fast(v->TP,i+3));
}
// Lines
if(v->NbSL){
nb = List_Nbr(v->SL) / v->NbSL ;
for(i = 0 ; i < List_Nbr(v->SL) ; i+=nb)
Draw_ScalarLine(v, ValMin, ValMax, Raise,
(double*)List_Pointer_Fast(v->SL,i),
(double*)List_Pointer_Fast(v->SL,i+2),
(double*)List_Pointer_Fast(v->SL,i+4),
(double*)List_Pointer_Fast(v->SL,i+6));
}
if(v->NbVL){
nb = List_Nbr(v->VL) / v->NbVL ;
for(i = 0 ; i < List_Nbr(v->VL) ; i+=nb)
Draw_VectorLine(v, ValMin, ValMax, Raise,
(double*)List_Pointer_Fast(v->VL,i),
(double*)List_Pointer_Fast(v->VL,i+2),
(double*)List_Pointer_Fast(v->VL,i+4),
(double*)List_Pointer_Fast(v->VL,i+6));
}
if(v->NbTL){
nb = List_Nbr(v->TL) / v->NbTL ;
for(i = 0 ; i < List_Nbr(v->TL) ; i+=nb)
Draw_VectorLine(v, ValMin, ValMax, Raise,
(double*)List_Pointer_Fast(v->TL,i),
(double*)List_Pointer_Fast(v->TL,i+2),
(double*)List_Pointer_Fast(v->TL,i+4),
(double*)List_Pointer_Fast(v->TL,i+6));
}
// Triangles
if(v->NbST){
nb = List_Nbr(v->ST) / v->NbST ;
for(i = 0 ; i < List_Nbr(v->ST) ; i+=nb)
Draw_ScalarTriangle(v, ValMin, ValMax, Raise,
(double*)List_Pointer_Fast(v->ST,i),
(double*)List_Pointer_Fast(v->ST,i+3),
(double*)List_Pointer_Fast(v->ST,i+6),
(double*)List_Pointer_Fast(v->ST,i+9));
}
if(v->NbVT){
nb = List_Nbr(v->VT) / v->NbVT ;
for(i = 0 ; i < List_Nbr(v->VT) ; i+=nb)
Draw_VectorTriangle(v, ValMin, ValMax, Raise,
(double*)List_Pointer_Fast(v->VT,i),
(double*)List_Pointer_Fast(v->VT,i+3),
(double*)List_Pointer_Fast(v->VT,i+6),
(double*)List_Pointer_Fast(v->VT,i+9));
}
if(v->NbTT){
nb = List_Nbr(v->TT) / v->NbTT ;
for(i = 0 ; i < List_Nbr(v->TT) ; i+=nb)
Draw_TensorTriangle(v, ValMin, ValMax, Raise,
(double*)List_Pointer_Fast(v->TT,i),
(double*)List_Pointer_Fast(v->TT,i+3),
(double*)List_Pointer_Fast(v->TT,i+6),
(double*)List_Pointer_Fast(v->TT,i+9));
}
// Tetrahedra
if(v->NbSS){
nb = List_Nbr(v->SS) / v->NbSS ;
for(i = 0 ; i < List_Nbr(v->SS) ; i+=nb)
Draw_ScalarTetrahedron(v, ValMin, ValMax, Raise,
(double*)List_Pointer_Fast(v->SS,i),
(double*)List_Pointer_Fast(v->SS,i+4),
(double*)List_Pointer_Fast(v->SS,i+8),
(double*)List_Pointer_Fast(v->SS,i+12));
}
if(v->NbVS){
nb = List_Nbr(v->VS) / v->NbVS ;
for(i = 0 ; i < List_Nbr(v->VS) ; i+=nb)
Draw_VectorTetrahedron(v, ValMin, ValMax, Raise,
(double*)List_Pointer_Fast(v->VS,i),
(double*)List_Pointer_Fast(v->VS,i+4),
(double*)List_Pointer_Fast(v->VS,i+8),
(double*)List_Pointer_Fast(v->VS,i+12));
}
if(v->NbTS){
nb = List_Nbr(v->TS) / v->NbTS ;
for(i = 0 ; i < List_Nbr(v->TS) ; i+=nb)
Draw_TensorTetrahedron(v, ValMin, ValMax, Raise,
(double*)List_Pointer_Fast(v->TS,i),
(double*)List_Pointer_Fast(v->TS,i+4),
(double*)List_Pointer_Fast(v->TS,i+8),
(double*)List_Pointer_Fast(v->TS,i+12));
}
if((n = List_Nbr(v->Lines)))
for(j=0 ; j<n ; j++)
Draw_Post_Line(v, (Post_Simplex*)List_Pointer(v->Lines,j),
ValMin, ValMax, Raise);
if((n = List_Nbr(v->Points)))
for(j=0 ; j<n ; j++)
Draw_Post_Point(v, (Post_Simplex*)List_Pointer(v->Points,j),
ValMin, ValMax, Raise);
if(CTX.display_lists){
glEndList();
v->Changed=0;
......
Graphics/PostSimplex.cpp
+ 323
− 295
View file @ 0f05e69e
/* $Id: PostSimplex.cpp,v 1.4 2000-11-26 15:43:46 geuzaine Exp $ */
/* $Id: PostSimplex.cpp,v 1.5 2000-11-27 10:58:54 geuzaine Exp $ */
#include "Gmsh.h"
#include "GmshUI.h"
......@@ -14,53 +14,53 @@ extern Context_T CTX;
/* P o i n t s */
/* ------------------------------------------------------------------------ */
void Draw_Post_Point(Post_View *View, Post_Simplex *PP,
double ValMin, double ValMax, double Raise[3][5]){
void Draw_ScalarPoint(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V){
double d;
d = V[View->TimeStep];
if(d>=ValMin && d<=ValMax){
Palette(View,View->NbIso,View->GIFV(ValMin,ValMax,View->NbIso,d));
glBegin(GL_POINTS);
glVertex3d(X[0], Y[0], Z[0]);
glEnd();
}
}
void Draw_VectorPoint(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V){
int i;
double d,dx,dy,dz,fact;
switch(PP->Type){
case DRAW_POST_SCALAR:
d = PP->V[View->TimeStep];
if(d>=ValMin && d<=ValMax){
Palette(View,View->NbIso,View->GIFV(ValMin,ValMax,View->NbIso,d));
glBegin(GL_POINTS);
glVertex3d(PP->X[0], PP->Y[0], PP->Z[0]);
glEnd();
}
break;
case DRAW_POST_VECTOR:
if(View->ArrowType == DRAW_POST_DISPLACEMENT){
fact = View->ArrowScale/100. ;
glColor4ubv((GLubyte*)&CTX.color.fg);
glBegin(GL_POINTS);
glVertex3d(fact*PP->V[3*View->TimeStep],
fact*PP->V[3*View->TimeStep+1],
fact*PP->V[3*View->TimeStep+2]);
if(View->ArrowType == DRAW_POST_DISPLACEMENT){
fact = View->ArrowScale/100. ;
glColor4ubv((GLubyte*)&CTX.color.fg);
glBegin(GL_POINTS);
glVertex3d(fact*V[3*View->TimeStep],
fact*V[3*View->TimeStep+1],
fact*V[3*View->TimeStep+2]);
glEnd();
if(View->TimeStep){
glBegin(GL_LINE_STRIP);
for(i=0 ; i<View->TimeStep+1 ; i++)
glVertex3d(fact*V[3*(View->TimeStep-i)],
fact*V[3*(View->TimeStep-i)+1],
fact*V[3*(View->TimeStep-i)+2]);
glEnd();
if(View->TimeStep){
glBegin(GL_LINE_STRIP);
for(i=0 ; i<View->TimeStep+1 ; i++)
glVertex3d(fact*PP->V[3*(View->TimeStep-i)],
fact*PP->V[3*(View->TimeStep-i)+1],
fact*PP->V[3*(View->TimeStep-i)+2]);
glEnd();
}
break;
}
dx = PP->V[3*View->TimeStep];
dy = PP->V[3*View->TimeStep+1];
dz = PP->V[3*View->TimeStep+2];
}
else{
dx = V[3*View->TimeStep];
dy = V[3*View->TimeStep+1];
dz = V[3*View->TimeStep+2];
d = sqrt(dx*dx+dy*dy+dz*dz);
if(d!=0.0 && d>=ValMin && d<=ValMax){
Palette(View,View->NbIso,View->GIFV(ValMin,ValMax,View->NbIso,d));
fact = 2.e-4 * CTX.lc * View->ArrowScale/View->Max ;
if(View->ScaleType == DRAW_POST_LOGARITHMIC && ValMin>0){
......@@ -70,141 +70,147 @@ void Draw_Post_Point(Post_View *View, Post_Simplex *PP,
}
RaiseFill(0, d, ValMin, Raise);
Draw_Vector(View->ArrowType, View->IntervalsType!=DRAW_POST_ISO,
PP->X[0], PP->Y[0], PP->Z[0],
X[0], Y[0], Z[0],
fact*d, fact*dx, fact*dy, fact*dz,
View->Offset, Raise);
}
break;
case DRAW_POST_TENSOR :
break;
}
}
void Draw_TensorPoint(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V){
}
/* ------------------------------------------------------------------------ */
/* L i n e s */
/* ------------------------------------------------------------------------ */
void Draw_Post_Line(Post_View *View, Post_Simplex *PL,
double ValMin, double ValMax, double Raise[3][5]){
void Draw_ScalarLine(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V){
int i,k,nb=0;
double d,dx,dy,dz,fact;
double d;
double Xp[5],Yp[5],Zp[5],value[5],thev;
char Num[100] ;
switch(PL->Type){
case DRAW_POST_SCALAR:
if(View->IntervalsType==DRAW_POST_NUMERIC){
d = (PL->V[2*View->TimeStep]+PL->V[2*View->TimeStep+1]) / 2.;
if(d >= ValMin && d <= ValMax){
sprintf(Num, "%g", d);
glColor4ubv((GLubyte*)&CTX.color.fg);
glRasterPos3d((PL->X[0] + PL->X[1])/2.,
(PL->Y[0] + PL->Y[1])/2.,
(PL->Z[0] + PL->Z[1])/2.);
Draw_String(Num);
}
break ;
if(View->IntervalsType==DRAW_POST_NUMERIC){
d = (V[2*View->TimeStep]+V[2*View->TimeStep+1]) / 2.;
if(d >= ValMin && d <= ValMax){
sprintf(Num, "%g", d);
glColor4ubv((GLubyte*)&CTX.color.fg);
glRasterPos3d((X[0] + X[1])/2.,
(Y[0] + Y[1])/2.,
(Z[0] + Z[1])/2.);
Draw_String(Num);
}
}
else{
glDisable(GL_LINE_STIPPLE);
for(k=0 ; k<2 ; k++) RaiseFill(k, PL->V[2*View->TimeStep+k], ValMin, Raise);
for(k=0 ; k<2 ; k++) RaiseFill(k, V[2*View->TimeStep+k], ValMin, Raise);
if(View->IntervalsType==DRAW_POST_CONTINUOUS){
glBegin(GL_LINES);
Palette2(View,ValMin,ValMax,PL->V[2*View->TimeStep]);
glVertex3d(PL->X[0]+View->Offset[0]+Raise[0][0],
PL->Y[0]+View->Offset[1]+Raise[1][0],
PL->Z[0]+View->Offset[2]+Raise[2][0]);
Palette2(View,ValMin,ValMax,PL->V[2*View->TimeStep+1]);
glVertex3d(PL->X[1]+View->Offset[0]+Raise[0][1],
PL->Y[1]+View->Offset[1]+Raise[1][1],
PL->Z[1]+View->Offset[2]+Raise[2][1]);
Palette2(View,ValMin,ValMax,V[2*View->TimeStep]);
glVertex3d(X[0]+View->Offset[0]+Raise[0][0],
Y[0]+View->Offset[1]+Raise[1][0],
Z[0]+View->Offset[2]+Raise[2][0]);
Palette2(View,ValMin,ValMax,V[2*View->TimeStep+1]);
glVertex3d(X[1]+View->Offset[0]+Raise[0][1],
Y[1]+View->Offset[1]+Raise[1][1],
Z[1]+View->Offset[2]+Raise[2][1]);
glEnd();
}
else{
for(k=0 ; k<View->NbIso ; k++){
Palette(View,View->NbIso,k);
if(View->IntervalsType==DRAW_POST_DISCRETE){
CutLine1D(PL->X,PL->Y,PL->Z,&PL->V[2*View->TimeStep],
View->GVFI(ValMin,ValMax,View->NbIso+1,k),
View->GVFI(ValMin,ValMax,View->NbIso+1,k+1),
ValMin,ValMax,Xp,Yp,Zp,&nb,value);
if(nb == 2){
for(i=0;i<2;i++) RaiseFill(i,value[i],ValMin,Raise);
Draw_Line(Xp,Yp,Zp,View->Offset,Raise);
}
}
else{
thev = View->GVFI(ValMin,ValMax,View->NbIso,k);
CutLine0D(PL->X,PL->Y,PL->Z,&PL->V[2*View->TimeStep],
thev, ValMin,ValMax,Xp,Yp,Zp,&nb);
if(nb){
RaiseFill(0,thev,ValMin,Raise);
Draw_Point(Xp,Yp,Zp,View->Offset,Raise);
}
}
Palette(View,View->NbIso,k);
if(View->IntervalsType==DRAW_POST_DISCRETE){
CutLine1D(X,Y,Z,&V[2*View->TimeStep],
View->GVFI(ValMin,ValMax,View->NbIso+1,k),
View->GVFI(ValMin,ValMax,View->NbIso+1,k+1),
ValMin,ValMax,Xp,Yp,Zp,&nb,value);
if(nb == 2){
for(i=0;i<2;i++) RaiseFill(i,value[i],ValMin,Raise);
Draw_Line(Xp,Yp,Zp,View->Offset,Raise);
}
}
else{
thev = View->GVFI(ValMin,ValMax,View->NbIso,k);
CutLine0D(X,Y,Z,&V[2*View->TimeStep],
thev, ValMin,ValMax,Xp,Yp,Zp,&nb);
if(nb){
RaiseFill(0,thev,ValMin,Raise);
Draw_Point(Xp,Yp,Zp,View->Offset,Raise);
}
}
}
}
break;
case DRAW_POST_VECTOR:
if(View->ArrowLocation == DRAW_POST_LOCATE_COG){
dx = 0.5 * (PL->V[6*View->TimeStep] +PL->V[6*View->TimeStep+3]);
dy = 0.5 * (PL->V[6*View->TimeStep+1]+PL->V[6*View->TimeStep+4]);
dz = 0.5 * (PL->V[6*View->TimeStep+2]+PL->V[6*View->TimeStep+5]);
d = sqrt(dx*dx+dy*dy+dz*dz);
if(d!=0.0 && d>=ValMin && d<=ValMax){
Palette(View,View->NbIso,View->GIFV(ValMin,ValMax,View->NbIso,d));
fact = 2.e-4 * CTX.lc * View->ArrowScale/View->Max ;
if(View->ScaleType == DRAW_POST_LOGARITHMIC && ValMin>0){
dx /= d ; dy /= d ; dz /= d ;
d = log10(d/ValMin) ;
dx *= d ; dy *= d ; dz *= d ;
}
RaiseFill(0, d, ValMin, Raise);
Draw_Vector(View->ArrowType, View->IntervalsType!=DRAW_POST_ISO,
0.5 * (PL->X[0] + PL->X[1]),
0.5 * (PL->Y[0] + PL->Y[1]),
0.5 * (PL->Z[0] + PL->Z[1]),
fact*d, fact*dx, fact*dy, fact*dz,
View->Offset, Raise);
}
}
void Draw_VectorLine(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V){
int k;
double d,dx,dy,dz,fact;
if(View->ArrowLocation == DRAW_POST_LOCATE_COG){
dx = 0.5 * (V[6*View->TimeStep] +V[6*View->TimeStep+3]);
dy = 0.5 * (V[6*View->TimeStep+1]+V[6*View->TimeStep+4]);
dz = 0.5 * (V[6*View->TimeStep+2]+V[6*View->TimeStep+5]);
d = sqrt(dx*dx+dy*dy+dz*dz);
if(d!=0.0 && d>=ValMin && d<=ValMax){
Palette(View,View->NbIso,View->GIFV(ValMin,ValMax,View->NbIso,d));
fact = 2.e-4 * CTX.lc * View->ArrowScale/View->Max ;
if(View->ScaleType == DRAW_POST_LOGARITHMIC && ValMin>0){
dx /= d ; dy /= d ; dz /= d ;
d = log10(d/ValMin) ;
dx *= d ; dy *= d ; dz *= d ;
}
RaiseFill(0, d, ValMin, Raise);
Draw_Vector(View->ArrowType, View->IntervalsType!=DRAW_POST_ISO,
0.5 * (X[0] + X[1]),
0.5 * (Y[0] + Y[1]),
0.5 * (Z[0] + Z[1]),
fact*d, fact*dx, fact*dy, fact*dz,
View->Offset, Raise);
}
else{
for(k=0 ; k<2 ; k++){
dx = PL->V[6*View->TimeStep +3*k] ;
dy = PL->V[6*View->TimeStep+1+3*k] ;
dz = PL->V[6*View->TimeStep+2+3*k] ;
d = sqrt(dx*dx+dy*dy+dz*dz);
if(d!=0.0 && d>=ValMin && d<=ValMax){
Palette(View,View->NbIso,View->GIFV(ValMin,ValMax,View->NbIso,d));
fact = 2.e-4 * CTX.lc * View->ArrowScale/View->Max ;
if(View->ScaleType == DRAW_POST_LOGARITHMIC && ValMin>0){
dx /= d ; dy /= d ; dz /= d ;
d = log10(d/ValMin) ;
dx *= d ; dy *= d ; dz *= d ;
}
RaiseFill(0, d, ValMin, Raise);
Draw_Vector(View->ArrowType, View->IntervalsType!=DRAW_POST_ISO,
PL->X[k], PL->Y[k], PL->Z[k],
fact*d, fact*dx, fact*dy, fact*dz,
View->Offset, Raise);
}
}
}
break;
case DRAW_POST_TENSOR :
break;
}
else{
for(k=0 ; k<2 ; k++){
dx = V[6*View->TimeStep +3*k] ;
dy = V[6*View->TimeStep+1+3*k] ;
dz = V[6*View->TimeStep+2+3*k] ;
d = sqrt(dx*dx+dy*dy+dz*dz);
if(d!=0.0 && d>=ValMin && d<=ValMax){
Palette(View,View->NbIso,View->GIFV(ValMin,ValMax,View->NbIso,d));
fact = 2.e-4 * CTX.lc * View->ArrowScale/View->Max ;
if(View->ScaleType == DRAW_POST_LOGARITHMIC && ValMin>0){
dx /= d ; dy /= d ; dz /= d ;
d = log10(d/ValMin) ;
dx *= d ; dy *= d ; dz *= d ;
}
RaiseFill(0, d, ValMin, Raise);
Draw_Vector(View->ArrowType, View->IntervalsType!=DRAW_POST_ISO,
X[k], Y[k], Z[k],
fact*d, fact*dx, fact*dy, fact*dz,
View->Offset, Raise);
}
}
}
}
void Draw_TensorLine(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V){
}
......@@ -212,46 +218,42 @@ void Draw_Post_Line(Post_View *View, Post_Simplex *PL,
/* T r i a n g l e s */
/* ------------------------------------------------------------------------ */
void Draw_Post_Triangle(Post_View *View, Post_Simplex *PT,
double ValMin, double ValMax, double Raise[3][5]){
void Draw_ScalarTriangle(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V){
int i, k, m, nb=0;
double d,dx,dy,dz,fact;
int i, k, nb=0;
double d;
double x1x0, y1y0, z1z0, x2x0, y2y0, z2z0, nn[3];
double xx[3],yy[3],zz[3];
double Xp[5],Yp[5],Zp[5],value[5],thev;
char Num[100] ;
if(View->ShowElement)
glEnable(GL_POLYGON_OFFSET_FILL);
switch(PT->Type){
case DRAW_POST_SCALAR:
if(View->IntervalsType==DRAW_POST_NUMERIC){
d = (PT->V[3*View->TimeStep]+PT->V[3*View->TimeStep+1]+PT->V[3*View->TimeStep+2]) / 3.;
if(d >= ValMin && d <= ValMax){
sprintf(Num, "%g", d);
glColor4ubv((GLubyte*)&CTX.color.fg);
glRasterPos3d((PT->X[0] + PT->X[1] + PT->X[2])/3.,
(PT->Y[0] + PT->Y[1] + PT->Y[2])/3.,
(PT->Z[0] + PT->Z[1] + PT->Z[2])/3.);
Draw_String(Num);
}
break ;
if(View->IntervalsType==DRAW_POST_NUMERIC){
d = (V[3*View->TimeStep]+V[3*View->TimeStep+1]+V[3*View->TimeStep+2]) / 3.;
if(d >= ValMin && d <= ValMax){
sprintf(Num, "%g", d);
glColor4ubv((GLubyte*)&CTX.color.fg);
glRasterPos3d((X[0] + X[1] + X[2])/3.,
(Y[0] + Y[1] + Y[2])/3.,
(Z[0] + Z[1] + Z[2])/3.);
Draw_String(Num);
}
}
else{
if(View->IntervalsType!=DRAW_POST_ISO)
for(i=0;i<3;i++)RaiseFill(i, PT->V[3*View->TimeStep+i], ValMin, Raise);
for(i=0;i<3;i++)RaiseFill(i, V[3*View->TimeStep+i], ValMin, Raise);
if(View->Light){
x1x0 = (PT->X[1]+Raise[0][1]) - (PT->X[0]+Raise[0][0]);
y1y0 = (PT->Y[1]+Raise[1][1]) - (PT->Y[0]+Raise[1][0]);
z1z0 = (PT->Z[1]+Raise[2][1]) - (PT->Z[0]+Raise[2][0]);
x2x0 = (PT->X[2]+Raise[0][2]) - (PT->X[0]+Raise[0][0]);
y2y0 = (PT->Y[2]+Raise[1][2]) - (PT->Y[0]+Raise[1][0]);
z2z0 = (PT->Z[2]+Raise[2][2]) - (PT->Z[0]+Raise[2][0]);
x1x0 = (X[1]+Raise[0][1]) - (X[0]+Raise[0][0]);
y1y0 = (Y[1]+Raise[1][1]) - (Y[0]+Raise[1][0]);
z1z0 = (Z[1]+Raise[2][1]) - (Z[0]+Raise[2][0]);
x2x0 = (X[2]+Raise[0][2]) - (X[0]+Raise[0][0]);
y2y0 = (Y[2]+Raise[1][2]) - (Y[0]+Raise[1][0]);
z2z0 = (Z[2]+Raise[2][2]) - (Z[0]+Raise[2][0]);
nn[0] = y1y0 * z2z0 - z1z0 * y2y0 ;
nn[1] = z1z0 * x2x0 - x1x0 * z2z0 ;
nn[2] = x1x0 * y2y0 - y1y0 * x2x0 ;
......@@ -267,26 +269,26 @@ void Draw_Post_Triangle(Post_View *View, Post_Simplex *PT,
}
if(View->IntervalsType==DRAW_POST_CONTINUOUS){
if(PT->V[3*View->TimeStep] >=ValMin && PT->V[3*View->TimeStep] <=ValMax &&
PT->V[3*View->TimeStep+1]>=ValMin && PT->V[3*View->TimeStep+1]<=ValMax &&
PT->V[3*View->TimeStep+2]>=ValMin && PT->V[3*View->TimeStep+2]<=ValMax){
if(V[3*View->TimeStep] >=ValMin && V[3*View->TimeStep] <=ValMax &&
V[3*View->TimeStep+1]>=ValMin && V[3*View->TimeStep+1]<=ValMax &&
V[3*View->TimeStep+2]>=ValMin && V[3*View->TimeStep+2]<=ValMax){
glBegin(GL_TRIANGLES);
Palette2(View,ValMin,ValMax,PT->V[3*View->TimeStep]);
glVertex3d(PT->X[0]+View->Offset[0]+Raise[0][0],
PT->Y[0]+View->Offset[1]+Raise[1][0],
PT->Z[0]+View->Offset[2]+Raise[2][0]);
Palette2(View,ValMin,ValMax,PT->V[3*View->TimeStep+1]);
glVertex3d(PT->X[1]+View->Offset[0]+Raise[0][1],
PT->Y[1]+View->Offset[1]+Raise[1][1],
PT->Z[1]+View->Offset[2]+Raise[2][1]);
Palette2(View,ValMin,ValMax,PT->V[3*View->TimeStep+2]);
glVertex3d(PT->X[2]+View->Offset[0]+Raise[0][2],
PT->Y[2]+View->Offset[1]+Raise[1][2],
PT->Z[2]+View->Offset[2]+Raise[2][2]);
Palette2(View,ValMin,ValMax,V[3*View->TimeStep]);
glVertex3d(X[0]+View->Offset[0]+Raise[0][0],
Y[0]+View->Offset[1]+Raise[1][0],
Z[0]+View->Offset[2]+Raise[2][0]);
Palette2(View,ValMin,ValMax,V[3*View->TimeStep+1]);
glVertex3d(X[1]+View->Offset[0]+Raise[0][1],
Y[1]+View->Offset[1]+Raise[1][1],
Z[1]+View->Offset[2]+Raise[2][1]);
Palette2(View,ValMin,ValMax,V[3*View->TimeStep+2]);
glVertex3d(X[2]+View->Offset[0]+Raise[0][2],
Y[2]+View->Offset[1]+Raise[1][2],
Z[2]+View->Offset[2]+Raise[2][2]);
glEnd();
}
else{
CutTriangle2D(PT->X,PT->Y,PT->Z,&PT->V[3*View->TimeStep],
CutTriangle2D(X,Y,Z,&V[3*View->TimeStep],
ValMin,ValMax,ValMin,ValMax,
Xp,Yp,Zp,&nb,value);
if(nb >= 3){
......@@ -306,7 +308,7 @@ void Draw_Post_Triangle(Post_View *View, Post_Simplex *PT,
for(k=0 ; k<View->NbIso ; k++){
if(View->IntervalsType==DRAW_POST_DISCRETE){
Palette(View,View->NbIso,k);
CutTriangle2D(PT->X,PT->Y,PT->Z,&PT->V[3*View->TimeStep],
CutTriangle2D(X,Y,Z,&V[3*View->TimeStep],
View->GVFI(ValMin,ValMax,View->NbIso+1,k),
View->GVFI(ValMin,ValMax,View->NbIso+1,k+1),
ValMin,ValMax,
......@@ -320,7 +322,7 @@ void Draw_Post_Triangle(Post_View *View, Post_Simplex *PT,
Palette(View,View->NbIso,k);
thev = View->GVFI(ValMin,ValMax,View->NbIso,k);
CutTriangle1D(PT->X,PT->Y,PT->Z,&PT->V[3*View->TimeStep],
CutTriangle1D(X,Y,Z,&V[3*View->TimeStep],
thev, ValMin,ValMax,Xp,Yp,Zp,&nb);
if(nb == 2){
for(i=0;i<2;i++) RaiseFill(i,thev,ValMin,Raise);
......@@ -329,33 +331,56 @@ void Draw_Post_Triangle(Post_View *View, Post_Simplex *PT,
}
}
}
break;
case DRAW_POST_VECTOR:
}
if(View->ArrowType == DRAW_POST_DISPLACEMENT){
fact = View->ArrowScale/100. ;
for(m=0;m<3;m++){
xx[m] = PT->X[m] + fact * PT->V[9*View->TimeStep + 3 * m ];
yy[m] = PT->Y[m] + fact * PT->V[9*View->TimeStep + 3 * m + 1];
zz[m] = PT->Z[m] + fact * PT->V[9*View->TimeStep + 3 * m + 2];
}
glEnable(GL_POLYGON_OFFSET_FILL);
glColor4ubv((GLubyte*)&CTX.color.bg);
if(View->IntervalsType!=DRAW_POST_ISO)
Draw_Polygon (3, xx, yy, zz, View->Offset, Raise);
glColor4ubv((GLubyte*)&CTX.color.fg);
glBegin(GL_LINE_LOOP);
for(m=0 ; m<3 ; m++) glVertex3d(xx[m], yy[m], zz[m]);
glEnd();
glDisable(GL_POLYGON_OFFSET_FILL);
break;
if(View->ShowElement){
glDisable(GL_POLYGON_OFFSET_FILL) ;
glColor4ubv((GLubyte*)&CTX.color.fg);
glBegin(GL_LINE_LOOP);
for(i=0 ; i<3 ; i++)
glVertex3d(X[i]+View->Offset[0]+Raise[0][i],
Y[i]+View->Offset[1]+Raise[1][i],
Z[i]+View->Offset[2]+Raise[2][i]);
glEnd();
}
}
void Draw_VectorTriangle(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V){
int i, k, m;
double d,dx,dy,dz,fact;
double xx[3],yy[3],zz[3];
if(View->ShowElement)
glEnable(GL_POLYGON_OFFSET_FILL);
if(View->ArrowType == DRAW_POST_DISPLACEMENT){
fact = View->ArrowScale/100. ;
for(m=0;m<3;m++){
xx[m] = X[m] + fact * V[9*View->TimeStep + 3 * m ];
yy[m] = Y[m] + fact * V[9*View->TimeStep + 3 * m + 1];
zz[m] = Z[m] + fact * V[9*View->TimeStep + 3 * m + 2];
}
glEnable(GL_POLYGON_OFFSET_FILL);
glColor4ubv((GLubyte*)&CTX.color.bg);
if(View->IntervalsType!=DRAW_POST_ISO)
Draw_Polygon (3, xx, yy, zz, View->Offset, Raise);
glColor4ubv((GLubyte*)&CTX.color.fg);
glBegin(GL_LINE_LOOP);
for(m=0 ; m<3 ; m++) glVertex3d(xx[m], yy[m], zz[m]);
glEnd();
glDisable(GL_POLYGON_OFFSET_FILL);
}
else{
if(View->ArrowLocation == DRAW_POST_LOCATE_COG){
dx = (PT->V[9*View->TimeStep] +PT->V[9*View->TimeStep+3]+PT->V[9*View->TimeStep+6])/3.;
dy = (PT->V[9*View->TimeStep+1]+PT->V[9*View->TimeStep+4]+PT->V[9*View->TimeStep+7])/3.;
dz = (PT->V[9*View->TimeStep+2]+PT->V[9*View->TimeStep+5]+PT->V[9*View->TimeStep+8])/3.;
dx = (V[9*View->TimeStep] +V[9*View->TimeStep+3]+V[9*View->TimeStep+6])/3.;
dy = (V[9*View->TimeStep+1]+V[9*View->TimeStep+4]+V[9*View->TimeStep+7])/3.;
dz = (V[9*View->TimeStep+2]+V[9*View->TimeStep+5]+V[9*View->TimeStep+8])/3.;
d = sqrt(dx*dx+dy*dy+dz*dz);
if(d!=0.0 && d>=ValMin && d<=ValMax){
Palette(View,View->NbIso,View->GIFV(ValMin,ValMax,View->NbIso,d));
......@@ -367,18 +392,18 @@ void Draw_Post_Triangle(Post_View *View, Post_Simplex *PT,
}
RaiseFill(0, d, ValMin, Raise);
Draw_Vector(View->ArrowType, View->IntervalsType!=DRAW_POST_ISO,
(PT->X[0] + PT->X[1] + PT->X[2])/3.,
(PT->Y[0] + PT->Y[1] + PT->Y[2])/3.,
(PT->Z[0] + PT->Z[1] + PT->Z[2])/3.,
(X[0] + X[1] + X[2])/3.,
(Y[0] + Y[1] + Y[2])/3.,
(Z[0] + Z[1] + Z[2])/3.,
fact*d, fact*dx, fact*dy, fact*dz,
View->Offset, Raise);
}
}
else{
for(k=0 ; k<3 ; k++){
dx = PT->V[9*View->TimeStep +3*k] ;
dy = PT->V[9*View->TimeStep+1+3*k] ;
dz = PT->V[9*View->TimeStep+2+3*k] ;
dx = V[9*View->TimeStep +3*k] ;
dy = V[9*View->TimeStep+1+3*k] ;
dz = V[9*View->TimeStep+2+3*k] ;
d = sqrt(dx*dx+dy*dy+dz*dz);
if(d!=0.0 && d>=ValMin && d<=ValMax){
......@@ -391,18 +416,14 @@ void Draw_Post_Triangle(Post_View *View, Post_Simplex *PT,
}
RaiseFill(0, d, ValMin, Raise);
Draw_Vector(View->ArrowType, View->IntervalsType!=DRAW_POST_ISO,
PT->X[k], PT->Y[k], PT->Z[k],
X[k], Y[k], Z[k],
fact*d, fact*dx, fact*dy, fact*dz,
View->Offset, Raise);
}
}
}
break;
case DRAW_POST_TENSOR :
break;
}
if(View->ShowElement){
......@@ -410,98 +431,105 @@ void Draw_Post_Triangle(Post_View *View, Post_Simplex *PT,
glColor4ubv((GLubyte*)&CTX.color.fg);
glBegin(GL_LINE_LOOP);
for(i=0 ; i<3 ; i++)
glVertex3d(PT->X[i]+View->Offset[0]+Raise[0][i],
PT->Y[i]+View->Offset[1]+Raise[1][i],
PT->Z[i]+View->Offset[2]+Raise[2][i]);
glVertex3d(X[i]+View->Offset[0]+Raise[0][i],
Y[i]+View->Offset[1]+Raise[1][i],
Z[i]+View->Offset[2]+Raise[2][i]);
glEnd();
}
}
void Draw_TensorTriangle(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V){
}
/* ------------------------------------------------------------------------ */
/* T e t r a h e d r a */
/* ------------------------------------------------------------------------ */
void Draw_Post_Tetrahedron(Post_View *View, Post_Simplex *PS,
double ValMin, double ValMax, double Raise[3][5]){
void Draw_ScalarTetrahedron(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V){
int k;
for(k=0 ; k<View->NbIso ; k++){
Palette(View,View->NbIso,k);
IsoSimplex(X, Y, Z, &V[4*View->TimeStep],
View->GVFI(ValMin,ValMax,View->NbIso,k),
ValMin, ValMax, View->Offset, Raise, View->Light);
}
}
void Draw_VectorTetrahedron(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V){
int k;
double d,dx,dy,dz,fact;
switch(PS->Type){
case DRAW_POST_SCALAR:
for(k=0 ; k<View->NbIso ; k++){
Palette(View,View->NbIso,k);
IsoSimplex(PS->X, PS->Y, PS->Z, &PS->V[4*View->TimeStep],
View->GVFI(ValMin,ValMax,View->NbIso,k),
ValMin, ValMax, View->Offset, Raise, View->Light);
}
break;
/*
la plus grande fleche (d=ValMax) est de taille CTX.lc/50
(View->ArrowScale == 100 par defaut)
*/
/*
la plus grande fleche (d=ValMax) est de taille CTX.lc/50
(View->ArrowScale == 100 par defaut)
*/
if(View->ArrowLocation == DRAW_POST_LOCATE_COG){
dx = 0.25 * (V[12*View->TimeStep] +V[12*View->TimeStep+3]+
V[12*View->TimeStep+6]+V[12*View->TimeStep+9] );
dy = 0.25 * (V[12*View->TimeStep+1]+V[12*View->TimeStep+4]+
V[12*View->TimeStep+7]+V[12*View->TimeStep+10] );
dz = 0.25 * (V[12*View->TimeStep+2]+V[12*View->TimeStep+5]+
V[12*View->TimeStep+8]+V[12*View->TimeStep+11] );
d = sqrt(dx*dx+dy*dy+dz*dz);
case DRAW_POST_VECTOR:
if(View->ArrowLocation == DRAW_POST_LOCATE_COG){
dx = 0.25 * (PS->V[12*View->TimeStep] +PS->V[12*View->TimeStep+3]+
PS->V[12*View->TimeStep+6]+PS->V[12*View->TimeStep+9] );
dy = 0.25 * (PS->V[12*View->TimeStep+1]+PS->V[12*View->TimeStep+4]+
PS->V[12*View->TimeStep+7]+PS->V[12*View->TimeStep+10] );
dz = 0.25 * (PS->V[12*View->TimeStep+2]+PS->V[12*View->TimeStep+5]+
PS->V[12*View->TimeStep+8]+PS->V[12*View->TimeStep+11] );
d = sqrt(dx*dx+dy*dy+dz*dz);
if(d!=0.0 && d>=ValMin && d<=ValMax){
Palette(View,View->NbIso,View->GIFV(ValMin,ValMax,View->NbIso,d));
fact = 2.e-4 * CTX.lc * View->ArrowScale/View->Max ;
if(View->ScaleType == DRAW_POST_LOGARITHMIC && ValMin>0){
dx /= d ; dy /= d ; dz /= d ;
d = log10(d/ValMin) ;
dx *= d ; dy *= d ; dz *= d ;
}
RaiseFill(0, d, ValMin, Raise);
Draw_Vector(View->ArrowType, View->IntervalsType!=DRAW_POST_ISO,
0.25 * (PS->X[0] + PS->X[1] + PS->X[2] + PS->X[3]),
0.25 * (PS->Y[0] + PS->Y[1] + PS->Y[2] + PS->Y[3]),
0.25 * (PS->Z[0] + PS->Z[1] + PS->Z[2] + PS->Z[3]),
fact*d, fact*dx, fact*dy, fact*dz,
View->Offset, Raise);
if(d!=0.0 && d>=ValMin && d<=ValMax){
Palette(View,View->NbIso,View->GIFV(ValMin,ValMax,View->NbIso,d));
fact = 2.e-4 * CTX.lc * View->ArrowScale/View->Max ;
if(View->ScaleType == DRAW_POST_LOGARITHMIC && ValMin>0){
dx /= d ; dy /= d ; dz /= d ;
d = log10(d/ValMin) ;
dx *= d ; dy *= d ; dz *= d ;
}
RaiseFill(0, d, ValMin, Raise);
Draw_Vector(View->ArrowType, View->IntervalsType!=DRAW_POST_ISO,
0.25 * (X[0] + X[1] + X[2] + X[3]),
0.25 * (Y[0] + Y[1] + Y[2] + Y[3]),
0.25 * (Z[0] + Z[1] + Z[2] + Z[3]),
fact*d, fact*dx, fact*dy, fact*dz,
View->Offset, Raise);
}
else{
for(k=0 ; k<4 ; k++){
dx = PS->V[12*View->TimeStep +3*k] ;
dy = PS->V[12*View->TimeStep+1+3*k] ;
dz = PS->V[12*View->TimeStep+2+3*k] ;
d = sqrt(dx*dx+dy*dy+dz*dz);
if(d!=0.0 && d>=ValMin && d<=ValMax){
Palette(View,View->NbIso,View->GIFV(ValMin,ValMax,View->NbIso,d));
fact = 2.e-4 * CTX.lc * View->ArrowScale/View->Max ;
if(View->ScaleType == DRAW_POST_LOGARITHMIC && ValMin>0){
dx /= d ; dy /= d ; dz /= d ;
d = log10(d/ValMin) ;
dx *= d ; dy *= d ; dz *= d ;
}
RaiseFill(0, d, ValMin, Raise);
Draw_Vector(View->ArrowType, View->IntervalsType!=DRAW_POST_ISO,
PS->X[k], PS->Y[k], PS->Z[k],
fact*d, fact*dx, fact*dy, fact*dz,
View->Offset, Raise);
}
}
}
break;
case DRAW_POST_TENSOR :
break;
}
else{
for(k=0 ; k<4 ; k++){
dx = V[12*View->TimeStep +3*k] ;
dy = V[12*View->TimeStep+1+3*k] ;
dz = V[12*View->TimeStep+2+3*k] ;
d = sqrt(dx*dx+dy*dy+dz*dz);
if(d!=0.0 && d>=ValMin && d<=ValMax){
Palette(View,View->NbIso,View->GIFV(ValMin,ValMax,View->NbIso,d));
fact = 2.e-4 * CTX.lc * View->ArrowScale/View->Max ;
if(View->ScaleType == DRAW_POST_LOGARITHMIC && ValMin>0){
dx /= d ; dy /= d ; dz /= d ;
d = log10(d/ValMin) ;
dx *= d ; dy *= d ; dz *= d ;
}
RaiseFill(0, d, ValMin, Raise);
Draw_Vector(View->ArrowType, View->IntervalsType!=DRAW_POST_ISO,
X[k], Y[k], Z[k],
fact*d, fact*dx, fact*dy, fact*dz,
View->Offset, Raise);
}
}
}
}
void Draw_TensorTetrahedron(Post_View *View,
double ValMin, double ValMax, double Raise[3][5],
double *X, double *Y, double *Z, double *V){
}
Mesh/3D_BGMesh.cpp
+ 156
− 109
View file @ 0f05e69e
/* $Id: 3D_BGMesh.cpp,v 1.9 2000-11-26 15:43:46 geuzaine Exp $ */
/* $Id: 3D_BGMesh.cpp,v 1.10 2000-11-27 10:58:56 geuzaine Exp $ */
#include "Gmsh.h"
#include "Mesh.h"
......@@ -123,10 +123,9 @@ static void AIG (void *a, void *b){
}
int BGMWithView (Post_View * ErrView){
static Vertex *VertexUp, *v, V, *ver[4];
int i, j, k;
Post_Simplex s, t;
int i, j, k, nb;
double *X, *Y, *Z, *Val;
Simplex *si;
VertexUp = Create_Vertex (-1, 0., 0., 1., 1., -1.0);
......@@ -138,50 +137,64 @@ int BGMWithView (Post_View * ErrView){
m.Simplexes = Tree_Create (sizeof (Simplex *), compareSimplex);
Create_BgMesh (ONFILE, .2, THEM);
k = 1;
for (i = 0; i < List_Nbr (ErrView->Triangles); i++){
List_Read (ErrView->Triangles, i, &t);
for (j = 0; j < 3; j++){
v = &V;
v->Pos.X = t.X[j];
v->Pos.Y = t.Y[j];
v->Pos.Z = t.Z[j];
if (0 /*Tree_Query(Pts,&v) */ ){
/* Corriger la Lc pour lissage */
//ver[j] = v;
}
else{
v = Create_Vertex (k++, t.X[j], t.Y[j], t.Z[j], t.V[j], -1.0);
ver[j] = v;
Tree_Add (m.Vertices, &v);
Tree_Add (Pts, &v);
if(ErrView->NbST){
nb = List_Nbr(ErrView->ST) / ErrView->NbST ;
for(i = 0 ; i < List_Nbr(ErrView->ST) ; i+=nb){
X = (double*)List_Pointer_Fast(ErrView->ST,i);
Y = (double*)List_Pointer_Fast(ErrView->ST,i+3);
Z = (double*)List_Pointer_Fast(ErrView->ST,i+6);
Val = (double*)List_Pointer_Fast(ErrView->ST,i+9);
for (j = 0; j < 3; j++){
v = &V;
v->Pos.X = X[j];
v->Pos.Y = Y[j];
v->Pos.Z = Z[j];
if (Tree_Query (Pts, &v)){
ver[j] = v;
}
else{
v = Create_Vertex (k++, X[j], Y[j], Z[j], Val[j], -1.0);
ver[j] = v;
Tree_Add (m.Vertices, &v);
Tree_Add (Pts, &v);
}
}
si = Create_Simplex (ver[0], ver[1], ver[2], VertexUp);
Tree_Add (m.Simplexes, &si);
}
si = Create_Simplex (ver[0], ver[1], ver[2], VertexUp);
Tree_Add (m.Simplexes, &si);
}
for (i = 0; i < List_Nbr (ErrView->Tetrahedra); i++){
List_Read (ErrView->Tetrahedra, i, &s);
for (j = 0; j < 4; j++){
v = &V;
v->Pos.X = s.X[j];
v->Pos.Y = s.Y[j];
v->Pos.Z = s.Z[j];
if (Tree_Query (Pts, &v)){
ver[j] = v;
}
else{
v = Create_Vertex (k++, s.X[k], s.Y[j], s.Z[j], s.V[0], -1.0);
ver[j] = v;
Tree_Add (m.Vertices, &v);
Tree_Add (Pts, &v);
if(ErrView->NbSS){
nb = List_Nbr(ErrView->SS) / ErrView->NbSS ;
for(i = 0 ; i < List_Nbr(ErrView->SS) ; i+=nb){
X = (double*)List_Pointer_Fast(ErrView->SS,i);
Y = (double*)List_Pointer_Fast(ErrView->SS,i+4);
Z = (double*)List_Pointer_Fast(ErrView->SS,i+8);
Val = (double*)List_Pointer_Fast(ErrView->SS,i+12);
for (j = 0; j < 4; j++){
v = &V;
v->Pos.X = X[j];
v->Pos.Y = Y[j];
v->Pos.Z = Z[j];
if (Tree_Query (Pts, &v)){
ver[j] = v;
}
else{
v = Create_Vertex (k++, X[j], Y[j], Z[j], Val[j], -1.0);
ver[j] = v;
Tree_Add (m.Vertices, &v);
Tree_Add (Pts, &v);
}
}
si = Create_Simplex (ver[0], ver[1], ver[2], ver[3]);
Tree_Add (m.Simplexes, &si);
}
si = Create_Simplex (ver[0], ver[1], ver[2], ver[3]);
Tree_Add (m.Simplexes, &si);
}
m.Grid.init = 0;
m.Grid.Nx = 10;
m.Grid.Ny = 10;
......@@ -208,31 +221,42 @@ int BGMWithView (Post_View * ErrView){
double ErrorInView (Post_View * ErrView, int *n){
Post_Simplex s, t;
double e, tot=0.0;
int i, j=0;
double e, tot=0.0, *X, *Y, *Z, *Val;
int i, j=0, nb;
if(ErrView == NULL){
Msg(WARNING, "Empty Error View");
return 0.;
}
for (i = 0; i < List_Nbr (ErrView->Triangles); i++){
List_Read (ErrView->Triangles, i, &t);
e = (t.V[0] + t.V[1] + t.V[2]) / 3. ;
tot += e * e;
j++;
if(ErrView->NbST){
nb = List_Nbr(ErrView->ST) / ErrView->NbST ;
for(i = 0 ; i < List_Nbr(ErrView->ST) ; i+=nb){
X = (double*)List_Pointer_Fast(ErrView->ST,i);
Y = (double*)List_Pointer_Fast(ErrView->ST,i+3);
Z = (double*)List_Pointer_Fast(ErrView->ST,i+6);
Val = (double*)List_Pointer_Fast(ErrView->ST,i+9);
e = (Val[0] + Val[1] + Val[2]) / 3. ;
tot += e * e;
j++;
}
}
for (i = 0; i < List_Nbr (ErrView->Tetrahedra); i++){
List_Read (ErrView->Tetrahedra, i, &s);
e = (t.V[0] + t.V[1] + t.V[2] + t.V[3]) * 0.25;
tot += e * e;
j++;
if(ErrView->NbSS){
nb = List_Nbr(ErrView->SS) / ErrView->NbSS ;
for(i = 0 ; i < List_Nbr(ErrView->SS) ; i+=nb){
X = (double*)List_Pointer_Fast(ErrView->SS,i);
Y = (double*)List_Pointer_Fast(ErrView->SS,i+3);
Z = (double*)List_Pointer_Fast(ErrView->SS,i+8);
Val = (double*)List_Pointer_Fast(ErrView->SS,i+12);
e = (Val[0] + Val[1] + Val[2] + Val[3]) * 0.25 ;
tot += e * e;
j++;
}
}
*n = j;
return 100 * sqrt (tot);
}
......@@ -243,20 +267,17 @@ double ErrorInView (Post_View * ErrView, int *n){
int CreateBGM (Post_View * ErrView, int OptiMethod, double Degree,
double OptiValue, double *ObjFunct, char *OutFile){
Post_Simplex s, t;
double *h, *p, *e, xc, yc, zc, c[3];
int N, i, j, dim;
double *h, *p, *e, xc, yc, zc, c[3], *X, *Y, *Z, *Val;
int N, i, j, dim, nb;
Simplex smp;
FILE *f;
if (List_Nbr (ErrView->Tetrahedra))
if (ErrView->NbSS)
dim = 3;
else
dim = 2;
N = List_Nbr (ErrView->Tetrahedra) +
List_Nbr (ErrView->Triangles) + 2;
N = ErrView->NbSS + ErrView->NbST + 2;
h = (double *) malloc (N * sizeof (double));
e = (double *) malloc (N * sizeof (double));
......@@ -264,40 +285,50 @@ int CreateBGM (Post_View * ErrView, int OptiMethod, double Degree,
j = 0;
for (i = 0; i < List_Nbr (ErrView->Triangles); i++){
List_Read (ErrView->Triangles, i, &t);
/*
Attention, cette ligne est seulement valable en
2d x-y. Si plus, calculer le centre du cercle en
3d ou utiliser une autre mesure de taille.
*/
CircumCircle (t.X[0], t.Y[0],
t.X[1], t.Y[1],
t.X[2], t.Y[2],
&xc, &yc);
h[j + 1] = sqrt ((xc - t.X[0]) * (xc - t.X[0]) +
(yc - t.Y[0]) * (yc - t.Y[0]));
p[j + 1] = Degree;
e[j + 1] = (t.V[0] + t.V[1] + t.V[2]) / 3. ;
j++;
if(ErrView->NbST){
nb = List_Nbr(ErrView->ST) / ErrView->NbST ;
for(i = 0 ; i < List_Nbr(ErrView->ST) ; i+=nb){
X = (double*)List_Pointer_Fast(ErrView->ST,i);
Y = (double*)List_Pointer_Fast(ErrView->ST,i+3);
Z = (double*)List_Pointer_Fast(ErrView->ST,i+6);
Val = (double*)List_Pointer_Fast(ErrView->ST,i+9);
/*
Attention, cette ligne est seulement valable en
2d x-y. Si plus, calculer le centre du cercle en
3d ou utiliser une autre mesure de taille.
*/
CircumCircle (X[0], Y[0],
X[1], Y[1],
X[2], Y[2],
&xc, &yc);
h[j + 1] = sqrt ((xc - X[0]) * (xc - X[0]) +
(yc - Y[0]) * (yc - Y[0]));
p[j + 1] = Degree;
e[j + 1] = (Val[0] + Val[1] + Val[2]) / 3. ;
j++;
}
}
for (i = 0; i < List_Nbr (ErrView->Tetrahedra); i++){
List_Read (ErrView->Tetrahedra, i, &s);
smp.center_tet (t.X, t.Y, t.Z, c);
if(ErrView->NbSS){
nb = List_Nbr(ErrView->SS) / ErrView->NbSS ;
for(i = 0 ; i < List_Nbr(ErrView->SS) ; i+=nb){
X = (double*)List_Pointer_Fast(ErrView->SS,i);
Y = (double*)List_Pointer_Fast(ErrView->SS,i+3);
Z = (double*)List_Pointer_Fast(ErrView->SS,i+8);
Val = (double*)List_Pointer_Fast(ErrView->SS,i+12);
xc = c[0];
yc = c[1];
zc = c[2];
smp.center_tet (X, Y, Z, c);
xc = c[0];
yc = c[1];
zc = c[2];
h[j + 1] = sqrt ((xc - t.X[0]) * (xc - t.X[0]) +
(yc - t.X[0]) * (yc - t.X[0]) +
(zc - t.Y[0]) * (zc - t.Y[0]));
p[j + 1] = Degree;
e[j + 1] = (t.V[0] + t.V[1] + t.V[2] + t.V[3]) * 0.25;
j++;
h[j + 1] = sqrt ((xc - X[0]) * (xc - X[0]) +
(yc - X[0]) * (yc - X[0]) +
(zc - Y[0]) * (zc - Y[0]));
p[j + 1] = Degree;
e[j + 1] = (Val[0] + Val[1] + Val[2] + Val[3]) * 0.25;
j++;
}
}
*ObjFunct = AdaptMesh (j, OptiMethod, dim, e, h, p, OptiValue);
......@@ -305,25 +336,40 @@ int CreateBGM (Post_View * ErrView, int OptiMethod, double Degree,
f = fopen (OutFile, "w");
fprintf (f, "View \"Auto_BGMesh\" Offset{0,0,0} {\n");
j = 0;
for (i = 0; i < List_Nbr (ErrView->Triangles); i++){
List_Read (ErrView->Triangles, i, &t);
fprintf (f, "ST(%g,%g,%g,%g,%g,%g,%g,%g,%g){%g,%g,%g};\n",
t.X[0], t.Y[0], t.Z[0],
t.X[1], t.Y[1], t.Z[1],
t.X[2], t.Y[2], t.Z[2],
h[j], h[j], h[j]);
j++;
if(ErrView->NbST){
nb = List_Nbr(ErrView->ST) / ErrView->NbST ;
for(i = 0 ; i < List_Nbr(ErrView->ST) ; i+=nb){
X = (double*)List_Pointer_Fast(ErrView->ST,i);
Y = (double*)List_Pointer_Fast(ErrView->ST,i+3);
Z = (double*)List_Pointer_Fast(ErrView->ST,i+6);
Val = (double*)List_Pointer_Fast(ErrView->ST,i+9);
fprintf (f, "ST(%g,%g,%g,%g,%g,%g,%g,%g,%g){%g,%g,%g};\n",
X[0], Y[0], Z[0],
X[1], Y[1], Z[1],
X[2], Y[2], Z[2],
h[j], h[j], h[j]);
j++;
}
}
for (i = 0; i < List_Nbr (ErrView->Tetrahedra); i++){
List_Read (ErrView->Tetrahedra, i, &s);
fprintf (f, "SS(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g){%g,%g,%g,%g};\n",
s.X[0], s.Y[0], s.Z[0],
s.X[1], s.Y[1], s.Z[1],
s.X[2], s.Y[2], s.Z[2],
s.X[3], s.Y[3], s.Z[3],
h[j], h[j], h[j], h[j]);
j++;
if(ErrView->NbSS){
nb = List_Nbr(ErrView->SS) / ErrView->NbSS ;
for(i = 0 ; i < List_Nbr(ErrView->SS) ; i+=nb){
X = (double*)List_Pointer_Fast(ErrView->SS,i);
Y = (double*)List_Pointer_Fast(ErrView->SS,i+3);
Z = (double*)List_Pointer_Fast(ErrView->SS,i+8);
Val = (double*)List_Pointer_Fast(ErrView->SS,i+12);
fprintf (f, "SS(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g){%g,%g,%g,%g};\n",
X[0], Y[0], Z[0],
X[1], Y[1], Z[1],
X[2], Y[2], Z[2],
X[3], Y[3], Z[3],
h[j], h[j], h[j], h[j]);
j++;
}
}
fprintf (f, "};\n");
fclose (f);
......@@ -331,5 +377,6 @@ int CreateBGM (Post_View * ErrView, int OptiMethod, double Degree,
Msg(INFOS, "Background Mesh Wriiten in '%s'", OutFile);
return 1;
}
Unix/CbGeneral.cpp
+ 5
− 5
View file @ 0f05e69e
/* $Id: CbGeneral.cpp,v 1.4 2000-11-26 15:43:47 geuzaine Exp $ */
/* $Id: CbGeneral.cpp,v 1.5 2000-11-27 10:58:59 geuzaine Exp $ */
#include "Gmsh.h"
#include "GmshUI.h"
......@@ -107,10 +107,10 @@ void CurrentInfoCb (Widget w, XtPointer client_data, XtPointer call_data){
for(i=0 ; i<List_Nbr(Post_ViewList) ; i++){
v = (Post_View*)List_Pointer(Post_ViewList, i);
if(v->Visible){
s[16] += List_Nbr(v->Points);
s[17] += List_Nbr(v->Lines);
s[18] += List_Nbr(v->Triangles);
s[19] += List_Nbr(v->Tetrahedra);
s[16] += v->NbSP + v->NbVP + v->NbTP;
s[17] += v->NbSL + v->NbVL + v->NbTL;
s[18] += v->NbST + v->NbVT + v->NbTT;
s[19] += v->NbSS + v->NbVS + v->NbTS;
}
}
sprintf(label, "%g", s[16]); XtVaSetValues(VLAB(19));
......
Unix/CbPost.cpp
+ 1
− 5
View file @ 0f05e69e
/* $Id: CbPost.cpp,v 1.6 2000-11-26 15:43:48 geuzaine Exp $ */
/* $Id: CbPost.cpp,v 1.7 2000-11-27 10:58:59 geuzaine Exp $ */
#include "Gmsh.h"
#include "GmshUI.h"
......@@ -129,10 +129,6 @@ void DuplicateViewCb (Widget w, XtPointer client_data, XtPointer call_data){
}
v2->Time = v1->Time;
v2->Points = v1->Points;
v2->Lines = v1->Lines;
v2->Triangles = v1->Triangles;
v2->Tetrahedra = v1->Tetrahedra;
v2->ScalarOnly = v1->ScalarOnly;
v2->Min = v1->Min;
v2->Max = v1->Max;
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment