pyobjcryst package

Submodules

pyobjcryst.atom module

Python wrapping of Atom.h

See the online ObjCryst++ documentation (http://vincefn.net/ObjCryst/).

Changes from ObjCryst::Atom

  • The default constructor has been disabled. When not followed-up by Init, it will cause segmentation faults, even if it is printed.
class pyobjcryst.atom.Atom

Bases: pyobjcryst._pyobjcryst.Scatterer

GetMass((Atom)arg1) → float :
C++ signature :
double GetMass(ObjCryst::Atom {lvalue})
GetRadius((Atom)arg1) → float :
C++ signature :
double GetRadius(ObjCryst::Atom {lvalue})
GetScatteringPower((Atom)arg1) → ScatteringPower :
C++ signature :
ObjCryst::ScatteringPower const* GetScatteringPower(ObjCryst::Atom)
Init((Atom)arg1, (float)x, (float)y, (float)z, (str)name, (ScatteringPower)pow[, (float)popu=1.0]) → None :
C++ signature :
void Init(ObjCryst::Atom {lvalue},double,double,double,std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,ObjCryst::ScatteringPower const* [,double=1.0])
IsDummy((Atom)arg1) → bool :
C++ signature :
bool IsDummy(ObjCryst::Atom {lvalue})

pyobjcryst.crystal module

Python wrapping of Crystal.h.

See the online ObjCryst++ documentation (http://vincefn.net/ObjCryst/).

Changes from ObjCryst::Crystal

  • CIFOutput accepts a python file-like object
  • CalcDynPopCorr is not enabled, as the API states that this is for internal use only.

Other Changes

  • CreateCrystalFromCIF is placed here instead of in a seperate CIF module. This method accepts a python file rather than a CIF object.
class pyobjcryst.crystal.Crystal

Bases: pyobjcryst._pyobjcryst.UnitCell

AddBondValenceRo((Crystal)arg1, (ScatteringPower)arg2, (ScatteringPower)arg3, (float)arg4) → None :
C++ signature :
void AddBondValenceRo(ObjCryst::Crystal {lvalue},ObjCryst::ScatteringPower,ObjCryst::ScatteringPower,double)
AddScatterer((Crystal)arg1, (Scatterer)arg2) → None :
C++ signature :
void AddScatterer(ObjCryst::Crystal {lvalue},ObjCryst::Scatterer*)
AddScatteringPower((Crystal)arg1, (ScatteringPower)arg2) → None :
C++ signature :
void AddScatteringPower(ObjCryst::Crystal {lvalue},ObjCryst::ScatteringPower*)
CIFOutput((Crystal)arg1, (object)file[, (float)mindist=0]) → None :
C++ signature :
void CIFOutput(ObjCryst::Crystal {lvalue},boost::python::api::object [,double=0])
ConnectAtoms((Crystal)arg1[, (float)min_relat_dist=0.4[, (float)max_relat_dist=1.3[, (bool)warnuser_fail=False]]]) → None :
C++ signature :
void ConnectAtoms(ObjCryst::Crystal {lvalue} [,double=0.4 [,double=1.3 [,bool=False]]])
GetBondValenceCost((Crystal)arg1) → float :
C++ signature :
double GetBondValenceCost(ObjCryst::Crystal {lvalue})
GetBondValenceRoList((Crystal)arg1) → mapsppairtodouble :
C++ signature :
std::__1::map<std::__1::pair<ObjCryst::ScatteringPower const*, ObjCryst::ScatteringPower const*>, double, std::__1::less<std::__1::pair<ObjCryst::ScatteringPower const*, ObjCryst::ScatteringPower const*> >, std::__1::allocator<std::__1::pair<std::__1::pair<ObjCryst::ScatteringPower const*, ObjCryst::ScatteringPower const*> const, double> > > {lvalue} GetBondValenceRoList(ObjCryst::Crystal {lvalue})
GetBumpMergeCost((Crystal)arg1) → float :
C++ signature :
double GetBumpMergeCost(ObjCryst::Crystal {lvalue})
GetBumpMergeParList((Crystal)arg1) → mapsppairtobmp :
C++ signature :
std::__1::map<std::__1::pair<ObjCryst::ScatteringPower const*, ObjCryst::ScatteringPower const*>, ObjCryst::Crystal::BumpMergePar, std::__1::less<std::__1::pair<ObjCryst::ScatteringPower const*, ObjCryst::ScatteringPower const*> >, std::__1::allocator<std::__1::pair<std::__1::pair<ObjCryst::ScatteringPower const*, ObjCryst::ScatteringPower const*> const, ObjCryst::Crystal::BumpMergePar> > > {lvalue} GetBumpMergeParList(ObjCryst::Crystal {lvalue})
GetClockScattCompList((Crystal)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock GetClockScattCompList(ObjCryst::Crystal {lvalue})
GetClockScattererList((Crystal)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock GetClockScattererList(ObjCryst::Crystal {lvalue})
GetMasterClockScatteringPower((Crystal)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock GetMasterClockScatteringPower(ObjCryst::Crystal {lvalue})
GetMinDistanceTable((Crystal)arg1[, (float)minDistance=1.0]) → object :
C++ signature :
CrystMatrix<double> GetMinDistanceTable(ObjCryst::Crystal {lvalue} [,double=1.0])
GetNbScatterer((Crystal)arg1) → int :
C++ signature :
long GetNbScatterer(ObjCryst::Crystal {lvalue})
GetScatt((Crystal)arg1, (str)arg2) → Scatterer :
C++ signature :
ObjCryst::Scatterer {lvalue} GetScatt(ObjCryst::Crystal {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)

GetScatt( (Crystal)arg1, (int)arg2) -> Scatterer :

C++ signature :
ObjCryst::Scatterer {lvalue} GetScatt(ObjCryst::Crystal {lvalue},long)
GetScatterer((Crystal)arg1, (str)arg2) → Scatterer :
C++ signature :
ObjCryst::Scatterer {lvalue} GetScatterer(ObjCryst::Crystal {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)

GetScatterer( (Crystal)arg1, (int)arg2) -> Scatterer :

C++ signature :
ObjCryst::Scatterer {lvalue} GetScatterer(ObjCryst::Crystal {lvalue},long)
GetScattererRegistry((Crystal)arg1) → ScattererRegistry :
C++ signature :
ObjCryst::ObjRegistry<ObjCryst::Scatterer> {lvalue} GetScattererRegistry(ObjCryst::Crystal {lvalue})
GetScatteringComponentList((Crystal)arg1) → list :
C++ signature :
boost::python::list GetScatteringComponentList(ObjCryst::Crystal {lvalue})
GetScatteringPower((Crystal)arg1, (str)arg2) → ScatteringPower :
C++ signature :
ObjCryst::ScatteringPower {lvalue} GetScatteringPower(ObjCryst::Crystal {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
GetScatteringPowerRegistry((Crystal)arg1) → ScatteringPowerRegistry :
C++ signature :
ObjCryst::ObjRegistry<ObjCryst::ScatteringPower> {lvalue} GetScatteringPowerRegistry(ObjCryst::Crystal {lvalue})
GetUseDynPopCorr((Crystal)arg1) → int :
C++ signature :
int GetUseDynPopCorr(ObjCryst::Crystal {lvalue})
PrintMinDistanceTable((Crystal)arg1[, (float)minDistance=1.0]) → None :
C++ signature :
void PrintMinDistanceTable(ObjCryst::Crystal [,double=1.0])
RemoveBondValenceRo((Crystal)arg1, (ScatteringPower)arg2, (ScatteringPower)arg3, (float)arg4) → None :
C++ signature :
void RemoveBondValenceRo(ObjCryst::Crystal {lvalue},ObjCryst::ScatteringPower,ObjCryst::ScatteringPower,double)
RemoveBumpMergeDistance((Crystal)arg1, (ScatteringPower)arg2, (ScatteringPower)arg3) → None :
C++ signature :
void RemoveBumpMergeDistance(ObjCryst::Crystal {lvalue},ObjCryst::ScatteringPower,ObjCryst::ScatteringPower)
RemoveScatterer((Crystal)arg1, (Scatterer)arg2) → None :
C++ signature :
void RemoveScatterer(ObjCryst::Crystal {lvalue},ObjCryst::Scatterer*)
RemoveScatteringPower((Crystal)arg1, (ScatteringPower)arg2) → None :
C++ signature :
void RemoveScatteringPower(ObjCryst::Crystal {lvalue},ObjCryst::ScatteringPower*)
ResetDynPopCorr((Crystal)arg1) → None :
C++ signature :
void ResetDynPopCorr(ObjCryst::Crystal {lvalue})
SetBumpMergeDistance((Crystal)arg1, (ScatteringPower)scatt1, (ScatteringPower)scatt2[, (float)dist=1.5]) → None :
C++ signature :
void SetBumpMergeDistance(ObjCryst::Crystal {lvalue},ObjCryst::ScatteringPower,ObjCryst::ScatteringPower [,double=1.5])

SetBumpMergeDistance( (Crystal)arg1, (ScatteringPower)scatt1, (ScatteringPower)scatt2, (float)dist, (bool)allowMerge) -> None :

C++ signature :
void SetBumpMergeDistance(ObjCryst::Crystal {lvalue},ObjCryst::ScatteringPower,ObjCryst::ScatteringPower,double,bool)
SetUseDynPopCorr((Crystal)arg1, (int)arg2) → None :
C++ signature :
void SetUseDynPopCorr(ObjCryst::Crystal {lvalue},int)
class pyobjcryst.crystal.BumpMergePar

Bases: Boost.Python.instance

mCanOverlap
mDist2
pyobjcryst.crystal.CreateCrystalFromCIF((object)file[, (bool)oneScatteringPowerPerElement=False[, (bool)connectAtoms=False]]) → Crystal :
C++ signature :
ObjCryst::Crystal* CreateCrystalFromCIF(boost::python::api::object [,bool=False [,bool=False]])

pyobjcryst.general module

Python wrapping of things from General.h.

See the online ObjCryst++ documentation (http://vincefn.net/ObjCryst/).

class pyobjcryst.general.RadiationType

Bases: Boost.Python.enum

RAD_ELECTRON = pyobjcryst._pyobjcryst.RadiationType.RAD_ELECTRON
RAD_NEUTRON = pyobjcryst._pyobjcryst.RadiationType.RAD_NEUTRON
RAD_XRAY = pyobjcryst._pyobjcryst.RadiationType.RAD_XRAY
names = {'RAD_XRAY': pyobjcryst._pyobjcryst.RadiationType.RAD_XRAY, 'RAD_ELECTRON': pyobjcryst._pyobjcryst.RadiationType.RAD_ELECTRON, 'RAD_NEUTRON': pyobjcryst._pyobjcryst.RadiationType.RAD_NEUTRON}
values = {0: pyobjcryst._pyobjcryst.RadiationType.RAD_NEUTRON, 1: pyobjcryst._pyobjcryst.RadiationType.RAD_XRAY, 2: pyobjcryst._pyobjcryst.RadiationType.RAD_ELECTRON}
exception pyobjcryst.general.ObjCrystException

Bases: exceptions.Exception

pyobjcryst.io module

Python wrapping of IO.h

See the online ObjCryst++ documentation (http://vincefn.net/ObjCryst/).

Changes from ObjCryst::XMLCrystTag - The istream constructor of XMLCrystTag is not wrapped.

class pyobjcryst.io.XMLCrystTag

Bases: Boost.Python.instance

AddAttribute((XMLCrystTag)arg1, (str)attName, (str)attValue) → None :
C++ signature :
void AddAttribute(ObjCryst::XMLCrystTag {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
GetAttribute((XMLCrystTag)arg1, (int)attNum, (str)attName, (str)attValue) → None :
C++ signature :
void GetAttribute(ObjCryst::XMLCrystTag {lvalue},int,std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > {lvalue})
GetAttributeName((XMLCrystTag)arg1, (int)arg2) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetAttributeName(ObjCryst::XMLCrystTag {lvalue},int)
GetAttributeValue((XMLCrystTag)arg1, (int)arg2) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetAttributeValue(ObjCryst::XMLCrystTag {lvalue},int)
GetClassName((XMLCrystTag)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetClassName(ObjCryst::XMLCrystTag {lvalue})
GetName((XMLCrystTag)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetName(ObjCryst::XMLCrystTag {lvalue})
GetNbAttribute((XMLCrystTag)arg1) → int :
C++ signature :
unsigned int GetNbAttribute(ObjCryst::XMLCrystTag {lvalue})
IsEmptyTag((XMLCrystTag)arg1) → bool :
C++ signature :
bool IsEmptyTag(ObjCryst::XMLCrystTag {lvalue})
IsEndTag((XMLCrystTag)arg1) → bool :
C++ signature :
bool IsEndTag(ObjCryst::XMLCrystTag {lvalue})
Print((XMLCrystTag)arg1) → None :
C++ signature :
void Print(ObjCryst::XMLCrystTag {lvalue})
SetIsEmptyTag((XMLCrystTag)arg1, (bool)arg2) → None :
C++ signature :
void SetIsEmptyTag(ObjCryst::XMLCrystTag {lvalue},bool)
SetIsEndTag((XMLCrystTag)arg1, (bool)arg2) → None :
C++ signature :
void SetIsEndTag(ObjCryst::XMLCrystTag {lvalue},bool)

pyobjcryst.molecule module

Python wrapping of Molecule.h

See the online ObjCryst++ documentation (http://vincefn.net/ObjCryst/).

Changes from ObjCryst::Molecule

  • The public data are not wrapped.
  • Added __getitem__ access for MolAtoms.
  • AddAtom returns the added MolAtom
  • AddBond returns the added MolBond
  • AddBondAngle returns the added MolBondAngle
  • AddDihedralAngle returns the added MolDihedralAngle
  • RemoveAtom returns None, has an indexed version
  • RemoveBond returns None, has an indexed version
  • RemoveBondAngle returns None, has an indexed version
  • RemoveDihedralAngle returns None, has an indexed version
  • RemoveRigidGroup returns None
  • Added GetNbAtoms
  • Added GetNbBonds
  • Added GetNbBondAngles
  • Added GetNbDihedralAngles
  • Added GetNbRigidGroups
  • Added GetBond
  • Added GetBondAngle
  • Added GetDihedralAngle
  • Added GetRigidGroup
  • FindBond returns the bond if found, None otherwise
  • FindBondAngle returns the bond angle if found, None otherwise
  • FindDihedralAngle returns the dihedral angle if found, None otherwise
  • FindAtom is identical to GetAtom.
  • FlipAtomGroup is not wrapped.
  • FlipGroup, RotorGroup and StretchModeGroup are not wrapped.
  • StretchMode getters are not wrapped
  • Quaternion ordinates Q0, Q1, Q2 and Q3 wrapped as properties.

Changes from ObjCryst::MolAtom

  • Wrapped as a to-python converter only (no constructor)
  • File IO is disabled
  • X, Y and Z are wrapped as properties rather than methods.

Changes from ObjCryst::MolBondAngle

  • Wrapped as a to-python converter only (no constructor)
  • Added __getitem__ access for MolAtoms.
  • File IO is disabled
  • GetDeriv and CalcGradient are not wrapped.
  • Angle0, AngleDelta and AngleSigma are wrapped as properties rather than methods.
  • IsFlexible and SetFlexible are not wrapped, as they are not implemented in the library.

Changes from ObjCryst::MolDihedralAngle

  • Wrapped as a to-python converter only (no constructor)
  • Added __getitem__ access for MolAtoms.

Changes from ObjCryst::Quaternion

  • IO is not wrapped
  • Q0, Q1, Q2 and Q3 are wrapped as properties, rather than functions.
  • RotateVector overloaded to return tuple of the mutated arguments.

Changes from ObjCryst::RigidGroup

  • RigidGroup is wrapped to have python-set methods rather than stl::set methods.
class pyobjcryst.molecule.Molecule

Bases: pyobjcryst._pyobjcryst.Scatterer

AddAtom((Molecule)arg1, (float)x, (float)y, (float)z, (ScatteringPower)pPow, (str)name[, (bool)updateDisplay=True]) → MolAtom :
C++ signature :
ObjCryst::MolAtom {lvalue} AddAtom(ObjCryst::Molecule {lvalue},double,double,double,ObjCryst::ScatteringPower const*,std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > [,bool=True])
AddBond((Molecule)arg1, (MolAtom)atom1, (MolAtom)atom2, (float)length, (float)sigma, (float)delta[, (float)bondOrder=1[, (bool)updateDisplay=True]]) → MolBond :
C++ signature :
ObjCryst::MolBond {lvalue} AddBond(ObjCryst::Molecule {lvalue},ObjCryst::MolAtom {lvalue},ObjCryst::MolAtom {lvalue},double,double,double [,double=1 [,bool=True]])
AddBondAngle((Molecule)arg1, (MolAtom)atom1, (MolAtom)atom2, (MolAtom)atom3, (float)angle, (float)sigma, (float)delta[, (bool)updateDisplay=True]) → MolBondAngle :
C++ signature :
ObjCryst::MolBondAngle {lvalue} AddBondAngle(ObjCryst::Molecule {lvalue},ObjCryst::MolAtom {lvalue},ObjCryst::MolAtom {lvalue},ObjCryst::MolAtom {lvalue},double,double,double [,bool=True])
AddDihedralAngle((Molecule)arg1, (MolAtom)atom1, (MolAtom)atom2, (MolAtom)atom3, (MolAtom)atom4, (float)angle, (float)sigma, (float)delta[, (bool)updateDisplay=True]) → MolDihedralAngle :
C++ signature :
ObjCryst::MolDihedralAngle {lvalue} AddDihedralAngle(ObjCryst::Molecule {lvalue},ObjCryst::MolAtom {lvalue},ObjCryst::MolAtom {lvalue},ObjCryst::MolAtom {lvalue},ObjCryst::MolAtom {lvalue},double,double,double [,bool=True])
AddRigidGroup((Molecule)arg1, (RigidGroup)group[, (bool)updateDisplay=True]) → RigidGroup :
C++ signature :
ObjCryst::RigidGroup {lvalue} AddRigidGroup(ObjCryst::Molecule {lvalue},ObjCryst::RigidGroup [,bool=True])

AddRigidGroup( (Molecule)arg1, (object)group [, (bool)updateDisplay=True]) -> RigidGroup :

C++ signature :
ObjCryst::RigidGroup {lvalue} AddRigidGroup(ObjCryst::Molecule {lvalue},boost::python::api::object {lvalue} [,bool=True])
AsZMatrix((Molecule)arg1, (bool)arg2) → list :
C++ signature :
boost::python::list AsZMatrix(ObjCryst::Molecule,bool)
BondAngleRandomChange((Molecule)arg1, (StretchModeBondAngle)mode, (float)amplitude[, (bool)respectRestraint=True]) → float :
C++ signature :
double BondAngleRandomChange(ObjCryst::Molecule {lvalue},ObjCryst::StretchModeBondAngle,double [,bool=True])
BondLengthRandomChange((Molecule)arg1, (StretchModeBondLength)mode, (float)amplitude[, (bool)respectRestraint=True]) → float :
C++ signature :
double BondLengthRandomChange(ObjCryst::Molecule {lvalue},ObjCryst::StretchModeBondLength,double [,bool=True])
BuildConnectivityTable((Molecule)arg1) → None :
C++ signature :
void BuildConnectivityTable(ObjCryst::Molecule {lvalue})
BuildFlipGroup((Molecule)arg1) → None :
C++ signature :
void BuildFlipGroup(ObjCryst::Molecule {lvalue})
BuildRingList((Molecule)arg1) → None :
C++ signature :
void BuildRingList(ObjCryst::Molecule {lvalue})
BuildRotorGroup((Molecule)arg1) → None :
C++ signature :
void BuildRotorGroup(ObjCryst::Molecule {lvalue})
BuildStretchModeBondAngle((Molecule)arg1) → None :
C++ signature :
void BuildStretchModeBondAngle(ObjCryst::Molecule {lvalue})
BuildStretchModeBondLength((Molecule)arg1) → None :
C++ signature :
void BuildStretchModeBondLength(ObjCryst::Molecule {lvalue})
BuildStretchModeGroups((Molecule)arg1) → None :
C++ signature :
void BuildStretchModeGroups(ObjCryst::Molecule {lvalue})
BuildStretchModeTorsion((Molecule)arg1) → None :
C++ signature :
void BuildStretchModeTorsion(ObjCryst::Molecule {lvalue})
BuildStretchModeTwist((Molecule)arg1) → None :
C++ signature :
void BuildStretchModeTwist(ObjCryst::Molecule {lvalue})
DihedralAngleRandomChange((Molecule)arg1, (StretchModeTorsion)mode, (float)amplitude[, (bool)respectRestraint=True]) → float :
C++ signature :
double DihedralAngleRandomChange(ObjCryst::Molecule {lvalue},ObjCryst::StretchModeTorsion,double [,bool=True])
FindAtom((Molecule)arg1, (str)arg2) → MolAtom :
C++ signature :
ObjCryst::MolAtom {lvalue} FindAtom(ObjCryst::Molecule {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
FindBond((Molecule)arg1, (MolAtom)arg2, (MolAtom)arg3) → object :
C++ signature :
_object* FindBond(ObjCryst::Molecule,ObjCryst::MolAtom,ObjCryst::MolAtom)
FindBondAngle((Molecule)arg1, (MolAtom)arg2, (MolAtom)arg3, (MolAtom)arg4) → object :
C++ signature :
_object* FindBondAngle(ObjCryst::Molecule,ObjCryst::MolAtom,ObjCryst::MolAtom,ObjCryst::MolAtom)
FindDihedralAngle((Molecule)arg1, (MolAtom)arg2, (MolAtom)arg3, (MolAtom)arg4, (MolAtom)arg5) → object :
C++ signature :
_object* FindDihedralAngle(ObjCryst::Molecule,ObjCryst::MolAtom,ObjCryst::MolAtom,ObjCryst::MolAtom,ObjCryst::MolAtom)
GetAtom((Molecule)arg1, (int)arg2) → MolAtom :
C++ signature :
ObjCryst::MolAtom {lvalue} GetAtom(ObjCryst::Molecule {lvalue},int)

GetAtom( (Molecule)arg1, (str)arg2) -> MolAtom :

C++ signature :
ObjCryst::MolAtom {lvalue} GetAtom(ObjCryst::Molecule {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
GetAtomList((Molecule)arg1) → list :
C++ signature :
boost::python::list GetAtomList(ObjCryst::Molecule)
GetAtomPositionClock((Molecule)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock {lvalue} GetAtomPositionClock(ObjCryst::Molecule {lvalue})
GetBond((Molecule)arg1, (int)arg2) → MolBond :
C++ signature :
ObjCryst::MolBond {lvalue} GetBond(ObjCryst::Molecule {lvalue},int)
GetBondAngle((Molecule)arg1, (int)arg2) → MolBondAngle :
C++ signature :
ObjCryst::MolBondAngle {lvalue} GetBondAngle(ObjCryst::Molecule {lvalue},int)
GetBondAngleList((Molecule)arg1) → list :
C++ signature :
boost::python::list GetBondAngleList(ObjCryst::Molecule)
GetBondList((Molecule)arg1) → list :
C++ signature :
boost::python::list GetBondList(ObjCryst::Molecule)
GetBondListClock((Molecule)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock {lvalue} GetBondListClock(ObjCryst::Molecule {lvalue})
GetCenterAtom((Molecule)arg1) → MolAtom :
C++ signature :
ObjCryst::MolAtom const* GetCenterAtom(ObjCryst::Molecule {lvalue})
GetConnectivityTable((Molecule)arg1) → dict :
C++ signature :
boost::python::dict GetConnectivityTable(ObjCryst::Molecule {lvalue})
GetDihedralAngle((Molecule)arg1, (int)arg2) → MolDihedralAngle :
C++ signature :
ObjCryst::MolDihedralAngle {lvalue} GetDihedralAngle(ObjCryst::Molecule {lvalue},int)
GetDihedralAngleList((Molecule)arg1) → list :
C++ signature :
boost::python::list GetDihedralAngleList(ObjCryst::Molecule)
GetFormula((Molecule)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetFormula(ObjCryst::Molecule {lvalue})
GetNbAtoms((Molecule)arg1) → int :
C++ signature :
unsigned long GetNbAtoms(ObjCryst::Molecule {lvalue})
GetNbBondAngles((Molecule)arg1) → int :
C++ signature :
unsigned long GetNbBondAngles(ObjCryst::Molecule {lvalue})
GetNbBonds((Molecule)arg1) → int :
C++ signature :
unsigned long GetNbBonds(ObjCryst::Molecule {lvalue})
GetNbDihedralAngles((Molecule)arg1) → int :
C++ signature :
unsigned long GetNbDihedralAngles(ObjCryst::Molecule {lvalue})
GetNbRigidGroups((Molecule)arg1) → int :
C++ signature :
unsigned long GetNbRigidGroups(ObjCryst::Molecule {lvalue})
GetRigidGroupClock((Molecule)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock {lvalue} GetRigidGroupClock(ObjCryst::Molecule {lvalue})
GetRigidGroupList((Molecule)arg1) → list :
C++ signature :
boost::python::list GetRigidGroupList(ObjCryst::Molecule)
GetStretchModeBondAngleList((Molecule)arg1) → list :
C++ signature :
boost::python::list GetStretchModeBondAngleList(ObjCryst::Molecule)
GetStretchModeBondLengthList((Molecule)arg1) → list :
C++ signature :
boost::python::list GetStretchModeBondLengthList(ObjCryst::Molecule)
GetStretchModeTorsionList((Molecule)arg1) → list :
C++ signature :
boost::python::list GetStretchModeTorsionList(ObjCryst::Molecule)
InitOptions((Molecule)arg1) → None :
C++ signature :
void InitOptions(ObjCryst::Molecule {lvalue})
OptimizeConformation((Molecule)arg1[, (int)nbTrial=10000[, (float)stopCost=0]]) → None :
C++ signature :
void OptimizeConformation(ObjCryst::Molecule {lvalue} [,long=10000 [,double=0]])
OptimizeConformationSteepestDescent((Molecule)arg1[, (float)maxStep=0.1[, (int)nbSteps=1]]) → None :
C++ signature :
void OptimizeConformationSteepestDescent(ObjCryst::Molecule {lvalue} [,double=0.1 [,unsigned int=1]])
Q0
Q1
Q2
Q3
RemoveAtom((Molecule)arg1, (MolAtom)arg2) → None :
C++ signature :
void RemoveAtom(ObjCryst::Molecule {lvalue},ObjCryst::MolAtom {lvalue})

RemoveAtom( (Molecule)arg1, (int)arg2) -> None :

C++ signature :
void RemoveAtom(ObjCryst::Molecule {lvalue},int)
RemoveBond((Molecule)arg1, (MolBond)arg2) → None :
C++ signature :
void RemoveBond(ObjCryst::Molecule {lvalue},ObjCryst::MolBond)

RemoveBond( (Molecule)arg1, (int)arg2) -> None :

C++ signature :
void RemoveBond(ObjCryst::Molecule {lvalue},int)
RemoveBondAngle((Molecule)arg1, (MolBondAngle)arg2) → None :
C++ signature :
void RemoveBondAngle(ObjCryst::Molecule {lvalue},ObjCryst::MolBondAngle {lvalue})

RemoveBondAngle( (Molecule)arg1, (int)arg2) -> None :

C++ signature :
void RemoveBondAngle(ObjCryst::Molecule {lvalue},int)
RemoveDihedralAngle((Molecule)arg1, (MolDihedralAngle)arg2) → None :
C++ signature :
void RemoveDihedralAngle(ObjCryst::Molecule {lvalue},ObjCryst::MolDihedralAngle {lvalue})

RemoveDihedralAngle( (Molecule)arg1, (int)arg2) -> None :

C++ signature :
void RemoveDihedralAngle(ObjCryst::Molecule {lvalue},int)
RemoveRigidGroup((Molecule)arg1, (RigidGroup)group[, (bool)updateDisplay=True]) → None :
C++ signature :
void RemoveRigidGroup(ObjCryst::Molecule {lvalue},ObjCryst::RigidGroup {lvalue} [,bool=True])
RigidifyWithDihedralAngles((Molecule)arg1) → None :
C++ signature :
void RigidifyWithDihedralAngles(ObjCryst::Molecule {lvalue})
RotateAtomGroup((Molecule)arg1, (MolAtom)at1, (MolAtom)at2, (object)atoms, (float)angle[, (bool)keepCenter=True]) → None :
C++ signature :
void RotateAtomGroup(ObjCryst::Molecule {lvalue},ObjCryst::MolAtom,ObjCryst::MolAtom,boost::python::api::object,double [,bool=True])

RotateAtomGroup( (Molecule)arg1, (MolAtom)at1, (float)vx, (float)vy, (float)vz, (object)atoms, (float)angle [, (bool)keepCenter=True]) -> None :

C++ signature :
void RotateAtomGroup(ObjCryst::Molecule {lvalue},ObjCryst::MolAtom,double,double,double,boost::python::api::object,double [,bool=True])

RotateAtomGroup( (Molecule)arg1, (object)v1, (object)v2, (object)atoms, (float)angle [, (bool)keepCenter=True]) -> None :

C++ signature :
void RotateAtomGroup(ObjCryst::Molecule {lvalue},boost::python::api::object {lvalue},boost::python::api::object {lvalue},boost::python::api::object,double [,bool=True])
SetCenterAtom((Molecule)arg1, (MolAtom)arg2) → None :
C++ signature :
void SetCenterAtom(ObjCryst::Molecule {lvalue},ObjCryst::MolAtom)
TranslateAtomGroup((Molecule)arg1, (object)atoms, (float)dx, (float)dy, (float)dz[, (bool)keepCenter=True]) → None :
C++ signature :
void TranslateAtomGroup(ObjCryst::Molecule {lvalue},boost::python::api::object,double,double,double [,bool=True])
TuneGlobalOptimRotationAmplitude((Molecule)arg1) → None :
C++ signature :
void TuneGlobalOptimRotationAmplitude(ObjCryst::Molecule {lvalue})
UpdateScattCompList((Molecule)arg1) → None :
C++ signature :
void UpdateScattCompList(ObjCryst::Molecule {lvalue})
pyobjcryst.molecule.GetBondLength((MolAtom)arg1, (MolAtom)arg2) → float :
C++ signature :
double GetBondLength(ObjCryst::MolAtom,ObjCryst::MolAtom)
pyobjcryst.molecule.GetBondAngle((MolAtom)arg1, (MolAtom)arg2, (MolAtom)arg3) → float :
C++ signature :
double GetBondAngle(ObjCryst::MolAtom,ObjCryst::MolAtom,ObjCryst::MolAtom)
pyobjcryst.molecule.GetDihedralAngle((MolAtom)arg1, (MolAtom)arg2, (MolAtom)arg3, (MolAtom)arg4) → float :
C++ signature :
double GetDihedralAngle(ObjCryst::MolAtom,ObjCryst::MolAtom,ObjCryst::MolAtom,ObjCryst::MolAtom)
class pyobjcryst.molecule.MolAtom

Bases: Boost.Python.instance

GetMolecule((MolAtom)arg1) → Molecule :
C++ signature :
ObjCryst::Molecule {lvalue} GetMolecule(ObjCryst::MolAtom {lvalue})
GetName((MolAtom)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetName(ObjCryst::MolAtom {lvalue})
GetOccupancy((MolAtom)arg1) → float :
C++ signature :
double GetOccupancy(ObjCryst::MolAtom {lvalue})
GetScatteringPower((MolAtom)arg1) → ScatteringPower :
C++ signature :
ObjCryst::ScatteringPower const* GetScatteringPower(ObjCryst::MolAtom)
GetX((MolAtom)arg1) → float :
C++ signature :
double GetX(ObjCryst::MolAtom {lvalue})
GetY((MolAtom)arg1) → float :
C++ signature :
double GetY(ObjCryst::MolAtom {lvalue})
GetZ((MolAtom)arg1) → float :
C++ signature :
double GetZ(ObjCryst::MolAtom {lvalue})
IsDummy((MolAtom)arg1) → bool :
C++ signature :
bool IsDummy(ObjCryst::MolAtom {lvalue})
IsInRing((MolAtom)arg1) → bool :
C++ signature :
bool IsInRing(ObjCryst::MolAtom {lvalue})
Occupancy
SetIsInRing((MolAtom)arg1, (bool)arg2) → None :
C++ signature :
void SetIsInRing(ObjCryst::MolAtom {lvalue},bool)
SetName((MolAtom)arg1, (str)arg2) → None :
C++ signature :
void SetName(ObjCryst::MolAtom {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
SetOccupancy((MolAtom)arg1, (float)arg2) → None :
C++ signature :
void SetOccupancy(ObjCryst::MolAtom {lvalue},double)
SetX((MolAtom)arg1, (float)arg2) → None :
C++ signature :
void SetX(ObjCryst::MolAtom {lvalue},double)
SetY((MolAtom)arg1, (float)arg2) → None :
C++ signature :
void SetY(ObjCryst::MolAtom {lvalue},double)
SetZ((MolAtom)arg1, (float)arg2) → None :
C++ signature :
void SetZ(ObjCryst::MolAtom {lvalue},double)
X
Y
Z
class pyobjcryst.molecule.MolBond

Bases: pyobjcryst._pyobjcryst.Restraint

BondOrder
GetAtom1((MolBond)arg1) → MolAtom :
C++ signature :
ObjCryst::MolAtom {lvalue} GetAtom1(ObjCryst::MolBond {lvalue})
GetAtom2((MolBond)arg1) → MolAtom :
C++ signature :
ObjCryst::MolAtom {lvalue} GetAtom2(ObjCryst::MolBond {lvalue})
GetBondOrder((MolBond)arg1) → float :
C++ signature :
double GetBondOrder(ObjCryst::MolBond {lvalue})
GetLength((MolBond)arg1) → float :
C++ signature :
double GetLength(ObjCryst::MolBond {lvalue})
GetLength0((MolBond)arg1) → float :
C++ signature :
double GetLength0(ObjCryst::MolBond {lvalue})
GetLengthDelta((MolBond)arg1) → float :
C++ signature :
double GetLengthDelta(ObjCryst::MolBond {lvalue})
GetLengthSigma((MolBond)arg1) → float :
C++ signature :
double GetLengthSigma(ObjCryst::MolBond {lvalue})
GetLogLikelihood((MolBond)arg1) → float :
C++ signature :
double GetLogLikelihood(ObjCryst::MolBond {lvalue})

GetLogLikelihood( (MolBond)arg1, (bool)arg2, (bool)arg3) -> float :

C++ signature :
double GetLogLikelihood(ObjCryst::MolBond {lvalue},bool,bool)
GetMolecule((MolBond)arg1) → Molecule :
C++ signature :
ObjCryst::Molecule {lvalue} GetMolecule(ObjCryst::MolBond {lvalue})
GetName((MolBond)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetName(ObjCryst::MolBond {lvalue})
IsFreeTorsion((MolBond)arg1) → bool :
C++ signature :
bool IsFreeTorsion(ObjCryst::MolBond {lvalue})
Length
Length0
LengthDelta
LengthSigma
SetAtom1((MolBond)arg1, (MolAtom)arg2) → None :
C++ signature :
void SetAtom1(ObjCryst::MolBond {lvalue},ObjCryst::MolAtom {lvalue})
SetAtom2((MolBond)arg1, (MolAtom)arg2) → None :
C++ signature :
void SetAtom2(ObjCryst::MolBond {lvalue},ObjCryst::MolAtom {lvalue})
SetBondOrder((MolBond)arg1, (float)arg2) → None :
C++ signature :
void SetBondOrder(ObjCryst::MolBond {lvalue},double)
SetFreeTorsion((MolBond)arg1, (bool)arg2) → None :
C++ signature :
void SetFreeTorsion(ObjCryst::MolBond {lvalue},bool)
SetLength0((MolBond)arg1, (float)arg2) → None :
C++ signature :
void SetLength0(ObjCryst::MolBond {lvalue},double)
SetLengthDelta((MolBond)arg1, (float)arg2) → None :
C++ signature :
void SetLengthDelta(ObjCryst::MolBond {lvalue},double)
SetLengthSigma((MolBond)arg1, (float)arg2) → None :
C++ signature :
void SetLengthSigma(ObjCryst::MolBond {lvalue},double)
class pyobjcryst.molecule.MolBondAngle

Bases: pyobjcryst._pyobjcryst.Restraint

Angle
Angle0
AngleDelta
AngleSigma
GetAngle((MolBondAngle)arg1) → float :
C++ signature :
double GetAngle(ObjCryst::MolBondAngle {lvalue})
GetAngle0((MolBondAngle)arg1) → float :
C++ signature :
double GetAngle0(ObjCryst::MolBondAngle {lvalue})
GetAngleDelta((MolBondAngle)arg1) → float :
C++ signature :
double GetAngleDelta(ObjCryst::MolBondAngle {lvalue})
GetAngleSigma((MolBondAngle)arg1) → float :
C++ signature :
double GetAngleSigma(ObjCryst::MolBondAngle {lvalue})
GetAtom1((MolBondAngle)arg1) → MolAtom :
C++ signature :
ObjCryst::MolAtom {lvalue} GetAtom1(ObjCryst::MolBondAngle {lvalue})
GetAtom2((MolBondAngle)arg1) → MolAtom :
C++ signature :
ObjCryst::MolAtom {lvalue} GetAtom2(ObjCryst::MolBondAngle {lvalue})
GetAtom3((MolBondAngle)arg1) → MolAtom :
C++ signature :
ObjCryst::MolAtom {lvalue} GetAtom3(ObjCryst::MolBondAngle {lvalue})
GetLogLikelihood((MolBondAngle)arg1) → float :
C++ signature :
double GetLogLikelihood(ObjCryst::MolBondAngle {lvalue})

GetLogLikelihood( (MolBondAngle)arg1, (bool)arg2, (bool)arg3) -> float :

C++ signature :
double GetLogLikelihood(ObjCryst::MolBondAngle {lvalue},bool,bool)
GetMolecule((MolBondAngle)arg1) → Molecule :
C++ signature :
ObjCryst::Molecule {lvalue} GetMolecule(ObjCryst::MolBondAngle {lvalue})
GetName((MolBondAngle)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetName(ObjCryst::MolBondAngle {lvalue})
SetAngle0((MolBondAngle)arg1, (float)arg2) → None :
C++ signature :
void SetAngle0(ObjCryst::MolBondAngle {lvalue},double)
SetAngleDelta((MolBondAngle)arg1, (float)arg2) → None :
C++ signature :
void SetAngleDelta(ObjCryst::MolBondAngle {lvalue},double)
SetAngleSigma((MolBondAngle)arg1, (float)arg2) → None :
C++ signature :
void SetAngleSigma(ObjCryst::MolBondAngle {lvalue},double)
SetAtom1((MolBondAngle)arg1, (MolAtom)arg2) → None :
C++ signature :
void SetAtom1(ObjCryst::MolBondAngle {lvalue},ObjCryst::MolAtom {lvalue})
SetAtom2((MolBondAngle)arg1, (MolAtom)arg2) → None :
C++ signature :
void SetAtom2(ObjCryst::MolBondAngle {lvalue},ObjCryst::MolAtom {lvalue})
SetAtom3((MolBondAngle)arg1, (MolAtom)arg2) → None :
C++ signature :
void SetAtom3(ObjCryst::MolBondAngle {lvalue},ObjCryst::MolAtom {lvalue})
class pyobjcryst.molecule.MolDihedralAngle

Bases: pyobjcryst._pyobjcryst.Restraint

Angle
Angle0
AngleDelta
AngleSigma
GetAngle((MolDihedralAngle)arg1) → float :
C++ signature :
double GetAngle(ObjCryst::MolDihedralAngle {lvalue})
GetAngle0((MolDihedralAngle)arg1) → float :
C++ signature :
double GetAngle0(ObjCryst::MolDihedralAngle {lvalue})
GetAngleDelta((MolDihedralAngle)arg1) → float :
C++ signature :
double GetAngleDelta(ObjCryst::MolDihedralAngle {lvalue})
GetAngleSigma((MolDihedralAngle)arg1) → float :
C++ signature :
double GetAngleSigma(ObjCryst::MolDihedralAngle {lvalue})
GetAtom1((MolDihedralAngle)arg1) → MolAtom :
C++ signature :
ObjCryst::MolAtom {lvalue} GetAtom1(ObjCryst::MolDihedralAngle {lvalue})
GetAtom2((MolDihedralAngle)arg1) → MolAtom :
C++ signature :
ObjCryst::MolAtom {lvalue} GetAtom2(ObjCryst::MolDihedralAngle {lvalue})
GetAtom3((MolDihedralAngle)arg1) → MolAtom :
C++ signature :
ObjCryst::MolAtom {lvalue} GetAtom3(ObjCryst::MolDihedralAngle {lvalue})
GetAtom4((MolDihedralAngle)arg1) → MolAtom :
C++ signature :
ObjCryst::MolAtom {lvalue} GetAtom4(ObjCryst::MolDihedralAngle {lvalue})
GetLogLikelihood((MolDihedralAngle)arg1) → float :
C++ signature :
double GetLogLikelihood(ObjCryst::MolDihedralAngle {lvalue})

GetLogLikelihood( (MolDihedralAngle)arg1, (bool)arg2, (bool)arg3) -> float :

C++ signature :
double GetLogLikelihood(ObjCryst::MolDihedralAngle {lvalue},bool,bool)
GetMolecule((MolDihedralAngle)arg1) → Molecule :
C++ signature :
ObjCryst::Molecule {lvalue} GetMolecule(ObjCryst::MolDihedralAngle {lvalue})
GetName((MolDihedralAngle)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetName(ObjCryst::MolDihedralAngle {lvalue})
SetAngle0((MolDihedralAngle)arg1, (float)arg2) → None :
C++ signature :
void SetAngle0(ObjCryst::MolDihedralAngle {lvalue},double)
SetAngleDelta((MolDihedralAngle)arg1, (float)arg2) → None :
C++ signature :
void SetAngleDelta(ObjCryst::MolDihedralAngle {lvalue},double)
SetAngleSigma((MolDihedralAngle)arg1, (float)arg2) → None :
C++ signature :
void SetAngleSigma(ObjCryst::MolDihedralAngle {lvalue},double)
SetAtom1((MolDihedralAngle)arg1, (MolAtom)arg2) → None :
C++ signature :
void SetAtom1(ObjCryst::MolDihedralAngle {lvalue},ObjCryst::MolAtom {lvalue})
SetAtom2((MolDihedralAngle)arg1, (MolAtom)arg2) → None :
C++ signature :
void SetAtom2(ObjCryst::MolDihedralAngle {lvalue},ObjCryst::MolAtom {lvalue})
SetAtom3((MolDihedralAngle)arg1, (MolAtom)arg2) → None :
C++ signature :
void SetAtom3(ObjCryst::MolDihedralAngle {lvalue},ObjCryst::MolAtom {lvalue})
SetAtom4((MolDihedralAngle)arg1, (MolAtom)arg2) → None :
C++ signature :
void SetAtom4(ObjCryst::MolDihedralAngle {lvalue},ObjCryst::MolAtom {lvalue})
class pyobjcryst.molecule.Quaternion

Bases: Boost.Python.instance

GetConjugate((Quaternion)arg1) → Quaternion :
C++ signature :
ObjCryst::Quaternion GetConjugate(ObjCryst::Quaternion {lvalue})
GetNorm((Quaternion)arg1) → float :
C++ signature :
double GetNorm(ObjCryst::Quaternion {lvalue})
Normalize((Quaternion)arg1) → None :
C++ signature :
void Normalize(ObjCryst::Quaternion {lvalue})
Q0
Q1
Q2
Q3
RotateVector((Quaternion)arg1, (float)v1, (float)v2, (float)v3) → tuple :
C++ signature :
boost::python::tuple RotateVector(ObjCryst::Quaternion,double,double,double)
static RotationQuaternion((float)ang, (float)v1, (float)v2, (float)v3) → Quaternion :
C++ signature :
ObjCryst::Quaternion RotationQuaternion(double,double,double,double)
class pyobjcryst.molecule.RigidGroup

Bases: pyobjcryst._pyobjcryst.MolAtomSet

GetName((RigidGroup)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetName(ObjCryst::RigidGroup {lvalue})
class pyobjcryst.molecule.StretchMode

Bases: Boost.Python.instance

CalcDeriv((StretchMode)arg1[, (bool)derivllk=True]) → None :
C++ signature :
void CalcDeriv(ObjCryst::StretchMode {lvalue} [,bool=True])

CalcDeriv( (StretchMode)arg1, (bool)arg2) -> None :

C++ signature :
void CalcDeriv((anonymous namespace)::StretchModeWrap {lvalue},bool)
RandomStretch((StretchMode)arg1, (float)arg2, (bool)amplitude) → None :
C++ signature :
void RandomStretch(ObjCryst::StretchMode {lvalue},double,bool)

RandomStretch( (StretchMode)arg1, (float)arg2, (bool)arg3) -> None :

C++ signature :
void RandomStretch((anonymous namespace)::StretchModeWrap {lvalue},double,bool)
Stretch((StretchMode)arg1, (float)amplitude[, (bool)keepCenter=True]) → None :
C++ signature :
void Stretch(ObjCryst::StretchMode {lvalue},double [,bool=True])

Stretch( (StretchMode)arg1, (float)arg2, (bool)arg3) -> None :

C++ signature :
void Stretch((anonymous namespace)::StretchModeWrap {lvalue},double,bool)
class pyobjcryst.molecule.StretchModeBondLength

Bases: pyobjcryst._pyobjcryst.StretchMode

AddAtom((StretchModeBondLength)arg1, (MolAtom)arg2) → None :
C++ signature :
void AddAtom(ObjCryst::StretchModeBondLength {lvalue},ObjCryst::MolAtom {lvalue})
AddAtoms((StretchModeBondLength)arg1, (object)arg2) → None :
C++ signature :
void AddAtoms(ObjCryst::StretchModeBondLength {lvalue},boost::python::api::object {lvalue})

AddAtoms( (StretchModeBondLength)arg1, (MolAtomSet)arg2) -> None :

C++ signature :
void AddAtoms(ObjCryst::StretchModeBondLength {lvalue},std::__1::set<ObjCryst::MolAtom*, std::__1::less<ObjCryst::MolAtom*>, std::__1::allocator<ObjCryst::MolAtom*> > {lvalue})
GetAtoms((StretchModeBondLength)arg1) → list :
C++ signature :
boost::python::list GetAtoms(ObjCryst::StretchModeBondLength {lvalue})
mpAtom0
mpAtom1
class pyobjcryst.molecule.StretchModeBondAngle

Bases: pyobjcryst._pyobjcryst.StretchMode

AddAtom((StretchModeBondAngle)arg1, (MolAtom)arg2) → None :
C++ signature :
void AddAtom(ObjCryst::StretchModeBondAngle {lvalue},ObjCryst::MolAtom {lvalue})
AddAtoms((StretchModeBondAngle)arg1, (object)arg2) → None :
C++ signature :
void AddAtoms(ObjCryst::StretchModeBondAngle {lvalue},boost::python::api::object {lvalue})

AddAtoms( (StretchModeBondAngle)arg1, (MolAtomSet)arg2) -> None :

C++ signature :
void AddAtoms(ObjCryst::StretchModeBondAngle {lvalue},std::__1::set<ObjCryst::MolAtom*, std::__1::less<ObjCryst::MolAtom*>, std::__1::allocator<ObjCryst::MolAtom*> > {lvalue})
GetAtoms((StretchModeBondAngle)arg1) → list :
C++ signature :
boost::python::list GetAtoms(ObjCryst::StretchModeBondAngle {lvalue})
mpAtom0
mpAtom1
mpAtom2
class pyobjcryst.molecule.StretchModeTorsion

Bases: pyobjcryst._pyobjcryst.StretchMode

AddAtom((StretchModeTorsion)arg1, (MolAtom)arg2) → None :
C++ signature :
void AddAtom(ObjCryst::StretchModeTorsion {lvalue},ObjCryst::MolAtom {lvalue})
AddAtoms((StretchModeTorsion)arg1, (object)arg2) → None :
C++ signature :
void AddAtoms(ObjCryst::StretchModeTorsion {lvalue},boost::python::api::object {lvalue})

AddAtoms( (StretchModeTorsion)arg1, (MolAtomSet)arg2) -> None :

C++ signature :
void AddAtoms(ObjCryst::StretchModeTorsion {lvalue},std::__1::set<ObjCryst::MolAtom*, std::__1::less<ObjCryst::MolAtom*>, std::__1::allocator<ObjCryst::MolAtom*> > {lvalue})
GetAtoms((StretchModeTorsion)arg1) → list :
C++ signature :
boost::python::list GetAtoms(ObjCryst::StretchModeTorsion {lvalue})
mpAtom1
mpAtom2
class pyobjcryst.molecule.StretchModeTwist

Bases: pyobjcryst._pyobjcryst.StretchMode

AddAtom((StretchModeTwist)arg1, (MolAtom)arg2) → None :
C++ signature :
void AddAtom(ObjCryst::StretchModeTwist {lvalue},ObjCryst::MolAtom {lvalue})
AddAtoms((StretchModeTwist)arg1, (object)arg2) → None :
C++ signature :
void AddAtoms(ObjCryst::StretchModeTwist {lvalue},boost::python::api::object {lvalue})

AddAtoms( (StretchModeTwist)arg1, (MolAtomSet)arg2) -> None :

C++ signature :
void AddAtoms(ObjCryst::StretchModeTwist {lvalue},std::__1::set<ObjCryst::MolAtom*, std::__1::less<ObjCryst::MolAtom*>, std::__1::allocator<ObjCryst::MolAtom*> > {lvalue})
GetAtoms((StretchModeTwist)arg1) → list :
C++ signature :
boost::python::list GetAtoms(ObjCryst::StretchModeTwist {lvalue})
mpAtom1
mpAtom2

pyobjcryst.polyhedron module

Python wrapping of Polyhedron.h

See the online ObjCryst++ documentation (http://vincefn.net/ObjCryst/).

pyobjcryst.polyhedron.MakeTetrahedron((Crystal)cryst, (str)name, (ScatteringPower)centralAtom, (ScatteringPower)peripheralAtom, (float)dist) → Molecule :
C++ signature :
ObjCryst::Molecule* MakeTetrahedron(ObjCryst::Crystal {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,ObjCryst::ScatteringPower const*,ObjCryst::ScatteringPower const*,double)
pyobjcryst.polyhedron.MakeOctahedron((Crystal)cryst, (str)name, (ScatteringPower)centralAtom, (ScatteringPower)peripheralAtom, (float)dist) → Molecule :
C++ signature :
ObjCryst::Molecule* MakeOctahedron(ObjCryst::Crystal {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,ObjCryst::ScatteringPower const*,ObjCryst::ScatteringPower const*,double)
pyobjcryst.polyhedron.MakeSquarePlane((Crystal)cryst, (str)name, (ScatteringPower)centralAtom, (ScatteringPower)peripheralAtom, (float)dist) → Molecule :
C++ signature :
ObjCryst::Molecule* MakeSquarePlane(ObjCryst::Crystal {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,ObjCryst::ScatteringPower const*,ObjCryst::ScatteringPower const*,double)
pyobjcryst.polyhedron.MakeCube((Crystal)cryst, (str)name, (ScatteringPower)centralAtom, (ScatteringPower)peripheralAtom, (float)dist) → Molecule :
C++ signature :
ObjCryst::Molecule* MakeCube(ObjCryst::Crystal {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,ObjCryst::ScatteringPower const*,ObjCryst::ScatteringPower const*,double)
pyobjcryst.polyhedron.MakeAntiPrismTetragonal((Crystal)cryst, (str)name, (ScatteringPower)centralAtom, (ScatteringPower)peripheralAtom, (float)dist) → Molecule :
C++ signature :
ObjCryst::Molecule* MakeAntiPrismTetragonal(ObjCryst::Crystal {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,ObjCryst::ScatteringPower const*,ObjCryst::ScatteringPower const*,double)
pyobjcryst.polyhedron.MakePrismTrigonal((Crystal)cryst, (str)name, (ScatteringPower)centralAtom, (ScatteringPower)peripheralAtom, (float)dist) → Molecule :
C++ signature :
ObjCryst::Molecule* MakePrismTrigonal(ObjCryst::Crystal {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,ObjCryst::ScatteringPower const*,ObjCryst::ScatteringPower const*,double)
pyobjcryst.polyhedron.MakeIcosahedron((Crystal)cryst, (str)name, (ScatteringPower)centralAtom, (ScatteringPower)peripheralAtom, (float)dist) → Molecule :
C++ signature :
ObjCryst::Molecule* MakeIcosahedron(ObjCryst::Crystal {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,ObjCryst::ScatteringPower const*,ObjCryst::ScatteringPower const*,double)
pyobjcryst.polyhedron.MakeTriangle((Crystal)cryst, (str)name, (ScatteringPower)centralAtom, (ScatteringPower)peripheralAtom, (float)dist) → Molecule :
C++ signature :
ObjCryst::Molecule* MakeTriangle(ObjCryst::Crystal {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,ObjCryst::ScatteringPower const*,ObjCryst::ScatteringPower const*,double)

pyobjcryst.refinableobj module

Python wrapping of RefinableObj.h

See the online ObjCryst++ documentation (http://vincefn.net/ObjCryst/).

Changes from ObjCryst::RefinableObj

  • XMLOutput and XMLInput accept python file-like objects.
  • GetPar that takes a const double* is not exposed, as it is designed for internal use.
  • GetParamSet returns a copy of the internal data so that no indirect manipulation can take place from python.
  • SetDeleteRefParInDestructor(false) is called in the constructors of the python class and the parameter accessors.
  • SetDeleteRefParInDestructor is not exposed.
  • RemovePar is overloaded to return None.

Changes from ObjCryst::RefinablePar

  • The constructor has been changed to accept a double, rather than a pointer to a double.
  • The copy and default constructors and Init are not wrapped in order to avoid memory corruption. Since boost cannot implicitly handle double* object, a wrapper class had to be created. However, this wrapper class cannot be used to convert RefinablePar objected created in c++. Thus, ObjCryst::RefinablePar objects created in c++ are passed into python as instances of _RefinablePar, which is a python wrapper around ObjCryst::RefinablePar. The RefinablePar python class is a wrapper around the C++ class PyRefinablePar, which manages its own double*. These python classes are interchangable once instantiated, so users should not notice.
  • XML input/output are not exposed.

Changes from ObjCryst::RefinableObjClock

  • operator= is wrapped as the SetEqual method a.SetEqual(b) -> a = b

Changes from ObjCryst::ObjRegistry

  • DeleteAll not wrapped
  • GetObj(const unsigned int i) not wrapped. Documentation says that this is for internal use only.

Changes from ObjCryst::Restraint

  • The default and copy constructors are not wrapped, nor is Init.
  • GetType returns a non-const reference to the RefParType. This should be a no-no, but RefParType has no mutating methods, so this should no lead to trouble.
  • XML input/output are not exposed.
class pyobjcryst.refinableobj.RefinableObjClock

Bases: Boost.Python.instance

We need to record exactly when refinable objects have been modified for the last time (to avoid re-computation), and to do that we need a precise time. Since the clock() function is not precise enough (and is architecture-dependant), we use a custom time, which records the number of events in the program which uses the library. This is purely internal, so don’t worry about it...

The clock values have nothing to do with ‘time’ as any normal person undertands it.

AddChild((RefinableObjClock)arg1, (RefinableObjClock)arg2) → None :

Add a ‘child’ clock. Whenever a child clock is clicked, it will also click its parent. This function takes care of adding itself to the list of parent in the children clock.

C++ signature :
void AddChild(ObjCryst::RefinableObjClock {lvalue},ObjCryst::RefinableObjClock)
AddParent((RefinableObjClock)arg1, (RefinableObjClock)arg2) → None :

Add a ‘parent’ clock. Whenever a clock is clicked, all parent clocks also are.

C++ signature :
void AddParent(ObjCryst::RefinableObjClock {lvalue},ObjCryst::RefinableObjClock {lvalue})
Click((RefinableObjClock)arg1) → None :

Record an event for this clock (generally, the ‘time’ an object has been modified, or some computation has been made)

C++ signature :
void Click(ObjCryst::RefinableObjClock {lvalue})
Print((RefinableObjClock)arg1) → None :

Print clock value. Only for debugging purposes.

C++ signature :
void Print(ObjCryst::RefinableObjClock {lvalue})
PrintStatic((RefinableObjClock)arg1) → None :

Print current general clock value. Only for debugging purposes.

C++ signature :
void PrintStatic(ObjCryst::RefinableObjClock {lvalue})
RemoveChild((RefinableObjClock)arg1, (RefinableObjClock)arg2) → None :

remove a child clock. This also tells the child clock to remove the parent.

C++ signature :
void RemoveChild(ObjCryst::RefinableObjClock {lvalue},ObjCryst::RefinableObjClock)
RemoveParent((RefinableObjClock)arg1, (RefinableObjClock)arg2) → None :

remove a parent clock

C++ signature :
void RemoveParent(ObjCryst::RefinableObjClock {lvalue},ObjCryst::RefinableObjClock {lvalue})
Reset((RefinableObjClock)arg1) → None :

Reset a Clock to 0, to force an update

C++ signature :
void Reset(ObjCryst::RefinableObjClock {lvalue})
SetEqual((RefinableObjClock)arg1, (RefinableObjClock)arg2) → None :
C++ signature :
void SetEqual(ObjCryst::RefinableObjClock {lvalue},ObjCryst::RefinableObjClock)
class pyobjcryst.refinableobj.RefinableObj

Bases: Boost.Python.instance

AddPar((RefinableObj)arg1, (_RefinablePar)par) → None :
C++ signature :
void AddPar(ObjCryst::RefinableObj {lvalue},ObjCryst::RefinablePar*)

AddPar( (RefinableObj)arg1, (RefinableObj)newRefParList [, (bool)copyParam=False]) -> None :

C++ signature :
void AddPar(ObjCryst::RefinableObj {lvalue},ObjCryst::RefinableObj {lvalue} [,bool=False])
AddRestraint((RefinableObj)arg1, (Restraint)arg2) → None :
C++ signature :
void AddRestraint(ObjCryst::RefinableObj {lvalue},ObjCryst::Restraint*)
BeginGlobalOptRandomMove((RefinableObj)arg1) → None :
C++ signature :
void BeginGlobalOptRandomMove(ObjCryst::RefinableObj {lvalue})
BeginOptimization((RefinableObj)arg1[, (bool)allowApproximations=False[, (bool)enableRestraints=False]]) → None :
C++ signature :
void BeginOptimization(ObjCryst::RefinableObj {lvalue} [,bool=False [,bool=False]])

BeginOptimization( (RefinableObj)arg1 [, (bool)allowApproximations=False [, (bool)enableRestraints=False]]) -> None :

C++ signature :
void BeginOptimization((anonymous namespace)::RefinableObjWrap {lvalue} [,bool=False [,bool=False]])
ClearParamSet((RefinableObj)arg1, (int)arg2) → None :
C++ signature :
void ClearParamSet(ObjCryst::RefinableObj {lvalue},unsigned long)
CreateParamSet((RefinableObj)arg1[, (str)name='']) → int :
C++ signature :
unsigned long CreateParamSet(ObjCryst::RefinableObj {lvalue} [,std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >=’‘])
DeRegisterClient((RefinableObj)arg1, (RefinableObj)arg2) → None :
C++ signature :
void DeRegisterClient(ObjCryst::RefinableObj {lvalue},ObjCryst::RefinableObj {lvalue})

DeRegisterClient( (RefinableObj)arg1, (RefinableObj)arg2) -> None :

C++ signature :
void DeRegisterClient((anonymous namespace)::RefinableObjWrap {lvalue},ObjCryst::RefinableObj {lvalue})
EndOptimization((RefinableObj)arg1) → None :
C++ signature :
void EndOptimization(ObjCryst::RefinableObj {lvalue})

EndOptimization( (RefinableObj)arg1) -> None :

C++ signature :
void EndOptimization((anonymous namespace)::RefinableObjWrap {lvalue})
EraseAllParamSet((RefinableObj)arg1) → None :
C++ signature :
void EraseAllParamSet((anonymous namespace)::RefinableObjWrap {lvalue})
FixAllPar((RefinableObj)arg1) → None :
C++ signature :
void FixAllPar(ObjCryst::RefinableObj {lvalue})
GetClassName((RefinableObj)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetClassName(ObjCryst::RefinableObj {lvalue})

GetClassName( (RefinableObj)arg1) -> str :

C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetClassName((anonymous namespace)::RefinableObjWrap {lvalue})
GetClientRegistry((RefinableObj)arg1) → RefinableObjRegistry :
C++ signature :
ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue} GetClientRegistry(ObjCryst::RefinableObj {lvalue})

GetClientRegistry( (RefinableObj)arg1) -> RefinableObjRegistry :

C++ signature :
ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue} GetClientRegistry((anonymous namespace)::RefinableObjWrap {lvalue})
GetClockMaster((RefinableObj)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock GetClockMaster(ObjCryst::RefinableObj {lvalue})
GetGeneGroup((RefinableObj)arg1, (RefinableObj)arg2, (object)arg3, (int)arg4) → None :
C++ signature :
void GetGeneGroup(ObjCryst::RefinableObj {lvalue},ObjCryst::RefinableObj,CrystVector<unsigned int> {lvalue},unsigned int {lvalue})

GetGeneGroup( (RefinableObj)arg1, (RefinableObj)arg2, (object)arg3, (int)arg4) -> None :

C++ signature :
void GetGeneGroup((anonymous namespace)::RefinableObjWrap {lvalue},ObjCryst::RefinableObj,CrystVector<unsigned int> {lvalue},unsigned int {lvalue})
GetLSQCalc((RefinableObj)arg1, (int)arg2) → object :
C++ signature :
CrystVector<double> GetLSQCalc(ObjCryst::RefinableObj {lvalue},unsigned int)

GetLSQCalc( (RefinableObj)arg1, (int)arg2) -> object :

C++ signature :
CrystVector<double> GetLSQCalc((anonymous namespace)::RefinableObjWrap {lvalue},unsigned int)
GetLSQDeriv((RefinableObj)arg1, (int)arg2, (_RefinablePar)arg3) → object :
C++ signature :
CrystVector<double> GetLSQDeriv(ObjCryst::RefinableObj {lvalue},unsigned int,ObjCryst::RefinablePar {lvalue})

GetLSQDeriv( (RefinableObj)arg1, (int)arg2, (_RefinablePar)arg3) -> object :

C++ signature :
CrystVector<double> GetLSQDeriv((anonymous namespace)::RefinableObjWrap {lvalue},unsigned int,ObjCryst::RefinablePar {lvalue})
GetLSQObs((RefinableObj)arg1, (int)arg2) → object :
C++ signature :
CrystVector<double> GetLSQObs(ObjCryst::RefinableObj {lvalue},unsigned int)

GetLSQObs( (RefinableObj)arg1, (int)arg2) -> object :

C++ signature :
CrystVector<double> GetLSQObs((anonymous namespace)::RefinableObjWrap {lvalue},unsigned int)
GetLSQWeight((RefinableObj)arg1, (int)arg2) → object :
C++ signature :
CrystVector<double> GetLSQWeight(ObjCryst::RefinableObj {lvalue},unsigned int)

GetLSQWeight( (RefinableObj)arg1, (int)arg2) -> object :

C++ signature :
CrystVector<double> GetLSQWeight((anonymous namespace)::RefinableObjWrap {lvalue},unsigned int)
GetLogLikelihood((RefinableObj)arg1) → float :
C++ signature :
double GetLogLikelihood(ObjCryst::RefinableObj {lvalue})

GetLogLikelihood( (RefinableObj)arg1) -> float :

C++ signature :
double GetLogLikelihood((anonymous namespace)::RefinableObjWrap {lvalue})
GetName((RefinableObj)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetName(ObjCryst::RefinableObj {lvalue})

GetName( (RefinableObj)arg1) -> str :

C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetName((anonymous namespace)::RefinableObjWrap {lvalue})
GetNbLSQFunction((RefinableObj)arg1) → int :
C++ signature :
unsigned int GetNbLSQFunction(ObjCryst::RefinableObj {lvalue})

GetNbLSQFunction( (RefinableObj)arg1) -> int :

C++ signature :
unsigned int GetNbLSQFunction((anonymous namespace)::RefinableObjWrap {lvalue})
GetNbOption((RefinableObj)arg1) → int :
C++ signature :
unsigned int GetNbOption(ObjCryst::RefinableObj {lvalue})
GetNbPar((RefinableObj)arg1) → int :
C++ signature :
long GetNbPar(ObjCryst::RefinableObj {lvalue})
GetNbParNotFixed((RefinableObj)arg1) → int :
C++ signature :
long GetNbParNotFixed(ObjCryst::RefinableObj {lvalue})
GetOption((RefinableObj)arg1, (int)arg2) → RefObjOpt :
C++ signature :
ObjCryst::RefObjOpt {lvalue} GetOption(ObjCryst::RefinableObj {lvalue},unsigned int)
GetPar((RefinableObj)arg1, (int)arg2) → _RefinablePar :
C++ signature :
ObjCryst::RefinablePar {lvalue} GetPar(ObjCryst::RefinableObj {lvalue},long)

GetPar( (RefinableObj)arg1, (str)arg2) -> _RefinablePar :

C++ signature :
ObjCryst::RefinablePar {lvalue} GetPar(ObjCryst::RefinableObj {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
GetParNotFixed((RefinableObj)arg1, (int)arg2) → _RefinablePar :
C++ signature :
ObjCryst::RefinablePar {lvalue} GetParNotFixed(ObjCryst::RefinableObj {lvalue},long)
GetParamSet((RefinableObj)arg1, (int)arg2) → object :
C++ signature :
CrystVector<double> GetParamSet(ObjCryst::RefinableObj {lvalue},unsigned long)
GetParamSetName((RefinableObj)arg1, (int)arg2) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetParamSetName(ObjCryst::RefinableObj {lvalue},unsigned long)
GetParamSet_ParNotFixedHumanValue((RefinableObj)arg1, (int)arg2, (int)arg3) → float :
C++ signature :
double GetParamSet_ParNotFixedHumanValue(ObjCryst::RefinableObj {lvalue},unsigned long,long)
GetRefParListClock((RefinableObj)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock GetRefParListClock(ObjCryst::RefinableObj {lvalue})
GetRestraintCost((RefinableObj)arg1) → float :
C++ signature :
double GetRestraintCost(ObjCryst::RefinableObj {lvalue})

GetRestraintCost( (RefinableObj)arg1) -> float :

C++ signature :
double GetRestraintCost((anonymous namespace)::RefinableObjWrap {lvalue})
GetSubObjRegistry((RefinableObj)arg1) → RefinableObjRegistry :
C++ signature :
ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue} GetSubObjRegistry(ObjCryst::RefinableObj {lvalue})
GlobalOptRandomMove((RefinableObj)arg1, (float)mutationAmplitude[, (RefParType)type=<pyobjcryst._pyobjcryst.RefParType object at 0x1060c88c0>]) → None :
C++ signature :
void GlobalOptRandomMove(ObjCryst::RefinableObj {lvalue},double [,ObjCryst::RefParType const*=<pyobjcryst._pyobjcryst.RefParType object at 0x1060c88c0>])

GlobalOptRandomMove( (RefinableObj)arg1, (float)mutationAmplitude [, (RefParType)type=<pyobjcryst._pyobjcryst.RefParType object at 0x1060c88c0>]) -> None :

C++ signature :
void GlobalOptRandomMove((anonymous namespace)::RefinableObjWrap {lvalue},double [,ObjCryst::RefParType const*=<pyobjcryst._pyobjcryst.RefParType object at 0x1060c88c0>])
IsBeingRefined((RefinableObj)arg1) → bool :
C++ signature :
bool IsBeingRefined(ObjCryst::RefinableObj {lvalue})
PrepareForRefinement((RefinableObj)arg1) → None :
C++ signature :
void PrepareForRefinement(ObjCryst::RefinableObj {lvalue})
Print((RefinableObj)arg1) → None :
C++ signature :
void Print(ObjCryst::RefinableObj {lvalue})

Print( (RefinableObj)arg1) -> None :

C++ signature :
void Print((anonymous namespace)::RefinableObjWrap {lvalue})
RandomizeConfiguration((RefinableObj)arg1) → None :
C++ signature :
void RandomizeConfiguration(ObjCryst::RefinableObj {lvalue})

RandomizeConfiguration( (RefinableObj)arg1) -> None :

C++ signature :
void RandomizeConfiguration((anonymous namespace)::RefinableObjWrap {lvalue})
RegisterClient((RefinableObj)arg1, (RefinableObj)arg2) → None :
C++ signature :
void RegisterClient(ObjCryst::RefinableObj {lvalue},ObjCryst::RefinableObj {lvalue})

RegisterClient( (RefinableObj)arg1, (RefinableObj)arg2) -> None :

C++ signature :
void RegisterClient((anonymous namespace)::RefinableObjWrap {lvalue},ObjCryst::RefinableObj {lvalue})
RemovePar((RefinableObj)arg1, (_RefinablePar)arg2) → None :
C++ signature :
void RemovePar(ObjCryst::RefinableObj {lvalue},ObjCryst::RefinablePar*)
RemoveRestraint((RefinableObj)arg1, (Restraint)arg2) → object :
C++ signature :
std::__1::__wrap_iter<ObjCryst::Restraint**> RemoveRestraint(ObjCryst::RefinableObj {lvalue},ObjCryst::Restraint*)
ResetParList((RefinableObj)arg1) → None :
C++ signature :
void ResetParList(ObjCryst::RefinableObj {lvalue})
RestoreParamSet((RefinableObj)arg1, (int)arg2) → None :
C++ signature :
void RestoreParamSet(ObjCryst::RefinableObj {lvalue},unsigned long)
SaveParamSet((RefinableObj)arg1, (int)arg2) → None :
C++ signature :
void SaveParamSet(ObjCryst::RefinableObj {lvalue},unsigned long)
SetGlobalOptimStep((RefinableObj)arg1, (RefParType)arg2, (float)arg3) → None :
C++ signature :
void SetGlobalOptimStep(ObjCryst::RefinableObj {lvalue},ObjCryst::RefParType const*,double)
SetLimitsAbsolute((RefinableObj)arg1, (str)arg2, (float)arg3, (float)arg4) → None :
C++ signature :
void SetLimitsAbsolute(ObjCryst::RefinableObj {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,double,double)

SetLimitsAbsolute( (RefinableObj)arg1, (RefParType)arg2, (float)arg3, (float)arg4) -> None :

C++ signature :
void SetLimitsAbsolute(ObjCryst::RefinableObj {lvalue},ObjCryst::RefParType const*,double,double)
SetLimitsProportional((RefinableObj)arg1, (str)arg2, (float)arg3, (float)arg4) → None :
C++ signature :
void SetLimitsProportional(ObjCryst::RefinableObj {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,double,double)

SetLimitsProportional( (RefinableObj)arg1, (RefParType)arg2, (float)arg3, (float)arg4) -> None :

C++ signature :
void SetLimitsProportional(ObjCryst::RefinableObj {lvalue},ObjCryst::RefParType const*,double,double)
SetLimitsRelative((RefinableObj)arg1, (str)arg2, (float)arg3, (float)arg4) → None :
C++ signature :
void SetLimitsRelative(ObjCryst::RefinableObj {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,double,double)

SetLimitsRelative( (RefinableObj)arg1, (RefParType)arg2, (float)arg3, (float)arg4) -> None :

C++ signature :
void SetLimitsRelative(ObjCryst::RefinableObj {lvalue},ObjCryst::RefParType const*,double,double)
SetName((RefinableObj)arg1, (str)arg2) → None :
C++ signature :
void SetName(ObjCryst::RefinableObj {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)

SetName( (RefinableObj)arg1, (str)arg2) -> None :

C++ signature :
void SetName((anonymous namespace)::RefinableObjWrap {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
SetParIsFixed((RefinableObj)arg1, (int)arg2, (bool)arg3) → None :
C++ signature :
void SetParIsFixed(ObjCryst::RefinableObj {lvalue},long,bool)

SetParIsFixed( (RefinableObj)arg1, (str)arg2, (bool)arg3) -> None :

C++ signature :
void SetParIsFixed(ObjCryst::RefinableObj {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,bool)

SetParIsFixed( (RefinableObj)arg1, (RefParType)arg2, (bool)arg3) -> None :

C++ signature :
void SetParIsFixed(ObjCryst::RefinableObj {lvalue},ObjCryst::RefParType const*,bool)
SetParIsUsed((RefinableObj)arg1, (str)arg2, (bool)arg3) → None :
C++ signature :
void SetParIsUsed(ObjCryst::RefinableObj {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,bool)

SetParIsUsed( (RefinableObj)arg1, (RefParType)arg2, (bool)arg3) -> None :

C++ signature :
void SetParIsUsed(ObjCryst::RefinableObj {lvalue},ObjCryst::RefParType const*,bool)
TagNewBestConfig((RefinableObj)arg1) → None :
C++ signature :
void TagNewBestConfig(ObjCryst::RefinableObj {lvalue})

TagNewBestConfig( (RefinableObj)arg1) -> None :

C++ signature :
void TagNewBestConfig((anonymous namespace)::RefinableObjWrap {lvalue})
UnFixAllPar((RefinableObj)arg1) → None :
C++ signature :
void UnFixAllPar(ObjCryst::RefinableObj {lvalue})
XMLInput((RefinableObj)arg1, (object)file, (XMLCrystTag)tag) → None :
C++ signature :
void XMLInput(ObjCryst::RefinableObj {lvalue},boost::python::api::object,ObjCryst::XMLCrystTag {lvalue})

XMLInput( (RefinableObj)arg1, (object)arg2, (XMLCrystTag)arg3) -> None :

C++ signature :
void XMLInput(ObjCryst::RefinableObj {lvalue},std::__1::basic_istream<char, std::__1::char_traits<char> > {lvalue},ObjCryst::XMLCrystTag)

XMLInput( (RefinableObj)arg1, (object)arg2, (XMLCrystTag)arg3) -> None :

C++ signature :
void XMLInput((anonymous namespace)::RefinableObjWrap {lvalue},std::__1::basic_istream<char, std::__1::char_traits<char> > {lvalue},ObjCryst::XMLCrystTag)
XMLOutput((RefinableObj)arg1, (object)file[, (int)indent=0]) → None :
C++ signature :
void XMLOutput(ObjCryst::RefinableObj,boost::python::api::object [,int=0])

XMLOutput( (RefinableObj)arg1, (object)arg2, (int)arg3) -> None :

C++ signature :
void XMLOutput(ObjCryst::RefinableObj {lvalue},std::__1::basic_ostream<char, std::__1::char_traits<char> > {lvalue},int)

XMLOutput( (RefinableObj)arg1, (object)arg2, (int)arg3) -> None :

C++ signature :
void XMLOutput((anonymous namespace)::RefinableObjWrap {lvalue},std::__1::basic_ostream<char, std::__1::char_traits<char> > {lvalue},int)
class pyobjcryst.refinableobj.RefObjOpt

Bases: Boost.Python.instance

GetChoice((RefObjOpt)arg1) → int :
C++ signature :
int GetChoice(ObjCryst::RefObjOpt {lvalue})
GetChoiceName((RefObjOpt)arg1, (int)arg2) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetChoiceName(ObjCryst::RefObjOpt {lvalue},int)
GetClassName((RefObjOpt)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetClassName(ObjCryst::RefObjOpt {lvalue})
GetClock((RefObjOpt)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock GetClock(ObjCryst::RefObjOpt {lvalue})
GetName((RefObjOpt)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetName(ObjCryst::RefObjOpt {lvalue})
GetNbChoice((RefObjOpt)arg1) → int :
C++ signature :
int GetNbChoice(ObjCryst::RefObjOpt {lvalue})
Init((RefObjOpt)arg1, (int)arg2, (str)arg3, (str)arg4) → None :
C++ signature :
void Init(ObjCryst::RefObjOpt {lvalue},int,std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const*,std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const*)
SetChoice((RefObjOpt)arg1, (int)arg2) → None :
C++ signature :
void SetChoice(ObjCryst::RefObjOpt {lvalue},int)

SetChoice( (RefObjOpt)arg1, (int)arg2) -> None :

C++ signature :
void SetChoice((anonymous namespace)::RefObjOptWrap {lvalue},int)

SetChoice( (RefObjOpt)arg1, (str)arg2) -> None :

C++ signature :
void SetChoice(ObjCryst::RefObjOpt {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
XMLInput((RefObjOpt)arg1, (object)arg2, (XMLCrystTag)arg3) → None :
C++ signature :
void XMLInput(ObjCryst::RefObjOpt {lvalue},std::__1::basic_istream<char, std::__1::char_traits<char> > {lvalue},ObjCryst::XMLCrystTag)
XMLOutput((RefObjOpt)arg1, (object)arg2, (int)arg3) → None :
C++ signature :
void XMLOutput(ObjCryst::RefObjOpt {lvalue},std::__1::basic_ostream<char, std::__1::char_traits<char> > {lvalue},int)
class pyobjcryst.refinableobj.RefinableObjRegistry

Bases: Boost.Python.instance

DeRegister((RefinableObjRegistry)arg1, (RefinableObj)arg2) → None :
C++ signature :
void DeRegister(ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue},ObjCryst::RefinableObj {lvalue})

DeRegister( (RefinableObjRegistry)arg1, (str)arg2) -> None :

C++ signature :
void DeRegister(ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
DeRegisterAll((RefinableObjRegistry)arg1) → None :
C++ signature :
void DeRegisterAll(ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue})
Find((RefinableObjRegistry)arg1, (str)arg2) → int :
C++ signature :
long Find(ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)

Find( (RefinableObjRegistry)arg1, (str)arg2, (str)arg3, (bool)arg4) -> int :

C++ signature :
long Find(ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,bool)

Find( (RefinableObjRegistry)arg1, (RefinableObj)arg2) -> int :

C++ signature :
long Find(ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue},ObjCryst::RefinableObj)
GetName((RefinableObjRegistry)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetName(ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue})
GetNb((RefinableObjRegistry)arg1) → int :
C++ signature :
long GetNb(ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue})
GetObj((RefinableObjRegistry)arg1, (int)arg2) → RefinableObj :
C++ signature :
ObjCryst::RefinableObj {lvalue} GetObj(ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue},unsigned int)

GetObj( (RefinableObjRegistry)arg1, (str)arg2) -> RefinableObj :

C++ signature :
ObjCryst::RefinableObj {lvalue} GetObj(ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)

GetObj( (RefinableObjRegistry)arg1, (str)arg2, (str)arg3) -> RefinableObj :

C++ signature :
ObjCryst::RefinableObj {lvalue} GetObj(ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
GetRegistryClock((RefinableObjRegistry)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock GetRegistryClock(ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue})
Print((RefinableObjRegistry)arg1) → None :
C++ signature :
void Print(ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue})
Register((RefinableObjRegistry)arg1, (RefinableObj)arg2) → None :
C++ signature :
void Register(ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue},ObjCryst::RefinableObj {lvalue})
SetName((RefinableObjRegistry)arg1, (str)arg2) → None :
C++ signature :
void SetName(ObjCryst::ObjRegistry<ObjCryst::RefinableObj> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
class pyobjcryst.refinableobj.RefParType

Bases: Boost.Python.instance

GetName((RefParType)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetName(ObjCryst::RefParType {lvalue})
IsDescendantFromOrSameAs((RefParType)arg1, (RefParType)arg2) → bool :
C++ signature :
bool IsDescendantFromOrSameAs(ObjCryst::RefParType {lvalue},ObjCryst::RefParType const*)
class pyobjcryst.refinableobj.RefParDerivStepModel

Bases: Boost.Python.enum

REFPAR_DERIV_STEP_ABSOLUTE = pyobjcryst._pyobjcryst.RefParDerivStepModel.REFPAR_DERIV_STEP_ABSOLUTE
REFPAR_DERIV_STEP_RELATIVE = pyobjcryst._pyobjcryst.RefParDerivStepModel.REFPAR_DERIV_STEP_RELATIVE
names = {'REFPAR_DERIV_STEP_ABSOLUTE': pyobjcryst._pyobjcryst.RefParDerivStepModel.REFPAR_DERIV_STEP_ABSOLUTE, 'REFPAR_DERIV_STEP_RELATIVE': pyobjcryst._pyobjcryst.RefParDerivStepModel.REFPAR_DERIV_STEP_RELATIVE}
values = {0: pyobjcryst._pyobjcryst.RefParDerivStepModel.REFPAR_DERIV_STEP_ABSOLUTE, 1: pyobjcryst._pyobjcryst.RefParDerivStepModel.REFPAR_DERIV_STEP_RELATIVE}
class pyobjcryst.refinableobj.RefinablePar

Bases: pyobjcryst._pyobjcryst._RefinablePar

class pyobjcryst.refinableobj.Restraint

Bases: Boost.Python.instance

GetLogLikelihood((Restraint)arg1) → float :
C++ signature :
double GetLogLikelihood(ObjCryst::Restraint {lvalue})

GetLogLikelihood( (Restraint)arg1) -> float :

C++ signature :
double GetLogLikelihood((anonymous namespace)::RestraintWrap {lvalue})
GetType((Restraint)arg1) → RefParType :
C++ signature :
ObjCryst::RefParType const* GetType(ObjCryst::Restraint {lvalue})

GetType( (Restraint)arg1) -> RefParType :

C++ signature :
ObjCryst::RefParType const* GetType((anonymous namespace)::RestraintWrap {lvalue})
SetType((Restraint)arg1, (RefParType)arg2) → None :
C++ signature :
void SetType(ObjCryst::Restraint {lvalue},ObjCryst::RefParType const*)

SetType( (Restraint)arg1, (RefParType)arg2) -> None :

C++ signature :
void SetType((anonymous namespace)::RestraintWrap {lvalue},ObjCryst::RefParType const*)
class pyobjcryst.refinableobj.ScattererRegistry

Bases: Boost.Python.instance

DeRegister((ScattererRegistry)arg1, (Scatterer)arg2) → None :
C++ signature :
void DeRegister(ObjCryst::ObjRegistry<ObjCryst::Scatterer> {lvalue},ObjCryst::Scatterer {lvalue})

DeRegister( (ScattererRegistry)arg1, (str)arg2) -> None :

C++ signature :
void DeRegister(ObjCryst::ObjRegistry<ObjCryst::Scatterer> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
DeRegisterAll((ScattererRegistry)arg1) → None :
C++ signature :
void DeRegisterAll(ObjCryst::ObjRegistry<ObjCryst::Scatterer> {lvalue})
Find((ScattererRegistry)arg1, (str)arg2) → int :
C++ signature :
long Find(ObjCryst::ObjRegistry<ObjCryst::Scatterer> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)

Find( (ScattererRegistry)arg1, (str)arg2, (str)arg3, (bool)arg4) -> int :

C++ signature :
long Find(ObjCryst::ObjRegistry<ObjCryst::Scatterer> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,bool)

Find( (ScattererRegistry)arg1, (Scatterer)arg2) -> int :

C++ signature :
long Find(ObjCryst::ObjRegistry<ObjCryst::Scatterer> {lvalue},ObjCryst::Scatterer)
GetName((ScattererRegistry)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetName(ObjCryst::ObjRegistry<ObjCryst::Scatterer> {lvalue})
GetNb((ScattererRegistry)arg1) → int :
C++ signature :
long GetNb(ObjCryst::ObjRegistry<ObjCryst::Scatterer> {lvalue})
GetObj((ScattererRegistry)arg1, (int)arg2) → Scatterer :
C++ signature :
ObjCryst::Scatterer {lvalue} GetObj(ObjCryst::ObjRegistry<ObjCryst::Scatterer> {lvalue},unsigned int)

GetObj( (ScattererRegistry)arg1, (str)arg2) -> Scatterer :

C++ signature :
ObjCryst::Scatterer {lvalue} GetObj(ObjCryst::ObjRegistry<ObjCryst::Scatterer> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)

GetObj( (ScattererRegistry)arg1, (str)arg2, (str)arg3) -> Scatterer :

C++ signature :
ObjCryst::Scatterer {lvalue} GetObj(ObjCryst::ObjRegistry<ObjCryst::Scatterer> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
GetRegistryClock((ScattererRegistry)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock GetRegistryClock(ObjCryst::ObjRegistry<ObjCryst::Scatterer> {lvalue})
Print((ScattererRegistry)arg1) → None :
C++ signature :
void Print(ObjCryst::ObjRegistry<ObjCryst::Scatterer> {lvalue})
Register((ScattererRegistry)arg1, (Scatterer)arg2) → None :
C++ signature :
void Register(ObjCryst::ObjRegistry<ObjCryst::Scatterer> {lvalue},ObjCryst::Scatterer {lvalue})
SetName((ScattererRegistry)arg1, (str)arg2) → None :
C++ signature :
void SetName(ObjCryst::ObjRegistry<ObjCryst::Scatterer> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
class pyobjcryst.refinableobj.ScatteringPowerRegistry

Bases: Boost.Python.instance

DeRegister((ScatteringPowerRegistry)arg1, (ScatteringPower)arg2) → None :
C++ signature :
void DeRegister(ObjCryst::ObjRegistry<ObjCryst::ScatteringPower> {lvalue},ObjCryst::ScatteringPower {lvalue})

DeRegister( (ScatteringPowerRegistry)arg1, (str)arg2) -> None :

C++ signature :
void DeRegister(ObjCryst::ObjRegistry<ObjCryst::ScatteringPower> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
DeRegisterAll((ScatteringPowerRegistry)arg1) → None :
C++ signature :
void DeRegisterAll(ObjCryst::ObjRegistry<ObjCryst::ScatteringPower> {lvalue})
Find((ScatteringPowerRegistry)arg1, (str)arg2) → int :
C++ signature :
long Find(ObjCryst::ObjRegistry<ObjCryst::ScatteringPower> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)

Find( (ScatteringPowerRegistry)arg1, (str)arg2, (str)arg3, (bool)arg4) -> int :

C++ signature :
long Find(ObjCryst::ObjRegistry<ObjCryst::ScatteringPower> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,bool)

Find( (ScatteringPowerRegistry)arg1, (ScatteringPower)arg2) -> int :

C++ signature :
long Find(ObjCryst::ObjRegistry<ObjCryst::ScatteringPower> {lvalue},ObjCryst::ScatteringPower)
GetName((ScatteringPowerRegistry)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetName(ObjCryst::ObjRegistry<ObjCryst::ScatteringPower> {lvalue})
GetNb((ScatteringPowerRegistry)arg1) → int :
C++ signature :
long GetNb(ObjCryst::ObjRegistry<ObjCryst::ScatteringPower> {lvalue})
GetObj((ScatteringPowerRegistry)arg1, (int)arg2) → ScatteringPower :
C++ signature :
ObjCryst::ScatteringPower {lvalue} GetObj(ObjCryst::ObjRegistry<ObjCryst::ScatteringPower> {lvalue},unsigned int)

GetObj( (ScatteringPowerRegistry)arg1, (str)arg2) -> ScatteringPower :

C++ signature :
ObjCryst::ScatteringPower {lvalue} GetObj(ObjCryst::ObjRegistry<ObjCryst::ScatteringPower> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)

GetObj( (ScatteringPowerRegistry)arg1, (str)arg2, (str)arg3) -> ScatteringPower :

C++ signature :
ObjCryst::ScatteringPower {lvalue} GetObj(ObjCryst::ObjRegistry<ObjCryst::ScatteringPower> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
GetRegistryClock((ScatteringPowerRegistry)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock GetRegistryClock(ObjCryst::ObjRegistry<ObjCryst::ScatteringPower> {lvalue})
Print((ScatteringPowerRegistry)arg1) → None :
C++ signature :
void Print(ObjCryst::ObjRegistry<ObjCryst::ScatteringPower> {lvalue})
Register((ScatteringPowerRegistry)arg1, (ScatteringPower)arg2) → None :
C++ signature :
void Register(ObjCryst::ObjRegistry<ObjCryst::ScatteringPower> {lvalue},ObjCryst::ScatteringPower {lvalue})
SetName((ScatteringPowerRegistry)arg1, (str)arg2) → None :
C++ signature :
void SetName(ObjCryst::ObjRegistry<ObjCryst::ScatteringPower> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
class pyobjcryst.refinableobj.ZAtomRegistry

Bases: Boost.Python.instance

DeRegister((ZAtomRegistry)arg1, (ZAtom)arg2) → None :
C++ signature :
void DeRegister(ObjCryst::ObjRegistry<ObjCryst::ZAtom> {lvalue},ObjCryst::ZAtom {lvalue})

DeRegister( (ZAtomRegistry)arg1, (str)arg2) -> None :

C++ signature :
void DeRegister(ObjCryst::ObjRegistry<ObjCryst::ZAtom> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
DeRegisterAll((ZAtomRegistry)arg1) → None :
C++ signature :
void DeRegisterAll(ObjCryst::ObjRegistry<ObjCryst::ZAtom> {lvalue})
Find((ZAtomRegistry)arg1, (str)arg2) → int :
C++ signature :
long Find(ObjCryst::ObjRegistry<ObjCryst::ZAtom> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)

Find( (ZAtomRegistry)arg1, (str)arg2, (str)arg3, (bool)arg4) -> int :

C++ signature :
long Find(ObjCryst::ObjRegistry<ObjCryst::ZAtom> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,bool)

Find( (ZAtomRegistry)arg1, (ZAtom)arg2) -> int :

C++ signature :
long Find(ObjCryst::ObjRegistry<ObjCryst::ZAtom> {lvalue},ObjCryst::ZAtom)
GetName((ZAtomRegistry)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetName(ObjCryst::ObjRegistry<ObjCryst::ZAtom> {lvalue})
GetNb((ZAtomRegistry)arg1) → int :
C++ signature :
long GetNb(ObjCryst::ObjRegistry<ObjCryst::ZAtom> {lvalue})
GetObj((ZAtomRegistry)arg1, (int)arg2) → ZAtom :
C++ signature :
ObjCryst::ZAtom {lvalue} GetObj(ObjCryst::ObjRegistry<ObjCryst::ZAtom> {lvalue},unsigned int)

GetObj( (ZAtomRegistry)arg1, (str)arg2) -> ZAtom :

C++ signature :
ObjCryst::ZAtom {lvalue} GetObj(ObjCryst::ObjRegistry<ObjCryst::ZAtom> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)

GetObj( (ZAtomRegistry)arg1, (str)arg2, (str)arg3) -> ZAtom :

C++ signature :
ObjCryst::ZAtom {lvalue} GetObj(ObjCryst::ObjRegistry<ObjCryst::ZAtom> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
GetRegistryClock((ZAtomRegistry)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock GetRegistryClock(ObjCryst::ObjRegistry<ObjCryst::ZAtom> {lvalue})
Print((ZAtomRegistry)arg1) → None :
C++ signature :
void Print(ObjCryst::ObjRegistry<ObjCryst::ZAtom> {lvalue})
Register((ZAtomRegistry)arg1, (ZAtom)arg2) → None :
C++ signature :
void Register(ObjCryst::ObjRegistry<ObjCryst::ZAtom> {lvalue},ObjCryst::ZAtom {lvalue})
SetName((ZAtomRegistry)arg1, (str)arg2) → None :
C++ signature :
void SetName(ObjCryst::ObjRegistry<ObjCryst::ZAtom> {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)

pyobjcryst.scatterer module

Python wrapping of Scatterer.h

See the online ObjCryst++ documentation (http://vincefn.net/ObjCryst/).

Changes from ObjCryst::Scatterer

  • C++ methods that can return const or non-const objects return non-const objects in python.
  • Operator string() is not exposed.
  • Internal use only methods have not been exposed.
  • InitRefParList is not exposed, as it is not used inside of Scatterer.
  • GetClockScattCompList is exposed using a workaround, because it is not implemented in the library.
  • Methods related to visualization are not exposed.
class pyobjcryst.scatterer.Scatterer

Bases: pyobjcryst._pyobjcryst.RefinableObj

GetClockScattCompList((Scatterer)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock GetClockScattCompList((anonymous namespace)::ScattererWrap {lvalue})
GetClockScatterer((Scatterer)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock {lvalue} GetClockScatterer(ObjCryst::Scatterer {lvalue})
GetComponentName((Scatterer)arg1, (int)arg2) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetComponentName(ObjCryst::Scatterer {lvalue},int)

GetComponentName( (Scatterer)arg1, (int)arg2) -> None :

C++ signature :
void GetComponentName((anonymous namespace)::ScattererWrap {lvalue},int)
GetCrystal((Scatterer)arg1) → Crystal :
C++ signature :
ObjCryst::Crystal {lvalue} GetCrystal(ObjCryst::Scatterer {lvalue})
GetNbComponent((Scatterer)arg1) → int :
C++ signature :
int GetNbComponent(ObjCryst::Scatterer {lvalue})

GetNbComponent( (Scatterer)arg1) -> None :

C++ signature :
void GetNbComponent((anonymous namespace)::ScattererWrap {lvalue})
GetOccupancy((Scatterer)arg1) → float :
C++ signature :
double GetOccupancy(ObjCryst::Scatterer {lvalue})
GetScatteringComponentList((Scatterer)arg1) → list :
C++ signature :
boost::python::list GetScatteringComponentList(ObjCryst::Scatterer {lvalue})
GetX((Scatterer)arg1) → float :
C++ signature :
double GetX(ObjCryst::Scatterer {lvalue})
GetY((Scatterer)arg1) → float :
C++ signature :
double GetY(ObjCryst::Scatterer {lvalue})
GetZ((Scatterer)arg1) → float :
C++ signature :
double GetZ(ObjCryst::Scatterer {lvalue})
Occupancy
Print((Scatterer)arg1) → None :
C++ signature :
void Print(ObjCryst::Scatterer {lvalue})

Print( (Scatterer)arg1) -> None :

C++ signature :
void Print((anonymous namespace)::ScattererWrap {lvalue})
SetCrystal((Scatterer)arg1, (Crystal)arg2) → None :
C++ signature :
void SetCrystal(ObjCryst::Scatterer {lvalue},ObjCryst::Crystal {lvalue})
SetOccupancy((Scatterer)arg1, (float)arg2) → None :
C++ signature :
void SetOccupancy(ObjCryst::Scatterer {lvalue},double)

SetOccupancy( (Scatterer)arg1, (float)arg2) -> None :

C++ signature :
void SetOccupancy((anonymous namespace)::ScattererWrap {lvalue},double)
SetX((Scatterer)arg1, (float)arg2) → None :
C++ signature :
void SetX(ObjCryst::Scatterer {lvalue},double)

SetX( (Scatterer)arg1, (float)arg2) -> None :

C++ signature :
void SetX((anonymous namespace)::ScattererWrap {lvalue},double)
SetY((Scatterer)arg1, (float)arg2) → None :
C++ signature :
void SetY(ObjCryst::Scatterer {lvalue},double)

SetY( (Scatterer)arg1, (float)arg2) -> None :

C++ signature :
void SetY((anonymous namespace)::ScattererWrap {lvalue},double)
SetZ((Scatterer)arg1, (float)arg2) → None :
C++ signature :
void SetZ(ObjCryst::Scatterer {lvalue},double)

SetZ( (Scatterer)arg1, (float)arg2) -> None :

C++ signature :
void SetZ((anonymous namespace)::ScattererWrap {lvalue},double)
X
Y
Z

pyobjcryst.scatteringpower module

Python wrapping of ScatteringPower.h

See the online ObjCryst++ documentation (http://vincefn.net/ObjCryst/).

Changes from ObjCryst::ScatteringComponent - Added attributes X, Y, Z, Occupancy to conform to MolAtom.

Changes from ObjCryst::ScatteringComponentList - Wrapped as a to-python converter only (no constructor)

class pyobjcryst.scatteringpower.ScatteringPower

Bases: pyobjcryst._pyobjcryst.RefinableObj

B11
B12
B13
B22
B23
B33
Biso
GetBij((ScatteringPower)arg1, (int)arg2, (int)arg3) → float :
C++ signature :
double GetBij(ObjCryst::ScatteringPower {lvalue},unsigned long,unsigned long)
GetBiso((ScatteringPower)arg1) → float :
C++ signature :
double GetBiso(ObjCryst::ScatteringPower {lvalue})
GetDynPopCorrIndex((ScatteringPower)arg1) → int :
C++ signature :
long GetDynPopCorrIndex(ObjCryst::ScatteringPower {lvalue})
GetFormalCharge((ScatteringPower)arg1) → float :
C++ signature :
double GetFormalCharge(ObjCryst::ScatteringPower {lvalue})

GetFormalCharge( (ScatteringPower)arg1) -> float :

C++ signature :
double GetFormalCharge((anonymous namespace)::ScatteringPowerWrap {lvalue})
GetForwardScatteringFactor((ScatteringPower)arg1, (RadiationType)arg2) → float :
C++ signature :
double GetForwardScatteringFactor(ObjCryst::ScatteringPower {lvalue},ObjCryst::RadiationType)

GetForwardScatteringFactor( (ScatteringPower)arg1, (RadiationType)arg2) -> None :

C++ signature :
void GetForwardScatteringFactor((anonymous namespace)::ScatteringPowerWrap {lvalue},ObjCryst::RadiationType)
GetLastChangeClock((ScatteringPower)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock GetLastChangeClock(ObjCryst::ScatteringPower {lvalue})
GetMaximumLikelihoodNbGhostAtom((ScatteringPower)arg1) → float :
C++ signature :
double GetMaximumLikelihoodNbGhostAtom(ObjCryst::ScatteringPower {lvalue})

GetMaximumLikelihoodNbGhostAtom( (ScatteringPower)arg1) -> None :

C++ signature :
void GetMaximumLikelihoodNbGhostAtom((anonymous namespace)::ScatteringPowerWrap {lvalue})
GetMaximumLikelihoodParClock((ScatteringPower)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock GetMaximumLikelihoodParClock(ObjCryst::ScatteringPower {lvalue})
GetMaximumLikelihoodPositionError((ScatteringPower)arg1) → float :
C++ signature :
double GetMaximumLikelihoodPositionError(ObjCryst::ScatteringPower {lvalue})

GetMaximumLikelihoodPositionError( (ScatteringPower)arg1) -> None :

C++ signature :
void GetMaximumLikelihoodPositionError((anonymous namespace)::ScatteringPowerWrap {lvalue})
GetNbScatteringPower((ScatteringPower)arg1) → int :
C++ signature :
long GetNbScatteringPower(ObjCryst::ScatteringPower {lvalue})
GetRadius((ScatteringPower)arg1) → float :
C++ signature :
double GetRadius(ObjCryst::ScatteringPower {lvalue})

GetRadius( (ScatteringPower)arg1) -> None :

C++ signature :
void GetRadius((anonymous namespace)::ScatteringPowerWrap {lvalue})
GetResonantScattFactImag((ScatteringPower)arg1, (ScatteringData)data[, (int)spgSymPosIndex=-1]) → object :
C++ signature :
CrystMatrix<double> GetResonantScattFactImag(ObjCryst::ScatteringPower {lvalue},ObjCryst::ScatteringData [,int=-1])

GetResonantScattFactImag( (ScatteringPower)arg1, (ScatteringData)arg2, (int)arg3) -> None :

C++ signature :
void GetResonantScattFactImag((anonymous namespace)::ScatteringPowerWrap {lvalue},ObjCryst::ScatteringData,int)
GetResonantScattFactReal((ScatteringPower)arg1, (ScatteringData)data[, (int)spgSymPosIndex=-1]) → object :
C++ signature :
CrystMatrix<double> GetResonantScattFactReal(ObjCryst::ScatteringPower {lvalue},ObjCryst::ScatteringData [,int=-1])

GetResonantScattFactReal( (ScatteringPower)arg1, (ScatteringData)arg2, (int)arg3) -> None :

C++ signature :
void GetResonantScattFactReal((anonymous namespace)::ScatteringPowerWrap {lvalue},ObjCryst::ScatteringData,int)
GetScatteringFactor((ScatteringPower)arg1, (ScatteringData)data[, (int)spgSymPosIndex=-1]) → object :
C++ signature :
CrystVector<double> GetScatteringFactor(ObjCryst::ScatteringPower {lvalue},ObjCryst::ScatteringData [,int=-1])

GetScatteringFactor( (ScatteringPower)arg1, (ScatteringData)arg2, (int)arg3) -> None :

C++ signature :
void GetScatteringFactor((anonymous namespace)::ScatteringPowerWrap {lvalue},ObjCryst::ScatteringData,int)
GetSymbol((ScatteringPower)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetSymbol(ObjCryst::ScatteringPower {lvalue})

GetSymbol( (ScatteringPower)arg1) -> str :

C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetSymbol((anonymous namespace)::ScatteringPowerWrap {lvalue})
GetTemperatureFactor((ScatteringPower)arg1, (ScatteringData)data[, (int)spgSymPosIndex=-1]) → object :
C++ signature :
CrystVector<double> GetTemperatureFactor(ObjCryst::ScatteringPower {lvalue},ObjCryst::ScatteringData [,int=-1])

GetTemperatureFactor( (ScatteringPower)arg1, (ScatteringData)arg2, (int)arg3) -> None :

C++ signature :
void GetTemperatureFactor((anonymous namespace)::ScatteringPowerWrap {lvalue},ObjCryst::ScatteringData,int)
IsIsotropic((ScatteringPower)arg1) → bool :
C++ signature :
bool IsIsotropic(ObjCryst::ScatteringPower {lvalue})
IsResonantScatteringAnisotropic((ScatteringPower)arg1) → bool :
C++ signature :
bool IsResonantScatteringAnisotropic(ObjCryst::ScatteringPower {lvalue})

IsResonantScatteringAnisotropic( (ScatteringPower)arg1) -> bool :

C++ signature :
bool IsResonantScatteringAnisotropic((anonymous namespace)::ScatteringPowerWrap {lvalue})
IsScatteringFactorAnisotropic((ScatteringPower)arg1) → bool :
C++ signature :
bool IsScatteringFactorAnisotropic(ObjCryst::ScatteringPower {lvalue})

IsScatteringFactorAnisotropic( (ScatteringPower)arg1) -> bool :

C++ signature :
bool IsScatteringFactorAnisotropic((anonymous namespace)::ScatteringPowerWrap {lvalue})
IsTemperatureFactorAnisotropic((ScatteringPower)arg1) → bool :
C++ signature :
bool IsTemperatureFactorAnisotropic(ObjCryst::ScatteringPower {lvalue})

IsTemperatureFactorAnisotropic( (ScatteringPower)arg1) -> bool :

C++ signature :
bool IsTemperatureFactorAnisotropic((anonymous namespace)::ScatteringPowerWrap {lvalue})
SetBij((ScatteringPower)arg1, (int)arg2, (int)arg3, (float)arg4) → None :
C++ signature :
void SetBij(ObjCryst::ScatteringPower {lvalue},unsigned long,unsigned long,double)

SetBij( (ScatteringPower)arg1, (int)arg2, (int)arg3, (float)arg4) -> None :

C++ signature :
void SetBij((anonymous namespace)::ScatteringPowerWrap {lvalue},unsigned long,unsigned long,double)
SetBiso((ScatteringPower)arg1, (float)arg2) → None :
C++ signature :
void SetBiso(ObjCryst::ScatteringPower {lvalue},double)

SetBiso( (ScatteringPower)arg1, (float)arg2) -> None :

C++ signature :
void SetBiso((anonymous namespace)::ScatteringPowerWrap {lvalue},double)
SetFormalCharge((ScatteringPower)arg1, (float)arg2) → None :
C++ signature :
void SetFormalCharge(ObjCryst::ScatteringPower {lvalue},double)

SetFormalCharge( (ScatteringPower)arg1, (float)arg2) -> None :

C++ signature :
void SetFormalCharge((anonymous namespace)::ScatteringPowerWrap {lvalue},double)
SetMaximumLikelihoodNbGhostAtom((ScatteringPower)arg1, (float)arg2) → None :
C++ signature :
void SetMaximumLikelihoodNbGhostAtom(ObjCryst::ScatteringPower {lvalue},double)

SetMaximumLikelihoodNbGhostAtom( (ScatteringPower)arg1, (float)arg2) -> None :

C++ signature :
void SetMaximumLikelihoodNbGhostAtom((anonymous namespace)::ScatteringPowerWrap {lvalue},double)
SetMaximumLikelihoodPositionError((ScatteringPower)arg1, (float)arg2) → None :
C++ signature :
void SetMaximumLikelihoodPositionError(ObjCryst::ScatteringPower {lvalue},double)

SetMaximumLikelihoodPositionError( (ScatteringPower)arg1, (float)arg2) -> None :

C++ signature :
void SetMaximumLikelihoodPositionError((anonymous namespace)::ScatteringPowerWrap {lvalue},double)
class pyobjcryst.scatteringpower.ScatteringComponent

Bases: Boost.Python.instance

Occupancy
Print((ScatteringComponent)arg1) → None :
C++ signature :
void Print(ObjCryst::ScatteringComponent {lvalue})
X
Y
Z
mDynPopCorr
mOccupancy
mX
mY
mZ
mpScattPow
class pyobjcryst.scatteringpower.ScatteringPowerAtom

Bases: pyobjcryst._pyobjcryst.ScatteringPower

GetAtomicNumber((ScatteringPowerAtom)arg1) → int :
C++ signature :
int GetAtomicNumber(ObjCryst::ScatteringPowerAtom {lvalue})
GetElementName((ScatteringPowerAtom)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetElementName(ObjCryst::ScatteringPowerAtom {lvalue})
Init((ScatteringPowerAtom)arg1, (str)name, (str)symbol[, (float)biso=1.0]) → None :
C++ signature :
void Init(ObjCryst::ScatteringPowerAtom {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > [,double=1.0])
SetSymbol((ScatteringPowerAtom)arg1, (str)arg2) → None :
C++ signature :
void SetSymbol(ObjCryst::ScatteringPowerAtom {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
class pyobjcryst.scatteringpower.ScatteringComponentList

Bases: Boost.Python.instance

GetNbComponent((ScatteringComponentList)arg1) → int :
C++ signature :
long GetNbComponent(ObjCryst::ScatteringComponentList {lvalue})
Print((ScatteringComponentList)arg1) → None :
C++ signature :
void Print(ObjCryst::ScatteringComponentList {lvalue})
Reset((ScatteringComponentList)arg1) → None :
C++ signature :
void Reset(ObjCryst::ScatteringComponentList {lvalue})

pyobjcryst.scatteringpowersphere module

Python wrapping of ScatteringPowerSphere.h

See the online ObjCryst++ documentation (http://vincefn.net/ObjCryst/).

class pyobjcryst.scatteringpowersphere.ScatteringPowerSphere

Bases: pyobjcryst._pyobjcryst.ScatteringPower

GetRadius((ScatteringPowerSphere)arg1) → float :
C++ signature :
double GetRadius(ObjCryst::ScatteringPowerSphere {lvalue})
Init((ScatteringPowerSphere)arg1, (str)name, (float)radius[, (float)biso=1.0]) → None :
C++ signature :
void Init(ObjCryst::ScatteringPowerSphere {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,double [,double=1.0])

pyobjcryst.spacegroup module

Python wrapping of SpaceGroup.h.

See the online ObjCryst++ documentation (http://vincefn.net/ObjCryst/).

class pyobjcryst.spacegroup.SpaceGroup

Bases: Boost.Python.instance

ChangeSpaceGroup((SpaceGroup)arg1, (str)arg2) → None :
C++ signature :
void ChangeSpaceGroup(ObjCryst::SpaceGroup {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
ChangeToAsymmetricUnit((SpaceGroup)arg1, (float)arg2, (float)arg3, (float)arg4) → None :
C++ signature :
void ChangeToAsymmetricUnit(ObjCryst::SpaceGroup {lvalue},double,double,double)
GetAllEquivRefl((SpaceGroup)arg1, (float)arg2, (float)arg3, (float)h, (bool)k, (bool)l[, (float)excludeFriedelMate=False[, (float)forceFriedelLaw=False]]) → object :
C++ signature :
CrystMatrix<double> GetAllEquivRefl(ObjCryst::SpaceGroup {lvalue},double,double,double,bool,bool [,double=False [,double=False]])
GetAllSymmetrics((SpaceGroup)arg1, (float)h, (float)k, (float)l[, (bool)noCenter=False[, (bool)noTransl=False[, (bool)noIdentical=False]]]) → object :
C++ signature :
CrystMatrix<double> GetAllSymmetrics(ObjCryst::SpaceGroup {lvalue},double,double,double [,bool=False [,bool=False [,bool=False]]])
GetAsymUnit((SpaceGroup)arg1) → AsymmetricUnit :
C++ signature :
ObjCryst::AsymmetricUnit GetAsymUnit(ObjCryst::SpaceGroup {lvalue})
GetClockSpaceGroup((SpaceGroup)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock GetClockSpaceGroup(ObjCryst::SpaceGroup {lvalue})
GetExpectedIntensityFactor((SpaceGroup)arg1, (float)arg2, (float)arg3, (float)arg4) → int :
C++ signature :
unsigned int GetExpectedIntensityFactor(ObjCryst::SpaceGroup {lvalue},double,double,double)
GetExtension((SpaceGroup)arg1) → str :
C++ signature :
char GetExtension(ObjCryst::SpaceGroup {lvalue})
GetInversionCenter((SpaceGroup)arg1) → object :
C++ signature :
CrystVector<double> GetInversionCenter(ObjCryst::SpaceGroup {lvalue})
GetName((SpaceGroup)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetName(ObjCryst::SpaceGroup {lvalue})
GetNbSymmetrics((SpaceGroup)arg1[, (bool)noCenter=False[, (bool)noTransl=False]]) → int :
C++ signature :
int GetNbSymmetrics(ObjCryst::SpaceGroup {lvalue} [,bool=False [,bool=False]])
GetNbTranslationVectors((SpaceGroup)arg1) → int :
C++ signature :
int GetNbTranslationVectors(ObjCryst::SpaceGroup {lvalue})
GetSpaceGroupNumber((SpaceGroup)arg1) → int :
C++ signature :
int GetSpaceGroupNumber(ObjCryst::SpaceGroup {lvalue})
GetSymmetryOperations((SpaceGroup)arg1) → list :
C++ signature :
boost::python::list GetSymmetryOperations(ObjCryst::SpaceGroup)
GetTranslationVectors((SpaceGroup)arg1) → list :
C++ signature :
boost::python::list GetTranslationVectors(ObjCryst::SpaceGroup)
GetUniqueAxis((SpaceGroup)arg1) → int :
C++ signature :
unsigned int GetUniqueAxis(ObjCryst::SpaceGroup {lvalue})
HasInversionCenter((SpaceGroup)arg1) → bool :
C++ signature :
bool HasInversionCenter(ObjCryst::SpaceGroup {lvalue})
IsCentrosymmetric((SpaceGroup)arg1) → bool :
C++ signature :
bool IsCentrosymmetric(ObjCryst::SpaceGroup {lvalue})
IsInAsymmetricUnit((SpaceGroup)arg1, (float)arg2, (float)arg3, (float)arg4) → bool :
C++ signature :
bool IsInAsymmetricUnit(ObjCryst::SpaceGroup {lvalue},double,double,double)

IsInAsymmetricUnit( (SpaceGroup)arg1, (float)arg2, (float)arg3, (float)arg4) -> bool :

C++ signature :
bool IsInAsymmetricUnit(ObjCryst::SpaceGroup {lvalue},double,double,double)
IsInversionCenterAtOrigin((SpaceGroup)arg1) → bool :
C++ signature :
bool IsInversionCenterAtOrigin(ObjCryst::SpaceGroup {lvalue})
IsReflCentric((SpaceGroup)arg1, (float)arg2, (float)arg3, (float)arg4) → bool :
C++ signature :
bool IsReflCentric(ObjCryst::SpaceGroup {lvalue},double,double,double)
IsReflSystematicAbsent((SpaceGroup)arg1, (float)arg2, (float)arg3, (float)arg4) → bool :
C++ signature :
bool IsReflSystematicAbsent(ObjCryst::SpaceGroup {lvalue},double,double,double)
Print((SpaceGroup)arg1) → None :
C++ signature :
void Print(ObjCryst::SpaceGroup {lvalue})
class pyobjcryst.spacegroup.AsymmetricUnit

Bases: Boost.Python.instance

IsInAsymmetricUnit((AsymmetricUnit)arg1, (float)x, (float)y, (float)z) → bool :
C++ signature :
bool IsInAsymmetricUnit(ObjCryst::AsymmetricUnit {lvalue},double,double,double)
SetSpaceGroup((AsymmetricUnit)arg1, (SpaceGroup)spg) → None :
C++ signature :
void SetSpaceGroup(ObjCryst::AsymmetricUnit {lvalue},ObjCryst::SpaceGroup)
Xmax((AsymmetricUnit)arg1) → float :
C++ signature :
double Xmax(ObjCryst::AsymmetricUnit {lvalue})
Xmin((AsymmetricUnit)arg1) → float :
C++ signature :
double Xmin(ObjCryst::AsymmetricUnit {lvalue})
Ymax((AsymmetricUnit)arg1) → float :
C++ signature :
double Ymax(ObjCryst::AsymmetricUnit {lvalue})
Ymin((AsymmetricUnit)arg1) → float :
C++ signature :
double Ymin(ObjCryst::AsymmetricUnit {lvalue})
Zmax((AsymmetricUnit)arg1) → float :
C++ signature :
double Zmax(ObjCryst::AsymmetricUnit {lvalue})
Zmin((AsymmetricUnit)arg1) → float :
C++ signature :
double Zmin(ObjCryst::AsymmetricUnit {lvalue})

pyobjcryst.unitcell module

Python wrapping of UnitCell.h

See the online ObjCryst++ documentation (http://vincefn.net/ObjCryst/).

class pyobjcryst.unitcell.UnitCell

Bases: pyobjcryst._pyobjcryst.RefinableObj

FractionalToOrthonormalCoords((UnitCell)arg1, (float)arg2, (float)arg3, (float)arg4) → tuple :
C++ signature :
boost::python::tuple FractionalToOrthonormalCoords(ObjCryst::UnitCell,double,double,double)
GetBMatrix((UnitCell)arg1) → object :
C++ signature :
CrystMatrix<double> GetBMatrix(ObjCryst::UnitCell {lvalue})
GetClockLatticePar((UnitCell)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock GetClockLatticePar(ObjCryst::UnitCell {lvalue})
GetClockMetricMatrix((UnitCell)arg1) → RefinableObjClock :
C++ signature :
ObjCryst::RefinableObjClock GetClockMetricMatrix(ObjCryst::UnitCell {lvalue})
GetLatticePar((UnitCell)arg1) → object :
C++ signature :
CrystVector<double> GetLatticePar(ObjCryst::UnitCell {lvalue})

GetLatticePar( (UnitCell)arg1, (int)arg2) -> float :

C++ signature :
double GetLatticePar(ObjCryst::UnitCell {lvalue},int)
GetOrthMatrix((UnitCell)arg1) → object :
C++ signature :
CrystMatrix<double> GetOrthMatrix(ObjCryst::UnitCell {lvalue})
GetOrthonormalCoords((UnitCell)arg1, (float)arg2, (float)arg3, (float)arg4) → object :
C++ signature :
CrystVector<double> GetOrthonormalCoords(ObjCryst::UnitCell {lvalue},double,double,double)
GetSpaceGroup((UnitCell)arg1) → SpaceGroup :
C++ signature :
ObjCryst::SpaceGroup {lvalue} GetSpaceGroup(ObjCryst::UnitCell {lvalue})
GetVolume((UnitCell)arg1) → float :
C++ signature :
double GetVolume(ObjCryst::UnitCell {lvalue})
MillerToOrthonormalCoords((UnitCell)arg1, (float)arg2, (float)arg3, (float)arg4) → tuple :
C++ signature :
boost::python::tuple MillerToOrthonormalCoords(ObjCryst::UnitCell,double,double,double)
OrthonormalToFractionalCoords((UnitCell)arg1, (float)arg2, (float)arg3, (float)arg4) → tuple :
C++ signature :
boost::python::tuple OrthonormalToFractionalCoords(ObjCryst::UnitCell,double,double,double)
OrthonormalToMillerCoords((UnitCell)arg1, (float)arg2, (float)arg3, (float)arg4) → tuple :
C++ signature :
boost::python::tuple OrthonormalToMillerCoords(ObjCryst::UnitCell,double,double,double)
a
alpha
b
beta
c
gamma

pyobjcryst.utils module

Utilities for crystals.

pyobjcryst.utils.printxyz(crystal)

Print a crystal in xyz format.

pyobjcryst.utils.putAtomsInMolecule(crystal, alist=None, name=None)

Place atoms from a crystal into a molecule inside the crystal.

Selected atoms are put into a new Molecule object, which is then placed inside of the Crystal. The atoms are then removed from the crystal. The molecule is placed at the center of mass of the moved atoms.

crystal – The crystal containing the atoms. alist – A list of indices or names identifying the atoms. If alist is

None (default), all atoms from the crystal are placed into a molecule.
name – A name for the molecule. If name is None (default), the name
m_cname will be given, where cname is substituted for the crystal’s name.

Raises TypeError if idxlist identifies a non-atom.

pyobjcryst.utils.writexyz(crystal, filename)

Write a crystal to an xyz file.

pyobjcryst.version module

Definition of __version__, __date__, __gitsha__, libobjcryst_version_info.

pyobjcryst.zscatterer module

Python wrapping of Zscatterer.

See the online ObjCryst++ documentation (http://vincefn.net/ObjCryst/).

Changes from ObjCryst::ZAtom - XMLOutput and Input are not wrapped.

Changes from ObjCryst++ - XMLOutput and Input are not wrapped.

class pyobjcryst.zscatterer.ZScatterer

Bases: pyobjcryst._pyobjcryst.Scatterer

AddAtom((ZScatterer)arg1, (str)name, (ScatteringPower)pow, (int)atomBond, (float)bondLength, (int)atomAngle, (float)bondAngle, (int)atomDihedral, (float)dihedralAngle[, (float)popu=1.0]) → None :
C++ signature :
void AddAtom(ObjCryst::ZScatterer {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >,ObjCryst::ScatteringPower const*,long,double,long,double,long,double [,double=1.0])
GetCenterAtomIndex((ZScatterer)arg1) → int :
C++ signature :
unsigned int GetCenterAtomIndex(ObjCryst::ZScatterer {lvalue})
GetChi((ZScatterer)arg1) → float :
C++ signature :
double GetChi(ObjCryst::ZScatterer {lvalue})
GetClassName((ZAtom)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetClassName(ObjCryst::ZAtom {lvalue})
GetPhi((ZScatterer)arg1) → float :
C++ signature :
double GetPhi(ObjCryst::ZScatterer {lvalue})
GetPsi((ZScatterer)arg1) → float :
C++ signature :
double GetPsi(ObjCryst::ZScatterer {lvalue})
GetXCoord((ZScatterer)arg1) → object :
C++ signature :
CrystVector<double> GetXCoord(ObjCryst::ZScatterer {lvalue})
GetYCoord((ZScatterer)arg1) → object :
C++ signature :
CrystVector<double> GetYCoord(ObjCryst::ZScatterer {lvalue})
GetZAngle((ZScatterer)arg1, (int)arg2) → float :
C++ signature :
double GetZAngle(ObjCryst::ZScatterer {lvalue},int)
GetZAngleAtom((ZScatterer)arg1, (int)arg2) → int :
C++ signature :
long GetZAngleAtom(ObjCryst::ZScatterer {lvalue},int)
GetZAtomRegistry((ZScatterer)arg1) → ZAtomRegistry :
C++ signature :
ObjCryst::ObjRegistry<ObjCryst::ZAtom> GetZAtomRegistry(ObjCryst::ZScatterer {lvalue})
GetZAtomX((ZScatterer)arg1, (int)arg2) → float :
C++ signature :
double GetZAtomX(ObjCryst::ZScatterer {lvalue},int)
GetZAtomY((ZScatterer)arg1, (int)arg2) → float :
C++ signature :
double GetZAtomY(ObjCryst::ZScatterer {lvalue},int)
GetZAtomZ((ZScatterer)arg1, (int)arg2) → float :
C++ signature :
double GetZAtomZ(ObjCryst::ZScatterer {lvalue},int)
GetZBondAtom((ZScatterer)arg1, (int)arg2) → int :
C++ signature :
long GetZBondAtom(ObjCryst::ZScatterer {lvalue},int)
GetZBondLength((ZScatterer)arg1, (int)arg2) → float :
C++ signature :
double GetZBondLength(ObjCryst::ZScatterer {lvalue},int)
GetZCoord((ZScatterer)arg1) → object :
C++ signature :
CrystVector<double> GetZCoord(ObjCryst::ZScatterer {lvalue})
GetZDihedralAngle((ZScatterer)arg1, (int)arg2) → float :
C++ signature :
double GetZDihedralAngle(ObjCryst::ZScatterer {lvalue},int)
GetZDihedralAngleAtom((ZScatterer)arg1, (int)arg2) → int :
C++ signature :
long GetZDihedralAngleAtom(ObjCryst::ZScatterer {lvalue},int)
SetCenterAtomIndex((ZScatterer)arg1, (int)arg2) → None :
C++ signature :
void SetCenterAtomIndex(ObjCryst::ZScatterer {lvalue},unsigned int)
SetChi((ZScatterer)arg1, (float)arg2) → None :
C++ signature :
void SetChi(ObjCryst::ZScatterer {lvalue},double)
SetPhi((ZScatterer)arg1, (float)arg2) → None :
C++ signature :
void SetPhi(ObjCryst::ZScatterer {lvalue},double)
SetPsi((ZScatterer)arg1, (float)arg2) → None :
C++ signature :
void SetPsi(ObjCryst::ZScatterer {lvalue},double)
SetZAngle((ZScatterer)arg1, (int)arg2, (float)arg3) → None :
C++ signature :
void SetZAngle(ObjCryst::ZScatterer {lvalue},int,double)
SetZBondLength((ZScatterer)arg1, (int)arg2, (float)arg3) → None :
C++ signature :
void SetZBondLength(ObjCryst::ZScatterer {lvalue},int,double)
SetZDihedralAngle((ZScatterer)arg1, (int)arg2, (float)arg3) → None :
C++ signature :
void SetZDihedralAngle(ObjCryst::ZScatterer {lvalue},int,double)
class pyobjcryst.zscatterer.ZAtom

Bases: Boost.Python.instance

GetClassName((ZAtom)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetClassName(ObjCryst::ZAtom {lvalue})
GetName((ZAtom)arg1) → str :
C++ signature :
std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > GetName(ObjCryst::ZAtom {lvalue})
GetOccupancy((ZAtom)arg1) → float :
C++ signature :
double GetOccupancy(ObjCryst::ZAtom {lvalue})
GetScatteringPower((ZAtom)arg1) → ScatteringPower :
C++ signature :
ObjCryst::ScatteringPower const* GetScatteringPower(ObjCryst::ZAtom {lvalue})
GetZAngle((ZAtom)arg1) → float :
C++ signature :
double GetZAngle(ObjCryst::ZAtom {lvalue})
GetZAngleAtom((ZAtom)arg1) → int :
C++ signature :
long GetZAngleAtom(ObjCryst::ZAtom {lvalue})
GetZBondAtom((ZAtom)arg1) → int :
C++ signature :
long GetZBondAtom(ObjCryst::ZAtom {lvalue})
GetZBondLength((ZAtom)arg1) → float :
C++ signature :
double GetZBondLength(ObjCryst::ZAtom {lvalue})
GetZDihedralAngle((ZAtom)arg1) → float :
C++ signature :
double GetZDihedralAngle(ObjCryst::ZAtom {lvalue})
GetZDihedralAngleAtom((ZAtom)arg1) → int :
C++ signature :
long GetZDihedralAngleAtom(ObjCryst::ZAtom {lvalue})
GetZScatterer((ZAtom)arg1) → ZScatterer :
C++ signature :
ObjCryst::ZScatterer {lvalue} GetZScatterer(ObjCryst::ZAtom {lvalue})
SetName((ZAtom)arg1, (str)arg2) → None :
C++ signature :
void SetName(ObjCryst::ZAtom {lvalue},std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
SetOccupancy((ZAtom)arg1, (float)arg2) → None :
C++ signature :
void SetOccupancy(ObjCryst::ZAtom {lvalue},double)
SetScatteringPower((ZAtom)arg1, (ScatteringPower)arg2) → None :
C++ signature :
void SetScatteringPower(ObjCryst::ZAtom {lvalue},ObjCryst::ScatteringPower const*)
SetZAngle((ZAtom)arg1, (float)arg2) → None :
C++ signature :
void SetZAngle(ObjCryst::ZAtom {lvalue},double)
SetZBondLength((ZAtom)arg1, (float)arg2) → None :
C++ signature :
void SetZBondLength(ObjCryst::ZAtom {lvalue},double)
SetZDihedralAngle((ZAtom)arg1, (float)arg2) → None :
C++ signature :
void SetZDihedralAngle(ObjCryst::ZAtom {lvalue},double)
class pyobjcryst.zscatterer.ZPolyhedron

Bases: pyobjcryst._pyobjcryst.ZScatterer

class pyobjcryst.zscatterer.RegularPolyhedraType

Bases: Boost.Python.enum

ANTIPRISM_TETRAGONAL = pyobjcryst._pyobjcryst.RegularPolyhedraType.ANTIPRISM_TETRAGONAL
CUBE = pyobjcryst._pyobjcryst.RegularPolyhedraType.CUBE
OCTAHEDRON = pyobjcryst._pyobjcryst.RegularPolyhedraType.OCTAHEDRON
PRISM_TETRAGONAL_MONOCAP = pyobjcryst._pyobjcryst.RegularPolyhedraType.PRISM_TETRAGONAL_MONOCAP
PRISM_TRIGONAL_TRICAPPED = pyobjcryst._pyobjcryst.RegularPolyhedraType.PRISM_TRIGONAL_TRICAPPED
SQUARE_PLANE = pyobjcryst._pyobjcryst.RegularPolyhedraType.SQUARE_PLANE
TETRAHEDRON = pyobjcryst._pyobjcryst.RegularPolyhedraType.TETRAHEDRON
names = {'PRISM_TETRAGONAL_DICAP ': pyobjcryst._pyobjcryst.RegularPolyhedraType.PRISM_TETRAGONAL_DICAP , 'CUBE': pyobjcryst._pyobjcryst.RegularPolyhedraType.CUBE, 'PRISM_TRIGONAL_TRICAPPED': pyobjcryst._pyobjcryst.RegularPolyhedraType.PRISM_TRIGONAL_TRICAPPED, 'SQUARE_PLANE': pyobjcryst._pyobjcryst.RegularPolyhedraType.SQUARE_PLANE, 'TETRAHEDRON': pyobjcryst._pyobjcryst.RegularPolyhedraType.TETRAHEDRON, 'OCTAHEDRON': pyobjcryst._pyobjcryst.RegularPolyhedraType.OCTAHEDRON, 'PRISM_TRIGONAL ': pyobjcryst._pyobjcryst.RegularPolyhedraType.PRISM_TRIGONAL , 'PRISM_TETRAGONAL_MONOCAP': pyobjcryst._pyobjcryst.RegularPolyhedraType.PRISM_TETRAGONAL_MONOCAP, 'ANTIPRISM_TETRAGONAL': pyobjcryst._pyobjcryst.RegularPolyhedraType.ANTIPRISM_TETRAGONAL, 'TRIANGLE_PLANE ': pyobjcryst._pyobjcryst.RegularPolyhedraType.TRIANGLE_PLANE , 'ICOSAHEDRON ': pyobjcryst._pyobjcryst.RegularPolyhedraType.ICOSAHEDRON }
values = {0: pyobjcryst._pyobjcryst.RegularPolyhedraType.TETRAHEDRON, 1: pyobjcryst._pyobjcryst.RegularPolyhedraType.OCTAHEDRON, 2: pyobjcryst._pyobjcryst.RegularPolyhedraType.SQUARE_PLANE, 3: pyobjcryst._pyobjcryst.RegularPolyhedraType.CUBE, 4: pyobjcryst._pyobjcryst.RegularPolyhedraType.ANTIPRISM_TETRAGONAL, 5: pyobjcryst._pyobjcryst.RegularPolyhedraType.PRISM_TETRAGONAL_MONOCAP, 6: pyobjcryst._pyobjcryst.RegularPolyhedraType.PRISM_TETRAGONAL_DICAP , 7: pyobjcryst._pyobjcryst.RegularPolyhedraType.PRISM_TRIGONAL , 8: pyobjcryst._pyobjcryst.RegularPolyhedraType.PRISM_TRIGONAL_TRICAPPED, 9: pyobjcryst._pyobjcryst.RegularPolyhedraType.ICOSAHEDRON , 10: pyobjcryst._pyobjcryst.RegularPolyhedraType.TRIANGLE_PLANE }
class pyobjcryst.zscatterer.GlobalScatteringPower

Bases: pyobjcryst._pyobjcryst.ScatteringPower

GetRadius((GlobalScatteringPower)arg1) → float :
C++ signature :
double GetRadius(ObjCryst::GlobalScatteringPower {lvalue})
Init((GlobalScatteringPower)arg1, (ZScatterer)arg2) → None :
C++ signature :
void Init(ObjCryst::GlobalScatteringPower {lvalue},ObjCryst::ZScatterer)

Module contents

Python wrapping of ObjCryst++.

Objects are wrapped according to their header file in the ObjCryst source.

See the online ObjCryst++ documentation (http://vincefn.net/ObjCryst/).

Modules

atom – Wrapping of Atom.h crystal – Wrapping of Crystal.h general – Wrapping of General.h io – Wrapping of IO.h molecule – Wrapping of Molecule.h polyhedron – Wrapping of Polyhedron.h refinableobj – Wrapping of RefinableObj.h scatterer – Wrapping of Scatterer.h scatteringpower – Wrapping of ScatteringPower.h scatteringpowersphere – Wrapping of ScatteringPowerSphere.h spacegroup – Wrapping of SpaceGroup.h unitcell – Wrapping of UnitCell.h zscatterer – Wrapping of ZScatterer.h

General Changes

  • C++ methods that can return const or non-const objects return non-const objects in python.
  • Classes with a Print() method have the output of this method exposed in the __str__ python method. Thus, obj.Print() == print obj.
  • CrystVector and CrystMatrix are converted to numpy arrays.
  • Indexing methods raise IndexError when index is out of bounds.

See the modules’ documentation for specific changes.

exception pyobjcryst.ObjCrystException

Bases: exceptions.Exception

pyobjcryst.loadCrystal(filename)

Load pyobjcryst Crystal object from a CIF file.

filename – CIF file to be loaded

Return a new Crystal object.

See pyobjcryst.crystal.CreateCrystalFromCIF for additional options for constructing Crystal object from CIF data.