weipa/src/VisItData.cpp


/*******************************************************
*
* Copyright (c) 2003-2010 by University of Queensland
* Earth Systems Science Computational Center (ESSCC)
* http://www.uq.edu.au/esscc
*
* Primary Business: Queensland, Australia
* Licensed under the Open Software License version 3.0
* http://www.opensource.org/licenses/osl-3.0.php
*
*******************************************************/

#include <weipa/VisItData.h>
#include <weipa/DataVar.h>
#include <weipa/ElementData.h>
#include <weipa/NodeData.h>

#include <VisItDataInterface_V2.h>

#include <boost/python/dict.hpp>
#include <boost/python/extract.hpp>

#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <sstream>

using std::map;
using std::set;
using std::string;
using std::vector;

namespace weipa {

//
// Returns simulation metadata from this dataset.
//
visit_handle VisItData::getSimMetaData()
{
    visit_handle mdh = VISIT_INVALID_HANDLE;
    VisIt_SimulationMetaData_alloc(&mdh);
    vector<string>::const_iterator it;
    for (it=cmdNames.begin(); it!=cmdNames.end(); it++) {
        visit_handle cmd = VISIT_INVALID_HANDLE;
        if (VisIt_CommandMetaData_alloc(&cmd) == VISIT_OKAY) {
            VisIt_CommandMetaData_setName(cmd, it->c_str());
            VisIt_SimulationMetaData_addGenericCommand(mdh, cmd);
        }
    }
    VisIt_SimulationMetaData_setMode(mdh, runFlag ?
        VISIT_SIMMODE_RUNNING : VISIT_SIMMODE_STOPPED);

    if (dataset.get() == NULL) {
        return mdh;
    }

    VisIt_SimulationMetaData_setCycleTime(
            mdh, dataset->getCycle(), dataset->getTime());

    set<string> usedMeshes;

    // add "special" mesh variable metadata
    const VarVector& meshVars = dataset->getMeshVariables();
    VarVector::const_iterator vIt;
    for (vIt = meshVars.begin(); vIt != meshVars.end(); vIt++) {
        // skip empty variable
        int numSamples = accumulate(vIt->sampleDistribution.begin(),
                vIt->sampleDistribution.end(), 0);
        if (numSamples > 0 && vIt->valid) {
            DataVar_ptr readerVar = vIt->dataChunks[0];
            string meshName = readerVar->getMeshName();
            usedMeshes.insert(meshName);
            int centering = readerVar->isNodeCentered() ?
                VISIT_VARCENTERING_NODE : VISIT_VARCENTERING_ZONE;
            string varPath = "mesh_vars/"+vIt->varName;
            variables[varPath] = readerVar;
            addVariableMetadata(mdh, varPath, meshName, centering, 0);
        }
    }

    // add other variables
    const VarVector& vars = dataset->getVariables();
    for (vIt = vars.begin(); vIt != vars.end(); vIt++) {
        // skip empty variable
        int numSamples = accumulate(vIt->sampleDistribution.begin(),
                vIt->sampleDistribution.end(), 0);
        if (numSamples == 0 || !vIt->valid) {
            continue;
        }

        const string& varName = vIt->varName;
        DataVar_ptr readerVar = vIt->dataChunks[0];
        string meshName = readerVar->getMeshName();
        usedMeshes.insert(meshName);
        int centering = readerVar->isNodeCentered() ?
            VISIT_VARCENTERING_NODE : VISIT_VARCENTERING_ZONE;
        int rank = readerVar->getRank();
        addVariableMetadata(mdh, varName, meshName, centering, rank);
        variables[varName] = readerVar;
    }

    // add all meshes
    int mpiSize=1;
#ifdef HAVE_MPI
    MPI_Comm comm = dataset->getMPIComm();
    MPI_Comm_size(comm, &mpiSize);
#endif
    set<string>::const_iterator sIt;
    int dim = dataset->getConvertedDomain()[0]->getNodes()->getNumDims();
    for (sIt = usedMeshes.begin(); sIt != usedMeshes.end(); sIt++) {
        addMeshMetadata(mdh, *sIt, dim, mpiSize);
    }

    return mdh;
}

///
/// Returns the domain list
///
visit_handle VisItData::getDomainList()
{
    // each MPI rank serves exactly one domain (chunk) of the data
    visit_handle domainList = VISIT_INVALID_HANDLE;
    if (VisIt_DomainList_alloc(&domainList) == VISIT_OKAY) {
        int mpiRank=0, mpiSize=1;
#ifdef HAVE_MPI
        MPI_Comm comm = dataset->getMPIComm();
        MPI_Comm_rank(comm, &mpiRank);
        MPI_Comm_size(comm, &mpiSize);
#endif
        visit_handle hdl;
        int* rank = (int*)malloc(sizeof(int));
        *rank = mpiRank;
        VisIt_VariableData_alloc(&hdl);
        VisIt_VariableData_setDataI(hdl, VISIT_OWNER_VISIT, 1, 1, rank);
        VisIt_DomainList_setDomains(domainList, mpiSize, hdl);
    }
    return domainList;
}

///
/// Returns mesh data for the specified mesh
///
visit_handle VisItData::getMesh(const char* name)
{
    visit_handle hmesh = VISIT_INVALID_HANDLE;
    DomainChunk_ptr dom = dataset->getConvertedDomain()[0];
    NodeData_ptr nodes = dom->getMeshByName(name);
    ElementData_ptr elements = dom->getElementsByName(name);

    if (nodes && elements
            && VisIt_UnstructuredMesh_alloc(&hmesh)) {

        // set node coordinates
        visit_handle hx, hy;
        VisIt_VariableData_alloc(&hx);
        VisIt_VariableData_alloc(&hy);
        VisIt_VariableData_setDataF(hx, VISIT_OWNER_SIM, 1,
                nodes->getNumNodes(), nodes->getCoords()[0]);
        VisIt_VariableData_setDataF(hy, VISIT_OWNER_SIM, 1,
                nodes->getNumNodes(), nodes->getCoords()[1]);

        if (nodes->getNumDims() > 2) {
            visit_handle hz;
            VisIt_VariableData_alloc(&hz);
            VisIt_VariableData_setDataF(hz, VISIT_OWNER_SIM, 1,
                    nodes->getNumNodes(), nodes->getCoords()[2]);
            VisIt_UnstructuredMesh_setCoordsXYZ(hmesh, hx, hy, hz);
        } else {
            VisIt_UnstructuredMesh_setCoordsXY(hmesh, hx, hy);
        }

        // set connectivity
        size_t sz = (elements->getNodesPerElement()+1) *
                     elements->getNumElements() * sizeof(int);
        int* conn = (int*)malloc(sz);
        int* cptr = conn;
        const int* nodeList = &elements->getNodeList()[0];
        int type = 0;
        memset(conn, 0, sz);
        switch (elements->getType()) {
            case weipa::ZONETYPE_BEAM: type = VISIT_CELL_BEAM; break;
            case weipa::ZONETYPE_HEX: type = VISIT_CELL_HEX; break;
            case weipa::ZONETYPE_POLYGON: type = VISIT_CELL_POINT; break;
            case weipa::ZONETYPE_QUAD: type = VISIT_CELL_QUAD; break;
            case weipa::ZONETYPE_TET: type = VISIT_CELL_TET; break;
            case weipa::ZONETYPE_TRIANGLE: type = VISIT_CELL_TRI; break;
            default:
                std::cerr << "Unhandled zone type " << elements->getType()
                    << std::endl;
                break;
        }
        for (size_t i=0; i<elements->getNumElements(); i++) {
            *cptr++ = type;
            for (size_t j=0; j<elements->getNodesPerElement(); j++) {
                *cptr++ = *nodeList++;
            }
        }

        visit_handle hc;
        VisIt_VariableData_alloc(&hc);
        VisIt_VariableData_setDataI(hc, VISIT_OWNER_VISIT, 1,
                sz / sizeof(int), conn);
        VisIt_UnstructuredMesh_setConnectivity(hmesh,
                elements->getNumElements(), hc);

        // set ghost information
        VisIt_UnstructuredMesh_setRealIndices(hmesh, 0,
            elements->getNumElements()-elements->getGhostCount()-1);
    }

    return hmesh;
}

///
/// Returns variable data for the specified variable
///
visit_handle VisItData::getVariable(const char* name)
{
    visit_handle hvar = VISIT_INVALID_HANDLE;
    map<string, DataVar_ptr>::const_iterator it;
    it = variables.find(name);
    if (it != variables.end()) {
        DataVar_ptr var = it->second;
        VisIt_VariableData_alloc(&hvar);
        VisIt_VariableData_setDataF(hvar, VISIT_OWNER_VISIT,
            var->getNumberOfComponents(),
            var->getNumberOfSamples(),
            var->getDataFlat());
    }

    return hvar;
}

///
/// Adds an expression to the simulation metadata smd
///
void VisItData::addExpressionMetadata(visit_handle smd, const string& name,
                                      const string& def, int type)
{
    visit_handle emd;
    if (VisIt_ExpressionMetaData_alloc(&emd) == VISIT_OKAY) {
        VisIt_ExpressionMetaData_setName(emd, name.c_str());
        VisIt_ExpressionMetaData_setDefinition(emd, def.c_str());
        VisIt_ExpressionMetaData_setType(emd, type);
        VisIt_SimulationMetaData_addExpression(smd, emd);
    }
}

///
/// Adds a mesh to the simulation metadata smd
///
void VisItData::addMeshMetadata(visit_handle smd, const string& name, int dim,
                                int numDoms)
{
    visit_handle mmd;
    if (VisIt_MeshMetaData_alloc(&mmd) == VISIT_OKAY) {
        VisIt_MeshMetaData_setName(mmd, name.c_str());
        VisIt_MeshMetaData_setMeshType(mmd, VISIT_MESHTYPE_UNSTRUCTURED);
        VisIt_MeshMetaData_setTopologicalDimension(mmd, dim);
        VisIt_MeshMetaData_setSpatialDimension(mmd, dim);
        VisIt_MeshMetaData_setNumDomains(mmd, numDoms);
        VisIt_MeshMetaData_setDomainTitle(mmd, "domains");
        VisIt_SimulationMetaData_addMesh(smd, mmd);
    }
}

///
/// Adds a variable to the simulation metadata smd
///
void VisItData::addVariableMetadata(visit_handle smd, const string& name,
                                    const string& meshName, int centering,
                                    int rank)
{
    visit_handle vmd;
    if (VisIt_VariableMetaData_alloc(&vmd) == VISIT_OKAY) {
        VisIt_VariableMetaData_setName(vmd, name.c_str());
        VisIt_VariableMetaData_setMeshName(vmd, meshName.c_str());
        if (rank == 0) {
            VisIt_VariableMetaData_setType(vmd, VISIT_VARTYPE_SCALAR);
        } else if (rank == 1) {
            VisIt_VariableMetaData_setType(vmd, VISIT_VARTYPE_VECTOR);
        } else {
            VisIt_VariableMetaData_setType(vmd, VISIT_VARTYPE_TENSOR);
        }
        VisIt_VariableMetaData_setCentering(vmd, centering);
        VisIt_SimulationMetaData_addVariable(smd, vmd);
    }
}

} // namespace weipa

