fragmentDB.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_STRUCTURE_FRAGMENTDB_H
#define BALL_STRUCTURE_FRAGMENTDB_H

#ifndef BALL_DATATYPE_STRINGHASHMAP_H
# include <BALL/DATATYPE/stringHashMap.h>
#endif

#ifndef BALL_KERNEL_RESIDUE_H
# include <BALL/KERNEL/residue.h>
#endif

#ifndef BALL_KERNEL_MOLECULE_H
# include <BALL/KERNEL/molecule.h>
#endif

#ifndef BALL_KERNEL_BOND_H
# include <BALL/KERNEL/bond.h>
#endif

#ifndef BALL_STRUCTURE_RECONSTRUCTFRAGMENTPROCESSOR_H
# include <BALL/STRUCTURE/reconstructFragmentProcessor.h>
#endif

#include <vector>
#include <list>

namespace BALL 
{

  class ResourceEntry;

  class BALL_EXPORT FragmentDB 
  {
    public:

    class AddHydrogensProcessor;
    friend class FragmentDB::AddHydrogensProcessor;

    BALL_CREATE_DEEP(FragmentDB)
  
    

    enum FragmentTypes 
    {
      TYPE__UNKNOWN = -1,
      TYPE__FRAGMENT,
      TYPE__RESIDUE,
      TYPE__MOLECULE
    };


    typedef short Type;
    typedef StringHashMap<String> NameMap;


    
    class BALL_EXPORT NoFragmentNode
      : public Exception::GeneralException
    {
      public:
      NoFragmentNode(const char* file, int line, const string& filename) ;
      ~NoFragmentNode() throw() {}

      protected:
      string filename_;
    };


  
    FragmentDB();

    FragmentDB(const String& filename)
      throw(Exception::FileNotFound);

    FragmentDB(const FragmentDB& db, bool deep = true); 

    FragmentDB& operator = (const FragmentDB& db)
      ;

    virtual ~FragmentDB();

    void destroy();



    void init()
      throw(Exception::FileNotFound, NoFragmentNode);
    


    void setFilename(const String& filename)
      throw(Exception::FileNotFound);
    
    const String& getFilename() const;
    
    bool has(const String& fragment_name) const;

    const std::vector<Residue*>& getFragments() const { return fragments_;}
    
    FragmentDB::Type getFragmentType(const String& fragment_name) const;

    list<String> getVariantNames(const String& name) const;
    
    const Fragment* getFragment(const String& fragment_name) const;

    const Fragment* getReferenceFragment(const Fragment& fragment) const;

    const Residue* getResidue(const String& fragment_name) const;

    Fragment* getFragmentCopy(const String& fragment_name) const;

    Molecule* getMoleculeCopy(const String& fragment_name) const;

    Residue* getResidueCopy(const String& fragment_name) const;

    const String& getDefaultNamingStandard() const;

    StringHashMap<NameMap>& getNamingStandards();

    const StringHashMap<String>& getNamingStandard(const String& std) const
      throw(StringHashMap<String>::IllegalKey);

    std::vector<String> getAvailableNamingStandards() const;



    bool isValid() const;



    class BALL_EXPORT NormalizeNamesProcessor 
      : public UnaryProcessor<Fragment>
    {
    
      public:


      NormalizeNamesProcessor();
    
    
      NormalizeNamesProcessor(FragmentDB& db);

      virtual ~NormalizeNamesProcessor();
    

      
      void setFragmentDB(FragmentDB& db);

      void setNamingStandard(const String& naming_standard);
    
      const String& getNamingStandard();

      bool matchName(String& res_name, String& atom_name, const NameMap& map) const;
   

      
      virtual bool start();

      virtual bool finish();
    
      virtual Processor::Result operator () (Fragment& fragment);


      private:
        enum CountingMode { ADD, OVERWRITE };
        String getSuffix_(const Fragment* frag) const;
        bool doMatch_(String& res_name, const String& res_name_suffix, String& atom_name, const NameMap& map) const;
        void countHits_(HashMap<NameMap*, Index>& maps, const std::list<Fragment*>& frags);
        void countHits_(HashMap<NameMap*, Index>& maps, const Fragment* frag, CountingMode mode = OVERWRITE);
        const NameMap* getBestMap_(const HashMap<NameMap*, Index>& maps) const;
        void normalizeFragments_(const NameMap* map, const std::list<Fragment*>& frags);
        void normalizeFragment_ (const NameMap* map, Fragment* frag);

      String                naming_standard_;

      FragmentDB*           fragment_db_;
    
      std::list<Fragment*>  fragments_;

    };


