surfaceDescriptors.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
//
 
#ifndef BALL_QSAR_SURFACEDESCRIPTORS_H
#define BALL_QSAR_SURFACEDESCRIPTORS_H
 
#ifndef BALL_QSAR_SURFACEBASE_H
# include <BALL/QSAR/surfaceBase.h>
#endif
 
namespace BALL
{
  // 15 surface descriptors 

  class BALL_EXPORT PositiveVdWSurface
    : public SurfaceBase
  {
    public:
 
    BALL_CREATE(PositiveVdWSurface);
    

    PositiveVdWSurface();

    PositiveVdWSurface(const PositiveVdWSurface& ps);
    
    virtual ~PositiveVdWSurface();


    PositiveVdWSurface& operator = (const PositiveVdWSurface& ps);
  };

  class BALL_EXPORT NegativeVdWSurface
    : public SurfaceBase
  {
    public:
 
    BALL_CREATE(NegativeVdWSurface)
 
    

    NegativeVdWSurface();

    NegativeVdWSurface(const NegativeVdWSurface& ns);

    virtual ~NegativeVdWSurface();


    NegativeVdWSurface& operator = (const NegativeVdWSurface& ns);
  };

  class BALL_EXPORT PositivePolarVdWSurface
    : public SurfaceBase
  {
    public:
 
    BALL_CREATE(PositivePolarVdWSurface)
 
    

    PositivePolarVdWSurface();

    PositivePolarVdWSurface(const PositivePolarVdWSurface& pps);

    virtual ~PositivePolarVdWSurface();


    PositivePolarVdWSurface& operator = (const PositivePolarVdWSurface& pps);
  };

  class BALL_EXPORT NegativePolarVdWSurface
    : public SurfaceBase
  {
    public:
 
    BALL_CREATE(NegativePolarVdWSurface)
 
    

    NegativePolarVdWSurface();

    NegativePolarVdWSurface(const NegativePolarVdWSurface& nps);
    
    virtual ~NegativePolarVdWSurface();


    NegativePolarVdWSurface& operator = (const NegativePolarVdWSurface& nps);
  };

  class BALL_EXPORT HydrophobicVdWSurface
    : public SurfaceBase
  {
    public:
 
    BALL_CREATE(HydrophobicVdWSurface)
 
    

    HydrophobicVdWSurface();

    HydrophobicVdWSurface(const HydrophobicVdWSurface& hs);

    virtual ~HydrophobicVdWSurface();


    HydrophobicVdWSurface& operator = (const HydrophobicVdWSurface& hs);
  };

  class BALL_EXPORT PolarVdWSurface
    : public SurfaceBase
  {
    public:
 
    BALL_CREATE(PolarVdWSurface)
 
    

    PolarVdWSurface();

    PolarVdWSurface(const PolarVdWSurface& ps);
    
    virtual ~PolarVdWSurface();


    PolarVdWSurface& operator = (const PolarVdWSurface& ps);
  };

  class BALL_EXPORT RelPositiveVdWSurface
    : public SurfaceBase
  {
    public:
 
    BALL_CREATE(RelPositiveVdWSurface)
 
    

    RelPositiveVdWSurface();
    
    RelPositiveVdWSurface(const RelPositiveVdWSurface& rps);
    
    virtual ~RelPositiveVdWSurface();


    RelPositiveVdWSurface& operator = (const RelPositiveVdWSurface& rps);
    
    double compute(AtomContainer& ac);
  };

  class BALL_EXPORT RelNegativeVdWSurface
    : public SurfaceBase
  {
    public:
 
    BALL_CREATE(RelNegativeVdWSurface)
 
    
    
    RelNegativeVdWSurface();

    RelNegativeVdWSurface(const RelNegativeVdWSurface& rns);
    
    virtual ~RelNegativeVdWSurface();
    //q}


    RelNegativeVdWSurface& operator = (const RelNegativeVdWSurface& rns);

    double compute(AtomContainer& ac);
  };

  class BALL_EXPORT RelPositivePolarVdWSurface
    : public SurfaceBase
  {
    public:
 
    BALL_CREATE(RelPositivePolarVdWSurface)
 
    

    RelPositivePolarVdWSurface();

    RelPositivePolarVdWSurface(const RelPositivePolarVdWSurface& rpps);

    virtual ~RelPositivePolarVdWSurface();


    RelPositivePolarVdWSurface& operator = (const RelPositivePolarVdWSurface& rpps);

    double compute(AtomContainer& ac);
  };

  class BALL_EXPORT RelNegativePolarVdWSurface
    : public SurfaceBase
  {
    public:
 
    BALL_CREATE(RelNegativePolarVdWSurface)
 
    
    
    RelNegativePolarVdWSurface();

    RelNegativePolarVdWSurface(const RelNegativePolarVdWSurface& rnps);

    virtual ~RelNegativePolarVdWSurface();
    

    RelNegativePolarVdWSurface& operator = (const RelNegativePolarVdWSurface& rnps);

    double compute(AtomContainer& ac);
  };

  class BALL_EXPORT RelHydrophobicVdWSurface
    : public SurfaceBase
  {
    public:
 
    BALL_CREATE(RelHydrophobicVdWSurface)
 
    

    RelHydrophobicVdWSurface();

    RelHydrophobicVdWSurface(const RelHydrophobicVdWSurface& rhs);

    virtual ~RelHydrophobicVdWSurface();


    RelHydrophobicVdWSurface& operator = (const RelHydrophobicVdWSurface& rhs);
    
    double compute(AtomContainer& ac);
  };

  class BALL_EXPORT RelPolarVdWSurface
    : public SurfaceBase
  {
    public:
 
    BALL_CREATE(RelPolarVdWSurface)
 
    

    RelPolarVdWSurface();

    RelPolarVdWSurface(const RelPolarVdWSurface& rps);

    virtual ~RelPolarVdWSurface();


    RelPolarVdWSurface& operator = (const RelPolarVdWSurface& rps);

    double compute(AtomContainer& ac);
  };

  class BALL_EXPORT VdWVolume
    : public SurfaceBase
  {
    public:
 
    BALL_CREATE(VdWVolume)
 
    
    
    VdWVolume();

    VdWVolume(const VdWVolume& vol);

    virtual ~VdWVolume();


    VdWVolume& operator = (const VdWVolume& vol);
  };

  class BALL_EXPORT Density
    : public SurfaceBase
  {
    public:
 
    BALL_CREATE(Density)
 
    
    
    Density();

    Density(const Density& rho);

    virtual ~Density();


    Density& operator = (const Density& rho);
  };

  class BALL_EXPORT VdWSurface
    : public SurfaceBase
  {
    public:
 
    BALL_CREATE(VdWSurface)
 
    
    
    VdWSurface();

    VdWSurface(const VdWSurface& s);
    
    virtual ~VdWSurface();


    VdWSurface& operator = (const VdWSurface& s);
  };
 
} // namespace BALL
 
#endif // BALL_QSAR_SURFACEDESCRIPTORS_H