Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Member Functions | Private Member Functions | List of all members
Nektar::FieldUtils::ProcessIsoContour Class Reference

This processing module extracts an isocontour. More...

#include <ProcessIsoContour.h>

Inheritance diagram for Nektar::FieldUtils::ProcessIsoContour:
Inheritance graph
[legend]
Collaboration diagram for Nektar::FieldUtils::ProcessIsoContour:
Collaboration graph
[legend]

Public Member Functions

 ProcessIsoContour (FieldSharedPtr f)
 
virtual ~ProcessIsoContour ()
 
virtual void Process (po::variables_map &vm)
 Write mesh to output file. More...
 
- Public Member Functions inherited from Nektar::FieldUtils::ProcessEquiSpacedOutput
 ProcessEquiSpacedOutput (FieldSharedPtr f)
 
virtual ~ProcessEquiSpacedOutput ()
 
virtual std::string GetModuleName ()
 
- Public Member Functions inherited from Nektar::FieldUtils::ProcessModule
 ProcessModule ()
 
 ProcessModule (FieldSharedPtr p_f)
 
- Public Member Functions inherited from Nektar::FieldUtils::Module
FIELD_UTILS_EXPORT Module (FieldSharedPtr p_f)
 
FIELD_UTILS_EXPORT void RegisterConfig (string key, string value)
 Register a configuration option with a module. More...
 
FIELD_UTILS_EXPORT void PrintConfig ()
 Print out all configuration options for a module. More...
 
FIELD_UTILS_EXPORT void SetDefaults ()
 Sets default configuration options for those which have not been set. More...
 
FIELD_UTILS_EXPORT bool GetRequireEquiSpaced (void)
 
FIELD_UTILS_EXPORT void SetRequireEquiSpaced (bool pVal)
 
FIELD_UTILS_EXPORT void EvaluateTriFieldAtEquiSpacedPts (LocalRegions::ExpansionSharedPtr &exp, const Array< OneD, const NekDouble > &infield, Array< OneD, NekDouble > &outfield)
 

Static Public Member Functions

static boost::shared_ptr< Modulecreate (FieldSharedPtr f)
 Creates an instance of this class. More...
 
- Static Public Member Functions inherited from Nektar::FieldUtils::ProcessEquiSpacedOutput
static boost::shared_ptr< Modulecreate (FieldSharedPtr f)
 Creates an instance of this class. More...
 

Static Public Attributes

static ModuleKey className
 
- Static Public Attributes inherited from Nektar::FieldUtils::ProcessEquiSpacedOutput
static ModuleKey className
 

Protected Member Functions

 ProcessIsoContour ()
 
void ResetFieldPts (vector< IsoSharedPtr > &iso)
 
void SetupIsoFromFieldPts (vector< IsoSharedPtr > &isovec)
 
- Protected Member Functions inherited from Nektar::FieldUtils::ProcessEquiSpacedOutput
 ProcessEquiSpacedOutput ()
 
void SetupEquiSpacedField (void)
 
void SetHomogeneousConnectivity (void)
 
void GenOrthoModes (int n, const Array< OneD, const NekDouble > &phys, Array< OneD, NekDouble > &coeffs)
 
- Protected Member Functions inherited from Nektar::FieldUtils::Module
 Module ()
 

Private Member Functions

vector< IsoSharedPtrExtractContour (const int fieldid, const NekDouble val)
 

Additional Inherited Members

- Protected Attributes inherited from Nektar::FieldUtils::Module
FieldSharedPtr m_f
 Field object. More...
 
map< string, ConfigOptionm_config
 List of configuration values. More...
 
bool m_requireEquiSpaced
 

Detailed Description

This processing module extracts an isocontour.

Definition at line 227 of file ProcessIsoContour.h.

Constructor & Destructor Documentation

Nektar::FieldUtils::ProcessIsoContour::ProcessIsoContour ( FieldSharedPtr  f)

Definition at line 69 of file ProcessIsoContour.cpp.

References Nektar::FieldUtils::Module::m_config.

