sdGenerator.h

Go to the documentation of this file.

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

#ifndef BALL_STRUCTURE_SDGENERATOR_H
#define BALL_STRUCTURE_SDGENERATOR_H

#ifndef BALL_DATATYPE_OPTIONS_H
# include <BALL/DATATYPE/options.h>
#endif

#ifndef BALL_STRUCTURE_RINGANALYSER_H
# include <BALL/STRUCTURE/ringAnalyser.h>
#endif

#ifndef BALL_KERNEL_PDBATOM_H
# include <BALL/KERNEL/PDBAtom.h>
#endif

#include <vector>
#include <queue>

namespace BALL
{
  class System;
  class Atom;

  class BALL_EXPORT SDGenerator
  {
    public:
    
      enum Property
      {
        FIRST_SDGENERATOR_PROPERTY = PDBAtom::NUMBER_OF_PROPERTIES+1,
        IN_RING,
        CORE_CHAIN,
        DEPOSITED,
        FXAS,
        EQAS,
        HEAD,
        EDGE,
        ASSEMBLED,
        ZIG,
        ZAG,
        INITIALIZED_HEAD_CFS,
        LAST_SDGENERATOR_PROPERTY
      };

      struct BALL_EXPORT Option
      { 
        static const char* SHOW_HYDROGENS;

        static const char* STANDARD_BOND_LENGTH;
      };

      struct BALL_EXPORT Default
      {
        static const bool SHOW_HYDROGENS;

        static const float STANDARD_BOND_LENGTH;
      };
      

      SDGenerator(bool show_hydrogens = false);

      virtual ~SDGenerator();

      Options options;

      void setDefaultOptions();

      void generateSD(System& molecule_sys);

      void clear();

    protected:
      
      class AtomComparator
      {
        public:
          bool operator() (Atom const* first, Atom const* second) const
          {
            Size first_value  =  first->getProperty("SDGenerator::PRIORITY").getUnsignedInt();
            Size second_value = second->getProperty("SDGenerator::PRIORITY").getUnsignedInt();

            return first_value < second_value;
          }
      };

      void prepare_();

      void constructRingSystem_(Position current_ring_system);

      // Obtain the CFS from the properties of the atom...
      Angle getCFS_(Atom const* atom, bool hi);

      // Convert a vector into the corresponding CFS angle
      Angle computeCFS_(Vector3 const& input);

      // store the CFS for an atom
      void setCFS_(Atom* atom, Angle cfs, bool high);

      // push the CFS before it is overwritten
      void pushCFS_(Atom* atom);

      // retrieve backup CVS values
      Angle getBackupCFS_(Atom const*, bool hi);

      //  Compute the CFS values for a full regular polygon
      void computeCoreCFS_(RingAnalyser::Ring& ring, bool clockwise);

      //
      Angle computeAngularSeparation_(Atom* seed);

      //
      Angle computeAngularDemand_(Atom* seed);

      //
      std::vector<Atom*> sequenceSubstituents_(Atom* seed);

      void computeShelleyPriorities_();

      void buildRegularPolygon_(RingAnalyser::Ring& ring, Position first_anchor_index, bool clockwise);

      void buildOpenPolygon_(RingAnalyser::Ring& ring, Position first_anchor_index, Position second_anchor_index);

      void attachCore_(Position current_ring, std::vector<RingAnalyser::Ring>& current_system, float x_start);

      void attachTemplate_(Position current_ring, std::vector<RingAnalyser::Ring>& current_system);

      void attachFused_(Position current_ring, std::vector<RingAnalyser::Ring>& current_system);

      void attachBridged_(Position current_ring, std::vector<RingAnalyser::Ring>& current_system);

      void attachSpiro_(Position current_ring, std::vector<RingAnalyser::Ring>& current_system);

      void computeAdjacencyMatrix_(std::vector<Atom*>& chain, std::vector<bool>& result);

      static bool compareChains_(const vector<Atom*>& x, const vector<Atom*>& y);

      void treatChains_();

      //
      void smoothCFSAngle_(Atom* seed);

      //
      void placeSubstituent_(Atom* seed, Atom* head, Atom* next);

      //
      void depositPFU_(Atom* seed_atom, Atom* next_neighbour);

      //
      void checkOverlap_(Atom* atom);

      //Check whether the ring is clockwise or not
      bool ringIsClockwise_(const RingAnalyser::Ring& ring, Index start_index = 0) const;

      void assembleSD_();

      // The backtracking for our Floyd-Warshall implementation
      void findFloydWarshallPath_(std::vector<int>& path, std::vector<Index>& next, Size remaining_atoms, Position i, Position j, std::list<Index>& output);

      RingAnalyser ring_analyser_;

      std::list<std::list<Atom*> > chains_;

      std::priority_queue<Atom*, std::vector<Atom*>, AtomComparator> redraw_queue_;

      System* system_;
  };

} // namepspace BALL

#endif