PCPPFieldData.H

Go to the documentation of this file.

#ifndef __PCPP_FIELD_DATA_H__
#define __PCPP_FIELD_DATA_H__

#include <ostream>
#include <istream>
#include <vector>
#include <string>
#include <sstream>

#include "PCPPTypes.H"

namespace pcpp {

  namespace field {
    
    //    typedef pcpp::ConfigType ConfigurationType;
    
    class databuffer {
      
    public:
      
      friend std::ostream &operator<<(std::ostream &Ostr,const databuffer &buf);
      friend std::istream &operator>>(std::istream &Istr,databuffer &buf);
      
    public:
      
      enum DataType {DTCHAR,DTBYTE,DTINT,DTFLOAT,DTDOUBLE};
      size_t DataSize[5];
      
    private:
      
      char         *_data_ptr;
      size_t        _item_size;
      bool          _my_data;
      size_t        _number_of_items;
      //    int           _mysize;
    public:
      
      databuffer() : _data_ptr(NULL), _item_size(1), 
                     _my_data(false), _number_of_items(0) //, _mysize(0)
      {
        DataSize[0] =  DataSize[1] = 1;
        DataSize[2] =  DataSize[3] = 4;
        DataSize[4] = 8;
      };
      
      databuffer(const databuffer &inBuffer) : _my_data(false)
      {
        Copy(inBuffer);
      };
      
      databuffer(void *buf,size_t number,size_t type) : _data_ptr(reinterpret_cast<char *>(buf)), 
                                                        _item_size(type), _my_data(false), 
                                                        _number_of_items(number)
      {//_mysize = _number_of_items * DataSize[_item_size];
        DataSize[0] =  DataSize[1] = 1;
        DataSize[2] =  DataSize[3] = 4;
        DataSize[4] = 8;
      };

      databuffer(size_t number,size_t type) : _data_ptr(NULL), _item_size(type),_my_data(false),
                                              _number_of_items(number) // , _mysize(0)
      {
        DataSize[0] =  DataSize[1] = 1;
        DataSize[2] =  DataSize[3] = 4;
        DataSize[4] = 8;
      };

      ~databuffer() { Destroy(); };

      bool Empty() 
      { 
        return(_number_of_items == 0); 
      };

      databuffer &operator=(const databuffer &inBuffer)
      {
        if(this != &inBuffer){
          Copy(inBuffer);
        }
        return(*this);
      };

      void Copy(const databuffer &inBuffer)
      {
        Destroy();
        _item_size = inBuffer._item_size;
        _my_data   = true;
        _number_of_items = inBuffer._number_of_items;
        size_t bufsize = _number_of_items*_item_size;
        _data_ptr = new char [bufsize];
        std::memcpy(_data_ptr,inBuffer._data_ptr,bufsize);
      };

      void Destroy()
      {
        if(_my_data && _data_ptr){
          if((_item_size > 1) || (_number_of_items > 1))
            delete [] _data_ptr;
          else
            delete _data_ptr;
        }
        _item_size = 1;
        _data_ptr = NULL;
        _number_of_items = 0;
        _my_data = false;
        //      _mysize = 0;
      };

      template<class T>
      T *Data() { return(reinterpret_cast<T *>(_data_ptr));};

      template<class T>
      const T *Data() const { return(reinterpret_cast<const T *>(_data_ptr)); };

      inline size_t ItemSize() const { return(_item_size); };

      inline size_t NItems() const { return(_number_of_items); };

      inline size_t &ItemSize() { return(_item_size); };

      inline size_t &NItems() { return(_number_of_items); };

      void CopyData(const void *buf, size_t start = 0,size_t nitems = 0)
      {
        if(!buf)
          return;
        if(!_data_ptr)
          return;
        if(nitems == 0)
          nitems = _number_of_items;
        size_t numData = nitems*_item_size;
        size_t realStart = start*_item_size;
        if(numData <= 0)
          return;
        if((realStart + numData) > _number_of_items*_item_size)
          return;
        std::memcpy(&(_data_ptr[realStart]),buf,numData);
        return;
      };

