en/latest/a00077_source.html

 /*  ObjCryst++ Object-Oriented Crystallographic Library

     (c) 2000-2002 Vincent Favre-Nicolin vincefn@users.sourceforge.net

         2000-2001 University of Geneva (Switzerland)


     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;  version 2 of the License.


     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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

 /*   Molecule.h

 *  header file for the Molecule scatterer

 *

 */

 #ifndef _OBJCRYST_MOLECULE_H_

 #define _OBJCRYST_MOLECULE_H_


 #include <string>

 #include <vector>

 #include <map>

 #include <set>

 #include <list>


 #include "ObjCryst/ObjCryst/General.h"

 #include "ObjCryst/ObjCryst/ScatteringPower.h"

 #include "ObjCryst/ObjCryst/Scatterer.h"


 namespace ObjCryst

 {

 class MolAtom;

 class MolBond;

 class Molecule;


 struct XYZ

 {

    XYZ(REAL x=0,REAL y=0,REAL z=0);

    REAL x,y,z;

 };


 class MolAtom

 {

    public:

       MolAtom(const REAL x, const REAL y, const REAL z,

               const ScatteringPower *pPow, const string &name,

               Molecule &parent);

       virtual ~MolAtom();

       void SetName(const string &name);

       const string& GetName()const;

       string& GetName();

       const Molecule& GetMolecule()const;

       Molecule& GetMolecule();

       const REAL& X()const;

       const REAL& Y()const;

       const REAL& Z()const;

       REAL& X();

       REAL& Y();

       REAL& Z();

       REAL GetX()const;

       REAL GetY()const;

       REAL GetZ()const;

       REAL GetOccupancy()const;

       void SetX(const REAL)const;

       void SetY(const REAL)const;

       void SetZ(const REAL)const;

       void SetOccupancy(const REAL);

       bool IsDummy()const;

       const ScatteringPower& GetScatteringPower()const;

       void SetScatteringPower(const ScatteringPower&);

       virtual void XMLOutput(ostream &os,int indent=0)const;

       virtual void XMLInput(istream &is,const XMLCrystTag &tag);

       void SetIsInRing(const bool r)const;

       bool IsInRing()const;

       void SetNonFlipAtom(const bool nonflip);

       bool IsNonFlipAtom() const;

       size_t int_ptr() const;

    private:

       string mName;

       /* Get the atom at the other end of bond #i

       MolAtom & GetBondedAtom(unsigned int i);

       */

       mutable REAL mX,mY,mZ;

       REAL mOccupancy;

       const ScatteringPower* mpScattPow;

       Molecule *mpMol;

       mutable bool mIsInRing;

       bool mIsNonFlipAtom;

    #ifdef __WX__CRYST__

    public:

       WXCrystObjBasic *mpWXCrystObj;

       virtual WXCrystObjBasic* WXCreate(wxWindow*);

       WXCrystObjBasic* WXGet();

       void WXDelete();

       void WXNotifyDelete();

    #endif

 };


 REAL GetBondLength(const MolAtom&,const MolAtom&);

 REAL GetBondAngle(const MolAtom&,const MolAtom&,const MolAtom&);

 REAL GetDihedralAngle(const MolAtom&,const MolAtom&,const MolAtom&,const MolAtom&);


 class MolBond:public Restraint

 {

    public:

       MolBond(MolAtom &atom1, MolAtom &atom2,

               const REAL length, const REAL sigma, const REAL delta,

               Molecule &parent,const REAL bondOrder=1.);

       virtual ~MolBond();

       const Molecule& GetMolecule()const;

       Molecule& GetMolecule();

       string GetName()const;

       virtual void XMLOutput(ostream &os,int indent=0)const;

       virtual void XMLInput(istream &is,const XMLCrystTag &tag);

       virtual REAL GetLogLikelihood()const;

       REAL GetLogLikelihood(const bool calcDeriv, const bool recalc)const;

       REAL GetDeriv(const std::map<const MolAtom*,XYZ> &m, const bool llk=false)const;

       void CalcGradient(std::map<MolAtom*,XYZ> &m)const;

       const MolAtom& GetAtom1()const;

       const MolAtom& GetAtom2()const;

       MolAtom& GetAtom1();

       MolAtom& GetAtom2();

       void SetAtom1(MolAtom &at1);

       void SetAtom2(MolAtom &at2);

       REAL GetLength()const;

       REAL GetLength0()const;

       REAL GetLengthDelta()const;

       REAL GetLengthSigma()const;

       REAL GetBondOrder()const;

       REAL& Length0();

       REAL& LengthDelta();

       REAL& LengthSigma();

       REAL& BondOrder();

       void SetLength0(const REAL length);

       void SetLengthDelta(const REAL length);

       void SetLengthSigma(const REAL length);

       void SetBondOrder(const REAL length);

       bool IsFreeTorsion()const;

       void SetFreeTorsion(const bool isInRing);

       size_t int_ptr() const;

   private:

       pair<MolAtom*,MolAtom*> mAtomPair;

       REAL mLength0,mDelta,mSigma;

       REAL mBondOrder;

       bool mIsFreeTorsion;

       Molecule *mpMol;

       mutable REAL mLLK;

       mutable XYZ mDerivAtom1,mDerivAtom2;

       mutable REAL mDerivLLKCoeff;

    #ifdef __WX__CRYST__

    public:

       WXCrystObjBasic *mpWXCrystObj;

       virtual WXCrystObjBasic* WXCreate(wxWindow*);

       WXCrystObjBasic* WXGet();

       void WXDelete();

       void WXNotifyDelete();

    #endif

 };


 class MolBondAngle:public Restraint

 {

    public:

       MolBondAngle(MolAtom &atom1,MolAtom &atom2,MolAtom &atom3,

                    const REAL angle, const REAL sigma, const REAL delta,

                    Molecule &parent);

       virtual ~MolBondAngle();

       const Molecule& GetMolecule()const;

       Molecule& GetMolecule();

       string GetName()const;

       virtual void XMLOutput(ostream &os,int indent=0)const;

       virtual void XMLInput(istream &is,const XMLCrystTag &tag);

       virtual REAL GetLogLikelihood()const;

       REAL GetLogLikelihood(const bool calcDeriv, const bool recalc)const;

       REAL GetDeriv(const std::map<const MolAtom*,XYZ> &m, const bool llk=false)const;

       void CalcGradient(std::map<MolAtom*,XYZ> &m)const;

       REAL GetAngle()const;

       REAL& Angle0();

       REAL& AngleDelta();

       REAL& AngleSigma();

       REAL GetAngle0()const;

       REAL GetAngleDelta()const;

       REAL GetAngleSigma()const;

       void SetAngle0(const REAL angle);

       void SetAngleDelta(const REAL delta);

       void SetAngleSigma(const REAL sigma);

       const MolAtom& GetAtom1()const;

       const MolAtom& GetAtom2()const;

       const MolAtom& GetAtom3()const;

       void SetAtom1(MolAtom &at);

       void SetAtom2(MolAtom &at);

       void SetAtom3(MolAtom &at);

       MolAtom& GetAtom1();

       MolAtom& GetAtom2();

       MolAtom& GetAtom3();

       bool IsFlexible()const;

       void SetFlexible(const bool isInRing);

       std::size_t size() const;

       vector<MolAtom*>::const_iterator begin() const;

       vector<MolAtom*>::const_iterator end() const;

       size_t int_ptr() const;

    private:

       vector<MolAtom*> mvpAtom;

       REAL mAngle0,mDelta,mSigma;

       Molecule *mpMol;

       bool mIsFlexible;

       mutable REAL mLLK;

       mutable XYZ mDerivAtom1,mDerivAtom2,mDerivAtom3;

       mutable REAL mDerivLLKCoeff;

    #ifdef __WX__CRYST__

    public:

       WXCrystObjBasic *mpWXCrystObj;

       virtual WXCrystObjBasic* WXCreate(wxWindow*);

       WXCrystObjBasic* WXGet();

       void WXDelete();

       void WXNotifyDelete();

    #endif

 };


 class MolDihedralAngle:public Restraint

 {

    public:

       MolDihedralAngle(MolAtom &atom1, MolAtom &atom2,

                        MolAtom &atom3, MolAtom &atom4,

                        const REAL angle, const REAL sigma, const REAL delta,

                        Molecule &parent);

       virtual ~MolDihedralAngle();

       const Molecule& GetMolecule()const;

       Molecule& GetMolecule();

       string GetName()const;

       virtual void XMLOutput(ostream &os,int indent=0)const;

       virtual void XMLInput(istream &is,const XMLCrystTag &tag);

       virtual REAL GetLogLikelihood()const;

       REAL GetLogLikelihood(const bool calcDeriv, const bool recalc)const;

       REAL GetDeriv(const std::map<const MolAtom*,XYZ> &m, const bool llk=false)const;

       void CalcGradient(std::map<MolAtom*,XYZ> &m)const;

       REAL GetAngle()const;

       REAL& Angle0();

       REAL& AngleDelta();

       REAL& AngleSigma();

       REAL GetAngle0()const;

       REAL GetAngleDelta()const;

       REAL GetAngleSigma()const;

       void SetAngle0(const REAL angle);

       void SetAngleDelta(const REAL delta);

       void SetAngleSigma(const REAL sigma);

       const MolAtom& GetAtom1()const;

       const MolAtom& GetAtom2()const;

       const MolAtom& GetAtom3()const;

       const MolAtom& GetAtom4()const;

       void SetAtom1(MolAtom& at);

       void SetAtom2(MolAtom& at);

       void SetAtom3(MolAtom& at);

       void SetAtom4(MolAtom& at);

       MolAtom& GetAtom1();

       MolAtom& GetAtom2();

       MolAtom& GetAtom3();

       MolAtom& GetAtom4();

       std::size_t size() const;

       vector<MolAtom*>::const_iterator begin() const;

       vector<MolAtom*>::const_iterator end() const;

       size_t int_ptr() const;

    private:

       vector<MolAtom*> mvpAtom;

       REAL mAngle0, mDelta, mSigma;

       Molecule *mpMol;

       mutable REAL mLLK;

       mutable XYZ mDerivAtom1,mDerivAtom2,mDerivAtom3,mDerivAtom4;

       mutable REAL mDerivLLKCoeff;

    #ifdef __WX__CRYST__

    public:

       WXCrystObjBasic *mpWXCrystObj;

       virtual WXCrystObjBasic* WXCreate(wxWindow*);

       WXCrystObjBasic* WXGet();

       void WXDelete();

       void WXNotifyDelete();

    #endif

 };


 class MolRing

 {

    public:

       MolRing();

       const std::list<MolAtom*>& GetAtomList()const;

       std::list<MolAtom*>& GetAtomList();

       size_t int_ptr() const;

    private:

       std::list<MolAtom*> mvpAtom;

 };


 class Quaternion

 {

    public:

       Quaternion();

       Quaternion(const REAL q0,const REAL q1,const REAL q2,const REAL q3,bool unit=true);

       ~Quaternion();

       static Quaternion  RotationQuaternion(const REAL ang,const REAL v1,const REAL v2,const REAL v3);

       Quaternion  GetConjugate()const;

       Quaternion operator*(const Quaternion &q)const;

       void operator*=(const Quaternion &q);

       void XMLOutput(ostream &os,int indent=0)const;

       void XMLInput(istream &is,const XMLCrystTag &tag);

       void RotateVector(REAL &v1,REAL &v2, REAL &v3)const;

       void Normalize()const ;

       REAL GetNorm()const;

       const REAL& Q0()const;

       const REAL& Q1()const;

       const REAL& Q2()const;

       const REAL& Q3()const;

       REAL& Q0();

       REAL& Q1();

       REAL& Q2();

       REAL& Q3();

    private:

       mutable REAL mQ0,mQ1,mQ2,mQ3;

       bool mIsUniQuaternion;

 };


 class RigidGroup:public std::set<MolAtom *>

 {

    public:

       std::string GetName()const;

       mutable Quaternion mQuat;

       mutable REAL mX,mY,mZ;

       mutable std::set<unsigned int> mvIdx;

       size_t int_ptr() const;

 };


 struct StretchMode

 {

    virtual ~StretchMode();

    virtual void CalcDeriv(const bool derivllk=true)const=0;

    virtual void Print(ostream &os,bool full=true)const=0;

    virtual void Stretch(const REAL change, const bool keepCenter=true)=0;

    virtual void RandomStretch(const REAL amplitude, const bool keepCenter=true)=0;

    std::map<const MolBond*,REAL> mvpBrokenBond;

    std::map<const MolBondAngle*,REAL> mvpBrokenBondAngle;

    std::map<const MolDihedralAngle*,REAL> mvpBrokenDihedralAngle;

    mutable REAL mLLKDeriv;

    mutable std::map<const MolAtom*,XYZ> mDerivXYZ;

    Molecule *mpMol;

    REAL mBaseAmplitude;

 };


 struct StretchModeBondLength:public StretchMode

 {

    StretchModeBondLength(MolAtom &at0,MolAtom &at1,const MolBond *pBond);

    virtual ~StretchModeBondLength();

    virtual void CalcDeriv(const bool derivllk=true)const;

    virtual void Print(ostream &os,bool full=true)const;

    virtual void Stretch(const REAL change, const bool keepCenter=true);

    virtual void RandomStretch(const REAL amplitude, const bool keepCenter=true);

    MolAtom * mpAtom0;

    MolAtom * mpAtom1;

    const MolBond *mpBond;

    set<MolAtom *> mvTranslatedAtomList;

 };


 struct StretchModeBondAngle:public StretchMode

 {

    StretchModeBondAngle(MolAtom &at0,MolAtom &at1,MolAtom &at2,

                         const MolBondAngle *pBondAngle);

    virtual ~StretchModeBondAngle();

    virtual void CalcDeriv(const bool derivllk=true)const;

    virtual void Print(ostream &os,bool full=true)const;

    virtual void Stretch(const REAL change, const bool keepCenter=true);

    virtual void RandomStretch(const REAL amplitude, const bool keepCenter=true);

    MolAtom * mpAtom0;

    MolAtom * mpAtom1;

    MolAtom * mpAtom2;

    const MolBondAngle *mpBondAngle;

    set<MolAtom *> mvRotatedAtomList;

 };

 struct StretchModeTorsion:public StretchMode

 {

    StretchModeTorsion(MolAtom &at1,MolAtom &at2,

                       const MolDihedralAngle *pDihedralAngle);

    virtual ~StretchModeTorsion();

    virtual void CalcDeriv(const bool derivllk=true)const;

    virtual void Print(ostream &os,bool full=true)const;

    virtual void Stretch(const REAL change, const bool keepCenter=true);

    virtual void RandomStretch(const REAL amplitude, const bool keepCenter=true);

    MolAtom * mpAtom1;

    MolAtom * mpAtom2;

    const MolDihedralAngle *mpDihedralAngle;

    set<MolAtom *> mvRotatedAtomList;

 };


 struct StretchModeTwist:public StretchMode

 {

    StretchModeTwist(MolAtom &at1,MolAtom &at2);

    virtual ~StretchModeTwist();

    virtual void CalcDeriv(const bool derivllk=true)const;

    virtual void Print(ostream &os,bool full=true)const;

    virtual void Stretch(const REAL change, const bool keepCenter=true);

    virtual void RandomStretch(const REAL amplitude, const bool keepCenter=true);

    MolAtom * mpAtom1;

    MolAtom * mpAtom2;

    set<MolAtom *> mvRotatedAtomList;

 };


 struct MDAtomGroup

 {

    MDAtomGroup();

    MDAtomGroup(std::set<MolAtom*> &vat,

                std::set<MolBond*> &vb,

                std::set<MolBondAngle*> &va,

                std::set<MolDihedralAngle*> &vd);

    void Print(ostream &os,bool full=true)const;

    std::set<MolAtom*> mvpAtom;

    std::vector<MolBond*> mvpBond;

    std::vector<MolBondAngle*> mvpBondAngle;

    std::vector<MolDihedralAngle*> mvpDihedralAngle;

 };


 struct MolZAtom

 {

    const ScatteringPower *mpPow;

    unsigned long mBondAtom,mBondAngleAtom,mDihedralAtom;

    REAL mBondLength,mBondAngle,mDihedralAngle;

 };


 class Molecule: public Scatterer

 {

    public:

       Molecule(Crystal &cryst, const string &name="");

       Molecule(const Molecule &old);

       ~Molecule();

       virtual Molecule* CreateCopy() const;

       virtual const string& GetClassName() const;

       virtual void SetName(const string &name);

       std::string GetFormula() const;

       virtual void Print()const;

       virtual void XMLOutput(ostream &os,int indent=0)const;

       virtual void XMLInput(istream &is,const XMLCrystTag &tag);

       virtual void UpdateDisplay()const;

       virtual void BeginOptimization(const bool allowApproximations=false,const bool enableRestraints=false);

       virtual void EndOptimization();

       virtual void RandomizeConfiguration();

       virtual void GlobalOptRandomMove(const REAL mutationAmplitude,

                                        const RefParType *type);

       virtual REAL GetLogLikelihood()const;


       virtual unsigned int GetNbLSQFunction()const;

       virtual const CrystVector_REAL& GetLSQCalc(const unsigned int) const;

       virtual const CrystVector_REAL& GetLSQObs(const unsigned int) const;

       virtual const CrystVector_REAL& GetLSQWeight(const unsigned int) const;

       virtual const CrystVector_REAL& GetLSQDeriv(const unsigned int n, RefinablePar&par);


       virtual void TagNewBestConfig()const;

       virtual int GetNbComponent() const;

       virtual const ScatteringComponentList& GetScatteringComponentList() const;

       virtual string GetComponentName(const int i) const;

       virtual ostream& POVRayDescription(ostream &os,

                                          const CrystalPOVRayOptions &options)const;


 #ifdef OBJCRYST_GL

       virtual void GLInitDisplayList(const bool onlyIndependentAtoms=false,

                                      const REAL xMin=-.1,const REAL xMax=1.1,

                                      const REAL yMin=-.1,const REAL yMax=1.1,

                                      const REAL zMin=-.1,const REAL zMax=1.1,

                                      const bool displayEnantiomer=false,

                                      const bool displayNames=false,

                                      const bool hideHydrogens=false,

                                      const REAL fadeDistance=0,

                                      const bool fullMoleculeInLimits=false)const;

 #endif  // OBJCRYST_GL


       void AddAtom(const REAL x, const REAL y, const REAL z,

                    const ScatteringPower *pPow,const string &name,

                    const bool updateDisplay=true);

       vector<MolAtom*>::iterator RemoveAtom(MolAtom&, const bool del = true);


       void AddBond(MolAtom &atom1, MolAtom &atom2,

                    const REAL length, const REAL sigma, const REAL delta,

                    const REAL bondOrder=1.,

                    const bool updateDisplay=true);

       vector<MolBond*>::iterator RemoveBond(const MolBond&, const bool del = true);

       vector<MolBond*>::const_iterator FindBond(const MolAtom&,const MolAtom&)const;

       vector<MolBond*>::iterator FindBond(const MolAtom&,const MolAtom&);

       void AddBondAngle(MolAtom &atom1, MolAtom &atom2, MolAtom &atom3,

                         const REAL angle, const REAL sigma, const REAL delta,

                         const bool updateDisplay=true);

       vector<MolBondAngle*>::iterator RemoveBondAngle(const MolBondAngle&, const bool del = true);

       vector<MolBondAngle*>::const_iterator FindBondAngle(const MolAtom& at1,const MolAtom&at0,const MolAtom&at2)const;

       void AddDihedralAngle(MolAtom &atom1, MolAtom &atom2,

                             MolAtom &atom3, MolAtom &atom4,

                             const REAL angle, const REAL sigma, const REAL delta,

                             const bool updateDisplay=true);

       vector<MolDihedralAngle*>::iterator RemoveDihedralAngle(const MolDihedralAngle&, const bool del = true);

       vector<MolDihedralAngle*>::const_iterator FindDihedralAngle(const MolAtom &at1,

                                                                   const MolAtom &at2,

                                                                   const MolAtom &at3,

                                                                   const MolAtom &at4)const;

       void AddRigidGroup(const RigidGroup&,const bool updateDisplay=true);

       std::vector<RigidGroup*>::iterator RemoveRigidGroup(const RigidGroup &group,const bool updateDisplay=true, const bool del = true);


       MolAtom &GetAtom(unsigned int i);

       const MolAtom &GetAtom(unsigned int i)const;

       MolAtom &GetAtom(const string &name);

       const MolAtom &GetAtom(const string &name)const;


       vector<MolAtom*>::reverse_iterator FindAtom(const string &name);

       vector<MolAtom*>::const_reverse_iterator FindAtom(const string &name)const;


       void OptimizeConformation(const long nbTrial=10000,const REAL stopCost=0.);

       void OptimizeConformationSteepestDescent(const REAL maxStep=0.1,const unsigned nbStep=1);

       void MolecularDynamicsEvolve(std::map<MolAtom*,XYZ> &v0,const unsigned nbStep,const REAL dt,

                                    const std::vector<MolBond*> &vb,const std::vector<MolBondAngle*> &va,

                                    const std::vector<MolDihedralAngle*> &vd,

                                    std::map<RigidGroup*,std::pair<XYZ,XYZ> > &vr, REAL nrj0=0);

       const std::vector<MolAtom*>& GetAtomList()const;

       const std::vector<MolBond*>& GetBondList()const;

       const std::vector<MolBondAngle*>& GetBondAngleList()const;

       const std::vector<MolDihedralAngle*>& GetDihedralAngleList()const;

       std::vector<MolAtom*>& GetAtomList();

       std::vector<MolBond*>& GetBondList();

       std::vector<MolBondAngle*>& GetBondAngleList();

       std::vector<MolDihedralAngle*>& GetDihedralAngleList();


       std::list<StretchModeBondLength>& GetStretchModeBondLengthList();

       std::list<StretchModeBondAngle>& GetStretchModeBondAngleList();

       std::list<StretchModeTorsion>& GetStretchModeTorsionList();


       const std::list<StretchModeBondLength>& GetStretchModeBondLengthList()const;

       const std::list<StretchModeBondAngle>& GetStretchModeBondAngleList()const;

       const std::list<StretchModeTorsion>& GetStretchModeTorsionList()const;


       const std::vector<RigidGroup *>& GetRigidGroupList()const;

       std::vector<RigidGroup *>& GetRigidGroupList();


       void RotateAtomGroup(const MolAtom &at1,const MolAtom &at2,

                            const set<MolAtom *> &atoms, const REAL angle,

                            const bool keepCenter=true);

       void RotateAtomGroup(const MolAtom &at,const REAL vx,const REAL vy,const REAL vz,

                            const set<MolAtom *> &atoms, const REAL angle,

                            const bool keepCenter=true);

       void TranslateAtomGroup(const set<MolAtom *> &atoms,

                               const REAL dx,const REAL dy,const REAL dz,

                               const bool keepCenter=true);

       void RestraintStatus(ostream &os)const;

       void RestraintExport(ostream &os)const;

       const map<MolAtom *,set<MolAtom *> > & GetConnectivityTable();

       RefinableObjClock& GetBondListClock();

       const RefinableObjClock& GetBondListClock()const;

       RefinableObjClock& GetAtomPositionClock();

       const RefinableObjClock& GetAtomPositionClock()const;

       const RefinableObjClock& GetAtomScattPowClock()const;

       RefinableObjClock& GetAtomScattPowClock();

       RefinableObjClock& GetRigidGroupClock();

       const RefinableObjClock& GetRigidGroupClock()const;

       void RigidifyWithDihedralAngles();

       REAL BondLengthRandomChange(const StretchModeBondLength& mode, const REAL amplitude,

                                   const bool respectRestraint=true);

       REAL BondAngleRandomChange(const StretchModeBondAngle& mode, const REAL amplitude,

                                  const bool respectRestraint=true);

       REAL DihedralAngleRandomChange(const StretchModeTorsion& mode, const REAL amplitude,

                                      const bool respectRestraint=true);

       const MolAtom* GetCenterAtom()const;

       void SetCenterAtom(const MolAtom &at);

       const std::vector<MolZAtom>& AsZMatrix(const bool keeporder)const;

       void SetDeleteSubObjInDestructor(const bool b);

    public:

       virtual void InitRefParList();

       void BuildRingList();

       void BuildConnectivityTable()const;

       void BuildRotorGroup();

       void TuneGlobalOptimRotationAmplitude();

       void BuildFlipGroup();

       void BuildStretchModeBondLength();

       void BuildStretchModeBondAngle();

       void BuildStretchModeTorsion();

       void BuildStretchModeTwist();

       void BuildStretchModeGroups();

       void BuildMDAtomGroups();

       void UpdateScattCompList()const;

       void InitOptions();

       void ResetRigidGroupsPar()const;

       mutable ScatteringComponentList mScattCompList;

       vector<MolAtom*> mvpAtom;

       vector<MolBond*> mvpBond;

       vector<MolBondAngle*> mvpBondAngle;

       vector<MolDihedralAngle*> mvpDihedralAngle;

       map<MolAtom* , std::vector<MolBond*> > mvAtomBond;

       std::vector<RigidGroup*> mvRigidGroup;

       mutable list<MolRing> mvRing;

       Quaternion mQuat;

       // Flag indicating whether to destroy MolAtoms, MolBonds, MolBondAngles,

       // and MolDihedralAngles in the destructor (default true). Mofified by

       // SetDeleteSubObjInDestructor.

       bool mDeleteSubObjInDestructor;

       REAL mBaseRotationAmplitude;

       // Clocks

          RefinableObjClock mClockAtomList;

          RefinableObjClock mClockBondList;

          RefinableObjClock mClockBondAngleList;

          RefinableObjClock mClockDihedralAngleList;

          RefinableObjClock mClockRigidGroup;

          RefinableObjClock mClockRestraint;

          RefinableObjClock mClockAtomPosition;

          RefinableObjClock mClockAtomScattPow;

          RefinableObjClock mClockOrientation;

          mutable RefinableObjClock mClockLogLikelihood;

          mutable RefinableObjClock mClockConnectivityTable;

          mutable RefinableObjClock mClockRingList;

          mutable RefinableObjClock mClockRotorGroup;

          mutable RefinableObjClock mClockFlipGroup;

          mutable RefinableObjClock mClockStretchModeBondLength;

          mutable RefinableObjClock mClockStretchModeBondAngle;

          mutable RefinableObjClock mClockStretchModeTorsion;

          mutable RefinableObjClock mClockStretchModeTwist;

          mutable RefinableObjClock mClockMDAtomGroup;


       // For local minimization (EXPERIMENTAL)

          unsigned long mLocalParamSet;

          mutable unsigned long mRandomConformChangeNbTest;

          mutable unsigned long mRandomConformChangeNbAccept;

          mutable REAL mRandomConformChangeTemp;

          REAL mLastLogLike;

          bool mIsSelfOptimizing;

       RefObjOpt mFlexModel;


       RefObjOpt mFlipModel;


       RefObjOpt mAutoOptimizeConformation;


       RefObjOpt mOptimizeOrientation;


       RefObjOpt mMoleculeCenter;


       const MolAtom* mpCenterAtom;


       mutable map<MolAtom *,set<MolAtom *> > mConnectivityTable;

       struct RotorGroup

       {

          RotorGroup(const MolAtom &at1,const MolAtom &at2);

          const MolAtom * mpAtom1;

          const MolAtom * mpAtom2;

          set<MolAtom *> mvRotatedAtomList;

          REAL mBaseRotationAmplitude;

       };

       mutable list<RotorGroup> mvRotorGroupTorsion;

       mutable list<RotorGroup> mvRotorGroupTorsionSingleChain;

       mutable list<RotorGroup> mvRotorGroupInternal;

       struct FlipGroup

       {

          FlipGroup(const MolAtom &at0,const MolAtom &at1,const MolAtom &at2);

          const MolAtom * mpAtom0;

          const MolAtom * mpAtom1;

          const MolAtom * mpAtom2;

          list<pair<const MolAtom *,set<MolAtom *> > > mvRotatedChainList;

          mutable unsigned long mNbTest,mNbAccept;

       };

       void FlipAtomGroup(const FlipGroup&, const bool keepCenter=true);

       mutable list<FlipGroup> mvFlipGroup;


       // Group of atoms for random moves naturally respecting restraints

          mutable list<StretchModeBondLength> mvStretchModeBondLength;

          mutable list<StretchModeBondAngle> mvStretchModeBondAngle;

          mutable list<StretchModeTorsion> mvStretchModeTorsion;

          mutable list<StretchModeTwist> mvStretchModeTwist;


       mutable std::list<StretchMode*> mvpStretchModeFree;

       mutable std::list<StretchMode*> mvpStretchModeNotFree;

       struct StretchModeGroup

       {

          std::set<StretchMode*> mvpStretchMode;

          std::set<const MolBond*> mvpBrokenBond;

          std::set<const MolBondAngle*> mvpBrokenBondAngle;

          std::set<const MolDihedralAngle*> mvpBrokenDihedralAngle;

       };

       mutable list<MDAtomGroup> mvMDAtomGroup;

       mutable std::set<MolAtom*> mvMDFullAtomGroup;


    REAL mMDMoveFreq;

    REAL mMDMoveEnergy;


    mutable std::vector<MolZAtom> mAsZMatrix;


    mutable REAL mLogLikelihood;

    REAL mLogLikelihoodScale;

    mutable CrystVector_REAL mLSQCalc;

    mutable CrystVector_REAL mLSQObs;

    mutable CrystVector_REAL mLSQWeight;


    #ifdef __WX__CRYST__

    public:

       virtual WXCrystObjBasic* WXCreate(wxWindow*);

    #endif

 };


 void ExpandAtomGroupRecursive(MolAtom* atom,

                               const map<MolAtom*,set<MolAtom*> > &connect,

                               set<MolAtom*> &atomlist,const MolAtom* finalAtom=0);


 void ExpandAtomGroupRecursive(MolAtom* atom,

                               const map<MolAtom*,set<MolAtom*> > &connect,

                               map<MolAtom*,unsigned long> &atomlist,const unsigned long maxdepth, unsigned long depth=0);


 // Forward declaration

 class ZScatterer;


 Molecule *ZScatterer2Molecule(ZScatterer *scatt);


 }//namespace

 #endif

