Commit 4ead86c8 authored by Yuanxin Liu's avatar Yuanxin Liu Committed by Code Review
Browse files

Merge topic 'move-amr-under-filters' into master

b93716f7 COMP: Update Tracers AMR dependencies
5220029c COMP: Update CMakeLists and AMR headers
8363e96b ENH: Move AMR under Filters/AMR
parents 8ba9a63d b93716f7
/*=========================================================================
Program: Visualization Toolkit
Module: vtkAMRBaseParticlesReader.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 vtkAMRBaseParticlesReader.h -- Base class for all AMR particle readers
//
// .SECTION Description
// An abstract base class that implements all the common functionality for
// all particle readers.
#ifndef VTKAMRBASEPARTICLESREADER_H_
#define VTKAMRBASEPARTICLESREADER_H_
#include "vtkAMRCoreModule.h" // For export macro
#include "vtkMultiBlockDataSetAlgorithm.h"
class vtkInformation;
class vtkInformationVector;
class vtkIndent;
class vtkMultiProcessController;
class vtkPolyData;
class vtkDataArraySelection;
class vtkCallbackCommand;
class VTKAMRCORE_EXPORT vtkAMRBaseParticlesReader :
public vtkMultiBlockDataSetAlgorithm
{
public:
vtkTypeMacro( vtkAMRBaseParticlesReader, vtkMultiBlockDataSetAlgorithm );
void PrintSelf(ostream &os, vtkIndent indent );
// Description:
// Set & Get the frequency.
vtkGetMacro(Frequency,int);
vtkSetMacro(Frequency,int);
// Description:
// Set & Get the multi-process controller.
vtkGetMacro(Controller, vtkMultiProcessController* );
vtkSetMacro(Controller, vtkMultiProcessController* );
// Description:
// Set & Get for filter location and boolean macro
vtkSetMacro(FilterLocation,int);
vtkGetMacro(FilterLocation,int);
vtkBooleanMacro(FilterLocation,int);
// Description:
// Get the data array selection tables used to configure which data
// arrays are loaded by the reader.
vtkGetObjectMacro(ParticleDataArraySelection,vtkDataArraySelection);
// Description:
// Get the number of particles arrays available in the input.
int GetNumberOfParticleArrays();
// Description:
// Get the particle array name of the array associated with the given
// index.
const char* GetParticleArrayName( int index );
// Description:
// Get/Set whether the particle array status.
int GetParticleArrayStatus( const char* name );
void SetParticleArrayStatus( const char* name, int status );
virtual void SetFileName( const char *fileName );
vtkGetStringMacro(FileName);
// Description:
// Sets the min location
inline void SetMinLocation(
const double minx, const double miny, const double minz )
{
this->MinLocation[ 0 ] = minx;
this->MinLocation[ 1 ] = miny;
this->MinLocation[ 2 ] = minz;
}
// Description:
// Sets the max location
inline void SetMaxLocation(
const double maxx, const double maxy, const double maxz )
{
this->MaxLocation[ 0 ] = maxx;
this->MaxLocation[ 1 ] = maxy;
this->MaxLocation[ 2 ] = maxz;
}
// Description:
// Returns the total number of particles
virtual int GetTotalNumberOfParticles() = 0;
protected:
vtkAMRBaseParticlesReader();
virtual ~vtkAMRBaseParticlesReader();
// Description:
// Reads the metadata, e.g., the number of blocks in the file.
// After the metadata is read, this->Initialized is set to true.
// Furthermore, to limit I/O, all concrete classes must make sure
// that this method returns immediately if this->Initialized is true.
virtual void ReadMetaData() = 0;
// Description:
// Reads the particles corresponding to the block associated with the
// given supplied block index.
virtual vtkPolyData* ReadParticles( const int blkIdx ) = 0;
// Description:
// Filters particles by their location. If FilterLocation is ON, this
// method returns whether or not the particle with the supplied xyz
// coordiantes flass within the bouning box spefixied by the user using
// the SetMinLocation & SetMaxLocation.
bool CheckLocation( const double x, const double y, const double z );
// Description:
// Determines whether this reader instance is running in parallel or not.
bool IsParallel( );
// Description:
// Determines if the block associated with the given block index belongs
// to the process that executes the current instance of the reader.
bool IsBlockMine( const int blkIdx );
// Description:
// Given the block index, this method determines the process Id.
// If the reader instance is serial this method always returns 0.
// Otherwise, static block-cyclic-distribution is assumed and each
// block is assigned to a process according to blkIdx%N, where N is
// the total number of processes.
int GetBlockProcessId( const int blkIdx );
// Description:
// Initializes the AMR Particles reader
// NOTE: must be called in the constructor of concrete classes.
void Initialize();
// Description:
// Standard Array selection variables & methods
vtkDataArraySelection *ParticleDataArraySelection;
vtkCallbackCommand *SelectionObserver;
// Description:
// Initializes the ParticleDataArraySelection object. This method
// only executes for an intial request in which case all arrays are
// deselected.
void InitializeParticleDataSelections();
// Description:
// Sets up the ParticleDataArraySelection. Implemented
// by concrete classes.
virtual void SetupParticleDataSelections() = 0;
// Description:
// Call-back registered with the SelectionObserver for selecting/deselecting
// particles
static void SelectionModifiedCallback(
vtkObject *caller,unsigned long eid,void *clientdata,void *calldata );
// Description:
// Standard pipeline operations
virtual int RequestData( vtkInformation *request,
vtkInformationVector **inputVector,
vtkInformationVector *outputVector );
virtual int FillOutputPortInformation( int port, vtkInformation *info );
int NumberOfBlocks;
int FilterLocation;
double MinLocation[3];
double MaxLocation[3];
int Frequency;
vtkMultiProcessController *Controller;
bool InitialRequest;
bool Initialized;
char *FileName;
private:
vtkAMRBaseParticlesReader( const vtkAMRBaseParticlesReader& ); // Not implemented
void operator=(const vtkAMRBaseParticlesReader& ); // Not implemented
};
#endif /* VTKAMRBASEPARTICLESREADER_H_ */
/*=========================================================================
Program: Visualization Toolkit
Module: vtkAMRBaseReader.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 vtkAMRBaseReader.h -- Base class for all AMR Readers
//
// .SECTION Description
// An abstract class that encapsulates common functionality for all AMR readers.
#ifndef VTKAMRBASEREADER_H_
#define VTKAMRBASEREADER_H_
#include "vtkAMRCoreModule.h" // For export macro
#include "vtkOverlappingAMRAlgorithm.h"
#include <vector> // STL vector header
#include <map> // STL map header
#include <utility> // for STL pair
// Forward Declarations
class vtkOverlappingAMR;
class vtkMultiProcessController;
class vtkDataArraySelection;
class vtkCallbackCommand;
class vtkIndent;
class vtkAMRDataSetCache;
class vtkUniformGrid;
class vtkDataArray;
class VTKAMRCORE_EXPORT vtkAMRBaseReader :
public vtkOverlappingAMRAlgorithm
{
public:
vtkTypeMacro( vtkAMRBaseReader, vtkOverlappingAMRAlgorithm );
void PrintSelf(ostream &os, vtkIndent indent);
// Description:
// Initializes the AMR reader.
// All concrete instances must call this method in their constructor.
void Initialize();
// Description:
// Set/Get Reader caching property
vtkSetMacro( EnableCaching, int );
vtkGetMacro( EnableCaching, int );
vtkBooleanMacro( EnableCaching, int );
bool IsCachingEnabled() const
{
return( (this->EnableCaching)?true:false);
};
// Description:
// Set/Get a multiprocess-controller for reading in parallel.
// By default this parameter is set to NULL by the constructor.
vtkSetMacro( Controller, vtkMultiProcessController* );
vtkGetMacro( Controller, vtkMultiProcessController* );
// Description:
// Set the level, up to which the blocks are loaded.
vtkSetMacro( MaxLevel,int);
// Description:
// Get the data array selection tables used to configure which data
// arrays are loaded by the reader.
vtkGetObjectMacro(CellDataArraySelection, vtkDataArraySelection);
vtkGetObjectMacro(PointDataArraySelection, vtkDataArraySelection);
// Description:
// Get the number of point or cell arrays available in the input.
int GetNumberOfPointArrays();
int GetNumberOfCellArrays();
// Description:
// Get the name of the point or cell array with the given index in
// the input.
const char* GetPointArrayName(int index);
const char* GetCellArrayName(int index);
// Description:
// Get/Set whether the point or cell array with the given name is to
// be read.
int GetPointArrayStatus(const char* name);
int GetCellArrayStatus(const char* name);
void SetPointArrayStatus(const char* name, int status);
void SetCellArrayStatus(const char* name, int status);
// Description:
// Set/Get the filename. Concrete instances of this class must implement
// the SetFileName method accordingly.
vtkGetStringMacro( FileName );
virtual void SetFileName( const char *fileName ) = 0;
// Description:
// Returns the total number of blocks. Implemented by concrete instances.
virtual int GetNumberOfBlocks() = 0;
// Description:
// Returns the total number of levels. Implemented by concrete instances.
virtual int GetNumberOfLevels() = 0;
protected:
vtkAMRBaseReader();
virtual ~vtkAMRBaseReader();
// Desscription:
// Checks if this reader instance is attached to a communicator
// with more than one MPI processes.
bool IsParallel();
// Description:
// Determines if the block is owned by this process based on the
// the block index and total number of processes.
bool IsBlockMine( const int blockIdx );
// Description:
// Loads the AMR block corresponding to the given index. The block
// is either loaded from the file, or, from the cache if caching is
// enabled.
vtkUniformGrid* GetAMRBlock( const int blockIdx );
// Description:
// This method assigns blocks to processes using block-cyclic distribution.
// It is the method that is used to load distributed AMR data by default.
void AssignAndLoadBlocks( vtkOverlappingAMR *amrds );
// Description:
// This method loads all the blocks in the BlockMap for the given process.
// It assumes that the downstream module is doing an upstream request with
// the flag LOAD_REQUESTED_BLOCKS which indicates that the downstream filter
// has already assigned which blocks are needed for each process.
void LoadRequestedBlocks( vtkOverlappingAMR *amrds );
// Description:
// Loads the AMR data corresponding to the given field name.
// NOTE: Currently, only cell-data are supported.
void GetAMRData(
const int blockIdx, vtkUniformGrid *block, const char *fieldName );
// Description:
// A wrapper that loops over point arrays and load the point
// arrays that are enabled, i.e., selected for the given block.
// NOTE: This method is currently not implemented.
void LoadPointData( const int blockIdx, vtkUniformGrid *block );
// Description:
// A wrapper that loops over all cell arrays and loads the cell
// arrays that are enabled, i.e., selected for the given block.
// The data are either loaded from the file, or, from the cache if
// caching is enabled.
void LoadCellData( const int blockIdx, vtkUniformGrid *block );
// Description:
// Returns the block process ID for the block corresponding to the
// given block index. If this reader instance is serial, i.e., there
// is no controller associated, the method returns 0. Otherwise, static
// block-cyclic-distribution is assumed and each block is assigned to
// a process according to blockIdx%N, where N is the total number of
// processes.
int GetBlockProcessId( const int blockIdx );
// Description:
// Initializes the request of blocks to be loaded. This method checks
// if an upstream request has been issued from a downstream module which
// specifies which blocks are to be loaded, otherwise, it uses the max
// level associated with this reader instance to determine which blocks
// are to be loaded.
void SetupBlockRequest( vtkInformation *outputInfo );
// Description:
// Reads all the metadata from the file. Implemented by concrete classes.
virtual void ReadMetaData() = 0;
// Description:
// Generates a linear index for each block. Implemented by concrete
// instances.
//
// Note this method must create a block map for all blocks
// that are to be rendered according to the max level argument. For
// example, a sample implementation may look as follows:
//<code>
// for(int i=0;i < this->Internal->NumberOfBlocks;i++ )
// {
// if ( this->GetBlockLevel( i ) <= this->MaxLevel )
// {
// this->BlockMap.push_back( i );
// }
// }
//</code>
virtual void GenerateBlockMap() = 0;
// Description:
// Returns the block level for the given block
virtual int GetBlockLevel( const int blockIdx ) = 0;
// Description:
// Loads all the AMR metadata & constructs the LevelIdxPair12InternalIdx
// datastructure which maps (level,id) pairs to an internal linear index
// used to identify the corresponding block.
virtual int FillMetaData( ) = 0;
// Description:
// Loads the block according to the index w.r.t. the generated BlockMap.
virtual vtkUniformGrid* GetAMRGrid( const int blockIdx ) = 0;
// Description:
// Loads the block data
virtual void GetAMRGridData(
const int blockIdx, vtkUniformGrid *block, const char *field ) = 0;
// Description:
// Standard Pipeline methods, subclasses may override this method if needed.
virtual int RequestData(
vtkInformation* vtkNotUsed(request),
vtkInformationVector** vtkNotUsed(inputVector),
vtkInformationVector* outputVector );
virtual int RequestInformation(
vtkInformation* rqst,
vtkInformationVector** inputVector,
vtkInformationVector* outputVector );
int FillOutputPortInformation(int port,vtkInformation *info);
// Array selection member variables and methods
vtkDataArraySelection *PointDataArraySelection;
vtkDataArraySelection *CellDataArraySelection;
vtkCallbackCommand *SelectionObserver;
// Description:
// Initializes the array selections. If this is an initial request,
// i.e., the first load from the file, all the arrays are deselected,
// and the IntialRequest ivar is set to false.
void InitializeArraySelections();
// Description:
// Initializes the PointDataArraySelection & CellDataArraySelection
virtual void SetUpDataArraySelections() = 0;
// Descriptions
// Call-back registered with the SelectionObserver.
static void SelectionModifiedCallback(
vtkObject *caller,unsigned long eid,void *clientdata,void *calldata );
bool InitialRequest;
int MaxLevel;
char *FileName;
vtkMultiProcessController *Controller;
int EnableCaching;
vtkAMRDataSetCache *Cache;
int NumBlocksFromFile;
int NumBlocksFromCache;
vtkOverlappingAMR *Metadata;
bool LoadedMetaData;
//BTX
std::vector<int> BlockMap;
//ETX
private:
vtkAMRBaseReader( const vtkAMRBaseReader& ); // Not implemented
void operator=( const vtkAMRBaseReader& ); // Not implemented
};
#endif /* VTKAMRBASEREADER_H_ */
/*=========================================================================
Program: Visualization Toolkit
Module: vtkAMRCutPlane.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 vtkAMRCutPlane.h -- Cuts an AMR dataset
//
// .SECTION Description
// A concrete instance of vtkMultiBlockDataSet that provides functionality for
// cutting an AMR dataset (an instance of vtkOverlappingAMR) with user supplied
// implicit plane function defined by a normal and center.
#ifndef VTKAMRCUTPLANE_H_
#define VTKAMRCUTPLANE_H_
#include "vtkAMRCoreModule.h" // For export macro
#include "vtkMultiBlockDataSetAlgorithm.h"
#include <vector> // For STL vector
#include <map> // For STL map
class vtkMultiBlockDataSet;
class vtkOverlappingAMR;
class vtkMultiProcessController;
class vtkInformation;
class vtkInformationVector;
class vtkIndent;
class vtkPlane;
class vtkUniformGrid;
class vtkCell;
class vtkPoints;
class vtkCellArray;
class vtkPointData;
class vtkCellData;
class VTKAMRCORE_EXPORT vtkAMRCutPlane : public vtkMultiBlockDataSetAlgorithm
{
public:
static vtkAMRCutPlane *New();
vtkTypeMacro(vtkAMRCutPlane, vtkMultiBlockDataSetAlgorithm);
void PrintSelf(ostream &oss, vtkIndent indent );
// Description:
// Sets the center
vtkSetVector3Macro(Center, double);
// Description:
// Sets the normal
vtkSetVector3Macro(Normal, double);
// Description:
// Sets the level of resolution
vtkSetMacro(LevelOfResolution, int);
vtkGetMacro(LevelOfResolution, int);
// Description:
//
vtkSetMacro(UseNativeCutter, int);
vtkGetMacro(UseNativeCutter, int);
vtkBooleanMacro(UseNativeCutter,int);
// Description:
// Set/Get a multiprocess controller for parallel processing.
// By default this parameter is set to NULL by the constructor.
vtkSetMacro(Controller, vtkMultiProcessController*);
vtkGetMacro(Controller, vtkMultiProcessController*);
// Standard pipeline routines
virtual int RequestData(
vtkInformation*,vtkInformationVector**,vtkInformationVector*);
virtual int FillInputPortInformation(int port, vtkInformation *info);
virtual int FillOutputPortInformation(int port, vtkInformation *info);
// Description:
// Gets the metadata from upstream module and determines which blocks
// should be loaded by this instance.
virtual int RequestInformation(
vtkInformation *rqst,
vtkInformationVector **inputVector,
vtkInformationVector *outputVector );
// Description:
// Performs upstream requests to the reader
virtual int RequestUpdateExtent(
vtkInformation*, vtkInformationVector**, vtkInformationVector* );
protected:
vtkAMRCutPlane();
virtual ~vtkAMRCutPlane();
// Description:
// Returns the cut-plane defined by a vtkCutPlane instance based on the
// user-supplied center and normal.
vtkPlane* GetCutPlane( vtkOverlappingAMR *metadata );
// Description:
// Extracts cell
void ExtractCellFromGrid(
vtkUniformGrid *grid, vtkCell* cell,
std::map<vtkIdType,vtkIdType>& gridPntMapping,
vtkPoints *nodes,
vtkCellArray *cells );
// Description:
// Given the grid and a subset ID pair, grid IDs mapping to the extracted
// grid IDs, extract the point data.
void ExtractPointDataFromGrid(
vtkUniformGrid *grid,
std::map<vtkIdType,vtkIdType>& gridPntMapping,
vtkIdType NumNodes,
vtkPointData *PD );
// Description:
// Given the grid and the list of cells that are extracted, extract the
// corresponding cell data.
void ExtractCellDataFromGrid(
vtkUniformGrid *grid,
std::vector<vtkIdType>& cellIdxList,
vtkCellData *CD);
// Description:
// Given a cut-plane, p, and the metadata, m, this method computes which
// blocks need to be loaded. The corresponding block IDs are stored in
// the internal STL vector, blocksToLoad, which is then propagated upstream
// in the RequestUpdateExtent.
void ComputeAMRBlocksToLoad( vtkPlane* p, vtkOverlappingAMR* m);
// Descriription:
// Initializes the cut-plane center given the min/max bounds.
void InitializeCenter( double min[3], double max[3] );
// Description:
// Determines if a plane intersects with an AMR box
bool PlaneIntersectsAMRBox( vtkPlane* pl, double bounds[6] );
bool PlaneIntersectsAMRBox( double plane[4], double bounds[6] );
// Description:
// Determines if a plane intersects with a grid cell