← Back to branch summary

~ubuntu-branches/ubuntu/karmic/gmsh/karmic

« back to all changes in this revision

Viewing changes to Plugin/ExtractElements.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Christophe Prud'homme, Christophe Prud'homme, Daniel Leidert
  • Date: 2008-05-18 12:46:05 UTC
  • mfrom: (1.2.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20080518124605-716xqbqeo07o497k
Tags: 2.2.0-2
[Christophe Prud'homme]
* Bug fix: "gmsh ships no .desktop", thanks to Vassilis Pandis (Closes:
  #375770). Applied the Ubuntu patch.

[Daniel Leidert]
* debian/control (Vcs-Svn): Fixed.
  (Build-Depends): Use texlive instead of tetex-bin.
* debian/gmsh.doc-base (Section): Fixed accordingly to doc-base (>= 0.8.10).
* debian/rules: Removed some variable declarations, that lead to double
  configuration and seem to be useless.
  (build/gmsh): Try to avoid multiple runs by using a stamp.
  (orig-tarball): Renamed to get-orig-source and changed to use uscan.
* debian/watch: Added.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Plugin/ExtractElements.cpp
1
 
// $Id: ExtractElements.cpp,v 1.8 2007-05-04 10:45:09 geuzaine Exp $
 
1
// $Id: ExtractElements.cpp,v 1.13 2008-04-05 17:49:23 geuzaine Exp $
2
2
//
3
 
// Copyright (C) 1997-2007 C. Geuzaine, J.-F. Remacle
 
3
// Copyright (C) 1997-2008 C. Geuzaine, J.-F. Remacle
4
4
//
5
5
// This program is free software; you can redistribute it and/or modify
6
6
// it under the terms of the GNU General Public License as published by
19
19
// 
20
20
// Please report all bugs and problems to <gmsh@geuz.org>.
21
21
 
22
 
#include "Plugin.h"
23
22
#include "ExtractElements.h"
24
 
#include "List.h"
25
 
#include "Views.h"
26
 
#include "Context.h"
27
 
#include "Malloc.h"
28
 
 
29
 
extern Context_T CTX;
 
23
#include "Numeric.h"
30
24
 
31
25
StringXNumber ExtractElementsOptions_Number[] = {
32
26
  {GMSH_FULLRC, "MinVal", NULL, 0.},
43
37
  }
44
38
}
45
39
 
46
 
GMSH_ExtractElementsPlugin::GMSH_ExtractElementsPlugin()
47
 
{
48
 
  ;
49
 
}
50
 
 
51
40
void GMSH_ExtractElementsPlugin::getName(char *name) const
52
41
{
53
42
  strcpy(name, "Extract Elements");
59
48
  strcpy(copyright, "DGR (www.multiphysics.com)");
60
49
  strcpy(help_text,
61
50
         "Plugin(ExtractElements) extracts the elements\n"
62
 
         "from the view `iView' whose `TimeStep'-th values\n"
63
 
         "(averaged by element) are comprised between\n"
64
 
         "`MinVal' and `MaxVal'. If `iView' < 0, the plugin\n"
65
 
         "is run on the current view.\n"
66
 
         "\n"
67
 
         "Plugin(ExtractElements) creates one new view.\n");
 
51
         "from the view `iView' whose `TimeStep'-th values\n"
 
52
         "(averaged by element) are comprised between\n"
 
53
         "`MinVal' and `MaxVal'. If `iView' < 0, the plugin\n"
 
54
         "is run on the current view.\n"
 
55
         "\n"
 
56
         "Plugin(ExtractElements) creates one new view.\n");
68
57
}
69
58
 
70
59
int GMSH_ExtractElementsPlugin::getNbOptions() const
83
72
}
84
73
 
85
74
static void extract(List_T *inList, int inNb, 
86
 
                    List_T *outList, int *outNb, 
87
 
                    int timeStep, int nbNod, int nbComp)
 
75
                    List_T *outList, int *outNb, 
 
76
                    int timeStep, int nbNod, int nbComp)
