VTK  9.0.1
vtkLagrangianBasicIntegrationModel.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkLagrangianBasicIntegrationModel.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
54 #ifndef vtkLagrangianBasicIntegrationModel_h
55 #define vtkLagrangianBasicIntegrationModel_h
56 
57 #include "vtkFiltersFlowPathsModule.h" // For export macro
58 #include "vtkFunctionSet.h"
59 #include "vtkNew.h" // For arrays
60 #include "vtkWeakPointer.h" // For weak pointer
61 
62 #include <map> // for array indexes
63 #include <mutex> // for mutexes
64 #include <queue> // for new particles
65 
66 class vtkAbstractArray;
68 class vtkCell;
69 class vtkCellData;
70 class vtkDataArray;
71 class vtkDataObject;
72 class vtkDataSet;
73 class vtkDataSetsType;
74 class vtkDoubleArray;
75 class vtkFieldData;
76 class vtkGenericCell;
78 class vtkIntArray;
81 class vtkLocatorsType;
84 class vtkPointData;
85 class vtkPolyData;
86 class vtkStringArray;
87 class vtkSurfaceType;
89 
90 class VTKFILTERSFLOWPATHS_EXPORT vtkLagrangianBasicIntegrationModel : public vtkFunctionSet
91 {
92 public:
94  void PrintSelf(ostream& os, vtkIndent indent) override;
95 
96  typedef enum SurfaceType
97  {
98  SURFACE_TYPE_MODEL = 0,
99  SURFACE_TYPE_TERM = 1,
100  SURFACE_TYPE_BOUNCE = 2,
101  SURFACE_TYPE_BREAK = 3,
102  SURFACE_TYPE_PASS = 4
103  } SurfaceType;
104 
105  typedef enum VariableStep
106  {
107  VARIABLE_STEP_PREV = -1,
108  VARIABLE_STEP_CURRENT = 0,
109  VARIABLE_STEP_NEXT = 1,
110  } VariableStep;
111 
112  typedef std::pair<unsigned int, vtkLagrangianParticle*> PassThroughParticlesItem;
113  typedef std::queue<PassThroughParticlesItem> PassThroughParticlesType;
114 
115  using Superclass::FunctionValues;
123  int FunctionValues(double* x, double* f, void* userData) override;
124 
126 
132  virtual void SetLocator(vtkAbstractCellLocator* locator);
133  vtkGetObjectMacro(Locator, vtkAbstractCellLocator);
135 
137 
140  vtkGetMacro(LocatorsBuilt, bool);
141  vtkSetMacro(LocatorsBuilt, bool);
143 
147  virtual void SetTracker(vtkLagrangianParticleTracker* Tracker);
148 
150 
159  virtual void AddDataSet(
160  vtkDataSet* dataset, bool surface = false, unsigned int surfaceFlatIndex = 0);
161  virtual void ClearDataSets(bool surface = false);
163 
165 
168  vtkSetMacro(UseInitialIntegrationTime, bool);
169  vtkGetMacro(UseInitialIntegrationTime, bool);
170  vtkBooleanMacro(UseInitialIntegrationTime, bool);
172 
174 
177  vtkGetMacro(Tolerance, double);
179 
197  virtual vtkLagrangianParticle* ComputeSurfaceInteraction(vtkLagrangianParticle* particle,
198  std::queue<vtkLagrangianParticle*>& particles, unsigned int& interactedSurfaceFlatIndex,
199  PassThroughParticlesType& passThroughParticles);
200 
206  virtual void SetInputArrayToProcess(
207  int idx, int port, int connection, int fieldAssociation, const char* name);
208 
218  virtual bool FindInLocators(double* x, vtkLagrangianParticle* particle, vtkDataSet*& dataset,
219  vtkIdType& cellId, vtkAbstractCellLocator*& loc, double*& weights);
220 
222 
226  virtual bool FindInLocators(
227  double* x, vtkLagrangianParticle* particle, vtkDataSet*& dataset, vtkIdType& cellId);
228  virtual bool FindInLocators(double* x, vtkLagrangianParticle* particle);
230 
235  virtual void InitializeParticle(vtkLagrangianParticle* vtkNotUsed(particle)) {}
236 
245  virtual bool CheckAdaptiveStepReintegration(vtkLagrangianParticle* vtkNotUsed(particle))
246  {
247  return true;
248  }
249 
258  virtual bool CheckFreeFlightTermination(vtkLagrangianParticle* vtkNotUsed(particle))
259  {
260  return false;
261  }
262 
264 
267  vtkSetMacro(NonPlanarQuadSupport, bool);
268  vtkGetMacro(NonPlanarQuadSupport, bool);
269  vtkBooleanMacro(NonPlanarQuadSupport, bool);
271 
276  virtual vtkStringArray* GetSeedArrayNames();
277 
282  virtual vtkIntArray* GetSeedArrayComps();
283 
288  virtual vtkIntArray* GetSeedArrayTypes();
289 
294  virtual vtkStringArray* GetSurfaceArrayNames();
295 
300  virtual vtkIntArray* GetSurfaceArrayTypes();
301 
306  virtual vtkStringArray* GetSurfaceArrayEnumValues();
307 
312  virtual vtkDoubleArray* GetSurfaceArrayDefaultValues();
313 
318  virtual vtkIntArray* GetSurfaceArrayComps();
319 
321 
325  virtual int GetWeightsSize();
327 
351  virtual bool ManualIntegration(vtkInitialValueProblemSolver* integrator, double* xcur,
352  double* xnext, double t, double& delT, double& delTActual, double minStep, double maxStep,
353  double maxError, double cellLength, double& error, int& integrationResult,
354  vtkLagrangianParticle* particle);
355 
361  virtual void ParallelManualShift(vtkLagrangianParticle* vtkNotUsed(particle)) {}
362 
368 
374 
380  virtual bool FinalizeOutputs(
381  vtkPolyData* vtkNotUsed(particlePathsOutput), vtkDataObject* vtkNotUsed(interractionOutput))
382  {
383  return true;
384  }
385 
389  virtual void PreIntegrate(std::queue<vtkLagrangianParticle*>& vtkNotUsed(particles)) {}
390 
395  virtual vtkAbstractArray* GetSeedArray(int idx, vtkPointData* pointData);
396 
404  vtkSetMacro(NumberOfTrackedUserData, int);
405  vtkGetMacro(NumberOfTrackedUserData, int);
406 
412  virtual void InitializePathData(vtkFieldData* data);
413 
419  virtual void InitializeInteractionData(vtkFieldData* data);
420 
426  virtual void InitializeParticleData(vtkFieldData* particleData, int maxTuples = 0);
427 
433  virtual void InsertPathData(vtkLagrangianParticle* particle, vtkFieldData* data);
434 
440  virtual void InsertInteractionData(vtkLagrangianParticle* particle, vtkFieldData* data);
441 
448  virtual void InsertParticleData(
449  vtkLagrangianParticle* particle, vtkFieldData* data, int stepEnum);
450 
456  virtual void InsertParticleSeedData(vtkLagrangianParticle* particle, vtkFieldData* data);
457 
464  virtual void ParticleAboutToBeDeleted(vtkLagrangianParticle* vtkNotUsed(particle)) {}
465 
466 protected:
469 
475  virtual int FunctionValues(vtkLagrangianParticle* particle, vtkDataSet* dataSet, vtkIdType cellId,
476  double* weights, double* x, double* f) = 0;
477 
484  virtual vtkIdType FindInLocator(vtkDataSet* dataSet, vtkAbstractCellLocator* locator, double* x,
485  vtkGenericCell* cell, double* weights);
486 
492  virtual bool TerminateParticle(vtkLagrangianParticle* particle);
493 
499  virtual bool BounceParticle(
500  vtkLagrangianParticle* particle, vtkDataSet* surface, vtkIdType cellId);
501 
509  virtual bool BreakParticle(vtkLagrangianParticle* particle, vtkDataSet* surface, vtkIdType cellId,
510  std::queue<vtkLagrangianParticle*>& particles);
511 
521  virtual bool InteractWithSurface(int surfaceType, vtkLagrangianParticle* particle,
522  vtkDataSet* surface, vtkIdType cellId, std::queue<vtkLagrangianParticle*>& particles);
523 
530  virtual bool IntersectWithLine(vtkLagrangianParticle* particle, vtkCell* cell, double p1[3],
531  double p2[3], double tol, double& t, double x[3]);
532 
537  virtual void InterpolateNextParticleVariables(
538  vtkLagrangianParticle* particle, double interpolationFactor, bool forceInside = false);
539 
545  virtual bool CheckSurfacePerforation(
546  vtkLagrangianParticle* particle, vtkDataSet* surface, vtkIdType cellId);
547 
554  virtual vtkAbstractArray* GetSeedArray(int idx, vtkLagrangianParticle* particle);
555 
563  virtual bool GetFlowOrSurfaceData(vtkLagrangianParticle* particle, int idx,
564  vtkDataSet* flowDataSet, vtkIdType tupleId, double* weights, double* data);
565 
573  virtual int GetFlowOrSurfaceDataNumberOfComponents(int idx, vtkDataSet* dataSet);
574 
580  virtual int GetFlowOrSurfaceDataFieldAssociation(int idx);
581 
590  virtual void ComputeSurfaceDefaultValues(
591  const char* arrayName, vtkDataSet* dataset, int nComponent, double* defaultValues);
592 
595  vtkLocatorsType* Locators;
596  vtkDataSetsType* DataSets;
597  std::vector<double> SharedWeights;
598 
599  struct ArrayVal
600  {
601  int val[3];
602  };
603  typedef std::pair<ArrayVal, std::string> ArrayMapVal;
604  std::map<int, ArrayMapVal> InputArrays;
605 
606  typedef struct SurfaceArrayDescription
607  {
608  int nComp;
609  int type;
610  std::vector<std::pair<int, std::string> > enumValues;
612  std::map<std::string, SurfaceArrayDescription> SurfaceArrayDescriptions;
613 
614  vtkSurfaceType* Surfaces;
615  vtkLocatorsType* SurfaceLocators;
616 
617  double Tolerance;
620  int NumberOfTrackedUserData = 0;
621 
630 
632  std::mutex ParticleQueueMutex;
633 
634 private:
636  void operator=(const vtkLagrangianBasicIntegrationModel&) = delete;
637 };
638 
639 #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:31
abstract class to specify dataset behavior
Definition: vtkDataSet.h:56
Abstract superclass for all arrays.
represent and manipulate cell attribute data
Definition: vtkCellData.h:32
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.
struct to hold a user data
int vtkIdType
Definition: vtkType.h:338
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:84
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 PreIntegrate(std::queue< vtkLagrangianParticle *> &vtkNotUsed(particles))
Enable model to modify particle before integration.
abstract class to specify cell behavior
Definition: vtkCell.h:56
dynamic, self-adjusting array of int
Definition: vtkIntArray.h:39
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:33
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:49
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
Composite dataset that organizes datasets into blocks.
virtual void FinalizeThreadedData(vtkLagrangianThreadedData *vtkNotUsed(data))
Let the model finalize and deallocate a user data at thread level This method is called serially for ...
virtual void InitializeThreadedData(vtkLagrangianThreadedData *vtkNotUsed(data))
Let the model allocate and initialize a threaded data.
std::pair< ArrayVal, std::string > ArrayMapVal
general representation of visualization data
Definition: vtkDataObject.h:59
Filter to inject and track particles in a flow.
represent and manipulate fields of data
Definition: vtkFieldData.h:53
Integrate a set of ordinary differential equations (initial value problem) in time.