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