      void Set(void *buf = NULL,size_t nitems = 0,size_t itemsize = 0)
      {
        if(nitems <= 0)
          nitems = _number_of_items;
        if(itemsize <= 0)
          itemsize = _item_size;
        Destroy();
        _my_data = false;
        _data_ptr = reinterpret_cast<char *>(buf);
        _number_of_items = nitems;
        _item_size = itemsize;
        //      _mysize = _number_of_items * DataSize[_item_size];
      };

      int Allocate()
      {
        Destroy();
        size_t bufsize = _number_of_items * _item_size;
        if(bufsize > 0)
          _data_ptr = new char [bufsize];
        _my_data = true;
        return(bufsize);
      };

      int Allocate(size_t nitems)
      {
        Destroy();
        _number_of_items = nitems;
        size_t bufsize = _number_of_items * _item_size;
        if(bufsize > 0)
          _data_ptr = new char [bufsize];
        _my_data = true;
        return(bufsize);
      };
    
      int Allocate(size_t nitems,size_t isize)
      {
        Destroy();
        _number_of_items = nitems;
        _item_size = isize;
        size_t bufsize = _number_of_items * _item_size;
        if(bufsize > 0)
          _data_ptr = new char [bufsize];
        _my_data = true;
        return(bufsize);
      };

      size_t size() const
      {
        return(_data_ptr ? (_number_of_items * _item_size) : 0); 
      };

      size_t resize(size_t newsize)
      {
        size_t save_item_size = _item_size;
        size_t save_nitems = _number_of_items;
        Destroy();
        if(newsize > 0){
          if((newsize%save_item_size) == 0){
            _item_size = save_item_size;
            _number_of_items = (newsize/_item_size);
          }
          _data_ptr = new char [newsize];
          _my_data = true;
        }
        return(_number_of_items * _item_size);
      };

      const char *data() const { return(_data_ptr); };
      char *data() { return(_data_ptr); };
  
      template<class T>
      std::ostream &OutputToStream(std::ostream &Ostr) const
      {
        char delimiter;
        std::ostringstream OutStr;
        if(sizeof(T) != 1)
          delimiter = ' ';
        T *dataptr = (T *)_data_ptr;
        for(size_t i = 0;i < _number_of_items;i++){
          OutStr << *dataptr++;
          if(i != (_number_of_items - 1))
            OutStr << delimiter;
        }
        OutStr << std::endl;
        Ostr << OutStr.str();
        return(Ostr);
      };
  
      template<class T>
      std::istream &ReadFromStream(std::istream &Istr)
      {
        T *dataptr = (T *)_data_ptr;
        std::string line;
        std::getline(Istr,line);
        std::istringstream InStr(line);
        for(size_t i = 0;i < _number_of_items;i++)
          InStr >> *dataptr++;
        return(Istr);
      };
    };
  
  
  
    class metadata {
    
    public:

      friend std::istream &operator>>(std::istream &IStr,metadata &md);
      friend std::ostream &operator<<(std::ostream &OStr,const metadata &md);

    public:

      std::string name;
      std::string unit;
      char loc;
      unsigned int ncomp;
      unsigned int dsize;

      bool operator==(const metadata &inMeta) const
      {
        return((name == inMeta.name) && (unit == inMeta.unit) &&
               (loc == inMeta.loc) && (ncomp == inMeta.ncomp) &&
               (dsize == inMeta.dsize));
      }

      bool operator!=(const metadata &inMeta) const
      {
        return(!(operator==(inMeta)));
      }
      
    };

    class metadataset : public std::vector<metadata>
    {
    public:

      friend std::istream &operator>>(std::istream &IStr,metadataset &md);
      friend std::ostream &operator<<(std::ostream &OStr,const metadataset &md);

    public:

      metadataset &operator=(const metadataset &inMetaData)
      {
        Copy(inMetaData);
        return(*this);
      };

      void Append(const metadataset &inMetaData)
      {
        std::vector<metadata>::const_iterator imdIt = inMetaData.begin();
        while(imdIt != inMetaData.end())
          this->push_back(*imdIt++);
        return;
      };

      void Copy(const metadataset &inMetaData)
      {
        this->resize(0);
        std::vector<metadata>::const_iterator imdIt = inMetaData.begin();
        while(imdIt != inMetaData.end())
          this->push_back(*imdIt++);
        return;
      };
      