ObjCryst
The namespace which includes all objects (crystallographic and algorithmic) in ObjCryst++.
Definition: doc-main.h:25

ObjCryst::GetBondLength
REAL GetBondLength(const MolAtom &at1, const MolAtom &at2)
Get The Bond Length between two atoms.
Definition: Molecule.cpp:62

ObjCryst::ZScatterer2Molecule
Molecule * ZScatterer2Molecule(ZScatterer *scatt)
Converter from ZScatterer to a Molecule object.
Definition: Molecule.cpp:7949

ObjCryst::ExpandAtomGroupRecursive
void ExpandAtomGroupRecursive(MolAtom *atom, const map< MolAtom *, set< MolAtom * > > &connect, set< MolAtom * > &atomlist, const MolAtom *finalAtom)
Build recursively a list of atoms, starting from a one atom, and given a connectivity table.
Definition: Molecule.cpp:154

ObjCryst::GetDihedralAngle
REAL GetDihedralAngle(const MolAtom &at1, const MolAtom &at2, const MolAtom &at3, const MolAtom &at4)
Get The dihedral angle defined by 4 atoms.
Definition: Molecule.cpp:114

ObjCryst::GetBondAngle
REAL GetBondAngle(const MolAtom &at1, const MolAtom &at2, const MolAtom &at3)
Get The Bond Angle of 3 atoms.
Definition: Molecule.cpp:98

