Atom.h

Go to the documentation of this file.

//
//  Copyright (C) 2001-2008 Greg Landrum and Rational Discovery LLC
//
//   @@ All Rights Reserved  @@
//
/*! \file Atom.h

  \brief Defines the Atom class and associated typedefs

*/  
#ifndef _RD_ATOM_H
#define _RD_ATOM_H

// Std stuff
#include <iostream>

// ours
#include <Query/QueryObjects.h>
#include <RDGeneral/types.h>


namespace RDKit{
  class ROMol;
  class RWMol;
  
  //! The class for representing atoms
  /*!

    <b>Notes:</b>
      - many of the methods of Atom require that the Atom be associated
        with a molecule (an ROMol).
      - each Atom maintains a Dict of \c properties:  
          - Each \c property is keyed by name and can store an
            arbitrary type.
          - \c Properties can be marked as \c calculated, in which case
            they will be cleared when the \c clearComputedProps() method
            is called.
          - Because they have no impact upon chemistry, all \c property
            operations are \c const, this allows extra flexibility for
            clients who need to store extra data on Atom objects.
      - Atom objects are lazy about computing their explicit and implicit valence
        values.  These will not be computed until their values are requested.

    <b>Chirality:</b>

    The chirality of an Atom is determined by two things:
      - its \c chiralTag
      - the input order of its bonds

    For tetrahedral coordination, the \c chiralTag tells you what
    direction you have to rotate to get from bond 2 to bond 3 while looking
    down bond 1. This is pretty much identical to the SMILES represenation of
    chirality
      
  */
  class Atom {
    friend class MolPickler; //!< the pickler needs access to our privates
    friend class ROMol;
    friend class RWMol;
  public:

    typedef boost::shared_ptr<Atom>    ATOM_SPTR;
    typedef boost::shared_ptr<const Atom>    C_ATOM_SPTR;
    // FIX: grn...
    typedef Queries::Query<int,Atom const *,true> QUERYATOM_QUERY;

    //! store hybridization
    typedef enum {
      UNSPECIFIED=0, //!< hybridization that hasn't been specified
      S,
      SP,
      SP2,
      SP3,
      SP3D,
      SP3D2,
      OTHER          //!< unrecognized hybridization
    } HybridizationType;

    //! store type of chirality
    typedef enum {
      CHI_UNSPECIFIED=0,  //!< chirality that hasn't been specified
      CHI_TETRAHEDRAL_CW, //!< tetrahedral: clockwise rotation (SMILES @@)
      CHI_TETRAHEDRAL_CCW,//!< tetrahedral: counter-clockwise rotation (SMILES @)
      CHI_OTHER           //!< some unrecognized type of chirality
    } ChiralType;

    Atom();
    //! construct an Atom with a particular atomic number
    explicit Atom(unsigned int num);
    //! construct an Atom with a particular symbol (looked up in the PeriodicTable)
    explicit Atom(std::string what);
    Atom(const Atom & other);
    virtual ~Atom();

    //! makes a copy of this Atom and returns a pointer to it.
    /*!
      <b>Note:</b> the caller is responsible for <tt>delete</tt>ing the result
    */
    virtual Atom *copy() const;

    //! returns our atomic number
    const int getAtomicNum() const { return d_atomicNum; };
    //! sets our atomic number
    void setAtomicNum(int newNum) { d_atomicNum = newNum; };

    //! returns our symbol (determined by our atomic number)
    std::string getSymbol() const;

    //! returns a reference to the ROMol that owns this Atom
    ROMol &getOwningMol() const { return *dp_mol; };
  
    //! returns our index within the ROMol
    const unsigned int getIdx() const {return d_index;};
    //! sets our index within the ROMol
    /*!
      <b>Notes:</b>
        - this makes no sense if we do not have an owning molecule
        - the index should be <tt>< this->getOwningMol()->getNumAtoms()</tt>
    */
    void setIdx(unsigned int index) {d_index=index;};

    //! returns the explicit degree of the Atom (number of bonded
    //!   neighbors in the graph)
    /*!
      <b>Notes:</b>
        - requires an owning molecule
    */
    unsigned int getDegree() const;

    //! returns the total degree of the Atom (number of bonded
    //!   neighbors + number of Hs)
    /*!
      <b>Notes:</b>
        - requires an owning molecule
    */
    unsigned int getTotalDegree() const;

    //! \brief returns the total number of Hs (implicit and explicit) that
    //! this Atom is bound to
    /*!
      <b>Notes:</b>
        - requires an owning molecule
    */
    unsigned int getTotalNumHs(bool includeNeighbors=false) const;

    //! returns the number of implicit Hs this Atom is bound to
    /*!
      <b>Notes:</b>
        - requires an owning molecule
    */
    unsigned int getNumImplicitHs() const;

    //! returns the number of explicit Hs this Atom is bound to
    int getExplicitValence() const;

