buildBondsProcessor.h

Go to the documentation of this file.

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

#ifndef BALL_STRUCTURE_BUILDBONDSPROCESSOR_H
#define BALL_STRUCTURE_BUILDBONDSPROCESSOR_H

#ifndef BALL_CONCEPT_PROCESSOR_H
  #include <BALL/CONCEPT/processor.h>
#endif

#ifndef BALL_KERNEL_ATOMCONTAINER_H
  #include <BALL/KERNEL/atomContainer.h>
#endif

#ifndef BALL_DATATYPE_HASHMAP_H
  #include <BALL/DATATYPE/hashMap.h>
#endif

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

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

namespace BALL 
{

  class BALL_EXPORT BuildBondsProcessor 
    : public UnaryProcessor<AtomContainer> 
  {

    public:

      struct BALL_EXPORT Option
      {
        static const char* BONDLENGTHS_FILENAME;
        
        static const char* DELETE_EXISTING_BONDS;

        static const char* REESTIMATE_BONDORDERS_RINGS;

        static const char* DELETE_OVERESTIMATED_BONDS;
      };

      struct BALL_EXPORT Default
      {
        static const char* BONDLENGTHS_FILENAME;
        
        static const bool DELETE_EXISTING_BONDS;

        static const bool REESTIMATE_BONDORDERS_RINGS;

        static const bool DELETE_OVERESTIMATED_BONDS;
      };
    


      BALL_CREATE(BuildBondsProcessor);
      
      BuildBondsProcessor();
    
      BuildBondsProcessor(const BuildBondsProcessor& bbp);
    
      BuildBondsProcessor(const String& file_name) throw(Exception::FileNotFound);
      
      virtual ~BuildBondsProcessor();


      virtual bool start();

      virtual Processor::Result operator () (AtomContainer& ac);

      Size getNumberOfBondsBuilt();

      void setBondLengths(const String& file_name) throw(Exception::FileNotFound);

      HashMap<Size, HashMap<Size, HashMap<int, float> > > getBondMap() { return bond_lengths_;};


      BuildBondsProcessor& operator = (const BuildBondsProcessor& bbp);

      Options options;

      void setDefaultOptions();
      
    protected:
    
      Size buildBondsHashGrid3_(AtomContainer& ac);
    
      void estimateBondOrders_(AtomContainer& ac);

      void reestimateBondOrdersRings_(AtomContainer& ac);

      void deleteOverestimatedBonds_(AtomContainer& ac);
      
      void readBondLengthsFromFile_(const String& file_name = "") throw(Exception::FileNotFound);
      
      Size num_bonds_;
    
      HashMap<Size, HashMap<Size, HashMap<int, float> > > bond_lengths_;

      HashMap<Size, HashMap<Size, float> > max_bond_lengths_;

      HashMap<Size, HashMap<Size, float> > min_bond_lengths_;

      /*_ returns the best fitting bond order of a bond between atoms of
          element e1 and element e2 with a distance of length
      */
      Bond::BondOrder getNearestBondOrder_(float length, Size e1, Size e2);

      /*_ Returns true if the atom with atomic number an1 and atom with
          atomic number an2 can share a bond. If, the parameter length
          holds the maximal length of such a bond.
      */
      bool getMaxBondLength_(float& length, Size an1, Size an2);

      /*_ Returns true if the atom with atomic number an1 and atom with
          atomic number an2 can share a bond. If, the parameter length
          holds the minimal length of such a bond.
      */
      bool getMinBondLength_(float& length, Size an1, Size an2);

      float max_length_;
  };

} // namespace BALL 


#endif // BALL_STRUCTURE_BUILDBONDSPROCESSOR_H