int avtDisplacementExpression::GetVariableDimension(void) { if (*(GetInput()) == NULL) return avtMultipleInputExpressionFilter::GetVariableDimension(); if (varnames.size() != 2) return avtMultipleInputExpressionFilter::GetVariableDimension(); avtDataAttributes &atts = GetInput()->GetInfo().GetAttributes(); if (! atts.ValidVariable(varnames[0])) return avtMultipleInputExpressionFilter::GetVariableDimension(); int ncomp1 = atts.GetVariableDimension(varnames[0]); if (! atts.ValidVariable(varnames[1])) return avtMultipleInputExpressionFilter::GetVariableDimension(); int ncomp2 = atts.GetVariableDimension(varnames[1]); return GetNumberOfComponentsInOutput(ncomp1, ncomp2); }
int avtUnaryMathExpression::GetVariableDimension(void) { if (*(GetInput()) == NULL) return avtSingleInputExpressionFilter::GetVariableDimension(); // // 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; if (varname == NULL) return avtSingleInputExpressionFilter::GetVariableDimension(); avtDataAttributes &atts = GetInput()->GetInfo().GetAttributes(); if (! atts.ValidVariable(varname)) return avtSingleInputExpressionFilter::GetVariableDimension(); int ncomp = atts.GetVariableDimension(varname); return GetNumberOfComponentsInOutput(ncomp); }
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; }