VTK  9.3.1
vtkGenericStreamTracer.h
Go to the documentation of this file.
1 // SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
2 // SPDX-License-Identifier: BSD-3-Clause
57 #ifndef vtkGenericStreamTracer_h
58 #define vtkGenericStreamTracer_h
59 
60 #include "vtkFiltersGenericModule.h" // For export macro
61 #include "vtkPolyDataAlgorithm.h"
62 
63 #include "vtkInitialValueProblemSolver.h" // Needed for constants
64 
65 VTK_ABI_NAMESPACE_BEGIN
66 class vtkDataArray;
68 class vtkIdList;
69 class vtkIntArray;
71 class vtkDataSet;
73 class vtkGenericDataSet;
74 
75 class VTKFILTERSGENERIC_EXPORT vtkGenericStreamTracer : public vtkPolyDataAlgorithm
76 {
77 public:
79  void PrintSelf(ostream& os, vtkIndent indent) override;
80 
87  static vtkGenericStreamTracer* New();
88 
90 
95  vtkSetVector3Macro(StartPosition, double);
96  vtkGetVector3Macro(StartPosition, double);
98 
100 
103  void SetSourceData(vtkDataSet* source);
104  vtkDataSet* GetSource();
106 
111  void SetSourceConnection(vtkAlgorithmOutput* algOutput);
112 
113  int FillInputPortInformation(int port, vtkInformation* info) override;
114 
115  enum Units
116  {
119  CELL_LENGTH_UNIT
120  };
121 
122  enum Solvers
123  {
129  };
130 
132  {
136  OUT_OF_TIME = 4,
137  OUT_OF_STEPS = 5,
138  STAGNATION = 6
139  };
140 
142 
153  void SetIntegrator(vtkInitialValueProblemSolver*);
154  vtkGetObjectMacro(Integrator, vtkInitialValueProblemSolver);
155  void SetIntegratorType(int type);
156  int GetIntegratorType();
157  void SetIntegratorTypeToRungeKutta2() { this->SetIntegratorType(RUNGE_KUTTA2); }
158  void SetIntegratorTypeToRungeKutta4() { this->SetIntegratorType(RUNGE_KUTTA4); }
159  void SetIntegratorTypeToRungeKutta45() { this->SetIntegratorType(RUNGE_KUTTA45); }
161 
163 
170  void SetMaximumPropagation(int unit, double max);
171  void SetMaximumPropagation(double max);
172  void SetMaximumPropagationUnit(int unit);
173  int GetMaximumPropagationUnit();
174  double GetMaximumPropagation();
175  void SetMaximumPropagationUnitToTimeUnit() { this->SetMaximumPropagationUnit(TIME_UNIT); }
176  void SetMaximumPropagationUnitToLengthUnit() { this->SetMaximumPropagationUnit(LENGTH_UNIT); }
178  {
179  this->SetMaximumPropagationUnit(CELL_LENGTH_UNIT);
180  }
182 
184 
192  void SetMinimumIntegrationStep(int unit, double step);
193  void SetMinimumIntegrationStepUnit(int unit);
194  void SetMinimumIntegrationStep(double step);
195  int GetMinimumIntegrationStepUnit();
196  double GetMinimumIntegrationStep();
197  void SetMinimumIntegrationStepUnitToTimeUnit() { this->SetMinimumIntegrationStepUnit(TIME_UNIT); }
199  {
200  this->SetMinimumIntegrationStepUnit(LENGTH_UNIT);
201  }
203  {
204  this->SetMinimumIntegrationStepUnit(CELL_LENGTH_UNIT);
205  }
207 
209 
217  void SetMaximumIntegrationStep(int unit, double step);
218  void SetMaximumIntegrationStepUnit(int unit);
219  void SetMaximumIntegrationStep(double step);
220  int GetMaximumIntegrationStepUnit();
221  double GetMaximumIntegrationStep();
222  void SetMaximumIntegrationStepUnitToTimeUnit() { this->SetMaximumIntegrationStepUnit(TIME_UNIT); }
224  {
225  this->SetMaximumIntegrationStepUnit(LENGTH_UNIT);
226  }
228  {
229  this->SetMaximumIntegrationStepUnit(CELL_LENGTH_UNIT);
230  }
232 
234 
243  void SetInitialIntegrationStep(int unit, double step);
244  void SetInitialIntegrationStepUnit(int unit);
245  void SetInitialIntegrationStep(double step);
246  int GetInitialIntegrationStepUnit();
247  double GetInitialIntegrationStep();
248  void SetInitialIntegrationStepUnitToTimeUnit() { this->SetInitialIntegrationStepUnit(TIME_UNIT); }
250  {
251  this->SetInitialIntegrationStepUnit(LENGTH_UNIT);
252  }
254  {
255  this->SetInitialIntegrationStepUnit(CELL_LENGTH_UNIT);
256  }
258 
260 
265  vtkSetMacro(MaximumError, double);
266  vtkGetMacro(MaximumError, double);
268 
270 
273  vtkSetMacro(MaximumNumberOfSteps, vtkIdType);
274  vtkGetMacro(MaximumNumberOfSteps, vtkIdType);
276 
278 
282  vtkSetMacro(TerminalSpeed, double);
283  vtkGetMacro(TerminalSpeed, double);
285 
287 
290  void SetIntegrationStepUnit(int unit)
291  {
292  this->SetInitialIntegrationStepUnit(unit);
293  this->SetMinimumIntegrationStepUnit(unit);
294  this->SetMaximumIntegrationStepUnit(unit);
295  }
297 
298  enum
299  {
302  BOTH
303  };
304 
306 
310  vtkSetClampMacro(IntegrationDirection, int, FORWARD, BOTH);
311  vtkGetMacro(IntegrationDirection, int);
312  void SetIntegrationDirectionToForward() { this->SetIntegrationDirection(FORWARD); }
313  void SetIntegrationDirectionToBackward() { this->SetIntegrationDirection(BACKWARD); }
314  void SetIntegrationDirectionToBoth() { this->SetIntegrationDirection(BOTH); }
316 
318 
323  vtkSetMacro(ComputeVorticity, vtkTypeBool);
324  vtkGetMacro(ComputeVorticity, vtkTypeBool);
325  vtkBooleanMacro(ComputeVorticity, vtkTypeBool);
327 
329 
333  vtkSetMacro(RotationScale, double);
334  vtkGetMacro(RotationScale, double);
336 
338 
343  vtkGetStringMacro(InputVectorsSelection);
344  void SelectInputVectors(const char* fieldName) { this->SetInputVectorsSelection(fieldName); }
346 
351 
356  void SetInterpolatorPrototype(vtkGenericInterpolatedVelocityField* ivf);
357 
358 protected:
360  ~vtkGenericStreamTracer() override;
361 
362  // hide the superclass' AddInput() from the user and the compiler
364  {
365  vtkErrorMacro(<< "AddInput() must be called with a vtkGenericDataSet not a vtkDataObject.");
366  }
367 
369 
377  void CalculateVorticity(vtkGenericAdaptorCell* cell, double pcoords[3],
378  vtkGenericAttribute* attribute, double vorticity[3]);
379 
380  void Integrate(vtkGenericDataSet* input0, vtkPolyData* output, vtkDataArray* seedSource,
381  vtkIdList* seedIds, vtkIntArray* integrationDirections, double lastPoint[3],
383  void SimpleIntegrate(
384  double seed[3], double lastPoint[3], double delt, vtkGenericInterpolatedVelocityField* func);
385  int CheckInputs(vtkGenericInterpolatedVelocityField*& func, vtkInformationVector** inputVector);
386  void GenerateNormals(vtkPolyData* output, double* firstNormal);
387 
389 
390  vtkSetStringMacro(InputVectorsSelection);
391  char* InputVectorsSelection;
392 
393  // starting from global x-y-z position
394  double StartPosition[3];
395 
396  static const double EPSILON;
398 
400 
402  {
403  double Interval;
404  int Unit;
405  };
406 
411 
412  void SetIntervalInformation(int unit, double interval, IntervalInformation& currentValues);
413  void SetIntervalInformation(int unit, IntervalInformation& currentValues);
414  static double ConvertToTime(IntervalInformation& interval, double cellLength, double speed);
415  static double ConvertToLength(IntervalInformation& interval, double cellLength, double speed);
416  static double ConvertToCellLength(IntervalInformation& interval, double cellLength, double speed);
417  static double ConvertToUnit(
418  IntervalInformation& interval, int unit, double cellLength, double speed);
419  void ConvertIntervals(
420  double& step, double& minStep, double& maxStep, int direction, double cellLength, double speed);
421 
422  void InitializeSeeds(
423  vtkDataArray*& seeds, vtkIdList*& seedIds, vtkIntArray*& integrationDirections);
424 
426 
427  // Prototype showing the integrator type to be set by the user.
429 
430  double MaximumError;
432 
435 
437 
438 private:
440  void operator=(const vtkGenericStreamTracer&) = delete;
441 };
442 
443 VTK_ABI_NAMESPACE_END
444 #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:52
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:315
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:79
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:64
defines cell interface
dynamic, self-adjusting array of int
Definition: vtkIntArray.h:34
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:28
list of point or cell ids
Definition: vtkIdList.h:22
IntervalInformation MaximumIntegrationStep
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:44
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:54
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.