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

This processing module extracts an isocontour. More...

#include <ProcessIsoContour.h>

Inheritance diagram for Nektar::Utilities::ProcessIsoContour:
Inheritance graph
[legend]
Collaboration diagram for Nektar::Utilities::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::Utilities::ProcessEquiSpacedOutput
 ProcessEquiSpacedOutput (FieldSharedPtr f)
 
virtual ~ProcessEquiSpacedOutput ()
 
- Public Member Functions inherited from Nektar::Utilities::ProcessModule
 ProcessModule ()
 
 ProcessModule (FieldSharedPtr p_f)
 
 ProcessModule (MeshSharedPtr p_m)
 
- Public Member Functions inherited from Nektar::Utilities::Module
 Module (FieldSharedPtr p_f)
 
void RegisterConfig (string key, string value)
 Register a configuration option with a module. More...
 
void PrintConfig ()
 Print out all configuration options for a module. More...
 
void SetDefaults ()
 Sets default configuration options for those which have not been set. More...
 
bool GetRequireEquiSpaced (void)
 
void SetRequireEquiSpaced (bool pVal)
 
void EvaluateTriFieldAtEquiSpacedPts (LocalRegions::ExpansionSharedPtr &exp, const Array< OneD, const NekDouble > &infield, Array< OneD, NekDouble > &outfield)
 
 Module (MeshSharedPtr p_m)
 
virtual void Process ()=0
 
void RegisterConfig (std::string key, std::string value)
 
void PrintConfig ()
 
void SetDefaults ()
 
MeshSharedPtr GetMesh ()
 
virtual void ProcessVertices ()
 Extract element vertices. More...
 
virtual void ProcessEdges (bool ReprocessEdges=true)
 Extract element edges. More...
 
virtual void ProcessFaces (bool ReprocessFaces=true)
 Extract element faces. More...
 
virtual void ProcessElements ()
 Generate element IDs. More...
 
virtual void ProcessComposites ()
 Generate composites. More...
 
virtual void ClearElementLinks ()
 

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::Utilities::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::Utilities::ProcessEquiSpacedOutput
static ModuleKey className
 

Protected Member Functions

 ProcessIsoContour ()
 
void ResetFieldPts (vector< IsoSharedPtr > &iso)
 
void SetupIsoFromFieldPts (vector< IsoSharedPtr > &isovec)
 
- Protected Member Functions inherited from Nektar::Utilities::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::Utilities::Module
 Module ()
 
void ReorderPrisms (PerMap &perFaces)
 Reorder node IDs so that prisms and tetrahedra are aligned correctly. More...
 
void PrismLines (int prism, PerMap &perFaces, std::set< int > &prismsDone, std::vector< ElementSharedPtr > &line)
 

Private Member Functions

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

Additional Inherited Members

- Protected Attributes inherited from Nektar::Utilities::Module
FieldSharedPtr m_f
 Field object. More...
 
map< string, ConfigOptionm_config
 List of configuration values. More...
 
bool m_requireEquiSpaced
 
MeshSharedPtr m_mesh
 Mesh object. More...
 
std::map< std::string,
ConfigOption
m_config
 List of configuration values. More...
 

Detailed Description

This processing module extracts an isocontour.

Definition at line 227 of file ProcessIsoContour.h.

Constructor & Destructor Documentation

Nektar::Utilities::ProcessIsoContour::ProcessIsoContour ( FieldSharedPtr  f)

Definition at line 60 of file ProcessIsoContour.cpp.

References Nektar::Utilities::Module::m_config.

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

Definition at line 103 of file ProcessIsoContour.cpp.

104 {
105 }
Nektar::Utilities::ProcessIsoContour::ProcessIsoContour ( )
inlineprotected

Definition at line 244 of file ProcessIsoContour.h.

244 {};

Member Function Documentation

static boost::shared_ptr<Module> Nektar::Utilities::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::Utilities::ProcessIsoContour::ExtractContour ( const int  fieldid,
const NekDouble  val 
)
private

Definition at line 355 of file ProcessIsoContour.cpp.

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

Referenced by Process().

