Method ProcessComposite

Filters/ParallelMPI/vtkHyperTreeGridRedistribute.cxx:233–304

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

//------------------------------------------------------------------------------
int vtkHyperTreeGridRedistribute::ProcessComposite(vtkDataObject* input, vtkDataObject* output)
{
  auto inPds = vtkPartitionedDataSet::SafeDownCast(input);
  auto inHTG = vtkHyperTreeGrid::SafeDownCast(input);
  auto inComposite = vtkCompositeDataSet::SafeDownCast(input);
  auto outComposite = vtkCompositeDataSet::SafeDownCast(output);

  int result = 1;
  if (inPds || inHTG)
  {
    result |= this->ProcessBlock(input, output);
  }
  else if (inComposite && outComposite)
  {
    outComposite->CopyStructure(inComposite);

    auto outputRange = vtk::Range(outComposite, vtk::CompositeDataSetOptions::None);
    auto inputRange = vtk::Range(inComposite, vtk::CompositeDataSetOptions::None);
    for (auto inIt = inputRange.begin(), outIt = outputRange.begin(); inIt != inputRange.end();
         ++inIt, ++outIt)
    {
      // Make sure type is shared among ranks.
      // Some ranks may not have a non-null dataset, so they don't know what type to instantiate
      constexpr int INVALID_TYPE = -1;
      int typeOut = INVALID_TYPE;
      int typeIn = *inIt ? inIt->GetDataObjectType() : INVALID_TYPE;
      this->Controller->AllReduce(&typeIn, &typeOut, 1, vtkCommunicator::MAX_OP);

      if (typeOut == INVALID_TYPE)
      {
        *outIt = nullptr;
        continue;
      }
      if (!*inIt)
      {
        *inIt = vtkSmartPointer<vtkDataObject>::Take(vtkDataObjectTypes::NewDataObject(typeOut));
      }

      *outIt = vtkSmartPointer<vtkDataObject>::Take(inIt->NewInstance());

      auto inputComposite = vtkCompositeDataSet::SafeDownCast(*inIt);
      auto outputComposite = vtkCompositeDataSet::SafeDownCast(*outIt);

      bool isComposite = inputComposite != nullptr;
      bool isPDS = inIt->GetDataObjectType() == VTK_PARTITIONED_DATA_SET;

      if (isComposite && !isPDS)
      {
        if (!outputComposite)
        {
          vtkErrorMacro(<< "Found no composite output data object");
          result = 0;
          continue;
        }
        // Composite but not PartitionedDS: recurse over the composite structure
        result |= this->ProcessComposite(inputComposite, outputComposite);
      }
      else