    //! returns the implicit valence for this Atom
    /*!
      <b>Notes:</b>
        - requires an owning molecule
    */
    int getImplicitValence() const;

    //! returns the number of radical electrons for this Atom
    /*!
      <b>Notes:</b>
        - requires an owning molecule
    */
    unsigned int getNumRadicalElectrons() const { return d_numRadicalElectrons; };
    void setNumRadicalElectrons(unsigned int num) { d_numRadicalElectrons=num; };


    //! returns the formal charge of this atom
    const int getFormalCharge() const { return d_formalCharge; };
    //! set's the formal charge of this atom
    void setFormalCharge(int what) { d_formalCharge = what;} ;

    //! \brief sets our \c noImplicit flag, indicating whether or not
    //!  we are allowed to have implicit Hs
    void setNoImplicit( bool what ) { df_noImplicit = what; };
    //! returns the \c noImplicit flag
    bool getNoImplicit() const { return df_noImplicit; };
    
    //! sets our number of explict Hs
    void setNumExplicitHs(unsigned int what) { d_numExplicitHs = what; };
    //! returns our number of explict Hs
    unsigned int getNumExplicitHs() const { return d_numExplicitHs; };
  
    //! sets our \c isAromatic flag, indicating whether or not we are aromatic
    void setIsAromatic( bool what ) { df_isAromatic = what; };
    //! returns our \c isAromatic flag
    bool getIsAromatic() const { return df_isAromatic; };

    //! sets our mass (for isotopes)
    void setMass( double what) { d_mass = what; };
    //! returns our mass
    double getMass() const {return d_mass; };

    //! sets our \c dativeFlag
    // intended to be used only in construction.
    // NOTE: the dative flag is not currently used anywhere
    void setDativeFlag(int what) {
      d_dativeFlag = what;
    };
    //! returns our \c dativeFlag
    // NOTE: the dative flag is not currently used anywhere
    int getDativeFlag() const {
      return d_dativeFlag;
    };
    bool hasDativeFlag(int what) const {
      return d_dativeFlag==what;
    };
    //! clears our \c dativeFlag
    // NOTE: the dative flag is not currently used anywhere
    void clearDativeFlag(){ d_dativeFlag = 0; };

    //! sets our \c chiralTag
    void setChiralTag(ChiralType what) { d_chiralTag = what; };
    //! inverts our \c chiralTag
    void invertChirality();
    //! returns our \c chiralTag
    ChiralType getChiralTag() const { return d_chiralTag; };

    //! sets our hybridization
    void setHybridization(HybridizationType what) { d_hybrid = what; };
    //! returns our hybridization
    HybridizationType getHybridization() const { return d_hybrid; };

    // ------------------------------------
    // Some words of explanation before getting down into
    // the query stuff.
    // These query functions are really only here so that they
    //  can have real functionality in subclasses (like QueryAtoms).
    // Since pretty much it's gonna be a mistake to call any of these
    //  (ever), we're saddling them all with a precondition which
    //  is guaranteed to fail.  I'd like to have them be pure virtual,
    //  but that doesn't work since we need to be able to instantiate
    //  Atoms.
    // ------------------------------------

    // This method can be used to distinguish query atoms from standard atoms:
    virtual bool hasQuery() const { return false; };
   
    //! NOT CALLABLE
    virtual void setQuery(QUERYATOM_QUERY *what);

    //! NOT CALLABLE
    virtual QUERYATOM_QUERY *getQuery() const;
    //! NOT CALLABLE
    virtual void expandQuery(QUERYATOM_QUERY *what,
                             Queries::CompositeQueryType how=Queries::COMPOSITE_AND,
                             bool maintainOrder=true);

    //! returns whether or not we match the argument
    /*!
        <b>Notes:</b>
          - for Atom objects, "match" means that atomic numbers are the same.
    */
    virtual bool Match(Atom const *what) const;
    //! \overload
    virtual bool Match(const ATOM_SPTR what) const;
  

    // ------------------------------------
    //  Local Property Dict functionality
    //  all setProp functions are const because they
    //     are not meant to change the atom chemically 
    // ------------------------------------
    //! returns a list with the names of our \c properties
    STR_VECT getPropList() const {
      return dp_props->keys();
    }

    //! sets a \c property value
    /*!
       \param key the name under which the \c property should be stored.
           If a \c property is already stored under this name, it will be
           replaced.
       \param val the value to be stored
       \param computed (optional) allows the \c property to be flagged
           \c computed.
     */
    template <typename T>
    void setProp(const char *key, T val, bool computed=false) const{
    
      //if(!dp_props) dp_props = new Dict();
      std::string what(key);
      setProp(what,val, computed);
    }

    //! \overload
    template <typename T>
    void setProp(const std::string key, T val, bool computed=false) const {
      if (computed) {
        STR_VECT compLst;
        if(hasProp("computedProps")) getProp("computedProps", compLst);
        if (std::find(compLst.begin(), compLst.end(), key) == compLst.end()) {
          compLst.push_back(key);
          dp_props->setVal("computedProps", compLst);
        }
      }
      //setProp(key.c_str(),val);
      dp_props->setVal(key, val);
    }

