vtkTemporalInterpolatedVelocityField.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 vtkTemporalInterpolatedVelocityField_h
#define vtkTemporalInterpolatedVelocityField_h
 
#include "vtkFiltersFlowPathsModule.h" // For export macro
#include "vtkFunctionSet.h"
#include "vtkSmartPointer.h" // For vtkSmartPointer
 
#include <vector> // For internal structures
 
VTK_ABI_NAMESPACE_BEGIN
class vtkAbstractCellLinks;
class vtkCompositeDataSet;
class vtkCompositeInterpolatedVelocityField;
class vtkDataArray;
class vtkDataSet;
class vtkDoubleArray;
class vtkFindCellStrategy;
class vtkGenericCell;
class vtkLocator;
class vtkPointData;
 
class VTKFILTERSFLOWPATHS_EXPORT vtkTemporalInterpolatedVelocityField : public vtkFunctionSet
{
public:
  vtkTypeMacro(vtkTemporalInterpolatedVelocityField, vtkFunctionSet);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkTemporalInterpolatedVelocityField* New();
 
  enum IDStates
  {
    INSIDE_ALL = 0,
    OUTSIDE_ALL = 1,
    OUTSIDE_T0 = 2,
    OUTSIDE_T1 = 3
  };
 
  enum MeshOverTimeTypes
  {
    DIFFERENT = 0,
    STATIC = 1,
    LINEAR_TRANSFORMATION = 2,
    SAME_TOPOLOGY = 3
  };
 
  /*
   * Set/Get the type of variance of the mesh over time.
   *
   * DIFFERENT = 0,
   * STATIC = 1,
   * LINEAR_TRANSFORMATION = 2
   * SAME_TOPOLOGY = 3
   */
  vtkSetClampMacro(MeshOverTime, int, DIFFERENT, SAME_TOPOLOGY);
  void SetMeshOverTimeToDifferent() { this->SetMeshOverTime(DIFFERENT); }
  void SetMeshOverTimeToStatic() { this->SetMeshOverTime(STATIC); }
  void SetMeshOverTimeToLinearTransformation() { this->SetMeshOverTime(LINEAR_TRANSFORMATION); }
  void SetMeshOverTimeToSameTopology() { this->SetMeshOverTime(SAME_TOPOLOGY); }
  vtkGetMacro(MeshOverTime, int);
 
  void Initialize(vtkCompositeDataSet* t0, vtkCompositeDataSet* t1);
 
  virtual void CopyParameters(vtkTemporalInterpolatedVelocityField* from);
 
  using Superclass::FunctionValues;
 
  int FunctionValues(double* x, double* u) override;
  int FunctionValuesAtT(int T, double* x, double* u);
 
  void SelectVectors(const char* fieldName) { this->SetVectorsSelection(fieldName); }
 
 
  void AddDataSetAtTime(int N, double T, vtkDataSet* dataset);
 
 
  bool GetCachedCellIds(vtkIdType id[2], int ds[2]);
  void SetCachedCellIds(vtkIdType id[2], int ds[2]);
 
  void ClearCache();
 
 
  int TestPoint(double* x);
  int QuickTestPoint(double* x);
 
 
  vtkGetVector3Macro(LastGoodVelocity, double);
 
 
  vtkGetMacro(CurrentWeight, double);
 
  bool InterpolatePoint(vtkPointData* outPD1, vtkPointData* outPD2, vtkIdType outIndex);
 
  bool InterpolatePoint(int T, vtkPointData* outPD1, vtkIdType outIndex);
 
  bool GetVorticityData(
    int T, double pcoords[3], double* weights, vtkGenericCell*& cell, vtkDoubleArray* cellVectors);
 
  void ShowCacheResults();
 
  void AdvanceOneTimeStep();
 
 
  virtual void SetFindCellStrategy(vtkFindCellStrategy*);
  vtkGetObjectMacro(FindCellStrategy, vtkFindCellStrategy);
 
protected:
  vtkTemporalInterpolatedVelocityField();
  ~vtkTemporalInterpolatedVelocityField() override;
 
  virtual void SetVectorsSelection(const char* v);
 
  int MeshOverTime = MeshOverTimeTypes::DIFFERENT;
 
  void InitializeWithLocators(vtkCompositeInterpolatedVelocityField* ivf,
    const std::vector<vtkDataSet*>& datasets, vtkFindCellStrategy* strategy,
    const std::vector<vtkSmartPointer<vtkLocator>>& locators,
    const std::vector<vtkSmartPointer<vtkAbstractCellLinks>>& links);
 
  void CreateLocators(const std::vector<vtkDataSet*>& datasets, vtkFindCellStrategy* strategy,
    std::vector<vtkSmartPointer<vtkLocator>>& locators);
  void CreateLinks(const std::vector<vtkDataSet*>& datasets,
    std::vector<vtkSmartPointer<vtkAbstractCellLinks>>& links);
  void CreateLinearTransformCellLocators(const std::vector<vtkSmartPointer<vtkLocator>>& locators,
    std::vector<vtkSmartPointer<vtkLocator>>& linearCellLocators);
 
  double Vals1[3];
  double Vals2[3];
  double Times[2];
  double LastGoodVelocity[3];
 
  static const double WEIGHT_TO_TOLERANCE;
 
  // The weight (0.0->1.0) of the value of T between the two available
  // time values for the current computation
  double CurrentWeight;
  // One minus the CurrentWeight
  double OneMinusWeight;
  // A scaling factor used when calculating the CurrentWeight { 1.0/(T2-T1) }
  double ScaleCoeff;
 
  vtkSmartPointer<vtkCompositeInterpolatedVelocityField> IVF[2];
  std::vector<vtkSmartPointer<vtkLocator>> Locators[2];
  std::vector<vtkSmartPointer<vtkLocator>> InitialCellLocators;
  std::vector<vtkSmartPointer<vtkAbstractCellLinks>> Links[2];
  std::vector<size_t> MaxCellSizes[2];
 
  vtkFindCellStrategy* FindCellStrategy;
 
private:
  // Hide this since we need multiple time steps and are using a different
  // function prototype
  virtual void AddDataSet(vtkDataSet*) {}
 
  vtkTemporalInterpolatedVelocityField(const vtkTemporalInterpolatedVelocityField&) = delete;
  void operator=(const vtkTemporalInterpolatedVelocityField&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif