ringAnalyser.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_STRUCTURE_RINGANALYSER_H
#define BALL_STRUCTURE_RINGANALYSER_H

#ifndef BALL_COMMON_GLOBAL_H
# include <BALL/common.h>
#endif

#ifndef BALL_KERNEL_ATOMCONTAINER_H
# include <BALL/KERNEL/atomContainer.h>
#endif

#ifndef BALL_CONCEPT_PROCESSOR_H
# include <BALL/CONCEPT/processor.h>
#endif

#ifndef BALL_CONCEPT_PROPERTY_H
# include <BALL/CONCEPT/property.h>
#endif

#include <vector>
#include <set>
#include <deque>

namespace BALL
{
  class Atom;
  class Bond;

  class BALL_EXPORT RingAnalyser
    : public UnaryProcessor<AtomContainer>
  {
    public:

      enum RingType 
      {
        NONE,
        TEMPLATE,
        FUSED,
        BRIDGED,
        SPIRO,
        CORE
      };

      class BALL_EXPORT Ring
        : public PropertyManager
      {
        public:
          Ring();

          Ring(std::vector<Atom*> const& atoms_);

          Position predecessor(Position i) const;

          Position successor(Position i) const;

          std::vector<Atom*> atoms;

          RingType type;

          std::set<Bond const*> shared_bonds;
      };


      RingAnalyser();

      virtual ~RingAnalyser();


      virtual bool start();
  
      virtual Processor::Result operator ()(AtomContainer& ac);

      virtual bool finish();


      void clear();

      bool isInRing(const Atom* atom, std::vector<Atom*> const& ring) const;

      bool isInRingSystem(const Atom* atom, Index i) const;

      void sequenceRing(std::vector<Atom*>& ring);

      Size getNumberOfRingSystems();

      std::vector<Ring> getRingSystem(Position i);

      std::vector<Position> getPeelingOrder(Position i);

    protected:

      void clusterRings_();

      void findSharedBonds_();

      void peelRings_();

      bool isCentralRing_(std::list<Position>::iterator ring, std::list<Position>& unassigned_rings);

      bool peelNextRing_(std::list<Position>& unassigned_rings, bool peel_fused = false);

      bool assignRTD_(std::list<Position>& trial_system);

      std::vector<Ring> rings_;

      std::vector<std::vector<Position> > ring_systems_;

      HashMap<Bond const*, std::deque<Position> > rings_per_bond_;

      std::vector<std::vector<Position> > peeling_order_;
  };

} // namespace BALL

#endif // BALL_STRUCTURE_RINGANALYSER_H