ObjCryst::Crystal
Crystal class: Unit cell, spacegroup, scatterers.
Definition: Crystal.h:98

ObjCryst::CrystalPOVRayOptions
Class to store POV-Ray output options.
Definition: General.h:178

ObjCryst::XYZ
Structure holding 3 coordinates, or deriviatives with respect to each of these coordinates.
Definition: Molecule.h:44

ObjCryst::MolAtom
MolAtom : atom inside a Molecule.
Definition: Molecule.h:59

ObjCryst::MolAtom::~MolAtom
virtual ~MolAtom()
Destructor.
Definition: Molecule.cpp:201

ObjCryst::MolAtom::mpScattPow
const ScatteringPower * mpScattPow
ScatteringPower.
Definition: Molecule.h:137

ObjCryst::MolAtom::mX
REAL mX
Cartesian oordinates in the Molecule reference frame.
Definition: Molecule.h:133

ObjCryst::MolAtom::int_ptr
size_t int_ptr() const
Access to the integer address of this object, for unique identification from python.
Definition: Molecule.cpp:359

ObjCryst::MolAtom::mIsInRing
bool mIsInRing
Is the atom in a ring ?
Definition: Molecule.h:141

ObjCryst::MolAtom::MolAtom
MolAtom(const REAL x, const REAL y, const REAL z, const ScatteringPower *pPow, const string &name, Molecule &parent)
Constructor for a MolAtom.
Definition: Molecule.cpp:191

