vtkLagrangianParticle.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkLagrangianParticle.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 vtkLagrangianParticle_h
#define vtkLagrangianParticle_h
 
#include "vtkFiltersFlowPathsModule.h" // For export macro
#include "vtkNew.h"                    // For vtkNew
#include "vtkSystemIncludes.h"         // For PrintSelf signature and vtkType
 
#include <vector>
 
class vtkAbstractCellLocator;
class vtkBilinearQuadIntersection;
class vtkDataSet;
class vtkGenericCell;
class vtkIdList;
class vtkPointData;
struct vtkLagrangianThreadedData;
 
class VTKFILTERSFLOWPATHS_EXPORT vtkLagrangianParticle
{
public:
  typedef enum ParticleTermination
  {
    PARTICLE_TERMINATION_NOT_TERMINATED = 0,
    PARTICLE_TERMINATION_SURF_TERMINATED,
    PARTICLE_TERMINATION_FLIGHT_TERMINATED,
    PARTICLE_TERMINATION_SURF_BREAK,
    PARTICLE_TERMINATION_OUT_OF_DOMAIN,
    PARTICLE_TERMINATION_OUT_OF_STEPS,
    PARTICLE_TERMINATION_OUT_OF_TIME
  } ParticleTermination;
 
  typedef enum SurfaceInteraction
  {
    SURFACE_INTERACTION_NO_INTERACTION = 0,
    SURFACE_INTERACTION_TERMINATED,
    SURFACE_INTERACTION_BREAK,
    SURFACE_INTERACTION_BOUNCE,
    SURFACE_INTERACTION_PASS,
    SURFACE_INTERACTION_OTHER
  } SurfaceInteraction;
 
  vtkLagrangianParticle(int numberOfVariables, vtkIdType seedId, vtkIdType particleId,
    vtkIdType seedArrayTupleIndex, double integrationTime, vtkPointData* seedData, int weightsSize,
    int numberOfTrackedUserData);
 
  static vtkLagrangianParticle* NewInstance(int numberOfVariables, vtkIdType seedId,
    vtkIdType particleId, vtkIdType seedArrayTupleIndex, double integrationTime,
    vtkPointData* seedData, int weightsSize, int numberOfTrackedUserData,
    vtkIdType numberOfSteps = 0, double previousIntegrationTime = 0);
 
  vtkLagrangianParticle* NewParticle(vtkIdType particleId);
 
  vtkLagrangianParticle* CloneParticle();
 
  virtual ~vtkLagrangianParticle();
 
 
  inline double* GetPrevEquationVariables() { return this->PrevEquationVariables.data(); }
 
 
  inline double* GetEquationVariables() { return this->EquationVariables.data(); }
 
 
  inline double* GetNextEquationVariables() { return this->NextEquationVariables.data(); }
 
 
  inline double* GetPrevPosition() { return this->PrevEquationVariables.data(); }
 
 
  inline double* GetPosition() { return this->EquationVariables.data(); }
 
 
  inline double* GetNextPosition() { return this->NextEquationVariables.data(); }
 
 
  inline double* GetPrevVelocity() { return this->PrevVelocity; }
 
 
  inline double* GetVelocity() { return this->Velocity; }
 
 
  inline double* GetNextVelocity() { return this->NextVelocity; }
 
 
  inline double* GetPrevUserVariables() { return this->PrevUserVariables; }
 
 
  inline double* GetUserVariables() { return this->UserVariables; }
 
 
  inline double* GetNextUserVariables() { return this->NextUserVariables; }
 
 
  inline std::vector<double>& GetPrevTrackedUserData() { return this->PrevTrackedUserData; }
 
 
  inline std::vector<double>& GetTrackedUserData() { return this->TrackedUserData; }
 
 
  inline std::vector<double>& GetNextTrackedUserData() { return this->NextTrackedUserData; }
 
 
  inline vtkLagrangianThreadedData* GetThreadedData() { return this->ThreadedData; }
  inline void SetThreadedData(vtkLagrangianThreadedData* threadedData)
  {
    this->ThreadedData = threadedData;
  }
 
  virtual void MoveToNextPosition();
 
  virtual vtkIdType GetId();
 
 
  virtual void SetParentId(vtkIdType parentId);
  virtual vtkIdType GetParentId();
 
  virtual vtkIdType GetSeedId();
 
  virtual int GetNumberOfVariables();
 
  virtual int GetNumberOfUserVariables();
 
  virtual vtkPointData* GetSeedData();
 
  virtual vtkIdType GetSeedArrayTupleIndex() const;
 
  double* GetLastWeights();
 
  vtkIdType GetLastCellId();
 
  double* GetLastCellPosition();
 
  vtkDataSet* GetLastDataSet();
 
  vtkAbstractCellLocator* GetLastLocator();
 
  vtkIdType GetLastSurfaceCellId();
 
  vtkDataSet* GetLastSurfaceDataSet();
 
  void SetLastCell(vtkAbstractCellLocator* locator, vtkDataSet* dataset, vtkIdType cellId,
    double lastCellPosition[3]);
 
  void SetLastSurfaceCell(vtkDataSet* dataset, vtkIdType cellId);
 
  virtual vtkIdType GetNumberOfSteps();
 
 
  virtual void SetTermination(int termination);
  virtual int GetTermination();
 
 
  virtual void SetInteraction(int interaction);
  virtual int GetInteraction();
 
 
  virtual void SetUserFlag(int flag);
  virtual int GetUserFlag();
 
 
  virtual void SetPInsertPreviousPosition(bool val);
  virtual bool GetPInsertPreviousPosition();
 
 
  virtual void SetPManualShift(bool val);
  virtual bool GetPManualShift();
 
  virtual double& GetStepTimeRef();
 
  virtual double GetIntegrationTime();
 
  virtual double GetPrevIntegrationTime();
 
  virtual void SetIntegrationTime(double time);
 
  double GetPositionVectorMagnitude();
 
  virtual void PrintSelf(ostream& os, vtkIndent indent);
 
protected:
  vtkLagrangianParticle(const vtkLagrangianParticle&) = delete;
  vtkLagrangianParticle() = delete;
  void operator=(const vtkLagrangianParticle&) = delete;
 
  std::vector<double> PrevEquationVariables;
  double* PrevVelocity;
  double* PrevUserVariables;
 
  std::vector<double> EquationVariables;
  double* Velocity;
  double* UserVariables;
 
  std::vector<double> NextEquationVariables;
  double* NextVelocity;
  double* NextUserVariables;
 
  std::vector<double> PrevTrackedUserData;
  std::vector<double> TrackedUserData;
  std::vector<double> NextTrackedUserData;
 
  vtkLagrangianThreadedData* ThreadedData = nullptr;
 
  vtkIdType Id;
  vtkIdType ParentId;
  vtkIdType SeedId;
  vtkIdType NumberOfSteps;
  vtkIdType SeedArrayTupleIndex;
  vtkPointData* SeedData;
 
  vtkAbstractCellLocator* LastLocator;
  vtkDataSet* LastDataSet;
  vtkIdType LastCellId;
  double LastCellPosition[3];
  int WeightsSize;
  std::vector<double> LastWeights;
 
  double StepTime;
  double IntegrationTime;
  double PrevIntegrationTime;
  int Termination;
  int Interaction;
  int UserFlag;
  vtkDataSet* LastSurfaceDataSet;
  vtkIdType LastSurfaceCellId;
  int NumberOfVariables;
 
  // Parallel related flags
  bool PInsertPreviousPosition;
  bool PManualShift;
};
 
#endif
// VTK-HeaderTest-Exclude: vtkLagrangianParticle.h