69  :
71 {
72 
73  m_config["fieldstr"] = ConfigOption(false, "NotSet",
74  "string of isocontour to be extracted");
75  m_config["fieldname"] = ConfigOption(false, "isocon",
76  "name for isocontour if fieldstr "
77  "specified, default is isocon");
78 
79  m_config["fieldid"] = ConfigOption(false, "NotSet",
80  "field id to extract");
81 
82  m_config["fieldvalue"] = ConfigOption(false, "NotSet",
83  "field value to extract");
84 
85  m_config["globalcondense"] = ConfigOption(true, "NotSet",
86  "Globally condense contour to unique "
87  "values");
88 
89  m_config["smooth"] = ConfigOption(true, "NotSet",
90  "Smooth isocontour (might require "
91  "globalcondense)");
92 
93  m_config["smoothiter"] = ConfigOption(false, "100",
94  "Number of smoothing cycle, default = "
95  "100");
96 
97  m_config["smoothposdiffusion"] = ConfigOption(false,"0.5",
98  "Postive diffusion coefficient "
99  "(0 < lambda < 1), default = 0.5");
100 
101  m_config["smoothnegdiffusion"] = ConfigOption(false,"0.505",
102  "Negative diffusion coefficient "
103  "(0 < mu < 1), default = 0.505");
104 
105  m_config["removesmallcontour"] = ConfigOption(false,"0",
106  "Remove contours with less than specified number of triangles."
107  "Only valid with GlobalCondense or Smooth options.");
108 
109 
110 }
map< string, ConfigOption > m_config
List of configuration values.
Nektar::FieldUtils::ProcessIsoContour::~ProcessIsoContour ( void  )
virtual

Definition at line 112 of file ProcessIsoContour.cpp.

113 {
114 }
Nektar::FieldUtils::ProcessIsoContour::ProcessIsoContour ( )
inlineprotected

Definition at line 244 of file ProcessIsoContour.h.

244 {};

Member Function Documentation

static boost::shared_ptr<Module> Nektar::FieldUtils::ProcessIsoContour::create ( FieldSharedPtr  f)
inlinestatic

Creates an instance of this class.

Definition at line 231 of file ProcessIsoContour.h.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

232  {
234  }
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
vector< IsoSharedPtr > Nektar::FieldUtils::ProcessIsoContour::ExtractContour ( const int  fieldid,
const NekDouble  val 
)
private

Definition at line 399 of file ProcessIsoContour.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, ASSERTL1, Nektar::LibUtilities::ePtsTetBlock, Nektar::FieldUtils::Module::m_f, Nektar::FieldUtils::ThreeSimilar(), and Nektar::FieldUtils::TwoPairs().

Referenced by Process().