      void ReadFromStream(std::istream &InStr)
      {
        int num_vars;
        std::string line;
        while(line.empty())
          std::getline(InStr,line);
        std::istringstream Istr(line);
        Istr >> num_vars;
        this->resize(num_vars);
        int num = 0;
        while(num < num_vars){
          std::getline(InStr,line);
          std::istringstream IStr(line);
          IStr >> (*this)[num++];
        }
      };

      void WriteToStream(std::ostream &OutStr)
      {
        int num_vars = this->size();
        int num = 0;
        OutStr << num_vars << std::endl;
        while(num < num_vars)
          OutStr << (*this)[num++] << std::endl;
      };

      void AddField(const std::string &name,char loc,unsigned int ncomp,
                    unsigned int dsize,const std::string &unit)
      {
        metadata md;
        md.name = name;
        md.unit = unit;
        md.loc = loc;
        md.ncomp = ncomp;
        md.dsize = dsize;
        this->push_back(md);
      };

      void AddField(const std::string &name,metadata &inMeta)
      {
        metadata md(inMeta);
        md.name = name;
        this->push_back(md);
      };

      std::string Report() const
      {
        std::ostringstream Ostr;
        metadataset::const_iterator metaIt = this->begin();
        while(metaIt != this->end()){
          const metadata &rMeta(*metaIt++);
          Ostr << "___" << std::endl;
          Ostr << "Field Name: " << rMeta.name   << std::endl
               << "Unit:       " << (rMeta.unit.empty() ? std::string("unitless") :
                                     rMeta.unit) << std::endl
               << "Components: " << rMeta.ncomp  << std::endl
               << "Location:   " 
               << ((rMeta.loc == 's') ? "Simulation-global" :
                   (rMeta.loc == 'd') ? "Domain-global" :
                   (rMeta.loc == 'm' || rMeta.loc == 'm') ?
                   "Mesh/Grid-global" :
                   (rMeta.loc == 'c') ? "Grid cells" :
                   (rMeta.loc == 'n') ? "Grid nodes" :
                   "Unknown location")           << std::endl
               << "DataType:   " 
               << ((rMeta.dsize == 1) ? "Byte " :
                   (rMeta.dsize == 4) ? "Integer " :
                   (rMeta.dsize == 8) ? "Real " :
                   "Invalid ") << "data"         << std::endl;
        }
        Ostr << "___" << std::endl;
        return(Ostr.str());
      };
    };

    class dataset
    {

    public:

      typedef databuffer                  DataBufferType;
      typedef std::vector<DataBufferType> DataContainerType;
      typedef field::metadata             MetaDataType;
      typedef field::metadataset          MetaDataSetType;

    protected:
      DataContainerType    data;
      MetaDataSetType      meta;
      size_t               numNodes;
      size_t               numCells;
      std::vector<int>     fieldIndices;
      std::map<std::string,int> fieldHandles;
    public:
      size_t NumNodes() { return(numNodes); };
      size_t NumCells() { return(numCells); };
      metadataset &Meta() { return (meta); };
      const metadataset &Meta() const { return (meta); };
      DataContainerType &Data() { return (data); };
      const DataContainerType &Data() const { return (data); };
      size_t NumData() const { return(data.size()); };
      size_t NumMeta() const { return(meta.size()); };
      int InitializeFieldHandles()
      {
        metadataset::iterator mdi = meta.begin();
        int index = 0;
        while(mdi != meta.end()){
          std::string &fieldName(mdi++->name);
          fieldHandles[fieldName] = index++;
        }
        return(InitializeFieldIndices());
        //        return;
      };

      int InitializeFieldIndices()
      {
        fieldIndices.resize(0);
        fieldIndices.resize(fieldHandles.size(),-1);
        metadataset::iterator mdi = meta.begin();
        int index = 0;
        while(mdi != meta.end()){
          std::string &fieldName(mdi++->name);
          std::map<std::string,int>::iterator fieldHandleIt = 
            fieldHandles.find(fieldName);
          if(fieldHandleIt == fieldHandles.end())
            return(1);
          int fieldHandle = fieldHandleIt->second;
          fieldIndices[fieldHandle] = index++;
        }
        return(0);
      };
      
      int GetFieldHandle(const std::string &fieldName) const
      {
        std::map<std::string,int>::const_iterator fieldHandleIt = 
          fieldHandles.find(fieldName);
        if(fieldHandleIt == fieldHandles.end())
          return(-1);
        return(fieldHandleIt->second);
      };
      int GetFieldIndexByHandle(int fieldHandle) const {
        if(fieldHandle > fieldIndices.size())
          return(-1);
        return(fieldIndices[fieldHandle]);
      };
      void SetMetaData(const MetaDataSetType &dataDictionary)
      {
        Destroy();
        meta = dataDictionary;
      };
      virtual void Prepare()
      {
        if(!meta.empty()){
          if(data.empty()){
            //          std::cout << "Data was empty." << std::endl;
            data.resize(meta.size());
            return;
          } else {
            size_t numMeta = meta.size();
            size_t numData = data.size();
            if(numMeta == numData){
              return;
            } else if(numData > numMeta){
              data.resize(numMeta);
              return;
            } else {
              while(numMeta > numData){
                DataBufferType newData;
                data.push_back(newData);
                numData++;
              }
            }
          }
        }
        return;
      };
      virtual void Copy(const dataset &inData)
      {
        fieldHandles = inData.fieldHandles;
        numNodes = inData.numNodes;
        numCells = inData.numCells;
        meta = inData.meta;
        int numBuffers = inData.data.size();
        data.resize(numBuffers);
        for(int i = 0;i < numBuffers;i++)
          data[i].Copy(inData.data[i]);
        InitializeFieldIndices();
      };

      virtual void Copy(const dataset &inData,const std::string &fieldNames)
      {
        std::istringstream nameStream(fieldNames);
        std::string fieldName;
        std::vector<int> copyFieldIndices;
        while(nameStream >> fieldName){
          int fieldIndex = inData.GetDataIndex(fieldName);
          if(fieldIndex < 0){
            std::cerr << "pcpp::field::dataset::Copy:ERROR! Cannot find ("
                      << fieldName << ") in input state." << std::endl;
            return;
          }
          copyFieldIndices.push_back(fieldIndex);
        }
        Copy(inData,copyFieldIndices);
      };
      
      virtual void Copy(const dataset &inData,const std::vector<int> &copyFieldIndices)
      {
        fieldHandles = inData.fieldHandles;
        numNodes     = inData.numNodes;
        numCells     = inData.numCells;
        int numFields = copyFieldIndices.size();
        meta.resize(numFields);
        data.resize(numFields);
        int index = 0;
        std::vector<int>::const_iterator copyFieldIndexIt = copyFieldIndices.begin();
        while(copyFieldIndexIt != copyFieldIndices.end()){
          int copyFieldIndex = *copyFieldIndexIt++;
          meta[index] = inData.meta[copyFieldIndex];
          data[index].Copy(inData.data[copyFieldIndex]);
          index++;
        }
        InitializeFieldIndices();
      };
      virtual void Destroy(const std::string &fieldName)
      {
        int fieldIndex = GetFieldIndex(fieldName);
        if(fieldIndex >= 0){
          data[fieldIndex].Destroy();
        }
      };
      virtual void Destroy()
      {
        meta.resize(0);
        data.resize(0);
      };
      virtual size_t ReCreate()
      {
        if(meta.empty()) 
          return(0);
        if(numNodes == 0 &&
           numCells == 0)
          return(0);
        unsigned int numMeta = meta.size();
        unsigned int numData = data.size();
        if(numMeta > numData){
          size_t all_data_size = 0;
          databuffer mydata;
          data.push_back(mydata);
          databuffer &newData(data[numData]);
          while(numMeta > numData){
            metadata &metaData(meta[numData++]);
            size_t nitems = ((metaData.loc == 's' || metaData.loc == 'm' || 
                              metaData.loc == 'g' || metaData.loc == 'd') ? 1 :
                             metaData.loc == 'c' ? numCells :
                             metaData.loc == 'n' ? numNodes :
                             0);
            assert(nitems > 0);
            size_t total_size = nitems * metaData.dsize * metaData.ncomp;
            all_data_size += total_size;
            //            DataBufferType newData(nitems*metaData.ncomp,metaData.dsize);
            newData.Allocate(nitems*metaData.ncomp,metaData.dsize);
            //            data.push_back(newData);
            numData = data.size();
          }
          return(all_data_size);        
        } else if(numMeta < numData) {
          return(-1);
        }
        return(0);
      };

      virtual size_t Create(size_t number_of_nodes = 0,size_t number_of_cells = 0)
      {
        if(!((number_of_nodes == 0) && (number_of_cells == 0)) ||
           data.empty()){
          numNodes = number_of_nodes;
          numCells = number_of_cells;
          if(meta.empty())
            return(0);
          size_t all_data_size = 0;
          //      if(meta.empty())
          //        return(-1);
          //        assert(!meta.empty());
          
          data.resize(meta.size());
          metadataset::iterator mdi = meta.begin();
          size_t data_index = 0;
          while(mdi != meta.end()){
            // location can be:
            // (s)    - simulation global
            // (d)    - domain global
            // (m)(g) - mesh/grid global
            // (c)    - mesh/grid cells
            // (n)    - mesh/grid nodes
            size_t nitems = ((mdi->loc == 's' || mdi->loc == 'm' || 
                              mdi->loc == 'g' || mdi->loc == 'd') ? 1 :
                             mdi->loc == 'c' ? number_of_cells :
                             mdi->loc == 'n' ? number_of_nodes :
                             0);
            if(nitems == 0){
              std::cerr << "dataset::Create: Error, unknown location: " << mdi->loc << std::endl;
            }
            assert(nitems > 0);
            // Total size will be the number of components (i.e. scalar = 1, vector = 2,3, etc) times
            // the number of items (i.e. number of nodes, elements, etc) times the size of each item
            size_t total_size = nitems * mdi->dsize * mdi->ncomp;
            all_data_size += total_size;
            data[data_index++].Allocate(nitems*mdi->ncomp,mdi->dsize);
            //        assert(data[data_index-1].NItems() == nitems*mdi->ncomp);
            mdi++;
          }
          return(all_data_size);
        } else {
          return(ReCreate());
        }
        return(0);
      };
  

      int GetDataIndex(const std::string &name) const
      {
        metadataset::const_iterator mdi = meta.begin();
        int index = 0;
        while(mdi != meta.end()){
          if(mdi++->name == name)
            return(index);
          index++;
        }
        return(-1);
      };
  
      int GetFieldIndex(const std::string &name) const
      {
        return(GetDataIndex(name));
      };
  
      metadata &GetFieldMetaData(const std::string &name)
      {
        metadataset::iterator mdi = meta.begin();
        while(mdi != meta.end()){
          if(mdi->name == name)
            return(*mdi);
          mdi++;
        }
        bool invalid_field_name = false;
        assert(invalid_field_name);
        return(*mdi); // never get here
      };
  
      DataBufferType &GetFieldData(const std::string &name) 
      {
    
        int known_field = GetDataIndex(name);
        assert(known_field >= 0);
        return(data[known_field]);
      };
  
      DataBufferType &Field(const std::string &name) 
      {
    
        int known_field = GetDataIndex(name);
        assert(known_field >= 0);
        return(data[known_field]);
      };
  
      // Dangerous, but faster
      DataBufferType &Field(int known_field) 
      {
        return(data[known_field]);
      };
  
      const DataBufferType &Field(int known_field) const
      {
        return(data[known_field]);
      };

      DataBufferType &GetFieldDataByHandle(int fieldHandle) 
      {
        int known_field = GetFieldIndexByHandle(fieldHandle);
        assert(known_field >= 0);
        return(data[known_field]);
      };

      const DataBufferType &GetFieldDataByHandle(int fieldHandle) const
      {
        int known_field = GetFieldIndexByHandle(fieldHandle);
        assert(known_field >= 0);
        return(data[known_field]);
      };

      const DataBufferType &GetFieldData(const std::string &name) const
      {
        int known_field = GetDataIndex(name);
        assert(known_field >= 0);
        return(data[known_field]);
      };

      const DataBufferType &Field(const std::string &name) const
      {
        int known_field = GetDataIndex(name);
        assert(known_field >= 0);
        return(data[known_field]);
      };

      bool FieldEmpty(int known_field = 0)
      {
        return(data[known_field].Empty());
      };

      void SetFieldBuffer(const std::string &name,void *buf)
      {
        int known_field = GetDataIndex(name);
        assert(known_field >= 0);
        data[known_field].Set(buf);
      };
    
      // High danger
      void SetFieldBuffer(int known_field,void *buf)
      {
        data[known_field].Set(buf);
      };

      template<class BufferDataType>
      void SetFieldBuffer(const std::string &name,std::vector<BufferDataType> &invec)
      {
        size_t dsize = sizeof(BufferDataType);
        int known_field = GetDataIndex(name);
        assert(known_field >= 0);
        data[known_field].Set(&invec[0],invec.size(),dsize);
      };

      template<class BufferDataType>
      void SetFieldBuffer(int known_field,std::vector<BufferDataType> &invec)
      {
        size_t dsize = sizeof(BufferDataType);
        data[known_field].Set(&invec[0],invec.size(),dsize);
      };

      template<class BufferDataType>
      BufferDataType *GetFieldBuffer(const std::string &fieldName)
      {
        int known_field = GetDataIndex(fieldName);
        assert(known_field >= 0);
        return(data[known_field].Data<BufferDataType>());
      };

      template<class BufferDataType>
      BufferDataType *GetFieldBufferByHandle(int fieldHandle)
      {
        int known_field = GetFieldIndexByHandle(fieldHandle);
        assert(known_field >= 0);
        return(data[known_field].Data<BufferDataType>());
      };

      template<class BufferDataType>
      const BufferDataType *GetFieldBuffer(const std::string &fieldName) const
      {
        int known_field = GetDataIndex(fieldName);
        assert(known_field >= 0);
        return(data[known_field].Data<BufferDataType>());
      };
    
      template<class BufferDataType>
      const BufferDataType *GetFieldBufferByHandle(int fieldHandle)
      {
        int known_field = GetFieldIndexByHandle(fieldHandle);
        assert(known_field >= 0);
        return(data[known_field].Data<BufferDataType>());
      };

      template<class BufferDataType>
      BufferDataType *GetFieldBuffer(int known_field)
      {
        assert(known_field >= 0);
        return(data[known_field].Data<BufferDataType>());
      };
    

      double *GetRealFieldBuffer(int known_field)
      {
        assert(known_field >= 0);
        return(data[known_field].Data<double>());
      };

      double *GetRealFieldBufferByHandle(int fieldHandle)
      {
        int known_field = GetFieldIndexByHandle(fieldHandle);
        assert(known_field >= 0);
        return(data[known_field].Data<double>());
      };
      
      const double *GetRealFieldBuffer(int known_field) const
      {
        assert(known_field >= 0);
        return(data[known_field].Data<double>());
      };
      
      const double *GetRealFieldBufferByHandle(int fieldHandle) const
      {
        int known_field = GetFieldIndexByHandle(fieldHandle);
        assert(known_field >= 0);
        return(data[known_field].Data<double>());
      };
      
      
      const metadata &GetFieldMetaData(const std::string &name) const
      {
      
        metadataset::const_iterator mdi = meta.begin();
        while(mdi != meta.end()){
          if(mdi->name == name)
            return(*mdi);
          mdi++;
        }
        bool invalid_field_name = false;
        assert(invalid_field_name);
        return(*mdi); // never get here
      };

      const metadata &GetFieldMetaData(int fieldId) const
      {
        assert(fieldId < meta.size());
        return(meta[fieldId]);
      };

      const metadata &GetFieldMetaDataByHandle(int fieldHandle) const
      {
        MetaDataType returnMeta;
        int known_field = GetFieldIndexByHandle(fieldHandle);
        assert(known_field >= 0);
        return(meta[known_field]);
      };

      std::ostream &WriteFieldToStream(std::ostream &OutStream,const std::string &name) const
      {
        int known_field = GetDataIndex(name);
        assert(known_field >= 0);
        OutStream << data[known_field];
        // to endl or not to endl?
        //      OutStream << std::endl;
        return(OutStream);
      };

      std::istream &ReadFieldFromStream(std::istream &InStream,const std::string &name)
      {
        int known_field = GetDataIndex(name);
        assert(known_field >= 0);
        InStream >> data[known_field];
        return(InStream);
      };
    
      template<typename ValueType>
      void AssignFieldValue(const std::string &name,ValueType value)
      {
        int known_field = GetDataIndex(name);
        assert(known_field >= 0);
        ValueType *dataBuffer = data[known_field].Data<ValueType>();
        int numItems = data[known_field].NItems();
        for(int iItem = 0;iItem < numItems;iItem++)
          dataBuffer[iItem] = value;
      
      }
      void AddField(const std::string &name,char loc,unsigned int ncomp,
                    unsigned int dsize,const std::string &unit)
      {
        metadata md;
        md.name = name;
        md.unit = unit;
        md.loc = loc;
        md.ncomp = ncomp;
        md.dsize = dsize;
        meta.push_back(md);
      };

      void AddField(const std::string &name,metadata &inMeta)
      {
        metadata md(inMeta);
        md.name = name;
        meta.push_back(md);
      };

     
      int RenameField(int known_field,const std::string &newFieldName)
      {
        assert(known_field >= 0);
        metadata &md(meta[known_field]);
        md.name = newFieldName;
        return(0);
      };

      int RenameField(const std::string &fieldName,const std::string &newFieldName)
      {
        int srcIndex = GetFieldIndex(fieldName);
        if(srcIndex < 0)
          return(1);
        return(RenameField(srcIndex,newFieldName));
      };

      int MakeLink(int known_field,const std::string &newFieldName)
      {
        assert(known_field >= 0);
        int targetFieldId = data.size();
        AddField(newFieldName,meta[known_field]);
        Create();
        DataBufferType &srcFieldBuffer(data[known_field]);
        SetFieldBuffer(targetFieldId,srcFieldBuffer.data());
        return(0);
      };

      int Use(const std::string &fieldNames,dataset &inData)
      {
        if(numNodes > 0)
          assert(numNodes == inData.numNodes);
        else
          numNodes = inData.numNodes;
        if(numCells > 0)
          assert(numCells == inData.numCells);
        else
          numCells = inData.numCells;
        std::string fieldName;
        std::istringstream Istr(fieldNames);
        while(Istr >> fieldName){
          int srcFieldIndex = inData.GetFieldIndex(fieldName);
          assert(srcFieldIndex > 0);
          DataBufferType &srcFieldBuffer(inData.data[srcFieldIndex]);
          metadata &srcMeta(inData.meta[srcFieldIndex]);
          int trgFieldIndex(GetFieldIndex(fieldName));
          if(trgFieldIndex > 0){
            metadata &trgMeta(meta[trgFieldIndex]);
            assert(trgMeta == srcMeta);
            SetFieldBuffer(trgFieldIndex,srcFieldBuffer.data());
          } else {
            AddField(fieldName,srcMeta);
            DataBufferType dataBuffer(srcFieldBuffer);
            data.push_back(dataBuffer);
          }
        }
        return(0);
      }

      metadataset Dictionary(const char loc)
      {
        metadataset returnMeta;
        metadataset::iterator mdIt = meta.begin();
        while(mdIt != meta.end()){
          metadata &fieldMetaData(*mdIt++); 
          if(fieldMetaData.loc == loc)
            returnMeta.push_back(fieldMetaData);
        }
        return(returnMeta);
      }
      
    }; // class dataset

  }
}

  // Solution().Meta().AddField("time",'s',1,8,"s");
  // Solution().Meta().AddField("dt",'s',1,8,"s");
  // Solution().Meta().AddField("id",'m',1,4,"");
  // Solution().Meta().AddField("displacement",'n',3,8,"m");
  // Solution().Meta().AddField("pressure",'c',1,8,"Pa");
  // Solution().Meta().AddField("temperature",'n',1,8,"K");
  // Solution().Meta().AddField("nodeflags",'n',1,4,"");
  // Solution().Meta().AddField("cellflags",'c',1,4,"");
   
  // Solution().Create();

  // Solution().SetFieldBuffer("time",time);
  // Solution().SetFieldBuffer("dt",delta_time);
  // Solution().SetFieldBuffer("temperature",temperatures);
  // Solution().SetFieldBuffer("nodeflags",nodeflags);
  // Solution().SetFieldBuffer("cellflags",cellflags);
  // Solution().SetFieldBuffer("displacement",displacements);
  // Solution().SetFieldBuffer("pressure",pressures);
  // Solution().SetFieldBuffer("id",id);

#endif