stereo.h

Go to the documentation of this file.

/**********************************************************************
  stereo.h - OBStereo & OBStereoBase

  Copyright (C) 2009-2010 by Tim Vandermeersch

  This file is part of the Open Babel project.
  For more information, see <http://openbabel.org/>

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.
 **********************************************************************/
#ifndef OB_STEREO_H
#define OB_STEREO_H

#include <openbabel/base.h> // OBGenericData
#include <openbabel/isomorphism.h> // Automorphisms
#include <vector>
#include <map>
#include <set>
#include <climits> // UINT_MAX

namespace OpenBabel {


  struct OBAPI OBStereo
  {
    enum Type {
      CisTrans            = (1<<0), 
      ExtendedCisTrans    = (1<<1), 
      SquarePlanar        = (1<<2), 
      Tetrahedral         = (1<<3), 
      ExtendedTetrahedral = (1<<4), 
      TrigonalBipyramidal = (1<<5), 
      Octahedral          = (1<<6)  
    };

    enum BondDirection { // Values taken from MDL format
      NotStereo =   0,
      UpBond =      1,
      DownBond =    6,
      UnknownDir =  4
    };

    enum Shape {
      ShapeU = 1,
      ShapeZ = 2,
      Shape4 = 3
    };

    enum View
    {
      ViewFrom = 1, 
      ViewTowards = 2 
    };

    enum Winding {
      Clockwise = 1,     
      AntiClockwise = 2, 
      UnknownWinding = 3 
    };



    typedef unsigned long Ref;
    enum {
      NoRef = UINT_MAX,       
      ImplicitRef = UINT_MAX - 1  
    };
    typedef std::vector<Ref> Refs;
    typedef Refs::iterator RefIter;
    typedef Refs::const_iterator ConstRefIter;



    static Refs MakeRefs(Ref ref1, Ref ref2, Ref ref3, Ref ref4 = NoRef)
    {
      Refs refs(3);
      refs[0] = ref1;
      refs[1] = ref2;
      refs[2] = ref3;
      if (ref4 != NoRef)
        refs.push_back(ref4);
      return refs;
    }
    static bool ContainsSameRefs(const Refs &refs1, const Refs &refs2);
    static bool ContainsRef(const Refs &refs, unsigned long ref);



    static int NumInversions(const Refs &refs);
    static void Permutate(Refs &refs, int i, int j);
    static Refs Permutated(const Refs &refs, int i, int j);

  };

  struct OBStereoUnit
  {
    OBStereoUnit() : type(static_cast<OBStereo::Type>(0)), id(OBStereo::NoRef), para(false)
    {
    }

    OBStereoUnit(OBStereo::Type _type, unsigned long _id, bool _para = false) :
        type(_type), id(_id), para(_para)
    {
    }

    OBStereo::Type type; 
    unsigned long id; 
    bool para; 
  };
  typedef std::vector<OBStereoUnit> OBStereoUnitSet;
  typedef std::vector<OBStereoUnitSet> OBStereoUnitSetOfSets;


  // fwd decl
  class OBMol;
  class OBAPI OBStereoBase : public OBGenericData
  {
    public:
      OBStereoBase(OBMol *mol) :
        OBGenericData("StereoData", OBGenericDataType::StereoData, perceived),
        m_mol(mol), m_specified(true)
      {
      }
      virtual ~OBStereoBase() { m_mol = 0; }



      OBMol* GetMolecule() const { return m_mol; }
      virtual OBStereo::Type GetType() const = 0;
      void SetSpecified(bool specified) { m_specified = specified; }
      bool IsSpecified() const { return m_specified; }
    private:
      OBMol *m_mol; 
      bool m_specified; 
  };

  // fwd decl
  class OBTetrahedralStereo;
  class OBCisTransStereo;
  class OBSquarePlanarStereo;
  class OBAPI OBStereoFacade
  {
    public:
      OBStereoFacade(OBMol *mol, bool perceive = true) :
          m_mol(mol), m_init(false), m_perceive(perceive)
      {
      }


      unsigned int NumTetrahedralStereo();
      bool HasTetrahedralStereo(unsigned long atomId);
      OBTetrahedralStereo* GetTetrahedralStereo(unsigned long atomId);


      unsigned int NumCisTransStereo();
      bool HasCisTransStereo(unsigned long bondId);
      OBCisTransStereo* GetCisTransStereo(unsigned long bondId);


      unsigned int NumSquarePlanarStereo();
      bool HasSquarePlanarStereo(unsigned long atomId);
      OBSquarePlanarStereo* GetSquarePlanarStereo(unsigned long atomId);

      template<int StereoType>
      bool HasStereo(unsigned long id);
      template<typename T>
      T* GetStereo(unsigned long id);


    private:
      inline void EnsureInit() { if (!m_init) InitMaps(); }
      void InitMaps();

      OBMol *m_mol;
      bool m_init;
      bool m_perceive;
      std::map<unsigned long, OBTetrahedralStereo*> m_tetrahedralMap;
      std::map<unsigned long, OBCisTransStereo*> m_cistransMap;
      std::map<unsigned long, OBSquarePlanarStereo*> m_squarePlanarMap;
  };

  // fwd decl
  class OBBond;

  OBAPI void PerceiveStereo(OBMol *mol, bool force = false);
  OBAPI void StereoFrom2D(OBMol *mol,
    std::map<OBBond*, enum OBStereo::BondDirection> *updown = NULL, bool force = false);
  OBAPI void StereoFrom3D(OBMol *mol, bool force = false);
  OBAPI void StereoFrom0D(OBMol *mol);


  OBAPI std::vector<OBTetrahedralStereo*> TetrahedralFrom3D(OBMol *mol,
      const OBStereoUnitSet &stereoUnits, bool addToMol = true);
  OBAPI std::vector<OBTetrahedralStereo*> TetrahedralFrom2D(OBMol *mol,
      const OBStereoUnitSet &stereoUnits, bool addToMol = true);
  OBAPI std::vector<OBTetrahedralStereo*> TetrahedralFrom0D(OBMol *mol,
      const OBStereoUnitSet &stereoUnits, bool addToMol = true);

  OBAPI std::vector<OBCisTransStereo*> CisTransFrom3D(OBMol *mol,
      const OBStereoUnitSet &stereoUnits, bool addToMol = true);
  OBAPI std::vector<OBCisTransStereo*> CisTransFrom2D(OBMol *mol,
      const OBStereoUnitSet &stereoUnits,
      const std::map<OBBond*, enum OBStereo::BondDirection> *updown = NULL, bool addToMol = true);
  OBAPI bool TetStereoToWedgeHash(OBMol &mol,
      std::map<OBBond*, enum OBStereo::BondDirection> &updown,
      std::map<OBBond*, OBStereo::Ref> &from);
  OBAPI std::set<OBBond*> GetUnspecifiedCisTrans(OBMol& mol);
  OBAPI void StereoRefToImplicit(OBMol& mol, OBStereo::Ref atomId);
  OBAPI std::vector<OBCisTransStereo*> CisTransFrom0D(OBMol *mol,
      const OBStereoUnitSet &stereoUnits,
      bool addToMol = true);



  OBAPI OBStereoUnitSet FindStereogenicUnits(OBMol *mol,
      const std::vector<unsigned int> &symClasses);
  OBAPI OBStereoUnitSet FindStereogenicUnits(OBMol *mol,
      const std::vector<unsigned int> &symClasses,
      const Automorphisms &automorphisms);


}

#endif