constraints.h

Go to the documentation of this file.

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

#ifndef BALL_DOCKING_COMMON_CONSTRAINTS
#define BALL_DOCKING_COMMON_CONSTRAINTS


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

#ifndef BALL_MATHS_MATRIX44_H
#include <BALL/MATHS/matrix44.h>
#endif

#ifndef BALL_MATHS_PLANE3_H
#include <BALL/MATHS/plane3.h>
#endif

#ifndef BALL_KERNEL_SYSTEM_H
#include <BALL/KERNEL/system.h>
#endif

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


namespace BALL
{
  class DockingAlgorithm;

  namespace VIEW
  {
    class DockRLDialog;
  }

  class ScoringFunction;

  class BALL_EXPORT Constraint
  {
    public:
      Constraint();

      virtual ~Constraint();

      virtual double calculateScore(AtomContainer* mol) = 0;

      virtual void setName(String name);

      String getName();

      String getType();

      virtual void setScoringFunction(ScoringFunction* sf);

    protected:
      String name_;

      String type_;

      double penalty_;
      ScoringFunction* scoring_function_;
  };

  class BALL_EXPORT ReferenceArea
    : public Constraint
  {
    public:
      ReferenceArea();

      ~ReferenceArea();
      ReferenceArea(Vector3& p1, Vector3& p2,  Vector3& p3, Vector3& p4, bool atom_fraction, double atoms, double penalty);

      ReferenceArea(Vector3& p1, Vector3& p2, int y_expansion, int z_expansion, bool atom_fraction, double atoms, double penalty);

      ReferenceArea(const AtomContainer* sys, bool atom_fraction, double atoms, double penalty);

      ReferenceArea(list<const AtomContainer*>& container_list, const list<String>& interaction_types, double desired_interaction_score, double penalt);

      double calculateScore(AtomContainer* mol);

      double getContainedAtoms();

      System* createBoundaryMolecule();

      void enlarge(double angstroem);

      void setNumberDesiredAtoms(double d);

      void setName(String name);

      void setScoringFunction(ScoringFunction* sf);

    private:
      double countContainedAtoms(AtomContainer* sys);

      Matrix4x4 T_;

      double min_x_, max_x_, min_y_, max_y_, min_z_, max_z_;

      double ref_atoms_;

      bool atom_fraction_;

      double contained_atoms_;

      vector<Vector3> input_points_;

      Size number_reflig_atoms_;

      bool scale_by_size_;

      friend class BALL::DockingAlgorithm;
      friend class BALL::VIEW::DockRLDialog;
  };

  class BALL_EXPORT PharmacophoreConstraint
    : public Constraint
  {
    public:
      PharmacophoreConstraint(list<const AtomContainer*>& container_list, const list<String>& interaction_types, double desired_interaction_score, double penalty);

      PharmacophoreConstraint(const AtomContainer* container, const list<String>& interaction_types, double desired_interaction_score, double penalty);

      PharmacophoreConstraint(const PharmacophoreConstraint& phC);

      ~PharmacophoreConstraint();

      PharmacophoreConstraint(vector<String>& residue_IDs, const list<String>& interaction_types, double desired_interaction_score, double penalty);

      void setScoringFunction(ScoringFunction* sf);

      double calculateScore(AtomContainer* mol);

      double getInteractionScore();

      bool usesReceptorResidues();

      AtomContainer* getGridContainer();

      const list<String>* getInteractionTypes();

      const list<const AtomContainer*>* getInteractionPartners();

    private:
      vector<String> residue_IDs_;
      vector<String> chain_IDs_;

      list<const AtomContainer*> interaction_partners_;
      list<String> interaction_types_;
      double desired_interaction_score_;
      double interaction_score_;
      bool uses_receptor_residues_;

      AtomContainer grid_container_;

      unsigned int gridSetID_;

      friend class BALL::DockingAlgorithm;
      friend class BALL::VIEW::DockRLDialog;
  };
}

#endif // BALL_DOCKING_COMMON_CONSTRAINTS