88
77
{
89
78
  if(!inNb)
90
79
    return;
95
84
  int nb = List_Nbr(inList) / inNb;
96
85
  for(int i = 0; i < List_Nbr(inList); i += nb) {
97
86
    double *vals = (double *)List_Pointer_Fast(inList, i + 3 * nbNod + 
98
 
                                               timeStep * nbNod * nbComp);
 
87
                                               timeStep * nbNod * nbComp);
99
88
    double d = 0.;
100
89
    for(int k = 0; k < nbNod; k++) {
101
90
      double *v = &vals[nbComp * k];
102
91
      switch(nbComp) {
103
92
      case 1: // scalar
104
 
        d += v[0];
105
 
        break;
 
93
        d += v[0];
 
94
        break;
106
95
      case 3 : // vector
107
 
        d += sqrt(DSQR(v[0]) + DSQR(v[1]) + DSQR(v[2]));
108
 
        break;
 
96
        d += sqrt(DSQR(v[0]) + DSQR(v[1]) + DSQR(v[2]));
 
97
        break;
109
98
      case 9 : // tensor
110
 
        d += ComputeVonMises(v);
111
 
        break;
 
99
        d += ComputeVonMises(v);
 
100
        break;
112
101
      }
113
102
    }
114
103
    d /= (double)nbNod;
116
105
    // worrying about roundoff errors
117
106
    if(d >= MinVal && d < MaxVal){
118
107
      for(int j = 0; j < nb; j++)
119
 
        List_Add(outList, List_Pointer_Fast(inList, i + j));
 
108
        List_Add(outList, List_Pointer_Fast(inList, i + j));
120
109
      (*outNb)++;
121
110
    }
122
111
  }
123
112
}
124
113
 
125
 
Post_View *GMSH_ExtractElementsPlugin::execute(Post_View * v)
 
