generalizedBornCase.h

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: generalizedBornCase.h,v 1.1 2005/11/21 19:38:38 anker Exp $
//

#ifndef BALL_SOLVATION_GENERALIZED_BORN_H
#define BALL_SOLVATION_GENERALIZED_BORN_H

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

#ifndef BALL_KERNEL_PTE_H
# include <BALL/KERNEL/PTE.h>
#endif

#ifndef BALL_KERNEL_ATOMCONTAINER_H
# include <BALL/KERNEL/atomContainer.h>
#endif

#ifndef BALL_DATATYPE_STRINGHASHMAP_H
# include <BALL/DATATYPE/stringHashMap.h>
#endif

#ifndef BALL_FORMAT_INIFILE_H
# include <BALL/FORMAT/INIFile.h>
#endif

#ifndef BALL_FORMAT_PARAMETERSECTION_H
# include <BALL/FORMAT/parameterSection.h>
#endif

#include <map>
#include <set>

namespace BALL 
{
  class GeneralizedBornModel
  {
    public:

    struct Option
    {
      static const String VERBOSITY;

      static const String LAMBDA;

      static const String DELTA;

      static const String KAPPA;

      static const String RHO_0;

      static const String DC_SOLVENT;

      static const String DC_SOLUTE;

      static const String FILENAME;
    };

    struct Default
    {
      static const Size VERBOSITY;

      static const float LAMBDA;

      static const float DELTA;

      static const float KAPPA;

      static const float RHO_0;

      static const float DC_SOLVENT;

      static const float DC_SOLUTE;

      static const String FILENAME;
    };

    GeneralizedBornModel()
      throw(Exception::FileNotFound);

    ~GeneralizedBornModel();

    void clear();

    bool setup(const AtomContainer& ac)
      throw(Exception::FileNotFound);

    void setScalingFactorFile(const String& filename);

    void setScalingFactors(const StringHashMap<float>& scaling_factors);

    const StringHashMap<float>& getScalingFactors() const;

    void setSolventDC(float solvent_dc);

    void setSoluteDC(float solute_dc);

    float calculateEnergy();

    float calculateSolvationEnergy();

    void calculatePotential(HashMap<const Atom*, float>& p_hash) const;

    float calculatePotential(const Atom& atom_i) const;

    bool readScalingFactors(const String& inifile_name)
      throw(Exception::FileNotFound);


    private:

    /* Parameters for the generalized Born model
    */
    class GBParameters : public ParameterSection
    {
      public:

      GBParameters();

      ~GBParameters();

      bool extractSection(Parameters& parameters, const String& section_name);

      const StringHashMap<float>& getScalingFactors() const;

      float getSoluteDC() const;

      float getSolventDC() const;

      float getKappa() const;

      private:

      /*_
      */
      StringHashMap<float> scaling_factors_;

      /*_
      */
      float dc_solute_;

      /*_
      */
      float dc_solvent_;

      /*_
      */
      float lambda_;

      /*_
      */
      float delta_;
      
      /*_
      */
      float kappa_;
      
      /*_
      */
      float rho_0_;

    };

    AtomContainer* ac_;

    std::vector<const Atom*> atoms_;

    std::vector<float> born_radii_;

    std::vector< std::pair<Size, Size> > pair_list_;

    std::vector< float > pair_distances_;
    std::vector< float > pair_charges_;
    std::vector< std::vector< float > > squared_distances_;

    float dc_solute_;
    float dc_solvent_;

    StringHashMap<float> scaling_factors_;
    std::vector<float> scaling_factor_;

    String scaling_factor_filename_;

    float lambda_;

    float delta_;

    float kappa_;

    float rho_0_;

    float to_kJ_mol_;

    void calculateBornRadii_();
    
    float calculateCreationEnergy_() const;

    float calculateTransferEnergy_() const;

    float f_GB_(Size i, Size j) const;

    float coulombIntegralApproximation_(float distance, float scaled_radius_j,
        float radius_i) const;



  };

 
} // namespace BALL

#endif // BALL_SOLVATION_GENERALIZED_BORN_H

---