402 {
403  vector<IsoSharedPtr> returnval;
404 
405  int coordim = m_f->m_fieldPts->GetDim();
406  int nfields = m_f->m_fieldPts->GetNFields() + coordim;
407 
408  ASSERTL0(m_f->m_fieldPts->GetPtsType() == LibUtilities::ePtsTetBlock,
409  "This methods is currently only set up for 3D fields");
410  ASSERTL1(coordim + fieldid < nfields,
411  "field id is larger than number contained in FieldPts");
412  Array<OneD, Array<OneD, NekDouble> > fields;
413  m_f->m_fieldPts->GetPts(fields);
414 
415  Array<OneD, NekDouble> c = fields[coordim + fieldid];
416 
417  int i, j, k, ii, jj, kk, r, s, n, counter, boolean;
418  Array<OneD, Array<OneD, NekDouble> > intfields(nfields);
419  intfields[0] = Array<OneD, NekDouble>(5*nfields);
420  for(i = 1; i < nfields; ++i)
421  {
422  intfields[i] = intfields[i-1] + 5;
423  }
424  Array<OneD, NekDouble> cx = intfields[0];
425  Array<OneD, NekDouble> cy = intfields[1];
426  Array<OneD, NekDouble> cz = intfields[2];
427 
428  vector<Array<OneD, int> > ptsConn;
429  m_f->m_fieldPts->GetConnectivity(ptsConn);
430  for(int zone = 0; zone < ptsConn.size(); ++zone)
431  {
432  IsoSharedPtr iso;
433 
434  iso = MemoryManager<Iso>::AllocateSharedPtr(nfields-3);
435 
436  int nelmt = ptsConn[zone].num_elements()
437  /(coordim+1);
438 
439  Array<OneD, int> conn = ptsConn[zone];
440 
441  for (n = 0, i = 0; i < nelmt; ++i)
442  {
443  // check to see if val is between vertex values
444  if(!(((c[conn[i*4]] >val)&&(c[conn[i*4+1]]>val)&&
445  (c[conn[i*4+2]]>val)&&(c[conn[i*4+3]]>val))||
446  ((c[conn[i*4 ]]<val)&&(c[conn[i*4+1]]<val)&&
447  (c[conn[i*4+2]]<val)&&(c[conn[i*4+3]]<val))))
448  {
449 
450  // loop over all edges and interpolate if
451  // contour is between vertex values
452  for (counter = 0, j=0; j<=2; j++)
453  {
454  for (k=j+1; k<=3; k++)
455  {
456  if (((c[conn[i*4+j]]>=val)&&
457  (val>=c[conn[i*4+k]]))||
458  ((c[conn[i*4+j]]<=val)&&
459  (val<=c[conn[i*4+k]])))
460  {
461  // linear interpolation of fields
462  // (and coords).
463  NekDouble cj = c[conn[i*4+j]];
464  NekDouble ck = c[conn[i*4+k]];
465  NekDouble factor = (val-cj)/(ck-cj);
466 
467  if(fabs(cj-ck) > 1e-12)
468  {
469  // interpolate coordinates and fields
470  for(int f = 0; f < nfields; ++f)
471  {
472  if(counter == 5)
473  {
474  ASSERTL0(false,"Counter is 5");
475  }
476  intfields[f][counter] =
477  fields[f][conn[4*i+j]] +
478  factor*(fields[f][conn[4*i+k]] -
479  fields[f][conn[4*i+j]]);
480  }
481  ++counter;
482  }
483  }
484  }
485  }
486 
487  switch(counter)
488  {
489  case 3:
490  n+=1;
491  iso->ResizeFields(3*n);
492 
493  for(j = 0; j < 3; ++j)
494  {
495  iso->SetFields(3*(n-1)+j,intfields,j);
496  }
497  break;
498  case 4:
499  n+=2;
500  iso->ResizeFields(3*n);
501 
502  for(j = 0; j < 3; ++j)
503  {
504  iso->SetFields(3*(n-2)+j,intfields,j);
505  iso->SetFields(3*(n-1)+j,intfields,j+1);
506  }
507  break;
508  case 5:
509  n+=1;
510  iso->ResizeFields(3*n);
511 
512  boolean=0;
513  for (ii=0;ii<=2;ii++)
514  {
515  for (jj=ii+1;jj<=3;jj++)
516  {
517  for (kk=jj+1;kk<=4;kk++)
518  {
519  if((((cx[ii]-cx[jj])==0.0)&&
520  ((cy[ii]-cy[jj])==0.0)&&
521  ((cz[ii]-cz[jj])==0.0))&&
522  (((cx[ii]-cx[kk])==0.0)&&
523  ((cy[ii]-cy[kk])==0.0)&&
524  ((cz[ii]-cz[kk])==0.0)))
525  {
526  boolean+=1;
527  ThreeSimilar (ii,jj,kk,r,s);
528 
529  iso->SetFields(3*(n-1) ,intfields,ii);
530  iso->SetFields(3*(n-1)+1,intfields,r);
531  iso->SetFields(3*(n-1)+2,intfields,s);
532  }
533  else
534  {
535  boolean+=0;
536  }
537  }
538  }
539  }
540 
541  if (boolean==0)
542  {
543  TwoPairs (cx,cy,cz,r);
544 
545  iso->SetFields(3*(n-1) ,intfields,0);
546  iso->SetFields(3*(n-1)+1,intfields,2);
547  iso->SetFields(3*(n-1)+2,intfields,r);
548  }
549  break;
550  }
551  }
552  }
553 
554  if(n)
555  {
556  iso->SetNTris(n);
557 
558  // condense the information in this elemental extraction.
559  iso->Condense();
560  returnval.push_back(iso);
561  }
562  }
563 
564  return returnval;
565 }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
void ThreeSimilar(const int i, const int j, const int k, int &pr, int &ps)
void TwoPairs(Array< OneD, NekDouble > &cx, Array< OneD, NekDouble > &cy, Array< OneD, NekDouble > &cz, int &pr)
boost::shared_ptr< Iso > IsoSharedPtr
double NekDouble
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
FieldSharedPtr m_f
Field object.
void Nektar::FieldUtils::ProcessIsoContour::Process ( po::variables_map &  vm)
virtual