358 {
359  vector<IsoSharedPtr> returnval;
360 
361  int coordim = m_f->m_fieldPts->GetDim();
362  int nfields = m_f->m_fieldPts->GetNFields() + coordim;
363 
364  ASSERTL0(m_f->m_fieldPts->GetPtsType() == LibUtilities::ePtsTetBlock,
365  "This methods is currently only set up for 3D fields");
366  ASSERTL1(coordim + fieldid < nfields,
367  "field id is larger than number contained in FieldPts");
368  Array<OneD, Array<OneD, NekDouble> > fields;
369  m_f->m_fieldPts->GetPts(fields);
370 
371  Array<OneD, NekDouble> c = fields[coordim + fieldid];
372 
373  int i, j, k, ii, jj, kk, r, s, n, counter, boolean;
374  Array<OneD, Array<OneD, NekDouble> > intfields(nfields);
375  intfields[0] = Array<OneD, NekDouble>(5*nfields);
376  for(i = 1; i < nfields; ++i)
377  {
378  intfields[i] = intfields[i-1] + 5;
379  }
380  Array<OneD, NekDouble> cx = intfields[0];
381  Array<OneD, NekDouble> cy = intfields[1];
382  Array<OneD, NekDouble> cz = intfields[2];
383 
384  vector<Array<OneD, int> > ptsConn;
385  m_f->m_fieldPts->GetConnectivity(ptsConn);
386  for(int zone = 0; zone < ptsConn.size(); ++zone)
387  {
388  IsoSharedPtr iso;
389 
390  iso = MemoryManager<Iso>::AllocateSharedPtr(nfields-3);
391 
392  int nelmt = ptsConn[zone].num_elements()
393  /(coordim+1);
394 
395  Array<OneD, int> conn = ptsConn[zone];
396 
397  for (n = 0, i = 0; i < nelmt; ++i)
398  {
399  // check to see if val is between vertex values
400  if(!(((c[conn[i*4]] >val)&&(c[conn[i*4+1]]>val)&&
401  (c[conn[i*4+2]]>val)&&(c[conn[i*4+3]]>val))||
402  ((c[conn[i*4 ]]<val)&&(c[conn[i*4+1]]<val)&&
403  (c[conn[i*4+2]]<val)&&(c[conn[i*4+3]]<val))))
404  {
405 
406  // loop over all edges and interpolate if
407  // contour is between vertex values
408  for (counter = 0, j=0; j<=2; j++)
409  {
410  for (k=j+1; k<=3; k++)
411  {
412  if (((c[conn[i*4+j]]>=val)&&
413  (val>=c[conn[i*4+k]]))||
414  ((c[conn[i*4+j]]<=val)&&
415  (val<=c[conn[i*4+k]])))
416  {
417  // linear interpolation of fields
418  // (and coords).
419  NekDouble cj = c[conn[i*4+j]];
420  NekDouble ck = c[conn[i*4+k]];
421  NekDouble factor = (val-cj)/(ck-cj);
422 
423  if(fabs(cj-ck) > 1e-12)
424  {
425  // interpolate coordinates and fields
426  for(int f = 0; f < nfields; ++f)
427  {
428  if(counter == 5)
429  {
430  ASSERTL0(false,"Counter is 5");
431  }
432  intfields[f][counter] =
433  fields[f][conn[4*i+j]] +
434  factor*(fields[f][conn[4*i+k]] -
435  fields[f][conn[4*i+j]]);
436  }
437  ++counter;
438  }
439  }
440  }
441  }
442 
443  switch(counter)
444  {
445  case 3:
446  n+=1;
447  iso->resize_fields(3*n);
448 
449  for(j = 0; j < 3; ++j)
450  {
451  iso->set_fields(3*(n-1)+j,intfields,j);
452  }
453  break;
454  case 4:
455  n+=2;
456  iso->resize_fields(3*n);
457 
458  for(j = 0; j < 3; ++j)
459  {
460  iso->set_fields(3*(n-2)+j,intfields,j);
461  iso->set_fields(3*(n-1)+j,intfields,j+1);
462  }
463  break;
464  case 5:
465  n+=1;
466  iso->resize_fields(3*n);
467 
468  boolean=0;
469  for (ii=0;ii<=2;ii++)
470  {
471  for (jj=ii+1;jj<=3;jj++)
472  {
473  for (kk=jj+1;kk<=4;kk++)
474  {
475  if((((cx[ii]-cx[jj])==0.0)&&
476  ((cy[ii]-cy[jj])==0.0)&&
477  ((cz[ii]-cz[jj])==0.0))&&
478  (((cx[ii]-cx[kk])==0.0)&&
479  ((cy[ii]-cy[kk])==0.0)&&
480  ((cz[ii]-cz[kk])==0.0)))
481  {
482  boolean+=1;
483  ThreeSimilar (ii,jj,kk,r,s);
484 
485  iso->set_fields(3*(n-1) ,intfields,ii);
486  iso->set_fields(3*(n-1)+1,intfields,r);
487  iso->set_fields(3*(n-1)+2,intfields,s);
488  }
489  else
490  {
491  boolean+=0;
492  }
493  }
494  }
495  }
496 
497  if (boolean==0)
498  {
499  TwoPairs (cx,cy,cz,r);
500 
501  iso->set_fields(3*(n-1) ,intfields,0);
502  iso->set_fields(3*(n-1)+1,intfields,2);
503  iso->set_fields(3*(n-1)+2,intfields,r);
504  }
505  break;
506  }
507  }
508  }
509  iso->set_ntris(n);
510 
511  // condense the information in this elemental extraction.
512  iso->condense();
513  returnval.push_back(iso);
514  }
515 
516  return returnval;
517 }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
FieldSharedPtr m_f
Field object.
boost::shared_ptr< Iso > IsoSharedPtr
void TwoPairs(Array< OneD, NekDouble > &cx, Array< OneD, NekDouble > &cy, Array< OneD, NekDouble > &cz, int &pr)
double NekDouble
void ThreeSimilar(const int i, const int j, const int k, int &pr, int &ps)
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:191
void Nektar::Utilities::ProcessIsoContour::Process ( po::variables_map &  vm)
virtual

