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:
[legend]

Public Member Functions

 ProcessIsoContour (FieldSharedPtr f)
 
virtual ~ProcessIsoContour ()
 
- 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)
 
virtual ~Module ()=default
 
void Process (po::variables_map &vm)
 
std::string GetModuleName ()
 
std::string GetModuleDescription ()
 
const ConfigOption & GetConfigOption (const std::string &key) const
 
ModulePriority GetModulePriority ()
 
FIELD_UTILS_EXPORT void RegisterConfig (std::string key, std::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 void AddFile (std::string fileType, std::string fileName)
 
FIELD_UTILS_EXPORT void EvaluateTriFieldAtEquiSpacedPts (LocalRegions::ExpansionSharedPtr &exp, const Array< OneD, const NekDouble > &infield, Array< OneD, NekDouble > &outfield)
 

Static Public Member Functions

static std::shared_ptr< Module > create (FieldSharedPtr f)
 Creates an instance of this class. More...
 

Static Public Attributes

static ModuleKey className
 

Protected Member Functions

virtual void v_Process (po::variables_map &vm) override
 Write mesh to output file. More...
 
virtual std::string v_GetModuleName () override
 
virtual std::string v_GetModuleDescription () override
 
virtual ModulePriority v_GetModulePriority () override
 
 ProcessIsoContour ()
 
void ResetFieldPts (std::vector< IsoSharedPtr > &iso)
 
void SetupIsoFromFieldPts (std::vector< IsoSharedPtr > &isovec)
 
- Protected Member Functions inherited from Nektar::FieldUtils::Module
 Module ()
 

Private Member Functions

std::vector< IsoSharedPtr > ExtractContour (const int fieldid, const NekDouble val)
 

Additional Inherited Members

- Public Attributes inherited from Nektar::FieldUtils::Module
FieldSharedPtr m_f
 Field object. More...
 
- Protected Attributes inherited from Nektar::FieldUtils::Module
std::map< std::string, ConfigOption > m_config
 List of configuration values. More...
 
std::set< std::string > m_allowedFiles
 List of allowed file formats. More...
 

Detailed Description

This processing module extracts an isocontour.

Definition at line 225 of file ProcessIsoContour.h.

Constructor & Destructor Documentation

◆ ProcessIsoContour() [1/2]

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

Definition at line 68 of file ProcessIsoContour.cpp.

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

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

◆ ~ProcessIsoContour()

Nektar::FieldUtils::ProcessIsoContour::~ProcessIsoContour ( void  )
virtual

Definition at line 112 of file ProcessIsoContour.cpp.

113 {
114 }

◆ ProcessIsoContour() [2/2]

Nektar::FieldUtils::ProcessIsoContour::ProcessIsoContour ( )
inlineprotected

Definition at line 258 of file ProcessIsoContour.h.

258 {};

Member Function Documentation

◆ create()

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

Creates an instance of this class.

Definition at line 229 of file ProcessIsoContour.h.

230  {
231  return MemoryManager<ProcessIsoContour>::AllocateSharedPtr(f);
232  }
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:168

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

◆ ExtractContour()

vector< IsoSharedPtr > Nektar::FieldUtils::ProcessIsoContour::ExtractContour ( const int  fieldid,
const NekDouble  val 
)
private

Definition at line 373 of file ProcessIsoContour.cpp.

375 {
376  vector<IsoSharedPtr> returnval;
377 
378  int coordim = m_f->m_fieldPts->GetDim();
379  int nfields = m_f->m_fieldPts->GetNFields() + coordim;
380 
381  ASSERTL0(m_f->m_fieldPts->GetPtsType() == LibUtilities::ePtsTetBlock,
382  "This methods is currently only set up for 3D fields");
383  ASSERTL1(coordim + fieldid < nfields,
384  "field id is larger than number contained in FieldPts");
385  Array<OneD, Array<OneD, NekDouble>> fields;
386  m_f->m_fieldPts->GetPts(fields);
387 
388  Array<OneD, NekDouble> c = fields[coordim + fieldid];
389 
390  int i, j, k, ii, jj, kk, r, s, n, counter, boolean;
391  Array<OneD, Array<OneD, NekDouble>> intfields(nfields);
392  intfields[0] = Array<OneD, NekDouble>(5 * nfields);
393  for (i = 1; i < nfields; ++i)
394  {
395  intfields[i] = intfields[i - 1] + 5;
396  }
397  Array<OneD, NekDouble> cx = intfields[0];
398  Array<OneD, NekDouble> cy = intfields[1];
399  Array<OneD, NekDouble> cz = intfields[2];
400 
401  vector<Array<OneD, int>> ptsConn;
402  m_f->m_fieldPts->GetConnectivity(ptsConn);
403 
404  for (int zone = 0; zone < ptsConn.size(); ++zone)
405  {
406  IsoSharedPtr iso;
407 
408  iso = MemoryManager<Iso>::AllocateSharedPtr(nfields - 3);
409 
410  int nelmt = ptsConn[zone].size() / (coordim + 1);
411 
412  Array<OneD, int> conn = ptsConn[zone];
413 
414  for (n = 0, i = 0; i < nelmt; ++i)
415  {
416  // check to see if val is between vertex values
417  if (!(((c[conn[i * 4]] > val) && (c[conn[i * 4 + 1]] > val) &&
418  (c[conn[i * 4 + 2]] > val) && (c[conn[i * 4 + 3]] > val)) ||
419  ((c[conn[i * 4]] < val) && (c[conn[i * 4 + 1]] < val) &&
420  (c[conn[i * 4 + 2]] < val) && (c[conn[i * 4 + 3]] < val))))
421  {
422 
423  // loop over all edges and interpolate if
424  // contour is between vertex values
425  for (counter = 0, j = 0; j <= 2; j++)
426  {
427  for (k = j + 1; k <= 3; k++)
428  {
429  if (((c[conn[i * 4 + j]] >= val) &&
430  (val >= c[conn[i * 4 + k]])) ||
431  ((c[conn[i * 4 + j]] <= val) &&
432  (val <= c[conn[i * 4 + k]])))
433  {
434  // linear interpolation of fields
435  // (and coords).
436  NekDouble cj = c[conn[i * 4 + j]];
437  NekDouble ck = c[conn[i * 4 + k]];
438  NekDouble factor = (val - cj) / (ck - cj);
439 
440  if (fabs(cj - ck) > 1e-12)
441  {
442  // interpolate coordinates and fields
443  for (int f = 0; f < nfields; ++f)
444  {
445  if (counter == 5)
446  {
447  ASSERTL0(false, "Counter is 5");
448  }
449  intfields[f][counter] =
450  fields[f][conn[4 * i + j]] +
451  factor * (fields[f][conn[4 * i + k]] -
452  fields[f][conn[4 * i + j]]);
453  }
454  ++counter;
455  }
456  }
457  }
458  }
459 
460  switch (counter)
461  {
462  case 3:
463  n += 1;
464  iso->ResizeFields(3 * n);
465 
466  for (j = 0; j < 3; ++j)
467  {
468  iso->SetFields(3 * (n - 1) + j, intfields, j);
469  }
470  break;
471  case 4:
472  n += 2;
473  iso->ResizeFields(3 * n);
474 
475  for (j = 0; j < 3; ++j)
476  {
477  iso->SetFields(3 * (n - 2) + j, intfields, j);
478  iso->SetFields(3 * (n - 1) + j, intfields, j + 1);
479  }
480  break;
481  case 5:
482  n += 1;
483  iso->ResizeFields(3 * n);
484 
485  boolean = 0;
486  for (ii = 0; ii <= 2; ii++)
487  {
488  for (jj = ii + 1; jj <= 3; jj++)
489  {
490  for (kk = jj + 1; kk <= 4; kk++)
491  {
492  if ((((cx[ii] - cx[jj]) == 0.0) &&
493  ((cy[ii] - cy[jj]) == 0.0) &&
494  ((cz[ii] - cz[jj]) == 0.0)) &&
495  (((cx[ii] - cx[kk]) == 0.0) &&
496  ((cy[ii] - cy[kk]) == 0.0) &&
497  ((cz[ii] - cz[kk]) == 0.0)))
498  {
499  boolean += 1;
500  ThreeSimilar(ii, jj, kk, r, s);
501 
502  iso->SetFields(3 * (n - 1), intfields,
503  ii);
504  iso->SetFields(3 * (n - 1) + 1,
505  intfields, r);
506  iso->SetFields(3 * (n - 1) + 2,
507  intfields, s);
508  }
509  else
510  {
511  boolean += 0;
512  }
513  }
514  }
515  }
516 
517  if (boolean == 0)
518  {
519  TwoPairs(cx, cy, cz, r);
520 
521  iso->SetFields(3 * (n - 1), intfields, 0);
522  iso->SetFields(3 * (n - 1) + 1, intfields, 2);
523  iso->SetFields(3 * (n - 1) + 2, intfields, r);
524  }
525  break;
526  }
527  }
528  }
529 
530  if (n)
531  {
532  iso->SetNTris(n);
533 
534  // condense the information in this elemental extraction.
535  iso->Condense();
536 
537  returnval.push_back(iso);
538  }
539  }
540 
541  return returnval;
542 }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:215
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:249
Nektar::FieldUtils::Module::m_f
FieldSharedPtr m_f
Field object.
Definition: Module.h:234
Nektar::FieldUtils::ThreeSimilar
void ThreeSimilar(const int i, const int j, const int k, int &pr, int &ps)
Definition: ProcessIsoContour.cpp:309
Nektar::FieldUtils::TwoPairs
void TwoPairs(Array< OneD, NekDouble > &cx, Array< OneD, NekDouble > &cy, Array< OneD, NekDouble > &cz, int &pr)
Definition: ProcessIsoContour.cpp:282
Nektar::FieldUtils::IsoSharedPtr
std::shared_ptr< Iso > IsoSharedPtr
Definition: ProcessIsoContour.h:186
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43

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

Referenced by v_Process().

◆ ResetFieldPts()

void Nektar::FieldUtils::ProcessIsoContour::ResetFieldPts ( std::vector< IsoSharedPtr > &  iso)
protected

Definition at line 545 of file ProcessIsoContour.cpp.

546 {
547  int nfields = m_f->m_fieldPts->GetNFields() + m_f->m_fieldPts->GetDim();
548 
549  // set output to triangle block.
550  m_f->m_fieldPts->SetPtsType(LibUtilities::ePtsTriBlock);
551 
552  Array<OneD, Array<OneD, NekDouble>> newfields(nfields);
553 
554  // count up number of points
555  int npts = 0;
556  for (int i = 0; i < iso.size(); ++i)
557  {
558  npts += iso[i]->GetNVert();
559  }
560 
561  // set up coordinate in new field
562  newfields[0] = Array<OneD, NekDouble>(npts);
563  newfields[1] = Array<OneD, NekDouble>(npts);
564  newfields[2] = Array<OneD, NekDouble>(npts);
565 
566  int cnt = 0;
567  for (int i = 0; i < iso.size(); ++i)
568  {
569  for (int j = 0; j < iso[i]->GetNVert(); ++j, ++cnt)
570  {
571  newfields[0][cnt] = iso[i]->GetX(j);
572  newfields[1][cnt] = iso[i]->GetY(j);
573  newfields[2][cnt] = iso[i]->GetZ(j);
574  }
575  }
576 
577  // set up fields
578  for (int f = 0; f < nfields - 3; ++f)
579  {
580  newfields[f + 3] = Array<OneD, NekDouble>(npts);
581 
582  cnt = 0;
583  for (int i = 0; i < iso.size(); ++i)
584  {
585  for (int j = 0; j < iso[i]->GetNVert(); ++j, ++cnt)
586  {
587  newfields[f + 3][cnt] = iso[i]->GetFields(f, j);
588  }
589  }
590  }
591 
592  m_f->m_fieldPts->SetPts(newfields);
593 
594  // set up connectivity data.
595  vector<Array<OneD, int>> ptsConn;
596  m_f->m_fieldPts->GetConnectivity(ptsConn);
597  cnt = 0;
598  ptsConn.clear();
599  for (int i = 0; i < iso.size(); ++i)
600  {
601  int ntris = iso[i]->GetNTris();
602  Array<OneD, int> conn(ntris * 3);
603 
604  for (int j = 0; j < 3 * ntris; ++j)
605  {
606  conn[j] = cnt + iso[i]->GetVId(j);
607  }
608  ptsConn.push_back(conn);
609  cnt += iso[i]->GetNVert();
610  }
611  m_f->m_fieldPts->SetConnectivity(ptsConn);
612 }

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

Referenced by v_Process().

◆ SetupIsoFromFieldPts()

void Nektar::FieldUtils::ProcessIsoContour::SetupIsoFromFieldPts ( std::vector< IsoSharedPtr > &  isovec)
protected

Definition at line 615 of file ProcessIsoContour.cpp.

616 {
617  ASSERTL0(m_f->m_fieldPts->GetPtsType() == LibUtilities::ePtsTriBlock,
618  "Assume input is from ePtsTriBlock");
619 
620  // get information from PtsField
621  int dim = m_f->m_fieldPts->GetDim();
622  int nfields = m_f->m_fieldPts->GetNFields() + dim;
623  Array<OneD, Array<OneD, NekDouble>> fieldpts;
624  m_f->m_fieldPts->GetPts(fieldpts);
625  vector<Array<OneD, int>> ptsConn;
626  m_f->m_fieldPts->GetConnectivity(ptsConn);
627 
628  int cnt = 0;
629  for (int c = 0; c < ptsConn.size(); ++c)
630  {
631  // set up single iso with all the information from PtsField
632  IsoSharedPtr iso = MemoryManager<Iso>::AllocateSharedPtr(nfields - dim);
633 
634  int nelmt = 0;
635  nelmt = ptsConn[c].size() / 3;
636 
637  iso->SetNTris(nelmt);
638  iso->ResizeVId(3 * nelmt);
639 
640  // fill in connectivity values.
641  int nvert = 0;
642  for (int i = 0; i < ptsConn[c].size(); ++i)
643  {
644  int cid = ptsConn[c][i] - cnt;
645  iso->SetVId(i, cid);
646  nvert = max(cid, nvert);
647  }
648  nvert++;
649 
650  iso->SetNVert(nvert);
651  iso->ResizeFields(nvert);
652 
653  // fill in points values (including coordinates)
654  for (int i = 0; i < nvert; ++i)
655  {
656  iso->SetFields(i, fieldpts, i + cnt);
657  }
658  cnt += nvert;
659  isovec.push_back(iso);
660  }
661 }

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

Referenced by v_Process().

◆ v_GetModuleDescription()

virtual std::string Nektar::FieldUtils::ProcessIsoContour::v_GetModuleDescription ( )
inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 247 of file ProcessIsoContour.h.

248  {
249  return "Extracting contour";
250  }

◆ v_GetModuleName()

virtual std::string Nektar::FieldUtils::ProcessIsoContour::v_GetModuleName ( )
inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 242 of file ProcessIsoContour.h.

243  {
244  return "ProcessIsoContour";
245  }

◆ v_GetModulePriority()

virtual ModulePriority Nektar::FieldUtils::ProcessIsoContour::v_GetModulePriority ( )
inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 252 of file ProcessIsoContour.h.

253  {
254  return eModifyPts;
255  }

References Nektar::FieldUtils::eModifyPts.

◆ v_Process()

void Nektar::FieldUtils::ProcessIsoContour::v_Process ( po::variables_map &  vm)
overrideprotectedvirtual

Write mesh to output file.

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 116 of file ProcessIsoContour.cpp.

117 {
118  m_f->SetUpExp(vm);
119 
120  bool verbose = (m_f->m_verbose && m_f->m_comm->TreatAsRankZero());
121 
122  vector<IsoSharedPtr> iso;
123 
124  ASSERTL0(m_f->m_fieldPts.get(), "Should have m_fieldPts for IsoContour.");
125 
126  if (m_f->m_fieldPts->GetPtsType() == LibUtilities::ePtsTriBlock)
127  {
128  // assume we have read .dat file to directly input dat file.
129  if (verbose)
130  {
131  cout << "\t Process read iso from Field Pts" << endl;
132  }
133 
134  SetupIsoFromFieldPts(iso);
135  }
136  else if (m_f->m_fieldPts->GetPtsType() == LibUtilities::ePtsTetBlock)
137  {
138  if (m_config["fieldstr"].m_beenSet)
139  {
140  string fieldName = m_config["fieldname"].as<string>();
141  m_f->m_variables.push_back(fieldName);
142  }
143 
144  if (m_f->m_fieldPts->GetNpoints() == 0)
145  {
146  return;
147  }
148 
149  int fieldid;
150  NekDouble value;
151 
152  if (m_config["fieldstr"].m_beenSet) // generate field of interest
153  {
154  fieldid = m_f->m_fieldPts->GetNFields();
155 
156  Array<OneD, NekDouble> pts(m_f->m_fieldPts->GetNpoints());
157 
158  // evaluate new function
159  LibUtilities::Interpreter strEval;
160  string varstr = "x y z";
161  vector<Array<OneD, const NekDouble>> interpfields;
162 
163  for (int i = 0; i < m_f->m_fieldPts->GetDim(); ++i)
164  {
165  interpfields.push_back(m_f->m_fieldPts->GetPts(i));
166  }
167  for (int i = 0; i < m_f->m_fieldPts->GetNFields(); ++i)
168  {
169  varstr += " " + m_f->m_fieldPts->GetFieldName(i);
170  interpfields.push_back(m_f->m_fieldPts->GetPts(i + 3));
171  }
172 
173  int ExprId = -1;
174  std::string str = m_config["fieldstr"].as<string>();
175  ExprId = strEval.DefineFunction(varstr.c_str(), str);
176 
177  strEval.Evaluate(ExprId, interpfields, pts);
178 
179  // set up field name if provided otherwise called "isocon" from
180  // default
181  string fieldName = m_config["fieldname"].as<string>();
182 
183  m_f->m_fieldPts->AddField(pts, fieldName);
184  }
185  else
186  {
187  ASSERTL0(m_config["fieldid"].as<string>() != "NotSet",
188  "fieldid must be specified");
189  fieldid = m_config["fieldid"].as<int>();
190  }
191 
192  ASSERTL0(m_config["fieldvalue"].as<string>() != "NotSet",
193  "fieldvalue must be specified");
194  value = m_config["fieldvalue"].as<NekDouble>();
195 
196  iso = ExtractContour(fieldid, value);
197  }
198  else
199  {
200  ASSERTL0(false, "PtsType not supported for isocontour.");
201  }
202 
203  // Process isocontour
204  bool smoothing = m_config["smooth"].as<bool>();
205  bool globalcondense = m_config["globalcondense"].as<bool>();
206  if (globalcondense)
207  {
208  if (verbose)
209  {
210  cout << "\t Process global condense ..." << endl;
211  }
212  int nfields = m_f->m_fieldPts->GetNFields() + m_f->m_fieldPts->GetDim();
213  IsoSharedPtr g_iso = MemoryManager<Iso>::AllocateSharedPtr(nfields - 3);
214 
215  g_iso->GlobalCondense(iso, verbose);
216 
217  iso.clear();
218  iso.push_back(g_iso);
219  }
220 
221  if (smoothing)
222  {
223  LibUtilities::Timer timersm;
224 
225  if (verbose)
226  {
227  cout << "\t Process Contour smoothing ..." << endl;
228  timersm.Start();
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 (verbose)
240  {
241  timersm.Stop();
242  NekDouble cpuTime = timersm.TimePerTest(1);
243 
244  stringstream ss;
245  ss << cpuTime << "s";
246  cout << "\t Process smooth CPU Time: " << setw(8) << left
247  << ss.str() << endl;
248  cpuTime = 0.0;
249  }
250  }
251 
252  int mincontour = 0;
253  if ((mincontour = m_config["removesmallcontour"].as<int>()))
254  {
255  vector<IsoSharedPtr> new_iso;
256 
257  if (verbose)
258  {
259  cout << "\t Identifying separate regions [." << flush;
260  }
261  for (int i = 0; i < iso.size(); ++i)
262  {
263  iso[i]->SeparateRegions(new_iso, mincontour, m_f->m_verbose);
264  }
265 
266  if (verbose)
267  {
268  cout << "]" << endl << flush;
269  }
270 
271  // reset iso to new_iso;
272  iso = new_iso;
273  }
274 
275  ResetFieldPts(iso);
276 }
Nektar::FieldUtils::ProcessIsoContour::ExtractContour
std::vector< IsoSharedPtr > ExtractContour(const int fieldid, const NekDouble val)
Definition: ProcessIsoContour.cpp:373
Nektar::FieldUtils::ProcessIsoContour::SetupIsoFromFieldPts
void SetupIsoFromFieldPts(std::vector< IsoSharedPtr > &isovec)
Definition: ProcessIsoContour.cpp:615
Nektar::FieldUtils::ProcessIsoContour::ResetFieldPts
void ResetFieldPts(std::vector< IsoSharedPtr > &iso)
Definition: ProcessIsoContour.cpp:545

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::Interpreter::DefineFunction(), Nektar::LibUtilities::ePtsTetBlock, Nektar::LibUtilities::ePtsTriBlock, Nektar::LibUtilities::Interpreter::Evaluate(), ExtractContour(), Nektar::FieldUtils::Module::m_config, Nektar::FieldUtils::Module::m_f, ResetFieldPts(), SetupIsoFromFieldPts(), Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and Nektar::LibUtilities::Timer::TimePerTest().

Member Data Documentation

◆ className

ModuleKey Nektar::FieldUtils::ProcessIsoContour::className
static
Initial value:
=
GetModuleFactory().RegisterCreatorFunction(
ModuleKey(eProcessModule, "isocontour"), ProcessIsoContour::create,
"Extract an isocontour of fieldid variable and at "
"value fieldvalue, Optionally fieldstr can be "
"specified for a string defiition or smooth for "
"smoothing")
Nektar::FieldUtils::ProcessIsoContour::create
static std::shared_ptr< Module > create(FieldSharedPtr f)
Creates an instance of this class.
Definition: ProcessIsoContour.h:229
Nektar::LibUtilities::NekFactory::RegisterCreatorFunction
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, std::string pDesc="")
Register a class with the factory.
Definition: NekFactory.hpp:198
Nektar::FieldUtils::ModuleKey
std::pair< ModuleType, std::string > ModuleKey
Definition: Module.h:317
Nektar::FieldUtils::GetModuleFactory
ModuleFactory & GetModuleFactory()
Definition: Module.cpp:49

Definition at line 233 of file ProcessIsoContour.h.

Generated on Sat Mar 25 2023 12:35:57 for Nektar++ by doxygen 1.9.1