vtkDGInterpolateCalculator.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 vtkDGInterpolateCalculator_h
#define vtkDGInterpolateCalculator_h
 
#include "vtkCellAttribute.h"         // For CellTypeInfo.
#include "vtkDGArrayOutputAccessor.h" // For ivars.
#include "vtkDGArraysInputAccessor.h" // For ivars.
#include "vtkDGCell.h"                // For ivar.
#include "vtkDGOperation.h"           // For ivars.
#include "vtkInterpolateCalculator.h"
#include "vtkSMPThreadLocal.h" // For thread-local data
#include "vtkSmartPointer.h"   // For ivar.
#include "vtkStringToken.h"    // For ivar.
 
VTK_ABI_NAMESPACE_BEGIN
 
class vtkCellAttribute;
class vtkDGRangeResponder;
class vtkDoubleArray;
class vtkDataArray;
class vtkIdTypeArray;
class vtkTypeInt64Array;

class VTKFILTERSCELLGRID_EXPORT vtkDGInterpolateCalculator : public vtkInterpolateCalculator
{
public:
  static vtkDGInterpolateCalculator* New();
  vtkTypeMacro(vtkDGInterpolateCalculator, vtkInterpolateCalculator);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void Evaluate(vtkIdType cellId, const vtkVector3d& rst, std::vector<double>& value) override;
  void Evaluate(vtkIdTypeArray* cellIds, vtkDataArray* rst, vtkDataArray* result,
    bool useMultithreading = false) override;
 
  bool AnalyticDerivative() const override;
  void EvaluateDerivative(vtkIdType cellId, const vtkVector3d& rst, std::vector<double>& jacobian,
    double neighborhood) override;
  void EvaluateDerivative(vtkIdTypeArray* cellIds, vtkDataArray* rst, vtkDataArray* result,
    bool useMultithreading = false) override;
 
  vtkSmartPointer<vtkCellAttributeCalculator> PrepareForGrid(
    vtkCellMetadata* cell, vtkCellAttribute* field) override;
 
protected:
  friend class vtkDGRangeResponder;
  vtkDGInterpolateCalculator() = default;
  ~vtkDGInterpolateCalculator() override = default;
 
  template <bool UseShape>
  void InternalDerivative(
    vtkIdType cellId, const vtkVector3d& rst, std::vector<double>& jacobian, double neighborhood);

  vtkDGCell* CellType{ nullptr };
  vtkCellAttribute* Field{ nullptr };
 
  struct ThreadLocalData
  {
    vtkSmartPointer<vtkDoubleArray> Result;
    vtkSmartPointer<vtkDoubleArray> VRst;
    vtkSmartPointer<vtkIdTypeArray> Ids;
 
    vtkSmartPointer<vtkDoubleArray> DerResult;
    vtkSmartPointer<vtkDoubleArray> DerVRst;
    vtkSmartPointer<vtkIdTypeArray> DerIds;

    vtkSmartPointer<vtkDoubleArray> LocalField;

    vtkDGOperation<vtkDGArraysInputAccessor, vtkDGArrayOutputAccessor> FieldEvaluator;
    vtkDGOperation<vtkDGArraysInputAccessor, vtkDGArrayOutputAccessor> FieldDerivative;
 
    vtkDGArraysInputAccessor InAccessor;
    vtkDGArrayOutputAccessor OutAccessor;
    vtkDGArraysInputAccessor DerInAccessor;
    vtkDGArrayOutputAccessor DerOutAccessor;
 
    bool Initialized{ false };
 
    ThreadLocalData();
    ThreadLocalData(const ThreadLocalData& other);
    void Swap(ThreadLocalData& other);
    ThreadLocalData& operator=(ThreadLocalData other);
 
    void EnsureInitialized(vtkDGCell* cellType, vtkCellAttribute* field);
  };
 
  vtkSMPThreadLocal<ThreadLocalData> LocalData;

  int Dimension{ 3 };
  vtkDGCell::Shape CellShape{ vtkDGCell::Shape::None };

  vtkCellAttribute::CellTypeInfo FieldCellInfo;
 
private:
  vtkDGInterpolateCalculator(const vtkDGInterpolateCalculator&) = delete;
  void operator=(const vtkDGInterpolateCalculator&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif // vtkDGInterpolateCalculator_h