vtkLagrangianParticleTracker.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkLagrangianParticleTracker.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 vtkLagrangianParticleTracker_h
#define vtkLagrangianParticleTracker_h

#include "vtkFiltersFlowPathsModule.h" // For export macro
#include "vtkDataObjectAlgorithm.h"
#include "vtkBoundingBox.h" // For cached bounds

#include <queue> // for particle queue

class vtkBoundingBox;
class vtkCellArray;
class vtkDataSet;
class vtkDoubleArray;
class vtkIdList;
class vtkInformation;
class vtkInitialValueProblemSolver;
class vtkLagrangianBasicIntegrationModel;
class vtkLagrangianParticle;
class vtkPointData;
class vtkPoints;
class vtkPolyData;

class VTKFILTERSFLOWPATHS_EXPORT vtkLagrangianParticleTracker :
  public vtkDataObjectAlgorithm
{
public:

  vtkTypeMacro(vtkLagrangianParticleTracker, vtkDataObjectAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  static vtkLagrangianParticleTracker *New();

  typedef enum CellLengthComputation{
    STEP_LAST_CELL_LENGTH = 0,
    STEP_CUR_CELL_LENGTH = 1,
    STEP_LAST_CELL_VEL_DIR = 2,
    STEP_CUR_CELL_VEL_DIR = 3,
    STEP_LAST_CELL_DIV_THEO = 4,
    STEP_CUR_CELL_DIV_THEO = 5
  } CellLengthComputation;


  void SetIntegrationModel(vtkLagrangianBasicIntegrationModel* integrationModel);
  vtkGetObjectMacro(IntegrationModel, vtkLagrangianBasicIntegrationModel);


  void SetIntegrator(vtkInitialValueProblemSolver* integrator);
  vtkGetObjectMacro(Integrator, vtkInitialValueProblemSolver);


  vtkSetMacro(GeneratePolyVertexInteractionOutput, bool);
  vtkGetMacro(GeneratePolyVertexInteractionOutput, bool);


  vtkSetMacro(CellLengthComputationMode, int);
  vtkGetMacro(CellLengthComputationMode, int);


  vtkSetMacro(StepFactor, double);
  vtkGetMacro(StepFactor, double);


  vtkSetMacro(StepFactorMin, double);
  vtkGetMacro(StepFactorMin, double);


  vtkSetMacro(StepFactorMax, double);
  vtkGetMacro(StepFactorMax, double);


  vtkSetMacro(MaximumNumberOfSteps, int);
  vtkGetMacro(MaximumNumberOfSteps, int);


  vtkSetMacro(MaximumIntegrationTime, double);
  vtkGetMacro(MaximumIntegrationTime, double);


  vtkSetMacro(AdaptiveStepReintegration, bool);
  vtkGetMacro(AdaptiveStepReintegration, bool);
  vtkBooleanMacro(AdaptiveStepReintegration, bool);


  vtkSetMacro(UseParticlePathsRenderingThreshold, bool);
  vtkGetMacro(UseParticlePathsRenderingThreshold, bool);
  vtkBooleanMacro(UseParticlePathsRenderingThreshold, bool);


  vtkSetMacro(ParticlePathsRenderingPointsThreshold, int);
  vtkGetMacro(ParticlePathsRenderingPointsThreshold, int);


  void SetSourceData(vtkDataObject* source);
  vtkDataObject* GetSource();

  void SetSourceConnection(vtkAlgorithmOutput* algOutput);


  void SetSurfaceData(vtkDataObject *source);
  vtkDataObject *GetSurface();

  void SetSurfaceConnection(vtkAlgorithmOutput* algOutput);

  int FillInputPortInformation(int port, vtkInformation* info) override;

  int FillOutputPortInformation(int port, vtkInformation* info) override;

  int RequestDataObject(vtkInformation*,
    vtkInformationVector**,
    vtkInformationVector*) override;

  int RequestData(vtkInformation *request,
    vtkInformationVector **inputVector,
    vtkInformationVector *outputVector) override;

  vtkMTimeType GetMTime() override;

  virtual vtkIdType GetNewParticleId();

protected:
  vtkLagrangianParticleTracker();
  ~vtkLagrangianParticleTracker() override;

  virtual bool InitializeInputs(vtkInformationVector **inputVector,
    vtkDataObject*& flow, vtkDataObject*& seeds, vtkDataObject*& surfaces,
    std::queue<vtkLagrangianParticle*>& particleQueue, vtkPointData* seedData);
  virtual bool InitializeFlow(vtkDataObject* flow, vtkBoundingBox* bounds);
  virtual bool InitializeParticles(const vtkBoundingBox* bounds, vtkDataObject* seeds,
    std::queue<vtkLagrangianParticle*>& particles, vtkPointData* seedData);
  virtual void GenerateParticles(const vtkBoundingBox* bounds, vtkDataSet* seeds,
    vtkDataArray* initialVelocities, vtkDataArray* initialIntegrationTimes,
    vtkPointData* seedData, int nVar, std::queue<vtkLagrangianParticle*>& particles);
  virtual bool UpdateSurfaceCacheIfNeeded(vtkDataObject*& surfaces);
  virtual void InitializeSurface(vtkDataObject*& surfaces);
  virtual bool InitializeOutputs(vtkInformationVector *outputVector, vtkPointData* seedData,
    vtkIdType numberOfSeeds, vtkDataObject* surfaces,
    vtkPolyData*& particlePathsOutput, vtkDataObject*& interactionOutput);

  virtual bool InitializePathsOutput(vtkInformationVector *outputVector,
    vtkPointData* seedData, vtkIdType numberOfSeeds,
    vtkPolyData*& particlePathsOutput);

  virtual bool InitializeInteractionOutput(vtkInformationVector *outputVector,
    vtkPointData* seedData, vtkDataObject* surfaces, vtkDataObject*& interractionOutput);

  virtual void InitializeParticleData(vtkFieldData* particleData, int maxTuples = 0);
  virtual void InitializePathData(vtkFieldData* data);
  virtual void InitializeInteractionData(vtkFieldData* data);

  virtual bool FinalizeOutputs(vtkPolyData* particlePathsOutput,
    vtkDataObject* interractionOutput);

  static void InsertPolyVertexCell(vtkPolyData* polydata);
  static void InsertVertexCells(vtkPolyData* polydata);

  virtual void GetParticleFeed(std::queue<vtkLagrangianParticle*>& particleQueue);

  virtual int Integrate(vtkLagrangianParticle*, std::queue<vtkLagrangianParticle*>&,
    vtkPolyData* particlePathsOutput, vtkIdList* particlePathPointId,
    vtkDataObject* interactionOutput);

  void InsertPathOutputPoint(vtkLagrangianParticle* particle,
    vtkPolyData* particlePathsOutput, vtkIdList* particlePathPointId,
    bool prev = false);

  void InsertInteractionOutputPoint(vtkLagrangianParticle* particle,
    unsigned int interactedSurfaceFlatIndex, vtkDataObject* interactionOutput);

  void InsertSeedData(vtkLagrangianParticle* particle, vtkFieldData* data);
  void InsertPathData(vtkLagrangianParticle* particle, vtkFieldData* data);
  void InsertInteractionData(vtkLagrangianParticle* particle, vtkFieldData* data);
  void InsertParticleData(vtkLagrangianParticle* particle, vtkFieldData* data, int stepEnum);

  double ComputeCellLength(vtkLagrangianParticle* particle);

  bool ComputeNextStep(
    double* xprev, double* xnext,
    double t, double& delT, double& delTActual,
    double minStep, double maxStep,
    int& integrationRes);

  virtual bool CheckParticlePathsRenderingThreshold(vtkPolyData* particlePathsOutput);

  vtkLagrangianBasicIntegrationModel* IntegrationModel;
  vtkInitialValueProblemSolver* Integrator;

  int CellLengthComputationMode;
  double StepFactor;
  double StepFactorMin;
  double StepFactorMax;
  int MaximumNumberOfSteps;
  double MaximumIntegrationTime;
  bool AdaptiveStepReintegration;
  bool UseParticlePathsRenderingThreshold;
  bool GeneratePolyVertexInteractionOutput;
  int ParticlePathsRenderingPointsThreshold;
  vtkIdType ParticleCounter;

  // internal parameters use for step computation
  double MinimumVelocityMagnitude;
  double MinimumReductionFactor;

  // Cache related parameters
  vtkDataObject* FlowCache;
  vtkMTimeType FlowTime;
  vtkBoundingBox FlowBoundsCache;
  vtkDataObject* SurfacesCache;
  vtkMTimeType SurfacesTime;

private:
  vtkLagrangianParticleTracker(const vtkLagrangianParticleTracker&) = delete;
  void operator=(const vtkLagrangianParticleTracker&) = delete;
};

#endif