VTK  9.0.2
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 
198  std::queue<vtkLagrangianParticle*>& particles, unsigned int& interactedSurfaceFlatIndex,
199  PassThroughParticlesType& passThroughParticles);
200 
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 
277 
283 
289 
295 
301 
307 
313 
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 
413 
420 
426  virtual void InitializeParticleData(vtkFieldData* particleData, int maxTuples = 0);
427 
434 
441 
448  virtual void InsertParticleData(
449  vtkLagrangianParticle* particle, vtkFieldData* data, int stepEnum);
450 
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 
538  vtkLagrangianParticle* particle, double interpolationFactor, bool forceInside = false);
539 
546  vtkLagrangianParticle* particle, vtkDataSet* surface, vtkIdType cellId);
547 
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 
581 
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;
611  } SurfaceArrayDescription;
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
Abstract superclass for all arrays.
an abstract base class for locators which find cells
represent and manipulate cell attribute data
Definition: vtkCellData.h:33
abstract class to specify cell behavior
Definition: vtkCell.h:57
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:50
general representation of visualization data
Definition: vtkDataObject.h:60
abstract class to specify dataset behavior
Definition: vtkDataSet.h:57
dynamic, self-adjusting array of double
represent and manipulate fields of data
Definition: vtkFieldData.h:54
Abstract interface for sets of functions.
provides thread-safe access to cells
a simple class to control print indentation
Definition: vtkIndent.h:34
Integrate a set of ordinary differential equations (initial value problem) in time.
dynamic, self-adjusting array of int
Definition: vtkIntArray.h:40
vtkFunctionSet abstract implementation to be used in the vtkLagrangianParticleTracker integrator.
virtual vtkIntArray * GetSeedArrayComps()
Get the seed arrays expected number of components Used Only be the vtkLagrangianSeedHelper in ParaVie...
virtual void InsertInteractionData(vtkLagrangianParticle *particle, vtkFieldData *data)
Method used by the LPT to insert data from the partice into the provided vtkFieldData.
virtual void InitializeParticle(vtkLagrangianParticle *vtkNotUsed(particle))
Initialize a particle by setting user variables and perform any user model specific operation.
virtual void SetInputArrayToProcess(int idx, int port, int connection, int fieldAssociation, const char *name)
Set a input array to process at a specific index, identified by a port, connection,...
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...
virtual int GetFlowOrSurfaceDataFieldAssociation(int idx)
Recover a field association for a specified array index if it has been set using SetInputArrayToProce...
std::queue< PassThroughParticlesItem > PassThroughParticlesType
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
virtual void InitializeParticleData(vtkFieldData *particleData, int maxTuples=0)
Method used by the LPT to initialize data insertion in the provided vtkFieldData.
virtual bool TerminateParticle(vtkLagrangianParticle *particle)
Terminate a particle, by positioning flags.
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 vtkStringArray * GetSurfaceArrayNames()
Get the surface arrays expected name Used Only be the vtkLagrangianSurfaceHelper in ParaView plugins.
virtual bool FindInLocators(double *x, vtkLagrangianParticle *particle, vtkDataSet *&dataset, vtkIdType &cellId)
Convienience methods to call FindInLocators with less arguments THESE METHODS ARE NOT THREAD-SAFE.
virtual void InterpolateNextParticleVariables(vtkLagrangianParticle *particle, double interpolationFactor, bool forceInside=false)
compute all particle variables using interpolation factor This method is thread-safe.
virtual void PreIntegrate(std::queue< vtkLagrangianParticle * > &vtkNotUsed(particles))
Enable model to modify particle before integration.
virtual void InitializeThreadedData(vtkLagrangianThreadedData *vtkNotUsed(data))
Let the model allocate and initialize a threaded data.
virtual void AddDataSet(vtkDataSet *dataset, bool surface=false, unsigned int surfaceFlatIndex=0)
Add a dataset to locate cells in This create a specific locator for the provided dataset using the Lo...
virtual void InitializePathData(vtkFieldData *data)
Method used by the LPT to initialize data insertion in the provided vtkFieldData.
virtual void SetTracker(vtkLagrangianParticleTracker *Tracker)
Set the parent tracker.
virtual bool CheckSurfacePerforation(vtkLagrangianParticle *particle, vtkDataSet *surface, vtkIdType cellId)
Given a particle, check if it perforate a surface cell ie : interact with next step after interacting...
virtual bool ManualIntegration(vtkInitialValueProblemSolver *integrator, double *xcur, double *xnext, double t, double &delT, double &delTActual, double minStep, double maxStep, double maxError, double cellLength, double &error, int &integrationResult, vtkLagrangianParticle *particle)
Let the model define it's own way to integrate Signature is very close to the integrator method signa...
virtual vtkStringArray * GetSurfaceArrayEnumValues()
Get the surface arrays expected values and associated enums Used Only be the vtkLagrangianSurfaceHelp...
virtual void SetLocator(vtkAbstractCellLocator *locator)
Set/Get the locator used to locate cells in the datasets.
virtual void InsertPathData(vtkLagrangianParticle *particle, vtkFieldData *data)
Method used by the LPT to insert data from the partice into the provided vtkFieldData.
virtual bool IntersectWithLine(vtkLagrangianParticle *particle, vtkCell *cell, double p1[3], double p2[3], double tol, double &t, double x[3])
Call vtkCell::IntersectWithLine This method is to be reimplemented in inherited classes willing to im...
virtual vtkStringArray * GetSeedArrayNames()
Get the seed arrays expected name Used Only be the vtkLagrangianSeedHelper in ParaView plugins.
virtual vtkIntArray * GetSurfaceArrayComps()
Get the seed array expected number of components Used Only be the vtkLagrangianSurfaceHelper in ParaV...
std::pair< unsigned int, vtkLagrangianParticle * > PassThroughParticlesItem
virtual void InitializeInteractionData(vtkFieldData *data)
Method used by the LPT to initialize data insertion in the provided vtkFieldData.
virtual bool BounceParticle(vtkLagrangianParticle *particle, vtkDataSet *surface, vtkIdType cellId)
Bounce a particle, using the normal of the cell it bounces on.
virtual void ParticleAboutToBeDeleted(vtkLagrangianParticle *vtkNotUsed(particle))
Method to be reimplemented if needed in inherited classes.
virtual vtkLagrangianParticle * ComputeSurfaceInteraction(vtkLagrangianParticle *particle, std::queue< vtkLagrangianParticle * > &particles, unsigned int &interactedSurfaceFlatIndex, PassThroughParticlesType &passThroughParticles)
Interact the current particle with a surfaces Return a particle to record as interaction point if not...
int FunctionValues(double *x, double *f, void *userData) override
Evaluate integration model velocity f at position x.
virtual bool CheckFreeFlightTermination(vtkLagrangianParticle *vtkNotUsed(particle))
Method to be reimplemented if needed in inherited classes.
virtual int GetFlowOrSurfaceDataNumberOfComponents(int idx, vtkDataSet *dataSet)
Recover the number of components for a specified array index if it has been set using SetInputArrayTo...
virtual bool CheckAdaptiveStepReintegration(vtkLagrangianParticle *vtkNotUsed(particle))
Method to be reimplemented if needed in inherited classes.
virtual void ClearDataSets(bool surface=false)
std::map< std::string, SurfaceArrayDescription > SurfaceArrayDescriptions
virtual void ComputeSurfaceDefaultValues(const char *arrayName, vtkDataSet *dataset, int nComponent, double *defaultValues)
Method used by ParaView surface helper to get default values for each leaf of each dataset of surface...
virtual bool FindInLocators(double *x, vtkLagrangianParticle *particle, vtkDataSet *&dataset, vtkIdType &cellId, vtkAbstractCellLocator *&loc, double *&weights)
Look for a dataset in this integration model containing the point x.
std::pair< ArrayVal, std::string > ArrayMapVal
virtual bool FindInLocators(double *x, vtkLagrangianParticle *particle)
virtual void ParallelManualShift(vtkLagrangianParticle *vtkNotUsed(particle))
Method called by parallel algorithm after receiving a particle from stream if PManualShift flag has b...
virtual bool InteractWithSurface(int surfaceType, vtkLagrangianParticle *particle, vtkDataSet *surface, vtkIdType cellId, std::queue< vtkLagrangianParticle * > &particles)
Call vtkLagrangianBasicIntegrationModel::Terminate This method is to be reimplemented in inherited cl...
virtual vtkAbstractArray * GetSeedArray(int idx, vtkPointData *pointData)
Get a seed array, as set in setInputArrayToProcess from the provided seed point data.
virtual void InsertParticleSeedData(vtkLagrangianParticle *particle, vtkFieldData *data)
Method used by the LPT to insert data from the partice into the provided vtkFieldData.
virtual int FunctionValues(vtkLagrangianParticle *particle, vtkDataSet *dataSet, vtkIdType cellId, double *weights, double *x, double *f)=0
Actually compute the integration model velocity field pure abstract, to be implemented in inherited c...
vtkWeakPointer< vtkLagrangianParticleTracker > Tracker
virtual vtkAbstractArray * GetSeedArray(int idx, vtkLagrangianParticle *particle)
Get a seed array, as set in setInputArrayToProcess from the provided particle seed data Access then t...
virtual vtkIdType FindInLocator(vtkDataSet *dataSet, vtkAbstractCellLocator *locator, double *x, vtkGenericCell *cell, double *weights)
Look in the given dataset and associated locator to see if it contains the point x,...
virtual int GetWeightsSize()
Get the maximum weights size necessary for calling FindInLocators with weights.
virtual vtkDoubleArray * GetSurfaceArrayDefaultValues()
Get the surface arrays default values for each leaf Used Only be the vtkLagrangianSurfaceHelper in Pa...
virtual void InsertParticleData(vtkLagrangianParticle *particle, vtkFieldData *data, int stepEnum)
Method used by the LPT to insert data from the partice into the provided vtkFieldData.
virtual bool BreakParticle(vtkLagrangianParticle *particle, vtkDataSet *surface, vtkIdType cellId, std::queue< vtkLagrangianParticle * > &particles)
Breakup a particle at intersection point, by terminating it and creating two new particle using the i...
virtual vtkIntArray * GetSeedArrayTypes()
Get the seed arrays expected type Used Only be the vtkLagrangianSeedHelper in ParaView plugins.
virtual bool GetFlowOrSurfaceData(vtkLagrangianParticle *particle, int idx, vtkDataSet *flowDataSet, vtkIdType tupleId, double *weights, double *data)
Directly get a double value from flow or surface data as defined in SetInputArrayToProcess.
virtual vtkIntArray * GetSurfaceArrayTypes()
Get the surface arrays expected type Used Only be the vtkLagrangianSurfaceHelper in ParaView plugins.
Filter to inject and track particles in a flow.
Basis class for Lagrangian particles.
Composite dataset that organizes datasets into blocks.
composite dataset to encapsulates pieces of dataset.
represent and manipulate point attribute data
Definition: vtkPointData.h:32
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:85
a vtkAbstractArray subclass for strings
@ port
Definition: vtkX3D.h:453
@ name
Definition: vtkX3D.h:225
@ data
Definition: vtkX3D.h:321
struct to hold a user data
int vtkIdType
Definition: vtkType.h:338