/* copy (memcpy) the data of a dataArray_double to an AVSfield_double * -assumes 2vec input */ AVSfield_double *dataArray_2_AVSfield(dataArray_double *in) { assert(in != NULL); assert(in->dimensions[0] == 2); /* veclen */ /* copy input array dimensions, copy veclen as a new dimension */ int *dim = (int*) malloc( sizeof(int)*((in->nd)) ); for(int i=0;i<(in->nd)-1;i++) dim[i] = in->dimensions[i+1]; /* allocate new dataArray_double */ char field_str[100]; /* generate a data type description for AVS */ sprintf(field_str,"field %dD %d-vector uniform double", 3, 2); AVSfield_double *out = (AVSfield_double *) AVSdata_alloc(field_str, dim);/* let AVS allocate array */ free(dim); /* copy the data */ memcpy(out->data, in->data, sizeof(double)*(in->num_elem)); return(out); }
/************************************************************************** Module Compute Routine */ int module_compute( AVSfield_double *coords, AVSfield_double *weights, AVSfield *kernelt_table_in, AVSfield_double **out, int iterations, int effective_matrix, float *rad_fov_prod, float *osf_in) { /* rfp is relative to the grid size */ float norm_rfp = (RADIUS_FOV_PRODUCT)*(*osf_in); /* update UI */ AVSmodify_float_parameter ("rad fov prod (pix)", AVS_VALUE|AVS_MINVAL|AVS_MAXVAL, norm_rfp, norm_rfp, norm_rfp); /* free downstream data */ if(*out!= NULL) AVSfield_free((AVSfield *) *out); /* COORDS */ /* copy from dataArray_double to AVSfield_double */ unsigned long *tmp_dims_l = (unsigned long *) malloc(sizeof(int)*(coords->ndim+1)); // make copy of dims tmp_dims_l[0] = coords->veclen; // add veclen as the first dimension for(int i=0;i<coords->ndim+1;i++) tmp_dims_l[i+1] = coords->dimensions[i]; // copy dims dataArray_double *crds_tmp = new_dataArray_double(coords->ndim+1,tmp_dims_l); // make new dataArray_double free(tmp_dims_l); memcpy(crds_tmp->data,coords->data,(crds_tmp->num_elem)*sizeof(double)); // copy coords /* make temporary output from sdc3grid_main() */ dataArray_double *out_tmp = NULL; /* make a temporary array for input weights, if available */ dataArray_double *weights_tmp = NULL; /* copy weights to a temporary dataArray_double if the user has passed them */ if(weights != NULL) { /* COORDS */ /* copy from dataArray_double to AVSfield_double */ unsigned long *tmp_dims_l = (unsigned long *) malloc(sizeof(int)*(weights->ndim)); // make copy of dims for(int i=0;i<weights->ndim;i++) tmp_dims_l[i] = weights->dimensions[i]; // copy dims weights_tmp = new_dataArray_double(weights->ndim,tmp_dims_l); // make new dataArray_double free(tmp_dims_l); memcpy(weights_tmp->data,weights->data,(weights_tmp->num_elem)*sizeof(double)); // copy weights } /* run sample density estimation */ out_tmp = sdc3grid_main(crds_tmp,weights_tmp,iterations,effective_matrix,*osf_in,2); /* OUTPUT */ /* copy from dataArray_double to AVSfield_double */ char field_str[100]; // generate a data type description for AVS sprintf(field_str,"field %dD %d-vector uniform double",out_tmp->nd, 1); int *tmp_dims = (int *) malloc(sizeof(int)*(out_tmp->nd)); for(int i=0;i<out_tmp->nd;i++) tmp_dims[i] = out_tmp->dimensions[i]; *out = (AVSfield_double *) AVSdata_alloc(field_str, tmp_dims);// let AVS allocate array free(tmp_dims); memcpy((*out)->data,out_tmp->data,out_tmp->num_elem*sizeof(double)); // copy the data /* free temp data */ free_dataArray_double(out_tmp); free_dataArray_double(crds_tmp); return 1; }
//bool UniField::allocField(int nDims, int *dims, int vecLen, int nSpace, bool, int, const char *name) bool UniField::allocField(int nDims, int *dims, int nSpace, bool, int nComp, int *compVecLen, const char **compNames, int) #endif #endif { // compNames: may be NULL and may have NULL entries #ifdef AVS char regularity[256]; sprintf(regularity, (regular ? "regular" : "irregular")); char type[256]; switch (dataType) { case DT_FLOAT: { sprintf(type, "float"); } break; default: printf("UniField: ERROR: unsupported data type\n"); } if (nComp > 1) printf("UniField: ERROR: compVecLen>1 not supported\n"); char desc[256]; sprintf(desc, "field %dD %d-vector %s %d-space %s", nDims, compVecLen[0], regularity, nSpace, type); AVSfield_float *wf; wf = (AVSfield_float *)AVSdata_alloc(desc, dims); avsFld = (AVSfield *)wf; return (avsFld); #endif #ifdef COVISE if (outPorts.size() < 1) { fprintf(stderr, "UniField:allocField: no output port information, exit\n"); exit(1); // ### } #ifdef COVISE5 covGrid = new DO_StructuredGrid #else covGrid = new coDoStructuredGrid #endif (outPorts[0]->getObjName(), // ### not ok dims[0], (nDims >= 2 ? dims[1] : 1), (nDims >= 3 ? dims[2] : 1)); if (compVecLen[0] <= 1) { #ifdef COVISE5 covScalarData = new DO_Structured_S3D_Data(outPorts[1]->getObjName(), // ### not ok dims[0], (nDims >= 2 ? dims[1] : 1), (nDims >= 3 ? dims[2] : 1)); #else covScalarData = new coDoFloat(outPorts[1]->getObjName(), // ### not ok dims[0] * (nDims >= 2 ? dims[1] : 1) * (nDims >= 3 ? dims[2] : 1)); #endif } else if (compVecLen[0] == 2) { #ifdef COVISE5 covVector2Data = new DO_Structured_V2D_Data(outPorts[1]->getObjName(), // ### not ok dims[0], (nDims >= 2 ? dims[1] : 1), (nDims >= 3 ? dims[2] : 1)); #else covVector2Data = new coDoVec2(outPorts[1]->getObjName(), // ### not ok dims[0] * (nDims >= 2 ? dims[1] : 1) * (nDims >= 3 ? dims[2] : 1)); #endif } else if (compVecLen[0] == 3) { #ifdef COVISE5 covVector3Data = new DO_Structured_V3D_Data(outPorts[1]->getObjName(), // ### not ok dims[0], (nDims >= 2 ? dims[1] : 1), (nDims >= 3 ? dims[2] : 1)); #else covVector3Data = new coDoVec3(outPorts[1]->getObjName(), // ### not ok dims[0] * (nDims >= 2 ? dims[1] : 1) * (nDims >= 3 ? dims[2] : 1)); #endif } else { fprintf(stderr, "UniField: error: unsupported vector length\n"); } return (covGrid && (covScalarData || covVector2Data || covVector3Data)); #endif #ifdef VTK #if 0 this->nDims = nDims; int vSize = 1; for (int i=0; i<nDims; i++) { this->dims[i] = dims[i]; vSize *= dims[i]; } this->vecLen = vecLen; this->nSpace = nSpace; this->regular = regular; vtkFld = (float *) malloc(vSize * vecLen * sizeof(float)); vtkPositions = (float *) malloc(vSize * nSpace * sizeof(float)); #else if (!vtkFld) vtkFld = vtkStructuredGrid::New(); selectedComp = 0; // get dims // ##### TODO: seems that VTK only supports 3-dims int dimensions[3] = { 1, 1, 1 }; if (nDims > 3) { printf("UniField: error: VTK supports only 3-dim\n"); nDims = 3; } int nnodes = 1; for (int i = 0; i < nDims; i++) { dimensions[i] = dims[i]; nnodes *= dims[i]; } // grid vtkFld->SetDimensions(dimensions); // coords vtkFloatArray *coords = vtkFloatArray::New(); coords->SetNumberOfComponents(nSpace); coords->SetNumberOfTuples(nnodes); vtkPoints *points = vtkPoints::New(); points->SetData(coords); vtkFld->SetPoints(points); coords->Delete(); points->Delete(); // data for (int c = 0; c < nComp; c++) { vtkFloatArray *dat = vtkFloatArray::New(); dat->SetNumberOfComponents(compVecLen[c]); dat->SetNumberOfTuples(nnodes); if (compNames && compNames[c]) dat->SetName(compNames[c]); else { char buf[256]; sprintf(buf, "%p", dat); dat->SetName(buf); } vtkFld->GetPointData()->AddArray(dat); dat->Delete(); } #endif return true; // ### #endif }
/* *****************************************/ int ucd_Mz_compute(UCD_structure *ucd, UCD_structure *grid, UCD_structure **ucd_out, AVSfield_float **trajectories, float *origin_x, float *origin_y, float *origin_z, int cells_x, int cells_y, int cells_z, float *cell_size, char *velocity, int unsteady, char *velocity_file, int strong_hyperbolicity, int ABC_steady, float *start_time, float *integration_time, int time_intervals, int integ_steps_max, int forward, int smoothing_range, int omit_boundary_cells, int grad_neigh_disabled, int execute) { /* ----> START OF USER-SUPPLIED CODE SECTION #3 (COMPUTE ROUTINE BODY) */ // system wrapper UniSys us; if (ucd_findNodeCompByVeclen(ucd, 3, 0) < 0) { us.error("UCD must contain at least one 3-vect component"); return 0; } //if (AVSparameter_changed("mode")) { { char *cp1, *cp2; if (grid) { AVScommand("kernel", "manipulator \"$Module:origin x\" -hide", &cp1, &cp2); AVScommand("kernel", "manipulator \"$Module:origin y\" -hide", &cp1, &cp2); AVScommand("kernel", "manipulator \"$Module:origin z\" -hide", &cp1, &cp2); AVScommand("kernel", "manipulator \"$Module:cells x\" -hide", &cp1, &cp2); AVScommand("kernel", "manipulator \"$Module:cells y\" -hide", &cp1, &cp2); AVScommand("kernel", "manipulator \"$Module:cells z\" -hide", &cp1, &cp2); AVScommand("kernel", "manipulator \"$Module:cell size\" -hide", &cp1, &cp2); } else { AVScommand("kernel", "manipulator \"$Module:origin x\" -show", &cp1, &cp2); AVScommand("kernel", "manipulator \"$Module:origin y\" -show", &cp1, &cp2); AVScommand("kernel", "manipulator \"$Module:origin z\" -show", &cp1, &cp2); AVScommand("kernel", "manipulator \"$Module:cells x\" -show", &cp1, &cp2); AVScommand("kernel", "manipulator \"$Module:cells y\" -show", &cp1, &cp2); AVScommand("kernel", "manipulator \"$Module:cells z\" -show", &cp1, &cp2); AVScommand("kernel", "manipulator \"$Module:cell size\" -show", &cp1, &cp2); } if (unsteady) { AVScommand("kernel", "manipulator \"$Module:velocity file\" -show", &cp1, &cp2); AVScommand("kernel", "manipulator \"$Module:start time\" -show", &cp1, &cp2); } else { AVScommand("kernel", "manipulator \"$Module:velocity file\" -hide", &cp1, &cp2); AVScommand("kernel", "manipulator \"$Module:start time\" -hide", &cp1, &cp2); } } if (*integration_time <= 0.0) { us.error("integration time must be larger than zero"); return 0; } // input wrapper if (AVSinput_changed("ucd", 0)) { if (unst) delete unst; unst = new Unstructured(ucd); } // process component choice selection int compVelo = ucd_processCompChoice(ucd, "ucd", velocity, "velocity", 3, unst->getVectorNodeDataComponent()); if (compVelo >= 0) unst->selectVectorNodeData(compVelo); // init /* Allocate output UCD */ if (*ucd_out && *ucd_out != ucd) UCDstructure_free(*ucd_out); UCD_structure *ucd1 = NULL; char labels[256] = "Mz.integration time"; int components[2] = { 1, 1 }; if (grid) { ucd1 = ucdClone(grid, 2, components, "ucd out", labels, "."); } else { ucd1 = generateUniformUCD("ucd out", *origin_x, *origin_y, *origin_z, cells_x, cells_y, cells_z, *cell_size, 2, components, labels, "."); } *ucd_out = ucd1; // unstructured wrapper for output Unstructured *unst_out = new Unstructured(*ucd_out); // allocate field for trajectories if (*trajectories) AVSfield_free((AVSfield *)*trajectories); int dims[2]; dims[0] = integ_steps_max + 1; dims[1] = ucd1->nnodes; *trajectories = (AVSfield_float *)AVSdata_alloc("field 2D 2-vector irregular 3-space float", dims); if (*trajectories == NULL) { AVSerror("allocation failed"); return (0); } // field wrapper for output UniField *unif_traj = new UniField((AVSfield *)*trajectories); // compute if (execute) { Mz_impl(&us, unst, compVelo, unsteady, velocity_file, strong_hyperbolicity, ABC_steady, *start_time, *integration_time, time_intervals, integ_steps_max, forward, unst_out, smoothing_range, omit_boundary_cells, grad_neigh_disabled, unif_traj); // ##### work around, because there is a bug in unsetVector3CB() if (unst) delete unst; unst = new Unstructured(ucd); } // delete unstructured wrapper for output (but not the field) delete unst_out; // delete field wrapper (but not the field) delete unif_traj; /* <---- END OF USER-SUPPLIED CODE SECTION #3 */ return (1); }