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, unsigned int i, unsigned int j);
 static Refs Permutated(const Refs &refs, unsigned int i, unsigned 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 void ImplicitRefToStereo(OBMol& mol, OBStereo::Ref centerId, OBStereo::Ref newId);
 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