ObjCryst::MolAtom::mpMol
Molecule * mpMol
Parent Molecule.
Definition: Molecule.h:139

ObjCryst::MolAtom::IsDummy
bool IsDummy() const
Returns true if this is a dummy atom, i.e.
Definition: Molecule.cpp:252

ObjCryst::MolAtom::mIsNonFlipAtom
bool mIsNonFlipAtom
Can the atom be flipped (this is used for optically active atom which should keep their absolute conf...
Definition: Molecule.h:143

ObjCryst::MolAtom::SetX
void SetX(const REAL) const
Set the X,Y,Z coordinate - this is const because sometimes their coordinate must be changed even thou...
Definition: Molecule.cpp:247

ObjCryst::MolAtom::mName
string mName
Name for this atom.
Definition: Molecule.h:124

ObjCryst::MolAtom::IsNonFlipAtom
bool IsNonFlipAtom() const
Can this atom be flipped (return=false) or should its absolute configuration be kept (return=true)
Definition: Molecule.cpp:354

ObjCryst::MolAtom::mOccupancy
REAL mOccupancy
Occupancy.
Definition: Molecule.h:135

ObjCryst::MolAtom::SetNonFlipAtom
void SetNonFlipAtom(const bool nonflip)
Set a flag to prevent the atom's absolute configuration to be changed.
Definition: Molecule.cpp:347

ObjCryst::MolAtom::SetIsInRing
void SetIsInRing(const bool r) const
Flag this atom as being in a ring (or not).
Definition: Molecule.cpp:344

ObjCryst::MolBond
Bond between two atoms, also a restraint on the associated bond length.
Definition: Molecule.h:165

ObjCryst::MolBond::int_ptr
size_t int_ptr() const
Access to the integer address of this object, for unique identification from python.
Definition: Molecule.cpp:641

ObjCryst::MolBond::~MolBond
virtual ~MolBond()
Destructor.
Definition: Molecule.cpp:389

ObjCryst::MolBond::mLLK
REAL mLLK
Stored log(likelihood)
Definition: Molecule.h:244

ObjCryst::MolBond::GetDeriv
REAL GetDeriv(const std::map< const MolAtom *, XYZ > &m, const bool llk=false) const
Get the derivative of the bond length, given the derivatives of the atom positions This requires that...
Definition: Molecule.cpp:557

ObjCryst::MolBond::GetLogLikelihood
virtual REAL GetLogLikelihood() const
Get -ln(likelihood) for this restraint.
Definition: Molecule.cpp:485

ObjCryst::MolBond::GetName
string GetName() const
Name of the bond, e.g. "C3-O4".
Definition: Molecule.cpp:399

ObjCryst::MolBond::MolBond
MolBond(MolAtom &atom1, MolAtom &atom2, const REAL length, const REAL sigma, const REAL delta, Molecule &parent, const REAL bondOrder=1.)
Constructor.
Definition: Molecule.cpp:378

ObjCryst::MolBond::CalcGradient
void CalcGradient(std::map< MolAtom *, XYZ > &m) const
Calc log(likelihood) gradient - versus all atomic coordinates.
Definition: Molecule.cpp:576

ObjCryst::MolBond::mpMol
Molecule * mpMol
Parent Molecule.
Definition: Molecule.h:242

ObjCryst::MolBond::mDerivLLKCoeff
REAL mDerivLLKCoeff
The factor used to change the derivative of the length/angle, to the derivative of the log(likelihood...
Definition: Molecule.h:253

ObjCryst::MolBond::mDerivAtom1
XYZ mDerivAtom1
Derivatives of the bond length with respect to the coordinates of the atoms.
Definition: Molecule.h:249

ObjCryst::MolBondAngle
Bond angle restraint between 3 atoms.
Definition: Molecule.h:271

ObjCryst::MolBondAngle::GetLogLikelihood
virtual REAL GetLogLikelihood() const
Get -ln(likelihood) for this restraint.
Definition: Molecule.cpp:779

ObjCryst::MolBondAngle::GetDeriv
REAL GetDeriv(const std::map< const MolAtom *, XYZ > &m, const bool llk=false) const
Get the derivative of the angle, given the derivatives of the atom positions This requires that GetLo...
Definition: Molecule.cpp:873

ObjCryst::MolBondAngle::mIsFlexible
bool mIsFlexible
When using the user-chosen flexibility model, this allows some flexibility for this bond angle,...
Definition: Molecule.h:337

ObjCryst::MolBondAngle::mDerivAtom1
XYZ mDerivAtom1
Partial derivatives of the angle with respect to the coordinates of the atoms.
Definition: Molecule.h:344

ObjCryst::MolBondAngle::CalcGradient
void CalcGradient(std::map< MolAtom *, XYZ > &m) const
Calc log(likelihood) gradient - versus all atomic coordinates.
Definition: Molecule.cpp:897

ObjCryst::MolBondAngle::MolBondAngle
MolBondAngle(MolAtom &atom1, MolAtom &atom2, MolAtom &atom3, const REAL angle, const REAL sigma, const REAL delta, Molecule &parent)
Constructor.
Definition: Molecule.cpp:660

ObjCryst::MolBondAngle::int_ptr
size_t int_ptr() const
Access to the integer address of this object, for unique identification from python.
Definition: Molecule.cpp:951

ObjCryst::MolBondAngle::mLLK
REAL mLLK
Stored log(likelihood)
Definition: Molecule.h:339

ObjCryst::MolBondAngle::mpMol
Molecule * mpMol
Parent Molecule.
Definition: Molecule.h:333

ObjCryst::MolBondAngle::mvpAtom
vector< MolAtom * > mvpAtom
The vector of the 3 atoms involved in the bond angle.
Definition: Molecule.h:330

ObjCryst::MolBondAngle::mDerivLLKCoeff
REAL mDerivLLKCoeff
The factor used to change the derivative of the length/angle, to the derivative of the log(likelihood...
Definition: Molecule.h:348

ObjCryst::MolBondAngle::~MolBondAngle
virtual ~MolBondAngle()
Destructor.
Definition: Molecule.cpp:673

ObjCryst::MolDihedralAngle
Dihedral angle restraint between 4 atoms.
Definition: Molecule.h:366

ObjCryst::MolDihedralAngle::mDerivAtom1
XYZ mDerivAtom1
Partial derivatives of the angle with respect to the coordinates of the atoms.
Definition: Molecule.h:437

ObjCryst::MolDihedralAngle::int_ptr
size_t int_ptr() const
Access to the integer address of this object, for unique identification from python.
Definition: Molecule.cpp:1314

ObjCryst::MolDihedralAngle::mvpAtom
vector< MolAtom * > mvpAtom
The vector of the 4 atoms involved in the bond angle.
Definition: Molecule.h:427

ObjCryst::MolDihedralAngle::mDerivLLKCoeff
REAL mDerivLLKCoeff
The factor used to change the derivative of the length/angle, to the derivative of the log(likelihood...
Definition: Molecule.h:441

ObjCryst::MolDihedralAngle::~MolDihedralAngle
virtual ~MolDihedralAngle()
Destructor.
Definition: Molecule.cpp:991

ObjCryst::MolDihedralAngle::CalcGradient
void CalcGradient(std::map< MolAtom *, XYZ > &m) const
Calc log(likelihood) gradient - versus all atomic coordinates.
Definition: Molecule.cpp:1253

ObjCryst::MolDihedralAngle::mLLK
REAL mLLK
Stored log(likelihood)
Definition: Molecule.h:432

ObjCryst::MolDihedralAngle::MolDihedralAngle
MolDihedralAngle(MolAtom &atom1, MolAtom &atom2, MolAtom &atom3, MolAtom &atom4, const REAL angle, const REAL sigma, const REAL delta, Molecule &parent)
Constructor.
Definition: Molecule.cpp:970

ObjCryst::MolDihedralAngle::mpMol
Molecule * mpMol
Parent Molecule.
Definition: Molecule.h:430

ObjCryst::MolDihedralAngle::GetLogLikelihood
virtual REAL GetLogLikelihood() const
Get -ln(likelihood) for this restraint.
Definition: Molecule.cpp:1106

ObjCryst::MolDihedralAngle::GetDeriv
REAL GetDeriv(const std::map< const MolAtom *, XYZ > &m, const bool llk=false) const
Get the derivative of the Angle, given the derivatives of the atom positions This requires that GetLo...
Definition: Molecule.cpp:1224

ObjCryst::MolRing
Ring class.
Definition: Molecule.h:459

ObjCryst::MolRing::int_ptr
size_t int_ptr() const
Access to the integer address of this object, for unique identification from python.
Definition: Molecule.cpp:1357

ObjCryst::Quaternion
A quaternion class, used to represent the orientation of the molecule.
Definition: Molecule.h:475

ObjCryst::Quaternion::GetConjugate
Quaternion GetConjugate() const
Get the conjugate of this quaternion (== the inverse if unit quaternion)
Definition: Molecule.cpp:1397

ObjCryst::Quaternion::operator*
Quaternion operator*(const Quaternion &q) const
Quaternion multiplication.
Definition: Molecule.cpp:1401

ObjCryst::Quaternion::mQ0
REAL mQ0
The components of the quaternion z=(q0,v) with v=(q1,q2,q3)
Definition: Molecule.h:512

ObjCryst::Quaternion::RotationQuaternion
static Quaternion RotationQuaternion(const REAL ang, const REAL v1, const REAL v2, const REAL v3)
Create a rotation quaternion around a given vector for a given angle.
Definition: Molecule.cpp:1386

ObjCryst::Quaternion::Normalize
void Normalize() const
Re-normalize the quaternion to unity.
Definition: Molecule.cpp:1524

ObjCryst::Quaternion::Quaternion
Quaternion()
Default constructor, yields q=(1,0,0,0)
Definition: Molecule.cpp:1364

ObjCryst::Quaternion::RotateVector
void RotateVector(REAL &v1, REAL &v2, REAL &v3) const
Rotate vector v=(v1,v2,v3). The rotated components are directly written.
Definition: Molecule.cpp:1501

ObjCryst::RigidGroup
Rigid groups of atoms inside a molecule.
Definition: Molecule.h:527

ObjCryst::RigidGroup::mvIdx
std::set< unsigned int > mvIdx
Temporary list of the atoms indices in the molecule, used during optimization This is created in Mole...
Definition: Molecule.h:540

ObjCryst::RigidGroup::mQuat
Quaternion mQuat
The unit quaternion defining the orientation - this is used during optimizations to rotate all atoms ...
Definition: Molecule.h:534

ObjCryst::RigidGroup::int_ptr
size_t int_ptr() const
Access to the integer address of this object, for unique identification from python.
Definition: Molecule.cpp:1341

ObjCryst::RigidGroup::mX
REAL mX
The translation of all the atoms as a group The values will be resetted whenever entering or leaving ...
Definition: Molecule.h:537

ObjCryst::StretchMode
Abstract base Stretch Mode for Molecule objects.
Definition: Molecule.h:549

ObjCryst::StretchMode::RandomStretch
virtual void RandomStretch(const REAL amplitude, const bool keepCenter=true)=0
Move the atoms according to this mode, randomly.

ObjCryst::StretchMode::Stretch
virtual void Stretch(const REAL change, const bool keepCenter=true)=0
Move the atoms according to this mode.

ObjCryst::StretchMode::mvpBrokenBondAngle
std::map< const MolBondAngle *, REAL > mvpBrokenBondAngle
List of bond angle restraints modified by this mode The key is the restraint, the value is the deriva...
Definition: Molecule.h:571

ObjCryst::StretchMode::mpMol
Molecule * mpMol
The Molecule corresponding to this stretch mode.
Definition: Molecule.h:580

ObjCryst::StretchMode::mDerivXYZ
std::map< const MolAtom *, XYZ > mDerivXYZ
Derivative of the atomic positions versus a change of the bond length.
Definition: Molecule.h:578

ObjCryst::StretchMode::CalcDeriv
virtual void CalcDeriv(const bool derivllk=true) const =0
Calculate the derivative of the Molecule's Log(likelihood) and atomic positions versus a change of th...

ObjCryst::StretchMode::mvpBrokenBond
std::map< const MolBond *, REAL > mvpBrokenBond
List of bond restraints affected by this mode The key is the restraint, the value is the derivative o...
Definition: Molecule.h:568

ObjCryst::StretchMode::Print
virtual void Print(ostream &os, bool full=true) const =0
Print one-line list of atoms moved.

ObjCryst::StretchMode::mvpBrokenDihedralAngle
std::map< const MolDihedralAngle *, REAL > mvpBrokenDihedralAngle
List of dihedral angle restraints modified by this mode The key is the restraint, the value is the de...
Definition: Molecule.h:574

ObjCryst::StretchMode::mBaseAmplitude
REAL mBaseAmplitude
The recommended change amplitude, for a base global optimization displacement, to obtain an average 0...
Definition: Molecule.h:588

ObjCryst::StretchMode::mLLKDeriv
REAL mLLKDeriv
Derivative of the Molecule's Log(likelihood) versus a change of the bond length.
Definition: Molecule.h:576

ObjCryst::StretchModeBondLength
Group of atoms for random moves changing a bond length.
Definition: Molecule.h:596

ObjCryst::StretchModeBondLength::RandomStretch
virtual void RandomStretch(const REAL amplitude, const bool keepCenter=true)
Move the atoms according to this mode, randomly.
Definition: Molecule.cpp:1629

ObjCryst::StretchModeBondLength::mpAtom0
MolAtom * mpAtom0
The first atom (fixed).
Definition: Molecule.h:610

ObjCryst::StretchModeBondLength::mpBond
const MolBond * mpBond
The (optional) bond length which this stretch mode should respect.
Definition: Molecule.h:614

ObjCryst::StretchModeBondLength::StretchModeBondLength
StretchModeBondLength(MolAtom &at0, MolAtom &at1, const MolBond *pBond)
Constructor If pBond!=0, the bond length restraint is respected.
Definition: Molecule.cpp:1556

ObjCryst::StretchModeBondLength::Print
virtual void Print(ostream &os, bool full=true) const
Print one-line list of atoms moved.
Definition: Molecule.cpp:1600

ObjCryst::StretchModeBondLength::CalcDeriv
virtual void CalcDeriv(const bool derivllk=true) const
Calculate the derivative of the Molecule's Log(likelihood) and atomic positions versus a change of th...
Definition: Molecule.cpp:1566

ObjCryst::StretchModeBondLength::mvTranslatedAtomList
set< MolAtom * > mvTranslatedAtomList
The set of atoms that are to be translated, including at1.
Definition: Molecule.h:616

ObjCryst::StretchModeBondLength::mpAtom1
MolAtom * mpAtom1
The second atom (first atom moved)
Definition: Molecule.h:612

ObjCryst::StretchModeBondLength::Stretch
virtual void Stretch(const REAL change, const bool keepCenter=true)
Move the atoms according to this mode.
Definition: Molecule.cpp:1614

ObjCryst::StretchModeBondAngle
Atoms moved when changing a bond angle.
Definition: Molecule.h:624

ObjCryst::StretchModeBondAngle::mpAtom2
MolAtom * mpAtom2
The third atom.
Definition: Molecule.h:643

ObjCryst::StretchModeBondAngle::mvRotatedAtomList
set< MolAtom * > mvRotatedAtomList
The set of atoms that are to be rotated around the direction going through at1 and perpendicular to t...
Definition: Molecule.h:648

ObjCryst::StretchModeBondAngle::Print
virtual void Print(ostream &os, bool full=true) const
Print one-line list of atoms moved.
Definition: Molecule.cpp:1699

ObjCryst::StretchModeBondAngle::RandomStretch
virtual void RandomStretch(const REAL amplitude, const bool keepCenter=true)
Move the atoms according to this mode, randomly.
Definition: Molecule.cpp:1729

ObjCryst::StretchModeBondAngle::mpAtom0
MolAtom * mpAtom0
The first atom.
Definition: Molecule.h:639

ObjCryst::StretchModeBondAngle::CalcDeriv
virtual void CalcDeriv(const bool derivllk=true) const
Calculate the derivative of the Molecule's Log(likelihood) and atomic positions versus a change of th...
Definition: Molecule.cpp:1645

ObjCryst::StretchModeBondAngle::Stretch
virtual void Stretch(const REAL change, const bool keepCenter=true)
Move the atoms according to this mode.
Definition: Molecule.cpp:1713

ObjCryst::StretchModeBondAngle::StretchModeBondAngle
StretchModeBondAngle(MolAtom &at0, MolAtom &at1, MolAtom &at2, const MolBondAngle *pBondAngle)
Constructor If pBondAngle!=0, the bond angle length restraint is respected.
Definition: Molecule.cpp:1635

ObjCryst::StretchModeBondAngle::mpAtom1
MolAtom * mpAtom1
The second atom.
Definition: Molecule.h:641

ObjCryst::StretchModeBondAngle::mpBondAngle
const MolBondAngle * mpBondAngle
The (optional) bond angle restraint which this stretch mode should respect.
Definition: Molecule.h:645

ObjCryst::StretchModeTorsion
Atoms moved when rotated around a bond at0-at1-at2-at3.
Definition: Molecule.h:655

ObjCryst::StretchModeTorsion::mpAtom1
MolAtom * mpAtom1
The first atom.
Definition: Molecule.h:670

ObjCryst::StretchModeTorsion::mpAtom2
MolAtom * mpAtom2
The second atom.
Definition: Molecule.h:672

ObjCryst::StretchModeTorsion::StretchModeTorsion
StretchModeTorsion(MolAtom &at1, MolAtom &at2, const MolDihedralAngle *pDihedralAngle)
Constructor If pDihedralAngle!=0, the dihedral angle length restraint is respected.
Definition: Molecule.cpp:1735

ObjCryst::StretchModeTorsion::Print
virtual void Print(ostream &os, bool full=true) const
Print one-line list of atoms moved.
Definition: Molecule.cpp:1787

ObjCryst::StretchModeTorsion::mpDihedralAngle
const MolDihedralAngle * mpDihedralAngle
The (optional) bond angle restraint which this stretch mode should respect.
Definition: Molecule.h:675

ObjCryst::StretchModeTorsion::RandomStretch
virtual void RandomStretch(const REAL amplitude, const bool keepCenter=true)
Move the atoms according to this mode, randomly.
Definition: Molecule.cpp:1806

ObjCryst::StretchModeTorsion::mvRotatedAtomList
set< MolAtom * > mvRotatedAtomList
The set of atoms that are to be rotated around at1-at2.
Definition: Molecule.h:677

ObjCryst::StretchModeTorsion::Stretch
virtual void Stretch(const REAL change, const bool keepCenter=true)
Move the atoms according to this mode.
Definition: Molecule.cpp:1801

ObjCryst::StretchModeTorsion::CalcDeriv
virtual void CalcDeriv(const bool derivllk=true) const
Calculate the derivative of the Molecule's Log(likelihood) and atomic positions versus a change of th...
Definition: Molecule.cpp:1745

ObjCryst::StretchModeTwist
Atoms moved between two other atoms, using a "twist" of their positions - only small twists of their ...
Definition: Molecule.h:687

ObjCryst::StretchModeTwist::mpAtom2
MolAtom * mpAtom2
The second atom.
Definition: Molecule.h:703

ObjCryst::StretchModeTwist::Print
virtual void Print(ostream &os, bool full=true) const
Print one-line list of atoms moved.
Definition: Molecule.cpp:1868

ObjCryst::StretchModeTwist::mvRotatedAtomList
set< MolAtom * > mvRotatedAtomList
The set of atoms that are to be rotated around at1-at2.
Definition: Molecule.h:705

ObjCryst::StretchModeTwist::StretchModeTwist
StretchModeTwist(MolAtom &at1, MolAtom &at2)
Constructor If pDihedralAngle!=0, the dihedral angle length restraint is respected.
Definition: Molecule.cpp:1818

ObjCryst::StretchModeTwist::Stretch
virtual void Stretch(const REAL change, const bool keepCenter=true)
Move the atoms according to this mode.
Definition: Molecule.cpp:1882

ObjCryst::StretchModeTwist::mpAtom1
MolAtom * mpAtom1
The first atom.
Definition: Molecule.h:701

ObjCryst::StretchModeTwist::RandomStretch
virtual void RandomStretch(const REAL amplitude, const bool keepCenter=true)
Move the atoms according to this mode, randomly.
Definition: Molecule.cpp:1887

ObjCryst::StretchModeTwist::CalcDeriv
virtual void CalcDeriv(const bool derivllk=true) const
Calculate the derivative of the Molecule's Log(likelihood) and atomic positions versus a change of th...
Definition: Molecule.cpp:1827

ObjCryst::MDAtomGroup
Groups of atoms that can be moved using molecular dynamics principles, taking a list of restraints as...
Definition: Molecule.h:714

ObjCryst::MDAtomGroup::MDAtomGroup
MDAtomGroup()
Default constructor.
Definition: Molecule.cpp:1903

ObjCryst::MDAtomGroup::Print
void Print(ostream &os, bool full=true) const
Print one-line list of atoms moved.
Definition: Molecule.cpp:1921

ObjCryst::MolZAtom
Light-weight representation of an atom in the molecule, as a part of a Z-matrix.
Definition: Molecule.h:739

ObjCryst::Molecule
Molecule : class for complex scatterer descriptions using cartesian coordinates with bond length/angl...
Definition: Molecule.h:760

ObjCryst::Molecule::GetScatteringComponentList
virtual const ScatteringComponentList & GetScatteringComponentList() const
Get the list of all scattering components for this scatterer.
Definition: Molecule.cpp:3242

ObjCryst::Molecule::RemoveBondAngle
vector< MolBondAngle * >::iterator RemoveBondAngle(const MolBondAngle &, const bool del=true)
Remove a BondAngle.
Definition: Molecule.cpp:4053

ObjCryst::Molecule::BuildMDAtomGroups
void BuildMDAtomGroups()
Find groups of atoms that cannot be moved relatively to each other using the free or non-free stretch...
Definition: Molecule.cpp:7458

ObjCryst::Molecule::TranslateAtomGroup
void TranslateAtomGroup(const set< MolAtom * > &atoms, const REAL dx, const REAL dy, const REAL dz, const bool keepCenter=true)
Translate a group of atoms in a given direction.
Definition: Molecule.cpp:4564

ObjCryst::Molecule::mConnectivityTable
map< MolAtom *, set< MolAtom * > > mConnectivityTable
Connectivity table: for each atom, keep the list of atoms bonded to it.
Definition: Molecule.h:1266

ObjCryst::Molecule::InitOptions
void InitOptions()
Build options for this object.
Definition: Molecule.cpp:7741

ObjCryst::Molecule::BuildStretchModeTorsion
void BuildStretchModeTorsion()
Build the groups of atoms moved when changing a dihedral angle, while respecting the Molecule restrai...
Definition: Molecule.cpp:6265

ObjCryst::Molecule::SetDeleteSubObjInDestructor
void SetDeleteSubObjInDestructor(const bool b)
Set whether to delete the MolAtoms, MolBonds, MolBondAngles and MolDihedralAngles in the destructor.
Definition: Molecule.cpp:7892

ObjCryst::Molecule::mvpDihedralAngle
vector< MolDihedralAngle * > mvpDihedralAngle
The list of dihedral angles.
Definition: Molecule.h:1173

ObjCryst::Molecule::mvpStretchModeFree
std::list< StretchMode * > mvpStretchModeFree
Groups of StretchMode not breaking any restraint (unless the one they are associated to)
Definition: Molecule.h:1365

ObjCryst::Molecule::mvRotorGroupTorsionSingleChain
list< RotorGroup > mvRotorGroupTorsionSingleChain
List of RotorGroups corresponding to free torsion bonds, but with only one chain of atoms listed.
Definition: Molecule.h:1306

ObjCryst::Molecule::SetCenterAtom
void SetCenterAtom(const MolAtom &at)
Get the atom defining the origin of the Molecule Equal to 0 if no atom as been set.
Definition: Molecule.cpp:5101

ObjCryst::Molecule::AddBondAngle
void AddBondAngle(MolAtom &atom1, MolAtom &atom2, MolAtom &atom3, const REAL angle, const REAL sigma, const REAL delta, const bool updateDisplay=true)
Add a bond angle restraint.
Definition: Molecule.cpp:4041

ObjCryst::Molecule::GetCenterAtom
const MolAtom * GetCenterAtom() const
Get the atom defining the origin of the Molecule Equal to 0 if no atom as been set.
Definition: Molecule.cpp:5096

ObjCryst::Molecule::POVRayDescription
virtual ostream & POVRayDescription(ostream &os, const CrystalPOVRayOptions &options) const
Definition: Molecule.cpp:3256

ObjCryst::Molecule::EndOptimization
virtual void EndOptimization()
This should be called by any optimization class at the end of an optimization.
Definition: Molecule.cpp:2576

ObjCryst::Molecule::mFlexModel
RefObjOpt mFlexModel
OPtion for the different types of flexibility possible for this molecule: rigid body,...
Definition: Molecule.h:1237

ObjCryst::Molecule::mvRing
list< MolRing > mvRing
The list of rings.
Definition: Molecule.h:1188

ObjCryst::Molecule::SetName
virtual void SetName(const string &name)
Name of the object.
Definition: Molecule.cpp:2171

ObjCryst::Molecule::BuildRotorGroup
void BuildRotorGroup()
Build the groups of atoms that will be rotated during global optimization.
Definition: Molecule.cpp:5421

ObjCryst::Molecule::BuildStretchModeBondAngle
void BuildStretchModeBondAngle()
Build the groups of atoms moved when changing a bond angle, while respecting the Molecule restraints.
Definition: Molecule.cpp:5928

ObjCryst::Molecule::GetNbLSQFunction
virtual unsigned int GetNbLSQFunction() const
Number of LSQ functions.
Definition: Molecule.cpp:3139

ObjCryst::Molecule::mvRigidGroup
std::vector< RigidGroup * > mvRigidGroup
Rigid groups of atoms.
Definition: Molecule.h:1183

ObjCryst::Molecule::mAsZMatrix
std::vector< MolZAtom > mAsZMatrix
The Molecule, as a lightweight ZMatrix, for export purposes.
Definition: Molecule.h:1392

ObjCryst::Molecule::BuildConnectivityTable
void BuildConnectivityTable() const
Build the Connectivity table.
Definition: Molecule.cpp:5369

ObjCryst::Molecule::mvMDAtomGroup
list< MDAtomGroup > mvMDAtomGroup
Groups of atoms that should be moved according to molecular dynamics principles.
Definition: Molecule.h:1380

ObjCryst::Molecule::mMoleculeCenter
RefObjOpt mMoleculeCenter
Option to choose the center of rotation of the Molecule for the global orientation either as the geom...
Definition: Molecule.h:1257

ObjCryst::Molecule::FlipAtomGroup
void FlipAtomGroup(const FlipGroup &, const bool keepCenter=true)
Flip a group of atom. See Molecule::FlipGroup.
Definition: Molecule.cpp:7812

ObjCryst::Molecule::mvStretchModeTwist
list< StretchModeTwist > mvStretchModeTwist
List of StretchModeTwist.
Definition: Molecule.h:1362

ObjCryst::Molecule::UpdateScattCompList
void UpdateScattCompList() const
Update the Molecule::mScattCompList from the cartesian coordinates of all atoms, and the orientation ...
Definition: Molecule.cpp:7617

ObjCryst::Molecule::RemoveDihedralAngle
vector< MolDihedralAngle * >::iterator RemoveDihedralAngle(const MolDihedralAngle &, const bool del=true)
Remove a dihedral angle.
Definition: Molecule.cpp:4101

ObjCryst::Molecule::RigidifyWithDihedralAngles
void RigidifyWithDihedralAngles()
Add dihedral angles so as to rigidify the Molecule.
Definition: Molecule.cpp:4657

ObjCryst::Molecule::mvStretchModeBondAngle
list< StretchModeBondAngle > mvStretchModeBondAngle
List of StretchModeBondLength.
Definition: Molecule.h:1358

ObjCryst::Molecule::GetRigidGroupList
const std::vector< RigidGroup * > & GetRigidGroupList() const
List of rigid group of atoms.
Definition: Molecule.cpp:4459

ObjCryst::Molecule::InitRefParList
virtual void InitRefParList()
Definition: Molecule.cpp:5275

ObjCryst::Molecule::FindBondAngle
vector< MolBondAngle * >::const_iterator FindBondAngle(const MolAtom &at1, const MolAtom &at0, const MolAtom &at2) const
Searches whether a bond between three atoms already exists, searching for either (at1,...
Definition: Molecule.cpp:4072

ObjCryst::Molecule::mDeleteSubObjInDestructor
bool mDeleteSubObjInDestructor
Base Rotation amplitude (in radians) for the Molecule, so that the average atomic displacement is equ...
Definition: Molecule.h:1201

ObjCryst::Molecule::mMDMoveEnergy
REAL mMDMoveEnergy
Relative energy of molecule during molecular dynamics move Default: 40, 10 (slow conformation change)...
Definition: Molecule.h:1389

ObjCryst::Molecule::mQuat
Quaternion mQuat
The unit quaternion defining the orientation.
Definition: Molecule.h:1192

ObjCryst::Molecule::mLSQObs
CrystVector_REAL mLSQObs
Current LSQ Calc - one value for each restraint (bond distance, angle or dihedral angle ideal values)
Definition: Molecule.h:1406

ObjCryst::Molecule::XMLInput
virtual void XMLInput(istream &is, const XMLCrystTag &tag)
Input From stream.
Definition: Molecule.cpp:2331

ObjCryst::Molecule::RemoveAtom
vector< MolAtom * >::iterator RemoveAtom(MolAtom &, const bool del=true)
Remove an atom.
Definition: Molecule.cpp:3932

ObjCryst::Molecule::BeginOptimization
virtual void BeginOptimization(const bool allowApproximations=false, const bool enableRestraints=false)
This should be called by any optimization class at the begining of an optimization.
Definition: Molecule.cpp:2449

ObjCryst::Molecule::FindDihedralAngle
vector< MolDihedralAngle * >::const_iterator FindDihedralAngle(const MolAtom &at1, const MolAtom &at2, const MolAtom &at3, const MolAtom &at4) const
Searches whether a dihedral between four atoms already exists, searching for either (at1,...
Definition: Molecule.cpp:4121

ObjCryst::Molecule::GetRigidGroupClock
RefinableObjClock & GetRigidGroupClock()
Get the clock associated to the list of rigid groups (clicked also whenever a rigid group is modified...
Definition: Molecule.cpp:4654

ObjCryst::Molecule::TagNewBestConfig
virtual void TagNewBestConfig() const
During a global optimization, tells the object that the current config is the latest "best" config.
Definition: Molecule.cpp:3191

ObjCryst::Molecule::mLSQWeight
CrystVector_REAL mLSQWeight
Current LSQ Calc - one value for each restraint(bond distance, angle or dihedral angle sigmas)
Definition: Molecule.h:1408

ObjCryst::Molecule::XMLOutput
virtual void XMLOutput(ostream &os, int indent=0) const
Output to stream in well-formed XML.
Definition: Molecule.cpp:2227

ObjCryst::Molecule::FindBond
vector< MolBond * >::const_iterator FindBond(const MolAtom &, const MolAtom &) const
Searches whether a bond between two atoms already exists.
Definition: Molecule.cpp:4020

ObjCryst::Molecule::mvFlipGroup
list< FlipGroup > mvFlipGroup
The list of FlipGroups.
Definition: Molecule.h:1352

ObjCryst::Molecule::AddAtom
void AddAtom(const REAL x, const REAL y, const REAL z, const ScatteringPower *pPow, const string &name, const bool updateDisplay=true)
Add an atom.
Definition: Molecule.cpp:3876

ObjCryst::Molecule::CreateCopy
virtual Molecule * CreateCopy() const
Definition: Molecule.cpp:2159

ObjCryst::Molecule::FindAtom
vector< MolAtom * >::reverse_iterator FindAtom(const string &name)
Search a MolAtom from its name.
Definition: Molecule.cpp:7720

ObjCryst::Molecule::mLogLikelihoodScale
REAL mLogLikelihoodScale
Scale (multiplier) for the log(likelihood)
Definition: Molecule.h:1402

ObjCryst::Molecule::BuildStretchModeTwist
void BuildStretchModeTwist()
Build the groups of atoms used to twist internally the Molecule, e.g.
Definition: Molecule.cpp:6679

ObjCryst::Molecule::GetLSQObs
virtual const CrystVector_REAL & GetLSQObs(const unsigned int) const
Get the observed values for the LSQ function.
Definition: Molecule.cpp:3157

ObjCryst::Molecule::GetNbComponent
virtual int GetNbComponent() const
Number of components in the scatterer (eg number of point scatterers)
Definition: Molecule.cpp:3240

ObjCryst::Molecule::BuildStretchModeGroups
void BuildStretchModeGroups()
Separate StretchMode that break more than their assigned restraint from others.
Definition: Molecule.cpp:7303

ObjCryst::Molecule::GetAtomScattPowClock
const RefinableObjClock & GetAtomScattPowClock() const
Get the clock associated to the scattering powers.
Definition: Molecule.cpp:4651

ObjCryst::Molecule::AsZMatrix
const std::vector< MolZAtom > & AsZMatrix(const bool keeporder) const
Molecule as Z-matrix.
Definition: Molecule.cpp:5183

ObjCryst::Molecule::mvStretchModeTorsion
list< StretchModeTorsion > mvStretchModeTorsion
List of StretchModeBondLength.
Definition: Molecule.h:1360

ObjCryst::Molecule::mClockRestraint
RefinableObjClock mClockRestraint
This clock is the parent of mClockAtomList, mClockBondList, mClockBondAngleList, mClockDihedralAngleL...
Definition: Molecule.h:1212

ObjCryst::Molecule::AddRigidGroup
void AddRigidGroup(const RigidGroup &, const bool updateDisplay=true)
Add a rigid group of atoms.
Definition: Molecule.cpp:4138

ObjCryst::Molecule::mOptimizeOrientation
RefObjOpt mOptimizeOrientation
Option to optimize the Molecule's orientation.
Definition: Molecule.h:1252

ObjCryst::Molecule::OptimizeConformation
void OptimizeConformation(const long nbTrial=10000, const REAL stopCost=0.)
Minimize configuration from internal restraints (bond lengths, angles and dihedral angles).
Definition: Molecule.cpp:4249

ObjCryst::Molecule::mpCenterAtom
const MolAtom * mpCenterAtom
Atom chosen as center of rotation, if mRotationCenter is set to use an atom rather than the geometric...
Definition: Molecule.h:1262

ObjCryst::Molecule::RandomizeConfiguration
virtual void RandomizeConfiguration()
Randomize Configuration (before a global optimization).
Definition: Molecule.cpp:2603

ObjCryst::Molecule::BuildRingList
void BuildRingList()
Build the list of rings in the molecule.
Definition: Molecule.cpp:5329

ObjCryst::Molecule::GetLogLikelihood
virtual REAL GetLogLikelihood() const
Get -log(likelihood) of the current configuration for the object.
Definition: Molecule.cpp:3125

ObjCryst::Molecule::MolecularDynamicsEvolve
void MolecularDynamicsEvolve(std::map< MolAtom *, XYZ > &v0, const unsigned nbStep, const REAL dt, const std::vector< MolBond * > &vb, const std::vector< MolBondAngle * > &va, const std::vector< MolDihedralAngle * > &vd, std::map< RigidGroup *, std::pair< XYZ, XYZ > > &vr, REAL nrj0=0)
Change the conformation of the molecule using molecular dynamics principles.
Definition: Molecule.cpp:4343

ObjCryst::Molecule::GetFormula
std::string GetFormula() const
Formula with atoms in alphabetic order.
Definition: Molecule.cpp:2193

ObjCryst::Molecule::RestraintStatus
void RestraintStatus(ostream &os) const
Print the status of all restraints (bond length, angles...)
Definition: Molecule.cpp:4616

ObjCryst::Molecule::RotateAtomGroup
void RotateAtomGroup(const MolAtom &at1, const MolAtom &at2, const set< MolAtom * > &atoms, const REAL angle, const bool keepCenter=true)
Rotate a group of atoms around an axis defined by two atoms.
Definition: Molecule.cpp:4462

ObjCryst::Molecule::mvpBondAngle
vector< MolBondAngle * > mvpBondAngle
The list of bond angles.
Definition: Molecule.h:1169

ObjCryst::Molecule::RestraintExport
void RestraintExport(ostream &os) const
Print the restraints (bond length, angles...) as whole labels and number in column text format which ...
Definition: Molecule.cpp:4591

ObjCryst::Molecule::TuneGlobalOptimRotationAmplitude
void TuneGlobalOptimRotationAmplitude()
Tune the rotation amplitude for free torsions and for the overall Molecule Rotation.
Definition: Molecule.cpp:6945

ObjCryst::Molecule::mLSQCalc
CrystVector_REAL mLSQCalc
Current LSQ Calc - one value for each restraint (bond distance, angle or dihedral angle)
Definition: Molecule.h:1404

ObjCryst::Molecule::RemoveBond
vector< MolBond * >::iterator RemoveBond(const MolBond &, const bool del=true)
Remove a bond.
Definition: Molecule.cpp:4001

ObjCryst::Molecule::AddBond
void AddBond(MolAtom &atom1, MolAtom &atom2, const REAL length, const REAL sigma, const REAL delta, const REAL bondOrder=1., const bool updateDisplay=true)
Add a bond.
Definition: Molecule.cpp:3988

ObjCryst::Molecule::mvStretchModeBondLength
list< StretchModeBondLength > mvStretchModeBondLength
List of StretchModeBondLength.
Definition: Molecule.h:1356

ObjCryst::Molecule::GetComponentName
virtual string GetComponentName(const int i) const
Name for the i-th component of this scatterer.
Definition: Molecule.cpp:3250

ObjCryst::Molecule::UpdateDisplay
virtual void UpdateDisplay() const
If there is an interface, this should be automatically be called each time there is a 'new,...
Definition: Molecule.cpp:2443

ObjCryst::Molecule::mvpBond
vector< MolBond * > mvpBond
The list of bonds.
Definition: Molecule.h:1165

ObjCryst::Molecule::ResetRigidGroupsPar
void ResetRigidGroupsPar() const
Set the orientation & translation parameters of all rigid groups to 0, after correcting the atomic po...
Definition: Molecule.cpp:7896

ObjCryst::Molecule::AddDihedralAngle
void AddDihedralAngle(MolAtom &atom1, MolAtom &atom2, MolAtom &atom3, MolAtom &atom4, const REAL angle, const REAL sigma, const REAL delta, const bool updateDisplay=true)
Add a dihedral angle restraint.
Definition: Molecule.cpp:4087

ObjCryst::Molecule::Print
virtual void Print() const
Print some info about the scatterer (ideally this should be one line...).
Definition: Molecule.cpp:2221

ObjCryst::Molecule::RemoveRigidGroup
std::vector< RigidGroup * >::iterator RemoveRigidGroup(const RigidGroup &group, const bool updateDisplay=true, const bool del=true)
Remove a rigid group of atoms.
Definition: Molecule.cpp:4218

ObjCryst::Molecule::GetConnectivityTable
const map< MolAtom *, set< MolAtom * > > & GetConnectivityTable()
Get the connectivity table.
Definition: Molecule.cpp:4639

ObjCryst::Molecule::BuildStretchModeBondLength
void BuildStretchModeBondLength()
Build the groups of atoms moved when stretching a bond length, while respecting the Molecule restrain...
Definition: Molecule.cpp:5656

ObjCryst::Molecule::OptimizeConformationSteepestDescent
void OptimizeConformationSteepestDescent(const REAL maxStep=0.1, const unsigned nbStep=1)
Optimize the conformation from internal restraints (bond lengths, angles and dihedral angles),...
Definition: Molecule.cpp:4267

ObjCryst::Molecule::mvRotorGroupInternal
list< RotorGroup > mvRotorGroupInternal
List of RotorGroups for internal rotations.
Definition: Molecule.h:1312

ObjCryst::Molecule::BuildFlipGroup
void BuildFlipGroup()
Build the groups of atoms that can be flipped.
Definition: Molecule.cpp:7124

ObjCryst::Molecule::mLogLikelihood
REAL mLogLikelihood
The current log(likelihood)
Definition: Molecule.h:1395

ObjCryst::Molecule::GetLSQDeriv
virtual const CrystVector_REAL & GetLSQDeriv(const unsigned int n, RefinablePar &par)
Get the first derivative values for the LSQ function, for a given parameter.
Definition: Molecule.cpp:3185

ObjCryst::Molecule::Molecule
Molecule(Crystal &cryst, const string &name="")
Constructor.
Definition: Molecule.cpp:1946

ObjCryst::Molecule::mvpAtom
vector< MolAtom * > mvpAtom
The list of atoms.
Definition: Molecule.h:1161

ObjCryst::Molecule::mvAtomBond
map< MolAtom *, std::vector< MolBond * > > mvAtomBond
List of Bonds for each atom.
Definition: Molecule.h:1178

ObjCryst::Molecule::BondAngleRandomChange
REAL BondAngleRandomChange(const StretchModeBondAngle &mode, const REAL amplitude, const bool respectRestraint=true)
change a bond angle, while respecting the Restraint (if any).
Definition: Molecule.cpp:4998

ObjCryst::Molecule::BondLengthRandomChange
REAL BondLengthRandomChange(const StretchModeBondLength &mode, const REAL amplitude, const bool respectRestraint=true)
Stretch a bond, while respecting the Restraint (if any).
Definition: Molecule.cpp:4954

ObjCryst::Molecule::GetBondListClock
RefinableObjClock & GetBondListClock()
get the clock associated to the list of bonds
Definition: Molecule.cpp:4645

ObjCryst::Molecule::GlobalOptRandomMove
virtual void GlobalOptRandomMove(const REAL mutationAmplitude, const RefParType *type)
Make a random move of the current configuration.
Definition: Molecule.cpp:2719

ObjCryst::Molecule::GetAtomPositionClock
RefinableObjClock & GetAtomPositionClock()
Get the clock associated to the atomic positions.
Definition: Molecule.cpp:4648

ObjCryst::Molecule::~Molecule
~Molecule()
Destructor.
Definition: Molecule.cpp:2134

ObjCryst::Molecule::mScattCompList
ScatteringComponentList mScattCompList
The list of scattering components.
Definition: Molecule.h:1157

ObjCryst::Molecule::mAutoOptimizeConformation
RefObjOpt mAutoOptimizeConformation
Option to automatically optimize the starting conformation, if the total restraint cost is too high.
Definition: Molecule.h:1247

ObjCryst::Molecule::mvpStretchModeNotFree
std::list< StretchMode * > mvpStretchModeNotFree
Groups of StretchMode breaking restraints (beyond the one they are associated to)
Definition: Molecule.h:1367

ObjCryst::Molecule::mMDMoveFreq
REAL mMDMoveFreq
Frequency of using molecular dynamics move during GlobalOptRandomMove()
Definition: Molecule.h:1386

ObjCryst::Molecule::GetLSQCalc
virtual const CrystVector_REAL & GetLSQCalc(const unsigned int) const
Get the current calculated value for the LSQ function.
Definition: Molecule.cpp:3144

ObjCryst::Molecule::mvMDFullAtomGroup
std::set< MolAtom * > mvMDFullAtomGroup
Full list of atoms that can be moved using molecular dynamics This excludes any atom part of a rigid ...
Definition: Molecule.h:1383

ObjCryst::Molecule::GetLSQWeight
virtual const CrystVector_REAL & GetLSQWeight(const unsigned int) const
Get the weight values for the LSQ function.
Definition: Molecule.cpp:3170

ObjCryst::Molecule::GetClassName
virtual const string & GetClassName() const
Name for this class ("RefinableObj", "Crystal",...).
Definition: Molecule.cpp:2165

ObjCryst::Molecule::mvRotorGroupTorsion
list< RotorGroup > mvRotorGroupTorsion
List of RotorGroups corresponding to free torsion bonds.
Definition: Molecule.h:1297

ObjCryst::Molecule::DihedralAngleRandomChange
REAL DihedralAngleRandomChange(const StretchModeTorsion &mode, const REAL amplitude, const bool respectRestraint=true)
Change a dihedral angle, while respecting the Restraint (if any).
Definition: Molecule.cpp:5055

ObjCryst::Molecule::RotorGroup
Defines a group of atoms which can be rotated around an axis defined by two other atoms.
Definition: Molecule.h:1271

ObjCryst::Molecule::RotorGroup::RotorGroup
RotorGroup(const MolAtom &at1, const MolAtom &at2)
Constructor, with the two atoms around which the rotation shall be made.
Definition: Molecule.cpp:5417

ObjCryst::Molecule::RotorGroup::mvRotatedAtomList
set< MolAtom * > mvRotatedAtomList
The set of atoms that are to be rotated.
Definition: Molecule.h:1281

ObjCryst::Molecule::RotorGroup::mpAtom1
const MolAtom * mpAtom1
The first atom defining the rotation axis.
Definition: Molecule.h:1277

ObjCryst::Molecule::RotorGroup::mBaseRotationAmplitude
REAL mBaseRotationAmplitude
The recommended rotation amplitude, for a base global optimization displacement, to obtain an average...
Definition: Molecule.h:1289

ObjCryst::Molecule::RotorGroup::mpAtom2
const MolAtom * mpAtom2
The second atom defining the rotation axis.
Definition: Molecule.h:1279

ObjCryst::Molecule::FlipGroup
When 3(A1..1n) or more atoms are connected to a same atom A, it defines a 'flip' group,...
Definition: Molecule.h:1324

ObjCryst::Molecule::FlipGroup::mvRotatedChainList
list< pair< const MolAtom *, set< MolAtom * > > > mvRotatedChainList
The set of atoms that are to be rotated during the flip.
Definition: Molecule.h:1340

ObjCryst::Molecule::FlipGroup::mpAtom2
const MolAtom * mpAtom2
The second atom defining the rotation axis.
Definition: Molecule.h:1333

ObjCryst::Molecule::FlipGroup::mpAtom0
const MolAtom * mpAtom0
The atom which is an asymmetric center.
Definition: Molecule.h:1329

ObjCryst::Molecule::FlipGroup::FlipGroup
FlipGroup(const MolAtom &at0, const MolAtom &at1, const MolAtom &at2)
Constructor, with the central atom.
Definition: Molecule.cpp:7807

ObjCryst::Molecule::FlipGroup::mNbTest
unsigned long mNbTest
Number of times this flip has been tried, and the number of times it has been accepted.
Definition: Molecule.h:1345

ObjCryst::Molecule::FlipGroup::mpAtom1
const MolAtom * mpAtom1
The first atom defining the rotation axis.
Definition: Molecule.h:1331

ObjCryst::Molecule::StretchModeGroup
Group of concurrent StretchModes (affecting common restraints) A given stretch mode can only belong t...
Definition: Molecule.h:1371

ObjCryst::Scatterer
Generic type of scatterer: can be an atom, or a more complex assembly of atoms.
Definition: Scatterer.h:131

ObjCryst::ScatteringPower
Abstract Base Class to describe the scattering power of any Scatterer component in a crystal.
Definition: ScatteringPower.h:111

ObjCryst::ScatteringComponentList
list of scattering positions in a crystal, associated with the corresponding occupancy and a pointer ...
Definition: ScatteringPower.h:506

ObjCryst::ZScatterer
ZScatterer: the basic type of complex scatterers, where atom positions are defined using a standard "...
Definition: ZScatterer.h:191

ObjCryst::XMLCrystTag
class to input or output a well-formatted xml beginning or ending tag.
Definition: RefinableObj/IO.h:73

ObjCryst::RefParType
class of refinable parameter types.
Definition: RefinableObj.h:80

ObjCryst::RefinableObjClock
We need to record exactly when refinable objects have been modified for the last time (to avoid re-co...
Definition: RefinableObj.h:140

ObjCryst::Restraint
Restraint: generic class for a restraint of a given model.
Definition: RefinableObj.h:201

ObjCryst::RefinablePar
Generic class for parameters of refinable objects.
Definition: RefinableObj.h:225

ObjCryst::RefObjOpt
Base class for options.
Definition: RefinableObj.h:552

ObjCryst::WXCrystObjBasic
Abstract base class for all objects in wxCryst.
Definition: wxCryst.h:128