    //! allows retrieval of a particular property value
    /*!

       \param key the name under which the \c property should be stored.
           If a \c property is already stored under this name, it will be
           replaced.
       \param res a reference to the storage location for the value.

       <b>Notes:</b>
         - if no \c property with name \c key exists, a KeyErrorException will be thrown.
         - the \c boost::lexical_cast machinery is used to attempt type conversions.
           If this fails, a \c boost::bad_lexical_cast exception will be thrown.

    */
    template <typename T>
    void getProp(const char *key,T &res) const {
      //PRECONDITION(dp_props,"getProp called on empty property dict");
      dp_props->getVal(key,res);
    }
    //! \overload
    template <typename T>
    void getProp(const std::string key,T &res) const {
      //return getProp(key.c_str(),res);
      dp_props->getVal(key,res);
    }

    //! returns whether or not we have a \c property with name \c key
    bool hasProp(const char *key) const {
      if(!dp_props) return false;
      return dp_props->hasVal(key);
    };
    //! \overload
    bool hasProp(const std::string key) const {
      if(!dp_props) return false;
      return dp_props->hasVal(key);
    };

    
    //! clears the value of a \c property
    /*!
       <b>Notes:</b>
         - if no \c property with name \c key exists, a KeyErrorException
           will be thrown.
         - if the \c property is marked as \c computed, it will also be removed
           from our list of \c computedProperties
    */
    void clearProp(const char *key) const {
      std::string what(key);
      clearProp(what);
    };
    //! \overload
    void clearProp(const std::string key) const {
      if(hasProp("computedProps")){
        STR_VECT compLst;
        getProp("computedProps", compLst);
        STR_VECT_I svi = std::find(compLst.begin(), compLst.end(), key);
        if (svi != compLst.end()) {
          compLst.erase(svi);
          dp_props->setVal("computedProps", compLst);
        }
      }    
      dp_props->clearVal(key);
    };

    //! clears all of our \c computed \c properties
    void clearComputedProps() const {
      if(!hasProp("computedProps")) return;
      STR_VECT compLst;
      getProp("computedProps", compLst);
      STR_VECT_CI svi;
      for (svi = compLst.begin(); svi != compLst.end(); svi++) {
        dp_props->clearVal(*svi);
      }
      compLst.clear();
      dp_props->setVal("computedProps", compLst);
    }

    //! returns the perturbation order for a list of integers
    /*!

      This value is associated with chirality.

      \param probe a list of bond indices.  This must be the same
        length as our number of incoming bonds (our degree).
      
      \return the number of swaps required to convert the ordering
        of the probe list to match the order of our incoming bonds:
        e.g. if our incoming bond order is: <tt>[0,1,2,3]</tt>
        \verbatim
        getPerturbationOrder([1,0,2,3]) = 1
        getPerturbationOrder([1,2,3,0]) = 3
        getPerturbationOrder([1,2,0,3]) = 2
        \endverbatim

      See the class documentation for a more detailed description
      of our representation of chirality.

      <b>Notes:</b>
        - requires an owning molecule
      
    */
    int getPerturbationOrder(INT_LIST probe) const;

    //! calculates any of our lazy \c properties
    /*!
      <b>Notes:</b>
        - requires an owning molecule
        - the current lazy \c properties are implicit and explicit valence
    */
    void updatePropertyCache(bool strict=true);

    //! calculates and returns our explicit valence
    /*!
      <b>Notes:</b>
        - requires an owning molecule
    */
    int calcExplicitValence(bool strict=true);

    //! calculates and returns our implicit valence
    /*!
      <b>Notes:</b>
        - requires an owning molecule
    */
    int calcImplicitValence(bool strict=true);

  protected:
    //! sets our owning molecule
    void setOwningMol(ROMol *other);
    //! sets our owning molecule
    void setOwningMol(ROMol &other) {setOwningMol(&other);};

    bool df_isAromatic; 
    bool df_noImplicit;
    int d_dativeFlag;
    unsigned int d_numExplicitHs;
    int d_formalCharge;
    unsigned int d_atomicNum;
    unsigned int d_index;
    // NOTE that these cannot be signed ints, they are calculated using
    // a lazy scheme and are initialized to -1 to indicate that the
    // calculation has not yet been done.
    int d_implicitValence, d_explicitValence;
    unsigned int d_numRadicalElectrons;
    ChiralType d_chiralTag;
    HybridizationType d_hybrid;
    double d_mass;
    ROMol *dp_mol;
    Dict *dp_props;
    void initAtom();
  };

};
//! allows Atom objects to be dumped to streams
std::ostream & operator<<(std::ostream& target, const RDKit::Atom &at);

#endif