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_Molecules_class(){
{ //::SireMol::Molecules
typedef bp::class_< SireMol::Molecules, bp::bases< SireBase::Property > > Molecules_exposer_t;
Molecules_exposer_t Molecules_exposer = Molecules_exposer_t( "Molecules", bp::init< >() );
bp::scope Molecules_scope( Molecules_exposer );
Molecules_exposer.def( bp::init< SireMol::MoleculeView const & >(( bp::arg("molecule") )) );
Molecules_exposer.def( bp::init< SireMol::ViewsOfMol const & >(( bp::arg("molviews") )) );
Molecules_exposer.def( bp::init< SireMol::Molecules const & >(( bp::arg("other") )) );
{ //::SireMol::Molecules::add
typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::MoleculeView const & ) ;
add_function_type add_function_value( &::SireMol::Molecules::add );
Molecules_exposer.def(
"add"
, add_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::add
typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::ViewsOfMol const & ) ;
add_function_type add_function_value( &::SireMol::Molecules::add );
Molecules_exposer.def(
"add"
, add_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::add
typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::Molecules const & ) ;
add_function_type add_function_value( &::SireMol::Molecules::add );
Molecules_exposer.def(
"add"
, add_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::addIfUnique
typedef bool ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::MoleculeView const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique );
Molecules_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::addIfUnique
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::ViewsOfMol const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique );
Molecules_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::addIfUnique
typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::Molecules const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique );
Molecules_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::assertContains
typedef void ( ::SireMol::Molecules::*assertContains_function_type )( ::SireMol::MolNum ) const;
assertContains_function_type assertContains_function_value( &::SireMol::Molecules::assertContains );
Molecules_exposer.def(
"assertContains"
, assertContains_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::at
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*at_function_type )( ::SireMol::MolNum ) const;
at_function_type at_function_value( &::SireMol::Molecules::at );
Molecules_exposer.def(
"at"
, at_function_value
, ( bp::arg("molnum") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::at
typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*at_function_type )( ::boost::tuples::tuple< SireMol::MolNum, SireID::Index, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > const & ) const;
at_function_type at_function_value( &::SireMol::Molecules::at );
Molecules_exposer.def(
"at"
, at_function_value
, ( bp::arg("viewidx") ) );
}
{ //::SireMol::Molecules::at
typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*at_function_type )( ::SireMol::MolNum,int ) const;
at_function_type at_function_value( &::SireMol::Molecules::at );
Molecules_exposer.def(
"at"
, at_function_value
, ( bp::arg("molnum"), bp::arg("idx") ) );
}
{ //::SireMol::Molecules::back
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*back_function_type )( ) const;
back_function_type back_function_value( &::SireMol::Molecules::back );
Molecules_exposer.def(
"back"
, back_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::begin
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*begin_function_type )( ) const;
begin_function_type begin_function_value( &::SireMol::Molecules::begin );
Molecules_exposer.def(
"begin"
, begin_function_value );
}
{ //::SireMol::Molecules::clear
typedef void ( ::SireMol::Molecules::*clear_function_type )( ) ;
clear_function_type clear_function_value( &::SireMol::Molecules::clear );
Molecules_exposer.def(
"clear"
, clear_function_value );
}
{ //::SireMol::Molecules::constBegin
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constBegin_function_type )( ) const;
constBegin_function_type constBegin_function_value( &::SireMol::Molecules::constBegin );
Molecules_exposer.def(
"constBegin"
, constBegin_function_value );
}
{ //::SireMol::Molecules::constEnd
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constEnd_function_type )( ) const;
constEnd_function_type constEnd_function_value( &::SireMol::Molecules::constEnd );
Molecules_exposer.def(
"constEnd"
, constEnd_function_value );
}
{ //::SireMol::Molecules::constFind
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constFind_function_type )( ::SireMol::MolNum ) const;
constFind_function_type constFind_function_value( &::SireMol::Molecules::constFind );
Molecules_exposer.def(
"constFind"
, constFind_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::contains
typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::MolNum ) const;
contains_function_type contains_function_value( &::SireMol::Molecules::contains );
Molecules_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::contains
typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::MoleculeView const & ) const;
contains_function_type contains_function_value( &::SireMol::Molecules::contains );
Molecules_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::contains
typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::ViewsOfMol const & ) const;
contains_function_type contains_function_value( &::SireMol::Molecules::contains );
Molecules_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::contains
typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::Molecules const & ) const;
contains_function_type contains_function_value( &::SireMol::Molecules::contains );
Molecules_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::count
typedef int ( ::SireMol::Molecules::*count_function_type )( ) const;
count_function_type count_function_value( &::SireMol::Molecules::count );
Molecules_exposer.def(
"count"
, count_function_value );
}
{ //::SireMol::Molecules::end
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*end_function_type )( ) const;
end_function_type end_function_value( &::SireMol::Molecules::end );
Molecules_exposer.def(
"end"
, end_function_value );
}
{ //::SireMol::Molecules::find
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*find_function_type )( ::SireMol::MolNum ) const;
find_function_type find_function_value( &::SireMol::Molecules::find );
Molecules_exposer.def(
"find"
, find_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::first
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*first_function_type )( ) const;
first_function_type first_function_value( &::SireMol::Molecules::first );
Molecules_exposer.def(
"first"
, first_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::front
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*front_function_type )( ) const;
front_function_type front_function_value( &::SireMol::Molecules::front );
Molecules_exposer.def(
"front"
, front_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::intersects
typedef bool ( ::SireMol::Molecules::*intersects_function_type )( ::SireMol::MoleculeView const & ) const;
intersects_function_type intersects_function_value( &::SireMol::Molecules::intersects );
Molecules_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::intersects
typedef bool ( ::SireMol::Molecules::*intersects_function_type )( ::SireMol::Molecules const & ) const;
intersects_function_type intersects_function_value( &::SireMol::Molecules::intersects );
Molecules_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("other") ) );
}
{ //::SireMol::Molecules::isEmpty
typedef bool ( ::SireMol::Molecules::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMol::Molecules::isEmpty );
Molecules_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireMol::Molecules::last
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*last_function_type )( ) const;
last_function_type last_function_value( &::SireMol::Molecules::last );
Molecules_exposer.def(
"last"
, last_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::molNums
typedef ::QSet< SireMol::MolNum > ( ::SireMol::Molecules::*molNums_function_type )( ) const;
molNums_function_type molNums_function_value( &::SireMol::Molecules::molNums );
Molecules_exposer.def(
"molNums"
, molNums_function_value );
}
{ //::SireMol::Molecules::molecule
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*molecule_function_type )( ::SireMol::MolNum ) const;
molecule_function_type molecule_function_value( &::SireMol::Molecules::molecule );
Molecules_exposer.def(
"molecule"
, molecule_function_value
, ( bp::arg("molnum") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::nMolecules
typedef int ( ::SireMol::Molecules::*nMolecules_function_type )( ) const;
nMolecules_function_type nMolecules_function_value( &::SireMol::Molecules::nMolecules );
Molecules_exposer.def(
"nMolecules"
, nMolecules_function_value );
}
{ //::SireMol::Molecules::nViews
typedef int ( ::SireMol::Molecules::*nViews_function_type )( ) const;
nViews_function_type nViews_function_value( &::SireMol::Molecules::nViews );
Molecules_exposer.def(
"nViews"
, nViews_function_value );
}
{ //::SireMol::Molecules::nViews
typedef int ( ::SireMol::Molecules::*nViews_function_type )( ::SireMol::MolNum ) const;
nViews_function_type nViews_function_value( &::SireMol::Molecules::nViews );
Molecules_exposer.def(
"nViews"
, nViews_function_value
, ( bp::arg("molnum") ) );
}
Molecules_exposer.def( bp::self != bp::self );
Molecules_exposer.def( bp::self + bp::self );
Molecules_exposer.def( bp::self - bp::self );
{ //::SireMol::Molecules::operator=
typedef ::SireMol::Molecules & ( ::SireMol::Molecules::*assign_function_type )( ::SireMol::Molecules const & ) ;
assign_function_type assign_function_value( &::SireMol::Molecules::operator= );
Molecules_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Molecules_exposer.def( bp::self == bp::self );
{ //::SireMol::Molecules::operator[]
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*__getitem___function_type )( ::SireMol::MolNum ) const;
__getitem___function_type __getitem___function_value( &::SireMol::Molecules::operator[] );
Molecules_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("molnum") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::operator[]
typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*__getitem___function_type )( ::boost::tuples::tuple< SireMol::MolNum, SireID::Index, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > const & ) const;
__getitem___function_type __getitem___function_value( &::SireMol::Molecules::operator[] );
Molecules_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("viewidx") ) );
}
{ //::SireMol::Molecules::remove
typedef bool ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::MoleculeView const & ) ;
remove_function_type remove_function_value( &::SireMol::Molecules::remove );
Molecules_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::remove
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::ViewsOfMol const & ) ;
remove_function_type remove_function_value( &::SireMol::Molecules::remove );
Molecules_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::remove
typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::Molecules const & ) ;
remove_function_type remove_function_value( &::SireMol::Molecules::remove );
Molecules_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::remove
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::MolNum ) ;
remove_function_type remove_function_value( &::SireMol::Molecules::remove );
Molecules_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::removeAll
typedef bool ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::MoleculeView const & ) ;
removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
Molecules_exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::removeAll
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::ViewsOfMol const & ) ;
removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
Molecules_exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::removeAll
typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::Molecules const & ) ;
removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
Molecules_exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::removeAll
typedef bool ( ::SireMol::Molecules::*removeAll_function_type )( ) ;
removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
Molecules_exposer.def(
"removeAll"
, removeAll_function_value );
}
{ //::SireMol::Molecules::removeDuplicates
typedef bool ( ::SireMol::Molecules::*removeDuplicates_function_type )( ) ;
removeDuplicates_function_type removeDuplicates_function_value( &::SireMol::Molecules::removeDuplicates );
Molecules_exposer.def(
"removeDuplicates"
, removeDuplicates_function_value );
}
{ //::SireMol::Molecules::reserve
typedef void ( ::SireMol::Molecules::*reserve_function_type )( int ) ;
reserve_function_type reserve_function_value( &::SireMol::Molecules::reserve );
Molecules_exposer.def(
"reserve"
, reserve_function_value
, ( bp::arg("nmolecules") ) );
}
{ //::SireMol::Molecules::toString
typedef ::QString ( ::SireMol::Molecules::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::Molecules::toString );
Molecules_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::Molecules::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::Molecules::typeName );
Molecules_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::Molecules::unite
typedef bool ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::MoleculeView const & ) ;
unite_function_type unite_function_value( &::SireMol::Molecules::unite );
Molecules_exposer.def(
"unite"
, unite_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::unite
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::ViewsOfMol const & ) ;
unite_function_type unite_function_value( &::SireMol::Molecules::unite );
Molecules_exposer.def(
"unite"
, unite_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::unite
typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::Molecules const & ) ;
unite_function_type unite_function_value( &::SireMol::Molecules::unite );
Molecules_exposer.def(
"unite"
, unite_function_value
, ( bp::arg("other") ) );
}
{ //::SireMol::Molecules::uniteViews
typedef bool ( ::SireMol::Molecules::*uniteViews_function_type )( ) ;
uniteViews_function_type uniteViews_function_value( &::SireMol::Molecules::uniteViews );
Molecules_exposer.def(
"uniteViews"
, uniteViews_function_value );
}
{ //::SireMol::Molecules::update
typedef bool ( ::SireMol::Molecules::*update_function_type )( ::SireMol::MoleculeData const & ) ;
update_function_type update_function_value( &::SireMol::Molecules::update );
Molecules_exposer.def(
"update"
, update_function_value
, ( bp::arg("moldata") ) );
}
{ //::SireMol::Molecules::update
typedef bool ( ::SireMol::Molecules::*update_function_type )( ::SireMol::MoleculeView const & ) ;
update_function_type update_function_value( &::SireMol::Molecules::update );
Molecules_exposer.def(
"update"
, update_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::update
typedef ::QList< SireMol::Molecule > ( ::SireMol::Molecules::*update_function_type )( ::SireMol::Molecules const & ) ;
update_function_type update_function_value( &::SireMol::Molecules::update );
Molecules_exposer.def(
"update"
, update_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::what
typedef char const * ( ::SireMol::Molecules::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMol::Molecules::what );
Molecules_exposer.def(
"what"
, what_function_value );
}
Molecules_exposer.staticmethod( "typeName" );
Molecules_exposer.def( "__copy__", &__copy__);
Molecules_exposer.def( "__deepcopy__", &__copy__);
Molecules_exposer.def( "clone", &__copy__);
Molecules_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Molecules >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Molecules_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Molecules >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Molecules_exposer.def( "__str__", &__str__< ::SireMol::Molecules > );
Molecules_exposer.def( "__repr__", &__str__< ::SireMol::Molecules > );
Molecules_exposer.def( "__len__", &__len_count< ::SireMol::Molecules > );
}
}
void register_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 > );
}
}
