GeometryReader.h

Go to the documentation of this file.

//                                                         //
// Copyright (c) 2003-2014 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.opensource.org/licenses/osl-3.0.php          //
//                                                         //


#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