void register_CLJAtom_class(){ { //::SireMM::CLJAtom typedef bp::class_< SireMM::CLJAtom > CLJAtom_exposer_t; CLJAtom_exposer_t CLJAtom_exposer = CLJAtom_exposer_t( "CLJAtom", bp::init< >() ); bp::scope CLJAtom_scope( CLJAtom_exposer ); CLJAtom_exposer.def( bp::init< SireMaths::Vector, SireUnits::Dimension::Charge, SireMM::LJParameter, bp::optional< qint32 > >(( bp::arg("coords"), bp::arg("charge"), bp::arg("ljparam"), bp::arg("idnum")=(int)(1) )) ); CLJAtom_exposer.def( bp::init< SireMM::CLJAtom const & >(( bp::arg("other") )) ); { //::SireMM::CLJAtom::ID typedef ::qint32 ( ::SireMM::CLJAtom::*ID_function_type )( ) const; ID_function_type ID_function_value( &::SireMM::CLJAtom::ID ); CLJAtom_exposer.def( "ID" , ID_function_value ); } { //::SireMM::CLJAtom::buildFrom typedef ::QVector< SireMM::CLJAtom > ( *buildFrom_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ); buildFrom_function_type buildFrom_function_value( &::SireMM::CLJAtom::buildFrom ); CLJAtom_exposer.def( "buildFrom" , buildFrom_function_value , ( bp::arg("molecule"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireMM::CLJAtom::charge typedef ::SireUnits::Dimension::Charge ( ::SireMM::CLJAtom::*charge_function_type )( ) const; charge_function_type charge_function_value( &::SireMM::CLJAtom::charge ); CLJAtom_exposer.def( "charge" , charge_function_value ); } { //::SireMM::CLJAtom::coordinates typedef ::SireMaths::Vector ( ::SireMM::CLJAtom::*coordinates_function_type )( ) const; coordinates_function_type coordinates_function_value( &::SireMM::CLJAtom::coordinates ); CLJAtom_exposer.def( "coordinates" , coordinates_function_value ); } { //::SireMM::CLJAtom::isDummy typedef bool ( ::SireMM::CLJAtom::*isDummy_function_type )( ) const; isDummy_function_type isDummy_function_value( &::SireMM::CLJAtom::isDummy ); CLJAtom_exposer.def( "isDummy" , isDummy_function_value ); } { //::SireMM::CLJAtom::isNull typedef bool ( ::SireMM::CLJAtom::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireMM::CLJAtom::isNull ); CLJAtom_exposer.def( "isNull" , isNull_function_value ); } { //::SireMM::CLJAtom::ljParameter typedef ::SireMM::LJParameter ( ::SireMM::CLJAtom::*ljParameter_function_type )( ) const; ljParameter_function_type ljParameter_function_value( &::SireMM::CLJAtom::ljParameter ); CLJAtom_exposer.def( "ljParameter" , ljParameter_function_value ); } { //::SireMM::CLJAtom::negate typedef ::SireMM::CLJAtom ( ::SireMM::CLJAtom::*negate_function_type )( ) const; negate_function_type negate_function_value( &::SireMM::CLJAtom::negate ); CLJAtom_exposer.def( "negate" , negate_function_value ); } CLJAtom_exposer.def( bp::self != bp::self ); { //::SireMM::CLJAtom::operator= typedef ::SireMM::CLJAtom & ( ::SireMM::CLJAtom::*assign_function_type )( ::SireMM::CLJAtom const & ) ; assign_function_type assign_function_value( &::SireMM::CLJAtom::operator= ); CLJAtom_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } CLJAtom_exposer.def( bp::self == bp::self ); { //::SireMM::CLJAtom::toString typedef ::QString ( ::SireMM::CLJAtom::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMM::CLJAtom::toString ); CLJAtom_exposer.def( "toString" , toString_function_value ); } { //::SireMM::CLJAtom::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::CLJAtom::typeName ); CLJAtom_exposer.def( "typeName" , typeName_function_value ); } { //::SireMM::CLJAtom::what typedef char const * ( ::SireMM::CLJAtom::*what_function_type )( ) const; what_function_type what_function_value( &::SireMM::CLJAtom::what ); CLJAtom_exposer.def( "what" , what_function_value ); } CLJAtom_exposer.staticmethod( "buildFrom" ); CLJAtom_exposer.staticmethod( "typeName" ); CLJAtom_exposer.def( "__copy__", &__copy__); CLJAtom_exposer.def( "__deepcopy__", &__copy__); CLJAtom_exposer.def( "clone", &__copy__); CLJAtom_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJAtom >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CLJAtom_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJAtom >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CLJAtom_exposer.def( "__str__", &__str__< ::SireMM::CLJAtom > ); CLJAtom_exposer.def( "__repr__", &__str__< ::SireMM::CLJAtom > ); } }
void register_CoordGroupArray_class(){ { //::SireVol::CoordGroupArray typedef bp::class_< SireVol::CoordGroupArray > CoordGroupArray_exposer_t; CoordGroupArray_exposer_t CoordGroupArray_exposer = CoordGroupArray_exposer_t( "CoordGroupArray", "This class holds an array of CoordGroups. While you could\nof course just use a QVector<CoordGroup>, this array\noptimises the memory layout of all of the CoordGroups\nso that they all lie contiguously along the same piece\nof memory (and indeed, all of the AABoxes are grouped\ntogether, while all of the coordinates are grouped together).\n\nThe memory packing means that this array is much more\nlimited than a QVector<CoordGroup>, i.e. you cant\nadd or remove CoordGroups from the array, and you cant\ndo anything to the contained CoordGroups except for\nchange their coordinates.\n\nThis class is really meant to be used as a fast container\nthat allow rapid iteration over all of the contained\nCoordGroups coordinates\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") ); bp::scope CoordGroupArray_scope( CoordGroupArray_exposer ); CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroup const & >(( bp::arg("cgroup") ), "Construct an array that holds just the passed CoordGroup") ); CoordGroupArray_exposer.def( bp::init< QVector< QVector< SireMaths::Vector > > const & >(( bp::arg("points") ), "Construct from a double-vector") ); CoordGroupArray_exposer.def( bp::init< QVector< SireVol::CoordGroup > const & >(( bp::arg("cgroups") ), "Construct from an array of CoordGroups") ); CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroupArray const &, SireVol::CoordGroupArray const & >(( bp::arg("array0"), bp::arg("array1") ), "Construct from a pair of CoordGroupArrays") ); CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireVol::CoordGroupArray::aaBox typedef ::SireVol::AABox ( ::SireVol::CoordGroupArray::*aaBox_function_type)( ) const; aaBox_function_type aaBox_function_value( &::SireVol::CoordGroupArray::aaBox ); CoordGroupArray_exposer.def( "aaBox" , aaBox_function_value , "Return an AABox that complete encompasses all of the CoordGroups\nin this array" ); } { //::SireVol::CoordGroupArray::append typedef void ( ::SireVol::CoordGroupArray::*append_function_type)( ::SireVol::CoordGroup const & ) ; append_function_type append_function_value( &::SireVol::CoordGroupArray::append ); CoordGroupArray_exposer.def( "append" , append_function_value , ( bp::arg("cgroup") ) , "Append the passed CoordGroup onto the end of this array" ); } { //::SireVol::CoordGroupArray::append typedef void ( ::SireVol::CoordGroupArray::*append_function_type)( ::SireVol::CoordGroupArray const & ) ; append_function_type append_function_value( &::SireVol::CoordGroupArray::append ); CoordGroupArray_exposer.def( "append" , append_function_value , ( bp::arg("cgroups") ) , "Append the passed CoordGroups onto the end of this array" ); } { //::SireVol::CoordGroupArray::assertValidCoordGroup typedef void ( ::SireVol::CoordGroupArray::*assertValidCoordGroup_function_type)( ::quint32 ) const; assertValidCoordGroup_function_type assertValidCoordGroup_function_value( &::SireVol::CoordGroupArray::assertValidCoordGroup ); CoordGroupArray_exposer.def( "assertValidCoordGroup" , assertValidCoordGroup_function_value , ( bp::arg("i") ) , "Assert that the index i points to a valid CoordGroup\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::assertValidCoordinate typedef void ( ::SireVol::CoordGroupArray::*assertValidCoordinate_function_type)( ::quint32 ) const; assertValidCoordinate_function_type assertValidCoordinate_function_value( &::SireVol::CoordGroupArray::assertValidCoordinate ); CoordGroupArray_exposer.def( "assertValidCoordinate" , assertValidCoordinate_function_value , ( bp::arg("i") ) , "Assert that the index i points a valid coordinate\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::assertValidIndex typedef void ( ::SireVol::CoordGroupArray::*assertValidIndex_function_type)( ::quint32 ) const; assertValidIndex_function_type assertValidIndex_function_value( &::SireVol::CoordGroupArray::assertValidIndex ); CoordGroupArray_exposer.def( "assertValidIndex" , assertValidIndex_function_value , ( bp::arg("i") ) , "Assert that the index i points to a valid CoordGroup\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::at typedef ::SireVol::CoordGroup const & ( ::SireVol::CoordGroupArray::*at_function_type)( ::quint32 ) const; at_function_type at_function_value( &::SireVol::CoordGroupArray::at ); CoordGroupArray_exposer.def( "at" , at_function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() , "Return a reference to the ith CoordGroup\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::changeFrame typedef void ( ::SireVol::CoordGroupArray::*changeFrame_function_type)( ::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ; changeFrame_function_type changeFrame_function_value( &::SireVol::CoordGroupArray::changeFrame ); CoordGroupArray_exposer.def( "changeFrame" , changeFrame_function_value , ( bp::arg("from_frame"), bp::arg("to_frame") ) , "Change all of the coordinates in this array from the\ncoordinate frame from_frame to the coordinate frame to_frame" ); } { //::SireVol::CoordGroupArray::changeFrame typedef void ( ::SireVol::CoordGroupArray::*changeFrame_function_type)( ::quint32,::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ; changeFrame_function_type changeFrame_function_value( &::SireVol::CoordGroupArray::changeFrame ); CoordGroupArray_exposer.def( "changeFrame" , changeFrame_function_value , ( bp::arg("i"), bp::arg("from_frame"), bp::arg("to_frame") ) , "Change all of the coordinates in the ith CoordGroup from\nthe coordinate frame from_frame to the coordinate frame\nto_frame\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::count typedef int ( ::SireVol::CoordGroupArray::*count_function_type)( ) const; count_function_type count_function_value( &::SireVol::CoordGroupArray::count ); CoordGroupArray_exposer.def( "count" , count_function_value , "Return the number of CoordGroups in this array" ); } { //::SireVol::CoordGroupArray::isEmpty typedef bool ( ::SireVol::CoordGroupArray::*isEmpty_function_type)( ) const; isEmpty_function_type isEmpty_function_value( &::SireVol::CoordGroupArray::isEmpty ); CoordGroupArray_exposer.def( "isEmpty" , isEmpty_function_value , "Return whether or not this array is empty" ); } { //::SireVol::CoordGroupArray::mapInto typedef void ( ::SireVol::CoordGroupArray::*mapInto_function_type)( ::SireMaths::AxisSet const & ) ; mapInto_function_type mapInto_function_value( &::SireVol::CoordGroupArray::mapInto ); CoordGroupArray_exposer.def( "mapInto" , mapInto_function_value , ( bp::arg("axes") ) , "Map all of the coordinates in this array into the coordinate\nframe represented by axes" ); } { //::SireVol::CoordGroupArray::mapInto typedef void ( ::SireVol::CoordGroupArray::*mapInto_function_type)( ::quint32,::SireMaths::AxisSet const & ) ; mapInto_function_type mapInto_function_value( &::SireVol::CoordGroupArray::mapInto ); CoordGroupArray_exposer.def( "mapInto" , mapInto_function_value , ( bp::arg("i"), bp::arg("axes") ) , "Map all of the coordinates of the CoordGroup at index i\ninto the coordinate frame represented by axes\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::merge typedef ::SireVol::CoordGroup ( ::SireVol::CoordGroupArray::*merge_function_type)( ) const; merge_function_type merge_function_value( &::SireVol::CoordGroupArray::merge ); CoordGroupArray_exposer.def( "merge" , merge_function_value , "Merge this array of CoordGroups back into a single CoordGroup" ); } { //::SireVol::CoordGroupArray::nCoordGroups typedef int ( ::SireVol::CoordGroupArray::*nCoordGroups_function_type)( ) const; nCoordGroups_function_type nCoordGroups_function_value( &::SireVol::CoordGroupArray::nCoordGroups ); CoordGroupArray_exposer.def( "nCoordGroups" , nCoordGroups_function_value , "Return the number of CoordGroups in this array" ); } { //::SireVol::CoordGroupArray::nCoords typedef int ( ::SireVol::CoordGroupArray::*nCoords_function_type)( ) const; nCoords_function_type nCoords_function_value( &::SireVol::CoordGroupArray::nCoords ); CoordGroupArray_exposer.def( "nCoords" , nCoords_function_value , "Return the number of coordinates in this array" ); } CoordGroupArray_exposer.def( bp::self != bp::self ); { //::SireVol::CoordGroupArray::operator= typedef ::SireVol::CoordGroupArray & ( ::SireVol::CoordGroupArray::*assign_function_type)( ::SireVol::CoordGroupArray const & ) ; assign_function_type assign_function_value( &::SireVol::CoordGroupArray::operator= ); CoordGroupArray_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } CoordGroupArray_exposer.def( bp::self == bp::self ); { //::SireVol::CoordGroupArray::operator[] typedef ::SireVol::CoordGroup const & ( ::SireVol::CoordGroupArray::*__getitem___function_type)( ::quint32 ) const; __getitem___function_type __getitem___function_value( &::SireVol::CoordGroupArray::operator[] ); CoordGroupArray_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireVol::CoordGroupArray::remove typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::quint32 ) ; remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove ); CoordGroupArray_exposer.def( "remove" , remove_function_value , ( bp::arg("i") ) , "Remove the ith CoordGroup from the array" ); } { //::SireVol::CoordGroupArray::remove typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::quint32,int ) ; remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove ); CoordGroupArray_exposer.def( "remove" , remove_function_value , ( bp::arg("i"), bp::arg("count") ) , "Remove count CoordGroups from the array, starting with the ith CoordGroup" ); } { //::SireVol::CoordGroupArray::remove typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::QVarLengthArray< unsigned int, 256 > const & ) ; remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove ); CoordGroupArray_exposer.def( "remove" , remove_function_value , ( bp::arg("idxs") ) , "Remove the specified CoordGroups from the array" ); } { //::SireVol::CoordGroupArray::rotate typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ; rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate ); CoordGroupArray_exposer.def( "rotate" , rotate_function_value , ( bp::arg("quat"), bp::arg("point") ) , "Rotate all of the coordinates in this array using the quaternion\nquat around the point point" ); } { //::SireVol::CoordGroupArray::rotate typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::SireMaths::Matrix const &,::SireMaths::Vector const & ) ; rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate ); CoordGroupArray_exposer.def( "rotate" , rotate_function_value , ( bp::arg("rotmat"), bp::arg("point") ) , "Rotate all of coordinates in this array using the matrix rotmat\nabout the point point" ); } { //::SireVol::CoordGroupArray::rotate typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::quint32,::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ; rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate ); CoordGroupArray_exposer.def( "rotate" , rotate_function_value , ( bp::arg("i"), bp::arg("quat"), bp::arg("point") ) , "Rotate all of the coordinates in the CoordGroup at index i using\nthe quaternion quat about the point point\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::rotate typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::quint32,::SireMaths::Matrix const &,::SireMaths::Vector const & ) ; rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate ); CoordGroupArray_exposer.def( "rotate" , rotate_function_value , ( bp::arg("i"), bp::arg("rotmat"), bp::arg("point") ) , "Rotate all of the coordinates in the CoordGroup at index i using\nthe matrix rotmat about the point point\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::size typedef int ( ::SireVol::CoordGroupArray::*size_function_type)( ) const; size_function_type size_function_value( &::SireVol::CoordGroupArray::size ); CoordGroupArray_exposer.def( "size" , size_function_value , "Return the number of CoordGroups in this array" ); } { //::SireVol::CoordGroupArray::toString typedef ::QString ( ::SireVol::CoordGroupArray::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireVol::CoordGroupArray::toString ); CoordGroupArray_exposer.def( "toString" , toString_function_value , "Return a string representation of this array" ); } { //::SireVol::CoordGroupArray::transform typedef void ( ::SireVol::CoordGroupArray::*transform_function_type)( ::SireMaths::Transform const & ) ; transform_function_type transform_function_value( &::SireVol::CoordGroupArray::transform ); CoordGroupArray_exposer.def( "transform" , transform_function_value , ( bp::arg("t") ) , "Transform all of coordinates in this array using the transformation t" ); } { //::SireVol::CoordGroupArray::transform typedef void ( ::SireVol::CoordGroupArray::*transform_function_type)( ::quint32,::SireMaths::Transform const & ) ; transform_function_type transform_function_value( &::SireVol::CoordGroupArray::transform ); CoordGroupArray_exposer.def( "transform" , transform_function_value , ( bp::arg("i"), bp::arg("t") ) , "Transform all of the coordinates in the CoordGroup at index i using\nthe transformation t\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::translate typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::SireMaths::Vector const & ) ; translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate ); CoordGroupArray_exposer.def( "translate" , translate_function_value , ( bp::arg("delta") ) , "Translate all of the coordinates in this array by delta" ); } { //::SireVol::CoordGroupArray::translate typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::quint32,::SireMaths::Vector const & ) ; translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate ); CoordGroupArray_exposer.def( "translate" , translate_function_value , ( bp::arg("i"), bp::arg("delta") ) , "Translate all of the coordinates in the ith CoordGroup by delta" ); } { //::SireVol::CoordGroupArray::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireVol::CoordGroupArray::typeName ); CoordGroupArray_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireVol::CoordGroupArray::update typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireVol::CoordGroup const & ) ; update_function_type update_function_value( &::SireVol::CoordGroupArray::update ); CoordGroupArray_exposer.def( "update" , update_function_value , ( bp::arg("i"), bp::arg("cgroup") ) , "Update the CoordGroup at index i so that it is equal to cgroup. Note\nthat cgroup must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" ); } { //::SireVol::CoordGroupArray::update typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::QVector< SireMaths::Vector > const & ) ; update_function_type update_function_value( &::SireVol::CoordGroupArray::update ); CoordGroupArray_exposer.def( "update" , update_function_value , ( bp::arg("i"), bp::arg("coords") ) , "Update the CoordGroup at index i so that it has coordinates coords\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" ); } { //::SireVol::CoordGroupArray::update typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireMaths::Vector const *,int ) ; update_function_type update_function_value( &::SireVol::CoordGroupArray::update ); CoordGroupArray_exposer.def( "update" , update_function_value , ( bp::arg("i"), bp::arg("coords"), bp::arg("ncoords") ) , "Update the CoordGroup at index i so that it has coordinates coords\n(there are ncoords coordinates in this array)\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" ); } { //::SireVol::CoordGroupArray::what typedef char const * ( ::SireVol::CoordGroupArray::*what_function_type)( ) const; what_function_type what_function_value( &::SireVol::CoordGroupArray::what ); CoordGroupArray_exposer.def( "what" , what_function_value , "" ); } CoordGroupArray_exposer.staticmethod( "typeName" ); CoordGroupArray_exposer.def( "__copy__", &__copy__); CoordGroupArray_exposer.def( "__deepcopy__", &__copy__); CoordGroupArray_exposer.def( "clone", &__copy__); CoordGroupArray_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::CoordGroupArray >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CoordGroupArray_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::CoordGroupArray >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CoordGroupArray_exposer.def( "__str__", &__str__< ::SireVol::CoordGroupArray > ); CoordGroupArray_exposer.def( "__repr__", &__str__< ::SireVol::CoordGroupArray > ); CoordGroupArray_exposer.def( "__len__", &__len_size< ::SireVol::CoordGroupArray > ); } }
void register_ExBase_class(){ { //::SireCAS::ExBase typedef bp::class_< SireCAS::ExBase, boost::noncopyable > ExBase_exposer_t; ExBase_exposer_t ExBase_exposer = ExBase_exposer_t( "ExBase", "\nPure-virtual base class of all of the parts of mathematical expressions.\n\nThis class provides the atom of SireCAS. ExBase objects are combined together\nto form complete expressions. All constants, functions and symbols are derived\nfrom this object.\n\nThis class is an example of an implicitly shared, self-managed object, and\nis designed so that it can be held by SharedPolyPointer (indeed,\nExpressionBase is just a proxy for SharedPolyPointer<ExBase>).\n\nAuthor: Christopher Woods\n", bp::no_init ); bp::scope ExBase_scope( ExBase_exposer ); { //::SireCAS::ExBase::children typedef ::SireCAS::Expressions ( ::SireCAS::ExBase::*children_function_type)( ) const; children_function_type children_function_value( &::SireCAS::ExBase::children ); ExBase_exposer.def( "children" , children_function_value , "Return the child expressions of this Expression" ); } { //::SireCAS::ExBase::conjugate typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*conjugate_function_type)( ) const; conjugate_function_type conjugate_function_value( &::SireCAS::ExBase::conjugate ); ExBase_exposer.def( "conjugate" , conjugate_function_value , "Return the complex conjugate of this expression" ); } { //::SireCAS::ExBase::differentiate typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*differentiate_function_type)( ::SireCAS::Symbol const & ) const; differentiate_function_type differentiate_function_value( &::SireCAS::ExBase::differentiate ); ExBase_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol") ) , "Return an expression that the differential of this ExBase\nwith respect to symbol. Note an exception may\nbe thrown if this ExBase cannot be differentiated.\nThrow: SireCAS::unavailable_differential\n" ); } { //::SireCAS::ExBase::evaluate typedef double ( ::SireCAS::ExBase::*evaluate_function_type)( ::SireCAS::Values const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::ExBase::evaluate ); ExBase_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) , "Evaluate this ExBase using values values. Any\nmissing symbols are assumed to equal zero.\n\nNote that an exception will be thrown if the result of the\nevaluation of this, or one of its children, is complex.\n\nThrow: SireMaths::domain_error\n" ); } { //::SireCAS::ExBase::evaluate typedef ::SireMaths::Complex ( ::SireCAS::ExBase::*evaluate_function_type)( ::SireCAS::ComplexValues const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::ExBase::evaluate ); ExBase_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) , "Evaluate this ExBase using the complex values values.\nAny missing symbols are assumed to equal zero." ); } { //::SireCAS::ExBase::expand typedef ::QList< SireCAS::Factor > ( ::SireCAS::ExBase::*expand_function_type)( ::SireCAS::Symbol const & ) const; expand_function_type expand_function_value( &::SireCAS::ExBase::expand ); ExBase_exposer.def( "expand" , expand_function_value , ( bp::arg("symbol") ) , "Rearrange this expression into the form\nm x^i + n x^j + ... + constant\nand return the factors and powers of x\n\nThrow: SireCAS::rearrangement_error\n" ); } { //::SireCAS::ExBase::functions typedef ::SireCAS::Functions ( ::SireCAS::ExBase::*functions_function_type)( ) const; functions_function_type functions_function_value( &::SireCAS::ExBase::functions ); ExBase_exposer.def( "functions" , functions_function_value , "Return the set of Functions that appear in this ExBase" ); } { //::SireCAS::ExBase::hash typedef ::uint ( ::SireCAS::ExBase::*hash_function_type)( ) const; hash_function_type hash_function_value( &::SireCAS::ExBase::hash ); ExBase_exposer.def( "hash" , hash_function_value , "Return a hash of this object - return a combination of the\nidentifying magic for the class and a hash for its contents." ); } { //::SireCAS::ExBase::integrate typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*integrate_function_type)( ::SireCAS::Symbol const & ) const; integrate_function_type integrate_function_value( &::SireCAS::ExBase::integrate ); ExBase_exposer.def( "integrate" , integrate_function_value , ( bp::arg("symbol") ) , "Return the indefinite integral of this ExBase with respect to\nsymbol. This is not guaranteed to work() and will return an\nexpression of the form Sum( integral(exbase) + integral_constant ).\nIf it doesnt work then an exception will be throw.\nThrow: SireCAS::unavailable_integral\n" ); } { //::SireCAS::ExBase::isComplex typedef bool ( ::SireCAS::ExBase::*isComplex_function_type)( ) const; isComplex_function_type isComplex_function_value( &::SireCAS::ExBase::isComplex ); ExBase_exposer.def( "isComplex" , isComplex_function_value , "Return whether or not this expression contains any complex (imaginary)\nparts" ); } { //::SireCAS::ExBase::isCompound typedef bool ( ::SireCAS::ExBase::*isCompound_function_type)( ) const; isCompound_function_type isCompound_function_value( &::SireCAS::ExBase::isCompound ); ExBase_exposer.def( "isCompound" , isCompound_function_value , "Return whether or not this is a compound expression, and thus as such\nrequires brackets placed around it when it is printed. Examples include\nSum, Product and Power. For most other functions it is safe to leave\nthis as false." ); } { //::SireCAS::ExBase::isConstant typedef bool ( ::SireCAS::ExBase::*isConstant_function_type)( ) const; isConstant_function_type isConstant_function_value( &::SireCAS::ExBase::isConstant ); ExBase_exposer.def( "isConstant" , isConstant_function_value , "Return whether or not this is a constant expression (does not\ndepend on any symbols)" ); } { //::SireCAS::ExBase::isFunction typedef bool ( ::SireCAS::ExBase::*isFunction_function_type)( ::SireCAS::Symbol const & ) const; isFunction_function_type isFunction_function_value( &::SireCAS::ExBase::isFunction ); ExBase_exposer.def( "isFunction" , isFunction_function_value , ( bp::arg("arg0") ) , "Return whether or not this is a function of the passed Symbol" ); } ExBase_exposer.def( bp::self != bp::self ); ExBase_exposer.def( -bp::self ); { //::SireCAS::ExBase::operator= typedef ::SireCAS::ExBase & ( ::SireCAS::ExBase::*assign_function_type)( ::SireCAS::ExBase const & ) ; assign_function_type assign_function_value( &::SireCAS::ExBase::operator= ); ExBase_exposer.def( "assign" , assign_function_value , ( bp::arg("arg0") ) , bp::return_self< >() , "Assignment operator" ); } ExBase_exposer.def( bp::self == bp::self ); { //::SireCAS::ExBase::series typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*series_function_type)( ::SireCAS::Symbol const &,int ) const; series_function_type series_function_value( &::SireCAS::ExBase::series ); ExBase_exposer.def( "series" , series_function_value , ( bp::arg("symbol"), bp::arg("n") ) , "Return a series expansion of this expression with respect to\nsymbol, if possible, to order\nn. This is not guaranteed to work, and will return this expression\nunchanged if it doesnt work. If it is expanded, then a series\nwill be returned, together with an estimate of the error (e.g. O(x^2))" ); } { //::SireCAS::ExBase::simplify typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*simplify_function_type)( int ) const; simplify_function_type simplify_function_value( &::SireCAS::ExBase::simplify ); ExBase_exposer.def( "simplify" , simplify_function_value , ( bp::arg("options")=(int)(0) ) , "Try to simplify this expression. This will try to use known mathematical\nidentities to convert complex expressions down to more simple ones.\nIf SireCAS::UNSAFE_COMPLEX_SIMPLIFICATIONS is true, then identities\nthat are not safe for complex math are used, e.g. z = sin(arcsin(z))." ); } { //::SireCAS::ExBase::substitute typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*substitute_function_type)( ::SireCAS::Identities const & ) const; substitute_function_type substitute_function_value( &::SireCAS::ExBase::substitute ); ExBase_exposer.def( "substitute" , substitute_function_value , ( bp::arg("identities") ) , "Return an expression that has the identities in identities\nsubstituted into this expression" ); } { //::SireCAS::ExBase::symbols typedef ::SireCAS::Symbols ( ::SireCAS::ExBase::*symbols_function_type)( ) const; symbols_function_type symbols_function_value( &::SireCAS::ExBase::symbols ); ExBase_exposer.def( "symbols" , symbols_function_value , "Return the set of Symbols that appear in this ExBase" ); } { //::SireCAS::ExBase::toOpenMMString typedef ::QString ( ::SireCAS::ExBase::*toOpenMMString_function_type)( ) const; toOpenMMString_function_type toOpenMMString_function_value( &::SireCAS::ExBase::toOpenMMString ); ExBase_exposer.def( "toOpenMMString" , toOpenMMString_function_value , "Return a string representation of this object in the OpenMM syntax" ); } { //::SireCAS::ExBase::toString typedef ::QString ( ::SireCAS::ExBase::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireCAS::ExBase::toString ); ExBase_exposer.def( "toString" , toString_function_value , "Return a string representation of this object" ); } { //::SireCAS::ExBase::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireCAS::ExBase::typeName ); ExBase_exposer.def( "typeName" , typeName_function_value , "Return the name of this class type" ); } { //::SireCAS::ExBase::what typedef char const * ( ::SireCAS::ExBase::*what_function_type)( ) const; what_function_type what_function_value( &::SireCAS::ExBase::what ); ExBase_exposer.def( "what" , what_function_value , "Return the name of the type of this ExBase object" ); } ExBase_exposer.staticmethod( "typeName" ); ExBase_exposer.def( bp::self * bp::self ); ExBase_exposer.def( bp::self * bp::other< SireCAS::Expression >() ); ExBase_exposer.def( bp::self * bp::other< double >() ); ExBase_exposer.def( bp::other< double >() * bp::self ); ExBase_exposer.def( bp::self * bp::other< SireMaths::Complex >() ); ExBase_exposer.def( bp::self + bp::self ); ExBase_exposer.def( bp::self + bp::other< SireCAS::Expression >() ); ExBase_exposer.def( bp::self + bp::other< double >() ); ExBase_exposer.def( bp::other< double >() + bp::self ); ExBase_exposer.def( bp::self + bp::other< SireMaths::Complex >() ); ExBase_exposer.def( bp::self - bp::self ); ExBase_exposer.def( bp::self - bp::other< SireCAS::Expression >() ); ExBase_exposer.def( bp::self - bp::other< double >() ); ExBase_exposer.def( bp::other< double >() - bp::self ); ExBase_exposer.def( bp::self - bp::other< SireMaths::Complex >() ); ExBase_exposer.def( bp::self / bp::self ); ExBase_exposer.def( bp::self / bp::other< SireCAS::Expression >() ); ExBase_exposer.def( bp::self / bp::other< double >() ); ExBase_exposer.def( bp::other< double >() / bp::self ); ExBase_exposer.def( bp::self / bp::other< SireMaths::Complex >() ); ExBase_exposer.def( self + self ); ExBase_exposer.def( self - self ); ExBase_exposer.def( self * self ); ExBase_exposer.def( self / self ); ExBase_exposer.def( other<double>() + self ); ExBase_exposer.def( other<double>() - self ); ExBase_exposer.def( other<double>() * self ); ExBase_exposer.def( other<double>() / self ); ExBase_exposer.def( self + other<double>() ); ExBase_exposer.def( self - other<double>() ); ExBase_exposer.def( self * other<double>() ); ExBase_exposer.def( self / other<double>() ); ExBase_exposer.def( other<SireMaths::Complex>() + self ); ExBase_exposer.def( other<SireMaths::Complex>() - self ); ExBase_exposer.def( other<SireMaths::Complex>() * self ); ExBase_exposer.def( other<SireMaths::Complex>() / self ); ExBase_exposer.def( self + other<SireMaths::Complex>() ); ExBase_exposer.def( self - other<SireMaths::Complex>() ); ExBase_exposer.def( self * other<SireMaths::Complex>() ); ExBase_exposer.def( self / other<SireMaths::Complex>() ); ExBase_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::ExBase >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ExBase_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::ExBase >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ExBase_exposer.def( "__str__", &__str__< ::SireCAS::ExBase > ); ExBase_exposer.def( "__repr__", &__str__< ::SireCAS::ExBase > ); ExBase_exposer.def( "__hash__", &::SireCAS::ExBase::hash ); } }
void register_Specify_SegID__class(){ { //::SireID::Specify< SireMol::SegID > typedef bp::class_< SireID::Specify< SireMol::SegID >, bp::bases< SireMol::SegID, SireID::ID > > Specify_SegID__exposer_t; Specify_SegID__exposer_t Specify_SegID__exposer = Specify_SegID__exposer_t( "Specify_SegID_", bp::init< >() ); bp::scope Specify_SegID__scope( Specify_SegID__exposer ); Specify_SegID__exposer.def( bp::init< SireMol::SegID const &, qint32 >(( bp::arg("id"), bp::arg("i") )) ); Specify_SegID__exposer.def( bp::init< SireMol::SegID const &, qint32, qint32 >(( bp::arg("id"), bp::arg("i"), bp::arg("j") )) ); Specify_SegID__exposer.def( bp::init< SireID::Specify< SireMol::SegID > const & >(( bp::arg("other") )) ); { //::SireID::Specify< SireMol::SegID >::hash typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef ::uint ( ::SireID::Specify< SireMol::SegID >::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireID::Specify< SireMol::SegID >::hash ); Specify_SegID__exposer.def( "hash" , hash_function_value ); } { //::SireID::Specify< SireMol::SegID >::isNull typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef bool ( ::SireID::Specify< SireMol::SegID >::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireID::Specify< SireMol::SegID >::isNull ); Specify_SegID__exposer.def( "isNull" , isNull_function_value ); } { //::SireID::Specify< SireMol::SegID >::map typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef ::QList< SireMol::SegIdx > ( ::SireID::Specify< SireMol::SegID >::*map_function_type )( ::SireMol::MolInfo const & ) const; map_function_type map_function_value( &::SireID::Specify< SireMol::SegID >::map ); Specify_SegID__exposer.def( "map" , map_function_value , ( bp::arg("obj") ) ); } Specify_SegID__exposer.def( bp::self != bp::self ); Specify_SegID__exposer.def( bp::self != bp::other< SireID::ID >() ); { //::SireID::Specify< SireMol::SegID >::operator() typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__call___function_type )( int ) const; __call___function_type __call___function_value( &::SireID::Specify< SireMol::SegID >::operator() ); Specify_SegID__exposer.def( "__call__" , __call___function_value , ( bp::arg("i") ) ); } { //::SireID::Specify< SireMol::SegID >::operator() typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__call___function_type )( int,int ) const; __call___function_type __call___function_value( &::SireID::Specify< SireMol::SegID >::operator() ); Specify_SegID__exposer.def( "__call__" , __call___function_value , ( bp::arg("i"), bp::arg("j") ) ); } { //::SireID::Specify< SireMol::SegID >::operator= typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef ::SireID::Specify< SireMol::SegID > & ( ::SireID::Specify< SireMol::SegID >::*assign_function_type )( ::SireID::Specify< SireMol::SegID > const & ) ; assign_function_type assign_function_value( &::SireID::Specify< SireMol::SegID >::operator= ); Specify_SegID__exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } Specify_SegID__exposer.def( bp::self == bp::self ); Specify_SegID__exposer.def( bp::self == bp::other< SireID::ID >() ); { //::SireID::Specify< SireMol::SegID >::operator[] typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__getitem___function_type )( int ) const; __getitem___function_type __getitem___function_value( &::SireID::Specify< SireMol::SegID >::operator[] ); Specify_SegID__exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) ); } { //::SireID::Specify< SireMol::SegID >::toString typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef ::QString ( ::SireID::Specify< SireMol::SegID >::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireID::Specify< SireMol::SegID >::toString ); Specify_SegID__exposer.def( "toString" , toString_function_value ); } { //::SireID::Specify< SireMol::SegID >::typeName typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireID::Specify< SireMol::SegID >::typeName ); Specify_SegID__exposer.def( "typeName" , typeName_function_value ); } { //::SireID::Specify< SireMol::SegID >::what typedef SireID::Specify< SireMol::SegID > exported_class_t; typedef char const * ( ::SireID::Specify< SireMol::SegID >::*what_function_type )( ) const; what_function_type what_function_value( &::SireID::Specify< SireMol::SegID >::what ); Specify_SegID__exposer.def( "what" , what_function_value ); } Specify_SegID__exposer.staticmethod( "typeName" ); Specify_SegID__exposer.def( "__copy__", &__copy__); Specify_SegID__exposer.def( "__deepcopy__", &__copy__); Specify_SegID__exposer.def( "clone", &__copy__); Specify_SegID__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Specify<SireMol::SegID> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Specify_SegID__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Specify<SireMol::SegID> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Specify_SegID__exposer.def( "__str__", &__str__< ::SireID::Specify<SireMol::SegID> > ); Specify_SegID__exposer.def( "__repr__", &__str__< ::SireID::Specify<SireMol::SegID> > ); } }
void register_MultiVector_class(){ { //::SireMaths::MultiVector typedef bp::class_< SireMaths::MultiVector > MultiVector_exposer_t; MultiVector_exposer_t MultiVector_exposer = MultiVector_exposer_t( "MultiVector", "\nThis is a vectorised version of Vector, e.g. x, y, and z\nare held as MultiDouble objects, meaning that this is a\npacked vector of vectors\n\nAuthor: Christopher Woods\n", bp::init< >("") ); bp::scope MultiVector_scope( MultiVector_exposer ); MultiVector_exposer.def( bp::init< SireMaths::MultiDouble const & >(( bp::arg("value") ), "Copy constructor") ); MultiVector_exposer.def( bp::init< SireMaths::MultiDouble const &, SireMaths::MultiDouble const &, SireMaths::MultiDouble const & >(( bp::arg("x"), bp::arg("y"), bp::arg("z") ), "") ); MultiVector_exposer.def( bp::init< SireMaths::Vector const *, int >(( bp::arg("array"), bp::arg("size") ), "Construct from an array of Vectors. This array cannot be greater\nthan MultiDouble::size()") ); MultiVector_exposer.def( bp::init< QVector< SireMaths::Vector > const & >(( bp::arg("array") ), "Construct from an array of Vectors. This array cannot be greater\nthan MultiDouble::size()") ); MultiVector_exposer.def( bp::init< SireMaths::MultiVector const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMaths::MultiVector::angle typedef ::SireMaths::MultiDouble ( *angle_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); angle_function_type angle_function_value( &::SireMaths::MultiVector::angle ); MultiVector_exposer.def( "angle" , angle_function_value , ( bp::arg("v0"), bp::arg("v1") ) , "Return the angle between vectors v0 and v1 - this is the smallest\nangle, and will always lie between 0 and 180 degrees" ); } { //::SireMaths::MultiVector::angle typedef ::SireMaths::MultiDouble ( *angle_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); angle_function_type angle_function_value( &::SireMaths::MultiVector::angle ); MultiVector_exposer.def( "angle" , angle_function_value , ( bp::arg("v0"), bp::arg("v1"), bp::arg("v2") ) , "Return the angle between v0-v1-v2 (treating the vectors as points in space)" ); } { //::SireMaths::MultiVector::at typedef ::SireMaths::Vector ( ::SireMaths::MultiVector::*at_function_type)( int ) const; at_function_type at_function_value( &::SireMaths::MultiVector::at ); MultiVector_exposer.def( "at" , at_function_value , ( bp::arg("i") ) , "Access the ith vector in the MultiVector" ); } { //::SireMaths::MultiVector::b typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*b_function_type)( ) const; b_function_type b_function_value( &::SireMaths::MultiVector::b ); MultiVector_exposer.def( "b" , b_function_value , "Return the components via rgb (limited between 0 and 1)" ); } { //::SireMaths::MultiVector::bearing typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearing_function_type)( ) const; bearing_function_type bearing_function_value( &::SireMaths::MultiVector::bearing ); MultiVector_exposer.def( "bearing" , bearing_function_value , "Return the bearing of this vector against (0,1,0) (north) on the xy plane" ); } { //::SireMaths::MultiVector::bearingXY typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearingXY_function_type)( ::SireMaths::MultiVector const & ) const; bearingXY_function_type bearingXY_function_value( &::SireMaths::MultiVector::bearingXY ); MultiVector_exposer.def( "bearingXY" , bearingXY_function_value , ( bp::arg("v") ) , "Return the bearing of this vector against v on the xy plane" ); } { //::SireMaths::MultiVector::bearingXZ typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearingXZ_function_type)( ::SireMaths::MultiVector const & ) const; bearingXZ_function_type bearingXZ_function_value( &::SireMaths::MultiVector::bearingXZ ); MultiVector_exposer.def( "bearingXZ" , bearingXZ_function_value , ( bp::arg("v") ) , "Return the bearing of this vector against v on the xz plane" ); } { //::SireMaths::MultiVector::bearingYZ typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearingYZ_function_type)( ::SireMaths::MultiVector const & ) const; bearingYZ_function_type bearingYZ_function_value( &::SireMaths::MultiVector::bearingYZ ); MultiVector_exposer.def( "bearingYZ" , bearingYZ_function_value , ( bp::arg("v") ) , "Return the bearing of this vector against v on the yz plane" ); } { //::SireMaths::MultiVector::count typedef int ( *count_function_type )( ); count_function_type count_function_value( &::SireMaths::MultiVector::count ); MultiVector_exposer.def( "count" , count_function_value , "Return the number of vectors in this MultiVector" ); } { //::SireMaths::MultiVector::cross typedef ::SireMaths::MultiVector ( *cross_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); cross_function_type cross_function_value( &::SireMaths::MultiVector::cross ); MultiVector_exposer.def( "cross" , cross_function_value , ( bp::arg("v0"), bp::arg("v1") ) , "Return the cross product of v0 and v1" ); } { //::SireMaths::MultiVector::dihedral typedef ::SireMaths::MultiDouble ( *dihedral_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const &,::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); dihedral_function_type dihedral_function_value( &::SireMaths::MultiVector::dihedral ); MultiVector_exposer.def( "dihedral" , dihedral_function_value , ( bp::arg("v0"), bp::arg("v1"), bp::arg("v2"), bp::arg("v3") ) , "Return the dihedral angle between v0-v1-v2-v3 (treating the vectors as points)" ); } { //::SireMaths::MultiVector::direction typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*direction_function_type)( ) const; direction_function_type direction_function_value( &::SireMaths::MultiVector::direction ); MultiVector_exposer.def( "direction" , direction_function_value , "Return the unit vector pointing in the direction of this vector" ); } { //::SireMaths::MultiVector::distance typedef ::SireMaths::MultiDouble ( *distance_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); distance_function_type distance_function_value( &::SireMaths::MultiVector::distance ); MultiVector_exposer.def( "distance" , distance_function_value , ( bp::arg("v1"), bp::arg("v2") ) , "Return the distance between two vectors" ); } { //::SireMaths::MultiVector::distance2 typedef ::SireMaths::MultiDouble ( *distance2_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); distance2_function_type distance2_function_value( &::SireMaths::MultiVector::distance2 ); MultiVector_exposer.def( "distance2" , distance2_function_value , ( bp::arg("v1"), bp::arg("v2") ) , "Return the distance squared between two vectors" ); } { //::SireMaths::MultiVector::dot typedef ::SireMaths::MultiDouble ( *dot_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); dot_function_type dot_function_value( &::SireMaths::MultiVector::dot ); MultiVector_exposer.def( "dot" , dot_function_value , ( bp::arg("v0"), bp::arg("v1") ) , "Return the dot product of v0 and v1" ); } { //::SireMaths::MultiVector::fromArray typedef ::QVector< SireMaths::MultiVector > ( *fromArray_function_type )( ::SireMaths::Vector const *,int ); fromArray_function_type fromArray_function_value( &::SireMaths::MultiVector::fromArray ); MultiVector_exposer.def( "fromArray" , fromArray_function_value , ( bp::arg("array"), bp::arg("size") ) , "Convert the passed array of vectors into an array of MultiVectors" ); } { //::SireMaths::MultiVector::fromArray typedef ::QVector< SireMaths::MultiVector > ( *fromArray_function_type )( ::QVector< SireMaths::Vector > const & ); fromArray_function_type fromArray_function_value( &::SireMaths::MultiVector::fromArray ); MultiVector_exposer.def( "fromArray" , fromArray_function_value , ( bp::arg("array") ) , "Convert the passed array of vectors into an array of MultiVectors" ); } { //::SireMaths::MultiVector::g typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*g_function_type)( ) const; g_function_type g_function_value( &::SireMaths::MultiVector::g ); MultiVector_exposer.def( "g" , g_function_value , "Return the components via rgb (limited between 0 and 1)" ); } { //::SireMaths::MultiVector::generate typedef ::SireMaths::MultiVector ( *generate_function_type )( ::SireMaths::MultiDouble const &,::SireMaths::MultiVector const &,::SireMaths::MultiDouble const &,::SireMaths::MultiVector const &,::SireMaths::MultiDouble const &,::SireMaths::MultiVector const & ); generate_function_type generate_function_value( &::SireMaths::MultiVector::generate ); MultiVector_exposer.def( "generate" , generate_function_value , ( bp::arg("dst"), bp::arg("v1"), bp::arg("ang"), bp::arg("v2"), bp::arg("dih"), bp::arg("v3") ) , "Generate a vector, v0, that has distance dst v0-v1, angle ang v0-v1-v2,\nand dihedral dih v0-v1-v2-v3" ); } { //::SireMaths::MultiVector::getitem typedef ::SireMaths::Vector ( ::SireMaths::MultiVector::*getitem_function_type)( int ) const; getitem_function_type getitem_function_value( &::SireMaths::MultiVector::getitem ); MultiVector_exposer.def( "getitem" , getitem_function_value , ( bp::arg("i") ) , "Access the ith vector in the MultiVector" ); } { //::SireMaths::MultiVector::invDistance typedef ::SireMaths::MultiDouble ( *invDistance_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); invDistance_function_type invDistance_function_value( &::SireMaths::MultiVector::invDistance ); MultiVector_exposer.def( "invDistance" , invDistance_function_value , ( bp::arg("v1"), bp::arg("v2") ) , "Return the 1 distance between two vectors" ); } { //::SireMaths::MultiVector::invDistance2 typedef ::SireMaths::MultiDouble ( *invDistance2_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & ); invDistance2_function_type invDistance2_function_value( &::SireMaths::MultiVector::invDistance2 ); MultiVector_exposer.def( "invDistance2" , invDistance2_function_value , ( bp::arg("v1"), bp::arg("v2") ) , "Return 1 distance2 between two vectors" ); } { //::SireMaths::MultiVector::invLength typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*invLength_function_type)( ) const; invLength_function_type invLength_function_value( &::SireMaths::MultiVector::invLength ); MultiVector_exposer.def( "invLength" , invLength_function_value , "" ); } { //::SireMaths::MultiVector::invLength2 typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*invLength2_function_type)( ) const; invLength2_function_type invLength2_function_value( &::SireMaths::MultiVector::invLength2 ); MultiVector_exposer.def( "invLength2" , invLength2_function_value , "Return the inverse length squared" ); } { //::SireMaths::MultiVector::length typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*length_function_type)( ) const; length_function_type length_function_value( &::SireMaths::MultiVector::length ); MultiVector_exposer.def( "length" , length_function_value , "" ); } { //::SireMaths::MultiVector::length2 typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*length2_function_type)( ) const; length2_function_type length2_function_value( &::SireMaths::MultiVector::length2 ); MultiVector_exposer.def( "length2" , length2_function_value , "" ); } { //::SireMaths::MultiVector::magnitude typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*magnitude_function_type)( ) const; magnitude_function_type magnitude_function_value( &::SireMaths::MultiVector::magnitude ); MultiVector_exposer.def( "magnitude" , magnitude_function_value , "Return the length of this vector" ); } { //::SireMaths::MultiVector::manhattanLength typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*manhattanLength_function_type)( ) const; manhattanLength_function_type manhattanLength_function_value( &::SireMaths::MultiVector::manhattanLength ); MultiVector_exposer.def( "manhattanLength" , manhattanLength_function_value , "Return the manhattan length of the vector" ); } { //::SireMaths::MultiVector::max typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*max_function_type)( ::SireMaths::MultiVector const & ) const; max_function_type max_function_value( &::SireMaths::MultiVector::max ); MultiVector_exposer.def( "max" , max_function_value , ( bp::arg("other") ) , "Return a vector that has the maximum xyz components out of this\nand other" ); } { //::SireMaths::MultiVector::min typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*min_function_type)( ::SireMaths::MultiVector const & ) const; min_function_type min_function_value( &::SireMaths::MultiVector::min ); MultiVector_exposer.def( "min" , min_function_value , ( bp::arg("other") ) , "Return a vector that has the minimum components" ); } { //::SireMaths::MultiVector::normalise typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*normalise_function_type)( ) const; normalise_function_type normalise_function_value( &::SireMaths::MultiVector::normalise ); MultiVector_exposer.def( "normalise" , normalise_function_value , "Return a normalised form of the vector" ); } MultiVector_exposer.def( bp::self != bp::self ); MultiVector_exposer.def( -bp::self ); { //::SireMaths::MultiVector::operator= typedef ::SireMaths::MultiVector & ( ::SireMaths::MultiVector::*assign_function_type)( ::SireMaths::MultiVector const & ) ; assign_function_type assign_function_value( &::SireMaths::MultiVector::operator= ); MultiVector_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } MultiVector_exposer.def( bp::self == bp::self ); { //::SireMaths::MultiVector::operator[] typedef ::SireMaths::Vector ( ::SireMaths::MultiVector::*__getitem___function_type)( int ) const; __getitem___function_type __getitem___function_value( &::SireMaths::MultiVector::operator[] ); MultiVector_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , "" ); } { //::SireMaths::MultiVector::quickSet typedef void ( ::SireMaths::MultiVector::*quickSet_function_type)( int,::SireMaths::Vector const & ) ; quickSet_function_type quickSet_function_value( &::SireMaths::MultiVector::quickSet ); MultiVector_exposer.def( "quickSet" , quickSet_function_value , ( bp::arg("i"), bp::arg("val") ) , "Quickly set the values of the vector, without checking the index is valid" ); } { //::SireMaths::MultiVector::r typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*r_function_type)( ) const; r_function_type r_function_value( &::SireMaths::MultiVector::r ); MultiVector_exposer.def( "r" , r_function_value , "Return the components via rgb (limited between 0 and 1)" ); } { //::SireMaths::MultiVector::set typedef void ( ::SireMaths::MultiVector::*set_function_type)( ::SireMaths::MultiDouble const &,::SireMaths::MultiDouble const &,::SireMaths::MultiDouble const & ) ; set_function_type set_function_value( &::SireMaths::MultiVector::set ); MultiVector_exposer.def( "set" , set_function_value , ( bp::arg("x"), bp::arg("y"), bp::arg("z") ) , "Set individual values of the vector" ); } { //::SireMaths::MultiVector::set typedef void ( ::SireMaths::MultiVector::*set_function_type)( int,::SireMaths::Vector const & ) ; set_function_type set_function_value( &::SireMaths::MultiVector::set ); MultiVector_exposer.def( "set" , set_function_value , ( bp::arg("i"), bp::arg("val") ) , "Set individual values of the vector" ); } { //::SireMaths::MultiVector::setB typedef void ( ::SireMaths::MultiVector::*setB_function_type)( ::SireMaths::MultiDouble const & ) ; setB_function_type setB_function_value( &::SireMaths::MultiVector::setB ); MultiVector_exposer.def( "setB" , setB_function_value , ( bp::arg("val") ) , "Set individual values of the vector" ); } { //::SireMaths::MultiVector::setG typedef void ( ::SireMaths::MultiVector::*setG_function_type)( ::SireMaths::MultiDouble const & ) ; setG_function_type setG_function_value( &::SireMaths::MultiVector::setG ); MultiVector_exposer.def( "setG" , setG_function_value , ( bp::arg("val") ) , "Set individual values of the vector" ); } { //::SireMaths::MultiVector::setMax typedef void ( ::SireMaths::MultiVector::*setMax_function_type)( ::SireMaths::MultiVector const & ) ; setMax_function_type setMax_function_value( &::SireMaths::MultiVector::setMax ); MultiVector_exposer.def( "setMax" , setMax_function_value , ( bp::arg("other") ) , "Set this Vector so that it has the maximum xyz components out of\nthis and other (e.g. this->x = max(this->x(),other.x() etc.)" ); } { //::SireMaths::MultiVector::setMin typedef void ( ::SireMaths::MultiVector::*setMin_function_type)( ::SireMaths::MultiVector const & ) ; setMin_function_type setMin_function_value( &::SireMaths::MultiVector::setMin ); MultiVector_exposer.def( "setMin" , setMin_function_value , ( bp::arg("other") ) , "Set this Vector so that it has the minimum xyz components" ); } { //::SireMaths::MultiVector::setR typedef void ( ::SireMaths::MultiVector::*setR_function_type)( ::SireMaths::MultiDouble const & ) ; setR_function_type setR_function_value( &::SireMaths::MultiVector::setR ); MultiVector_exposer.def( "setR" , setR_function_value , ( bp::arg("val") ) , "Set individual values of the vector" ); } { //::SireMaths::MultiVector::setX typedef void ( ::SireMaths::MultiVector::*setX_function_type)( ::SireMaths::MultiDouble const & ) ; setX_function_type setX_function_value( &::SireMaths::MultiVector::setX ); MultiVector_exposer.def( "setX" , setX_function_value , ( bp::arg("val") ) , "Set individual values of the vector" ); } { //::SireMaths::MultiVector::setY typedef void ( ::SireMaths::MultiVector::*setY_function_type)( ::SireMaths::MultiDouble const & ) ; setY_function_type setY_function_value( &::SireMaths::MultiVector::setY ); MultiVector_exposer.def( "setY" , setY_function_value , ( bp::arg("val") ) , "Set individual values of the vector" ); } { //::SireMaths::MultiVector::setZ typedef void ( ::SireMaths::MultiVector::*setZ_function_type)( ::SireMaths::MultiDouble const & ) ; setZ_function_type setZ_function_value( &::SireMaths::MultiVector::setZ ); MultiVector_exposer.def( "setZ" , setZ_function_value , ( bp::arg("val") ) , "Set individual values of the vector" ); } { //::SireMaths::MultiVector::size typedef int ( *size_function_type )( ); size_function_type size_function_value( &::SireMaths::MultiVector::size ); MultiVector_exposer.def( "size" , size_function_value , "Return the number of vectors in this MultiVector" ); } { //::SireMaths::MultiVector::swap typedef void ( *swap_function_type )( ::SireMaths::MultiVector &,int,::SireMaths::MultiVector &,int ); swap_function_type swap_function_value( &::SireMaths::MultiVector::swap ); MultiVector_exposer.def( "swap" , swap_function_value , ( bp::arg("v0"), bp::arg("idx0"), bp::arg("v1"), bp::arg("idx1") ) , "Swap the values of the value at index idx0 in f0 with the value at index idx in f1" ); } { //::SireMaths::MultiVector::toString typedef ::QString ( ::SireMaths::MultiVector::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMaths::MultiVector::toString ); MultiVector_exposer.def( "toString" , toString_function_value , "Return a QString representation of the vector" ); } { //::SireMaths::MultiVector::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMaths::MultiVector::typeName ); MultiVector_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMaths::MultiVector::what typedef char const * ( ::SireMaths::MultiVector::*what_function_type)( ) const; what_function_type what_function_value( &::SireMaths::MultiVector::what ); MultiVector_exposer.def( "what" , what_function_value , "" ); } { //::SireMaths::MultiVector::x typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*x_function_type)( ) const; x_function_type x_function_value( &::SireMaths::MultiVector::x ); MultiVector_exposer.def( "x" , x_function_value , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireMaths::MultiVector::y typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*y_function_type)( ) const; y_function_type y_function_value( &::SireMaths::MultiVector::y ); MultiVector_exposer.def( "y" , y_function_value , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireMaths::MultiVector::z typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*z_function_type)( ) const; z_function_type z_function_value( &::SireMaths::MultiVector::z ); MultiVector_exposer.def( "z" , z_function_value , bp::return_value_policy< bp::copy_const_reference >() , "" ); } MultiVector_exposer.staticmethod( "angle" ); MultiVector_exposer.staticmethod( "count" ); MultiVector_exposer.staticmethod( "cross" ); MultiVector_exposer.staticmethod( "dihedral" ); MultiVector_exposer.staticmethod( "distance" ); MultiVector_exposer.staticmethod( "distance2" ); MultiVector_exposer.staticmethod( "dot" ); MultiVector_exposer.staticmethod( "fromArray" ); MultiVector_exposer.staticmethod( "generate" ); MultiVector_exposer.staticmethod( "invDistance" ); MultiVector_exposer.staticmethod( "invDistance2" ); MultiVector_exposer.staticmethod( "size" ); MultiVector_exposer.staticmethod( "swap" ); MultiVector_exposer.staticmethod( "typeName" ); MultiVector_exposer.def( bp::self * bp::other< SireMaths::MultiDouble >() ); MultiVector_exposer.def( bp::self * bp::other< SireMaths::MultiQuaternion >() ); MultiVector_exposer.def( bp::self + bp::self ); MultiVector_exposer.def( bp::self - bp::self ); MultiVector_exposer.def( bp::self / bp::other< SireMaths::MultiDouble >() ); MultiVector_exposer.def( "__copy__", &__copy__); MultiVector_exposer.def( "__deepcopy__", &__copy__); MultiVector_exposer.def( "clone", &__copy__); MultiVector_exposer.def( "__str__", &__str__< ::SireMaths::MultiVector > ); MultiVector_exposer.def( "__repr__", &__str__< ::SireMaths::MultiVector > ); MultiVector_exposer.def( "__len__", &__len_size< ::SireMaths::MultiVector > ); MultiVector_exposer.def( "__getitem__", &::SireMaths::MultiVector::getitem ); } }
void register_AngleComponent_class(){ { //::SireMM::AngleComponent typedef bp::class_< SireMM::AngleComponent, bp::bases< SireFF::FFComponent, SireCAS::Symbol, SireCAS::ExBase > > AngleComponent_exposer_t; AngleComponent_exposer_t AngleComponent_exposer = AngleComponent_exposer_t( "AngleComponent", "This class represents a Angle component of a forcefield", bp::init< bp::optional< SireFF::FFName const & > >(( bp::arg("ffname")=SireFF::FFName() ), "Constructor") ); bp::scope AngleComponent_scope( AngleComponent_exposer ); AngleComponent_exposer.def( bp::init< SireCAS::Symbol const & >(( bp::arg("symbol") ), "Construct from a symbol\nThrow: SireError::incompatible_error\n") ); AngleComponent_exposer.def( bp::init< SireMM::AngleComponent const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMM::AngleComponent::changeEnergy typedef void ( ::SireMM::AngleComponent::*changeEnergy_function_type)( ::SireFF::FF &,::SireMM::AngleEnergy const & ) const; changeEnergy_function_type changeEnergy_function_value( &::SireMM::AngleComponent::changeEnergy ); AngleComponent_exposer.def( "changeEnergy" , changeEnergy_function_value , ( bp::arg("ff"), bp::arg("angnrg") ) , "Change the component of the energy in the forcefield ff\nby delta" ); } { //::SireMM::AngleComponent::setEnergy typedef void ( ::SireMM::AngleComponent::*setEnergy_function_type)( ::SireFF::FF &,::SireMM::AngleEnergy const & ) const; setEnergy_function_type setEnergy_function_value( &::SireMM::AngleComponent::setEnergy ); AngleComponent_exposer.def( "setEnergy" , setEnergy_function_value , ( bp::arg("ff"), bp::arg("angnrg") ) , "Set the component of the energy in the forcefield ff\nto be equal to the passed energy" ); } { //::SireMM::AngleComponent::symbols typedef ::SireCAS::Symbols ( ::SireMM::AngleComponent::*symbols_function_type)( ) const; symbols_function_type symbols_function_value( &::SireMM::AngleComponent::symbols ); AngleComponent_exposer.def( "symbols" , symbols_function_value , "" ); } { //::SireMM::AngleComponent::total typedef ::SireMM::AngleComponent const & ( ::SireMM::AngleComponent::*total_function_type)( ) const; total_function_type total_function_value( &::SireMM::AngleComponent::total ); AngleComponent_exposer.def( "total" , total_function_value , bp::return_value_policy<bp::clone_const_reference>() , "" ); } { //::SireMM::AngleComponent::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::AngleComponent::typeName ); AngleComponent_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMM::AngleComponent::what typedef char const * ( ::SireMM::AngleComponent::*what_function_type)( ) const; what_function_type what_function_value( &::SireMM::AngleComponent::what ); AngleComponent_exposer.def( "what" , what_function_value , "" ); } AngleComponent_exposer.staticmethod( "typeName" ); AngleComponent_exposer.def( "__copy__", &__copy__); AngleComponent_exposer.def( "__deepcopy__", &__copy__); AngleComponent_exposer.def( "clone", &__copy__); AngleComponent_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::AngleComponent >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); AngleComponent_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::AngleComponent >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); AngleComponent_exposer.def( "__str__", &__str__< ::SireMM::AngleComponent > ); AngleComponent_exposer.def( "__repr__", &__str__< ::SireMM::AngleComponent > ); AngleComponent_exposer.def( "__hash__", &::SireMM::AngleComponent::hash ); } }
void register_Expression_class(){ { //::SireCAS::Expression typedef bp::class_< SireCAS::Expression > Expression_exposer_t; Expression_exposer_t Expression_exposer = Expression_exposer_t( "Expression", bp::init< >() ); bp::scope Expression_scope( Expression_exposer ); Expression_exposer.def( bp::init< int >(( bp::arg("constant") )) ); Expression_exposer.def( bp::init< SireMaths::Rational const & >(( bp::arg("constant") )) ); Expression_exposer.def( bp::init< double >(( bp::arg("constant") )) ); Expression_exposer.def( bp::init< SireMaths::Complex const & >(( bp::arg("constant") )) ); Expression_exposer.def( bp::init< SireCAS::ExpressionBase const & >(( bp::arg("base") )) ); Expression_exposer.def( bp::init< SireCAS::ExBase const & >(( bp::arg("base") )) ); Expression_exposer.def( bp::init< SireCAS::Expression const & >(( bp::arg("other") )) ); { //::SireCAS::Expression::add typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireCAS::Expression const & ) const; add_function_type add_function_value( &::SireCAS::Expression::add ); Expression_exposer.def( "add" , add_function_value , ( bp::arg("ex") ) ); } { //::SireCAS::Expression::add typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( double ) const; add_function_type add_function_value( &::SireCAS::Expression::add ); Expression_exposer.def( "add" , add_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::add typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireMaths::Complex const & ) const; add_function_type add_function_value( &::SireCAS::Expression::add ); Expression_exposer.def( "add" , add_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::base typedef ::SireCAS::ExpressionBase const & ( ::SireCAS::Expression::*base_function_type )( ) const; base_function_type base_function_value( &::SireCAS::Expression::base ); Expression_exposer.def( "base" , base_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireCAS::Expression::children typedef ::SireCAS::Expressions ( ::SireCAS::Expression::*children_function_type )( ) const; children_function_type children_function_value( &::SireCAS::Expression::children ); Expression_exposer.def( "children" , children_function_value ); } { //::SireCAS::Expression::conjugate typedef ::SireCAS::Expression ( ::SireCAS::Expression::*conjugate_function_type )( ) const; conjugate_function_type conjugate_function_value( &::SireCAS::Expression::conjugate ); Expression_exposer.def( "conjugate" , conjugate_function_value ); } { //::SireCAS::Expression::cubed typedef ::SireCAS::Expression ( ::SireCAS::Expression::*cubed_function_type )( ) const; cubed_function_type cubed_function_value( &::SireCAS::Expression::cubed ); Expression_exposer.def( "cubed" , cubed_function_value ); } { //::SireCAS::Expression::diff typedef ::SireCAS::Expression ( ::SireCAS::Expression::*diff_function_type )( ::SireCAS::Symbol const &,int ) const; diff_function_type diff_function_value( &::SireCAS::Expression::diff ); Expression_exposer.def( "diff" , diff_function_value , ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) ); } { //::SireCAS::Expression::differentiate typedef ::SireCAS::Expression ( ::SireCAS::Expression::*differentiate_function_type )( ::SireCAS::Symbol const &,int ) const; differentiate_function_type differentiate_function_value( &::SireCAS::Expression::differentiate ); Expression_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) ); } { //::SireCAS::Expression::divide typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireCAS::Expression const & ) const; divide_function_type divide_function_value( &::SireCAS::Expression::divide ); Expression_exposer.def( "divide" , divide_function_value , ( bp::arg("ex") ) ); } { //::SireCAS::Expression::divide typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( double ) const; divide_function_type divide_function_value( &::SireCAS::Expression::divide ); Expression_exposer.def( "divide" , divide_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::divide typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireMaths::Complex const & ) const; divide_function_type divide_function_value( &::SireCAS::Expression::divide ); Expression_exposer.def( "divide" , divide_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::evaluate typedef double ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::Values const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate ); Expression_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::Expression::evaluate typedef ::SireMaths::Complex ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate ); Expression_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::Expression::expand typedef ::QList< SireCAS::Factor > ( ::SireCAS::Expression::*expand_function_type )( ::SireCAS::Symbol const & ) const; expand_function_type expand_function_value( &::SireCAS::Expression::expand ); Expression_exposer.def( "expand" , expand_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Expression::factor typedef double ( ::SireCAS::Expression::*factor_function_type )( ) const; factor_function_type factor_function_value( &::SireCAS::Expression::factor ); Expression_exposer.def( "factor" , factor_function_value ); } { //::SireCAS::Expression::functions typedef ::SireCAS::Functions ( ::SireCAS::Expression::*functions_function_type )( ) const; functions_function_type functions_function_value( &::SireCAS::Expression::functions ); Expression_exposer.def( "functions" , functions_function_value ); } { //::SireCAS::Expression::hash typedef ::uint ( ::SireCAS::Expression::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireCAS::Expression::hash ); Expression_exposer.def( "hash" , hash_function_value ); } { //::SireCAS::Expression::integ typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integ_function_type )( ::SireCAS::Symbol const & ) const; integ_function_type integ_function_value( &::SireCAS::Expression::integ ); Expression_exposer.def( "integ" , integ_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Expression::integrate typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integrate_function_type )( ::SireCAS::Symbol const & ) const; integrate_function_type integrate_function_value( &::SireCAS::Expression::integrate ); Expression_exposer.def( "integrate" , integrate_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Expression::invert typedef ::SireCAS::Expression ( ::SireCAS::Expression::*invert_function_type )( ) const; invert_function_type invert_function_value( &::SireCAS::Expression::invert ); Expression_exposer.def( "invert" , invert_function_value ); } { //::SireCAS::Expression::isComplex typedef bool ( ::SireCAS::Expression::*isComplex_function_type )( ) const; isComplex_function_type isComplex_function_value( &::SireCAS::Expression::isComplex ); Expression_exposer.def( "isComplex" , isComplex_function_value ); } { //::SireCAS::Expression::isCompound typedef bool ( ::SireCAS::Expression::*isCompound_function_type )( ) const; isCompound_function_type isCompound_function_value( &::SireCAS::Expression::isCompound ); Expression_exposer.def( "isCompound" , isCompound_function_value ); } { //::SireCAS::Expression::isConstant typedef bool ( ::SireCAS::Expression::*isConstant_function_type )( ) const; isConstant_function_type isConstant_function_value( &::SireCAS::Expression::isConstant ); Expression_exposer.def( "isConstant" , isConstant_function_value ); } { //::SireCAS::Expression::isFunction typedef bool ( ::SireCAS::Expression::*isFunction_function_type )( ::SireCAS::Symbol const & ) const; isFunction_function_type isFunction_function_value( &::SireCAS::Expression::isFunction ); Expression_exposer.def( "isFunction" , isFunction_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Expression::isZero typedef bool ( ::SireCAS::Expression::*isZero_function_type )( ) const; isZero_function_type isZero_function_value( &::SireCAS::Expression::isZero ); Expression_exposer.def( "isZero" , isZero_function_value ); } { //::SireCAS::Expression::multiply typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireCAS::Expression const & ) const; multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply ); Expression_exposer.def( "multiply" , multiply_function_value , ( bp::arg("ex") ) ); } { //::SireCAS::Expression::multiply typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( double ) const; multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply ); Expression_exposer.def( "multiply" , multiply_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::multiply typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireMaths::Complex const & ) const; multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply ); Expression_exposer.def( "multiply" , multiply_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::negate typedef ::SireCAS::Expression ( ::SireCAS::Expression::*negate_function_type )( ) const; negate_function_type negate_function_value( &::SireCAS::Expression::negate ); Expression_exposer.def( "negate" , negate_function_value ); } Expression_exposer.def( bp::self != bp::self ); { //::SireCAS::Expression::operator() typedef double ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::Values const & ) const; __call___function_type __call___function_value( &::SireCAS::Expression::operator() ); Expression_exposer.def( "__call__" , __call___function_value , ( bp::arg("values") ) ); } { //::SireCAS::Expression::operator() typedef ::SireMaths::Complex ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::ComplexValues const & ) const; __call___function_type __call___function_value( &::SireCAS::Expression::operator() ); Expression_exposer.def( "__call__" , __call___function_value , ( bp::arg("values") ) ); } Expression_exposer.def( -bp::self ); { //::SireCAS::Expression::operator= typedef ::SireCAS::Expression & ( ::SireCAS::Expression::*assign_function_type )( ::SireCAS::Expression const & ) ; assign_function_type assign_function_value( &::SireCAS::Expression::operator= ); Expression_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } Expression_exposer.def( bp::self == bp::self ); { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( int ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Rational const & ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( double ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Complex const & ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireCAS::Expression const & ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::root typedef ::SireCAS::Expression ( ::SireCAS::Expression::*root_function_type )( int ) const; root_function_type root_function_value( &::SireCAS::Expression::root ); Expression_exposer.def( "root" , root_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::series typedef ::SireCAS::Expression ( ::SireCAS::Expression::*series_function_type )( ::SireCAS::Symbol const &,int ) const; series_function_type series_function_value( &::SireCAS::Expression::series ); Expression_exposer.def( "series" , series_function_value , ( bp::arg("symbol"), bp::arg("order") ) ); } { //::SireCAS::Expression::simplify typedef ::SireCAS::Expression ( ::SireCAS::Expression::*simplify_function_type )( int ) const; simplify_function_type simplify_function_value( &::SireCAS::Expression::simplify ); Expression_exposer.def( "simplify" , simplify_function_value , ( bp::arg("options")=(int)(0) ) ); } { //::SireCAS::Expression::squared typedef ::SireCAS::Expression ( ::SireCAS::Expression::*squared_function_type )( ) const; squared_function_type squared_function_value( &::SireCAS::Expression::squared ); Expression_exposer.def( "squared" , squared_function_value ); } { //::SireCAS::Expression::substitute typedef ::SireCAS::Expression ( ::SireCAS::Expression::*substitute_function_type )( ::SireCAS::Identities const & ) const; substitute_function_type substitute_function_value( &::SireCAS::Expression::substitute ); Expression_exposer.def( "substitute" , substitute_function_value , ( bp::arg("identities") ) ); } { //::SireCAS::Expression::subtract typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireCAS::Expression const & ) const; subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract ); Expression_exposer.def( "subtract" , subtract_function_value , ( bp::arg("ex") ) ); } { //::SireCAS::Expression::subtract typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( double ) const; subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract ); Expression_exposer.def( "subtract" , subtract_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::subtract typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireMaths::Complex const & ) const; subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract ); Expression_exposer.def( "subtract" , subtract_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::symbols typedef ::SireCAS::Symbols ( ::SireCAS::Expression::*symbols_function_type )( ) const; symbols_function_type symbols_function_value( &::SireCAS::Expression::symbols ); Expression_exposer.def( "symbols" , symbols_function_value ); } { //::SireCAS::Expression::toString typedef ::QString ( ::SireCAS::Expression::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireCAS::Expression::toString ); Expression_exposer.def( "toString" , toString_function_value ); } { //::SireCAS::Expression::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireCAS::Expression::typeName ); Expression_exposer.def( "typeName" , typeName_function_value ); } { //::SireCAS::Expression::what typedef char const * ( ::SireCAS::Expression::*what_function_type )( ) const; what_function_type what_function_value( &::SireCAS::Expression::what ); Expression_exposer.def( "what" , what_function_value ); } Expression_exposer.staticmethod( "typeName" ); Expression_exposer.def( bp::self * bp::other< SireMaths::Complex >() ); Expression_exposer.def( bp::other< SireMaths::Complex >() * bp::self ); Expression_exposer.def( bp::self * bp::other< double >() ); Expression_exposer.def( bp::other< double >() * bp::self ); Expression_exposer.def( bp::self * bp::self ); Expression_exposer.def( bp::self * bp::other< SireCAS::ExBase >() ); Expression_exposer.def( bp::other< SireMaths::Complex >() + bp::self ); Expression_exposer.def( bp::self + bp::other< SireMaths::Complex >() ); Expression_exposer.def( bp::other< double >() + bp::self ); Expression_exposer.def( bp::self + bp::other< double >() ); Expression_exposer.def( bp::self + bp::self ); Expression_exposer.def( bp::self + bp::other< SireCAS::ExBase >() ); Expression_exposer.def( bp::other< double >() - bp::self ); Expression_exposer.def( bp::self - bp::other< double >() ); Expression_exposer.def( bp::self - bp::self ); Expression_exposer.def( bp::self - bp::other< SireCAS::ExBase >() ); Expression_exposer.def( bp::other< SireMaths::Complex >() / bp::self ); Expression_exposer.def( bp::self / bp::other< SireMaths::Complex >() ); Expression_exposer.def( bp::other< double >() / bp::self ); Expression_exposer.def( bp::self / bp::other< double >() ); Expression_exposer.def( bp::self / bp::self ); Expression_exposer.def( bp::self / bp::other< SireCAS::ExBase >() ); Expression_exposer.def( self + self ); Expression_exposer.def( self - self ); Expression_exposer.def( self * self ); Expression_exposer.def( self / self ); Expression_exposer.def( other<double>() + self ); Expression_exposer.def( other<double>() - self ); Expression_exposer.def( other<double>() * self ); Expression_exposer.def( other<double>() / self ); Expression_exposer.def( self + other<double>() ); Expression_exposer.def( self - other<double>() ); Expression_exposer.def( self * other<double>() ); Expression_exposer.def( self / other<double>() ); Expression_exposer.def( other<SireMaths::Complex>() + self ); Expression_exposer.def( other<SireMaths::Complex>() - self ); Expression_exposer.def( other<SireMaths::Complex>() * self ); Expression_exposer.def( other<SireMaths::Complex>() / self ); Expression_exposer.def( self + other<SireMaths::Complex>() ); Expression_exposer.def( self - other<SireMaths::Complex>() ); Expression_exposer.def( self * other<SireMaths::Complex>() ); Expression_exposer.def( self / other<SireMaths::Complex>() ); Expression_exposer.def( other<SireCAS::ExBase>() + self ); Expression_exposer.def( other<SireCAS::ExBase>() - self ); Expression_exposer.def( other<SireCAS::ExBase>() * self ); Expression_exposer.def( other<SireCAS::ExBase>() / self ); Expression_exposer.def( self + other<SireCAS::ExBase>() ); Expression_exposer.def( self - other<SireCAS::ExBase>() ); Expression_exposer.def( self * other<SireCAS::ExBase>() ); Expression_exposer.def( self / other<SireCAS::ExBase>() ); Expression_exposer.def( "__copy__", &__copy__); Expression_exposer.def( "__deepcopy__", &__copy__); Expression_exposer.def( "clone", &__copy__); Expression_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Expression >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Expression_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Expression >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Expression_exposer.def( "__str__", &__str__< ::SireCAS::Expression > ); Expression_exposer.def( "__repr__", &__str__< ::SireCAS::Expression > ); } }
void register_Process_class(){ { //::SireBase::Process typedef bp::class_< SireBase::Process > Process_exposer_t; Process_exposer_t Process_exposer = Process_exposer_t( "Process", "This class provides a means to run an external process\n(executable). This provides the equivalent of\nstd::system, but with added error handling and\nsignal handling (which ensures that any child processes\nare killed when Sire exits)\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") ); bp::scope Process_scope( Process_exposer ); Process_exposer.def( bp::init< SireBase::Process const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireBase::Process::hasFinished typedef bool ( ::SireBase::Process::*hasFinished_function_type)( ) ; hasFinished_function_type hasFinished_function_value( &::SireBase::Process::hasFinished ); Process_exposer.def( "hasFinished" , hasFinished_function_value , "Return whether or not this process has finished running" ); } { //::SireBase::Process::isError typedef bool ( ::SireBase::Process::*isError_function_type)( ) ; isError_function_type isError_function_value( &::SireBase::Process::isError ); Process_exposer.def( "isError" , isError_function_value , "Return whether or not the process exited in error" ); } { //::SireBase::Process::isRunning typedef bool ( ::SireBase::Process::*isRunning_function_type)( ) ; isRunning_function_type isRunning_function_value( &::SireBase::Process::isRunning ); Process_exposer.def( "isRunning" , isRunning_function_value , "Return whether or not the job is running" ); } { //::SireBase::Process::kill typedef void ( ::SireBase::Process::*kill_function_type)( ) ; kill_function_type kill_function_value( &::SireBase::Process::kill ); Process_exposer.def( "kill" , kill_function_value , "Kill this process" ); } { //::SireBase::Process::killAll typedef void ( *killAll_function_type )( ); killAll_function_type killAll_function_value( &::SireBase::Process::killAll ); Process_exposer.def( "killAll" , killAll_function_value , "Use this function to kill all of the jobs that are currently running" ); } Process_exposer.def( bp::self != bp::self ); { //::SireBase::Process::operator= typedef ::SireBase::Process & ( ::SireBase::Process::*assign_function_type)( ::SireBase::Process const & ) ; assign_function_type assign_function_value( &::SireBase::Process::operator= ); Process_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } Process_exposer.def( bp::self == bp::self ); { //::SireBase::Process::run typedef ::SireBase::Process ( *run_function_type )( ::QString const & ); run_function_type run_function_value( &::SireBase::Process::run ); Process_exposer.def( "run" , run_function_value , ( bp::arg("command") ) , "Run the command command and return a Process object that can be\nused to monitor the command" ); } { //::SireBase::Process::run typedef ::SireBase::Process ( *run_function_type )( ::QString const &,::QString const & ); run_function_type run_function_value( &::SireBase::Process::run ); Process_exposer.def( "run" , run_function_value , ( bp::arg("command"), bp::arg("arg") ) , "Run the command command with the solitary argument arg" ); } { //::SireBase::Process::run typedef ::SireBase::Process ( *run_function_type )( ::QString const &,::QStringList const & ); run_function_type run_function_value( &::SireBase::Process::run ); Process_exposer.def( "run" , run_function_value , ( bp::arg("command"), bp::arg("arguments") ) , "Run the command command with the arguments arguments, and\nreturn a Process object that can be used to query and control the\njob" ); } { //::SireBase::Process::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireBase::Process::typeName ); Process_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireBase::Process::wait typedef void ( ::SireBase::Process::*wait_function_type)( ) ; wait_function_type wait_function_value( &::SireBase::Process::wait ); Process_exposer.def( "wait" , wait_function_value , "Wait until the process has finished" ); } { //::SireBase::Process::wait typedef bool ( ::SireBase::Process::*wait_function_type)( int ) ; wait_function_type wait_function_value( &::SireBase::Process::wait ); Process_exposer.def( "wait" , wait_function_value , ( bp::arg("ms") ) , "Wait until the process has finished, or until ms milliseconds have passed.\nThis returns whether or not the process has finished" ); } { //::SireBase::Process::wasKilled typedef bool ( ::SireBase::Process::*wasKilled_function_type)( ) ; wasKilled_function_type wasKilled_function_value( &::SireBase::Process::wasKilled ); Process_exposer.def( "wasKilled" , wasKilled_function_value , "Return whether or not the process was killed" ); } { //::SireBase::Process::what typedef char const * ( ::SireBase::Process::*what_function_type)( ) const; what_function_type what_function_value( &::SireBase::Process::what ); Process_exposer.def( "what" , what_function_value , "" ); } Process_exposer.staticmethod( "killAll" ); Process_exposer.staticmethod( "run" ); Process_exposer.staticmethod( "typeName" ); Process_exposer.def( "__copy__", &__copy__); Process_exposer.def( "__deepcopy__", &__copy__); Process_exposer.def( "clone", &__copy__); Process_exposer.def( "__str__", &pvt_get_name); Process_exposer.def( "__repr__", &pvt_get_name); } }
void register_MolWithResID_class(){ { //::SireMol::MolWithResID typedef bp::class_< SireMol::MolWithResID, bp::bases< SireMol::MolID, SireID::ID > > MolWithResID_exposer_t; MolWithResID_exposer_t MolWithResID_exposer = MolWithResID_exposer_t( "MolWithResID", bp::init< >() ); bp::scope MolWithResID_scope( MolWithResID_exposer ); MolWithResID_exposer.def( bp::init< QString const & >(( bp::arg("resname") )) ); MolWithResID_exposer.def( bp::init< int >(( bp::arg("resnum") )) ); MolWithResID_exposer.def( bp::init< SireMol::ResID const & >(( bp::arg("resid") )) ); MolWithResID_exposer.def( bp::init< QString const &, SireID::CaseSensitivity >(( bp::arg("resname"), bp::arg("case_sensitivity") )) ); MolWithResID_exposer.def( bp::init< SireMol::MolWithResID const & >(( bp::arg("other") )) ); { //::SireMol::MolWithResID::hash typedef ::uint ( ::SireMol::MolWithResID::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireMol::MolWithResID::hash ); MolWithResID_exposer.def( "hash" , hash_function_value ); } { //::SireMol::MolWithResID::isNull typedef bool ( ::SireMol::MolWithResID::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireMol::MolWithResID::isNull ); MolWithResID_exposer.def( "isNull" , isNull_function_value ); } { //::SireMol::MolWithResID::map typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::Molecules const & ) const; map_function_type map_function_value( &::SireMol::MolWithResID::map ); MolWithResID_exposer.def( "map" , map_function_value , ( bp::arg("molecules") ) ); } { //::SireMol::MolWithResID::map typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::MoleculeGroup const & ) const; map_function_type map_function_value( &::SireMol::MolWithResID::map ); MolWithResID_exposer.def( "map" , map_function_value , ( bp::arg("molgroup") ) ); } { //::SireMol::MolWithResID::map typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::MolGroupsBase const & ) const; map_function_type map_function_value( &::SireMol::MolWithResID::map ); MolWithResID_exposer.def( "map" , map_function_value , ( bp::arg("molgroups") ) ); } MolWithResID_exposer.def( bp::self != bp::self ); { //::SireMol::MolWithResID::operator= typedef ::SireMol::MolWithResID & ( ::SireMol::MolWithResID::*assign_function_type )( ::SireMol::MolWithResID const & ) ; assign_function_type assign_function_value( &::SireMol::MolWithResID::operator= ); MolWithResID_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } MolWithResID_exposer.def( bp::self == bp::other< SireID::ID >() ); MolWithResID_exposer.def( bp::self == bp::self ); { //::SireMol::MolWithResID::resID typedef ::SireMol::ResID const & ( ::SireMol::MolWithResID::*resID_function_type )( ) const; resID_function_type resID_function_value( &::SireMol::MolWithResID::resID ); MolWithResID_exposer.def( "resID" , resID_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::MolWithResID::toString typedef ::QString ( ::SireMol::MolWithResID::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMol::MolWithResID::toString ); MolWithResID_exposer.def( "toString" , toString_function_value ); } { //::SireMol::MolWithResID::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::MolWithResID::typeName ); MolWithResID_exposer.def( "typeName" , typeName_function_value ); } { //::SireMol::MolWithResID::what typedef char const * ( ::SireMol::MolWithResID::*what_function_type )( ) const; what_function_type what_function_value( &::SireMol::MolWithResID::what ); MolWithResID_exposer.def( "what" , what_function_value ); } MolWithResID_exposer.staticmethod( "typeName" ); MolWithResID_exposer.def( "__copy__", &__copy__); MolWithResID_exposer.def( "__deepcopy__", &__copy__); MolWithResID_exposer.def( "clone", &__copy__); MolWithResID_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::MolWithResID >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); MolWithResID_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::MolWithResID >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); MolWithResID_exposer.def( "__str__", &__str__< ::SireMol::MolWithResID > ); MolWithResID_exposer.def( "__repr__", &__str__< ::SireMol::MolWithResID > ); } }
void register_IDOrSet_SegID__class(){ { //::SireID::IDOrSet< SireMol::SegID > typedef bp::class_< SireID::IDOrSet< SireMol::SegID >, bp::bases< SireMol::SegID, SireID::ID > > IDOrSet_SegID__exposer_t; IDOrSet_SegID__exposer_t IDOrSet_SegID__exposer = IDOrSet_SegID__exposer_t( "IDOrSet_SegID_", bp::init< >() ); bp::scope IDOrSet_SegID__scope( IDOrSet_SegID__exposer ); IDOrSet_SegID__exposer.def( bp::init< SireMol::SegID const & >(( bp::arg("id") )) ); IDOrSet_SegID__exposer.def( bp::init< SireMol::SegID const &, SireMol::SegID const & >(( bp::arg("id0"), bp::arg("id1") )) ); IDOrSet_SegID__exposer.def( bp::init< QList< SireMol::SegIdentifier > const & >(( bp::arg("ids") )) ); IDOrSet_SegID__exposer.def( bp::init< SireID::IDOrSet< SireMol::SegID > const & >(( bp::arg("other") )) ); { //::SireID::IDOrSet< SireMol::SegID >::IDs typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef ::QSet< SireMol::SegIdentifier > const & ( ::SireID::IDOrSet< SireMol::SegID >::*IDs_function_type )( ) const; IDs_function_type IDs_function_value( &::SireID::IDOrSet< SireMol::SegID >::IDs ); IDOrSet_SegID__exposer.def( "IDs" , IDs_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireID::IDOrSet< SireMol::SegID >::hash typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef ::uint ( ::SireID::IDOrSet< SireMol::SegID >::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireID::IDOrSet< SireMol::SegID >::hash ); IDOrSet_SegID__exposer.def( "hash" , hash_function_value ); } { //::SireID::IDOrSet< SireMol::SegID >::isNull typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef bool ( ::SireID::IDOrSet< SireMol::SegID >::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireID::IDOrSet< SireMol::SegID >::isNull ); IDOrSet_SegID__exposer.def( "isNull" , isNull_function_value ); } { //::SireID::IDOrSet< SireMol::SegID >::map typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef ::QList< SireMol::SegIdx > ( ::SireID::IDOrSet< SireMol::SegID >::*map_function_type )( ::SireMol::MolInfo const & ) const; map_function_type map_function_value( &::SireID::IDOrSet< SireMol::SegID >::map ); IDOrSet_SegID__exposer.def( "map" , map_function_value , ( bp::arg("obj") ) ); } IDOrSet_SegID__exposer.def( bp::self != bp::other< SireID::ID >() ); IDOrSet_SegID__exposer.def( bp::self != bp::self ); IDOrSet_SegID__exposer.def( bp::self != bp::other< SireMol::SegID >() ); { //::SireID::IDOrSet< SireMol::SegID >::operator= typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef ::SireID::IDOrSet< SireMol::SegID > & ( ::SireID::IDOrSet< SireMol::SegID >::*assign_function_type )( ::SireID::IDOrSet< SireMol::SegID > const & ) ; assign_function_type assign_function_value( &::SireID::IDOrSet< SireMol::SegID >::operator= ); IDOrSet_SegID__exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } { //::SireID::IDOrSet< SireMol::SegID >::operator= typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef ::SireID::IDOrSet< SireMol::SegID > & ( ::SireID::IDOrSet< SireMol::SegID >::*assign_function_type )( ::SireMol::SegID const & ) ; assign_function_type assign_function_value( &::SireID::IDOrSet< SireMol::SegID >::operator= ); IDOrSet_SegID__exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } IDOrSet_SegID__exposer.def( bp::self == bp::other< SireID::ID >() ); IDOrSet_SegID__exposer.def( bp::self == bp::self ); IDOrSet_SegID__exposer.def( bp::self == bp::other< SireMol::SegID >() ); { //::SireID::IDOrSet< SireMol::SegID >::toString typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef ::QString ( ::SireID::IDOrSet< SireMol::SegID >::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireID::IDOrSet< SireMol::SegID >::toString ); IDOrSet_SegID__exposer.def( "toString" , toString_function_value ); } { //::SireID::IDOrSet< SireMol::SegID >::typeName typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireID::IDOrSet< SireMol::SegID >::typeName ); IDOrSet_SegID__exposer.def( "typeName" , typeName_function_value ); } { //::SireID::IDOrSet< SireMol::SegID >::what typedef SireID::IDOrSet< SireMol::SegID > exported_class_t; typedef char const * ( ::SireID::IDOrSet< SireMol::SegID >::*what_function_type )( ) const; what_function_type what_function_value( &::SireID::IDOrSet< SireMol::SegID >::what ); IDOrSet_SegID__exposer.def( "what" , what_function_value ); } IDOrSet_SegID__exposer.staticmethod( "typeName" ); IDOrSet_SegID__exposer.def( "__copy__", &__copy__); IDOrSet_SegID__exposer.def( "__deepcopy__", &__copy__); IDOrSet_SegID__exposer.def( "clone", &__copy__); IDOrSet_SegID__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::IDOrSet<SireMol::SegID> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); IDOrSet_SegID__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::IDOrSet<SireMol::SegID> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); IDOrSet_SegID__exposer.def( "__str__", &__str__< ::SireID::IDOrSet<SireMol::SegID> > ); IDOrSet_SegID__exposer.def( "__repr__", &__str__< ::SireID::IDOrSet<SireMol::SegID> > ); } }
void register_Process_class(){ { //::SireBase::Process typedef bp::class_< SireBase::Process > Process_exposer_t; Process_exposer_t Process_exposer = Process_exposer_t( "Process", bp::init< >() ); bp::scope Process_scope( Process_exposer ); Process_exposer.def( bp::init< SireBase::Process const & >(( bp::arg("other") )) ); { //::SireBase::Process::hasFinished typedef bool ( ::SireBase::Process::*hasFinished_function_type )( ) ; hasFinished_function_type hasFinished_function_value( &::SireBase::Process::hasFinished ); Process_exposer.def( "hasFinished" , hasFinished_function_value ); } { //::SireBase::Process::isError typedef bool ( ::SireBase::Process::*isError_function_type )( ) ; isError_function_type isError_function_value( &::SireBase::Process::isError ); Process_exposer.def( "isError" , isError_function_value ); } { //::SireBase::Process::isRunning typedef bool ( ::SireBase::Process::*isRunning_function_type )( ) ; isRunning_function_type isRunning_function_value( &::SireBase::Process::isRunning ); Process_exposer.def( "isRunning" , isRunning_function_value ); } { //::SireBase::Process::kill typedef void ( ::SireBase::Process::*kill_function_type )( ) ; kill_function_type kill_function_value( &::SireBase::Process::kill ); Process_exposer.def( "kill" , kill_function_value ); } { //::SireBase::Process::killAll typedef void ( *killAll_function_type )( ); killAll_function_type killAll_function_value( &::SireBase::Process::killAll ); Process_exposer.def( "killAll" , killAll_function_value ); } Process_exposer.def( bp::self != bp::self ); { //::SireBase::Process::operator= typedef ::SireBase::Process & ( ::SireBase::Process::*assign_function_type )( ::SireBase::Process const & ) ; assign_function_type assign_function_value( &::SireBase::Process::operator= ); Process_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } Process_exposer.def( bp::self == bp::self ); { //::SireBase::Process::run typedef ::SireBase::Process ( *run_function_type )( ::QString const & ); run_function_type run_function_value( &::SireBase::Process::run ); Process_exposer.def( "run" , run_function_value , ( bp::arg("command") ) ); } { //::SireBase::Process::run typedef ::SireBase::Process ( *run_function_type )( ::QString const &,::QString const & ); run_function_type run_function_value( &::SireBase::Process::run ); Process_exposer.def( "run" , run_function_value , ( bp::arg("command"), bp::arg("arg") ) ); } { //::SireBase::Process::run typedef ::SireBase::Process ( *run_function_type )( ::QString const &,::QStringList const & ); run_function_type run_function_value( &::SireBase::Process::run ); Process_exposer.def( "run" , run_function_value , ( bp::arg("command"), bp::arg("arguments") ) ); } { //::SireBase::Process::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireBase::Process::typeName ); Process_exposer.def( "typeName" , typeName_function_value ); } { //::SireBase::Process::wait typedef void ( ::SireBase::Process::*wait_function_type )( ) ; wait_function_type wait_function_value( &::SireBase::Process::wait ); Process_exposer.def( "wait" , wait_function_value ); } { //::SireBase::Process::wait typedef bool ( ::SireBase::Process::*wait_function_type )( int ) ; wait_function_type wait_function_value( &::SireBase::Process::wait ); Process_exposer.def( "wait" , wait_function_value , ( bp::arg("ms") ) ); } { //::SireBase::Process::wasKilled typedef bool ( ::SireBase::Process::*wasKilled_function_type )( ) ; wasKilled_function_type wasKilled_function_value( &::SireBase::Process::wasKilled ); Process_exposer.def( "wasKilled" , wasKilled_function_value ); } { //::SireBase::Process::what typedef char const * ( ::SireBase::Process::*what_function_type )( ) const; what_function_type what_function_value( &::SireBase::Process::what ); Process_exposer.def( "what" , what_function_value ); } Process_exposer.staticmethod( "killAll" ); Process_exposer.staticmethod( "run" ); Process_exposer.staticmethod( "typeName" ); Process_exposer.def( "__copy__", &__copy__); Process_exposer.def( "__deepcopy__", &__copy__); Process_exposer.def( "clone", &__copy__); Process_exposer.def( "__str__", &pvt_get_name); Process_exposer.def( "__repr__", &pvt_get_name); } }
void register_InternalParameters3D_class(){ { //::SireMM::InternalParameters3D typedef bp::class_< SireMM::InternalParameters3D, bp::bases< SireMM::InternalParameters > > InternalParameters3D_exposer_t; InternalParameters3D_exposer_t InternalParameters3D_exposer = InternalParameters3D_exposer_t( "InternalParameters3D", "This class holds intramolecular bonding parameters for 3D molecules\n(so it also contains the 3D coordinates of the molecule)\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") ); bp::scope InternalParameters3D_scope( InternalParameters3D_exposer ); InternalParameters3D_exposer.def( bp::init< SireMol::PartialMolecule const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, bool >(( bp::arg("molecule"), bp::arg("coords_property"), bp::arg("bond_params"), bp::arg("angle_params"), bp::arg("dihedral_params"), bp::arg("improper_params"), bp::arg("ub_params"), bp::arg("ss_params"), bp::arg("sb_params"), bp::arg("bb_params"), bp::arg("sbt_params"), bp::arg("isstrict") ), "Construct, creating the parameters from the passed molecule\nusing the supplied property names\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\nThrow: SireError::incompatible_error\n") ); InternalParameters3D_exposer.def( bp::init< SireMM::InternalParameters3D const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMM::InternalParameters3D::addChangedGroups typedef void ( ::SireMM::InternalParameters3D::*addChangedGroups_function_type)( ::SireMM::InternalParameters3D const &,::QSet< unsigned int > & ) const; addChangedGroups_function_type addChangedGroups_function_value( &::SireMM::InternalParameters3D::addChangedGroups ); InternalParameters3D_exposer.def( "addChangedGroups" , addChangedGroups_function_value , ( bp::arg("other"), bp::arg("changed_groups") ) , "Add the changed groups that are different in other compared to this\nto changed_groups" ); } { //::SireMM::InternalParameters3D::applyMask typedef ::SireMM::InternalParameters3D ( ::SireMM::InternalParameters3D::*applyMask_function_type)( ::QSet< unsigned int > const & ) const; applyMask_function_type applyMask_function_value( &::SireMM::InternalParameters3D::applyMask ); InternalParameters3D_exposer.def( "applyMask" , applyMask_function_value , ( bp::arg("cgidxs") ) , "Mask these parameters so that only the parameters for the CutGroups\nwhose indicies are in cgidxs are contained." ); } { //::SireMM::InternalParameters3D::atomicCoordinates typedef ::SireVol::CoordGroupArray const & ( ::SireMM::InternalParameters3D::*atomicCoordinates_function_type)( ) const; atomicCoordinates_function_type atomicCoordinates_function_value( &::SireMM::InternalParameters3D::atomicCoordinates ); InternalParameters3D_exposer.def( "atomicCoordinates" , atomicCoordinates_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the coordinates" ); } { //::SireMM::InternalParameters3D::changedAllGroups typedef bool ( ::SireMM::InternalParameters3D::*changedAllGroups_function_type)( ::SireMM::InternalParameters3D const & ) const; changedAllGroups_function_type changedAllGroups_function_value( &::SireMM::InternalParameters3D::changedAllGroups ); InternalParameters3D_exposer.def( "changedAllGroups" , changedAllGroups_function_value , ( bp::arg("other") ) , "Return whether or not all of the CutGroup have changed compared to other" ); } { //::SireMM::InternalParameters3D::getChangedGroups typedef ::QSet< unsigned int > ( ::SireMM::InternalParameters3D::*getChangedGroups_function_type)( ::SireMM::InternalParameters3D const & ) const; getChangedGroups_function_type getChangedGroups_function_value( &::SireMM::InternalParameters3D::getChangedGroups ); InternalParameters3D_exposer.def( "getChangedGroups" , getChangedGroups_function_value , ( bp::arg("other") ) , "Return the indicies of the CutGroups that have changed in other compared\nto this set of parameters" ); } { //::SireMM::InternalParameters3D::nCutGroups typedef int ( ::SireMM::InternalParameters3D::*nCutGroups_function_type)( ) const; nCutGroups_function_type nCutGroups_function_value( &::SireMM::InternalParameters3D::nCutGroups ); InternalParameters3D_exposer.def( "nCutGroups" , nCutGroups_function_value , "Return the number of CutGroups in the molecule whose parameters are\ncontained in this object" ); } InternalParameters3D_exposer.def( bp::self != bp::self ); { //::SireMM::InternalParameters3D::operator= typedef ::SireMM::InternalParameters3D & ( ::SireMM::InternalParameters3D::*assign_function_type)( ::SireMM::InternalParameters3D const & ) ; assign_function_type assign_function_value( &::SireMM::InternalParameters3D::operator= ); InternalParameters3D_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } InternalParameters3D_exposer.def( bp::self == bp::self ); { //::SireMM::InternalParameters3D::setAtomicCoordinates typedef void ( ::SireMM::InternalParameters3D::*setAtomicCoordinates_function_type)( ::SireFF::detail::AtomicCoords3D const & ) ; setAtomicCoordinates_function_type setAtomicCoordinates_function_value( &::SireMM::InternalParameters3D::setAtomicCoordinates ); InternalParameters3D_exposer.def( "setAtomicCoordinates" , setAtomicCoordinates_function_value , ( bp::arg("coords") ) , "Set the coordinates used by these parameters" ); } { //::SireMM::InternalParameters3D::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::InternalParameters3D::typeName ); InternalParameters3D_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMM::InternalParameters3D::what typedef char const * ( ::SireMM::InternalParameters3D::*what_function_type)( ) const; what_function_type what_function_value( &::SireMM::InternalParameters3D::what ); InternalParameters3D_exposer.def( "what" , what_function_value , "" ); } InternalParameters3D_exposer.staticmethod( "typeName" ); InternalParameters3D_exposer.def( "__copy__", &__copy__); InternalParameters3D_exposer.def( "__deepcopy__", &__copy__); InternalParameters3D_exposer.def( "clone", &__copy__); InternalParameters3D_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::InternalParameters3D >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); InternalParameters3D_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::InternalParameters3D >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); InternalParameters3D_exposer.def( "__str__", &pvt_get_name); InternalParameters3D_exposer.def( "__repr__", &pvt_get_name); } }
void register_CLJSoftIntraShiftFunction_class(){ { //::SireMM::CLJSoftIntraShiftFunction typedef bp::class_< SireMM::CLJSoftIntraShiftFunction, bp::bases< SireMM::CLJSoftIntraFunction, SireMM::CLJIntraFunction, SireMM::CLJCutoffFunction, SireMM::CLJFunction, SireBase::Property > > CLJSoftIntraShiftFunction_exposer_t; CLJSoftIntraShiftFunction_exposer_t CLJSoftIntraShiftFunction_exposer = CLJSoftIntraShiftFunction_exposer_t( "CLJSoftIntraShiftFunction", bp::init< >() ); bp::scope CLJSoftIntraShiftFunction_scope( CLJSoftIntraShiftFunction_exposer ); CLJSoftIntraShiftFunction_exposer.def( bp::init< SireUnits::Dimension::Length >(( bp::arg("cutoff") )) ); CLJSoftIntraShiftFunction_exposer.def( bp::init< SireUnits::Dimension::Length, SireUnits::Dimension::Length >(( bp::arg("coul_cutoff"), bp::arg("lj_cutoff") )) ); CLJSoftIntraShiftFunction_exposer.def( bp::init< SireVol::Space const &, SireUnits::Dimension::Length >(( bp::arg("space"), bp::arg("cutoff") )) ); CLJSoftIntraShiftFunction_exposer.def( bp::init< SireVol::Space const &, SireUnits::Dimension::Length, SireUnits::Dimension::Length >(( bp::arg("space"), bp::arg("coul_cutoff"), bp::arg("lj_cutoff") )) ); CLJSoftIntraShiftFunction_exposer.def( bp::init< SireUnits::Dimension::Length, SireMM::CLJFunction::COMBINING_RULES >(( bp::arg("cutoff"), bp::arg("combining_rules") )) ); CLJSoftIntraShiftFunction_exposer.def( bp::init< SireUnits::Dimension::Length, SireUnits::Dimension::Length, SireMM::CLJFunction::COMBINING_RULES >(( bp::arg("coul_cutoff"), bp::arg("lj_cutoff"), bp::arg("combining_rules") )) ); CLJSoftIntraShiftFunction_exposer.def( bp::init< SireVol::Space const &, SireMM::CLJFunction::COMBINING_RULES >(( bp::arg("space"), bp::arg("combining_rules") )) ); CLJSoftIntraShiftFunction_exposer.def( bp::init< SireVol::Space const &, SireUnits::Dimension::Length, SireMM::CLJFunction::COMBINING_RULES >(( bp::arg("space"), bp::arg("cutoff"), bp::arg("combining_rules") )) ); CLJSoftIntraShiftFunction_exposer.def( bp::init< SireVol::Space const &, SireUnits::Dimension::Length, SireUnits::Dimension::Length, SireMM::CLJFunction::COMBINING_RULES >(( bp::arg("space"), bp::arg("coul_cutoff"), bp::arg("lj_cutoff"), bp::arg("combining_rules") )) ); CLJSoftIntraShiftFunction_exposer.def( bp::init< SireMM::CLJSoftIntraShiftFunction const & >(( bp::arg("other") )) ); { //::SireMM::CLJSoftIntraShiftFunction::defaultShiftFunction typedef ::SireMM::CLJFunctionPtr ( *defaultShiftFunction_function_type )( ); defaultShiftFunction_function_type defaultShiftFunction_function_value( &::SireMM::CLJSoftIntraShiftFunction::defaultShiftFunction ); CLJSoftIntraShiftFunction_exposer.def( "defaultShiftFunction" , defaultShiftFunction_function_value ); } CLJSoftIntraShiftFunction_exposer.def( bp::self != bp::self ); { //::SireMM::CLJSoftIntraShiftFunction::operator= typedef ::SireMM::CLJSoftIntraShiftFunction & ( ::SireMM::CLJSoftIntraShiftFunction::*assign_function_type )( ::SireMM::CLJSoftIntraShiftFunction const & ) ; assign_function_type assign_function_value( &::SireMM::CLJSoftIntraShiftFunction::operator= ); CLJSoftIntraShiftFunction_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } CLJSoftIntraShiftFunction_exposer.def( bp::self == bp::self ); { //::SireMM::CLJSoftIntraShiftFunction::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::CLJSoftIntraShiftFunction::typeName ); CLJSoftIntraShiftFunction_exposer.def( "typeName" , typeName_function_value ); } { //::SireMM::CLJSoftIntraShiftFunction::what typedef char const * ( ::SireMM::CLJSoftIntraShiftFunction::*what_function_type )( ) const; what_function_type what_function_value( &::SireMM::CLJSoftIntraShiftFunction::what ); CLJSoftIntraShiftFunction_exposer.def( "what" , what_function_value ); } CLJSoftIntraShiftFunction_exposer.staticmethod( "defaultShiftFunction" ); CLJSoftIntraShiftFunction_exposer.staticmethod( "typeName" ); CLJSoftIntraShiftFunction_exposer.def( "__copy__", &__copy__); CLJSoftIntraShiftFunction_exposer.def( "__deepcopy__", &__copy__); CLJSoftIntraShiftFunction_exposer.def( "clone", &__copy__); CLJSoftIntraShiftFunction_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJSoftIntraShiftFunction >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CLJSoftIntraShiftFunction_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJSoftIntraShiftFunction >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CLJSoftIntraShiftFunction_exposer.def( "__str__", &__str__< ::SireMM::CLJSoftIntraShiftFunction > ); CLJSoftIntraShiftFunction_exposer.def( "__repr__", &__str__< ::SireMM::CLJSoftIntraShiftFunction > ); } }
void register_PotentialTable_class(){ { //::SireFF::PotentialTable typedef bp::class_< SireFF::PotentialTable > PotentialTable_exposer_t; PotentialTable_exposer_t PotentialTable_exposer = PotentialTable_exposer_t( "PotentialTable", "A PotentialTable is a workspace within which all of the potentials\nat the points of atoms in molecules, or the points on a grid\nmay be stored. A PotentialTable is used as storing the potentials\nmay require lots of memory, and continually\ncreating a deleting such large amouts of memory would be inefficient.\nAlso, using a PotentialTable allows for potentials to be accumalated directly,\nrather than requiring intermediate storage space for the\nindividual components.\n\nYou create a potential table to hold all of the potentials at all of\nthe atoms of all of the molecules in a specified MoleculeGroup,\nor at all of the points of a passed Grid.\n\nThe potentials are held in an array that holds the potentials for\nthe molecules in the same order as the molecules appear\nin the molecule group, or in an array that holds the potentials\nin the same order as they appear in the grid.\nThe potential table also comes with an index so you can quickly\nlook up the potential for a specific molecule.\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") ); bp::scope PotentialTable_scope( PotentialTable_exposer ); PotentialTable_exposer.def( bp::init< SireMol::MoleculeGroup const & >(( bp::arg("molgroup") ), "Construct the table to hold the potentials at the points of all\nof the atoms in the CutGroups that are viewed in the molecules\nin molgroup") ); PotentialTable_exposer.def( bp::init< SireVol::Grid const & >(( bp::arg("grid") ), "Construct the table to hold the potentials at all of the points\nin the passed grid") ); PotentialTable_exposer.def( bp::init< QVector< SireBase::PropPtr< SireVol::Grid > > const & >(( bp::arg("grids") ), "Construct the table to hold the potentials at all of the points\nof all of the passed grids") ); PotentialTable_exposer.def( bp::init< SireMol::MoleculeGroup const &, SireVol::Grid const & >(( bp::arg("molgroup"), bp::arg("grid") ), "Construct the table to hold the potentials at the points of all\nof the atoms in the CutGroups that are viewed in the molecules\nin molgroup, and all of the grid points in the passed grid") ); PotentialTable_exposer.def( bp::init< SireMol::MoleculeGroup const &, QVector< SireBase::PropPtr< SireVol::Grid > > const & >(( bp::arg("molgroup"), bp::arg("grids") ), "Construct the table to hold the potentials at the points of all\nof the atoms in the CutGroups that are viewed in the molecules\nin molgroup, and all of the grid points in the passed grids") ); PotentialTable_exposer.def( bp::init< SireFF::PotentialTable const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireFF::PotentialTable::add typedef void ( ::SireFF::PotentialTable::*add_function_type)( ::SireFF::PotentialTable const & ) ; add_function_type add_function_value( &::SireFF::PotentialTable::add ); PotentialTable_exposer.def( "add" , add_function_value , ( bp::arg("other") ) , "Add the contents of the table other onto this table. This will only\nadd the potentials for the molecules grids that are in both tables" ); } { //::SireFF::PotentialTable::add typedef void ( ::SireFF::PotentialTable::*add_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ; add_function_type add_function_value( &::SireFF::PotentialTable::add ); PotentialTable_exposer.def( "add" , add_function_value , ( bp::arg("potential") ) , "Add the potential potential onto all of the atom grid points in this table" ); } { //::SireFF::PotentialTable::assertContainsTableFor typedef void ( ::SireFF::PotentialTable::*assertContainsTableFor_function_type)( ::SireMol::MolNum ) const; assertContainsTableFor_function_type assertContainsTableFor_function_value( &::SireFF::PotentialTable::assertContainsTableFor ); PotentialTable_exposer.def( "assertContainsTableFor" , assertContainsTableFor_function_value , ( bp::arg("molnum") ) , "Assert that this contains a table for the molecule with number molnum\nThrow: SireError::unavailable_resource\n" ); } { //::SireFF::PotentialTable::assertContainsTableFor typedef void ( ::SireFF::PotentialTable::*assertContainsTableFor_function_type)( ::SireVol::Grid const & ) const; assertContainsTableFor_function_type assertContainsTableFor_function_value( &::SireFF::PotentialTable::assertContainsTableFor ); PotentialTable_exposer.def( "assertContainsTableFor" , assertContainsTableFor_function_value , ( bp::arg("grid") ) , "Assert that this contains a table for the passed grid\nThrow: SireError::unavailable_resource\n" ); } { //::SireFF::PotentialTable::constGetTable typedef ::SireFF::MolPotentialTable const & ( ::SireFF::PotentialTable::*constGetTable_function_type)( ::SireMol::MolNum ) const; constGetTable_function_type constGetTable_function_value( &::SireFF::PotentialTable::constGetTable ); PotentialTable_exposer.def( "constGetTable" , constGetTable_function_value , ( bp::arg("molnum") ) , bp::return_value_policy< bp::copy_const_reference >() , "Return the potential table for the passed grid\nThrow: SireError::unavailable_resource\n" ); } { //::SireFF::PotentialTable::constGetTable typedef ::SireFF::GridPotentialTable const & ( ::SireFF::PotentialTable::*constGetTable_function_type)( ::SireVol::Grid const & ) const; constGetTable_function_type constGetTable_function_value( &::SireFF::PotentialTable::constGetTable ); PotentialTable_exposer.def( "constGetTable" , constGetTable_function_value , ( bp::arg("grid") ) , bp::return_value_policy< bp::copy_const_reference >() , "Return the potential table for the passed grid\nThrow: SireError::unavailable_resource\n" ); } { //::SireFF::PotentialTable::contains typedef bool ( ::SireFF::PotentialTable::*contains_function_type)( ::SireMol::MolNum ) const; contains_function_type contains_function_value( &::SireFF::PotentialTable::contains ); PotentialTable_exposer.def( "contains" , contains_function_value , ( bp::arg("molnum") ) , "Return whether or not this contains a table for the passed grid" ); } { //::SireFF::PotentialTable::contains typedef bool ( ::SireFF::PotentialTable::*contains_function_type)( ::SireVol::Grid const & ) const; contains_function_type contains_function_value( &::SireFF::PotentialTable::contains ); PotentialTable_exposer.def( "contains" , contains_function_value , ( bp::arg("grid") ) , "Return whether or not this contains a table for the passed grid" ); } { //::SireFF::PotentialTable::divide typedef void ( ::SireFF::PotentialTable::*divide_function_type)( double ) ; divide_function_type divide_function_value( &::SireFF::PotentialTable::divide ); PotentialTable_exposer.def( "divide" , divide_function_value , ( bp::arg("value") ) , "Divide the potential at all atom and grid points by value" ); } { //::SireFF::PotentialTable::getTable typedef ::SireFF::MolPotentialTable const & ( ::SireFF::PotentialTable::*getTable_function_type)( ::SireMol::MolNum ) const; getTable_function_type getTable_function_value( &::SireFF::PotentialTable::getTable ); PotentialTable_exposer.def( "getTable" , getTable_function_value , ( bp::arg("molnum") ) , bp::return_value_policy< bp::copy_const_reference >() , "Return the potential table for the passed grid\nThrow: SireError::unavailable_resource\n" ); } { //::SireFF::PotentialTable::getTable typedef ::SireFF::GridPotentialTable const & ( ::SireFF::PotentialTable::*getTable_function_type)( ::SireVol::Grid const & ) const; getTable_function_type getTable_function_value( &::SireFF::PotentialTable::getTable ); PotentialTable_exposer.def( "getTable" , getTable_function_value , ( bp::arg("grid") ) , bp::return_value_policy< bp::copy_const_reference >() , "Return the potential table for the passed grid\nThrow: SireError::unavailable_resource\n" ); } { //::SireFF::PotentialTable::index typedef ::QHash< SireMol::MolNum, int > const & ( ::SireFF::PotentialTable::*index_function_type)( ) const; index_function_type index_function_value( &::SireFF::PotentialTable::index ); PotentialTable_exposer.def( "index" , index_function_value , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireFF::PotentialTable::indexOf typedef int ( ::SireFF::PotentialTable::*indexOf_function_type)( ::SireMol::MolNum ) const; indexOf_function_type indexOf_function_value( &::SireFF::PotentialTable::indexOf ); PotentialTable_exposer.def( "indexOf" , indexOf_function_value , ( bp::arg("molnum") ) , "Return the index of the molecule with number molnum in this table\nThrow: SireMol::missing_molecule\n" ); } { //::SireFF::PotentialTable::initialiseTable typedef void ( ::SireFF::PotentialTable::*initialiseTable_function_type)( ::SireMol::MolNum ) ; initialiseTable_function_type initialiseTable_function_value( &::SireFF::PotentialTable::initialiseTable ); PotentialTable_exposer.def( "initialiseTable" , initialiseTable_function_value , ( bp::arg("molnum") ) , "Initialise the table for the molecule with number molnum" ); } { //::SireFF::PotentialTable::initialiseTable typedef void ( ::SireFF::PotentialTable::*initialiseTable_function_type)( ::SireVol::Grid const & ) ; initialiseTable_function_type initialiseTable_function_value( &::SireFF::PotentialTable::initialiseTable ); PotentialTable_exposer.def( "initialiseTable" , initialiseTable_function_value , ( bp::arg("grid") ) , "Initialise the table for the grid grid" ); } { //::SireFF::PotentialTable::initialiseTables typedef void ( ::SireFF::PotentialTable::*initialiseTables_function_type)( ) ; initialiseTables_function_type initialiseTables_function_value( &::SireFF::PotentialTable::initialiseTables ); PotentialTable_exposer.def( "initialiseTables" , initialiseTables_function_value , "Initialise all of the tables to have a zero potential" ); } { //::SireFF::PotentialTable::isEmpty typedef bool ( ::SireFF::PotentialTable::*isEmpty_function_type)( ) const; isEmpty_function_type isEmpty_function_value( &::SireFF::PotentialTable::isEmpty ); PotentialTable_exposer.def( "isEmpty" , isEmpty_function_value , "Return whether or not this table is empty" ); } { //::SireFF::PotentialTable::molNums typedef ::QList< SireMol::MolNum > ( ::SireFF::PotentialTable::*molNums_function_type)( ) const; molNums_function_type molNums_function_value( &::SireFF::PotentialTable::molNums ); PotentialTable_exposer.def( "molNums" , molNums_function_value , "" ); } { //::SireFF::PotentialTable::multiply typedef void ( ::SireFF::PotentialTable::*multiply_function_type)( double ) ; multiply_function_type multiply_function_value( &::SireFF::PotentialTable::multiply ); PotentialTable_exposer.def( "multiply" , multiply_function_value , ( bp::arg("value") ) , "Multiply the potential at all atom and grid points by value" ); } { //::SireFF::PotentialTable::nGrids typedef int ( ::SireFF::PotentialTable::*nGrids_function_type)( ) const; nGrids_function_type nGrids_function_value( &::SireFF::PotentialTable::nGrids ); PotentialTable_exposer.def( "nGrids" , nGrids_function_value , "" ); } { //::SireFF::PotentialTable::nMolecules typedef int ( ::SireFF::PotentialTable::*nMolecules_function_type)( ) const; nMolecules_function_type nMolecules_function_value( &::SireFF::PotentialTable::nMolecules ); PotentialTable_exposer.def( "nMolecules" , nMolecules_function_value , "" ); } PotentialTable_exposer.def( bp::self != bp::self ); PotentialTable_exposer.def( bp::self * bp::other< double >() ); PotentialTable_exposer.def( bp::self + bp::self ); PotentialTable_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() ); PotentialTable_exposer.def( bp::self - bp::self ); PotentialTable_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() ); PotentialTable_exposer.def( -bp::self ); PotentialTable_exposer.def( bp::self / bp::other< double >() ); { //::SireFF::PotentialTable::operator= typedef ::SireFF::PotentialTable & ( ::SireFF::PotentialTable::*assign_function_type)( ::SireFF::PotentialTable const & ) ; assign_function_type assign_function_value( &::SireFF::PotentialTable::operator= ); PotentialTable_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } { //::SireFF::PotentialTable::operator= typedef ::SireFF::PotentialTable & ( ::SireFF::PotentialTable::*assign_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ; assign_function_type assign_function_value( &::SireFF::PotentialTable::operator= ); PotentialTable_exposer.def( "assign" , assign_function_value , ( bp::arg("potential") ) , bp::return_self< >() , "" ); } PotentialTable_exposer.def( bp::self == bp::self ); { //::SireFF::PotentialTable::setAll typedef void ( ::SireFF::PotentialTable::*setAll_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ; setAll_function_type setAll_function_value( &::SireFF::PotentialTable::setAll ); PotentialTable_exposer.def( "setAll" , setAll_function_value , ( bp::arg("potential") ) , "Set the potential at all atom and grid points equal to potential" ); } { //::SireFF::PotentialTable::subtract typedef void ( ::SireFF::PotentialTable::*subtract_function_type)( ::SireFF::PotentialTable const & ) ; subtract_function_type subtract_function_value( &::SireFF::PotentialTable::subtract ); PotentialTable_exposer.def( "subtract" , subtract_function_value , ( bp::arg("other") ) , "Subtract the contents of the table other from this table. This will only\nsubtract the potentials for the molecules grids that are in both tables" ); } { //::SireFF::PotentialTable::subtract typedef void ( ::SireFF::PotentialTable::*subtract_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ; subtract_function_type subtract_function_value( &::SireFF::PotentialTable::subtract ); PotentialTable_exposer.def( "subtract" , subtract_function_value , ( bp::arg("potential") ) , "Subtract the potential potential from all of the atom grid points in this table" ); } { //::SireFF::PotentialTable::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireFF::PotentialTable::typeName ); PotentialTable_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireFF::PotentialTable::what typedef char const * ( ::SireFF::PotentialTable::*what_function_type)( ) const; what_function_type what_function_value( &::SireFF::PotentialTable::what ); PotentialTable_exposer.def( "what" , what_function_value , "" ); } PotentialTable_exposer.staticmethod( "typeName" ); PotentialTable_exposer.def( "__copy__", &__copy__); PotentialTable_exposer.def( "__deepcopy__", &__copy__); PotentialTable_exposer.def( "clone", &__copy__); PotentialTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::PotentialTable >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); PotentialTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::PotentialTable >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); PotentialTable_exposer.def( "__str__", &pvt_get_name); PotentialTable_exposer.def( "__repr__", &pvt_get_name); } }
void register_InterGroupLJFF_class() { { //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > typedef bp::class_< SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >, bp::bases< SireFF::FF3D, SireFF::Inter2B2GFF<SireMM::LJPotentialInterface<SireMM::InterLJPotential> >, SireMM::LJPotentialInterface<SireMM::InterLJPotential>, SireFF::G2FF, SireFF::FF, SireMol::MolGroupsBase, SireBase::Property > > InterGroupLJFF_exposer_t; InterGroupLJFF_exposer_t InterGroupLJFF_exposer = InterGroupLJFF_exposer_t( "InterGroupLJFF", bp::init< >() ); bp::scope InterGroupLJFF_scope( InterGroupLJFF_exposer ); InterGroupLJFF_exposer.def( bp::init< QString const & >(( bp::arg("name") )) ); InterGroupLJFF_exposer.def( bp::init< SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > const & >(( bp::arg("other") )) ); { //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::energy typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t; typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*energy_function_type )( ::SireFF::EnergyTable &,double ) ; energy_function_type energy_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::energy ); InterGroupLJFF_exposer.def( "energy" , energy_function_value , ( bp::arg("energytable"), bp::arg("scale_energy")=1 ) ); } { //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::energy typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t; typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*energy_function_type )( ::SireFF::EnergyTable &,::SireCAS::Symbol const &,double ) ; energy_function_type energy_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::energy ); InterGroupLJFF_exposer.def( "energy" , energy_function_value , ( bp::arg("energytable"), bp::arg("symbol"), bp::arg("scale_energy")=1 ) ); } { //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t; typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*field_function_type )( ::SireFF::FieldTable &,double ) ; field_function_type field_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field ); InterGroupLJFF_exposer.def( "field" , field_function_value , ( bp::arg("fieldtable"), bp::arg("scale_field")=1 ) ); } { //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t; typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,double ) ; field_function_type field_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field ); InterGroupLJFF_exposer.def( "field" , field_function_value , ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("scale_field")=1 ) ); } { //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t; typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*field_function_type )( ::SireFF::FieldTable &,::SireFF::Probe const &,double ) ; field_function_type field_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field ); InterGroupLJFF_exposer.def( "field" , field_function_value , ( bp::arg("fieldtable"), bp::arg("probe"), bp::arg("scale_field")=1 ) ); } { //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t; typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ; field_function_type field_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field ); InterGroupLJFF_exposer.def( "field" , field_function_value , ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_field")=1 ) ); } { //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::force typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t; typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*force_function_type )( ::SireFF::ForceTable &,double ) ; force_function_type force_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::force ); InterGroupLJFF_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) ); } { //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::force typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t; typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*force_function_type )( ::SireFF::ForceTable &,::SireCAS::Symbol const &,double ) ; force_function_type force_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::force ); InterGroupLJFF_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("symbol"), bp::arg("scale_force")=1 ) ); } InterGroupLJFF_exposer.def( bp::self != bp::self ); { //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::operator= typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t; typedef ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > & ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*assign_function_type )( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > const & ) ; assign_function_type assign_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::operator= ); InterGroupLJFF_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } InterGroupLJFF_exposer.def( bp::self == bp::self ); { //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t; typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,double ) ; potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential ); InterGroupLJFF_exposer.def( "potential" , potential_function_value , ( bp::arg("potentialtable"), bp::arg("scale_potential")=1 ) ); } { //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t; typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,double ) ; potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential ); InterGroupLJFF_exposer.def( "potential" , potential_function_value , ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("scale_potential")=1 ) ); } { //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t; typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,::SireFF::Probe const &,double ) ; potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential ); InterGroupLJFF_exposer.def( "potential" , potential_function_value , ( bp::arg("potentialtable"), bp::arg("probe"), bp::arg("scale_potential")=1 ) ); } { //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t; typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ; potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential ); InterGroupLJFF_exposer.def( "potential" , potential_function_value , ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_potential")=1 ) ); } { //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::typeName typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t; typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::typeName ); InterGroupLJFF_exposer.def( "typeName" , typeName_function_value ); } { //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::what typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t; typedef char const * ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*what_function_type )( ) const; what_function_type what_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::what ); InterGroupLJFF_exposer.def( "what" , what_function_value ); } InterGroupLJFF_exposer.staticmethod( "typeName" ); InterGroupLJFF_exposer.def( "__copy__", &__copy__); InterGroupLJFF_exposer.def( "__deepcopy__", &__copy__); InterGroupLJFF_exposer.def( "clone", &__copy__); InterGroupLJFF_exposer.def( "__str__", &__str__< ::SireFF::Inter2B2G3DFF<SireMM::LJPotentialInterface<SireMM::InterLJPotential> > > ); InterGroupLJFF_exposer.def( "__repr__", &__str__< ::SireFF::Inter2B2G3DFF<SireMM::LJPotentialInterface<SireMM::InterLJPotential> > > ); InterGroupLJFF_exposer.def( "__len__", &__len_count< ::SireFF::Inter2B2G3DFF<SireMM::LJPotentialInterface<SireMM::InterLJPotential> > > ); } }
void register_CLJ14Group_class(){ { //::SireMM::CLJ14Group typedef bp::class_< SireMM::CLJ14Group > CLJ14Group_exposer_t; CLJ14Group_exposer_t CLJ14Group_exposer = CLJ14Group_exposer_t( "CLJ14Group", bp::init< >() ); bp::scope CLJ14Group_scope( CLJ14Group_exposer ); CLJ14Group_exposer.def( bp::init< SireMol::MoleculeView const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("molecule"), bp::arg("map")=SireBase::PropertyMap() )) ); CLJ14Group_exposer.def( bp::init< SireMol::MoleculeView const &, SireMM::CLJFunction::COMBINING_RULES, bool, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("molecule"), bp::arg("combining_rules"), bp::arg("is_strict"), bp::arg("map")=SireBase::PropertyMap() )) ); CLJ14Group_exposer.def( bp::init< SireMM::CLJ14Group const & >(( bp::arg("other") )) ); { //::SireMM::CLJ14Group::add typedef void ( ::SireMM::CLJ14Group::*add_function_type )( ::SireMol::MoleculeView const & ) ; add_function_type add_function_value( &::SireMM::CLJ14Group::add ); CLJ14Group_exposer.def( "add" , add_function_value , ( bp::arg("new_molecule") ) ); } { //::SireMM::CLJ14Group::add typedef void ( ::SireMM::CLJ14Group::*add_function_type )( ::SireMol::AtomSelection const & ) ; add_function_type add_function_value( &::SireMM::CLJ14Group::add ); CLJ14Group_exposer.def( "add" , add_function_value , ( bp::arg("new_selection") ) ); } { //::SireMM::CLJ14Group::combiningRules typedef ::SireMM::CLJFunction::COMBINING_RULES ( ::SireMM::CLJ14Group::*combiningRules_function_type )( ) const; combiningRules_function_type combiningRules_function_value( &::SireMM::CLJ14Group::combiningRules ); CLJ14Group_exposer.def( "combiningRules" , combiningRules_function_value ); } { //::SireMM::CLJ14Group::energy typedef ::boost::tuples::tuple< double, double, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > ( ::SireMM::CLJ14Group::*energy_function_type )( ) ; energy_function_type energy_function_value( &::SireMM::CLJ14Group::energy ); CLJ14Group_exposer.def( "energy" , energy_function_value ); } { //::SireMM::CLJ14Group::isNull typedef bool ( ::SireMM::CLJ14Group::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireMM::CLJ14Group::isNull ); CLJ14Group_exposer.def( "isNull" , isNull_function_value ); } { //::SireMM::CLJ14Group::isStrict typedef bool ( ::SireMM::CLJ14Group::*isStrict_function_type )( ) const; isStrict_function_type isStrict_function_value( &::SireMM::CLJ14Group::isStrict ); CLJ14Group_exposer.def( "isStrict" , isStrict_function_value ); } { //::SireMM::CLJ14Group::molecule typedef ::SireMol::MoleculeView const & ( ::SireMM::CLJ14Group::*molecule_function_type )( ) const; molecule_function_type molecule_function_value( &::SireMM::CLJ14Group::molecule ); CLJ14Group_exposer.def( "molecule" , molecule_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::CLJ14Group::mustNowRecalculateFromScratch typedef void ( ::SireMM::CLJ14Group::*mustNowRecalculateFromScratch_function_type )( ) ; mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::SireMM::CLJ14Group::mustNowRecalculateFromScratch ); CLJ14Group_exposer.def( "mustNowRecalculateFromScratch" , mustNowRecalculateFromScratch_function_value ); } { //::SireMM::CLJ14Group::mustReallyRecalculateFromScratch typedef void ( ::SireMM::CLJ14Group::*mustReallyRecalculateFromScratch_function_type )( ) ; mustReallyRecalculateFromScratch_function_type mustReallyRecalculateFromScratch_function_value( &::SireMM::CLJ14Group::mustReallyRecalculateFromScratch ); CLJ14Group_exposer.def( "mustReallyRecalculateFromScratch" , mustReallyRecalculateFromScratch_function_value ); } CLJ14Group_exposer.def( bp::self != bp::self ); { //::SireMM::CLJ14Group::operator= typedef ::SireMM::CLJ14Group & ( ::SireMM::CLJ14Group::*assign_function_type )( ::SireMM::CLJ14Group const & ) ; assign_function_type assign_function_value( &::SireMM::CLJ14Group::operator= ); CLJ14Group_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } CLJ14Group_exposer.def( bp::self == bp::self ); { //::SireMM::CLJ14Group::propertyMap typedef ::SireBase::PropertyMap ( ::SireMM::CLJ14Group::*propertyMap_function_type )( ) const; propertyMap_function_type propertyMap_function_value( &::SireMM::CLJ14Group::propertyMap ); CLJ14Group_exposer.def( "propertyMap" , propertyMap_function_value ); } { //::SireMM::CLJ14Group::recalculatingFromScratch typedef bool ( ::SireMM::CLJ14Group::*recalculatingFromScratch_function_type )( ) const; recalculatingFromScratch_function_type recalculatingFromScratch_function_value( &::SireMM::CLJ14Group::recalculatingFromScratch ); CLJ14Group_exposer.def( "recalculatingFromScratch" , recalculatingFromScratch_function_value ); } { //::SireMM::CLJ14Group::remove typedef void ( ::SireMM::CLJ14Group::*remove_function_type )( ::SireMol::AtomSelection const & ) ; remove_function_type remove_function_value( &::SireMM::CLJ14Group::remove ); CLJ14Group_exposer.def( "remove" , remove_function_value , ( bp::arg("new_selection") ) ); } { //::SireMM::CLJ14Group::remove typedef void ( ::SireMM::CLJ14Group::*remove_function_type )( ::SireMol::MoleculeView const & ) ; remove_function_type remove_function_value( &::SireMM::CLJ14Group::remove ); CLJ14Group_exposer.def( "remove" , remove_function_value , ( bp::arg("new_molecule") ) ); } { //::SireMM::CLJ14Group::setArithmeticCombiningRules typedef void ( ::SireMM::CLJ14Group::*setArithmeticCombiningRules_function_type )( bool ) ; setArithmeticCombiningRules_function_type setArithmeticCombiningRules_function_value( &::SireMM::CLJ14Group::setArithmeticCombiningRules ); CLJ14Group_exposer.def( "setArithmeticCombiningRules" , setArithmeticCombiningRules_function_value , ( bp::arg("on") ) ); } { //::SireMM::CLJ14Group::setCombiningRules typedef void ( ::SireMM::CLJ14Group::*setCombiningRules_function_type )( ::SireMM::CLJFunction::COMBINING_RULES ) ; setCombiningRules_function_type setCombiningRules_function_value( &::SireMM::CLJ14Group::setCombiningRules ); CLJ14Group_exposer.def( "setCombiningRules" , setCombiningRules_function_value , ( bp::arg("rules") ) ); } { //::SireMM::CLJ14Group::setGeometricCombiningRules typedef void ( ::SireMM::CLJ14Group::*setGeometricCombiningRules_function_type )( bool ) ; setGeometricCombiningRules_function_type setGeometricCombiningRules_function_value( &::SireMM::CLJ14Group::setGeometricCombiningRules ); CLJ14Group_exposer.def( "setGeometricCombiningRules" , setGeometricCombiningRules_function_value , ( bp::arg("on") ) ); } { //::SireMM::CLJ14Group::setStrict typedef bool ( ::SireMM::CLJ14Group::*setStrict_function_type )( bool ) ; setStrict_function_type setStrict_function_value( &::SireMM::CLJ14Group::setStrict ); CLJ14Group_exposer.def( "setStrict" , setStrict_function_value , ( bp::arg("isstrict") ) ); } { //::SireMM::CLJ14Group::toString typedef ::QString ( ::SireMM::CLJ14Group::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMM::CLJ14Group::toString ); CLJ14Group_exposer.def( "toString" , toString_function_value ); } { //::SireMM::CLJ14Group::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::CLJ14Group::typeName ); CLJ14Group_exposer.def( "typeName" , typeName_function_value ); } { //::SireMM::CLJ14Group::update typedef void ( ::SireMM::CLJ14Group::*update_function_type )( ::SireMol::MoleculeView const & ) ; update_function_type update_function_value( &::SireMM::CLJ14Group::update ); CLJ14Group_exposer.def( "update" , update_function_value , ( bp::arg("new_molecule") ) ); } { //::SireMM::CLJ14Group::updateSelection typedef void ( ::SireMM::CLJ14Group::*updateSelection_function_type )( ::SireMol::AtomSelection const & ) ; updateSelection_function_type updateSelection_function_value( &::SireMM::CLJ14Group::updateSelection ); CLJ14Group_exposer.def( "updateSelection" , updateSelection_function_value , ( bp::arg("selection") ) ); } { //::SireMM::CLJ14Group::usingArithmeticCombiningRules typedef bool ( ::SireMM::CLJ14Group::*usingArithmeticCombiningRules_function_type )( ) const; usingArithmeticCombiningRules_function_type usingArithmeticCombiningRules_function_value( &::SireMM::CLJ14Group::usingArithmeticCombiningRules ); CLJ14Group_exposer.def( "usingArithmeticCombiningRules" , usingArithmeticCombiningRules_function_value ); } { //::SireMM::CLJ14Group::usingGeometricCombiningRules typedef bool ( ::SireMM::CLJ14Group::*usingGeometricCombiningRules_function_type )( ) const; usingGeometricCombiningRules_function_type usingGeometricCombiningRules_function_value( &::SireMM::CLJ14Group::usingGeometricCombiningRules ); CLJ14Group_exposer.def( "usingGeometricCombiningRules" , usingGeometricCombiningRules_function_value ); } { //::SireMM::CLJ14Group::what typedef char const * ( ::SireMM::CLJ14Group::*what_function_type )( ) const; what_function_type what_function_value( &::SireMM::CLJ14Group::what ); CLJ14Group_exposer.def( "what" , what_function_value ); } { //::SireMM::CLJ14Group::wouldChangeProperties typedef bool ( ::SireMM::CLJ14Group::*wouldChangeProperties_function_type )( ::SireBase::PropertyMap const & ) const; wouldChangeProperties_function_type wouldChangeProperties_function_value( &::SireMM::CLJ14Group::wouldChangeProperties ); CLJ14Group_exposer.def( "wouldChangeProperties" , wouldChangeProperties_function_value , ( bp::arg("map") ) ); } CLJ14Group_exposer.staticmethod( "typeName" ); CLJ14Group_exposer.def( "__copy__", &__copy__); CLJ14Group_exposer.def( "__deepcopy__", &__copy__); CLJ14Group_exposer.def( "clone", &__copy__); CLJ14Group_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJ14Group >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CLJ14Group_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJ14Group >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CLJ14Group_exposer.def( "__str__", &__str__< ::SireMM::CLJ14Group > ); CLJ14Group_exposer.def( "__repr__", &__str__< ::SireMM::CLJ14Group > ); } }
void register_LJParameter_class(){ { //::SireMM::LJParameter typedef bp::class_< SireMM::LJParameter > LJParameter_exposer_t; LJParameter_exposer_t LJParameter_exposer = LJParameter_exposer_t( "LJParameter", bp::init< >() ); bp::scope LJParameter_scope( LJParameter_exposer ); LJParameter_exposer.def( bp::init< SireUnits::Dimension::Length, SireUnits::Dimension::MolarEnergy >(( bp::arg("sigma"), bp::arg("epsilon") )) ); LJParameter_exposer.def( bp::init< SireMM::LJPair const & >(( bp::arg("ljpair") )) ); LJParameter_exposer.def( bp::init< SireMM::LJParameter const & >(( bp::arg("param") )) ); { //::SireMM::LJParameter::A typedef double ( ::SireMM::LJParameter::*A_function_type )( ) const; A_function_type A_function_value( &::SireMM::LJParameter::A ); LJParameter_exposer.def( "A" , A_function_value ); } { //::SireMM::LJParameter::B typedef double ( ::SireMM::LJParameter::*B_function_type )( ) const; B_function_type B_function_value( &::SireMM::LJParameter::B ); LJParameter_exposer.def( "B" , B_function_value ); } { //::SireMM::LJParameter::dummy typedef ::SireMM::LJParameter ( *dummy_function_type )( ); dummy_function_type dummy_function_value( &::SireMM::LJParameter::dummy ); LJParameter_exposer.def( "dummy" , dummy_function_value ); } { //::SireMM::LJParameter::epsilon typedef ::SireUnits::Dimension::MolarEnergy ( ::SireMM::LJParameter::*epsilon_function_type )( ) const; epsilon_function_type epsilon_function_value( &::SireMM::LJParameter::epsilon ); LJParameter_exposer.def( "epsilon" , epsilon_function_value ); } { //::SireMM::LJParameter::fromAAndB typedef ::SireMM::LJParameter ( *fromAAndB_function_type )( double,double ); fromAAndB_function_type fromAAndB_function_value( &::SireMM::LJParameter::fromAAndB ); LJParameter_exposer.def( "fromAAndB" , fromAAndB_function_value , ( bp::arg("a"), bp::arg("b") ) ); } { //::SireMM::LJParameter::fromRMinAndEpsilon typedef ::SireMM::LJParameter ( *fromRMinAndEpsilon_function_type )( ::SireUnits::Dimension::Length,::SireUnits::Dimension::MolarEnergy ); fromRMinAndEpsilon_function_type fromRMinAndEpsilon_function_value( &::SireMM::LJParameter::fromRMinAndEpsilon ); LJParameter_exposer.def( "fromRMinAndEpsilon" , fromRMinAndEpsilon_function_value , ( bp::arg("rmin"), bp::arg("epsilon") ) ); } { //::SireMM::LJParameter::fromSigmaAndEpsilon typedef ::SireMM::LJParameter ( *fromSigmaAndEpsilon_function_type )( ::SireUnits::Dimension::Length,::SireUnits::Dimension::MolarEnergy ); fromSigmaAndEpsilon_function_type fromSigmaAndEpsilon_function_value( &::SireMM::LJParameter::fromSigmaAndEpsilon ); LJParameter_exposer.def( "fromSigmaAndEpsilon" , fromSigmaAndEpsilon_function_value , ( bp::arg("sigma"), bp::arg("epsilon") ) ); } { //::SireMM::LJParameter::isDummy typedef bool ( ::SireMM::LJParameter::*isDummy_function_type )( ) const; isDummy_function_type isDummy_function_value( &::SireMM::LJParameter::isDummy ); LJParameter_exposer.def( "isDummy" , isDummy_function_value ); } LJParameter_exposer.def( bp::self != bp::self ); LJParameter_exposer.def( bp::self == bp::self ); { //::SireMM::LJParameter::rmin typedef ::SireUnits::Dimension::Length ( ::SireMM::LJParameter::*rmin_function_type )( ) const; rmin_function_type rmin_function_value( &::SireMM::LJParameter::rmin ); LJParameter_exposer.def( "rmin" , rmin_function_value ); } { //::SireMM::LJParameter::sigma typedef ::SireUnits::Dimension::Length ( ::SireMM::LJParameter::*sigma_function_type )( ) const; sigma_function_type sigma_function_value( &::SireMM::LJParameter::sigma ); LJParameter_exposer.def( "sigma" , sigma_function_value ); } { //::SireMM::LJParameter::sqrtEpsilon typedef double ( ::SireMM::LJParameter::*sqrtEpsilon_function_type )( ) const; sqrtEpsilon_function_type sqrtEpsilon_function_value( &::SireMM::LJParameter::sqrtEpsilon ); LJParameter_exposer.def( "sqrtEpsilon" , sqrtEpsilon_function_value ); } { //::SireMM::LJParameter::sqrtSigma typedef double ( ::SireMM::LJParameter::*sqrtSigma_function_type )( ) const; sqrtSigma_function_type sqrtSigma_function_value( &::SireMM::LJParameter::sqrtSigma ); LJParameter_exposer.def( "sqrtSigma" , sqrtSigma_function_value ); } { //::SireMM::LJParameter::toString typedef ::QString ( ::SireMM::LJParameter::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMM::LJParameter::toString ); LJParameter_exposer.def( "toString" , toString_function_value ); } { //::SireMM::LJParameter::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::LJParameter::typeName ); LJParameter_exposer.def( "typeName" , typeName_function_value ); } { //::SireMM::LJParameter::what typedef char const * ( ::SireMM::LJParameter::*what_function_type )( ) const; what_function_type what_function_value( &::SireMM::LJParameter::what ); LJParameter_exposer.def( "what" , what_function_value ); } { //::SireMM::LJParameter::zeroLJ typedef bool ( ::SireMM::LJParameter::*zeroLJ_function_type )( ) const; zeroLJ_function_type zeroLJ_function_value( &::SireMM::LJParameter::zeroLJ ); LJParameter_exposer.def( "zeroLJ" , zeroLJ_function_value ); } LJParameter_exposer.staticmethod( "dummy" ); LJParameter_exposer.staticmethod( "fromAAndB" ); LJParameter_exposer.staticmethod( "fromRMinAndEpsilon" ); LJParameter_exposer.staticmethod( "fromSigmaAndEpsilon" ); LJParameter_exposer.staticmethod( "typeName" ); LJParameter_exposer.def( "__copy__", &__copy__); LJParameter_exposer.def( "__deepcopy__", &__copy__); LJParameter_exposer.def( "clone", &__copy__); LJParameter_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::LJParameter >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); LJParameter_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::LJParameter >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); LJParameter_exposer.def( "__str__", &__str__< ::SireMM::LJParameter > ); LJParameter_exposer.def( "__repr__", &__str__< ::SireMM::LJParameter > ); } }
void register_InterGroupCLJFFBase_class(){ { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > typedef bp::class_< SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >, bp::bases< SireMM::CLJPotentialInterface<SireMM::InterCLJPotential>, SireFF::G2FF, SireFF::FF, SireMol::MolGroupsBase, SireBase::Property > > InterGroupCLJFFBase_exposer_t; InterGroupCLJFFBase_exposer_t InterGroupCLJFFBase_exposer = InterGroupCLJFFBase_exposer_t( "InterGroupCLJFFBase", "", bp::init< >("") ); bp::scope InterGroupCLJFFBase_scope( InterGroupCLJFFBase_exposer ); InterGroupCLJFFBase_exposer.def( bp::init< QString const & >(( bp::arg("name") ), "") ); InterGroupCLJFFBase_exposer.def( bp::init< SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > const & >(( bp::arg("other") ), "") ); { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::components typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t; typedef ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::Components const & ( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*components_function_type)( ) const; components_function_type components_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::components ); InterGroupCLJFFBase_exposer.def( "components" , components_function_value , bp::return_value_policy<bp::clone_const_reference>() , "" ); } { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::containsProperty typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t; typedef bool ( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*containsProperty_function_type)( ::QString const & ) const; containsProperty_function_type containsProperty_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::containsProperty ); InterGroupCLJFFBase_exposer.def( "containsProperty" , containsProperty_function_value , ( bp::arg("name") ) , "" ); } { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::mustNowRecalculateFromScratch typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t; typedef void ( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*mustNowRecalculateFromScratch_function_type)( ) ; mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::mustNowRecalculateFromScratch ); InterGroupCLJFFBase_exposer.def( "mustNowRecalculateFromScratch" , mustNowRecalculateFromScratch_function_value , "" ); } InterGroupCLJFFBase_exposer.def( bp::self != bp::self ); { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::operator= typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t; typedef ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > & ( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*assign_function_type)( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > const & ) ; assign_function_type assign_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::operator= ); InterGroupCLJFFBase_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } InterGroupCLJFFBase_exposer.def( bp::self == bp::self ); { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::properties typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t; typedef ::SireBase::Properties const & ( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*properties_function_type)( ) const; properties_function_type properties_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::properties ); InterGroupCLJFFBase_exposer.def( "properties" , properties_function_value , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::property typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t; typedef ::SireBase::Property const & ( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*property_function_type)( ::QString const & ) const; property_function_type property_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::property ); InterGroupCLJFFBase_exposer.def( "property" , property_function_value , ( bp::arg("name") ) , bp::return_value_policy<bp::clone_const_reference>() , "" ); } { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::setProperty typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t; typedef bool ( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*setProperty_function_type)( ::QString const &,::SireBase::Property const & ) ; setProperty_function_type setProperty_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::setProperty ); InterGroupCLJFFBase_exposer.def( "setProperty" , setProperty_function_value , ( bp::arg("name"), bp::arg("property") ) , "" ); } { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::typeName typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t; typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::typeName ); InterGroupCLJFFBase_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::what typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t; typedef char const * ( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*what_function_type)( ) const; what_function_type what_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::what ); InterGroupCLJFFBase_exposer.def( "what" , what_function_value , "" ); } InterGroupCLJFFBase_exposer.staticmethod( "typeName" ); InterGroupCLJFFBase_exposer.def( "__copy__", &__copy__); InterGroupCLJFFBase_exposer.def( "__deepcopy__", &__copy__); InterGroupCLJFFBase_exposer.def( "clone", &__copy__); InterGroupCLJFFBase_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::Inter2B2GFF<SireMM::CLJPotentialInterface<SireMM::InterCLJPotential> > >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); InterGroupCLJFFBase_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::Inter2B2GFF<SireMM::CLJPotentialInterface<SireMM::InterCLJPotential> > >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); InterGroupCLJFFBase_exposer.def( "__str__", &__str__< ::SireFF::Inter2B2GFF<SireMM::CLJPotentialInterface<SireMM::InterCLJPotential> > > ); InterGroupCLJFFBase_exposer.def( "__repr__", &__str__< ::SireFF::Inter2B2GFF<SireMM::CLJPotentialInterface<SireMM::InterCLJPotential> > > ); InterGroupCLJFFBase_exposer.def( "__len__", &__len_count< ::SireFF::Inter2B2GFF<SireMM::CLJPotentialInterface<SireMM::InterCLJPotential> > > ); } }
void register_AtomMultiMatcher_class(){ { //::SireMol::AtomMultiMatcher typedef bp::class_< SireMol::AtomMultiMatcher, bp::bases< SireMol::AtomMatcher, SireBase::Property > > AtomMultiMatcher_exposer_t; AtomMultiMatcher_exposer_t AtomMultiMatcher_exposer = AtomMultiMatcher_exposer_t( "AtomMultiMatcher", "This is an atom matcher combines several sub-AtomMatchers together\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") ); bp::scope AtomMultiMatcher_scope( AtomMultiMatcher_exposer ); AtomMultiMatcher_exposer.def( bp::init< SireMol::AtomMatcher const & >(( bp::arg("matcher") ), "Construct from a single match") ); AtomMultiMatcher_exposer.def( bp::init< SireMol::AtomMatcher const &, SireMol::AtomMatcher const & >(( bp::arg("m0"), bp::arg("m1") ), "Construct from a pair of matches") ); AtomMultiMatcher_exposer.def( bp::init< SireMol::AtomMultiMatcher const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMol::AtomMultiMatcher::isNull typedef bool ( ::SireMol::AtomMultiMatcher::*isNull_function_type)( ) const; isNull_function_type isNull_function_value( &::SireMol::AtomMultiMatcher::isNull ); AtomMultiMatcher_exposer.def( "isNull" , isNull_function_value , "Return whether or not this matcher is null (cannot be used for matching)" ); } AtomMultiMatcher_exposer.def( bp::self != bp::self ); { //::SireMol::AtomMultiMatcher::operator= typedef ::SireMol::AtomMultiMatcher & ( ::SireMol::AtomMultiMatcher::*assign_function_type)( ::SireMol::AtomMultiMatcher const & ) ; assign_function_type assign_function_value( &::SireMol::AtomMultiMatcher::operator= ); AtomMultiMatcher_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } AtomMultiMatcher_exposer.def( bp::self == bp::self ); { //::SireMol::AtomMultiMatcher::toString typedef ::QString ( ::SireMol::AtomMultiMatcher::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMol::AtomMultiMatcher::toString ); AtomMultiMatcher_exposer.def( "toString" , toString_function_value , "" ); } { //::SireMol::AtomMultiMatcher::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::AtomMultiMatcher::typeName ); AtomMultiMatcher_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMol::AtomMultiMatcher::what typedef char const * ( ::SireMol::AtomMultiMatcher::*what_function_type)( ) const; what_function_type what_function_value( &::SireMol::AtomMultiMatcher::what ); AtomMultiMatcher_exposer.def( "what" , what_function_value , "" ); } AtomMultiMatcher_exposer.staticmethod( "typeName" ); AtomMultiMatcher_exposer.def( "__copy__", &__copy__); AtomMultiMatcher_exposer.def( "__deepcopy__", &__copy__); AtomMultiMatcher_exposer.def( "clone", &__copy__); AtomMultiMatcher_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::AtomMultiMatcher >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); AtomMultiMatcher_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::AtomMultiMatcher >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); AtomMultiMatcher_exposer.def( "__str__", &__str__< ::SireMol::AtomMultiMatcher > ); AtomMultiMatcher_exposer.def( "__repr__", &__str__< ::SireMol::AtomMultiMatcher > ); } }
void register_QMFF_class(){ { //::Squire::QMFF typedef bp::class_< Squire::QMFF, bp::bases< SireFF::FF3D, SireFF::G1FF, SireFF::FF, SireMol::MolGroupsBase, SireBase::Property > > QMFF_exposer_t; QMFF_exposer_t QMFF_exposer = QMFF_exposer_t( "QMFF", bp::init< >() ); bp::scope QMFF_scope( QMFF_exposer ); QMFF_exposer.def( bp::init< QString const & >(( bp::arg("name") )) ); QMFF_exposer.def( bp::init< Squire::QMFF const & >(( bp::arg("other") )) ); { //::Squire::QMFF::components typedef ::Squire::QMComponent const & ( ::Squire::QMFF::*components_function_type )( ) const; components_function_type components_function_value( &::Squire::QMFF::components ); QMFF_exposer.def( "components" , components_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::Squire::QMFF::containsProperty typedef bool ( ::Squire::QMFF::*containsProperty_function_type )( ::QString const & ) const; containsProperty_function_type containsProperty_function_value( &::Squire::QMFF::containsProperty ); QMFF_exposer.def( "containsProperty" , containsProperty_function_value , ( bp::arg("name") ) ); } { //::Squire::QMFF::energy typedef void ( ::Squire::QMFF::*energy_function_type )( ::SireFF::EnergyTable &,double ) ; energy_function_type energy_function_value( &::Squire::QMFF::energy ); QMFF_exposer.def( "energy" , energy_function_value , ( bp::arg("energytable"), bp::arg("scale_energy")=1 ) ); } { //::Squire::QMFF::energy typedef void ( ::Squire::QMFF::*energy_function_type )( ::SireFF::EnergyTable &,::SireCAS::Symbol const &,double ) ; energy_function_type energy_function_value( &::Squire::QMFF::energy ); QMFF_exposer.def( "energy" , energy_function_value , ( bp::arg("energytable"), bp::arg("symbol"), bp::arg("scale_energy")=1 ) ); } { //::Squire::QMFF::energyCommandFile typedef ::QString ( ::Squire::QMFF::*energyCommandFile_function_type )( ) const; energyCommandFile_function_type energyCommandFile_function_value( &::Squire::QMFF::energyCommandFile ); QMFF_exposer.def( "energyCommandFile" , energyCommandFile_function_value ); } { //::Squire::QMFF::field typedef void ( ::Squire::QMFF::*field_function_type )( ::SireFF::FieldTable &,double ) ; field_function_type field_function_value( &::Squire::QMFF::field ); QMFF_exposer.def( "field" , field_function_value , ( bp::arg("fieldtable"), bp::arg("scale_field")=1 ) ); } { //::Squire::QMFF::field typedef void ( ::Squire::QMFF::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,double ) ; field_function_type field_function_value( &::Squire::QMFF::field ); QMFF_exposer.def( "field" , field_function_value , ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("scale_field")=1 ) ); } { //::Squire::QMFF::field typedef void ( ::Squire::QMFF::*field_function_type )( ::SireFF::FieldTable &,::SireFF::Probe const &,double ) ; field_function_type field_function_value( &::Squire::QMFF::field ); QMFF_exposer.def( "field" , field_function_value , ( bp::arg("fieldtable"), bp::arg("probe"), bp::arg("scale_field")=1 ) ); } { //::Squire::QMFF::field typedef void ( ::Squire::QMFF::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ; field_function_type field_function_value( &::Squire::QMFF::field ); QMFF_exposer.def( "field" , field_function_value , ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_field")=1 ) ); } { //::Squire::QMFF::fieldCommandFile typedef ::QString ( ::Squire::QMFF::*fieldCommandFile_function_type )( ::SireFF::FieldTable const & ) const; fieldCommandFile_function_type fieldCommandFile_function_value( &::Squire::QMFF::fieldCommandFile ); QMFF_exposer.def( "fieldCommandFile" , fieldCommandFile_function_value , ( bp::arg("fieldtable") ) ); } { //::Squire::QMFF::fieldCommandFile typedef ::QString ( ::Squire::QMFF::*fieldCommandFile_function_type )( ::SireFF::FieldTable const &,::SireFF::Probe const & ) const; fieldCommandFile_function_type fieldCommandFile_function_value( &::Squire::QMFF::fieldCommandFile ); QMFF_exposer.def( "fieldCommandFile" , fieldCommandFile_function_value , ( bp::arg("fieldtable"), bp::arg("probe") ) ); } { //::Squire::QMFF::force typedef void ( ::Squire::QMFF::*force_function_type )( ::SireFF::ForceTable &,double ) ; force_function_type force_function_value( &::Squire::QMFF::force ); QMFF_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) ); } { //::Squire::QMFF::force typedef void ( ::Squire::QMFF::*force_function_type )( ::SireFF::ForceTable &,::SireCAS::Symbol const &,double ) ; force_function_type force_function_value( &::Squire::QMFF::force ); QMFF_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("symbol"), bp::arg("scale_force")=1 ) ); } { //::Squire::QMFF::forceCommandFile typedef ::QString ( ::Squire::QMFF::*forceCommandFile_function_type )( ::SireFF::ForceTable const & ) const; forceCommandFile_function_type forceCommandFile_function_value( &::Squire::QMFF::forceCommandFile ); QMFF_exposer.def( "forceCommandFile" , forceCommandFile_function_value , ( bp::arg("forcetable") ) ); } { //::Squire::QMFF::mustNowRecalculateFromScratch typedef void ( ::Squire::QMFF::*mustNowRecalculateFromScratch_function_type )( ) ; mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::Squire::QMFF::mustNowRecalculateFromScratch ); QMFF_exposer.def( "mustNowRecalculateFromScratch" , mustNowRecalculateFromScratch_function_value ); } QMFF_exposer.def( bp::self != bp::self ); { //::Squire::QMFF::operator= typedef ::Squire::QMFF & ( ::Squire::QMFF::*assign_function_type )( ::Squire::QMFF const & ) ; assign_function_type assign_function_value( &::Squire::QMFF::operator= ); QMFF_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } QMFF_exposer.def( bp::self == bp::self ); { //::Squire::QMFF::parameters typedef ::SireFF::detail::AtomicParameters3D< SireMol::Element > ( ::Squire::QMFF::*parameters_function_type )( ) const; parameters_function_type parameters_function_value( &::Squire::QMFF::parameters ); QMFF_exposer.def( "parameters" , parameters_function_value ); } { //::Squire::QMFF::potential typedef void ( ::Squire::QMFF::*potential_function_type )( ::SireFF::PotentialTable &,double ) ; potential_function_type potential_function_value( &::Squire::QMFF::potential ); QMFF_exposer.def( "potential" , potential_function_value , ( bp::arg("potentialtable"), bp::arg("scale_potential")=1 ) ); } { //::Squire::QMFF::potential typedef void ( ::Squire::QMFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,double ) ; potential_function_type potential_function_value( &::Squire::QMFF::potential ); QMFF_exposer.def( "potential" , potential_function_value , ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("scale_potential")=1 ) ); } { //::Squire::QMFF::potential typedef void ( ::Squire::QMFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireFF::Probe const &,double ) ; potential_function_type potential_function_value( &::Squire::QMFF::potential ); QMFF_exposer.def( "potential" , potential_function_value , ( bp::arg("potentialtable"), bp::arg("probe"), bp::arg("scale_potential")=1 ) ); } { //::Squire::QMFF::potential typedef void ( ::Squire::QMFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ; potential_function_type potential_function_value( &::Squire::QMFF::potential ); QMFF_exposer.def( "potential" , potential_function_value , ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_potential")=1 ) ); } { //::Squire::QMFF::potentialCommandFile typedef ::QString ( ::Squire::QMFF::*potentialCommandFile_function_type )( ::SireFF::PotentialTable const & ) const; potentialCommandFile_function_type potentialCommandFile_function_value( &::Squire::QMFF::potentialCommandFile ); QMFF_exposer.def( "potentialCommandFile" , potentialCommandFile_function_value , ( bp::arg("pottable") ) ); } { //::Squire::QMFF::potentialCommandFile typedef ::QString ( ::Squire::QMFF::*potentialCommandFile_function_type )( ::SireFF::PotentialTable const &,::SireFF::Probe const & ) const; potentialCommandFile_function_type potentialCommandFile_function_value( &::Squire::QMFF::potentialCommandFile ); QMFF_exposer.def( "potentialCommandFile" , potentialCommandFile_function_value , ( bp::arg("pottable"), bp::arg("probe") ) ); } { //::Squire::QMFF::properties typedef ::SireBase::Properties const & ( ::Squire::QMFF::*properties_function_type )( ) const; properties_function_type properties_function_value( &::Squire::QMFF::properties ); QMFF_exposer.def( "properties" , properties_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::Squire::QMFF::property typedef ::SireBase::Property const & ( ::Squire::QMFF::*property_function_type )( ::QString const & ) const; property_function_type property_function_value( &::Squire::QMFF::property ); QMFF_exposer.def( "property" , property_function_value , ( bp::arg("name") ) , bp::return_value_policy<bp::clone_const_reference>() ); } { //::Squire::QMFF::quantumProgram typedef ::Squire::QMProgram const & ( ::Squire::QMFF::*quantumProgram_function_type )( ) const; quantumProgram_function_type quantumProgram_function_value( &::Squire::QMFF::quantumProgram ); QMFF_exposer.def( "quantumProgram" , quantumProgram_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::Squire::QMFF::setProperty typedef bool ( ::Squire::QMFF::*setProperty_function_type )( ::QString const &,::SireBase::Property const & ) ; setProperty_function_type setProperty_function_value( &::Squire::QMFF::setProperty ); QMFF_exposer.def( "setProperty" , setProperty_function_value , ( bp::arg("name"), bp::arg("property") ) ); } { //::Squire::QMFF::setQuantumProgram typedef bool ( ::Squire::QMFF::*setQuantumProgram_function_type )( ::Squire::QMProgram const & ) ; setQuantumProgram_function_type setQuantumProgram_function_value( &::Squire::QMFF::setQuantumProgram ); QMFF_exposer.def( "setQuantumProgram" , setQuantumProgram_function_value , ( bp::arg("qmprog") ) ); } { //::Squire::QMFF::setSpace typedef bool ( ::Squire::QMFF::*setSpace_function_type )( ::SireVol::Space const & ) ; setSpace_function_type setSpace_function_value( &::Squire::QMFF::setSpace ); QMFF_exposer.def( "setSpace" , setSpace_function_value , ( bp::arg("space") ) ); } { //::Squire::QMFF::setZeroEnergy typedef bool ( ::Squire::QMFF::*setZeroEnergy_function_type )( ::SireUnits::Dimension::MolarEnergy ) ; setZeroEnergy_function_type setZeroEnergy_function_value( &::Squire::QMFF::setZeroEnergy ); QMFF_exposer.def( "setZeroEnergy" , setZeroEnergy_function_value , ( bp::arg("zero_energy") ) ); } { //::Squire::QMFF::space typedef ::SireVol::Space const & ( ::Squire::QMFF::*space_function_type )( ) const; space_function_type space_function_value( &::Squire::QMFF::space ); QMFF_exposer.def( "space" , space_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::Squire::QMFF::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::Squire::QMFF::typeName ); QMFF_exposer.def( "typeName" , typeName_function_value ); } { //::Squire::QMFF::what typedef char const * ( ::Squire::QMFF::*what_function_type )( ) const; what_function_type what_function_value( &::Squire::QMFF::what ); QMFF_exposer.def( "what" , what_function_value ); } { //::Squire::QMFF::zeroEnergy typedef ::SireUnits::Dimension::MolarEnergy ( ::Squire::QMFF::*zeroEnergy_function_type )( ) const; zeroEnergy_function_type zeroEnergy_function_value( &::Squire::QMFF::zeroEnergy ); QMFF_exposer.def( "zeroEnergy" , zeroEnergy_function_value ); } QMFF_exposer.staticmethod( "typeName" ); QMFF_exposer.def( "__copy__", &__copy__); QMFF_exposer.def( "__deepcopy__", &__copy__); QMFF_exposer.def( "clone", &__copy__); QMFF_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::Squire::QMFF >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); QMFF_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::Squire::QMFF >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); QMFF_exposer.def( "__str__", &__str__< ::Squire::QMFF > ); QMFF_exposer.def( "__repr__", &__str__< ::Squire::QMFF > ); QMFF_exposer.def( "__len__", &__len_count< ::Squire::QMFF > ); } }
void register_Tan_class(){ { //::SireCAS::Tan typedef bp::class_< SireCAS::Tan, bp::bases< SireCAS::SingleFunc, SireCAS::ExBase > > Tan_exposer_t; Tan_exposer_t Tan_exposer = Tan_exposer_t( "Tan", "Tangent", bp::init< >("Null constructor") ); bp::scope Tan_scope( Tan_exposer ); Tan_exposer.def( bp::init< SireCAS::Expression const & >(( bp::arg("ex") ), "Construct cos(expression)") ); Tan_exposer.def( bp::init< SireCAS::Tan const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireCAS::Tan::evaluate typedef double ( ::SireCAS::Tan::*evaluate_function_type)( ::SireCAS::Values const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Tan::evaluate ); Tan_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) , "Evaluate this function" ); } { //::SireCAS::Tan::evaluate typedef ::SireMaths::Complex ( ::SireCAS::Tan::*evaluate_function_type)( ::SireCAS::ComplexValues const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Tan::evaluate ); Tan_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) , "Complex evaluation" ); } Tan_exposer.def( bp::self == bp::other< SireCAS::ExBase >() ); { //::SireCAS::Tan::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireCAS::Tan::typeName ); Tan_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireCAS::Tan::what typedef char const * ( ::SireCAS::Tan::*what_function_type)( ) const; what_function_type what_function_value( &::SireCAS::Tan::what ); Tan_exposer.def( "what" , what_function_value , "" ); } Tan_exposer.staticmethod( "typeName" ); Tan_exposer.def( "__copy__", &__copy__); Tan_exposer.def( "__deepcopy__", &__copy__); Tan_exposer.def( "clone", &__copy__); Tan_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Tan >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Tan_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Tan >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Tan_exposer.def( "__str__", &__str__< ::SireCAS::Tan > ); Tan_exposer.def( "__repr__", &__str__< ::SireCAS::Tan > ); Tan_exposer.def( "__hash__", &::SireCAS::Tan::hash ); } }
void register_SupraSubSimPacket_class(){ { //::SireMove::SupraSubSimPacket typedef bp::class_< SireMove::SupraSubSimPacket, bp::bases< SireCluster::WorkPacketBase > > SupraSubSimPacket_exposer_t; SupraSubSimPacket_exposer_t SupraSubSimPacket_exposer = SupraSubSimPacket_exposer_t( "SupraSubSimPacket", bp::init< >() ); bp::scope SupraSubSimPacket_scope( SupraSubSimPacket_exposer ); SupraSubSimPacket_exposer.def( bp::init< SireMove::SupraSubSystem const &, SireMove::SupraSubMoves const &, int, bp::optional< bool > >(( bp::arg("system"), bp::arg("moves"), bp::arg("nmoves"), bp::arg("record_stats")=(bool)(true) )) ); SupraSubSimPacket_exposer.def( bp::init< SireMove::SupraSubSimPacket const & >(( bp::arg("other") )) ); { //::SireMove::SupraSubSimPacket::approximatePacketSize typedef int ( ::SireMove::SupraSubSimPacket::*approximatePacketSize_function_type )( ) const; approximatePacketSize_function_type approximatePacketSize_function_value( &::SireMove::SupraSubSimPacket::approximatePacketSize ); SupraSubSimPacket_exposer.def( "approximatePacketSize" , approximatePacketSize_function_value ); } { //::SireMove::SupraSubSimPacket::hasFinished typedef bool ( ::SireMove::SupraSubSimPacket::*hasFinished_function_type )( ) const; hasFinished_function_type hasFinished_function_value( &::SireMove::SupraSubSimPacket::hasFinished ); SupraSubSimPacket_exposer.def( "hasFinished" , hasFinished_function_value ); } { //::SireMove::SupraSubSimPacket::nSubCompleted typedef int ( ::SireMove::SupraSubSimPacket::*nSubCompleted_function_type )( ) const; nSubCompleted_function_type nSubCompleted_function_value( &::SireMove::SupraSubSimPacket::nSubCompleted ); SupraSubSimPacket_exposer.def( "nSubCompleted" , nSubCompleted_function_value ); } { //::SireMove::SupraSubSimPacket::nSubMoves typedef int ( ::SireMove::SupraSubSimPacket::*nSubMoves_function_type )( ) const; nSubMoves_function_type nSubMoves_function_value( &::SireMove::SupraSubSimPacket::nSubMoves ); SupraSubSimPacket_exposer.def( "nSubMoves" , nSubMoves_function_value ); } SupraSubSimPacket_exposer.def( bp::self != bp::self ); { //::SireMove::SupraSubSimPacket::operator= typedef ::SireMove::SupraSubSimPacket & ( ::SireMove::SupraSubSimPacket::*assign_function_type )( ::SireMove::SupraSubSimPacket const & ) ; assign_function_type assign_function_value( &::SireMove::SupraSubSimPacket::operator= ); SupraSubSimPacket_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } SupraSubSimPacket_exposer.def( bp::self == bp::self ); { //::SireMove::SupraSubSimPacket::recordingSubStatistics typedef bool ( ::SireMove::SupraSubSimPacket::*recordingSubStatistics_function_type )( ) const; recordingSubStatistics_function_type recordingSubStatistics_function_value( &::SireMove::SupraSubSimPacket::recordingSubStatistics ); SupraSubSimPacket_exposer.def( "recordingSubStatistics" , recordingSubStatistics_function_value ); } { //::SireMove::SupraSubSimPacket::shouldPack typedef bool ( ::SireMove::SupraSubSimPacket::*shouldPack_function_type )( ) const; shouldPack_function_type shouldPack_function_value( &::SireMove::SupraSubSimPacket::shouldPack ); SupraSubSimPacket_exposer.def( "shouldPack" , shouldPack_function_value ); } { //::SireMove::SupraSubSimPacket::subMoves typedef ::SireMove::SupraSubMoves const & ( ::SireMove::SupraSubSimPacket::*subMoves_function_type )( ) const; subMoves_function_type subMoves_function_value( &::SireMove::SupraSubSimPacket::subMoves ); SupraSubSimPacket_exposer.def( "subMoves" , subMoves_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMove::SupraSubSimPacket::subSystem typedef ::SireMove::SupraSubSystem const & ( ::SireMove::SupraSubSimPacket::*subSystem_function_type )( ) const; subSystem_function_type subSystem_function_value( &::SireMove::SupraSubSimPacket::subSystem ); SupraSubSimPacket_exposer.def( "subSystem" , subSystem_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMove::SupraSubSimPacket::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMove::SupraSubSimPacket::typeName ); SupraSubSimPacket_exposer.def( "typeName" , typeName_function_value ); } { //::SireMove::SupraSubSimPacket::what typedef char const * ( ::SireMove::SupraSubSimPacket::*what_function_type )( ) const; what_function_type what_function_value( &::SireMove::SupraSubSimPacket::what ); SupraSubSimPacket_exposer.def( "what" , what_function_value ); } SupraSubSimPacket_exposer.staticmethod( "typeName" ); SupraSubSimPacket_exposer.def( "__copy__", &__copy__); SupraSubSimPacket_exposer.def( "__deepcopy__", &__copy__); SupraSubSimPacket_exposer.def( "clone", &__copy__); SupraSubSimPacket_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::SupraSubSimPacket >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); SupraSubSimPacket_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::SupraSubSimPacket >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); SupraSubSimPacket_exposer.def( "__str__", &pvt_get_name); SupraSubSimPacket_exposer.def( "__repr__", &pvt_get_name); } }
void register_CLJWorkspace_class(){ { //::SireMM::CLJWorkspace typedef bp::class_< SireMM::CLJWorkspace > CLJWorkspace_exposer_t; CLJWorkspace_exposer_t CLJWorkspace_exposer = CLJWorkspace_exposer_t( "CLJWorkspace", "This class provides a workspace in which to hold the details of the changes\nthat occur in a CLJ forcefield during a Monte Carlo move. The class is optimised\nto avoid copying or duplicating data during Sires copy-on-write copying\n(e.g. the memory allocated in a workspace will always be available for the\nnew copy of a forcefield rather than the old, which, if things work correctly,\nwill mean that there should be no memory allocation during simple MC moves...)\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") ); bp::scope CLJWorkspace_scope( CLJWorkspace_exposer ); CLJWorkspace_exposer.def( bp::init< SireMM::CLJWorkspace const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMM::CLJWorkspace::accept typedef void ( ::SireMM::CLJWorkspace::*accept_function_type)( ::SireMM::CLJBoxes & ) ; accept_function_type accept_function_value( &::SireMM::CLJWorkspace::accept ); CLJWorkspace_exposer.def( "accept" , accept_function_value , ( bp::arg("boxes") ) , "Accept this workspace - this clears the recalc_from_scratch flag as it\nsignals that we have put the CLJBoxes into a sane state" ); } { //::SireMM::CLJWorkspace::at typedef ::SireMM::CLJDelta const & ( ::SireMM::CLJWorkspace::*at_function_type)( int ) const; at_function_type at_function_value( &::SireMM::CLJWorkspace::at ); CLJWorkspace_exposer.def( "at" , at_function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() , "Return the ith delta" ); } { //::SireMM::CLJWorkspace::changedAtoms typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*changedAtoms_function_type)( ) const; changedAtoms_function_type changedAtoms_function_value( &::SireMM::CLJWorkspace::changedAtoms ); CLJWorkspace_exposer.def( "changedAtoms" , changedAtoms_function_value , "Merge all of the deltas together into a single set of changed CLJAtoms that\ncan be used for the change in energy calculation" ); } { //::SireMM::CLJWorkspace::clear typedef void ( ::SireMM::CLJWorkspace::*clear_function_type)( ) ; clear_function_type clear_function_value( &::SireMM::CLJWorkspace::clear ); CLJWorkspace_exposer.def( "clear" , clear_function_value , "Clear this workspace" ); } { //::SireMM::CLJWorkspace::commit typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJWorkspace::*commit_function_type)( ::SireMM::CLJBoxes &,::SireMM::CLJDelta const & ) ; commit_function_type commit_function_value( &::SireMM::CLJWorkspace::commit ); CLJWorkspace_exposer.def( "commit" , commit_function_value , ( bp::arg("boxes"), bp::arg("delta") ) , "Commit the changes in the passed delta into the passed CLJBoxes" ); } { //::SireMM::CLJWorkspace::count typedef int ( ::SireMM::CLJWorkspace::*count_function_type)( ) const; count_function_type count_function_value( &::SireMM::CLJWorkspace::count ); CLJWorkspace_exposer.def( "count" , count_function_value , "Return the number of deltas" ); } { //::SireMM::CLJWorkspace::getitem typedef ::SireMM::CLJDelta ( ::SireMM::CLJWorkspace::*getitem_function_type)( int ) const; getitem_function_type getitem_function_value( &::SireMM::CLJWorkspace::getitem ); CLJWorkspace_exposer.def( "getitem" , getitem_function_value , ( bp::arg("i") ) , "Return the ith delta" ); } { //::SireMM::CLJWorkspace::isEmpty typedef bool ( ::SireMM::CLJWorkspace::*isEmpty_function_type)( ) const; isEmpty_function_type isEmpty_function_value( &::SireMM::CLJWorkspace::isEmpty ); CLJWorkspace_exposer.def( "isEmpty" , isEmpty_function_value , "Return whether or not this workspace is empty" ); } { //::SireMM::CLJWorkspace::isSingleID typedef bool ( ::SireMM::CLJWorkspace::*isSingleID_function_type)( ) const; isSingleID_function_type isSingleID_function_value( &::SireMM::CLJWorkspace::isSingleID ); CLJWorkspace_exposer.def( "isSingleID" , isSingleID_function_value , "Return whether or not this workspace contains deltas with a single\nID (a single CLJAtoms ID)" ); } { //::SireMM::CLJWorkspace::merge typedef ::boost::tuples::tuple< SireMM::CLJAtoms, SireMM::CLJAtoms, SireMM::CLJAtoms, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > ( ::SireMM::CLJWorkspace::*merge_function_type)( ) const; merge_function_type merge_function_value( &::SireMM::CLJWorkspace::merge ); CLJWorkspace_exposer.def( "merge" , merge_function_value , "Merge all of the deltas together to return the tuple of the\nchanged, old and new atoms. This is equivalent to calling\nchangedAtoms(), oldAtoms() and newAtoms() and placing them\ninto a tuple. This is more efficient than three separate calls" ); } { //::SireMM::CLJWorkspace::mustRecalculateFromScratch typedef void ( ::SireMM::CLJWorkspace::*mustRecalculateFromScratch_function_type)( ::SireMM::CLJBoxes & ) ; mustRecalculateFromScratch_function_type mustRecalculateFromScratch_function_value( &::SireMM::CLJWorkspace::mustRecalculateFromScratch ); CLJWorkspace_exposer.def( "mustRecalculateFromScratch" , mustRecalculateFromScratch_function_value , ( bp::arg("boxes") ) , "Tell the workspace that we are now recalculating everything from scratch" ); } { //::SireMM::CLJWorkspace::nDeltas typedef int ( ::SireMM::CLJWorkspace::*nDeltas_function_type)( ) const; nDeltas_function_type nDeltas_function_value( &::SireMM::CLJWorkspace::nDeltas ); CLJWorkspace_exposer.def( "nDeltas" , nDeltas_function_value , "Return the number of deltas in this workspace" ); } { //::SireMM::CLJWorkspace::needsAccepting typedef bool ( ::SireMM::CLJWorkspace::*needsAccepting_function_type)( ) const; needsAccepting_function_type needsAccepting_function_value( &::SireMM::CLJWorkspace::needsAccepting ); CLJWorkspace_exposer.def( "needsAccepting" , needsAccepting_function_value , "Return whether or not this workspace needs accepting" ); } { //::SireMM::CLJWorkspace::newAtoms typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*newAtoms_function_type)( ) const; newAtoms_function_type newAtoms_function_value( &::SireMM::CLJWorkspace::newAtoms ); CLJWorkspace_exposer.def( "newAtoms" , newAtoms_function_value , "Merge all of the new atoms from the deltas together into a single\nset of new CLJAtoms that can be used for the change in energy calculation" ); } { //::SireMM::CLJWorkspace::oldAtoms typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*oldAtoms_function_type)( ) const; oldAtoms_function_type oldAtoms_function_value( &::SireMM::CLJWorkspace::oldAtoms ); CLJWorkspace_exposer.def( "oldAtoms" , oldAtoms_function_value , "Merge all of the old atoms from the deltas together into a single\nset of old CLJAtoms that can be used for the change in energy calculation" ); } CLJWorkspace_exposer.def( bp::self != bp::self ); { //::SireMM::CLJWorkspace::operator= typedef ::SireMM::CLJWorkspace & ( ::SireMM::CLJWorkspace::*assign_function_type)( ::SireMM::CLJWorkspace const & ) ; assign_function_type assign_function_value( &::SireMM::CLJWorkspace::operator= ); CLJWorkspace_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } CLJWorkspace_exposer.def( bp::self == bp::self ); { //::SireMM::CLJWorkspace::operator[] typedef ::SireMM::CLJDelta const & ( ::SireMM::CLJWorkspace::*__getitem___function_type)( int ) const; __getitem___function_type __getitem___function_value( &::SireMM::CLJWorkspace::operator[] ); CLJWorkspace_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireMM::CLJWorkspace::push typedef ::SireMM::CLJDelta ( ::SireMM::CLJWorkspace::*push_function_type)( ::SireMM::CLJBoxes &,::QVector< SireMM::CLJBoxIndex > const &,::SireMM::CLJAtoms const &,::SireMM::CLJDelta const & ) ; push_function_type push_function_value( &::SireMM::CLJWorkspace::push ); CLJWorkspace_exposer.def( "push" , push_function_value , ( bp::arg("boxes"), bp::arg("old_atoms"), bp::arg("new_atoms"), bp::arg("old_delta") ) , "Push the passed change onto the workspace. This changes the atoms in the\npassed CLJBoxes from their values in old_atoms to their values in the\npassed new_atoms. The last CLJDelta used for these atoms is supplied as\nold_delta, and this returns the new CLJDelta for these atoms." ); } { //::SireMM::CLJWorkspace::recalculatingFromScratch typedef bool ( ::SireMM::CLJWorkspace::*recalculatingFromScratch_function_type)( ) const; recalculatingFromScratch_function_type recalculatingFromScratch_function_value( &::SireMM::CLJWorkspace::recalculatingFromScratch ); CLJWorkspace_exposer.def( "recalculatingFromScratch" , recalculatingFromScratch_function_value , "Return whether or not we are recalculating everything from scratch" ); } { //::SireMM::CLJWorkspace::removeSameIDAtoms typedef void ( ::SireMM::CLJWorkspace::*removeSameIDAtoms_function_type)( ::SireMM::CLJBoxes & ) ; removeSameIDAtoms_function_type removeSameIDAtoms_function_value( &::SireMM::CLJWorkspace::removeSameIDAtoms ); CLJWorkspace_exposer.def( "removeSameIDAtoms" , removeSameIDAtoms_function_value , ( bp::arg("boxes") ) , "Internal function used to fully remove atoms that have not been\nremoved because they all have the same ID. This is used when the\noptimisation of not removing same ID atoms would break the energy\ncalculation, e.g. if we have multiple CLJGroups and have multiple\nchanged IDs across these groups" ); } { //::SireMM::CLJWorkspace::revert typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJWorkspace::*revert_function_type)( ::SireMM::CLJBoxes &,::SireMM::CLJDelta const & ) ; revert_function_type revert_function_value( &::SireMM::CLJWorkspace::revert ); CLJWorkspace_exposer.def( "revert" , revert_function_value , ( bp::arg("boxes"), bp::arg("delta") ) , "Revert the changes supplied in the passed delta" ); } { //::SireMM::CLJWorkspace::size typedef int ( ::SireMM::CLJWorkspace::*size_function_type)( ) const; size_function_type size_function_value( &::SireMM::CLJWorkspace::size ); CLJWorkspace_exposer.def( "size" , size_function_value , "Return the number of deltas" ); } { //::SireMM::CLJWorkspace::toString typedef ::QString ( ::SireMM::CLJWorkspace::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMM::CLJWorkspace::toString ); CLJWorkspace_exposer.def( "toString" , toString_function_value , "" ); } { //::SireMM::CLJWorkspace::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::CLJWorkspace::typeName ); CLJWorkspace_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMM::CLJWorkspace::what typedef char const * ( ::SireMM::CLJWorkspace::*what_function_type)( ) const; what_function_type what_function_value( &::SireMM::CLJWorkspace::what ); CLJWorkspace_exposer.def( "what" , what_function_value , "" ); } CLJWorkspace_exposer.staticmethod( "typeName" ); CLJWorkspace_exposer.def( "__copy__", &__copy__); CLJWorkspace_exposer.def( "__deepcopy__", &__copy__); CLJWorkspace_exposer.def( "clone", &__copy__); CLJWorkspace_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJWorkspace >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CLJWorkspace_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJWorkspace >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CLJWorkspace_exposer.def( "__str__", &__str__< ::SireMM::CLJWorkspace > ); CLJWorkspace_exposer.def( "__repr__", &__str__< ::SireMM::CLJWorkspace > ); CLJWorkspace_exposer.def( "__len__", &__len_size< ::SireMM::CLJWorkspace > ); CLJWorkspace_exposer.def( "__getitem__", &::SireMM::CLJWorkspace::getitem ); } }
void register_CoulombScaleFactor_class(){ { //::SireMM::CoulombScaleFactor typedef bp::class_< SireMM::CoulombScaleFactor > CoulombScaleFactor_exposer_t; CoulombScaleFactor_exposer_t CoulombScaleFactor_exposer = CoulombScaleFactor_exposer_t( "CoulombScaleFactor", bp::init< bp::optional< double > >(( bp::arg("scl")=0 )) ); bp::scope CoulombScaleFactor_scope( CoulombScaleFactor_exposer ); CoulombScaleFactor_exposer.def( bp::init< SireMM::CoulombScaleFactor const & >(( bp::arg("other") )) ); { //::SireMM::CoulombScaleFactor::coulomb typedef double ( ::SireMM::CoulombScaleFactor::*coulomb_function_type )( ) const; coulomb_function_type coulomb_function_value( &::SireMM::CoulombScaleFactor::coulomb ); CoulombScaleFactor_exposer.def( "coulomb" , coulomb_function_value ); } CoulombScaleFactor_exposer.def( bp::self != bp::self ); { //::SireMM::CoulombScaleFactor::operator= typedef ::SireMM::CoulombScaleFactor & ( ::SireMM::CoulombScaleFactor::*assign_function_type )( ::SireMM::CoulombScaleFactor const & ) ; assign_function_type assign_function_value( &::SireMM::CoulombScaleFactor::operator= ); CoulombScaleFactor_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } CoulombScaleFactor_exposer.def( bp::self == bp::self ); { //::SireMM::CoulombScaleFactor::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::CoulombScaleFactor::typeName ); CoulombScaleFactor_exposer.def( "typeName" , typeName_function_value ); } { //::SireMM::CoulombScaleFactor::what typedef char const * ( ::SireMM::CoulombScaleFactor::*what_function_type )( ) const; what_function_type what_function_value( &::SireMM::CoulombScaleFactor::what ); CoulombScaleFactor_exposer.def( "what" , what_function_value ); } CoulombScaleFactor_exposer.staticmethod( "typeName" ); CoulombScaleFactor_exposer.def( "__copy__", &__copy__); CoulombScaleFactor_exposer.def( "__deepcopy__", &__copy__); CoulombScaleFactor_exposer.def( "clone", &__copy__); CoulombScaleFactor_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CoulombScaleFactor >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CoulombScaleFactor_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CoulombScaleFactor >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CoulombScaleFactor_exposer.def( "__str__", &pvt_get_name); CoulombScaleFactor_exposer.def( "__repr__", &pvt_get_name); } }
void register_StretchBendTorsionComponent_class() { { //::SireMM::StretchBendTorsionComponent typedef bp::class_< SireMM::StretchBendTorsionComponent, bp::bases< SireFF::FFComponent, SireCAS::Symbol, SireCAS::ExBase > > StretchBendTorsionComponent_exposer_t; StretchBendTorsionComponent_exposer_t StretchBendTorsionComponent_exposer = StretchBendTorsionComponent_exposer_t( "StretchBendTorsionComponent", bp::init< bp::optional< SireFF::FFName const & > >(( bp::arg("ffname")=SireFF::FFName() )) ); bp::scope StretchBendTorsionComponent_scope( StretchBendTorsionComponent_exposer ); StretchBendTorsionComponent_exposer.def( bp::init< SireCAS::Symbol const & >(( bp::arg("symbol") )) ); StretchBendTorsionComponent_exposer.def( bp::init< SireMM::StretchBendTorsionComponent const & >(( bp::arg("other") )) ); { //::SireMM::StretchBendTorsionComponent::changeEnergy typedef void ( ::SireMM::StretchBendTorsionComponent::*changeEnergy_function_type )( ::SireFF::FF &,::SireMM::StretchBendTorsionEnergy const & ) const; changeEnergy_function_type changeEnergy_function_value( &::SireMM::StretchBendTorsionComponent::changeEnergy ); StretchBendTorsionComponent_exposer.def( "changeEnergy" , changeEnergy_function_value , ( bp::arg("ff"), bp::arg("sbtnrg") ) ); } { //::SireMM::StretchBendTorsionComponent::setEnergy typedef void ( ::SireMM::StretchBendTorsionComponent::*setEnergy_function_type )( ::SireFF::FF &,::SireMM::StretchBendTorsionEnergy const & ) const; setEnergy_function_type setEnergy_function_value( &::SireMM::StretchBendTorsionComponent::setEnergy ); StretchBendTorsionComponent_exposer.def( "setEnergy" , setEnergy_function_value , ( bp::arg("ff"), bp::arg("sbtnrg") ) ); } { //::SireMM::StretchBendTorsionComponent::symbols typedef ::SireCAS::Symbols ( ::SireMM::StretchBendTorsionComponent::*symbols_function_type )( ) const; symbols_function_type symbols_function_value( &::SireMM::StretchBendTorsionComponent::symbols ); StretchBendTorsionComponent_exposer.def( "symbols" , symbols_function_value ); } { //::SireMM::StretchBendTorsionComponent::total typedef ::SireMM::StretchBendTorsionComponent const & ( ::SireMM::StretchBendTorsionComponent::*total_function_type )( ) const; total_function_type total_function_value( &::SireMM::StretchBendTorsionComponent::total ); StretchBendTorsionComponent_exposer.def( "total" , total_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::StretchBendTorsionComponent::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::StretchBendTorsionComponent::typeName ); StretchBendTorsionComponent_exposer.def( "typeName" , typeName_function_value ); } { //::SireMM::StretchBendTorsionComponent::what typedef char const * ( ::SireMM::StretchBendTorsionComponent::*what_function_type )( ) const; what_function_type what_function_value( &::SireMM::StretchBendTorsionComponent::what ); StretchBendTorsionComponent_exposer.def( "what" , what_function_value ); } StretchBendTorsionComponent_exposer.staticmethod( "typeName" ); StretchBendTorsionComponent_exposer.def( "__copy__", &__copy__); StretchBendTorsionComponent_exposer.def( "__deepcopy__", &__copy__); StretchBendTorsionComponent_exposer.def( "clone", &__copy__); StretchBendTorsionComponent_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::StretchBendTorsionComponent >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); StretchBendTorsionComponent_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::StretchBendTorsionComponent >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); StretchBendTorsionComponent_exposer.def( "__str__", &__str__< ::SireMM::StretchBendTorsionComponent > ); StretchBendTorsionComponent_exposer.def( "__repr__", &__str__< ::SireMM::StretchBendTorsionComponent > ); } }
void register_GridInfo_class(){ { //::SireVol::GridInfo typedef bp::class_< SireVol::GridInfo > GridInfo_exposer_t; GridInfo_exposer_t GridInfo_exposer = GridInfo_exposer_t( "GridInfo", bp::init< >() ); bp::scope GridInfo_scope( GridInfo_exposer ); GridInfo_exposer.def( bp::init< SireVol::AABox const &, SireUnits::Dimension::Length >(( bp::arg("dimensions"), bp::arg("spacing") )) ); GridInfo_exposer.def( bp::init< SireVol::GridInfo const & >(( bp::arg("other") )) ); { //::SireVol::GridInfo::arrayToGridIndex typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*arrayToGridIndex_function_type )( int ) const; arrayToGridIndex_function_type arrayToGridIndex_function_value( &::SireVol::GridInfo::arrayToGridIndex ); GridInfo_exposer.def( "arrayToGridIndex" , arrayToGridIndex_function_value , ( bp::arg("i") ) ); } { //::SireVol::GridInfo::at typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*at_function_type )( int ) const; at_function_type at_function_value( &::SireVol::GridInfo::at ); GridInfo_exposer.def( "at" , at_function_value , ( bp::arg("i") ) ); } { //::SireVol::GridInfo::at typedef int ( ::SireVol::GridInfo::*at_function_type )( ::SireVol::GridIndex const & ) const; at_function_type at_function_value( &::SireVol::GridInfo::at ); GridInfo_exposer.def( "at" , at_function_value , ( bp::arg("idx") ) ); } { //::SireVol::GridInfo::at typedef int ( ::SireVol::GridInfo::*at_function_type )( int,int,int ) const; at_function_type at_function_value( &::SireVol::GridInfo::at ); GridInfo_exposer.def( "at" , at_function_value , ( bp::arg("i"), bp::arg("j"), bp::arg("k") ) ); } { //::SireVol::GridInfo::at typedef int ( ::SireVol::GridInfo::*at_function_type )( ::SireMaths::Vector const & ) const; at_function_type at_function_value( &::SireVol::GridInfo::at ); GridInfo_exposer.def( "at" , at_function_value , ( bp::arg("point") ) ); } { //::SireVol::GridInfo::box typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( int ) const; box_function_type box_function_value( &::SireVol::GridInfo::box ); GridInfo_exposer.def( "box" , box_function_value , ( bp::arg("i") ) ); } { //::SireVol::GridInfo::box typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( ::SireVol::GridIndex const & ) const; box_function_type box_function_value( &::SireVol::GridInfo::box ); GridInfo_exposer.def( "box" , box_function_value , ( bp::arg("idx") ) ); } { //::SireVol::GridInfo::box typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( ::SireMaths::Vector const & ) const; box_function_type box_function_value( &::SireVol::GridInfo::box ); GridInfo_exposer.def( "box" , box_function_value , ( bp::arg("point") ) ); } { //::SireVol::GridInfo::closestIndexTo typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*closestIndexTo_function_type )( ::SireMaths::Vector const & ) const; closestIndexTo_function_type closestIndexTo_function_value( &::SireVol::GridInfo::closestIndexTo ); GridInfo_exposer.def( "closestIndexTo" , closestIndexTo_function_value , ( bp::arg("point") ) ); } { //::SireVol::GridInfo::contains typedef bool ( ::SireVol::GridInfo::*contains_function_type )( ::SireMaths::Vector const & ) const; contains_function_type contains_function_value( &::SireVol::GridInfo::contains ); GridInfo_exposer.def( "contains" , contains_function_value , ( bp::arg("point") ) ); } { //::SireVol::GridInfo::count typedef int ( ::SireVol::GridInfo::*count_function_type )( ) const; count_function_type count_function_value( &::SireVol::GridInfo::count ); GridInfo_exposer.def( "count" , count_function_value ); } { //::SireVol::GridInfo::dimX typedef ::qint32 ( ::SireVol::GridInfo::*dimX_function_type )( ) const; dimX_function_type dimX_function_value( &::SireVol::GridInfo::dimX ); GridInfo_exposer.def( "dimX" , dimX_function_value ); } { //::SireVol::GridInfo::dimY typedef ::qint32 ( ::SireVol::GridInfo::*dimY_function_type )( ) const; dimY_function_type dimY_function_value( &::SireVol::GridInfo::dimY ); GridInfo_exposer.def( "dimY" , dimY_function_value ); } { //::SireVol::GridInfo::dimZ typedef ::qint32 ( ::SireVol::GridInfo::*dimZ_function_type )( ) const; dimZ_function_type dimZ_function_value( &::SireVol::GridInfo::dimZ ); GridInfo_exposer.def( "dimZ" , dimZ_function_value ); } { //::SireVol::GridInfo::dimensions typedef ::SireVol::AABox ( ::SireVol::GridInfo::*dimensions_function_type )( ) const; dimensions_function_type dimensions_function_value( &::SireVol::GridInfo::dimensions ); GridInfo_exposer.def( "dimensions" , dimensions_function_value ); } { //::SireVol::GridInfo::getitem typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*getitem_function_type )( int ) const; getitem_function_type getitem_function_value( &::SireVol::GridInfo::getitem ); GridInfo_exposer.def( "getitem" , getitem_function_value , ( bp::arg("i") ) ); } { //::SireVol::GridInfo::gridToArrayIndex typedef int ( ::SireVol::GridInfo::*gridToArrayIndex_function_type )( int,int,int ) const; gridToArrayIndex_function_type gridToArrayIndex_function_value( &::SireVol::GridInfo::gridToArrayIndex ); GridInfo_exposer.def( "gridToArrayIndex" , gridToArrayIndex_function_value , ( bp::arg("i"), bp::arg("j"), bp::arg("k") ) ); } { //::SireVol::GridInfo::gridToArrayIndex typedef int ( ::SireVol::GridInfo::*gridToArrayIndex_function_type )( ::SireVol::GridIndex const & ) const; gridToArrayIndex_function_type gridToArrayIndex_function_value( &::SireVol::GridInfo::gridToArrayIndex ); GridInfo_exposer.def( "gridToArrayIndex" , gridToArrayIndex_function_value , ( bp::arg("idx") ) ); } { //::SireVol::GridInfo::indexOf typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*indexOf_function_type )( int,::SireVol::GridInfo const & ) const; indexOf_function_type indexOf_function_value( &::SireVol::GridInfo::indexOf ); GridInfo_exposer.def( "indexOf" , indexOf_function_value , ( bp::arg("i"), bp::arg("grid") ) ); } { //::SireVol::GridInfo::indexOf typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*indexOf_function_type )( ::SireVol::GridIndex const &,::SireVol::GridInfo const & ) const; indexOf_function_type indexOf_function_value( &::SireVol::GridInfo::indexOf ); GridInfo_exposer.def( "indexOf" , indexOf_function_value , ( bp::arg("idx"), bp::arg("grid") ) ); } { //::SireVol::GridInfo::isEmpty typedef bool ( ::SireVol::GridInfo::*isEmpty_function_type )( ) const; isEmpty_function_type isEmpty_function_value( &::SireVol::GridInfo::isEmpty ); GridInfo_exposer.def( "isEmpty" , isEmpty_function_value ); } { //::SireVol::GridInfo::nPoints typedef int ( ::SireVol::GridInfo::*nPoints_function_type )( ) const; nPoints_function_type nPoints_function_value( &::SireVol::GridInfo::nPoints ); GridInfo_exposer.def( "nPoints" , nPoints_function_value ); } GridInfo_exposer.def( bp::self != bp::self ); { //::SireVol::GridInfo::operator= typedef ::SireVol::GridInfo & ( ::SireVol::GridInfo::*assign_function_type )( ::SireVol::GridInfo const & ) ; assign_function_type assign_function_value( &::SireVol::GridInfo::operator= ); GridInfo_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } GridInfo_exposer.def( bp::self == bp::self ); { //::SireVol::GridInfo::operator[] typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*__getitem___function_type )( int ) const; __getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] ); GridInfo_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) ); } { //::SireVol::GridInfo::operator[] typedef int ( ::SireVol::GridInfo::*__getitem___function_type )( ::SireVol::GridIndex const & ) const; __getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] ); GridInfo_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("idx") ) ); } { //::SireVol::GridInfo::operator[] typedef int ( ::SireVol::GridInfo::*__getitem___function_type )( ::SireMaths::Vector const & ) const; __getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] ); GridInfo_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("point") ) ); } { //::SireVol::GridInfo::point typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( int ) const; point_function_type point_function_value( &::SireVol::GridInfo::point ); GridInfo_exposer.def( "point" , point_function_value , ( bp::arg("i") ) ); } { //::SireVol::GridInfo::point typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( ::SireVol::GridIndex const & ) const; point_function_type point_function_value( &::SireVol::GridInfo::point ); GridInfo_exposer.def( "point" , point_function_value , ( bp::arg("idx") ) ); } { //::SireVol::GridInfo::point typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( ::SireMaths::Vector const & ) const; point_function_type point_function_value( &::SireVol::GridInfo::point ); GridInfo_exposer.def( "point" , point_function_value , ( bp::arg("point") ) ); } { //::SireVol::GridInfo::pointToArrayIndex typedef int ( ::SireVol::GridInfo::*pointToArrayIndex_function_type )( ::SireMaths::Vector const & ) const; pointToArrayIndex_function_type pointToArrayIndex_function_value( &::SireVol::GridInfo::pointToArrayIndex ); GridInfo_exposer.def( "pointToArrayIndex" , pointToArrayIndex_function_value , ( bp::arg("point") ) ); } { //::SireVol::GridInfo::pointToGridCorners typedef void ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::Vector const &,::QVector< int > & ) const; pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners ); GridInfo_exposer.def( "pointToGridCorners" , pointToGridCorners_function_value , ( bp::arg("point"), bp::arg("indicies") ) ); } { //::SireVol::GridInfo::pointToGridCorners typedef void ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::Vector const &,::QVector< int > &,::QVector< float > & ) const; pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners ); GridInfo_exposer.def( "pointToGridCorners" , pointToGridCorners_function_value , ( bp::arg("point"), bp::arg("indicies"), bp::arg("weights") ) ); } { //::SireVol::GridInfo::pointToGridCorners typedef int ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::QVector< SireMaths::MultiInt > & ) const; pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners ); GridInfo_exposer.def( "pointToGridCorners" , pointToGridCorners_function_value , ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("indicies") ) ); } { //::SireVol::GridInfo::pointToGridCorners typedef int ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::QVector< SireMaths::MultiInt > &,::QVector< SireMaths::MultiFloat > & ) const; pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners ); GridInfo_exposer.def( "pointToGridCorners" , pointToGridCorners_function_value , ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("indicies"), bp::arg("weights") ) ); } { //::SireVol::GridInfo::pointToGridIndex typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*pointToGridIndex_function_type )( ::SireMaths::Vector const & ) const; pointToGridIndex_function_type pointToGridIndex_function_value( &::SireVol::GridInfo::pointToGridIndex ); GridInfo_exposer.def( "pointToGridIndex" , pointToGridIndex_function_value , ( bp::arg("point") ) ); } { //::SireVol::GridInfo::redimension typedef ::QVector< float > ( ::SireVol::GridInfo::*redimension_function_type )( ::QVector< float > const &,::SireVol::GridInfo const & ) const; redimension_function_type redimension_function_value( &::SireVol::GridInfo::redimension ); GridInfo_exposer.def( "redimension" , redimension_function_value , ( bp::arg("values"), bp::arg("new_grid") ) ); } { //::SireVol::GridInfo::size typedef int ( ::SireVol::GridInfo::*size_function_type )( ) const; size_function_type size_function_value( &::SireVol::GridInfo::size ); GridInfo_exposer.def( "size" , size_function_value ); } { //::SireVol::GridInfo::spacing typedef ::SireUnits::Dimension::Length ( ::SireVol::GridInfo::*spacing_function_type )( ) const; spacing_function_type spacing_function_value( &::SireVol::GridInfo::spacing ); GridInfo_exposer.def( "spacing" , spacing_function_value ); } { //::SireVol::GridInfo::toString typedef ::QString ( ::SireVol::GridInfo::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireVol::GridInfo::toString ); GridInfo_exposer.def( "toString" , toString_function_value ); } { //::SireVol::GridInfo::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireVol::GridInfo::typeName ); GridInfo_exposer.def( "typeName" , typeName_function_value ); } { //::SireVol::GridInfo::what typedef char const * ( ::SireVol::GridInfo::*what_function_type )( ) const; what_function_type what_function_value( &::SireVol::GridInfo::what ); GridInfo_exposer.def( "what" , what_function_value ); } GridInfo_exposer.staticmethod( "typeName" ); GridInfo_exposer.def( "__copy__", &__copy__); GridInfo_exposer.def( "__deepcopy__", &__copy__); GridInfo_exposer.def( "clone", &__copy__); GridInfo_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::GridInfo >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); GridInfo_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::GridInfo >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); GridInfo_exposer.def( "__str__", &__str__< ::SireVol::GridInfo > ); GridInfo_exposer.def( "__repr__", &__str__< ::SireVol::GridInfo > ); GridInfo_exposer.def( "__len__", &__len_size< ::SireVol::GridInfo > ); GridInfo_exposer.def( "__getitem__", &::SireVol::GridInfo::getitem ); } }
void register_ChainsWithRes_class(){ { //::SireMol::ChainsWithRes typedef bp::class_< SireMol::ChainsWithRes, bp::bases< SireMol::ChainID, SireID::ID > > ChainsWithRes_exposer_t; ChainsWithRes_exposer_t ChainsWithRes_exposer = ChainsWithRes_exposer_t( "ChainsWithRes", "This ID class identifies chains that contain residues that\nmatch the passed ResID\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") ); bp::scope ChainsWithRes_scope( ChainsWithRes_exposer ); ChainsWithRes_exposer.def( bp::init< SireMol::ResID const & >(( bp::arg("resid") ), "Construct from the passed residue ID") ); ChainsWithRes_exposer.def( bp::init< SireMol::ChainsWithRes const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMol::ChainsWithRes::hash typedef ::uint ( ::SireMol::ChainsWithRes::*hash_function_type)( ) const; hash_function_type hash_function_value( &::SireMol::ChainsWithRes::hash ); ChainsWithRes_exposer.def( "hash" , hash_function_value , "Return a hash of this identifier" ); } { //::SireMol::ChainsWithRes::isNull typedef bool ( ::SireMol::ChainsWithRes::*isNull_function_type)( ) const; isNull_function_type isNull_function_value( &::SireMol::ChainsWithRes::isNull ); ChainsWithRes_exposer.def( "isNull" , isNull_function_value , "Is this selection null?" ); } { //::SireMol::ChainsWithRes::map typedef ::QList< SireMol::ChainIdx > ( ::SireMol::ChainsWithRes::*map_function_type)( ::SireMol::MolInfo const & ) const; map_function_type map_function_value( &::SireMol::ChainsWithRes::map ); ChainsWithRes_exposer.def( "map" , map_function_value , ( bp::arg("molinfo") ) , "Map this ID to the list of indicies of chains that match this ID\nThrow: SireMol::missing_chain\nThrow: SireError::invalid_index\n" ); } ChainsWithRes_exposer.def( bp::self != bp::self ); { //::SireMol::ChainsWithRes::operator= typedef ::SireMol::ChainsWithRes & ( ::SireMol::ChainsWithRes::*assign_function_type)( ::SireMol::ChainsWithRes const & ) ; assign_function_type assign_function_value( &::SireMol::ChainsWithRes::operator= ); ChainsWithRes_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } ChainsWithRes_exposer.def( bp::self == bp::other< SireID::ID >() ); ChainsWithRes_exposer.def( bp::self == bp::self ); { //::SireMol::ChainsWithRes::resID typedef ::SireMol::ResID const & ( ::SireMol::ChainsWithRes::*resID_function_type)( ) const; resID_function_type resID_function_value( &::SireMol::ChainsWithRes::resID ); ChainsWithRes_exposer.def( "resID" , resID_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the residue ID" ); } { //::SireMol::ChainsWithRes::toString typedef ::QString ( ::SireMol::ChainsWithRes::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMol::ChainsWithRes::toString ); ChainsWithRes_exposer.def( "toString" , toString_function_value , "Return a string representatio of this ID" ); } { //::SireMol::ChainsWithRes::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::ChainsWithRes::typeName ); ChainsWithRes_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMol::ChainsWithRes::what typedef char const * ( ::SireMol::ChainsWithRes::*what_function_type)( ) const; what_function_type what_function_value( &::SireMol::ChainsWithRes::what ); ChainsWithRes_exposer.def( "what" , what_function_value , "" ); } ChainsWithRes_exposer.staticmethod( "typeName" ); ChainsWithRes_exposer.def( "__copy__", &__copy__); ChainsWithRes_exposer.def( "__deepcopy__", &__copy__); ChainsWithRes_exposer.def( "clone", &__copy__); ChainsWithRes_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ChainsWithRes >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ChainsWithRes_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ChainsWithRes >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ChainsWithRes_exposer.def( "__str__", &__str__< ::SireMol::ChainsWithRes > ); ChainsWithRes_exposer.def( "__repr__", &__str__< ::SireMol::ChainsWithRes > ); ChainsWithRes_exposer.def( "__hash__", &::SireMol::ChainsWithRes::hash ); } }
void register_GeneralUnit_class(){ { //::SireUnits::Dimension::GeneralUnit typedef bp::class_< SireUnits::Dimension::GeneralUnit, bp::bases< SireUnits::Dimension::Unit > > GeneralUnit_exposer_t; GeneralUnit_exposer_t GeneralUnit_exposer = GeneralUnit_exposer_t( "GeneralUnit", bp::init< >() ); bp::scope GeneralUnit_scope( GeneralUnit_exposer ); GeneralUnit_exposer.def( bp::init< SireUnits::Dimension::GeneralUnit const & >(( bp::arg("other") )) ); { //::SireUnits::Dimension::GeneralUnit::ANGLE typedef int ( ::SireUnits::Dimension::GeneralUnit::*ANGLE_function_type )( ) const; ANGLE_function_type ANGLE_function_value( &::SireUnits::Dimension::GeneralUnit::ANGLE ); GeneralUnit_exposer.def( "ANGLE" , ANGLE_function_value ); } { //::SireUnits::Dimension::GeneralUnit::CHARGE typedef int ( ::SireUnits::Dimension::GeneralUnit::*CHARGE_function_type )( ) const; CHARGE_function_type CHARGE_function_value( &::SireUnits::Dimension::GeneralUnit::CHARGE ); GeneralUnit_exposer.def( "CHARGE" , CHARGE_function_value ); } { //::SireUnits::Dimension::GeneralUnit::LENGTH typedef int ( ::SireUnits::Dimension::GeneralUnit::*LENGTH_function_type )( ) const; LENGTH_function_type LENGTH_function_value( &::SireUnits::Dimension::GeneralUnit::LENGTH ); GeneralUnit_exposer.def( "LENGTH" , LENGTH_function_value ); } { //::SireUnits::Dimension::GeneralUnit::MASS typedef int ( ::SireUnits::Dimension::GeneralUnit::*MASS_function_type )( ) const; MASS_function_type MASS_function_value( &::SireUnits::Dimension::GeneralUnit::MASS ); GeneralUnit_exposer.def( "MASS" , MASS_function_value ); } { //::SireUnits::Dimension::GeneralUnit::QUANTITY typedef int ( ::SireUnits::Dimension::GeneralUnit::*QUANTITY_function_type )( ) const; QUANTITY_function_type QUANTITY_function_value( &::SireUnits::Dimension::GeneralUnit::QUANTITY ); GeneralUnit_exposer.def( "QUANTITY" , QUANTITY_function_value ); } { //::SireUnits::Dimension::GeneralUnit::TEMPERATURE typedef int ( ::SireUnits::Dimension::GeneralUnit::*TEMPERATURE_function_type )( ) const; TEMPERATURE_function_type TEMPERATURE_function_value( &::SireUnits::Dimension::GeneralUnit::TEMPERATURE ); GeneralUnit_exposer.def( "TEMPERATURE" , TEMPERATURE_function_value ); } { //::SireUnits::Dimension::GeneralUnit::TIME typedef int ( ::SireUnits::Dimension::GeneralUnit::*TIME_function_type )( ) const; TIME_function_type TIME_function_value( &::SireUnits::Dimension::GeneralUnit::TIME ); GeneralUnit_exposer.def( "TIME" , TIME_function_value ); } { //::SireUnits::Dimension::GeneralUnit::invert typedef ::SireUnits::Dimension::GeneralUnit ( ::SireUnits::Dimension::GeneralUnit::*invert_function_type )( ) const; invert_function_type invert_function_value( &::SireUnits::Dimension::GeneralUnit::invert ); GeneralUnit_exposer.def( "invert" , invert_function_value ); } GeneralUnit_exposer.def( bp::self != bp::self ); GeneralUnit_exposer.def( bp::self * bp::self ); GeneralUnit_exposer.def( bp::self * bp::other< double >() ); GeneralUnit_exposer.def( bp::self * bp::other< int >() ); GeneralUnit_exposer.def( bp::self *= bp::self ); GeneralUnit_exposer.def( bp::self + bp::self ); GeneralUnit_exposer.def( -bp::self ); GeneralUnit_exposer.def( bp::self - bp::self ); GeneralUnit_exposer.def( bp::self / bp::self ); GeneralUnit_exposer.def( bp::self / bp::other< double >() ); GeneralUnit_exposer.def( bp::self / bp::other< int >() ); GeneralUnit_exposer.def( bp::self /= bp::self ); { //::SireUnits::Dimension::GeneralUnit::operator= typedef ::SireUnits::Dimension::GeneralUnit & ( ::SireUnits::Dimension::GeneralUnit::*assign_function_type )( ::SireUnits::Dimension::GeneralUnit const & ) ; assign_function_type assign_function_value( &::SireUnits::Dimension::GeneralUnit::operator= ); GeneralUnit_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } GeneralUnit_exposer.def( bp::self == bp::self ); { //::SireUnits::Dimension::GeneralUnit::to typedef double ( ::SireUnits::Dimension::GeneralUnit::*to_function_type )( ::SireUnits::Dimension::TempBase const & ) const; to_function_type to_function_value( &::SireUnits::Dimension::GeneralUnit::to ); GeneralUnit_exposer.def( "to" , to_function_value , ( bp::arg("other") ) ); } { //::SireUnits::Dimension::GeneralUnit::to typedef double ( ::SireUnits::Dimension::GeneralUnit::*to_function_type )( ::SireUnits::Dimension::GeneralUnit const & ) const; to_function_type to_function_value( &::SireUnits::Dimension::GeneralUnit::to ); GeneralUnit_exposer.def( "to" , to_function_value , ( bp::arg("other") ) ); } { //::SireUnits::Dimension::GeneralUnit::toString typedef ::QString ( ::SireUnits::Dimension::GeneralUnit::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireUnits::Dimension::GeneralUnit::toString ); GeneralUnit_exposer.def( "toString" , toString_function_value ); } { //::SireUnits::Dimension::GeneralUnit::typeName typedef ::QString ( ::SireUnits::Dimension::GeneralUnit::*typeName_function_type )( ) const; typeName_function_type typeName_function_value( &::SireUnits::Dimension::GeneralUnit::typeName ); GeneralUnit_exposer.def( "typeName" , typeName_function_value ); } { //::SireUnits::Dimension::GeneralUnit::what typedef ::QString ( ::SireUnits::Dimension::GeneralUnit::*what_function_type )( ) const; what_function_type what_function_value( &::SireUnits::Dimension::GeneralUnit::what ); GeneralUnit_exposer.def( "what" , what_function_value ); } GeneralUnit_exposer.def( bp::other<double>() * bp::self ); GeneralUnit_exposer.def( bp::other<double>() / bp::self ); GeneralUnit_exposer.def( "__copy__", &__copy__); GeneralUnit_exposer.def( "__deepcopy__", &__copy__); GeneralUnit_exposer.def( "clone", &__copy__); GeneralUnit_exposer.def( "__str__", &__str__< ::SireUnits::Dimension::GeneralUnit > ); GeneralUnit_exposer.def( "__repr__", &__str__< ::SireUnits::Dimension::GeneralUnit > ); } }
void register_Molecules_class(){ { //::SireMol::Molecules typedef bp::class_< SireMol::Molecules, bp::bases< SireBase::Property > > Molecules_exposer_t; Molecules_exposer_t Molecules_exposer = Molecules_exposer_t( "Molecules", bp::init< >() ); bp::scope Molecules_scope( Molecules_exposer ); Molecules_exposer.def( bp::init< SireMol::MoleculeView const & >(( bp::arg("molecule") )) ); Molecules_exposer.def( bp::init< SireMol::ViewsOfMol const & >(( bp::arg("molviews") )) ); Molecules_exposer.def( bp::init< SireMol::Molecules const & >(( bp::arg("other") )) ); { //::SireMol::Molecules::add typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::MoleculeView const & ) ; add_function_type add_function_value( &::SireMol::Molecules::add ); Molecules_exposer.def( "add" , add_function_value , ( bp::arg("molview") ) ); } { //::SireMol::Molecules::add typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::ViewsOfMol const & ) ; add_function_type add_function_value( &::SireMol::Molecules::add ); Molecules_exposer.def( "add" , add_function_value , ( bp::arg("molviews") ) ); } { //::SireMol::Molecules::add typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::Molecules const & ) ; add_function_type add_function_value( &::SireMol::Molecules::add ); Molecules_exposer.def( "add" , add_function_value , ( bp::arg("molecules") ) ); } { //::SireMol::Molecules::addIfUnique typedef bool ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::MoleculeView const & ) ; addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique ); Molecules_exposer.def( "addIfUnique" , addIfUnique_function_value , ( bp::arg("molview") ) ); } { //::SireMol::Molecules::addIfUnique typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::ViewsOfMol const & ) ; addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique ); Molecules_exposer.def( "addIfUnique" , addIfUnique_function_value , ( bp::arg("molviews") ) ); } { //::SireMol::Molecules::addIfUnique typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::Molecules const & ) ; addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique ); Molecules_exposer.def( "addIfUnique" , addIfUnique_function_value , ( bp::arg("molecules") ) ); } { //::SireMol::Molecules::assertContains typedef void ( ::SireMol::Molecules::*assertContains_function_type )( ::SireMol::MolNum ) const; assertContains_function_type assertContains_function_value( &::SireMol::Molecules::assertContains ); Molecules_exposer.def( "assertContains" , assertContains_function_value , ( bp::arg("molnum") ) ); } { //::SireMol::Molecules::at typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*at_function_type )( ::SireMol::MolNum ) const; at_function_type at_function_value( &::SireMol::Molecules::at ); Molecules_exposer.def( "at" , at_function_value , ( bp::arg("molnum") ) , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::Molecules::at typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*at_function_type )( ::boost::tuples::tuple< SireMol::MolNum, SireID::Index, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > const & ) const; at_function_type at_function_value( &::SireMol::Molecules::at ); Molecules_exposer.def( "at" , at_function_value , ( bp::arg("viewidx") ) ); } { //::SireMol::Molecules::at typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*at_function_type )( ::SireMol::MolNum,int ) const; at_function_type at_function_value( &::SireMol::Molecules::at ); Molecules_exposer.def( "at" , at_function_value , ( bp::arg("molnum"), bp::arg("idx") ) ); } { //::SireMol::Molecules::back typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*back_function_type )( ) const; back_function_type back_function_value( &::SireMol::Molecules::back ); Molecules_exposer.def( "back" , back_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::Molecules::begin typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*begin_function_type )( ) const; begin_function_type begin_function_value( &::SireMol::Molecules::begin ); Molecules_exposer.def( "begin" , begin_function_value ); } { //::SireMol::Molecules::clear typedef void ( ::SireMol::Molecules::*clear_function_type )( ) ; clear_function_type clear_function_value( &::SireMol::Molecules::clear ); Molecules_exposer.def( "clear" , clear_function_value ); } { //::SireMol::Molecules::constBegin typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constBegin_function_type )( ) const; constBegin_function_type constBegin_function_value( &::SireMol::Molecules::constBegin ); Molecules_exposer.def( "constBegin" , constBegin_function_value ); } { //::SireMol::Molecules::constEnd typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constEnd_function_type )( ) const; constEnd_function_type constEnd_function_value( &::SireMol::Molecules::constEnd ); Molecules_exposer.def( "constEnd" , constEnd_function_value ); } { //::SireMol::Molecules::constFind typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constFind_function_type )( ::SireMol::MolNum ) const; constFind_function_type constFind_function_value( &::SireMol::Molecules::constFind ); Molecules_exposer.def( "constFind" , constFind_function_value , ( bp::arg("molnum") ) ); } { //::SireMol::Molecules::contains typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::MolNum ) const; contains_function_type contains_function_value( &::SireMol::Molecules::contains ); Molecules_exposer.def( "contains" , contains_function_value , ( bp::arg("molnum") ) ); } { //::SireMol::Molecules::contains typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::MoleculeView const & ) const; contains_function_type contains_function_value( &::SireMol::Molecules::contains ); Molecules_exposer.def( "contains" , contains_function_value , ( bp::arg("molview") ) ); } { //::SireMol::Molecules::contains typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::ViewsOfMol const & ) const; contains_function_type contains_function_value( &::SireMol::Molecules::contains ); Molecules_exposer.def( "contains" , contains_function_value , ( bp::arg("molviews") ) ); } { //::SireMol::Molecules::contains typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::Molecules const & ) const; contains_function_type contains_function_value( &::SireMol::Molecules::contains ); Molecules_exposer.def( "contains" , contains_function_value , ( bp::arg("molecules") ) ); } { //::SireMol::Molecules::count typedef int ( ::SireMol::Molecules::*count_function_type )( ) const; count_function_type count_function_value( &::SireMol::Molecules::count ); Molecules_exposer.def( "count" , count_function_value ); } { //::SireMol::Molecules::end typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*end_function_type )( ) const; end_function_type end_function_value( &::SireMol::Molecules::end ); Molecules_exposer.def( "end" , end_function_value ); } { //::SireMol::Molecules::find typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*find_function_type )( ::SireMol::MolNum ) const; find_function_type find_function_value( &::SireMol::Molecules::find ); Molecules_exposer.def( "find" , find_function_value , ( bp::arg("molnum") ) ); } { //::SireMol::Molecules::first typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*first_function_type )( ) const; first_function_type first_function_value( &::SireMol::Molecules::first ); Molecules_exposer.def( "first" , first_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::Molecules::front typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*front_function_type )( ) const; front_function_type front_function_value( &::SireMol::Molecules::front ); Molecules_exposer.def( "front" , front_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::Molecules::intersects typedef bool ( ::SireMol::Molecules::*intersects_function_type )( ::SireMol::MoleculeView const & ) const; intersects_function_type intersects_function_value( &::SireMol::Molecules::intersects ); Molecules_exposer.def( "intersects" , intersects_function_value , ( bp::arg("molview") ) ); } { //::SireMol::Molecules::intersects typedef bool ( ::SireMol::Molecules::*intersects_function_type )( ::SireMol::Molecules const & ) const; intersects_function_type intersects_function_value( &::SireMol::Molecules::intersects ); Molecules_exposer.def( "intersects" , intersects_function_value , ( bp::arg("other") ) ); } { //::SireMol::Molecules::isEmpty typedef bool ( ::SireMol::Molecules::*isEmpty_function_type )( ) const; isEmpty_function_type isEmpty_function_value( &::SireMol::Molecules::isEmpty ); Molecules_exposer.def( "isEmpty" , isEmpty_function_value ); } { //::SireMol::Molecules::last typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*last_function_type )( ) const; last_function_type last_function_value( &::SireMol::Molecules::last ); Molecules_exposer.def( "last" , last_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::Molecules::molNums typedef ::QSet< SireMol::MolNum > ( ::SireMol::Molecules::*molNums_function_type )( ) const; molNums_function_type molNums_function_value( &::SireMol::Molecules::molNums ); Molecules_exposer.def( "molNums" , molNums_function_value ); } { //::SireMol::Molecules::molecule typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*molecule_function_type )( ::SireMol::MolNum ) const; molecule_function_type molecule_function_value( &::SireMol::Molecules::molecule ); Molecules_exposer.def( "molecule" , molecule_function_value , ( bp::arg("molnum") ) , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::Molecules::nMolecules typedef int ( ::SireMol::Molecules::*nMolecules_function_type )( ) const; nMolecules_function_type nMolecules_function_value( &::SireMol::Molecules::nMolecules ); Molecules_exposer.def( "nMolecules" , nMolecules_function_value ); } { //::SireMol::Molecules::nViews typedef int ( ::SireMol::Molecules::*nViews_function_type )( ) const; nViews_function_type nViews_function_value( &::SireMol::Molecules::nViews ); Molecules_exposer.def( "nViews" , nViews_function_value ); } { //::SireMol::Molecules::nViews typedef int ( ::SireMol::Molecules::*nViews_function_type )( ::SireMol::MolNum ) const; nViews_function_type nViews_function_value( &::SireMol::Molecules::nViews ); Molecules_exposer.def( "nViews" , nViews_function_value , ( bp::arg("molnum") ) ); } Molecules_exposer.def( bp::self != bp::self ); Molecules_exposer.def( bp::self + bp::self ); Molecules_exposer.def( bp::self - bp::self ); { //::SireMol::Molecules::operator= typedef ::SireMol::Molecules & ( ::SireMol::Molecules::*assign_function_type )( ::SireMol::Molecules const & ) ; assign_function_type assign_function_value( &::SireMol::Molecules::operator= ); Molecules_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } Molecules_exposer.def( bp::self == bp::self ); { //::SireMol::Molecules::operator[] typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*__getitem___function_type )( ::SireMol::MolNum ) const; __getitem___function_type __getitem___function_value( &::SireMol::Molecules::operator[] ); Molecules_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("molnum") ) , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMol::Molecules::operator[] typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*__getitem___function_type )( ::boost::tuples::tuple< SireMol::MolNum, SireID::Index, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > const & ) const; __getitem___function_type __getitem___function_value( &::SireMol::Molecules::operator[] ); Molecules_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("viewidx") ) ); } { //::SireMol::Molecules::remove typedef bool ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::MoleculeView const & ) ; remove_function_type remove_function_value( &::SireMol::Molecules::remove ); Molecules_exposer.def( "remove" , remove_function_value , ( bp::arg("molview") ) ); } { //::SireMol::Molecules::remove typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::ViewsOfMol const & ) ; remove_function_type remove_function_value( &::SireMol::Molecules::remove ); Molecules_exposer.def( "remove" , remove_function_value , ( bp::arg("molviews") ) ); } { //::SireMol::Molecules::remove typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::Molecules const & ) ; remove_function_type remove_function_value( &::SireMol::Molecules::remove ); Molecules_exposer.def( "remove" , remove_function_value , ( bp::arg("molecules") ) ); } { //::SireMol::Molecules::remove typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::MolNum ) ; remove_function_type remove_function_value( &::SireMol::Molecules::remove ); Molecules_exposer.def( "remove" , remove_function_value , ( bp::arg("molnum") ) ); } { //::SireMol::Molecules::removeAll typedef bool ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::MoleculeView const & ) ; removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll ); Molecules_exposer.def( "removeAll" , removeAll_function_value , ( bp::arg("molview") ) ); } { //::SireMol::Molecules::removeAll typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::ViewsOfMol const & ) ; removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll ); Molecules_exposer.def( "removeAll" , removeAll_function_value , ( bp::arg("molviews") ) ); } { //::SireMol::Molecules::removeAll typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::Molecules const & ) ; removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll ); Molecules_exposer.def( "removeAll" , removeAll_function_value , ( bp::arg("molecules") ) ); } { //::SireMol::Molecules::removeAll typedef bool ( ::SireMol::Molecules::*removeAll_function_type )( ) ; removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll ); Molecules_exposer.def( "removeAll" , removeAll_function_value ); } { //::SireMol::Molecules::removeDuplicates typedef bool ( ::SireMol::Molecules::*removeDuplicates_function_type )( ) ; removeDuplicates_function_type removeDuplicates_function_value( &::SireMol::Molecules::removeDuplicates ); Molecules_exposer.def( "removeDuplicates" , removeDuplicates_function_value ); } { //::SireMol::Molecules::reserve typedef void ( ::SireMol::Molecules::*reserve_function_type )( int ) ; reserve_function_type reserve_function_value( &::SireMol::Molecules::reserve ); Molecules_exposer.def( "reserve" , reserve_function_value , ( bp::arg("nmolecules") ) ); } { //::SireMol::Molecules::toString typedef ::QString ( ::SireMol::Molecules::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMol::Molecules::toString ); Molecules_exposer.def( "toString" , toString_function_value ); } { //::SireMol::Molecules::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::Molecules::typeName ); Molecules_exposer.def( "typeName" , typeName_function_value ); } { //::SireMol::Molecules::unite typedef bool ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::MoleculeView const & ) ; unite_function_type unite_function_value( &::SireMol::Molecules::unite ); Molecules_exposer.def( "unite" , unite_function_value , ( bp::arg("molview") ) ); } { //::SireMol::Molecules::unite typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::ViewsOfMol const & ) ; unite_function_type unite_function_value( &::SireMol::Molecules::unite ); Molecules_exposer.def( "unite" , unite_function_value , ( bp::arg("molviews") ) ); } { //::SireMol::Molecules::unite typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::Molecules const & ) ; unite_function_type unite_function_value( &::SireMol::Molecules::unite ); Molecules_exposer.def( "unite" , unite_function_value , ( bp::arg("other") ) ); } { //::SireMol::Molecules::uniteViews typedef bool ( ::SireMol::Molecules::*uniteViews_function_type )( ) ; uniteViews_function_type uniteViews_function_value( &::SireMol::Molecules::uniteViews ); Molecules_exposer.def( "uniteViews" , uniteViews_function_value ); } { //::SireMol::Molecules::update typedef bool ( ::SireMol::Molecules::*update_function_type )( ::SireMol::MoleculeData const & ) ; update_function_type update_function_value( &::SireMol::Molecules::update ); Molecules_exposer.def( "update" , update_function_value , ( bp::arg("moldata") ) ); } { //::SireMol::Molecules::update typedef bool ( ::SireMol::Molecules::*update_function_type )( ::SireMol::MoleculeView const & ) ; update_function_type update_function_value( &::SireMol::Molecules::update ); Molecules_exposer.def( "update" , update_function_value , ( bp::arg("molview") ) ); } { //::SireMol::Molecules::update typedef ::QList< SireMol::Molecule > ( ::SireMol::Molecules::*update_function_type )( ::SireMol::Molecules const & ) ; update_function_type update_function_value( &::SireMol::Molecules::update ); Molecules_exposer.def( "update" , update_function_value , ( bp::arg("molecules") ) ); } { //::SireMol::Molecules::what typedef char const * ( ::SireMol::Molecules::*what_function_type )( ) const; what_function_type what_function_value( &::SireMol::Molecules::what ); Molecules_exposer.def( "what" , what_function_value ); } Molecules_exposer.staticmethod( "typeName" ); Molecules_exposer.def( "__copy__", &__copy__); Molecules_exposer.def( "__deepcopy__", &__copy__); Molecules_exposer.def( "clone", &__copy__); Molecules_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Molecules >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Molecules_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Molecules >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Molecules_exposer.def( "__str__", &__str__< ::SireMol::Molecules > ); Molecules_exposer.def( "__repr__", &__str__< ::SireMol::Molecules > ); Molecules_exposer.def( "__len__", &__len_count< ::SireMol::Molecules > ); } }
void register_DataPoint_class(){ { //::SireAnalysis::DataPoint typedef bp::class_< SireAnalysis::DataPoint > DataPoint_exposer_t; DataPoint_exposer_t DataPoint_exposer = DataPoint_exposer_t( "DataPoint", "This class represents a single datapoint on an x,y graph. The point\nhas associated errors (small and large) on both the x and y axes\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor. This constructs the point (0,0) with no error") ); bp::scope DataPoint_scope( DataPoint_exposer ); DataPoint_exposer.def( bp::init< double, double >(( bp::arg("x"), bp::arg("y") ), "Construct the point (x,y) with no error") ); DataPoint_exposer.def( bp::init< double, double, double, double >(( bp::arg("x"), bp::arg("y"), bp::arg("xerror"), bp::arg("yerror") ), "Construct the point (x,y) with error (xerror,yerror)") ); DataPoint_exposer.def( bp::init< double, double, double, double, double, double >(( bp::arg("x"), bp::arg("y"), bp::arg("xminerror"), bp::arg("yminerror"), bp::arg("xmaxerror"), bp::arg("ymaxerror") ), "Construct the point (x,y) with a minimum error of (xminerror,yminerror)\nand a maximum error of (xmaxerror,ymaxerror). This is for situations where\nthere may be multiple different error measures on a point and you want\nto store the range of errors (based on a range of error estimates)") ); DataPoint_exposer.def( bp::init< SireAnalysis::DataPoint const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireAnalysis::DataPoint::equalWithinError typedef bool ( ::SireAnalysis::DataPoint::*equalWithinError_function_type)( ::SireAnalysis::DataPoint const & ) const; equalWithinError_function_type equalWithinError_function_value( &::SireAnalysis::DataPoint::equalWithinError ); DataPoint_exposer.def( "equalWithinError" , equalWithinError_function_value , ( bp::arg("other") ) , "Return whether or not this data point is equal to the other, within\nthe error range of the two points" ); } { //::SireAnalysis::DataPoint::equalWithinMaxError typedef bool ( ::SireAnalysis::DataPoint::*equalWithinMaxError_function_type)( ::SireAnalysis::DataPoint const & ) const; equalWithinMaxError_function_type equalWithinMaxError_function_value( &::SireAnalysis::DataPoint::equalWithinMaxError ); DataPoint_exposer.def( "equalWithinMaxError" , equalWithinMaxError_function_value , ( bp::arg("other") ) , "Return whether or not this data point in equal to the other, within\nthe maximum error range of the two points" ); } { //::SireAnalysis::DataPoint::equalWithinMinError typedef bool ( ::SireAnalysis::DataPoint::*equalWithinMinError_function_type)( ::SireAnalysis::DataPoint const & ) const; equalWithinMinError_function_type equalWithinMinError_function_value( &::SireAnalysis::DataPoint::equalWithinMinError ); DataPoint_exposer.def( "equalWithinMinError" , equalWithinMinError_function_value , ( bp::arg("other") ) , "Return whether or not this data point in equal to the other, within\nthe minimum error range of the two points" ); } { //::SireAnalysis::DataPoint::hasError typedef bool ( ::SireAnalysis::DataPoint::*hasError_function_type)( ) const; hasError_function_type hasError_function_value( &::SireAnalysis::DataPoint::hasError ); DataPoint_exposer.def( "hasError" , hasError_function_value , "Return whether or not this data point has any error" ); } { //::SireAnalysis::DataPoint::hasErrorRange typedef bool ( ::SireAnalysis::DataPoint::*hasErrorRange_function_type)( ) const; hasErrorRange_function_type hasErrorRange_function_value( &::SireAnalysis::DataPoint::hasErrorRange ); DataPoint_exposer.def( "hasErrorRange" , hasErrorRange_function_value , "Return whether or not this data point has an error range" ); } { //::SireAnalysis::DataPoint::hasXError typedef bool ( ::SireAnalysis::DataPoint::*hasXError_function_type)( ) const; hasXError_function_type hasXError_function_value( &::SireAnalysis::DataPoint::hasXError ); DataPoint_exposer.def( "hasXError" , hasXError_function_value , "Return whether or not there is any error in the x value" ); } { //::SireAnalysis::DataPoint::hasXErrorRange typedef bool ( ::SireAnalysis::DataPoint::*hasXErrorRange_function_type)( ) const; hasXErrorRange_function_type hasXErrorRange_function_value( &::SireAnalysis::DataPoint::hasXErrorRange ); DataPoint_exposer.def( "hasXErrorRange" , hasXErrorRange_function_value , "Return whether or not there is an error range on the x value" ); } { //::SireAnalysis::DataPoint::hasYError typedef bool ( ::SireAnalysis::DataPoint::*hasYError_function_type)( ) const; hasYError_function_type hasYError_function_value( &::SireAnalysis::DataPoint::hasYError ); DataPoint_exposer.def( "hasYError" , hasYError_function_value , "Return whether or not there is any error in the y value" ); } { //::SireAnalysis::DataPoint::hasYErrorRange typedef bool ( ::SireAnalysis::DataPoint::*hasYErrorRange_function_type)( ) const; hasYErrorRange_function_type hasYErrorRange_function_value( &::SireAnalysis::DataPoint::hasYErrorRange ); DataPoint_exposer.def( "hasYErrorRange" , hasYErrorRange_function_value , "Return whether or not there is an error range on the x value" ); } DataPoint_exposer.def( bp::self != bp::self ); { //::SireAnalysis::DataPoint::operator= typedef ::SireAnalysis::DataPoint & ( ::SireAnalysis::DataPoint::*assign_function_type)( ::SireAnalysis::DataPoint const & ) ; assign_function_type assign_function_value( &::SireAnalysis::DataPoint::operator= ); DataPoint_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } DataPoint_exposer.def( bp::self == bp::self ); { //::SireAnalysis::DataPoint::toString typedef ::QString ( ::SireAnalysis::DataPoint::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireAnalysis::DataPoint::toString ); DataPoint_exposer.def( "toString" , toString_function_value , "" ); } { //::SireAnalysis::DataPoint::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireAnalysis::DataPoint::typeName ); DataPoint_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireAnalysis::DataPoint::what typedef char const * ( ::SireAnalysis::DataPoint::*what_function_type)( ) const; what_function_type what_function_value( &::SireAnalysis::DataPoint::what ); DataPoint_exposer.def( "what" , what_function_value , "" ); } { //::SireAnalysis::DataPoint::x typedef double ( ::SireAnalysis::DataPoint::*x_function_type)( ) const; x_function_type x_function_value( &::SireAnalysis::DataPoint::x ); DataPoint_exposer.def( "x" , x_function_value , "Return the x value of the point" ); } { //::SireAnalysis::DataPoint::xError typedef double ( ::SireAnalysis::DataPoint::*xError_function_type)( ) const; xError_function_type xError_function_value( &::SireAnalysis::DataPoint::xError ); DataPoint_exposer.def( "xError" , xError_function_value , "Return the error on the x value. This is the average\nof the minimum and maximum error" ); } { //::SireAnalysis::DataPoint::xMaxError typedef double ( ::SireAnalysis::DataPoint::*xMaxError_function_type)( ) const; xMaxError_function_type xMaxError_function_value( &::SireAnalysis::DataPoint::xMaxError ); DataPoint_exposer.def( "xMaxError" , xMaxError_function_value , "Return the maximum size of the error on the x value" ); } { //::SireAnalysis::DataPoint::xMinError typedef double ( ::SireAnalysis::DataPoint::*xMinError_function_type)( ) const; xMinError_function_type xMinError_function_value( &::SireAnalysis::DataPoint::xMinError ); DataPoint_exposer.def( "xMinError" , xMinError_function_value , "Return the minimum size of the error on the x value" ); } { //::SireAnalysis::DataPoint::y typedef double ( ::SireAnalysis::DataPoint::*y_function_type)( ) const; y_function_type y_function_value( &::SireAnalysis::DataPoint::y ); DataPoint_exposer.def( "y" , y_function_value , "Return the y value of the point" ); } { //::SireAnalysis::DataPoint::yError typedef double ( ::SireAnalysis::DataPoint::*yError_function_type)( ) const; yError_function_type yError_function_value( &::SireAnalysis::DataPoint::yError ); DataPoint_exposer.def( "yError" , yError_function_value , "Return the error on the y value. This is the average\nof the minimum and maximum error" ); } { //::SireAnalysis::DataPoint::yMaxError typedef double ( ::SireAnalysis::DataPoint::*yMaxError_function_type)( ) const; yMaxError_function_type yMaxError_function_value( &::SireAnalysis::DataPoint::yMaxError ); DataPoint_exposer.def( "yMaxError" , yMaxError_function_value , "Return the maximum size of the error on the y value" ); } { //::SireAnalysis::DataPoint::yMinError typedef double ( ::SireAnalysis::DataPoint::*yMinError_function_type)( ) const; yMinError_function_type yMinError_function_value( &::SireAnalysis::DataPoint::yMinError ); DataPoint_exposer.def( "yMinError" , yMinError_function_value , "Return the minimum size of the error on the y value" ); } DataPoint_exposer.staticmethod( "typeName" ); DataPoint_exposer.def( "__copy__", &__copy__); DataPoint_exposer.def( "__deepcopy__", &__copy__); DataPoint_exposer.def( "clone", &__copy__); DataPoint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::DataPoint >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); DataPoint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::DataPoint >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); DataPoint_exposer.def( "__str__", &__str__< ::SireAnalysis::DataPoint > ); DataPoint_exposer.def( "__repr__", &__str__< ::SireAnalysis::DataPoint > ); } }