visit_handle
SimGetMesh(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
if(strcmp(name, "unstructured3d") == 0)
{
if(VisIt_UnstructuredMesh_alloc(&h) != VISIT_ERROR)
{
visit_handle x,y,z,conn;
VisIt_VariableData_alloc(&x);
VisIt_VariableData_alloc(&y);
VisIt_VariableData_alloc(&z);
VisIt_VariableData_setDataD(x, VISIT_OWNER_SIM, 1, umnnodes, umx);
VisIt_VariableData_setDataD(y, VISIT_OWNER_SIM, 1, umnnodes, umy);
VisIt_VariableData_setDataD(z, VISIT_OWNER_SIM, 1, umnnodes, umz);
VisIt_VariableData_alloc(&conn);
VisIt_VariableData_setDataI(conn, VISIT_OWNER_SIM, 1,
lconnectivity, connectivity);
VisIt_UnstructuredMesh_setCoordsXYZ(h, x, y, z);
VisIt_UnstructuredMesh_setConnectivity(h, umnzones, conn);
}
}
return h;
}
visit_handle
SimGetMesh(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
simulation_data *sim = (simulation_data *)cbdata;
if(strcmp(name, "mesh1d") == 0)
{
if(VisIt_UnstructuredMesh_alloc(&h) != VISIT_ERROR)
{
visit_handle x,y,conn;
int nzones;
nzones = sim->npts-1;
VisIt_VariableData_alloc(&x);
VisIt_VariableData_alloc(&y);
VisIt_VariableData_setDataF(x, VISIT_OWNER_SIM, 1, sim->npts, sim->x);
VisIt_VariableData_setDataF(y, VISIT_OWNER_SIM, 1, sim->npts, sim->y);
VisIt_VariableData_alloc(&conn);
VisIt_VariableData_setDataI(conn, VISIT_OWNER_SIM, 1,
3*nzones, sim->conn);
VisIt_UnstructuredMesh_setCoordsXY(h, x, y);
VisIt_UnstructuredMesh_setConnectivity(h, nzones, conn);
}
}
return h;
}
visit_handle
SimGetVariable(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
simulation_data *sim = (simulation_data *)cbdata;
if(strcmp(name, "zonal") == 0)
{
/* Find the right domain. */
int i;
Domain *d = NULL;
for(i = 0; i < sim->nDomains; ++i)
{
if(sim->domains[i].globalIndex == domain)
{
d = &sim->domains[i];
break;
}
}
if(d != NULL && VisIt_VariableData_alloc(&h) != VISIT_ERROR)
{
int nTuples = (d->dims[0]-1) * (d->dims[1]-1) * (d->dims[2]-1);
VisIt_VariableData_alloc(&h);
VisIt_VariableData_setDataF(h, VISIT_OWNER_SIM, 1,
nTuples, d->variable);
}
}
return h;
}
visit_handle
SimGetMesh(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
if(strcmp(name, "mesh2d") == 0)
{
if(VisIt_RectilinearMesh_alloc(&h) == VISIT_OKAY)
{
int i;
visit_handle x,y;
/* Initialize X coords. */
for(i = 0; i < NX; ++i)
{
float t = (float)i / (float)(NX-1);
rmesh_x[i] = (1.f-t)*XMIN + t*XMAX;
}
/* Initialize Y coords. */
for(i = 0; i < NY; ++i)
{
float t = (float)i / (float)(NY-1);
rmesh_y[i] = (1.f-t)*YMIN + t*YMAX;
}
VisIt_VariableData_alloc(&x);
VisIt_VariableData_alloc(&y);
VisIt_VariableData_setDataF(x, VISIT_OWNER_SIM, 1, NX, rmesh_x);
VisIt_VariableData_setDataF(y, VISIT_OWNER_SIM, 1, NY, rmesh_y);
VisIt_RectilinearMesh_setCoordsXY(h, x, y);
}
}
else if(strcmp(name, "ucdmesh") == 0)
{
visit_handle c, hc;
if(VisIt_UnstructuredMesh_alloc(&h) == VISIT_OKAY &&
VisIt_VariableData_alloc(&c) == VISIT_OKAY &&
VisIt_VariableData_alloc(&hc) == VISIT_OKAY)
{
int nnodes, nzones;
nnodes = (NX * NY);
nzones = (NX-1)*(NY-1);
VisIt_VariableData_setDataF(c, VISIT_OWNER_SIM, 2, nnodes, (float*)coords2d);
VisIt_VariableData_setDataI(hc, VISIT_OWNER_SIM, 1, 5*nzones,
connectivity);
VisIt_UnstructuredMesh_setCoords(h, c);
VisIt_UnstructuredMesh_setConnectivity(h, nzones, hc);
}
}
return h;
}
visit_handle
SimGetDomainList(const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
if(VisIt_DomainList_alloc(&h) != VISIT_ERROR)
{
visit_handle hdl;
int i, *iptr = NULL, dcount = 0;
int ndoms = 9;
simulation_data *sim = (simulation_data *)cbdata;
iptr = (int *)malloc(ndoms * sizeof(int));
memset(iptr, 0, ndoms * sizeof(int));
for(i = 0; i < ndoms; i++)
{
int owner_of_domain = i % sim->par_size;
if(sim->par_rank == owner_of_domain)
iptr[dcount++] = i;
}
VisIt_VariableData_alloc(&hdl);
VisIt_VariableData_setDataI(hdl, VISIT_OWNER_VISIT, 1, dcount, iptr);
VisIt_DomainList_setDomains(h, dcount, hdl);
}
return h;
}
visit_handle SimGetVariable(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
int f, ret = -1, nComponents = 1, nTuples;
simulation_data *sim = (simulation_data *)cbdata;
if(VisIt_VariableData_alloc(&h) == VISIT_OKAY)
{
nTuples = (sim->grid.Ncolumns) * (sim->grid.Nrows) * (sim->grid.Nlevels);
for (f = 0; f < NFIELDS; f++)
{
char simdname[8];
sprintf(simdname, "data%03d", f);
if(strcmp(name, simdname) == 0)
{
ret = VisIt_VariableData_setDataF(h, VISIT_OWNER_SIM, nComponents, nTuples, sim->grid.data[f]);
break;
}
}
if(ret == VISIT_ERROR)
{
VisIt_VariableData_free(h);
h = VISIT_INVALID_HANDLE;
}
}
return h;
}
visit_handle
SimGetVariable(int domain, const char *name, void *cbdata)
{
int ncells;
visit_handle h = VISIT_INVALID_HANDLE;
simulation_data *sim = (simulation_data *)cbdata;
if(strcmp(name, "rect_var") == 0)
{
ncells = (sim->blankRectMesh.dims[0]-1) * (sim->blankRectMesh.dims[1]-1);
VisIt_VariableData_alloc(&h);
VisIt_VariableData_setDataF(h, VISIT_OWNER_SIM, 1,
ncells, sim->blankRectMesh.data);
}
else if(strcmp(name, "curv_var") == 0)
{
ncells = (sim->blankCurvMesh.dims[0]-1) * (sim->blankCurvMesh.dims[1]-1);
VisIt_VariableData_alloc(&h);
VisIt_VariableData_setDataF(h, VISIT_OWNER_SIM, 1,
ncells, sim->blankCurvMesh.data);
}
else if(strcmp(name, "ucd_var") == 0)
{
VisIt_VariableData_alloc(&h);
VisIt_VariableData_setDataF(h, VISIT_OWNER_SIM, 1,
sim->blankUcdMesh.ncells, sim->blankUcdMesh.data);
}
else if(strncmp(name, "multi_var", 9) == 0)
{
ncells = (sim->multidomain[domain].m.dims[0]-1) * (sim->multidomain[domain].m.dims[1]-1);
VisIt_VariableData_alloc(&h);
VisIt_VariableData_setDataF(h, VISIT_OWNER_SIM, 1,
ncells, sim->multidomain[domain].m.data);
}
else if(domain < 4 && strcmp(name, "multi_types_var") == 0)
{
ncells = (sim->multipletypes[domain].dims[0]-1) *
(sim->multipletypes[domain].dims[1]-1) *
(sim->multipletypes[domain].dims[2]-1);
VisIt_VariableData_alloc(&h);
VisIt_VariableData_setDataF(h, VISIT_OWNER_SIM, 1,
ncells, sim->multipletypes[domain].data);
}
return h;
}
visit_handle
SimGetMesh(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
if(strcmp(name, "amr") == 0)
{
if(VisIt_RectilinearMesh_alloc(&h) != VISIT_ERROR)
{
visit_handle x, y;
int i, nx, ny;
float cx[100], cy[100], t;
/* Create the X coordinates */
nx = rmxext[domain][1] - rmxext[domain][0]+1+1;
for(i = 0; i < nx; ++i)
{
t = (float)i / (float)(nx-1);
cx[i] = (1.-t)*rmx[domain][0] + t*rmx[domain][1];
}
/* Create the Y coordinates */
ny = rmyext[domain][1] - rmyext[domain][0]+1+1;
for(i = 0; i < ny; ++i)
{
t = (float)i / (float)(ny-1);
cy[i] = (1.-t)*rmy[domain][0] + t*rmy[domain][1];
}
VisIt_VariableData_alloc(&x);
VisIt_VariableData_alloc(&y);
VisIt_VariableData_setDataF(x, VISIT_OWNER_COPY, 1, nx, cx);
VisIt_VariableData_setDataF(y, VISIT_OWNER_COPY, 1, ny, cy);
VisIt_RectilinearMesh_setCoordsXY(h, x, y);
}
}
return h;
}
visit_handle SimGetMesh(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
simulation_data *sim = (simulation_data *)cbdata;
if(strcmp(name, "mesh") == 0)
{
if(VisIt_RectilinearMesh_alloc(&h) != VISIT_ERROR)
{
int minRealIndex[3], maxRealIndex[3];
minRealIndex[0] = 0;
minRealIndex[1] = 0;
minRealIndex[2] = 0;
maxRealIndex[0] = sim->grid.Ncolumns;
maxRealIndex[1] = sim->grid.Nrows;
maxRealIndex[2] = sim->grid.Nlevels;
#ifdef SHOW_GHOST_ARRAY
// only modify in X and Y directions, since Z does not have ghost
minRealIndex[0]++;
minRealIndex[1]++;
maxRealIndex[0]--;
maxRealIndex[1]--;
#endif
//fprintf(stderr,"minRealIndex[%dx%dx%d], maxRealIndex[%dx%dx%d]\n", minRealIndex[0], minRealIndex[1],minRealIndex[2],maxRealIndex[0], maxRealIndex[1],maxRealIndex[2]);
visit_handle hxc, hyc, hzc;
VisIt_VariableData_alloc(&hxc);
VisIt_VariableData_alloc(&hyc);
VisIt_VariableData_alloc(&hzc);
VisIt_VariableData_setDataF(hxc, VISIT_OWNER_SIM, 1, sim->grid.Ncolumns+1, sim->grid.rmesh_x);
VisIt_VariableData_setDataF(hyc, VISIT_OWNER_SIM, 1, sim->grid.Nrows+1, sim->grid.rmesh_y);
VisIt_VariableData_setDataF(hzc, VISIT_OWNER_SIM, 1, sim->grid.Nlevels+1, sim->grid.rmesh_z);
VisIt_RectilinearMesh_setCoordsXYZ(h, hxc, hyc, hzc);
#ifdef SHOW_GHOST_ARRAY
VisIt_RectilinearMesh_setRealIndices(h, minRealIndex, maxRealIndex);
#endif
}
}
return h;
}
visit_handle
SimGetMesh(int domain, const char *name, void *cbdata)
{
visit_handle res = VISIT_INVALID_HANDLE;
if(strcmp(name, "quadmesh") == 0)
{
if(VisIt_RectilinearMesh_alloc(&res) != VISIT_ERROR)
{
int i,minRealIndex[3]={0,0,0}, maxRealIndex[3]={0,0,0};
float *rmesh[3];
visit_handle h[3];
// fprintf(stderr,"proc %d\t:simgetmesh: %d\t%d\t%d\n",rank,rmesh_dims[0],rmesh_dims[1],rmesh_dims[2]);
// fflush(stderr);
for(i=0;i<3;i++)
{
minRealIndex[i] = 0;
maxRealIndex[i] = rmesh_dims[i]-1;
// attention do not free !
rmesh[i] = (float *)malloc(sizeof(float) * rmesh_dims[i]);
}
for(i = 0; i < rmesh_dims[0]; ++i)
rmesh[0][i] = i*dx;
for(i = 0; i < rmesh_dims[1]; ++i)
rmesh[1][i] = i*dy;
for(i = 0; i < rmesh_dims[2]; ++i)
rmesh[2][i] =(zmin+i)*dz;
for(i=0;i<3;i++)
{
VisIt_VariableData_alloc(&h[i]);
VisIt_VariableData_setDataF(h[i], VISIT_OWNER_VISIT, 1,rmesh_dims[i], rmesh[i]);
}
VisIt_RectilinearMesh_setCoordsXYZ(res, h[0], h[1],h[2]);
VisIt_RectilinearMesh_setRealIndices(res, minRealIndex, maxRealIndex);
}
else
{
fprintf(stderr,"proc: %d:Erreur allocation in SimGetMesh\n",rank);
}
}
return res;
}
visit_handle
SimGetCurve(const char *name, void *cbdata)
{
int h = VISIT_INVALID_HANDLE;
simulation_data *sim = (simulation_data *)cbdata;
if(strcmp(name, "sine") == 0)
{
if(VisIt_CurveData_alloc(&h) != VISIT_ERROR)
{
visit_handle hxc, hyc;
/* Give the arrays to VisIt. VisIt will free them. */
VisIt_VariableData_alloc(&hxc);
VisIt_VariableData_alloc(&hyc);
VisIt_VariableData_setDataF(hxc, VISIT_OWNER_SIM, 1, NPTS, sim->x);
VisIt_VariableData_setDataF(hyc, VISIT_OWNER_SIM, 1, NPTS, sim->y);
VisIt_CurveData_setCoordsXY(h, hxc, hyc);
}
}
return h;
}
visit_handle
SimGetVariable(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
simulation_data *sim = (simulation_data *)cbdata;
if(strcmp(name, "zonal") == 0)
{
int nTuples = sim->npts-1;
VisIt_VariableData_alloc(&h);
VisIt_VariableData_setDataF(h, VISIT_OWNER_SIM, 1,
nTuples, sim->zonal);
}
else if(strcmp(name, "nodal") == 0)
{
int nTuples = sim->npts;
VisIt_VariableData_alloc(&h);
VisIt_VariableData_setDataF(h, VISIT_OWNER_SIM, 1,
nTuples, sim->nodal);
}
return h;
}
visit_handle
SimGetMesh(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
simulation_data *sim = (simulation_data *)cbdata;
if(strcmp(name, "mesh") == 0)
{
/* Find the right domain. */
int i;
Domain *d = NULL;
for(i = 0; i < sim->nDomains; ++i)
{
if(sim->domains[i].globalIndex == domain)
{
d = &sim->domains[i];
break;
}
}
if(d != NULL && VisIt_RectilinearMesh_alloc(&h) != VISIT_ERROR)
{
visit_handle hx, hy, hz;
VisIt_VariableData_alloc(&hx);
VisIt_VariableData_alloc(&hy);
VisIt_VariableData_alloc(&hz);
VisIt_VariableData_setDataF(hx, VISIT_OWNER_SIM, 1, d->dims[0], d->x);
VisIt_VariableData_setDataF(hy, VISIT_OWNER_SIM, 1, d->dims[1], d->y);
VisIt_VariableData_setDataF(hz, VISIT_OWNER_SIM, 1, d->dims[2], d->z);
VisIt_RectilinearMesh_setCoordsXYZ(h, hx, hy, hz);
}
}
return h;
}
visit_handle
SimGetMesh(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
if(strcmp(name, "mesh2d") == 0)
{
if(VisIt_RectilinearMesh_alloc(&h) != VISIT_ERROR)
{
visit_handle hxc, hyc;
VisIt_VariableData_alloc(&hxc);
VisIt_VariableData_alloc(&hyc);
VisIt_VariableData_setDataF(hxc, VISIT_OWNER_SIM, 1, rmesh_dims[0], rmesh_x);
VisIt_VariableData_setDataF(hyc, VISIT_OWNER_SIM, 1, rmesh_dims[1], rmesh_y);
VisIt_RectilinearMesh_setCoordsXY(h, hxc, hyc);
}
}
else if(strcmp(name, "mesh3d") == 0)
{
if(VisIt_CurvilinearMesh_alloc(&h) != VISIT_ERROR)
{
int nn;
visit_handle hxc, hyc, hzc;
nn = cmesh_dims[0] * cmesh_dims[1] * cmesh_dims[2];
VisIt_VariableData_alloc(&hxc);
VisIt_VariableData_alloc(&hyc);
VisIt_VariableData_alloc(&hzc);
VisIt_VariableData_setDataF(hxc, VISIT_OWNER_SIM, 1, nn, (float*)cmesh_x);
VisIt_VariableData_setDataF(hyc, VISIT_OWNER_SIM, 1, nn, (float*)cmesh_y);
VisIt_VariableData_setDataF(hzc, VISIT_OWNER_SIM, 1, nn, (float*)cmesh_z);
VisIt_CurvilinearMesh_setCoordsXYZ(h, cmesh_dims, hxc, hyc, hzc);
}
}
return h;
}
visit_handle
SimGetVariable(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
if(strcmp(name, "scalar") == 0)
{
if(VisIt_VariableData_alloc(&h) == VISIT_OKAY)
{
VisIt_VariableData_setDataF(h, VISIT_OWNER_SIM, 1,
(NX-1) * (NY-1), &zonal_scalar[0][0]);
}
}
return h;
}
visit_handle
SimGetMixedVariable(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
if(strcmp(name, "scalar") == 0)
{
if(VisIt_VariableData_alloc(&h) == VISIT_OKAY)
{
int nTuples = sizeof(mixvar) / sizeof(float);
VisIt_VariableData_setDataF(h, VISIT_OWNER_SIM, 1,
nTuples, mixvar);
}
}
return h;
}
/*
visit_handle
SimGetVariableWorking(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
// simulation_data *sim = (simulation_data *)cbdata;
// fprintf(stderr,"proc %d: SimGetVariable\n",rank);
if(strcmp(name, "u") == 0)
{
float *zoneptr;
float *rmesh_zonal;
int i, j, k, nTuples;
// Calculate a zonal variable that moves around.
rmesh_zonal = (float*)malloc(sizeof(float) * (rmesh_dims[0]-1) * (rmesh_dims[1]-1)*(rmesh_dims[2]-1));
zoneptr = rmesh_zonal;
for(k=zmin;k<zmax;k++)
{
for(j = 0; j < rmesh_dims[1]-1; ++j)
{
for(i = 0; i < rmesh_dims[0]-1; ++i)
{
*zoneptr++ = fields[0][k][j][i];
}
}
}
nTuples = (rmesh_dims[0]-1) * (rmesh_dims[1]-1)*(rmesh_dims[2]-1);
VisIt_VariableData_alloc(&h);
VisIt_VariableData_setDataF(h, VISIT_OWNER_VISIT, 1,
nTuples, rmesh_zonal);
}
return h;
}
*/
visit_handle
SimGetVariable(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
// simulation_data *sim = (simulation_data *)cbdata;
// fprintf(stderr,"proc %d: SimGetVariable\n",rank);
if(strcmp(name, "u") == 0)
{
float *zoneptr;
float *rmesh_zonal;
int i, j, k, nTuples;
nTuples = (rmesh_dims[0]) * (rmesh_dims[1])*(rmesh_dims[2]);
// Calculate a zonal variable that moves around.
rmesh_zonal = (float*)malloc(sizeof(float)*nTuples);
zoneptr = rmesh_zonal;
// A RETRAVAILLER
if((size==2)&&rank==0)
{
// for(k=zmin;k<=zmax;k++)
for(k=zmax+NG;k>=zmin;--k)
{
for(j = 0; j < rmesh_dims[1]; ++j)
{
for(i = 0; i < rmesh_dims[0]; ++i)
{
*zoneptr++ = fields[0][k][j][i];
}
}
}
}
else
{
VisIt_VariableData_alloc(&h);
VisIt_VariableData_setDataD(h,VISIT_OWNER_SIM,1,nTuples, &fields[0][zmin][ymin][xmin]);
}
}
return h;
}
visit_handle
SimGetDomainList(const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
if(VisIt_DomainList_alloc(&h) != VISIT_ERROR)
{
visit_handle hdl;
int *iptr = NULL;
simulation_data *sim = (simulation_data *)cbdata;
iptr = (int *)malloc(sizeof(int));
*iptr = sim->par_rank;
VisIt_VariableData_alloc(&hdl);
VisIt_VariableData_setDataI(hdl, VISIT_OWNER_VISIT, 1, 1, iptr);
VisIt_DomainList_setDomains(h, sim->par_size, hdl);
}
return h;
}
visit_handle
SimGetDomainList(const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
if(VisIt_DomainList_alloc(&h) != VISIT_ERROR)
{
visit_handle hdl;
int i, *iptr = NULL;
simulation_data *sim = (simulation_data *)cbdata;
iptr = (int *)malloc(sizeof(int) * sim->nDomains);
for(i = 0; i < sim->nDomains; ++i)
iptr[i] = sim->domains[i].globalIndex;
VisIt_VariableData_alloc(&hdl);
VisIt_VariableData_setDataI(hdl, VISIT_OWNER_VISIT, 1, sim->nDomains, iptr);
VisIt_DomainList_setDomains(h, sim->nTotalDomains, hdl);
}
return h;
}
visit_handle
SimGetMesh(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
if(strcmp(name, "mesh2d") == 0)
{
if(VisIt_CurvilinearMesh_alloc(&h) != VISIT_ERROR)
{
int nTuples;
visit_handle hxy;
nTuples = mesh_dims[domain][0] * mesh_dims[domain][1];
VisIt_VariableData_alloc(&hxy);
VisIt_VariableData_setDataF(hxy, VISIT_OWNER_SIM, 2, nTuples,
mesh_coords[domain]);
VisIt_CurvilinearMesh_setCoords2(h, mesh_dims[domain], hxy);
}
}
return h;
}
visit_handle
SimGetDomainList(const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
if(VisIt_DomainList_alloc(&h) != VISIT_ERROR)
{
visit_handle hdl;
int *iptr = NULL, i, nTuples = 0;
simulation_data *sim = (simulation_data *)cbdata;
iptr = (int *)malloc(sizeof(int) * NDOMAINS);
for(i = 0; i < NDOMAINS; ++i)
{
if(i % sim->par_size == sim->par_rank)
iptr[nTuples++] = i;
}
VisIt_VariableData_alloc(&hdl);
VisIt_VariableData_setDataI(hdl, VISIT_OWNER_VISIT, 1, nTuples, iptr);
VisIt_DomainList_setDomains(h, NDOMAINS, hdl);
}
return h;
}
visit_handle
SimGetVariable(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
int nComponents = 1, nTuples = 0;
if(VisIt_VariableData_alloc(&h) == VISIT_OKAY)
{
if(strcmp(name, "zonal") == 0)
{
nTuples = (rmesh_dims[0]-1) * (rmesh_dims[1]-1);
VisIt_VariableData_setDataF(h, VISIT_OWNER_SIM, nComponents,
nTuples, zonal);
}
else if(strcmp(name, "nodal") == 0)
{
nTuples = cmesh_dims[0] * cmesh_dims[1] *
cmesh_dims[2];
VisIt_VariableData_setDataD(h, VISIT_OWNER_SIM, nComponents,
nTuples, (double*)nodal);
}
}
return h;
}
visit_handle
SimGetVariable(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
simulation_data *sim = (simulation_data *)cbdata;
if(strcmp(name, "domainID") == 0)
{
double *domainID = NULL;
int i, nTuples;
/* Fill in the domain id. */
nTuples = (mesh_dims[domain][0]-1)*(mesh_dims[domain][1]-1);
domainID = (double*)malloc(sizeof(double) * nTuples);
for(i = 0; i < nTuples; ++i)
domainID[i] = (double)domain;
VisIt_VariableData_alloc(&h);
VisIt_VariableData_setDataD(h, VISIT_OWNER_VISIT, 1,
nTuples, domainID);
}
return h;
}
visit_handle Simulation:: get_variable( int domain, const string &name ) const
{
visit_handle h = VISIT_INVALID_HANDLE;
if( name == "P" )
{
const int nComponents= 1;
const int nTuples = P.items;
//MPI.Printf0( stderr, "Sending P: %dx%d\n", nComponents, nTuples);
assert(P.entry!=NULL);
if(VisIt_VariableData_alloc(&h) == VISIT_OKAY)
{
VisIt_VariableData_setDataD(h, VISIT_OWNER_SIM, nComponents, nTuples, P.entry);
}
return h;
}
if( name == "B" )
{
const int nComponents= 1;
const int nTuples = B.items;
//MPI.Printf0( stderr, "Sending B: %dx%d\n", nComponents, nTuples);
assert(B.entry!=NULL);
if(VisIt_VariableData_alloc(&h) == VISIT_OKAY)
{
VisIt_VariableData_setDataD(h, VISIT_OWNER_SIM, nComponents, nTuples, B.entry);
}
return h;
}
if( name == "Bulk" )
{
const int nComponents= 1;
const int nTuples = B.items;
//MPI.Printf0( stderr, "Sending B: %dx%d\n", nComponents, nTuples);
assert(Bulk.entry!=NULL);
if(VisIt_VariableData_alloc(&h) == VISIT_OKAY)
{
VisIt_VariableData_setDataD(h, VISIT_OWNER_SIM, nComponents, nTuples, Bulk.entry);
}
return h;
}
if( name == "U" )
{
const int nComponents= 2;
const int nTuples = U.items;
//MPI.Printf0( stderr, "Sending U: %dx%d\n", nComponents, nTuples);
assert(U.entry!=NULL);
if(VisIt_VariableData_alloc(&h) == VISIT_OKAY)
{
VisIt_VariableData_setDataD(h, VISIT_OWNER_SIM, nComponents, nTuples, (Real*)(U.entry));
}
return h;
}
if( name == "gradP" )
{
const int nComponents= 2;
const int nTuples = gradP.items;
//MPI.Printf0( stderr, "Sending U: %dx%d\n", nComponents, nTuples);
assert(gradP.entry!=NULL);
if(VisIt_VariableData_alloc(&h) == VISIT_OKAY)
{
VisIt_VariableData_setDataD(h, VISIT_OWNER_SIM, nComponents, nTuples, (Real*)(gradP.entry));
}
return h;
}
if( name == "Penter" )
{
const int nComponents= 2;
const int nTuples = U.items;
assert(Penter.entry!=NULL);
if(VisIt_VariableData_alloc(&h) == VISIT_OKAY)
{
VisIt_VariableData_setDataD(h, VISIT_OWNER_SIM, nComponents, nTuples, (Real*)(Penter.entry));
}
return h;
}
if( name == "Pleave" )
{
const int nComponents= 2;
const int nTuples = U.items;
assert(Pleave.entry!=NULL);
if(VisIt_VariableData_alloc(&h) == VISIT_OKAY)
{
VisIt_VariableData_setDataD(h, VISIT_OWNER_SIM, nComponents, nTuples, (Real*)(Pleave.entry));
}
return h;
}
return h;
}
visit_handle
SimGetVariable(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
int nComponents = 1, nTuples = 0;
if(VisIt_VariableData_alloc(&h) == VISIT_OKAY)
{
if(strcmp(name, "zonal_scalar") == 0)
{
nTuples = (rmesh_dims[0]-1) * (rmesh_dims[1]-1);
VisIt_VariableData_setDataF(h, VISIT_OWNER_SIM, nComponents,
nTuples, zonal);
}
else if(strcmp(name, "nodal_scalar") == 0 ||
strcmp(name, "hidden") == 0)
{
nTuples = cmesh_dims[0] * cmesh_dims[1] *
cmesh_dims[2];
VisIt_VariableData_setDataD(h, VISIT_OWNER_SIM, nComponents,
nTuples, (double*)nodal);
}
else if(strcmp(name, "zonal_vector") == 0)
{
nComponents = 2;
nTuples = (rmesh_dims[0]-1) * (rmesh_dims[1]-1);
VisIt_VariableData_setDataF(h, VISIT_OWNER_SIM, nComponents,
nTuples, (float *)zonal_vector);
}
else if(strcmp(name, "nodal_vector") == 0)
{
nComponents = 3;
nTuples = cmesh_dims[0] * cmesh_dims[1] *
cmesh_dims[2];
VisIt_VariableData_setDataD(h, VISIT_OWNER_SIM, nComponents,
nTuples, (double *)nodal_vector);
}
else if(strcmp(name, "zonal_label") == 0)
{
nComponents = 7;
nTuples = (rmesh_dims[0]-1) * (rmesh_dims[1]-1);
VisIt_VariableData_setDataC(h, VISIT_OWNER_SIM, nComponents,
nTuples, (char *)zonal_labels);
}
else if(strcmp(name, "zonal_array") == 0)
{
nComponents = 4;
nTuples = (rmesh_dims[0]-1) * (rmesh_dims[1]-1);
VisIt_VariableData_setDataF(h, VISIT_OWNER_SIM, nComponents,
nTuples, (float *)zonal_array);
}
else if(strcmp(name, "nodal_array") == 0)
{
nComponents = 4;
nTuples = cmesh_dims[0] * cmesh_dims[1] *
cmesh_dims[2];
VisIt_VariableData_setDataD(h, VISIT_OWNER_SIM, nComponents,
nTuples, (double *)nodal_array);
}
else
{
VisIt_VariableData_free(h);
h = VISIT_INVALID_HANDLE;
}
}
return h;
}
visit_handle
SimGetMesh(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
visit_handle c = VISIT_INVALID_HANDLE;
int owner = VISIT_OWNER_SIM;
int dt = VISIT_DATATYPE_FLOAT;
if(strstr(name, "double") != NULL)
dt = VISIT_DATATYPE_DOUBLE;
if(strstr(name, "dynamic") != NULL)
owner = VISIT_OWNER_VISIT;
if(strstr(name, "curv") != NULL)
{
if(VisIt_CurvilinearMesh_alloc(&h) == VISIT_OKAY &&
VisIt_VariableData_alloc(&c) == VISIT_OKAY)
{
if(strstr(name, "curv2d") != NULL)
{
int dims[2];
dims[0] = NX;
dims[1] = NY;
SetData(c, owner, dt, 2, NX*NY, (float*)coords2d);
VisIt_CurvilinearMesh_setCoords2(h, dims, c);
}
else
{
int dims[3];
dims[0] = NX;
dims[1] = NY;
dims[2] = NZ;
SetData(c, owner, dt, 3, NX*NY*NZ, (float*)coords3d);
VisIt_CurvilinearMesh_setCoords3(h, dims, c);
}
}
}
else if(strstr(name, "point") != NULL)
{
if(VisIt_PointMesh_alloc(&h) == VISIT_OKAY &&
VisIt_VariableData_alloc(&c) == VISIT_OKAY)
{
if(strstr(name, "point2d") != NULL)
SetData(c, owner, dt, 2, NX*NY, (float*)coords2d);
else
SetData(c, owner, dt, 3, NX*NY*NZ, (float*)coords3d);
VisIt_PointMesh_setCoords(h, c);
}
}
else if(strstr(name, "ucd") != NULL)
{
visit_handle hc;
if(VisIt_UnstructuredMesh_alloc(&h) == VISIT_OKAY &&
VisIt_VariableData_alloc(&c) == VISIT_OKAY &&
VisIt_VariableData_alloc(&hc) == VISIT_OKAY)
{
int nzones = 0;
if(strstr(name, "ucd2d") != NULL)
{
int i, j, lconnectivity;
int *connectivity = NULL, *conn = NULL;
nzones = (NX-1)*(NY-1);
lconnectivity = 5*nzones;
conn = connectivity = (int*)malloc(lconnectivity * sizeof(int));
for(j = 0; j < NY-1; ++j)
for(i = 0; i < NX-1; ++i)
{
*conn++ = VISIT_CELL_QUAD;
*conn++ = j*NX + i;
*conn++ = j*NX + (i+1);
*conn++ = (j+1)*NX + (i+1);
*conn++ = (j+1)*NX + i;
}
SetData(c, owner, dt, 2, NX*NY, (float*)coords2d);
VisIt_VariableData_setDataI(hc, VISIT_OWNER_VISIT, 1, lconnectivity,
connectivity);
}
else
{
int i, j, k, lconnectivity;
int *connectivity = NULL, *conn = NULL;
nzones = (NX-1)*(NY-1)*(NZ-1);
lconnectivity = 9*nzones;
conn = connectivity = (int*)malloc(lconnectivity * sizeof(int));
for(k = 0; k < NZ-1; ++k)
for(j = 0; j < NY-1; ++j)
for(i = 0; i < NX-1; ++i)
{
*conn++ = VISIT_CELL_HEX;
*conn++ = k*NX*NY + j*NX + i;
*conn++ = k*NX*NY + j*NX + (i+1);
*conn++ = k*NX*NY + (j+1)*NX + (i+1);
*conn++ = k*NX*NY + (j+1)*NX + i;
*conn++ = (k+1)*NX*NY + j*NX + i;
*conn++ = (k+1)*NX*NY + j*NX + (i+1);
*conn++ = (k+1)*NX*NY + (j+1)*NX + (i+1);
*conn++ = (k+1)*NX*NY + (j+1)*NX + i;
}
SetData(c, owner, dt, 3, NX*NY*NZ, (float*)coords3d);
VisIt_VariableData_setDataI(hc, VISIT_OWNER_VISIT, 1, lconnectivity,
connectivity);
}
VisIt_UnstructuredMesh_setCoords(h, c);
VisIt_UnstructuredMesh_setConnectivity(h, nzones, hc);
}
}
return h;
}
visit_handle
SimGetMesh(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
simulation_data *sim = (simulation_data *)cbdata;
if(strcmp(name, "rect_blank") == 0)
{
if(VisIt_RectilinearMesh_alloc(&h) != VISIT_ERROR)
{
int ncells;
visit_handle hx, hy, gc;
VisIt_VariableData_alloc(&hx);
VisIt_VariableData_alloc(&hy);
VisIt_VariableData_setDataF(hx, VISIT_OWNER_SIM, 1, sim->blankRectMesh.dims[0], sim->blankRectMesh.x);
VisIt_VariableData_setDataF(hy, VISIT_OWNER_SIM, 1, sim->blankRectMesh.dims[1], sim->blankRectMesh.y);
VisIt_RectilinearMesh_setCoordsXY(h, hx, hy);
/* Attach ghost cells to blank out certain cells*/
VisIt_VariableData_alloc(&gc);
ncells = (sim->blankRectMesh.dims[0]-1) * (sim->blankRectMesh.dims[1]-1);
VisIt_VariableData_setDataI(gc, VISIT_OWNER_SIM, 1, ncells, sim->blankRectMesh.ghostCells);
VisIt_RectilinearMesh_setGhostCells(h, gc);
}
}
else if(strcmp(name, "curv_blank") == 0)
{
if(VisIt_CurvilinearMesh_alloc(&h) != VISIT_ERROR)
{
int ncells, nnodes;
visit_handle hx, hy, gc;
nnodes = sim->blankCurvMesh.dims[0] * sim->blankCurvMesh.dims[1];
ncells = (sim->blankCurvMesh.dims[0]-1) * (sim->blankCurvMesh.dims[1]-1);
VisIt_VariableData_alloc(&hx);
VisIt_VariableData_alloc(&hy);
VisIt_VariableData_setDataF(hx, VISIT_OWNER_SIM, 1, nnodes, sim->blankCurvMesh.x);
VisIt_VariableData_setDataF(hy, VISIT_OWNER_SIM, 1, nnodes, sim->blankCurvMesh.y);
VisIt_CurvilinearMesh_setCoordsXY(h, sim->blankCurvMesh.dims, hx, hy);
/* Attach ghost cells to blank out certain cells*/
VisIt_VariableData_alloc(&gc);
VisIt_VariableData_setDataI(gc, VISIT_OWNER_SIM, 1, ncells, sim->blankCurvMesh.ghostCells);
VisIt_CurvilinearMesh_setGhostCells(h, gc);
}
}
else if(strcmp(name, "ucd_blank") == 0)
{
if(VisIt_UnstructuredMesh_alloc(&h) != VISIT_ERROR)
{
visit_handle hxyz, hc, gc;
VisIt_VariableData_alloc(&hxyz);
VisIt_VariableData_setDataF(hxyz, VISIT_OWNER_SIM, 3, sim->blankUcdMesh.nnodes, sim->blankUcdMesh.xyz);
VisIt_UnstructuredMesh_setCoords(h, hxyz);
VisIt_VariableData_alloc(&hc);
VisIt_VariableData_setDataI(hc, VISIT_OWNER_SIM, 1, sim->blankUcdMesh.connectivityLen,
sim->blankUcdMesh.connectivity);
VisIt_UnstructuredMesh_setConnectivity(h, sim->blankUcdMesh.ncells, hc);
/* Attach ghost cells to blank out certain cells*/
VisIt_VariableData_alloc(&gc);
VisIt_VariableData_setDataI(gc, VISIT_OWNER_SIM, 1, sim->blankUcdMesh.ncells, sim->blankUcdMesh.ghostCells);
VisIt_UnstructuredMesh_setGhostCells(h, gc);
}
}
else if(strncmp(name, "multi_domain", 12) == 0)
{
if(VisIt_RectilinearMesh_alloc(&h) != VISIT_ERROR)
{
int ncells;
visit_handle hx, hy, gc;
VisIt_VariableData_alloc(&hx);
VisIt_VariableData_alloc(&hy);
VisIt_VariableData_setDataF(hx, VISIT_OWNER_SIM, 1, sim->multidomain[domain].m.dims[0], sim->multidomain[domain].m.x);
VisIt_VariableData_setDataF(hy, VISIT_OWNER_SIM, 1, sim->multidomain[domain].m.dims[1], sim->multidomain[domain].m.y);
VisIt_RectilinearMesh_setCoordsXY(h, hx, hy);
if(strcmp(name, "multi_domain") == 0)
{
/* Do ghost cells using a ghost cells array. */
VisIt_VariableData_alloc(&gc);
ncells = (sim->multidomain[domain].m.dims[0]-1) * (sim->multidomain[domain].m.dims[1]-1);
VisIt_VariableData_setDataI(gc, VISIT_OWNER_SIM, 1, ncells, sim->multidomain[domain].m.ghostCells);
VisIt_RectilinearMesh_setGhostCells(h, gc);
}
else
{
/* Do ghost cells using indices. Note: other mesh types can also
* designate ghost cells using indices.
*/
VisIt_RectilinearMesh_setRealIndices(h, sim->multidomain[domain].minReal,
sim->multidomain[domain].maxReal);
}
}
}
else if(strcmp(name, "multi_types") == 0)
{
if(domain < 4 && VisIt_RectilinearMesh_alloc(&h) != VISIT_ERROR)
{
int ncells;
visit_handle hx, hy, hz, gc;
VisIt_VariableData_alloc(&hx);
VisIt_VariableData_alloc(&hy);
VisIt_VariableData_alloc(&hz);
VisIt_VariableData_setDataF(hx, VISIT_OWNER_SIM, 1, sim->multipletypes[domain].dims[0], sim->multipletypes[domain].x);
VisIt_VariableData_setDataF(hy, VISIT_OWNER_SIM, 1, sim->multipletypes[domain].dims[1], sim->multipletypes[domain].y);
VisIt_VariableData_setDataF(hz, VISIT_OWNER_SIM, 1, sim->multipletypes[domain].dims[2], sim->multipletypes[domain].z);
VisIt_RectilinearMesh_setCoordsXYZ(h, hx, hy, hz);
/* Do ghost cells using a ghost cells array. */
VisIt_VariableData_alloc(&gc);
ncells = (sim->multipletypes[domain].dims[0]-1) *
(sim->multipletypes[domain].dims[1]-1) *
(sim->multipletypes[domain].dims[2]-1);
VisIt_VariableData_setDataI(gc, VISIT_OWNER_SIM, 1, ncells, sim->multipletypes[domain].ghostCells);
VisIt_RectilinearMesh_setGhostCells(h, gc);
}
}
return h;
}
visit_handle
SimGetMesh(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
simulation_data *sim = (simulation_data *)cbdata;
if(VisIt_CurvilinearMesh_alloc(&h) != VISIT_ERROR)
{
visit_handle hx, hy, hz, hxyz;
if(strcmp(name, "soa_s") == 0)
{
/* Set coordinates using a single variable data made from SOA data. */
serror(VisIt_VariableData_alloc(&hxyz));
serror(VisIt_VariableData_setArrayDataD(hxyz, 0, VISIT_OWNER_SIM, sim->soa.nnodes, 0, sizeof(double), sim->soa.x));
serror(VisIt_VariableData_setArrayDataD(hxyz, 1, VISIT_OWNER_SIM, sim->soa.nnodes, 0, sizeof(double), sim->soa.y));
serror(VisIt_VariableData_setArrayDataD(hxyz, 2, VISIT_OWNER_SIM, sim->soa.nnodes, 0, sizeof(double), sim->soa.z));
serror(VisIt_CurvilinearMesh_setCoords3(h, sim->dims, hxyz));
}
else if(strcmp(name, "soa_m") == 0)
{
/* Set coordinates using 3 variable datas made from SOA data. */
serror(VisIt_VariableData_alloc(&hx));
serror(VisIt_VariableData_alloc(&hy));
serror(VisIt_VariableData_alloc(&hz));
serror(VisIt_VariableData_setDataD(hx, VISIT_OWNER_SIM, 1, sim->soa.nnodes, sim->soa.x));
serror(VisIt_VariableData_setDataD(hy, VISIT_OWNER_SIM, 1, sim->soa.nnodes, sim->soa.y));
serror(VisIt_VariableData_setDataD(hz, VISIT_OWNER_SIM, 1, sim->soa.nnodes, sim->soa.z));
serror(VisIt_CurvilinearMesh_setCoordsXYZ(h, sim->dims, hx, hy, hz));
}
else if(strcmp(name, "soa_i") == 0)
{
/* Set coordinates using a single variable data made from SOA interleaved data. */
serror(VisIt_VariableData_alloc(&hxyz));
serror(VisIt_VariableData_setDataD(hxyz, VISIT_OWNER_SIM, 3, sim->soa.nnodes, sim->soa.xyz));
serror(VisIt_CurvilinearMesh_setCoords3(h, sim->dims, hxyz));
}
else if(strcmp(name, "aos_s") == 0)
{
/* Set coordinates using a single variable data made from AOS data. */
serror(VisIt_VariableData_alloc(&hxyz));
serror(VisIt_VariableData_setArrayDataD(hxyz, 0, VISIT_OWNER_SIM, sim->aos.nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].x)));
serror(VisIt_VariableData_setArrayDataD(hxyz, 1, VISIT_OWNER_SIM, sim->aos.nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].y)));
serror(VisIt_VariableData_setArrayDataD(hxyz, 2, VISIT_OWNER_SIM, sim->aos.nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].z)));
serror(VisIt_CurvilinearMesh_setCoords3(h, sim->dims, hxyz));
}
else if(strcmp(name, "aos_m") == 0)
{
/* Set coordinates using 3 variable datas made from AOS data. */
serror(VisIt_VariableData_alloc(&hx));
serror(VisIt_VariableData_alloc(&hy));
serror(VisIt_VariableData_alloc(&hz));
serror(VisIt_VariableData_setArrayDataD(hx, 0, VISIT_OWNER_SIM, sim->aos.nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].x)));
serror(VisIt_VariableData_setArrayDataD(hy, 0, VISIT_OWNER_SIM, sim->aos.nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].y)));
serror(VisIt_VariableData_setArrayDataD(hz, 0, VISIT_OWNER_SIM, sim->aos.nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].z)));
serror(VisIt_CurvilinearMesh_setCoordsXYZ(h, sim->dims, hx, hy, hz));
}
else if(strcmp(name, "aos_c") == 0)
{
/* Set coordinates using 3 variable datas made from AOS data. Let's COPY data */
serror(VisIt_VariableData_alloc(&hx));
serror(VisIt_VariableData_alloc(&hy));
serror(VisIt_VariableData_alloc(&hz));
serror(VisIt_VariableData_setArrayDataD(hx, 0, VISIT_OWNER_COPY, sim->aos.nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].x)));
serror(VisIt_VariableData_setArrayDataD(hy, 0, VISIT_OWNER_COPY, sim->aos.nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].y)));
serror(VisIt_VariableData_setArrayDataD(hz, 0, VISIT_OWNER_COPY, sim->aos.nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].z)));
serror(VisIt_CurvilinearMesh_setCoordsXYZ(h, sim->dims, hx, hy, hz));
}
}
return h;
}
visit_handle
SimGetMaterial(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
/* Allocate a VisIt_MaterialData */
VisIt_MaterialData_alloc(&h);
if(strcmp(name, "Material") == 0)
{
int i, j, m, cell = 0, arrlen = 0;
int nmats, cellmat[10], matnos[3]={1,2,3};
float cellmatvf[10];
/* The matlist table indicates the material numbers that are found in
* each cell. Every 3 numbers indicates the material numbers in a cell.
* A material number of 0 means that the material entry is not used.
*/
int matlist[NY-1][NX-1][3] = {
{{3,0,0},{2,3,0},{1,2,0},{1,0,0}},
{{3,0,0},{2,3,0},{1,2,0},{1,0,0}},
{{3,0,0},{2,3,0},{1,2,3},{1,2,0}}
};
/* The mat_vf table indicates the material volume fractions that are
* found in a cell.
*/
float mat_vf[NY-1][NX-1][3] = {
{{1.,0.,0.},{0.75,0.25,0.}, {0.8125,0.1875, 0.},{1.,0.,0.}},
{{1.,0.,0.},{0.625,0.375,0.},{0.5625,0.4375,0.}, {1.,0.,0.}},
{{1.,0.,0.},{0.3,0.7,0.}, {0.2,0.4,0.4}, {0.55,0.45,0.}}
};
/* Tell the object we'll be adding cells to it using add*Cell functions */
VisIt_MaterialData_appendCells(h, (NX-1)*(NY-1));
/* Fill in the VisIt_MaterialData */
VisIt_MaterialData_addMaterial(h, matNames[0], &matnos[0]);
VisIt_MaterialData_addMaterial(h, matNames[1], &matnos[1]);
VisIt_MaterialData_addMaterial(h, matNames[2], &matnos[2]);
for(j = 0; j < NY-1; ++j)
{
for(i = 0; i < NX-1; ++i, ++cell)
{
nmats = 0;
for(m = 0; m < 3; ++m)
{
if(matlist[j][i][m] > 0)
{
cellmat[nmats] = matnos[matlist[j][i][m] - 1];
cellmatvf[nmats] = mat_vf[j][i][m];
nmats++;
}
}
if(nmats > 1)
VisIt_MaterialData_addMixedCell(h, cell, cellmat, cellmatvf, nmats);
else
VisIt_MaterialData_addCleanCell(h, cell, cellmat[0]);
}
}
}
else if(strcmp(name, "MaterialFromArrays") == 0)
{
int nTuples, matnos[] = {11,22,33};
visit_handle hmatlist, hmix_zone, hmix_mat, hmix_vf, hmix_next;
/* Fill in the VisIt_MaterialData using arrays encode the material. */
VisIt_MaterialData_addMaterial(h, matNames[0], &matnos[0]);
VisIt_MaterialData_addMaterial(h, matNames[1], &matnos[1]);
VisIt_MaterialData_addMaterial(h, matNames[2], &matnos[2]);
VisIt_VariableData_alloc(&hmatlist);
VisIt_VariableData_setDataI(hmatlist, VISIT_OWNER_SIM, 1, (NX-1)*(NY-1), matlist);
VisIt_MaterialData_setMaterials(h, hmatlist);
nTuples = sizeof(mix_zone) / sizeof(int);
VisIt_VariableData_alloc(&hmix_zone);
VisIt_VariableData_setDataI(hmix_zone, VISIT_OWNER_SIM, 1, nTuples, mix_zone);
VisIt_VariableData_alloc(&hmix_mat);
VisIt_VariableData_setDataI(hmix_mat, VISIT_OWNER_SIM, 1, nTuples, mix_mat);
VisIt_VariableData_alloc(&hmix_vf);
VisIt_VariableData_setDataD(hmix_vf, VISIT_OWNER_SIM, 1, nTuples, mix_vf);
VisIt_VariableData_alloc(&hmix_next);
VisIt_VariableData_setDataI(hmix_next, VISIT_OWNER_SIM, 1, nTuples, mix_next);
VisIt_MaterialData_setMixedMaterials(h, hmix_mat, hmix_zone, hmix_next, hmix_vf);
}
return h;
}
visit_handle
SimGetVariable(int domain, const char *name, void *cbdata)
{
visit_handle h = VISIT_INVALID_HANDLE;
simulation_data *sim = (simulation_data *)cbdata;
if(strncmp(name, "aos", 3) == 0)
{
int nnodes, owner;
owner = (strcmp(name, "aos_c") == 0) ? VISIT_OWNER_COPY : VISIT_OWNER_SIM;
nnodes = sim->aos.nnodes;
/* Use setDataArray functions to set up strided array access. */
VisIt_VariableData_alloc(&h);
if(strcmp(name+6, "temperature") == 0)
serror(VisIt_VariableData_setArrayDataF(h, 0, owner, nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].temperature)));
else if(strcmp(name+6, "vx") == 0)
serror(VisIt_VariableData_setArrayDataD(h, 0, owner, nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].vx)));
else if(strcmp(name+6, "vy") == 0)
serror(VisIt_VariableData_setArrayDataD(h, 0, owner, nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].vy)));
else if(strcmp(name+6, "vz") == 0)
serror(VisIt_VariableData_setArrayDataD(h, 0, owner, nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].vz)));
else if(strcmp(name+6, "I") == 0)
serror(VisIt_VariableData_setArrayDataI(h, 0, owner, nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].I)));
else if(strcmp(name+6, "J") == 0)
serror(VisIt_VariableData_setArrayDataI(h, 0, owner, nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].J)));
else if(strcmp(name+6, "K") == 0)
serror(VisIt_VariableData_setArrayDataI(h, 0, owner, nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].K)));
else if(strcmp(name+6, "velocity") == 0)
{
/* Combine separate strided array access into a vector. */
serror(VisIt_VariableData_setArrayDataD(h, 0, owner, nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].vx)));
serror(VisIt_VariableData_setArrayDataD(h, 1, owner, nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].vy)));
serror(VisIt_VariableData_setArrayDataD(h, 2, owner, nnodes, 0, sizeof(Node), &(sim->aos.nodes[0].vz)));
}
}
else if(strncmp(name, "soa", 3) == 0)
{
int nnodes = sim->soa.nnodes;
/* Use setData functions to set up contiguous array access. */
VisIt_VariableData_alloc(&h);
if(strcmp(name+6, "temperature") == 0)
serror(VisIt_VariableData_setDataF(h, VISIT_OWNER_SIM, 1, nnodes, sim->soa.temperature));
else if(strcmp(name+6, "vx") == 0)
serror(VisIt_VariableData_setDataD(h, VISIT_OWNER_SIM, 1, nnodes, sim->soa.vx));
else if(strcmp(name+6, "vy") == 0)
serror(VisIt_VariableData_setDataD(h, VISIT_OWNER_SIM, 1, nnodes, sim->soa.vy));
else if(strcmp(name+6, "vz") == 0)
serror(VisIt_VariableData_setDataD(h, VISIT_OWNER_SIM, 1, nnodes, sim->soa.vz));
else if(strcmp(name+6, "I") == 0)
serror(VisIt_VariableData_setDataI(h, VISIT_OWNER_SIM, 1, nnodes, sim->soa.I));
else if(strcmp(name+6, "J") == 0)
serror(VisIt_VariableData_setDataI(h, VISIT_OWNER_SIM, 1, nnodes, sim->soa.J));
else if(strcmp(name+6, "K") == 0)
serror(VisIt_VariableData_setDataI(h, VISIT_OWNER_SIM, 1, nnodes, sim->soa.K));
else if(strcmp(name+6, "velocity") == 0)
{
/* Combine separate contiguous arrays into a vector. */
serror(VisIt_VariableData_setArrayDataD(h, 0, VISIT_OWNER_SIM, nnodes, 0, sizeof(double), sim->soa.vx));
serror(VisIt_VariableData_setArrayDataD(h, 1, VISIT_OWNER_SIM, nnodes, 0, sizeof(double), sim->soa.vy));
serror(VisIt_VariableData_setArrayDataD(h, 2, VISIT_OWNER_SIM, nnodes, 0, sizeof(double), sim->soa.vz));
}
}
return h;
}
