enm-lib.hpp

 
/*
  This file is part of LOOS.
 
  LOOS (Lightweight Object-Oriented Structure library)
  Copyright (c) 2010 Tod D. Romo
  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_ENMLIB_HPP)
#define LOOS_ENMLIB_HPP
 
#include <loos.hpp>
#include "hessian.hpp"
 
namespace ENM {
 
  // -------------------------------------
  // Support routines & types
 
 
  void copyMasses(loos::AtomicGroup& target, const loos::AtomicGroup& source);
 
 
 
  void massFromPSF(loos::AtomicGroup& grp, const std::string& name);
 
  void massFromOccupancy(loos::AtomicGroup& grp);
 
 
  loos::DoubleMatrix getMasses(const loos::AtomicGroup& grp);
 
 
  // -------------------------------------
 
 
 
  // This class describes the interface for all ENMs...
  // To instantiate, you must pass a SuperBlock which determines how the
  // hessian is built.
 
  class ElasticNetworkModel {
  public:
 
    ElasticNetworkModel(SuperBlock* blocker) : blocker_(blocker), name_("ENM"), prefix_(""), meta_(""), debugging_(false), verbosity_(0) { }
    virtual ~ElasticNetworkModel() { }
 
    // Should we allow this?
    void setSuperBlockFunction(SuperBlock* p) { blocker_ = p; }
 
    virtual void solve() =0;
 
    void prefix(const std::string& s) { prefix_ = s; }
    std::string prefix() const { return(prefix_); }
 
    void meta(const std::string& s) { meta_ = s; }
    std::string meta() const { return(meta_); }
 
    void debugging(const bool b) { debugging_ = b; }
    bool debugging() const { return(debugging_); }
 
    void verbosity(const int i) { verbosity_ = i; }
    int verbosity() const { return(verbosity_); }
 
    // -----------------------------------------------------
    SpringFunction::Params setParams(const SpringFunction::Params& v) {
      return(blocker_->setParams(v));
    }
 
    bool validParams() const { return(blocker_->validParams()); }
 
    uint paramSize() const { return(blocker_->paramSize()); }
    // -----------------------------------------------------
 
 
    const loos::DoubleMatrix& eigenvectors() const { return(eigenvecs_); }
 
    const loos::DoubleMatrix& eigenvalues() const { return(eigenvals_); }
 
    const loos::DoubleMatrix& hessian() const { return(hessian_); }
 
 
 
  protected:
  
 
 
    void buildHessian();
  
 
  protected:
    // Arguably, some of the following should be private rather than
    // protected...  But for now, we'll just cheat and make 'em all
    // protected..
    SuperBlock* blocker_;
    std::string name_;
    std::string prefix_;
    std::string meta_;
    bool debugging_;
    int verbosity_;
 
    loos::DoubleMatrix eigenvecs_;
    loos::DoubleMatrix eigenvals_;
 
    loos::DoubleMatrix hessian_;
  
  };
 
 
};
 
#endif