numericalSAS.h

Go to the documentation of this file.

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

#ifndef BALL_STRUCTURE_NUMERICALSAS_H
#define BALL_STRUCTURE_NUMERICALSAS_H

#ifndef BALL_COMMON_H
# include <BALL/common.h>
#endif

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

#ifndef BALL_MATHS_SURFACE_H
# include <BALL/MATHS/surface.h>
#endif

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

namespace BALL 
{
  class Atom;
  class AtomContainer;
  template <typename Key, typename T>
  class HashMap;
  class TriangulatedSphere;

  class BALL_EXPORT NumericalSAS
  {
    public:

      struct BALL_EXPORT Option
      {
        static const String COMPUTE_AREA;

        static const String COMPUTE_VOLUME;

        static const String COMPUTE_SURFACE;

        static const String COMPUTE_SURFACE_PER_ATOM;

        static const String COMPUTE_SURFACE_MAP;

        static const String NUMBER_OF_POINTS;

        static const String PROBE_RADIUS;
      };

      struct BALL_EXPORT Default
      {
        static const bool COMPUTE_AREA;

        static const bool COMPUTE_VOLUME;

        static const bool COMPUTE_SURFACE;

        static const bool COMPUTE_SURFACE_PER_ATOM;

        static const bool COMPUTE_SURFACE_MAP;

        static const Size NUMBER_OF_POINTS;

        static const float PROBE_RADIUS;
      };



      BALL_CREATE(NumericalSAS)

      
      NumericalSAS();

      NumericalSAS(const Options& options);

      ~NumericalSAS();
      

      void operator() (const AtomContainer& fragment);

      float getTotalArea() {return total_area_;}

      HashMap<const Atom*, float>& getAtomAreas() {return atom_areas_;}

      const HashMap<const Atom*, float>& getAtomAreas() const {return atom_areas_;}

      float getTotalVolume() {return total_volume_;}

      HashMap<const Atom*, float>& getAtomVolumes() {return atom_volumes_;}

      const HashMap<const Atom*, float>& getAtomVolumes() const {return atom_volumes_;}

      Surface& getSurface() {return surface_;}

      const Surface& getSurface() const {return surface_;}

      HashMap<const Atom*, Surface>& getSurfacePerAtom() {return atom_surfaces_;}

      const HashMap<const Atom*, Surface>& getSurfacePerAtom() const {return atom_surfaces_;}

      std::vector< std::pair<Vector3, Surface> >& getSurfaceMap() {return atom_surface_map_;}

      const std::vector< std::pair<Vector3, Surface> >& getSurfaceMap() const {return atom_surface_map_;}
      

      Options options;

    protected:
      void setDefaultOptions_();

      Size computeSphereTesselation_(TriangulatedSphere& result, int num_points);

      AtomContainer const* fragment_;

      HashMap<Atom const*, float> atom_areas_;

      float total_area_;

      HashMap<Atom const*, float> atom_volumes_;

      float total_volume_;

      Surface surface_;

      HashMap<Atom const*, Surface> atom_surfaces_;

      std::vector< std::pair<Vector3, Surface> > atom_surface_map_;
  };

  BALL_EXPORT BALL_DEPRECATED 
  float calculateSASArea(const AtomContainer& fragment, float probe_radius = 1.5,
                         Size number_of_dots = 400); 

  BALL_EXPORT BALL_DEPRECATED
  float calculateSASVolume(const AtomContainer& fragment, float probe_radius = 1.5,
                           Size number_of_dots = 400); 

  BALL_EXPORT BALL_DEPRECATED
  float calculateSASAtomAreas(const AtomContainer& fragment, HashMap<const Atom*,float>& atom_areas,
                              float probe_radius = 1.5, Size number_of_dots = 400);
  
  BALL_EXPORT BALL_DEPRECATED
  float calculateSASPoints(const AtomContainer& fragment, Surface& surface_points,
                           float probe_radius = 1.5,  Size number_of_dots = 400);

  BALL_EXPORT BALL_DEPRECATED
  float calculateSASAtomPoints(const AtomContainer& fragment, 
                               std::vector< std::pair<Vector3, Surface> >& atom_surfaces,
                               float probe_radius = 1.5,  Size number_of_dots = 400);
} // namespace BALL

#endif // BALL_STRUCTURE_NUMERICALSAS_H