Skip to content
Snippets Groups Projects
Commit e87c83a1 authored by Oliver Sander's avatar Oliver Sander
Browse files

cleanup 

[[Imported from SVN: r842]]
parent 52325ca7
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 0 additions and 2310 deletions
lib/io/.gitignore deleted 100644 → 0
+ 0
− 6
View file @ 52325ca7
.deps
.libs
Makefile
Makefile.in
*.lo
libduneio.la
\ No newline at end of file
lib/io/Makefile.am deleted 100644 → 0
+ 0
− 6
View file @ 52325ca7
# $Id$
# this library should only exist during the build (noinst)
noinst_LTLIBRARIES = libduneio.la
libduneio_la_SOURCES = gridwriter.cc
lib/io/amirameshreader.hh deleted 100644 → 0
+ 0
− 49
View file @ 52325ca7
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef __DUNE_AMIRAMESHREADER_HH__
#define __DUNE_AMIRAMESHREADER_HH__
#include <string>
#include "../../common/array.hh"
namespace Dune {
/** @ingroup IO
* \brief Provides file reading facilities in the AmiraMesh format.
*
*/
template<class GRID>
class AmiraMeshReader {
public:
/** \brief The method that does the reading.
*
* @param grid The grid objects that is to be written
* @param filename The filename
*/
static void read(GRID& grid,
const std::string& filename);
AmiraMeshReader() {}
};
}
// Default implementation
template<class GRID>
void Dune::AmiraMeshReader<GRID>::read(GRID& grid,
const std::string& filename)
{
printf("No AmiraMesh reading has been implemented for this grid type!\n");
}
// the amiramesh reader for UGGrid
#ifdef HAVE_UG
#include "amuggridreader.cc"
#endif
#endif
lib/io/amirameshwriter.cc deleted 100644 → 0
+ 0
− 424
View file @ 52325ca7
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#include <amiramesh/AmiraMesh.h>
#if _3
template<class GRID, class DiscFuncType>
void Dune::AmiraMeshWriter<GRID, T>::write(const GRID& grid,
const std::string& filename)
{
// Temporary: we write this level
int level = grid.maxlevel();
// Find out whether the grid contains only tetrahedra. If yes, then
// it is written in TetraGrid format. If not, it is written in
// hexagrid format.
bool containsOnlyTetrahedra = true;
typename GRID::template Traits<0>::LevelIterator element = grid.template lbegin<0>(level);
typename GRID::template Traits<0>::LevelIterator end = grid.template lend<0>(level);
for (; element!=end; ++element) {
if (element->geometry().type() != tetrahedron) {
containsOnlyTetrahedra = false;
break;
}
}
printf("This is the AmiraMesh writer!\n");
int maxVerticesPerElement = (containsOnlyTetrahedra) ? 4 : 8;
const int DIM = 3;
int noOfNodes = grid.size(level, 3);
int noOfElem = grid.size(level, 0);
printf("noOfNodes %d, nodeOfElem: %d\n", noOfNodes, noOfElem);
int i;
//int tl, k, noOfBndTri, MarkKey, ncomp, maxSubDom;
std::string solFilename;
// Construct the name for the geometry file
std::string geoFilename(filename);
geoFilename += ".am";
// create amiramesh object
AmiraMesh am_geometry;
// write grid vertex coordinates
AmiraMesh::Location* geo_nodes = new AmiraMesh::Location("Nodes", noOfNodes);
am_geometry.insert(geo_nodes);
AmiraMesh::Data* geo_node_data = new AmiraMesh::Data("Coordinates", geo_nodes,
McPrimType::mc_float, DIM);
am_geometry.insert(geo_node_data);
typename GRID::template Traits<3>::LevelIterator vertex = grid.template lbegin<3>(level);
typename GRID::template Traits<3>::LevelIterator endvertex = grid.template lend<3>(level);
for (; vertex!=endvertex; ++vertex)
{
int index = vertex->index();
Vec<3, double> coords = vertex->geometry()[0];
((float*)geo_node_data->dataPtr())[3*index+0] = coords(0);
((float*)geo_node_data->dataPtr())[3*index+1] = coords(1);
((float*)geo_node_data->dataPtr())[3*index+2] = coords(2);
}
#if 0
// handle materials
HxParamBundle* materials = new HxParamBundle("Materials");
for (k=0; k<=maxSubDom; k++) {
char buffer[100];
sprintf(buffer, "Material%d", k);
HxParamBundle* newMaterial = new HxParamBundle(buffer);
HxParameter* newId = new HxParameter("Id", k);
newMaterial->insert(newId);
materials->insert(newMaterial);
}
am_geometry.parameters.insert(materials);
ncomp = 0;
for(i=0; i<NVECTYPES; i++)
ncomp = MAX(ncomp,VD_NCMPS_IN_TYPE(sol, i));
#endif
/* write element section to geo - file */
AmiraMesh::Location* element_loc = NULL;
if (containsOnlyTetrahedra)
element_loc = new AmiraMesh::Location("Tetrahedra", noOfElem);
else
element_loc = new AmiraMesh::Location("Hexahedra", noOfElem);
am_geometry.insert(element_loc);
AmiraMesh::Data* element_data = new AmiraMesh::Data("Nodes", element_loc,
McPrimType::mc_int32, maxVerticesPerElement);
am_geometry.insert(element_data);
//int *(dPtr[maxVerticesPerElement]) = (int*)element_data->dataPtr();
int *dPtr = (int*)element_data->dataPtr();
typename GRID::template Traits<0>::LevelIterator element2 = grid.template lbegin<0>(level);
typename GRID::template Traits<0>::LevelIterator endelement = grid.template lend<0>(level);
for (i=0; element2!=endelement; ++element2, i++) {
switch (element2->geometry().type()) {
case hexahedron :
dPtr[i*maxVerticesPerElement+0] = element2->template subIndex<3>(0)+1;
dPtr[i*maxVerticesPerElement+1] = element2->template subIndex<3>(1)+1;
dPtr[i*maxVerticesPerElement+2] = element2->template subIndex<3>(3)+1;
dPtr[i*maxVerticesPerElement+3] = element2->template subIndex<3>(2)+1;
dPtr[i*maxVerticesPerElement+4] = element2->template subIndex<3>(4)+1;
dPtr[i*maxVerticesPerElement+5] = element2->template subIndex<3>(5)+1;
dPtr[i*maxVerticesPerElement+6] = element2->template subIndex<3>(7)+1;
dPtr[i*maxVerticesPerElement+7] = element2->template subIndex<3>(6)+1;
break;
default :
for (int j=0; j<element2->geometry().corners(); j++)
dPtr[i*maxVerticesPerElement+j] = element2->template subIndex<3>(j)+1;
// If the element has less than 8 vertices use the last value
// to fill up the remaining slots
for (int j=element2->geometry().corners(); j<maxVerticesPerElement; j++)
dPtr[i*maxVerticesPerElement+j] = dPtr[i*maxVerticesPerElement+element2->geometry().corners()-1];
}
}
// write material section to geo-file
AmiraMesh::Data* element_materials = new AmiraMesh::Data("Materials", element_loc, McPrimType::mc_uint8, 1);
am_geometry.insert(element_materials);
// for(i=0; i<noOfElem; i++)
// ((unsigned char*)element_materials->dataPtr())[i] = SUBDOMAIN(elemList[i]);
for(i=0; i<noOfElem; i++)
((unsigned char*)element_materials->dataPtr())[i] = 0;
//////////////////////////////////////////////////////
// Now save the solution
#if 0
AmiraMesh::Data* nodeData = new AmiraMesh::Data("Data", geo_nodes, McPrimType::mc_float, ncomp);
am_geometry.insert(nodeData);
AmiraMesh::Field* nodeField = new AmiraMesh::Field("f", ncomp, McPrimType::mc_float,
AmiraMesh::t_linear, nodeData);
am_geometry.insert(nodeField);
i=0;
for (k=fl; k<=tl; k++)
for (vec=FIRSTVECTOR(GRID_ON_LEVEL(theMG,k)); vec!= NULL; vec=SUCCVC(vec))
if ((VOTYPE(vec) == NODEVEC) && ((k==tl) || (VNCLASS(vec)<1) ))
{
SHORT vtype = VTYPE(vec);
/** \bug This definition of ncomp shadows another one! */
SHORT ncomp = VD_NCMPS_IN_TYPE(sol, vtype);
SHORT *cmpptr = VD_CMPPTR_OF_TYPE(sol, vtype);
SHORT j;
for (j=0; j<ncomp; j++)
((float*)nodeData->dataPtr())[ncomp*i+j] = VVALUE(vec, cmpptr[j]);
i++;
}
// actually save the solution file
// if (!am_solution.write(solFilename, 1) ) {
// printf("An error has occured writing file %s.\n", solFilename);
// return PARAMERRORCODE;
// }
#endif
if(!am_geometry.write(geoFilename.c_str(), 1)) {
printf("writing geometry file failed in amira : \n");
/** \todo Do a decent error handling */
return;
}
printf("Grid written successfully to:\n %s \n", geoFilename.c_str());
}
#endif // #if _3
#ifdef _2
template<class GRID, class DiscFuncType>
void Dune::AmiraMeshWriter<GRID, DiscFuncType>::writeGrid(const GRID& grid,
const std::string& filename)
{
// Temporary: we write this level
int level = grid.maxlevel();
// Find out whether the grid contains only triangles. If yes, then
// it is written as a HxTriangularGrid. If not, it cannot be
// written (so far).
bool containsOnlyTetrahedra = true;
typename GRID::template Traits<0>::LevelIterator element = grid.template lbegin<0>(level);
typename GRID::template Traits<0>::LevelIterator end = grid.template lend<0>(level);
for (; element!=end; ++element) {
if (element->geometry().type() != triangle) {
containsOnlyTetrahedra = false;
break;
}
}
printf("This is the 2D AmiraMesh writer!\n");
int maxVerticesPerElement = (containsOnlyTetrahedra) ? 3 : 4;
const int DIM = 2;
int noOfNodes = grid.size(level, DIM);
int noOfElem = grid.size(level, 0);
printf("noOfNodes %d, nodeOfElem: %d\n", noOfNodes, noOfElem);
int i;
//int tl, k, noOfBndTri, MarkKey, ncomp, maxSubDom;
std::string solFilename;
// Construct the name for the geometry file
std::string geoFilename(filename);
geoFilename += ".am";
// create amiramesh object
AmiraMesh am_geometry;
// Set the appropriate content type
am_geometry.parameters.set("ContentType", "HxTriangularGrid");
// write grid vertex coordinates
AmiraMesh::Location* geo_nodes = new AmiraMesh::Location("Nodes", noOfNodes);
am_geometry.insert(geo_nodes);
AmiraMesh::Data* geo_node_data = new AmiraMesh::Data("Coordinates", geo_nodes,
McPrimType::mc_float, DIM);
am_geometry.insert(geo_node_data);
typename GRID::template Traits<2>::LevelIterator vertex = grid.template lbegin<DIM>(level);
typename GRID::template Traits<2>::LevelIterator endvertex = grid.template lend<DIM>(level);
for (; vertex!=endvertex; ++vertex)
{
int index = vertex->index();
Vec<DIM, double> coords = vertex->geometry()[0];
((float*)geo_node_data->dataPtr())[2*index+0] = coords(0);
((float*)geo_node_data->dataPtr())[2*index+1] = coords(1);
}
#if 0
// handle materials
HxParamBundle* materials = new HxParamBundle("Materials");
for (k=0; k<=maxSubDom; k++) {
char buffer[100];
sprintf(buffer, "Material%d", k);
HxParamBundle* newMaterial = new HxParamBundle(buffer);
HxParameter* newId = new HxParameter("Id", k);
newMaterial->insert(newId);
materials->insert(newMaterial);
}
am_geometry.parameters.insert(materials);
ncomp = 0;
for(i=0; i<NVECTYPES; i++)
ncomp = MAX(ncomp,VD_NCMPS_IN_TYPE(sol, i));
#endif
/* write element section to geo - file */
AmiraMesh::Location* element_loc = NULL;
if (containsOnlyTetrahedra)
element_loc = new AmiraMesh::Location("Triangles", noOfElem);
else
element_loc = new AmiraMesh::Location("Quadrangles", noOfElem);
am_geometry.insert(element_loc);
AmiraMesh::Data* element_data = new AmiraMesh::Data("Nodes", element_loc,
McPrimType::mc_int32, maxVerticesPerElement);
am_geometry.insert(element_data);
//int *(dPtr[maxVerticesPerElement]) = (int*)element_data->dataPtr();
int *dPtr = (int*)element_data->dataPtr();
typename GRID::template Traits<0>::LevelIterator element2 = grid.template lbegin<0>(level);
typename GRID::template Traits<0>::LevelIterator endelement = grid.template lend<0>(level);
for (i=0; element2!=endelement; ++element2, i++) {
switch (element2->geometry().type()) {
// case hexahedron:
// dPtr[i*maxVerticesPerElement+0] = element2->template subIndex<3>(0)+1;
// dPtr[i*maxVerticesPerElement+1] = element2->template subIndex<3>(1)+1;
// dPtr[i*maxVerticesPerElement+2] = element2->template subIndex<3>(3)+1;
// dPtr[i*maxVerticesPerElement+3] = element2->template subIndex<3>(2)+1;
// dPtr[i*maxVerticesPerElement+4] = element2->template subIndex<3>(4)+1;
// dPtr[i*maxVerticesPerElement+5] = element2->template subIndex<3>(5)+1;
// dPtr[i*maxVerticesPerElement+6] = element2->template subIndex<3>(7)+1;
// dPtr[i*maxVerticesPerElement+7] = element2->template subIndex<3>(6)+1;
// break;
default :
for (int j=0; j<element2->geometry().corners(); j++)
dPtr[i*maxVerticesPerElement+j] = element2->template subIndex<DIM>(j)+1;
// If the element has less than 8 vertices use the last value
// to fill up the remaining slots
for (int j=element2->geometry().corners(); j<maxVerticesPerElement; j++)
dPtr[i*maxVerticesPerElement+j] = dPtr[i*maxVerticesPerElement+element2->geometry().corners()-1];
}
}
// write material section to geo-file
AmiraMesh::Data* element_materials = new AmiraMesh::Data("Materials", element_loc, McPrimType::mc_uint8, 1);
am_geometry.insert(element_materials);
// for(i=0; i<noOfElem; i++)
// ((unsigned char*)element_materials->dataPtr())[i] = SUBDOMAIN(elemList[i]);
for(i=0; i<noOfElem; i++)
((unsigned char*)element_materials->dataPtr())[i] = 0;
if(!am_geometry.write(geoFilename.c_str(), 1)) {
printf("writing geometry file failed in amira : \n");
/** \todo Do a decent error handling */
return;
}
printf("Grid written successfully to:\n %s \n", geoFilename.c_str());
}
template<class GRID, class DiscFuncType>
void Dune::AmiraMeshWriter<GRID, DiscFuncType>::writeFunction(const DiscFuncType& f,
const std::string& filename)
{
// Get grid type associated with DiscFuncType
typedef typename DiscFuncType::FunctionSpaceType FunctionSpaceType;
typedef typename FunctionSpaceType::GridType GridType;
const GridType& grid = f.getFunctionSpace().getGrid();
const int level = grid.maxlevel();
const int noOfNodes = grid.size(level, GridType::dimension);
// temporary hack
const int ncomp = 1;
// Create AmiraMesh object
AmiraMesh am;
// Set the appropriate content type
am.parameters.set("ContentType", "HxTriangularData");
AmiraMesh::Location* sol_nodes = new AmiraMesh::Location("Nodes", noOfNodes);
am.insert(sol_nodes);
AmiraMesh::Data* nodeData = new AmiraMesh::Data("Data", sol_nodes, McPrimType::mc_double, ncomp);
am.insert(nodeData);
AmiraMesh::Field* nodeField = new AmiraMesh::Field("f", ncomp, McPrimType::mc_double,
AmiraMesh::t_linear, nodeData);
am.insert(nodeField);
// write the data into the AmiraMesh object
typedef typename DiscFuncType::DofIteratorType DofIterator;
DofIterator dit = f.dbegin(level);
DofIterator ditend = f.dend(level);
int i=0;
for (; dit!=ditend; ++dit, i++) {
((double*)nodeData->dataPtr())[i] = *dit;
}
// actually save the solution file
// (the 1 means: ascii)
if (!am.write(filename.c_str(), 1) ) {
std::cerr << "An error has occured writing file " << filename << "\n";
return;
}
}
#endif // #ifdef _2
lib/io/amirameshwriter.hh deleted 100644 → 0
+ 0
− 54
View file @ 52325ca7
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef __DUNE_AMIRAMESHWRITER_HH__
#define __DUNE_AMIRAMESHWRITER_HH__
#include <string>
namespace Dune {
/** @ingroup IO
* \brief Provides file writing facilities in the AmiraMesh format.
*
* Use it by calling the static method write(). Its default implementation
* only yields a warning message. Actual functionality is provided by
* specializations of the methods. So far, the following ones are
* available:
* <ul>
* <li> SimpleGrid<3,3>, with <code>double</code> data </li>
* </ul>
*/
template<class GRID, class DiscFuncType>
class AmiraMeshWriter {
public:
/** \brief Writes a grid in AmiraMesh format
*
* @param grid The grid objects that is to be written
* @param filename The filename
*/
static void writeGrid(const GRID& grid,
const std::string& filename);
/** \brief Writes a discrete function in AmiraMesh format
*
* @param f Function that should be written
* @param filename The filename
*/
static void writeFunction(const DiscFuncType& f,
const std::string& filename);
AmiraMeshWriter() {}
};
}
// The default implementation
#include "amirameshwriter.cc"
// the amiramesh writer for SimpleGrid
//#include "amsimplegridwriter.cc"
#endif
lib/io/amsimplegridwriter.cc deleted 100644 → 0
+ 0
− 76
View file @ 52325ca7
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// ///////////////////////////////////////////////
// Specialization of the AmiraMesh writer for SimpleGrid<3,3>
// ///////////////////////////////////////////////
#include "../../grid/simplegrid.hh"
namespace Dune {
template<>
class AmiraMeshWriter<SimpleGrid<3,3>, double> {
public:
static void write(const SimpleGrid<3,3>& grid,
const Array<double>& sol,
const std::string& filename);
AmiraMeshWriter() {}
};
}
//template<>
void Dune::AmiraMeshWriter<Dune::SimpleGrid<3,3>, double>::write(const Dune::SimpleGrid<3,3>& grid,
const Array<double>& sol,
const std::string& filename)
{
printf("This is the AmiraMesh writer for SimpleGrid<3,3>!\n");
int maxlevel = grid.maxlevel();
const levelinfo<3>* li = grid.get_levelinfo(maxlevel);
// determine current time
time_t time_val = time(NULL);
struct tm* localtime_val = localtime(&time_val);
const char* asctime_val = asctime(localtime_val);
// write the amiramesh header
FILE* fp = fopen(filename.c_str(), "w");
fprintf(fp, "# AmiraMesh 3D ASCII 2.0\n");
fprintf(fp, "# CreationDate: %s\n\n\n", asctime_val);
fprintf(fp, "define Lattice %d %d %d\n\n", li->ne[0], li->ne[1], li->ne[2]);
fprintf(fp, "Parameters {\n");
// SimpleGrids always have the unit bounding box
fprintf(fp, " BoundingBox 0 1 0 1 0 1,\n");
fprintf(fp, " CoordType \"uniform\",\n");
fprintf(fp, " Content \"%dx%dx%d double, uniform coordinates\"\n",
li->ne[0], li->ne[1], li->ne[2]);
fprintf(fp, "}\n\n");
fprintf(fp, "Lattice { double Data } @1\n\n");
fprintf(fp, "# Data section follows\n");
fprintf(fp, "@1\n");
// SimpleGrid<3,3>::Traits<0>::LevelIterator iter = grid.lbegin<0>(maxlevel);
// for (; iter!= grid.lend<0>(maxlevel); ++iter) {
// fprintf(fp, "%f\n", iter->index(), *iter);
// }
Array<double>::Iterator iter = sol.begin();
for (; iter!=sol.end(); ++iter) {
fprintf(fp, "%f\n", *iter);
}
fclose(fp);
}
lib/io/amuggridreader.cc deleted 100644 → 0
+ 0
− 1593
View file @ 52325ca7
This diff is collapsed.
lib/io/rawdatawriter.hh deleted 100644 → 0
+ 0
− 54
View file @ 52325ca7
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef __DUNE_RAWDATAWRITER_HH__
#define __DUNE_RAWDATAWRITER_HH__
#include <string>
namespace Dune {
/** @ingroup IO
* \brief Provides file writing facilities in the raw data format.
*
* Use it by calling the static method write(). Its default implementation
* only yields a warning message. Actual functionality is provided by
* specializations of the methods. So far, the following ones are
* available:
* <ul>
* <li> SimpleGrid<3,3> </li>
* </ul>
*/
template<class GRID, class T>
class RawDataWriter {
public:
/** \brief The method that does the writing.
*
* @param grid The grid objects that is to be written
* @param sol Data that should be written along with the grid
* @param filename The filename
*/
static void write(const GRID& grid,
const Array<T>& sol,
const std::string& filename);
RawDataWriter() {}
};
}
// Default implementation
template<class GRID, class T>
void Dune::RawDataWriter<GRID, T>::write(const GRID& grid,
const Array<T>& sol,
const std::string& filename)
{
printf("No rawdata writing has been implemented for this grid type!\n");
}
#include "rdsimplegridwriter.cc"
#endif
lib/io/rdsimplegridwriter.cc deleted 100644 → 0
+ 0
− 48
View file @ 52325ca7
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#include "../../grid/simplegrid.hh"
// ///////////////////////////////////////////////
// Specialization for SimpleGrid<3,3>
// ///////////////////////////////////////////////
namespace Dune {
template<class T>
class RawDataWriter<SimpleGrid<3,3>, T> {
public:
static void write(const SimpleGrid<3,3>& grid,
const Array<T>& sol,
const std::string& filename);
RawDataWriter() {}
};
}
template<class T>
void Dune::RawDataWriter<Dune::SimpleGrid<3,3>, T>::write(const Dune::SimpleGrid<3,3>& grid,
const Array<T>& sol,
const std::string& filename)
{
printf("This is the rawdata writer for SimpleGrid<3,3>!\n");
int maxlevel = grid.maxlevel();
const levelinfo<3>* li = grid.get_levelinfo(maxlevel);
// write the amiramesh header
FILE* fp = fopen(filename.c_str(), "wb");
for (Array<T>::Iterator iter = sol.begin(); iter!=sol.end(); ++iter) {
fwrite(iter.operator->(), sizeof(T), 1, fp);
}
fclose(fp);
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment