geometry/meshImport.hh

Go to the documentation of this file.

#ifndef meshImport_hh
#define meshImport_hh

#include <vector>
#include "mesh.hh"
#include "toolbox/array.hh"
#include "toolbox/multiArray.hh"
#include "basics/vectorsMatricesForward.hh"
#include "basics/debug.hh"

#define ImportMeshReadInts_D 0
#define ImportMeshReadLine_D 0

namespace concepts {

  // ************************************************************ ImportMesh **

  class ImportMesh {
  public:
    ImportMesh(const uint idxStart = 1) 
      : idxStart_(idxStart), Edg_(true), twoAttr_(true), threeAttr_(true),
  fourAttr_(true), sixAttr_(true), eightAttr_(true)  {}
    virtual ~ImportMesh();
  protected:    
    const uint idxStart_;

    std::vector<Vertex*> vtx_;
    std::vector<Connector1*> edg_;
    MultiArray<1, Vertex*> Vtx_; // map from vertex index in the file to Vertex
    MultiArray<2, Edge*> Edg_;   // map from vertex indices in the file to Edge

    MultiArray<1, Attribute> oneAttr_;
    MultiArray<2, Attribute> twoAttr_;
    MultiArray<3, Attribute> threeAttr_;
    MultiArray<4, Attribute> fourAttr_;
    MultiArray<6, Attribute> sixAttr_;
    MultiArray<8, Attribute> eightAttr_;

    virtual void createEntity_(const MultiIndex<1>& idx);
    virtual void createEntity_(const MultiIndex<2>& idx);
    virtual void createEntity_(const MultiIndex<3>& idx) 
      throw(concepts::MissingFeature);
    virtual void createEntity_(const MultiIndex<4>& idx) 
      throw(concepts::MissingFeature);
    virtual void createEntity_(const MultiIndex<6>& idx) 
      throw(concepts::MissingFeature);
    virtual void createEntity_(const MultiIndex<8>& idx) 
      throw(concepts::MissingFeature);

    virtual void createCell_(const MultiIndex<2>& idx)
      throw(concepts::MissingFeature);
    virtual void createCell_(const MultiIndex<3>& idx)
      throw(concepts::MissingFeature);
    virtual void createCell_(const MultiIndex<4>& idx)
      throw(concepts::MissingFeature);
    virtual void createCell_(const MultiIndex<6>& idx)
      throw(concepts::MissingFeature);
    virtual void createCell_(const MultiIndex<8>& idx)
      throw(concepts::MissingFeature);

    uint readInts_(const std::string& i, std::vector<int>& v) const;
    template<class F>
    uint readLine_(const std::string& i, Array<F>& a,
       bool first = false) const;

    void readCells_(const std::string& elms, const Array<bool>& dimensions,
        const std::vector<Real3d>& vertices);
    template<uint dim>
    void newCell_(MultiIndex<dim> i);
    
    void readAttributes_(const std::string& bound,
       const Array<bool>& dimensions);

    template<class T>
    void clear_(std::vector<T*>& field);
  };

  template<class F>
  uint ImportMesh::readLine_(const std::string& i, Array<F>& a, 
           bool first) const {
    std::istringstream input(i.c_str());
    F number = 0;
    DEBUGL(ImportMeshReadLine_D, number);
    std::vector<F> v;
    if (!first) input >> number;
    while (input >> number) {
      v.push_back(number);
      DEBUGL(ImportMeshReadLine_D, "inserted " << v.back());
    }
    a.resize(v.size());
    for(uint i = 0; i < a.size(); ++i) a[i] = v[i];
    DEBUGL(ImportMeshReadLine_D, "array = " << a);
    return a.size();
  }

  template<class T>
  void ImportMesh::clear_(std::vector<T*>& field) {
    for (typename std::vector<T*>::iterator i = field.begin();
   i != field.end(); ++i) {
      delete *i; *i = 0;
    }
  }
  
  template<class T>
  std::ostream& operator<<(std::ostream& os, const std::vector<T*>& field) {
    uint j=0;
    for (typename std::vector<T*>::const_iterator i = field.begin();
   i != field.end(); ++j) {
      if (i != field.begin()) os << ", ";
      T* val = *i++;
      os << '(' << j << ',';
      if (val) os << *val; else os << '0';
      os << ')';
    }
    return os;
  }

} // namespace concepts

#endif // meshImport_hh