OilfieldToolsNet/LBPM
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Working on IO classes

Browse Source
This commit is contained in:
Mark Berrill
2014-11-04 21:58:20 -05:00
parent f8f09ae999
commit bc2f191537
14 changed files with 798 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

449
IO/MeshDatabase.cpp
View File

@@ -1,4 +1,5 @@
#include "IO/MeshDatabase.h"
#include "IO/Mesh.h"
#include "common/Utilities.h"
#include <vector>
@@ -25,7 +26,232 @@ inline std::string deblank( const std::string& str )
}
// MeshDatabase::MeshDatabase
/****************************************************
* Pack/unpack data from a buffer *
****************************************************/
template<class TYPE>
size_t packsize( const TYPE& rhs );
template<class TYPE>
void pack( const TYPE& rhs, char *buffer );
template<class TYPE>
void unpack( TYPE& data, const char *buffer );
// std::vector
template<class TYPE>
size_t packsize( const std::vector<TYPE>& rhs )
{
size_t bytes = sizeof(size_t);
for (size_t i=0; i<rhs.size(); i++)
bytes += packsize(rhs[i]);
return bytes;
}
template<class TYPE>
void pack( const std::vector<TYPE>& rhs, char *buffer )
{
size_t size = rhs.size();
memcpy(buffer,&size,sizeof(size_t));
size_t pos = sizeof(size_t);
for (int i=0; i<rhs.size(); i++) {
pack(rhs[i],&buffer[pos]);
pos += packsize(rhs[i]);
}
}
template<class TYPE>
void unpack( std::vector<TYPE>& data, const char *buffer )
{
size_t size;
memcpy(&size,buffer,sizeof(size_t));
data.clear();
data.resize(size);
size_t pos = sizeof(size_t);
for (int i=0; i<data.size(); i++) {
unpack(data[i],&buffer[pos]);
pos += packsize(data[i]);
}
}
// std::pair
template<class TYPE1, class TYPE2>
size_t packsize( const std::pair<TYPE1,TYPE2>& rhs )
{
return packsize(rhs.first)+packsize(rhs.second);
}
template<class TYPE1, class TYPE2>
void pack( const std::pair<TYPE1,TYPE2>& rhs, char *buffer )
{
pack(rhs.first,buffer);
pack(rhs.second,&buffer[packsize(rhs.first)]);
}
template<class TYPE1, class TYPE2>
void unpack( std::pair<TYPE1,TYPE2>& data, const char *buffer )
{
unpack(data.first,buffer);
unpack(data.second,&buffer[packsize(data.first)]);
}
// std::map
template<class TYPE1, class TYPE2>
size_t packsize( const std::map<TYPE1,TYPE2>& rhs )
{
size_t bytes = sizeof(size_t);
typename std::map<TYPE1,TYPE2>::const_iterator it;
for (it=rhs.begin(); it!=rhs.end(); ++it) {
bytes += packsize(it->first);
bytes += packsize(it->second);
}
return bytes;
}
template<class TYPE1, class TYPE2>
void pack( const std::map<TYPE1,TYPE2>& rhs, char *buffer )
{
size_t N = rhs.size();
pack(N,buffer);
size_t pos = sizeof(size_t);
typename std::map<TYPE1,TYPE2>::const_iterator it;
for (it=rhs.begin(); it!=rhs.end(); ++it) {
pack(it->first,&buffer[pos]); pos+=packsize(it->first);
pack(it->second,&buffer[pos]); pos+=packsize(it->second);
}
}
template<class TYPE1, class TYPE2>
void unpack( std::map<TYPE1,TYPE2>& data, const char *buffer )
{
size_t N = 0;
unpack(N,buffer);
size_t pos = sizeof(size_t);
data.clear();
for (size_t i=0; i<N; i++) {
std::pair<TYPE1,TYPE2> tmp;
unpack(tmp.first,&buffer[pos]); pos+=packsize(tmp.first);
unpack(tmp.second,&buffer[pos]); pos+=packsize(tmp.second);
data.insert(tmp);
}
}
// size_t
template<>
size_t packsize<size_t>( const size_t& rhs )
{
return sizeof(size_t);
}
template<>
void pack<size_t>( const size_t& rhs, char *buffer )
{
memcpy(buffer,&rhs,sizeof(size_t));
}
template<>
void unpack<size_t>( size_t& data, const char *buffer )
{
memcpy(&data,buffer,sizeof(size_t));
}
// unsigned char
template<>
size_t packsize<unsigned char>( const unsigned char& rhs )
{
return sizeof(unsigned char);
}
template<>
void pack<unsigned char>( const unsigned char& rhs, char *buffer )
{
memcpy(buffer,&rhs,sizeof(unsigned char));
}
template<>
void unpack<unsigned char>( unsigned char& data, const char *buffer )
{
memcpy(&data,buffer,sizeof(unsigned char));
}
// std::string
template<>
size_t packsize<std::string>( const std::string& rhs )
{
return rhs.size()+1;
}
template<>
void pack<std::string>( const std::string& rhs, char *buffer )
{
memcpy(buffer,rhs.c_str(),rhs.size()+1);
}
template<>
void unpack<std::string>( std::string& data, const char *buffer )
{
data = std::string(buffer);
}
// MeshType
template<>
size_t packsize<MeshType>( const MeshType& rhs )
{
return sizeof(MeshType);
}
template<>
void pack<MeshType>( const MeshType& rhs, char *buffer )
{
memcpy(buffer,&rhs,sizeof(MeshType));
}
template<>
void unpack<MeshType>( MeshType& data, const char *buffer )
{
memcpy(&data,buffer,sizeof(MeshType));
}
// DatabaseEntry
template<>
size_t packsize<DatabaseEntry>( const DatabaseEntry& rhs )
{
return packsize(rhs.name)+packsize(rhs.file)+packsize(rhs.offset);
}
template<>
void pack<DatabaseEntry>( const DatabaseEntry& rhs, char *buffer )
{
size_t i=0;
pack(rhs.name,&buffer[i]); i+=packsize(rhs.name);
pack(rhs.file,&buffer[i]); i+=packsize(rhs.file);
pack(rhs.offset,&buffer[i]); i+=packsize(rhs.offset);
}
template<>
void unpack<DatabaseEntry>( DatabaseEntry& data, const char *buffer )
{
size_t i=0;
unpack(data.name,&buffer[i]); i+=packsize(data.name);
unpack(data.file,&buffer[i]); i+=packsize(data.file);
unpack(data.offset,&buffer[i]); i+=packsize(data.offset);
}
// MeshDatabase
template<>
size_t packsize<MeshDatabase>( const MeshDatabase& data )
{
return packsize(data.name)
+ packsize(data.type)
+ packsize(data.meshClass)
+ packsize(data.format)
+ packsize(data.domains)
+ packsize(data.variables)
+ packsize(data.variable_data);
}
template<>
void pack<MeshDatabase>( const MeshDatabase& rhs, char *buffer )
{
size_t i = 0;
pack(rhs.name,&buffer[i]); i+=packsize(rhs.name);
pack(rhs.type,&buffer[i]); i+=packsize(rhs.type);
pack(rhs.meshClass,&buffer[i]); i+=packsize(rhs.meshClass);
pack(rhs.format,&buffer[i]); i+=packsize(rhs.format);
pack(rhs.domains,&buffer[i]); i+=packsize(rhs.domains);
pack(rhs.variables,&buffer[i]); i+=packsize(rhs.variables);
pack(rhs.variable_data,&buffer[i]); i+=packsize(rhs.variable_data);
}
template<>
void unpack<MeshDatabase>( MeshDatabase& data, const char *buffer )
{
size_t i=0;
unpack(data.name,&buffer[i]); i+=packsize(data.name);
unpack(data.type,&buffer[i]); i+=packsize(data.type);
unpack(data.meshClass,&buffer[i]); i+=packsize(data.meshClass);
unpack(data.format,&buffer[i]); i+=packsize(data.format);
unpack(data.domains,&buffer[i]); i+=packsize(data.domains);
unpack(data.variables,&buffer[i]); i+=packsize(data.variables);
unpack(data.variable_data,&buffer[i]); i+=packsize(data.variable_data);
}
/****************************************************
* MeshDatabase *
****************************************************/
MeshDatabase::MeshDatabase()
{
}
@@ -36,94 +262,88 @@ MeshDatabase::MeshDatabase(const MeshDatabase& rhs)
{
name = rhs.name;
type = rhs.type;
meshClass = rhs.meshClass;
format = rhs.format;
domains = rhs.domains;
file = rhs.file;
variables = rhs.variables;
variable_data = rhs.variable_data;
}
MeshDatabase& MeshDatabase::operator=(const MeshDatabase& rhs)
{
this->name = rhs.name;
this->type = rhs.type;
this->meshClass = rhs.meshClass;
this->format = rhs.format;
this->domains = rhs.domains;
this->file = rhs.file;
this->variables = rhs.variables;
this->variable_data = rhs.variable_data;
return *this;
}
// Pack/Unpack the MeshDatabase to/from buffer
static size_t MeshDatabaseSize( const MeshDatabase& data )
/****************************************************
* Split a line into pieces *
****************************************************/
static inline size_t find( const char *line, char key )
{
size_t bytes = 2;
bytes += data.name.size()+1;
bytes += sizeof(int);
for (size_t i=0; i<data.domains.size(); i++)
bytes += data.domains[i].size()+1;
bytes += sizeof(int);
for (size_t i=0; i<data.file.size(); i++)
bytes += data.file[i].size()+1;
bytes += sizeof(int);
for (size_t i=0; i<data.variables.size(); i++)
bytes += data.variables[i].size()+1;
return bytes;
size_t i=0;
while ( 1 ) {
if ( line[i]==key || line[i]<32 || line[i]==0 )
break;
++i;
}
return i;
}
static void pack( const MeshDatabase& data, char *buffer )
static inline std::vector<std::string> splitList( const char *line )
{
buffer[0] = static_cast<char>(data.type);
buffer[1] = data.format;
size_t pos = 2;
memcpy(&buffer[pos],data.name.c_str(),data.name.size()+1);
pos += data.name.size()+1;
*reinterpret_cast<int*>(&buffer[pos]) = data.domains.size();
pos += sizeof(int);
for (size_t i=0; i<data.domains.size(); i++) {
memcpy(&buffer[pos],data.domains[i].c_str(),data.domains[i].size()+1);
pos += data.domains[i].size()+1;
}
*reinterpret_cast<int*>(&buffer[pos]) = data.file.size();
pos += sizeof(int);
for (size_t i=0; i<data.file.size(); i++) {
memcpy(&buffer[pos],data.file[i].c_str(),data.file[i].size()+1);
pos += data.file[i].size()+1;
}
*reinterpret_cast<int*>(&buffer[pos]) = data.variables.size();
pos += sizeof(int);
for (size_t i=0; i<data.variables.size(); i++) {
memcpy(&buffer[pos],data.variables[i].c_str(),data.variables[i].size()+1);
pos += data.variables[i].size()+1;
std::vector<std::string> list;
size_t i1 = 0;
size_t i2 = 0;
while ( 1 ) {
if ( line[i2]==';' || line[i2]<32 ) {
std::string tmp(&line[i1],i2-i1);
tmp = deblank(tmp);
if ( !tmp.empty() )
list.push_back(tmp);
i1 = i2+1;
}
if ( line[i2]==0 )
break;
i2++;
}
return list;
}
static MeshDatabase unpack( const char *buffer )
/****************************************************
* DatabaseEntry *
****************************************************/
std::string DatabaseEntry::write( ) const
{
MeshDatabase data;
data.type = static_cast<MeshType>(buffer[0]);
data.format = buffer[1];
size_t pos = 2;
data.name = std::string(&buffer[pos]);
pos += data.name.size()+1;
int N_domains = *reinterpret_cast<const int*>(&buffer[pos]);
pos += sizeof(int);
data.domains.resize(N_domains);
for (size_t i=0; i<data.domains.size(); i++) {
data.domains[i] = std::string(&buffer[pos]);
pos += data.domains[i].size()+1;
}
int N_file = *reinterpret_cast<const int*>(&buffer[pos]);
pos += sizeof(int);
data.file.resize(N_file);
for (size_t i=0; i<data.file.size(); i++) {
data.file[i] = std::string(&buffer[pos]);
pos += data.file[i].size()+1;
}
int N_variables = *reinterpret_cast<const int*>(&buffer[pos]);
pos += sizeof(int);
data.variables.resize(N_variables);
for (size_t i=0; i<data.variables.size(); i++) {
data.variables[i] = std::string(&buffer[pos]);
pos += data.variables[i].size()+1;
}
return data;
char tmp[1000];
sprintf(tmp,"%s; %s; %lu",name.c_str(),file.c_str(),offset);
return std::string(tmp);
}
DatabaseEntry::DatabaseEntry( const char* line )
{
std::vector<std::string> list = splitList(line);
name = list[0];
file = list[1];
offset = atol(list[2].c_str());
}
void DatabaseEntry::read( const char* line )
{
std::vector<std::string> list = splitList(line);
name = list[0];
file = list[1];
offset = atol(list[2].c_str());
}
void DatabaseEntry::read( const std::string& line )
{
std::vector<std::string> list = splitList(line.c_str());
name = list[0];
file = list[1];
offset = atol(list[2].c_str());
}
@@ -138,12 +358,12 @@ std::vector<MeshDatabase> gatherAll( const std::vector<MeshDatabase>& meshes, MP
// First pack the mesh data to local buffers
size_t localsize = 0;
for (size_t i=0; i<meshes.size(); i++)
localsize += MeshDatabaseSize(meshes[i]);
localsize += packsize(meshes[i]);
char *localbuf = new char[localsize];
size_t pos = 0;
for (size_t i=0; i<meshes.size(); i++) {
pack( meshes[i], &localbuf[pos] );
pos += MeshDatabaseSize(meshes[i]);
pos += packsize(meshes[i]);
}
// Get the number of bytes each processor will be sending/recieving
int sendsize = static_cast<int>(localsize);
@@ -151,8 +371,8 @@ std::vector<MeshDatabase> gatherAll( const std::vector<MeshDatabase>& meshes, MP
MPI_Allgather(&sendsize,1,MPI_INT,recvsize,1,MPI_INT,comm);
size_t globalsize = recvsize[0];
int *disp = new int[size];
disp[0] = 0;
for (size_t i=1; i<size; i++) {
disp[0] = 0;
for (int i=1; i<size; i++) {
disp[i] = disp[i-1] + recvsize[i];
globalsize += recvsize[i];
}
@@ -163,18 +383,18 @@ std::vector<MeshDatabase> gatherAll( const std::vector<MeshDatabase>& meshes, MP
std::map<std::string,MeshDatabase> data;
pos = 0;
while ( pos < globalsize ) {
MeshDatabase tmp = unpack(&globalbuf[pos]);
pos += MeshDatabaseSize(tmp);
MeshDatabase tmp;
unpack(tmp,&globalbuf[pos]);
pos += packsize(tmp);
std::map<std::string,MeshDatabase>::iterator it = data.find(tmp.name);
if ( it==data.end() ) {
data[tmp.name] = tmp;
} else {
for (size_t i=0; i<tmp.domains.size(); i++)
it->second.domains.push_back(tmp.domains[i]);
for (size_t i=0; i<tmp.domains.size(); i++)
it->second.file.push_back(tmp.file[i]);
for (size_t i=0; i<tmp.variables.size(); i++)
it->second.variables.push_back(tmp.variables[i]);
it->second.variable_data.insert(tmp.variable_data.begin(),tmp.variable_data.end());
}
}
for (std::map<std::string,MeshDatabase>::iterator it=data.begin(); it!=data.end(); ++it) {
@@ -204,51 +424,28 @@ void write( const std::vector<MeshDatabase>& meshes, const std::string& filename
FILE *fid = fopen(filename.c_str(),"wb");
for (size_t i=0; i<meshes.size(); i++) {
fprintf(fid,"%s\n",meshes[i].name.c_str());
fprintf(fid," format: %i\n",static_cast<int>(meshes[i].format));
fprintf(fid," type: %i\n",static_cast<int>(meshes[i].type));
fprintf(fid," domains: ");
for (size_t j=0; j<meshes[i].domains.size(); j++) {
fprintf(fid,"%s; ",meshes[i].domains[j].c_str());
}
fprintf(fid,"\n");
fprintf(fid," file: ");
for (size_t j=0; j<meshes[i].file.size(); j++) {
fprintf(fid,"%s; ",meshes[i].file[j].c_str());
}
fprintf(fid,"\n");
fprintf(fid," meshClass: %s\n",meshes[i].meshClass.c_str());
fprintf(fid," format: %i\n",static_cast<int>(meshes[i].format));
for (size_t j=0; j<meshes[i].domains.size(); j++)
fprintf(fid," domain: %s\n",meshes[i].domains[j].write().c_str());
fprintf(fid," variables: ");
for (size_t j=0; j<meshes[i].variables.size(); j++) {
fprintf(fid,"%s; ",meshes[i].variables[j].c_str());
}
fprintf(fid,"\n");
std::map<std::pair<std::string,std::string>,DatabaseEntry>::const_iterator it;
for (it=meshes[i].variable_data.begin(); it!=meshes[i].variable_data.end(); ++it) {
const char* domain = it->first.first.c_str();
const char* variable = it->first.second.c_str();
fprintf(fid," variable(%s,%s): %s\n",domain,variable,it->second.write().c_str());
}
}
fclose(fid);
PROFILE_STOP("write");
}
// Helper function to split a line into the sub variables
static inline std::vector<std::string> splitList( const char *line )
{
std::vector<std::string> list;
size_t i1 = 0;
size_t i2 = 0;
while ( 1 ) {
if ( line[i2]==';' || line[i2]<32 ) {
std::string tmp(&line[i1],i2-i1);
tmp = deblank(tmp);
if ( !tmp.empty() )
list.push_back(tmp);
i1 = i2+1;
}
if ( line[i2]==0 )
break;
i2++;
}
return list;
}
//! Read the mesh databases from a file
std::vector<MeshDatabase> read( const std::string& filename )
{
@@ -271,12 +468,22 @@ std::vector<MeshDatabase> read( const std::string& filename )
meshes.back().format = static_cast<unsigned char>(atoi(&line[10]));
} else if ( strncmp(line," type:",8)==0 ) {
meshes.back().type = static_cast<MeshType>(atoi(&line[8]));
} else if ( strncmp(line," domains:",11)==0 ) {
meshes.back().domains = splitList(&line[11]);
} else if ( strncmp(line," file:",8)==0 ) {
meshes.back().file = splitList(&line[8]);
} else if ( strncmp(line," meshClass:",13)==0 ) {
meshes.back().meshClass = deblank(std::string(&line[13]));
} else if ( strncmp(line," domain:",10)==0 ) {
DatabaseEntry data(&line[10]);
meshes.back().domains.push_back(data);
} else if ( strncmp(line," variables:",13)==0 ) {
meshes.back().variables = splitList(&line[13]);
} else if ( strncmp(line," variable(",12)==0 ) {
size_t i1 = find(line,',');
size_t i2 = find(line,':');
std::string domain = deblank(std::string(line,13,i1-13));
std::string variable = deblank(std::string(line,i1+1,i2-i1));
std::pair<std::string,std::string> key(domain,variable);
DatabaseEntry data(&line[i2+1]);
meshes.back().variable_data.insert(
std::pair<std::pair<std::string,std::string>,DatabaseEntry>(key,data) );
} else {
ERROR("Error reading line");
}
@@ -288,6 +495,20 @@ std::vector<MeshDatabase> read( const std::string& filename )
}
// Return the mesh type
IO::MeshType meshType( std::shared_ptr<IO::Mesh> mesh )
{
IO::MeshType type = IO::MeshType::Unknown;
if ( std::dynamic_pointer_cast<IO::PointList>(mesh)!=NULL ) {
type = IO::MeshType::PointMesh;
} else if ( std::dynamic_pointer_cast<IO::TriList>(mesh)!=NULL || std::dynamic_pointer_cast<IO::TriMesh>(mesh)!=NULL ) {
type = IO::MeshType::SurfaceMesh;
} else {
ERROR("Unknown mesh");
}
return type;
}
} // IO namespace