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_;}

      const std::vector< std::vector<Position> >& getBackboneHBondPairs() 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

---