HBondProcessor.h

Go to the documentation of this file.

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

#ifndef BALL_STRUCTURE_HBONDPROCESSOR_H
#define BALL_STRUCTURE_HBONDPROCESSOR_H

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

#ifndef BALL_KERNEL_RESIDUE_H
#include <BALL/KERNEL/residue.h>
#endif

#ifndef BALL_MATHS_VECTOR3_H
#include <BALL/MATHS/vector3.h>
#endif

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

#include <vector>
#include <map>

namespace BALL
{
  class BALL_EXPORT HBondProcessor
    : public UnaryProcessor<Composite>
  {

    public:


      class BALL_EXPORT HBond
      {
        public:
          HBond();
          HBond(Atom const* acceptor, Atom const* donor, bool donor_is_hydrogen=false)
                {acceptor_ = acceptor; donor_ = donor; donor_is_hydrogen_ = donor_is_hydrogen;}
          Atom const* getAcceptor() { return acceptor_; }
          Atom const* getDonor()    { return donor_; }

          bool donorIsHydrogen()    { return donor_is_hydrogen_; }

          float getLength() { return acceptor_->getDistance(*donor_); }

          // TODO: getAngle()? This is tricky as the DSSP works with implicit hydrogen positions

        protected:
          Atom const* acceptor_;
          Atom const* donor_;
          bool        donor_is_hydrogen_;
      };

      struct BALL_EXPORT Option
      {
        static const String PREDICTION_METHOD;

        static const String ADD_HBONDS;

        static const String KABSCH_SANDER_ENERGY_CUTOFF;
      };

      struct BALL_EXPORT Default
      {
        static const String PREDICTION_METHOD;
        static const bool ADD_HBONDS;
        static const float KABSCH_SANDER_ENERGY_CUTOFF;
      };

      struct BALL_EXPORT PredictionMethod
      {
        static const String KABSCH_SANDER;
        static const String WISHART_ET_AL;
      };

      // constants for Kabsch Sander
      // 5.2 Angstrom is the maximum distance between N and O in a hydrogen bond.
      // 4.2 Angstrom is an upper bound for the distance between N and O in the same
      // residue. Therefore, if two residues are farther apart than MAX_LENGTH, N and O
      // are farther apart than 5.2 Angstroms and there will be no hydrogen bond.
      static float MAX_LENGTH;
      static float BOND_LENGTH_N_H;
      static float BOND_LENGTH_C_O;

      // constants for Wishard et al
      static float AMIDE_PROTON_OXYGEN_SEPARATION_DISTANCE; // = 3.5;
      static float ALPHA_PROTON_OXYGEN_SEPARATION_DISTANCE; // = 2.77208;

      struct BALL_EXPORT ResidueData
      {
        Vector3  pos_C;
        Vector3  pos_N;
        Vector3  pos_H;
        Vector3  pos_O;
        Size     number;
        Residue* res;
        bool is_complete;
      };

      BALL_CREATE(HBondProcessor);


      HBondProcessor();

      HBondProcessor(Options& new_options);

      virtual ~HBondProcessor();




      virtual void init();

      virtual bool start();

      //                            computes the theoretical position of H
      //                            and stores the residue information in residue_data_
      //                            
      virtual Processor::Result operator() (Composite &composite);

      // to the chosen method <tt> PredictionMethod</tt>.
      virtual bool finish();



      const std::vector< HBond>& getHBonds() const {return h_bonds_;}

      std::vector< HBond> getHBonds() {return h_bonds_;}

      BALL_DEPRECATED const std::vector< std::vector<Position> >& getBackboneHBondPairs() const;

      const std::vector< std::vector<Position> >& getBackboneHBondPattern() const;

      const std::vector<ResidueData>& getResidueData() const;


      Options options;

      void setDefaultOptions();

    protected:

      void preComputeBonds_(ResidueIterator& data);
      bool finishKabschSander_();
      bool finishWishartEtAl_();



      //_ lower point of the grid
      Vector3         upper_;
      //_ upper point of the grid
      Vector3         lower_;

      //_ the atom positions and an accending number per residue 
      std::vector<ResidueData>            residue_data_;

      //_ the backbone hydrogen bonds for the secondary structure processor
      std::vector<std::vector<Position> > backbone_h_bond_pairs_;




      /*_ list of __ShiftX__ HBond donors collected by <tt>operator ()</tt>
       */
      std::vector<Atom*>             donors_;

      /*_ list of HBond acceptors collected by <tt>operator ()</tt>
       */
      std::vector<Atom*>             acceptors_;

      std::map< Residue*, Position>  residue_ptr_to_position_;


      std::vector<HBond>        h_bonds_;

  }; //class HBondProcessor
} //namesspace BALL


#endif // BALL_STRUCTURE_HBONDPROCESSOR_H