Write mesh to output file.

Reimplemented from Nektar::FieldUtils::ProcessEquiSpacedOutput.

Definition at line 116 of file ProcessIsoContour.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, ExtractContour(), Nektar::FieldUtils::Module::m_config, Nektar::FieldUtils::Module::m_f, ResetFieldPts(), Nektar::FieldUtils::ProcessEquiSpacedOutput::SetupEquiSpacedField(), SetupIsoFromFieldPts(), Nektar::Timer::Start(), Nektar::Timer::Stop(), and Nektar::Timer::TimePerTest().

117 {
118  Timer timer;
119  int rank = m_f->m_comm->GetRank();
120 
121  if(m_f->m_verbose)
122  {
123  if(rank == 0)
124  {
125  cout << "Process Contour extraction..." << endl;
126  timer.Start();
127  }
128  }
129 
130  vector<IsoSharedPtr> iso;
131 
132  if(m_f->m_fieldPts.get()) // assume we have read .dat file to directly input dat file.
133  {
134  if(rank == 0)
135  {
136  cout << "Process read iso from Field Pts" << endl;
137  }
138 
140  }
141  else // extract isocontour from field
142  {
143  if(m_f->m_exp.size() == 0)
144  {
145  return;
146  }
147 
148  // extract all fields to equi-spaced
150 
151  int fieldid;
152  NekDouble value;
153 
154  if(m_config["fieldstr"].m_beenSet) //generate field of interest
155  {
156  fieldid = m_f->m_fieldPts->GetNFields();
157 
158  Array<OneD, NekDouble> pts(m_f->m_fieldPts->GetNpoints());
159 
160  // evaluate new function
161  LibUtilities::AnalyticExpressionEvaluator strEval;
162  string varstr = "x y z";
163  vector<Array<OneD, const NekDouble> > interpfields;
164 
165  for(int i = 0; i < m_f->m_fieldPts->GetDim(); ++i)
166  {
167  interpfields.push_back(m_f->m_fieldPts->GetPts(i));
168  }
169  for(int i = 0; i < m_f->m_fieldPts->GetNFields(); ++i)
170  {
171  varstr += " " + m_f->m_fieldPts->GetFieldName(i);
172  interpfields.push_back(m_f->m_fieldPts->GetPts(i+3));
173  }
174 
175  int ExprId = -1;
176  std::string str = m_config["fieldstr"].as<string>();
177  ExprId = strEval.DefineFunction(varstr.c_str(), str);
178 
179  strEval.Evaluate(ExprId, interpfields, pts);
180 
181  // set up field name if provided otherwise called "isocon" from default
182  string fieldName = m_config["fieldname"].as<string>();
183 
184  m_f->m_fieldPts->AddField(pts, fieldName);
185  }
186  else
187  {
188  ASSERTL0(m_config["fieldid"].as<string>() != "NotSet", "fieldid must be specified");
189  fieldid = m_config["fieldid"].as<int>();
190  }
191 
192  ASSERTL0(m_config["fieldvalue"].as<string>() != "NotSet", "fieldvalue must be specified");
193  value = m_config["fieldvalue"].as<NekDouble>();
194 
195  iso = ExtractContour(fieldid,value);
196 
197  }
198 
199  // Process isocontour
200  bool smoothing = m_config["smooth"].m_beenSet;
201  bool globalcondense = m_config["globalcondense"].m_beenSet;
202  if(globalcondense)
203  {
204  if(rank == 0)
205  {
206  cout << "Process global condense ..." << endl;
207  }
208  int nfields = m_f->m_fieldPts->GetNFields() + m_f->m_fieldPts->GetDim();
210 
211  g_iso->GlobalCondense(iso,m_f->m_verbose);
212 
213 
214  iso.clear();
215  iso.push_back(g_iso);
216  }
217 
218  if(smoothing)
219  {
220  Timer timersm;
221 
222  if(m_f->m_verbose)
223  {
224  if(rank == 0)
225  {
226  cout << "Process Contour smoothing ..." << endl;
227  timersm.Start();
228  }
229  }
230 
231  int niter = m_config["smoothiter"].as<int>();
232  NekDouble lambda = m_config["smoothposdiffusion"].as<NekDouble>();
233  NekDouble mu = m_config["smoothnegdiffusion"].as<NekDouble>();
234  for(int i =0 ; i < iso.size(); ++i)
235  {
236  iso[i]->Smooth(niter,lambda,-mu);
237  }
238 
239  if(m_f->m_verbose)
240  {
241  if(rank == 0)
242  {
243  timersm.Stop();
244  NekDouble cpuTime = timersm.TimePerTest(1);
245 
246  stringstream ss;
247  ss << cpuTime << "s";
248  cout << "Process smooth CPU Time: " << setw(8) << left
249  << ss.str() << endl;
250  cpuTime = 0.0;
251  }
252  }
253  }
254 
255  int mincontour = 0;
256  if((mincontour = m_config["removesmallcontour"].as<int>()))
257  {
258  vector<IsoSharedPtr> new_iso;
259 
260  if(rank == 0)
261  {
262  cout << "Identifying separate regions [." << flush ;
263  }
264  for(int i =0 ; i < iso.size(); ++i)
265  {
266  iso[i]->SeparateRegions(new_iso,mincontour,m_f->m_verbose);
267  }
268 
269  if(rank == 0)
270  {
271  cout << "]" << endl << flush ;
272  }
273 
274  // reset iso to new_iso;
275  iso = new_iso;
276  }
277 
278  ResetFieldPts(iso);
279 
280 
281  if(m_f->m_verbose)
282  {
283  if(rank == 0)
284  {
285  timer.Stop();
286  NekDouble cpuTime = timer.TimePerTest(1);
287 
288  stringstream ss;
289  ss << cpuTime << "s";
290  cout << "Process Isocontour CPU Time: " << setw(8) << left
291  << ss.str() << endl;
292  cpuTime = 0.0;
293  }
294  }
295 }
map< string, ConfigOption > m_config
List of configuration values.
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
void ResetFieldPts(vector< IsoSharedPtr > &iso)
void SetupIsoFromFieldPts(vector< IsoSharedPtr > &isovec)
boost::shared_ptr< Iso > IsoSharedPtr
double NekDouble
vector< IsoSharedPtr > ExtractContour(const int fieldid, const NekDouble val)
FieldSharedPtr m_f
Field object.
void Nektar::FieldUtils::ProcessIsoContour::ResetFieldPts ( vector< IsoSharedPtr > &  iso)
protected

