GeometryReader.h

Go to the documentation of this file.

//                                                         //
// Copyright (c) 2003-2017 by The University of Queensland //
// Centre for Geoscience Computing                         //
// http://earth.uq.edu.au/centre-geoscience-computing      //
//                                                         //
// Primary Business: Brisbane, Queensland, Australia       //
// Licensed under the Open Software License version 3.0    //
// http://www.apache.org/licenses/LICENSE-2.0              //
//                                                         //
 
 
#ifndef ESYS_LSMGEOMETRYREADER_H
#define ESYS_LSMGEOMETRYREADER_H
 
#include "Foundation/vec3.h"
#include "Parallel/IterativeReader.h"
#include "Geometry/GeometryInfo.h"
#include "Geometry/SimpleParticleData.h"
 
#include <string>
#include <vector>
#include <iostream>
 
typedef std::vector<bool> BoolVector;
typedef std::vector<int>  IntVector;
typedef std::vector<Vec3> Vec3Vector;
 
namespace esys
{
  namespace lsm
  {
    class ParticleIterator : public IStreamIterator<SimpleParticleData>
    {
    public:
      typedef IStreamIterator<SimpleParticleData>::value_type value_type;
 
      ParticleIterator(std::istream &iStream, int numElements, bool is2d = true)
        : IStreamIterator<SimpleParticleData>(iStream, numElements),
          m_is2d(is2d)
      {
      }
 
    protected:
      virtual void readDataFromStream()
      {
        IStreamIterator<SimpleParticleData>::readDataFromStream();
 
        double mass = M_PI*m_data.getRadius() * m_data.getRadius();
        if (!m_is2d)
        {
          mass *= (4.0/3.0)*m_data.getRadius();
        }
        m_data.setMass(mass);
      }
 
    private:
      bool m_is2d;
    };
    
    class ParticleReader : public IterativeReader<ParticleIterator>
    {
    public:
      ParticleReader(std::istream &iStream, bool is2d);
 
      virtual void initialise();
      
      const std::string &getParticleType();
      
    protected:
      virtual ParticleIterator *createNewIterator();
 
    private:
      std::string m_particleType;
      bool        m_is2d;
    };
 
    class SimpleConnectionData
    {
    public:
      typedef SimpleParticleData::Id  Id;
      typedef SimpleParticleData::Tag Tag;
 
      SimpleConnectionData();
 
      SimpleConnectionData(Id p1Id, Id p2Id, Tag tag);
 
      bool operator==(const SimpleConnectionData &particleData) const;
 
      const Id &getP1Id() const;
      
      const Id &getP2Id() const;
 
      const Tag &getTag() const;
 
      void read(std::istream &istream);
 
      void write(std::ostream &write) const;
 
    private:
      Id  m_particle1Id;
      Id  m_particle2Id;
      Tag m_tag;
    };
 
    std::istream &operator>>(std::istream &iStream, SimpleConnectionData &connectionData);
    std::ostream &operator<<(std::ostream &oStream, const SimpleConnectionData &connectionData);
 
    class ConnectionReader : public IterativeReader<IStreamIterator<SimpleConnectionData> >
    {
    public:
      ConnectionReader(std::istream &iStream);
 
      virtual void initialise();
 
    private:
    };
 
    class GeometryReader
    {
    public:
      typedef ParticleReader::Iterator   ParticleIterator;
      typedef ConnectionReader::Iterator ConnectionIterator;
      GeometryReader(const std::string &fileName);
 
      GeometryReader(std::istream &iStream);
 
      virtual ~GeometryReader();
 
      const std::string &getFileName() const;
 
      const std::string &getParticleType();
 
      const GeometryInfo &getGeometryInfo() const;
      
      ParticleIterator &getParticleIterator();
 
      ConnectionIterator &getConnectionIterator();
 
    protected:
      void initialise();
 
    private:
      GeometryReader(const GeometryReader &geoReader);
      GeometryReader &operator=(const GeometryReader &geoReader) const;
 
      class Impl;
 
      Impl *m_pImpl;
    };
  } // namespace lsm
} // namespace esys
 
#endif