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_Segment_class(){ { //::SireMol::Segment typedef bp::class_< SireMol::Segment, bp::bases< SireMol::MoleculeView, SireBase::Property > > Segment_exposer_t; Segment_exposer_t Segment_exposer = Segment_exposer_t( "Segment", bp::init< >() ); bp::scope Segment_scope( Segment_exposer ); Segment_exposer.def( bp::init< SireMol::MoleculeData const &, SireMol::SegID const & >(( bp::arg("data"), bp::arg("segid") )) ); Segment_exposer.def( bp::init< SireMol::Segment const & >(( bp::arg("other") )) ); { //::SireMol::Segment::assertContainsMetadata typedef void ( ::SireMol::Segment::*assertContainsMetadata_function_type )( ::SireBase::PropertyName const & ) const; assertContainsMetadata_function_type assertContainsMetadata_function_value( &::SireMol::Segment::assertContainsMetadata ); Segment_exposer.def( "assertContainsMetadata" , assertContainsMetadata_function_value , ( bp::arg("metakey") ) ); } { //::SireMol::Segment::assertContainsMetadata typedef void ( ::SireMol::Segment::*assertContainsMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const; assertContainsMetadata_function_type assertContainsMetadata_function_value( &::SireMol::Segment::assertContainsMetadata ); Segment_exposer.def( "assertContainsMetadata" , assertContainsMetadata_function_value , ( bp::arg("key"), bp::arg("metakey") ) ); } { //::SireMol::Segment::assertContainsProperty typedef void ( ::SireMol::Segment::*assertContainsProperty_function_type )( ::SireBase::PropertyName const & ) const; assertContainsProperty_function_type assertContainsProperty_function_value( &::SireMol::Segment::assertContainsProperty ); Segment_exposer.def( "assertContainsProperty" , assertContainsProperty_function_value , ( bp::arg("key") ) ); } { //::SireMol::Segment::atomIdxs typedef ::QList< SireMol::AtomIdx > const & ( ::SireMol::Segment::*atomIdxs_function_type )( ) const; atomIdxs_function_type atomIdxs_function_value( &::SireMol::Segment::atomIdxs ); Segment_exposer.def( "atomIdxs" , atomIdxs_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMol::Segment::contains typedef bool ( ::SireMol::Segment::*contains_function_type )( ::SireMol::AtomIdx ) const; contains_function_type contains_function_value( &::SireMol::Segment::contains ); Segment_exposer.def( "contains" , contains_function_value , ( bp::arg("atomidx") ) ); } { //::SireMol::Segment::contains typedef bool ( ::SireMol::Segment::*contains_function_type )( ::SireMol::AtomID const & ) const; contains_function_type contains_function_value( &::SireMol::Segment::contains ); Segment_exposer.def( "contains" , contains_function_value , ( bp::arg("atomid") ) ); } { //::SireMol::Segment::edit typedef ::SireMol::SegEditor ( ::SireMol::Segment::*edit_function_type )( ) const; edit_function_type edit_function_value( &::SireMol::Segment::edit ); Segment_exposer.def( "edit" , edit_function_value ); } { //::SireMol::Segment::evaluate typedef ::SireMol::Evaluator ( ::SireMol::Segment::*evaluate_function_type )( ) const; evaluate_function_type evaluate_function_value( &::SireMol::Segment::evaluate ); Segment_exposer.def( "evaluate" , evaluate_function_value ); } { //::SireMol::Segment::hasMetadata typedef bool ( ::SireMol::Segment::*hasMetadata_function_type )( ::SireBase::PropertyName const & ) const; hasMetadata_function_type hasMetadata_function_value( &::SireMol::Segment::hasMetadata ); Segment_exposer.def( "hasMetadata" , hasMetadata_function_value , ( bp::arg("metakey") ) ); } { //::SireMol::Segment::hasMetadata typedef bool ( ::SireMol::Segment::*hasMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const; hasMetadata_function_type hasMetadata_function_value( &::SireMol::Segment::hasMetadata ); Segment_exposer.def( "hasMetadata" , hasMetadata_function_value , ( bp::arg("key"), bp::arg("metakey") ) ); } { //::SireMol::Segment::hasProperty typedef bool ( ::SireMol::Segment::*hasProperty_function_type )( ::SireBase::PropertyName const & ) const; hasProperty_function_type hasProperty_function_value( &::SireMol::Segment::hasProperty ); Segment_exposer.def( "hasProperty" , hasProperty_function_value , ( bp::arg("key") ) ); } { //::SireMol::Segment::index typedef ::SireMol::SegIdx ( ::SireMol::Segment::*index_function_type )( ) const; index_function_type index_function_value( &::SireMol::Segment::index ); Segment_exposer.def( "index" , index_function_value ); } { //::SireMol::Segment::intersects typedef bool ( ::SireMol::Segment::*intersects_function_type )( ::SireMol::AtomID const & ) const; intersects_function_type intersects_function_value( &::SireMol::Segment::intersects ); Segment_exposer.def( "intersects" , intersects_function_value , ( bp::arg("atomid") ) ); } { //::SireMol::Segment::isEmpty typedef bool ( ::SireMol::Segment::*isEmpty_function_type )( ) const; isEmpty_function_type isEmpty_function_value( &::SireMol::Segment::isEmpty ); Segment_exposer.def( "isEmpty" , isEmpty_function_value ); } { //::SireMol::Segment::metadataKeys typedef ::QStringList ( ::SireMol::Segment::*metadataKeys_function_type )( ) const; metadataKeys_function_type metadataKeys_function_value( &::SireMol::Segment::metadataKeys ); Segment_exposer.def( "metadataKeys" , metadataKeys_function_value ); } { //::SireMol::Segment::metadataKeys typedef ::QStringList ( ::SireMol::Segment::*metadataKeys_function_type )( ::SireBase::PropertyName const & ) const; metadataKeys_function_type metadataKeys_function_value( &::SireMol::Segment::metadataKeys ); Segment_exposer.def( "metadataKeys" , metadataKeys_function_value , ( bp::arg("key") ) ); } { //::SireMol::Segment::move typedef ::SireMol::Mover< SireMol::Segment > ( ::SireMol::Segment::*move_function_type )( ) const; move_function_type move_function_value( &::SireMol::Segment::move ); Segment_exposer.def( "move" , move_function_value ); } { //::SireMol::Segment::nAtoms typedef int ( ::SireMol::Segment::*nAtoms_function_type )( ) const; nAtoms_function_type nAtoms_function_value( &::SireMol::Segment::nAtoms ); Segment_exposer.def( "nAtoms" , nAtoms_function_value ); } { //::SireMol::Segment::name typedef ::SireMol::SegName const & ( ::SireMol::Segment::*name_function_type )( ) const; name_function_type name_function_value( &::SireMol::Segment::name ); Segment_exposer.def( "name" , name_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } Segment_exposer.def( bp::self != bp::self ); { //::SireMol::Segment::operator= typedef ::SireMol::Segment & ( ::SireMol::Segment::*assign_function_type )( ::SireMol::Segment const & ) ; assign_function_type assign_function_value( &::SireMol::Segment::operator= ); Segment_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } Segment_exposer.def( bp::self == bp::self ); { //::SireMol::Segment::propertyKeys typedef ::QStringList ( ::SireMol::Segment::*propertyKeys_function_type )( ) const; propertyKeys_function_type propertyKeys_function_value( &::SireMol::Segment::propertyKeys ); Segment_exposer.def( "propertyKeys" , propertyKeys_function_value ); } { //::SireMol::Segment::selectedAll typedef bool ( ::SireMol::Segment::*selectedAll_function_type )( ) const; selectedAll_function_type selectedAll_function_value( &::SireMol::Segment::selectedAll ); Segment_exposer.def( "selectedAll" , selectedAll_function_value ); } { //::SireMol::Segment::selection typedef ::SireMol::AtomSelection ( ::SireMol::Segment::*selection_function_type )( ) const; selection_function_type selection_function_value( &::SireMol::Segment::selection ); Segment_exposer.def( "selection" , selection_function_value ); } { //::SireMol::Segment::selector typedef ::SireMol::Selector< SireMol::Segment > ( ::SireMol::Segment::*selector_function_type )( ) const; selector_function_type selector_function_value( &::SireMol::Segment::selector ); Segment_exposer.def( "selector" , selector_function_value ); } { //::SireMol::Segment::toString typedef ::QString ( ::SireMol::Segment::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMol::Segment::toString ); Segment_exposer.def( "toString" , toString_function_value ); } { //::SireMol::Segment::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::Segment::typeName ); Segment_exposer.def( "typeName" , typeName_function_value ); } { //::SireMol::Segment::update typedef void ( ::SireMol::Segment::*update_function_type )( ::SireMol::MoleculeData const & ) ; update_function_type update_function_value( &::SireMol::Segment::update ); Segment_exposer.def( "update" , update_function_value , ( bp::arg("moldata") ) ); } Segment_exposer.staticmethod( "typeName" ); Segment_exposer.def( "_get_property_SireMol_SegStringProperty", &SireMol::Segment::property< QString >, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_metadata_SireMol_SegStringProperty", get_Metadata_SireMol_SegStringProperty_function1, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_metadata_SireMol_SegStringProperty", &get_Metadata_SireMol_SegStringProperty_function2, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_property_SireMol_SegIntProperty", &SireMol::Segment::property< qint64 >, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_metadata_SireMol_SegIntProperty", get_Metadata_SireMol_SegIntProperty_function1, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_metadata_SireMol_SegIntProperty", &get_Metadata_SireMol_SegIntProperty_function2, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_property_SireMol_SegFloatProperty", &SireMol::Segment::property< double >, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_metadata_SireMol_SegFloatProperty", get_Metadata_SireMol_SegFloatProperty_function1, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_metadata_SireMol_SegFloatProperty", &get_Metadata_SireMol_SegFloatProperty_function2, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_property_SireMol_SegVariantProperty", &SireMol::Segment::property< QVariant >, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_metadata_SireMol_SegVariantProperty", get_Metadata_SireMol_SegVariantProperty_function1, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "_get_metadata_SireMol_SegVariantProperty", &get_Metadata_SireMol_SegVariantProperty_function2, bp::return_value_policy<bp::copy_const_reference>()); Segment_exposer.def( "__copy__", &__copy__); Segment_exposer.def( "__deepcopy__", &__copy__); Segment_exposer.def( "clone", &__copy__); Segment_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Segment >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Segment_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Segment >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Segment_exposer.def( "__str__", &__str__< ::SireMol::Segment > ); Segment_exposer.def( "__repr__", &__str__< ::SireMol::Segment > ); } }
void register_AABox_class(){ { //::SireVol::AABox typedef bp::class_< SireVol::AABox > AABox_exposer_t; AABox_exposer_t AABox_exposer = AABox_exposer_t( "AABox", "\nAn AABox is an axis-aligned bounding box that is the smallest box that is aligned with the three cartesian axes that completely encases a CoordGroup. It is trivial to obtain the bounding sphere from the AABox. The AABox is used by the distance calculators to quickly determine whether two CoordGroups are within the cutoff radius, and to obtain all CoordGroups that are within particular regions of space.\n\nAuthor: Christopher Woods\n", bp::init< >("Construct an empty AABox") ); bp::scope AABox_scope( AABox_exposer ); AABox_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("point") ), "Construct an AABox that completely encloses the point point") ); AABox_exposer.def( bp::init< SireMaths::Vector const &, SireMaths::Vector const & >(( bp::arg("cent"), bp::arg("extents") ), "Construct an AABox with center at cent, and half-extents extents") ); AABox_exposer.def( bp::init< QVector< SireMaths::Vector > const & >(( bp::arg("coordinates") ), "Construct an AABox that completely encases the points in coordinates") ); AABox_exposer.def( bp::init< SireMaths::Vector const *, int >(( bp::arg("coords"), bp::arg("ncoords") ), "Construct an AABox that completely encases the points in coords") ); AABox_exposer.def( bp::init< SireVol::CoordGroupBase const & >(( bp::arg("coordgroup") ), "Construct an AABox that completely encases the CoordGroup coordgroup") ); AABox_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("cgarray") ), "Construct an AABox that completely encases all of the points in all of the\nCoordGroups in cgarray") ); AABox_exposer.def( bp::init< SireVol::CoordGroupArrayArray const & >(( bp::arg("cgarrays") ), "Construct an AABox that completely encases all of the points in all of the\nCoordGroups in all of the arrays in cgarrays") ); { //::SireVol::AABox::add typedef void ( ::SireVol::AABox::*add_function_type)( ::SireVol::AABox const & ) ; add_function_type add_function_value( &::SireVol::AABox::add ); AABox_exposer.def( "add" , add_function_value , ( bp::arg("other") ) , "Add another AABox to this one - this forms the union of both of the\nboxes." ); } { //::SireVol::AABox::add typedef void ( ::SireVol::AABox::*add_function_type)( ::SireMaths::Vector const & ) ; add_function_type add_function_value( &::SireVol::AABox::add ); AABox_exposer.def( "add" , add_function_value , ( bp::arg("point") ) , "Add a point to this box" ); } { //::SireVol::AABox::add typedef void ( ::SireVol::AABox::*add_function_type)( ::QVector< SireMaths::Vector > const & ) ; add_function_type add_function_value( &::SireVol::AABox::add ); AABox_exposer.def( "add" , add_function_value , ( bp::arg("points") ) , "Add lots of points to this box" ); } { //::SireVol::AABox::boundingSphere typedef ::SireMaths::Sphere ( ::SireVol::AABox::*boundingSphere_function_type)( ) const; boundingSphere_function_type boundingSphere_function_value( &::SireVol::AABox::boundingSphere ); AABox_exposer.def( "boundingSphere" , boundingSphere_function_value , "Return the sphere that just contains this AABox" ); } { //::SireVol::AABox::center typedef ::SireMaths::Vector const & ( ::SireVol::AABox::*center_function_type)( ) const; center_function_type center_function_value( &::SireVol::AABox::center ); AABox_exposer.def( "center" , center_function_value , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireVol::AABox::contains typedef bool ( ::SireVol::AABox::*contains_function_type)( ::SireVol::AABox const & ) const; contains_function_type contains_function_value( &::SireVol::AABox::contains ); AABox_exposer.def( "contains" , contains_function_value , ( bp::arg("other") ) , "Return whether or not this box contains other" ); } { //::SireVol::AABox::contains typedef bool ( ::SireVol::AABox::*contains_function_type)( ::SireMaths::Vector const & ) const; contains_function_type contains_function_value( &::SireVol::AABox::contains ); AABox_exposer.def( "contains" , contains_function_value , ( bp::arg("point") ) , "Return whether or not this box contains the point point" ); } { //::SireVol::AABox::from typedef ::SireVol::AABox ( *from_function_type )( ::SireMaths::Vector const & ); from_function_type from_function_value( &::SireVol::AABox::from ); AABox_exposer.def( "from" , from_function_value , ( bp::arg("point") ) , "Return an AABox constructed to contain the coordinates of point" ); } { //::SireVol::AABox::from typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupBase const & ); from_function_type from_function_value( &::SireVol::AABox::from ); AABox_exposer.def( "from" , from_function_value , ( bp::arg("coordgroup") ) , "Return an AABox constructed to contain the coordinates in coordinates" ); } { //::SireVol::AABox::from typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupArray const & ); from_function_type from_function_value( &::SireVol::AABox::from ); AABox_exposer.def( "from" , from_function_value , ( bp::arg("cgarray") ) , "Return an AABox constructed to contain all of the CoordGroups in cgarray" ); } { //::SireVol::AABox::from typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupArrayArray const & ); from_function_type from_function_value( &::SireVol::AABox::from ); AABox_exposer.def( "from" , from_function_value , ( bp::arg("cgarrays") ) , "Return an AABox constructed to contain all of the CoordGroups in the\narrays in cgarrays" ); } { //::SireVol::AABox::from typedef ::SireVol::AABox ( *from_function_type )( ::QVector< SireMaths::Vector > const & ); from_function_type from_function_value( &::SireVol::AABox::from ); AABox_exposer.def( "from" , from_function_value , ( bp::arg("coords") ) , "Return an AABox constructed to contain the coordinates in coordinates" ); } { //::SireVol::AABox::from typedef ::SireVol::AABox ( *from_function_type )( ::SireMaths::Vector const &,::SireMaths::Vector const & ); from_function_type from_function_value( &::SireVol::AABox::from ); AABox_exposer.def( "from" , from_function_value , ( bp::arg("mincoords"), bp::arg("maxcoords") ) , "Construct a new AABox from the passed minimum and maximum coordinates" ); } { //::SireVol::AABox::halfExtents typedef ::SireMaths::Vector const & ( ::SireVol::AABox::*halfExtents_function_type)( ) const; halfExtents_function_type halfExtents_function_value( &::SireVol::AABox::halfExtents ); AABox_exposer.def( "halfExtents" , halfExtents_function_value , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireVol::AABox::intersects typedef bool ( ::SireVol::AABox::*intersects_function_type)( ::SireVol::AABox const & ) const; intersects_function_type intersects_function_value( &::SireVol::AABox::intersects ); AABox_exposer.def( "intersects" , intersects_function_value , ( bp::arg("other") ) , "Return whether this box intersects with box" ); } { //::SireVol::AABox::isEmpty typedef bool ( ::SireVol::AABox::*isEmpty_function_type)( ) const; isEmpty_function_type isEmpty_function_value( &::SireVol::AABox::isEmpty ); AABox_exposer.def( "isEmpty" , isEmpty_function_value , "Return if the AABox is empty" ); } { //::SireVol::AABox::isNull typedef bool ( ::SireVol::AABox::*isNull_function_type)( ) const; isNull_function_type isNull_function_value( &::SireVol::AABox::isNull ); AABox_exposer.def( "isNull" , isNull_function_value , "Return if the AABox is null" ); } { //::SireVol::AABox::maxCoords typedef ::SireMaths::Vector ( ::SireVol::AABox::*maxCoords_function_type)( ) const; maxCoords_function_type maxCoords_function_value( &::SireVol::AABox::maxCoords ); AABox_exposer.def( "maxCoords" , maxCoords_function_value , "" ); } { //::SireVol::AABox::minCoords typedef ::SireMaths::Vector ( ::SireVol::AABox::*minCoords_function_type)( ) const; minCoords_function_type minCoords_function_value( &::SireVol::AABox::minCoords ); AABox_exposer.def( "minCoords" , minCoords_function_value , "" ); } AABox_exposer.def( bp::self != bp::self ); AABox_exposer.def( bp::self + bp::self ); AABox_exposer.def( bp::self + bp::other< SireMaths::Vector >() ); AABox_exposer.def( bp::self + bp::other< QVector< SireMaths::Vector > >() ); { //::SireVol::AABox::operator= typedef ::SireVol::AABox const & ( ::SireVol::AABox::*assign_function_type)( ::SireVol::AABox const & ) ; assign_function_type assign_function_value( &::SireVol::AABox::operator= ); AABox_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_value_policy< bp::copy_const_reference >() , "" ); } AABox_exposer.def( bp::self == bp::self ); { //::SireVol::AABox::radius typedef double ( ::SireVol::AABox::*radius_function_type)( ) const; radius_function_type radius_function_value( &::SireVol::AABox::radius ); AABox_exposer.def( "radius" , radius_function_value , "" ); } { //::SireVol::AABox::recalculate typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::SireVol::CoordGroupBase const & ) ; recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate ); AABox_exposer.def( "recalculate" , recalculate_function_value , ( bp::arg("coordgroup") ) , "Recalculate the AABox so that it completely encloses the CoordGroup coordgroup" ); } { //::SireVol::AABox::recalculate typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::SireVol::CoordGroupArray const & ) ; recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate ); AABox_exposer.def( "recalculate" , recalculate_function_value , ( bp::arg("cgarray") ) , "Recalculate the AABox so that it completely encloses the CoordGroups\nin the array cgarray" ); } { //::SireVol::AABox::recalculate typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::SireVol::CoordGroupArrayArray const & ) ; recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate ); AABox_exposer.def( "recalculate" , recalculate_function_value , ( bp::arg("cgarrays") ) , "Recalculate the AABox so that it completely encloses the CoordGroups\nin the arrays cgarrays" ); } { //::SireVol::AABox::recalculate typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::QVector< SireMaths::Vector > const & ) ; recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate ); AABox_exposer.def( "recalculate" , recalculate_function_value , ( bp::arg("coordinates") ) , "Recalculate the AABox so that it completely encloses the coordinates" ); } { //::SireVol::AABox::toString typedef ::QString ( ::SireVol::AABox::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireVol::AABox::toString ); AABox_exposer.def( "toString" , toString_function_value , "Return a string representation of this AABox" ); } { //::SireVol::AABox::translate typedef void ( ::SireVol::AABox::*translate_function_type)( ::SireMaths::Vector const & ) ; translate_function_type translate_function_value( &::SireVol::AABox::translate ); AABox_exposer.def( "translate" , translate_function_value , ( bp::arg("delta") ) , "Translate this AABox by delta" ); } { //::SireVol::AABox::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireVol::AABox::typeName ); AABox_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireVol::AABox::what typedef char const * ( ::SireVol::AABox::*what_function_type)( ) const; what_function_type what_function_value( &::SireVol::AABox::what ); AABox_exposer.def( "what" , what_function_value , "" ); } { //::SireVol::AABox::withinDistance typedef bool ( ::SireVol::AABox::*withinDistance_function_type)( double,::SireVol::AABox const & ) const; withinDistance_function_type withinDistance_function_value( &::SireVol::AABox::withinDistance ); AABox_exposer.def( "withinDistance" , withinDistance_function_value , ( bp::arg("dist"), bp::arg("box") ) , "Return whether or not this box is within dist of box box.\n(using infinite cartesian axes)" ); } AABox_exposer.staticmethod( "from" ); AABox_exposer.staticmethod( "typeName" ); AABox_exposer.def( "__copy__", &__copy__); AABox_exposer.def( "__deepcopy__", &__copy__); AABox_exposer.def( "clone", &__copy__); AABox_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::AABox >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); AABox_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::AABox >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); AABox_exposer.def( "__str__", &__str__< ::SireVol::AABox > ); AABox_exposer.def( "__repr__", &__str__< ::SireVol::AABox > ); } }
void register_DistanceRestraint_class(){ { //::SireMM::DistanceRestraint typedef bp::class_< SireMM::DistanceRestraint, bp::bases< SireMM::Restraint3D, SireMM::Restraint, SireBase::Property > > DistanceRestraint_exposer_t; DistanceRestraint_exposer_t DistanceRestraint_exposer = DistanceRestraint_exposer_t( "DistanceRestraint", "This is a restraint that operates on the distance between\ntwo SireMM::Point objects (e.g. two atoms in a molecule,\na point in space and the center of a molecule, the\ncenter of geometry of one molecule with the center of\nmass of the solvent)\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") ); bp::scope DistanceRestraint_scope( DistanceRestraint_exposer ); DistanceRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("restraint") ), "Construct a restraint that acts between the two points point0 and point1,\nrestraining the distance between these points using the expression\nrestraint") ); DistanceRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const &, SireCAS::Values const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("restraint"), bp::arg("values") ), "Construct a restraint that acts between the two points point0 and point1,\nrestraining the distance between these points using the expression\nrestraint, with supplied values for this expression in values.\nNote that any extra values in values that arent in the expression\nrestraint are ignored") ); DistanceRestraint_exposer.def( bp::init< SireMM::DistanceRestraint const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMM::DistanceRestraint::builtinSymbols typedef ::SireCAS::Symbols ( ::SireMM::DistanceRestraint::*builtinSymbols_function_type)( ) const; builtinSymbols_function_type builtinSymbols_function_value( &::SireMM::DistanceRestraint::builtinSymbols ); DistanceRestraint_exposer.def( "builtinSymbols" , builtinSymbols_function_value , "Return the built-in symbols of this restraint" ); } { //::SireMM::DistanceRestraint::builtinValues typedef ::SireCAS::Values ( ::SireMM::DistanceRestraint::*builtinValues_function_type)( ) const; builtinValues_function_type builtinValues_function_value( &::SireMM::DistanceRestraint::builtinValues ); DistanceRestraint_exposer.def( "builtinValues" , builtinValues_function_value , "Return the built-in values of this restraint" ); } { //::SireMM::DistanceRestraint::contains typedef bool ( ::SireMM::DistanceRestraint::*contains_function_type)( ::SireMol::MolNum ) const; contains_function_type contains_function_value( &::SireMM::DistanceRestraint::contains ); DistanceRestraint_exposer.def( "contains" , contains_function_value , ( bp::arg("molnum") ) , "Return whether or not this restraint affects the molecule\nwith number molnum" ); } { //::SireMM::DistanceRestraint::contains typedef bool ( ::SireMM::DistanceRestraint::*contains_function_type)( ::SireMol::MolID const & ) const; contains_function_type contains_function_value( &::SireMM::DistanceRestraint::contains ); DistanceRestraint_exposer.def( "contains" , contains_function_value , ( bp::arg("molid") ) , "Return whether or not this restraint affects the molecule\nwith ID molid" ); } { //::SireMM::DistanceRestraint::differentialRestraintFunction typedef ::SireCAS::Expression const & ( ::SireMM::DistanceRestraint::*differentialRestraintFunction_function_type)( ) const; differentialRestraintFunction_function_type differentialRestraintFunction_function_value( &::SireMM::DistanceRestraint::differentialRestraintFunction ); DistanceRestraint_exposer.def( "differentialRestraintFunction" , differentialRestraintFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the function used to calculate the restraint force" ); } { //::SireMM::DistanceRestraint::differentiate typedef ::SireMM::RestraintPtr ( ::SireMM::DistanceRestraint::*differentiate_function_type)( ::SireCAS::Symbol const & ) const; differentiate_function_type differentiate_function_value( &::SireMM::DistanceRestraint::differentiate ); DistanceRestraint_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol") ) , "Return the restraint that is the differential of this restraint\nwith respect to the symbol symbol\nThrow: SireCAS::unavailable_differential\n" ); } { //::SireMM::DistanceRestraint::force typedef void ( ::SireMM::DistanceRestraint::*force_function_type)( ::SireFF::MolForceTable &,double ) const; force_function_type force_function_value( &::SireMM::DistanceRestraint::force ); DistanceRestraint_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) , "Calculate the force acting on the molecule in the forcetable forcetable\ncaused by this restraint, and add it on to the forcetable scaled by\nscale_force" ); } { //::SireMM::DistanceRestraint::force typedef void ( ::SireMM::DistanceRestraint::*force_function_type)( ::SireFF::ForceTable &,double ) const; force_function_type force_function_value( &::SireMM::DistanceRestraint::force ); DistanceRestraint_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) , "Calculate the force acting on the molecules in the forcetable forcetable\ncaused by this restraint, and add it on to the forcetable scaled by\nscale_force" ); } { //::SireMM::DistanceRestraint::halfHarmonic typedef ::SireMM::DistanceRestraint ( *halfHarmonic_function_type )( ::SireFF::PointRef const &,::SireFF::PointRef const &,::SireUnits::Dimension::Length const &,::SireMM::HarmonicDistanceForceConstant const & ); halfHarmonic_function_type halfHarmonic_function_value( &::SireMM::DistanceRestraint::halfHarmonic ); DistanceRestraint_exposer.def( "halfHarmonic" , halfHarmonic_function_value , ( bp::arg("point0"), bp::arg("point1"), bp::arg("distance"), bp::arg("force_constant") ) , "Return a distance restraint that applied a half-harmonic potential\nbetween the points point0 and point1 above a distance distance\nusing a force constant force_constant" ); } { //::SireMM::DistanceRestraint::harmonic typedef ::SireMM::DistanceRestraint ( *harmonic_function_type )( ::SireFF::PointRef const &,::SireFF::PointRef const &,::SireMM::HarmonicDistanceForceConstant const & ); harmonic_function_type harmonic_function_value( &::SireMM::DistanceRestraint::harmonic ); DistanceRestraint_exposer.def( "harmonic" , harmonic_function_value , ( bp::arg("point0"), bp::arg("point1"), bp::arg("force_constant") ) , "Return a distance restraint that applies a harmonic potential between\nthe points point0 and point1 using a force constant force_constant" ); } { //::SireMM::DistanceRestraint::molecules typedef ::SireMol::Molecules ( ::SireMM::DistanceRestraint::*molecules_function_type)( ) const; molecules_function_type molecules_function_value( &::SireMM::DistanceRestraint::molecules ); DistanceRestraint_exposer.def( "molecules" , molecules_function_value , "Return the molecules used in this restraint" ); } { //::SireMM::DistanceRestraint::nPoints typedef int ( ::SireMM::DistanceRestraint::*nPoints_function_type)( ) const; nPoints_function_type nPoints_function_value( &::SireMM::DistanceRestraint::nPoints ); DistanceRestraint_exposer.def( "nPoints" , nPoints_function_value , "This restraint involves two points" ); } DistanceRestraint_exposer.def( bp::self != bp::self ); { //::SireMM::DistanceRestraint::operator= typedef ::SireMM::DistanceRestraint & ( ::SireMM::DistanceRestraint::*assign_function_type)( ::SireMM::DistanceRestraint const & ) ; assign_function_type assign_function_value( &::SireMM::DistanceRestraint::operator= ); DistanceRestraint_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } DistanceRestraint_exposer.def( bp::self == bp::self ); { //::SireMM::DistanceRestraint::point typedef ::SireFF::Point const & ( ::SireMM::DistanceRestraint::*point_function_type)( int ) const; point_function_type point_function_value( &::SireMM::DistanceRestraint::point ); DistanceRestraint_exposer.def( "point" , point_function_value , ( bp::arg("i") ) , bp::return_value_policy<bp::clone_const_reference>() , "Return the ith point" ); } { //::SireMM::DistanceRestraint::point0 typedef ::SireFF::Point const & ( ::SireMM::DistanceRestraint::*point0_function_type)( ) const; point0_function_type point0_function_value( &::SireMM::DistanceRestraint::point0 ); DistanceRestraint_exposer.def( "point0" , point0_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the first point" ); } { //::SireMM::DistanceRestraint::point1 typedef ::SireFF::Point const & ( ::SireMM::DistanceRestraint::*point1_function_type)( ) const; point1_function_type point1_function_value( &::SireMM::DistanceRestraint::point1 ); DistanceRestraint_exposer.def( "point1" , point1_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the second point" ); } { //::SireMM::DistanceRestraint::r typedef ::SireCAS::Symbol const & ( *r_function_type )( ); r_function_type r_function_value( &::SireMM::DistanceRestraint::r ); DistanceRestraint_exposer.def( "r" , r_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the symbol that represents the distance between the\ntwo points (r)" ); } { //::SireMM::DistanceRestraint::setSpace typedef void ( ::SireMM::DistanceRestraint::*setSpace_function_type)( ::SireVol::Space const & ) ; setSpace_function_type setSpace_function_value( &::SireMM::DistanceRestraint::setSpace ); DistanceRestraint_exposer.def( "setSpace" , setSpace_function_value , ( bp::arg("space") ) , "Set the space used to evaluate the energy of this restraint\nThrow: SireVol::incompatible_space\n" ); } { //::SireMM::DistanceRestraint::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::DistanceRestraint::typeName ); DistanceRestraint_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMM::DistanceRestraint::update typedef void ( ::SireMM::DistanceRestraint::*update_function_type)( ::SireMol::MoleculeData const & ) ; update_function_type update_function_value( &::SireMM::DistanceRestraint::update ); DistanceRestraint_exposer.def( "update" , update_function_value , ( bp::arg("moldata") ) , "Update the points of this restraint using new molecule data from moldata\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\nThrow: SireError::incompatible_error\n" ); } { //::SireMM::DistanceRestraint::update typedef void ( ::SireMM::DistanceRestraint::*update_function_type)( ::SireMol::Molecules const & ) ; update_function_type update_function_value( &::SireMM::DistanceRestraint::update ); DistanceRestraint_exposer.def( "update" , update_function_value , ( bp::arg("molecules") ) , "Update the points of this restraint using new molecule data from molecules\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\nThrow: SireError::incompatible_error\n" ); } { //::SireMM::DistanceRestraint::usesMoleculesIn typedef bool ( ::SireMM::DistanceRestraint::*usesMoleculesIn_function_type)( ::SireFF::ForceTable const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DistanceRestraint::usesMoleculesIn ); DistanceRestraint_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("forcetable") ) , "Return whether or not this restraint involves any of the molecules\nthat are in the forcetable forcetable" ); } { //::SireMM::DistanceRestraint::usesMoleculesIn typedef bool ( ::SireMM::DistanceRestraint::*usesMoleculesIn_function_type)( ::SireMol::Molecules const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DistanceRestraint::usesMoleculesIn ); DistanceRestraint_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("molecules") ) , "Return whether or not this restraint involves any of the molecules\nin molecules" ); } DistanceRestraint_exposer.staticmethod( "halfHarmonic" ); DistanceRestraint_exposer.staticmethod( "harmonic" ); DistanceRestraint_exposer.staticmethod( "r" ); DistanceRestraint_exposer.staticmethod( "typeName" ); DistanceRestraint_exposer.def( "__copy__", &__copy__); DistanceRestraint_exposer.def( "__deepcopy__", &__copy__); DistanceRestraint_exposer.def( "clone", &__copy__); DistanceRestraint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::DistanceRestraint >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); DistanceRestraint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::DistanceRestraint >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); DistanceRestraint_exposer.def( "__str__", &__str__< ::SireMM::DistanceRestraint > ); DistanceRestraint_exposer.def( "__repr__", &__str__< ::SireMM::DistanceRestraint > ); } }
void register_Sphere_class(){ { //::SireMaths::Sphere typedef bp::class_< SireMaths::Sphere > Sphere_exposer_t; Sphere_exposer_t Sphere_exposer = Sphere_exposer_t( "Sphere", bp::init< >() ); bp::scope Sphere_scope( Sphere_exposer ); Sphere_exposer.def( bp::init< double const & >(( bp::arg("radius") )) ); Sphere_exposer.def( bp::init< SireMaths::Vector const &, double const & >(( bp::arg("position"), bp::arg("radius") )) ); Sphere_exposer.def( bp::init< SireMaths::Sphere const & >(( bp::arg("other") )) ); { //::SireMaths::Sphere::center typedef ::SireMaths::Vector const & ( ::SireMaths::Sphere::*center_function_type )( ) const; center_function_type center_function_value( &::SireMaths::Sphere::center ); Sphere_exposer.def( "center" , center_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMaths::Sphere::combinedVolume typedef double ( *combinedVolume_function_type )( ::QVector< SireMaths::Sphere > const & ); combinedVolume_function_type combinedVolume_function_value( &::SireMaths::Sphere::combinedVolume ); Sphere_exposer.def( "combinedVolume" , combinedVolume_function_value , ( bp::arg("spheres") ) ); } { //::SireMaths::Sphere::combinedVolumeMC typedef double ( *combinedVolumeMC_function_type )( ::QVector< SireMaths::Sphere > const &,qint64 ); combinedVolumeMC_function_type combinedVolumeMC_function_value( &::SireMaths::Sphere::combinedVolumeMC ); Sphere_exposer.def( "combinedVolumeMC" , combinedVolumeMC_function_value , ( bp::arg("spheres"), bp::arg("nsamples")=(qint64)(-0x00000000000000001) ) ); } { //::SireMaths::Sphere::contains typedef bool ( ::SireMaths::Sphere::*contains_function_type )( ::SireMaths::Sphere const & ) const; contains_function_type contains_function_value( &::SireMaths::Sphere::contains ); Sphere_exposer.def( "contains" , contains_function_value , ( bp::arg("other") ) ); } { //::SireMaths::Sphere::intersectionVolume typedef double ( ::SireMaths::Sphere::*intersectionVolume_function_type )( ::SireMaths::Sphere const & ) const; intersectionVolume_function_type intersectionVolume_function_value( &::SireMaths::Sphere::intersectionVolume ); Sphere_exposer.def( "intersectionVolume" , intersectionVolume_function_value , ( bp::arg("other") ) ); } { //::SireMaths::Sphere::intersectionVolume typedef double ( ::SireMaths::Sphere::*intersectionVolume_function_type )( ::SireMaths::Sphere const &,::SireMaths::Sphere const & ) const; intersectionVolume_function_type intersectionVolume_function_value( &::SireMaths::Sphere::intersectionVolume ); Sphere_exposer.def( "intersectionVolume" , intersectionVolume_function_value , ( bp::arg("other0"), bp::arg("other1") ) ); } { //::SireMaths::Sphere::intersects typedef bool ( ::SireMaths::Sphere::*intersects_function_type )( ::SireMaths::Sphere const & ) const; intersects_function_type intersects_function_value( &::SireMaths::Sphere::intersects ); Sphere_exposer.def( "intersects" , intersects_function_value , ( bp::arg("other") ) ); } Sphere_exposer.def( bp::self != bp::self ); Sphere_exposer.def( bp::self == bp::self ); { //::SireMaths::Sphere::position typedef ::SireMaths::Vector const & ( ::SireMaths::Sphere::*position_function_type )( ) const; position_function_type position_function_value( &::SireMaths::Sphere::position ); Sphere_exposer.def( "position" , position_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMaths::Sphere::radius typedef double ( ::SireMaths::Sphere::*radius_function_type )( ) const; radius_function_type radius_function_value( &::SireMaths::Sphere::radius ); Sphere_exposer.def( "radius" , radius_function_value ); } { //::SireMaths::Sphere::setCenter typedef void ( ::SireMaths::Sphere::*setCenter_function_type )( ::SireMaths::Vector const & ) ; setCenter_function_type setCenter_function_value( &::SireMaths::Sphere::setCenter ); Sphere_exposer.def( "setCenter" , setCenter_function_value , ( bp::arg("center") ) ); } { //::SireMaths::Sphere::setPosition typedef void ( ::SireMaths::Sphere::*setPosition_function_type )( ::SireMaths::Vector const & ) ; setPosition_function_type setPosition_function_value( &::SireMaths::Sphere::setPosition ); Sphere_exposer.def( "setPosition" , setPosition_function_value , ( bp::arg("position") ) ); } { //::SireMaths::Sphere::setRadius typedef void ( ::SireMaths::Sphere::*setRadius_function_type )( double ) ; setRadius_function_type setRadius_function_value( &::SireMaths::Sphere::setRadius ); Sphere_exposer.def( "setRadius" , setRadius_function_value , ( bp::arg("radius") ) ); } { //::SireMaths::Sphere::surfaceArea typedef double ( ::SireMaths::Sphere::*surfaceArea_function_type )( ) const; surfaceArea_function_type surfaceArea_function_value( &::SireMaths::Sphere::surfaceArea ); Sphere_exposer.def( "surfaceArea" , surfaceArea_function_value ); } { //::SireMaths::Sphere::toString typedef ::QString ( ::SireMaths::Sphere::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMaths::Sphere::toString ); Sphere_exposer.def( "toString" , toString_function_value ); } { //::SireMaths::Sphere::translate typedef ::SireMaths::Sphere ( ::SireMaths::Sphere::*translate_function_type )( ::SireMaths::Vector const & ) const; translate_function_type translate_function_value( &::SireMaths::Sphere::translate ); Sphere_exposer.def( "translate" , translate_function_value , ( bp::arg("delta") ) ); } { //::SireMaths::Sphere::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMaths::Sphere::typeName ); Sphere_exposer.def( "typeName" , typeName_function_value ); } { //::SireMaths::Sphere::volume typedef double ( ::SireMaths::Sphere::*volume_function_type )( ) const; volume_function_type volume_function_value( &::SireMaths::Sphere::volume ); Sphere_exposer.def( "volume" , volume_function_value ); } { //::SireMaths::Sphere::what typedef char const * ( ::SireMaths::Sphere::*what_function_type )( ) const; what_function_type what_function_value( &::SireMaths::Sphere::what ); Sphere_exposer.def( "what" , what_function_value ); } Sphere_exposer.staticmethod( "combinedVolume" ); Sphere_exposer.staticmethod( "combinedVolumeMC" ); Sphere_exposer.staticmethod( "typeName" ); Sphere_exposer.def( "__copy__", &__copy__); Sphere_exposer.def( "__deepcopy__", &__copy__); Sphere_exposer.def( "clone", &__copy__); Sphere_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::Sphere >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Sphere_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::Sphere >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Sphere_exposer.def( "__str__", &__str__< ::SireMaths::Sphere > ); Sphere_exposer.def( "__repr__", &__str__< ::SireMaths::Sphere > ); } }
void register_AABox_class(){ { //::SireVol::AABox typedef bp::class_< SireVol::AABox > AABox_exposer_t; AABox_exposer_t AABox_exposer = AABox_exposer_t( "AABox", bp::init< >() ); bp::scope AABox_scope( AABox_exposer ); AABox_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("point") )) ); AABox_exposer.def( bp::init< SireMaths::Vector const &, SireMaths::Vector const & >(( bp::arg("cent"), bp::arg("extents") )) ); AABox_exposer.def( bp::init< QVector< SireMaths::Vector > const & >(( bp::arg("coordinates") )) ); AABox_exposer.def( bp::init< SireMaths::Vector const *, int >(( bp::arg("coords"), bp::arg("ncoords") )) ); AABox_exposer.def( bp::init< SireVol::CoordGroupBase const & >(( bp::arg("coordgroup") )) ); AABox_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("cgarray") )) ); AABox_exposer.def( bp::init< SireVol::CoordGroupArrayArray const & >(( bp::arg("cgarrays") )) ); { //::SireVol::AABox::add typedef void ( ::SireVol::AABox::*add_function_type )( ::SireVol::AABox const & ) ; add_function_type add_function_value( &::SireVol::AABox::add ); AABox_exposer.def( "add" , add_function_value , ( bp::arg("other") ) ); } { //::SireVol::AABox::add typedef void ( ::SireVol::AABox::*add_function_type )( ::SireMaths::Vector const & ) ; add_function_type add_function_value( &::SireVol::AABox::add ); AABox_exposer.def( "add" , add_function_value , ( bp::arg("point") ) ); } { //::SireVol::AABox::add typedef void ( ::SireVol::AABox::*add_function_type )( ::QVector< SireMaths::Vector > const & ) ; add_function_type add_function_value( &::SireVol::AABox::add ); AABox_exposer.def( "add" , add_function_value , ( bp::arg("points") ) ); } { //::SireVol::AABox::boundingSphere typedef ::SireMaths::Sphere ( ::SireVol::AABox::*boundingSphere_function_type )( ) const; boundingSphere_function_type boundingSphere_function_value( &::SireVol::AABox::boundingSphere ); AABox_exposer.def( "boundingSphere" , boundingSphere_function_value ); } { //::SireVol::AABox::center typedef ::SireMaths::Vector const & ( ::SireVol::AABox::*center_function_type )( ) const; center_function_type center_function_value( &::SireVol::AABox::center ); AABox_exposer.def( "center" , center_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireVol::AABox::contains typedef bool ( ::SireVol::AABox::*contains_function_type )( ::SireVol::AABox const & ) const; contains_function_type contains_function_value( &::SireVol::AABox::contains ); AABox_exposer.def( "contains" , contains_function_value , ( bp::arg("other") ) ); } { //::SireVol::AABox::contains typedef bool ( ::SireVol::AABox::*contains_function_type )( ::SireMaths::Vector const & ) const; contains_function_type contains_function_value( &::SireVol::AABox::contains ); AABox_exposer.def( "contains" , contains_function_value , ( bp::arg("point") ) ); } { //::SireVol::AABox::from typedef ::SireVol::AABox ( *from_function_type )( ::SireMaths::Vector const & ); from_function_type from_function_value( &::SireVol::AABox::from ); AABox_exposer.def( "from" , from_function_value , ( bp::arg("point") ) ); } { //::SireVol::AABox::from typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupBase const & ); from_function_type from_function_value( &::SireVol::AABox::from ); AABox_exposer.def( "from" , from_function_value , ( bp::arg("coordgroup") ) ); } { //::SireVol::AABox::from typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupArray const & ); from_function_type from_function_value( &::SireVol::AABox::from ); AABox_exposer.def( "from" , from_function_value , ( bp::arg("cgarray") ) ); } { //::SireVol::AABox::from typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupArrayArray const & ); from_function_type from_function_value( &::SireVol::AABox::from ); AABox_exposer.def( "from" , from_function_value , ( bp::arg("cgarrays") ) ); } { //::SireVol::AABox::from typedef ::SireVol::AABox ( *from_function_type )( ::QVector< SireMaths::Vector > const & ); from_function_type from_function_value( &::SireVol::AABox::from ); AABox_exposer.def( "from" , from_function_value , ( bp::arg("coords") ) ); } { //::SireVol::AABox::from typedef ::SireVol::AABox ( *from_function_type )( ::SireMaths::Vector const &,::SireMaths::Vector const & ); from_function_type from_function_value( &::SireVol::AABox::from ); AABox_exposer.def( "from" , from_function_value , ( bp::arg("mincoords"), bp::arg("maxcoords") ) ); } { //::SireVol::AABox::halfExtents typedef ::SireMaths::Vector const & ( ::SireVol::AABox::*halfExtents_function_type )( ) const; halfExtents_function_type halfExtents_function_value( &::SireVol::AABox::halfExtents ); AABox_exposer.def( "halfExtents" , halfExtents_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireVol::AABox::intersects typedef bool ( ::SireVol::AABox::*intersects_function_type )( ::SireVol::AABox const & ) const; intersects_function_type intersects_function_value( &::SireVol::AABox::intersects ); AABox_exposer.def( "intersects" , intersects_function_value , ( bp::arg("other") ) ); } { //::SireVol::AABox::isEmpty typedef bool ( ::SireVol::AABox::*isEmpty_function_type )( ) const; isEmpty_function_type isEmpty_function_value( &::SireVol::AABox::isEmpty ); AABox_exposer.def( "isEmpty" , isEmpty_function_value ); } { //::SireVol::AABox::isNull typedef bool ( ::SireVol::AABox::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireVol::AABox::isNull ); AABox_exposer.def( "isNull" , isNull_function_value ); } { //::SireVol::AABox::maxCoords typedef ::SireMaths::Vector ( ::SireVol::AABox::*maxCoords_function_type )( ) const; maxCoords_function_type maxCoords_function_value( &::SireVol::AABox::maxCoords ); AABox_exposer.def( "maxCoords" , maxCoords_function_value ); } { //::SireVol::AABox::minCoords typedef ::SireMaths::Vector ( ::SireVol::AABox::*minCoords_function_type )( ) const; minCoords_function_type minCoords_function_value( &::SireVol::AABox::minCoords ); AABox_exposer.def( "minCoords" , minCoords_function_value ); } AABox_exposer.def( bp::self != bp::self ); AABox_exposer.def( bp::self + bp::self ); AABox_exposer.def( bp::self + bp::other< SireMaths::Vector >() ); AABox_exposer.def( bp::self + bp::other< QVector< SireMaths::Vector > >() ); { //::SireVol::AABox::operator= typedef ::SireVol::AABox const & ( ::SireVol::AABox::*assign_function_type )( ::SireVol::AABox const & ) ; assign_function_type assign_function_value( &::SireVol::AABox::operator= ); AABox_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_value_policy< bp::copy_const_reference >() ); } AABox_exposer.def( bp::self == bp::self ); { //::SireVol::AABox::radius typedef double ( ::SireVol::AABox::*radius_function_type )( ) const; radius_function_type radius_function_value( &::SireVol::AABox::radius ); AABox_exposer.def( "radius" , radius_function_value ); } { //::SireVol::AABox::recalculate typedef void ( ::SireVol::AABox::*recalculate_function_type )( ::SireVol::CoordGroupBase const & ) ; recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate ); AABox_exposer.def( "recalculate" , recalculate_function_value , ( bp::arg("coordgroup") ) ); } { //::SireVol::AABox::recalculate typedef void ( ::SireVol::AABox::*recalculate_function_type )( ::SireVol::CoordGroupArray const & ) ; recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate ); AABox_exposer.def( "recalculate" , recalculate_function_value , ( bp::arg("cgarray") ) ); } { //::SireVol::AABox::recalculate typedef void ( ::SireVol::AABox::*recalculate_function_type )( ::SireVol::CoordGroupArrayArray const & ) ; recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate ); AABox_exposer.def( "recalculate" , recalculate_function_value , ( bp::arg("cgarrays") ) ); } { //::SireVol::AABox::recalculate typedef void ( ::SireVol::AABox::*recalculate_function_type )( ::QVector< SireMaths::Vector > const & ) ; recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate ); AABox_exposer.def( "recalculate" , recalculate_function_value , ( bp::arg("coordinates") ) ); } { //::SireVol::AABox::toString typedef ::QString ( ::SireVol::AABox::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireVol::AABox::toString ); AABox_exposer.def( "toString" , toString_function_value ); } { //::SireVol::AABox::translate typedef void ( ::SireVol::AABox::*translate_function_type )( ::SireMaths::Vector const & ) ; translate_function_type translate_function_value( &::SireVol::AABox::translate ); AABox_exposer.def( "translate" , translate_function_value , ( bp::arg("delta") ) ); } { //::SireVol::AABox::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireVol::AABox::typeName ); AABox_exposer.def( "typeName" , typeName_function_value ); } { //::SireVol::AABox::what typedef char const * ( ::SireVol::AABox::*what_function_type )( ) const; what_function_type what_function_value( &::SireVol::AABox::what ); AABox_exposer.def( "what" , what_function_value ); } { //::SireVol::AABox::withinDistance typedef bool ( ::SireVol::AABox::*withinDistance_function_type )( double,::SireVol::AABox const & ) const; withinDistance_function_type withinDistance_function_value( &::SireVol::AABox::withinDistance ); AABox_exposer.def( "withinDistance" , withinDistance_function_value , ( bp::arg("dist"), bp::arg("box") ) ); } AABox_exposer.staticmethod( "from" ); AABox_exposer.staticmethod( "typeName" ); AABox_exposer.def( "__copy__", &__copy__); AABox_exposer.def( "__deepcopy__", &__copy__); AABox_exposer.def( "clone", &__copy__); AABox_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::AABox >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); AABox_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::AABox >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); AABox_exposer.def( "__str__", &__str__< ::SireVol::AABox > ); AABox_exposer.def( "__repr__", &__str__< ::SireVol::AABox > ); } }
void register_Center_class(){ { //::SireFF::Center typedef bp::class_< SireFF::Center, bp::bases< SireFF::Point, SireBase::Property > > Center_exposer_t; Center_exposer_t Center_exposer = Center_exposer_t( "Center", "This point returns the center of a view of a molecule, or group\nof molecules", bp::init< >("Constructor") ); bp::scope Center_scope( Center_exposer ); Center_exposer.def( bp::init< SireMol::MoleculeView const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("molview"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to get the center of the molecule view molview using the\npassed property map to find the required properties\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\n") ); Center_exposer.def( bp::init< SireMol::Molecules const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to get the center of the molecules in molecules, using the\npassed property map to find the required properties\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\n") ); Center_exposer.def( bp::init< SireFF::Center const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireFF::Center::addForce typedef bool ( ::SireFF::Center::*addForce_function_type)( ::SireFF::MolForceTable &,::SireMaths::Vector const & ) const; addForce_function_type addForce_function_value( &::SireFF::Center::addForce ); Center_exposer.def( "addForce" , addForce_function_value , ( bp::arg("molforces"), bp::arg("force") ) , "Decompose the force force acting on this point from the\nmolecule whose forces are in molforces and add the\nforce onto the table" ); } { //::SireFF::Center::addForce typedef bool ( ::SireFF::Center::*addForce_function_type)( ::SireFF::ForceTable &,::SireMaths::Vector const & ) const; addForce_function_type addForce_function_value( &::SireFF::Center::addForce ); Center_exposer.def( "addForce" , addForce_function_value , ( bp::arg("forces"), bp::arg("force") ) , "Decompose the force force into the forces acting on\nthe molecules that contribute to this point and add those\nforces onto the table forces" ); } { //::SireFF::Center::contains typedef bool ( ::SireFF::Center::*contains_function_type)( ::SireMol::MolNum ) const; contains_function_type contains_function_value( &::SireFF::Center::contains ); Center_exposer.def( "contains" , contains_function_value , ( bp::arg("molnum") ) , "Return whether or not the molecule with number molnum is\nneeded to generate this point" ); } { //::SireFF::Center::contains typedef bool ( ::SireFF::Center::*contains_function_type)( ::SireMol::MolID const & ) const; contains_function_type contains_function_value( &::SireFF::Center::contains ); Center_exposer.def( "contains" , contains_function_value , ( bp::arg("molid") ) , "Return whether or not this molecule with ID molid is\nneeded to generate this point" ); } { //::SireFF::Center::isExtraMoleculePoint typedef bool ( ::SireFF::Center::*isExtraMoleculePoint_function_type)( ) const; isExtraMoleculePoint_function_type isExtraMoleculePoint_function_value( &::SireFF::Center::isExtraMoleculePoint ); Center_exposer.def( "isExtraMoleculePoint" , isExtraMoleculePoint_function_value , "Return whether or not this is an extramolecular point (it is independent\nof the coordinates of atoms in any molecule, i.e. it is just a point in space)" ); } { //::SireFF::Center::isInterMoleculePoint typedef bool ( ::SireFF::Center::*isInterMoleculePoint_function_type)( ) const; isInterMoleculePoint_function_type isInterMoleculePoint_function_value( &::SireFF::Center::isInterMoleculePoint ); Center_exposer.def( "isInterMoleculePoint" , isInterMoleculePoint_function_value , "Return whether or not this is an intermolecular point (it depends on\ncoordinates of atoms from than one molecule)" ); } { //::SireFF::Center::isIntraMoleculePoint typedef bool ( ::SireFF::Center::*isIntraMoleculePoint_function_type)( ) const; isIntraMoleculePoint_function_type isIntraMoleculePoint_function_value( &::SireFF::Center::isIntraMoleculePoint ); Center_exposer.def( "isIntraMoleculePoint" , isIntraMoleculePoint_function_value , "Return whether this is an intramolecular point (it depends on coordinates\nof atoms in just one molecule)" ); } { //::SireFF::Center::molecules typedef ::SireMol::Molecules ( ::SireFF::Center::*molecules_function_type)( ) const; molecules_function_type molecules_function_value( &::SireFF::Center::molecules ); Center_exposer.def( "molecules" , molecules_function_value , "Return all of the molecules used to generate this point" ); } { //::SireFF::Center::nMolecules typedef int ( ::SireFF::Center::*nMolecules_function_type)( ) const; nMolecules_function_type nMolecules_function_value( &::SireFF::Center::nMolecules ); Center_exposer.def( "nMolecules" , nMolecules_function_value , "Return the number of molecules needed to generate this point" ); } Center_exposer.def( bp::self != bp::self ); { //::SireFF::Center::operator= typedef ::SireFF::Center & ( ::SireFF::Center::*assign_function_type)( ::SireFF::Center const & ) ; assign_function_type assign_function_value( &::SireFF::Center::operator= ); Center_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } Center_exposer.def( bp::self == bp::self ); { //::SireFF::Center::setSpace typedef void ( ::SireFF::Center::*setSpace_function_type)( ::SireVol::Space const & ) ; setSpace_function_type setSpace_function_value( &::SireFF::Center::setSpace ); Center_exposer.def( "setSpace" , setSpace_function_value , ( bp::arg("space") ) , "Set the space - if there is more than one molecule, then this\npoint can only be used with a cartesian, non-periodic space" ); } { //::SireFF::Center::toString typedef ::QString ( ::SireFF::Center::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireFF::Center::toString ); Center_exposer.def( "toString" , toString_function_value , "Return a string representation" ); } { //::SireFF::Center::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireFF::Center::typeName ); Center_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireFF::Center::update typedef bool ( ::SireFF::Center::*update_function_type)( ::SireMol::MoleculeData const & ) ; update_function_type update_function_value( &::SireFF::Center::update ); Center_exposer.def( "update" , update_function_value , ( bp::arg("moldata") ) , "Update the molecules used to create this point" ); } { //::SireFF::Center::update typedef bool ( ::SireFF::Center::*update_function_type)( ::SireMol::Molecules const & ) ; update_function_type update_function_value( &::SireFF::Center::update ); Center_exposer.def( "update" , update_function_value , ( bp::arg("molecules") ) , "Update the molecules used to create this point" ); } { //::SireFF::Center::update typedef bool ( ::SireFF::Center::*update_function_type)( ::SireMol::MoleculeGroup const & ) ; update_function_type update_function_value( &::SireFF::Center::update ); Center_exposer.def( "update" , update_function_value , ( bp::arg("molgroup") ) , "Update the molecules used to create this point" ); } { //::SireFF::Center::update typedef bool ( ::SireFF::Center::*update_function_type)( ::SireMol::MolGroupsBase const & ) ; update_function_type update_function_value( &::SireFF::Center::update ); Center_exposer.def( "update" , update_function_value , ( bp::arg("molgroups") ) , "Update the molecules used to create this point" ); } { //::SireFF::Center::usesMoleculesIn typedef bool ( ::SireFF::Center::*usesMoleculesIn_function_type)( ::SireFF::ForceTable const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireFF::Center::usesMoleculesIn ); Center_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("forcetable") ) , "Return whether or not this point uses data from any of the\nmolecules in the passed forcetable" ); } { //::SireFF::Center::usesMoleculesIn typedef bool ( ::SireFF::Center::*usesMoleculesIn_function_type)( ::SireMol::Molecules const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireFF::Center::usesMoleculesIn ); Center_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("molecules") ) , "Return whether or not this point uses data from any of the\nmolecules in molecules" ); } { //::SireFF::Center::usesMoleculesIn typedef bool ( ::SireFF::Center::*usesMoleculesIn_function_type)( ::SireMol::MoleculeGroup const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireFF::Center::usesMoleculesIn ); Center_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("molgroup") ) , "Return whether or not this point uses data from any of the\nmolecules in the group molgroup" ); } { //::SireFF::Center::usesMoleculesIn typedef bool ( ::SireFF::Center::*usesMoleculesIn_function_type)( ::SireMol::MolGroupsBase const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireFF::Center::usesMoleculesIn ); Center_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("molgroups") ) , "Return whether or not this point uses data from any of the\nmolecules in the groups in molgroups" ); } { //::SireFF::Center::wouldUpdate typedef bool ( ::SireFF::Center::*wouldUpdate_function_type)( ::SireMol::MoleculeData const & ) const; wouldUpdate_function_type wouldUpdate_function_value( &::SireFF::Center::wouldUpdate ); Center_exposer.def( "wouldUpdate" , wouldUpdate_function_value , ( bp::arg("moldata") ) , "Return whether or not the passed molecule would change this point" ); } { //::SireFF::Center::wouldUpdate typedef bool ( ::SireFF::Center::*wouldUpdate_function_type)( ::SireMol::Molecules const & ) const; wouldUpdate_function_type wouldUpdate_function_value( &::SireFF::Center::wouldUpdate ); Center_exposer.def( "wouldUpdate" , wouldUpdate_function_value , ( bp::arg("molecules") ) , "Return whether or not the passed molecules would change this point" ); } { //::SireFF::Center::wouldUpdate typedef bool ( ::SireFF::Center::*wouldUpdate_function_type)( ::SireMol::MoleculeGroup const & ) const; wouldUpdate_function_type wouldUpdate_function_value( &::SireFF::Center::wouldUpdate ); Center_exposer.def( "wouldUpdate" , wouldUpdate_function_value , ( bp::arg("molgroup") ) , "Return whether or not the passed molecules would change this point" ); } { //::SireFF::Center::wouldUpdate typedef bool ( ::SireFF::Center::*wouldUpdate_function_type)( ::SireMol::MolGroupsBase const & ) const; wouldUpdate_function_type wouldUpdate_function_value( &::SireFF::Center::wouldUpdate ); Center_exposer.def( "wouldUpdate" , wouldUpdate_function_value , ( bp::arg("molgroups") ) , "Return whether or not the passed molecules would change this point" ); } Center_exposer.staticmethod( "typeName" ); Center_exposer.def( "__copy__", &__copy__); Center_exposer.def( "__deepcopy__", &__copy__); Center_exposer.def( "clone", &__copy__); Center_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::Center >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Center_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::Center >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Center_exposer.def( "__str__", &__str__< ::SireFF::Center > ); Center_exposer.def( "__repr__", &__str__< ::SireFF::Center > ); } }
void register_NullRestraint_class() { { //::SireMM::NullRestraint typedef bp::class_< SireMM::NullRestraint, bp::bases< SireMM::Restraint3D, SireMM::Restraint, SireBase::Property > > NullRestraint_exposer_t; NullRestraint_exposer_t NullRestraint_exposer = NullRestraint_exposer_t( "NullRestraint", bp::init< >() ); bp::scope NullRestraint_scope( NullRestraint_exposer ); NullRestraint_exposer.def( bp::init< SireMM::NullRestraint const & >(( bp::arg("other") )) ); { //::SireMM::NullRestraint::builtinSymbols typedef ::SireCAS::Symbols ( ::SireMM::NullRestraint::*builtinSymbols_function_type )( ) const; builtinSymbols_function_type builtinSymbols_function_value( &::SireMM::NullRestraint::builtinSymbols ); NullRestraint_exposer.def( "builtinSymbols" , builtinSymbols_function_value ); } { //::SireMM::NullRestraint::builtinValues typedef ::SireCAS::Values ( ::SireMM::NullRestraint::*builtinValues_function_type )( ) const; builtinValues_function_type builtinValues_function_value( &::SireMM::NullRestraint::builtinValues ); NullRestraint_exposer.def( "builtinValues" , builtinValues_function_value ); } { //::SireMM::NullRestraint::contains typedef bool ( ::SireMM::NullRestraint::*contains_function_type )( ::SireMol::MolNum ) const; contains_function_type contains_function_value( &::SireMM::NullRestraint::contains ); NullRestraint_exposer.def( "contains" , contains_function_value , ( bp::arg("molnum") ) ); } { //::SireMM::NullRestraint::contains typedef bool ( ::SireMM::NullRestraint::*contains_function_type )( ::SireMol::MolID const & ) const; contains_function_type contains_function_value( &::SireMM::NullRestraint::contains ); NullRestraint_exposer.def( "contains" , contains_function_value , ( bp::arg("molid") ) ); } { //::SireMM::NullRestraint::differentiate typedef ::SireMM::RestraintPtr ( ::SireMM::NullRestraint::*differentiate_function_type )( ::SireCAS::Symbol const & ) const; differentiate_function_type differentiate_function_value( &::SireMM::NullRestraint::differentiate ); NullRestraint_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol") ) ); } { //::SireMM::NullRestraint::energy typedef ::SireUnits::Dimension::MolarEnergy ( ::SireMM::NullRestraint::*energy_function_type )( ) const; energy_function_type energy_function_value( &::SireMM::NullRestraint::energy ); NullRestraint_exposer.def( "energy" , energy_function_value ); } { //::SireMM::NullRestraint::force typedef void ( ::SireMM::NullRestraint::*force_function_type )( ::SireFF::MolForceTable &,double ) const; force_function_type force_function_value( &::SireMM::NullRestraint::force ); NullRestraint_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) ); } { //::SireMM::NullRestraint::force typedef void ( ::SireMM::NullRestraint::*force_function_type )( ::SireFF::ForceTable &,double ) const; force_function_type force_function_value( &::SireMM::NullRestraint::force ); NullRestraint_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) ); } { //::SireMM::NullRestraint::getValue typedef double ( ::SireMM::NullRestraint::*getValue_function_type )( ::SireCAS::Symbol const & ) const; getValue_function_type getValue_function_value( &::SireMM::NullRestraint::getValue ); NullRestraint_exposer.def( "getValue" , getValue_function_value , ( bp::arg("symbol") ) ); } { //::SireMM::NullRestraint::hasValue typedef bool ( ::SireMM::NullRestraint::*hasValue_function_type )( ::SireCAS::Symbol const & ) const; hasValue_function_type hasValue_function_value( &::SireMM::NullRestraint::hasValue ); NullRestraint_exposer.def( "hasValue" , hasValue_function_value , ( bp::arg("symbol") ) ); } { //::SireMM::NullRestraint::molecules typedef ::SireMol::Molecules ( ::SireMM::NullRestraint::*molecules_function_type )( ) const; molecules_function_type molecules_function_value( &::SireMM::NullRestraint::molecules ); NullRestraint_exposer.def( "molecules" , molecules_function_value ); } NullRestraint_exposer.def( bp::self != bp::self ); { //::SireMM::NullRestraint::operator= typedef ::SireMM::NullRestraint & ( ::SireMM::NullRestraint::*assign_function_type )( ::SireMM::NullRestraint const & ) ; assign_function_type assign_function_value( &::SireMM::NullRestraint::operator= ); NullRestraint_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } NullRestraint_exposer.def( bp::self == bp::self ); { //::SireMM::NullRestraint::setValue typedef void ( ::SireMM::NullRestraint::*setValue_function_type )( ::SireCAS::Symbol const &,double ) ; setValue_function_type setValue_function_value( &::SireMM::NullRestraint::setValue ); NullRestraint_exposer.def( "setValue" , setValue_function_value , ( bp::arg("symbol"), bp::arg("value") ) ); } { //::SireMM::NullRestraint::symbols typedef ::SireCAS::Symbols ( ::SireMM::NullRestraint::*symbols_function_type )( ) const; symbols_function_type symbols_function_value( &::SireMM::NullRestraint::symbols ); NullRestraint_exposer.def( "symbols" , symbols_function_value ); } { //::SireMM::NullRestraint::toString typedef ::QString ( ::SireMM::NullRestraint::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMM::NullRestraint::toString ); NullRestraint_exposer.def( "toString" , toString_function_value ); } { //::SireMM::NullRestraint::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::NullRestraint::typeName ); NullRestraint_exposer.def( "typeName" , typeName_function_value ); } { //::SireMM::NullRestraint::update typedef void ( ::SireMM::NullRestraint::*update_function_type )( ::SireMol::MoleculeData const & ) ; update_function_type update_function_value( &::SireMM::NullRestraint::update ); NullRestraint_exposer.def( "update" , update_function_value , ( bp::arg("moldata") ) ); } { //::SireMM::NullRestraint::update typedef void ( ::SireMM::NullRestraint::*update_function_type )( ::SireMol::Molecules const & ) ; update_function_type update_function_value( &::SireMM::NullRestraint::update ); NullRestraint_exposer.def( "update" , update_function_value , ( bp::arg("molecules") ) ); } { //::SireMM::NullRestraint::userSymbols typedef ::SireCAS::Symbols ( ::SireMM::NullRestraint::*userSymbols_function_type )( ) const; userSymbols_function_type userSymbols_function_value( &::SireMM::NullRestraint::userSymbols ); NullRestraint_exposer.def( "userSymbols" , userSymbols_function_value ); } { //::SireMM::NullRestraint::userValues typedef ::SireCAS::Values ( ::SireMM::NullRestraint::*userValues_function_type )( ) const; userValues_function_type userValues_function_value( &::SireMM::NullRestraint::userValues ); NullRestraint_exposer.def( "userValues" , userValues_function_value ); } { //::SireMM::NullRestraint::usesMoleculesIn typedef bool ( ::SireMM::NullRestraint::*usesMoleculesIn_function_type )( ::SireFF::ForceTable const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::NullRestraint::usesMoleculesIn ); NullRestraint_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("forcetable") ) ); } { //::SireMM::NullRestraint::usesMoleculesIn typedef bool ( ::SireMM::NullRestraint::*usesMoleculesIn_function_type )( ::SireMol::Molecules const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::NullRestraint::usesMoleculesIn ); NullRestraint_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("molecules") ) ); } { //::SireMM::NullRestraint::values typedef ::SireCAS::Values ( ::SireMM::NullRestraint::*values_function_type )( ) const; values_function_type values_function_value( &::SireMM::NullRestraint::values ); NullRestraint_exposer.def( "values" , values_function_value ); } NullRestraint_exposer.staticmethod( "typeName" ); NullRestraint_exposer.def( "__copy__", &__copy__); NullRestraint_exposer.def( "__deepcopy__", &__copy__); NullRestraint_exposer.def( "clone", &__copy__); NullRestraint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::NullRestraint >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); NullRestraint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::NullRestraint >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); NullRestraint_exposer.def( "__str__", &__str__< ::SireMM::NullRestraint > ); NullRestraint_exposer.def( "__repr__", &__str__< ::SireMM::NullRestraint > ); } }
void register_DoubleDistanceRestraint_class(){ { //::SireMM::DoubleDistanceRestraint typedef bp::class_< SireMM::DoubleDistanceRestraint, bp::bases< SireMM::Restraint3D, SireMM::Restraint, SireBase::Property > > DoubleDistanceRestraint_exposer_t; DoubleDistanceRestraint_exposer_t DoubleDistanceRestraint_exposer = DoubleDistanceRestraint_exposer_t( "DoubleDistanceRestraint", bp::init< >() ); bp::scope DoubleDistanceRestraint_scope( DoubleDistanceRestraint_exposer ); DoubleDistanceRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("restraint") )) ); DoubleDistanceRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const &, SireCAS::Values const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("restraint"), bp::arg("values") )) ); DoubleDistanceRestraint_exposer.def( bp::init< SireMM::DoubleDistanceRestraint const & >(( bp::arg("other") )) ); { //::SireMM::DoubleDistanceRestraint::builtinSymbols typedef ::SireCAS::Symbols ( ::SireMM::DoubleDistanceRestraint::*builtinSymbols_function_type )( ) const; builtinSymbols_function_type builtinSymbols_function_value( &::SireMM::DoubleDistanceRestraint::builtinSymbols ); DoubleDistanceRestraint_exposer.def( "builtinSymbols" , builtinSymbols_function_value ); } { //::SireMM::DoubleDistanceRestraint::builtinValues typedef ::SireCAS::Values ( ::SireMM::DoubleDistanceRestraint::*builtinValues_function_type )( ) const; builtinValues_function_type builtinValues_function_value( &::SireMM::DoubleDistanceRestraint::builtinValues ); DoubleDistanceRestraint_exposer.def( "builtinValues" , builtinValues_function_value ); } { //::SireMM::DoubleDistanceRestraint::contains typedef bool ( ::SireMM::DoubleDistanceRestraint::*contains_function_type )( ::SireMol::MolNum ) const; contains_function_type contains_function_value( &::SireMM::DoubleDistanceRestraint::contains ); DoubleDistanceRestraint_exposer.def( "contains" , contains_function_value , ( bp::arg("molnum") ) ); } { //::SireMM::DoubleDistanceRestraint::contains typedef bool ( ::SireMM::DoubleDistanceRestraint::*contains_function_type )( ::SireMol::MolID const & ) const; contains_function_type contains_function_value( &::SireMM::DoubleDistanceRestraint::contains ); DoubleDistanceRestraint_exposer.def( "contains" , contains_function_value , ( bp::arg("molid") ) ); } { //::SireMM::DoubleDistanceRestraint::differentialRestraintFunction01 typedef ::SireCAS::Expression const & ( ::SireMM::DoubleDistanceRestraint::*differentialRestraintFunction01_function_type )( ) const; differentialRestraintFunction01_function_type differentialRestraintFunction01_function_value( &::SireMM::DoubleDistanceRestraint::differentialRestraintFunction01 ); DoubleDistanceRestraint_exposer.def( "differentialRestraintFunction01" , differentialRestraintFunction01_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMM::DoubleDistanceRestraint::differentialRestraintFunction23 typedef ::SireCAS::Expression const & ( ::SireMM::DoubleDistanceRestraint::*differentialRestraintFunction23_function_type )( ) const; differentialRestraintFunction23_function_type differentialRestraintFunction23_function_value( &::SireMM::DoubleDistanceRestraint::differentialRestraintFunction23 ); DoubleDistanceRestraint_exposer.def( "differentialRestraintFunction23" , differentialRestraintFunction23_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMM::DoubleDistanceRestraint::differentiate typedef ::SireMM::RestraintPtr ( ::SireMM::DoubleDistanceRestraint::*differentiate_function_type )( ::SireCAS::Symbol const & ) const; differentiate_function_type differentiate_function_value( &::SireMM::DoubleDistanceRestraint::differentiate ); DoubleDistanceRestraint_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol") ) ); } { //::SireMM::DoubleDistanceRestraint::force typedef void ( ::SireMM::DoubleDistanceRestraint::*force_function_type )( ::SireFF::MolForceTable &,double ) const; force_function_type force_function_value( &::SireMM::DoubleDistanceRestraint::force ); DoubleDistanceRestraint_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) ); } { //::SireMM::DoubleDistanceRestraint::force typedef void ( ::SireMM::DoubleDistanceRestraint::*force_function_type )( ::SireFF::ForceTable &,double ) const; force_function_type force_function_value( &::SireMM::DoubleDistanceRestraint::force ); DoubleDistanceRestraint_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) ); } { //::SireMM::DoubleDistanceRestraint::molecules typedef ::SireMol::Molecules ( ::SireMM::DoubleDistanceRestraint::*molecules_function_type )( ) const; molecules_function_type molecules_function_value( &::SireMM::DoubleDistanceRestraint::molecules ); DoubleDistanceRestraint_exposer.def( "molecules" , molecules_function_value ); } { //::SireMM::DoubleDistanceRestraint::nPoints typedef int ( ::SireMM::DoubleDistanceRestraint::*nPoints_function_type )( ) const; nPoints_function_type nPoints_function_value( &::SireMM::DoubleDistanceRestraint::nPoints ); DoubleDistanceRestraint_exposer.def( "nPoints" , nPoints_function_value ); } DoubleDistanceRestraint_exposer.def( bp::self != bp::self ); { //::SireMM::DoubleDistanceRestraint::operator= typedef ::SireMM::DoubleDistanceRestraint & ( ::SireMM::DoubleDistanceRestraint::*assign_function_type )( ::SireMM::DoubleDistanceRestraint const & ) ; assign_function_type assign_function_value( &::SireMM::DoubleDistanceRestraint::operator= ); DoubleDistanceRestraint_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } DoubleDistanceRestraint_exposer.def( bp::self == bp::self ); { //::SireMM::DoubleDistanceRestraint::point typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point_function_type )( int ) const; point_function_type point_function_value( &::SireMM::DoubleDistanceRestraint::point ); DoubleDistanceRestraint_exposer.def( "point" , point_function_value , ( bp::arg("i") ) , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::DoubleDistanceRestraint::point0 typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point0_function_type )( ) const; point0_function_type point0_function_value( &::SireMM::DoubleDistanceRestraint::point0 ); DoubleDistanceRestraint_exposer.def( "point0" , point0_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::DoubleDistanceRestraint::point1 typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point1_function_type )( ) const; point1_function_type point1_function_value( &::SireMM::DoubleDistanceRestraint::point1 ); DoubleDistanceRestraint_exposer.def( "point1" , point1_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::DoubleDistanceRestraint::point2 typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point2_function_type )( ) const; point2_function_type point2_function_value( &::SireMM::DoubleDistanceRestraint::point2 ); DoubleDistanceRestraint_exposer.def( "point2" , point2_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::DoubleDistanceRestraint::point3 typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point3_function_type )( ) const; point3_function_type point3_function_value( &::SireMM::DoubleDistanceRestraint::point3 ); DoubleDistanceRestraint_exposer.def( "point3" , point3_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::DoubleDistanceRestraint::r01 typedef ::SireCAS::Symbol const & ( *r01_function_type )( ); r01_function_type r01_function_value( &::SireMM::DoubleDistanceRestraint::r01 ); DoubleDistanceRestraint_exposer.def( "r01" , r01_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::DoubleDistanceRestraint::r23 typedef ::SireCAS::Symbol const & ( *r23_function_type )( ); r23_function_type r23_function_value( &::SireMM::DoubleDistanceRestraint::r23 ); DoubleDistanceRestraint_exposer.def( "r23" , r23_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::DoubleDistanceRestraint::setSpace typedef void ( ::SireMM::DoubleDistanceRestraint::*setSpace_function_type )( ::SireVol::Space const & ) ; setSpace_function_type setSpace_function_value( &::SireMM::DoubleDistanceRestraint::setSpace ); DoubleDistanceRestraint_exposer.def( "setSpace" , setSpace_function_value , ( bp::arg("space") ) ); } { //::SireMM::DoubleDistanceRestraint::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::DoubleDistanceRestraint::typeName ); DoubleDistanceRestraint_exposer.def( "typeName" , typeName_function_value ); } { //::SireMM::DoubleDistanceRestraint::update typedef void ( ::SireMM::DoubleDistanceRestraint::*update_function_type )( ::SireMol::MoleculeData const & ) ; update_function_type update_function_value( &::SireMM::DoubleDistanceRestraint::update ); DoubleDistanceRestraint_exposer.def( "update" , update_function_value , ( bp::arg("moldata") ) ); } { //::SireMM::DoubleDistanceRestraint::update typedef void ( ::SireMM::DoubleDistanceRestraint::*update_function_type )( ::SireMol::Molecules const & ) ; update_function_type update_function_value( &::SireMM::DoubleDistanceRestraint::update ); DoubleDistanceRestraint_exposer.def( "update" , update_function_value , ( bp::arg("molecules") ) ); } { //::SireMM::DoubleDistanceRestraint::usesMoleculesIn typedef bool ( ::SireMM::DoubleDistanceRestraint::*usesMoleculesIn_function_type )( ::SireFF::ForceTable const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DoubleDistanceRestraint::usesMoleculesIn ); DoubleDistanceRestraint_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("forcetable") ) ); } { //::SireMM::DoubleDistanceRestraint::usesMoleculesIn typedef bool ( ::SireMM::DoubleDistanceRestraint::*usesMoleculesIn_function_type )( ::SireMol::Molecules const & ) const; usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DoubleDistanceRestraint::usesMoleculesIn ); DoubleDistanceRestraint_exposer.def( "usesMoleculesIn" , usesMoleculesIn_function_value , ( bp::arg("molecules") ) ); } DoubleDistanceRestraint_exposer.staticmethod( "r01" ); DoubleDistanceRestraint_exposer.staticmethod( "r23" ); DoubleDistanceRestraint_exposer.staticmethod( "typeName" ); DoubleDistanceRestraint_exposer.def( "__copy__", &__copy__); DoubleDistanceRestraint_exposer.def( "__deepcopy__", &__copy__); DoubleDistanceRestraint_exposer.def( "clone", &__copy__); DoubleDistanceRestraint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::DoubleDistanceRestraint >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); DoubleDistanceRestraint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::DoubleDistanceRestraint >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); DoubleDistanceRestraint_exposer.def( "__str__", &__str__< ::SireMM::DoubleDistanceRestraint > ); DoubleDistanceRestraint_exposer.def( "__repr__", &__str__< ::SireMM::DoubleDistanceRestraint > ); } }