1
2	/*******************************************************
3	*
4	* Copyright (c) 2003-2010 by University of Queensland
5	* Earth Systems Science Computational Center (ESSCC)
6	* http://www.uq.edu.au/esscc
7	*
8	* Primary Business: Queensland, Australia
9	* Licensed under the Open Software License version 3.0
10	* http://www.opensource.org/licenses/osl-3.0.php
11	*
12	*******************************************************/
13
14	#include <weipa/VisItData.h>
15	#include <weipa/DataVar.h>
16	#include <weipa/ElementData.h>
17	#include <weipa/NodeData.h>
18
19	#include <VisItDataInterface_V2.h>
20
21	#include <boost/python/dict.hpp>
22	#include <boost/python/extract.hpp>
23
24	#include <iostream>
25	#include <map>
26	#include <numeric>
27	#include <set>
28	#include <sstream>
29
30	using std::map;
31	using std::set;
32	using std::string;
33	using std::vector;
34
35	namespace weipa {
36
37	//
38	// Returns simulation metadata from this dataset.
39	//
40	visit_handle VisItData::getSimMetaData()
41	{
42	visit_handle mdh = VISIT_INVALID_HANDLE;
43	VisIt_SimulationMetaData_alloc(&mdh);
44	vector<string>::const_iterator it;
45	for (it=cmdNames.begin(); it!=cmdNames.end(); it++) {
46	visit_handle cmd = VISIT_INVALID_HANDLE;
47	if (VisIt_CommandMetaData_alloc(&cmd) == VISIT_OKAY) {
48	VisIt_CommandMetaData_setName(cmd, it->c_str());
49	VisIt_SimulationMetaData_addGenericCommand(mdh, cmd);
50	}
51	}
52	VisIt_SimulationMetaData_setMode(mdh, runFlag ?
53	VISIT_SIMMODE_RUNNING : VISIT_SIMMODE_STOPPED);
54
55	if (dataset.get() == NULL) {
56	return mdh;
57	}
58
59	VisIt_SimulationMetaData_setCycleTime(
60	mdh, dataset->getCycle(), dataset->getTime());
61
62	set<string> usedMeshes;
63
64	// add "special" mesh variable metadata
65	const VarVector& meshVars = dataset->getMeshVariables();
66	VarVector::const_iterator vIt;
67	for (vIt = meshVars.begin(); vIt != meshVars.end(); vIt++) {
68	// skip empty variable
69	int numSamples = accumulate(vIt->sampleDistribution.begin(),
70	vIt->sampleDistribution.end(), 0);
71	if (numSamples > 0 && vIt->valid) {
72	DataVar_ptr readerVar = vIt->dataChunks[0];
73	string meshName = readerVar->getMeshName();
74	usedMeshes.insert(meshName);
75	int centering = readerVar->isNodeCentered() ?
76	VISIT_VARCENTERING_NODE : VISIT_VARCENTERING_ZONE;
77	string varPath = "mesh_vars/"+vIt->varName;
78	variables[varPath] = readerVar;
79	addVariableMetadata(mdh, varPath, meshName, centering, 0);
80	}
81	}
82
83	// add other variables
84	const VarVector& vars = dataset->getVariables();
85	for (vIt = vars.begin(); vIt != vars.end(); vIt++) {
86	// skip empty variable
87	int numSamples = accumulate(vIt->sampleDistribution.begin(),
88	vIt->sampleDistribution.end(), 0);
89	if (numSamples == 0 \|\| !vIt->valid) {
90	continue;
91	}
92
93	const string& varName = vIt->varName;
94	DataVar_ptr readerVar = vIt->dataChunks[0];
95	string meshName = readerVar->getMeshName();
96	usedMeshes.insert(meshName);
97	int centering = readerVar->isNodeCentered() ?
98	VISIT_VARCENTERING_NODE : VISIT_VARCENTERING_ZONE;
99	int rank = readerVar->getRank();
100	addVariableMetadata(mdh, varName, meshName, centering, rank);
101	variables[varName] = readerVar;
102	}
103
104	// add all meshes
105	int mpiSize=1;
106	#ifdef HAVE_MPI
107	MPI_Comm comm = dataset->getMPIComm();
108	MPI_Comm_size(comm, &mpiSize);
109	#endif
110	set<string>::const_iterator sIt;
111	int dim = dataset->getConvertedDomain()[0]->getNodes()->getNumDims();
112	for (sIt = usedMeshes.begin(); sIt != usedMeshes.end(); sIt++) {
113	addMeshMetadata(mdh, *sIt, dim, mpiSize);
114	}
115
116	return mdh;
117	}
118
119	///
120	/// Returns the domain list
121	///
122	visit_handle VisItData::getDomainList()
123	{
124	// each MPI rank serves exactly one domain (chunk) of the data
125	visit_handle domainList = VISIT_INVALID_HANDLE;
126	if (VisIt_DomainList_alloc(&domainList) == VISIT_OKAY) {
127	int mpiRank=0, mpiSize=1;
128	#ifdef HAVE_MPI
129	MPI_Comm comm = dataset->getMPIComm();
130	MPI_Comm_rank(comm, &mpiRank);
131	MPI_Comm_size(comm, &mpiSize);
132	#endif
133	visit_handle hdl;
134	int* rank = (int*)malloc(sizeof(int));
135	*rank = mpiRank;
136	VisIt_VariableData_alloc(&hdl);
137	VisIt_VariableData_setDataI(hdl, VISIT_OWNER_VISIT, 1, 1, rank);
138	VisIt_DomainList_setDomains(domainList, mpiSize, hdl);
139	}
140	return domainList;
141	}
142
143	///
144	/// Returns mesh data for the specified mesh
145	///
146	visit_handle VisItData::getMesh(const char* name)
147	{
148	visit_handle hmesh = VISIT_INVALID_HANDLE;
149	DomainChunk_ptr dom = dataset->getConvertedDomain()[0];
150	NodeData_ptr nodes = dom->getMeshByName(name);
151	ElementData_ptr elements = dom->getElementsByName(name);
152
153	if (nodes && elements
154	&& VisIt_UnstructuredMesh_alloc(&hmesh)) {
155
156	// set node coordinates
157	visit_handle hx, hy;
158	VisIt_VariableData_alloc(&hx);
159	VisIt_VariableData_alloc(&hy);
160	VisIt_VariableData_setDataF(hx, VISIT_OWNER_SIM, 1,
161	nodes->getNumNodes(), nodes->getCoords()[0]);
162	VisIt_VariableData_setDataF(hy, VISIT_OWNER_SIM, 1,
163	nodes->getNumNodes(), nodes->getCoords()[1]);
164
165	if (nodes->getNumDims() > 2) {
166	visit_handle hz;
167	VisIt_VariableData_alloc(&hz);
168	VisIt_VariableData_setDataF(hz, VISIT_OWNER_SIM, 1,
169	nodes->getNumNodes(), nodes->getCoords()[2]);
170	VisIt_UnstructuredMesh_setCoordsXYZ(hmesh, hx, hy, hz);
171	} else {
172	VisIt_UnstructuredMesh_setCoordsXY(hmesh, hx, hy);
173	}
174
175	// set connectivity
176	size_t sz = (elements->getNodesPerElement()+1) *
177	elements->getNumElements() * sizeof(int);
178	int* conn = (int*)malloc(sz);
179	int* cptr = conn;
180	const int* nodeList = &elements->getNodeList()[0];
181	int type = 0;
182	memset(conn, 0, sz);
183	switch (elements->getType()) {
184	case weipa::ZONETYPE_BEAM: type = VISIT_CELL_BEAM; break;
185	case weipa::ZONETYPE_HEX: type = VISIT_CELL_HEX; break;
186	case weipa::ZONETYPE_POLYGON: type = VISIT_CELL_POINT; break;
187	case weipa::ZONETYPE_QUAD: type = VISIT_CELL_QUAD; break;
188	case weipa::ZONETYPE_TET: type = VISIT_CELL_TET; break;
189	case weipa::ZONETYPE_TRIANGLE: type = VISIT_CELL_TRI; break;
190	default:
191	std::cerr << "Unhandled zone type " << elements->getType()
192	<< std::endl;
193	break;
194	}
195	for (size_t i=0; i<elements->getNumElements(); i++) {
196	*cptr++ = type;
197	for (size_t j=0; j<elements->getNodesPerElement(); j++) {
198	cptr++ = nodeList++;
199	}
200	}
201
202	visit_handle hc;
203	VisIt_VariableData_alloc(&hc);
204	VisIt_VariableData_setDataI(hc, VISIT_OWNER_VISIT, 1,
205	sz / sizeof(int), conn);
206	VisIt_UnstructuredMesh_setConnectivity(hmesh,
207	elements->getNumElements(), hc);
208
209	// set ghost information
210	VisIt_UnstructuredMesh_setRealIndices(hmesh, 0,
211	elements->getNumElements()-elements->getGhostCount()-1);
212	}
213
214	return hmesh;
215	}
216
217	///
218	/// Returns variable data for the specified variable
219	///
220	visit_handle VisItData::getVariable(const char* name)
221	{
222	visit_handle hvar = VISIT_INVALID_HANDLE;
223	map<string, DataVar_ptr>::const_iterator it;
224	it = variables.find(name);
225	if (it != variables.end()) {
226	DataVar_ptr var = it->second;
227	VisIt_VariableData_alloc(&hvar);
228	VisIt_VariableData_setDataF(hvar, VISIT_OWNER_VISIT,
229	var->getNumberOfComponents(),
230	var->getNumberOfSamples(),
231	var->getDataFlat());
232	}
233
234	return hvar;
235	}
236
237	///
238	/// Adds an expression to the simulation metadata smd
239	///
240	void VisItData::addExpressionMetadata(visit_handle smd, const string& name,
241	const string& def, int type)
242	{
243	visit_handle emd;
244	if (VisIt_ExpressionMetaData_alloc(&emd) == VISIT_OKAY) {
245	VisIt_ExpressionMetaData_setName(emd, name.c_str());
246	VisIt_ExpressionMetaData_setDefinition(emd, def.c_str());
247	VisIt_ExpressionMetaData_setType(emd, type);
248	VisIt_SimulationMetaData_addExpression(smd, emd);
249	}
250	}
251
252	///
253	/// Adds a mesh to the simulation metadata smd
254	///
255	void VisItData::addMeshMetadata(visit_handle smd, const string& name, int dim,
256	int numDoms)
257	{
258	visit_handle mmd;
259	if (VisIt_MeshMetaData_alloc(&mmd) == VISIT_OKAY) {
260	VisIt_MeshMetaData_setName(mmd, name.c_str());
261	VisIt_MeshMetaData_setMeshType(mmd, VISIT_MESHTYPE_UNSTRUCTURED);
262	VisIt_MeshMetaData_setTopologicalDimension(mmd, dim);
263	VisIt_MeshMetaData_setSpatialDimension(mmd, dim);
264	VisIt_MeshMetaData_setNumDomains(mmd, numDoms);
265	VisIt_MeshMetaData_setDomainTitle(mmd, "domains");
266	VisIt_SimulationMetaData_addMesh(smd, mmd);
267	}
268	}
269
270	///
271	/// Adds a variable to the simulation metadata smd
272	///
273	void VisItData::addVariableMetadata(visit_handle smd, const string& name,
274	const string& meshName, int centering,
275	int rank)
276	{
277	visit_handle vmd;
278	if (VisIt_VariableMetaData_alloc(&vmd) == VISIT_OKAY) {
279	VisIt_VariableMetaData_setName(vmd, name.c_str());
280	VisIt_VariableMetaData_setMeshName(vmd, meshName.c_str());
281	if (rank == 0) {
282	VisIt_VariableMetaData_setType(vmd, VISIT_VARTYPE_SCALAR);
283	} else if (rank == 1) {
284	VisIt_VariableMetaData_setType(vmd, VISIT_VARTYPE_VECTOR);
285	} else {
286	VisIt_VariableMetaData_setType(vmd, VISIT_VARTYPE_TENSOR);
287	}
288	VisIt_VariableMetaData_setCentering(vmd, centering);
289	VisIt_SimulationMetaData_addVariable(smd, vmd);
290	}
291	}
292
293	} // namespace weipa
294