Definition at line 568 of file ProcessIsoContour.cpp.

References Nektar::LibUtilities::ePtsTriBlock, Nektar::FieldUtils::Module::m_f, and npts.

Referenced by Process().

569 {
570  int nfields = m_f->m_fieldPts->GetNFields() + m_f->m_fieldPts->GetDim();
571 
572  // set output to triangle block.
573  m_f->m_fieldPts->SetPtsType(LibUtilities::ePtsTriBlock);
574 
575  Array<OneD, Array<OneD, NekDouble> > newfields(nfields);
576 
577  // count up number of points
578  int npts = 0;
579  for(int i =0; i < iso.size(); ++i)
580  {
581  npts += iso[i]->GetNVert();
582  }
583 
584  // set up coordinate in new field
585  newfields[0] = Array<OneD, NekDouble>(npts);
586  newfields[1] = Array<OneD, NekDouble>(npts);
587  newfields[2] = Array<OneD, NekDouble>(npts);
588 
589  int cnt = 0;
590  for(int i =0; i < iso.size(); ++i)
591  {
592  for(int j = 0; j < iso[i]->GetNVert(); ++j,++cnt)
593  {
594  newfields[0][cnt] = iso[i]->GetX(j);
595  newfields[1][cnt] = iso[i]->GetY(j);
596  newfields[2][cnt] = iso[i]->GetZ(j);
597  }
598  }
599 
600 
601  // set up fields
602  for(int f = 0; f < nfields-3; ++f)
603  {
604  newfields[f+3] = Array<OneD, NekDouble>(npts);
605 
606  cnt = 0;
607  for(int i =0; i < iso.size(); ++i)
608  {
609  for(int j = 0; j < iso[i]->GetNVert(); ++j,++cnt)
610  {
611  newfields[f+3][cnt] = iso[i]->GetFields(f,j);
612  }
613  }
614  }
615 
616  m_f->m_fieldPts->SetPts(newfields);
617 
618  // set up connectivity data.
619  vector<Array<OneD, int> > ptsConn;
620  m_f->m_fieldPts->GetConnectivity(ptsConn);
621  cnt = 0;
622  ptsConn.clear();
623  for(int i =0; i < iso.size(); ++i)
624  {
625  int ntris = iso[i]->GetNTris();
626  Array<OneD, int> conn(ntris*3);
627 
628  for(int j = 0; j < 3*ntris; ++j)
629  {
630  conn[j] = cnt + iso[i]->GetVId(j);
631  }
632  ptsConn.push_back(conn);
633  cnt += iso[i]->GetNVert();
634  }
635  m_f->m_fieldPts->SetConnectivity(ptsConn);
636 }
static std::string npts
Definition: InputFld.cpp:43
FieldSharedPtr m_f
Field object.
void Nektar::FieldUtils::ProcessIsoContour::SetupIsoFromFieldPts ( vector< IsoSharedPtr > &  isovec)
protected

