Method RequestData

Filters/Sources/vtkPartitionedDataSetSource.cxx:203–278

----------------------------------------------------------------------------

//----------------------------------------------------------------------------
int vtkPartitionedDataSetSource::RequestData(
  vtkInformation*, vtkInformationVector**, vtkInformationVector* outputVector)
{
  // We must meet these preconditions to continue this method
  if (!this->GetParametricFunction())
  {
    vtkLogF(WARNING, "RequestData aborted since ParametricFunction is missing");
    return 1;
  }

  if (!this->RanksEnabledByDefault && this->Allocations.empty())
  {
    return 1;
  }

  auto outInfo = outputVector->GetInformationObject(0);
  auto pds = vtkPartitionedDataSet::GetData(outInfo);
  const int rank = outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER());
  const int numRanks = outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES());

  auto* function = this->GetParametricFunction();
  function->JoinVOff();
  function->JoinUOff();

  vtkNew<vtkParametricFunctionSource> source;
  source->SetOutputPointsPrecision(vtkAlgorithm::DOUBLE_PRECISION);
  source->SetParametricFunction(function);
  source->SetScalarModeToV();

  // We set our default policy here
  auto defaultAlloc = (this->RanksEnabledByDefault) ? NUM_PARTITIONS::MULTIPLE_PARTITIONS
                                                    : NUM_PARTITIONS::NO_PARTITIONS;

  std::vector<int> allocs(numRanks, defaultAlloc);
  for (auto& kv : this->Allocations)
  {
    if (kv.first < static_cast<int>(allocs.size()))
    {
      allocs[kv.first] = kv.second;
    }
  }

  const int numberOfPartitions = (this->NumberOfPartitions > 0)
    ? this->NumberOfPartitions
    : std::count(allocs.begin(), allocs.end(), NUM_PARTITIONS::MULTIPLE_PARTITIONS);

  if (numberOfPartitions <= 0)
  {
    return 1;
  }

  const auto partsPerRank = ::GenerateAllocations(allocs, numberOfPartitions);
  const auto range = ::GetRange(rank, partsPerRank);

  const double deltaV = function->GetMaximumV() / numberOfPartitions;
  for (int idx = 0, partition = range.first; partition < range.second; ++partition, ++idx)
  {
    function->SetMinimumV(partition * deltaV);