poissonBoltzmann.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: poissonBoltzmann.h,v 1.31 2005/12/23 17:02:00 amoll Exp $ 
//
 
// Finite Difference Poisson Boltzmann Solver
 
#ifndef BALL_SOLVATION_POISSONBOLTZMANN_H
#define BALL_SOLVATION_POISSONBOLTZMANN_H
 
#ifndef BALL_COMMON_H_
# include <BALL/common.h>
#endif
 
#ifndef BALL_DATATYPE_REGULARDATA3D_H
# include <BALL/DATATYPE/regularData3D.h>
#endif
 
#ifndef BALL_KERNEL_SYSTEM_H
# include <BALL/KERNEL/system.h>
#endif
 
#ifndef BALL_DATATYPE_OPTIONS_H
# include <BALL/DATATYPE/options.h>
#endif
 
#include <vector>
using std::vector;
 
namespace BALL 
{
  class BALL_EXPORT FDPB 
  {
 
    public:
 
    enum ErrorCode 
    {
      ERROR__NONE = -1,
 
      ERROR__UNKNOWN  =  0,
 
      ERROR__NOT_IMPLEMENTED  =  1,
 
      ERROR__CANNOT_CREATE_ATOM_ARRAY,
 
      ERROR__CANNOT_CREATE_SAS_GRID,
 
      ERROR__CANNOT_CREATE_EPSILON_GRID,
 
      ERROR__CANNOT_CREATE_KAPPA_GRID,
 
      ERROR__CANNOT_CREATE_CHARGE_GRID,
    
      ERROR__CANNOT_CREATE_PHI_GRID,
 
      ERROR__SAS_GRID_REQUIRED,
 
      ERROR__EPSILON_GRID_REQUIRED,
 
      ERROR__ATOM_ARRAY_REQUIRED,
 
      ERROR__PHI_GRID_REQUIRED,
 
      ERROR__OUT_OF_MEMORY,
 
      ERROR__UNKNOWN_DIELECTRIC_SMOOTHING_METHOD,
    
      ERROR__UNKNOWN_CHARGE_DISTRIBUTION_METHOD,
 
      ERROR__UNKNOWN_BOUNDARY_CONDITION_TYPE,
 
      ERROR__NOT_A_VECTOR_IN_UPPER_LOWER,   
 
      ERROR__ILLEGAL_VALUE_FOR_LOWER_UPPER,
 
      ERROR__SETUP_REQUIRED,
 
      NUMBER_OF_ERRORS
    };
 
    struct BALL_EXPORT Option 
    {
      static const String VERBOSITY;
 
      static const String PRINT_TIMING;
      
      static const String SPACING;
 
      static const String BORDER;
 
      static const String IONIC_STRENGTH;
 
      static const String SOLUTE_DC;
 
      static const String SOLVENT_DC;
 
      static const String PROBE_RADIUS;
 
      static const String ION_RADIUS;
 
      static const String TEMPERATURE;
 
      static const String BOUNDARY;
 
      static const String CHARGE_DISTRIBUTION;
 
      static const String DIELECTRIC_SMOOTHING;
 
      static const String OFFSET;
 
      static const String RMS_CRITERION;
 
      static const String MAX_CRITERION;
 
      static const String CHECK_AFTER_ITERATIONS;
 
      static const String MAX_ITERATIONS;
 
      static const String LOWER;
 
      static const String UPPER;
 
      static const String BOUNDING_BOX_LOWER;
 
      static const String BOUNDING_BOX_UPPER;
 
    };
 
    struct BALL_EXPORT Boundary 
    {
      static const String ZERO;
 
      static const String DEBYE;
 
      static const String COULOMB;
 
      static const String DIPOLE;
 
      static const String FOCUSING;
    };
    
    struct BALL_EXPORT ChargeDistribution 
    {
      static const String TRILINEAR;
 
      static const String UNIFORM;
    };
 
    struct BALL_EXPORT DielectricSmoothing 
    {
      static const String NONE;
 
      static const String UNIFORM;
 
      static const String HARMONIC;
    };
 
    struct BALL_EXPORT Default 
    {
      static const int VERBOSITY;
 
      static const bool PRINT_TIMING ;
 
      static const float SPACING;
 
      static const float BORDER;
 
      static const float IONIC_STRENGTH;
 
      static const float TEMPERATURE;
 
      static const float PROBE_RADIUS;
 
      static const float ION_RADIUS;
 
      static const String  BOUNDARY;
 
      static const String CHARGE_DISTRIBUTION;
 
      static const String DIELECTRIC_SMOOTHING;
 
      static const float SOLVENT_DC;
 
      static const float SOLUTE_DC;
 
      static const float RMS_CRITERION; 
 
      static const float MAX_CRITERION;
 
      static const Index MAX_ITERATIONS;
 
      static const Index CHECK_AFTER_ITERATIONS;
    };
 
    struct BALL_EXPORT FastAtomStruct 
    {
      float q;
      float r;
      float x, y, z;
      Index index;
    };
 
    typedef struct FastAtomStruct FastAtom;
 
 
    
    FDPB();
    
    FDPB(const FDPB& fdpb);
 
    FDPB(System& system);
 
    FDPB(Options& new_options);
 
    FDPB(System& system, Options& new_options);
 
    virtual ~FDPB();
 
    void destroy();
 
    void destroyGrids();
 
 
 
    bool setup(System& system);
 
    bool setup(System& system, Options& options);
 
    bool setupEpsGrid(System& system);
 
          
    // ?????
    bool setupSASGrid(System& system);
 
    bool setupAtomArray(System& system);
 
    bool setupKappaGrid();
 
    bool setupQGrid();
 
    bool setupPhiGrid();
 
    bool setupBoundary();
 
 
 
    bool  solve();
 
    double getEnergy() const;
 
    double getReactionFieldEnergy() const;
 
    double calculateReactionFieldEnergy() const;
 
    Size  getNumberOfIterations() const;
 
 
 
    Index getErrorCode() const;
 
    static String getErrorMessage(Index error_code);
 
 
 
    Options options;
 
    Options results;
 
 
 
    TRegularData3D<Vector3>*  eps_grid;
 
    TRegularData3D<float>*  kappa_grid;
 
    TRegularData3D<float>*  q_grid;
 
    TRegularData3D<float>*  phi_grid;
 
    TRegularData3D<char>* SAS_grid;
 
    vector<FDPB::FastAtom>* atom_array;
    
 
    protected:
 
    Vector3 lower_;
    Vector3 upper_;
    Vector3 offset_;
 
    bool    use_offset_;
 
    float   spacing_;
 
    // final energy of the last calculation
    double  energy_;
 
    // the reaction field energy of the last calculation
    double  reaction_field_energy_;
 
    // the indices of the boundary points,
    // i.e., the points that have at least one neighbouring
    // grid point that is inside the solute
    vector<Position>  boundary_points_;
 
    // number of iterations of the last calculation
    Size number_of_iterations_;
 
    // error code. use getErrorMessage to access the corresponding 
    // error message
    int error_code_;
 
    static const char* error_message_[];
  };
   
} // namespace BALL 
 
#endif