vtkLagrangianParticle.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#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>
 
VTK_ABI_NAMESPACE_BEGIN
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,
    PARTICLE_TERMINATION_TRANSFERRED,
    PARTICLE_TERMINATION_ABORTED
  } 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 numberOfTrackedUserData);
 
  static vtkLagrangianParticle* NewInstance(int numberOfVariables, vtkIdType seedId,
    vtkIdType particleId, vtkIdType seedArrayTupleIndex, double integrationTime,
    vtkPointData* seedData, int numberOfTrackedUserData, vtkIdType numberOfSteps = 0,
    double previousIntegrationTime = 0);
 
  vtkLagrangianParticle* NewParticle(vtkIdType particleId);
 
  vtkLagrangianParticle* CloneParticle();
 
  virtual ~vtkLagrangianParticle();
 
 
  double* GetPrevEquationVariables() { return this->PrevEquationVariables.data(); }
 
 
  double* GetEquationVariables() { return this->EquationVariables.data(); }
 
 
  double* GetNextEquationVariables() { return this->NextEquationVariables.data(); }
 
 
  double* GetPrevPosition() { return this->PrevEquationVariables.data(); }
 
 
  double* GetPosition() { return this->EquationVariables.data(); }
 
 
  double* GetNextPosition() { return this->NextEquationVariables.data(); }
 
 
  double* GetPrevVelocity() { return this->PrevVelocity; }
 
 
  double* GetVelocity() { return this->Velocity; }
 
 
  double* GetNextVelocity() { return this->NextVelocity; }
 
 
  double* GetPrevUserVariables() { return this->PrevUserVariables; }
 
 
  double* GetUserVariables() { return this->UserVariables; }
 
 
  double* GetNextUserVariables() { return this->NextUserVariables; }
 
 
  std::vector<double>& GetPrevTrackedUserData() { return this->PrevTrackedUserData; }
 
 
  std::vector<double>& GetTrackedUserData() { return this->TrackedUserData; }
 
 
  std::vector<double>& GetNextTrackedUserData() { return this->NextTrackedUserData; }
 
 
  vtkLagrangianThreadedData* GetThreadedData() { return this->ThreadedData; }
  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;
 
  vtkIdType GetLastSurfaceCellId();
 
  vtkDataSet* GetLastSurfaceDataSet();
 
  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;
 
  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;
};
 
VTK_ABI_NAMESPACE_END
#endif
// VTK-HeaderTest-Exclude: vtkLagrangianParticle.h