void register_PackedArray2D_int_Array_class(){
{ //::SireBase::detail::PackedArray2D_Array< int >
typedef bp::class_< SireBase::detail::PackedArray2D_Array< int > > PackedArray2D_int_Array_exposer_t;
PackedArray2D_int_Array_exposer_t PackedArray2D_int_Array_exposer = PackedArray2D_int_Array_exposer_t( "PackedArray2D_int_Array", bp::init< >() );
bp::scope PackedArray2D_int_Array_scope( PackedArray2D_int_Array_exposer );
PackedArray2D_int_Array_exposer.def( bp::init< quint32 >(( bp::arg("sz") )) );
PackedArray2D_int_Array_exposer.def( bp::init< quint32, int const & >(( bp::arg("sz"), bp::arg("value") )) );
PackedArray2D_int_Array_exposer.def( bp::init< QVector< int > const & >(( bp::arg("values") )) );
PackedArray2D_int_Array_exposer.def( bp::init< SireBase::detail::PackedArray2D_Array< int > const & >(( bp::arg("other") )) );
{ //::SireBase::detail::PackedArray2D_Array< int >::assertValidIndex
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef void ( ::SireBase::detail::PackedArray2D_Array< int >::*assertValidIndex_function_type )( ::quint32 ) const;
assertValidIndex_function_type assertValidIndex_function_value( &::SireBase::detail::PackedArray2D_Array< int >::assertValidIndex );
PackedArray2D_int_Array_exposer.def(
"assertValidIndex"
, assertValidIndex_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::at
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int const & ( ::SireBase::detail::PackedArray2D_Array< int >::*at_function_type )( ::quint32 ) const;
at_function_type at_function_value( &::SireBase::detail::PackedArray2D_Array< int >::at );
PackedArray2D_int_Array_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::count
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int ( ::SireBase::detail::PackedArray2D_Array< int >::*count_function_type )( ) const;
count_function_type count_function_value( &::SireBase::detail::PackedArray2D_Array< int >::count );
PackedArray2D_int_Array_exposer.def(
"count"
, count_function_value );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::isEmpty
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef bool ( ::SireBase::detail::PackedArray2D_Array< int >::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireBase::detail::PackedArray2D_Array< int >::isEmpty );
PackedArray2D_int_Array_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::nValues
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int ( ::SireBase::detail::PackedArray2D_Array< int >::*nValues_function_type )( ) const;
nValues_function_type nValues_function_value( &::SireBase::detail::PackedArray2D_Array< int >::nValues );
PackedArray2D_int_Array_exposer.def(
"nValues"
, nValues_function_value );
}
PackedArray2D_int_Array_exposer.def( bp::self != bp::self );
{ //::SireBase::detail::PackedArray2D_Array< int >::operator=
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef ::SireBase::detail::PackedArray2D_Array< int > & ( ::SireBase::detail::PackedArray2D_Array< int >::*assign_function_type )( ::SireBase::detail::PackedArray2D_Array< int > const & ) ;
assign_function_type assign_function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator= );
PackedArray2D_int_Array_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
PackedArray2D_int_Array_exposer.def( bp::self == bp::self );
{ //::SireBase::detail::PackedArray2D_Array< int >::operator[]
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int const & ( ::SireBase::detail::PackedArray2D_Array< int >::*__getitem___function_type )( ::quint32 ) const;
__getitem___function_type __getitem___function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator[] );
PackedArray2D_int_Array_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::operator[]
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int & ( ::SireBase::detail::PackedArray2D_Array< int >::*__getitem___function_type )( ::quint32 ) ;
__getitem___function_type __getitem___function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator[] );
PackedArray2D_int_Array_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::size
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int ( ::SireBase::detail::PackedArray2D_Array< int >::*size_function_type )( ) const;
size_function_type size_function_value( &::SireBase::detail::PackedArray2D_Array< int >::size );
PackedArray2D_int_Array_exposer.def(
"size"
, size_function_value );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::toQVector
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef ::QVector< int > ( ::SireBase::detail::PackedArray2D_Array< int >::*toQVector_function_type )( ) const;
toQVector_function_type toQVector_function_value( &::SireBase::detail::PackedArray2D_Array< int >::toQVector );
PackedArray2D_int_Array_exposer.def(
"toQVector"
, toQVector_function_value );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::toString
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef ::QString ( ::SireBase::detail::PackedArray2D_Array< int >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireBase::detail::PackedArray2D_Array< int >::toString );
PackedArray2D_int_Array_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::update
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef void ( ::SireBase::detail::PackedArray2D_Array< int >::*update_function_type )( ::SireBase::detail::PackedArray2D_Array< int > const & ) ;
update_function_type update_function_value( &::SireBase::detail::PackedArray2D_Array< int >::update );
PackedArray2D_int_Array_exposer.def(
"update"
, update_function_value
, ( bp::arg("other") ) );
}
PackedArray2D_int_Array_exposer.def( "__copy__", &__copy__);
PackedArray2D_int_Array_exposer.def( "__deepcopy__", &__copy__);
PackedArray2D_int_Array_exposer.def( "clone", &__copy__);
PackedArray2D_int_Array_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::detail::PackedArray2D_Array<int> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PackedArray2D_int_Array_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::detail::PackedArray2D_Array<int> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PackedArray2D_int_Array_exposer.def( "__str__", &__str__< ::SireBase::detail::PackedArray2D_Array<int> > );
PackedArray2D_int_Array_exposer.def( "__repr__", &__str__< ::SireBase::detail::PackedArray2D_Array<int> > );
PackedArray2D_int_Array_exposer.def( "__len__", &__len_size< ::SireBase::detail::PackedArray2D_Array<int> > );
}
}
void register_Nodes_class(){
{ //::SireCluster::Nodes
typedef bp::class_< SireCluster::Nodes > Nodes_exposer_t;
Nodes_exposer_t Nodes_exposer = Nodes_exposer_t( "Nodes", bp::init< >() );
bp::scope Nodes_scope( Nodes_exposer );
Nodes_exposer.def( bp::init< SireCluster::Nodes const & >(( bp::arg("other") )) );
{ //::SireCluster::Nodes::add
typedef void ( ::SireCluster::Nodes::*add_function_type )( ::SireCluster::Node ) ;
add_function_type add_function_value( &::SireCluster::Nodes::add );
Nodes_exposer.def(
"add"
, add_function_value
, ( bp::arg("node") ) );
}
{ //::SireCluster::Nodes::add
typedef void ( ::SireCluster::Nodes::*add_function_type )( ::SireCluster::Nodes & ) ;
add_function_type add_function_value( &::SireCluster::Nodes::add );
Nodes_exposer.def(
"add"
, add_function_value
, ( bp::arg("nodes") ) );
}
{ //::SireCluster::Nodes::addNode
typedef void ( ::SireCluster::Nodes::*addNode_function_type )( ) ;
addNode_function_type addNode_function_value( &::SireCluster::Nodes::addNode );
Nodes_exposer.def(
"addNode"
, addNode_function_value );
}
{ //::SireCluster::Nodes::addNode
typedef void ( ::SireCluster::Nodes::*addNode_function_type )( int ) ;
addNode_function_type addNode_function_value( &::SireCluster::Nodes::addNode );
Nodes_exposer.def(
"addNode"
, addNode_function_value
, ( bp::arg("timeout") ) );
}
{ //::SireCluster::Nodes::addNodes
typedef void ( ::SireCluster::Nodes::*addNodes_function_type )( int ) ;
addNodes_function_type addNodes_function_value( &::SireCluster::Nodes::addNodes );
Nodes_exposer.def(
"addNodes"
, addNodes_function_value
, ( bp::arg("n") ) );
}
{ //::SireCluster::Nodes::addNodes
typedef void ( ::SireCluster::Nodes::*addNodes_function_type )( int,int ) ;
addNodes_function_type addNodes_function_value( &::SireCluster::Nodes::addNodes );
Nodes_exposer.def(
"addNodes"
, addNodes_function_value
, ( bp::arg("n"), bp::arg("timeout") ) );
}
{ //::SireCluster::Nodes::borrowThisThread
typedef ::SireCluster::ThisThread ( ::SireCluster::Nodes::*borrowThisThread_function_type )( ) ;
borrowThisThread_function_type borrowThisThread_function_value( &::SireCluster::Nodes::borrowThisThread );
Nodes_exposer.def(
"borrowThisThread"
, borrowThisThread_function_value );
}
{ //::SireCluster::Nodes::count
typedef int ( ::SireCluster::Nodes::*count_function_type )( ) ;
count_function_type count_function_value( &::SireCluster::Nodes::count );
Nodes_exposer.def(
"count"
, count_function_value );
}
{ //::SireCluster::Nodes::getAllNodes
typedef ::QList< SireCluster::Node > ( ::SireCluster::Nodes::*getAllNodes_function_type )( ) ;
getAllNodes_function_type getAllNodes_function_value( &::SireCluster::Nodes::getAllNodes );
Nodes_exposer.def(
"getAllNodes"
, getAllNodes_function_value );
}
{ //::SireCluster::Nodes::getAllNodes
typedef ::QList< SireCluster::Node > ( ::SireCluster::Nodes::*getAllNodes_function_type )( int ) ;
getAllNodes_function_type getAllNodes_function_value( &::SireCluster::Nodes::getAllNodes );
Nodes_exposer.def(
"getAllNodes"
, getAllNodes_function_value
, ( bp::arg("timeout") ) );
}
{ //::SireCluster::Nodes::getNode
typedef ::SireCluster::Node ( ::SireCluster::Nodes::*getNode_function_type )( ) ;
getNode_function_type getNode_function_value( &::SireCluster::Nodes::getNode );
Nodes_exposer.def(
"getNode"
, getNode_function_value );
}
{ //::SireCluster::Nodes::getNode
typedef ::SireCluster::Node ( ::SireCluster::Nodes::*getNode_function_type )( int ) ;
getNode_function_type getNode_function_value( &::SireCluster::Nodes::getNode );
Nodes_exposer.def(
"getNode"
, getNode_function_value
, ( bp::arg("timeout") ) );
}
{ //::SireCluster::Nodes::getNodes
typedef ::QList< SireCluster::Node > ( ::SireCluster::Nodes::*getNodes_function_type )( int ) ;
getNodes_function_type getNodes_function_value( &::SireCluster::Nodes::getNodes );
Nodes_exposer.def(
"getNodes"
, getNodes_function_value
, ( bp::arg("n") ) );
}
{ //::SireCluster::Nodes::getNodes
typedef ::QList< SireCluster::Node > ( ::SireCluster::Nodes::*getNodes_function_type )( int,int ) ;
getNodes_function_type getNodes_function_value( &::SireCluster::Nodes::getNodes );
Nodes_exposer.def(
"getNodes"
, getNodes_function_value
, ( bp::arg("n"), bp::arg("timeout") ) );
}
{ //::SireCluster::Nodes::isEmpty
typedef bool ( ::SireCluster::Nodes::*isEmpty_function_type )( ) ;
isEmpty_function_type isEmpty_function_value( &::SireCluster::Nodes::isEmpty );
Nodes_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireCluster::Nodes::nBusy
typedef int ( ::SireCluster::Nodes::*nBusy_function_type )( ) ;
nBusy_function_type nBusy_function_value( &::SireCluster::Nodes::nBusy );
Nodes_exposer.def(
"nBusy"
, nBusy_function_value );
}
{ //::SireCluster::Nodes::nFree
typedef int ( ::SireCluster::Nodes::*nFree_function_type )( ) ;
nFree_function_type nFree_function_value( &::SireCluster::Nodes::nFree );
Nodes_exposer.def(
"nFree"
, nFree_function_value );
}
{ //::SireCluster::Nodes::nNodes
typedef int ( ::SireCluster::Nodes::*nNodes_function_type )( ) ;
nNodes_function_type nNodes_function_value( &::SireCluster::Nodes::nNodes );
Nodes_exposer.def(
"nNodes"
, nNodes_function_value );
}
Nodes_exposer.def( bp::self != bp::self );
{ //::SireCluster::Nodes::operator=
typedef ::SireCluster::Nodes & ( ::SireCluster::Nodes::*assign_function_type )( ::SireCluster::Nodes const & ) ;
assign_function_type assign_function_value( &::SireCluster::Nodes::operator= );
Nodes_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Nodes_exposer.def( bp::self == bp::self );
{ //::SireCluster::Nodes::remove
typedef void ( ::SireCluster::Nodes::*remove_function_type )( ::SireCluster::Node ) ;
remove_function_type remove_function_value( &::SireCluster::Nodes::remove );
Nodes_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("node") ) );
}
{ //::SireCluster::Nodes::removeAll
typedef void ( ::SireCluster::Nodes::*removeAll_function_type )( ) ;
removeAll_function_type removeAll_function_value( &::SireCluster::Nodes::removeAll );
Nodes_exposer.def(
"removeAll"
, removeAll_function_value );
}
{ //::SireCluster::Nodes::toString
typedef ::QString ( ::SireCluster::Nodes::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireCluster::Nodes::toString );
Nodes_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireCluster::Nodes::waitUntilAllFree
typedef void ( ::SireCluster::Nodes::*waitUntilAllFree_function_type )( ) ;
waitUntilAllFree_function_type waitUntilAllFree_function_value( &::SireCluster::Nodes::waitUntilAllFree );
Nodes_exposer.def(
"waitUntilAllFree"
, waitUntilAllFree_function_value );
}
{ //::SireCluster::Nodes::waitUntilAllFree
typedef bool ( ::SireCluster::Nodes::*waitUntilAllFree_function_type )( int ) ;
waitUntilAllFree_function_type waitUntilAllFree_function_value( &::SireCluster::Nodes::waitUntilAllFree );
Nodes_exposer.def(
"waitUntilAllFree"
, waitUntilAllFree_function_value
, ( bp::arg("timeout") ) );
}
Nodes_exposer.def( "__copy__", &__copy__);
Nodes_exposer.def( "__deepcopy__", &__copy__);
Nodes_exposer.def( "clone", &__copy__);
Nodes_exposer.def( "__str__", &__str__< ::SireCluster::Nodes > );
Nodes_exposer.def( "__repr__", &__str__< ::SireCluster::Nodes > );
Nodes_exposer.def( "__len__", &__len_count< ::SireCluster::Nodes > );
}
}
void register_ChunkedVector_double__class(){
{ //::SireBase::ChunkedVector< double, 100 >
typedef bp::class_< SireBase::ChunkedVector< double, 100 > > ChunkedVector_double__exposer_t;
ChunkedVector_double__exposer_t ChunkedVector_double__exposer = ChunkedVector_double__exposer_t( "ChunkedVector_double_", bp::init< >() );
bp::scope ChunkedVector_double__scope( ChunkedVector_double__exposer );
{ //::SireBase::ChunkedVector< double, 100 >::const_iterator
typedef bp::class_< SireBase::ChunkedVector< double, 100 >::const_iterator > const_iterator_exposer_t;
const_iterator_exposer_t const_iterator_exposer = const_iterator_exposer_t( "const_iterator", bp::init< >() );
bp::scope const_iterator_scope( const_iterator_exposer );
const_iterator_exposer.def( bp::init< SireBase::ChunkedVector< double, 100 >::const_iterator const & >(( bp::arg("other") )) );
const_iterator_exposer.def( bp::self != bp::self );
{ //::SireBase::ChunkedVector< double, 100 >::const_iterator::operator=
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator & ( ::SireBase::ChunkedVector< double, 100 >::const_iterator::*assign_function_type )( ::SireBase::ChunkedVector< double, 100 >::const_iterator const & ) ;
assign_function_type assign_function_value( &::SireBase::ChunkedVector< double, 100 >::const_iterator::operator= );
const_iterator_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
const_iterator_exposer.def( bp::self == bp::self );
}
{ //::SireBase::ChunkedVector< double, 100 >::iterator
typedef bp::class_< SireBase::ChunkedVector< double, 100 >::iterator > iterator_exposer_t;
iterator_exposer_t iterator_exposer = iterator_exposer_t( "iterator", bp::init< >() );
bp::scope iterator_scope( iterator_exposer );
iterator_exposer.def( bp::init< SireBase::ChunkedVector< double, 100 >::iterator const & >(( bp::arg("other") )) );
iterator_exposer.def( bp::self != bp::self );
{ //::SireBase::ChunkedVector< double, 100 >::iterator::operator=
typedef ::SireBase::ChunkedVector< double, 100 >::iterator & ( ::SireBase::ChunkedVector< double, 100 >::iterator::*assign_function_type )( ::SireBase::ChunkedVector< double, 100 >::iterator const & ) ;
assign_function_type assign_function_value( &::SireBase::ChunkedVector< double, 100 >::iterator::operator= );
iterator_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
iterator_exposer.def( bp::self == bp::self );
}
ChunkedVector_double__exposer.def( bp::init< int >(( bp::arg("size") )) );
ChunkedVector_double__exposer.def( bp::init< int, double const & >(( bp::arg("size"), bp::arg("value") )) );
ChunkedVector_double__exposer.def( bp::init< SireBase::ChunkedVector< double, 100 > const & >(( bp::arg("other") )) );
{ //::SireBase::ChunkedVector< double, 100 >::append
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*append_function_type )( double const & ) ;
append_function_type append_function_value( &::SireBase::ChunkedVector< double, 100 >::append );
ChunkedVector_double__exposer.def(
"append"
, append_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::at
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double const & ( ::SireBase::ChunkedVector< double, 100 >::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireBase::ChunkedVector< double, 100 >::at );
ChunkedVector_double__exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::ChunkedVector< double, 100 >::begin
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::iterator ( ::SireBase::ChunkedVector< double, 100 >::*begin_function_type )( ) ;
begin_function_type begin_function_value( &::SireBase::ChunkedVector< double, 100 >::begin );
ChunkedVector_double__exposer.def(
"begin"
, begin_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::begin
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*begin_function_type )( ) const;
begin_function_type begin_function_value( &::SireBase::ChunkedVector< double, 100 >::begin );
ChunkedVector_double__exposer.def(
"begin"
, begin_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::capacity
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef int ( ::SireBase::ChunkedVector< double, 100 >::*capacity_function_type )( ) const;
capacity_function_type capacity_function_value( &::SireBase::ChunkedVector< double, 100 >::capacity );
ChunkedVector_double__exposer.def(
"capacity"
, capacity_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::clear
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*clear_function_type )( ) ;
clear_function_type clear_function_value( &::SireBase::ChunkedVector< double, 100 >::clear );
ChunkedVector_double__exposer.def(
"clear"
, clear_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::constBegin
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*constBegin_function_type )( ) const;
constBegin_function_type constBegin_function_value( &::SireBase::ChunkedVector< double, 100 >::constBegin );
ChunkedVector_double__exposer.def(
"constBegin"
, constBegin_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::constEnd
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*constEnd_function_type )( ) const;
constEnd_function_type constEnd_function_value( &::SireBase::ChunkedVector< double, 100 >::constEnd );
ChunkedVector_double__exposer.def(
"constEnd"
, constEnd_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::count
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef int ( ::SireBase::ChunkedVector< double, 100 >::*count_function_type )( ) const;
count_function_type count_function_value( &::SireBase::ChunkedVector< double, 100 >::count );
ChunkedVector_double__exposer.def(
"count"
, count_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::count
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef int ( ::SireBase::ChunkedVector< double, 100 >::*count_function_type )( double const & ) const;
count_function_type count_function_value( &::SireBase::ChunkedVector< double, 100 >::count );
ChunkedVector_double__exposer.def(
"count"
, count_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::end
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::iterator ( ::SireBase::ChunkedVector< double, 100 >::*end_function_type )( ) ;
end_function_type end_function_value( &::SireBase::ChunkedVector< double, 100 >::end );
ChunkedVector_double__exposer.def(
"end"
, end_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::end
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*end_function_type )( ) const;
end_function_type end_function_value( &::SireBase::ChunkedVector< double, 100 >::end );
ChunkedVector_double__exposer.def(
"end"
, end_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::fromList
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 > ( *fromList_function_type )( ::QList< double > const & );
fromList_function_type fromList_function_value( &::SireBase::ChunkedVector< double, 100 >::fromList );
ChunkedVector_double__exposer.def(
"fromList"
, fromList_function_value
, ( bp::arg("list") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::fromStdVector
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 > ( *fromStdVector_function_type )( ::std::vector< double > const & );
fromStdVector_function_type fromStdVector_function_value( &::SireBase::ChunkedVector< double, 100 >::fromStdVector );
ChunkedVector_double__exposer.def(
"fromStdVector"
, fromStdVector_function_value
, ( bp::arg("vector") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::fromVector
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 > ( *fromVector_function_type )( ::QVector< double > const & );
fromVector_function_type fromVector_function_value( &::SireBase::ChunkedVector< double, 100 >::fromVector );
ChunkedVector_double__exposer.def(
"fromVector"
, fromVector_function_value
, ( bp::arg("vector") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::isEmpty
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef bool ( ::SireBase::ChunkedVector< double, 100 >::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireBase::ChunkedVector< double, 100 >::isEmpty );
ChunkedVector_double__exposer.def(
"isEmpty"
, isEmpty_function_value );
}
ChunkedVector_double__exposer.def( bp::self != bp::self );
{ //::SireBase::ChunkedVector< double, 100 >::operator=
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 > & ( ::SireBase::ChunkedVector< double, 100 >::*assign_function_type )( ::SireBase::ChunkedVector< double, 100 > const & ) ;
assign_function_type assign_function_value( &::SireBase::ChunkedVector< double, 100 >::operator= );
ChunkedVector_double__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
ChunkedVector_double__exposer.def( bp::self == bp::self );
{ //::SireBase::ChunkedVector< double, 100 >::operator[]
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double & ( ::SireBase::ChunkedVector< double, 100 >::*__getitem___function_type )( int ) ;
__getitem___function_type __getitem___function_value( &::SireBase::ChunkedVector< double, 100 >::operator[] );
ChunkedVector_double__exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
{ //::SireBase::ChunkedVector< double, 100 >::operator[]
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double const & ( ::SireBase::ChunkedVector< double, 100 >::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireBase::ChunkedVector< double, 100 >::operator[] );
ChunkedVector_double__exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::ChunkedVector< double, 100 >::remove
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*remove_function_type )( int ) ;
remove_function_type remove_function_value( &::SireBase::ChunkedVector< double, 100 >::remove );
ChunkedVector_double__exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::remove
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*remove_function_type )( int,int ) ;
remove_function_type remove_function_value( &::SireBase::ChunkedVector< double, 100 >::remove );
ChunkedVector_double__exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i"), bp::arg("count") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::reserve
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*reserve_function_type )( int ) ;
reserve_function_type reserve_function_value( &::SireBase::ChunkedVector< double, 100 >::reserve );
ChunkedVector_double__exposer.def(
"reserve"
, reserve_function_value
, ( bp::arg("count") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::resize
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*resize_function_type )( int ) ;
resize_function_type resize_function_value( &::SireBase::ChunkedVector< double, 100 >::resize );
ChunkedVector_double__exposer.def(
"resize"
, resize_function_value
, ( bp::arg("count") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::size
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef int ( ::SireBase::ChunkedVector< double, 100 >::*size_function_type )( ) const;
size_function_type size_function_value( &::SireBase::ChunkedVector< double, 100 >::size );
ChunkedVector_double__exposer.def(
"size"
, size_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::squeeze
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*squeeze_function_type )( ) ;
squeeze_function_type squeeze_function_value( &::SireBase::ChunkedVector< double, 100 >::squeeze );
ChunkedVector_double__exposer.def(
"squeeze"
, squeeze_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::toList
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::QList< double > ( ::SireBase::ChunkedVector< double, 100 >::*toList_function_type )( ) const;
toList_function_type toList_function_value( &::SireBase::ChunkedVector< double, 100 >::toList );
ChunkedVector_double__exposer.def(
"toList"
, toList_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::toStdVector
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::std::vector< double > ( ::SireBase::ChunkedVector< double, 100 >::*toStdVector_function_type )( ) const;
toStdVector_function_type toStdVector_function_value( &::SireBase::ChunkedVector< double, 100 >::toStdVector );
ChunkedVector_double__exposer.def(
"toStdVector"
, toStdVector_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::toVector
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::QVector< double > ( ::SireBase::ChunkedVector< double, 100 >::*toVector_function_type )( ) const;
toVector_function_type toVector_function_value( &::SireBase::ChunkedVector< double, 100 >::toVector );
ChunkedVector_double__exposer.def(
"toVector"
, toVector_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::value
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double ( ::SireBase::ChunkedVector< double, 100 >::*value_function_type )( int ) const;
value_function_type value_function_value( &::SireBase::ChunkedVector< double, 100 >::value );
ChunkedVector_double__exposer.def(
"value"
, value_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::value
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double ( ::SireBase::ChunkedVector< double, 100 >::*value_function_type )( int,double const & ) const;
value_function_type value_function_value( &::SireBase::ChunkedVector< double, 100 >::value );
ChunkedVector_double__exposer.def(
"value"
, value_function_value
, ( bp::arg("i"), bp::arg("default_value") ) );
}
ChunkedVector_double__exposer.staticmethod( "fromList" );
ChunkedVector_double__exposer.staticmethod( "fromStdVector" );
ChunkedVector_double__exposer.staticmethod( "fromVector" );
ChunkedVector_double__exposer.def( "__copy__", &__copy__);
ChunkedVector_double__exposer.def( "__deepcopy__", &__copy__);
ChunkedVector_double__exposer.def( "clone", &__copy__);
ChunkedVector_double__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::ChunkedVector<double, 100> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChunkedVector_double__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::ChunkedVector<double, 100> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChunkedVector_double__exposer.def( "__str__", &pvt_get_name);
ChunkedVector_double__exposer.def( "__repr__", &pvt_get_name);
ChunkedVector_double__exposer.def( "__len__", &__len_size< ::SireBase::ChunkedVector<double, 100> > );
}
}
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_CoordGroupArray_class(){
{ //::SireVol::CoordGroupArray
typedef bp::class_< SireVol::CoordGroupArray > CoordGroupArray_exposer_t;
CoordGroupArray_exposer_t CoordGroupArray_exposer = CoordGroupArray_exposer_t( "CoordGroupArray", "This class holds an array of CoordGroups. While you could\nof course just use a QVector<CoordGroup>, this array\noptimises the memory layout of all of the CoordGroups\nso that they all lie contiguously along the same piece\nof memory (and indeed, all of the AABoxes are grouped\ntogether, while all of the coordinates are grouped together).\n\nThe memory packing means that this array is much more\nlimited than a QVector<CoordGroup>, i.e. you cant\nadd or remove CoordGroups from the array, and you cant\ndo anything to the contained CoordGroups except for\nchange their coordinates.\n\nThis class is really meant to be used as a fast container\nthat allow rapid iteration over all of the contained\nCoordGroups coordinates\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope CoordGroupArray_scope( CoordGroupArray_exposer );
CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroup const & >(( bp::arg("cgroup") ), "Construct an array that holds just the passed CoordGroup") );
CoordGroupArray_exposer.def( bp::init< QVector< QVector< SireMaths::Vector > > const & >(( bp::arg("points") ), "Construct from a double-vector") );
CoordGroupArray_exposer.def( bp::init< QVector< SireVol::CoordGroup > const & >(( bp::arg("cgroups") ), "Construct from an array of CoordGroups") );
CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroupArray const &, SireVol::CoordGroupArray const & >(( bp::arg("array0"), bp::arg("array1") ), "Construct from a pair of CoordGroupArrays") );
CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireVol::CoordGroupArray::aaBox
typedef ::SireVol::AABox ( ::SireVol::CoordGroupArray::*aaBox_function_type)( ) const;
aaBox_function_type aaBox_function_value( &::SireVol::CoordGroupArray::aaBox );
CoordGroupArray_exposer.def(
"aaBox"
, aaBox_function_value
, "Return an AABox that complete encompasses all of the CoordGroups\nin this array" );
}
{ //::SireVol::CoordGroupArray::append
typedef void ( ::SireVol::CoordGroupArray::*append_function_type)( ::SireVol::CoordGroup const & ) ;
append_function_type append_function_value( &::SireVol::CoordGroupArray::append );
CoordGroupArray_exposer.def(
"append"
, append_function_value
, ( bp::arg("cgroup") )
, "Append the passed CoordGroup onto the end of this array" );
}
{ //::SireVol::CoordGroupArray::append
typedef void ( ::SireVol::CoordGroupArray::*append_function_type)( ::SireVol::CoordGroupArray const & ) ;
append_function_type append_function_value( &::SireVol::CoordGroupArray::append );
CoordGroupArray_exposer.def(
"append"
, append_function_value
, ( bp::arg("cgroups") )
, "Append the passed CoordGroups onto the end of this array" );
}
{ //::SireVol::CoordGroupArray::assertValidCoordGroup
typedef void ( ::SireVol::CoordGroupArray::*assertValidCoordGroup_function_type)( ::quint32 ) const;
assertValidCoordGroup_function_type assertValidCoordGroup_function_value( &::SireVol::CoordGroupArray::assertValidCoordGroup );
CoordGroupArray_exposer.def(
"assertValidCoordGroup"
, assertValidCoordGroup_function_value
, ( bp::arg("i") )
, "Assert that the index i points to a valid CoordGroup\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::assertValidCoordinate
typedef void ( ::SireVol::CoordGroupArray::*assertValidCoordinate_function_type)( ::quint32 ) const;
assertValidCoordinate_function_type assertValidCoordinate_function_value( &::SireVol::CoordGroupArray::assertValidCoordinate );
CoordGroupArray_exposer.def(
"assertValidCoordinate"
, assertValidCoordinate_function_value
, ( bp::arg("i") )
, "Assert that the index i points a valid coordinate\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::assertValidIndex
typedef void ( ::SireVol::CoordGroupArray::*assertValidIndex_function_type)( ::quint32 ) const;
assertValidIndex_function_type assertValidIndex_function_value( &::SireVol::CoordGroupArray::assertValidIndex );
CoordGroupArray_exposer.def(
"assertValidIndex"
, assertValidIndex_function_value
, ( bp::arg("i") )
, "Assert that the index i points to a valid CoordGroup\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::at
typedef ::SireVol::CoordGroup const & ( ::SireVol::CoordGroupArray::*at_function_type)( ::quint32 ) const;
at_function_type at_function_value( &::SireVol::CoordGroupArray::at );
CoordGroupArray_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "Return a reference to the ith CoordGroup\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::changeFrame
typedef void ( ::SireVol::CoordGroupArray::*changeFrame_function_type)( ::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
changeFrame_function_type changeFrame_function_value( &::SireVol::CoordGroupArray::changeFrame );
CoordGroupArray_exposer.def(
"changeFrame"
, changeFrame_function_value
, ( bp::arg("from_frame"), bp::arg("to_frame") )
, "Change all of the coordinates in this array from the\ncoordinate frame from_frame to the coordinate frame to_frame" );
}
{ //::SireVol::CoordGroupArray::changeFrame
typedef void ( ::SireVol::CoordGroupArray::*changeFrame_function_type)( ::quint32,::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
changeFrame_function_type changeFrame_function_value( &::SireVol::CoordGroupArray::changeFrame );
CoordGroupArray_exposer.def(
"changeFrame"
, changeFrame_function_value
, ( bp::arg("i"), bp::arg("from_frame"), bp::arg("to_frame") )
, "Change all of the coordinates in the ith CoordGroup from\nthe coordinate frame from_frame to the coordinate frame\nto_frame\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::count
typedef int ( ::SireVol::CoordGroupArray::*count_function_type)( ) const;
count_function_type count_function_value( &::SireVol::CoordGroupArray::count );
CoordGroupArray_exposer.def(
"count"
, count_function_value
, "Return the number of CoordGroups in this array" );
}
{ //::SireVol::CoordGroupArray::isEmpty
typedef bool ( ::SireVol::CoordGroupArray::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireVol::CoordGroupArray::isEmpty );
CoordGroupArray_exposer.def(
"isEmpty"
, isEmpty_function_value
, "Return whether or not this array is empty" );
}
{ //::SireVol::CoordGroupArray::mapInto
typedef void ( ::SireVol::CoordGroupArray::*mapInto_function_type)( ::SireMaths::AxisSet const & ) ;
mapInto_function_type mapInto_function_value( &::SireVol::CoordGroupArray::mapInto );
CoordGroupArray_exposer.def(
"mapInto"
, mapInto_function_value
, ( bp::arg("axes") )
, "Map all of the coordinates in this array into the coordinate\nframe represented by axes" );
}
{ //::SireVol::CoordGroupArray::mapInto
typedef void ( ::SireVol::CoordGroupArray::*mapInto_function_type)( ::quint32,::SireMaths::AxisSet const & ) ;
mapInto_function_type mapInto_function_value( &::SireVol::CoordGroupArray::mapInto );
CoordGroupArray_exposer.def(
"mapInto"
, mapInto_function_value
, ( bp::arg("i"), bp::arg("axes") )
, "Map all of the coordinates of the CoordGroup at index i\ninto the coordinate frame represented by axes\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::merge
typedef ::SireVol::CoordGroup ( ::SireVol::CoordGroupArray::*merge_function_type)( ) const;
merge_function_type merge_function_value( &::SireVol::CoordGroupArray::merge );
CoordGroupArray_exposer.def(
"merge"
, merge_function_value
, "Merge this array of CoordGroups back into a single CoordGroup" );
}
{ //::SireVol::CoordGroupArray::nCoordGroups
typedef int ( ::SireVol::CoordGroupArray::*nCoordGroups_function_type)( ) const;
nCoordGroups_function_type nCoordGroups_function_value( &::SireVol::CoordGroupArray::nCoordGroups );
CoordGroupArray_exposer.def(
"nCoordGroups"
, nCoordGroups_function_value
, "Return the number of CoordGroups in this array" );
}
{ //::SireVol::CoordGroupArray::nCoords
typedef int ( ::SireVol::CoordGroupArray::*nCoords_function_type)( ) const;
nCoords_function_type nCoords_function_value( &::SireVol::CoordGroupArray::nCoords );
CoordGroupArray_exposer.def(
"nCoords"
, nCoords_function_value
, "Return the number of coordinates in this array" );
}
CoordGroupArray_exposer.def( bp::self != bp::self );
{ //::SireVol::CoordGroupArray::operator=
typedef ::SireVol::CoordGroupArray & ( ::SireVol::CoordGroupArray::*assign_function_type)( ::SireVol::CoordGroupArray const & ) ;
assign_function_type assign_function_value( &::SireVol::CoordGroupArray::operator= );
CoordGroupArray_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
CoordGroupArray_exposer.def( bp::self == bp::self );
{ //::SireVol::CoordGroupArray::operator[]
typedef ::SireVol::CoordGroup const & ( ::SireVol::CoordGroupArray::*__getitem___function_type)( ::quint32 ) const;
__getitem___function_type __getitem___function_value( &::SireVol::CoordGroupArray::operator[] );
CoordGroupArray_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireVol::CoordGroupArray::remove
typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::quint32 ) ;
remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove );
CoordGroupArray_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i") )
, "Remove the ith CoordGroup from the array" );
}
{ //::SireVol::CoordGroupArray::remove
typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::quint32,int ) ;
remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove );
CoordGroupArray_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i"), bp::arg("count") )
, "Remove count CoordGroups from the array, starting with the ith CoordGroup" );
}
{ //::SireVol::CoordGroupArray::remove
typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::QVarLengthArray< unsigned int, 256 > const & ) ;
remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove );
CoordGroupArray_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("idxs") )
, "Remove the specified CoordGroups from the array" );
}
{ //::SireVol::CoordGroupArray::rotate
typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
CoordGroupArray_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("quat"), bp::arg("point") )
, "Rotate all of the coordinates in this array using the quaternion\nquat around the point point" );
}
{ //::SireVol::CoordGroupArray::rotate
typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
CoordGroupArray_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("rotmat"), bp::arg("point") )
, "Rotate all of coordinates in this array using the matrix rotmat\nabout the point point" );
}
{ //::SireVol::CoordGroupArray::rotate
typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::quint32,::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
CoordGroupArray_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("i"), bp::arg("quat"), bp::arg("point") )
, "Rotate all of the coordinates in the CoordGroup at index i using\nthe quaternion quat about the point point\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::rotate
typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::quint32,::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
CoordGroupArray_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("i"), bp::arg("rotmat"), bp::arg("point") )
, "Rotate all of the coordinates in the CoordGroup at index i using\nthe matrix rotmat about the point point\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::size
typedef int ( ::SireVol::CoordGroupArray::*size_function_type)( ) const;
size_function_type size_function_value( &::SireVol::CoordGroupArray::size );
CoordGroupArray_exposer.def(
"size"
, size_function_value
, "Return the number of CoordGroups in this array" );
}
{ //::SireVol::CoordGroupArray::toString
typedef ::QString ( ::SireVol::CoordGroupArray::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireVol::CoordGroupArray::toString );
CoordGroupArray_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this array" );
}
{ //::SireVol::CoordGroupArray::transform
typedef void ( ::SireVol::CoordGroupArray::*transform_function_type)( ::SireMaths::Transform const & ) ;
transform_function_type transform_function_value( &::SireVol::CoordGroupArray::transform );
CoordGroupArray_exposer.def(
"transform"
, transform_function_value
, ( bp::arg("t") )
, "Transform all of coordinates in this array using the transformation t" );
}
{ //::SireVol::CoordGroupArray::transform
typedef void ( ::SireVol::CoordGroupArray::*transform_function_type)( ::quint32,::SireMaths::Transform const & ) ;
transform_function_type transform_function_value( &::SireVol::CoordGroupArray::transform );
CoordGroupArray_exposer.def(
"transform"
, transform_function_value
, ( bp::arg("i"), bp::arg("t") )
, "Transform all of the coordinates in the CoordGroup at index i using\nthe transformation t\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::translate
typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::SireMaths::Vector const & ) ;
translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate );
CoordGroupArray_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("delta") )
, "Translate all of the coordinates in this array by delta" );
}
{ //::SireVol::CoordGroupArray::translate
typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::quint32,::SireMaths::Vector const & ) ;
translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate );
CoordGroupArray_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("i"), bp::arg("delta") )
, "Translate all of the coordinates in the ith CoordGroup by delta" );
}
{ //::SireVol::CoordGroupArray::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireVol::CoordGroupArray::typeName );
CoordGroupArray_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireVol::CoordGroupArray::update
typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireVol::CoordGroup const & ) ;
update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
CoordGroupArray_exposer.def(
"update"
, update_function_value
, ( bp::arg("i"), bp::arg("cgroup") )
, "Update the CoordGroup at index i so that it is equal to cgroup. Note\nthat cgroup must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
}
{ //::SireVol::CoordGroupArray::update
typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::QVector< SireMaths::Vector > const & ) ;
update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
CoordGroupArray_exposer.def(
"update"
, update_function_value
, ( bp::arg("i"), bp::arg("coords") )
, "Update the CoordGroup at index i so that it has coordinates coords\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
}
{ //::SireVol::CoordGroupArray::update
typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireMaths::Vector const *,int ) ;
update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
CoordGroupArray_exposer.def(
"update"
, update_function_value
, ( bp::arg("i"), bp::arg("coords"), bp::arg("ncoords") )
, "Update the CoordGroup at index i so that it has coordinates coords\n(there are ncoords coordinates in this array)\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
}
{ //::SireVol::CoordGroupArray::what
typedef char const * ( ::SireVol::CoordGroupArray::*what_function_type)( ) const;
what_function_type what_function_value( &::SireVol::CoordGroupArray::what );
CoordGroupArray_exposer.def(
"what"
, what_function_value
, "" );
}
CoordGroupArray_exposer.staticmethod( "typeName" );
CoordGroupArray_exposer.def( "__copy__", &__copy__);
CoordGroupArray_exposer.def( "__deepcopy__", &__copy__);
CoordGroupArray_exposer.def( "clone", &__copy__);
CoordGroupArray_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::CoordGroupArray >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CoordGroupArray_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::CoordGroupArray >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CoordGroupArray_exposer.def( "__str__", &__str__< ::SireVol::CoordGroupArray > );
CoordGroupArray_exposer.def( "__repr__", &__str__< ::SireVol::CoordGroupArray > );
CoordGroupArray_exposer.def( "__len__", &__len_size< ::SireVol::CoordGroupArray > );
}
}
void register_PackedArray2D_QString__class(){
{ //::SireBase::PackedArray2D< QString >
typedef bp::class_< SireBase::PackedArray2D< QString > > PackedArray2D_QString__exposer_t;
PackedArray2D_QString__exposer_t PackedArray2D_QString__exposer = PackedArray2D_QString__exposer_t( "PackedArray2D_QString_", bp::init< >() );
bp::scope PackedArray2D_QString__scope( PackedArray2D_QString__exposer );
PackedArray2D_QString__exposer.def( bp::init< SireBase::detail::PackedArray2D_Array< QString > const & >(( bp::arg("array") )) );
PackedArray2D_QString__exposer.def( bp::init< QVector< SireBase::detail::PackedArray2D_Array< QString > > const & >(( bp::arg("arrays") )) );
PackedArray2D_QString__exposer.def( bp::init< QVector< QString > const & >(( bp::arg("values") )) );
PackedArray2D_QString__exposer.def( bp::init< QVector< QVector< QString > > const & >(( bp::arg("values") )) );
PackedArray2D_QString__exposer.def( bp::init< SireBase::PackedArray2D< QString > const &, SireBase::PackedArray2D< QString > const & >(( bp::arg("array0"), bp::arg("array1") )) );
PackedArray2D_QString__exposer.def( bp::init< SireBase::PackedArray2D< QString > const & >(( bp::arg("other") )) );
{ //::SireBase::PackedArray2D< QString >::append
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::SireBase::detail::PackedArray2D_Array< QString > const & ) ;
append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append );
PackedArray2D_QString__exposer.def(
"append"
, append_function_value
, ( bp::arg("array") ) );
}
{ //::SireBase::PackedArray2D< QString >::append
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::SireBase::PackedArray2D< QString > const & ) ;
append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append );
PackedArray2D_QString__exposer.def(
"append"
, append_function_value
, ( bp::arg("arrays") ) );
}
{ //::SireBase::PackedArray2D< QString >::append
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::QVector< QString > const & ) ;
append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append );
PackedArray2D_QString__exposer.def(
"append"
, append_function_value
, ( bp::arg("array") ) );
}
{ //::SireBase::PackedArray2D< QString >::append
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::QVector< QVector< QString > > const & ) ;
append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append );
PackedArray2D_QString__exposer.def(
"append"
, append_function_value
, ( bp::arg("arrays") ) );
}
{ //::SireBase::PackedArray2D< QString >::assertValidIndex
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*assertValidIndex_function_type )( ::quint32 ) const;
assertValidIndex_function_type assertValidIndex_function_value( &::SireBase::PackedArray2D< QString >::assertValidIndex );
PackedArray2D_QString__exposer.def(
"assertValidIndex"
, assertValidIndex_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PackedArray2D< QString >::at
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::SireBase::detail::PackedArray2D_Array< QString > const & ( ::SireBase::PackedArray2D< QString >::*at_function_type )( ::quint32 ) const;
at_function_type at_function_value( &::SireBase::PackedArray2D< QString >::at );
PackedArray2D_QString__exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::PackedArray2D< QString >::at
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::QString const & ( ::SireBase::PackedArray2D< QString >::*at_function_type )( ::quint32,::quint32 ) const;
at_function_type at_function_value( &::SireBase::PackedArray2D< QString >::at );
PackedArray2D_QString__exposer.def(
"at"
, at_function_value
, ( bp::arg("i"), bp::arg("j") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::PackedArray2D< QString >::count
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef int ( ::SireBase::PackedArray2D< QString >::*count_function_type )( ) const;
count_function_type count_function_value( &::SireBase::PackedArray2D< QString >::count );
PackedArray2D_QString__exposer.def(
"count"
, count_function_value );
}
{ //::SireBase::PackedArray2D< QString >::fromVariant
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::SireBase::PackedArray2D< QString > ( *fromVariant_function_type )( ::SireBase::PackedArray2D< QVariant > const & );
fromVariant_function_type fromVariant_function_value( &::SireBase::PackedArray2D< QString >::fromVariant );
PackedArray2D_QString__exposer.def(
"fromVariant"
, fromVariant_function_value
, ( bp::arg("variant") ) );
}
{ //::SireBase::PackedArray2D< QString >::isEmpty
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef bool ( ::SireBase::PackedArray2D< QString >::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireBase::PackedArray2D< QString >::isEmpty );
PackedArray2D_QString__exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireBase::PackedArray2D< QString >::nArrays
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef int ( ::SireBase::PackedArray2D< QString >::*nArrays_function_type )( ) const;
nArrays_function_type nArrays_function_value( &::SireBase::PackedArray2D< QString >::nArrays );
PackedArray2D_QString__exposer.def(
"nArrays"
, nArrays_function_value );
}
{ //::SireBase::PackedArray2D< QString >::nValues
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef int ( ::SireBase::PackedArray2D< QString >::*nValues_function_type )( ) const;
nValues_function_type nValues_function_value( &::SireBase::PackedArray2D< QString >::nValues );
PackedArray2D_QString__exposer.def(
"nValues"
, nValues_function_value );
}
{ //::SireBase::PackedArray2D< QString >::nValues
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef int ( ::SireBase::PackedArray2D< QString >::*nValues_function_type )( ::quint32 ) const;
nValues_function_type nValues_function_value( &::SireBase::PackedArray2D< QString >::nValues );
PackedArray2D_QString__exposer.def(
"nValues"
, nValues_function_value
, ( bp::arg("i") ) );
}
PackedArray2D_QString__exposer.def( bp::self != bp::self );
{ //::SireBase::PackedArray2D< QString >::operator()
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::QString const & ( ::SireBase::PackedArray2D< QString >::*__call___function_type )( ::quint32,::quint32 ) const;
__call___function_type __call___function_value( &::SireBase::PackedArray2D< QString >::operator() );
PackedArray2D_QString__exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i"), bp::arg("j") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::PackedArray2D< QString >::operator=
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::SireBase::PackedArray2D< QString > & ( ::SireBase::PackedArray2D< QString >::*assign_function_type )( ::SireBase::PackedArray2D< QString > const & ) ;
assign_function_type assign_function_value( &::SireBase::PackedArray2D< QString >::operator= );
PackedArray2D_QString__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
PackedArray2D_QString__exposer.def( bp::self == bp::self );
{ //::SireBase::PackedArray2D< QString >::operator[]
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::SireBase::detail::PackedArray2D_Array< QString > const & ( ::SireBase::PackedArray2D< QString >::*__getitem___function_type )( ::quint32 ) const;
__getitem___function_type __getitem___function_value( &::SireBase::PackedArray2D< QString >::operator[] );
PackedArray2D_QString__exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::PackedArray2D< QString >::remove
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*remove_function_type )( ::quint32 ) ;
remove_function_type remove_function_value( &::SireBase::PackedArray2D< QString >::remove );
PackedArray2D_QString__exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PackedArray2D< QString >::removeAll
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*removeAll_function_type )( ::QVarLengthArray< int, 256 > const & ) ;
removeAll_function_type removeAll_function_value( &::SireBase::PackedArray2D< QString >::removeAll );
PackedArray2D_QString__exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("idxs") ) );
}
{ //::SireBase::PackedArray2D< QString >::size
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef int ( ::SireBase::PackedArray2D< QString >::*size_function_type )( ) const;
size_function_type size_function_value( &::SireBase::PackedArray2D< QString >::size );
PackedArray2D_QString__exposer.def(
"size"
, size_function_value );
}
{ //::SireBase::PackedArray2D< QString >::toQVector
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::QVector< QString > ( ::SireBase::PackedArray2D< QString >::*toQVector_function_type )( ) const;
toQVector_function_type toQVector_function_value( &::SireBase::PackedArray2D< QString >::toQVector );
PackedArray2D_QString__exposer.def(
"toQVector"
, toQVector_function_value );
}
{ //::SireBase::PackedArray2D< QString >::toQVectorVector
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::QVector< QVector< QString > > ( ::SireBase::PackedArray2D< QString >::*toQVectorVector_function_type )( ) const;
toQVectorVector_function_type toQVectorVector_function_value( &::SireBase::PackedArray2D< QString >::toQVectorVector );
PackedArray2D_QString__exposer.def(
"toQVectorVector"
, toQVectorVector_function_value );
}
{ //::SireBase::PackedArray2D< QString >::toString
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::QString ( ::SireBase::PackedArray2D< QString >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireBase::PackedArray2D< QString >::toString );
PackedArray2D_QString__exposer.def(
"toString"
, toString_function_value );
}
{ //::SireBase::PackedArray2D< QString >::toVariant
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::SireBase::PackedArray2D< QVariant > ( ::SireBase::PackedArray2D< QString >::*toVariant_function_type )( ) const;
toVariant_function_type toVariant_function_value( &::SireBase::PackedArray2D< QString >::toVariant );
PackedArray2D_QString__exposer.def(
"toVariant"
, toVariant_function_value );
}
{ //::SireBase::PackedArray2D< QString >::update
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*update_function_type )( ::quint32,::SireBase::detail::PackedArray2D_Array< QString > const & ) ;
update_function_type update_function_value( &::SireBase::PackedArray2D< QString >::update );
PackedArray2D_QString__exposer.def(
"update"
, update_function_value
, ( bp::arg("i"), bp::arg("array") ) );
}
{ //::SireBase::PackedArray2D< QString >::update
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*update_function_type )( ::quint32,::QVector< QString > const & ) ;
update_function_type update_function_value( &::SireBase::PackedArray2D< QString >::update );
PackedArray2D_QString__exposer.def(
"update"
, update_function_value
, ( bp::arg("i"), bp::arg("array") ) );
}
{ //::SireBase::PackedArray2D< QString >::updateAll
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*updateAll_function_type )( ::QVarLengthArray< int, 256 > const &,::SireBase::PackedArray2D< QString > const & ) ;
updateAll_function_type updateAll_function_value( &::SireBase::PackedArray2D< QString >::updateAll );
PackedArray2D_QString__exposer.def(
"updateAll"
, updateAll_function_value
, ( bp::arg("idxs"), bp::arg("arrays") ) );
}
PackedArray2D_QString__exposer.staticmethod( "fromVariant" );
PackedArray2D_QString__exposer.def( "__copy__", &__copy__);
PackedArray2D_QString__exposer.def( "__deepcopy__", &__copy__);
PackedArray2D_QString__exposer.def( "clone", &__copy__);
PackedArray2D_QString__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::PackedArray2D<QString> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PackedArray2D_QString__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::PackedArray2D<QString> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PackedArray2D_QString__exposer.def( "__str__", &__str__< ::SireBase::PackedArray2D<QString> > );
PackedArray2D_QString__exposer.def( "__repr__", &__str__< ::SireBase::PackedArray2D<QString> > );
PackedArray2D_QString__exposer.def( "__len__", &__len_size< ::SireBase::PackedArray2D<QString> > );
}
}
void register_BennettsRatios_class(){
{ //::SireAnalysis::BennettsRatios
typedef bp::class_< SireAnalysis::BennettsRatios, bp::bases< SireBase::Property > > BennettsRatios_exposer_t;
BennettsRatios_exposer_t BennettsRatios_exposer = BennettsRatios_exposer_t( "BennettsRatios", bp::init< >() );
bp::scope BennettsRatios_scope( BennettsRatios_exposer );
BennettsRatios_exposer.def( bp::init< QList< double > const &, QMap< double, SireMaths::BennettsFreeEnergyAverage > const &, QMap< double, SireMaths::BennettsFreeEnergyAverage > const & >(( bp::arg("windows"), bp::arg("forwards_ratios"), bp::arg("backwards_ratios") )) );
BennettsRatios_exposer.def( bp::init< SireAnalysis::BennettsRatios const & >(( bp::arg("other") )) );
{ //::SireAnalysis::BennettsRatios::backwardsData
typedef ::QMap< double, SireMaths::BennettsFreeEnergyAverage > ( ::SireAnalysis::BennettsRatios::*backwardsData_function_type )( ) const;
backwardsData_function_type backwardsData_function_value( &::SireAnalysis::BennettsRatios::backwardsData );
BennettsRatios_exposer.def(
"backwardsData"
, backwardsData_function_value );
}
{ //::SireAnalysis::BennettsRatios::backwardsRatios
typedef ::QMap< double, SireMaths::BennettsFreeEnergyAverage > ( ::SireAnalysis::BennettsRatios::*backwardsRatios_function_type )( ) const;
backwardsRatios_function_type backwardsRatios_function_value( &::SireAnalysis::BennettsRatios::backwardsRatios );
BennettsRatios_exposer.def(
"backwardsRatios"
, backwardsRatios_function_value );
}
{ //::SireAnalysis::BennettsRatios::constants
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::BennettsRatios::*constants_function_type )( ) const;
constants_function_type constants_function_value( &::SireAnalysis::BennettsRatios::constants );
BennettsRatios_exposer.def(
"constants"
, constants_function_value );
}
{ //::SireAnalysis::BennettsRatios::denominators
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::BennettsRatios::*denominators_function_type )( ) const;
denominators_function_type denominators_function_value( &::SireAnalysis::BennettsRatios::denominators );
BennettsRatios_exposer.def(
"denominators"
, denominators_function_value );
}
{ //::SireAnalysis::BennettsRatios::forwardsData
typedef ::QMap< double, SireMaths::BennettsFreeEnergyAverage > ( ::SireAnalysis::BennettsRatios::*forwardsData_function_type )( ) const;
forwardsData_function_type forwardsData_function_value( &::SireAnalysis::BennettsRatios::forwardsData );
BennettsRatios_exposer.def(
"forwardsData"
, forwardsData_function_value );
}
{ //::SireAnalysis::BennettsRatios::forwardsRatios
typedef ::QMap< double, SireMaths::BennettsFreeEnergyAverage > ( ::SireAnalysis::BennettsRatios::*forwardsRatios_function_type )( ) const;
forwardsRatios_function_type forwardsRatios_function_value( &::SireAnalysis::BennettsRatios::forwardsRatios );
BennettsRatios_exposer.def(
"forwardsRatios"
, forwardsRatios_function_value );
}
{ //::SireAnalysis::BennettsRatios::integrate
typedef ::SireAnalysis::PMF ( ::SireAnalysis::BennettsRatios::*integrate_function_type )( ) const;
integrate_function_type integrate_function_value( &::SireAnalysis::BennettsRatios::integrate );
BennettsRatios_exposer.def(
"integrate"
, integrate_function_value );
}
{ //::SireAnalysis::BennettsRatios::isEmpty
typedef bool ( ::SireAnalysis::BennettsRatios::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireAnalysis::BennettsRatios::isEmpty );
BennettsRatios_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireAnalysis::BennettsRatios::lambdaValues
typedef ::QList< double > ( ::SireAnalysis::BennettsRatios::*lambdaValues_function_type )( ) const;
lambdaValues_function_type lambdaValues_function_value( &::SireAnalysis::BennettsRatios::lambdaValues );
BennettsRatios_exposer.def(
"lambdaValues"
, lambdaValues_function_value );
}
{ //::SireAnalysis::BennettsRatios::merge
typedef ::SireAnalysis::BennettsRatios ( *merge_function_type )( ::QList< SireAnalysis::BennettsRatios > const & );
merge_function_type merge_function_value( &::SireAnalysis::BennettsRatios::merge );
BennettsRatios_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("deltas") ) );
}
{ //::SireAnalysis::BennettsRatios::nLambdaValues
typedef int ( ::SireAnalysis::BennettsRatios::*nLambdaValues_function_type )( ) const;
nLambdaValues_function_type nLambdaValues_function_value( &::SireAnalysis::BennettsRatios::nLambdaValues );
BennettsRatios_exposer.def(
"nLambdaValues"
, nLambdaValues_function_value );
}
{ //::SireAnalysis::BennettsRatios::nSamples
typedef ::qint64 ( ::SireAnalysis::BennettsRatios::*nSamples_function_type )( ) const;
nSamples_function_type nSamples_function_value( &::SireAnalysis::BennettsRatios::nSamples );
BennettsRatios_exposer.def(
"nSamples"
, nSamples_function_value );
}
{ //::SireAnalysis::BennettsRatios::nWindows
typedef int ( ::SireAnalysis::BennettsRatios::*nWindows_function_type )( ) const;
nWindows_function_type nWindows_function_value( &::SireAnalysis::BennettsRatios::nWindows );
BennettsRatios_exposer.def(
"nWindows"
, nWindows_function_value );
}
{ //::SireAnalysis::BennettsRatios::numerators
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::BennettsRatios::*numerators_function_type )( ) const;
numerators_function_type numerators_function_value( &::SireAnalysis::BennettsRatios::numerators );
BennettsRatios_exposer.def(
"numerators"
, numerators_function_value );
}
BennettsRatios_exposer.def( bp::self != bp::self );
BennettsRatios_exposer.def( bp::self + bp::self );
{ //::SireAnalysis::BennettsRatios::operator=
typedef ::SireAnalysis::BennettsRatios & ( ::SireAnalysis::BennettsRatios::*assign_function_type )( ::SireAnalysis::BennettsRatios const & ) ;
assign_function_type assign_function_value( &::SireAnalysis::BennettsRatios::operator= );
BennettsRatios_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
BennettsRatios_exposer.def( bp::self == bp::self );
{ //::SireAnalysis::BennettsRatios::sum
typedef ::SireAnalysis::PMF ( ::SireAnalysis::BennettsRatios::*sum_function_type )( ) const;
sum_function_type sum_function_value( &::SireAnalysis::BennettsRatios::sum );
BennettsRatios_exposer.def(
"sum"
, sum_function_value );
}
{ //::SireAnalysis::BennettsRatios::temperature
typedef ::SireUnits::Dimension::Temperature ( ::SireAnalysis::BennettsRatios::*temperature_function_type )( ) const;
temperature_function_type temperature_function_value( &::SireAnalysis::BennettsRatios::temperature );
BennettsRatios_exposer.def(
"temperature"
, temperature_function_value );
}
{ //::SireAnalysis::BennettsRatios::toString
typedef ::QString ( ::SireAnalysis::BennettsRatios::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireAnalysis::BennettsRatios::toString );
BennettsRatios_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireAnalysis::BennettsRatios::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireAnalysis::BennettsRatios::typeName );
BennettsRatios_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireAnalysis::BennettsRatios::values
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::BennettsRatios::*values_function_type )( ) const;
values_function_type values_function_value( &::SireAnalysis::BennettsRatios::values );
BennettsRatios_exposer.def(
"values"
, values_function_value );
}
{ //::SireAnalysis::BennettsRatios::what
typedef char const * ( ::SireAnalysis::BennettsRatios::*what_function_type )( ) const;
what_function_type what_function_value( &::SireAnalysis::BennettsRatios::what );
BennettsRatios_exposer.def(
"what"
, what_function_value );
}
{ //::SireAnalysis::BennettsRatios::windows
typedef ::QList< double > ( ::SireAnalysis::BennettsRatios::*windows_function_type )( ) const;
windows_function_type windows_function_value( &::SireAnalysis::BennettsRatios::windows );
BennettsRatios_exposer.def(
"windows"
, windows_function_value );
}
BennettsRatios_exposer.staticmethod( "merge" );
BennettsRatios_exposer.staticmethod( "typeName" );
BennettsRatios_exposer.def( "__copy__", &__copy__);
BennettsRatios_exposer.def( "__deepcopy__", &__copy__);
BennettsRatios_exposer.def( "clone", &__copy__);
BennettsRatios_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::BennettsRatios >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
BennettsRatios_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::BennettsRatios >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
BennettsRatios_exposer.def( "__str__", &__str__< ::SireAnalysis::BennettsRatios > );
BennettsRatios_exposer.def( "__repr__", &__str__< ::SireAnalysis::BennettsRatios > );
}
}
void register_CLJWorkspace_class(){
{ //::SireMM::CLJWorkspace
typedef bp::class_< SireMM::CLJWorkspace > CLJWorkspace_exposer_t;
CLJWorkspace_exposer_t CLJWorkspace_exposer = CLJWorkspace_exposer_t( "CLJWorkspace", "This class provides a workspace in which to hold the details of the changes\nthat occur in a CLJ forcefield during a Monte Carlo move. The class is optimised\nto avoid copying or duplicating data during Sires copy-on-write copying\n(e.g. the memory allocated in a workspace will always be available for the\nnew copy of a forcefield rather than the old, which, if things work correctly,\nwill mean that there should be no memory allocation during simple MC moves...)\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope CLJWorkspace_scope( CLJWorkspace_exposer );
CLJWorkspace_exposer.def( bp::init< SireMM::CLJWorkspace const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMM::CLJWorkspace::accept
typedef void ( ::SireMM::CLJWorkspace::*accept_function_type)( ::SireMM::CLJBoxes & ) ;
accept_function_type accept_function_value( &::SireMM::CLJWorkspace::accept );
CLJWorkspace_exposer.def(
"accept"
, accept_function_value
, ( bp::arg("boxes") )
, "Accept this workspace - this clears the recalc_from_scratch flag as it\nsignals that we have put the CLJBoxes into a sane state" );
}
{ //::SireMM::CLJWorkspace::at
typedef ::SireMM::CLJDelta const & ( ::SireMM::CLJWorkspace::*at_function_type)( int ) const;
at_function_type at_function_value( &::SireMM::CLJWorkspace::at );
CLJWorkspace_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the ith delta" );
}
{ //::SireMM::CLJWorkspace::changedAtoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*changedAtoms_function_type)( ) const;
changedAtoms_function_type changedAtoms_function_value( &::SireMM::CLJWorkspace::changedAtoms );
CLJWorkspace_exposer.def(
"changedAtoms"
, changedAtoms_function_value
, "Merge all of the deltas together into a single set of changed CLJAtoms that\ncan be used for the change in energy calculation" );
}
{ //::SireMM::CLJWorkspace::clear
typedef void ( ::SireMM::CLJWorkspace::*clear_function_type)( ) ;
clear_function_type clear_function_value( &::SireMM::CLJWorkspace::clear );
CLJWorkspace_exposer.def(
"clear"
, clear_function_value
, "Clear this workspace" );
}
{ //::SireMM::CLJWorkspace::commit
typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJWorkspace::*commit_function_type)( ::SireMM::CLJBoxes &,::SireMM::CLJDelta const & ) ;
commit_function_type commit_function_value( &::SireMM::CLJWorkspace::commit );
CLJWorkspace_exposer.def(
"commit"
, commit_function_value
, ( bp::arg("boxes"), bp::arg("delta") )
, "Commit the changes in the passed delta into the passed CLJBoxes" );
}
{ //::SireMM::CLJWorkspace::count
typedef int ( ::SireMM::CLJWorkspace::*count_function_type)( ) const;
count_function_type count_function_value( &::SireMM::CLJWorkspace::count );
CLJWorkspace_exposer.def(
"count"
, count_function_value
, "Return the number of deltas" );
}
{ //::SireMM::CLJWorkspace::getitem
typedef ::SireMM::CLJDelta ( ::SireMM::CLJWorkspace::*getitem_function_type)( int ) const;
getitem_function_type getitem_function_value( &::SireMM::CLJWorkspace::getitem );
CLJWorkspace_exposer.def(
"getitem"
, getitem_function_value
, ( bp::arg("i") )
, "Return the ith delta" );
}
{ //::SireMM::CLJWorkspace::isEmpty
typedef bool ( ::SireMM::CLJWorkspace::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMM::CLJWorkspace::isEmpty );
CLJWorkspace_exposer.def(
"isEmpty"
, isEmpty_function_value
, "Return whether or not this workspace is empty" );
}
{ //::SireMM::CLJWorkspace::isSingleID
typedef bool ( ::SireMM::CLJWorkspace::*isSingleID_function_type)( ) const;
isSingleID_function_type isSingleID_function_value( &::SireMM::CLJWorkspace::isSingleID );
CLJWorkspace_exposer.def(
"isSingleID"
, isSingleID_function_value
, "Return whether or not this workspace contains deltas with a single\nID (a single CLJAtoms ID)" );
}
{ //::SireMM::CLJWorkspace::merge
typedef ::boost::tuples::tuple< SireMM::CLJAtoms, SireMM::CLJAtoms, SireMM::CLJAtoms, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > ( ::SireMM::CLJWorkspace::*merge_function_type)( ) const;
merge_function_type merge_function_value( &::SireMM::CLJWorkspace::merge );
CLJWorkspace_exposer.def(
"merge"
, merge_function_value
, "Merge all of the deltas together to return the tuple of the\nchanged, old and new atoms. This is equivalent to calling\nchangedAtoms(), oldAtoms() and newAtoms() and placing them\ninto a tuple. This is more efficient than three separate calls" );
}
{ //::SireMM::CLJWorkspace::mustRecalculateFromScratch
typedef void ( ::SireMM::CLJWorkspace::*mustRecalculateFromScratch_function_type)( ::SireMM::CLJBoxes & ) ;
mustRecalculateFromScratch_function_type mustRecalculateFromScratch_function_value( &::SireMM::CLJWorkspace::mustRecalculateFromScratch );
CLJWorkspace_exposer.def(
"mustRecalculateFromScratch"
, mustRecalculateFromScratch_function_value
, ( bp::arg("boxes") )
, "Tell the workspace that we are now recalculating everything from scratch" );
}
{ //::SireMM::CLJWorkspace::nDeltas
typedef int ( ::SireMM::CLJWorkspace::*nDeltas_function_type)( ) const;
nDeltas_function_type nDeltas_function_value( &::SireMM::CLJWorkspace::nDeltas );
CLJWorkspace_exposer.def(
"nDeltas"
, nDeltas_function_value
, "Return the number of deltas in this workspace" );
}
{ //::SireMM::CLJWorkspace::needsAccepting
typedef bool ( ::SireMM::CLJWorkspace::*needsAccepting_function_type)( ) const;
needsAccepting_function_type needsAccepting_function_value( &::SireMM::CLJWorkspace::needsAccepting );
CLJWorkspace_exposer.def(
"needsAccepting"
, needsAccepting_function_value
, "Return whether or not this workspace needs accepting" );
}
{ //::SireMM::CLJWorkspace::newAtoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*newAtoms_function_type)( ) const;
newAtoms_function_type newAtoms_function_value( &::SireMM::CLJWorkspace::newAtoms );
CLJWorkspace_exposer.def(
"newAtoms"
, newAtoms_function_value
, "Merge all of the new atoms from the deltas together into a single\nset of new CLJAtoms that can be used for the change in energy calculation" );
}
{ //::SireMM::CLJWorkspace::oldAtoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*oldAtoms_function_type)( ) const;
oldAtoms_function_type oldAtoms_function_value( &::SireMM::CLJWorkspace::oldAtoms );
CLJWorkspace_exposer.def(
"oldAtoms"
, oldAtoms_function_value
, "Merge all of the old atoms from the deltas together into a single\nset of old CLJAtoms that can be used for the change in energy calculation" );
}
CLJWorkspace_exposer.def( bp::self != bp::self );
{ //::SireMM::CLJWorkspace::operator=
typedef ::SireMM::CLJWorkspace & ( ::SireMM::CLJWorkspace::*assign_function_type)( ::SireMM::CLJWorkspace const & ) ;
assign_function_type assign_function_value( &::SireMM::CLJWorkspace::operator= );
CLJWorkspace_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
CLJWorkspace_exposer.def( bp::self == bp::self );
{ //::SireMM::CLJWorkspace::operator[]
typedef ::SireMM::CLJDelta const & ( ::SireMM::CLJWorkspace::*__getitem___function_type)( int ) const;
__getitem___function_type __getitem___function_value( &::SireMM::CLJWorkspace::operator[] );
CLJWorkspace_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMM::CLJWorkspace::push
typedef ::SireMM::CLJDelta ( ::SireMM::CLJWorkspace::*push_function_type)( ::SireMM::CLJBoxes &,::QVector< SireMM::CLJBoxIndex > const &,::SireMM::CLJAtoms const &,::SireMM::CLJDelta const & ) ;
push_function_type push_function_value( &::SireMM::CLJWorkspace::push );
CLJWorkspace_exposer.def(
"push"
, push_function_value
, ( bp::arg("boxes"), bp::arg("old_atoms"), bp::arg("new_atoms"), bp::arg("old_delta") )
, "Push the passed change onto the workspace. This changes the atoms in the\npassed CLJBoxes from their values in old_atoms to their values in the\npassed new_atoms. The last CLJDelta used for these atoms is supplied as\nold_delta, and this returns the new CLJDelta for these atoms." );
}
{ //::SireMM::CLJWorkspace::recalculatingFromScratch
typedef bool ( ::SireMM::CLJWorkspace::*recalculatingFromScratch_function_type)( ) const;
recalculatingFromScratch_function_type recalculatingFromScratch_function_value( &::SireMM::CLJWorkspace::recalculatingFromScratch );
CLJWorkspace_exposer.def(
"recalculatingFromScratch"
, recalculatingFromScratch_function_value
, "Return whether or not we are recalculating everything from scratch" );
}
{ //::SireMM::CLJWorkspace::removeSameIDAtoms
typedef void ( ::SireMM::CLJWorkspace::*removeSameIDAtoms_function_type)( ::SireMM::CLJBoxes & ) ;
removeSameIDAtoms_function_type removeSameIDAtoms_function_value( &::SireMM::CLJWorkspace::removeSameIDAtoms );
CLJWorkspace_exposer.def(
"removeSameIDAtoms"
, removeSameIDAtoms_function_value
, ( bp::arg("boxes") )
, "Internal function used to fully remove atoms that have not been\nremoved because they all have the same ID. This is used when the\noptimisation of not removing same ID atoms would break the energy\ncalculation, e.g. if we have multiple CLJGroups and have multiple\nchanged IDs across these groups" );
}
{ //::SireMM::CLJWorkspace::revert
typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJWorkspace::*revert_function_type)( ::SireMM::CLJBoxes &,::SireMM::CLJDelta const & ) ;
revert_function_type revert_function_value( &::SireMM::CLJWorkspace::revert );
CLJWorkspace_exposer.def(
"revert"
, revert_function_value
, ( bp::arg("boxes"), bp::arg("delta") )
, "Revert the changes supplied in the passed delta" );
}
{ //::SireMM::CLJWorkspace::size
typedef int ( ::SireMM::CLJWorkspace::*size_function_type)( ) const;
size_function_type size_function_value( &::SireMM::CLJWorkspace::size );
CLJWorkspace_exposer.def(
"size"
, size_function_value
, "Return the number of deltas" );
}
{ //::SireMM::CLJWorkspace::toString
typedef ::QString ( ::SireMM::CLJWorkspace::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMM::CLJWorkspace::toString );
CLJWorkspace_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireMM::CLJWorkspace::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::CLJWorkspace::typeName );
CLJWorkspace_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMM::CLJWorkspace::what
typedef char const * ( ::SireMM::CLJWorkspace::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMM::CLJWorkspace::what );
CLJWorkspace_exposer.def(
"what"
, what_function_value
, "" );
}
CLJWorkspace_exposer.staticmethod( "typeName" );
CLJWorkspace_exposer.def( "__copy__", &__copy__);
CLJWorkspace_exposer.def( "__deepcopy__", &__copy__);
CLJWorkspace_exposer.def( "clone", &__copy__);
CLJWorkspace_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJWorkspace >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJWorkspace_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJWorkspace >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJWorkspace_exposer.def( "__str__", &__str__< ::SireMM::CLJWorkspace > );
CLJWorkspace_exposer.def( "__repr__", &__str__< ::SireMM::CLJWorkspace > );
CLJWorkspace_exposer.def( "__len__", &__len_size< ::SireMM::CLJWorkspace > );
CLJWorkspace_exposer.def( "__getitem__", &::SireMM::CLJWorkspace::getitem );
}
}
void register_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_AtomFloatProperty_class(){
{ //::SireMol::AtomProperty< double >
typedef bp::class_< SireMol::AtomProperty< double >, bp::bases< SireMol::AtomProp, SireMol::MolViewProperty, SireBase::Property > > AtomFloatProperty_exposer_t;
AtomFloatProperty_exposer_t AtomFloatProperty_exposer = AtomFloatProperty_exposer_t( "AtomFloatProperty", "", bp::init< >("") );
bp::scope AtomFloatProperty_scope( AtomFloatProperty_exposer );
AtomFloatProperty_exposer.def( bp::init< SireMol::MoleculeInfoData const & >(( bp::arg("molinfo") ), "") );
AtomFloatProperty_exposer.def( bp::init< SireMol::MoleculeInfoData const &, double const & >(( bp::arg("molinfo"), bp::arg("default_value") ), "") );
AtomFloatProperty_exposer.def( bp::init< double const & >(( bp::arg("value") ), "") );
AtomFloatProperty_exposer.def( bp::init< SireBase::PackedArray2D< double > const & >(( bp::arg("values") ), "") );
AtomFloatProperty_exposer.def( bp::init< SireMol::AtomProperty< double > const & >(( bp::arg("other") ), "") );
{ //::SireMol::AtomProperty< double >::array
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PackedArray2D< double > const & ( ::SireMol::AtomProperty< double >::*array_function_type)( ) const;
array_function_type array_function_value( &::SireMol::AtomProperty< double >::array );
AtomFloatProperty_exposer.def(
"array"
, array_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::assertCanConvert
typedef SireMol::AtomProperty< double > exported_class_t;
typedef void ( ::SireMol::AtomProperty< double >::*assertCanConvert_function_type)( ::QVariant const & ) const;
assertCanConvert_function_type assertCanConvert_function_value( &::SireMol::AtomProperty< double >::assertCanConvert );
AtomFloatProperty_exposer.def(
"assertCanConvert"
, assertCanConvert_function_value
, ( bp::arg("value") )
, "" );
}
{ //::SireMol::AtomProperty< double >::assignFrom
typedef SireMol::AtomProperty< double > exported_class_t;
typedef void ( ::SireMol::AtomProperty< double >::*assignFrom_function_type)( ::SireMol::AtomProperty< QVariant > const & ) ;
assignFrom_function_type assignFrom_function_value( &::SireMol::AtomProperty< double >::assignFrom );
AtomFloatProperty_exposer.def(
"assignFrom"
, assignFrom_function_value
, ( bp::arg("values") )
, "" );
}
{ //::SireMol::AtomProperty< double >::at
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PackedArray2D< double >::Array const & ( ::SireMol::AtomProperty< double >::*at_function_type)( ::SireMol::CGIdx ) const;
at_function_type at_function_value( &::SireMol::AtomProperty< double >::at );
AtomFloatProperty_exposer.def(
"at"
, at_function_value
, ( bp::arg("cgidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::at
typedef SireMol::AtomProperty< double > exported_class_t;
typedef double const & ( ::SireMol::AtomProperty< double >::*at_function_type)( ::SireMol::CGAtomIdx const & ) const;
at_function_type at_function_value( &::SireMol::AtomProperty< double >::at );
AtomFloatProperty_exposer.def(
"at"
, at_function_value
, ( bp::arg("cgatomidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::canConvert
typedef SireMol::AtomProperty< double > exported_class_t;
typedef bool ( ::SireMol::AtomProperty< double >::*canConvert_function_type)( ::QVariant const & ) const;
canConvert_function_type canConvert_function_value( &::SireMol::AtomProperty< double >::canConvert );
AtomFloatProperty_exposer.def(
"canConvert"
, canConvert_function_value
, ( bp::arg("value") )
, "" );
}
{ //::SireMol::AtomProperty< double >::copyFrom
typedef SireMol::AtomProperty< double > exported_class_t;
typedef void ( ::SireMol::AtomProperty< double >::*copyFrom_function_type)( ::QVector< double > const & ) ;
copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< double >::copyFrom );
AtomFloatProperty_exposer.def(
"copyFrom"
, copyFrom_function_value
, ( bp::arg("values") )
, "" );
}
{ //::SireMol::AtomProperty< double >::copyFrom
typedef SireMol::AtomProperty< double > exported_class_t;
typedef void ( ::SireMol::AtomProperty< double >::*copyFrom_function_type)( ::QVector< double > const &,::SireMol::AtomSelection const & ) ;
copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< double >::copyFrom );
AtomFloatProperty_exposer.def(
"copyFrom"
, copyFrom_function_value
, ( bp::arg("values"), bp::arg("selection") )
, "" );
}
{ //::SireMol::AtomProperty< double >::count
typedef SireMol::AtomProperty< double > exported_class_t;
typedef int ( ::SireMol::AtomProperty< double >::*count_function_type)( ) const;
count_function_type count_function_value( &::SireMol::AtomProperty< double >::count );
AtomFloatProperty_exposer.def(
"count"
, count_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::divide
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< double >::*divide_function_type)( ::QVector< SireMol::AtomSelection > const & ) const;
divide_function_type divide_function_value( &::SireMol::AtomProperty< double >::divide );
AtomFloatProperty_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("beads") )
, "" );
}
{ //::SireMol::AtomProperty< double >::divideByResidue
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< double >::*divideByResidue_function_type)( ::SireMol::MoleculeInfoData const & ) const;
divideByResidue_function_type divideByResidue_function_value( &::SireMol::AtomProperty< double >::divideByResidue );
AtomFloatProperty_exposer.def(
"divideByResidue"
, divideByResidue_function_value
, ( bp::arg("molinfo") )
, "" );
}
{ //::SireMol::AtomProperty< double >::fromVariant
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< double > ( *fromVariant_function_type )( ::SireMol::AtomProperty< QVariant > const & );
fromVariant_function_type fromVariant_function_value( &::SireMol::AtomProperty< double >::fromVariant );
AtomFloatProperty_exposer.def(
"fromVariant"
, fromVariant_function_value
, ( bp::arg("variant") )
, "" );
}
{ //::SireMol::AtomProperty< double >::get
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PackedArray2D< double >::Array const & ( ::SireMol::AtomProperty< double >::*get_function_type)( ::SireMol::CGIdx ) const;
get_function_type get_function_value( &::SireMol::AtomProperty< double >::get );
AtomFloatProperty_exposer.def(
"get"
, get_function_value
, ( bp::arg("cgidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::get
typedef SireMol::AtomProperty< double > exported_class_t;
typedef double const & ( ::SireMol::AtomProperty< double >::*get_function_type)( ::SireMol::CGAtomIdx const & ) const;
get_function_type get_function_value( &::SireMol::AtomProperty< double >::get );
AtomFloatProperty_exposer.def(
"get"
, get_function_value
, ( bp::arg("cgatomidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::isCompatibleWith
typedef SireMol::AtomProperty< double > exported_class_t;
typedef bool ( ::SireMol::AtomProperty< double >::*isCompatibleWith_function_type)( ::SireMol::MoleculeInfoData const & ) const;
isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::AtomProperty< double >::isCompatibleWith );
AtomFloatProperty_exposer.def(
"isCompatibleWith"
, isCompatibleWith_function_value
, ( bp::arg("molinfo") )
, "" );
}
{ //::SireMol::AtomProperty< double >::isCompatibleWith
typedef SireMol::AtomProperty< double > exported_class_t;
typedef bool ( ::SireMol::AtomProperty< double >::*isCompatibleWith_function_type)( ::SireMol::MoleculeInfo const & ) const;
isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::AtomProperty< double >::isCompatibleWith );
AtomFloatProperty_exposer.def(
"isCompatibleWith"
, isCompatibleWith_function_value
, ( bp::arg("molinfo") )
, "" );
}
{ //::SireMol::AtomProperty< double >::isEmpty
typedef SireMol::AtomProperty< double > exported_class_t;
typedef bool ( ::SireMol::AtomProperty< double >::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMol::AtomProperty< double >::isEmpty );
AtomFloatProperty_exposer.def(
"isEmpty"
, isEmpty_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::matchToSelection
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< double > ( ::SireMol::AtomProperty< double >::*matchToSelection_function_type)( ::SireMol::AtomSelection const & ) const;
matchToSelection_function_type matchToSelection_function_value( &::SireMol::AtomProperty< double >::matchToSelection );
AtomFloatProperty_exposer.def(
"matchToSelection"
, matchToSelection_function_value
, ( bp::arg("selection") )
, "" );
}
{ //::SireMol::AtomProperty< double >::merge
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< double >::*merge_function_type)( ::SireMol::MoleculeInfoData const & ) const;
merge_function_type merge_function_value( &::SireMol::AtomProperty< double >::merge );
AtomFloatProperty_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("molinfo") )
, "" );
}
{ //::SireMol::AtomProperty< double >::nAtoms
typedef SireMol::AtomProperty< double > exported_class_t;
typedef int ( ::SireMol::AtomProperty< double >::*nAtoms_function_type)( ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< double >::nAtoms );
AtomFloatProperty_exposer.def(
"nAtoms"
, nAtoms_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::nAtoms
typedef SireMol::AtomProperty< double > exported_class_t;
typedef int ( ::SireMol::AtomProperty< double >::*nAtoms_function_type)( ::SireMol::CGIdx ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< double >::nAtoms );
AtomFloatProperty_exposer.def(
"nAtoms"
, nAtoms_function_value
, ( bp::arg("cgidx") )
, "" );
}
{ //::SireMol::AtomProperty< double >::nCutGroups
typedef SireMol::AtomProperty< double > exported_class_t;
typedef int ( ::SireMol::AtomProperty< double >::*nCutGroups_function_type)( ) const;
nCutGroups_function_type nCutGroups_function_value( &::SireMol::AtomProperty< double >::nCutGroups );
AtomFloatProperty_exposer.def(
"nCutGroups"
, nCutGroups_function_value
, "" );
}
AtomFloatProperty_exposer.def( bp::self != bp::self );
{ //::SireMol::AtomProperty< double >::operator=
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< double > & ( ::SireMol::AtomProperty< double >::*assign_function_type)( ::SireMol::AtomProperty< double > const & ) ;
assign_function_type assign_function_value( &::SireMol::AtomProperty< double >::operator= );
AtomFloatProperty_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
AtomFloatProperty_exposer.def( bp::self == bp::self );
{ //::SireMol::AtomProperty< double >::operator[]
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PackedArray2D< double >::Array const & ( ::SireMol::AtomProperty< double >::*__getitem___function_type)( ::SireMol::CGIdx ) const;
__getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< double >::operator[] );
AtomFloatProperty_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("cgidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::operator[]
typedef SireMol::AtomProperty< double > exported_class_t;
typedef double const & ( ::SireMol::AtomProperty< double >::*__getitem___function_type)( ::SireMol::CGAtomIdx const & ) const;
__getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< double >::operator[] );
AtomFloatProperty_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("cgatomidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::set
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< double > & ( ::SireMol::AtomProperty< double >::*set_function_type)( ::SireMol::CGAtomIdx const &,double const & ) ;
set_function_type set_function_value( &::SireMol::AtomProperty< double >::set );
AtomFloatProperty_exposer.def(
"set"
, set_function_value
, ( bp::arg("cgatomidx"), bp::arg("value") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::AtomProperty< double >::set
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< double > & ( ::SireMol::AtomProperty< double >::*set_function_type)( ::SireMol::CGIdx,::QVector< double > const & ) ;
set_function_type set_function_value( &::SireMol::AtomProperty< double >::set );
AtomFloatProperty_exposer.def(
"set"
, set_function_value
, ( bp::arg("cgidx"), bp::arg("values") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::AtomProperty< double >::size
typedef SireMol::AtomProperty< double > exported_class_t;
typedef int ( ::SireMol::AtomProperty< double >::*size_function_type)( ) const;
size_function_type size_function_value( &::SireMol::AtomProperty< double >::size );
AtomFloatProperty_exposer.def(
"size"
, size_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::toString
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::QString ( ::SireMol::AtomProperty< double >::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::AtomProperty< double >::toString );
AtomFloatProperty_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::toVariant
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< QVariant > ( ::SireMol::AtomProperty< double >::*toVariant_function_type)( ) const;
toVariant_function_type toVariant_function_value( &::SireMol::AtomProperty< double >::toVariant );
AtomFloatProperty_exposer.def(
"toVariant"
, toVariant_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::toVector
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::QVector< double > ( ::SireMol::AtomProperty< double >::*toVector_function_type)( ) const;
toVector_function_type toVector_function_value( &::SireMol::AtomProperty< double >::toVector );
AtomFloatProperty_exposer.def(
"toVector"
, toVector_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::toVector
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::QVector< double > ( ::SireMol::AtomProperty< double >::*toVector_function_type)( ::SireMol::AtomSelection const & ) const;
toVector_function_type toVector_function_value( &::SireMol::AtomProperty< double >::toVector );
AtomFloatProperty_exposer.def(
"toVector"
, toVector_function_value
, ( bp::arg("selection") )
, "" );
}
{ //::SireMol::AtomProperty< double >::typeName
typedef SireMol::AtomProperty< double > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::AtomProperty< double >::typeName );
AtomFloatProperty_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
AtomFloatProperty_exposer.staticmethod( "fromVariant" );
AtomFloatProperty_exposer.staticmethod( "typeName" );
AtomFloatProperty_exposer.def( "__copy__", &__copy__);
AtomFloatProperty_exposer.def( "__deepcopy__", &__copy__);
AtomFloatProperty_exposer.def( "clone", &__copy__);
AtomFloatProperty_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::AtomProperty<double> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AtomFloatProperty_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::AtomProperty<double> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AtomFloatProperty_exposer.def( "__str__", &__str__< ::SireMol::AtomProperty<double> > );
AtomFloatProperty_exposer.def( "__repr__", &__str__< ::SireMol::AtomProperty<double> > );
AtomFloatProperty_exposer.def( "__len__", &__len_size< ::SireMol::AtomProperty<double> > );
}
}
void register_Name_class(){
{ //::SireID::Name
typedef bp::class_< SireID::Name, boost::noncopyable > Name_exposer_t;
Name_exposer_t Name_exposer = Name_exposer_t( "Name", bp::no_init );
bp::scope Name_scope( Name_exposer );
{ //::SireID::Name::hash
typedef ::uint ( ::SireID::Name::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireID::Name::hash );
Name_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireID::Name::isCaseSensitive
typedef bool ( ::SireID::Name::*isCaseSensitive_function_type )( ) const;
isCaseSensitive_function_type isCaseSensitive_function_value( &::SireID::Name::isCaseSensitive );
Name_exposer.def(
"isCaseSensitive"
, isCaseSensitive_function_value );
}
{ //::SireID::Name::isEmpty
typedef bool ( ::SireID::Name::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireID::Name::isEmpty );
Name_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireID::Name::isNull
typedef bool ( ::SireID::Name::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireID::Name::isNull );
Name_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireID::Name::value
typedef ::QString const & ( ::SireID::Name::*value_function_type )( ) const;
value_function_type value_function_value( &::SireID::Name::value );
Name_exposer.def(
"value"
, value_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
Name_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Name >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Name_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Name >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Name_exposer.def( "__str__", &pvt_get_name);
Name_exposer.def( "__repr__", &pvt_get_name);
}
}
void register_CLJBoxes_class(){
{ //::SireMM::CLJBoxes
typedef bp::class_< SireMM::CLJBoxes > CLJBoxes_exposer_t;
CLJBoxes_exposer_t CLJBoxes_exposer = CLJBoxes_exposer_t( "CLJBoxes", bp::init< >() );
bp::scope CLJBoxes_scope( CLJBoxes_exposer );
CLJBoxes_exposer.def( bp::init< SireUnits::Dimension::Length >(( bp::arg("box_size") )) );
CLJBoxes_exposer.def( bp::init< SireMM::CLJAtoms const & >(( bp::arg("atoms") )) );
CLJBoxes_exposer.def( bp::init< SireMM::CLJAtoms const &, SireMM::CLJAtoms const & >(( bp::arg("atoms0"), bp::arg("atoms1") )) );
CLJBoxes_exposer.def( bp::init< SireMM::CLJAtoms const &, SireUnits::Dimension::Length >(( bp::arg("atoms"), bp::arg("box_size") )) );
CLJBoxes_exposer.def( bp::init< SireMM::CLJAtoms const &, SireMM::CLJAtoms const &, SireUnits::Dimension::Length >(( bp::arg("atoms0"), bp::arg("atoms1"), bp::arg("box_size") )) );
CLJBoxes_exposer.def( bp::init< SireMM::CLJBoxes const & >(( bp::arg("other") )) );
{ //::SireMM::CLJBoxes::add
typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJBoxes::*add_function_type )( ::SireMM::CLJAtoms const & ) ;
add_function_type add_function_value( &::SireMM::CLJBoxes::add );
CLJBoxes_exposer.def(
"add"
, add_function_value
, ( bp::arg("atoms") ) );
}
{ //::SireMM::CLJBoxes::at
typedef ::SireMM::CLJAtom ( ::SireMM::CLJBoxes::*at_function_type )( ::SireMM::CLJBoxIndex const & ) const;
at_function_type at_function_value( &::SireMM::CLJBoxes::at );
CLJBoxes_exposer.def(
"at"
, at_function_value
, ( bp::arg("idx") ) );
}
{ //::SireMM::CLJBoxes::atoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJBoxes::*atoms_function_type )( ) const;
atoms_function_type atoms_function_value( &::SireMM::CLJBoxes::atoms );
CLJBoxes_exposer.def(
"atoms"
, atoms_function_value );
}
{ //::SireMM::CLJBoxes::atoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJBoxes::*atoms_function_type )( ::QVector< SireMM::CLJBoxIndex > const & ) const;
atoms_function_type atoms_function_value( &::SireMM::CLJBoxes::atoms );
CLJBoxes_exposer.def(
"atoms"
, atoms_function_value
, ( bp::arg("atoms") ) );
}
{ //::SireMM::CLJBoxes::boxAt
typedef ::SireMM::CLJBox ( ::SireMM::CLJBoxes::*boxAt_function_type )( int ) const;
boxAt_function_type boxAt_function_value( &::SireMM::CLJBoxes::boxAt );
CLJBoxes_exposer.def(
"boxAt"
, boxAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireMM::CLJBoxes::boxAt
typedef ::SireMM::CLJBox ( ::SireMM::CLJBoxes::*boxAt_function_type )( ::SireMM::CLJBoxIndex const & ) const;
boxAt_function_type boxAt_function_value( &::SireMM::CLJBoxes::boxAt );
CLJBoxes_exposer.def(
"boxAt"
, boxAt_function_value
, ( bp::arg("index") ) );
}
{ //::SireMM::CLJBoxes::boxAt
typedef ::SireMM::CLJBox ( ::SireMM::CLJBoxes::*boxAt_function_type )( ::SireMaths::Vector const & ) const;
boxAt_function_type boxAt_function_value( &::SireMM::CLJBoxes::boxAt );
CLJBoxes_exposer.def(
"boxAt"
, boxAt_function_value
, ( bp::arg("coords") ) );
}
{ //::SireMM::CLJBoxes::boxDimensions
typedef ::QVector< SireVol::AABox > ( ::SireMM::CLJBoxes::*boxDimensions_function_type )( ) const;
boxDimensions_function_type boxDimensions_function_value( &::SireMM::CLJBoxes::boxDimensions );
CLJBoxes_exposer.def(
"boxDimensions"
, boxDimensions_function_value );
}
{ //::SireMM::CLJBoxes::boxDimensionsAt
typedef ::SireVol::AABox ( ::SireMM::CLJBoxes::*boxDimensionsAt_function_type )( int ) const;
boxDimensionsAt_function_type boxDimensionsAt_function_value( &::SireMM::CLJBoxes::boxDimensionsAt );
CLJBoxes_exposer.def(
"boxDimensionsAt"
, boxDimensionsAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireMM::CLJBoxes::boxDimensionsAt
typedef ::SireVol::AABox ( ::SireMM::CLJBoxes::*boxDimensionsAt_function_type )( ::SireMM::CLJBoxIndex const & ) const;
boxDimensionsAt_function_type boxDimensionsAt_function_value( &::SireMM::CLJBoxes::boxDimensionsAt );
CLJBoxes_exposer.def(
"boxDimensionsAt"
, boxDimensionsAt_function_value
, ( bp::arg("index") ) );
}
{ //::SireMM::CLJBoxes::boxDimensionsAt
typedef ::SireVol::AABox ( ::SireMM::CLJBoxes::*boxDimensionsAt_function_type )( ::SireMaths::Vector const & ) const;
boxDimensionsAt_function_type boxDimensionsAt_function_value( &::SireMM::CLJBoxes::boxDimensionsAt );
CLJBoxes_exposer.def(
"boxDimensionsAt"
, boxDimensionsAt_function_value
, ( bp::arg("coords") ) );
}
{ //::SireMM::CLJBoxes::boxes
typedef ::QVector< SireMM::CLJBox > ( ::SireMM::CLJBoxes::*boxes_function_type )( ) const;
boxes_function_type boxes_function_value( &::SireMM::CLJBoxes::boxes );
CLJBoxes_exposer.def(
"boxes"
, boxes_function_value );
}
{ //::SireMM::CLJBoxes::get
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJBoxes::*get_function_type )( ::QVector< SireMM::CLJBoxIndex > const & ) const;
get_function_type get_function_value( &::SireMM::CLJBoxes::get );
CLJBoxes_exposer.def(
"get"
, get_function_value
, ( bp::arg("atoms") ) );
}
{ //::SireMM::CLJBoxes::getDistance
typedef float ( ::SireMM::CLJBoxes::*getDistance_function_type )( ::SireMM::CLJBoxIndex const &,::SireMM::CLJBoxIndex const & ) const;
getDistance_function_type getDistance_function_value( &::SireMM::CLJBoxes::getDistance );
CLJBoxes_exposer.def(
"getDistance"
, getDistance_function_value
, ( bp::arg("box0"), bp::arg("box1") ) );
}
{ //::SireMM::CLJBoxes::getDistance
typedef float ( ::SireMM::CLJBoxes::*getDistance_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxIndex const &,::SireMM::CLJBoxIndex const & ) const;
getDistance_function_type getDistance_function_value( &::SireMM::CLJBoxes::getDistance );
CLJBoxes_exposer.def(
"getDistance"
, getDistance_function_value
, ( bp::arg("space"), bp::arg("box0"), bp::arg("box1") ) );
}
{ //::SireMM::CLJBoxes::getDistance
typedef float ( ::SireMM::CLJBoxes::*getDistance_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxIndex const &,::SireMM::CLJBoxIndex const &,::quint32,::quint32,::quint32 ) const;
getDistance_function_type getDistance_function_value( &::SireMM::CLJBoxes::getDistance );
CLJBoxes_exposer.def(
"getDistance"
, getDistance_function_value
, ( bp::arg("space"), bp::arg("box0"), bp::arg("box1"), bp::arg("nx"), bp::arg("ny"), bp::arg("nz") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxes const & );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("boxes") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxes const &,::SireUnits::Dimension::Length );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("boxes"), bp::arg("cutoff") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxes const &,::SireMM::CLJBoxes const & );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("boxes0"), bp::arg("boxes1") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxes const &,::SireMM::CLJBoxes const &,::SireUnits::Dimension::Length );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("boxes0"), bp::arg("boxes1"), bp::arg("cutoff") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJAtoms const &,::SireMM::CLJBoxes const & );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("atoms0"), bp::arg("boxes1") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJAtoms const &,::SireMM::CLJBoxes const &,::SireUnits::Dimension::Length );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("atoms0"), bp::arg("boxes1"), bp::arg("cutoff") ) );
}
{ //::SireMM::CLJBoxes::getitem
typedef ::SireMM::CLJAtom ( ::SireMM::CLJBoxes::*getitem_function_type )( ::SireMM::CLJBoxIndex const & ) const;
getitem_function_type getitem_function_value( &::SireMM::CLJBoxes::getitem );
CLJBoxes_exposer.def(
"getitem"
, getitem_function_value
, ( bp::arg("idx") ) );
}
{ //::SireMM::CLJBoxes::isEmpty
typedef bool ( ::SireMM::CLJBoxes::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMM::CLJBoxes::isEmpty );
CLJBoxes_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireMM::CLJBoxes::length
typedef ::SireUnits::Dimension::Length ( ::SireMM::CLJBoxes::*length_function_type )( ) const;
length_function_type length_function_value( &::SireMM::CLJBoxes::length );
CLJBoxes_exposer.def(
"length"
, length_function_value );
}
{ //::SireMM::CLJBoxes::nAtoms
typedef int ( ::SireMM::CLJBoxes::*nAtoms_function_type )( ) const;
nAtoms_function_type nAtoms_function_value( &::SireMM::CLJBoxes::nAtoms );
CLJBoxes_exposer.def(
"nAtoms"
, nAtoms_function_value );
}
{ //::SireMM::CLJBoxes::nOccupiedBoxes
typedef int ( ::SireMM::CLJBoxes::*nOccupiedBoxes_function_type )( ) const;
nOccupiedBoxes_function_type nOccupiedBoxes_function_value( &::SireMM::CLJBoxes::nOccupiedBoxes );
CLJBoxes_exposer.def(
"nOccupiedBoxes"
, nOccupiedBoxes_function_value );
}
{ //::SireMM::CLJBoxes::occupiedBoxIndicies
typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJBoxes::*occupiedBoxIndicies_function_type )( ) const;
occupiedBoxIndicies_function_type occupiedBoxIndicies_function_value( &::SireMM::CLJBoxes::occupiedBoxIndicies );
CLJBoxes_exposer.def(
"occupiedBoxIndicies"
, occupiedBoxIndicies_function_value );
}
{ //::SireMM::CLJBoxes::occupiedBoxes
typedef ::QVector< SireMM::CLJBoxPtr > const & ( ::SireMM::CLJBoxes::*occupiedBoxes_function_type )( ) const;
occupiedBoxes_function_type occupiedBoxes_function_value( &::SireMM::CLJBoxes::occupiedBoxes );
CLJBoxes_exposer.def(
"occupiedBoxes"
, occupiedBoxes_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
CLJBoxes_exposer.def( bp::self != bp::self );
CLJBoxes_exposer.def( bp::self + bp::self );
{ //::SireMM::CLJBoxes::operator=
typedef ::SireMM::CLJBoxes & ( ::SireMM::CLJBoxes::*assign_function_type )( ::SireMM::CLJBoxes const & ) ;
assign_function_type assign_function_value( &::SireMM::CLJBoxes::operator= );
CLJBoxes_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
CLJBoxes_exposer.def( bp::self == bp::self );
{ //::SireMM::CLJBoxes::operator[]
typedef ::SireMM::CLJAtom ( ::SireMM::CLJBoxes::*__getitem___function_type )( ::SireMM::CLJBoxIndex const & ) const;
__getitem___function_type __getitem___function_value( &::SireMM::CLJBoxes::operator[] );
CLJBoxes_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("idx") ) );
}
{ //::SireMM::CLJBoxes::remove
typedef void ( ::SireMM::CLJBoxes::*remove_function_type )( ::QVector< SireMM::CLJBoxIndex > const & ) ;
remove_function_type remove_function_value( &::SireMM::CLJBoxes::remove );
CLJBoxes_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("atoms") ) );
}
{ //::SireMM::CLJBoxes::squeeze
typedef ::SireMM::CLJBoxes ( ::SireMM::CLJBoxes::*squeeze_function_type )( ) const;
squeeze_function_type squeeze_function_value( &::SireMM::CLJBoxes::squeeze );
CLJBoxes_exposer.def(
"squeeze"
, squeeze_function_value );
}
{ //::SireMM::CLJBoxes::take
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJBoxes::*take_function_type )( ::QVector< SireMM::CLJBoxIndex > const & ) ;
take_function_type take_function_value( &::SireMM::CLJBoxes::take );
CLJBoxes_exposer.def(
"take"
, take_function_value
, ( bp::arg("atoms") ) );
}
{ //::SireMM::CLJBoxes::toString
typedef ::QString ( ::SireMM::CLJBoxes::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMM::CLJBoxes::toString );
CLJBoxes_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMM::CLJBoxes::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::CLJBoxes::typeName );
CLJBoxes_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMM::CLJBoxes::what
typedef char const * ( ::SireMM::CLJBoxes::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMM::CLJBoxes::what );
CLJBoxes_exposer.def(
"what"
, what_function_value );
}
CLJBoxes_exposer.staticmethod( "getDistances" );
CLJBoxes_exposer.staticmethod( "typeName" );
CLJBoxes_exposer.def( "__copy__", &__copy__);
CLJBoxes_exposer.def( "__deepcopy__", &__copy__);
CLJBoxes_exposer.def( "clone", &__copy__);
CLJBoxes_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJBoxes >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJBoxes_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJBoxes >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJBoxes_exposer.def( "__str__", &__str__< ::SireMM::CLJBoxes > );
CLJBoxes_exposer.def( "__repr__", &__str__< ::SireMM::CLJBoxes > );
CLJBoxes_exposer.def( "__getitem__", &::SireMM::CLJBoxes::getitem );
}
}
void register_PartialMolecule_class(){
{ //::SireMol::PartialMolecule
typedef bp::class_< SireMol::PartialMolecule, bp::bases< SireMol::MoleculeView, SireBase::Property > > PartialMolecule_exposer_t;
PartialMolecule_exposer_t PartialMolecule_exposer = PartialMolecule_exposer_t( "PartialMolecule", bp::init< >() );
bp::scope PartialMolecule_scope( PartialMolecule_exposer );
PartialMolecule_exposer.def( bp::init< SireMol::MoleculeView const & >(( bp::arg("molecule") )) );
PartialMolecule_exposer.def( bp::init< SireMol::MoleculeData const &, SireMol::AtomSelection const & >(( bp::arg("moldata"), bp::arg("atoms") )) );
PartialMolecule_exposer.def( bp::init< SireMol::PartialMolecule const & >(( bp::arg("other") )) );
{ //::SireMol::PartialMolecule::evaluate
typedef ::SireMol::Evaluator ( ::SireMol::PartialMolecule::*evaluate_function_type )( ) const;
evaluate_function_type evaluate_function_value( &::SireMol::PartialMolecule::evaluate );
PartialMolecule_exposer.def(
"evaluate"
, evaluate_function_value );
}
{ //::SireMol::PartialMolecule::extract
typedef ::SireMol::PartialMolecule ( ::SireMol::PartialMolecule::*extract_function_type )( ) const;
extract_function_type extract_function_value( &::SireMol::PartialMolecule::extract );
PartialMolecule_exposer.def(
"extract"
, extract_function_value );
}
{ //::SireMol::PartialMolecule::hasMetadata
typedef bool ( ::SireMol::PartialMolecule::*hasMetadata_function_type )( ::SireBase::PropertyName const & ) const;
hasMetadata_function_type hasMetadata_function_value( &::SireMol::PartialMolecule::hasMetadata );
PartialMolecule_exposer.def(
"hasMetadata"
, hasMetadata_function_value
, ( bp::arg("metakey") ) );
}
{ //::SireMol::PartialMolecule::hasMetadata
typedef bool ( ::SireMol::PartialMolecule::*hasMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
hasMetadata_function_type hasMetadata_function_value( &::SireMol::PartialMolecule::hasMetadata );
PartialMolecule_exposer.def(
"hasMetadata"
, hasMetadata_function_value
, ( bp::arg("key"), bp::arg("metakey") ) );
}
{ //::SireMol::PartialMolecule::hasProperty
typedef bool ( ::SireMol::PartialMolecule::*hasProperty_function_type )( ::SireBase::PropertyName const & ) const;
hasProperty_function_type hasProperty_function_value( &::SireMol::PartialMolecule::hasProperty );
PartialMolecule_exposer.def(
"hasProperty"
, hasProperty_function_value
, ( bp::arg("key") ) );
}
{ //::SireMol::PartialMolecule::isEmpty
typedef bool ( ::SireMol::PartialMolecule::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMol::PartialMolecule::isEmpty );
PartialMolecule_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireMol::PartialMolecule::metadata
typedef ::SireBase::Property const & ( ::SireMol::PartialMolecule::*metadata_function_type )( ::SireBase::PropertyName const & ) const;
metadata_function_type metadata_function_value( &::SireMol::PartialMolecule::metadata );
PartialMolecule_exposer.def(
"metadata"
, metadata_function_value
, ( bp::arg("metakey") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::PartialMolecule::metadata
typedef ::SireBase::Property const & ( ::SireMol::PartialMolecule::*metadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
metadata_function_type metadata_function_value( &::SireMol::PartialMolecule::metadata );
PartialMolecule_exposer.def(
"metadata"
, metadata_function_value
, ( bp::arg("key"), bp::arg("metakey") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::PartialMolecule::metadataKeys
typedef ::QStringList ( ::SireMol::PartialMolecule::*metadataKeys_function_type )( ) const;
metadataKeys_function_type metadataKeys_function_value( &::SireMol::PartialMolecule::metadataKeys );
PartialMolecule_exposer.def(
"metadataKeys"
, metadataKeys_function_value );
}
{ //::SireMol::PartialMolecule::metadataKeys
typedef ::QStringList ( ::SireMol::PartialMolecule::*metadataKeys_function_type )( ::SireBase::PropertyName const & ) const;
metadataKeys_function_type metadataKeys_function_value( &::SireMol::PartialMolecule::metadataKeys );
PartialMolecule_exposer.def(
"metadataKeys"
, metadataKeys_function_value
, ( bp::arg("key") ) );
}
{ //::SireMol::PartialMolecule::move
typedef ::SireMol::Mover< SireMol::PartialMolecule > ( ::SireMol::PartialMolecule::*move_function_type )( ) const;
move_function_type move_function_value( &::SireMol::PartialMolecule::move );
PartialMolecule_exposer.def(
"move"
, move_function_value );
}
{ //::SireMol::PartialMolecule::nAtoms
typedef int ( ::SireMol::PartialMolecule::*nAtoms_function_type )( ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::PartialMolecule::nAtoms );
PartialMolecule_exposer.def(
"nAtoms"
, nAtoms_function_value );
}
{ //::SireMol::PartialMolecule::nChains
typedef int ( ::SireMol::PartialMolecule::*nChains_function_type )( ) const;
nChains_function_type nChains_function_value( &::SireMol::PartialMolecule::nChains );
PartialMolecule_exposer.def(
"nChains"
, nChains_function_value );
}
{ //::SireMol::PartialMolecule::nCutGroups
typedef int ( ::SireMol::PartialMolecule::*nCutGroups_function_type )( ) const;
nCutGroups_function_type nCutGroups_function_value( &::SireMol::PartialMolecule::nCutGroups );
PartialMolecule_exposer.def(
"nCutGroups"
, nCutGroups_function_value );
}
{ //::SireMol::PartialMolecule::nResidues
typedef int ( ::SireMol::PartialMolecule::*nResidues_function_type )( ) const;
nResidues_function_type nResidues_function_value( &::SireMol::PartialMolecule::nResidues );
PartialMolecule_exposer.def(
"nResidues"
, nResidues_function_value );
}
{ //::SireMol::PartialMolecule::nSegments
typedef int ( ::SireMol::PartialMolecule::*nSegments_function_type )( ) const;
nSegments_function_type nSegments_function_value( &::SireMol::PartialMolecule::nSegments );
PartialMolecule_exposer.def(
"nSegments"
, nSegments_function_value );
}
{ //::SireMol::PartialMolecule::name
typedef ::SireMol::MolName const & ( ::SireMol::PartialMolecule::*name_function_type )( ) const;
name_function_type name_function_value( &::SireMol::PartialMolecule::name );
PartialMolecule_exposer.def(
"name"
, name_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::PartialMolecule::number
typedef ::SireMol::MolNum ( ::SireMol::PartialMolecule::*number_function_type )( ) const;
number_function_type number_function_value( &::SireMol::PartialMolecule::number );
PartialMolecule_exposer.def(
"number"
, number_function_value );
}
PartialMolecule_exposer.def( bp::self != bp::self );
{ //::SireMol::PartialMolecule::operator=
typedef ::SireMol::PartialMolecule & ( ::SireMol::PartialMolecule::*assign_function_type )( ::SireMol::MoleculeView const & ) ;
assign_function_type assign_function_value( &::SireMol::PartialMolecule::operator= );
PartialMolecule_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireMol::PartialMolecule::operator=
typedef ::SireMol::PartialMolecule & ( ::SireMol::PartialMolecule::*assign_function_type )( ::SireMol::PartialMolecule const & ) ;
assign_function_type assign_function_value( &::SireMol::PartialMolecule::operator= );
PartialMolecule_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
PartialMolecule_exposer.def( bp::self == bp::self );
{ //::SireMol::PartialMolecule::property
typedef ::SireBase::Property const & ( ::SireMol::PartialMolecule::*property_function_type )( ::SireBase::PropertyName const & ) const;
property_function_type property_function_value( &::SireMol::PartialMolecule::property );
PartialMolecule_exposer.def(
"property"
, property_function_value
, ( bp::arg("key") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::PartialMolecule::propertyKeys
typedef ::QStringList ( ::SireMol::PartialMolecule::*propertyKeys_function_type )( ) const;
propertyKeys_function_type propertyKeys_function_value( &::SireMol::PartialMolecule::propertyKeys );
PartialMolecule_exposer.def(
"propertyKeys"
, propertyKeys_function_value );
}
{ //::SireMol::PartialMolecule::selectedAll
typedef bool ( ::SireMol::PartialMolecule::*selectedAll_function_type )( ) const;
selectedAll_function_type selectedAll_function_value( &::SireMol::PartialMolecule::selectedAll );
PartialMolecule_exposer.def(
"selectedAll"
, selectedAll_function_value );
}
{ //::SireMol::PartialMolecule::selection
typedef ::SireMol::AtomSelection ( ::SireMol::PartialMolecule::*selection_function_type )( ) const;
selection_function_type selection_function_value( &::SireMol::PartialMolecule::selection );
PartialMolecule_exposer.def(
"selection"
, selection_function_value );
}
{ //::SireMol::PartialMolecule::toString
typedef ::QString ( ::SireMol::PartialMolecule::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::PartialMolecule::toString );
PartialMolecule_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::PartialMolecule::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::PartialMolecule::typeName );
PartialMolecule_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::PartialMolecule::version
typedef ::quint64 ( ::SireMol::PartialMolecule::*version_function_type )( ) const;
version_function_type version_function_value( &::SireMol::PartialMolecule::version );
PartialMolecule_exposer.def(
"version"
, version_function_value );
}
{ //::SireMol::PartialMolecule::version
typedef ::quint64 ( ::SireMol::PartialMolecule::*version_function_type )( ::SireBase::PropertyName const & ) const;
version_function_type version_function_value( &::SireMol::PartialMolecule::version );
PartialMolecule_exposer.def(
"version"
, version_function_value
, ( bp::arg("key") ) );
}
PartialMolecule_exposer.staticmethod( "typeName" );
PartialMolecule_exposer.def( "__copy__", &__copy__);
PartialMolecule_exposer.def( "__deepcopy__", &__copy__);
PartialMolecule_exposer.def( "clone", &__copy__);
PartialMolecule_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::PartialMolecule >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PartialMolecule_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::PartialMolecule >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PartialMolecule_exposer.def( "__str__", &__str__< ::SireMol::PartialMolecule > );
PartialMolecule_exposer.def( "__repr__", &__str__< ::SireMol::PartialMolecule > );
}
}
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_ComponentGradients_class(){
{ //::SireAnalysis::ComponentGradients
typedef bp::class_< SireAnalysis::ComponentGradients, bp::bases< SireBase::Property > > ComponentGradients_exposer_t;
ComponentGradients_exposer_t ComponentGradients_exposer = ComponentGradients_exposer_t( "ComponentGradients", "This class is used to hold the individual free energy gradients\nfor each of the components collected by the SireSystem::FreeEnergyMonitor\nclass\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope ComponentGradients_scope( ComponentGradients_exposer );
ComponentGradients_exposer.def( bp::init< QMap< double, SireSystem::FreeEnergyMonitor > const &, bp::optional< bool > >(( bp::arg("gradients"), bp::arg("conserve_memory")=(bool)(true) ), "Construct from the passed map of component monitors") );
ComponentGradients_exposer.def( bp::init< QList< SireSystem::FreeEnergyMonitor > const &, bp::optional< bool > >(( bp::arg("gradients"), bp::arg("conserve_memory")=(bool)(true) ), "Construct from the passed list of component monitors") );
ComponentGradients_exposer.def( bp::init< SireAnalysis::ComponentGradients const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireAnalysis::ComponentGradients::conserveMemory
typedef void ( ::SireAnalysis::ComponentGradients::*conserveMemory_function_type)( ) ;
conserveMemory_function_type conserveMemory_function_value( &::SireAnalysis::ComponentGradients::conserveMemory );
ComponentGradients_exposer.def(
"conserveMemory"
, conserveMemory_function_value
, "This function reduces the memory used by this object by ensuring that\nthe FreeEnergyMonitor at each lambda value uses the copy of the\nmolecules used at the first lambda value" );
}
{ //::SireAnalysis::ComponentGradients::conserveMemory
typedef void ( ::SireAnalysis::ComponentGradients::*conserveMemory_function_type)( ::SireAnalysis::ComponentGradients const & ) ;
conserveMemory_function_type conserveMemory_function_value( &::SireAnalysis::ComponentGradients::conserveMemory );
ComponentGradients_exposer.def(
"conserveMemory"
, conserveMemory_function_value
, ( bp::arg("other") )
, "This function conserves memory by copying in all of the shared molecule\ndata etc. from other into this object" );
}
{ //::SireAnalysis::ComponentGradients::coulombGradientsAt
typedef ::SireAnalysis::Gradients ( ::SireAnalysis::ComponentGradients::*coulombGradientsAt_function_type)( int ) const;
coulombGradientsAt_function_type coulombGradientsAt_function_value( &::SireAnalysis::ComponentGradients::coulombGradientsAt );
ComponentGradients_exposer.def(
"coulombGradientsAt"
, coulombGradientsAt_function_value
, ( bp::arg("i") )
, "Return the set of coulomb free energy gradients for the ith free energy component" );
}
{ //::SireAnalysis::ComponentGradients::coulombValues
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::ComponentGradients::*coulombValues_function_type)( int ) const;
coulombValues_function_type coulombValues_function_value( &::SireAnalysis::ComponentGradients::coulombValues );
ComponentGradients_exposer.def(
"coulombValues"
, coulombValues_function_value
, ( bp::arg("i") )
, "Return the actual values of the coulomb free energy gradients of the ith component" );
}
{ //::SireAnalysis::ComponentGradients::data
typedef ::QMap< double, SireSystem::FreeEnergyMonitor > ( ::SireAnalysis::ComponentGradients::*data_function_type)( ) const;
data_function_type data_function_value( &::SireAnalysis::ComponentGradients::data );
ComponentGradients_exposer.def(
"data"
, data_function_value
, "Return the raw data for all of the free energy components" );
}
{ //::SireAnalysis::ComponentGradients::deltaLambda
typedef double ( ::SireAnalysis::ComponentGradients::*deltaLambda_function_type)( ) const;
deltaLambda_function_type deltaLambda_function_value( &::SireAnalysis::ComponentGradients::deltaLambda );
ComponentGradients_exposer.def(
"deltaLambda"
, deltaLambda_function_value
, "Return the value of delta lambda used to approximate the free energy gradients" );
}
{ //::SireAnalysis::ComponentGradients::gradientsAt
typedef ::SireAnalysis::Gradients ( ::SireAnalysis::ComponentGradients::*gradientsAt_function_type)( int ) const;
gradientsAt_function_type gradientsAt_function_value( &::SireAnalysis::ComponentGradients::gradientsAt );
ComponentGradients_exposer.def(
"gradientsAt"
, gradientsAt_function_value
, ( bp::arg("i") )
, "Return the set of free energy gradients for the ith free energy component" );
}
{ //::SireAnalysis::ComponentGradients::integrate
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrate_function_type)( int ) const;
integrate_function_type integrate_function_value( &::SireAnalysis::ComponentGradients::integrate );
ComponentGradients_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("i") )
, "Integrate the free energy gradients of the ith component\nand return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrate
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrate_function_type)( int,int ) const;
integrate_function_type integrate_function_value( &::SireAnalysis::ComponentGradients::integrate );
ComponentGradients_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("i"), bp::arg("order") )
, "Integrate the free energy gradients of the ith component to order order and\nreturn the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrate
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrate_function_type)( int,double,double ) const;
integrate_function_type integrate_function_value( &::SireAnalysis::ComponentGradients::integrate );
ComponentGradients_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max") )
, "Integrate the free energy gradients of the ith component between the range\nrange_min to range_max, and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrate
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrate_function_type)( int,double,double,int ) const;
integrate_function_type integrate_function_value( &::SireAnalysis::ComponentGradients::integrate );
ComponentGradients_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max"), bp::arg("order") )
, "Integrate the free energy gradients of the ith component to order order\nbetween the range range_min to range_max and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateCoulomb
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateCoulomb_function_type)( int ) const;
integrateCoulomb_function_type integrateCoulomb_function_value( &::SireAnalysis::ComponentGradients::integrateCoulomb );
ComponentGradients_exposer.def(
"integrateCoulomb"
, integrateCoulomb_function_value
, ( bp::arg("i") )
, "Integrate the coulomb free energy gradients of the ith component\nand return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateCoulomb
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateCoulomb_function_type)( int,int ) const;
integrateCoulomb_function_type integrateCoulomb_function_value( &::SireAnalysis::ComponentGradients::integrateCoulomb );
ComponentGradients_exposer.def(
"integrateCoulomb"
, integrateCoulomb_function_value
, ( bp::arg("i"), bp::arg("order") )
, "Integrate the coulomb free energy gradients of the ith component to order order and\nreturn the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateCoulomb
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateCoulomb_function_type)( int,double,double ) const;
integrateCoulomb_function_type integrateCoulomb_function_value( &::SireAnalysis::ComponentGradients::integrateCoulomb );
ComponentGradients_exposer.def(
"integrateCoulomb"
, integrateCoulomb_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max") )
, "Integrate the coulomb free energy gradients of the ith component between the range\nrange_min to range_max, and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateCoulomb
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateCoulomb_function_type)( int,double,double,int ) const;
integrateCoulomb_function_type integrateCoulomb_function_value( &::SireAnalysis::ComponentGradients::integrateCoulomb );
ComponentGradients_exposer.def(
"integrateCoulomb"
, integrateCoulomb_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max"), bp::arg("order") )
, "Integrate the coulomb free energy gradients of the ith component to order order\nbetween the range range_min to range_max and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateLJ
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateLJ_function_type)( int ) const;
integrateLJ_function_type integrateLJ_function_value( &::SireAnalysis::ComponentGradients::integrateLJ );
ComponentGradients_exposer.def(
"integrateLJ"
, integrateLJ_function_value
, ( bp::arg("i") )
, "Integrate the LJ free energy gradients of the ith component\nand return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateLJ
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateLJ_function_type)( int,int ) const;
integrateLJ_function_type integrateLJ_function_value( &::SireAnalysis::ComponentGradients::integrateLJ );
ComponentGradients_exposer.def(
"integrateLJ"
, integrateLJ_function_value
, ( bp::arg("i"), bp::arg("order") )
, "Integrate the LJ free energy gradients of the ith component to order order and\nreturn the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateLJ
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateLJ_function_type)( int,double,double ) const;
integrateLJ_function_type integrateLJ_function_value( &::SireAnalysis::ComponentGradients::integrateLJ );
ComponentGradients_exposer.def(
"integrateLJ"
, integrateLJ_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max") )
, "Integrate the LJ free energy gradients of the ith component between the range\nrange_min to range_max, and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateLJ
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateLJ_function_type)( int,double,double,int ) const;
integrateLJ_function_type integrateLJ_function_value( &::SireAnalysis::ComponentGradients::integrateLJ );
ComponentGradients_exposer.def(
"integrateLJ"
, integrateLJ_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max"), bp::arg("order") )
, "Integrate the LJ free energy gradients of the ith component to order order\nbetween the range range_min to range_max and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::isCompatible
typedef bool ( ::SireAnalysis::ComponentGradients::*isCompatible_function_type)( ::SireAnalysis::ComponentGradients const & ) const;
isCompatible_function_type isCompatible_function_value( &::SireAnalysis::ComponentGradients::isCompatible );
ComponentGradients_exposer.def(
"isCompatible"
, isCompatible_function_value
, ( bp::arg("other") )
, "Return whether or not this set of gradients is compatible with the ones\nprovided in other" );
}
{ //::SireAnalysis::ComponentGradients::isEmpty
typedef bool ( ::SireAnalysis::ComponentGradients::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireAnalysis::ComponentGradients::isEmpty );
ComponentGradients_exposer.def(
"isEmpty"
, isEmpty_function_value
, "Return whether or not this set is empty" );
}
{ //::SireAnalysis::ComponentGradients::lambdaValues
typedef ::QList< double > ( ::SireAnalysis::ComponentGradients::*lambdaValues_function_type)( ) const;
lambdaValues_function_type lambdaValues_function_value( &::SireAnalysis::ComponentGradients::lambdaValues );
ComponentGradients_exposer.def(
"lambdaValues"
, lambdaValues_function_value
, "Return the lambda values over which all of the components were collected" );
}
{ //::SireAnalysis::ComponentGradients::ljGradientsAt
typedef ::SireAnalysis::Gradients ( ::SireAnalysis::ComponentGradients::*ljGradientsAt_function_type)( int ) const;
ljGradientsAt_function_type ljGradientsAt_function_value( &::SireAnalysis::ComponentGradients::ljGradientsAt );
ComponentGradients_exposer.def(
"ljGradientsAt"
, ljGradientsAt_function_value
, ( bp::arg("i") )
, "Return the set of LJ free energy gradients for the ith free energy component" );
}
{ //::SireAnalysis::ComponentGradients::ljValues
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::ComponentGradients::*ljValues_function_type)( int ) const;
ljValues_function_type ljValues_function_value( &::SireAnalysis::ComponentGradients::ljValues );
ComponentGradients_exposer.def(
"ljValues"
, ljValues_function_value
, ( bp::arg("i") )
, "Return the actual values of the LJ free energy gradients of the ith component" );
}
{ //::SireAnalysis::ComponentGradients::merge
typedef ::SireAnalysis::ComponentGradients ( *merge_function_type )( ::QList< SireAnalysis::ComponentGradients > const & );
merge_function_type merge_function_value( &::SireAnalysis::ComponentGradients::merge );
ComponentGradients_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("gradients") )
, "Merge together all of the passed gradients. Note that they must all be compatible\nwith one another, otherwise an exception will be raised" );
}
{ //::SireAnalysis::ComponentGradients::nComponents
typedef int ( ::SireAnalysis::ComponentGradients::*nComponents_function_type)( ) const;
nComponents_function_type nComponents_function_value( &::SireAnalysis::ComponentGradients::nComponents );
ComponentGradients_exposer.def(
"nComponents"
, nComponents_function_value
, "Return the number of free energy components (number of molecule views whose\nfree energy of interaction was recorded)" );
}
{ //::SireAnalysis::ComponentGradients::nLambdaValues
typedef int ( ::SireAnalysis::ComponentGradients::*nLambdaValues_function_type)( ) const;
nLambdaValues_function_type nLambdaValues_function_value( &::SireAnalysis::ComponentGradients::nLambdaValues );
ComponentGradients_exposer.def(
"nLambdaValues"
, nLambdaValues_function_value
, "Return the number of lambda values over which the free energy components have\nbeen recorded" );
}
{ //::SireAnalysis::ComponentGradients::nSamples
typedef ::qint64 ( ::SireAnalysis::ComponentGradients::*nSamples_function_type)( ) const;
nSamples_function_type nSamples_function_value( &::SireAnalysis::ComponentGradients::nSamples );
ComponentGradients_exposer.def(
"nSamples"
, nSamples_function_value
, "Return the number of samples used to form all of the average components" );
}
ComponentGradients_exposer.def( bp::self != bp::self );
ComponentGradients_exposer.def( bp::self + bp::self );
{ //::SireAnalysis::ComponentGradients::operator=
typedef ::SireAnalysis::ComponentGradients & ( ::SireAnalysis::ComponentGradients::*assign_function_type)( ::SireAnalysis::ComponentGradients const & ) ;
assign_function_type assign_function_value( &::SireAnalysis::ComponentGradients::operator= );
ComponentGradients_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
ComponentGradients_exposer.def( bp::self == bp::self );
{ //::SireAnalysis::ComponentGradients::temperature
typedef ::SireUnits::Dimension::Temperature ( ::SireAnalysis::ComponentGradients::*temperature_function_type)( ) const;
temperature_function_type temperature_function_value( &::SireAnalysis::ComponentGradients::temperature );
ComponentGradients_exposer.def(
"temperature"
, temperature_function_value
, "Return the temperature at which all of the components were collected" );
}
{ //::SireAnalysis::ComponentGradients::toString
typedef ::QString ( ::SireAnalysis::ComponentGradients::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireAnalysis::ComponentGradients::toString );
ComponentGradients_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireAnalysis::ComponentGradients::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireAnalysis::ComponentGradients::typeName );
ComponentGradients_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireAnalysis::ComponentGradients::values
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::ComponentGradients::*values_function_type)( int ) const;
values_function_type values_function_value( &::SireAnalysis::ComponentGradients::values );
ComponentGradients_exposer.def(
"values"
, values_function_value
, ( bp::arg("i") )
, "Return the actual values of the free energy gradients of the ith component" );
}
{ //::SireAnalysis::ComponentGradients::viewAt
typedef ::SireMol::PartialMolecule ( ::SireAnalysis::ComponentGradients::*viewAt_function_type)( int ) const;
viewAt_function_type viewAt_function_value( &::SireAnalysis::ComponentGradients::viewAt );
ComponentGradients_exposer.def(
"viewAt"
, viewAt_function_value
, ( bp::arg("i") )
, "Return the ith view that corresponds to the ith free energy component.\nNote that this returns the view in the numerically first (lowest) lambda\nvalue. Use viewAt(int i, double lamval) if you want to specify the lambda\nvalue from which you want to extract the view." );
}
{ //::SireAnalysis::ComponentGradients::viewAt
typedef ::SireMol::PartialMolecule ( ::SireAnalysis::ComponentGradients::*viewAt_function_type)( int,double ) const;
viewAt_function_type viewAt_function_value( &::SireAnalysis::ComponentGradients::viewAt );
ComponentGradients_exposer.def(
"viewAt"
, viewAt_function_value
, ( bp::arg("i"), bp::arg("lamval") )
, "Return the ith view from lambda value lamval that corresponds to the\nith free energy component." );
}
{ //::SireAnalysis::ComponentGradients::what
typedef char const * ( ::SireAnalysis::ComponentGradients::*what_function_type)( ) const;
what_function_type what_function_value( &::SireAnalysis::ComponentGradients::what );
ComponentGradients_exposer.def(
"what"
, what_function_value
, "" );
}
ComponentGradients_exposer.staticmethod( "merge" );
ComponentGradients_exposer.staticmethod( "typeName" );
ComponentGradients_exposer.def( "__copy__", &__copy__);
ComponentGradients_exposer.def( "__deepcopy__", &__copy__);
ComponentGradients_exposer.def( "clone", &__copy__);
ComponentGradients_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::ComponentGradients >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ComponentGradients_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::ComponentGradients >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ComponentGradients_exposer.def( "__str__", &__str__< ::SireAnalysis::ComponentGradients > );
ComponentGradients_exposer.def( "__repr__", &__str__< ::SireAnalysis::ComponentGradients > );
}
}
void register_GridInfo_class(){
{ //::SireVol::GridInfo
typedef bp::class_< SireVol::GridInfo > GridInfo_exposer_t;
GridInfo_exposer_t GridInfo_exposer = GridInfo_exposer_t( "GridInfo", bp::init< >() );
bp::scope GridInfo_scope( GridInfo_exposer );
GridInfo_exposer.def( bp::init< SireVol::AABox const &, SireUnits::Dimension::Length >(( bp::arg("dimensions"), bp::arg("spacing") )) );
GridInfo_exposer.def( bp::init< SireVol::GridInfo const & >(( bp::arg("other") )) );
{ //::SireVol::GridInfo::arrayToGridIndex
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*arrayToGridIndex_function_type )( int ) const;
arrayToGridIndex_function_type arrayToGridIndex_function_value( &::SireVol::GridInfo::arrayToGridIndex );
GridInfo_exposer.def(
"arrayToGridIndex"
, arrayToGridIndex_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::at
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::at
typedef int ( ::SireVol::GridInfo::*at_function_type )( ::SireVol::GridIndex const & ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::at
typedef int ( ::SireVol::GridInfo::*at_function_type )( int,int,int ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("k") ) );
}
{ //::SireVol::GridInfo::at
typedef int ( ::SireVol::GridInfo::*at_function_type )( ::SireMaths::Vector const & ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::box
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( int ) const;
box_function_type box_function_value( &::SireVol::GridInfo::box );
GridInfo_exposer.def(
"box"
, box_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::box
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( ::SireVol::GridIndex const & ) const;
box_function_type box_function_value( &::SireVol::GridInfo::box );
GridInfo_exposer.def(
"box"
, box_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::box
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( ::SireMaths::Vector const & ) const;
box_function_type box_function_value( &::SireVol::GridInfo::box );
GridInfo_exposer.def(
"box"
, box_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::closestIndexTo
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*closestIndexTo_function_type )( ::SireMaths::Vector const & ) const;
closestIndexTo_function_type closestIndexTo_function_value( &::SireVol::GridInfo::closestIndexTo );
GridInfo_exposer.def(
"closestIndexTo"
, closestIndexTo_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::contains
typedef bool ( ::SireVol::GridInfo::*contains_function_type )( ::SireMaths::Vector const & ) const;
contains_function_type contains_function_value( &::SireVol::GridInfo::contains );
GridInfo_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::count
typedef int ( ::SireVol::GridInfo::*count_function_type )( ) const;
count_function_type count_function_value( &::SireVol::GridInfo::count );
GridInfo_exposer.def(
"count"
, count_function_value );
}
{ //::SireVol::GridInfo::dimX
typedef ::qint32 ( ::SireVol::GridInfo::*dimX_function_type )( ) const;
dimX_function_type dimX_function_value( &::SireVol::GridInfo::dimX );
GridInfo_exposer.def(
"dimX"
, dimX_function_value );
}
{ //::SireVol::GridInfo::dimY
typedef ::qint32 ( ::SireVol::GridInfo::*dimY_function_type )( ) const;
dimY_function_type dimY_function_value( &::SireVol::GridInfo::dimY );
GridInfo_exposer.def(
"dimY"
, dimY_function_value );
}
{ //::SireVol::GridInfo::dimZ
typedef ::qint32 ( ::SireVol::GridInfo::*dimZ_function_type )( ) const;
dimZ_function_type dimZ_function_value( &::SireVol::GridInfo::dimZ );
GridInfo_exposer.def(
"dimZ"
, dimZ_function_value );
}
{ //::SireVol::GridInfo::dimensions
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*dimensions_function_type )( ) const;
dimensions_function_type dimensions_function_value( &::SireVol::GridInfo::dimensions );
GridInfo_exposer.def(
"dimensions"
, dimensions_function_value );
}
{ //::SireVol::GridInfo::getitem
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*getitem_function_type )( int ) const;
getitem_function_type getitem_function_value( &::SireVol::GridInfo::getitem );
GridInfo_exposer.def(
"getitem"
, getitem_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::gridToArrayIndex
typedef int ( ::SireVol::GridInfo::*gridToArrayIndex_function_type )( int,int,int ) const;
gridToArrayIndex_function_type gridToArrayIndex_function_value( &::SireVol::GridInfo::gridToArrayIndex );
GridInfo_exposer.def(
"gridToArrayIndex"
, gridToArrayIndex_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("k") ) );
}
{ //::SireVol::GridInfo::gridToArrayIndex
typedef int ( ::SireVol::GridInfo::*gridToArrayIndex_function_type )( ::SireVol::GridIndex const & ) const;
gridToArrayIndex_function_type gridToArrayIndex_function_value( &::SireVol::GridInfo::gridToArrayIndex );
GridInfo_exposer.def(
"gridToArrayIndex"
, gridToArrayIndex_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::indexOf
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*indexOf_function_type )( int,::SireVol::GridInfo const & ) const;
indexOf_function_type indexOf_function_value( &::SireVol::GridInfo::indexOf );
GridInfo_exposer.def(
"indexOf"
, indexOf_function_value
, ( bp::arg("i"), bp::arg("grid") ) );
}
{ //::SireVol::GridInfo::indexOf
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*indexOf_function_type )( ::SireVol::GridIndex const &,::SireVol::GridInfo const & ) const;
indexOf_function_type indexOf_function_value( &::SireVol::GridInfo::indexOf );
GridInfo_exposer.def(
"indexOf"
, indexOf_function_value
, ( bp::arg("idx"), bp::arg("grid") ) );
}
{ //::SireVol::GridInfo::isEmpty
typedef bool ( ::SireVol::GridInfo::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireVol::GridInfo::isEmpty );
GridInfo_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireVol::GridInfo::nPoints
typedef int ( ::SireVol::GridInfo::*nPoints_function_type )( ) const;
nPoints_function_type nPoints_function_value( &::SireVol::GridInfo::nPoints );
GridInfo_exposer.def(
"nPoints"
, nPoints_function_value );
}
GridInfo_exposer.def( bp::self != bp::self );
{ //::SireVol::GridInfo::operator=
typedef ::SireVol::GridInfo & ( ::SireVol::GridInfo::*assign_function_type )( ::SireVol::GridInfo const & ) ;
assign_function_type assign_function_value( &::SireVol::GridInfo::operator= );
GridInfo_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
GridInfo_exposer.def( bp::self == bp::self );
{ //::SireVol::GridInfo::operator[]
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] );
GridInfo_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::operator[]
typedef int ( ::SireVol::GridInfo::*__getitem___function_type )( ::SireVol::GridIndex const & ) const;
__getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] );
GridInfo_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::operator[]
typedef int ( ::SireVol::GridInfo::*__getitem___function_type )( ::SireMaths::Vector const & ) const;
__getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] );
GridInfo_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::point
typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( int ) const;
point_function_type point_function_value( &::SireVol::GridInfo::point );
GridInfo_exposer.def(
"point"
, point_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::point
typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( ::SireVol::GridIndex const & ) const;
point_function_type point_function_value( &::SireVol::GridInfo::point );
GridInfo_exposer.def(
"point"
, point_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::point
typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( ::SireMaths::Vector const & ) const;
point_function_type point_function_value( &::SireVol::GridInfo::point );
GridInfo_exposer.def(
"point"
, point_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::pointToArrayIndex
typedef int ( ::SireVol::GridInfo::*pointToArrayIndex_function_type )( ::SireMaths::Vector const & ) const;
pointToArrayIndex_function_type pointToArrayIndex_function_value( &::SireVol::GridInfo::pointToArrayIndex );
GridInfo_exposer.def(
"pointToArrayIndex"
, pointToArrayIndex_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef void ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::Vector const &,::QVector< int > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("point"), bp::arg("indicies") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef void ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::Vector const &,::QVector< int > &,::QVector< float > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("point"), bp::arg("indicies"), bp::arg("weights") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef int ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::QVector< SireMaths::MultiInt > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("indicies") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef int ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::QVector< SireMaths::MultiInt > &,::QVector< SireMaths::MultiFloat > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("indicies"), bp::arg("weights") ) );
}
{ //::SireVol::GridInfo::pointToGridIndex
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*pointToGridIndex_function_type )( ::SireMaths::Vector const & ) const;
pointToGridIndex_function_type pointToGridIndex_function_value( &::SireVol::GridInfo::pointToGridIndex );
GridInfo_exposer.def(
"pointToGridIndex"
, pointToGridIndex_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::redimension
typedef ::QVector< float > ( ::SireVol::GridInfo::*redimension_function_type )( ::QVector< float > const &,::SireVol::GridInfo const & ) const;
redimension_function_type redimension_function_value( &::SireVol::GridInfo::redimension );
GridInfo_exposer.def(
"redimension"
, redimension_function_value
, ( bp::arg("values"), bp::arg("new_grid") ) );
}
{ //::SireVol::GridInfo::size
typedef int ( ::SireVol::GridInfo::*size_function_type )( ) const;
size_function_type size_function_value( &::SireVol::GridInfo::size );
GridInfo_exposer.def(
"size"
, size_function_value );
}
{ //::SireVol::GridInfo::spacing
typedef ::SireUnits::Dimension::Length ( ::SireVol::GridInfo::*spacing_function_type )( ) const;
spacing_function_type spacing_function_value( &::SireVol::GridInfo::spacing );
GridInfo_exposer.def(
"spacing"
, spacing_function_value );
}
{ //::SireVol::GridInfo::toString
typedef ::QString ( ::SireVol::GridInfo::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireVol::GridInfo::toString );
GridInfo_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireVol::GridInfo::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireVol::GridInfo::typeName );
GridInfo_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireVol::GridInfo::what
typedef char const * ( ::SireVol::GridInfo::*what_function_type )( ) const;
what_function_type what_function_value( &::SireVol::GridInfo::what );
GridInfo_exposer.def(
"what"
, what_function_value );
}
GridInfo_exposer.staticmethod( "typeName" );
GridInfo_exposer.def( "__copy__", &__copy__);
GridInfo_exposer.def( "__deepcopy__", &__copy__);
GridInfo_exposer.def( "clone", &__copy__);
GridInfo_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::GridInfo >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GridInfo_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::GridInfo >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GridInfo_exposer.def( "__str__", &__str__< ::SireVol::GridInfo > );
GridInfo_exposer.def( "__repr__", &__str__< ::SireVol::GridInfo > );
GridInfo_exposer.def( "__len__", &__len_size< ::SireVol::GridInfo > );
GridInfo_exposer.def( "__getitem__", &::SireVol::GridInfo::getitem );
}
}
void register_PropertyList_class(){
{ //::SireBase::PropertyList
typedef bp::class_< SireBase::PropertyList, bp::bases< SireBase::Property > > PropertyList_exposer_t;
PropertyList_exposer_t PropertyList_exposer = PropertyList_exposer_t( "PropertyList", bp::init< >() );
bp::scope PropertyList_scope( PropertyList_exposer );
PropertyList_exposer.def( bp::init< QList< SireBase::PropPtr< SireBase::Property > > const & >(( bp::arg("props") )) );
PropertyList_exposer.def( bp::init< SireBase::PropertyList const & >(( bp::arg("other") )) );
{ //::SireBase::PropertyList::append
typedef void ( ::SireBase::PropertyList::*append_function_type )( ::SireBase::Property const & ) ;
append_function_type append_function_value( &::SireBase::PropertyList::append );
PropertyList_exposer.def(
"append"
, append_function_value
, ( bp::arg("property") ) );
}
{ //::SireBase::PropertyList::append
typedef void ( ::SireBase::PropertyList::*append_function_type )( ::QList< SireBase::PropPtr< SireBase::Property > > const & ) ;
append_function_type append_function_value( &::SireBase::PropertyList::append );
PropertyList_exposer.def(
"append"
, append_function_value
, ( bp::arg("props") ) );
}
{ //::SireBase::PropertyList::array
typedef ::QList< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*array_function_type )( ) const;
array_function_type array_function_value( &::SireBase::PropertyList::array );
PropertyList_exposer.def(
"array"
, array_function_value );
}
{ //::SireBase::PropertyList::at
typedef ::SireBase::Property const & ( ::SireBase::PropertyList::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireBase::PropertyList::at );
PropertyList_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireBase::PropertyList::clear
typedef void ( ::SireBase::PropertyList::*clear_function_type )( ) ;
clear_function_type clear_function_value( &::SireBase::PropertyList::clear );
PropertyList_exposer.def(
"clear"
, clear_function_value );
}
{ //::SireBase::PropertyList::count
typedef int ( ::SireBase::PropertyList::*count_function_type )( ) const;
count_function_type count_function_value( &::SireBase::PropertyList::count );
PropertyList_exposer.def(
"count"
, count_function_value );
}
{ //::SireBase::PropertyList::empty
typedef bool ( ::SireBase::PropertyList::*empty_function_type )( ) const;
empty_function_type empty_function_value( &::SireBase::PropertyList::empty );
PropertyList_exposer.def(
"empty"
, empty_function_value );
}
{ //::SireBase::PropertyList::insert
typedef void ( ::SireBase::PropertyList::*insert_function_type )( int,::SireBase::Property const & ) ;
insert_function_type insert_function_value( &::SireBase::PropertyList::insert );
PropertyList_exposer.def(
"insert"
, insert_function_value
, ( bp::arg("i"), bp::arg("value") ) );
}
{ //::SireBase::PropertyList::isEmpty
typedef bool ( ::SireBase::PropertyList::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireBase::PropertyList::isEmpty );
PropertyList_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireBase::PropertyList::mid
typedef ::SireBase::PropertyList ( ::SireBase::PropertyList::*mid_function_type )( int,int ) const;
mid_function_type mid_function_value( &::SireBase::PropertyList::mid );
PropertyList_exposer.def(
"mid"
, mid_function_value
, ( bp::arg("pos"), bp::arg("length")=(int)(-0x00000000000000001) ) );
}
{ //::SireBase::PropertyList::move
typedef void ( ::SireBase::PropertyList::*move_function_type )( int,int ) ;
move_function_type move_function_value( &::SireBase::PropertyList::move );
PropertyList_exposer.def(
"move"
, move_function_value
, ( bp::arg("from"), bp::arg("to") ) );
}
PropertyList_exposer.def( bp::self != bp::self );
PropertyList_exposer.def( bp::self + bp::self );
{ //::SireBase::PropertyList::operator=
typedef ::SireBase::PropertyList & ( ::SireBase::PropertyList::*assign_function_type )( ::SireBase::PropertyList const & ) ;
assign_function_type assign_function_value( &::SireBase::PropertyList::operator= );
PropertyList_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
PropertyList_exposer.def( bp::self == bp::self );
{ //::SireBase::PropertyList::operator[]
typedef ::SireBase::Property const & ( ::SireBase::PropertyList::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireBase::PropertyList::operator[] );
PropertyList_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireBase::PropertyList::pop_back
typedef void ( ::SireBase::PropertyList::*pop_back_function_type )( ) ;
pop_back_function_type pop_back_function_value( &::SireBase::PropertyList::pop_back );
PropertyList_exposer.def(
"pop_back"
, pop_back_function_value );
}
{ //::SireBase::PropertyList::pop_front
typedef void ( ::SireBase::PropertyList::*pop_front_function_type )( ) ;
pop_front_function_type pop_front_function_value( &::SireBase::PropertyList::pop_front );
PropertyList_exposer.def(
"pop_front"
, pop_front_function_value );
}
{ //::SireBase::PropertyList::prepend
typedef void ( ::SireBase::PropertyList::*prepend_function_type )( ::SireBase::Property const & ) ;
prepend_function_type prepend_function_value( &::SireBase::PropertyList::prepend );
PropertyList_exposer.def(
"prepend"
, prepend_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::PropertyList::push_back
typedef void ( ::SireBase::PropertyList::*push_back_function_type )( ::SireBase::Property const & ) ;
push_back_function_type push_back_function_value( &::SireBase::PropertyList::push_back );
PropertyList_exposer.def(
"push_back"
, push_back_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::PropertyList::push_front
typedef void ( ::SireBase::PropertyList::*push_front_function_type )( ::SireBase::Property const & ) ;
push_front_function_type push_front_function_value( &::SireBase::PropertyList::push_front );
PropertyList_exposer.def(
"push_front"
, push_front_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::PropertyList::removeAt
typedef void ( ::SireBase::PropertyList::*removeAt_function_type )( int ) ;
removeAt_function_type removeAt_function_value( &::SireBase::PropertyList::removeAt );
PropertyList_exposer.def(
"removeAt"
, removeAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PropertyList::removeFirst
typedef void ( ::SireBase::PropertyList::*removeFirst_function_type )( ) ;
removeFirst_function_type removeFirst_function_value( &::SireBase::PropertyList::removeFirst );
PropertyList_exposer.def(
"removeFirst"
, removeFirst_function_value );
}
{ //::SireBase::PropertyList::removeLast
typedef void ( ::SireBase::PropertyList::*removeLast_function_type )( ) ;
removeLast_function_type removeLast_function_value( &::SireBase::PropertyList::removeLast );
PropertyList_exposer.def(
"removeLast"
, removeLast_function_value );
}
{ //::SireBase::PropertyList::replace
typedef void ( ::SireBase::PropertyList::*replace_function_type )( int,::SireBase::Property const & ) ;
replace_function_type replace_function_value( &::SireBase::PropertyList::replace );
PropertyList_exposer.def(
"replace"
, replace_function_value
, ( bp::arg("i"), bp::arg("value") ) );
}
{ //::SireBase::PropertyList::size
typedef int ( ::SireBase::PropertyList::*size_function_type )( ) const;
size_function_type size_function_value( &::SireBase::PropertyList::size );
PropertyList_exposer.def(
"size"
, size_function_value );
}
{ //::SireBase::PropertyList::swap
typedef void ( ::SireBase::PropertyList::*swap_function_type )( ::SireBase::PropertyList & ) ;
swap_function_type swap_function_value( &::SireBase::PropertyList::swap );
PropertyList_exposer.def(
"swap"
, swap_function_value
, ( bp::arg("other") ) );
}
{ //::SireBase::PropertyList::swap
typedef void ( ::SireBase::PropertyList::*swap_function_type )( int,int ) ;
swap_function_type swap_function_value( &::SireBase::PropertyList::swap );
PropertyList_exposer.def(
"swap"
, swap_function_value
, ( bp::arg("i"), bp::arg("j") ) );
}
{ //::SireBase::PropertyList::takeAt
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeAt_function_type )( int ) ;
takeAt_function_type takeAt_function_value( &::SireBase::PropertyList::takeAt );
PropertyList_exposer.def(
"takeAt"
, takeAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PropertyList::takeFirst
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeFirst_function_type )( ) ;
takeFirst_function_type takeFirst_function_value( &::SireBase::PropertyList::takeFirst );
PropertyList_exposer.def(
"takeFirst"
, takeFirst_function_value );
}
{ //::SireBase::PropertyList::takeLast
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeLast_function_type )( ) ;
takeLast_function_type takeLast_function_value( &::SireBase::PropertyList::takeLast );
PropertyList_exposer.def(
"takeLast"
, takeLast_function_value );
}
{ //::SireBase::PropertyList::toList
typedef ::QList< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*toList_function_type )( ) const;
toList_function_type toList_function_value( &::SireBase::PropertyList::toList );
PropertyList_exposer.def(
"toList"
, toList_function_value );
}
{ //::SireBase::PropertyList::toString
typedef ::QString ( ::SireBase::PropertyList::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireBase::PropertyList::toString );
PropertyList_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireBase::PropertyList::toVector
typedef ::QVector< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*toVector_function_type )( ) const;
toVector_function_type toVector_function_value( &::SireBase::PropertyList::toVector );
PropertyList_exposer.def(
"toVector"
, toVector_function_value );
}
{ //::SireBase::PropertyList::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireBase::PropertyList::typeName );
PropertyList_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireBase::PropertyList::value
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*value_function_type )( int ) const;
value_function_type value_function_value( &::SireBase::PropertyList::value );
PropertyList_exposer.def(
"value"
, value_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PropertyList::value
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*value_function_type )( int,::SireBase::Property const & ) const;
value_function_type value_function_value( &::SireBase::PropertyList::value );
PropertyList_exposer.def(
"value"
, value_function_value
, ( bp::arg("i"), bp::arg("default_value") ) );
}
PropertyList_exposer.staticmethod( "typeName" );
PropertyList_exposer.def( "__copy__", &__copy__);
PropertyList_exposer.def( "__deepcopy__", &__copy__);
PropertyList_exposer.def( "clone", &__copy__);
PropertyList_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::PropertyList >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PropertyList_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::PropertyList >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PropertyList_exposer.def( "__str__", &__str__< ::SireBase::PropertyList > );
PropertyList_exposer.def( "__repr__", &__str__< ::SireBase::PropertyList > );
PropertyList_exposer.def( "__len__", &__len_size< ::SireBase::PropertyList > );
}
}
void register_SegStringProperty_class(){
{ //::SireMol::SegProperty< QString >
typedef bp::class_< SireMol::SegProperty< QString >, bp::bases< SireMol::SegProp, SireMol::MolViewProperty, SireBase::Property > > SegStringProperty_exposer_t;
SegStringProperty_exposer_t SegStringProperty_exposer = SegStringProperty_exposer_t( "SegStringProperty", bp::init< >() );
bp::scope SegStringProperty_scope( SegStringProperty_exposer );
SegStringProperty_exposer.def( bp::init< SireMol::MoleculeInfoData const & >(( bp::arg("molinfo") )) );
SegStringProperty_exposer.def( bp::init< QVector< QString > const & >(( bp::arg("values") )) );
SegStringProperty_exposer.def( bp::init< SireMol::SegProperty< QString > const & >(( bp::arg("other") )) );
{ //::SireMol::SegProperty< QString >::array
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::QVector< QString > const & ( ::SireMol::SegProperty< QString >::*array_function_type )( ) const;
array_function_type array_function_value( &::SireMol::SegProperty< QString >::array );
SegStringProperty_exposer.def(
"array"
, array_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::SegProperty< QString >::assertCanConvert
typedef SireMol::SegProperty< QString > exported_class_t;
typedef void ( ::SireMol::SegProperty< QString >::*assertCanConvert_function_type )( ::QVariant const & ) const;
assertCanConvert_function_type assertCanConvert_function_value( &::SireMol::SegProperty< QString >::assertCanConvert );
SegStringProperty_exposer.def(
"assertCanConvert"
, assertCanConvert_function_value
, ( bp::arg("value") ) );
}
{ //::SireMol::SegProperty< QString >::assignFrom
typedef SireMol::SegProperty< QString > exported_class_t;
typedef void ( ::SireMol::SegProperty< QString >::*assignFrom_function_type )( ::SireMol::SegProperty< QVariant > const & ) ;
assignFrom_function_type assignFrom_function_value( &::SireMol::SegProperty< QString >::assignFrom );
SegStringProperty_exposer.def(
"assignFrom"
, assignFrom_function_value
, ( bp::arg("values") ) );
}
{ //::SireMol::SegProperty< QString >::at
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::QString const & ( ::SireMol::SegProperty< QString >::*at_function_type )( ::SireMol::SegIdx const & ) const;
at_function_type at_function_value( &::SireMol::SegProperty< QString >::at );
SegStringProperty_exposer.def(
"at"
, at_function_value
, ( bp::arg("segidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::SegProperty< QString >::canConvert
typedef SireMol::SegProperty< QString > exported_class_t;
typedef bool ( ::SireMol::SegProperty< QString >::*canConvert_function_type )( ::QVariant const & ) const;
canConvert_function_type canConvert_function_value( &::SireMol::SegProperty< QString >::canConvert );
SegStringProperty_exposer.def(
"canConvert"
, canConvert_function_value
, ( bp::arg("value") ) );
}
{ //::SireMol::SegProperty< QString >::count
typedef SireMol::SegProperty< QString > exported_class_t;
typedef int ( ::SireMol::SegProperty< QString >::*count_function_type )( ) const;
count_function_type count_function_value( &::SireMol::SegProperty< QString >::count );
SegStringProperty_exposer.def(
"count"
, count_function_value );
}
{ //::SireMol::SegProperty< QString >::fromVariant
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::SireMol::SegProperty< QString > ( *fromVariant_function_type )( ::SireMol::SegProperty< QVariant > const & );
fromVariant_function_type fromVariant_function_value( &::SireMol::SegProperty< QString >::fromVariant );
SegStringProperty_exposer.def(
"fromVariant"
, fromVariant_function_value
, ( bp::arg("values") ) );
}
{ //::SireMol::SegProperty< QString >::get
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::QString const & ( ::SireMol::SegProperty< QString >::*get_function_type )( ::SireMol::SegIdx const & ) const;
get_function_type get_function_value( &::SireMol::SegProperty< QString >::get );
SegStringProperty_exposer.def(
"get"
, get_function_value
, ( bp::arg("segidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::SegProperty< QString >::isCompatibleWith
typedef SireMol::SegProperty< QString > exported_class_t;
typedef bool ( ::SireMol::SegProperty< QString >::*isCompatibleWith_function_type )( ::SireMol::MoleculeInfoData const & ) const;
isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::SegProperty< QString >::isCompatibleWith );
SegStringProperty_exposer.def(
"isCompatibleWith"
, isCompatibleWith_function_value
, ( bp::arg("molinfo") ) );
}
{ //::SireMol::SegProperty< QString >::isEmpty
typedef SireMol::SegProperty< QString > exported_class_t;
typedef bool ( ::SireMol::SegProperty< QString >::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMol::SegProperty< QString >::isEmpty );
SegStringProperty_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireMol::SegProperty< QString >::nSegments
typedef SireMol::SegProperty< QString > exported_class_t;
typedef int ( ::SireMol::SegProperty< QString >::*nSegments_function_type )( ) const;
nSegments_function_type nSegments_function_value( &::SireMol::SegProperty< QString >::nSegments );
SegStringProperty_exposer.def(
"nSegments"
, nSegments_function_value );
}
SegStringProperty_exposer.def( bp::self != bp::self );
{ //::SireMol::SegProperty< QString >::operator=
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::SireMol::SegProperty< QString > & ( ::SireMol::SegProperty< QString >::*assign_function_type )( ::SireMol::SegProperty< QString > const & ) ;
assign_function_type assign_function_value( &::SireMol::SegProperty< QString >::operator= );
SegStringProperty_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
SegStringProperty_exposer.def( bp::self == bp::self );
{ //::SireMol::SegProperty< QString >::operator[]
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::QString const & ( ::SireMol::SegProperty< QString >::*__getitem___function_type )( ::SireMol::SegIdx const & ) const;
__getitem___function_type __getitem___function_value( &::SireMol::SegProperty< QString >::operator[] );
SegStringProperty_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("segidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::SegProperty< QString >::set
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::SireMol::SegProperty< QString > & ( ::SireMol::SegProperty< QString >::*set_function_type )( ::SireMol::SegIdx,::QString const & ) ;
set_function_type set_function_value( &::SireMol::SegProperty< QString >::set );
SegStringProperty_exposer.def(
"set"
, set_function_value
, ( bp::arg("segidx"), bp::arg("value") )
, bp::return_self< >() );
}
{ //::SireMol::SegProperty< QString >::size
typedef SireMol::SegProperty< QString > exported_class_t;
typedef int ( ::SireMol::SegProperty< QString >::*size_function_type )( ) const;
size_function_type size_function_value( &::SireMol::SegProperty< QString >::size );
SegStringProperty_exposer.def(
"size"
, size_function_value );
}
{ //::SireMol::SegProperty< QString >::toString
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::QString ( ::SireMol::SegProperty< QString >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::SegProperty< QString >::toString );
SegStringProperty_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::SegProperty< QString >::toVariant
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::SireMol::SegProperty< QVariant > ( ::SireMol::SegProperty< QString >::*toVariant_function_type )( ) const;
toVariant_function_type toVariant_function_value( &::SireMol::SegProperty< QString >::toVariant );
SegStringProperty_exposer.def(
"toVariant"
, toVariant_function_value );
}
{ //::SireMol::SegProperty< QString >::typeName
typedef SireMol::SegProperty< QString > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::SegProperty< QString >::typeName );
SegStringProperty_exposer.def(
"typeName"
, typeName_function_value );
}
SegStringProperty_exposer.staticmethod( "fromVariant" );
SegStringProperty_exposer.staticmethod( "typeName" );
SegStringProperty_exposer.def( "__copy__", &__copy__);
SegStringProperty_exposer.def( "__deepcopy__", &__copy__);
SegStringProperty_exposer.def( "clone", &__copy__);
SegStringProperty_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::SegProperty<QString> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
SegStringProperty_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::SegProperty<QString> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
SegStringProperty_exposer.def( "__str__", &__str__< ::SireMol::SegProperty<QString> > );
SegStringProperty_exposer.def( "__repr__", &__str__< ::SireMol::SegProperty<QString> > );
SegStringProperty_exposer.def( "__len__", &__len_size< ::SireMol::SegProperty<QString> > );
}
}
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_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_CombinedSpace_class(){
{ //::SireVol::CombinedSpace
typedef bp::class_< SireVol::CombinedSpace, bp::bases< SireVol::Space, SireBase::Property > > CombinedSpace_exposer_t;
CombinedSpace_exposer_t CombinedSpace_exposer = CombinedSpace_exposer_t( "CombinedSpace", bp::init< >() );
bp::scope CombinedSpace_scope( CombinedSpace_exposer );
CombinedSpace_exposer.def( bp::init< SireVol::Space const & >(( bp::arg("space") )) );
CombinedSpace_exposer.def( bp::init< SireVol::Space const &, SireVol::Space const & >(( bp::arg("space0"), bp::arg("space1") )) );
CombinedSpace_exposer.def( bp::init< QList< SireBase::PropPtr< SireVol::Space > > const & >(( bp::arg("spaces") )) );
CombinedSpace_exposer.def( bp::init< QVector< SireBase::PropPtr< SireVol::Space > > const & >(( bp::arg("spaces") )) );
CombinedSpace_exposer.def( bp::init< SireVol::CombinedSpace const & >(( bp::arg("other") )) );
{ //::SireVol::CombinedSpace::at
typedef ::SireVol::Space const & ( ::SireVol::CombinedSpace::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireVol::CombinedSpace::at );
CombinedSpace_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireVol::CombinedSpace::beyond
typedef bool ( ::SireVol::CombinedSpace::*beyond_function_type )( double,::SireVol::CoordGroup const &,::SireVol::CoordGroup const & ) const;
beyond_function_type beyond_function_value( &::SireVol::CombinedSpace::beyond );
CombinedSpace_exposer.def(
"beyond"
, beyond_function_value
, ( bp::arg("dist"), bp::arg("group0"), bp::arg("group1") ) );
}
{ //::SireVol::CombinedSpace::beyond
typedef bool ( ::SireVol::CombinedSpace::*beyond_function_type )( double,::SireVol::AABox const &,::SireVol::AABox const & ) const;
beyond_function_type beyond_function_value( &::SireVol::CombinedSpace::beyond );
CombinedSpace_exposer.def(
"beyond"
, beyond_function_value
, ( bp::arg("dist"), bp::arg("aabox0"), bp::arg("aabox1") ) );
}
{ //::SireVol::CombinedSpace::calcAngle
typedef ::SireUnits::Dimension::Angle ( ::SireVol::CombinedSpace::*calcAngle_function_type )( ::SireMaths::Vector const &,::SireMaths::Vector const &,::SireMaths::Vector const & ) const;
calcAngle_function_type calcAngle_function_value( &::SireVol::CombinedSpace::calcAngle );
CombinedSpace_exposer.def(
"calcAngle"
, calcAngle_function_value
, ( bp::arg("point0"), bp::arg("point1"), bp::arg("point2") ) );
}
{ //::SireVol::CombinedSpace::calcDihedral
typedef ::SireUnits::Dimension::Angle ( ::SireVol::CombinedSpace::*calcDihedral_function_type )( ::SireMaths::Vector const &,::SireMaths::Vector const &,::SireMaths::Vector const &,::SireMaths::Vector const & ) const;
calcDihedral_function_type calcDihedral_function_value( &::SireVol::CombinedSpace::calcDihedral );
CombinedSpace_exposer.def(
"calcDihedral"
, calcDihedral_function_value
, ( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3") ) );
}
{ //::SireVol::CombinedSpace::calcDist
typedef double ( ::SireVol::CombinedSpace::*calcDist_function_type )( ::SireMaths::Vector const &,::SireMaths::Vector const & ) const;
calcDist_function_type calcDist_function_value( &::SireVol::CombinedSpace::calcDist );
CombinedSpace_exposer.def(
"calcDist"
, calcDist_function_value
, ( bp::arg("point0"), bp::arg("point1") ) );
}
{ //::SireVol::CombinedSpace::calcDist
typedef double ( ::SireVol::CombinedSpace::*calcDist_function_type )( ::SireVol::CoordGroup const &,::SireVol::DistMatrix & ) const;
calcDist_function_type calcDist_function_value( &::SireVol::CombinedSpace::calcDist );
CombinedSpace_exposer.def(
"calcDist"
, calcDist_function_value
, ( bp::arg("group"), bp::arg("distmat") ) );
}
{ //::SireVol::CombinedSpace::calcDist
typedef double ( ::SireVol::CombinedSpace::*calcDist_function_type )( ::SireVol::CoordGroup const &,::SireVol::CoordGroup const &,::SireVol::DistMatrix & ) const;
calcDist_function_type calcDist_function_value( &::SireVol::CombinedSpace::calcDist );
CombinedSpace_exposer.def(
"calcDist"
, calcDist_function_value
, ( bp::arg("group1"), bp::arg("group2"), bp::arg("distmat") ) );
}
{ //::SireVol::CombinedSpace::calcDist
typedef double ( ::SireVol::CombinedSpace::*calcDist_function_type )( ::SireVol::CoordGroup const &,::SireMaths::Vector const &,::SireVol::DistMatrix & ) const;
calcDist_function_type calcDist_function_value( &::SireVol::CombinedSpace::calcDist );
CombinedSpace_exposer.def(
"calcDist"
, calcDist_function_value
, ( bp::arg("group"), bp::arg("point"), bp::arg("distmat") ) );
}
{ //::SireVol::CombinedSpace::calcDist2
typedef double ( ::SireVol::CombinedSpace::*calcDist2_function_type )( ::SireMaths::Vector const &,::SireMaths::Vector const & ) const;
calcDist2_function_type calcDist2_function_value( &::SireVol::CombinedSpace::calcDist2 );
CombinedSpace_exposer.def(
"calcDist2"
, calcDist2_function_value
, ( bp::arg("point0"), bp::arg("point1") ) );
}
{ //::SireVol::CombinedSpace::calcDist2
typedef double ( ::SireVol::CombinedSpace::*calcDist2_function_type )( ::SireVol::CoordGroup const &,::SireVol::DistMatrix & ) const;
calcDist2_function_type calcDist2_function_value( &::SireVol::CombinedSpace::calcDist2 );
CombinedSpace_exposer.def(
"calcDist2"
, calcDist2_function_value
, ( bp::arg("group"), bp::arg("distmat") ) );
}
{ //::SireVol::CombinedSpace::calcDist2
typedef double ( ::SireVol::CombinedSpace::*calcDist2_function_type )( ::SireVol::CoordGroup const &,::SireVol::CoordGroup const &,::SireVol::DistMatrix & ) const;
calcDist2_function_type calcDist2_function_value( &::SireVol::CombinedSpace::calcDist2 );
CombinedSpace_exposer.def(
"calcDist2"
, calcDist2_function_value
, ( bp::arg("group1"), bp::arg("group2"), bp::arg("distmat") ) );
}
{ //::SireVol::CombinedSpace::calcDist2
typedef double ( ::SireVol::CombinedSpace::*calcDist2_function_type )( ::SireVol::CoordGroup const &,::SireMaths::Vector const &,::SireVol::DistMatrix & ) const;
calcDist2_function_type calcDist2_function_value( &::SireVol::CombinedSpace::calcDist2 );
CombinedSpace_exposer.def(
"calcDist2"
, calcDist2_function_value
, ( bp::arg("group"), bp::arg("point"), bp::arg("distmat") ) );
}
{ //::SireVol::CombinedSpace::calcDistVector
typedef ::SireMaths::DistVector ( ::SireVol::CombinedSpace::*calcDistVector_function_type )( ::SireMaths::Vector const &,::SireMaths::Vector const & ) const;
calcDistVector_function_type calcDistVector_function_value( &::SireVol::CombinedSpace::calcDistVector );
CombinedSpace_exposer.def(
"calcDistVector"
, calcDistVector_function_value
, ( bp::arg("point0"), bp::arg("point1") ) );
}
{ //::SireVol::CombinedSpace::calcDistVectors
typedef double ( ::SireVol::CombinedSpace::*calcDistVectors_function_type )( ::SireVol::CoordGroup const &,::SireVol::DistVectorMatrix & ) const;
calcDistVectors_function_type calcDistVectors_function_value( &::SireVol::CombinedSpace::calcDistVectors );
CombinedSpace_exposer.def(
"calcDistVectors"
, calcDistVectors_function_value
, ( bp::arg("group"), bp::arg("distmat") ) );
}
{ //::SireVol::CombinedSpace::calcDistVectors
typedef double ( ::SireVol::CombinedSpace::*calcDistVectors_function_type )( ::SireVol::CoordGroup const &,::SireVol::CoordGroup const &,::SireVol::DistVectorMatrix & ) const;
calcDistVectors_function_type calcDistVectors_function_value( &::SireVol::CombinedSpace::calcDistVectors );
CombinedSpace_exposer.def(
"calcDistVectors"
, calcDistVectors_function_value
, ( bp::arg("group1"), bp::arg("group2"), bp::arg("distmat") ) );
}
{ //::SireVol::CombinedSpace::calcDistVectors
typedef double ( ::SireVol::CombinedSpace::*calcDistVectors_function_type )( ::SireVol::CoordGroup const &,::SireMaths::Vector const &,::SireVol::DistVectorMatrix & ) const;
calcDistVectors_function_type calcDistVectors_function_value( &::SireVol::CombinedSpace::calcDistVectors );
CombinedSpace_exposer.def(
"calcDistVectors"
, calcDistVectors_function_value
, ( bp::arg("group"), bp::arg("point"), bp::arg("distmat") ) );
}
{ //::SireVol::CombinedSpace::calcInvDist
typedef double ( ::SireVol::CombinedSpace::*calcInvDist_function_type )( ::SireVol::CoordGroup const &,::SireVol::DistMatrix & ) const;
calcInvDist_function_type calcInvDist_function_value( &::SireVol::CombinedSpace::calcInvDist );
CombinedSpace_exposer.def(
"calcInvDist"
, calcInvDist_function_value
, ( bp::arg("group"), bp::arg("distmat") ) );
}
{ //::SireVol::CombinedSpace::calcInvDist
typedef double ( ::SireVol::CombinedSpace::*calcInvDist_function_type )( ::SireVol::CoordGroup const &,::SireVol::CoordGroup const &,::SireVol::DistMatrix & ) const;
calcInvDist_function_type calcInvDist_function_value( &::SireVol::CombinedSpace::calcInvDist );
CombinedSpace_exposer.def(
"calcInvDist"
, calcInvDist_function_value
, ( bp::arg("group1"), bp::arg("group2"), bp::arg("distmat") ) );
}
{ //::SireVol::CombinedSpace::calcInvDist2
typedef double ( ::SireVol::CombinedSpace::*calcInvDist2_function_type )( ::SireVol::CoordGroup const &,::SireVol::DistMatrix & ) const;
calcInvDist2_function_type calcInvDist2_function_value( &::SireVol::CombinedSpace::calcInvDist2 );
CombinedSpace_exposer.def(
"calcInvDist2"
, calcInvDist2_function_value
, ( bp::arg("group"), bp::arg("distmat") ) );
}
{ //::SireVol::CombinedSpace::calcInvDist2
typedef double ( ::SireVol::CombinedSpace::*calcInvDist2_function_type )( ::SireVol::CoordGroup const &,::SireVol::CoordGroup const &,::SireVol::DistMatrix & ) const;
calcInvDist2_function_type calcInvDist2_function_value( &::SireVol::CombinedSpace::calcInvDist2 );
CombinedSpace_exposer.def(
"calcInvDist2"
, calcInvDist2_function_value
, ( bp::arg("group1"), bp::arg("group2"), bp::arg("distmat") ) );
}
{ //::SireVol::CombinedSpace::count
typedef int ( ::SireVol::CombinedSpace::*count_function_type )( ) const;
count_function_type count_function_value( &::SireVol::CombinedSpace::count );
CombinedSpace_exposer.def(
"count"
, count_function_value );
}
{ //::SireVol::CombinedSpace::getBoxCenter
typedef ::SireMaths::Vector ( ::SireVol::CombinedSpace::*getBoxCenter_function_type )( ::SireMaths::Vector const & ) const;
getBoxCenter_function_type getBoxCenter_function_value( &::SireVol::CombinedSpace::getBoxCenter );
CombinedSpace_exposer.def(
"getBoxCenter"
, getBoxCenter_function_value
, ( bp::arg("p") ) );
}
{ //::SireVol::CombinedSpace::getBoxCenter
typedef ::SireMaths::Vector ( ::SireVol::CombinedSpace::*getBoxCenter_function_type )( ::SireMaths::Vector const &,::SireMaths::Vector const & ) const;
getBoxCenter_function_type getBoxCenter_function_value( &::SireVol::CombinedSpace::getBoxCenter );
CombinedSpace_exposer.def(
"getBoxCenter"
, getBoxCenter_function_value
, ( bp::arg("p"), bp::arg("center") ) );
}
{ //::SireVol::CombinedSpace::getCopiesWithin
typedef ::QList< boost::tuples::tuple< double, SireVol::CoordGroup, 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 > > ( ::SireVol::CombinedSpace::*getCopiesWithin_function_type )( ::SireVol::CoordGroup const &,::SireVol::CoordGroup const &,double ) const;
getCopiesWithin_function_type getCopiesWithin_function_value( &::SireVol::CombinedSpace::getCopiesWithin );
CombinedSpace_exposer.def(
"getCopiesWithin"
, getCopiesWithin_function_value
, ( bp::arg("group"), bp::arg("center"), bp::arg("dist") ) );
}
{ //::SireVol::CombinedSpace::getImagesWithin
typedef ::QVector< SireMaths::Vector > ( ::SireVol::CombinedSpace::*getImagesWithin_function_type )( ::SireMaths::Vector const &,::SireMaths::Vector const &,double ) const;
getImagesWithin_function_type getImagesWithin_function_value( &::SireVol::CombinedSpace::getImagesWithin );
CombinedSpace_exposer.def(
"getImagesWithin"
, getImagesWithin_function_value
, ( bp::arg("point"), bp::arg("center"), bp::arg("dist") ) );
}
{ //::SireVol::CombinedSpace::getMinimumImage
typedef ::SireVol::CoordGroup ( ::SireVol::CombinedSpace::*getMinimumImage_function_type )( ::SireVol::CoordGroup const &,::SireMaths::Vector const & ) const;
getMinimumImage_function_type getMinimumImage_function_value( &::SireVol::CombinedSpace::getMinimumImage );
CombinedSpace_exposer.def(
"getMinimumImage"
, getMinimumImage_function_value
, ( bp::arg("group"), bp::arg("center") ) );
}
{ //::SireVol::CombinedSpace::getMinimumImage
typedef ::SireVol::CoordGroupArray ( ::SireVol::CombinedSpace::*getMinimumImage_function_type )( ::SireVol::CoordGroupArray const &,::SireMaths::Vector const &,bool ) const;
getMinimumImage_function_type getMinimumImage_function_value( &::SireVol::CombinedSpace::getMinimumImage );
CombinedSpace_exposer.def(
"getMinimumImage"
, getMinimumImage_function_value
, ( bp::arg("groups"), bp::arg("center"), bp::arg("translate_as_one")=(bool)(false) ) );
}
{ //::SireVol::CombinedSpace::getMinimumImage
typedef ::SireVol::AABox ( ::SireVol::CombinedSpace::*getMinimumImage_function_type )( ::SireVol::AABox const &,::SireMaths::Vector const & ) const;
getMinimumImage_function_type getMinimumImage_function_value( &::SireVol::CombinedSpace::getMinimumImage );
CombinedSpace_exposer.def(
"getMinimumImage"
, getMinimumImage_function_value
, ( bp::arg("aabox"), bp::arg("center") ) );
}
{ //::SireVol::CombinedSpace::getMinimumImage
typedef ::SireMaths::Vector ( ::SireVol::CombinedSpace::*getMinimumImage_function_type )( ::SireMaths::Vector const &,::SireMaths::Vector const & ) const;
getMinimumImage_function_type getMinimumImage_function_value( &::SireVol::CombinedSpace::getMinimumImage );
CombinedSpace_exposer.def(
"getMinimumImage"
, getMinimumImage_function_value
, ( bp::arg("point"), bp::arg("center") ) );
}
{ //::SireVol::CombinedSpace::getRandomPoint
typedef ::SireMaths::Vector ( ::SireVol::CombinedSpace::*getRandomPoint_function_type )( ::SireMaths::Vector const &,::SireMaths::RanGenerator const & ) const;
getRandomPoint_function_type getRandomPoint_function_value( &::SireVol::CombinedSpace::getRandomPoint );
CombinedSpace_exposer.def(
"getRandomPoint"
, getRandomPoint_function_value
, ( bp::arg("center"), bp::arg("generator") ) );
}
{ //::SireVol::CombinedSpace::isCartesian
typedef bool ( ::SireVol::CombinedSpace::*isCartesian_function_type )( ) const;
isCartesian_function_type isCartesian_function_value( &::SireVol::CombinedSpace::isCartesian );
CombinedSpace_exposer.def(
"isCartesian"
, isCartesian_function_value );
}
{ //::SireVol::CombinedSpace::isEmpty
typedef bool ( ::SireVol::CombinedSpace::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireVol::CombinedSpace::isEmpty );
CombinedSpace_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireVol::CombinedSpace::isPeriodic
typedef bool ( ::SireVol::CombinedSpace::*isPeriodic_function_type )( ) const;
isPeriodic_function_type isPeriodic_function_value( &::SireVol::CombinedSpace::isPeriodic );
CombinedSpace_exposer.def(
"isPeriodic"
, isPeriodic_function_value );
}
{ //::SireVol::CombinedSpace::minimumDistance
typedef double ( ::SireVol::CombinedSpace::*minimumDistance_function_type )( ::SireVol::AABox const &,::SireVol::AABox const & ) const;
minimumDistance_function_type minimumDistance_function_value( &::SireVol::CombinedSpace::minimumDistance );
CombinedSpace_exposer.def(
"minimumDistance"
, minimumDistance_function_value
, ( bp::arg("box0"), bp::arg("box1") ) );
}
{ //::SireVol::CombinedSpace::minimumDistance
typedef double ( ::SireVol::CombinedSpace::*minimumDistance_function_type )( ::SireVol::CoordGroup const &,::SireVol::CoordGroup const & ) const;
minimumDistance_function_type minimumDistance_function_value( &::SireVol::CombinedSpace::minimumDistance );
CombinedSpace_exposer.def(
"minimumDistance"
, minimumDistance_function_value
, ( bp::arg("group0"), bp::arg("group1") ) );
}
{ //::SireVol::CombinedSpace::minimumDistance
typedef double ( ::SireVol::CombinedSpace::*minimumDistance_function_type )( ::SireVol::CoordGroup const & ) const;
minimumDistance_function_type minimumDistance_function_value( &::SireVol::CombinedSpace::minimumDistance );
CombinedSpace_exposer.def(
"minimumDistance"
, minimumDistance_function_value
, ( bp::arg("group") ) );
}
{ //::SireVol::CombinedSpace::nSpaces
typedef int ( ::SireVol::CombinedSpace::*nSpaces_function_type )( ) const;
nSpaces_function_type nSpaces_function_value( &::SireVol::CombinedSpace::nSpaces );
CombinedSpace_exposer.def(
"nSpaces"
, nSpaces_function_value );
}
CombinedSpace_exposer.def( bp::self != bp::self );
{ //::SireVol::CombinedSpace::operator=
typedef ::SireVol::CombinedSpace & ( ::SireVol::CombinedSpace::*assign_function_type )( ::SireVol::CombinedSpace const & ) ;
assign_function_type assign_function_value( &::SireVol::CombinedSpace::operator= );
CombinedSpace_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
CombinedSpace_exposer.def( bp::self == bp::self );
{ //::SireVol::CombinedSpace::operator[]
typedef ::SireVol::Space const & ( ::SireVol::CombinedSpace::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireVol::CombinedSpace::operator[] );
CombinedSpace_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireVol::CombinedSpace::setVolume
typedef ::SireVol::SpacePtr ( ::SireVol::CombinedSpace::*setVolume_function_type )( ::SireUnits::Dimension::Volume ) const;
setVolume_function_type setVolume_function_value( &::SireVol::CombinedSpace::setVolume );
CombinedSpace_exposer.def(
"setVolume"
, setVolume_function_value
, ( bp::arg("volume") ) );
}
{ //::SireVol::CombinedSpace::size
typedef int ( ::SireVol::CombinedSpace::*size_function_type )( ) ;
size_function_type size_function_value( &::SireVol::CombinedSpace::size );
CombinedSpace_exposer.def(
"size"
, size_function_value );
}
{ //::SireVol::CombinedSpace::toString
typedef ::QString ( ::SireVol::CombinedSpace::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireVol::CombinedSpace::toString );
CombinedSpace_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireVol::CombinedSpace::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireVol::CombinedSpace::typeName );
CombinedSpace_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireVol::CombinedSpace::volume
typedef ::SireUnits::Dimension::Volume ( ::SireVol::CombinedSpace::*volume_function_type )( ) const;
volume_function_type volume_function_value( &::SireVol::CombinedSpace::volume );
CombinedSpace_exposer.def(
"volume"
, volume_function_value );
}
CombinedSpace_exposer.staticmethod( "typeName" );
CombinedSpace_exposer.def( "__copy__", &__copy__);
CombinedSpace_exposer.def( "__deepcopy__", &__copy__);
CombinedSpace_exposer.def( "clone", &__copy__);
CombinedSpace_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::CombinedSpace >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CombinedSpace_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::CombinedSpace >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CombinedSpace_exposer.def( "__str__", &__str__< ::SireVol::CombinedSpace > );
CombinedSpace_exposer.def( "__repr__", &__str__< ::SireVol::CombinedSpace > );
CombinedSpace_exposer.def( "__len__", &__len_size< ::SireVol::CombinedSpace > );
}
}
