bindingPocketProcessor.h

Go to the documentation of this file.

#ifndef BALL_STRUCTURE_PASSPROCESSOR_H
#define BALL_STRUCTURE_PASSPROCESSOR_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_KERNEL_SYSTEM_H
# include <BALL/KERNEL/system.h>
#endif

#ifndef BALL_DATATYPE_HASHGRID_H
# include <BALL/DATATYPE/hashGrid.h>
#endif

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

#include <vector>
#include <string>

#include <fstream>

namespace BALL
{

  class BALL_EXPORT BindingPocketProcessor 
    : public UnaryProcessor<Composite>
  {
  
  public:
    
    struct Option
    {
      static const String HEAVY_ONLY;
      static const String PARSE_INI_FILE;
      static const String INI_FILE_NAME;
 
      static const String RADIUS_HYDROGEN;
      static const String RADIUS_OXYGEN;
      static const String RADIUS_NITROGEN;
      static const String RADIUS_CARBON;
      static const String RADIUS_SULFUR;

      static const String PROBE_SPHERE_RADIUS;
      static const String PROBE_SPHERE_RADIUS_HYDROGEN_FREE;
      static const String PROBE_LAYER_RADIUS;
      static const String BURIAL_COUNT_THRESHOLD;
      static const String BURIAL_COUNT_THRESHOLD_HYDROGEN_FREE;
      static const String BURIAL_COUNT_RADIUS;
      static const String PW_SQUARE_WELL;
      static const String PW_GAUSSIAN_WIDTH;
      static const String PW_MAX_DISTANCE;
      static const String MAX_ASPS;
      // additional factor for the computation of the collision of two spheres 
      static const String CLASH_FACTOR;
      static const String ASP_SEPERATION;
    };
    
    struct Default
    {
      static const bool HEAVY_ONLY;
      static const bool PARSE_INI_FILE;
      static const String INI_FILE_NAME;

      static const double RADIUS_HYDROGEN;
      static const double RADIUS_OXYGEN;
      static const double RADIUS_NITROGEN;
      static const double RADIUS_CARBON;
      static const double RADIUS_SULFUR;
      
      static const double PROBE_SPHERE_RADIUS;
      static const double PROBE_SPHERE_RADIUS_HYDROGEN_FREE;
      static const double PROBE_LAYER_RADIUS;         
      static const Position BURIAL_COUNT_THRESHOLD;
      static const Position BURIAL_COUNT_THRESHOLD_HYDROGEN_FREE;      
      static const double BURIAL_COUNT_RADIUS;
      static const double PW_SQUARE_WELL;
      static const double PW_GAUSSIAN_WIDTH;
      static const double PW_MAX_DISTANCE;
      static const Position MAX_ASPS;
      static const double CLASH_FACTOR;
      static const double ASP_SEPERATION;
    };
    
    BindingPocketProcessor();
    
    BindingPocketProcessor(Options& new_options);   
    
    BindingPocketProcessor(const BindingPocketProcessor& pp);

    virtual ~BindingPocketProcessor();

    const BindingPocketProcessor& operator=(const BindingPocketProcessor& pp);
   
    virtual bool finish();

    virtual Processor::Result operator() (Composite &composite);

    const vector<std::pair<Vector3,double> >& getActiveSitePoints() const;
    
    const vector<vector<std::pair<Vector3,double> > >& getLayers() const;

    Options options;

  private:
    
    class Sphere_
    {
    public:
      Sphere_();
      
      BALL::Vector3 position;
      
      float radius;
      
      Position b_count;
      
      float probe_weight; 
      
      Position layer;
      
      inline bool operator<(const Sphere_& sp) const {return probe_weight > sp.probe_weight;};
      
      int id;
      static int global_id; 
      Position a,b,c,d;
      
      inline bool operator==(const Sphere_& sp) const {return a == sp.a && b == sp.b && c == sp.c && d == sp.d;};
    };  
    
    class SphereComparator_
    {
      public:
        int operator()(const Sphere_& sp1, const Sphere_& sp2) const
        {
          if (sp1.a != sp2.a)
            return sp1.a < sp2.a;
          if (sp1.b != sp2.b)
            return sp1.b < sp2.b;
          if (sp1.c != sp2.c)
            return sp1.c < sp2.c;
          if (sp1.d != sp2.d)
            return sp1.d < sp2.d;
          return 0;
        };
    };
    
    Position layer_;
    
    friend std::ostream& operator<<(std::ostream& os, const BindingPocketProcessor::Sphere_& sp) {return os;};
    
    HashGrid3<Sphere_> sphere_grid_;
    
    HashGrid3<Sphere_> protein_grid_;
    
    HashGrid3<Sphere_> layer_grid_;
    
    HashGrid3<Sphere_> clayer_grid_;
    
    HashGrid3<Sphere_> BC_grid_;  
    
    HashGrid3<Sphere_> pw_grid_;  

    HashGrid3<Sphere_> candidates_grid_;
    
    std::vector<Sphere_> sorted_spheres_;
    
    double sphere_rad_;
    
    double second_layer_rad_;
    
    double protein_clash_rad_;
    
    double BC_threshold_;
    
    Position found_new_;
    
    double c_factor_;
    
    std::vector<Sphere_> candidates;
  
    std::vector<std::pair<Vector3,double> >  asps_;
 
    std::vector<std::vector<std::pair<Vector3,double> > > layers_; 
  
    double radius_(const String& element);
    
    void trySphere__(HashGridBox3<Sphere_>::DataIterator data_it, 
        HashGridBox3<Sphere_>::DataIterator data_it2, 
        HashGridBox3<Sphere_>::DataIterator data_it3);
    
    void addSphere_s_();
    
    Vector3 calculateT_(HashGridBox3<Sphere_>::DataIterator data_it, 
      HashGridBox3<Sphere_>::DataIterator data_it2);
    
    void testFirst_(HashGrid3<Sphere_>& hg,HashGridBox3<Sphere_>::DataIterator data_it,
        Position x, Position y, Position z);
    
    void testSecond_(HashGrid3<Sphere_>& hg,HashGridBox3<Sphere_>::DataIterator data_it,
         HashGridBox3<Sphere_>::DataIterator data_it2,
         Position x, Position y, Position z,Position step);
    
    bool testSphereClash_(Vector3& v);
    
    bool testProteinClash_(Vector3& v);
    
    bool testBC_(Sphere_& sp);
    
    void weedCandidates_();
    
    bool parse_();
    
    
    bool second_it_;
    
  };   
  
} //namesspace BALL

#endif // BALL_STRUCTURE_BALLProcessor_H