void
avtQueryOverTimeFilter::UpdateDataObjectInfo(void)
{
GetOutput()->GetInfo().GetValidity().InvalidateZones();
GetOutput()->GetInfo().GetValidity().InvalidateSpatialMetaData();
avtDataAttributes &outAtts = GetOutput()->GetInfo().GetAttributes();
outAtts.SetTopologicalDimension(1);
if (finalOutputCreated)
{
outAtts.GetOriginalSpatialExtents()->Clear();
outAtts.GetDesiredSpatialExtents()->Clear();
if (useTimeForXAxis)
{
outAtts.SetXLabel("Time");
outAtts.SetYLabel(label);
if (atts.GetTimeType() == QueryOverTimeAttributes::Cycle)
{
outAtts.SetXUnits("cycle");
}
else if (atts.GetTimeType() == QueryOverTimeAttributes::DTime)
{
outAtts.SetXUnits("time");
}
else if (atts.GetTimeType() == QueryOverTimeAttributes::Timestep)
{
outAtts.SetXUnits("timestep");
}
else
{
outAtts.SetXUnits("");
}
if (useVarForYAxis)
{
std::string yl = outAtts.GetVariableName();
outAtts.SetYLabel(yl);
outAtts.SetYUnits(outAtts.GetVariableUnits(yl.c_str()));
}
}
else
{
std::string xl = atts.GetQueryAtts().GetVariables()[0] + "(t)";
std::string yl = atts.GetQueryAtts().GetVariables()[1] + "(t)";
outAtts.SetXLabel(xl);
outAtts.SetYLabel(yl);
outAtts.SetXUnits(atts.GetQueryAtts().GetXUnits());
outAtts.SetYUnits(atts.GetQueryAtts().GetYUnits());
}
outAtts.SetLabels(atts.GetQueryAtts().GetVariables());
if (atts.GetQueryAtts().GetVariables().size() > 1)
outAtts.SetConstructMultipleCurves(true);
else
outAtts.SetConstructMultipleCurves(false);
double bounds[6];
avtDataset_p ds = GetTypedOutput();
avtDatasetExaminer::GetSpatialExtents(ds, bounds);
outAtts.GetThisProcsOriginalSpatialExtents()->Set(bounds);
}
}
void
avtLineoutFilter::PostExecute(void)
{
avtDataAttributes &outAtts = GetOutput()->GetInfo().GetAttributes();
outAtts.GetOriginalSpatialExtents()->Clear();
outAtts.GetDesiredSpatialExtents()->Clear();
double bounds[6];
avtDataset_p ds = GetTypedOutput();
avtDatasetExaminer::GetSpatialExtents(ds, bounds);
outAtts.GetThisProcsOriginalSpatialExtents()->Set(bounds);
}
void
avtMissingDataFilter::PostExecute(void)
{
// Call the base class's PostExecute. Set the spatial dimension to zero to
// bypass a check in avtDataObjectToDatasetFilter::PostExecute that causes
// all unstructured meshes with tdim<sdim to become polydata. We don't want
// that so work around it by setting tdim==sdim. Then we do the PostExecute
// and restore the old value.
avtDataAttributes &outAtts = GetOutput()->GetInfo().GetAttributes();
int sdim = outAtts.GetSpatialDimension();
int tdim = outAtts.GetTopologicalDimension();
if(tdim < sdim && sdim >= 2)
outAtts.SetTopologicalDimension(sdim);
avtDataTreeIterator::PostExecute();
if(tdim < sdim && sdim >= 2)
outAtts.SetTopologicalDimension(tdim);
if(removeMode)
{
// If anyone removed data, redo the original extents.
int dataWasRemoved = (int) this->removedData;
if (canDoCollectiveCommunication)
dataWasRemoved = UnifyMaximumValue(dataWasRemoved);
if(dataWasRemoved > 0)
{
avtDataAttributes &atts = GetInput()->GetInfo().GetAttributes();
avtDataset_p ds = GetTypedOutput();
int nVars = atts.GetNumberOfVariables();
double de[2];
for (int i = 0 ; i < nVars ; i++)
{
const char *vname = atts.GetVariableName(i).c_str();
if (! contract->ShouldCalculateVariableExtents(vname))
continue;
bool foundDE = avtDatasetExaminer::GetDataExtents(ds, de, vname);
if (foundDE)
{
outAtts.GetOriginalDataExtents(vname)->Merge(de);
outAtts.GetThisProcsOriginalDataExtents(vname)->Merge(de);
}
}
}
}
}
void
avtLegacyStreamlineFilter::PostExecute(void)
{
avtDataTreeIterator::PostExecute();
if (coloringMethod == STREAMLINE_COLOR_VORTICITY ||
coloringMethod == STREAMLINE_COLOR_SPEED)
{
double range[2];
avtDataset_p ds = GetTypedOutput();
avtDatasetExaminer::GetDataExtents(ds, range, "colorVar");
avtExtents *e;
e = GetOutput()->GetInfo().GetAttributes().GetCumulativeTrueDataExtents();
e->Merge(range);
e = GetOutput()->GetInfo().GetAttributes().GetCumulativeCurrentDataExtents();
e->Merge(range);
}
}
void
avtResampleFilter::ResampleInput(void)
{
int i, j, k;
avtDataset_p output = GetTypedOutput();
double bounds[6] = { 0, 0, 0, 0, 0, 0 };
bool is3D = GetBounds(bounds);
debug4 << "Resampling over space: " << bounds[0] << ", " << bounds[1]
<< ": " << bounds[2] << ", " << bounds[3] << ": " << bounds[4]
<< ", " << bounds[5] << endl;
//
// Our resampling leaves some invalid values in the data range. The
// easiest way to bypass this is to get the data range from the input and
// pass it along (since resampling does not change it in theory).
//
double range[2];
if (GetInput()->GetInfo().GetAttributes().ValidActiveVariable())
{
GetDataExtents(range);
output->GetInfo().GetAttributes().GetDesiredDataExtents()->Set(range);
}
avtViewInfo view;
double scale[3];
CreateViewFromBounds(view, bounds, scale);
//
// What we want the width, height, and depth to be depends on the
// attributes.
//
int width, height, depth;
GetDimensions(width, height, depth, bounds, is3D);
//
// If there are no variables, then just create the mesh and exit.
//
bool thereAreNoVariables =
(GetInput()->GetInfo().GetAttributes().GetNumberOfVariables() <= 0);
if (thereAreNoVariables)
{
if (PAR_Rank() == 0)
{
vtkRectilinearGrid *rg = CreateGrid(bounds, width, height, depth,
0, width, 0, height, cellCenteredOutput, is3D);
avtDataTree_p tree = new avtDataTree(rg, 0);
rg->Delete();
SetOutputDataTree(tree);
}
else
{
//
// Putting in a NULL data tree can lead to seg faults, etc.
//
avtDataTree_p dummy = new avtDataTree();
SetOutputDataTree(dummy);
}
return;
}
//
// World space is a right-handed coordinate system. Image space (as used
// in the sample point extractor) is a left-handed coordinate system.
// This is because large X is at the right and large Y is at the top.
// The z-buffer has the closest points at z=0, so Z is going away from the
// screen ===> left handed coordinate system. If we reflect across X,
// then this will account for the difference between the coordinate
// systems.
//
scale[0] *= -1.;
//
// We don't want an Update to go all the way up the pipeline, so make
// a terminating source corresponding to our input.
//
avtDataset_p ds;
avtDataObject_p dObj = GetInput();
CopyTo(ds, dObj);
avtSourceFromAVTDataset termsrc(ds);
//
// The sample point extractor expects everything to be in image space.
//
avtWorldSpaceToImageSpaceTransform trans(view, scale);
trans.SetInput(termsrc.GetOutput());
bool doKernel =
(GetInput()->GetInfo().GetAttributes().GetTopologicalDimension() == 0);
avtSamplePointExtractor extractor(width, height, depth);
extractor.SendCellsMode(false);
extractor.Set3DMode(is3D);
extractor.SetInput(trans.GetOutput());
if (doKernel)
extractor.SetKernelBasedSampling(true);
avtSamplePoints_p samples = extractor.GetTypedOutput();
//
// If the selection this filter exists to create has already been handled,
// or if there are no pieces for this processor to process, then we can skip
// execution. But, take care to emulate the same collective
// calls other processors may make before returning.
//
if (GetInput()->GetInfo().GetAttributes().GetSelectionApplied(selID))
{
debug1 << "Bypassing Resample operator because database plugin "
"claims to have applied the selection already" << endl;
SetOutputDataTree(GetInputDataTree());
// we can save a lot of time if we know everyone can bypass
if (UnifyMaximumValue(0) == 0)
return;
// here is some dummied up code to match collective calls below
int effectiveVars = samples->GetNumberOfRealVariables();
double *ptrtmp = new double[width*height*depth];
for (int jj = 0; jj < width*height*depth; jj++)
ptrtmp[jj] = -FLT_MAX;
for (i = 0 ; i < effectiveVars ; i++)
Collect(ptrtmp, width*height*depth);
delete [] ptrtmp;
return;
}
else
{
UnifyMaximumValue(1);
}
//
//
// PROBLEM SIZED WORK OCCURS BEYOND THIS POINT
// If you add (or remove) collective calls below this point, make sure to
// put matching sequence into bypass code above
//
//
avtSamplePointCommunicator communicator;
avtImagePartition partition(width, height, PAR_Size(), PAR_Rank());
communicator.SetImagePartition(&partition);
bool doDistributedResample = false;
#ifdef PARALLEL
doDistributedResample = atts.GetDistributedResample();
#endif
if (doDistributedResample)
{
partition.SetShouldProduceOverlaps(true);
avtDataObject_p dob;
CopyTo(dob, samples);
communicator.SetInput(dob);
samples = communicator.GetTypedOutput();
}
// Always set up an arbitrator, even if user selected random.
bool arbLessThan = !atts.GetUseArbitrator() || atts.GetArbitratorLessThan();
std::string arbName = atts.GetArbitratorVarName();
if (arbName == "default")
arbName = primaryVariable;
extractor.SetUpArbitrator(arbName, arbLessThan);
//
// Since this is Execute, forcing an update is okay...
//
samples->Update(GetGeneralContract());
if (samples->GetInfo().GetValidity().HasErrorOccurred())
{
GetOutput()->GetInfo().GetValidity().ErrorOccurred();
GetOutput()->GetInfo().GetValidity().SetErrorMessage(
samples->GetInfo().GetValidity().GetErrorMessage());
}
//
// Create a rectilinear dataset that is stretched according to the
// original bounds.
//
int width_start = 0;
int width_end = width;
int height_start = 0;
int height_end = height;
if (doDistributedResample)
{
partition.GetThisPartition(width_start, width_end, height_start,
height_end);
width_end += 1;
height_end += 1;
}
//
// If we have more processors than domains, we have to handle that
// gracefully. Communicate how many variables there are so that those
// that don't have data can play well.
//
int realVars = samples->GetNumberOfRealVariables();
int numArrays = realVars;
if (doKernel)
numArrays++;
vtkDataArray **vars = new vtkDataArray*[numArrays];
for (i = 0 ; i < numArrays ; i++)
{
vars[i] = vtkDoubleArray::New();
if (doKernel && (i == numArrays-1))
vars[i]->SetNumberOfComponents(1);
else
{
vars[i]->SetNumberOfComponents(samples->GetVariableSize(i));
vars[i]->SetName(samples->GetVariableName(i).c_str());
}
}
if (doKernel)
samples->GetVolume()->SetUseKernel(true);
avtImagePartition *ip = NULL;
if (doDistributedResample)
ip = &partition;
// We want all uncovered regions to get the default value. That is
// what the first argument of GetVariables is for. But if the
// default value is large, then it will screw up the collect call below,
// which uses MPI_MAX for an all reduce. So give uncovered regions very
// small values now (-FLT_MAX) and then replace them later.
double defaultPlaceholder = -FLT_MAX;
samples->GetVolume()->GetVariables(defaultPlaceholder, vars,
numArrays, ip);
if (!doDistributedResample)
{
//
// Collect will perform the parallel collection. Does nothing in
// serial. This will only be valid on processor 0.
//
for (i = 0 ; i < numArrays ; i++)
{
double *ptr = (double *) vars[i]->GetVoidPointer(0);
Collect(ptr, vars[i]->GetNumberOfComponents()*width*height*depth);
}
}
// Now replace the -FLT_MAX's with the default value. (See comment above.)
for (i = 0 ; i < numArrays ; i++)
{
int numTups = vars[i]->GetNumberOfComponents()
* vars[i]->GetNumberOfTuples();
if (numTups > 0)
{
double *ptr = (double *) vars[i]->GetVoidPointer(0);
for (j = 0 ; j < numTups ; j++)
ptr[j] = (ptr[j] == defaultPlaceholder
? atts.GetDefaultVal()
: ptr[j]);
}
}
bool iHaveData = false;
if (doDistributedResample)
iHaveData = true;
if (PAR_Rank() == 0)
iHaveData = true;
if (height_end > height)
iHaveData = false;
if (iHaveData)
{
vtkRectilinearGrid *rg = CreateGrid(bounds, width, height, depth,
width_start, width_end, height_start,
height_end, cellCenteredOutput, is3D);
if (doKernel)
{
double min_weight = avtPointExtractor::GetMinimumWeightCutoff();
vtkDataArray *weights = vars[numArrays-1];
int numVals = weights->GetNumberOfTuples();
for (i = 0 ; i < realVars ; i++)
{
for (j = 0 ; j < vars[i]->GetNumberOfComponents() ; j++)
{
for (k = 0 ; k < numVals ; k++)
{
double weight = weights->GetTuple1(k);
if (weight <= min_weight)
vars[i]->SetComponent(k, j, atts.GetDefaultVal());
else
vars[i]->SetComponent(k, j,
vars[i]->GetComponent(k, j) / weight);
}
}
}
}
//
// Attach these variables to our rectilinear grid.
//
for (i = 0 ; i < realVars ; i++)
{
const char *varname = vars[i]->GetName();
if (strcmp(varname, primaryVariable) == 0)
{
if (vars[i]->GetNumberOfComponents() == 3)
if (cellCenteredOutput)
rg->GetCellData()->SetVectors(vars[i]);
else
rg->GetPointData()->SetVectors(vars[i]);
else if (vars[i]->GetNumberOfComponents() == 1)
{
if (cellCenteredOutput)
{
rg->GetCellData()->AddArray(vars[i]);
rg->GetCellData()->SetScalars(vars[i]);
}
else
{
rg->GetPointData()->AddArray(vars[i]);
rg->GetPointData()->SetScalars(vars[i]);
}
}
else
{
if (cellCenteredOutput)
rg->GetCellData()->AddArray(vars[i]);
else
rg->GetPointData()->AddArray(vars[i]);
}
}
else
{
if (cellCenteredOutput)
rg->GetCellData()->AddArray(vars[i]);
else
rg->GetPointData()->AddArray(vars[i]);
}
}
avtDataTree_p tree = new avtDataTree(rg, 0);
rg->Delete();
SetOutputDataTree(tree);
}
else
{
//
// Putting in a NULL data tree can lead to seg faults, etc.
//
avtDataTree_p dummy = new avtDataTree();
SetOutputDataTree(dummy);
}
for (i = 0 ; i < numArrays ; i++)
{
vars[i]->Delete();
}
delete [] vars;
}
void
avtSamplePointCommunicator::Execute(void)
{
#ifdef PARALLEL
int timingsIndex = visitTimer->StartTimer();
int nProgressStages = 14;
int currentStage = 1;
//
// We are typically still waiting for the sample point extractors, so put
// in a barrier so this filter can be absolved of blame.
//
int t1 = visitTimer->StartTimer();
Barrier();
visitTimer->StopTimer(t1, "Waiting for other processors to catch up");
UpdateProgress(currentStage++, nProgressStages);
if (imagePartition == NULL)
{
EXCEPTION0(ImproperUseException);
}
int t2 = visitTimer->StartTimer();
EstablishImagePartitionBoundaries();
visitTimer->StopTimer(t2, "Establishing partition boundaries");
UpdateProgress(currentStage++, nProgressStages);
avtVolume *involume = GetTypedInput()->GetVolume();
int volumeWidth = involume->GetVolumeWidth();
int volumeHeight = involume->GetVolumeHeight();
int volumeDepth = involume->GetVolumeDepth();
//
// Have the rays serialize their sample points.
//
int t3 = visitTimer->StartTimer();
int *out_points_count = new int[numProcs];
char **out_points_msgs = new char*[numProcs];
char *tmpcat1 = involume->ConstructMessages(imagePartition,
out_points_msgs, out_points_count);
UpdateProgress(currentStage++, nProgressStages);
visitTimer->StopTimer(t3, "Building sample messages");
//
// Have the cells serialize themselves.
//
int t4 = visitTimer->StartTimer();
avtCellList *incl = GetTypedInput()->GetCellList();
int *out_cells_count = new int[numProcs];
char **out_cells_msgs = new char*[numProcs];
char *tmpcat2 = incl->ConstructMessages(imagePartition, out_cells_msgs,
out_cells_count);
UpdateProgress(currentStage++, nProgressStages);
visitTimer->StopTimer(t4, "Building cell messages");
//
// Determine which cells/points are going where and distribute them in a
// way that minimizes communication.
//
int t5 = visitTimer->StartTimer();
DetermineImagePartitionAssignments(out_points_count, out_cells_count);
UpdateProgress(currentStage++, nProgressStages);
visitTimer->StopTimer(t5, "Assigning image portions to processors");
//
// The messages are set up for image partition assignments of 0->0, 1->1,
// etc. Rework them so that they can be sent in to our CommunicateMessage
// routines.
//
int t6 = visitTimer->StartTimer();
char *pointsOnThisProc;
int numPointsOnThisProc;
char *concat1 = MutateMessagesByAssignment(out_points_msgs,
out_points_count, pointsOnThisProc, numPointsOnThisProc);
delete [] tmpcat1; // No longer needed. out_points_msgs contains the
// same info with the proper ordering.
UpdateProgress(currentStage++, nProgressStages);
visitTimer->StopTimer(t6, "Preparing sample messages to send");
int t7 = visitTimer->StartTimer();
char *cellsOnThisProc;
int numCellsOnThisProc;
char *concat2 = MutateMessagesByAssignment(out_cells_msgs,
out_cells_count, cellsOnThisProc, numCellsOnThisProc);
delete [] tmpcat2; // No longer needed. out_cells_msgs contains the
// same info with the proper ordering.
UpdateProgress(currentStage++, nProgressStages);
visitTimer->StopTimer(t7, "Preparing cell messages to send");
//
// Send the sample points.
//
int t8 = visitTimer->StartTimer();
int *in_points_count = new int[numProcs];
char **in_points_msgs = new char*[numProcs];
char *concat3 = CommunicateMessages(out_points_msgs, out_points_count,
in_points_msgs, in_points_count);
delete [] concat1;
delete [] out_points_count;
delete [] out_points_msgs;
UpdateProgress(currentStage++, nProgressStages);
visitTimer->StopTimer(t8, "Sending sample points");
//
// Send the cells.
//
int t9 = visitTimer->StartTimer();
int *in_cells_count = new int[numProcs];
char **in_cells_msgs = new char*[numProcs];
char *concat4 = CommunicateMessages(out_cells_msgs, out_cells_count,
in_cells_msgs, in_cells_count);
delete [] concat2;
delete [] out_cells_count;
delete [] out_cells_msgs;
UpdateProgress(currentStage++, nProgressStages);
visitTimer->StopTimer(t9, "Sending cells");
//
// Create the output volume and let it know that it only is for a restricted
// part of the volume.
//
int outMinWidth, outMaxWidth, outMinHeight, outMaxHeight;
imagePartition->GetThisPartition(outMinWidth, outMaxWidth, outMinHeight,
outMaxHeight);
int nv = GetTypedInput()->GetNumberOfVariables();
nv = UnifyMaximumValue(nv);
if (GetTypedInput()->GetUseWeightingScheme())
GetTypedOutput()->SetUseWeightingScheme(true);
if (GetTypedOutput()->GetVolume() == NULL)
GetTypedOutput()->SetVolume(volumeWidth, volumeHeight, volumeDepth);
else
GetTypedOutput()->GetVolume()->ResetSamples();
avtVolume *outvolume = GetTypedOutput()->GetVolume();
outvolume->Restrict(outMinWidth, outMaxWidth, outMinHeight, outMaxHeight);
//
// Put the sample points into our output volume.
//
int t10 = visitTimer->StartTimer();
outvolume->ExtractSamples(in_points_msgs, in_points_count, numProcs);
delete [] concat3;
delete [] in_points_count;
delete [] in_points_msgs;
UpdateProgress(currentStage++, nProgressStages);
outvolume->ExtractSamples(&pointsOnThisProc, &numPointsOnThisProc, 1);
delete [] pointsOnThisProc;
UpdateProgress(currentStage++, nProgressStages);
visitTimer->StopTimer(t10, "Getting sample points out of messages");
//
// Extract the sample points from the new cells.
//
int t11 = visitTimer->StartTimer();
avtCellList *outcl = GetTypedOutput()->GetCellList();
outcl->SetJittering(jittering);
outcl->Restrict(outMinWidth, outMaxWidth, outMinHeight, outMaxHeight);
outcl->ExtractCells(in_cells_msgs, in_cells_count, numProcs, outvolume);
UpdateProgress(currentStage++, nProgressStages);
delete [] concat4;
delete [] in_cells_count;
delete [] in_cells_msgs;
outcl->ExtractCells(&cellsOnThisProc, &numCellsOnThisProc, 1, outvolume);
delete [] cellsOnThisProc;
UpdateProgress(currentStage++, nProgressStages);
visitTimer->StopTimer(t11, "Getting sample points out of cells");
visitTimer->StopTimer(timingsIndex, "Sample point communication");
#else
GetTypedOutput()->Copy(*(GetTypedInput()));
#endif
}
