vtkDGOperation.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 vtkDGOperation_h
#define vtkDGOperation_h

#include "vtkCompiler.h"              // For VTK_ALWAYS_EXPORT.
#include "vtkDGCell.h"                // For vtkDGCell::Source used in API.
#include "vtkDGOperationStateEntry.h" // For API.
#include "vtkSMPThreadLocal.h"        // For API.

VTK_ABI_NAMESPACE_BEGIN

class vtkDoubleArray;

class VTKFILTERSCELLGRID_EXPORT vtkDGOperationBase
{
public:
  struct VTKFILTERSCELLGRID_EXPORT RangeKey
  {
    vtkTypeUInt64 Begin;
    vtkTypeUInt64 End;
    bool Contains(vtkTypeUInt64 cellId) const;
    bool ContainedBy(const RangeKey& other) const;
    bool operator<(const RangeKey& other) const;
  };
};

template <typename InputIterator, typename OutputIterator>
class VTK_ALWAYS_EXPORT vtkDGOperation : public vtkDGOperationBase
{
public:
  using SelfType = vtkDGOperation<InputIterator, OutputIterator>;
  using OpEval = vtkDGCellRangeEvaluator<InputIterator, OutputIterator>;
  using OpEvalEntry = vtkDGOperationStateEntry<InputIterator, OutputIterator>;
  using vtkDGOperationBase::RangeKey;
  using EvaluatorMap = std::map<RangeKey, OpEvalEntry>;

  vtkDGOperation() = default;
  vtkDGOperation(const SelfType& other);
  vtkDGOperation(
    vtkDGCell* cellType, vtkCellAttribute* cellAttribute, vtkStringToken operationName);

  void PrintSelf(std::ostream& os, vtkIndent indent);

  bool Prepare(vtkDGCell* cellType, vtkCellAttribute* cellAttribute, vtkStringToken operationName,
    bool includeShape = true);

  bool Evaluate(InputIterator& inIter, OutputIterator& outIter, vtkTypeUInt64 begin = 0,
    vtkTypeUInt64 end = ~0);

  OpEval GetEvaluatorForSideSpec(vtkDGCell* cell, int sideSpecId);

  int GetNumberOfResultComponents() const { return this->NumberOfResultComponents; }

  struct VTK_ALWAYS_EXPORT Worker
  {
    InputIterator& InIter;
    OutputIterator& OutIter;
    vtkDGCell* DGCell{ nullptr };
    vtkCellAttribute* CellAtt{ nullptr };
    vtkStringToken OpName;

    Worker(InputIterator& inIter, OutputIterator& outIter, vtkDGCell* dgCell,
      vtkCellAttribute* cellAtt, vtkStringToken opName)
      : InIter(inIter)
      , OutIter(outIter)
      , DGCell(dgCell)
      , CellAtt(cellAtt)
      , OpName(opName)
    {
    }

    vtkSMPThreadLocal<vtkDGOperation<InputIterator, OutputIterator>> TLOp;

    void Initialize()
    {
      if (!TLOp.Local().Prepare(this->DGCell, this->CellAtt, this->OpName))
      {
        throw std::runtime_error("Could not initialize operation for evaluation.");
      }
    }

    void operator()(vtkIdType begin, vtkIdType end)
    {
      TLOp.Local()(this->InIter, this->OutIter, begin, end);
    }
  };

protected:
  void AddSource(vtkCellGrid* grid, vtkDGCell* cellType, std::size_t sideSpecIdx,
    vtkCellAttribute* cellAtt, const vtkCellAttribute::CellTypeInfo& cellTypeInfo,
    vtkDGOperatorEntry& op, bool includeShape);

  typename EvaluatorMap::const_iterator FindEvaluator(
    RangeKey cellKey, const EvaluatorMap& evaluators);

  int NumberOfResultComponents{ 0 };
  EvaluatorMap Evaluators;
};

VTK_ABI_NAMESPACE_END
#endif // vtkDGOperation_h
// VTK-HeaderTest-Exclude: vtkDGOperation.h