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