EFShiftProcessor.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: EFShiftProcessor.h,v 1.23.10.5 2007-04-12 13:53:52 anne Exp $
//

#ifndef BALL_NMR_EFSHIFTPROCESSOR_H
#define BALL_NMR_EFSHIFTPROCESSOR_H

#ifndef BALL_NMR_SHIFT_MODULE_H
# include<BALL/NMR/shiftModule.h>
#endif

#ifndef BALL_KERNEL_EXPRESSION_H
# include<BALL/KERNEL/expression.h>
#endif

namespace BALL 
{
  class Atom;
    
  class BALL_EXPORT EFShiftProcessor
    : public ShiftModule
  {
    public:

    BALL_CREATE(EFShiftProcessor)

    

    static const char* PROPERTY__EF_SHIFT;
    


    EFShiftProcessor()
      ;
  
    EFShiftProcessor(const EFShiftProcessor& processor)
      ;
      
    virtual ~EFShiftProcessor()
      ; 



    virtual void init()
      ;


    
    virtual bool start()
      ;


    virtual Processor::Result operator () (Composite& composite)
      ;

    virtual bool finish()
      ;
      

    protected:
  
    /*_ The list of all target bonds collected by {\tt operator ()}.
    *   The first element of the pair is the origin of the bond, the second the destination.
    *   The shift _always_ applies to the first element of the pair.
    */
    std::vector<std::pair<Atom*, Atom*> >       bond_list_;

    /*_  The index of the expression that matched to result in the corresponding element in bond_list_
     */
    std::vector<Index>      expression_number_;

    /*_ The list of charged atoms (effectors).
    */
    std::list<Atom*>        effector_list_;

    /*_ The expressions describing the first atom of a bond.
    */
    std::vector<Expression> first_atom_expressions_;

    /*_ The expressions describing the first atom of a bond.
    */
    std::vector<Expression> second_atom_expressions_;

    /*_ The parameter $\varepsilon_1$.
    */
    std::vector<float>      epsilon1_;

    /*_ The parameter $\varepsilon_2$.
    */
    std::vector<float>      epsilon2_;

    /*_ The charge assignment map.
    */
    StringHashMap<float>    charge_map_;

    /*_ A flag indicating whether effectors in the same residues are to be considered.
        Set this flag by specifying the option {\tt exclude_residue_field = true} in 
        the ElectricFieldShift section of the parameter file.
        Default is false.
    */
    bool                    exclude_residue_field_;
    
    /*_ A flag indicating whether effectors in adjacent residues are to be considered.
        Set this flag by specifying the option {\tt exclude_adjacent_residue_field = true} in 
        the ElectricFieldShift section of the parameter file.
        Default is false.
    */
    bool                    exclude_adjacent_residue_field_;
    
    /*_ A flag indicating whether carbonyl effectors are to be considered for amid targets.
        Set this flag by specifying the option {\tt carbonyl_influences_amide_field = false} in 
        the ElectricFieldShift section of the parameter file.
        Default is false.
    */
    bool                    carbonyl_influences_amide_field_;
    
    
    /*_ A flag indicating whether solvent atoms do act as effectors.
        Set this flag by specifying the option {\tt exclude exclude_solvent_field = true} in 
        the ElectricFieldShift section of the parameter file.
        Default is false.
    */
    bool                    exclude_solvent_field_;


    
    /*_ A cut off value for the electric field effect.
        Any effector that is further away than this cut off is ignored.
        The distance is read from the option {\tt cut_off} in the 
        section <TT>  ElectricFieldEffect </TT> from the parameter file.
        This member contains the squared value(!) of the distance.
    */
    float                   cut_off2_;


    /*_ A factor for switching the charge unit between esu and elementary charges. 
        The unit is read from the option {\tt unit} of the section 
        <TT>  Charges </TT> from the parameter file.
        For numeric aspects, in the init() function the esu unit is divided by 
        the charge_factor_, such that the molecules charges (which are given 
        by PDB.org in elementary units) can easily be multiplied with. 
        When computing the shift, the charge_factor is again multiplied with.  
        Default is 1.0
    */

    float                   charge_factor_;
    
    private:
  
    /*_ Some debugging functions printing parameter/effector/target information
     *  to the Log-stream.
     */
    void      printParameters_();
    void      printEffectors_();
    void      printTargets_();
    
    /*_ A function to perform some ShiftX-y postprocessing: 
        add for all CA-atoms 0.2 times the EF-shift-value of the bound HA-atoms 
    */
    void      postprocessing_();

  };
  
} // namespace BALL

#endif // BALL_NMR_EFSHIFTPROCESSOR_H