[Paraview] Parallel Python Programmable Filter Requesting Additional Ghost Data
Burlen Loring
bloring at lbl.gov
Tue Jul 17 14:04:01 EDT 2012
There is also ghost cell generator for image data that does not convert
to multi block. It's called SQImageGhosts and resides in the
SciberQuestToolKit pluign.
You would need to ensure the plugin is loaded and insert this filter
upstream of your python filter.
In your filter's RequestUpdateExtent you'll need to set both
UPDATE_NUMBER_OF_GHOST_LEVELS() and UPDATE_EXTENT() to reflect the
number of ghost cells that you need. When you set UPDATE_EXTENT() to
include ghost cells you must ensure that it is contained by WHOLE_EXTENT().
In your filter's RequestData you'll need to give PV the extent he
initially asked for and process the input and output arrays according to
the modified input extents and requested output extents respectively.
The following c++ code illustrates. You'll have to build PV from source
and turn on the plugin during the build. I would recommend pulling the
sources from PV git repo since a number of windows and mac build issues
were recently fixed.
Burlen
this illustrates how ghost cells are requested in a filter:
//-----------------------------------------------------------------------------
int vtkSQKernelConvolution::RequestUpdateExtent(
vtkInformation *req,
vtkInformationVector **inInfos,
vtkInformationVector *outInfos)
{
// ...
// We will modify the extents we request from our input so
// that we will have a layers of ghost cells. We also pass
// the number of ghosts through the piece based key.
int nGhosts = this->KernelWidth/2;
inInfo->Set(
vtkSDDPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS(),
nGhosts);
CartesianExtent outputExt;
outInfo->Get(
vtkSDDPipeline::UPDATE_EXTENT(),
outputExt.GetData());
CartesianExtent wholeExt;
inInfo->Get(
vtkSDDPipeline::WHOLE_EXTENT(),
wholeExt.GetData());
outputExt = CartesianExtent::Grow(
outputExt,
wholeExt,
nGhosts,
this->Mode);
inInfo->Set(
vtkSDDPipeline::UPDATE_EXTENT(),
outputExt.GetData(),
6);
int piece
= outInfo->Get(vtkSDDPipeline::UPDATE_PIECE_NUMBER());
int numPieces
= outInfo->Get(vtkSDDPipeline::UPDATE_NUMBER_OF_PIECES());
inInfo->Set(vtkSDDPipeline::UPDATE_PIECE_NUMBER(), piece);
inInfo->Set(vtkSDDPipeline::UPDATE_NUMBER_OF_PIECES(), numPieces);
inInfo->Set(vtkSDDPipeline::EXACT_EXTENT(), 1);
return 1;
}
//-----------------------------------------------------------------------------
int vtkSQKernelConvolution::RequestData(
vtkInformation * /*req*/,
vtkInformationVector **inInfoVec,
vtkInformationVector *outInfoVec)
{
// ...
// Get the input and output extents.
CartesianExtent inputExt;
inInfo->Get(
vtkStreamingDemandDrivenPipeline::UPDATE_EXTENT(),
inputExt.GetData());
CartesianExtent inputDom;
inInfo->Get(
vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT(),
inputDom.GetData());
CartesianExtent outputExt;
outInfo->Get(
vtkStreamingDemandDrivenPipeline::UPDATE_EXTENT(),
outputExt.GetData());
CartesianExtent domainExt;
outInfo->Get(
vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT(),
domainExt.GetData());
// Check that we have the ghost cells that we need (more is OK).
int nGhost = this->KernelWidth/2;
CartesianExtent inputBox(inputExt);
CartesianExtent outputBox
= CartesianExtent::Grow(outputExt, nGhost, this->Mode);
if (!inputBox.Contains(outputBox))
{
vtkErrorMacro(
<< "This filter requires ghost cells to function correctly. "
<< "The input must contain the output plus " << nGhost
<< " layers of ghosts. The input is " << inputBox
<< ", but it must be at least "
<< outputBox << ".");
return 1;
}
// NOTE You can't do a shallow copy because the array dimensions are
// different on output and input because of the ghost layers.
vtkImageData *inImData=dynamic_cast<vtkImageData *>(inData);
vtkImageData *outImData=dynamic_cast<vtkImageData *>(outData);
// set up the output.
double X0[3];
outInfo->Get(vtkDataObject::ORIGIN(),X0);
outImData->SetOrigin(X0);
double dX[3];
outInfo->Get(vtkDataObject::SPACING(),dX);
outImData->SetSpacing(dX);
outImData->SetExtent(outputExt.GetData());
// ...
}
On 07/17/2012 10:24 AM, George Zagaris wrote:
> Since you have structured grids, one other possibility is using:
> vtkPUniformGridGhostDataGenerator
> (http://www.vtk.org/doc/nightly/html/classvtkPUniformGridGhostDataGenerator.html)
>
> Each process constructs a vtkMultiBlockDataSet instance consisting of
> the grids/blocks owned by the process with NULL entries for all remote
> blocks.
> The resulting output of the filter is a vtkMultiBlockDataSet
> consisting of the ghosted grid/block instances. Make sure that you
> specify the whole-extent for the entire dataset and that for each
> block you attach PIECE_EXTENT() in the corresponding vtkInformation.
>
> Let me know if you need more help on this.
>
> Best,
> George
>
>
> On Tue, Jul 17, 2012 at 12:22 PM, Jesus Pulido<jpulido at ucdavis.edu> wrote
>> Thank you Berk.
>>
>> I was under the impression that this command would trigger the reader to
>> automatically load in the additional # of requested ghost levels. I tested
>> the command and each data piece still has the same extents as before.
>>
>> Is there any additional way to load in ghost level that's parallel friendly?
>> I am aware of the D3 filter but, from the memory usage, it seems that it
>> will load in the entire dataset into each processor and this is not feasible
>> for large datasets.
>>
>> I am using binary, "raw" vti piece files each with their own extent of the
>> data and a header pvti file.
>> The data has no encoded ghost layers between pieces so I was hoping to have
>> paraview do that for me.
>>
>> Jesus
>>
>>
>> On Tue, Jul 17, 2012 at 7:29 AM, Berk Geveci<berk.geveci at kitware.com>
>> wrote:
>>>
>>> self.GetExecutive().GetOutputInformation(0).Set(vtk.vtkStreamingDemandDrivenPipeline.UPDATE_NUMBER_OF_GHOST_LEVELS(),
>>> 1)
>>>
>>>
>>> in RequestUpdateExtent script. Of course, this requires that the reader or
>>> a filter before the programmable filter is able to provide ghost levels.
>>>
>>>
>>> -berk
>>>
>>>
>>> On Wed, Jul 11, 2012 at 3:04 PM, Jesus Pulido<jpulido at ucdavis.edu> wrote:
>>>> Hello,
>>>>
>>>> I am trying to request ghost data in my python programmable filter but I
>>>> am not sure how to go about and do so. I am assuming the call would go into
>>>> the RequestUpdateExtent Script.
>>>>
>>>> In the C++ equivalent filters that do request ghost data, the call to is
>>>> something along the lines of
>>>> vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS() , and
>>>> there are examples of that in the Paraview source but the way the objects
>>>> are defined and called does not translate into Paraview VTK Python. What
>>>> would be the appropriate call?
>>>>
>>>> Thank you,
>>>> Jesus
>>>>
>>>>
>>>> _______________________________________________
>>>> Powered by www.kitware.com
>>>>
>>>> Visit other Kitware open-source projects at
>>>> http://www.kitware.com/opensource/opensource.html
>>>>
>>>> Please keep messages on-topic and check the ParaView Wiki at:
>>>> http://paraview.org/Wiki/ParaView
>>>>
>>>> Follow this link to subscribe/unsubscribe:
>>>> http://www.paraview.org/mailman/listinfo/paraview
>>>>
>>
>> _______________________________________________
>> Powered by www.kitware.com
>>
>> Visit other Kitware open-source projects at
>> http://www.kitware.com/opensource/opensource.html
>>
>> Please keep messages on-topic and check the ParaView Wiki at:
>> http://paraview.org/Wiki/ParaView
>>
>> Follow this link to subscribe/unsubscribe:
>> http://www.paraview.org/mailman/listinfo/paraview
>>
> _______________________________________________
> Powered by www.kitware.com
>
> Visit other Kitware open-source projects at http://www.kitware.com/opensource/opensource.html
>
> Please keep messages on-topic and check the ParaView Wiki at: http://paraview.org/Wiki/ParaView
>
> Follow this link to subscribe/unsubscribe:
> http://www.paraview.org/mailman/listinfo/paraview
More information about the ParaView
mailing list