BALL::HBondShiftProcessor Class Reference
[Shift modules]

#include <BALL/NMR/HBondShiftProcessor.h>

Inheritance diagram for BALL::HBondShiftProcessor:

Public Member Functions
Constructors and Destructors

	HBondShiftProcessor ()
	HBondShiftProcessor (const HBondShiftProcessor &processor)
virtual	~HBondShiftProcessor ()
Accessors

virtual void	init ()
Processor specific funtions.

virtual bool	start ()
virtual Processor::Result	operator() (Composite &composite)
virtual bool	finish ()
Static Public Attributes
Enums and Constants

static const char *	PROPERTY__HBOND_SHIFT
Protected Attributes
std::vector< String >	acceptor_types_
std::vector< Atom * >	donors_
std::vector< Atom * >	acceptors_
bool	amide_protons_are_targets_
float	amide_proton_factor_
float	amide_proton_subtrahend_
float	amide_proton_oxygen_hydrogen_separation_distance_
float	alpha_proton_oxygen_hydrogen_separation_distance_
bool	exclude_selfinteraction_
bool	ShiftXwise_hydrogen_bonds_computation_
Private Member Functions
void	printParameters_ ()
void	printEffectors_ ()
void	printTargets_ ()
Atom *	getDonor_ (Atom *a)
void	postprocessing_ ()
Private Attributes
std::multimap< float, std::pair< Atom , Atom > >	hbonds_
std::map< Atom *, bool >	donor_occupied_
std::map< Atom *, bool >	acceptor_occupied_

Detailed Description

Shift assignment processor implementing the effect of hydrogen bonds.

Definition at line 37 of file HBondShiftProcessor.h.

Constructor & Destructor Documentation

BALL::HBondShiftProcessor::HBondShiftProcessor ( )

Default constructor.

BALL::HBondShiftProcessor::HBondShiftProcessor ( const HBondShiftProcessor & processor )

Copy constructor.

virtual BALL::HBondShiftProcessor::~HBondShiftProcessor ( ) [virtual]

Destructor.

Member Function Documentation

virtual bool BALL::HBondShiftProcessor::finish ( ) [virtual]

Finish method. This method performs the chemical shift calculation as specified in the SHIFTX.ini - file read in the init() method. According to $var ShiftXwise_hydrogen_bonds_computation_ $ we temporarily compute hydrogenbonds in an ShiftX like manner or we assume the hydrogen bonds already be set.

The ShiftX definition of hydrogen bonds is:

Donors are: H and HA
Acceptors are: O, OD_n, OE_n, OG_n, OH_n or water in the solvent! By now we do not consider water (as ShiftX does not consider too)!
Donors and Acceptors have to be on different residues.
HA even does not form hydrogen bonds with neighbours.
If the acceptor is a solvent oxygen, the donor must not be a HA (not yet implemented!)
The oxygen--hydrogen separation must be less than 3.5 A for H(N) and 2.77 A for HA.
For all hydrogens must hold: ~the angle between the N_H donor bond vector and the C=O acceptor bond vector must be 90 degrees or more, and ~the hydrogen-oxygen distance must be less than 2.5 + cos of the angle, and ~hydrogen-oxygen distance must be less than the nitrogen - oxygen distance

Having applied these rules to each donor--acceptor pair, we sort the list of possible bonds by the O_H separation distance, shortest to longest. The list is then processed so that only the single strongest hydrogen bond is identified for each donor--acceptor pair. Up to that point any bond involving the same donor or acceptor is preculded!

The chemical shift is added to the {acceptor} atom using the named property ShiftModule::PROPERTY__SHIFT and stored in the named property PROPERTY__HBOND_SHIFT .

Returns:: bool, false if invalid

Reimplemented from BALL::ShiftModule.

Atom* BALL::HBondShiftProcessor::getDonor_ ( Atom * a ) [private]

virtual void BALL::HBondShiftProcessor::init ( ) [virtual]

Initialization method. This method reads the parameter section "HBondEffect" and parses its content. This section contains the parameters used to calculate the contribution of a hydrogen bond to the chemical shift of alpha protons and amide protons.

In addition, this section contains the definition of the Hbond effector types, which are stored in the vector { /tt acceptor_types_}.

The formular for amid protons is given as

amide_proton_factor_ shift = ---------------------- - amide_proton_subtrahend_, r^3

the formular for alpha protons is given as

0.147521 (1.65458E-05) 0.000134668 0.0598561 15.6855 shift = ------- - ------------- - ------------- + ----------- + -------- - 0.673905 . r r^1.5 r*r r^2.5 r^3

The section contains the following flags:

amide_protons_are_targets denotes, whether amid protons are targets of the HydrogenBond shift effect. Default is false.
$var amide_proton_factor$ denotes the factor of the amid term, default is zero.
$var amide_proton_subtrahend$ denotes the subtrahend of the amid term, default is zero.
$var amide_proton_oxygen_hydrogen_separation_distance $ denotes the maximal possible HN--O distance, default is zero.
$var alpha_proton_oxygen_hydrogen_separation_distance $ denotes the denotes the maximal possible H_alpha--O distance, default is zero.
$var exclude_selfinteraction$ denotes if effectors (O) influence hydrogens of the same residue, default is true.
$var ShiftXwise_hydrogen_bonds_computation $ denotes if the hydrogenbonds are computed as in the ShiftX approach, default is false.

Right now, it is assumed that the hydrogen bonds were already set via for example the HBondProcessor.

Reimplemented from BALL::ShiftModule.

virtual Processor::Result BALL::HBondShiftProcessor::operator() ( Composite & composite ) [virtual]