void
avtTraceExpression::DoOperation(vtkDataArray *in, vtkDataArray *out,
int ncomponents, int ntuples)
{
if (ncomponents == 9)
{
for (int i = 0 ; i < ntuples ; i++)
{
double val1 = in->GetComponent(i, 0);
double val2 = in->GetComponent(i, 4);
double val3 = in->GetComponent(i, 8);
out->SetTuple1(i, val1+val2+val3);
}
}
else
{
EXCEPTION2(ExpressionException, outputVariableName, "Cannot take trace of non-tensor.");
}
}
void
avtArraySumExpression::ProcessArguments(ArgsExpr *args,
ExprPipelineState *state)
{
// Check the number of arguments
std::vector<ArgExpr*> *arguments = args->GetArgs();
int nargs = arguments->size();
if (nargs != 1)
{
EXCEPTION2(ExpressionException, outputVariableName,
"this expression must be specified with exactly one "
"arguments. Usage: array_sum(array)");
}
// Tell the first argument to create its filters.
ArgExpr *firstarg = (*arguments)[0];
avtExprNode *firstTree = dynamic_cast<avtExprNode*>(firstarg->GetExpr());
firstTree->CreateFilters(state);
}
void
VisWinTools::SetToolEnabled(int i, bool val)
{
if(i < 0 || i > numTools)
EXCEPTION2(BadIndexException, 0, numTools);
if(val)
tools[i]->Enable();
else
{
if (toolProxy.GetToolUpdateMode() == UPDATE_ONCLOSE)
tools[i]->CallCallback();
tools[i]->Disable();
}
UpdateHighlight();
toolProxy.RecalculateRenderOrder();
toolProxy.Render();
}
void
avtEigenvalueExpression::DoOperation(vtkDataArray *in, vtkDataArray *out,
int ncomponents, int ntuples)
{
if (ncomponents == 9)
{
for (int i = 0 ; i < ntuples ; i++)
{
double *vals = in->GetTuple9(i);
double *input[3];
double row1[3];
double row2[3];
double row3[3];
input[0] = row1;
input[1] = row2;
input[2] = row3;
input[0][0] = vals[0];
input[0][1] = vals[1];
input[0][2] = vals[2];
input[1][0] = vals[3];
input[1][1] = vals[4];
input[1][2] = vals[5];
input[2][0] = vals[6];
input[2][1] = vals[7];
input[2][2] = vals[8];
double *eigenvecs[3];
double outrow1[3];
double outrow2[3];
double outrow3[3];
eigenvecs[0] = outrow1;
eigenvecs[1] = outrow2;
eigenvecs[2] = outrow3;
double eigenvals[3];
vtkMath::Jacobi(input, eigenvals, eigenvecs);
out->SetTuple(i, eigenvals);
}
}
else
{
EXCEPTION2(ExpressionException, outputVariableName, "Cannot determine tensor type");
}
}
void
avtLogicalAndExpression::DoOperation(vtkDataArray *in1, vtkDataArray *in2,
vtkDataArray *out, int ncomponents,
int ntuples)
{
int in1ncomps = in1->GetNumberOfComponents();
int in2ncomps = in2->GetNumberOfComponents();
if (in1ncomps != 1 || in2ncomps != 1)
{
EXCEPTION2(ExpressionException, outputVariableName,
"Cannot logically and vector variables.");
}
for (int i = 0 ; i < ntuples ; i++)
{
bool val1, val2;
if (in1->GetDataType() == VTK_UNSIGNED_CHAR)
{
val1 = (unsigned char) in1->GetTuple1(i);
}
else
{
val1 = (in1->GetTuple1(i) != 0. ? true : false);
}
if (in2->GetDataType() == VTK_UNSIGNED_CHAR)
{
val2 = (unsigned char) in2->GetTuple1(i);
}
else
{
val2 = (in2->GetTuple1(i) != 0. ? true : false);
}
unsigned char outval = val1 && val2;
out->SetTuple1(i, outval);
}
}
avtContract_p
avtApplyDataBinningExpression::ModifyContract(avtContract_p spec)
{
if (theDataBinning == NULL)
{
// We should have failed before getting to this point...
EXCEPTION2(ExpressionException, outputVariableName,
"Could not locate the data binning.");
}
avtDataRequest_p ds = spec->GetDataRequest();
avtDataRequest_p new_ds = new avtDataRequest(ds);
avtDataBinningFunctionInfo *info = theDataBinning->GetFunctionInfo();
int nVars = info->GetDomainNumberOfTuples();
for (int i = 0 ; i < nVars ; i++)
new_ds->AddSecondaryVariable(info->GetDomainTupleName(i).c_str());
new_ds->AddSecondaryVariable(info->GetCodomainName().c_str());
avtContract_p rv = new avtContract(spec, new_ds);
rv = avtSingleInputExpressionFilter::ModifyContract(rv);
return rv;
}
void
avtMinMaxExpression::DoOperation(vtkDataArray *in1, vtkDataArray *in2,
vtkDataArray *out, int ncomponents,int ntuples)
{
bool var1IsSingleton = (in1->GetNumberOfTuples() == 1);
bool var2IsSingleton = (in2->GetNumberOfTuples() == 1);
int in1ncomps = in1->GetNumberOfComponents();
int in2ncomps = in2->GetNumberOfComponents();
if (in1ncomps == in2ncomps)
{
for (int i = 0 ; i < ntuples ; i++)
{
for (int j = 0 ; j < in1ncomps ; j++)
{
int tup1 = (var1IsSingleton ? 0 : i);
int tup2 = (var2IsSingleton ? 0 : i);
double val1 = in1->GetComponent(tup1, j);
double val2 = in2->GetComponent(tup2, j);
bool val1Bigger = (val1 > val2);
// Circumflex (^) is the exclusive or.
// doMin == true && val1Bigger == true --> val2
// doMin == false && val1Bigger == true --> val1
// doMin == true && val1Bigger == false --> val1
// doMin == false && val1Bigger == false --> val2
// --> values same, then val2, values different, then val1
double outval = (doMin ^ val1Bigger ? val1 : val2);
out->SetComponent(i, j, outval);
}
}
}
else
{
EXCEPTION2(ExpressionException, outputVariableName,
"Don't know how to take minimums or "
"maximums with data of differing dimensions.");
}
}
void
avtRelativeDifferenceExpression::DoOperation(vtkDataArray *in1,
vtkDataArray *in2, vtkDataArray *out, int ncomponents,int ntuples)
{
vtkIdType in1ncomps = in1->GetNumberOfComponents();
vtkIdType in2ncomps = in2->GetNumberOfComponents();
if (in1ncomps != 1 || in2ncomps != 1)
{
EXCEPTION2(ExpressionException, outputVariableName,
"Can only take relative difference of scalars.");
}
vtkIdType ntups = out->GetNumberOfTuples();
for (vtkIdType i = 0 ; i < ntups ; i++)
{
double val1 = in1->GetComponent(i, 0);
double val2 = in2->GetComponent(i, 0);
double outval = 0.;
if (val1 != 0. || val2 != 0.)
outval = (val1-val2) / (fabs(val1) + fabs(val2));
out->SetComponent(i, 0, outval);
}
}
void
avtTestGreaterThanOrEqualToExpression::DoOperation(vtkDataArray *in1,
vtkDataArray *in2, vtkDataArray *out, int ncomponents, int ntuples)
{
bool var1IsSingleton = (in1->GetNumberOfTuples() == 1);
bool var2IsSingleton = (in2->GetNumberOfTuples() == 1);
int in1ncomps = in1->GetNumberOfComponents();
int in2ncomps = in2->GetNumberOfComponents();
if (in1ncomps != 1 || in2ncomps != 1)
{
EXCEPTION2(ExpressionException, outputVariableName,
"Cannot compare vector variables.");
}
for (int i = 0 ; i < ntuples ; i++)
{
int tup1 = (var1IsSingleton ? 0 : i);
int tup2 = (var2IsSingleton ? 0 : i);
unsigned char outval = (in1->GetTuple1(tup1) >= in2->GetTuple1(tup2)
? '\1' : '\0');
out->SetTuple1(i, outval);
}
}
void
avtMultiCurveLabelMapper::GetLevelColor(const int levelNum, double col[4])
{
int nc = cal.GetNumColors();
if (nc == 1) // constant color for all levels
{
col[0] = cal[0].Red() * INV_255;
col[1] = cal[0].Green() * INV_255;
col[2] = cal[0].Blue() * INV_255;
col[3] = cal[0].Alpha() * INV_255;
return;
}
if (levelNum < 0 || levelNum >= nc)
{
EXCEPTION2(BadIndexException, levelNum, nc);
}
col[0] = cal[levelNum].Red() * INV_255;
col[1] = cal[levelNum].Green() * INV_255;
col[2] = cal[levelNum].Blue() * INV_255;
col[3] = cal[levelNum].Alpha() * INV_255;
}
void
avtTimeIteratorExpression::AddInputVariableName(const char *v)
{
if (varnames.size() < NumberOfVariables())
varnames.push_back(v);
else
{
if (varnames.size() == NumberOfVariables() && cmfeType == POS_CMFE)
{
// Need to remove quotes around the variable (if any), since that
// won't be parsed well.
std::string var_wo_quotes = std::string(v);
for (int j = var_wo_quotes.size()-1 ; j >= 0 ; j--)
if (var_wo_quotes[j] == '\'')
var_wo_quotes.replace(j,1,"");
varnames.push_back(var_wo_quotes);
}
else
{
EXCEPTION2(ExpressionException, outputVariableName,
"An internal error occurred.");
}
}
}
void
avtVariableSkewExpression::DoOperation(vtkDataArray *in1, vtkDataArray *in2,
vtkDataArray *out, int ncomponents,
int ntuples)
{
vtkIdType in1ncomps = in1->GetNumberOfComponents();
vtkIdType in2ncomps = in2->GetNumberOfComponents();
if (in1ncomps == 1 && in2ncomps == 1)
{
double *r = in1->GetRange();
for (int i = 0 ; i < ntuples ; i++)
{
double val1 = in1->GetComponent(i, 0);
double val2 = in2->GetComponent(i, 0);
double f = vtkSkewValue(val1, r[0], r[1], val2);
out->SetComponent(i, 0, f);
}
}
else
{
EXCEPTION2(ExpressionException, outputVariableName, "Skew can only be "
"used on scalar variables.");
}
}
void
avtMultiCurveLabelMapper::SetDatasetInput(vtkDataSet *ds, int inNum)
{
if (ds == NULL || ds->GetNumberOfPoints() == 0 ||
ds->GetNumberOfCells() == 0)
{
return;
}
if (inNum < 0)
{
EXCEPTION2(BadIndexException, inNum, 10);
}
double col[4];
GetLevelColor(inNum, col);
vtkIntArray *intArray = vtkIntArray::SafeDownCast(
ds->GetPointData()->GetArray("CurveSymbols"));
int *buf = (intArray == NULL) ? NULL : intArray->GetPointer(0);
vtkIntArray *intArray2 = vtkIntArray::SafeDownCast(
ds->GetPointData()->GetArray("CurveIds"));
int *buf2 = (intArray2 == NULL) ? NULL : intArray2->GetPointer(0);
//
// If the number of points is greater than 500, then don't create the
// markers and ids since the performance is so slow when the number of
// actors is too large.
//
if (ds->GetNumberOfPoints() > 500)
return;
double pos[3];
for (vtkIdType i = 0; i < ds->GetNumberOfPoints(); i++)
{
// Add the marker.
avtLabelActor_p la = new avtLabelActor;
ds->GetPoint(i, pos);
la->SetAttachmentPoint(pos);
if (buf != NULL)
la->SetMarker(buf[i]);
else
la->SetMarker(2);
la->SetScaleFactor(scale);
la->SetLineWidth(LineWidth2Int(markerLineWidth));
la->SetForegroundColor(col[0], col[1], col[2], col[3]);
actors.push_back(la);
colors.push_back(inNum);
// Add the id.
la = new avtLabelActor;
ds->GetPoint(i, pos);
la->SetAttachmentPoint(pos);
char label[16];
if (buf2 != NULL)
if (buf2[i] != INT_MIN)
sprintf(label, "%d", buf2[i]);
else
strcpy(label, "");
else
sprintf(label, "%lld", i);
la->SetDesignator(label);
la->SetScaleFactor(scale);
la->SetForegroundColor(col[0], col[1], col[2], col[3]);
actors.push_back(la);
colors.push_back(inNum);
}
}
// ****************************************************************************
// Method: avtRecenterExpression::ProcessArguments
//
// Purpose:
// Parses optional centering argument.
//
// Arguments:
// args Expression arguments
// state Expression pipeline state
//
// Programmer: Sean Ahern
// Creation: Wed Sep 10 12:04:12 EDT 2008
//
// ****************************************************************************
void
avtRecenterExpression::ProcessArguments(ArgsExpr *args,
ExprPipelineState *state)
{
// Get the argument list and number of arguments.
std::vector<ArgExpr*> *arguments = args->GetArgs();
int nargs = arguments->size();
// Check for a call with no arguments.
if (nargs == 0)
{
EXCEPTION2(ExpressionException, outputVariableName,
"recenter(): Incorrect syntax.\n"
" usage: recenter(varname, [centering])\n"
" The centering parameter is optional "
" and specifies nodal or zonal centering.\n"
" Valid values of centering: \"nodal\", \"zonal\", and \"toggle\".\n"
" The default centering is to toggle, that is, to convert "
" nodal to zonal or zonal to nodal.");
}
// Grab off the first argument.
ArgExpr *firstArg = (*arguments)[0];
avtExprNode *firstTree = dynamic_cast<avtExprNode*>(firstArg->GetExpr());
firstTree->CreateFilters(state);
// Check if we have a second optional argument that tells us how to
// center.
//
// Options:
// nodal: Recenter to nodes
// zonal: Recenter to zones
// toggle: Toggle centering
// Default: toggle
if (nargs > 1)
{
ArgExpr *secondArg = (*arguments)[1];
ExprParseTreeNode *secondTree = secondArg->GetExpr();
std::string secondType = secondTree->GetTypeName();
// Check for argument passed as string
if (secondType == "StringConst")
{
std::string sval = dynamic_cast<StringConstExpr*>(secondTree)->GetValue();
if (sval == "toggle")
recenterMode = Toggle;
else if (sval == "nodal")
recenterMode = Nodal;
else if (sval == "zonal")
recenterMode = Zonal;
else
{
EXCEPTION2(ExpressionException, outputVariableName,
"avtRecenterExpression: Invalid second argument.\n"
" Valid options are: \"nodal\", \"zonal\", or \"toggle\".");
}
}
else // Invalid argument type
{
EXCEPTION2(ExpressionException, outputVariableName,
"avtRecenterExpression: Invalid second argument type.\n"
"Must be a string with one of: \"nodal\", \"zonal\", \"toggle\".");
}
}
}
vtkDataArray *
avtUnaryMathExpression::DeriveVariable(vtkDataSet *in_ds, int currentDomainsIndex)
{
int i;
vtkDataArray *cell_data = NULL;
vtkDataArray *point_data = NULL;
vtkDataArray *data = NULL;
if (activeVariable == NULL)
{
//
// This hack is getting more and more refined. This situation comes up
// when we don't know what the active variable is (mostly for the
// constant creation filter). We probably need more infrastructure
// to handle this.
// Iteration 1 of this hack said take any array.
// Iteration 2 said take any array that isn't vtkGhostLevels, etc.
// Iteration 3 says take the first scalar array if one is available,
// provided that array is not vtkGhostLevels, etc.
// This is because most constants we create are scalar.
//
// Note: this hack used to be quite important because we would use
// the resulting array to determine the centering of the variable.
// Now we use the IsPointVariable() method. So this data array is
// only used to get the type.
//
int ncellArray = in_ds->GetCellData()->GetNumberOfArrays();
for (i = 0 ; i < ncellArray ; i++)
{
vtkDataArray *candidate = in_ds->GetCellData()->GetArray(i);
if (strstr(candidate->GetName(), "vtk") != NULL)
continue;
if (strstr(candidate->GetName(), "avt") != NULL)
continue;
if (candidate->GetNumberOfComponents() == 1)
{
// Definite winner
cell_data = candidate;
break;
}
else
// Potential winner -- keep looking
cell_data = candidate;
}
int npointArray = in_ds->GetPointData()->GetNumberOfArrays();
for (i = 0 ; i < npointArray ; i++)
{
vtkDataArray *candidate = in_ds->GetPointData()->GetArray(i);
if (strstr(candidate->GetName(), "vtk") != NULL)
continue;
if (strstr(candidate->GetName(), "avt") != NULL)
continue;
if (candidate->GetNumberOfComponents() == 1)
{
// Definite winner
point_data = candidate;
break;
}
else
// Potential winner -- keep looking
point_data = candidate;
}
if (cell_data != NULL && cell_data->GetNumberOfComponents() == 1)
{
data = cell_data;
centering = AVT_ZONECENT;
}
else if (point_data != NULL && point_data->GetNumberOfComponents()== 1)
{
data = point_data;
centering = AVT_NODECENT;
}
else if (cell_data != NULL)
{
data = cell_data;
centering = AVT_ZONECENT;
}
else
{
data = point_data;
centering = AVT_NODECENT;
}
}
else
{
cell_data = in_ds->GetCellData()->GetArray(activeVariable);
point_data = in_ds->GetPointData()->GetArray(activeVariable);
if (cell_data != NULL)
{
data = cell_data;
centering = AVT_ZONECENT;
}
else
{
data = point_data;
centering = AVT_NODECENT;
}
}
//
// Set up a VTK variable reflecting the calculated variable
//
int ncomps = 0;
int nvals = 0;
if (FilterCreatesSingleton())
nvals = 1;
else if (activeVariable == NULL || data == NULL)
nvals = (IsPointVariable() ? in_ds->GetNumberOfPoints()
: in_ds->GetNumberOfCells());
else
nvals = data->GetNumberOfTuples();
vtkDataArray *dv = NULL;
if (data == NULL)
{
//
// We could not find a single array. We must be doing something with
// the mesh.
//
ncomps = 1;
dv = CreateArrayFromMesh(in_ds);
}
else
{
ncomps = data->GetNumberOfComponents();
dv = CreateArray(data);
}
if (data == NULL)
{
if (! NullInputIsExpected())
{
// One way to get here is to have vtkPolyData Curve plots.
EXCEPTION2(ExpressionException, outputVariableName,
"An internal error occurred when "
"trying to calculate your expression. Please contact a "
"VisIt developer.");
}
}
int noutcomps = GetNumberOfComponentsInOutput(ncomps);
dv->SetNumberOfComponents(noutcomps);
dv->SetNumberOfTuples(nvals);
//
// Should we send in ncomps or noutcomps? They are the same number
// unless the derived type re-defined GetNumberOfComponentsInOutput.
// If it did, it probably doesn't matter. If not, then it is the same
// number. So send in the input. Really doesn't matter.
//
cur_mesh = in_ds;
DoOperation(data, dv, ncomps, nvals);
cur_mesh = NULL;
return dv;
}
void
avtDatasetToVTKDatasetFilter::Execute(avtDomainList *dl)
{
int i;
//
// We previously set the dataset that was naturally the output of the
// append filter as the output of the bridge. Because VTK does not want
// to have two objects share that output, it has code under the covers
// that removes the dataset as output from the append filter. Restore
// that now.
//
appendFilter->SetOutput(bridge->GetOutput());
//
// Remove all of the inputs from the appender. Count down so there are
// no issues with the array being squeezed and indices changing.
//
int numInputs = appendFilter->GetNumberOfInputs();
for (i = numInputs-1 ; i >= 0 ; i--)
{
vtkDataSet *ds = appendFilter->GetInput(i);
if (ds != NULL)
{
appendFilter->RemoveInput(ds);
}
}
//
// Set the input to the appender to fit with the domain list.
//
avtDataTree_p tree = GetInputDataTree();
int nc = tree->GetNChildren();
int nd = dl->NumDomains();
if (nd != nc)
{
EXCEPTION2(IncompatibleDomainListsException, nd, nc);
}
for (i = 0 ; i < dl->NumDomains() ; i++)
{
if (dl->Domain(i) && tree->ChildIsPresent(i))
{
bool dummy;
tree->GetChild(i)->Traverse(CAddInputToAppendFilter,
appendFilter, dummy);
}
}
//
// Force an execution of the append filter. We set all of the input to its
// inputs as NULL, so we don't have to worry about it trying to go back up
// the (most certainly defunct) pipeline.
//
appendFilter->Update();
//
// The output of the bridge and the append filter is shared. Give it back
// to the bridge, so our pipeline will work properly.
//
bridge->SetOutput(appendFilter->GetOutput());
}
// ****************************************************************************
// Method: avtVectorComposeExpression::DeriveVariable
//
// Purpose:
// Creates a vector variable from components.
//
// Arguments:
// inDS The input dataset.
//
// Returns: The derived variable. The calling class must free this
// memory.
//
// Programmer: Sean Ahern
// Creation: Thu Mar 6 19:40:32 America/Los_Angeles 2003
//
// Modifications:
//
// Hank Childs, Thu Aug 14 11:01:34 PDT 2003
// Add better support for 2D vectors.
//
// Hank Childs, Fri Sep 19 13:46:13 PDT 2003
// Added support for tensors, symmetric tensors.
//
// Hank Childs, Sun Jan 13 20:11:35 PST 2008
// Add support for singleton constants.
//
// ****************************************************************************
vtkDataArray *
avtVectorComposeExpression::DeriveVariable(vtkDataSet *in_ds)
{
size_t numinputs = varnames.size();
bool twoDVector =
(GetInput()->GetInfo().GetAttributes().GetSpatialDimension() == 2);
//
// Our first operand is in the active variable. We don't know if it's
// point data or cell data, so check which one is non-NULL.
//
vtkDataArray *cell_data1 = in_ds->GetCellData()->GetArray(varnames[0]);
vtkDataArray *point_data1 = in_ds->GetPointData()->GetArray(varnames[0]);
vtkDataArray *data1 = NULL, *data2 = NULL, *data3 = NULL;
avtCentering centering;
if (cell_data1 != NULL)
{
data1 = cell_data1;
centering = AVT_ZONECENT;
}
else
{
data1 = point_data1;
centering = AVT_NODECENT;
}
// Get the second variable.
if (centering == AVT_ZONECENT)
data2 = in_ds->GetCellData()->GetArray(varnames[1]);
else
data2 = in_ds->GetPointData()->GetArray(varnames[1]);
if (data2 == NULL)
{
EXCEPTION2(ExpressionException, outputVariableName,
"The first two variables have different centering.");
}
if (numinputs == 3)
{
// Get the third variable.
if (centering == AVT_ZONECENT)
data3 = in_ds->GetCellData()->GetArray(varnames[2]);
else
data3 = in_ds->GetPointData()->GetArray(varnames[2]);
if (data3 == NULL)
{
EXCEPTION2(ExpressionException, outputVariableName,
"The first and third variables have different centering.");
}
}
// As we proceed to build the vector out of components,
// we make a list of offsets for each component
// so that we can attach that list to the resulting vector dataset
// In the future, we need a generic way to merge vtkInformationObjects here
std::vector<avtVector> offsets(3);
vtkInformation* data1Info = data1->GetInformation();
if (data1Info->Has(avtVariableCache::OFFSET_3())) {
double* vals = data1Info->Get(avtVariableCache::OFFSET_3());
offsets[0].x = vals[0];
offsets[0].y = vals[1];
offsets[0].z = vals[2];
}
vtkInformation* data2Info =data2->GetInformation();
if (data2Info->Has(avtVariableCache::OFFSET_3())) {
double* vals = data2Info->Get(avtVariableCache::OFFSET_3());
offsets[1].x = vals[0];
offsets[1].y = vals[1];
offsets[1].z = vals[2];
}
if (numinputs == 3) {
vtkInformation* data3Info = data3->GetInformation();
if (data3Info->Has(avtVariableCache::OFFSET_3())) {
double* vals = data3Info->Get(avtVariableCache::OFFSET_3());
offsets[2].x = vals[0];
offsets[2].y = vals[1];
offsets[2].z = vals[2];
}
}
vtkIdType nvals1 = data1->GetNumberOfTuples();
vtkIdType nvals2 = data2->GetNumberOfTuples();
vtkIdType nvals3 = 1;
if (numinputs == 3)
nvals3 = data3->GetNumberOfTuples();
vtkIdType nvals = nvals1;
if (nvals == 1)
nvals = nvals2;
if (nvals == 1 && numinputs == 3)
nvals = nvals3;
vtkDataArray *dv = data1->NewInstance();
if (twoDVector)
{
if (numinputs == 2)
{
if (data1->GetNumberOfComponents() == 1 &&
data2->GetNumberOfComponents() == 1)
{
//
// Standard vector case.
//
dv->SetNumberOfComponents(3); // VTK doesn't like 2.
dv->SetNumberOfTuples(nvals);
for (vtkIdType i = 0 ; i < nvals ; i++)
{
double val1 = data1->GetTuple1((nvals1>1 ? i : 0));
double val2 = data2->GetTuple1((nvals2>1 ? i : 0));
dv->SetTuple3(i, val1, val2, 0.);
}
}
else if ((data1->GetNumberOfComponents() == 3) &&
(data2->GetNumberOfComponents() == 3))
{
//
// 2D tensor.
//
dv->SetNumberOfComponents(9);
dv->SetNumberOfTuples(nvals);
for (vtkIdType i = 0 ; i < nvals ; i++)
{
double vals[9];
vals[0] = data1->GetComponent((nvals1>1 ? i : 0), 0);
vals[1] = data1->GetComponent((nvals2>1 ? i : 0), 1);
vals[2] = 0.;
vals[3] = data2->GetComponent((nvals1>1 ? i : 0), 0);
vals[4] = data2->GetComponent((nvals2>1 ? i : 0), 1);
vals[5] = 0.;
vals[6] = 0.;
vals[7] = 0.;
vals[8] = 0.;
dv->SetTuple(i, vals);
}
}
else
{
char str[1024];
sprintf(str, "Do not know how to assemble arrays of %d and "
"%d into a vector or tensor.",
data1->GetNumberOfComponents(),
data2->GetNumberOfComponents());
EXCEPTION2(ExpressionException, outputVariableName, str);
}
}
else if (numinputs == 3)
{
EXCEPTION2(ExpressionException, outputVariableName,
"I don't know how to compose "
"3 variables to make a field for a 2D dataset.");
}
}
else
{
if (numinputs == 3)
{
if (data1->GetNumberOfComponents() == 1 &&
data2->GetNumberOfComponents() == 1 &&
data3->GetNumberOfComponents() == 1)
{
//
// This is your everyday 3D vector combination.
//
dv->SetNumberOfComponents(3);
dv->SetNumberOfTuples(nvals);
for (vtkIdType i = 0 ; i < nvals ; i++)
{
double val1 = data1->GetTuple1((nvals1>1 ? i : 0));
double val2 = data2->GetTuple1((nvals2>1 ? i : 0));
double val3 = data3->GetTuple1((nvals3>1 ? i : 0));
dv->SetTuple3(i, val1, val2, val3);
}
}
else if (data1->GetNumberOfComponents() == 3 &&
data2->GetNumberOfComponents() == 3 &&
data3->GetNumberOfComponents() == 3)
{
//
// This is a 3D tensor. Interpret it as:
// Data1 = XX, XY, XZ
// Data2 = YX, YY, YZ
// Data3 = ZX, ZY, ZZ
//
dv->SetNumberOfComponents(9);
dv->SetNumberOfTuples(nvals);
for (vtkIdType i = 0 ; i < nvals ; i++)
{
double entry[9];
data1->GetTuple((nvals1>1 ? i : 0), entry);
data2->GetTuple((nvals2>1 ? i : 0), entry+3);
data3->GetTuple((nvals3>1 ? i : 0), entry+6);
dv->SetTuple(i, entry);
}
}
else
{
EXCEPTION2(ExpressionException, outputVariableName,
"The only interpretation "
"VisIt can make of 3 variables for a 3D dataset is "
"a vector or a tensor. But these inputs don't have"
" the right number of components to make either.");
}
}
else
{
EXCEPTION2(ExpressionException, outputVariableName,
"You must specify three vectors "
"to compose a field for a 3D dataset.");
}
}
//If offset information existed on the input dataset, set it on the output
if ((offsets[0].x != 0) || (offsets[0].y != 0) || (offsets[0].z != 0) ||
(offsets[1].x != 0) || (offsets[1].y != 0) || (offsets[1].z != 0) ||
(offsets[2].x != 0) || (offsets[2].y != 0) || (offsets[2].z != 0)) {
vtkInformation* dvInfo = dv->GetInformation();
dvInfo->Set(avtVariableCache::OFFSET_3_COMPONENT_0(), offsets[0].x, offsets[0].y, offsets[0].z);
dvInfo->Set(avtVariableCache::OFFSET_3_COMPONENT_1(), offsets[1].x, offsets[1].y, offsets[1].z);
dvInfo->Set(avtVariableCache::OFFSET_3_COMPONENT_2(), offsets[2].x, offsets[2].y, offsets[2].z);
}
return dv;
}
vtkDataArray *
avtVectorDecomposeExpression::DeriveVariable(vtkDataSet *in_ds)
{
vtkDataArray *arr = NULL;
//
// The base class will set the variable of interest to be the
// 'activeVariable'. This is a by-product of how the base class sets its
// input. If that method should change (SetActiveVariable), this
// technique for inferring the variable name may stop working.
//
const char *varname = activeVariable;
//
// Get the array of interest.
//
if (in_ds->GetPointData()->GetArray(varname) != NULL)
{
arr = in_ds->GetPointData()->GetArray(varname);
}
else
{
arr = in_ds->GetCellData()->GetArray(varname);
}
if (arr == NULL)
{
EXCEPTION2(ExpressionException, outputVariableName,
"When creating an expression, VisIt "
"was not able to locate a necessary variable.");
}
//
// The logic here can be pretty tricky. We want to decompose this "vector"
// variable. But the "vector" can be an everyday vector, or it can be a
// symmetric on non-symmetric tensor. Based on the dimensionality of the
// dataset, the output could be a scalar or it could be a vector.
//
vtkIdType ntuples = arr->GetNumberOfTuples();
vtkDataArray *rv = arr->NewInstance();
bool twoDVector =
(GetInput()->GetInfo().GetAttributes().GetSpatialDimension() == 2);
if (twoDVector)
{
if ((which_comp > 1) || (which_comp < 0))
{
EXCEPTION2(ExpressionException, outputVariableName,
"The only valid indices for 2D vectors are 0 and 1.");
}
if (arr->GetNumberOfComponents() == 3)
{
rv->SetNumberOfComponents(1);
rv->SetNumberOfTuples(ntuples);
for (vtkIdType i = 0 ; i < ntuples ; i++)
{
double val = arr->GetComponent(i, which_comp);
rv->SetTuple1(i, val);
}
}
else if (arr->GetNumberOfComponents() == 9)
{
//
// Give one row of the tensor back. Since VTK dislikes vectors
// of size 2, make sure that we have 3 components.
//
rv->SetNumberOfComponents(3);
rv->SetNumberOfTuples(ntuples);
for (vtkIdType i = 0 ; i < ntuples ; i++)
{
double val1 = arr->GetComponent(i, 3*which_comp);
double val2 = arr->GetComponent(i, 3*which_comp+1);
rv->SetTuple3(i, val1, val2, 0.);
}
}
else
{
EXCEPTION2(ExpressionException, outputVariableName,
"You can only decompose vectors and tensors.");
}
}
else
{
if ((which_comp > 2) || (which_comp < 0))
{
EXCEPTION2(ExpressionException, outputVariableName,
"The only valid indices for 3D vectors are 0, 1, and 2");
}
if (arr->GetNumberOfComponents() == 3)
{
//
// Looks like an everyday 3D vector.
//
rv->SetNumberOfComponents(1);
rv->SetNumberOfTuples(ntuples);
for (vtkIdType i = 0 ; i < ntuples ; i++)
{
double val = arr->GetComponent(i, which_comp);
rv->SetTuple1(i, val);
}
}
else if (arr->GetNumberOfComponents() == 9)
{
//
// Tensor data. Return a row (*X, *Y, *Z).
//
rv->SetNumberOfComponents(3);
rv->SetNumberOfTuples(ntuples);
for (vtkIdType i = 0 ; i < ntuples ; i++)
{
double val1 = arr->GetComponent(i, 3*which_comp);
double val2 = arr->GetComponent(i, 3*which_comp+1);
double val3 = arr->GetComponent(i, 3*which_comp+2);
rv->SetTuple3(i, val1, val2, val3);
}
}
else
{
EXCEPTION2(ExpressionException, outputVariableName,
"You can only decompose vectors and tensors.");
}
}
return rv;
}
void
avtTimeIteratorExpression::ProcessArguments(ArgsExpr *args,
ExprPipelineState *state)
{
int i;
// get the argument list and # of arguments
std::vector<ArgExpr*> *arguments = args->GetArgs();
int nargs = arguments->size();
// check for call with no args
if (nargs < NumberOfVariables())
{
EXCEPTION2(ExpressionException, outputVariableName,
"Not enough arguments to time iterator expression");
}
// Each of these arguments should be variables.
for (i = 0 ; i < NumberOfVariables() ; i++)
{
ArgExpr *arg = (*arguments)[i];
avtExprNode *tree = dynamic_cast<avtExprNode*>(arg->GetExpr());
tree->CreateFilters(state);
}
std::vector<int> timecontrols;
for (i = NumberOfVariables() ; i < nargs ; i++)
{
ArgExpr *arg= (*arguments)[i];
ExprParseTreeNode *tree= arg->GetExpr();
std::string argtype = tree->GetTypeName();
// check for arg passed as integer
if (argtype == "IntegerConst")
{
int t = dynamic_cast<IntegerConstExpr*>(tree)->GetValue();
timecontrols.push_back(t);
}
else if (argtype == "StringConst")
{
std::string s = dynamic_cast<StringConstExpr*>(tree)->GetValue();
if (s == "pos_cmfe")
{
if (i == nargs-1)
{
EXCEPTION2(ExpressionException, outputVariableName,
"If specify pos_cmfe, then you must follow that"
" immediately with a default variable.");
}
i++;
ArgExpr *arg = (*arguments)[i];
avtExprNode *tree = dynamic_cast<avtExprNode*>(arg->GetExpr());
tree->CreateFilters(state);
cmfeType = POS_CMFE;
}
else if (s != "conn_cmfe")
{
char msg[1024];
SNPRINTF(msg, 1024, "Could not understand meaning of \"%s\"",
s.c_str());
EXCEPTION2(ExpressionException, outputVariableName,msg);
}
}
}
if (timecontrols.size() == 3)
{
firstTimeSlice = timecontrols[0];
lastTimeSlice = timecontrols[1];
timeStride = timecontrols[2];
}
else if (timecontrols.size() != 0)
{
EXCEPTION2(ExpressionException, outputVariableName,
"The specification of time must use integers. "
"These integers are dump indices, 0-indexed."
"If you specify time controls, there must be three integers"
", start, stop, stride");
}
}
/**
* @brief Linux-specific version of do_cpu_set_init().
*
* @param cpu_set The CPU set.
*
* @return 0 on success. Negative value on error.
*/
static void cpu_set_init_Linux(cpu_set_p cpu_set)
{
int i;
os_cpu_set_t original_affinity_set;
int num_cpus = sysconf(_SC_NPROCESSORS_CONF);
/* get current affinity set so we can restore it when we're done */
if ( sched_getaffinity( 0, sizeof(os_cpu_set_t), &original_affinity_set ) )
throw EXCEPTION2(ThreadException,
"sched_getaffinity() failed with %s",
errno_to_str().data());
/* test restoration */
if ( sched_setaffinity( 0, sizeof(os_cpu_set_t), &original_affinity_set ) )
throw EXCEPTION2(ThreadException,
"sched_setaffinity() failed with %s",
errno_to_str().data());
/* allocate cpus */
cpu_t cpus =
(cpu_t)malloc( num_cpus * sizeof(struct cpu_s) );
if ( cpus == NULL )
throw EXCEPTION1(BadAlloc, "cpu array");
for (i = 0; i < num_cpus; i++)
/* initialize fields */
CPU_ZERO( &cpus[i].cpu_set );
/* find the CPUs on the system */
int num_found = 0;
int cpu_num;
for (cpu_num = 0; ; cpu_num++)
{
os_cpu_set_t test_set;
CPU_ZERO( &test_set );
CPU_SET ( cpu_num, &test_set );
if ( !sched_setaffinity( 0, sizeof(os_cpu_set_t), &test_set ) )
{
/* found a new CPU */
cpus[num_found].cpu_unique_id = cpu_num;
cpu_set_copy( &cpus[num_found].cpu_set, &test_set );
num_found++;
if ( num_found == num_cpus )
break;
}
}
/* restore original affinity set */
if ( sched_setaffinity( 0, sizeof(os_cpu_set_t), &original_affinity_set ) )
throw EXCEPTION2(ThreadException,
"sched_setaffinity() failed with %s",
errno_to_str().data());
/* return parameters */
cpu_set->cpuset_num_cpus = num_cpus;
cpu_set->cpuset_cpus = cpus;
}
// ****************************************************************************
// Method: avtCylindricalRadiusExpression::ProcessArguments
//
// Purpose:
// Parses optional arguments.
// Allows the user to pass a string constaint specifying the cylinder
// axis (default = z ) or a vector that defines the cylinder axis.
//
//
// Programmer: Cyrus Harrison
// Creation: March 31, 2008
//
// Modifications:
//
// ****************************************************************************
void
avtCylindricalRadiusExpression::ProcessArguments(
ArgsExpr *args, ExprPipelineState *state)
{
axisVector[0] = 0;
axisVector[1] = 0;
axisVector[2] = 1;
// Check the number of arguments
std::vector<ArgExpr*> *arguments = args->GetArgs();
size_t nargs = arguments->size();
if (nargs == 0)
{
EXCEPTION2(ExpressionException, outputVariableName,
"avtCylindricalRadiusExpression: No arguments given.");
}
// First arg should be a mesh name, let it gen is filters.
ArgExpr *first_arg = (*arguments)[0];
avtExprNode *first_tree = dynamic_cast<avtExprNode*>(first_arg->GetExpr());
first_tree->CreateFilters(state);
// If we only have two arguments, we expect a string const or vector const
if (nargs == 2)
{
ArgExpr *second_arg = (*arguments)[1];
ExprParseTreeNode *second_tree = second_arg->GetExpr();
std::string arg_type = second_tree->GetTypeName();
std::string error_msg = "avtCylindricalRadiusExpression: "
"Invalid second argument."
"Expected \"x\", \"y\", or \"z\"";
if (arg_type != "StringConst" && arg_type != "Vector" )
{
debug5 << error_msg << endl;
EXCEPTION2(ExpressionException, outputVariableName,
error_msg.c_str());
}
if (arg_type == "StringConst")
{
// string case
std::string val = dynamic_cast<StringConstExpr*>(second_tree)->GetValue();
if ( ! ( val == "x" || val == "y" || val == "z"))
{
error_msg += "\nPassed value \"" + val + "\"";
debug5 << error_msg << endl;
EXCEPTION2(ExpressionException, outputVariableName,
error_msg.c_str());
}
debug5 << "avtCylindricalCoordinatesExpression:"
<< "Using " << val << " as Cylinder Axis." << endl;
if(val == "x")
{
axisVector[0] = 1;
axisVector[1] = 0;
axisVector[2] = 0;
}
else if(val == "y")
{
axisVector[0] = 0;
axisVector[1] = 1;
axisVector[2] = 0;
}
else if(val == "z")
{
axisVector[0] = 0;
axisVector[1] = 0;
axisVector[2] = 1;
}
}
else if(arg_type == "Vector")
{
VectorExpr *vec = dynamic_cast<VectorExpr*>(second_tree);
if(!vec->Z())
{
error_msg += "\nVector missing z-component.";
debug5 << error_msg << endl;
EXCEPTION2(ExpressionException, outputVariableName,
error_msg.c_str());
}
// get the vector
double val = 0;
if(GetNumericVal(vec->X(),val))
{
axisVector[0] = val;
}
else
{
error_msg += "\nVector x-component is not a floating point number.";
debug5 << error_msg << endl;
EXCEPTION2(ExpressionException, outputVariableName,
error_msg.c_str());
}
if(GetNumericVal(vec->Y(),val))
{
axisVector[1] = val;
}
else
{
error_msg += "\nVector z-component is not a floating point number.";
debug5 << error_msg << endl;
EXCEPTION2(ExpressionException, outputVariableName,
error_msg.c_str());
}
if(GetNumericVal(vec->Z(),val))
{
axisVector[2] = val;
}
else
{
error_msg += "\nVector z-component is not a floating point number.";
debug5 << error_msg << endl;
EXCEPTION2(ExpressionException, outputVariableName,
error_msg.c_str());
}
if ( axisVector[0] == 0 && axisVector[1] == 0 && axisVector[2] == 0 )
{
error_msg += "\nDegenerate vector {0,0,0}.";
debug5 << error_msg << endl;
EXCEPTION2(ExpressionException, outputVariableName,
error_msg.c_str());
}
}
}
}
void
avtCurlExpression::GetMacro(std::vector<std::string> &args, std::string &ne,
Expression::ExprType &type)
{
bool do3D = true;
if (*(GetInput()) != NULL)
{
avtDataAttributes &atts = GetInput()->GetInfo().GetAttributes();
if (atts.GetTopologicalDimension() < 3)
{
do3D = false;
}
}
int nargs = args.size();
char new_expr[2048];
if (do3D)
{
if(nargs == 1)
{
SNPRINTF(new_expr,2048,
"{gradient(%s[2])[1]-gradient(%s[1])[2],"
"gradient(%s[0])[2]-gradient(%s[2])[0],"
"gradient(%s[1])[0]-gradient(%s[0])[1]}",
args[0].c_str(), args[0].c_str(), args[0].c_str(),
args[0].c_str(), args[0].c_str(), args[0].c_str());
}
else if(nargs > 1)
{
SNPRINTF(new_expr,2048,
"{gradient(%s[2],%s)[1]-gradient(%s[1],%s)[2],"
"gradient(%s[0],%s)[2]-gradient(%s[2],%s)[0],"
"gradient(%s[1],%s)[0]-gradient(%s[0],%s)[1]}",
args[0].c_str(), args[1].c_str(),
args[0].c_str(), args[1].c_str(),
args[0].c_str(), args[1].c_str(),
args[0].c_str(), args[1].c_str(),
args[0].c_str(), args[1].c_str(),
args[0].c_str(), args[1].c_str());
}
else
{
EXCEPTION2(ExpressionException, outputVariableName,
" invalid curl syntax. "
"Expected arguments: "
"vector_var, gradient_algorithm\n"
"[gradient_algorithm is optional]");
}
type = Expression::VectorMeshVar;
}
else
{
if(nargs == 1)
{
SNPRINTF(new_expr,2048,
"gradient(%s[1])[0]-gradient(%s[0])[1]",
args[0].c_str(), args[0].c_str());
}
else if(nargs > 1)
{
SNPRINTF(new_expr,2048,
"gradient(%s[1],%s)[0]-gradient(%s[0],%s)[1]",
args[0].c_str(), args[1].c_str(),
args[0].c_str(), args[1].c_str());
}
else
{
EXCEPTION2(ExpressionException, outputVariableName,
" invalid curl syntax. "
"Expected arguments: "
"vector_var, gradient_algorithm\n"
"[gradient_algorithm is optional]");
}
type = Expression::ScalarMeshVar;
}
ne = new_expr;
}
void
avtTimeIteratorDataTreeIteratorExpression::PrepareAndExecuteDataset(
vtkDataSet *ds, int ts)
{
std::vector<vtkDataArray *> ds_vars;
std::vector<vtkDataArray *> delete_vars;
bool haveZonal = false;
size_t nvars = varnames.size();
if (cmfeType == POS_CMFE)
nvars--;
for (size_t i = 0 ; i < nvars ; i++)
{
std::string vname = GetInternalVarname(i);
vtkDataArray *cell_data1 = ds->GetCellData()->GetArray(vname.c_str());
vtkDataArray *point_data1 = ds->GetPointData()->GetArray(vname.c_str());
if (cell_data1 == NULL && point_data1 == NULL)
{
EXCEPTION2(ExpressionException, outputVariableName,
"An internal error occurred when calculating an expression."
" Please contact a VisIt developer.");
}
haveZonal = (cell_data1 != NULL);
}
bool doZonal = false;
if (haveZonal)
doZonal = true; // mixed centering -> zonal
for (size_t i = 0 ; i < nvars ; i++)
{
std::string vname = GetInternalVarname(i);
vtkDataArray *cell_data1 = ds->GetCellData()->GetArray(vname.c_str());
vtkDataArray *point_data1 = ds->GetPointData()->GetArray(vname.c_str());
if (doZonal)
{
if (cell_data1 != NULL)
ds_vars.push_back(cell_data1);
else
{
vtkDataArray *tmp = Recenter(ds, point_data1, AVT_NODECENT,
varnames[i], AVT_ZONECENT);
ds_vars.push_back(tmp);
delete_vars.push_back(tmp);
}
}
else
{
if (point_data1 != NULL)
ds_vars.push_back(point_data1);
else
{
vtkDataArray *tmp = Recenter(ds, cell_data1, AVT_ZONECENT,
varnames[i], AVT_NODECENT);
ds_vars.push_back(tmp);
delete_vars.push_back(tmp);
}
}
}
vtkDataArray *out_arr = vars[arrayIndex++];
ExecuteDataset(ds_vars, out_arr, ts);
for (size_t i = 0 ; i < delete_vars.size() ; i++)
delete_vars[i]->Delete();
}
void
avtRAWFileFormat::ReadFile(const char *name)
{
const char *mName = "avtRAWFileFormat::ReadFile: ";
int total = visitTimer->StartTimer();
debug4 << mName << endl;
// Open the file.
ifstream ifile(name);
if (ifile.fail())
{
EXCEPTION1(InvalidFilesException, name);
}
debug4 << "Opened the file: " << name << endl;
bool trianglesAdded = false;
#ifndef MDSERVER
// Make a guess about the number of cells and points based on
// the size of the file.
int nCells = 100;
VisItStat_t statbuf;
VisItStat(name, &statbuf);
VisItOff_t fileSize = statbuf.st_size;
nCells = fileSize / (VisItOff_t) 80;
debug4 << mName << "Guessing there are about " << nCells << " cells" << endl;
vtkPolyData *currentPD = NewPD(nCells);
VertexManager *vertexMgr = new VertexManager(currentPD->GetPoints());
#else
vtkPolyData *currentPD = 0;
#endif
int domain = 0;
char line[1024];
double pts[9] = {0.,0.,0.,0.,0.,0.,0.,0.,0.};
int nc = 0;
for(int lineIndex = 0; ifile.good(); ++lineIndex)
{
// Get the line
ifile.getline(line, 1024);
if (lineIndex<100 && !StringHelpers::IsPureASCII(line, 1024))
EXCEPTION2(InvalidFilesException, name, "Not ASCII.");
// Skip leading spaces.
char *cptr = line;
while((*cptr == ' ' || *cptr == '\t') &&
(cptr < (line + 1024)))
++cptr;
if((cptr[0] >= '0' && cptr[0] <= '9') || (cptr[0] == '-'))
{
#ifndef MDSERVER
// We found a line with points. Read the line and add a triangle cell.
int n = sscanf(cptr, "%lg %lg %lg %lg %lg %lg %lg %lg %lg",
&pts[0], &pts[1], &pts[2],
&pts[3], &pts[4], &pts[5],
&pts[6], &pts[7], &pts[8]);
if (GetStrictMode() && n != 9)
{
EXCEPTION2(InvalidFilesException, GetFilename(),
"Bad line in file; less than nine values");
}
vtkIdType ids[3];
ids[0] = vertexMgr->GetVertexId(pts);
ids[1] = vertexMgr->GetVertexId(pts + 3);
ids[2] = vertexMgr->GetVertexId(pts + 6);
currentPD->InsertNextCell(VTK_TRIANGLE, 3, ids);
#endif
trianglesAdded = true;
}
else
{
// If we're hitting a new object name and we've added some triangles
// then we need to add the currentPD to the meshes vector.
if(trianglesAdded)
{
if(meshes.size() == 0)
{
// We get here when we've created some polydata but have not
// seen an object id for it yet. In that case, we add an object
// to the list.
debug4 << mName << "Adding Object mesh" << endl;
domain_data dom;
dom.domainName = "Object";
dom.mesh = currentPD;
meshes.push_back(dom);
++domain;
}
#ifndef MDSERVER
else
{
// We get here when we've created some polydata for a tag that
// we've seen and we're encountering a new tag.
debug4 << mName << "Setting mesh for mesh["
<< (domain-1) << "]\n";
meshes[domain-1].mesh = currentPD;
}
currentPD->Squeeze();
// Reset for a new polydata.
currentPD = NewPD(nCells);
delete vertexMgr;
vertexMgr = new VertexManager(currentPD->GetPoints());
#endif
trianglesAdded = false;
}
// We have the name of a new object.
domain_data dom;
int len = strlen(cptr);
if(len > 0)
{
// If the new name is valid then add a mesh entry for it.
if(cptr[len-1] == '\n')
cptr[len-1] = '\0'; // Remove the end of line.
dom.domainName = std::string(cptr);
dom.mesh = 0;
meshes.push_back(dom);
++domain;
debug4 << mName << "Domain " << domain << " is called: " << cptr << endl;
}
else
{
debug4 << mName << "Empty domain name" << endl;
if (GetStrictMode() && !ifile.eof())
{
EXCEPTION2(InvalidFilesException, GetFilename(),
"Empty domain name.");
}
}
}
}
// Print out the meshes list
debug4 << "MESHES\n===========================\n";
for(int i = 0; i < meshes.size(); ++i)
{
debug4 << mName << "Mesh " << i << ": " << meshes[i].domainName.c_str()
<< ", ptr=" << (void*)meshes[i].mesh << endl;
}
#ifndef MDSERVER
// Delete the vertex manager if it exists.
if(vertexMgr != 0)
delete vertexMgr;
#endif
debug4 << mName << "end" << endl;
visitTimer->StopTimer(total, "Loading RAW file");
}
vtkDataArray *
avtConditionalExpression::DeriveVariable(vtkDataSet *in_ds, int currentDomainsIndex)
{
// Our first operand is in the active variable. We don't know if it's
// point data or cell data, so check which one is non-NULL.
vtkDataArray *cell_data1 = in_ds->GetCellData()->GetArray(varnames[0]);
vtkDataArray *point_data1 = in_ds->GetPointData()->GetArray(varnames[0]);
vtkDataArray *data1 = NULL, *data2 = NULL, *data3 = NULL;
avtCentering centering;
if (cell_data1 != NULL)
{
data1 = cell_data1;
centering = AVT_ZONECENT;
}
else
{
data1 = point_data1;
centering = AVT_NODECENT;
}
if (data1 == NULL)
{
EXCEPTION2(ExpressionException, outputVariableName,
"Could not identify centering of first variable");
}
if (data1->GetNumberOfComponents() != 1)
{
EXCEPTION2(ExpressionException, outputVariableName,
"Cannot interpret conditional with vector dimensionality");
}
// Get the second variable.
if (centering == AVT_ZONECENT)
data2 = in_ds->GetCellData()->GetArray(varnames[1]);
else
data2 = in_ds->GetPointData()->GetArray(varnames[1]);
if (data2 == NULL)
{
char msg[1024];
SNPRINTF(msg, 1024,
"the first two arguments to \"if\" (%s and %s) have "
" different centerings.", varnames[0], varnames[1]);
EXCEPTION2(ExpressionException, outputVariableName, msg);
}
// Get the third variable.
if (centering == AVT_ZONECENT)
data3 = in_ds->GetCellData()->GetArray(varnames[2]);
else
data3 = in_ds->GetPointData()->GetArray(varnames[2]);
if (data3 == NULL)
{
char msg[1024];
SNPRINTF(msg, 1024,
"the first and third arguments to \"if\" (%s and %s) have "
" different centerings.", varnames[0], varnames[2]);
EXCEPTION2(ExpressionException, outputVariableName, msg);
}
// sanity check: make sure the input arrays have the same # of tuples
int d1_nvals = data1->GetNumberOfTuples();
int d2_nvals = data2->GetNumberOfTuples();
int d3_nvals = data2->GetNumberOfTuples();
if ( d1_nvals != d2_nvals || d2_nvals != d3_nvals )
{
std::string msg = " the input datasets for the \"if\" expression "
" do not have the same number of tuples!";
EXCEPTION2(ExpressionException, outputVariableName, msg.c_str());
}
//
// Set up a VTK variable reflecting the calculated variable
//
int nvals = data2->GetNumberOfTuples();
vtkDataArray *dv = data2->NewInstance();
dv->SetNumberOfComponents(data2->GetNumberOfComponents());
dv->SetNumberOfTuples(nvals);
if (data1->GetDataType() == VTK_UNSIGNED_CHAR)
{
vtkUnsignedCharArray *uca = (vtkUnsignedCharArray *) data1;
for (int i = 0 ; i < nvals ; i++)
{
unsigned char val = uca->GetValue(i);
if (val != '\0')
{
dv->SetTuple(i, data2->GetTuple(i));
}
else
{
dv->SetTuple(i, data3->GetTuple(i));
}
}
}
else
{
for (int i = 0 ; i < nvals ; i++)
{
double val = data1->GetTuple1(i);
if (val != 0.)
{
dv->SetTuple(i, data2->GetTuple(i));
}
else
{
dv->SetTuple(i, data3->GetTuple(i));
}
}
}
return dv;
}
// ****************************************************************************
// Function: DetectBoundaryGhostLayers
//
// Purpose: Detects number of ghost layers in each dimension given
// knowledge of the dimension, non-ghosted size of the patch in each
// dimension and the pre-existing avtGhostZones data
//
// To perform the detection, basically we try all reasonable combinations
// of ghost numbers of layers and probe the ghostData array around the
// extreme high and low ijk corners of the patch to see if we get something
// thats consistent. The loop looks daunting but it completes very quickly.
//
// Programmer: Mark C. Miller
// Creation: January 8, 2004
//
// ****************************************************************************
void
DetectBoundaryGhostLayers(int numDims, unsigned char *ghostData, int numCells,
vector<int> extents, int *ghostLayers)
{
int Ni = 0, Nj = 0, Nk = 0;
// compute size of NON-ghosted patch
switch (numDims) // note: exploits fall-through
{
case 3: Nk = extents[5] - extents[2] + 1;
case 2: Nj = extents[4] - extents[1] + 1;
case 1: Ni = extents[3] - extents[0] + 1;
}
// vector to populate with valid ghost cases
vector<int> ghostCases;
// loop over all possible combinations of ghost layer widths
int gi, gj, gk;
for (gi = 0; gi <= (Ni==0 ? 0 : MAX_GHOST_LAYERS); gi++)
{
for (gj = 0; gj <= (Nj==0 ? 0 : MAX_GHOST_LAYERS); gj++)
{
for (gk = 0; gk <= (Nk==0 ? 0 : MAX_GHOST_LAYERS); gk++)
{
// we always skip the all 0 case
if ((gi == 0) && (gj == 0) && (gk == 0))
continue;
// compute size of ghosted patch given this layering
int Mk = Nk + 2 * gk;
int Mj = Nj + 2 * gj;
int Mi = Ni + 2 * gi;
// can ignore this case immediately if the number of
// cells it presumes doesn't equate to the number of
// cells we know we have
int ncells = 0;
switch (numDims)
{
case 3: ncells = Mk * Mj * Mi; break;
case 2: ncells = Mj * Mi; break;
case 1: ncells = Mi; break;
}
if (ncells != numCells)
continue;
// probe ghost data array round 2 extreme corners
int mult;
bool impossibleGhostCase = false;
for (mult = -1; (mult <= 1) && !impossibleGhostCase; mult += 2)
{
int i0, j0, k0;
// set which corner to examine ghost values around
// -1 --> Lower, Left, Front
// +1 --> Upper, Right, Back
if (mult == -1)
{
// the extreme lowest corner
// in the
i0 = 0 + gi;
j0 = 0 + gj;
k0 = 0 + gk;
}
else
{
// the extreme highest corner
i0 = Ni - 1 + gi;
j0 = Nj - 1 + gj;
k0 = Nk - 1 + gk;
}
// examine all cells around the corner for ghost values
int i,j,k;
for (i = 0; (i <= gi) && !impossibleGhostCase; i++)
{
for (j = 0; (j <= gj) && !impossibleGhostCase; j++)
{
for (k = 0; (k <= gk) && !impossibleGhostCase; k++)
{
// we always skip the all 0 case
if ((i == 0) && (j == 0) && (k == 0))
continue;
// compute index within ghosted patch
int a = i0 + i * mult;
int b = j0 + j * mult;
int c = k0 + k * mult;
int idx;
// compute offset into ghost array assuming
// a zone really exists at the logical index [a,b,c]
switch (numDims)
{
case 3: idx = c*Mi*Mj + b*Mi + a; break;
case 2: idx = b*Mi + a; break;
case 1: idx = a; break;
}
// if the computed index is either out of
// range or the ghost value indicates it
// is NOT really a ghost, its invalid
if ((idx < 0) || (idx >= numCells) ||
(ghostData[idx] == 0))
{
impossibleGhostCase = true;
}
}
}
}
}
if (!impossibleGhostCase)
{
ghostCases.push_back(gi);
ghostCases.push_back(gj);
ghostCases.push_back(gk);
}
}
}
}
if (ghostCases.size() != 3)
{
EXCEPTION2(UnexpectedValueException, 3, ghostCases.size());
}
ghostLayers[0] = ghostCases[0];
ghostLayers[1] = ghostCases[1];
ghostLayers[2] = ghostCases[2];
}
vtkDataArray *
avtColorComposeExpression::DeriveVariable(vtkDataSet *in_ds, int currentDomainsIndex)
{
size_t numinputs = varnames.size();
//
// Our first operand is in the active variable. We don't know if it's
// point data or cell data, so check which one is non-NULL.
//
vtkDataArray *cell_data1 = in_ds->GetCellData()->GetArray(varnames[0]);
vtkDataArray *point_data1 = in_ds->GetPointData()->GetArray(varnames[0]);
vtkDataArray *data1 = NULL, *data2 = NULL, *data3 = NULL, *data4 = NULL;
avtCentering centering;
if (cell_data1 != NULL)
{
data1 = cell_data1;
centering = AVT_ZONECENT;
}
else
{
data1 = point_data1;
centering = AVT_NODECENT;
}
if (data1 != NULL && data1->GetNumberOfComponents() != 1)
{
EXCEPTION2(ExpressionException, outputVariableName,
"The first variable is not a scalar.");
}
// Get the second variable.
if (centering == AVT_ZONECENT)
data2 = in_ds->GetCellData()->GetArray(varnames[1]);
else
data2 = in_ds->GetPointData()->GetArray(varnames[1]);
if (data2 == NULL)
{
EXCEPTION2(ExpressionException, outputVariableName,
"The first two variables have different centering.");
}
if (data2->GetNumberOfComponents() != 1)
{
EXCEPTION2(ExpressionException, outputVariableName,
"The second variable is not a scalar.");
}
if (numinputs >= 3)
{
// Get the third variable.
if (centering == AVT_ZONECENT)
data3 = in_ds->GetCellData()->GetArray(varnames[2]);
else
data3 = in_ds->GetPointData()->GetArray(varnames[2]);
if (data3 == NULL)
{
EXCEPTION2(ExpressionException, outputVariableName,
"The first and third variables have different centering.");
}
if (data3->GetNumberOfComponents() != 1)
{
EXCEPTION2(ExpressionException, outputVariableName,
"The third variable is not a scalar.");
}
}
if (numinputs == 4)
{
// Get the fourth variable.
if (centering == AVT_ZONECENT)
data4 = in_ds->GetCellData()->GetArray(varnames[3]);
else
data4 = in_ds->GetPointData()->GetArray(varnames[3]);
if (data4 == NULL)
{
EXCEPTION2(ExpressionException, outputVariableName,
"The first and fourth variables have different centering.");
}
if (data4->GetNumberOfComponents() != 1)
{
EXCEPTION2(ExpressionException, outputVariableName,
"The fourth variable is not a scalar.");
}
}
vtkIdType nvals = data1->GetNumberOfTuples();
vtkDataArray *dv = data1->NewInstance();
dv->SetNumberOfComponents(4);
dv->SetNumberOfTuples(data1->GetNumberOfTuples());
if(numinputs == 1)
{
for(vtkIdType id = 0; id < nvals; ++id)
{
double val1 = ClampColor(data1->GetTuple1(id));
dv->SetTuple4(id, val1, 0., 0., 255.);
}
}
else if(numinputs == 2)
{
for(vtkIdType id = 0; id < nvals; ++id)
{
double val1 = ClampColor(data1->GetTuple1(id));
double val2 = ClampColor(data2->GetTuple1(id));
dv->SetTuple4(id, val1, val2, 0., 255.);
}
}
else if(numinputs == 3)
{
for(vtkIdType id = 0; id < nvals; ++id)
{
double val1 = ClampColor(data1->GetTuple1(id));
double val2 = ClampColor(data2->GetTuple1(id));
double val3 = ClampColor(data3->GetTuple1(id));
dv->SetTuple4(id, val1, val2, val3, 255.);
}
}
else if(numinputs == 4)
{
for(vtkIdType id = 0; id < nvals; ++id)
{
double val1 = ClampColor(data1->GetTuple1(id));
double val2 = ClampColor(data2->GetTuple1(id));
double val3 = ClampColor(data3->GetTuple1(id));
double val4 = ClampColor(data4->GetTuple1(id));
dv->SetTuple4(id, val1, val2, val3, val4);
}
}
return dv;
}
void
avtShapeletDecompositionQuery::Execute(vtkDataSet *ds, const int dom)
{
// clear any prev result
if(decompResult)
{
delete decompResult;
decompResult = NULL;
}
// make sure set is rectilinear
if (ds->GetDataObjectType() != VTK_RECTILINEAR_GRID)
{
EXCEPTION1(VisItException,
"The Shapelet Decomposition Query only operates on 2D"
" rectilinear grids.");
}
vtkRectilinearGrid *rgrid = (vtkRectilinearGrid *) ds;
int dims[3];
rgrid->GetDimensions(dims);
if (dims[2] > 1)
{
EXCEPTION2(InvalidDimensionsException, "Shapelet Decomposition",
"2-dimensional");
}
// make sure this is a zonal varaible
std::string var = queryAtts.GetVariables()[0];
vtkDataArray *vals = rgrid->GetCellData()->GetArray(var.c_str());
if(!vals)
{
EXCEPTION1(InvalidVariableException, var.c_str());
}
// get width & height
int width = dims[0]-1;
int height = dims[1]-1;
recompError = 1.0; // set error to 1.0 (max)
// create basis set
avtShapeletBasisSet basis_set(beta,nmax,width,height);
avtShapeletDecompose decomp;
avtShapeletReconstruct recomp;
// do decomp
decompResult = decomp.Execute(rgrid,var,&basis_set);
if(decompResult)
{
// do recomp
vtkRectilinearGrid *recomp_res = recomp.Execute(decompResult,var,&basis_set);
// calc error
recompError = ComputeError(rgrid,recomp_res,var);
if(recompOutputFileName != "")
{
// save output
vtkVisItUtility::WriteDataSet(recomp_res,
recompOutputFileName.c_str());
}
// delete recomp image
recomp_res->Delete();
}
}
void
avtArrayComposeWithBinsExpression::ProcessArguments(ArgsExpr *args,
ExprPipelineState *state)
{
// Check the number of arguments
std::vector<ArgExpr*> *arguments = args->GetArgs();
nvars = (int)arguments->size()-1;
int idx_of_list = arguments->size()-1;
ArgExpr *listarg = (*arguments)[idx_of_list];
ExprParseTreeNode *listTree = listarg->GetExpr();
if (listTree->GetTypeName() != "List")
{
debug1 << "avtArrayComposeWithBinsExpression: second arg is not a "
<< "list: " << listTree->GetTypeName() << endl;
EXCEPTION2(ExpressionException, outputVariableName,
"the last argument to array_compose_"
"with_bins must be a list");
}
ListExpr *list = dynamic_cast<ListExpr*>(listTree);
std::vector<ListElemExpr*> *elems = list->GetElems();
binRanges.resize(elems->size());
if ((int)elems->size() != nvars+1)
{
EXCEPTION2(ExpressionException, outputVariableName,
"the list for array_compose_with_bins"
" must have one more number than there are variables. "
" For two variables (V1 and V2), there should be a list of"
" size 3: [L0, L1, L2]. V1's bin goes from L0 to L1, "
"and V2's bin goes from L1 to L2.");
}
for (size_t i = 0 ; i < elems->size() ; i++)
{
if ((*elems)[i]->GetEnd())
{
EXCEPTION2(ExpressionException, outputVariableName,
"the list for array_compose_with"
"_bins expression cannot contain ranges.");
}
ExprNode *item = (*elems)[i]->GetItem();
if (item->GetTypeName() == "FloatConst")
{
ConstExpr *c = dynamic_cast<ConstExpr*>(item);
binRanges[i] = dynamic_cast<FloatConstExpr*>(c)->GetValue();
}
else if (item->GetTypeName() == "IntegerConst")
{
ConstExpr *c = dynamic_cast<ConstExpr*>(item);
binRanges[i] = dynamic_cast<IntegerConstExpr*>(c)->GetValue();
}
else
{
EXCEPTION2(ExpressionException, outputVariableName,
"the list for the array_compose"
"_with_bins expression may contain only numbers.");
}
}
// Let the base class do this processing. We only had to over-ride this
// function to determine the number of arguments.
avtMultipleInputExpressionFilter::ProcessArguments(args, state);
}
vtkDataArray *
avtMagnitudeExpression::DeriveVariable(vtkDataSet *in_ds, int currentDomainsIndex)
{
//
// The base class will set the variable of interest to be the
// 'activeVariable'. This is a by-product of how the base class sets its
// input. If that method should change (SetActiveVariable), this
// technique for inferring the variable name may stop working.
//
const char *varname = activeVariable;
vtkDataArray *vectorValues = in_ds->GetPointData()->GetArray(varname);
if (vectorValues == NULL)
{
vectorValues = in_ds->GetCellData()->GetArray(varname);
}
if (vectorValues == NULL)
{
EXCEPTION2(ExpressionException, outputVariableName,
"Unable to locate variable for magnitude expression");
}
if (vectorValues->GetNumberOfComponents() != 3)
{
EXCEPTION2(ExpressionException, outputVariableName,
"Can only take magnitude of vectors.");
}
vtkIdType ntuples = vectorValues->GetNumberOfTuples();
vtkDataArray *results = vectorValues->NewInstance();
results->SetNumberOfComponents(1);
results->SetNumberOfTuples(ntuples);
#define COMPUTE_MAG(dtype) \
{ \
dtype *x = (dtype*)vectorValues->GetVoidPointer(0); \
dtype *r = (dtype*)results->GetVoidPointer(0); \
for (vtkIdType i = 0, idx = 0 ; i < ntuples ; i++, idx += 3) \
{ \
r[i] = sqrt((double)x[idx+0]*(double)x[idx+0]+\
(double)x[idx+1]*(double)x[idx+1]+\
(double)x[idx+2]*(double)x[idx+2]); \
} \
}
if(vectorValues->HasStandardMemoryLayout())
{
switch(vectorValues->GetDataType())
{
vtkTemplateMacro(COMPUTE_MAG(VTK_TT));
}
}
else
{
for(vtkIdType i = 0; i < ntuples ; i++)
{
const double *x = vectorValues->GetTuple(i);
results->SetTuple1(i, sqrt(x[0]*x[0]+ x[1]*x[1]+ x[2]*x[2]));
}
}
return results;
}
