Commit d575a70b authored by Utkarsh Ayachit's avatar Utkarsh Ayachit Committed by Kitware Robot

Merge topic 'mpi-parallel-plot3d'

07869098 Win64 fixes for vtkMultiBlockPLOT3DReader.
9c1667f6 Do not override DATA_NUMBER_OF_GHOST_LEVELS() unnecesarily.
0027efa6 Do not rexecute based on ghosts for serial execution
1c0cfb9a Improved ghost array generation.
44c7f0b8 Cleaning python testing macros.
695b4817 Adding a basic test to test vtkMPIMultiBlockPLOT3DReader.
bc18ac79 Add vtkMPIMultiBlockPLOT3DReader -- MPI-IO enabled reader for Plot3D.
d3dee7d6 Make vtkMultiBlockPLOT3DReader factory overridable.
...
Acked-by: Kitware Robot's avatarKitware Robot <kwrobot@kitware.com>
Reviewed-by: Berk Geveci's avatarBerk Geveci <berk.geveci@kitware.com>
Merge-request: !428
parents 56155d23 07869098
......@@ -370,9 +370,14 @@ endfunction()
# The 'vtk_test_prefix' variable may be set to create separate tests from a
# single test name (e.g., running with different arguments), but should be
# used only when required.
#
# Before calling this function, you can define VTK_PYTHON_EXE to point the
# executable (or generator expression for the executable) to run for the test.
# If VTK_PYTHON_EXE is not defined, `vtkpython` is assumed i.e.
# ($<TARGET_FILE:vtkpython>)
function(vtk_add_test_python)
if(NOT VTK_PYTHON_EXE)
message(FATAL_ERROR "VTK_PYTHON_EXE not set")
if (NOT DEFINED VTK_PYTHON_EXE)
set(VTK_PYTHON_EXE "\$<TARGET_FILE:vtkpython>")
endif()
set(python_options
NO_DATA
......@@ -447,6 +452,10 @@ function(vtk_add_test_python)
endforeach()
endfunction()
# Before calling this function, you can define VTK_PYTHON_EXE to point the
# executable (or generator expression for the executable) to run for the test.
# If VTK_PYTHON_EXE is not defined, `vtkpython` is assumed i.e.
# ($<TARGET_FILE:pvtkpython>)
function(vtk_add_test_python_mpi)
set(_vtk_test_python_suffix "-MPI")
......@@ -460,6 +469,9 @@ function(vtk_add_test_python_mpi)
${VTK_MPI_PRENUMPROC_FLAGS} ${VTK_MPI_NUMPROC_FLAG} ${numprocs}
${VTK_MPI_PREFLAGS})
if (NOT DEFINED VTK_PYTHON_EXE)
set(VTK_PYTHON_EXE "\$<TARGET_FILE:pvtkpython>")
endif()
vtk_add_test_python(${ARGN})
endfunction()
......
......@@ -476,7 +476,6 @@ endif()
if(VTK_WRAP_PYTHON)
set(VTK_WRAP_PYTHON_EXE vtkWrapPython)
set(VTK_WRAP_PYTHON_INIT_EXE vtkWrapPythonInit)
set(VTK_PYTHON_EXE vtkpython)
# Force the WrappingPythonCore module to on if wrapping is on
set(Module_vtkWrappingPythonCore ON CACHE BOOL "Core Python wrapping library"
FORCE)
......
......@@ -245,11 +245,11 @@ VTK_BYTE_SWAP_IMPL(unsigned char)
VTK_BYTE_SWAP_IMPL(unsigned short)
VTK_BYTE_SWAP_IMPL(unsigned int)
VTK_BYTE_SWAP_IMPL(unsigned long)
#if defined(VTK_IMPL_USE_LONG_LONG)
#if defined(VTK_TYPE_USE_LONG_LONG)
VTK_BYTE_SWAP_IMPL(long long)
VTK_BYTE_SWAP_IMPL(unsigned long long)
#endif
#if defined(VTK_IMPL_USE___INT64)
#if defined(VTK_TYPE_USE___INT64)
VTK_BYTE_SWAP_IMPL(__int64)
VTK_BYTE_SWAP_IMPL(unsigned __int64)
#endif
......
......@@ -54,11 +54,11 @@ public:
VTK_BYTE_SWAP_DECL(unsigned short);
VTK_BYTE_SWAP_DECL(unsigned int);
VTK_BYTE_SWAP_DECL(unsigned long);
#if defined(VTK_DECL_USE_LONG_LONG)
#if defined(VTK_TYPE_USE_LONG_LONG)
VTK_BYTE_SWAP_DECL(long long);
VTK_BYTE_SWAP_DECL(unsigned long long);
#endif
#if defined(VTK_DECL_USE___INT64)
#if defined(VTK_TYPE_USE___INT64)
VTK_BYTE_SWAP_DECL(__int64);
VTK_BYTE_SWAP_DECL(unsigned __int64);
#endif
......
......@@ -25,6 +25,8 @@
#include "vtkInformationVector.h"
#include "vtkMath.h"
#include "vtkPointData.h"
#include "vtkSmartPointer.h"
#include "vtkStructuredData.h"
#include <math.h>
......@@ -478,7 +480,7 @@ int vtkDataSet::CheckAttributes()
}
//----------------------------------------------------------------------------
void vtkDataSet::GenerateGhostArray(int zeroExt[6])
void vtkDataSet::GenerateGhostArray(int zeroExt[6], bool cellOnly)
{
// Make sure this is a structured data set.
if(this->GetExtentType() != VTK_3D_EXTENT)
......@@ -486,21 +488,42 @@ void vtkDataSet::GenerateGhostArray(int zeroExt[6])
return;
}
// Avoid generating these if the producer has generated them.
if(!this->PointData->GetArray(vtkDataSetAttributes::GhostArrayName()))
{ // Set ghost types for cells and points.
vtkUnsignedCharArray *ghosts;
int extent[6];
int i, j, k, di, dj, dk, dist;
int extent[6];
int i, j, k, di, dj, dk, dist;
this->Information->Get(vtkDataObject::DATA_EXTENT(), extent);
bool sameExtent = true;
for (i=0; i<6; i++)
{
if (extent[i] != zeroExt[i])
{
sameExtent = false;
break;
}
}
if (sameExtent)
{
return;
}
this->Information->Get(vtkDataObject::DATA_EXTENT(), extent);
vtkIdType index = 0;
// ---- POINTS ----
// Allocate the appropriate ghost types.
ghosts = vtkUnsignedCharArray::New();
ghosts->Allocate((extent[1]-extent[0] + 1) *
(extent[3]-extent[2] + 1) *
(extent[5]-extent[4] + 1));
// ---- POINTS ----
if (!cellOnly)
{
vtkSmartPointer<vtkUnsignedCharArray> ghostPoints =
vtkUnsignedCharArray::SafeDownCast(
this->PointData->GetArray(vtkDataSetAttributes::GhostArrayName()));
if (!ghostPoints)
{
ghostPoints.TakeReference(vtkUnsignedCharArray::New());
ghostPoints->SetName(vtkDataSetAttributes::GhostArrayName());
ghostPoints->SetNumberOfTuples(vtkStructuredData::GetNumberOfPoints(extent));
ghostPoints->FillComponent(0, 0);
this->PointData->AddArray(ghostPoints);
}
// Loop through the points in this image.
for (k = extent[4]; k <= extent[5]; ++k)
......@@ -546,102 +569,106 @@ void vtkDataSet::GenerateGhostArray(int zeroExt[6])
{
dist = dk;
}
unsigned char value = 0;
unsigned char value = ghostPoints->GetValue(index);
if(dist > 0)
{
value |= vtkDataSetAttributes::DUPLICATEPOINT;
}
ghosts->InsertNextValue(value);
ghostPoints->SetValue(index, value);
index++;
}
}
}
ghosts->SetName(vtkDataSetAttributes::GhostArrayName());
this->PointData->AddArray(ghosts);
ghosts->Delete();
}
// ---- CELLS ----
// Allocate the appropriate ghost types.
ghosts = vtkUnsignedCharArray::New();
ghosts->Allocate((extent[1]-extent[0]) *
(extent[3]-extent[2]) *
(extent[5]-extent[4]));
// ---- CELLS ----
// Loop through the cells in this image.
// Cells may be 2d or 1d ... Treat all as 3D
if (extent[0] == extent[1])
vtkSmartPointer<vtkUnsignedCharArray> ghostCells =
vtkUnsignedCharArray::SafeDownCast(
this->CellData->GetArray(vtkDataSetAttributes::GhostArrayName()));
if (!ghostCells)
{
ghostCells.TakeReference(vtkUnsignedCharArray::New());
ghostCells->SetName(vtkDataSetAttributes::GhostArrayName());
ghostCells->SetNumberOfTuples(vtkStructuredData::GetNumberOfCells(extent));
ghostCells->FillComponent(0, 0);
this->CellData->AddArray(ghostCells);
}
index = 0;
// Loop through the cells in this image.
// Cells may be 2d or 1d ... Treat all as 3D
if (extent[0] == extent[1])
{
++extent[1];
++zeroExt[1];
}
if (extent[2] == extent[3])
{
++extent[3];
++zeroExt[3];
}
if (extent[4] == extent[5])
{
++extent[5];
++zeroExt[5];
}
// Loop
for (k = extent[4]; k < extent[5]; ++k)
{ // Determine the Manhatten distances to zero extent.
dk = 0;
if (k < zeroExt[4])
{
++extent[1];
++zeroExt[1];
dk = zeroExt[4] - k;
}
if (extent[2] == extent[3])
if (k >= zeroExt[5])
{
++extent[3];
++zeroExt[3];
dk = k - zeroExt[5] + 1;
}
if (extent[4] == extent[5])
for (j = extent[2]; j < extent[3]; ++j)
{
++extent[5];
++zeroExt[5];
}
// Loop
for (k = extent[4]; k < extent[5]; ++k)
{ // Determine the Manhatten distances to zero extent.
dk = 0;
if (k < zeroExt[4])
dj = 0;
if (j < zeroExt[2])
{
dk = zeroExt[4] - k;
dj = zeroExt[2] - j;
}
if (k >= zeroExt[5])
if (j >= zeroExt[3])
{
dk = k - zeroExt[5] + 1;
dj = j - zeroExt[3] + 1;
}
for (j = extent[2]; j < extent[3]; ++j)
for (i = extent[0]; i < extent[1]; ++i)
{
dj = 0;
if (j < zeroExt[2])
di = 0;
if (i < zeroExt[0])
{
dj = zeroExt[2] - j;
di = zeroExt[0] - i;
}
if (j >= zeroExt[3])
if (i >= zeroExt[1])
{
dj = j - zeroExt[3] + 1;
di = i - zeroExt[1] + 1;
}
for (i = extent[0]; i < extent[1]; ++i)
// Compute Manhatten distance.
dist = di;
if (dj > dist)
{
di = 0;
if (i < zeroExt[0])
{
di = zeroExt[0] - i;
}
if (i >= zeroExt[1])
{
di = i - zeroExt[1] + 1;
}
// Compute Manhatten distance.
dist = di;
if (dj > dist)
{
dist = dj;
}
if (dk > dist)
{
dist = dk;
}
unsigned char value = 0;
if(dist > 0)
{
value |= vtkDataSetAttributes::DUPLICATECELL;
}
ghosts->InsertNextValue(value);
dist = dj;
}
if (dk > dist)
{
dist = dk;
}
unsigned char value = ghostCells->GetValue(index);
if(dist > 0)
{
value |= vtkDataSetAttributes::DUPLICATECELL;
}
ghostCells->SetValue(index, value);
index++;
}
}
ghosts->SetName(vtkDataSetAttributes::GhostArrayName());
this->CellData->AddArray(ghosts);
ghosts->Delete();
}
}
//----------------------------------------------------------------------------
......
......@@ -335,7 +335,11 @@ public:
// Normally called by pipeline executives or algoritms only. This method
// computes the ghost arrays for a given dataset. The zeroExt argument
// specifies the extent of the region which ghost type = 0.
virtual void GenerateGhostArray(int zeroExt[6]);
virtual void GenerateGhostArray(int zeroExt[6])
{
this->GenerateGhostArray(zeroExt, false);
}
virtual void GenerateGhostArray(int zeroExt[6], bool cellOnly);
//BTX
// Description:
......
......@@ -587,7 +587,7 @@ int vtkCompositeDataPipeline::NeedToExecuteData(
}
int dataGhostLevel = dataInfo->Get(vtkDataObject::DATA_NUMBER_OF_GHOST_LEVELS());
int updateGhostLevel = outInfo->Get(UPDATE_NUMBER_OF_GHOST_LEVELS());
if(dataGhostLevel < updateGhostLevel)
if(updateNumberOfPieces > 1 && dataGhostLevel < updateGhostLevel)
{
return 1;
}
......
......@@ -1060,7 +1060,22 @@ vtkStreamingDemandDrivenPipeline
{
dataInfo->Set(vtkDataObject::DATA_PIECE_NUMBER(), piece);
dataInfo->Set(vtkDataObject::DATA_NUMBER_OF_PIECES(), numPieces);
dataInfo->Set(vtkDataObject::DATA_NUMBER_OF_GHOST_LEVELS(), ghostLevel);
// If the source or filter produced a different number of ghost
// levels, honor it.
int dataGhostLevel = 0;
if (dataInfo->Has(vtkDataObject::DATA_NUMBER_OF_GHOST_LEVELS()))
{
dataGhostLevel =
dataInfo->Get(vtkDataObject::DATA_NUMBER_OF_GHOST_LEVELS());
}
// If the ghost level generated by the algorithm is larger than
// requested, we keep it. Otherwise, we store the requested one.
// We do this because there is no point in the algorithm re-executing
// if the downstream asks for the same level even though the
// algorithm cannot produce it.
dataInfo->Set(
vtkDataObject::DATA_NUMBER_OF_GHOST_LEVELS(),
ghostLevel > dataGhostLevel ? ghostLevel : dataGhostLevel);
}
// In this block, we make sure that DATA_TIME_STEP() is set if:
......
......@@ -9,7 +9,7 @@ vtk_module(vtkFiltersParallelFlowPaths
vtkIOAMR
vtkTestingRendering
vtkRenderingParallel
vtkIOGeometry
vtkIOParallel
KIT
vtkParallel
)
......@@ -11,6 +11,7 @@ vtk_module(vtkFiltersSources
vtkRendering${VTK_RENDERING_BACKEND}
vtkFiltersModeling
vtkIOXML
vtkIOParallel
KIT
vtkFilters
)
......@@ -13,13 +13,10 @@ SET(Module_SRCS
vtkMCubesWriter.cxx
vtkMFIXReader.cxx
vtkMoleculeReaderBase.cxx
vtkMultiBlockPLOT3DReader.cxx
vtkMultiBlockPLOT3DReaderInternals.cxx
vtkOBJReader.cxx
vtkOpenFOAMReader.cxx
vtkParticleReader.cxx
vtkPDBReader.cxx
vtkPlot3DMetaReader.cxx
vtkProStarReader.cxx
vtkSTLReader.cxx
vtkSTLWriter.cxx
......@@ -34,9 +31,4 @@ set_source_files_properties(
ABSTRACT
)
set_source_files_properties(
vtkMultiBlockPLOT3DReaderInternals
WRAP_EXCLUDE
)
vtk_module_library(vtkIOGeometry ${Module_SRCS})
......@@ -8,7 +8,6 @@ vtk_module(vtkIOGeometry
vtkIOCore
PRIVATE_DEPENDS
vtkzlib
vtkjsoncpp
vtksys
TEST_DEPENDS
vtkIOAMR
......
include(vtkMPI)
# We don't build the parallel WindBlade reader on windows
# We don't build the parallel readers on windows
# because there's problems with the MPI_File_open()
# function when there's paths in the filenames.
set(PWindBladeReader vtkPWindBladeReader.cxx)
set (vtk_module_overrides)
if(WIN32)
set(PWindBladeReader)
endif()
set(Module_SRCS
${PWindBladeReader}
${CMAKE_CURRENT_BINARY_DIR}/${vtk-module}ObjectFactory.cxx
)
set(Module_SRCS)
else()
set(Module_SRCS
vtkPWindBladeReader.cxx
vtkMPIMultiBlockPLOT3DReader.cxx
)
set_source_files_properties(
${vtk-module}ObjectFactory
WRAP_EXCLUDE
)
vtk_add_override(vtkWindBladeReader vtkPWindBladeReader)
vtk_add_override(vtkMultiBlockPLOT3DReader vtkMPIMultiBlockPLOT3DReader)
endif()
# Now to generate our object factory.
set( vtk_module_overrides
WindBladeReader
vtk_object_factory_configure("${vtk_module_overrides}")
list(APPEND Module_SRCS
${CMAKE_CURRENT_BINARY_DIR}/${vtk-module}ObjectFactory.cxx
)
if(WIN32)
set( vtk_module_overrides )
endif()
foreach(_class ${vtk_module_overrides})
set(_override vtkP${_class})
set(_vtk_override_includes "${_vtk_override_includes} #include \"${_override}.h\"")
set(_vtk_override_creates "${_vtk_override_creates}
VTK_CREATE_CREATE_FUNCTION(${_override})")
set(_vtk_override_do "${_vtk_override_do}
this->RegisterOverride(\"vtk${_class}\",
\"${_override}\",
\"Override for ${vtk-module} module\", 1,
vtkObjectFactoryCreate${_override});")
endforeach()
# Now lets create the object factory classes
string(TOUPPER ${vtk-module} VTK-MODULE)
configure_file(${VTK_CMAKE_DIR}/vtkObjectFactory.h.in
${CMAKE_CURRENT_BINARY_DIR}/${vtk-module}ObjectFactory.h)
configure_file(${VTK_CMAKE_DIR}/vtkObjectFactory.cxx.in
${CMAKE_CURRENT_BINARY_DIR}/${vtk-module}ObjectFactory.cxx)
set_source_files_properties(${vtk-module}ObjectFactory WRAP_EXCLUDE)
vtk_module_library(${vtk-module} ${Module_SRCS})
vtk_mpi_link(${vtk-module})
vtk_add_test_python_mpi(
Plot3DMPIIO.py,NO_VALID
)
#!/usr/bin/env python
import sys
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
def Gather(c, arr, root):
vtkArr = vtk.vtkDoubleArray()
count = len(arr)
vtkArr.SetNumberOfTuples(count)
for i in range(count):
vtkArr.SetValue(i, arr[i])
vtkResult = vtk.vtkDoubleArray()
c.Gather(vtkArr, vtkResult, root)
result = [vtkResult.GetValue(i) for i in range(vtkResult.GetNumberOfTuples())]
return [ tuple(result[i : i + count]) \
for i in xrange(0, vtkResult.GetNumberOfTuples(), count) ]
renWin = vtk.vtkRenderWindow()
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
r = vtk.vtkMultiBlockPLOT3DReader()
# Since vtkMPIMultiBlockPLOT3DReader is not created on Windows even when MPI
# is enabled.
assert r.IsA("vtkMPIMultiBlockPLOT3DReader") == 1 or sys.platform == "win32"
r.SetFileName(VTK_DATA_ROOT + "/Data/multi-bin.xyz")
r.SetQFileName(VTK_DATA_ROOT + "/Data/multi-bin-oflow.q")
r.SetFunctionFileName(VTK_DATA_ROOT + "/Data/multi-bin.f")
r.AutoDetectFormatOn()
r.Update()
c = vtk.vtkMPIController.GetGlobalController()
size = c.GetNumberOfProcesses()
rank = c.GetLocalProcessId()
block = 0
bounds = r.GetOutput().GetBlock(block).GetBounds()
bounds = Gather(c, bounds, root=0)
if rank == 0:
print "Reader:", r.GetClassName()
print "Bounds:"
for i in range(size):
print bounds[i]
c.Barrier()
aname = "StagnationEnergy"
rng = r.GetOutput().GetBlock(block).GetPointData().GetArray(aname).GetRange(0)
rng = Gather(c, rng, root=0)
if rank == 0:
print "StagnationEnergy Ranges:"
for i in range(size):
print rng[i]
assert rng[i][0] > 1.1 and rng[i][0] < 24.1 and \
rng[i][1] > 1.1 and rng[i][1] < 24.1
vtk_module(vtkIOMPIParallel
IMPLEMENTS
vtkIOGeometry
vtkIOParallel
GROUPS
MPI
DEPENDS
vtkIOGeometry
vtkParallelMPI
vtkIOParallel
PRIVATE_DEPENDS
vtksys
vtkParallelMPI
TEST_DEPENDS
vtkRendering${VTK_RENDERING_BACKEND}
vtkTestingRendering
......
This diff is collapsed.
/*=========================================================================
Program: Visualization Toolkit
Module: vtkMPIMultiBlockPLOT3DReader.h
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
// .NAME vtkMPIMultiBlockPLOT3DReader - vtkMultiBlockPLOT3DReader subclass that
// uses MPI-IO to efficiently read binary files for 3D domains in parallel using
// MPI-IO.
// .SECTION Description
// vtkMPIMultiBlockPLOT3DReader extends vtkMultiBlockPLOT3DReader to use MPI-IO
// instead of POSIX IO to read file in parallel.
#ifndef vtkMPIMultiBlockPLOT3DReader_h
#define vtkMPIMultiBlockPLOT3DReader_h
#include "vtkMultiBlockPLOT3DReader.h"
#include "vtkIOMPIParallelModule.h" // For export macro
class VTKIOMPIPARALLEL_EXPORT vtkMPIMultiBlockPLOT3DReader : public vtkMultiBlockPLOT3DReader
{
public:
static vtkMPIMultiBlockPLOT3DReader* New();
vtkTypeMacro(vtkMPIMultiBlockPLOT3DReader, vtkMultiBlockPLOT3DReader);
void PrintSelf(ostream& os, vtkIndent indent);
// Description:
// Use this to override using MPI-IO. When set to false (default is true),
// this class will simply forward all method calls to the superclass.
vtkSetMacro(UseMPIIO, bool);
vtkGetMacro(UseMPIIO, bool);
vtkBooleanMacro(UseMPIIO, bool);
protected:
vtkMPIMultiBlockPLOT3DReader();
~vtkMPIMultiBlockPLOT3DReader();
// Description:
// Determines we should use MPI-IO for the current file. We don't use MPI-IO
// for 2D files or ASCII files.
bool CanUseMPIIO();
virtual int OpenFileForDataRead(void*& fp, const char* fname);
virtual void CloseFile(void* fp);
virtual int ReadIntScalar(
void* vfp,
int extent[6], int wextent[6],
vtkDataArray* scalar, vtkTypeUInt64 offset);
virtual int ReadScalar(
void* vfp,
int extent[6], int wextent[6],
vtkDataArray* scalar, vtkTypeUInt64 offset);
virtual int ReadVector(
void* vfp,
int extent[6], int wextent[6],
int numDims, vtkDataArray* vector, vtkTypeUInt64 offset);
bool UseMPIIO;
private:
vtkMPIMultiBlockPLOT3DReader(const vtkMPIMultiBlockPLOT3DReader&); // Not implemented.
void operator=(const vtkMPIMultiBlockPLOT3DReader&); // Not implemented.
};
#endif
set(Module_SRCS
vtkEnSightWriter.cxx
# vtkExodusIIWriter.cxx needs vtkMultiProcessController
vtkMultiBlockPLOT3DReader.cxx
vtkMultiBlockPLOT3DReaderInternals.cxx
vtkPlot3DMetaReader.cxx
vtkPChacoReader.cxx
vtkPDataSetReader.cxx
vtkPDataSetWriter.cxx
......@@ -9,4 +12,9 @@ set(Module_SRCS
vtkPSLACReader.cxx
)
set_source_files_properties(
vtkMultiBlockPLOT3DReaderInternals
WRAP_EXCLUDE
)
vtk_module_library(vtkIOParallel ${Module_SRCS})
......@@ -9,7 +9,9 @@ vtk_module(vtkIOParallel
vtkIOImage
PRIVATE_DEPENDS
vtkexodusII
vtkjsoncpp
vtknetcdf
vtksys
TEST_DEPENDS
vtkParallelMPI
vtkRenderingParallel
......
......@@ -83,17 +83,18 @@
#ifndef vtkMultiBlockPLOT3DReader_h
#define vtkMultiBlockPLOT3DReader_h
#include "vtkIOGeometryModule.h" // For export macro
#include "vtkIOParallelModule.h" // For export macro
#include "vtkMultiBlockDataSetAlgorithm.h"
class vtkDataArray;
class vtkUnsignedCharArray;
class vtkIntArray;
class vtkStructuredGrid;
//BTX
class vtkMultiProcessController;
struct vtkMultiBlockPLOT3DReaderInternals;
//ETX
class VTKIOGEOMETRY_EXPORT vtkMultiBlockPLOT3DReader : public vtkMultiBlockDataSetAlgorithm
class VTKIOPARALLEL_EXPORT vtkMultiBlockPLOT3DReader : public vtkMultiBlockDataSetAlgorithm
{
public:
static vtkMultiBlockPLOT3DReader *New();
......@@ -233,9 +234,10 @@ public:
virtual int CanReadBinaryFile(const char* fname);
// Description:
// Overwritten to make sure that RequestInformation reads the meta-data
// again after the reader parameters were changed.
virtual void Modified();
// Set/Get the communicator object (we'll use global World controller
// if you don't set a different one).
void SetController(vtkMultiProcessController *c);
vtkGetObjectMacro(Controller, vtkMultiProcessController);