    class BALL_EXPORT BuildBondsProcessor 
      : public UnaryProcessor<Fragment> 
    {

      public:


      struct Connection
      {
        Atom*       atom;
        String      type_name;
        String      connect_to;
        Bond::Order order;
        float       dist;
        float       delta;
      };

      typedef std::list<Connection> ConnectionList;


    
      BuildBondsProcessor();
      
      BuildBondsProcessor(const FragmentDB& db);

      virtual ~BuildBondsProcessor();


      virtual bool finish();

      virtual bool start();

      virtual Processor::Result operator () (Fragment& fragment);

      
      Size getNumberOfBondsBuilt();

      void setFragmentDB(const FragmentDB& fragment_db);



      Size buildFragmentBonds(Fragment& fragment) const;

      Size buildFragmentBonds(Fragment& fragment, const Fragment& tplate) const
        throw(Exception::TooManyBonds);

      Size buildInterFragmentBonds(Fragment& first, Fragment& second) const
        throw(Exception::TooManyBonds);


      protected:

      void storeConnections_(Fragment& fragment);

      bool buildConnection_(Connection& con1, Connection& con2)
        throw(Exception::TooManyBonds);
    
      FragmentDB*     fragment_db_;
      
      std::list<Fragment*>  fragment_list_;

      /*_ The number of bonds built.
          This value is reset in the start method, so each application of 
          the processor, so <TT>  getNumberOfBuiltBonds </TT> always returns
          the number of bonds built in the last application.
      */
      Size  bonds_built_;

      /*_ The list of connects between(!) fragments still to be examined
      */
      ConnectionList  connections_;
    };



    NormalizeNamesProcessor   normalize_names;

    ReconstructFragmentProcessor  add_hydrogens;

    BuildBondsProcessor       build_bonds;

    ResourceEntry*  tree;


    private:
      
    /*_ @name Parse functions
        These functions parse different sections of the fragment DB resource
        tree and translate everything into the correct data structures.
    */
    //_@{

    /*_ Parses the Atoms entry and creates the atoms of the fragment
    */
    void parseAtoms_(ResourceEntry& entry, Fragment& fragment);

    /*_ Parses the Bonds entry and creates the bonds of the fragment
    */
    void parseBonds_(ResourceEntry& entry, Fragment& fragment);

    /*_ Parses the properties of a fragment/variant and sets the corresponding properties.
        Properties are set or reset (if the property name starts with "!") for the current 
        fragment. All properties of fragment and residue are recognized, if they
        are written exactly as in the header file (case insensitive) and set.
        Unknown properties are set as name/value pairs as bool properties and set to 
        <b>  true </b>.
    */
    void parseProperties_(ResourceEntry& entry, PropertyManager& property_man);

    /*_ Parses the Delete section.
        All atoms given in this section are removed from the fragment.
    */
    void parseDelete_(ResourceEntry& entry, Fragment& fragment);

    /*_ Parses the Rename section.
        All atoms given in this section are renamed to the given new name.
    */
    void parseRename_(ResourceEntry& entry, Fragment& fragment);

    //_@}

    Position addNewFragment_(Residue* fragment);

    /*_ Expands all include directives in the resource file.
        This method calls expandFirst_ until it returns true. 
    */
    void expandTree_(ResourceEntry& root_entry);
   
    /*_ Expands the first occuring include directive.
        If no include directive is found, <b>  false </b> is returned, otherwise <b>  true </b>.
    */
    bool expandFirst_(ResourceEntry& root_entry)
      throw(Exception::FileNotFound);

    // The status of the FragmentDB
    bool            valid_;

    // The filename of the master fragment file.
    String          filename_;

    // The naming standard we default to.
    String          default_standard_;

    // An array containing all allocated residues.
    std::vector<Residue*>           fragments_;

    // Maps a fragment name back to a path in the database
    NameMap                         name_to_path_;

    // Maps a fragment name back to the array index in fragments_
    StringHashMap<Position>         name_to_frag_index_;

    // Maps all variants of a specific fragment back to array indices.
    StringHashMap<list<Position> >  name_to_variants_;

    // Contains the naming standards as a nested map.
    StringHashMap<NameMap>          standards_;
  };
  
} // namespace BALL 


#endif // BALL_STRUCTURE_FRAGMENTDB_H

---