VTK  9.2.6
vtkGenericStreamTracer.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkGenericStreamTracer.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 =========================================================================*/
69 #ifndef vtkGenericStreamTracer_h
70 #define vtkGenericStreamTracer_h
71 
72 #include "vtkFiltersGenericModule.h" // For export macro
73 #include "vtkPolyDataAlgorithm.h"
74 
75 #include "vtkInitialValueProblemSolver.h" // Needed for constants
76 
77 class vtkDataArray;
79 class vtkIdList;
80 class vtkIntArray;
82 class vtkDataSet;
84 class vtkGenericDataSet;
85 
86 class VTKFILTERSGENERIC_EXPORT vtkGenericStreamTracer : public vtkPolyDataAlgorithm
87 {
88 public:
90  void PrintSelf(ostream& os, vtkIndent indent) override;
91 
98  static vtkGenericStreamTracer* New();
99 
101 
106  vtkSetVector3Macro(StartPosition, double);
107  vtkGetVector3Macro(StartPosition, double);
109 
111 
114  void SetSourceData(vtkDataSet* source);
115  vtkDataSet* GetSource();
117 
122  void SetSourceConnection(vtkAlgorithmOutput* algOutput);
123 
124  int FillInputPortInformation(int port, vtkInformation* info) override;
125 
126  enum Units
127  {
130  CELL_LENGTH_UNIT
131  };
132 
133  enum Solvers
134  {
140  };
141 
143  {
147  OUT_OF_TIME = 4,
148  OUT_OF_STEPS = 5,
149  STAGNATION = 6
150  };
151 
153 
164  void SetIntegrator(vtkInitialValueProblemSolver*);
165  vtkGetObjectMacro(Integrator, vtkInitialValueProblemSolver);
166  void SetIntegratorType(int type);
167  int GetIntegratorType();
168  void SetIntegratorTypeToRungeKutta2() { this->SetIntegratorType(RUNGE_KUTTA2); }
169  void SetIntegratorTypeToRungeKutta4() { this->SetIntegratorType(RUNGE_KUTTA4); }
170  void SetIntegratorTypeToRungeKutta45() { this->SetIntegratorType(RUNGE_KUTTA45); }
172 
174 
181  void SetMaximumPropagation(int unit, double max);
182  void SetMaximumPropagation(double max);
183  void SetMaximumPropagationUnit(int unit);
184  int GetMaximumPropagationUnit();
185  double GetMaximumPropagation();
186  void SetMaximumPropagationUnitToTimeUnit() { this->SetMaximumPropagationUnit(TIME_UNIT); }
187  void SetMaximumPropagationUnitToLengthUnit() { this->SetMaximumPropagationUnit(LENGTH_UNIT); }
189  {
190  this->SetMaximumPropagationUnit(CELL_LENGTH_UNIT);
191  }
193 
195 
203  void SetMinimumIntegrationStep(int unit, double step);
204  void SetMinimumIntegrationStepUnit(int unit);
205  void SetMinimumIntegrationStep(double step);
206  int GetMinimumIntegrationStepUnit();
207  double GetMinimumIntegrationStep();
208  void SetMinimumIntegrationStepUnitToTimeUnit() { this->SetMinimumIntegrationStepUnit(TIME_UNIT); }
210  {
211  this->SetMinimumIntegrationStepUnit(LENGTH_UNIT);
212  }
214  {
215  this->SetMinimumIntegrationStepUnit(CELL_LENGTH_UNIT);
216  }
218 
220 
228  void SetMaximumIntegrationStep(int unit, double step);
229  void SetMaximumIntegrationStepUnit(int unit);
230  void SetMaximumIntegrationStep(double step);
231  int GetMaximumIntegrationStepUnit();
232  double GetMaximumIntegrationStep();
233  void SetMaximumIntegrationStepUnitToTimeUnit() { this->SetMaximumIntegrationStepUnit(TIME_UNIT); }
235  {
236  this->SetMaximumIntegrationStepUnit(LENGTH_UNIT);
237  }
239  {
240  this->SetMaximumIntegrationStepUnit(CELL_LENGTH_UNIT);
241  }
243 
245 
254  void SetInitialIntegrationStep(int unit, double step);
255  void SetInitialIntegrationStepUnit(int unit);
256  void SetInitialIntegrationStep(double step);
257  int GetInitialIntegrationStepUnit();
258  double GetInitialIntegrationStep();
259  void SetInitialIntegrationStepUnitToTimeUnit() { this->SetInitialIntegrationStepUnit(TIME_UNIT); }
261  {
262  this->SetInitialIntegrationStepUnit(LENGTH_UNIT);
263  }
265  {
266  this->SetInitialIntegrationStepUnit(CELL_LENGTH_UNIT);
267  }
269 
271 
276  vtkSetMacro(MaximumError, double);
277  vtkGetMacro(MaximumError, double);
279 
281 
284  vtkSetMacro(MaximumNumberOfSteps, vtkIdType);
285  vtkGetMacro(MaximumNumberOfSteps, vtkIdType);
287 
289 
293  vtkSetMacro(TerminalSpeed, double);
294  vtkGetMacro(TerminalSpeed, double);
296 
298 
301  void SetIntegrationStepUnit(int unit)
302  {
303  this->SetInitialIntegrationStepUnit(unit);
304  this->SetMinimumIntegrationStepUnit(unit);
305  this->SetMaximumIntegrationStepUnit(unit);
306  }
308 
309  enum
310  {
313  BOTH
314  };
315 
317 
321  vtkSetClampMacro(IntegrationDirection, int, FORWARD, BOTH);
322  vtkGetMacro(IntegrationDirection, int);
323  void SetIntegrationDirectionToForward() { this->SetIntegrationDirection(FORWARD); }
324  void SetIntegrationDirectionToBackward() { this->SetIntegrationDirection(BACKWARD); }
325  void SetIntegrationDirectionToBoth() { this->SetIntegrationDirection(BOTH); }
327 
329 
334  vtkSetMacro(ComputeVorticity, vtkTypeBool);
335  vtkGetMacro(ComputeVorticity, vtkTypeBool);
336  vtkBooleanMacro(ComputeVorticity, vtkTypeBool);
338 
340 
344  vtkSetMacro(RotationScale, double);
345  vtkGetMacro(RotationScale, double);
347 
349 
354  vtkGetStringMacro(InputVectorsSelection);
355  void SelectInputVectors(const char* fieldName) { this->SetInputVectorsSelection(fieldName); }
357 
362 
367  void SetInterpolatorPrototype(vtkGenericInterpolatedVelocityField* ivf);
368 
369 protected:
371  ~vtkGenericStreamTracer() override;
372 
373  // hide the superclass' AddInput() from the user and the compiler
375  {
376  vtkErrorMacro(<< "AddInput() must be called with a vtkGenericDataSet not a vtkDataObject.");
377  }
378 
380 
388  void CalculateVorticity(vtkGenericAdaptorCell* cell, double pcoords[3],
389  vtkGenericAttribute* attribute, double vorticity[3]);
390 
391  void Integrate(vtkGenericDataSet* input0, vtkPolyData* output, vtkDataArray* seedSource,
392  vtkIdList* seedIds, vtkIntArray* integrationDirections, double lastPoint[3],
394  void SimpleIntegrate(
395  double seed[3], double lastPoint[3], double delt, vtkGenericInterpolatedVelocityField* func);
396  int CheckInputs(vtkGenericInterpolatedVelocityField*& func, vtkInformationVector** inputVector);
397  void GenerateNormals(vtkPolyData* output, double* firstNormal);
398 
400 
401  vtkSetStringMacro(InputVectorsSelection);
402  char* InputVectorsSelection;
403 
404  // starting from global x-y-z position
405  double StartPosition[3];
406 
407  static const double EPSILON;
409 
411 
413  {
414  double Interval;
415  int Unit;
416  };
417 
422 
423  void SetIntervalInformation(int unit, double interval, IntervalInformation& currentValues);
424  void SetIntervalInformation(int unit, IntervalInformation& currentValues);
425  static double ConvertToTime(IntervalInformation& interval, double cellLength, double speed);
426  static double ConvertToLength(IntervalInformation& interval, double cellLength, double speed);
427  static double ConvertToCellLength(IntervalInformation& interval, double cellLength, double speed);
428  static double ConvertToUnit(
429  IntervalInformation& interval, int unit, double cellLength, double speed);
430  void ConvertIntervals(
431  double& step, double& minStep, double& maxStep, int direction, double cellLength, double speed);
432 
433  void InitializeSeeds(
434  vtkDataArray*& seeds, vtkIdList*& seedIds, vtkIntArray*& integrationDirections);
435 
437 
438  // Prototype showing the integrator type to be set by the user.
440 
441  double MaximumError;
443 
446 
448 
449 private:
451  void operator=(const vtkGenericStreamTracer&) = delete;
452 };
453 
454 #endif
void SetMinimumIntegrationStepUnitToLengthUnit()
Specify the minimum step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
void SetMaximumPropagationUnitToTimeUnit()
Specify the maximum length of the streamlines expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT = 1 ...
void SetIntegrationDirectionToBackward()
Specify whether the streamtrace will be generated in the upstream or downstream direction.
void SelectInputVectors(const char *fieldName)
If you want to generate traces using an arbitrary vector array, then set its name here...
vtkGenericInterpolatedVelocityField * InterpolatorPrototype
Store vtkAlgorithm input/output information.
abstract class to specify dataset behavior
Definition: vtkDataSet.h:62
virtual int RequestData(vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector)
This is called by the superclass.
void SetInitialIntegrationStepUnitToTimeUnit()
Specify the initial step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
void SetInitialIntegrationStepUnitToCellLengthUnit()
Specify the initial step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
void SetMinimumIntegrationStepUnitToTimeUnit()
Specify the minimum step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
void AddInputData(vtkDataObject *)
Assign a data object as input.
void SetIntegrationDirectionToBoth()
Specify whether the streamtrace will be generated in the upstream or downstream direction.
vtkInitialValueProblemSolver * Integrator
int vtkIdType
Definition: vtkType.h:332
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:90
abstract class defined API for attribute data
void AddInput(vtkDataObject *)
IntervalInformation MinimumIntegrationStep
Proxy object to connect input/output ports.
static vtkPolyDataAlgorithm * New()
int vtkTypeBool
Definition: vtkABI.h:69
defines cell interface
dynamic, self-adjusting array of int
Definition: vtkIntArray.h:45
Superclass for algorithms that produce only polydata as output.
void SetInitialIntegrationStepUnitToLengthUnit()
Specify the initial step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
a simple class to control print indentation
Definition: vtkIndent.h:39
list of point or cell ids
Definition: vtkIdList.h:33
IntervalInformation MaximumIntegrationStep
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:55
void SetMaximumIntegrationStepUnitToCellLengthUnit()
Specify the maximum step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
void SetIntegrationDirectionToForward()
Specify whether the streamtrace will be generated in the upstream or downstream direction.
void SetIntegratorTypeToRungeKutta2()
Set/get the integrator type to be used in the stream line calculation.
void SetIntegratorTypeToRungeKutta4()
Set/get the integrator type to be used in the stream line calculation.
void SetMaximumPropagationUnitToLengthUnit()
Specify the maximum length of the streamlines expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT = 1 ...
Streamline generator.
IntervalInformation MaximumPropagation
int FillInputPortInformation(int port, vtkInformation *info) override
Fill the input port information objects for this algorithm.
void SetIntegratorTypeToRungeKutta45()
Set/get the integrator type to be used in the stream line calculation.
Store zero or more vtkInformation instances.
defines dataset interface
IntervalInformation InitialIntegrationStep
general representation of visualization data
Definition: vtkDataObject.h:65
void SetMaximumPropagationUnitToCellLengthUnit()
Specify the maximum length of the streamlines expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT = 1 ...
void SetMaximumIntegrationStepUnitToLengthUnit()
Specify the maximum step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
#define max(a, b)
Interface for obtaining interpolated velocity values.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
void SetMaximumIntegrationStepUnitToTimeUnit()
Specify the maximum step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
void SetMinimumIntegrationStepUnitToCellLengthUnit()
Specify the minimum step used in the integration expressed in one of the: TIME_UNIT = 0 LENGTH_UNIT =...
Integrate a set of ordinary differential equations (initial value problem) in time.
void SetIntegrationStepUnit(int unit)
Simplified API to set an homogeneous unit across Min/Max/Init IntegrationStepUnit.