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
68class vtkCell;
69class vtkCellData;
70class vtkDataArray;
71class vtkDataObject;
72class vtkDataSet;
73class vtkDataSetsType;
74class vtkDoubleArray;
75class vtkFieldData;
76class vtkGenericCell;
78class vtkIntArray;
81class vtkLocatorsType;
84class vtkPointData;
85class vtkPolyData;
86class vtkStringArray;
87class vtkSurfaceType;
89
90class VTKFILTERSFLOWPATHS_EXPORT vtkLagrangianBasicIntegrationModel : public vtkFunctionSet
91{
92public:
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
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
424 virtual void InitializePathData(vtkFieldData* data);
425
432
438 virtual void InitializeParticleData(vtkFieldData* particleData, int maxTuples = 0);
439
445 virtual void InsertPathData(vtkLagrangianParticle* particle, vtkFieldData* data);
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
487protected:
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
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
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
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
655
656private:
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:42
abstract class to specify cell behavior
Definition: vtkCell.h:61
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:56
general representation of visualization data
Definition: vtkDataObject.h:66
abstract class to specify dataset behavior
Definition: vtkDataSet.h:63
dynamic, self-adjusting array of double
represent and manipulate fields of data
Definition: vtkFieldData.h:63
Abstract interface for sets of functions.
provides thread-safe access to cells
a simple class to control print indentation
Definition: vtkIndent.h:40
Integrate a set of ordinary differential equations (initial value problem) in time.
dynamic, self-adjusting array of int
Definition: vtkIntArray.h:46
vtkFunctionSet abstract implementation to be used in the vtkLagrangianParticleTracker integrator.
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...
virtual vtkStringArray * GetSurfaceArrayEnumValues()
Get the surface arrays expected values and associated enums Used Only be the vtkLagrangianSurfaceHelp...
virtual vtkStringArray * GetSurfaceArrayNames()
Get the surface arrays expected name Used Only be the vtkLagrangianSurfaceHelper in ParaView plugins.
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 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 vtkLagrangianThreadedData * InitializeThreadedData()
Let the model allocate and initialize a threaded data.
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 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...
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 ...
int FunctionValues(double *x, double *f, void *userData) override
Evaluate integration model velocity f at position x.
virtual vtkIntArray * GetSurfaceArrayTypes()
Get the surface arrays expected type Used Only be the vtkLagrangianSurfaceHelper in ParaView plugins.
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.
virtual vtkIntArray * GetSeedArrayComps()
Get the seed arrays expected number of components Used Only be the vtkLagrangianSeedHelper in ParaVie...
std::map< std::string, SurfaceArrayDescription > SurfaceArrayDescriptions
virtual vtkStringArray * GetSeedArrayNames()
Get the seed arrays expected name Used Only be the vtkLagrangianSeedHelper in ParaView plugins.
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.
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...
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 vtkAbstractArray * GetSeedArray(int idx, vtkPointData *pointData)
Get a seed array, as set in setInputArrayToProcess from the provided seed point data.
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 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 void InsertParticleSeedData(vtkLagrangianParticle *particle, vtkFieldData *data)
Method used by the LPT to insert data from the partice into the provided vtkFieldData.
virtual vtkIntArray * GetSurfaceArrayComps()
Get the seed array expected number of components Used Only be the vtkLagrangianSurfaceHelper in ParaV...
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...
virtual vtkIntArray * GetSeedArrayTypes()
Get the seed arrays expected type Used Only be the vtkLagrangianSeedHelper in ParaView plugins.
virtual vtkDoubleArray * GetSurfaceArrayDefaultValues()
Get the surface arrays default values for each leaf Used Only be the vtkLagrangianSurfaceHelper in Pa...
vtkWeakPointer< vtkLagrangianParticleTracker > Tracker
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 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 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.
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.
Allocate and hold a VTK object.
Definition: vtkNew.h:62
represent and manipulate point attribute data
Definition: vtkPointData.h:42
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:91
a vtkAbstractArray subclass for strings
a weak reference to a vtkObject.
struct to hold a user data
int vtkIdType
Definition: vtkType.h:332