hybridisationProcessor.h

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

#ifndef BALL_STRUCTURE_HYBRIDISATIONPROCESSOR_H
#define BALL_STRUCTURE_HYBRIDISATIONPROCESSOR_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

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


#include <map>


namespace BALL 
{

  class BALL_EXPORT HybridisationProcessor 
    : public UnaryProcessor<AtomContainer> 
  {

    public:


      struct BALL_EXPORT Option
      {
        static const char* ATOM_TYPE_SMARTS_FILENAME;
        
        static const char* ATOM_TYPE_FF_FILENAME;
        
        static const String METHOD; 

      };

      struct BALL_EXPORT Default
      {
        static const char* ATOM_TYPE_SMARTS_FILENAME;
        
        static const char* ATOM_TYPE_FF_FILENAME;
        
        static const String METHOD;
      };

      struct BALL_EXPORT Method
      {
        static const String SMART_MATCHING;
        static const String STRUCTURE_BASED; 
        static const String FF_BASED; 
      };


    


      BALL_CREATE(HybridisationProcessor);
      
      HybridisationProcessor();
    
      HybridisationProcessor(const HybridisationProcessor& hp);
    
      HybridisationProcessor(const String& smarts_file_name, const String& ff_file_name) throw(Exception::FileNotFound);
      
      virtual ~HybridisationProcessor();


      virtual bool start();

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


      Size getNumberOfHybridisationStatesSet(); 

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

      vector< std::pair<String, Size> > getHybridisationMap() { return atom_type_smarts_;};


      HybridisationProcessor& operator = (const HybridisationProcessor& hp);


      Options options;

      void setDefaultOptions();
      
    protected:
      
      struct Elements_
      {
        String type;
        unsigned char hyb;
      };
      
      struct AtomNames_
      {
        String a1;
        String a2;
        String a3;
      };
      
      bool readAtomTypeSmartsFromFile_(const String& file_name = "") throw(Exception::FileNotFound);
      
      Size num_hybridisation_states_;

      vector< std::pair<String, Size> > atom_type_smarts_;
      
      StringHashMap<StringHashMap<StringHashMap<std::multimap<float, AtomNames_> > > > bond_angles_;
      
      bool readAndInitBondAnglesFromFile_(const String& file_name = "") throw(Exception::FileNotFound);
      
      StringHashMap<Elements_> elements_;
      

      bool valid_;
      
  
      double AverageBondAngle_(Atom* a);

  };

} // namespace BALL 


#endif // BALL_STRUCTURE_HYBRIDISATIONPROCESSOR_H

---