Definition at line 639 of file ProcessIsoContour.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::ePtsTriBlock, and Nektar::FieldUtils::Module::m_f.

Referenced by Process().

640 {
641  ASSERTL0(m_f->m_fieldPts->GetPtsType() == LibUtilities::ePtsTriBlock,
642  "Assume input is from ePtsTriBlock");
643 
644  // get information from PtsField
645  int dim = m_f->m_fieldPts->GetDim();
646  int nfields = m_f->m_fieldPts->GetNFields() + dim;
647  Array<OneD, Array<OneD, NekDouble> > fieldpts;
648  m_f->m_fieldPts->GetPts(fieldpts);
649  vector<Array<OneD, int> > ptsConn;
650  m_f->m_fieldPts->GetConnectivity(ptsConn);
651 
652 
653  int cnt = 0;
654  for(int c = 0; c < ptsConn.size(); ++c)
655  {
656  // set up single iso with all the information from PtsField
658 
659  int nelmt = 0;
660  nelmt = ptsConn[c].num_elements()/3;
661 
662  iso->SetNTris(nelmt);
663  iso->ResizeVId(3*nelmt);
664 
665  // fill in connectivity values.
666  int nvert = 0;
667  for(int i = 0; i < ptsConn[c].num_elements(); ++i)
668  {
669  int cid = ptsConn[c][i]-cnt;
670  iso->SetVId(i,cid);
671  nvert = max(cid,nvert);
672  }
673  nvert++;
674 
675  iso->SetNVert(nvert);
676  iso->ResizeFields(nvert);
677 
678  // fill in points values (including coordinates)
679  for(int i = 0; i < nvert; ++i)
680  {
681  iso->SetFields(i,fieldpts,i+cnt);
682  }
683  cnt += nvert;
684  isovec.push_back(iso);
685  }
686 
687 }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
boost::shared_ptr< Iso > IsoSharedPtr
FieldSharedPtr m_f
Field object.

Member Data Documentation

ModuleKey Nektar::FieldUtils::ProcessIsoContour::className
static
Initial value:
=
ModuleKey(eProcessModule, "isocontour"),
"Extract an isocontour of fieldid variable and at "
"value fieldvalue, Optionally fieldstr can be "
"specified for a string defiition or smooth for "
"smoothing")

Definition at line 235 of file ProcessIsoContour.h.