VTK  9.2.6
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 
181 
184  vtkGetMacro(LocatorTolerance, double);
186 
205  std::queue<vtkLagrangianParticle*>& particles, unsigned int& interactedSurfaceFlatIndex,
206  PassThroughParticlesType& passThroughParticles);
207 
214  int idx, int port, int connection, int fieldAssociation, const char* name);
215 
225  virtual bool FindInLocators(double* x, vtkLagrangianParticle* particle, vtkDataSet*& dataset,
226  vtkIdType& cellId, vtkAbstractCellLocator*& loc, double*& weights);
227 
229 
233  virtual bool FindInLocators(
234  double* x, vtkLagrangianParticle* particle, vtkDataSet*& dataset, vtkIdType& cellId);
235  virtual bool FindInLocators(double* x, vtkLagrangianParticle* particle);
237 
242  virtual void InitializeParticle(vtkLagrangianParticle* vtkNotUsed(particle)) {}
243 
252  virtual bool CheckAdaptiveStepReintegration(vtkLagrangianParticle* vtkNotUsed(particle))
253  {
254  return true;
255  }
256 
265  virtual bool CheckFreeFlightTermination(vtkLagrangianParticle* vtkNotUsed(particle))
266  {
267  return false;
268  }
269 
271 
274  vtkSetMacro(NonPlanarQuadSupport, bool);
275  vtkGetMacro(NonPlanarQuadSupport, bool);
276  vtkBooleanMacro(NonPlanarQuadSupport, bool);
278 
284 
290 
296 
302 
308 
314 
320 
326 
328 
332  virtual int GetWeightsSize();
334 
358  virtual bool ManualIntegration(vtkInitialValueProblemSolver* integrator, double* xcur,
359  double* xnext, double t, double& delT, double& delTActual, double minStep, double maxStep,
360  double maxError, double cellLength, double& error, int& integrationResult,
361  vtkLagrangianParticle* particle);
362 
368  virtual void ParallelManualShift(vtkLagrangianParticle* vtkNotUsed(particle)) {}
369 
375 
381 
387  virtual bool FinalizeOutputs(
388  vtkPolyData* vtkNotUsed(particlePathsOutput), vtkDataObject* vtkNotUsed(interractionOutput))
389  {
390  return true;
391  }
392 
396  virtual void PreParticleInitalization() {}
397 
401  virtual void PreIntegrate(std::queue<vtkLagrangianParticle*>& vtkNotUsed(particles)) {}
402 
407  virtual vtkAbstractArray* GetSeedArray(int idx, vtkPointData* pointData);
408 
416  vtkSetMacro(NumberOfTrackedUserData, int);
417  vtkGetMacro(NumberOfTrackedUserData, int);
418 
425 
432 
438  virtual void InitializeParticleData(vtkFieldData* particleData, int maxTuples = 0);
439 
446 
453 
460  virtual void InsertParticleData(
461  vtkLagrangianParticle* particle, vtkFieldData* data, int stepEnum);
462 
469 
476  virtual void ParticleAboutToBeDeleted(vtkLagrangianParticle* vtkNotUsed(particle)) {}
477 
483  vtkLagrangianParticle* vtkNotUsed(particle), vtkPointData* vtkNotUsed(particleData))
484  {
485  }
486 
487 protected:
490 
496  virtual int FunctionValues(vtkLagrangianParticle* particle, vtkDataSet* dataSet, vtkIdType cellId,
497  double* weights, double* x, double* f) = 0;
498 
505  virtual vtkIdType FindInLocator(vtkDataSet* dataSet, vtkAbstractCellLocator* locator, double* x,
506  vtkGenericCell* cell, double* weights);
507 
513  virtual bool TerminateParticle(vtkLagrangianParticle* particle);
514 
520  virtual bool BounceParticle(
521  vtkLagrangianParticle* particle, vtkDataSet* surface, vtkIdType cellId);
522 
530  virtual bool BreakParticle(vtkLagrangianParticle* particle, vtkDataSet* surface, vtkIdType cellId,
531  std::queue<vtkLagrangianParticle*>& particles);
532 
542  virtual bool InteractWithSurface(int surfaceType, vtkLagrangianParticle* particle,
543  vtkDataSet* surface, vtkIdType cellId, std::queue<vtkLagrangianParticle*>& particles);
544 
551  virtual bool IntersectWithLine(vtkLagrangianParticle* particle, vtkCell* cell, double p1[3],
552  double p2[3], double tol, double& t, double x[3]);
553 
559  vtkLagrangianParticle* particle, double interpolationFactor, bool forceInside = false);
560 
567  vtkLagrangianParticle* particle, vtkDataSet* surface, vtkIdType cellId);
568 
576 
584  virtual bool GetFlowOrSurfaceData(vtkLagrangianParticle* particle, int idx,
585  vtkDataSet* flowDataSet, vtkIdType tupleId, double* weights, double* data);
586 
594  virtual int GetFlowOrSurfaceDataNumberOfComponents(int idx, vtkDataSet* dataSet);
595 
602 
612  const char* arrayName, vtkDataSet* dataset, int nComponent, double* defaultValues);
613 
616  vtkLocatorsType* Locators;
617  vtkDataSetsType* DataSets;
618  int WeightsSize = 0;
619 
620  struct ArrayVal
621  {
622  int val[3];
623  };
624  typedef std::pair<ArrayVal, std::string> ArrayMapVal;
625  std::map<int, ArrayMapVal> InputArrays;
626 
627  typedef struct SurfaceArrayDescription
628  {
629  int nComp;
630  int type;
631  std::vector<std::pair<int, std::string>> enumValues;
632  } SurfaceArrayDescription;
633  std::map<std::string, SurfaceArrayDescription> SurfaceArrayDescriptions;
634 
635  vtkSurfaceType* Surfaces;
636  vtkLocatorsType* SurfaceLocators;
637 
638  double Tolerance;
639  double LocatorTolerance = 0.001;
642  int NumberOfTrackedUserData = 0;
643 
652 
654  std::mutex ParticleQueueMutex;
655 
656 private:
658  void operator=(const vtkLagrangianBasicIntegrationModel&) = delete;
659 };
660 
661 #endif
Abstract superclass for all arrays.
an abstract base class for locators which find cells
represent and manipulate cell attribute data
Definition: vtkCellData.h:151
abstract class to specify cell behavior
Definition: vtkCell.h:150
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:165
general representation of visualization data
abstract class to specify dataset behavior
Definition: vtkDataSet.h:172
dynamic, self-adjusting array of double
represent and manipulate fields of data
Definition: vtkFieldData.h:172
Abstract interface for sets of functions.
provides thread-safe access to cells
a simple class to control print indentation
Definition: vtkIndent.h:119
Integrate a set of ordinary differential equations (initial value problem) in time.
dynamic, self-adjusting array of int
Definition: vtkIntArray.h:155
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 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 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...
virtual vtkLagrangianThreadedData * InitializeThreadedData()
Let the model allocate and initialize a threaded data.
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 void FinalizeThreadedData(vtkLagrangianThreadedData *&data)
Let the model finalize and deallocate a user data at thread level This method is called serially for ...
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)
Add a dataset to locate cells in This create a specific locator for the provided dataset using the Lo...
virtual void InsertSurfaceInteractionData(vtkLagrangianParticle *vtkNotUsed(particle), vtkPointData *vtkNotUsed(particleData))
Method to be reimplemented if needed in inherited classes.
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)
Convienience methods to call FindInLocators with less arguments THESE METHODS ARE NOT THREAD-SAFE.
virtual void PreParticleInitalization()
Allow for model setup prior to Particle Initalization.
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:151
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:200
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:332