114
PView *GMSH_ExtractElementsPlugin::execute(PView *v)
126
115
{
127
116
  int step = (int)ExtractElementsOptions_Number[2].def;
128
117
  int iView = (int)ExtractElementsOptions_Number[3].def;
129
118
 
130
 
  if(iView < 0)
131
 
    iView = v ? v->Index : 0;
132
 
 
133
 
  if(!List_Pointer_Test(CTX.post.list, iView)) {
134
 
    Msg(GERROR, "View[%d] does not exist", iView);
135
 
    return v;
136
 
  }
137
 
 
138
 
  Post_View *v1 = *(Post_View **)List_Pointer(CTX.post.list, iView);
139
 
  Post_View *v2 = BeginView(1);
140
 
 
141
 
  if(step < 0 || step > v1->NbTimeStep-1){
 
119
  PView *v1 = getView(iView, v);
 
120
  if(!v1) return v;
 
121
 
 
122
  PViewDataList *data1 = getDataList(v1);
 
123
  if(!data1) return v;
 
124
 
 
125
  PView *v2 = new PView(true);
 
126
 
 
127
  PViewDataList *data2 = getDataList(v2);
 
128
  if(!data2) return v;
 
129
 
 
130
  if(step < 0 || step > data1->getNumTimeSteps() - 1){
142
131
    Msg(GERROR, "Invalid time step (%d) in View[%d]: using first step instead",
143
 
        step, v1->Num);
 
132
        step, v1->getIndex());
144
133
    step = 0;
145
134
  }
146
135
 
147
136
  // points
148
 
  extract(v1->SP, v1->NbSP, v2->SP, &v2->NbSP, step, 1, 1);
149
 
  extract(v1->VP, v1->NbVP, v2->SP, &v2->NbSP, step, 1, 3);
150
 
  extract(v1->TP, v1->NbTP, v2->SP, &v2->NbSP, step, 1, 9);
151
 
  // lines                                              
152
 
  extract(v1->SL, v1->NbSL, v2->SL, &v2->NbSL, step, 2, 1);
153
 
  extract(v1->VL, v1->NbVL, v2->SL, &v2->NbSL, step, 2, 3);
154
 
  extract(v1->TL, v1->NbTL, v2->SL, &v2->NbSL, step, 2, 9);
155
 
  // triangles                                          
156
 
  extract(v1->ST, v1->NbST, v2->ST, &v2->NbST, step, 3, 1);
157
 
  extract(v1->VT, v1->NbVT, v2->ST, &v2->NbST, step, 3, 3);
158
 
  extract(v1->TT, v1->NbTT, v2->ST, &v2->NbST, step, 3, 9);
159
 
  // quadrangles                                        
160
 
  extract(v1->SQ, v1->NbSQ, v2->SQ, &v2->NbSQ, step, 4, 1);
161
 
  extract(v1->VQ, v1->NbVQ, v2->SQ, &v2->NbSQ, step, 4, 3);
162
 
  extract(v1->TQ, v1->NbTQ, v2->SQ, &v2->NbSQ, step, 4, 9);
163
 
  // tets                                               
164
 
  extract(v1->SS, v1->NbSS, v2->SS, &v2->NbSS, step, 4, 1);
165
 
  extract(v1->VS, v1->NbVS, v2->SS, &v2->NbSS, step, 4, 3);
166
 
  extract(v1->TS, v1->NbTS, v2->SS, &v2->NbSS, step, 4, 9);
167
 
  // hexas                                              
168
 
  extract(v1->SH, v1->NbSH, v2->SH, &v2->NbSH, step, 8, 1);
169
 
  extract(v1->VH, v1->NbVH, v2->SH, &v2->NbSH, step, 8, 3);
170
 
  extract(v1->TH, v1->NbTH, v2->SH, &v2->NbSH, step, 8, 9);
171
 
  // prisms                                             
172
 
  extract(v1->SI, v1->NbSI, v2->SI, &v2->NbSI, step, 6, 1);
173
 
  extract(v1->VI, v1->NbVI, v2->SI, &v2->NbSI, step, 6, 3);
174
 
  extract(v1->TI, v1->NbTI, v2->SI, &v2->NbSI, step, 6, 9);
175
 
  // pyramids                                           
176
 
  extract(v1->SY, v1->NbSY, v2->SY, &v2->NbSY, step, 5, 1);
177
 
  extract(v1->VY, v1->NbVY, v2->SY, &v2->NbSY, step, 5, 3);
178
 
  extract(v1->TY, v1->NbTY, v2->SY, &v2->NbSY, step, 5, 9);
179
 
 
180
 
  // copy time data
181
 
  for(int i = 0; i < List_Nbr(v1->Time); i++)
182
 
    List_Add(v2->Time, List_Pointer(v1->Time, i));
183
 
 
184
 
  // finalize
185
 
  char name[1024], filename[1024];
186
 
  sprintf(name, "%s_ExtractElements", v1->Name);
187
 
  sprintf(filename, "%s_ExtractElements.pos", v1->Name);
188
 
  EndView(v2, 1, filename, name);
 
137
  extract(data1->SP, data1->NbSP, data2->SP, &data2->NbSP, step, 1, 1);
 
138
  extract(data1->VP, data1->NbVP, data2->VP, &data2->NbVP, step, 1, 3);
 
139
  extract(data1->TP, data1->NbTP, data2->TP, &data2->NbTP, step, 1, 9);
 
140
  // lines                                              
 
141
  extract(data1->SL, data1->NbSL, data2->SL, &data2->NbSL, step, 2, 1);
 
142
  extract(data1->VL, data1->NbVL, data2->VL, &data2->NbVL, step, 2, 3);
 
143
  extract(data1->TL, data1->NbTL, data2->TL, &data2->NbTL, step, 2, 9);
 
144
  // triangles                                          
 
145
  extract(data1->ST, data1->NbST, data2->ST, &data2->NbST, step, 3, 1);
 
146
  extract(data1->VT, data1->NbVT, data2->VT, &data2->NbVT, step, 3, 3);
 
147
  extract(data1->TT, data1->NbTT, data2->TT, &data2->NbTT, step, 3, 9);
 
148
  // quadrangles                                        
 
149
  extract(data1->SQ, data1->NbSQ, data2->SQ, &data2->NbSQ, step, 4, 1);
 
150
  extract(data1->VQ, data1->NbVQ, data2->VQ, &data2->NbVQ, step, 4, 3);
 
151
  extract(data1->TQ, data1->NbTQ, data2->TQ, &data2->NbTQ, step, 4, 9);
 
152
  // tets                                               
 
153
  extract(data1->SS, data1->NbSS, data2->SS, &data2->NbSS, step, 4, 1);
 
154
  extract(data1->VS, data1->NbVS, data2->VS, &data2->NbVS, step, 4, 3);
 
155
  extract(data1->TS, data1->NbTS, data2->TS, &data2->NbTS, step, 4, 9);
 
156
  // hexas                                              
 
157
  extract(data1->SH, data1->NbSH, data2->SH, &data2->NbSH, step, 8, 1);
 
158
  extract(data1->VH, data1->NbVH, data2->VH, &data2->NbVH, step, 8, 3);
 
159
  extract(data1->TH, data1->NbTH, data2->TH, &data2->NbTH, step, 8, 9);
 
160
  // prisms                                             
 
161
  extract(data1->SI, data1->NbSI, data2->SI, &data2->NbSI, step, 6, 1);
 
162
  extract(data1->VI, data1->NbVI, data2->VI, &data2->NbVI, step, 6, 3);
 
163
  extract(data1->TI, data1->NbTI, data2->TI, &data2->NbTI, step, 6, 9);
 
164
  // pyramids                                           
 
165
  extract(data1->SY, data1->NbSY, data2->SY, &data2->NbSY, step, 5, 1);
 
166
  extract(data1->VY, data1->NbVY, data2->VY, &data2->NbVY, step, 5, 3);
 
167
  extract(data1->TY, data1->NbTY, data2->TY, &data2->NbTY, step, 5, 9);
 
168
 
 
169
  for(int i = 0; i < List_Nbr(data1->Time); i++)
 
170
    List_Add(data2->Time, List_Pointer(data1->Time, i));
 
171
  data2->setName(data1->getName() + "_ExtractElements");
 
172
  data2->setFileName(data1->getName() + "_ExtractElements.pos");
 
173
  data2->finalize();
 
174
 
189
175
  return v2;
190
176
}