void
avtLocateAndPickNodeQuery::SetInputParams(const MapNode ¶ms)
{
if (params.HasEntry("vars"))
{
const stringVector &v = params.GetEntry("vars")->AsStringVector();
if (v.empty())
EXCEPTION2(QueryArgumentException, "vars", 1);
timeCurveSpecs["nResultsToStore"] = (int)v.size();
pickAtts.SetVariables(v);
}
else
EXCEPTION1(QueryArgumentException, "vars");
if (params.HasNumericVectorEntry("ray_start_point"))
{
doubleVector v;
params.GetEntry("ray_start_point")->ToDoubleVector(v);
if (v.size() != 3)
EXCEPTION2(QueryArgumentException, "ray_start_point", 3);
pickAtts.SetRayPoint1(v);
}
else
EXCEPTION1(QueryArgumentException, "ray_start_point");
if (params.HasNumericVectorEntry("ray_end_point"))
{
doubleVector v;
params.GetEntry("ray_end_point")->ToDoubleVector(v);
if (v.size() != 3)
EXCEPTION2(QueryArgumentException, "ray_end_point", 3);
pickAtts.SetRayPoint2(v);
}
else
EXCEPTION1(QueryArgumentException, "ray_end_point");
if (params.HasNumericEntry("domain"))
domain = params.GetEntry("domain")->ToInt();
else
EXCEPTION1(QueryArgumentException, "domain");
if (params.HasNumericEntry("element"))
node = params.GetEntry("element")->ToInt();
else
EXCEPTION1(QueryArgumentException, "element");
}
void
VisitHotPointInteractor::Start2DMode(INTERACTION_MODE mode)
{
if(!proxy.HasPlots())
{
return;
}
VisitInteractor *newInteractor = NULL;
switch(mode)
{
case NAVIGATE:
if(navigate2D == NULL)
{
navigate2D = new Navigate2D(proxy);
}
newInteractor = navigate2D;
break;
case NODE_PICK:
case ZONE_PICK:
case SPREADSHEET_PICK:
case DDT_PICK:
if(pick == NULL)
{
pick = new Pick(proxy);
}
newInteractor = pick;
break;
case ZOOM:
if(zoom2D == NULL)
{
zoom2D = new Zoom2D(proxy);
}
newInteractor = zoom2D;
break;
case LINEOUT:
if(lineout2D == NULL)
{
lineout2D = new Lineout2D(proxy);
}
newInteractor = lineout2D;
break;
}
if(newInteractor == NULL)
{
//
// We have an invalid navigation mode or an invalid window mode.
//
EXCEPTION1(BadInteractorException, mode);
}
//
// No reason to set the interactor again if it is the same one.
//
if(newInteractor != currentInteractor)
SetInteractor(newInteractor);
}
void
avtTimeIteratorExpression::Execute(void)
{
FinalizeTimeLoop();
avtContract_p contract = ConstructContractWithVarnames();
contract->DisableExtentsCalculations();
// Store off the original expression list.
ParsingExprList *pel = ParsingExprList::Instance();
ExpressionList orig_list = *(pel->GetList());
InitializeOutput();
std::string db = GetInput()->GetInfo().GetAttributes().GetFullDBName();
ref_ptr<avtDatabase> dbp = avtCallback::GetDatabase(db, 0, NULL);
if (*dbp == NULL)
EXCEPTION1(InvalidFilesException, db.c_str());
// The first EEF already set up its expressions ... we need a new one
// to set up filters for the CMFE expressions.
avtExpressionEvaluatorFilter myeef;
myeef.SetInput(GetInput());
for (int i = 0 ; i < numTimeSlicesToProcess ; i++)
{
int timeSlice = firstTimeSlice + i*timeStride;
if (timeSlice > actualLastTimeSlice)
timeSlice = actualLastTimeSlice;
debug1 << "Time iterating expression working on time slice "
<< timeSlice << endl;
UpdateExpressions(timeSlice);
// won't re-execute without setting modified to true, because
// it doesn't check to see if expression definitions change.
myeef.ReleaseData();
myeef.GetOutput()->Update(contract);
avtCallback::ResetTimeout(5*60);
Barrier();
avtCallback::ResetTimeout(5*60);
avtDatabaseMetaData *md = dbp->GetMetaData(timeSlice, false,
false, false);
currentCycle = md->GetCycles()[timeSlice];
currentTime = md->GetTimes()[timeSlice];
ProcessDataTree(myeef.GetTypedOutput()->GetDataTree(), i);
debug1 << "Time iterating expression done working on time slice "
<< timeSlice << endl;
}
// Get the upstream filters back the way they are supposed to be.
GetInput()->Update(executionContract);
FinalizeOutput();
// Restore the original expression list ... i.e. undo the temporary
// expressions we put in.
*(pel->GetList()) = orig_list;
}
vtkDataArray *
ADIOSFileObject::AllocateArray(ADIOS_DATATYPES &t)
{
vtkDataArray *array = NULL;
switch (t)
{
case adios_unsigned_byte:
array = vtkCharArray::New();
break;
case adios_byte:
array = vtkUnsignedCharArray::New();
break;
case adios_string:
array = vtkCharArray::New();
break;
case adios_unsigned_short:
array = vtkUnsignedShortArray::New();
break;
case adios_short:
array = vtkShortArray::New();
break;
case adios_unsigned_integer:
array = vtkUnsignedIntArray::New();
break;
case adios_integer:
array = vtkIntArray::New();
break;
case adios_unsigned_long:
array = vtkUnsignedLongArray::New();
break;
case adios_long:
array = vtkLongArray::New();
break;
case adios_real:
array = vtkFloatArray::New();
break;
case adios_double:
array = vtkDoubleArray::New();
break;
case adios_long_double: // 16 bytes
case adios_complex: // 8 bytes
case adios_double_complex: // 16 bytes
default:
std::string str = "Inavlid variable type";
EXCEPTION1(InvalidVariableException, str);
break;
}
return array;
}
// ****************************************************************************
// Method: VisitHotPointInteractor::StartAxisArrayMode
//
// Purpose:
// Sets up the interactors for axis array window mode.
//
// Arguments:
// mode the interaction mode
//
// Programmer: Jeremy Meredith
// Creation: January 31, 2008
//
// Modifications:
// Jeremy Meredith, Mon Feb 4 13:24:08 EST 2008
// Added zoom interactor for AxisArray mode.
//
// Gunther H. Weber, Wed Mar 19 16:10:11 PDT 2008
// Added SPREADSHEET_PICK
//
// Eric Brugger, Tue Dec 9 16:32:45 PST 2008
// Added code to set the axis orientation for the navigateAxisArray.
//
// Jonathan Byrd (Allinea Software), Sun Dec 18, 2011
// Added the DDT_PICK mode
//
// Eric Brugger, Mon Nov 5 15:48:46 PST 2012
// I added the ability to display the parallel axes either horizontally
// or vertically.
//
// ****************************************************************************
void
VisitHotPointInteractor::StartAxisArrayMode(INTERACTION_MODE mode)
{
if (!proxy.HasPlots())
{
return;
}
VisitInteractor *newInteractor = NULL;
switch(mode)
{
case LINEOUT:
// We don't have a lineout or zoom interaction.
// Fall through to navigation mode.
case NAVIGATE:
if (navigateAxisArray == NULL)
{
navigateAxisArray = new NavigateAxisArray(proxy);
}
navigateAxisArray->SetAxisOrientation(NavigateAxisArray::Vertical);
navigateAxisArray->SetDomainOrientation(NavigateAxisArray::Horizontal);
newInteractor = navigateAxisArray;
break;
case ZOOM:
if(zoomAxisArray == NULL)
{
zoomAxisArray = new ZoomAxisArray(proxy);
}
newInteractor = zoomAxisArray;
break;
case ZONE_PICK:
case NODE_PICK:
case SPREADSHEET_PICK:
case DDT_PICK:
if (pick == NULL)
{
pick = new Pick(proxy);
}
newInteractor = pick;
break;
}
if (newInteractor == NULL)
{
//
// We have an invalid navigation mode or an invalid window mode.
//
EXCEPTION1(BadInteractorException, mode);
}
//
// No reason to set the interactor again if it is the same one.
//
if (newInteractor != currentInteractor)
SetInteractor(newInteractor);
}
avtIVPVTKTimeVaryingField::avtIVPVTKTimeVaryingField( vtkDataSet* dataset,
avtCellLocator* locator,
double _t0, double _t1 )
: ds(dataset), loc(locator), t0(_t0), t1(_t1), dt(_t1-_t0)
{
if( ds )
ds->Register( NULL );
if( (velData[0] = ds->GetPointData()->GetVectors()) )
{
velCellBased = false;
velData[1] = ds->GetPointData()->GetArray( NextTimePrefix );
}
else if( (velData[0] = ds->GetCellData()->GetVectors()) )
{
velCellBased = true;
velData[1] = ds->GetCellData()->GetArray( NextTimePrefix );
}
else
{
velData[0] = velData[1] = NULL;
EXCEPTION1( ImproperUseException,
"avtIVPVTKTimeVaryingField: Can't locate vectors to interpolate." );
}
if( velData[1] == NULL )
{
EXCEPTION1( ImproperUseException,
"avtIVPVTKTimeVaryingField: Can't locate second pair of vectors to interpolate." );
}
lastCell = -1;
lastPos.x = lastPos.y = lastPos.z =
std::numeric_limits<double>::quiet_NaN();
std::fill( sclData[0], sclData[0]+256, (vtkDataArray*)NULL );
std::fill( sclData[1], sclData[1]+256, (vtkDataArray*)NULL );
std::fill( sclCellBased, sclCellBased+256, false );
sclDataName.resize( 256 );
}
void
avtLineScanQuery::PreExecute(void)
{
avtDatasetQuery::PreExecute();
if (numBins <= 0)
{
EXCEPTION1(VisItException, "There must be at least one bin.");
}
if (numLines <= 0)
{
EXCEPTION1(VisItException, "There must be at least one line.");
}
if (minLength < 0 || maxLength <= minLength)
{
EXCEPTION1(VisItException, "The min length must be less than the max "
"length and they both must be positive.");
}
}
void
avtExecuteThenTimeLoopFilter::FinalizeTimeLoop()
{
int numStates = GetInput()->GetInfo().GetAttributes().GetNumStates();
if (startTime < 0)
{
startTime = 0;
}
if (endTime < 0)
{
endTime = numStates - 1;
}
if (stride < 0)
{
stride = 1;
}
if (startTime > endTime)
{
std::string msg("Start time must be smaller than or equal to the end time for " );
msg += GetType();
msg += ".\n";
EXCEPTION1(ImproperUseException, msg);
}
nFrames = (int) ceil((((float)endTime-startTime))/(float)stride) + 1;
// ARS - This check will always pass because of the additional
// frame added to nFrames above and startTime must be greater than
// or equal to endTime. Thus it is commented out.
// if (nFrames < 1)
// {
// std::string msg(GetType());
// msg = msg + " requires at least 1 frame, please correct start " +
// "and end times and try again.";
// EXCEPTION1(ImproperUseException, msg);
// }
if (endTime >= numStates)
{
std::string msg(GetType());
msg += ": Clamping end time to number of available timesteps.";
avtCallback::IssueWarning(msg.c_str());
}
//
// Ensure that the specified endTime is included,
// regardless of the stride.
//
actualEnd = startTime + nFrames * stride;
if (actualEnd < endTime)
actualEnd = endTime + stride;
}
void
avtGTCFileFormat::BinData( int dim, parallelBuffer **array, float *vars, float *ids,
float **myVarsPtr, float **myIdsPtr )
{
int ptCnt = nTotalPoints / nProcs;
int remainder = nTotalPoints % nProcs;
float *ptrIDs = ids, *ptrVars = vars, *myVars = *myVarsPtr, *myIds = *myIdsPtr;
float *data = new float[dim+1];
for ( int i = 0; i < nPoints; i++ )
{
int id = ((int) *ptrIDs) - 1; //Make the id 0...N-1 for the math below.
int whichProc;
// Determine which processor this ID goes to.
if ( id < (remainder * (ptCnt+1)) )
whichProc = id / (ptCnt+1);
else
{
int id2 = id - (remainder * (ptCnt+1));
whichProc = remainder + id2/ptCnt;
}
if ( whichProc < 0 || whichProc >= nProcs )
{
char str[512];
sprintf( str, "Bad Id mapping: %d ==> %d\n", id, whichProc );
EXCEPTION1( InvalidDBTypeException, str );
}
// This is our data, so copy it to the front of the var, ids arrays.
if ( whichProc == rank )
{
// ID
*myIds++ = *ptrIDs++;
for ( int j = 0; j < dim; j++ )
*myVars++ = *ptrVars++;
}
// This data isn't ours. Stash it in the buffer to be sent.
else
{
// ID
data[0] = *ptrIDs++;
for ( int j = 0; j < dim; j++ )
data[j+1] = *ptrVars++;
array[whichProc]->Add( data );
}
}
delete [] data;
*myIdsPtr = myIds;
*myVarsPtr = myVars;
}
vtkDataArray *
avtADIOSBasicFileFormat::GetVar(int timestate, int domain, const char *varname)
{
debug1 << "avtADIOSBasicFileFormat::GetVar " << varname << endl;
Initialize();
vtkFloatArray *arr = NULL;
if (! fileObj->ReadVariable(varname, timestate, &arr))
EXCEPTION1(InvalidVariableException, varname);
return arr;
}
OperatorPluginManager *
ViewerProxy::GetOperatorPluginManager() const
{
if(operatorPlugins == 0)
{
EXCEPTION1(ImproperUseException, "ViewerProxy::InitializePlugins "
"must be called before ViewerProxy::GetOperatorPluginManager");
}
return operatorPlugins;
}
avtFileFormatInterface *
VASP_CreateFileFormatInterface(const char * const *list, int nList, int nBlock)
{
avtFileFormatInterface *ffi = 0;
if (list != 0 && nList > 0)
{
// Determine the type of reader that we want to use.
int flavor = -1;
TRY
{
std::string fn(list[0]);
if(flavor == -1 && avtOUTCARFileFormat::Identify(fn))
{
flavor = 0;
debug4 << "Database is avtOUTCARFileFormat" << endl;
}
if(flavor == -1 && avtCHGCARFileFormat::Identify(fn))
{
flavor = 1;
debug4 << "Database is avtCHGCARFileFormat" << endl;
}
if(flavor == -1 && avtPOSCARFileFormat::Identify(fn))
{
flavor = 2;
debug4 << "Database is avtPOSCARFileFormat" << endl;
}
if(flavor == -1)
{
EXCEPTION1(InvalidFilesException, list[0]);
}
}
CATCH(VisItException)
{
RETHROW;
}
ENDTRY
switch(flavor)
{
case 0:
ffi = avtOUTCARFileFormat::CreateInterface(list, nList, nBlock);
break;
case 1:
ffi = avtCHGCARFileFormat::CreateInterface(list, nList, nBlock);
break;
case 2:
ffi = avtPOSCARFileFormat::CreateInterface(list, nList, nBlock);
break;
}
}
void
avtIVPVTKTimeVaryingField::SetScalarVariable(unsigned char index, const std::string& name)
{
vtkDataArray* data[2] = { NULL, NULL };
bool cellBased;
if( (data[0] = ds->GetPointData()->GetScalars( name.c_str() )) )
{
cellBased = false;
data[1] =
ds->GetPointData()->GetArray( (NextTimePrefix+name).c_str() );
}
else if( (data[0] = ds->GetCellData()->GetScalars( name.c_str() )) )
{
cellBased = true;
data[1] =
ds->GetCellData()->GetArray( (NextTimePrefix+name).c_str() );
}
else
EXCEPTION1( ImproperUseException,
"avtIVPVTKTimeVaryingField: Can't locate scalar \"" + name +
"\" to interpolate." );
/* TODO. not sure we want all data to have a second value
if( data[1] == NULL )
EXCEPTION1( ImproperUseException,
"avtIVPVTKTimeVaryingField: Can't locate next scalar \"" + name +
"\" to interpolate." );
*/
if( data[0]->GetNumberOfComponents() != 1 ||
(data[1] && data[1]->GetNumberOfComponents() != 1) )
EXCEPTION1( ImproperUseException,
"avtIVPVTKTimeVaryingField: Given variable \"" + name +
"\" is not scalar." );
sclDataName[index] = name;
sclData[0][index] = data[0];
sclData[1][index] = data[1];
sclCellBased[index] = cellBased;
}
void
avtFluxFilter::InferVariableNameFromContract(avtContract_p c)
{
avtDataRequest_p in_dr = c->GetDataRequest();
bool foundIt = false;
if (strncmp(in_dr->GetVariable(), "operators/Flux/",
strlen("operators/Flux/")) == 0)
{
foundIt = true;
if (atts.GetFlowField() == "default")
{
EXCEPTION1(VisItException, "You can't set the flow field as \"default\" "
"since the default field is not a vector.");
}
if (atts.GetWeight() && atts.GetWeightField() == "default")
{
EXCEPTION1(VisItException, "You can't set the weighting field as \"default\" "
"since that would lead to a recursive definition.");
}
varname = in_dr->GetVariable()+strlen("operators/Flux/");
}
if (!foundIt)
{
std::vector<CharStrRef> vars2nd = in_dr->GetSecondaryVariablesWithoutDuplicates();
for (size_t i = 0 ; i < vars2nd.size() ; i++)
if (strncmp(*(vars2nd[i]), "operators/Flux/",
strlen("operators/Flux/")) == 0)
{
foundIt = true;
varname = *(vars2nd[i])+strlen("operators/Flux/");
}
}
if (!foundIt)
{
EXCEPTION1(VisItException, "Unable to determine variable name from contract");
}
}
void
avtShapeletDecompositionQuery::SetInputParams(const MapNode & params)
{
if (params.HasNumericEntry("beta"))
{
double b = params.GetEntry("beta")->ToDouble();
if (b < 1.0)
{
EXCEPTION1(VisItException, "Shapelet Decomposition requires "
"beta and nmax >= 1.");
}
SetBeta(b);
}
else
{
SetBeta(1.0);
}
if (params.HasNumericEntry("nmax"))
{
int m = params.GetEntry("nmax")->ToInt();
SetNMax(m < 1 ? 1 : m);
}
SetDecompOutputFileName("");
if (params.HasEntry("recomp_file"))
{
std::string rf(params.GetEntry("recomp_file")->AsString());
if (rf.empty())
{
EXCEPTION1(QueryArgumentException, "recomp_file");
}
SetRecompOutputFileName(rf);
}
else
{
SetRecompOutputFileName("");
}
}
avtCellLocatorRect::avtCellLocatorRect( vtkDataSet* ds ) :
avtCellLocator( ds )
{
vtkRectilinearGrid* rg = vtkRectilinearGrid::SafeDownCast( dataSet );
if( dataSet->GetDataObjectType() != VTK_RECTILINEAR_GRID || rg == NULL )
EXCEPTION1( ImproperUseException, "avtCellLocatorRect: Dataset is not rectilinear." );
// copy the coordinate arrays for faster access later
vtkDataArray* ca[3] = {
rg->GetXCoordinates(),
rg->GetYCoordinates(),
rg->GetZCoordinates(),
};
for( unsigned int d=0; d<3; ++d )
{
coord[d].resize( ca[d]->GetNumberOfTuples() );
ascending[d] = true;
for( unsigned int i=0; i<coord[d].size(); ++i )
{
coord[d][i] = ca[d]->GetComponent( i, 0 );
if (i == 1)
{
if (coord[d][1] < coord[d][0])
ascending[d] = false;
}
else if (i > 1)
{
bool thisPairAscending = (coord[d][i] > coord[d][i-1]);
if (thisPairAscending != ascending[d])
{
EXCEPTION1( ImproperUseException, "avtCellLocatorRect: Coordinate "
"arrays are not monotonic.");
}
}
}
}
}
const std::string &
ViewerProxy::GetLocalUserName() const
{
if(viewer == 0 && viewerP == 0)
{
EXCEPTION1(VisItException, "Viewer not created.");
}
if(viewer != 0)
return viewer->GetLocalUserName();
return viewerP->GetLocalUserName();
}
void
ADIOSFileObject::OpenGroup(int grpIdx)
{
if (!gps)
return;
if (gps[grpIdx] == NULL)
gps[grpIdx] = adios_gopen_byid(fp, grpIdx);
if (gps[grpIdx] == NULL)
{
std::string errmsg = "Error opening group "+std::string(fp->group_namelist[grpIdx])+" in " + fileName;
EXCEPTION1(InvalidDBTypeException, errmsg.c_str());
}
}
int
avtScalarMetaData::AddEnumNameRange(std::string name, double min, double max)
{
if (min > max)
{
EXCEPTION1(ImproperUseException, name);
}
enumNames.push_back(name);
enumRanges.push_back(min);
enumRanges.push_back(max);
return enumNames.size() - 1;
}
void
avtRayCompositer::InsertOpaqueImage(avtImage_p img)
{
avtImageRepresentation &rep = img->GetImage();
if (rep.GetZBuffer() == NULL)
{
//
// How can we incorporate an image if it has no zbuffer?
//
EXCEPTION1(ImproperUseException, "Need Z buffer.");
}
opaqueImage = img;
}
void
avtNamedSelectionManager::CreateNamedSelection(avtDataObject_p dob,
const SelectionProperties &selProps, avtNamedSelectionExtension *ext)
{
const char *mName = "avtNamedSelectionManager::CreateNamedSelection: ";
StackTimer t0("CreateNamedSelection");
if (strcmp(dob->GetType(), "avtDataset") != 0)
{
EXCEPTION1(VisItException, "Named selections only work on data sets");
}
// Save the selection properties.
AddSelectionProperties(selProps);
// Augment the contract based on the selection properties.
avtContract_p c0 = dob->GetContractFromPreviousExecution();
bool needsUpdate = false;
avtContract_p contract = ext->ModifyContract(c0, selProps, needsUpdate);
//
// Let the input try to create the named selection ... some have special
// logic, for example the parallel coordinates filter.
//
const std::string &selName = selProps.GetName();
avtNamedSelection *ns = NULL;
if(selProps.GetSelectionType() == SelectionProperties::BasicSelection)
{
ns = dob->GetSource()->CreateNamedSelection(contract, selName);
if (ns != NULL)
{
int curSize = selList.size();
selList.resize(curSize+1);
selList[curSize] = ns;
//
// Save out the named selection in case of engine crash /
// save/restore session, etc.
//
SaveNamedSelection(selName, true);
return;
}
}
//
// Call into the extension to get the per-processor named selection.
//
TimedCodeBlock("Creating selection in extension",
ns = ext->GetSelection(dob, selProps, cache);
);
vtkDataSet *
avtADIOSBasicFileFormat::GetMesh(int timestate, int domain, const char *meshname)
{
debug1 << "avtADIOSBasicFileFormat::GetMesh " << meshname << endl;
Initialize();
// Look it up in the mesh table.
std::map<std::string,meshInfo>::const_iterator m = meshes.find(meshname);
if (m != meshes.end())
{
vtkRectilinearGrid *grid = NULL;
grid = CreateUniformGrid(m->second.start,
m->second.count);
grid->Register(NULL);
return grid;
}
//It might be a curve.
std::map<std::string, ADIOSVar>::const_iterator v = fileObj->variables.find(meshname);
if (v != fileObj->variables.end() && v->second.dim == 1)
{
vtkRectilinearGrid *grid = NULL;
grid = CreateUniformGrid(v->second.start,
v->second.count);
vtkFloatArray *vals = NULL;
if (!fileObj->ReadVariable(meshname, timestate, &vals))
EXCEPTION1(InvalidVariableException, meshname);
vals->SetName(meshname);
grid->GetPointData()->SetScalars(vals);
vals->Delete();
grid->Register(NULL);
return grid;
}
debug1<<meshname<<" not found"<<endl;
EXCEPTION1(InvalidVariableException, meshname);
}
vtkDataArray *
avtMM5FileFormat::GetVar(int timestate, const char *varname)
{
mm5_fieldinfo_t *field = 0;
Initialize();
if(mm5file == 0)
{
EXCEPTION1(InvalidVariableException, varname);
}
field = mm5_file_find_field(mm5file, varname, timestate);
if(field == 0)
{
EXCEPTION1(InvalidVariableException, varname);
}
// Set up the return array.
vtkFloatArray *rv = vtkFloatArray::New();
int n_elements = field->header.end_index[0] *
field->header.end_index[1] *
field->header.end_index[2] *
field->header.end_index[3];
rv->SetNumberOfTuples(n_elements);
float *fptr = (float *)rv->GetVoidPointer(0);
// Read the data directly into the array.
if(mm5_file_read_field(mm5file, varname, timestate, fptr) == 0)
{
rv->Delete();
EXCEPTION1(InvalidVariableException, varname);
}
return rv;
}
// ****************************************************************************
// Method: avtConnComponentsLengthQuery::Execute
//
// Purpose:
// Processes a single input domain to update the per component area sums.
//
// Arguments:
// ds Input dataset
// dom Input domain number
//
// Programmer: Cyrus Harrison
// Creation: Wed Jun 15 13:09:43 PDT 2011
//
// ****************************************************************************
void
avtConnComponentsLengthQuery::Execute(vtkDataSet *ds, const int dom)
{
// get the number of cells to process
int ncells = ds->GetNumberOfCells();
// get the component labels and volume arrays
vtkIntArray *labels =(vtkIntArray*)ds->GetCellData()->GetArray("avt_ccl");
vtkDataArray *vol= ds->GetCellData()->GetArray("avt_weight");
// make sure the volume and component label arrays are valid
if (vol == NULL)
{
EXCEPTION1(InvalidVariableException, "avt_weight");
}
if (labels == NULL)
{
EXCEPTION1(InvalidVariableException, "avt_ccl");
}
double len_val = 0.0;
// loop over all cells
for (int i = 0 ; i < ncells ; i++)
{
// get the cell & and its component label
vtkCell *cell = ds->GetCell(i);
int comp_id = labels->GetValue(i);
// get cell area
len_val = (double) vol->GetTuple1(i);
// add to total component area
lengthPerComp[comp_id] += len_val;
}
}
/** Method: avtGGCM constructor
* Programmer: tfogal -- generated by xml2avt
* Creation: Thu Jun 1 13:38:54 PST 2006 */
avtGGCMFileFormat::avtGGCMFileFormat(const char *filename,
DBOptionsAttributes *db)
: avtMTSDFileFormat(&filename, 1)
{
assert(filename != NULL);
DeriveGridFile(filename, &this->fn_grid);
if(this->fn_grid == NULL)
{
EXCEPTION1(InvalidDBTypeException, "Could not derive grid filename.");
}
this->selList.clear();
this->selsApplied = NULL;
this->restricted = false;
}
void
ADIOSFileObject::CloseGroup(int grpIdx)
{
if (!gps)
return;
if (gps[grpIdx] != NULL)
{
int val = adios_gclose(gps[grpIdx]);
gps[grpIdx] = NULL;
if (val != 0)
{
std::string errmsg = "Error closing group "+std::string(fp->group_namelist[grpIdx])+" in " + fileName;
EXCEPTION1(InvalidDBTypeException, errmsg.c_str());
}
}
}
int *
avtGTCFileFormat::GetDataShareMatrix( parallelBuffer **array )
{
// Binning done, now tell everyone else how many particles we have for them.
int *particleCnts = new int[nProcs], *gatherCnts = new int[nProcs*nProcs];
for ( int i = 0; i < nProcs; i++ )
particleCnts[i] = array[i]->Size();
// Allgather is a little overkill, but there isn't much data.
int err = MPI_Allgather( particleCnts, nProcs, MPI_INT,
gatherCnts, nProcs*nProcs, MPI_INT, VISIT_MPI_COMM );
if ( err != MPI_SUCCESS )
EXCEPTION1(InvalidDBTypeException, "GTC Reader: MPI_Allgather() failure." );
return gatherCnts;
}
avtCellList *
avtSamplePoints::GetCellList(void)
{
if (varnames.size() <= 0)
{
EXCEPTION1(VisItException,
"Degenerate case: asked to resample a data set with no variables."
" This has not been implemented.");
}
if (celllist == NULL)
{
celllist = new avtCellList(GetNumberOfVariables());
}
return celllist;
}
AdvDocument *
GetDocument(AdvDocFile *f, const std::string &var)
{
AdvDocument *doc = adv_dio_open_by_property(f, 0,
"content_type", "HDDM_FEGenericAttribute",
"label", var.c_str(), 0);
if(doc == 0)
{
doc = adv_dio_open_by_property(f, 0,
"content_type", "FEGenericAttribute",
"label", var.c_str(), 0);
}
if(doc == 0)
{
EXCEPTION1(InvalidVariableException, var.c_str());
}
return doc;
}
const std::string &
ViewerProxy::GetLocalHostName() const
{
if(viewer == 0 && viewerP == 0)
{
EXCEPTION1(VisItException, "Viewer not created.");
}
if(viewer != 0)
return viewer->GetLocalHostName();
#if 0
return viewerP->GetLocalHostName();
#else
cerr << "Fix ViewerProxy::GetLocalHostName: " << __LINE__ << endl;
return *(new std::string("localhost"));
#endif
}
