vtkGenericStreamTracer.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkGenericStreamTracer.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkGenericStreamTracer_h
#define vtkGenericStreamTracer_h
 
#include "vtkFiltersGenericModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
 
#include "vtkInitialValueProblemSolver.h" // Needed for constants
 
class vtkDataArray;
class vtkGenericAdaptorCell;
class vtkIdList;
class vtkIntArray;
class vtkGenericInterpolatedVelocityField;
class vtkDataSet;
class vtkGenericAttribute;
class vtkGenericDataSet;
 
class VTKFILTERSGENERIC_EXPORT vtkGenericStreamTracer : public vtkPolyDataAlgorithm
{
public:
  vtkTypeMacro(vtkGenericStreamTracer, vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkGenericStreamTracer* New();
 
 
  vtkSetVector3Macro(StartPosition, double);
  vtkGetVector3Macro(StartPosition, double);
 
 
  void SetSourceData(vtkDataSet* source);
  vtkDataSet* GetSource();
 
  void SetSourceConnection(vtkAlgorithmOutput* algOutput);
 
  int FillInputPortInformation(int port, vtkInformation* info) override;
 
  enum Units
  {
    TIME_UNIT,
    LENGTH_UNIT,
    CELL_LENGTH_UNIT
  };
 
  enum Solvers
  {
    RUNGE_KUTTA2,
    RUNGE_KUTTA4,
    RUNGE_KUTTA45,
    NONE,
    UNKNOWN
  };
 
  enum ReasonForTermination
  {
    OUT_OF_DOMAIN = vtkInitialValueProblemSolver::OUT_OF_DOMAIN,
    NOT_INITIALIZED = vtkInitialValueProblemSolver::NOT_INITIALIZED,
    UNEXPECTED_VALUE = vtkInitialValueProblemSolver::UNEXPECTED_VALUE,
    OUT_OF_TIME = 4,
    OUT_OF_STEPS = 5,
    STAGNATION = 6
  };
 
 
  void SetIntegrator(vtkInitialValueProblemSolver*);
  vtkGetObjectMacro(Integrator, vtkInitialValueProblemSolver);
  void SetIntegratorType(int type);
  int GetIntegratorType();
  void SetIntegratorTypeToRungeKutta2() { this->SetIntegratorType(RUNGE_KUTTA2); }
  void SetIntegratorTypeToRungeKutta4() { this->SetIntegratorType(RUNGE_KUTTA4); }
  void SetIntegratorTypeToRungeKutta45() { this->SetIntegratorType(RUNGE_KUTTA45); }
 
 
  void SetMaximumPropagation(int unit, double max);
  void SetMaximumPropagation(double max);
  void SetMaximumPropagationUnit(int unit);
  int GetMaximumPropagationUnit();
  double GetMaximumPropagation();
  void SetMaximumPropagationUnitToTimeUnit() { this->SetMaximumPropagationUnit(TIME_UNIT); }
  void SetMaximumPropagationUnitToLengthUnit() { this->SetMaximumPropagationUnit(LENGTH_UNIT); }
  void SetMaximumPropagationUnitToCellLengthUnit()
  {
    this->SetMaximumPropagationUnit(CELL_LENGTH_UNIT);
  }
 
 
  void SetMinimumIntegrationStep(int unit, double step);
  void SetMinimumIntegrationStepUnit(int unit);
  void SetMinimumIntegrationStep(double step);
  int GetMinimumIntegrationStepUnit();
  double GetMinimumIntegrationStep();
  void SetMinimumIntegrationStepUnitToTimeUnit() { this->SetMinimumIntegrationStepUnit(TIME_UNIT); }
  void SetMinimumIntegrationStepUnitToLengthUnit()
  {
    this->SetMinimumIntegrationStepUnit(LENGTH_UNIT);
  }
  void SetMinimumIntegrationStepUnitToCellLengthUnit()
  {
    this->SetMinimumIntegrationStepUnit(CELL_LENGTH_UNIT);
  }
 
 
  void SetMaximumIntegrationStep(int unit, double step);
  void SetMaximumIntegrationStepUnit(int unit);
  void SetMaximumIntegrationStep(double step);
  int GetMaximumIntegrationStepUnit();
  double GetMaximumIntegrationStep();
  void SetMaximumIntegrationStepUnitToTimeUnit() { this->SetMaximumIntegrationStepUnit(TIME_UNIT); }
  void SetMaximumIntegrationStepUnitToLengthUnit()
  {
    this->SetMaximumIntegrationStepUnit(LENGTH_UNIT);
  }
  void SetMaximumIntegrationStepUnitToCellLengthUnit()
  {
    this->SetMaximumIntegrationStepUnit(CELL_LENGTH_UNIT);
  }
 
 
  void SetInitialIntegrationStep(int unit, double step);
  void SetInitialIntegrationStepUnit(int unit);
  void SetInitialIntegrationStep(double step);
  int GetInitialIntegrationStepUnit();
  double GetInitialIntegrationStep();
  void SetInitialIntegrationStepUnitToTimeUnit() { this->SetInitialIntegrationStepUnit(TIME_UNIT); }
  void SetInitialIntegrationStepUnitToLengthUnit()
  {
    this->SetInitialIntegrationStepUnit(LENGTH_UNIT);
  }
  void SetInitialIntegrationStepUnitToCellLengthUnit()
  {
    this->SetInitialIntegrationStepUnit(CELL_LENGTH_UNIT);
  }
 
 
  vtkSetMacro(MaximumError, double);
  vtkGetMacro(MaximumError, double);
 
 
  vtkSetMacro(MaximumNumberOfSteps, vtkIdType);
  vtkGetMacro(MaximumNumberOfSteps, vtkIdType);
 
 
  vtkSetMacro(TerminalSpeed, double);
  vtkGetMacro(TerminalSpeed, double);
 
 
  void SetIntegrationStepUnit(int unit)
  {
    this->SetInitialIntegrationStepUnit(unit);
    this->SetMinimumIntegrationStepUnit(unit);
    this->SetMaximumIntegrationStepUnit(unit);
  }
 
  enum
  {
    FORWARD,
    BACKWARD,
    BOTH
  };
 
 
  vtkSetClampMacro(IntegrationDirection, int, FORWARD, BOTH);
  vtkGetMacro(IntegrationDirection, int);
  void SetIntegrationDirectionToForward() { this->SetIntegrationDirection(FORWARD); }
  void SetIntegrationDirectionToBackward() { this->SetIntegrationDirection(BACKWARD); }
  void SetIntegrationDirectionToBoth() { this->SetIntegrationDirection(BOTH); }
 
 
  vtkSetMacro(ComputeVorticity, vtkTypeBool);
  vtkGetMacro(ComputeVorticity, vtkTypeBool);
  vtkBooleanMacro(ComputeVorticity, vtkTypeBool);
 
 
  vtkSetMacro(RotationScale, double);
  vtkGetMacro(RotationScale, double);
 
 
  vtkGetStringMacro(InputVectorsSelection);
  void SelectInputVectors(const char* fieldName) { this->SetInputVectorsSelection(fieldName); }
 
  void AddInputData(vtkGenericDataSet* in);
 
  void SetInterpolatorPrototype(vtkGenericInterpolatedVelocityField* ivf);
 
protected:
  vtkGenericStreamTracer();
  ~vtkGenericStreamTracer() override;
 
  // hide the superclass' AddInput() from the user and the compiler
  void AddInput(vtkDataObject*)
  {
    vtkErrorMacro(<< "AddInput() must be called with a vtkGenericDataSet not a vtkDataObject.");
  }
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  void CalculateVorticity(vtkGenericAdaptorCell* cell, double pcoords[3],
    vtkGenericAttribute* attribute, double vorticity[3]);
 
  void Integrate(vtkGenericDataSet* input0, vtkPolyData* output, vtkDataArray* seedSource,
    vtkIdList* seedIds, vtkIntArray* integrationDirections, double lastPoint[3],
    vtkGenericInterpolatedVelocityField* func);
  void SimpleIntegrate(
    double seed[3], double lastPoint[3], double delt, vtkGenericInterpolatedVelocityField* func);
  int CheckInputs(vtkGenericInterpolatedVelocityField*& func, vtkInformationVector** inputVector);
  void GenerateNormals(vtkPolyData* output, double* firstNormal);
 
  int GenerateNormalsInIntegrate;
 
  vtkSetStringMacro(InputVectorsSelection);
  char* InputVectorsSelection;
 
  // starting from global x-y-z position
  double StartPosition[3];
 
  static const double EPSILON;
  double TerminalSpeed;
 
  double LastUsedTimeStep;
 
  struct IntervalInformation
  {
    double Interval;
    int Unit;
  };
 
  IntervalInformation MaximumPropagation;
  IntervalInformation MinimumIntegrationStep;
  IntervalInformation MaximumIntegrationStep;
  IntervalInformation InitialIntegrationStep;
 
  void SetIntervalInformation(int unit, double interval, IntervalInformation& currentValues);
  void SetIntervalInformation(int unit, IntervalInformation& currentValues);
  static double ConvertToTime(IntervalInformation& interval, double cellLength, double speed);
  static double ConvertToLength(IntervalInformation& interval, double cellLength, double speed);
  static double ConvertToCellLength(IntervalInformation& interval, double cellLength, double speed);
  static double ConvertToUnit(
    IntervalInformation& interval, int unit, double cellLength, double speed);
  void ConvertIntervals(
    double& step, double& minStep, double& maxStep, int direction, double cellLength, double speed);
 
  void InitializeSeeds(
    vtkDataArray*& seeds, vtkIdList*& seedIds, vtkIntArray*& integrationDirections);
 
  int IntegrationDirection;
 
  // Prototype showing the integrator type to be set by the user.
  vtkInitialValueProblemSolver* Integrator;
 
  double MaximumError;
  vtkIdType MaximumNumberOfSteps;
 
  vtkTypeBool ComputeVorticity;
  double RotationScale;
 
  vtkGenericInterpolatedVelocityField* InterpolatorPrototype;
 
private:
  vtkGenericStreamTracer(const vtkGenericStreamTracer&) = delete;
  void operator=(const vtkGenericStreamTracer&) = delete;
};
 
#endif