empiricalHSShiftProcessor.h

Go to the documentation of this file.

#ifndef BALL_NMR_EMPIRICALHSSHIFTPROCESSOR_H
#define BALL_NMR_EMPIRICALHSSHIFTPROCESSOR_H

#ifndef BALL_MATHS_CUBICSPLINE2D_H
# include <BALL/MATHS/cubicSpline2D.h>
#endif

#ifndef BALL_MATHS_CUBICSPLINE1D_H
# include <BALL/MATHS/cubicSpline1D.h>
#endif


#ifndef BALL_FORMAT_GENERICMOLFILE_H
# include <BALL/FORMAT/genericMolFile.h>
#endif

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

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

#ifndef BALL_DATATYPE_OPTIONS_H
# include <BALL/DATATYPE/options.h>
#endif


#include <set>
#include <map>

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

    BALL_CREATE(EmpiricalHSShiftProcessor)
    
    static const int VERBOSITY_LEVEL_CRITICAL;
    static const int VERBOSITY_LEVEL_DEBUG;


    struct BALL_EXPORT Option
    { 
      static const char* VERBOSITY;
      
    };
    
    struct BALL_EXPORT Default
    {
      static const int VERBOSITY;
    };
  



    static const char* PROPERTY__EHS_SHIFT;
  


    EmpiricalHSShiftProcessor()
      throw();

    virtual ~EmpiricalHSShiftProcessor()
      throw();  


  
    virtual void init()
      throw();


    
    virtual bool start()
      throw();


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

    virtual bool finish()
      throw();
      


      Options options;

      void setDefaultOptions();

    protected:
    
    
    /*_ Neested class providing atom properties for the shift computations 
     * */ 
    class BALL_EXPORT PropertiesForShift_
    {
      public:
              
        PropertiesForShift_(int verbosity_ = EmpiricalHSShiftProcessor::VERBOSITY_LEVEL_CRITICAL) 
          throw();

        Atom*       current_atom;

        bool computeProperties_(Atom* atom, std::set<String> properties)  throw();  

        std::pair<float, String> operator [] (const String& property_name) throw();

        static bool isDiscrete(String property) throw();
        
        static bool isMixed(String property) throw();

      protected:

        // Storing the atoms properties 
        // ...as numerical value
        std::map<String, float>  properties_real_;
        // ... as alphanumerical/discrete value
        std::map<String, String> properties_string_;

      protected:
        
        float     getChiAngle_(Residue* residue) throw();
        float     getChi2Angle_(Residue* residue) throw();
        char      getAminoAcid_(Residue* residue) throw();
        char      getSecondaryStructure_(Residue* residue) throw();
        float     getHA_HBondLen_(Residue* residue) throw();
        float     getHA2_HBondLen_(Residue* residue) throw();
        float     getHN_HBondLen_(Residue* residue) throw();
        float     getO_HBondLen_(Residue* residue) throw();
        bool      hasDisulfidBond_(Residue* residue) throw();
        bool      hasHA_HBond_(Residue* residue) throw();
        bool      hasHA2_HBond_(Residue* residue) throw();
        bool      hasHN_HBond_(Residue* residue) throw();
        bool      hasO_HBond_(Residue* residue) throw();
        
      private:
        // verbosity of the classes methods
        int     verbosity_;
    }; // end of nested class
    

    /*_ Neested class handling the empirical hypersurfaces. 
     **/
    
    class ShiftHyperSurface_
    {
      public:
        typedef std::map<String, std::map<String, float> > tabletype;


        enum HYPERSURFACE__TYPE{
          REAL__REAL,
          REAL__DISCRETE,     
          DISCRETE__REAL,     // not used 
          DISCRETE__DISCRETE,
          CHI__REAL,          // not used
          REAL__CHI,
          CHI__DISCRETE,      
          DISCRETE__CHI,      
          CHI__CHI,           
          SINGLE__REAL,  
          SINGLE__DISCRETE, 
          SINGLE__CHI         
        };

        /*_  Constructors and Destructors.
        */
        ShiftHyperSurface_(int verbosity = EmpiricalHSShiftProcessor::VERBOSITY_LEVEL_CRITICAL) throw();

        /*_ Detailed constructor. 
         *  Creates a ShiftHyperSurface given the <b>filename<\b> of the data file, 
         *  the atom type, and the two property types according to its deduced 
         *  hypersurface types (see {\tt HYPERSURFACE__TYPE()}).
         *  
         *  If the data file cannot be found, no hypersurface is created.
         *
         *  In the special case that the two properties have the same type, we create just one table entry in 
         *  {\tt table_} or just one spline  { \tt in s1d_ }. 
         *  
         *  In case of hypersurfaces of type {\tt REAL__DISCRETE} the splines default values are set to the  
         *  row-averages if given specified in the datafile. 
         *  
         *  In case of hypersurfaces of type {\tt  REAL__CHI, REAL__REAL } the splines default values are 
         *  set to the splines averages. 
         *
         *  In all cases but look-up tables the bounds for the splines are set as specified in 
         *  the datafile if specified.
         * 
         *  Note: 
         *  The spline or value can be accessed 
         *  by the {\tt operator () } given __not__ the property-value, but the property name. 
         *  
         */
        ShiftHyperSurface_(String filename, String atomtype, 
                           String firstproperty, String secondproperty, 
                           int verbosity = EmpiricalHSShiftProcessor::VERBOSITY_LEVEL_CRITICAL)
          throw(Exception::FileNotFound);  

        virtual ~ShiftHyperSurface_() throw();

        float operator () (PropertiesForShift_& properties) throw();  

        bool isvalid() throw(){return !invalid_;}

        // Returns the total average given in the input file.
        float getTotalAverage() throw() {return average_;}

      private:

        // Computes the average of the look-up table values.
        float getTableAverage_() throw();

        // Computes the row average of the look-up table given a row name.
        float getTableRowAverage_(const std::map<String, float>& row) throw();

        // Computes the column average of the look-up table given a column name.
        float getTableColumnAverage_(const String& name) throw();

        bool tableHasColumn_(const String& name) throw();

        void parseDataFile_(BALL::File& file, String filename) throw();

        // Method to convert a vector of strings into a vector of floats {/tt output}.
        void convertToReal_(const vector<String>& input, vector<float>& output) throw();

        void setType_(String firstproperty, String secondproperty) throw();

        // The type of the hypersurface.
        int type_;

        // The properties of the hypersurface. 
        String  first_property_; 
        String  second_property_;

        // The hypersurface can be a 2D spline, 1D spline or a look-up table.
        CubicSpline2D                               s2d_;
        std::map <String, CubicSpline1D >           s1d_;
        // Note: access of the look--up table: first the discrete key x, second the numerical key y. 
        std::map <String, std::map<String, float> > table_;

        // The averages of the hypersurface as read from the file.
        // //TODO rename to row_defaults
        std::map <String, float>                    row_averages_;
        std::map <String, float>                    col_averages_;

        // The spacing in x and y direction as read from the file.
        float row_spacing_;
        float col_spacing_;

        // Flag to store whether the spline we created is valid.
        bool invalid_;

        // The average over the complete hypersurface as read from the file.
        // Note: this average maybe weighted in non-obvious ways! 
        float average_;

        // verbosity of the method
        int verbosity_;

        // The underlying data of the hypersurface as read from the file.
        vector<String>           y_axis_values_;
        vector<vector<String> >  x_axis_values_;
        vector<vector<float> >   sample_values_;
    };




    /*_ The target atoms collected by {\tt operator ()}.
    */
    std::vector<PropertiesForShift_>        targets_;

    /*_ The target atom types stored as a vector of strings collected from the ini-file
     *  by {\tt init ()}.
     */
    vector<String>                      target_names_;  

    /*_ The target properties used for determine the 
     * empirical hypersurface shifts. The properties are collected 
     * from the ini-file by {\tt init ()} and are stored per target atom
     * in the same order as the target_names.
     */
    vector< std::set<String> >      target_property_names_;

    /*_ The file names of the files storing the property-data-splines for computing the
     * shift contributions are stored in a map, whose key is the pair of
     * properties, to which the splines belong.
     * The maps are stored per target atom type in the same order as the target_names.
     * The files are specified in the section {\tt EmpiricalShiftHyperSurfaces} 
     * of the file {\tt ShiftX.ini} and are collected by {\tt init ()}.
     */
    vector< std::map< std::pair<String, String>, String > >   property_files_; 

    /*_ The property pairs for each atom type are stored in this map.
     *  The map is created in {\tt init ()}.
     **/
    std::map< String, vector< std::pair<String, String> > >  property_pairs_;

    /*_ The hypersurfaces are precomputed by {\tt init()}
     *  and then are stored per atom type in a  map with key atom_type of 
     *  maps with the property pair as key.
     */

    std::map<String, std::map <std::pair<String, String>,EmpiricalHSShiftProcessor::ShiftHyperSurface_> > hypersurfaces_;

    /*_ Option to exclude prolins from the shift computations. 
      Default is false.
      */
    bool exclude_prolins_;

    // Map containing possible correction terms for ssbonds.
    std::map<String, float> ssbond_correction_;

  private:

    /*_ Some debugging functions printing parameter/effector/target information
     *   to the Log stream.
     */
    void      printParameters_() throw();
    void      printTargets_() throw();  

    /*_ 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.
      Due to some reason ShiftX does not perform this postprocessing 
      for the empirical Hypersurface contributions.
      */
    void      postprocessing_() throw();

    int       verbosity_;

  };// end of class
} // end of namespace
#endif // BALL_NMR_EMPIRICALHSSHIFTPROCESSOR_H

---