VTK  9.0.20200925
vtkParticleTracerBase.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkParticleTracerBase.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 =========================================================================*/
28 #ifndef vtkParticleTracerBase_h
29 #define vtkParticleTracerBase_h
30 
31 #include "vtkFiltersFlowPathsModule.h" // For export macro
32 #include "vtkPolyDataAlgorithm.h"
33 #include "vtkSmartPointer.h" // For protected ivars.
34 
35 #include <list> // STL Header
36 #include <vector> // STL Header
37 
40 class vtkCellArray;
41 class vtkCharArray;
43 class vtkDataArray;
44 class vtkDataSet;
45 class vtkDoubleArray;
46 class vtkFloatArray;
47 class vtkGenericCell;
49 class vtkIntArray;
52 class vtkPointData;
53 class vtkPoints;
54 class vtkPolyData;
56 
58 {
59 struct Position_t
60 {
61  double x[4];
62 };
63 using Position = struct Position_t;
64 
66 {
67  // These are used during iteration
72  // These are computed scalars we might display
73  int SourceID;
74  int TimeStepAge; // amount of time steps the particle has advanced
76  int InjectedStepId; // time step the particle was injected
79  // These are useful to track for debugging etc
80  int ErrorCode;
81  float age;
82  // these are needed across time steps to compute vorticity
83  float rotation;
84  float angularVel;
85  float time;
86  float speed;
87  // once the partice is added, PointId is valid and is the tuple location
88  // in ProtoPD.
90  // if PointId is negative then in parallel this particle was just
91  // received and we need to get the tuple value from vtkPParticleTracerBase::Tail.
93 };
95 
96 typedef std::vector<ParticleInformation> ParticleVector;
97 typedef ParticleVector::iterator ParticleIterator;
98 typedef std::list<ParticleInformation> ParticleDataList;
99 typedef ParticleDataList::iterator ParticleListIterator;
100 };
101 
102 class VTKFILTERSFLOWPATHS_EXPORT vtkParticleTracerBase : public vtkPolyDataAlgorithm
103 {
104 public:
105  enum Solvers
106  {
111  UNKNOWN
112  };
113 
115  void PrintSelf(ostream& os, vtkIndent indent) override;
116  void PrintParticleHistories();
117 
119 
124  vtkGetMacro(ComputeVorticity, bool);
125  void SetComputeVorticity(bool);
127 
129 
132  vtkGetMacro(TerminalSpeed, double);
133  void SetTerminalSpeed(double);
135 
137 
141  vtkGetMacro(RotationScale, double);
142  void SetRotationScale(double);
144 
146 
150  vtkSetMacro(IgnorePipelineTime, vtkTypeBool);
151  vtkGetMacro(IgnorePipelineTime, vtkTypeBool);
152  vtkBooleanMacro(IgnorePipelineTime, vtkTypeBool);
154 
156 
165  vtkGetMacro(ForceReinjectionEveryNSteps, int);
166  void SetForceReinjectionEveryNSteps(int);
168 
170 
176  void SetTerminationTime(double t);
177  vtkGetMacro(TerminationTime, double);
179 
180  void SetIntegrator(vtkInitialValueProblemSolver*);
181  vtkGetObjectMacro(Integrator, vtkInitialValueProblemSolver);
182 
183  void SetIntegratorType(int type);
184  int GetIntegratorType();
185 
187 
191  vtkGetMacro(StartTime, double);
192  void SetStartTime(double t);
194 
196 
205  vtkSetMacro(StaticSeeds, int);
206  vtkGetMacro(StaticSeeds, int);
208 
210 
219  vtkSetMacro(StaticMesh, int);
220  vtkGetMacro(StaticMesh, int);
222 
224 
230  virtual void SetParticleWriter(vtkAbstractParticleWriter* pw);
231  vtkGetObjectMacro(ParticleWriter, vtkAbstractParticleWriter);
233 
235 
239  vtkSetStringMacro(ParticleFileName);
240  vtkGetStringMacro(ParticleFileName);
242 
244 
248  vtkSetMacro(EnableParticleWriting, vtkTypeBool);
249  vtkGetMacro(EnableParticleWriting, vtkTypeBool);
250  vtkBooleanMacro(EnableParticleWriting, vtkTypeBool);
252 
254 
259  vtkSetMacro(DisableResetCache, vtkTypeBool);
260  vtkGetMacro(DisableResetCache, vtkTypeBool);
261  vtkBooleanMacro(DisableResetCache, vtkTypeBool);
263 
265 
268  void AddSourceConnection(vtkAlgorithmOutput* input);
269  void RemoveAllSources();
271 
272 protected:
273  vtkSmartPointer<vtkPolyData> Output; // managed by child classes
275 
280  vtkIdType UniqueIdCounter; // global Id counter used to give particles a stamp
282  vtkSmartPointer<vtkPointData> ParticlePointData; // the current particle point data consistent
283  // with particle history
284  // Everything related to time
285  vtkTypeBool IgnorePipelineTime; // whether to use the pipeline time for termination
286  vtkTypeBool DisableResetCache; // whether to enable ResetCache() method
288 
290  ~vtkParticleTracerBase() override;
291 
292  //
293  // Make sure the pipeline knows what type we expect as input
294  //
295  int FillInputPortInformation(int port, vtkInformation* info) override;
296 
297  //
298  // The usual suspects
299  //
301  vtkInformationVector* outputVector) override;
302 
303  //
304  // Store any information we need in the output and fetch what we can
305  // from the input
306  //
307  int RequestInformation(vtkInformation* request, vtkInformationVector** inputVector,
308  vtkInformationVector* outputVector) override;
309 
310  //
311  // Compute input time steps given the output step
312  //
313  int RequestUpdateExtent(vtkInformation* request, vtkInformationVector** inputVector,
314  vtkInformationVector* outputVector) override;
315 
316  //
317  // what the pipeline calls for each time step
318  //
319  int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
320  vtkInformationVector* outputVector) override;
321 
322  //
323  // these routines are internally called to actually generate the output
324  //
325  virtual int ProcessInput(vtkInformationVector** inputVector);
326 
327  // This is the main part of the algorithm:
328  // * move all the particles one step
329  // * Reinject particles (by adding them to this->ParticleHistories)
330  // either at the beginning or at the end of each step (modulo
331  // this->ForceReinjectionEveryNSteps)
332  // * Output a polydata representing the moved particles
333  // Note that if the starting and the ending time coincide, the polydata is still valid.
334  virtual vtkPolyData* Execute(vtkInformationVector** inputVector);
335 
336  // the RequestData will call these methods in turn
337  virtual void Initialize() {} // the first iteration
338  virtual int OutputParticles(vtkPolyData* poly) = 0; // every iteration
339  virtual void Finalize() {} // the last iteration
340 
345  virtual std::vector<vtkDataSet*> GetSeedSources(vtkInformationVector* inputVector, int timeStep);
346 
347  //
348  // Initialization of input (vector-field) geometry
349  //
350  int InitializeInterpolator();
351  int UpdateDataCache(vtkDataObject* td);
352 
357  void TestParticles(vtkParticleTracerBaseNamespace::ParticleVector& candidates,
359 
360  void TestParticles(
361  vtkParticleTracerBaseNamespace::ParticleVector& candidates, std::vector<int>& passed);
362 
369  virtual void AssignSeedsToProcessors(double time, vtkDataSet* source, int sourceID, int ptId,
370  vtkParticleTracerBaseNamespace::ParticleVector& localSeedPoints, int& localAssignedCount);
371 
376  virtual void AssignUniqueIds(vtkParticleTracerBaseNamespace::ParticleVector& localSeedPoints);
377 
382  void UpdateParticleList(vtkParticleTracerBaseNamespace::ParticleVector& candidates);
383 
389  virtual bool UpdateParticleListFromOtherProcesses() { return false; }
390 
394  void IntegrateParticle(vtkParticleTracerBaseNamespace::ParticleListIterator& it,
395  double currenttime, double terminationtime, vtkInitialValueProblemSolver* integrator);
396 
397  // if the particle is added to send list, then returns value is 1,
398  // if it is kept on this process after a retry return value is 0
401  {
402  return true;
403  }
404 
411  bool ComputeDomainExitLocation(
412  double pos[4], double p2[4], double intersection[4], vtkGenericCell* cell);
413 
414  //
415  // Scalar arrays that are generated as each particle is updated
416  //
417  void CreateProtoPD(vtkDataObject* input);
418 
419  vtkFloatArray* GetParticleAge(vtkPointData*);
420  vtkIntArray* GetParticleIds(vtkPointData*);
421  vtkCharArray* GetParticleSourceIds(vtkPointData*);
422  vtkIntArray* GetInjectedPointIds(vtkPointData*);
423  vtkIntArray* GetInjectedStepIds(vtkPointData*);
424  vtkIntArray* GetErrorCodeArr(vtkPointData*);
425  vtkFloatArray* GetParticleVorticity(vtkPointData*);
426  vtkFloatArray* GetParticleRotation(vtkPointData*);
427  vtkFloatArray* GetParticleAngularVel(vtkPointData*);
428 
429  // utility function we use to test if a point is inside any of our local datasets
430  bool InsideBounds(double point[]);
431 
432  void CalculateVorticity(
433  vtkGenericCell* cell, double pcoords[3], vtkDoubleArray* cellVectors, double vorticity[3]);
434 
435  //------------------------------------------------------
436 
437  double GetCacheDataTime(int i);
438  double GetCacheDataTime();
439 
440  virtual void ResetCache();
441  void AddParticle(vtkParticleTracerBaseNamespace::ParticleInformation& info, double* velocity);
442 
444 
449  virtual bool IsPointDataValid(vtkDataObject* input);
450  bool IsPointDataValid(vtkCompositeDataSet* input, std::vector<std::string>& arrayNames);
451  void GetPointDataArrayNames(vtkDataSet* input, std::vector<std::string>& names);
453 
454  vtkGetMacro(ReinjectionCounter, int);
455  vtkGetMacro(CurrentTimeValue, double);
456 
461  virtual void InitializeExtraPointDataArrays(vtkPointData* vtkNotUsed(outputPD)) {}
462 
464 
465  vtkTemporalInterpolatedVelocityField* GetInterpolator();
466 
471  virtual void AddRestartSeeds(vtkInformationVector** /*inputVector*/) {}
472 
473 private:
477  void SetInterpolatorPrototype(vtkAbstractInterpolatedVelocityField*) {}
478 
488  bool RetryWithPush(vtkParticleTracerBaseNamespace::ParticleInformation& info, double* point1,
489  double delT, int subSteps);
490 
491  bool SetTerminationTimeNoModify(double t);
492 
493  // Parameters of tracing
494  vtkInitialValueProblemSolver* Integrator;
495  double IntegrationStep;
496  double MaximumError;
497  bool ComputeVorticity;
498  double RotationScale;
499  double TerminalSpeed;
500 
501  // A counter to keep track of how many times we reinjected
502  int ReinjectionCounter;
503 
504  // Important for Caching of Cells/Ids/Weights etc
505  int AllFixedGeometry;
506  int StaticMesh;
507  int StaticSeeds;
508 
509  std::vector<double> InputTimeValues;
510  double StartTime;
511  double TerminationTime;
512  double CurrentTimeValue;
513 
514  int StartTimeStep; // InputTimeValues[StartTimeStep] <= StartTime <=
515  // InputTimeValues[StartTimeStep+1]
516  int CurrentTimeStep;
517  int TerminationTimeStep; // computed from start time
518  bool FirstIteration;
519 
520  // Innjection parameters
521  int ForceReinjectionEveryNSteps;
522  vtkTimeStamp ParticleInjectionTime;
523  bool HasCache;
524 
525  // Particle writing to disk
526  vtkAbstractParticleWriter* ParticleWriter;
527  char* ParticleFileName;
528  vtkTypeBool EnableParticleWriting;
529 
530  // The main lists which are held during operation- between time step updates
532 
533  // The velocity interpolator
535  vtkAbstractInterpolatedVelocityField* InterpolatorPrototype;
536 
537  // Data for time step CurrentTimeStep-1 and CurrentTimeStep
539 
540  // Cache bounds info for each dataset we will use repeatedly
541  struct bounds_t
542  {
543  double b[6];
544  };
545  using bounds = struct bounds_t;
546  std::vector<bounds> CachedBounds[2];
547 
548  // temporary variables used by Exeucte(), for convenience only
549 
550  vtkSmartPointer<vtkPoints> OutputCoordinates;
551  vtkSmartPointer<vtkFloatArray> ParticleAge;
552  vtkSmartPointer<vtkIntArray> ParticleIds;
553  vtkSmartPointer<vtkCharArray> ParticleSourceIds;
554  vtkSmartPointer<vtkIntArray> InjectedPointIds;
555  vtkSmartPointer<vtkIntArray> InjectedStepIds;
556  vtkSmartPointer<vtkIntArray> ErrorCodeArray;
557  vtkSmartPointer<vtkFloatArray> ParticleVorticity;
558  vtkSmartPointer<vtkFloatArray> ParticleRotation;
559  vtkSmartPointer<vtkFloatArray> ParticleAngularVel;
561  vtkSmartPointer<vtkPointData> OutputPointData;
562  vtkSmartPointer<vtkDataSet> DataReferenceT[2];
563  vtkSmartPointer<vtkCellArray> ParticleCells;
564 
566  void operator=(const vtkParticleTracerBase&) = delete;
567  vtkTimeStamp ExecuteTime;
568 
569  unsigned int NumberOfParticles();
570 
573 
574  static const double Epsilon;
575 };
576 
577 #endif
vtkPoints
represent and manipulate 3D points
Definition: vtkPoints.h:33
vtkParticleTracerBaseNamespace::Position_t::x
double x[4]
Definition: vtkParticleTracerBase.h:61
vtkParticleTracerBase
A particle tracer for vector fields.
Definition: vtkParticleTracerBase.h:102
vtkParticleTracerBaseNamespace::ParticleInformation_t::rotation
float rotation
Definition: vtkParticleTracerBase.h:83
vtkParticleTracerBase::Output
vtkSmartPointer< vtkPolyData > Output
Definition: vtkParticleTracerBase.h:273
vtkParticleTracerBase::Finalize
virtual void Finalize()
Definition: vtkParticleTracerBase.h:339
vtkParticleTracerBaseNamespace::ParticleInformation_t::speed
float speed
Definition: vtkParticleTracerBase.h:86
vtkParticleTracerBaseNamespace::ParticleInformation_t::LocationState
int LocationState
Definition: vtkParticleTracerBase.h:71
vtkPointData
represent and manipulate point attribute data
Definition: vtkPointData.h:32
vtkParticleTracerBase::InitializeExtraPointDataArrays
virtual void InitializeExtraPointDataArrays(vtkPointData *vtkNotUsed(outputPD))
Methods to append values to existing point data arrays that may only be desired on specific concrete ...
Definition: vtkParticleTracerBase.h:461
vtkX3D::type
Definition: vtkX3D.h:522
vtkIdType
int vtkIdType
Definition: vtkType.h:330
vtkFloatArray
dynamic, self-adjusting array of float
Definition: vtkFloatArray.h:35
vtkInformationVector
Store zero or more vtkInformation instances.
Definition: vtkInformationVector.h:35
vtkParticleTracerBaseNamespace
Definition: vtkParticleTracerBase.h:57
vtkTimeStamp
record modification and/or execution time
Definition: vtkTimeStamp.h:32
vtkPolyDataAlgorithm::RequestUpdateExtent
virtual int RequestUpdateExtent(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called by the superclass.
vtkParticleTracerBase::ParticlePointData
vtkSmartPointer< vtkPointData > ParticlePointData
Definition: vtkParticleTracerBase.h:282
vtkParticleTracerBaseNamespace::ParticleDataList
std::list< ParticleInformation > ParticleDataList
Definition: vtkParticleTracerBase.h:98
vtkSmartPointer< vtkPolyData >
vtkParticleTracerBaseNamespace::ParticleInformation_t::InjectedStepId
int InjectedStepId
Definition: vtkParticleTracerBase.h:76
vtkParticleTracerBase::NONE
Definition: vtkParticleTracerBase.h:110
vtkParticleTracerBase::DisableResetCache
vtkTypeBool DisableResetCache
Definition: vtkParticleTracerBase.h:286
vtkParticleTracerBase::AddRestartSeeds
virtual void AddRestartSeeds(vtkInformationVector **)
For restarts of particle paths, we add in the ability to add in particles from a previous computation...
Definition: vtkParticleTracerBase.h:471
vtkParticleTracerBase::Initialize
virtual void Initialize()
Definition: vtkParticleTracerBase.h:337
vtkParticleTracerBaseNamespace::ParticleInformation_t::CachedCellId
vtkIdType CachedCellId[2]
Definition: vtkParticleTracerBase.h:70
vtkParticleTracerBaseNamespace::ParticleVector
std::vector< ParticleInformation > ParticleVector
Definition: vtkParticleTracerBase.h:96
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:49
vtkX3D::time
Definition: vtkX3D.h:503
vtkPolyDataAlgorithm::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkMultiBlockDataSet
Composite dataset that organizes datasets into blocks.
Definition: vtkMultiBlockDataSet.h:45
vtkCompositeDataSet
abstract superclass for composite (multi-block or AMR) datasets
Definition: vtkCompositeDataSet.h:45
vtkParticleTracerBaseNamespace::ParticleInformation_t::InjectedPointId
int InjectedPointId
Definition: vtkParticleTracerBase.h:75
vtkParticleTracerBase::ParticleHistories
vtkParticleTracerBaseNamespace::ParticleDataList ParticleHistories
Definition: vtkParticleTracerBase.h:281
vtkParticleTracerBaseNamespace::ParticleInformation_t::angularVel
float angularVel
Definition: vtkParticleTracerBase.h:84
vtkPolyDataAlgorithm.h
vtkParticleTracerBase::Solvers
Solvers
Definition: vtkParticleTracerBase.h:105
vtkParticleTracerBase::UniqueIdCounter
vtkIdType UniqueIdCounter
Definition: vtkParticleTracerBase.h:280
vtkCharArray
dynamic, self-adjusting array of char
Definition: vtkCharArray.h:35
vtkX3D::port
Definition: vtkX3D.h:453
vtkParticleTracerBase::RUNGE_KUTTA45
Definition: vtkParticleTracerBase.h:109
vtkX3D::point
Definition: vtkX3D.h:242
vtkParticleTracerBase::IgnorePipelineTime
vtkTypeBool IgnorePipelineTime
Definition: vtkParticleTracerBase.h:285
vtkPolyDataAlgorithm::ProcessRequest
vtkTypeBool ProcessRequest(vtkInformation *, vtkInformationVector **, vtkInformationVector *) override
see vtkAlgorithm for details
vtkParticleTracerBaseNamespace::ParticleListIterator
ParticleDataList::iterator ParticleListIterator
Definition: vtkParticleTracerBase.h:99
vtkParticleTracerBaseNamespace::ParticleInformation_t::CachedDataSetId
int CachedDataSetId[2]
Definition: vtkParticleTracerBase.h:69
vtkParticleTracerBase::ProtoPD
vtkSmartPointer< vtkPointData > ProtoPD
ProtoPD is used just to keep track of the input array names and number of components for copy allocat...
Definition: vtkParticleTracerBase.h:279
vtkPolyDataAlgorithm::RequestData
virtual int RequestData(vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector)
This is called by the superclass.
vtkParticleTracerBaseNamespace::ParticleInformation_t::UniqueParticleId
int UniqueParticleId
Definition: vtkParticleTracerBase.h:77
vtkMultiProcessController
Multiprocessing communication superclass.
Definition: vtkMultiProcessController.h:76
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:33
vtkParticleTracerBaseNamespace::ParticleInformation_t::ErrorCode
int ErrorCode
Definition: vtkParticleTracerBase.h:80
vtkCellArray
object to represent cell connectivity
Definition: vtkCellArray.h:180
vtkIntArray
dynamic, self-adjusting array of int
Definition: vtkIntArray.h:39
vtkSmartPointer.h
vtkAbstractParticleWriter
abstract class to write particle data to file
Definition: vtkAbstractParticleWriter.h:37
vtkParticleTracerBase::RUNGE_KUTTA2
Definition: vtkParticleTracerBase.h:107
vtkParticleTracerBaseNamespace::ParticleInformation_t
Definition: vtkParticleTracerBase.h:65
vtkPolyDataAlgorithm::FillInputPortInformation
int FillInputPortInformation(int port, vtkInformation *info) override
Fill the input port information objects for this algorithm.
vtkParticleTracerBaseNamespace::ParticleInformation_t::time
float time
Definition: vtkParticleTracerBase.h:85
vtkParticleTracerBaseNamespace::ParticleInformation_t::SimulationTime
double SimulationTime
Definition: vtkParticleTracerBase.h:78
StreaklineFilterInternal
Definition: vtkStreaklineFilter.h:33
vtkParticleTracerBaseNamespace::ParticleInformation_t::TailPointId
vtkIdType TailPointId
Definition: vtkParticleTracerBase.h:92
vtkParticleTracerBaseNamespace::ParticleInformation_t::TimeStepAge
int TimeStepAge
Definition: vtkParticleTracerBase.h:74
vtkDataSet
abstract class to specify dataset behavior
Definition: vtkDataSet.h:56
vtkAbstractInterpolatedVelocityField
An abstract class for obtaining the interpolated velocity values at a point.
Definition: vtkAbstractInterpolatedVelocityField.h:82
vtkInformation
Store vtkAlgorithm input/output information.
Definition: vtkInformation.h:73
vtkX3D::info
Definition: vtkX3D.h:382
vtkParticleTracerBase::SendParticleToAnotherProcess
virtual bool SendParticleToAnotherProcess(vtkParticleTracerBaseNamespace::ParticleInformation &, vtkParticleTracerBaseNamespace::ParticleInformation &, vtkPointData *)
Definition: vtkParticleTracerBase.h:399
vtkParticleTracerBase::AppendToExtraPointDataArrays
virtual void AppendToExtraPointDataArrays(vtkParticleTracerBaseNamespace::ParticleInformation &)
Definition: vtkParticleTracerBase.h:463
vtkParticleTracerBaseNamespace::Position_t
Definition: vtkParticleTracerBase.h:59
vtkParticleTracerBase::UpdateParticleListFromOtherProcesses
virtual bool UpdateParticleListFromOtherProcesses()
this is used during classification of seed points and also between iterations of the main loop as par...
Definition: vtkParticleTracerBase.h:389
vtkAlgorithmOutput
Proxy object to connect input/output ports.
Definition: vtkAlgorithmOutput.h:36
vtkTemporalInterpolatedVelocityField
A helper class for interpolating between times during particle tracing.
Definition: vtkTemporalInterpolatedVelocityField.h:69
vtkPolyData
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:85
vtkGenericCell
provides thread-safe access to cells
Definition: vtkGenericCell.h:36
vtkDoubleArray
dynamic, self-adjusting array of double
Definition: vtkDoubleArray.h:35
source
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
Definition: vtkBoostGraphAdapter.h:959
vtkInitialValueProblemSolver
Integrate a set of ordinary differential equations (initial value problem) in time.
Definition: vtkInitialValueProblemSolver.h:40
vtkParticleTracerBaseNamespace::ParticleInformation_t::PointId
vtkIdType PointId
Definition: vtkParticleTracerBase.h:89
vtkParticleTracerBaseNamespace::ParticleIterator
ParticleVector::iterator ParticleIterator
Definition: vtkParticleTracerBase.h:97
vtkDataObject
general representation of visualization data
Definition: vtkDataObject.h:59
vtkParticleTracerBaseNamespace::ParticleInformation_t::SourceID
int SourceID
Definition: vtkParticleTracerBase.h:73
vtkParticleTracerBase::RUNGE_KUTTA4
Definition: vtkParticleTracerBase.h:108
vtkParticleTracerBaseNamespace::ParticleInformation_t::CurrentPosition
Position CurrentPosition
Definition: vtkParticleTracerBase.h:68
vtkTypeBool
int vtkTypeBool
Definition: vtkABI.h:69
vtkPolyDataAlgorithm::RequestInformation
virtual int RequestInformation(vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector)
vtkPolyDataAlgorithm
Superclass for algorithms that produce only polydata as output.
Definition: vtkPolyDataAlgorithm.h:41
ParticlePathFilterInternal
Definition: vtkParticlePathFilter.h:34
vtkParticleTracerBaseNamespace::ParticleInformation_t::age
float age
Definition: vtkParticleTracerBase.h:81