VTK  9.3.1
vtkLagrangianBasicIntegrationModel.h
Go to the documentation of this file.
1 // SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
2 // SPDX-License-Identifier: BSD-3-Clause
42 #ifndef vtkLagrangianBasicIntegrationModel_h
43 #define vtkLagrangianBasicIntegrationModel_h
44 
45 #include "vtkFiltersFlowPathsModule.h" // For export macro
46 #include "vtkFunctionSet.h"
47 #include "vtkNew.h" // For arrays
48 #include "vtkWeakPointer.h" // For weak pointer
49 
50 #include <map> // for array indexes
51 #include <mutex> // for mutexes
52 #include <queue> // for new particles
53 
54 VTK_ABI_NAMESPACE_BEGIN
55 class vtkAbstractArray;
57 class vtkCell;
58 class vtkCellData;
59 class vtkDataArray;
60 class vtkDataObject;
61 class vtkDataSet;
62 class vtkDataSetsType;
63 class vtkDoubleArray;
64 class vtkFieldData;
65 class vtkGenericCell;
67 class vtkIntArray;
70 class vtkLocatorsType;
73 class vtkPointData;
74 class vtkPolyData;
75 class vtkStringArray;
76 class vtkSurfaceType;
78 
79 class VTKFILTERSFLOWPATHS_EXPORT vtkLagrangianBasicIntegrationModel : public vtkFunctionSet
80 {
81 public:
83  void PrintSelf(ostream& os, vtkIndent indent) override;
84 
85  typedef enum SurfaceType
86  {
87  SURFACE_TYPE_MODEL = 0,
88  SURFACE_TYPE_TERM = 1,
89  SURFACE_TYPE_BOUNCE = 2,
90  SURFACE_TYPE_BREAK = 3,
91  SURFACE_TYPE_PASS = 4
92  } SurfaceType;
93 
94  typedef enum VariableStep
95  {
96  VARIABLE_STEP_PREV = -1,
97  VARIABLE_STEP_CURRENT = 0,
98  VARIABLE_STEP_NEXT = 1,
99  } VariableStep;
100 
101  typedef std::pair<unsigned int, vtkLagrangianParticle*> PassThroughParticlesItem;
102  typedef std::queue<PassThroughParticlesItem> PassThroughParticlesType;
103 
104  using Superclass::FunctionValues;
112  int FunctionValues(double* x, double* f, void* userData) override;
113 
115 
121  virtual void SetLocator(vtkAbstractCellLocator* locator);
122  vtkGetObjectMacro(Locator, vtkAbstractCellLocator);
124 
126 
129  vtkGetMacro(LocatorsBuilt, bool);
130  vtkSetMacro(LocatorsBuilt, bool);
132 
136  virtual void SetTracker(vtkLagrangianParticleTracker* Tracker);
137 
139 
148  virtual void AddDataSet(
149  vtkDataSet* dataset, bool surface = false, unsigned int surfaceFlatIndex = 0);
150  virtual void ClearDataSets(bool surface = false);
152 
154 
157  vtkSetMacro(UseInitialIntegrationTime, bool);
158  vtkGetMacro(UseInitialIntegrationTime, bool);
159  vtkBooleanMacro(UseInitialIntegrationTime, bool);
161 
163 
166  vtkGetMacro(Tolerance, double);
168 
170 
173  vtkGetMacro(LocatorTolerance, double);
175 
193  virtual vtkLagrangianParticle* ComputeSurfaceInteraction(vtkLagrangianParticle* particle,
194  std::queue<vtkLagrangianParticle*>& particles, unsigned int& interactedSurfaceFlatIndex,
195  PassThroughParticlesType& passThroughParticles);
196 
202  virtual void SetInputArrayToProcess(
203  int idx, int port, int connection, int fieldAssociation, const char* name);
204 
214  virtual bool FindInLocators(double* x, vtkLagrangianParticle* particle, vtkDataSet*& dataset,
215  vtkIdType& cellId, vtkAbstractCellLocator*& loc, double*& weights);
216 
218 
222  virtual bool FindInLocators(
223  double* x, vtkLagrangianParticle* particle, vtkDataSet*& dataset, vtkIdType& cellId);
224  virtual bool FindInLocators(double* x, vtkLagrangianParticle* particle);
226 
231  virtual void InitializeParticle(vtkLagrangianParticle* vtkNotUsed(particle)) {}
232 
241  virtual bool CheckAdaptiveStepReintegration(vtkLagrangianParticle* vtkNotUsed(particle))
242  {
243  return true;
244  }
245 
254  virtual bool CheckFreeFlightTermination(vtkLagrangianParticle* vtkNotUsed(particle))
255  {
256  return false;
257  }
258 
260 
263  vtkSetMacro(NonPlanarQuadSupport, bool);
264  vtkGetMacro(NonPlanarQuadSupport, bool);
265  vtkBooleanMacro(NonPlanarQuadSupport, bool);
267 
272  virtual vtkStringArray* GetSeedArrayNames();
273 
278  virtual vtkIntArray* GetSeedArrayComps();
279 
284  virtual vtkIntArray* GetSeedArrayTypes();
285 
290  virtual vtkStringArray* GetSurfaceArrayNames();
291 
296  virtual vtkIntArray* GetSurfaceArrayTypes();
297 
302  virtual vtkStringArray* GetSurfaceArrayEnumValues();
303 
308  virtual vtkDoubleArray* GetSurfaceArrayDefaultValues();
309 
314  virtual vtkIntArray* GetSurfaceArrayComps();
315 
317 
321  virtual int GetWeightsSize();
323 
347  virtual bool ManualIntegration(vtkInitialValueProblemSolver* integrator, double* xcur,
348  double* xnext, double t, double& delT, double& delTActual, double minStep, double maxStep,
349  double maxError, double cellLength, double& error, int& integrationResult,
350  vtkLagrangianParticle* particle);
351 
357  virtual void ParallelManualShift(vtkLagrangianParticle* vtkNotUsed(particle)) {}
358 
363  virtual vtkLagrangianThreadedData* InitializeThreadedData();
364 
369  virtual void FinalizeThreadedData(vtkLagrangianThreadedData*& data);
370 
376  virtual bool FinalizeOutputs(
377  vtkPolyData* vtkNotUsed(particlePathsOutput), vtkDataObject* vtkNotUsed(interractionOutput))
378  {
379  return true;
380  }
381 
385  virtual void PreParticleInitalization() {}
386 
390  virtual void PreIntegrate(std::queue<vtkLagrangianParticle*>& vtkNotUsed(particles)) {}
391 
396  virtual vtkAbstractArray* GetSeedArray(int idx, vtkPointData* pointData);
397 
405  vtkSetMacro(NumberOfTrackedUserData, int);
406  vtkGetMacro(NumberOfTrackedUserData, int);
407 
413  virtual void InitializePathData(vtkFieldData* data);
414 
420  virtual void InitializeInteractionData(vtkFieldData* data);
421 
427  virtual void InitializeParticleData(vtkFieldData* particleData, int maxTuples = 0);
428 
434  virtual void InsertPathData(vtkLagrangianParticle* particle, vtkFieldData* data);
435 
441  virtual void InsertInteractionData(vtkLagrangianParticle* particle, vtkFieldData* data);
442 
449  virtual void InsertParticleData(
450  vtkLagrangianParticle* particle, vtkFieldData* data, int stepEnum);
451 
457  virtual void InsertParticleSeedData(vtkLagrangianParticle* particle, vtkFieldData* data);
458 
465  virtual void ParticleAboutToBeDeleted(vtkLagrangianParticle* vtkNotUsed(particle)) {}
466 
472  vtkLagrangianParticle* vtkNotUsed(particle), vtkPointData* vtkNotUsed(particleData))
473  {
474  }
475 
476 protected:
479 
485  virtual int FunctionValues(vtkLagrangianParticle* particle, vtkDataSet* dataSet, vtkIdType cellId,
486  double* weights, double* x, double* f) = 0;
487 
494  virtual vtkIdType FindInLocator(vtkDataSet* dataSet, vtkAbstractCellLocator* locator, double* x,
495  vtkGenericCell* cell, double* weights);
496 
502  virtual bool TerminateParticle(vtkLagrangianParticle* particle);
503 
509  virtual bool BounceParticle(
510  vtkLagrangianParticle* particle, vtkDataSet* surface, vtkIdType cellId);
511 
519  virtual bool BreakParticle(vtkLagrangianParticle* particle, vtkDataSet* surface, vtkIdType cellId,
520  std::queue<vtkLagrangianParticle*>& particles);
521 
531  virtual bool InteractWithSurface(int surfaceType, vtkLagrangianParticle* particle,
532  vtkDataSet* surface, vtkIdType cellId, std::queue<vtkLagrangianParticle*>& particles);
533 
540  virtual bool IntersectWithLine(vtkLagrangianParticle* particle, vtkCell* cell, double p1[3],
541  double p2[3], double tol, double& t, double x[3]);
542 
547  virtual void InterpolateNextParticleVariables(
548  vtkLagrangianParticle* particle, double interpolationFactor, bool forceInside = false);
549 
555  virtual bool CheckSurfacePerforation(
556  vtkLagrangianParticle* particle, vtkDataSet* surface, vtkIdType cellId);
557 
564  virtual vtkAbstractArray* GetSeedArray(int idx, vtkLagrangianParticle* particle);
565 
573  virtual bool GetFlowOrSurfaceData(vtkLagrangianParticle* particle, int idx,
574  vtkDataSet* flowDataSet, vtkIdType tupleId, double* weights, double* data);
575 
583  virtual int GetFlowOrSurfaceDataNumberOfComponents(int idx, vtkDataSet* dataSet);
584 
590  virtual int GetFlowOrSurfaceDataFieldAssociation(int idx);
591 
600  virtual void ComputeSurfaceDefaultValues(
601  const char* arrayName, vtkDataSet* dataset, int nComponent, double* defaultValues);
602 
605  vtkLocatorsType* Locators;
606  vtkDataSetsType* DataSets;
607  int WeightsSize = 0;
608 
609  struct ArrayVal
610  {
611  int val[3];
612  };
613  typedef std::pair<ArrayVal, std::string> ArrayMapVal;
614  std::map<int, ArrayMapVal> InputArrays;
615 
616  typedef struct SurfaceArrayDescription
617  {
618  int nComp;
619  int type;
620  std::vector<std::pair<int, std::string>> enumValues;
622  std::map<std::string, SurfaceArrayDescription> SurfaceArrayDescriptions;
623 
624  vtkSurfaceType* Surfaces;
625  vtkLocatorsType* SurfaceLocators;
626 
627  double Tolerance;
628  double LocatorTolerance = 0.001;
631  int NumberOfTrackedUserData = 0;
632 
641 
643  std::mutex ParticleQueueMutex;
644 
645 private:
647  void operator=(const vtkLagrangianBasicIntegrationModel&) = delete;
648 };
649 
650 VTK_ABI_NAMESPACE_END
651 #endif
virtual void ParticleAboutToBeDeleted(vtkLagrangianParticle *vtkNotUsed(particle))
Method to be reimplemented if needed in inherited classes.
virtual void InitializeParticle(vtkLagrangianParticle *vtkNotUsed(particle))
Initialize a particle by setting user variables and perform any user model specific operation...
std::queue< PassThroughParticlesItem > PassThroughParticlesType
std::pair< unsigned int, vtkLagrangianParticle * > PassThroughParticlesItem
represent and manipulate point attribute data
Definition: vtkPointData.h:29
abstract class to specify dataset behavior
Definition: vtkDataSet.h:52
Abstract superclass for all arrays.
represent and manipulate cell attribute data
Definition: vtkCellData.h:30
an abstract base class for locators which find cells
a vtkAbstractArray subclass for strings
virtual bool CheckAdaptiveStepReintegration(vtkLagrangianParticle *vtkNotUsed(particle))
Method to be reimplemented if needed in inherited classes.
virtual void PreParticleInitalization()
Allow for model setup prior to Particle Initalization.
struct to hold a user data
int vtkIdType
Definition: vtkType.h:315
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:79
vtkWeakPointer< vtkLagrangianParticleTracker > Tracker
virtual bool FinalizeOutputs(vtkPolyData *vtkNotUsed(particlePathsOutput), vtkDataObject *vtkNotUsed(interractionOutput))
Enable model post process on output Return true if successful, false otherwise Empty and Always retur...
provides thread-safe access to cells
dynamic, self-adjusting array of double
virtual void InsertSurfaceInteractionData(vtkLagrangianParticle *vtkNotUsed(particle), vtkPointData *vtkNotUsed(particleData))
Method to be reimplemented if needed in inherited classes.
abstract class to specify cell behavior
Definition: vtkCell.h:49
dynamic, self-adjusting array of int
Definition: vtkIntArray.h:34
virtual void ParallelManualShift(vtkLagrangianParticle *vtkNotUsed(particle))
Method called by parallel algorithm after receiving a particle from stream if PManualShift flag has b...
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
a simple class to control print indentation
Definition: vtkIndent.h:28
vtkFunctionSet abstract implementation to be used in the vtkLagrangianParticleTracker integrator...
composite dataset to encapsulates pieces of dataset.
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:44
Abstract interface for sets of functions.
Basis class for Lagrangian particles.
virtual int FunctionValues(double *x, double *f)
Evaluate functions at x_j.
virtual bool CheckFreeFlightTermination(vtkLagrangianParticle *vtkNotUsed(particle))
Method to be reimplemented if needed in inherited classes.
std::map< std::string, SurfaceArrayDescription > SurfaceArrayDescriptions
virtual void PreIntegrate(std::queue< vtkLagrangianParticle * > &vtkNotUsed(particles))
Enable model to modify particle before integration.
Composite dataset that organizes datasets into blocks.
std::pair< ArrayVal, std::string > ArrayMapVal
general representation of visualization data
Definition: vtkDataObject.h:54
Filter to inject and track particles in a flow.
represent and manipulate fields of data
Definition: vtkFieldData.h:51
Integrate a set of ordinary differential equations (initial value problem) in time.