Write mesh to output file.

Reimplemented from Nektar::Utilities::ProcessEquiSpacedOutput.

Definition at line 107 of file ProcessIsoContour.cpp.

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

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

Definition at line 520 of file ProcessIsoContour.cpp.

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

Referenced by Process().

521 {
522  int nfields = m_f->m_fieldPts->GetNFields() + m_f->m_fieldPts->GetDim();
523 
524  // set output to triangle block.
525  m_f->m_fieldPts->SetPtsType(LibUtilities::ePtsTriBlock);
526 
527  Array<OneD, Array<OneD, NekDouble> > newfields(nfields);
528 
529  // count up number of points
530  int npts = 0;
531  for(int i =0; i < iso.size(); ++i)
532  {
533  npts += iso[i]->get_nvert();
534  }
535 
536  // set up coordinate in new field
537  newfields[0] = Array<OneD, NekDouble>(npts);
538  newfields[1] = Array<OneD, NekDouble>(npts);
539  newfields[2] = Array<OneD, NekDouble>(npts);
540 
541  int cnt = 0;
542  for(int i =0; i < iso.size(); ++i)
543  {
544  for(int j = 0; j < iso[i]->get_nvert(); ++j,++cnt)
545  {
546  newfields[0][cnt] = iso[i]->get_x(j);
547  newfields[1][cnt] = iso[i]->get_y(j);
548  newfields[2][cnt] = iso[i]->get_z(j);
549  }
550  }
551 
552 
553  // set up fields
554  for(int f = 0; f < nfields-3; ++f)
555  {
556  newfields[f+3] = Array<OneD, NekDouble>(npts);
557 
558  cnt = 0;
559  for(int i =0; i < iso.size(); ++i)
560  {
561  for(int j = 0; j < iso[i]->get_nvert(); ++j,++cnt)
562  {
563  newfields[f+3][cnt] = iso[i]->get_fields(f,j);
564  }
565  }
566  }
567 
568  m_f->m_fieldPts->SetPts(newfields);
569 
570  // set up connectivity data.
571  vector<Array<OneD, int> > ptsConn;
572  m_f->m_fieldPts->GetConnectivity(ptsConn);
573  cnt = 0;
574  ptsConn.clear();
575  for(int i =0; i < iso.size(); ++i)
576  {
577  int ntris = iso[i]->get_ntris();
578  Array<OneD, int> conn(ntris*3);
579 
580  for(int j = 0; j < 3*ntris; ++j)
581  {
582  conn[j] = cnt + iso[i]->get_vid(j);
583  }
584  ptsConn.push_back(conn);
585  cnt += iso[i]->get_nvert();
586  }
587  m_f->m_fieldPts->SetConnectivity(ptsConn);
588 }
FieldSharedPtr m_f
Field object.
static std::string npts
Definition: InputFld.cpp:43
void Nektar::Utilities::ProcessIsoContour::SetupIsoFromFieldPts ( vector< IsoSharedPtr > &  isovec)
protected

Definition at line 591 of file ProcessIsoContour.cpp.

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

Referenced by Process().

592 {
593  ASSERTL0(m_f->m_fieldPts->GetPtsType() == LibUtilities::ePtsTriBlock,
594  "Assume input is from ePtsTriBlock");
595 
596  // get information from PtsField
597  int dim = m_f->m_fieldPts->GetDim();
598  int nfields = m_f->m_fieldPts->GetNFields() + dim;
599  Array<OneD, Array<OneD, NekDouble> > fieldpts;
600  m_f->m_fieldPts->GetPts(fieldpts);
601  vector<Array<OneD, int> > ptsConn;
602  m_f->m_fieldPts->GetConnectivity(ptsConn);
603 
604 
605  int cnt = 0;
606  for(int c = 0; c < ptsConn.size(); ++c)
607  {
608  // set up single iso with all the information from PtsField
610 
611  int nelmt = 0;
612  nelmt = ptsConn[c].num_elements()/3;
613 
614  iso->set_ntris(nelmt);
615  iso->resize_vid(3*nelmt);
616 
617  // fill in connectivity values.
618  int nvert = 0;
619  for(int i = 0; i < ptsConn[c].num_elements(); ++i)
620  {
621  int cid = ptsConn[c][i]-cnt;
622  iso->set_vid(i,cid);
623  nvert = max(cid,nvert);
624  }
625  nvert++;
626 
627  iso->set_nvert(nvert);
628  iso->resize_fields(nvert);
629 
630  // fill in points values (including coordinates)
631  for(int i = 0; i < nvert; ++i)
632  {
633  iso->set_fields(i,fieldpts,i+cnt);
634  }
635  cnt += nvert;
636  isovec.push_back(iso);
637  }
638 
639 }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
FieldSharedPtr m_f
Field object.
boost::shared_ptr< Iso > IsoSharedPtr

Member Data Documentation

ModuleKey Nektar::Utilities::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.