internal-water-filter.hpp

/*
  Internal water filter library
*/
 
 
/*
  This file is part of LOOS.
 
  LOOS (Lightweight Object-Oriented Structure library)
  Copyright (c) 2008, Tod D. Romo, Alan Grossfield
  Department of Biochemistry and Biophysics
  School of Medicine & Dentistry, University of Rochester
 
  This package (LOOS) is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation under version 3 of the License.
 
  This package is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
 
 
#if !defined(LOOS_INTERNAL_WATER_FILTER_HPP)
#define LOOS_INTERNAL_WATER_FILTER_HPP
 
#include <loos.hpp>
#include <DensityGrid.hpp>
#include <vector>
 
 
namespace loos {
 
  namespace DensityTools {
 
 
    class WaterFilterBase {
    public:
      WaterFilterBase() { }
      virtual ~WaterFilterBase() { }
 
 
      virtual std::vector<int> filter(const loos::AtomicGroup&, const loos::AtomicGroup&) =0;
 
      virtual std::vector<loos::GCoord> boundingBox(const loos::AtomicGroup&) =0;
 
      virtual double volume(void) =0;
 
      virtual std::string name(void) const =0;
 
    protected:
      std::vector<loos::GCoord> bdd_;
    };
 
 
    // --------------------------------------------------------------------------------
 
 
    class WaterFilterBox : public WaterFilterBase {
    public:
      WaterFilterBox(const double pad) : pad_(pad) { }
      virtual ~WaterFilterBox() { }
 
      virtual std::vector<int> filter(const loos::AtomicGroup&, const loos::AtomicGroup&);
      virtual std::vector<loos::GCoord> boundingBox(const loos::AtomicGroup&);
 
      virtual double volume(void);
      virtual std::string name(void) const;
 
    private:
      double pad_;
    };
 
 
 
    // --------------------------------------------------------------------------------
 
 
    class WaterFilterRadius : public WaterFilterBase {
    public:
      WaterFilterRadius(const double radius) : radius_(radius) { }
      virtual ~WaterFilterRadius() { }
 
      virtual std::vector<int> filter(const loos::AtomicGroup&, const loos::AtomicGroup&);
      virtual std::vector<loos::GCoord> boundingBox(const loos::AtomicGroup&);
 
      virtual double volume(void);
      virtual std::string name(void) const;
 
    private:
      double radius_;
    };
 
    // --------------------------------------------------------------------------------
 
 
    class WaterFilterContacts : public WaterFilterBase {
    public:
      WaterFilterContacts(const double radius, const uint mincontacts) : radius_(radius), threshold_(mincontacts) { }
      virtual ~WaterFilterContacts() { }
 
      virtual std::vector<int> filter(const loos::AtomicGroup&, const loos::AtomicGroup&);
      virtual std::vector<loos::GCoord> boundingBox(const loos::AtomicGroup&);
 
      virtual double volume(void);
      virtual std::string name(void) const;
 
    private:
      double radius_;
      uint threshold_;
    };
 
 
    // --------------------------------------------------------------------------------
 
 
    class WaterFilterAxis : public WaterFilterBase {
    public:
      WaterFilterAxis(const double radius) : radius_(radius*radius) { }
      virtual ~WaterFilterAxis() { }
 
      virtual std::string name(void) const;
      virtual double volume(void);
 
      virtual std::vector<int> filter(const loos::AtomicGroup&, const loos::AtomicGroup&);
      std::vector<loos::GCoord> boundingBox(const loos::AtomicGroup&);
 
    private:
      loos::GCoord axis_, orig_;
      double radius_;
    };
 
    // --------------------------------------------------------------------------------
 
 
    class WaterFilterCore : public WaterFilterBase {
    public:
      WaterFilterCore(const double radius) : radius_(radius*radius) { }
      virtual ~WaterFilterCore() { }
 
      virtual std::string name(void) const;
      virtual double volume(void);
 
      virtual std::vector<int> filter(const loos::AtomicGroup&, const loos::AtomicGroup&);
      std::vector<loos::GCoord> boundingBox(const loos::AtomicGroup&);
 
    private:
      loos::GCoord calculateAxis(const loos::AtomicGroup& grp);
      
 
      loos::GCoord axis_, orig_;
      double radius_;
    };
 
 
 
    // --------------------------------------------------------------------------------
 
 
    class WaterFilterBlob : public WaterFilterBase {
    public:
      WaterFilterBlob(const DensityGrid<int>& blob) : blob_(blob), bdd_set(false), vol(-1.0) { }
      virtual ~WaterFilterBlob() { }
 
      virtual std::string name(void) const;
      virtual double volume(void);
 
      std::vector<int> filter(const loos::AtomicGroup&, const loos::AtomicGroup&);
      std::vector<loos::GCoord> boundingBox(const loos::AtomicGroup&);
 
    private:
      DensityGrid<int> blob_;
      bool bdd_set;
      double vol;
    };
 
 
    // --------------------------------------------------------------------------------
 
    class WaterFilterDecorator : public WaterFilterBase {
    public:
      WaterFilterDecorator(WaterFilterBase* p) : base(p) { }
      virtual ~WaterFilterDecorator() { }
 
      virtual std::string name(void) const { return(base->name()); }
      virtual double volume(void) { return(base->volume()); }
  
      virtual std::vector<int> filter(const loos::AtomicGroup& solv, const loos::AtomicGroup& prot) {
        return(base->filter(solv, prot));
      }
 
      virtual std::vector<loos::GCoord> boundingBox(const loos::AtomicGroup& prot) {
        return(base->boundingBox(prot));
      }
 
    private:
      WaterFilterBase *base;
    };
 
 
    class ZClippedWaterFilter : public WaterFilterDecorator {
    public:
      ZClippedWaterFilter(WaterFilterBase* p, const double zmin, const double zmax) : WaterFilterDecorator(p),
                                                                                      zmin_(zmin), zmax_(zmax) { }
      virtual ~ZClippedWaterFilter() { }
 
      std::string name(void) const;
      std::vector<int> filter(const loos::AtomicGroup&, const loos::AtomicGroup&);
      std::vector<loos::GCoord> boundingBox(const loos::AtomicGroup&);
 
      double volume(void) { return(0.0); }
 
    private:
      double zmin_, zmax_;
    };
 
 
 
 
    class BulkedWaterFilter : public WaterFilterDecorator {
    public:
      BulkedWaterFilter(WaterFilterBase* p, const double pad, const double zmin, const double zmax) : WaterFilterDecorator(p),
                                                                                                      pad_(pad),
                                                                                                      zmin_(zmin), zmax_(zmax) { }
      virtual ~BulkedWaterFilter() { }
 
      std::string name(void) const;
      std::vector<int> filter(const loos::AtomicGroup&, const loos::AtomicGroup&);
      std::vector<loos::GCoord> boundingBox(const loos::AtomicGroup&);
 
      double volume(void) { return(0.0); }
 
    private:
      double pad_;
      double zmin_, zmax_;
    };
 
  };
 
}
 
 
#endif