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_FEP_class(){ { //::SireAnalysis::FEP typedef bp::class_< SireAnalysis::FEP, bp::bases< SireBase::Property > > FEP_exposer_t; FEP_exposer_t FEP_exposer = FEP_exposer_t( "FEP", "This class is used to analyse the free energies that are\ncalculated during a free energy perturbation (FEP) simulation\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") ); bp::scope FEP_scope( FEP_exposer ); FEP_exposer.def( bp::init< QList< double > const &, QMap< double, SireMaths::FreeEnergyAverage > const & >(( bp::arg("windows"), bp::arg("deltas") ), "Construct to use the passed set of windows, with the free energy deltas from\neach window to the window above") ); FEP_exposer.def( bp::init< QList< double > const &, QMap< double, SireMaths::FreeEnergyAverage > const &, QMap< double, SireMaths::FreeEnergyAverage > const & >(( bp::arg("windows"), bp::arg("forwards_deltas"), bp::arg("backwards_deltas") ), "Construct to use the passed windows, with the free energy deltas from\neach window to the window above in forwards_deltas and from the window\nbelow to each window in backwards_deltas") ); FEP_exposer.def( bp::init< SireAnalysis::FEPDeltas const & >(( bp::arg("deltas") ), "Construct to use the passed FEP deltas") ); FEP_exposer.def( bp::init< SireAnalysis::FEP const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireAnalysis::FEP::add typedef void ( ::SireAnalysis::FEP::*add_function_type)( ::QList< double > const &,::QMap< double, SireMaths::FreeEnergyAverage > const & ) ; add_function_type add_function_value( &::SireAnalysis::FEP::add ); FEP_exposer.def( "add" , add_function_value , ( bp::arg("windows"), bp::arg("deltas") ) , "Add the data for the next iteration, which contains the deltas for the passed windows,\nwith the free energy being for each window to the next window" ); } { //::SireAnalysis::FEP::add typedef void ( ::SireAnalysis::FEP::*add_function_type)( ::QList< double > const &,::QMap< double, SireMaths::FreeEnergyAverage > const &,::QMap< double, SireMaths::FreeEnergyAverage > const & ) ; add_function_type add_function_value( &::SireAnalysis::FEP::add ); FEP_exposer.def( "add" , add_function_value , ( bp::arg("windows"), bp::arg("forwards_deltas"), bp::arg("backwards_deltas") ) , "Add the data for the next iteration, which contains the deltas for the passed windows,\nwith forwards_deltas containing the free energy from each window to the next window,\nand backwards_deltas containing the free energy from the previous window to each window" ); } { //::SireAnalysis::FEP::add typedef void ( ::SireAnalysis::FEP::*add_function_type)( ::SireAnalysis::FEPDeltas const & ) ; add_function_type add_function_value( &::SireAnalysis::FEP::add ); FEP_exposer.def( "add" , add_function_value , ( bp::arg("deltas") ) , "Add the data for the next iteration" ); } { //::SireAnalysis::FEP::at typedef ::SireAnalysis::FEPDeltas ( ::SireAnalysis::FEP::*at_function_type)( int ) const; at_function_type at_function_value( &::SireAnalysis::FEP::at ); FEP_exposer.def( "at" , at_function_value , ( bp::arg("i") ) , "Return the deltas for the ith iteration" ); } { //::SireAnalysis::FEP::clear typedef void ( ::SireAnalysis::FEP::*clear_function_type)( ) ; clear_function_type clear_function_value( &::SireAnalysis::FEP::clear ); FEP_exposer.def( "clear" , clear_function_value , "Remove all values from the histogram" ); } { //::SireAnalysis::FEP::count typedef int ( ::SireAnalysis::FEP::*count_function_type)( ) const; count_function_type count_function_value( &::SireAnalysis::FEP::count ); FEP_exposer.def( "count" , count_function_value , "Return the number of iterations" ); } { //::SireAnalysis::FEP::deltas typedef ::QList< SireAnalysis::FEPDeltas > ( ::SireAnalysis::FEP::*deltas_function_type)( ) const; deltas_function_type deltas_function_value( &::SireAnalysis::FEP::deltas ); FEP_exposer.def( "deltas" , deltas_function_value , "Return the deltas for all iterations" ); } { //::SireAnalysis::FEP::lambdaValues typedef ::QList< double > ( ::SireAnalysis::FEP::*lambdaValues_function_type)( ) const; lambdaValues_function_type lambdaValues_function_value( &::SireAnalysis::FEP::lambdaValues ); FEP_exposer.def( "lambdaValues" , lambdaValues_function_value , "Return the values of all windows" ); } { //::SireAnalysis::FEP::merge typedef ::SireAnalysis::FEPDeltas ( ::SireAnalysis::FEP::*merge_function_type)( int,int ) const; merge_function_type merge_function_value( &::SireAnalysis::FEP::merge ); FEP_exposer.def( "merge" , merge_function_value , ( bp::arg("start"), bp::arg("end") ) , "Merge the deltas for iterations start->end" ); } { //::SireAnalysis::FEP::merge typedef ::SireAnalysis::FEPDeltas ( ::SireAnalysis::FEP::*merge_function_type)( ::QList< int > ) const; merge_function_type merge_function_value( &::SireAnalysis::FEP::merge ); FEP_exposer.def( "merge" , merge_function_value , ( bp::arg("indicies") ) , "Merge the deltas at the passed indicies" ); } { //::SireAnalysis::FEP::nIterations typedef int ( ::SireAnalysis::FEP::*nIterations_function_type)( ) const; nIterations_function_type nIterations_function_value( &::SireAnalysis::FEP::nIterations ); FEP_exposer.def( "nIterations" , nIterations_function_value , "Return the number of iterations" ); } { //::SireAnalysis::FEP::nLambdaValues typedef int ( ::SireAnalysis::FEP::*nLambdaValues_function_type)( ) const; nLambdaValues_function_type nLambdaValues_function_value( &::SireAnalysis::FEP::nLambdaValues ); FEP_exposer.def( "nLambdaValues" , nLambdaValues_function_value , "Return the number of lambda values (windows)" ); } { //::SireAnalysis::FEP::nSamples typedef ::qint64 ( ::SireAnalysis::FEP::*nSamples_function_type)( ) const; nSamples_function_type nSamples_function_value( &::SireAnalysis::FEP::nSamples ); FEP_exposer.def( "nSamples" , nSamples_function_value , "Return the total number of samples in the simulation" ); } { //::SireAnalysis::FEP::nWindows typedef int ( ::SireAnalysis::FEP::*nWindows_function_type)( ) const; nWindows_function_type nWindows_function_value( &::SireAnalysis::FEP::nWindows ); FEP_exposer.def( "nWindows" , nWindows_function_value , "Return the number of windows" ); } FEP_exposer.def( bp::self != bp::self ); { //::SireAnalysis::FEP::operator= typedef ::SireAnalysis::FEP & ( ::SireAnalysis::FEP::*assign_function_type)( ::SireAnalysis::FEP const & ) ; assign_function_type assign_function_value( &::SireAnalysis::FEP::operator= ); FEP_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } FEP_exposer.def( bp::self == bp::self ); { //::SireAnalysis::FEP::operator[] typedef ::SireAnalysis::FEPDeltas ( ::SireAnalysis::FEP::*__getitem___function_type)( int ) const; __getitem___function_type __getitem___function_value( &::SireAnalysis::FEP::operator[] ); FEP_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , "" ); } { //::SireAnalysis::FEP::removeAt typedef void ( ::SireAnalysis::FEP::*removeAt_function_type)( int ) ; removeAt_function_type removeAt_function_value( &::SireAnalysis::FEP::removeAt ); FEP_exposer.def( "removeAt" , removeAt_function_value , ( bp::arg("i") ) , "Remove the data for iteration i" ); } { //::SireAnalysis::FEP::removeRange typedef void ( ::SireAnalysis::FEP::*removeRange_function_type)( int,int ) ; removeRange_function_type removeRange_function_value( &::SireAnalysis::FEP::removeRange ); FEP_exposer.def( "removeRange" , removeRange_function_value , ( bp::arg("start"), bp::arg("end") ) , "Remove every iteration from start to end (inclusively)" ); } { //::SireAnalysis::FEP::rollingAverage typedef ::QList< SireAnalysis::FEPDeltas > ( ::SireAnalysis::FEP::*rollingAverage_function_type)( int ) const; rollingAverage_function_type rollingAverage_function_value( &::SireAnalysis::FEP::rollingAverage ); FEP_exposer.def( "rollingAverage" , rollingAverage_function_value , ( bp::arg("niterations") ) , "Return a list of Gradients that represents the rolling average over niterations\niterations over this TI data set. If this data set contains 100 iterations, and\nwe calculate the rolling average over 50 iterations, then the returned Gradients\nwill be the average from 1-50, then 2-51, 3-52.....51-100" ); } { //::SireAnalysis::FEP::set typedef void ( ::SireAnalysis::FEP::*set_function_type)( int,::QList< double > const &,::QMap< double, SireMaths::FreeEnergyAverage > const & ) ; set_function_type set_function_value( &::SireAnalysis::FEP::set ); FEP_exposer.def( "set" , set_function_value , ( bp::arg("i"), bp::arg("windows"), bp::arg("deltas") ) , "Set the deltas for the ith iteration" ); } { //::SireAnalysis::FEP::set typedef void ( ::SireAnalysis::FEP::*set_function_type)( int,::QList< double > const &,::QMap< double, SireMaths::FreeEnergyAverage > const &,::QMap< double, SireMaths::FreeEnergyAverage > const & ) ; set_function_type set_function_value( &::SireAnalysis::FEP::set ); FEP_exposer.def( "set" , set_function_value , ( bp::arg("i"), bp::arg("windows"), bp::arg("forwards_deltas"), bp::arg("backwards_deltas") ) , "Set the deltas for the ith iteration" ); } { //::SireAnalysis::FEP::set typedef void ( ::SireAnalysis::FEP::*set_function_type)( int,::SireAnalysis::FEPDeltas const & ) ; set_function_type set_function_value( &::SireAnalysis::FEP::set ); FEP_exposer.def( "set" , set_function_value , ( bp::arg("i"), bp::arg("deltas") ) , "Set the deltas for the ith iteration" ); } { //::SireAnalysis::FEP::size typedef int ( ::SireAnalysis::FEP::*size_function_type)( ) const; size_function_type size_function_value( &::SireAnalysis::FEP::size ); FEP_exposer.def( "size" , size_function_value , "Return the number of iterations" ); } { //::SireAnalysis::FEP::toString typedef ::QString ( ::SireAnalysis::FEP::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireAnalysis::FEP::toString ); FEP_exposer.def( "toString" , toString_function_value , "" ); } { //::SireAnalysis::FEP::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireAnalysis::FEP::typeName ); FEP_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireAnalysis::FEP::what typedef char const * ( ::SireAnalysis::FEP::*what_function_type)( ) const; what_function_type what_function_value( &::SireAnalysis::FEP::what ); FEP_exposer.def( "what" , what_function_value , "" ); } { //::SireAnalysis::FEP::windows typedef ::QList< double > ( ::SireAnalysis::FEP::*windows_function_type)( ) const; windows_function_type windows_function_value( &::SireAnalysis::FEP::windows ); FEP_exposer.def( "windows" , windows_function_value , "Return the value of all windows" ); } FEP_exposer.staticmethod( "typeName" ); FEP_exposer.def( "__copy__", &__copy__); FEP_exposer.def( "__deepcopy__", &__copy__); FEP_exposer.def( "clone", &__copy__); FEP_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::FEP >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); FEP_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::FEP >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); FEP_exposer.def( "__str__", &__str__< ::SireAnalysis::FEP > ); FEP_exposer.def( "__repr__", &__str__< ::SireAnalysis::FEP > ); FEP_exposer.def( "__len__", &__len_size< ::SireAnalysis::FEP > ); } }
void register_TestFF_class(){ { //::SireMM::TestFF typedef bp::class_< SireMM::TestFF > TestFF_exposer_t; TestFF_exposer_t TestFF_exposer = TestFF_exposer_t( "TestFF", bp::init< >() ); bp::scope TestFF_scope( TestFF_exposer ); TestFF_exposer.def( bp::init< SireMM::TestFF const & >(( bp::arg("other") )) ); { //::SireMM::TestFF::add typedef void ( ::SireMM::TestFF::*add_function_type )( ::SireMol::Molecules const & ) ; add_function_type add_function_value( &::SireMM::TestFF::add ); TestFF_exposer.def( "add" , add_function_value , ( bp::arg("molecules") ) ); } { //::SireMM::TestFF::addFixedAtoms typedef void ( ::SireMM::TestFF::*addFixedAtoms_function_type )( ::SireMol::Molecules const & ) ; addFixedAtoms_function_type addFixedAtoms_function_value( &::SireMM::TestFF::addFixedAtoms ); TestFF_exposer.def( "addFixedAtoms" , addFixedAtoms_function_value , ( bp::arg("molecules") ) ); } { //::SireMM::TestFF::calculateEnergy typedef void ( ::SireMM::TestFF::*calculateEnergy_function_type )( ) ; calculateEnergy_function_type calculateEnergy_function_value( &::SireMM::TestFF::calculateEnergy ); TestFF_exposer.def( "calculateEnergy" , calculateEnergy_function_value ); } { //::SireMM::TestFF::operator= typedef ::SireMM::TestFF & ( ::SireMM::TestFF::*assign_function_type )( ::SireMM::TestFF const & ) ; assign_function_type assign_function_value( &::SireMM::TestFF::operator= ); TestFF_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } { //::SireMM::TestFF::setCutoff typedef void ( ::SireMM::TestFF::*setCutoff_function_type )( ::SireUnits::Dimension::Length,::SireUnits::Dimension::Length ) ; setCutoff_function_type setCutoff_function_value( &::SireMM::TestFF::setCutoff ); TestFF_exposer.def( "setCutoff" , setCutoff_function_value , ( bp::arg("coul_cutoff"), bp::arg("lj_cutoff") ) ); } TestFF_exposer.def( "__copy__", &__copy__); TestFF_exposer.def( "__deepcopy__", &__copy__); TestFF_exposer.def( "clone", &__copy__); TestFF_exposer.def( "__str__", &pvt_get_name); TestFF_exposer.def( "__repr__", &pvt_get_name); } }
void register_ComplexValues_class(){ { //::SireCAS::ComplexValues typedef bp::class_< SireCAS::ComplexValues > ComplexValues_exposer_t; ComplexValues_exposer_t ComplexValues_exposer = ComplexValues_exposer_t( "ComplexValues", "\nThis class holds a set of Symbols and their associated complex values.\nThis is used when numerically evaluating an equation using complex maths.\n\nAuthor: Christopher Woods\n", bp::init< >("Construct an empty set of values") ); bp::scope ComplexValues_scope( ComplexValues_exposer ); ComplexValues_exposer.def( bp::init< QList< SireCAS::SymbolComplex > const & >(( bp::arg("values") ), "Construct from a list of values") ); ComplexValues_exposer.def( bp::init< QHash< SireCAS::Symbol, SireMaths::Complex > const & >(( bp::arg("values") ), "Construct from a hash of values indexed by symbol") ); ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const & >(( bp::arg("symval0") ), "Construct from the passed values") ); ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1") ), "Construct from the passed values") ); ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2") ), "Construct from the passed values") ); ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3") ), "Construct from the passed values") ); ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4") ), "Construct from the passed values") ); ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5") ), "Construct from the passed values") ); ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6") ), "Construct from the passed values") ); ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6"), bp::arg("symval7") ), "Construct from the passed values") ); ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6"), bp::arg("symval7"), bp::arg("symval8") ), "Construct from the passed values") ); ComplexValues_exposer.def( bp::init< SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const &, SireCAS::SymbolComplex const & >(( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6"), bp::arg("symval7"), bp::arg("symval8"), bp::arg("symval9") ), "Construct from the passed values") ); ComplexValues_exposer.def( bp::init< SireCAS::Values const & >(( bp::arg("other") ), "Construct from Values") ); ComplexValues_exposer.def( bp::init< SireCAS::ComplexValues const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireCAS::ComplexValues::add typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const & ) ; add_function_type add_function_value( &::SireCAS::ComplexValues::add ); ComplexValues_exposer.def( "add" , add_function_value , ( bp::arg("symval0") ) , "" ); } { //::SireCAS::ComplexValues::add typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ; add_function_type add_function_value( &::SireCAS::ComplexValues::add ); ComplexValues_exposer.def( "add" , add_function_value , ( bp::arg("symval0"), bp::arg("symval1") ) , "Add the passed values" ); } { //::SireCAS::ComplexValues::add typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ; add_function_type add_function_value( &::SireCAS::ComplexValues::add ); ComplexValues_exposer.def( "add" , add_function_value , ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2") ) , "Add the passed values" ); } { //::SireCAS::ComplexValues::add typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ; add_function_type add_function_value( &::SireCAS::ComplexValues::add ); ComplexValues_exposer.def( "add" , add_function_value , ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3") ) , "Add the passed values" ); } { //::SireCAS::ComplexValues::add typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ; add_function_type add_function_value( &::SireCAS::ComplexValues::add ); ComplexValues_exposer.def( "add" , add_function_value , ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4") ) , "Add the passed values" ); } { //::SireCAS::ComplexValues::add typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ; add_function_type add_function_value( &::SireCAS::ComplexValues::add ); ComplexValues_exposer.def( "add" , add_function_value , ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5") ) , "Add the passed values" ); } { //::SireCAS::ComplexValues::add typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ; add_function_type add_function_value( &::SireCAS::ComplexValues::add ); ComplexValues_exposer.def( "add" , add_function_value , ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6") ) , "Add the passed values" ); } { //::SireCAS::ComplexValues::add typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ; add_function_type add_function_value( &::SireCAS::ComplexValues::add ); ComplexValues_exposer.def( "add" , add_function_value , ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6"), bp::arg("symval7") ) , "Add the passed values" ); } { //::SireCAS::ComplexValues::add typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ; add_function_type add_function_value( &::SireCAS::ComplexValues::add ); ComplexValues_exposer.def( "add" , add_function_value , ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6"), bp::arg("symval7"), bp::arg("symval8") ) , "Add the passed values" ); } { //::SireCAS::ComplexValues::add typedef void ( ::SireCAS::ComplexValues::*add_function_type)( ::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const &,::SireCAS::SymbolComplex const & ) ; add_function_type add_function_value( &::SireCAS::ComplexValues::add ); ComplexValues_exposer.def( "add" , add_function_value , ( bp::arg("symval0"), bp::arg("symval1"), bp::arg("symval2"), bp::arg("symval3"), bp::arg("symval4"), bp::arg("symval5"), bp::arg("symval6"), bp::arg("symval7"), bp::arg("symval8"), bp::arg("symval9") ) , "Add the passed values" ); } { //::SireCAS::ComplexValues::set typedef void ( ::SireCAS::ComplexValues::*set_function_type)( ::SireCAS::Symbol const &,::SireMaths::Complex const & ) ; set_function_type set_function_value( &::SireCAS::ComplexValues::set ); ComplexValues_exposer.def( "set" , set_function_value , ( bp::arg("symbol"), bp::arg("value") ) , "" ); } { //::SireCAS::ComplexValues::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireCAS::ComplexValues::typeName ); ComplexValues_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireCAS::ComplexValues::value typedef ::SireMaths::Complex ( ::SireCAS::ComplexValues::*value_function_type)( ::SireCAS::Symbol const & ) const; value_function_type value_function_value( &::SireCAS::ComplexValues::value ); ComplexValues_exposer.def( "value" , value_function_value , ( bp::arg("sym") ) , "Return the value of the Symbol with ID id, or 0.0 if there is no such symbol" ); } { //::SireCAS::ComplexValues::values typedef ::QHash< unsigned int, SireMaths::Complex > const & ( ::SireCAS::ComplexValues::*values_function_type)( ) const; values_function_type values_function_value( &::SireCAS::ComplexValues::values ); ComplexValues_exposer.def( "values" , values_function_value , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireCAS::ComplexValues::what typedef char const * ( ::SireCAS::ComplexValues::*what_function_type)( ) const; what_function_type what_function_value( &::SireCAS::ComplexValues::what ); ComplexValues_exposer.def( "what" , what_function_value , "" ); } ComplexValues_exposer.staticmethod( "typeName" ); ComplexValues_exposer.def( "__copy__", &__copy__); ComplexValues_exposer.def( "__deepcopy__", &__copy__); ComplexValues_exposer.def( "clone", &__copy__); ComplexValues_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::ComplexValues >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ComplexValues_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::ComplexValues >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ComplexValues_exposer.def( "__str__", &pvt_get_name); ComplexValues_exposer.def( "__repr__", &pvt_get_name); } }
void register_GridPotentialTable_class(){ { //::SireFF::GridPotentialTable typedef bp::class_< SireFF::GridPotentialTable > GridPotentialTable_exposer_t; GridPotentialTable_exposer_t GridPotentialTable_exposer = GridPotentialTable_exposer_t( "GridPotentialTable", "A GridPotentialTable contains the potentials at point specified by a grid", bp::init< >("Null constructor") ); bp::scope GridPotentialTable_scope( GridPotentialTable_exposer ); GridPotentialTable_exposer.def( bp::init< SireVol::Grid const & >(( bp::arg("grid") ), "Construct to hold the potential at each of the points of the passed grid") ); GridPotentialTable_exposer.def( bp::init< SireFF::GridPotentialTable const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireFF::GridPotentialTable::add typedef void ( ::SireFF::GridPotentialTable::*add_function_type)( int,::SireUnits::Dimension::MolarEnergy const & ) ; add_function_type add_function_value( &::SireFF::GridPotentialTable::add ); GridPotentialTable_exposer.def( "add" , add_function_value , ( bp::arg("ipoint"), bp::arg("potential") ) , "Add the potential potential onto the potential for the ipointth grid point\nThrow: SireError::invalid_index\n" ); } { //::SireFF::GridPotentialTable::add typedef void ( ::SireFF::GridPotentialTable::*add_function_type)( ::SireFF::GridPotentialTable const & ) ; add_function_type add_function_value( &::SireFF::GridPotentialTable::add ); GridPotentialTable_exposer.def( "add" , add_function_value , ( bp::arg("other") ) , "Add the potential in other onto that for this table - this only\nadds the potential if the two grids are identical" ); } { //::SireFF::GridPotentialTable::add typedef void ( ::SireFF::GridPotentialTable::*add_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ; add_function_type add_function_value( &::SireFF::GridPotentialTable::add ); GridPotentialTable_exposer.def( "add" , add_function_value , ( bp::arg("potential") ) , "Add the potential potential to all of the points in this table" ); } { //::SireFF::GridPotentialTable::at typedef ::SireUnits::Dimension::MolarEnergy const & ( ::SireFF::GridPotentialTable::*at_function_type)( int ) const; at_function_type at_function_value( &::SireFF::GridPotentialTable::at ); GridPotentialTable_exposer.def( "at" , at_function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() , "Return the potential value of the ith grid point\nThrow: SireError::invalid_index\n" ); } { //::SireFF::GridPotentialTable::count typedef int ( ::SireFF::GridPotentialTable::*count_function_type)( ) const; count_function_type count_function_value( &::SireFF::GridPotentialTable::count ); GridPotentialTable_exposer.def( "count" , count_function_value , "Return the number of grid points (and thus potential values)" ); } { //::SireFF::GridPotentialTable::divide typedef void ( ::SireFF::GridPotentialTable::*divide_function_type)( double ) ; divide_function_type divide_function_value( &::SireFF::GridPotentialTable::divide ); GridPotentialTable_exposer.def( "divide" , divide_function_value , ( bp::arg("value") ) , "Divide the potential at all of the points in this table by value" ); } { //::SireFF::GridPotentialTable::grid typedef ::SireVol::Grid const & ( ::SireFF::GridPotentialTable::*grid_function_type)( ) const; grid_function_type grid_function_value( &::SireFF::GridPotentialTable::grid ); GridPotentialTable_exposer.def( "grid" , grid_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the grid that contains the points at which the potential is\nevaluated - the order of points in the grid is the same as the order\nof potential values in this table" ); } { //::SireFF::GridPotentialTable::initialise typedef void ( ::SireFF::GridPotentialTable::*initialise_function_type)( ) ; initialise_function_type initialise_function_value( &::SireFF::GridPotentialTable::initialise ); GridPotentialTable_exposer.def( "initialise" , initialise_function_value , "Initialise the potential at each grid point to equal 0" ); } { //::SireFF::GridPotentialTable::multiply typedef void ( ::SireFF::GridPotentialTable::*multiply_function_type)( double ) ; multiply_function_type multiply_function_value( &::SireFF::GridPotentialTable::multiply ); GridPotentialTable_exposer.def( "multiply" , multiply_function_value , ( bp::arg("value") ) , "Multiply the potential at all of the points in this table by value" ); } { //::SireFF::GridPotentialTable::nPoints typedef int ( ::SireFF::GridPotentialTable::*nPoints_function_type)( ) const; nPoints_function_type nPoints_function_value( &::SireFF::GridPotentialTable::nPoints ); GridPotentialTable_exposer.def( "nPoints" , nPoints_function_value , "Return the number of grid points (and thus potential values)" ); } GridPotentialTable_exposer.def( bp::self != bp::self ); GridPotentialTable_exposer.def( bp::self * bp::other< double >() ); GridPotentialTable_exposer.def( bp::self + bp::self ); GridPotentialTable_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() ); GridPotentialTable_exposer.def( bp::self - bp::self ); GridPotentialTable_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() ); GridPotentialTable_exposer.def( -bp::self ); GridPotentialTable_exposer.def( bp::self / bp::other< double >() ); { //::SireFF::GridPotentialTable::operator= typedef ::SireFF::GridPotentialTable & ( ::SireFF::GridPotentialTable::*assign_function_type)( ::SireFF::GridPotentialTable const & ) ; assign_function_type assign_function_value( &::SireFF::GridPotentialTable::operator= ); GridPotentialTable_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } { //::SireFF::GridPotentialTable::operator= typedef ::SireFF::GridPotentialTable & ( ::SireFF::GridPotentialTable::*assign_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ; assign_function_type assign_function_value( &::SireFF::GridPotentialTable::operator= ); GridPotentialTable_exposer.def( "assign" , assign_function_value , ( bp::arg("potential") ) , bp::return_self< >() , "" ); } GridPotentialTable_exposer.def( bp::self == bp::self ); { //::SireFF::GridPotentialTable::operator[] typedef ::SireUnits::Dimension::MolarEnergy & ( ::SireFF::GridPotentialTable::*__getitem___function_type)( int ) ; __getitem___function_type __getitem___function_value( &::SireFF::GridPotentialTable::operator[] ); GridPotentialTable_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , bp::return_internal_reference< >() , "" ); } { //::SireFF::GridPotentialTable::operator[] typedef ::SireUnits::Dimension::MolarEnergy const & ( ::SireFF::GridPotentialTable::*__getitem___function_type)( int ) const; __getitem___function_type __getitem___function_value( &::SireFF::GridPotentialTable::operator[] ); GridPotentialTable_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireFF::GridPotentialTable::setAll typedef void ( ::SireFF::GridPotentialTable::*setAll_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ; setAll_function_type setAll_function_value( &::SireFF::GridPotentialTable::setAll ); GridPotentialTable_exposer.def( "setAll" , setAll_function_value , ( bp::arg("potential") ) , "Set the potential at all of the points in this table equal to potential" ); } { //::SireFF::GridPotentialTable::subtract typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type)( int,::SireUnits::Dimension::MolarEnergy const & ) ; subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract ); GridPotentialTable_exposer.def( "subtract" , subtract_function_value , ( bp::arg("ipoint"), bp::arg("potential") ) , "Subtract the potential potential from the potential for the ipointth grid point\nThrow: SireError::invalid_index\n" ); } { //::SireFF::GridPotentialTable::subtract typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type)( ::SireFF::GridPotentialTable const & ) ; subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract ); GridPotentialTable_exposer.def( "subtract" , subtract_function_value , ( bp::arg("other") ) , "Subtract the potential in other from that for this table - this only\nsubtracts the potential if the two grids are identical" ); } { //::SireFF::GridPotentialTable::subtract typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ; subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract ); GridPotentialTable_exposer.def( "subtract" , subtract_function_value , ( bp::arg("potential") ) , "Subtract the potential potential from all of the points in this table" ); } { //::SireFF::GridPotentialTable::toVector typedef ::QVector< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > > ( ::SireFF::GridPotentialTable::*toVector_function_type)( ) const; toVector_function_type toVector_function_value( &::SireFF::GridPotentialTable::toVector ); GridPotentialTable_exposer.def( "toVector" , toVector_function_value , "Return the array of potential values - the order is the same\nas the order of points in the grid" ); } { //::SireFF::GridPotentialTable::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireFF::GridPotentialTable::typeName ); GridPotentialTable_exposer.def( "typeName" , typeName_function_value , "" ); } GridPotentialTable_exposer.staticmethod( "typeName" ); GridPotentialTable_exposer.def( "__copy__", &__copy__); GridPotentialTable_exposer.def( "__deepcopy__", &__copy__); GridPotentialTable_exposer.def( "clone", &__copy__); GridPotentialTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::GridPotentialTable >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); GridPotentialTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::GridPotentialTable >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); GridPotentialTable_exposer.def( "__str__", &pvt_get_name); GridPotentialTable_exposer.def( "__repr__", &pvt_get_name); GridPotentialTable_exposer.def( "__len__", &__len_count< ::SireFF::GridPotentialTable > ); } }
void register_Expression_class(){ { //::SireCAS::Expression typedef bp::class_< SireCAS::Expression > Expression_exposer_t; Expression_exposer_t Expression_exposer = Expression_exposer_t( "Expression", bp::init< >() ); bp::scope Expression_scope( Expression_exposer ); Expression_exposer.def( bp::init< int >(( bp::arg("constant") )) ); Expression_exposer.def( bp::init< SireMaths::Rational const & >(( bp::arg("constant") )) ); Expression_exposer.def( bp::init< double >(( bp::arg("constant") )) ); Expression_exposer.def( bp::init< SireMaths::Complex const & >(( bp::arg("constant") )) ); Expression_exposer.def( bp::init< SireCAS::ExpressionBase const & >(( bp::arg("base") )) ); Expression_exposer.def( bp::init< SireCAS::ExBase const & >(( bp::arg("base") )) ); Expression_exposer.def( bp::init< SireCAS::Expression const & >(( bp::arg("other") )) ); { //::SireCAS::Expression::add typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireCAS::Expression const & ) const; add_function_type add_function_value( &::SireCAS::Expression::add ); Expression_exposer.def( "add" , add_function_value , ( bp::arg("ex") ) ); } { //::SireCAS::Expression::add typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( double ) const; add_function_type add_function_value( &::SireCAS::Expression::add ); Expression_exposer.def( "add" , add_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::add typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireMaths::Complex const & ) const; add_function_type add_function_value( &::SireCAS::Expression::add ); Expression_exposer.def( "add" , add_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::base typedef ::SireCAS::ExpressionBase const & ( ::SireCAS::Expression::*base_function_type )( ) const; base_function_type base_function_value( &::SireCAS::Expression::base ); Expression_exposer.def( "base" , base_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireCAS::Expression::children typedef ::SireCAS::Expressions ( ::SireCAS::Expression::*children_function_type )( ) const; children_function_type children_function_value( &::SireCAS::Expression::children ); Expression_exposer.def( "children" , children_function_value ); } { //::SireCAS::Expression::conjugate typedef ::SireCAS::Expression ( ::SireCAS::Expression::*conjugate_function_type )( ) const; conjugate_function_type conjugate_function_value( &::SireCAS::Expression::conjugate ); Expression_exposer.def( "conjugate" , conjugate_function_value ); } { //::SireCAS::Expression::cubed typedef ::SireCAS::Expression ( ::SireCAS::Expression::*cubed_function_type )( ) const; cubed_function_type cubed_function_value( &::SireCAS::Expression::cubed ); Expression_exposer.def( "cubed" , cubed_function_value ); } { //::SireCAS::Expression::diff typedef ::SireCAS::Expression ( ::SireCAS::Expression::*diff_function_type )( ::SireCAS::Symbol const &,int ) const; diff_function_type diff_function_value( &::SireCAS::Expression::diff ); Expression_exposer.def( "diff" , diff_function_value , ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) ); } { //::SireCAS::Expression::differentiate typedef ::SireCAS::Expression ( ::SireCAS::Expression::*differentiate_function_type )( ::SireCAS::Symbol const &,int ) const; differentiate_function_type differentiate_function_value( &::SireCAS::Expression::differentiate ); Expression_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) ); } { //::SireCAS::Expression::divide typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireCAS::Expression const & ) const; divide_function_type divide_function_value( &::SireCAS::Expression::divide ); Expression_exposer.def( "divide" , divide_function_value , ( bp::arg("ex") ) ); } { //::SireCAS::Expression::divide typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( double ) const; divide_function_type divide_function_value( &::SireCAS::Expression::divide ); Expression_exposer.def( "divide" , divide_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::divide typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireMaths::Complex const & ) const; divide_function_type divide_function_value( &::SireCAS::Expression::divide ); Expression_exposer.def( "divide" , divide_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::evaluate typedef double ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::Values const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate ); Expression_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::Expression::evaluate typedef ::SireMaths::Complex ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const; evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate ); Expression_exposer.def( "evaluate" , evaluate_function_value , ( bp::arg("values") ) ); } { //::SireCAS::Expression::expand typedef ::QList< SireCAS::Factor > ( ::SireCAS::Expression::*expand_function_type )( ::SireCAS::Symbol const & ) const; expand_function_type expand_function_value( &::SireCAS::Expression::expand ); Expression_exposer.def( "expand" , expand_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Expression::factor typedef double ( ::SireCAS::Expression::*factor_function_type )( ) const; factor_function_type factor_function_value( &::SireCAS::Expression::factor ); Expression_exposer.def( "factor" , factor_function_value ); } { //::SireCAS::Expression::functions typedef ::SireCAS::Functions ( ::SireCAS::Expression::*functions_function_type )( ) const; functions_function_type functions_function_value( &::SireCAS::Expression::functions ); Expression_exposer.def( "functions" , functions_function_value ); } { //::SireCAS::Expression::hash typedef ::uint ( ::SireCAS::Expression::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireCAS::Expression::hash ); Expression_exposer.def( "hash" , hash_function_value ); } { //::SireCAS::Expression::integ typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integ_function_type )( ::SireCAS::Symbol const & ) const; integ_function_type integ_function_value( &::SireCAS::Expression::integ ); Expression_exposer.def( "integ" , integ_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Expression::integrate typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integrate_function_type )( ::SireCAS::Symbol const & ) const; integrate_function_type integrate_function_value( &::SireCAS::Expression::integrate ); Expression_exposer.def( "integrate" , integrate_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Expression::invert typedef ::SireCAS::Expression ( ::SireCAS::Expression::*invert_function_type )( ) const; invert_function_type invert_function_value( &::SireCAS::Expression::invert ); Expression_exposer.def( "invert" , invert_function_value ); } { //::SireCAS::Expression::isComplex typedef bool ( ::SireCAS::Expression::*isComplex_function_type )( ) const; isComplex_function_type isComplex_function_value( &::SireCAS::Expression::isComplex ); Expression_exposer.def( "isComplex" , isComplex_function_value ); } { //::SireCAS::Expression::isCompound typedef bool ( ::SireCAS::Expression::*isCompound_function_type )( ) const; isCompound_function_type isCompound_function_value( &::SireCAS::Expression::isCompound ); Expression_exposer.def( "isCompound" , isCompound_function_value ); } { //::SireCAS::Expression::isConstant typedef bool ( ::SireCAS::Expression::*isConstant_function_type )( ) const; isConstant_function_type isConstant_function_value( &::SireCAS::Expression::isConstant ); Expression_exposer.def( "isConstant" , isConstant_function_value ); } { //::SireCAS::Expression::isFunction typedef bool ( ::SireCAS::Expression::*isFunction_function_type )( ::SireCAS::Symbol const & ) const; isFunction_function_type isFunction_function_value( &::SireCAS::Expression::isFunction ); Expression_exposer.def( "isFunction" , isFunction_function_value , ( bp::arg("symbol") ) ); } { //::SireCAS::Expression::isZero typedef bool ( ::SireCAS::Expression::*isZero_function_type )( ) const; isZero_function_type isZero_function_value( &::SireCAS::Expression::isZero ); Expression_exposer.def( "isZero" , isZero_function_value ); } { //::SireCAS::Expression::multiply typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireCAS::Expression const & ) const; multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply ); Expression_exposer.def( "multiply" , multiply_function_value , ( bp::arg("ex") ) ); } { //::SireCAS::Expression::multiply typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( double ) const; multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply ); Expression_exposer.def( "multiply" , multiply_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::multiply typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireMaths::Complex const & ) const; multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply ); Expression_exposer.def( "multiply" , multiply_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::negate typedef ::SireCAS::Expression ( ::SireCAS::Expression::*negate_function_type )( ) const; negate_function_type negate_function_value( &::SireCAS::Expression::negate ); Expression_exposer.def( "negate" , negate_function_value ); } Expression_exposer.def( bp::self != bp::self ); { //::SireCAS::Expression::operator() typedef double ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::Values const & ) const; __call___function_type __call___function_value( &::SireCAS::Expression::operator() ); Expression_exposer.def( "__call__" , __call___function_value , ( bp::arg("values") ) ); } { //::SireCAS::Expression::operator() typedef ::SireMaths::Complex ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::ComplexValues const & ) const; __call___function_type __call___function_value( &::SireCAS::Expression::operator() ); Expression_exposer.def( "__call__" , __call___function_value , ( bp::arg("values") ) ); } Expression_exposer.def( -bp::self ); { //::SireCAS::Expression::operator= typedef ::SireCAS::Expression & ( ::SireCAS::Expression::*assign_function_type )( ::SireCAS::Expression const & ) ; assign_function_type assign_function_value( &::SireCAS::Expression::operator= ); Expression_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } Expression_exposer.def( bp::self == bp::self ); { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( int ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Rational const & ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( double ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Complex const & ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::pow typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireCAS::Expression const & ) const; pow_function_type pow_function_value( &::SireCAS::Expression::pow ); Expression_exposer.def( "pow" , pow_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::root typedef ::SireCAS::Expression ( ::SireCAS::Expression::*root_function_type )( int ) const; root_function_type root_function_value( &::SireCAS::Expression::root ); Expression_exposer.def( "root" , root_function_value , ( bp::arg("n") ) ); } { //::SireCAS::Expression::series typedef ::SireCAS::Expression ( ::SireCAS::Expression::*series_function_type )( ::SireCAS::Symbol const &,int ) const; series_function_type series_function_value( &::SireCAS::Expression::series ); Expression_exposer.def( "series" , series_function_value , ( bp::arg("symbol"), bp::arg("order") ) ); } { //::SireCAS::Expression::simplify typedef ::SireCAS::Expression ( ::SireCAS::Expression::*simplify_function_type )( int ) const; simplify_function_type simplify_function_value( &::SireCAS::Expression::simplify ); Expression_exposer.def( "simplify" , simplify_function_value , ( bp::arg("options")=(int)(0) ) ); } { //::SireCAS::Expression::squared typedef ::SireCAS::Expression ( ::SireCAS::Expression::*squared_function_type )( ) const; squared_function_type squared_function_value( &::SireCAS::Expression::squared ); Expression_exposer.def( "squared" , squared_function_value ); } { //::SireCAS::Expression::substitute typedef ::SireCAS::Expression ( ::SireCAS::Expression::*substitute_function_type )( ::SireCAS::Identities const & ) const; substitute_function_type substitute_function_value( &::SireCAS::Expression::substitute ); Expression_exposer.def( "substitute" , substitute_function_value , ( bp::arg("identities") ) ); } { //::SireCAS::Expression::subtract typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireCAS::Expression const & ) const; subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract ); Expression_exposer.def( "subtract" , subtract_function_value , ( bp::arg("ex") ) ); } { //::SireCAS::Expression::subtract typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( double ) const; subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract ); Expression_exposer.def( "subtract" , subtract_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::subtract typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireMaths::Complex const & ) const; subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract ); Expression_exposer.def( "subtract" , subtract_function_value , ( bp::arg("val") ) ); } { //::SireCAS::Expression::symbols typedef ::SireCAS::Symbols ( ::SireCAS::Expression::*symbols_function_type )( ) const; symbols_function_type symbols_function_value( &::SireCAS::Expression::symbols ); Expression_exposer.def( "symbols" , symbols_function_value ); } { //::SireCAS::Expression::toString typedef ::QString ( ::SireCAS::Expression::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireCAS::Expression::toString ); Expression_exposer.def( "toString" , toString_function_value ); } { //::SireCAS::Expression::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireCAS::Expression::typeName ); Expression_exposer.def( "typeName" , typeName_function_value ); } { //::SireCAS::Expression::what typedef char const * ( ::SireCAS::Expression::*what_function_type )( ) const; what_function_type what_function_value( &::SireCAS::Expression::what ); Expression_exposer.def( "what" , what_function_value ); } Expression_exposer.staticmethod( "typeName" ); Expression_exposer.def( bp::self * bp::other< SireMaths::Complex >() ); Expression_exposer.def( bp::other< SireMaths::Complex >() * bp::self ); Expression_exposer.def( bp::self * bp::other< double >() ); Expression_exposer.def( bp::other< double >() * bp::self ); Expression_exposer.def( bp::self * bp::self ); Expression_exposer.def( bp::self * bp::other< SireCAS::ExBase >() ); Expression_exposer.def( bp::other< SireMaths::Complex >() + bp::self ); Expression_exposer.def( bp::self + bp::other< SireMaths::Complex >() ); Expression_exposer.def( bp::other< double >() + bp::self ); Expression_exposer.def( bp::self + bp::other< double >() ); Expression_exposer.def( bp::self + bp::self ); Expression_exposer.def( bp::self + bp::other< SireCAS::ExBase >() ); Expression_exposer.def( bp::other< double >() - bp::self ); Expression_exposer.def( bp::self - bp::other< double >() ); Expression_exposer.def( bp::self - bp::self ); Expression_exposer.def( bp::self - bp::other< SireCAS::ExBase >() ); Expression_exposer.def( bp::other< SireMaths::Complex >() / bp::self ); Expression_exposer.def( bp::self / bp::other< SireMaths::Complex >() ); Expression_exposer.def( bp::other< double >() / bp::self ); Expression_exposer.def( bp::self / bp::other< double >() ); Expression_exposer.def( bp::self / bp::self ); Expression_exposer.def( bp::self / bp::other< SireCAS::ExBase >() ); Expression_exposer.def( self + self ); Expression_exposer.def( self - self ); Expression_exposer.def( self * self ); Expression_exposer.def( self / self ); Expression_exposer.def( other<double>() + self ); Expression_exposer.def( other<double>() - self ); Expression_exposer.def( other<double>() * self ); Expression_exposer.def( other<double>() / self ); Expression_exposer.def( self + other<double>() ); Expression_exposer.def( self - other<double>() ); Expression_exposer.def( self * other<double>() ); Expression_exposer.def( self / other<double>() ); Expression_exposer.def( other<SireMaths::Complex>() + self ); Expression_exposer.def( other<SireMaths::Complex>() - self ); Expression_exposer.def( other<SireMaths::Complex>() * self ); Expression_exposer.def( other<SireMaths::Complex>() / self ); Expression_exposer.def( self + other<SireMaths::Complex>() ); Expression_exposer.def( self - other<SireMaths::Complex>() ); Expression_exposer.def( self * other<SireMaths::Complex>() ); Expression_exposer.def( self / other<SireMaths::Complex>() ); Expression_exposer.def( other<SireCAS::ExBase>() + self ); Expression_exposer.def( other<SireCAS::ExBase>() - self ); Expression_exposer.def( other<SireCAS::ExBase>() * self ); Expression_exposer.def( other<SireCAS::ExBase>() / self ); Expression_exposer.def( self + other<SireCAS::ExBase>() ); Expression_exposer.def( self - other<SireCAS::ExBase>() ); Expression_exposer.def( self * other<SireCAS::ExBase>() ); Expression_exposer.def( self / other<SireCAS::ExBase>() ); Expression_exposer.def( "__copy__", &__copy__); Expression_exposer.def( "__deepcopy__", &__copy__); Expression_exposer.def( "clone", &__copy__); Expression_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Expression >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Expression_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Expression >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Expression_exposer.def( "__str__", &__str__< ::SireCAS::Expression > ); Expression_exposer.def( "__repr__", &__str__< ::SireCAS::Expression > ); } }
void register_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_CLJ14Group_class(){ { //::SireMM::CLJ14Group typedef bp::class_< SireMM::CLJ14Group > CLJ14Group_exposer_t; CLJ14Group_exposer_t CLJ14Group_exposer = CLJ14Group_exposer_t( "CLJ14Group", bp::init< >() ); bp::scope CLJ14Group_scope( CLJ14Group_exposer ); CLJ14Group_exposer.def( bp::init< SireMol::MoleculeView const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("molecule"), bp::arg("map")=SireBase::PropertyMap() )) ); CLJ14Group_exposer.def( bp::init< SireMol::MoleculeView const &, SireMM::CLJFunction::COMBINING_RULES, bool, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("molecule"), bp::arg("combining_rules"), bp::arg("is_strict"), bp::arg("map")=SireBase::PropertyMap() )) ); CLJ14Group_exposer.def( bp::init< SireMM::CLJ14Group const & >(( bp::arg("other") )) ); { //::SireMM::CLJ14Group::add typedef void ( ::SireMM::CLJ14Group::*add_function_type )( ::SireMol::MoleculeView const & ) ; add_function_type add_function_value( &::SireMM::CLJ14Group::add ); CLJ14Group_exposer.def( "add" , add_function_value , ( bp::arg("new_molecule") ) ); } { //::SireMM::CLJ14Group::add typedef void ( ::SireMM::CLJ14Group::*add_function_type )( ::SireMol::AtomSelection const & ) ; add_function_type add_function_value( &::SireMM::CLJ14Group::add ); CLJ14Group_exposer.def( "add" , add_function_value , ( bp::arg("new_selection") ) ); } { //::SireMM::CLJ14Group::combiningRules typedef ::SireMM::CLJFunction::COMBINING_RULES ( ::SireMM::CLJ14Group::*combiningRules_function_type )( ) const; combiningRules_function_type combiningRules_function_value( &::SireMM::CLJ14Group::combiningRules ); CLJ14Group_exposer.def( "combiningRules" , combiningRules_function_value ); } { //::SireMM::CLJ14Group::energy typedef ::boost::tuples::tuple< double, double, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > ( ::SireMM::CLJ14Group::*energy_function_type )( ) ; energy_function_type energy_function_value( &::SireMM::CLJ14Group::energy ); CLJ14Group_exposer.def( "energy" , energy_function_value ); } { //::SireMM::CLJ14Group::isNull typedef bool ( ::SireMM::CLJ14Group::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireMM::CLJ14Group::isNull ); CLJ14Group_exposer.def( "isNull" , isNull_function_value ); } { //::SireMM::CLJ14Group::isStrict typedef bool ( ::SireMM::CLJ14Group::*isStrict_function_type )( ) const; isStrict_function_type isStrict_function_value( &::SireMM::CLJ14Group::isStrict ); CLJ14Group_exposer.def( "isStrict" , isStrict_function_value ); } { //::SireMM::CLJ14Group::molecule typedef ::SireMol::MoleculeView const & ( ::SireMM::CLJ14Group::*molecule_function_type )( ) const; molecule_function_type molecule_function_value( &::SireMM::CLJ14Group::molecule ); CLJ14Group_exposer.def( "molecule" , molecule_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::CLJ14Group::mustNowRecalculateFromScratch typedef void ( ::SireMM::CLJ14Group::*mustNowRecalculateFromScratch_function_type )( ) ; mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::SireMM::CLJ14Group::mustNowRecalculateFromScratch ); CLJ14Group_exposer.def( "mustNowRecalculateFromScratch" , mustNowRecalculateFromScratch_function_value ); } { //::SireMM::CLJ14Group::mustReallyRecalculateFromScratch typedef void ( ::SireMM::CLJ14Group::*mustReallyRecalculateFromScratch_function_type )( ) ; mustReallyRecalculateFromScratch_function_type mustReallyRecalculateFromScratch_function_value( &::SireMM::CLJ14Group::mustReallyRecalculateFromScratch ); CLJ14Group_exposer.def( "mustReallyRecalculateFromScratch" , mustReallyRecalculateFromScratch_function_value ); } CLJ14Group_exposer.def( bp::self != bp::self ); { //::SireMM::CLJ14Group::operator= typedef ::SireMM::CLJ14Group & ( ::SireMM::CLJ14Group::*assign_function_type )( ::SireMM::CLJ14Group const & ) ; assign_function_type assign_function_value( &::SireMM::CLJ14Group::operator= ); CLJ14Group_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } CLJ14Group_exposer.def( bp::self == bp::self ); { //::SireMM::CLJ14Group::propertyMap typedef ::SireBase::PropertyMap ( ::SireMM::CLJ14Group::*propertyMap_function_type )( ) const; propertyMap_function_type propertyMap_function_value( &::SireMM::CLJ14Group::propertyMap ); CLJ14Group_exposer.def( "propertyMap" , propertyMap_function_value ); } { //::SireMM::CLJ14Group::recalculatingFromScratch typedef bool ( ::SireMM::CLJ14Group::*recalculatingFromScratch_function_type )( ) const; recalculatingFromScratch_function_type recalculatingFromScratch_function_value( &::SireMM::CLJ14Group::recalculatingFromScratch ); CLJ14Group_exposer.def( "recalculatingFromScratch" , recalculatingFromScratch_function_value ); } { //::SireMM::CLJ14Group::remove typedef void ( ::SireMM::CLJ14Group::*remove_function_type )( ::SireMol::AtomSelection const & ) ; remove_function_type remove_function_value( &::SireMM::CLJ14Group::remove ); CLJ14Group_exposer.def( "remove" , remove_function_value , ( bp::arg("new_selection") ) ); } { //::SireMM::CLJ14Group::remove typedef void ( ::SireMM::CLJ14Group::*remove_function_type )( ::SireMol::MoleculeView const & ) ; remove_function_type remove_function_value( &::SireMM::CLJ14Group::remove ); CLJ14Group_exposer.def( "remove" , remove_function_value , ( bp::arg("new_molecule") ) ); } { //::SireMM::CLJ14Group::setArithmeticCombiningRules typedef void ( ::SireMM::CLJ14Group::*setArithmeticCombiningRules_function_type )( bool ) ; setArithmeticCombiningRules_function_type setArithmeticCombiningRules_function_value( &::SireMM::CLJ14Group::setArithmeticCombiningRules ); CLJ14Group_exposer.def( "setArithmeticCombiningRules" , setArithmeticCombiningRules_function_value , ( bp::arg("on") ) ); } { //::SireMM::CLJ14Group::setCombiningRules typedef void ( ::SireMM::CLJ14Group::*setCombiningRules_function_type )( ::SireMM::CLJFunction::COMBINING_RULES ) ; setCombiningRules_function_type setCombiningRules_function_value( &::SireMM::CLJ14Group::setCombiningRules ); CLJ14Group_exposer.def( "setCombiningRules" , setCombiningRules_function_value , ( bp::arg("rules") ) ); } { //::SireMM::CLJ14Group::setGeometricCombiningRules typedef void ( ::SireMM::CLJ14Group::*setGeometricCombiningRules_function_type )( bool ) ; setGeometricCombiningRules_function_type setGeometricCombiningRules_function_value( &::SireMM::CLJ14Group::setGeometricCombiningRules ); CLJ14Group_exposer.def( "setGeometricCombiningRules" , setGeometricCombiningRules_function_value , ( bp::arg("on") ) ); } { //::SireMM::CLJ14Group::setStrict typedef bool ( ::SireMM::CLJ14Group::*setStrict_function_type )( bool ) ; setStrict_function_type setStrict_function_value( &::SireMM::CLJ14Group::setStrict ); CLJ14Group_exposer.def( "setStrict" , setStrict_function_value , ( bp::arg("isstrict") ) ); } { //::SireMM::CLJ14Group::toString typedef ::QString ( ::SireMM::CLJ14Group::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMM::CLJ14Group::toString ); CLJ14Group_exposer.def( "toString" , toString_function_value ); } { //::SireMM::CLJ14Group::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::CLJ14Group::typeName ); CLJ14Group_exposer.def( "typeName" , typeName_function_value ); } { //::SireMM::CLJ14Group::update typedef void ( ::SireMM::CLJ14Group::*update_function_type )( ::SireMol::MoleculeView const & ) ; update_function_type update_function_value( &::SireMM::CLJ14Group::update ); CLJ14Group_exposer.def( "update" , update_function_value , ( bp::arg("new_molecule") ) ); } { //::SireMM::CLJ14Group::updateSelection typedef void ( ::SireMM::CLJ14Group::*updateSelection_function_type )( ::SireMol::AtomSelection const & ) ; updateSelection_function_type updateSelection_function_value( &::SireMM::CLJ14Group::updateSelection ); CLJ14Group_exposer.def( "updateSelection" , updateSelection_function_value , ( bp::arg("selection") ) ); } { //::SireMM::CLJ14Group::usingArithmeticCombiningRules typedef bool ( ::SireMM::CLJ14Group::*usingArithmeticCombiningRules_function_type )( ) const; usingArithmeticCombiningRules_function_type usingArithmeticCombiningRules_function_value( &::SireMM::CLJ14Group::usingArithmeticCombiningRules ); CLJ14Group_exposer.def( "usingArithmeticCombiningRules" , usingArithmeticCombiningRules_function_value ); } { //::SireMM::CLJ14Group::usingGeometricCombiningRules typedef bool ( ::SireMM::CLJ14Group::*usingGeometricCombiningRules_function_type )( ) const; usingGeometricCombiningRules_function_type usingGeometricCombiningRules_function_value( &::SireMM::CLJ14Group::usingGeometricCombiningRules ); CLJ14Group_exposer.def( "usingGeometricCombiningRules" , usingGeometricCombiningRules_function_value ); } { //::SireMM::CLJ14Group::what typedef char const * ( ::SireMM::CLJ14Group::*what_function_type )( ) const; what_function_type what_function_value( &::SireMM::CLJ14Group::what ); CLJ14Group_exposer.def( "what" , what_function_value ); } { //::SireMM::CLJ14Group::wouldChangeProperties typedef bool ( ::SireMM::CLJ14Group::*wouldChangeProperties_function_type )( ::SireBase::PropertyMap const & ) const; wouldChangeProperties_function_type wouldChangeProperties_function_value( &::SireMM::CLJ14Group::wouldChangeProperties ); CLJ14Group_exposer.def( "wouldChangeProperties" , wouldChangeProperties_function_value , ( bp::arg("map") ) ); } CLJ14Group_exposer.staticmethod( "typeName" ); CLJ14Group_exposer.def( "__copy__", &__copy__); CLJ14Group_exposer.def( "__deepcopy__", &__copy__); CLJ14Group_exposer.def( "clone", &__copy__); CLJ14Group_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJ14Group >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CLJ14Group_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJ14Group >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CLJ14Group_exposer.def( "__str__", &__str__< ::SireMM::CLJ14Group > ); CLJ14Group_exposer.def( "__repr__", &__str__< ::SireMM::CLJ14Group > ); } }
void register_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_GridPotentialTable_class(){ { //::SireFF::GridPotentialTable typedef bp::class_< SireFF::GridPotentialTable > GridPotentialTable_exposer_t; GridPotentialTable_exposer_t GridPotentialTable_exposer = GridPotentialTable_exposer_t( "GridPotentialTable", bp::init< >() ); bp::scope GridPotentialTable_scope( GridPotentialTable_exposer ); GridPotentialTable_exposer.def( bp::init< SireVol::Grid const & >(( bp::arg("grid") )) ); GridPotentialTable_exposer.def( bp::init< SireFF::GridPotentialTable const & >(( bp::arg("other") )) ); { //::SireFF::GridPotentialTable::add typedef void ( ::SireFF::GridPotentialTable::*add_function_type )( int,::SireUnits::Dimension::MolarEnergy const & ) ; add_function_type add_function_value( &::SireFF::GridPotentialTable::add ); GridPotentialTable_exposer.def( "add" , add_function_value , ( bp::arg("ipoint"), bp::arg("potential") ) ); } { //::SireFF::GridPotentialTable::add typedef void ( ::SireFF::GridPotentialTable::*add_function_type )( ::SireFF::GridPotentialTable const & ) ; add_function_type add_function_value( &::SireFF::GridPotentialTable::add ); GridPotentialTable_exposer.def( "add" , add_function_value , ( bp::arg("other") ) ); } { //::SireFF::GridPotentialTable::add typedef void ( ::SireFF::GridPotentialTable::*add_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ; add_function_type add_function_value( &::SireFF::GridPotentialTable::add ); GridPotentialTable_exposer.def( "add" , add_function_value , ( bp::arg("potential") ) ); } { //::SireFF::GridPotentialTable::at typedef ::SireUnits::Dimension::MolarEnergy const & ( ::SireFF::GridPotentialTable::*at_function_type )( int ) const; at_function_type at_function_value( &::SireFF::GridPotentialTable::at ); GridPotentialTable_exposer.def( "at" , at_function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireFF::GridPotentialTable::count typedef int ( ::SireFF::GridPotentialTable::*count_function_type )( ) const; count_function_type count_function_value( &::SireFF::GridPotentialTable::count ); GridPotentialTable_exposer.def( "count" , count_function_value ); } { //::SireFF::GridPotentialTable::divide typedef void ( ::SireFF::GridPotentialTable::*divide_function_type )( double ) ; divide_function_type divide_function_value( &::SireFF::GridPotentialTable::divide ); GridPotentialTable_exposer.def( "divide" , divide_function_value , ( bp::arg("value") ) ); } { //::SireFF::GridPotentialTable::grid typedef ::SireVol::Grid const & ( ::SireFF::GridPotentialTable::*grid_function_type )( ) const; grid_function_type grid_function_value( &::SireFF::GridPotentialTable::grid ); GridPotentialTable_exposer.def( "grid" , grid_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireFF::GridPotentialTable::initialise typedef void ( ::SireFF::GridPotentialTable::*initialise_function_type )( ) ; initialise_function_type initialise_function_value( &::SireFF::GridPotentialTable::initialise ); GridPotentialTable_exposer.def( "initialise" , initialise_function_value ); } { //::SireFF::GridPotentialTable::multiply typedef void ( ::SireFF::GridPotentialTable::*multiply_function_type )( double ) ; multiply_function_type multiply_function_value( &::SireFF::GridPotentialTable::multiply ); GridPotentialTable_exposer.def( "multiply" , multiply_function_value , ( bp::arg("value") ) ); } { //::SireFF::GridPotentialTable::nPoints typedef int ( ::SireFF::GridPotentialTable::*nPoints_function_type )( ) const; nPoints_function_type nPoints_function_value( &::SireFF::GridPotentialTable::nPoints ); GridPotentialTable_exposer.def( "nPoints" , nPoints_function_value ); } GridPotentialTable_exposer.def( bp::self != bp::self ); GridPotentialTable_exposer.def( bp::self * bp::other< double >() ); GridPotentialTable_exposer.def( bp::self + bp::self ); GridPotentialTable_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() ); GridPotentialTable_exposer.def( bp::self - bp::self ); GridPotentialTable_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() ); GridPotentialTable_exposer.def( -bp::self ); GridPotentialTable_exposer.def( bp::self / bp::other< double >() ); { //::SireFF::GridPotentialTable::operator= typedef ::SireFF::GridPotentialTable & ( ::SireFF::GridPotentialTable::*assign_function_type )( ::SireFF::GridPotentialTable const & ) ; assign_function_type assign_function_value( &::SireFF::GridPotentialTable::operator= ); GridPotentialTable_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } { //::SireFF::GridPotentialTable::operator= typedef ::SireFF::GridPotentialTable & ( ::SireFF::GridPotentialTable::*assign_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ; assign_function_type assign_function_value( &::SireFF::GridPotentialTable::operator= ); GridPotentialTable_exposer.def( "assign" , assign_function_value , ( bp::arg("potential") ) , bp::return_self< >() ); } GridPotentialTable_exposer.def( bp::self == bp::self ); { //::SireFF::GridPotentialTable::operator[] typedef ::SireUnits::Dimension::MolarEnergy & ( ::SireFF::GridPotentialTable::*__getitem___function_type )( int ) ; __getitem___function_type __getitem___function_value( &::SireFF::GridPotentialTable::operator[] ); GridPotentialTable_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , bp::return_internal_reference< >() ); } { //::SireFF::GridPotentialTable::operator[] typedef ::SireUnits::Dimension::MolarEnergy const & ( ::SireFF::GridPotentialTable::*__getitem___function_type )( int ) const; __getitem___function_type __getitem___function_value( &::SireFF::GridPotentialTable::operator[] ); GridPotentialTable_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireFF::GridPotentialTable::setAll typedef void ( ::SireFF::GridPotentialTable::*setAll_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ; setAll_function_type setAll_function_value( &::SireFF::GridPotentialTable::setAll ); GridPotentialTable_exposer.def( "setAll" , setAll_function_value , ( bp::arg("potential") ) ); } { //::SireFF::GridPotentialTable::subtract typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type )( int,::SireUnits::Dimension::MolarEnergy const & ) ; subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract ); GridPotentialTable_exposer.def( "subtract" , subtract_function_value , ( bp::arg("ipoint"), bp::arg("potential") ) ); } { //::SireFF::GridPotentialTable::subtract typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type )( ::SireFF::GridPotentialTable const & ) ; subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract ); GridPotentialTable_exposer.def( "subtract" , subtract_function_value , ( bp::arg("other") ) ); } { //::SireFF::GridPotentialTable::subtract typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ; subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract ); GridPotentialTable_exposer.def( "subtract" , subtract_function_value , ( bp::arg("potential") ) ); } { //::SireFF::GridPotentialTable::toVector typedef ::QVector< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > > ( ::SireFF::GridPotentialTable::*toVector_function_type )( ) const; toVector_function_type toVector_function_value( &::SireFF::GridPotentialTable::toVector ); GridPotentialTable_exposer.def( "toVector" , toVector_function_value ); } { //::SireFF::GridPotentialTable::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireFF::GridPotentialTable::typeName ); GridPotentialTable_exposer.def( "typeName" , typeName_function_value ); } GridPotentialTable_exposer.staticmethod( "typeName" ); GridPotentialTable_exposer.def( "__copy__", &__copy__); GridPotentialTable_exposer.def( "__deepcopy__", &__copy__); GridPotentialTable_exposer.def( "clone", &__copy__); GridPotentialTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::GridPotentialTable >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); GridPotentialTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::GridPotentialTable >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); GridPotentialTable_exposer.def( "__str__", &pvt_get_name); GridPotentialTable_exposer.def( "__repr__", &pvt_get_name); GridPotentialTable_exposer.def( "__len__", &__len_count< ::SireFF::GridPotentialTable > ); } }
void register_TestFF_class(){ { //::SireMM::TestFF typedef bp::class_< SireMM::TestFF > TestFF_exposer_t; TestFF_exposer_t TestFF_exposer = TestFF_exposer_t( "TestFF", "This is a simple forcefield that is designed to let me test new\nways of calculating energies before rolling out the new design\nto the rest of Sire\n\nAuthor: Christopher Woods\n", bp::init< >("") ); bp::scope TestFF_scope( TestFF_exposer ); TestFF_exposer.def( bp::init< SireMM::TestFF const & >(( bp::arg("other") ), "") ); { //::SireMM::TestFF::add typedef void ( ::SireMM::TestFF::*add_function_type)( ::SireMol::Molecules const & ) ; add_function_type add_function_value( &::SireMM::TestFF::add ); TestFF_exposer.def( "add" , add_function_value , ( bp::arg("molecules") ) , "" ); } { //::SireMM::TestFF::addFixedAtoms typedef void ( ::SireMM::TestFF::*addFixedAtoms_function_type)( ::SireMol::Molecules const & ) ; addFixedAtoms_function_type addFixedAtoms_function_value( &::SireMM::TestFF::addFixedAtoms ); TestFF_exposer.def( "addFixedAtoms" , addFixedAtoms_function_value , ( bp::arg("molecules") ) , "" ); } { //::SireMM::TestFF::calculateEnergy typedef void ( ::SireMM::TestFF::*calculateEnergy_function_type)( ) ; calculateEnergy_function_type calculateEnergy_function_value( &::SireMM::TestFF::calculateEnergy ); TestFF_exposer.def( "calculateEnergy" , calculateEnergy_function_value , "" ); } { //::SireMM::TestFF::operator= typedef ::SireMM::TestFF & ( ::SireMM::TestFF::*assign_function_type)( ::SireMM::TestFF const & ) ; assign_function_type assign_function_value( &::SireMM::TestFF::operator= ); TestFF_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } { //::SireMM::TestFF::setCutoff typedef void ( ::SireMM::TestFF::*setCutoff_function_type)( ::SireUnits::Dimension::Length,::SireUnits::Dimension::Length ) ; setCutoff_function_type setCutoff_function_value( &::SireMM::TestFF::setCutoff ); TestFF_exposer.def( "setCutoff" , setCutoff_function_value , ( bp::arg("coul_cutoff"), bp::arg("lj_cutoff") ) , "" ); } TestFF_exposer.def( "__copy__", &__copy__); TestFF_exposer.def( "__deepcopy__", &__copy__); TestFF_exposer.def( "clone", &__copy__); TestFF_exposer.def( "__str__", &pvt_get_name); TestFF_exposer.def( "__repr__", &pvt_get_name); } }
void register_HF_class(){ { //::Squire::HF typedef bp::class_< Squire::HF > HF_exposer_t; HF_exposer_t HF_exposer = HF_exposer_t( "HF", "This is my first attempt at a small HF program", bp::init< >("Constructor") ); bp::scope HF_scope( HF_exposer ); { //::Squire::HF::add typedef void ( ::Squire::HF::*add_function_type)( ::Squire::Orbital const & ) ; add_function_type add_function_value( &::Squire::HF::add ); HF_exposer.def( "add" , add_function_value , ( bp::arg("orbital") ) , "Add an orbital that does not to be located at a particular\npoint in space" ); } { //::Squire::HF::add typedef void ( ::Squire::HF::*add_function_type)( ::SireMaths::Vector const &,::Squire::Orbital const & ) ; add_function_type add_function_value( &::Squire::HF::add ); HF_exposer.def( "add" , add_function_value , ( bp::arg("point"), bp::arg("orbital") ) , "Add an orbital that needs to be placed at center" ); } { //::Squire::HF::add typedef void ( ::Squire::HF::*add_function_type)( ::SireMaths::Vector const &,::SireUnits::Dimension::Charge const & ) ; add_function_type add_function_value( &::Squire::HF::add ); HF_exposer.def( "add" , add_function_value , ( bp::arg("point"), bp::arg("charge") ) , "Add an orbital that needs to be placed at center" ); } { //::Squire::HF::add typedef void ( ::Squire::HF::*add_function_type)( ::SireMaths::Vector const &,::SireMaths::Vector const & ) ; add_function_type add_function_value( &::Squire::HF::add ); HF_exposer.def( "add" , add_function_value , ( bp::arg("point"), bp::arg("dipole") ) , "Add an orbital that needs to be placed at center" ); } { //::Squire::HF::solve typedef void ( ::Squire::HF::*solve_function_type)( ) ; solve_function_type solve_function_value( &::Squire::HF::solve ); HF_exposer.def( "solve" , solve_function_value , "" ); } HF_exposer.def( "__copy__", &__copy__); HF_exposer.def( "__deepcopy__", &__copy__); HF_exposer.def( "clone", &__copy__); HF_exposer.def( "__str__", &pvt_get_name); HF_exposer.def( "__repr__", &pvt_get_name); } }
void register_ForceTable_class(){ { //::SireFF::ForceTable typedef bp::class_< SireFF::ForceTable > ForceTable_exposer_t; ForceTable_exposer_t ForceTable_exposer = ForceTable_exposer_t( "ForceTable", bp::init< >() ); bp::scope ForceTable_scope( ForceTable_exposer ); ForceTable_exposer.def( bp::init< SireMol::MoleculeGroup const & >(( bp::arg("molgroup") )) ); ForceTable_exposer.def( bp::init< SireFF::ForceTable const & >(( bp::arg("other") )) ); { //::SireFF::ForceTable::add typedef void ( ::SireFF::ForceTable::*add_function_type )( ::SireFF::ForceTable const & ) ; add_function_type add_function_value( &::SireFF::ForceTable::add ); ForceTable_exposer.def( "add" , add_function_value , ( bp::arg("other") ) ); } { //::SireFF::ForceTable::add typedef void ( ::SireFF::ForceTable::*add_function_type )( ::SireMaths::Vector const & ) ; add_function_type add_function_value( &::SireFF::ForceTable::add ); ForceTable_exposer.def( "add" , add_function_value , ( bp::arg("force") ) ); } { //::SireFF::ForceTable::assertContainsTableFor typedef void ( ::SireFF::ForceTable::*assertContainsTableFor_function_type )( ::SireMol::MolNum ) const; assertContainsTableFor_function_type assertContainsTableFor_function_value( &::SireFF::ForceTable::assertContainsTableFor ); ForceTable_exposer.def( "assertContainsTableFor" , assertContainsTableFor_function_value , ( bp::arg("molnum") ) ); } { //::SireFF::ForceTable::constGetTable typedef ::SireFF::MolForceTable const & ( ::SireFF::ForceTable::*constGetTable_function_type )( ::SireMol::MolNum ) const; constGetTable_function_type constGetTable_function_value( &::SireFF::ForceTable::constGetTable ); ForceTable_exposer.def( "constGetTable" , constGetTable_function_value , ( bp::arg("molnum") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireFF::ForceTable::containsTable typedef bool ( ::SireFF::ForceTable::*containsTable_function_type )( ::SireMol::MolNum ) const; containsTable_function_type containsTable_function_value( &::SireFF::ForceTable::containsTable ); ForceTable_exposer.def( "containsTable" , containsTable_function_value , ( bp::arg("molnum") ) ); } { //::SireFF::ForceTable::count typedef int ( ::SireFF::ForceTable::*count_function_type )( ) const; count_function_type count_function_value( &::SireFF::ForceTable::count ); ForceTable_exposer.def( "count" , count_function_value ); } { //::SireFF::ForceTable::divide typedef void ( ::SireFF::ForceTable::*divide_function_type )( double ) ; divide_function_type divide_function_value( &::SireFF::ForceTable::divide ); ForceTable_exposer.def( "divide" , divide_function_value , ( bp::arg("value") ) ); } { //::SireFF::ForceTable::getTable typedef ::SireFF::MolForceTable const & ( ::SireFF::ForceTable::*getTable_function_type )( ::SireMol::MolNum ) const; getTable_function_type getTable_function_value( &::SireFF::ForceTable::getTable ); ForceTable_exposer.def( "getTable" , getTable_function_value , ( bp::arg("molnum") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireFF::ForceTable::index typedef ::QHash< SireMol::MolNum, int > const & ( ::SireFF::ForceTable::*index_function_type )( ) const; index_function_type index_function_value( &::SireFF::ForceTable::index ); ForceTable_exposer.def( "index" , index_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireFF::ForceTable::indexOf typedef int ( ::SireFF::ForceTable::*indexOf_function_type )( ::SireMol::MolNum ) const; indexOf_function_type indexOf_function_value( &::SireFF::ForceTable::indexOf ); ForceTable_exposer.def( "indexOf" , indexOf_function_value , ( bp::arg("molnum") ) ); } { //::SireFF::ForceTable::initialiseTable typedef void ( ::SireFF::ForceTable::*initialiseTable_function_type )( ::SireMol::MolNum ) ; initialiseTable_function_type initialiseTable_function_value( &::SireFF::ForceTable::initialiseTable ); ForceTable_exposer.def( "initialiseTable" , initialiseTable_function_value , ( bp::arg("molnum") ) ); } { //::SireFF::ForceTable::initialiseTables typedef void ( ::SireFF::ForceTable::*initialiseTables_function_type )( ) ; initialiseTables_function_type initialiseTables_function_value( &::SireFF::ForceTable::initialiseTables ); ForceTable_exposer.def( "initialiseTables" , initialiseTables_function_value ); } { //::SireFF::ForceTable::molNums typedef ::QList< SireMol::MolNum > ( ::SireFF::ForceTable::*molNums_function_type )( ) const; molNums_function_type molNums_function_value( &::SireFF::ForceTable::molNums ); ForceTable_exposer.def( "molNums" , molNums_function_value ); } { //::SireFF::ForceTable::multiply typedef void ( ::SireFF::ForceTable::*multiply_function_type )( double ) ; multiply_function_type multiply_function_value( &::SireFF::ForceTable::multiply ); ForceTable_exposer.def( "multiply" , multiply_function_value , ( bp::arg("value") ) ); } ForceTable_exposer.def( bp::self != bp::self ); ForceTable_exposer.def( bp::self * bp::other< double >() ); ForceTable_exposer.def( bp::self + bp::self ); ForceTable_exposer.def( bp::self + bp::other< SireMaths::Vector >() ); ForceTable_exposer.def( bp::self - bp::self ); ForceTable_exposer.def( bp::self - bp::other< SireMaths::Vector >() ); ForceTable_exposer.def( -bp::self ); ForceTable_exposer.def( bp::self / bp::other< double >() ); { //::SireFF::ForceTable::operator= typedef ::SireFF::ForceTable & ( ::SireFF::ForceTable::*assign_function_type )( ::SireFF::ForceTable const & ) ; assign_function_type assign_function_value( &::SireFF::ForceTable::operator= ); ForceTable_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } { //::SireFF::ForceTable::operator= typedef ::SireFF::ForceTable & ( ::SireFF::ForceTable::*assign_function_type )( ::SireMaths::Vector const & ) ; assign_function_type assign_function_value( &::SireFF::ForceTable::operator= ); ForceTable_exposer.def( "assign" , assign_function_value , ( bp::arg("force") ) , bp::return_self< >() ); } ForceTable_exposer.def( bp::self == bp::self ); { //::SireFF::ForceTable::setAll typedef void ( ::SireFF::ForceTable::*setAll_function_type )( ::SireMaths::Vector const & ) ; setAll_function_type setAll_function_value( &::SireFF::ForceTable::setAll ); ForceTable_exposer.def( "setAll" , setAll_function_value , ( bp::arg("force") ) ); } { //::SireFF::ForceTable::subtract typedef void ( ::SireFF::ForceTable::*subtract_function_type )( ::SireFF::ForceTable const & ) ; subtract_function_type subtract_function_value( &::SireFF::ForceTable::subtract ); ForceTable_exposer.def( "subtract" , subtract_function_value , ( bp::arg("other") ) ); } { //::SireFF::ForceTable::subtract typedef void ( ::SireFF::ForceTable::*subtract_function_type )( ::SireMaths::Vector const & ) ; subtract_function_type subtract_function_value( &::SireFF::ForceTable::subtract ); ForceTable_exposer.def( "subtract" , subtract_function_value , ( bp::arg("force") ) ); } { //::SireFF::ForceTable::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireFF::ForceTable::typeName ); ForceTable_exposer.def( "typeName" , typeName_function_value ); } { //::SireFF::ForceTable::what typedef char const * ( ::SireFF::ForceTable::*what_function_type )( ) const; what_function_type what_function_value( &::SireFF::ForceTable::what ); ForceTable_exposer.def( "what" , what_function_value ); } ForceTable_exposer.staticmethod( "typeName" ); ForceTable_exposer.def( "__copy__", &__copy__); ForceTable_exposer.def( "__deepcopy__", &__copy__); ForceTable_exposer.def( "clone", &__copy__); ForceTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::ForceTable >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ForceTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::ForceTable >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ForceTable_exposer.def( "__str__", &pvt_get_name); ForceTable_exposer.def( "__repr__", &pvt_get_name); ForceTable_exposer.def( "__len__", &__len_count< ::SireFF::ForceTable > ); } }
void register_MolPotentialTable_class(){ { //::SireFF::MolPotentialTable typedef bp::class_< SireFF::MolPotentialTable > MolPotentialTable_exposer_t; MolPotentialTable_exposer_t MolPotentialTable_exposer = MolPotentialTable_exposer_t( "MolPotentialTable", bp::init< >() ); bp::scope MolPotentialTable_scope( MolPotentialTable_exposer ); MolPotentialTable_exposer.def( bp::init< SireMol::MoleculeView const & >(( bp::arg("molview") )) ); MolPotentialTable_exposer.def( bp::init< SireFF::MolPotentialTable const & >(( bp::arg("other") )) ); { //::SireFF::MolPotentialTable::add typedef bool ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireMol::CGAtomIdx const &,::SireUnits::Dimension::MolarEnergy const & ) ; add_function_type add_function_value( &::SireFF::MolPotentialTable::add ); MolPotentialTable_exposer.def( "add" , add_function_value , ( bp::arg("cgatomidx"), bp::arg("potential") ) ); } { //::SireFF::MolPotentialTable::add typedef bool ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireMol::AtomSelection const &,::SireUnits::Dimension::MolarEnergy const & ) ; add_function_type add_function_value( &::SireFF::MolPotentialTable::add ); MolPotentialTable_exposer.def( "add" , add_function_value , ( bp::arg("selected_atoms"), bp::arg("potential") ) ); } { //::SireFF::MolPotentialTable::add typedef void ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireFF::MolPotentialTable const & ) ; add_function_type add_function_value( &::SireFF::MolPotentialTable::add ); MolPotentialTable_exposer.def( "add" , add_function_value , ( bp::arg("other") ) ); } { //::SireFF::MolPotentialTable::add typedef void ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ; add_function_type add_function_value( &::SireFF::MolPotentialTable::add ); MolPotentialTable_exposer.def( "add" , add_function_value , ( bp::arg("potential") ) ); } { //::SireFF::MolPotentialTable::divide typedef void ( ::SireFF::MolPotentialTable::*divide_function_type )( double ) ; divide_function_type divide_function_value( &::SireFF::MolPotentialTable::divide ); MolPotentialTable_exposer.def( "divide" , divide_function_value , ( bp::arg("value") ) ); } { //::SireFF::MolPotentialTable::initialise typedef void ( ::SireFF::MolPotentialTable::*initialise_function_type )( ) ; initialise_function_type initialise_function_value( &::SireFF::MolPotentialTable::initialise ); MolPotentialTable_exposer.def( "initialise" , initialise_function_value ); } { //::SireFF::MolPotentialTable::map typedef int ( ::SireFF::MolPotentialTable::*map_function_type )( ::SireMol::CGIdx ) const; map_function_type map_function_value( &::SireFF::MolPotentialTable::map ); MolPotentialTable_exposer.def( "map" , map_function_value , ( bp::arg("cgidx") ) ); } { //::SireFF::MolPotentialTable::molNum typedef ::SireMol::MolNum ( ::SireFF::MolPotentialTable::*molNum_function_type )( ) const; molNum_function_type molNum_function_value( &::SireFF::MolPotentialTable::molNum ); MolPotentialTable_exposer.def( "molNum" , molNum_function_value ); } { //::SireFF::MolPotentialTable::molUID typedef ::QUuid const & ( ::SireFF::MolPotentialTable::*molUID_function_type )( ) const; molUID_function_type molUID_function_value( &::SireFF::MolPotentialTable::molUID ); MolPotentialTable_exposer.def( "molUID" , molUID_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireFF::MolPotentialTable::multiply typedef void ( ::SireFF::MolPotentialTable::*multiply_function_type )( double ) ; multiply_function_type multiply_function_value( &::SireFF::MolPotentialTable::multiply ); MolPotentialTable_exposer.def( "multiply" , multiply_function_value , ( bp::arg("value") ) ); } { //::SireFF::MolPotentialTable::nCutGroups typedef int ( ::SireFF::MolPotentialTable::*nCutGroups_function_type )( ) const; nCutGroups_function_type nCutGroups_function_value( &::SireFF::MolPotentialTable::nCutGroups ); MolPotentialTable_exposer.def( "nCutGroups" , nCutGroups_function_value ); } { //::SireFF::MolPotentialTable::nSelectedCutGroups typedef int ( ::SireFF::MolPotentialTable::*nSelectedCutGroups_function_type )( ) const; nSelectedCutGroups_function_type nSelectedCutGroups_function_value( &::SireFF::MolPotentialTable::nSelectedCutGroups ); MolPotentialTable_exposer.def( "nSelectedCutGroups" , nSelectedCutGroups_function_value ); } MolPotentialTable_exposer.def( bp::self != bp::self ); MolPotentialTable_exposer.def( bp::self * bp::other< double >() ); MolPotentialTable_exposer.def( bp::self + bp::self ); MolPotentialTable_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() ); MolPotentialTable_exposer.def( bp::self - bp::self ); MolPotentialTable_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() ); MolPotentialTable_exposer.def( -bp::self ); MolPotentialTable_exposer.def( bp::self / bp::other< double >() ); { //::SireFF::MolPotentialTable::operator= typedef ::SireFF::MolPotentialTable & ( ::SireFF::MolPotentialTable::*assign_function_type )( ::SireFF::MolPotentialTable const & ) ; assign_function_type assign_function_value( &::SireFF::MolPotentialTable::operator= ); MolPotentialTable_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } { //::SireFF::MolPotentialTable::operator= typedef ::SireFF::MolPotentialTable & ( ::SireFF::MolPotentialTable::*assign_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ; assign_function_type assign_function_value( &::SireFF::MolPotentialTable::operator= ); MolPotentialTable_exposer.def( "assign" , assign_function_value , ( bp::arg("potential") ) , bp::return_self< >() ); } MolPotentialTable_exposer.def( bp::self == bp::self ); { //::SireFF::MolPotentialTable::selected typedef bool ( ::SireFF::MolPotentialTable::*selected_function_type )( ::SireMol::CGIdx ) const; selected_function_type selected_function_value( &::SireFF::MolPotentialTable::selected ); MolPotentialTable_exposer.def( "selected" , selected_function_value , ( bp::arg("cgidx") ) ); } { //::SireFF::MolPotentialTable::selectedAll typedef bool ( ::SireFF::MolPotentialTable::*selectedAll_function_type )( ) const; selectedAll_function_type selectedAll_function_value( &::SireFF::MolPotentialTable::selectedAll ); MolPotentialTable_exposer.def( "selectedAll" , selectedAll_function_value ); } { //::SireFF::MolPotentialTable::setAll typedef void ( ::SireFF::MolPotentialTable::*setAll_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ; setAll_function_type setAll_function_value( &::SireFF::MolPotentialTable::setAll ); MolPotentialTable_exposer.def( "setAll" , setAll_function_value , ( bp::arg("potential") ) ); } { //::SireFF::MolPotentialTable::subtract typedef bool ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireMol::CGAtomIdx const &,::SireUnits::Dimension::MolarEnergy const & ) ; subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract ); MolPotentialTable_exposer.def( "subtract" , subtract_function_value , ( bp::arg("cgatomidx"), bp::arg("potential") ) ); } { //::SireFF::MolPotentialTable::subtract typedef bool ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireMol::AtomSelection const &,::SireUnits::Dimension::MolarEnergy const & ) ; subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract ); MolPotentialTable_exposer.def( "subtract" , subtract_function_value , ( bp::arg("selected_atoms"), bp::arg("potential") ) ); } { //::SireFF::MolPotentialTable::subtract typedef void ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireFF::MolPotentialTable const & ) ; subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract ); MolPotentialTable_exposer.def( "subtract" , subtract_function_value , ( bp::arg("other") ) ); } { //::SireFF::MolPotentialTable::subtract typedef void ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ; subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract ); MolPotentialTable_exposer.def( "subtract" , subtract_function_value , ( bp::arg("potential") ) ); } { //::SireFF::MolPotentialTable::toVector typedef ::QVector< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > > ( ::SireFF::MolPotentialTable::*toVector_function_type )( ) const; toVector_function_type toVector_function_value( &::SireFF::MolPotentialTable::toVector ); MolPotentialTable_exposer.def( "toVector" , toVector_function_value ); } { //::SireFF::MolPotentialTable::toVector typedef ::QVector< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > > ( ::SireFF::MolPotentialTable::*toVector_function_type )( ::SireMol::AtomSelection const & ) const; toVector_function_type toVector_function_value( &::SireFF::MolPotentialTable::toVector ); MolPotentialTable_exposer.def( "toVector" , toVector_function_value , ( bp::arg("selection") ) ); } { //::SireFF::MolPotentialTable::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireFF::MolPotentialTable::typeName ); MolPotentialTable_exposer.def( "typeName" , typeName_function_value ); } { //::SireFF::MolPotentialTable::what typedef char const * ( ::SireFF::MolPotentialTable::*what_function_type )( ) const; what_function_type what_function_value( &::SireFF::MolPotentialTable::what ); MolPotentialTable_exposer.def( "what" , what_function_value ); } MolPotentialTable_exposer.staticmethod( "typeName" ); MolPotentialTable_exposer.def( "__copy__", &__copy__); MolPotentialTable_exposer.def( "__deepcopy__", &__copy__); MolPotentialTable_exposer.def( "clone", &__copy__); MolPotentialTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::MolPotentialTable >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); MolPotentialTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::MolPotentialTable >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); MolPotentialTable_exposer.def( "__str__", &__str__< ::SireFF::MolPotentialTable > ); MolPotentialTable_exposer.def( "__repr__", &__str__< ::SireFF::MolPotentialTable > ); MolPotentialTable_exposer.def( "__len__", &__len_size< ::SireFF::MolPotentialTable > ); } }
void register_G1FF_class(){ { //::SireFF::G1FF typedef bp::class_< SireFF::G1FF, bp::bases< SireFF::FF, SireMol::MolGroupsBase, SireBase::Property >, boost::noncopyable > G1FF_exposer_t; G1FF_exposer_t G1FF_exposer = G1FF_exposer_t( "G1FF", bp::no_init ); bp::scope G1FF_scope( G1FF_exposer ); { //::SireFF::G1FF::accept typedef void ( ::SireFF::G1FF::*accept_function_type )( ) ; accept_function_type accept_function_value( &::SireFF::G1FF::accept ); G1FF_exposer.def( "accept" , accept_function_value ); } { //::SireFF::G1FF::add typedef void ( ::SireFF::G1FF::*add_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) ; add_function_type add_function_value( &::SireFF::G1FF::add ); G1FF_exposer.def( "add" , add_function_value , ( bp::arg("molview"), bp::arg("map") ) ); } { //::SireFF::G1FF::add typedef void ( ::SireFF::G1FF::*add_function_type )( ::SireMol::ViewsOfMol const &,::SireBase::PropertyMap const & ) ; add_function_type add_function_value( &::SireFF::G1FF::add ); G1FF_exposer.def( "add" , add_function_value , ( bp::arg("molviews"), bp::arg("map") ) ); } { //::SireFF::G1FF::add typedef void ( ::SireFF::G1FF::*add_function_type )( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) ; add_function_type add_function_value( &::SireFF::G1FF::add ); G1FF_exposer.def( "add" , add_function_value , ( bp::arg("molecules"), bp::arg("map") ) ); } { //::SireFF::G1FF::add typedef void ( ::SireFF::G1FF::*add_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) ; add_function_type add_function_value( &::SireFF::G1FF::add ); G1FF_exposer.def( "add" , add_function_value , ( bp::arg("molgroup"), bp::arg("map") ) ); } { //::SireFF::G1FF::add typedef void ( ::SireFF::G1FF::*add_function_type )( ::SireMol::MoleculeView const & ) ; add_function_type add_function_value( &::SireFF::G1FF::add ); G1FF_exposer.def( "add" , add_function_value , ( bp::arg("molview") ) ); } { //::SireFF::G1FF::add typedef void ( ::SireFF::G1FF::*add_function_type )( ::SireMol::ViewsOfMol const & ) ; add_function_type add_function_value( &::SireFF::G1FF::add ); G1FF_exposer.def( "add" , add_function_value , ( bp::arg("molviews") ) ); } { //::SireFF::G1FF::add typedef void ( ::SireFF::G1FF::*add_function_type )( ::SireMol::Molecules const & ) ; add_function_type add_function_value( &::SireFF::G1FF::add ); G1FF_exposer.def( "add" , add_function_value , ( bp::arg("molecules") ) ); } { //::SireFF::G1FF::add typedef void ( ::SireFF::G1FF::*add_function_type )( ::SireMol::MoleculeGroup const & ) ; add_function_type add_function_value( &::SireFF::G1FF::add ); G1FF_exposer.def( "add" , add_function_value , ( bp::arg("molgroup") ) ); } { //::SireFF::G1FF::addIfUnique typedef void ( ::SireFF::G1FF::*addIfUnique_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) ; addIfUnique_function_type addIfUnique_function_value( &::SireFF::G1FF::addIfUnique ); G1FF_exposer.def( "addIfUnique" , addIfUnique_function_value , ( bp::arg("molview"), bp::arg("map") ) ); } { //::SireFF::G1FF::addIfUnique typedef void ( ::SireFF::G1FF::*addIfUnique_function_type )( ::SireMol::ViewsOfMol const &,::SireBase::PropertyMap const & ) ; addIfUnique_function_type addIfUnique_function_value( &::SireFF::G1FF::addIfUnique ); G1FF_exposer.def( "addIfUnique" , addIfUnique_function_value , ( bp::arg("molviews"), bp::arg("map") ) ); } { //::SireFF::G1FF::addIfUnique typedef void ( ::SireFF::G1FF::*addIfUnique_function_type )( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) ; addIfUnique_function_type addIfUnique_function_value( &::SireFF::G1FF::addIfUnique ); G1FF_exposer.def( "addIfUnique" , addIfUnique_function_value , ( bp::arg("molecules"), bp::arg("map") ) ); } { //::SireFF::G1FF::addIfUnique typedef void ( ::SireFF::G1FF::*addIfUnique_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) ; addIfUnique_function_type addIfUnique_function_value( &::SireFF::G1FF::addIfUnique ); G1FF_exposer.def( "addIfUnique" , addIfUnique_function_value , ( bp::arg("molgroup"), bp::arg("map") ) ); } { //::SireFF::G1FF::addIfUnique typedef void ( ::SireFF::G1FF::*addIfUnique_function_type )( ::SireMol::MoleculeView const & ) ; addIfUnique_function_type addIfUnique_function_value( &::SireFF::G1FF::addIfUnique ); G1FF_exposer.def( "addIfUnique" , addIfUnique_function_value , ( bp::arg("molview") ) ); } { //::SireFF::G1FF::addIfUnique typedef void ( ::SireFF::G1FF::*addIfUnique_function_type )( ::SireMol::ViewsOfMol const & ) ; addIfUnique_function_type addIfUnique_function_value( &::SireFF::G1FF::addIfUnique ); G1FF_exposer.def( "addIfUnique" , addIfUnique_function_value , ( bp::arg("molviews") ) ); } { //::SireFF::G1FF::addIfUnique typedef void ( ::SireFF::G1FF::*addIfUnique_function_type )( ::SireMol::Molecules const & ) ; addIfUnique_function_type addIfUnique_function_value( &::SireFF::G1FF::addIfUnique ); G1FF_exposer.def( "addIfUnique" , addIfUnique_function_value , ( bp::arg("molecules") ) ); } { //::SireFF::G1FF::addIfUnique typedef void ( ::SireFF::G1FF::*addIfUnique_function_type )( ::SireMol::MoleculeGroup const & ) ; addIfUnique_function_type addIfUnique_function_value( &::SireFF::G1FF::addIfUnique ); G1FF_exposer.def( "addIfUnique" , addIfUnique_function_value , ( bp::arg("molgroup") ) ); } { //::SireFF::G1FF::assertContains typedef void ( ::SireFF::G1FF::*assertContains_function_type )( ::SireMol::MGNum ) const; assertContains_function_type assertContains_function_value( &::SireFF::G1FF::assertContains ); G1FF_exposer.def( "assertContains" , assertContains_function_value , ( bp::arg("mgnum") ) ); } { //::SireFF::G1FF::at typedef ::SireMol::MoleculeGroup const & ( ::SireFF::G1FF::*at_function_type )( ::SireMol::MGNum ) const; at_function_type at_function_value( &::SireFF::G1FF::at ); G1FF_exposer.def( "at" , at_function_value , ( bp::arg("mgnum") ) , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireFF::G1FF::needsAccepting typedef bool ( ::SireFF::G1FF::*needsAccepting_function_type )( ) const; needsAccepting_function_type needsAccepting_function_value( &::SireFF::G1FF::needsAccepting ); G1FF_exposer.def( "needsAccepting" , needsAccepting_function_value ); } { //::SireFF::G1FF::remove typedef bool ( ::SireFF::G1FF::*remove_function_type )( ::SireMol::MoleculeView const & ) ; remove_function_type remove_function_value( &::SireFF::G1FF::remove ); G1FF_exposer.def( "remove" , remove_function_value , ( bp::arg("molview") ) ); } { //::SireFF::G1FF::remove typedef bool ( ::SireFF::G1FF::*remove_function_type )( ::SireMol::ViewsOfMol const & ) ; remove_function_type remove_function_value( &::SireFF::G1FF::remove ); G1FF_exposer.def( "remove" , remove_function_value , ( bp::arg("molviews") ) ); } { //::SireFF::G1FF::remove typedef bool ( ::SireFF::G1FF::*remove_function_type )( ::SireMol::Molecules const & ) ; remove_function_type remove_function_value( &::SireFF::G1FF::remove ); G1FF_exposer.def( "remove" , remove_function_value , ( bp::arg("molecules") ) ); } { //::SireFF::G1FF::remove typedef bool ( ::SireFF::G1FF::*remove_function_type )( ::SireMol::MoleculeGroup const & ) ; remove_function_type remove_function_value( &::SireFF::G1FF::remove ); G1FF_exposer.def( "remove" , remove_function_value , ( bp::arg("molgroup") ) ); } { //::SireFF::G1FF::remove typedef bool ( ::SireFF::G1FF::*remove_function_type )( ::SireMol::MolNum ) ; remove_function_type remove_function_value( &::SireFF::G1FF::remove ); G1FF_exposer.def( "remove" , remove_function_value , ( bp::arg("molnum") ) ); } { //::SireFF::G1FF::remove typedef bool ( ::SireFF::G1FF::*remove_function_type )( ::QSet< SireMol::MolNum > const & ) ; remove_function_type remove_function_value( &::SireFF::G1FF::remove ); G1FF_exposer.def( "remove" , remove_function_value , ( bp::arg("molnums") ) ); } { //::SireFF::G1FF::removeAll typedef bool ( ::SireFF::G1FF::*removeAll_function_type )( ) ; removeAll_function_type removeAll_function_value( &::SireFF::G1FF::removeAll ); G1FF_exposer.def( "removeAll" , removeAll_function_value ); } { //::SireFF::G1FF::removeAll typedef bool ( ::SireFF::G1FF::*removeAll_function_type )( ::SireMol::MoleculeView const & ) ; removeAll_function_type removeAll_function_value( &::SireFF::G1FF::removeAll ); G1FF_exposer.def( "removeAll" , removeAll_function_value , ( bp::arg("molview") ) ); } { //::SireFF::G1FF::removeAll typedef bool ( ::SireFF::G1FF::*removeAll_function_type )( ::SireMol::ViewsOfMol const & ) ; removeAll_function_type removeAll_function_value( &::SireFF::G1FF::removeAll ); G1FF_exposer.def( "removeAll" , removeAll_function_value , ( bp::arg("molviews") ) ); } { //::SireFF::G1FF::removeAll typedef bool ( ::SireFF::G1FF::*removeAll_function_type )( ::SireMol::Molecules const & ) ; removeAll_function_type removeAll_function_value( &::SireFF::G1FF::removeAll ); G1FF_exposer.def( "removeAll" , removeAll_function_value , ( bp::arg("molecules") ) ); } { //::SireFF::G1FF::removeAll typedef bool ( ::SireFF::G1FF::*removeAll_function_type )( ::SireMol::MoleculeGroup const & ) ; removeAll_function_type removeAll_function_value( &::SireFF::G1FF::removeAll ); G1FF_exposer.def( "removeAll" , removeAll_function_value , ( bp::arg("molgroup") ) ); } { //::SireFF::G1FF::setContents typedef void ( ::SireFF::G1FF::*setContents_function_type )( ::SireMol::MoleculeView const & ) ; setContents_function_type setContents_function_value( &::SireFF::G1FF::setContents ); G1FF_exposer.def( "setContents" , setContents_function_value , ( bp::arg("molview") ) ); } { //::SireFF::G1FF::setContents typedef void ( ::SireFF::G1FF::*setContents_function_type )( ::SireMol::ViewsOfMol const & ) ; setContents_function_type setContents_function_value( &::SireFF::G1FF::setContents ); G1FF_exposer.def( "setContents" , setContents_function_value , ( bp::arg("molview") ) ); } { //::SireFF::G1FF::setContents typedef void ( ::SireFF::G1FF::*setContents_function_type )( ::SireMol::Molecules const & ) ; setContents_function_type setContents_function_value( &::SireFF::G1FF::setContents ); G1FF_exposer.def( "setContents" , setContents_function_value , ( bp::arg("molecules") ) ); } { //::SireFF::G1FF::setContents typedef void ( ::SireFF::G1FF::*setContents_function_type )( ::SireMol::MoleculeGroup const & ) ; setContents_function_type setContents_function_value( &::SireFF::G1FF::setContents ); G1FF_exposer.def( "setContents" , setContents_function_value , ( bp::arg("molgroup") ) ); } { //::SireFF::G1FF::setContents typedef void ( ::SireFF::G1FF::*setContents_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) ; setContents_function_type setContents_function_value( &::SireFF::G1FF::setContents ); G1FF_exposer.def( "setContents" , setContents_function_value , ( bp::arg("molview"), bp::arg("map") ) ); } { //::SireFF::G1FF::setContents typedef void ( ::SireFF::G1FF::*setContents_function_type )( ::SireMol::ViewsOfMol const &,::SireBase::PropertyMap const & ) ; setContents_function_type setContents_function_value( &::SireFF::G1FF::setContents ); G1FF_exposer.def( "setContents" , setContents_function_value , ( bp::arg("molviews"), bp::arg("map") ) ); } { //::SireFF::G1FF::setContents typedef void ( ::SireFF::G1FF::*setContents_function_type )( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) ; setContents_function_type setContents_function_value( &::SireFF::G1FF::setContents ); G1FF_exposer.def( "setContents" , setContents_function_value , ( bp::arg("molecules"), bp::arg("map") ) ); } { //::SireFF::G1FF::setContents typedef void ( ::SireFF::G1FF::*setContents_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) ; setContents_function_type setContents_function_value( &::SireFF::G1FF::setContents ); G1FF_exposer.def( "setContents" , setContents_function_value , ( bp::arg("molgroup"), bp::arg("map") ) ); } G1FF_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::G1FF >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); G1FF_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::G1FF >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); G1FF_exposer.def( "__str__", &__str__< ::SireFF::G1FF > ); G1FF_exposer.def( "__repr__", &__str__< ::SireFF::G1FF > ); G1FF_exposer.def( "__len__", &__len_count< ::SireFF::G1FF > ); } }
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_N4Matrix_class(){ { //::SireMaths::N4Matrix typedef bp::class_< SireMaths::N4Matrix > N4Matrix_exposer_t; N4Matrix_exposer_t N4Matrix_exposer = N4Matrix_exposer_t( "N4Matrix", "This is a dense, double, general NMLK 4-dimensional matrix.\nThe data is stored as a column-major 2D matrix of column-major\n2D matricies (so each 2D sub-matrix is suitable for\nuse with Fortran BLAS or LAPACK functions). This is\ndesigned for high speed.\n\nThe data is implicitly shared (copy on write), so\ncopying a matrix is very fast.\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") ); bp::scope N4Matrix_scope( N4Matrix_exposer ); N4Matrix_exposer.def( bp::init< int, int, int, int >(( bp::arg("nbigrows"), bp::arg("nbigcolumns"), bp::arg("nrows"), bp::arg("columns") ), "Construct a matrix with nbigrows big rows, nbigcolumns big columns,\nnrows rows and ncolumns columns. The values in the matrix are not initialised") ); N4Matrix_exposer.def( bp::init< int, int, int, int, double >(( bp::arg("nbigrows"), bp::arg("nbigcolumn"), bp::arg("nrows"), bp::arg("ncolumns"), bp::arg("initial_value") ), "Construct a matrix with nbigrows big rows, nbigcolumns big columns,\nnrows rows and ncolumns columns. The values in the matrix are\ninitialised to be equal to initial_value") ); N4Matrix_exposer.def( bp::init< SireMaths::NMatrix const & >(( bp::arg("matrix") ), "Construct from the passed matrix - this creates a matrix\nof dimension [1, 1, matrix.nRows(), matrix.nColumns()]") ); N4Matrix_exposer.def( bp::init< SireBase::Array2D< SireMaths::NMatrix > const & >(( bp::arg("matrix") ), "Construct from the passed Array or Matricies") ); N4Matrix_exposer.def( bp::init< QVector< QVector< QVector< QVector< double > > > > const & >(( bp::arg("matrix") ), "Construct from the passed vector of vector of vector of vectors...") ); N4Matrix_exposer.def( bp::init< SireMaths::N4Matrix const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMaths::N4Matrix::add typedef void ( ::SireMaths::N4Matrix::*add_function_type)( int,int,::SireMaths::NMatrix const & ) ; add_function_type add_function_value( &::SireMaths::N4Matrix::add ); N4Matrix_exposer.def( "add" , add_function_value , ( bp::arg("i"), bp::arg("j"), bp::arg("matrix") ) , "Add the contents of matrix to the sub-matrix view at [i,j]\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" ); } { //::SireMaths::N4Matrix::assertNBigColumns typedef void ( ::SireMaths::N4Matrix::*assertNBigColumns_function_type)( int ) const; assertNBigColumns_function_type assertNBigColumns_function_value( &::SireMaths::N4Matrix::assertNBigColumns ); N4Matrix_exposer.def( "assertNBigColumns" , assertNBigColumns_function_value , ( bp::arg("nbigcolumns") ) , "Assert that this matrix has nbigcolumns big columns\nThrow: SireError::incompatible_error\n" ); } { //::SireMaths::N4Matrix::assertNBigRows typedef void ( ::SireMaths::N4Matrix::*assertNBigRows_function_type)( int ) const; assertNBigRows_function_type assertNBigRows_function_value( &::SireMaths::N4Matrix::assertNBigRows ); N4Matrix_exposer.def( "assertNBigRows" , assertNBigRows_function_value , ( bp::arg("nbigrows") ) , "Assert that this matrix has nbigrows big rows\nThrow: SireError::incompatible_error\n" ); } { //::SireMaths::N4Matrix::assertNColumns typedef void ( ::SireMaths::N4Matrix::*assertNColumns_function_type)( int ) const; assertNColumns_function_type assertNColumns_function_value( &::SireMaths::N4Matrix::assertNColumns ); N4Matrix_exposer.def( "assertNColumns" , assertNColumns_function_value , ( bp::arg("ncolumns") ) , "Assert that this matrix has ncolumns columns\nThrow: SireError::incompatible_error\n" ); } { //::SireMaths::N4Matrix::assertNRows typedef void ( ::SireMaths::N4Matrix::*assertNRows_function_type)( int ) const; assertNRows_function_type assertNRows_function_value( &::SireMaths::N4Matrix::assertNRows ); N4Matrix_exposer.def( "assertNRows" , assertNRows_function_value , ( bp::arg("nrows") ) , "Assert that this matrix has nrows rows\nThrow: SireError::incompatible_error\n" ); } { //::SireMaths::N4Matrix::assertValidBigColumn typedef void ( ::SireMaths::N4Matrix::*assertValidBigColumn_function_type)( int ) const; assertValidBigColumn_function_type assertValidBigColumn_function_value( &::SireMaths::N4Matrix::assertValidBigColumn ); N4Matrix_exposer.def( "assertValidBigColumn" , assertValidBigColumn_function_value , ( bp::arg("j") ) , "Assert that there is an jth big column\nThrow: SireError::invalid_index\n" ); } { //::SireMaths::N4Matrix::assertValidBigRow typedef void ( ::SireMaths::N4Matrix::*assertValidBigRow_function_type)( int ) const; assertValidBigRow_function_type assertValidBigRow_function_value( &::SireMaths::N4Matrix::assertValidBigRow ); N4Matrix_exposer.def( "assertValidBigRow" , assertValidBigRow_function_value , ( bp::arg("i") ) , "Assert that there is an ith big row\nThrow: SireError::invalid_index\n" ); } { //::SireMaths::N4Matrix::assertValidColumn typedef void ( ::SireMaths::N4Matrix::*assertValidColumn_function_type)( int ) const; assertValidColumn_function_type assertValidColumn_function_value( &::SireMaths::N4Matrix::assertValidColumn ); N4Matrix_exposer.def( "assertValidColumn" , assertValidColumn_function_value , ( bp::arg("l") ) , "Assert that there is an lth column\nThrow: SireError::invalid_index\n" ); } { //::SireMaths::N4Matrix::assertValidIndex typedef void ( ::SireMaths::N4Matrix::*assertValidIndex_function_type)( int,int,int,int ) const; assertValidIndex_function_type assertValidIndex_function_value( &::SireMaths::N4Matrix::assertValidIndex ); N4Matrix_exposer.def( "assertValidIndex" , assertValidIndex_function_value , ( bp::arg("i"), bp::arg("j"), bp::arg("k"), bp::arg("l") ) , "Assert that the index [i,j,k,l] is valid for this matrix\nThrow: SireError::invalid_index\n" ); } { //::SireMaths::N4Matrix::assertValidRow typedef void ( ::SireMaths::N4Matrix::*assertValidRow_function_type)( int ) const; assertValidRow_function_type assertValidRow_function_value( &::SireMaths::N4Matrix::assertValidRow ); N4Matrix_exposer.def( "assertValidRow" , assertValidRow_function_value , ( bp::arg("k") ) , "Assert that there is an kth row\nThrow: SireError::invalid_index\n" ); } { //::SireMaths::N4Matrix::checkedOffset typedef int ( ::SireMaths::N4Matrix::*checkedOffset_function_type)( int,int,int,int ) const; checkedOffset_function_type checkedOffset_function_value( &::SireMaths::N4Matrix::checkedOffset ); N4Matrix_exposer.def( "checkedOffset" , checkedOffset_function_value , ( bp::arg("i"), bp::arg("j"), bp::arg("k"), bp::arg("l") ) , "Calculate the offset in the 1D array of the value\nat index [i,j,k,l]\nThrow: SireError::invalid_index\n" ); } { //::SireMaths::N4Matrix::memory typedef ::QVector< double > ( ::SireMaths::N4Matrix::*memory_function_type)( ) const; memory_function_type memory_function_value( &::SireMaths::N4Matrix::memory ); N4Matrix_exposer.def( "memory" , memory_function_value , "Return the raw QVector memory used by this matrix" ); } { //::SireMaths::N4Matrix::nBigColumns typedef int ( ::SireMaths::N4Matrix::*nBigColumns_function_type)( ) const; nBigColumns_function_type nBigColumns_function_value( &::SireMaths::N4Matrix::nBigColumns ); N4Matrix_exposer.def( "nBigColumns" , nBigColumns_function_value , "Return the number of big columns in this matrix" ); } { //::SireMaths::N4Matrix::nBigRows typedef int ( ::SireMaths::N4Matrix::*nBigRows_function_type)( ) const; nBigRows_function_type nBigRows_function_value( &::SireMaths::N4Matrix::nBigRows ); N4Matrix_exposer.def( "nBigRows" , nBigRows_function_value , "Return the number of big rows in this matrix" ); } { //::SireMaths::N4Matrix::nColumns typedef int ( ::SireMaths::N4Matrix::*nColumns_function_type)( ) const; nColumns_function_type nColumns_function_value( &::SireMaths::N4Matrix::nColumns ); N4Matrix_exposer.def( "nColumns" , nColumns_function_value , "Return the number of columns in this matrix" ); } { //::SireMaths::N4Matrix::nRows typedef int ( ::SireMaths::N4Matrix::*nRows_function_type)( ) const; nRows_function_type nRows_function_value( &::SireMaths::N4Matrix::nRows ); N4Matrix_exposer.def( "nRows" , nRows_function_value , "Return the number of rows in this matrix" ); } { //::SireMaths::N4Matrix::offset typedef int ( ::SireMaths::N4Matrix::*offset_function_type)( int,int,int,int ) const; offset_function_type offset_function_value( &::SireMaths::N4Matrix::offset ); N4Matrix_exposer.def( "offset" , offset_function_value , ( bp::arg("i"), bp::arg("j"), bp::arg("k"), bp::arg("l") ) , "" ); } N4Matrix_exposer.def( bp::self != bp::self ); { //::SireMaths::N4Matrix::operator() typedef double const & ( ::SireMaths::N4Matrix::*__call___function_type)( int,int,int,int ) const; __call___function_type __call___function_value( &::SireMaths::N4Matrix::operator() ); N4Matrix_exposer.def( "__call__" , __call___function_value , ( bp::arg("i"), bp::arg("j"), bp::arg("k"), bp::arg("l") ) , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireMaths::N4Matrix::operator() typedef ::SireMaths::NMatrix ( ::SireMaths::N4Matrix::*__call___function_type)( int,int ) const; __call___function_type __call___function_value( &::SireMaths::N4Matrix::operator() ); N4Matrix_exposer.def( "__call__" , __call___function_value , ( bp::arg("i"), bp::arg("j") ) , "" ); } N4Matrix_exposer.def( bp::self * bp::other< double >() ); N4Matrix_exposer.def( bp::self + bp::self ); N4Matrix_exposer.def( -bp::self ); N4Matrix_exposer.def( bp::self - bp::self ); N4Matrix_exposer.def( bp::self / bp::other< double >() ); { //::SireMaths::N4Matrix::operator= typedef ::SireMaths::N4Matrix & ( ::SireMaths::N4Matrix::*assign_function_type)( ::SireMaths::N4Matrix const & ) ; assign_function_type assign_function_value( &::SireMaths::N4Matrix::operator= ); N4Matrix_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } N4Matrix_exposer.def( bp::self == bp::self ); { //::SireMaths::N4Matrix::redimension typedef void ( ::SireMaths::N4Matrix::*redimension_function_type)( int,int,int,int ) ; redimension_function_type redimension_function_value( &::SireMaths::N4Matrix::redimension ); N4Matrix_exposer.def( "redimension" , redimension_function_value , ( bp::arg("nbigrows"), bp::arg("nbigcolumns"), bp::arg("nrows"), bp::arg("ncolumns") ) , "Redimension this matrix to have nbigrows big rows,\nnbigcolumns big columns, nrows rows and ncolumns\ncolumns. The contents of this matrix are undefined after\nthis redimension. This function will only reallocate\nmemory if there is not enough memory allocated to store\nthe new matrix. Use this function if you want to use\nthe same piece of memory over and over again for lots\nof different size matricies - just create a matrix with\nthe maximum dimension, then call this redimension function\nwhenever you want to change. It is very fast, as it just\nupdates the internal record of the size of the matrix" ); } { //::SireMaths::N4Matrix::set typedef void ( ::SireMaths::N4Matrix::*set_function_type)( int,int,::SireMaths::NMatrix const & ) ; set_function_type set_function_value( &::SireMaths::N4Matrix::set ); N4Matrix_exposer.def( "set" , set_function_value , ( bp::arg("i"), bp::arg("j"), bp::arg("matrix") ) , "Set the view at [i,j] equal to matrix\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" ); } { //::SireMaths::N4Matrix::set typedef void ( ::SireMaths::N4Matrix::*set_function_type)( int,int,int,int,double ) ; set_function_type set_function_value( &::SireMaths::N4Matrix::set ); N4Matrix_exposer.def( "set" , set_function_value , ( bp::arg("i"), bp::arg("j"), bp::arg("k"), bp::arg("l"), bp::arg("value") ) , "Set the value at [i,j,k,l] equal to value\nThrow: SireError::invalid_index\n" ); } { //::SireMaths::N4Matrix::setAll typedef void ( ::SireMaths::N4Matrix::*setAll_function_type)( double ) ; setAll_function_type setAll_function_value( &::SireMaths::N4Matrix::setAll ); N4Matrix_exposer.def( "setAll" , setAll_function_value , ( bp::arg("value") ) , "Set all entries in the matrix to the value value" ); } { //::SireMaths::N4Matrix::subtract typedef void ( ::SireMaths::N4Matrix::*subtract_function_type)( int,int,::SireMaths::NMatrix const & ) ; subtract_function_type subtract_function_value( &::SireMaths::N4Matrix::subtract ); N4Matrix_exposer.def( "subtract" , subtract_function_value , ( bp::arg("i"), bp::arg("j"), bp::arg("matrix") ) , "Subtract the contents of matrix from the sub-matrix view at [i,j]\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" ); } { //::SireMaths::N4Matrix::toString typedef ::QString ( ::SireMaths::N4Matrix::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMaths::N4Matrix::toString ); N4Matrix_exposer.def( "toString" , toString_function_value , "Return a string representation of this matrix" ); } { //::SireMaths::N4Matrix::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMaths::N4Matrix::typeName ); N4Matrix_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMaths::N4Matrix::view typedef ::SireMaths::NMatrix ( ::SireMaths::N4Matrix::*view_function_type)( int,int ) const; view_function_type view_function_value( &::SireMaths::N4Matrix::view ); N4Matrix_exposer.def( "view" , view_function_value , ( bp::arg("i"), bp::arg("j") ) , "Return the sub-matrix view at [i,j,k,l]\nThrow: SireError::invalid_index\n" ); } { //::SireMaths::N4Matrix::what typedef char const * ( ::SireMaths::N4Matrix::*what_function_type)( ) const; what_function_type what_function_value( &::SireMaths::N4Matrix::what ); N4Matrix_exposer.def( "what" , what_function_value , "" ); } N4Matrix_exposer.staticmethod( "typeName" ); N4Matrix_exposer.def( "__copy__", &__copy__); N4Matrix_exposer.def( "__deepcopy__", &__copy__); N4Matrix_exposer.def( "clone", &__copy__); N4Matrix_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::N4Matrix >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); N4Matrix_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::N4Matrix >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); N4Matrix_exposer.def( "__str__", &__str__< ::SireMaths::N4Matrix > ); N4Matrix_exposer.def( "__repr__", &__str__< ::SireMaths::N4Matrix > ); } }
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_MolEditor_class(){ { //::SireMol::MolEditor typedef bp::class_< SireMol::MolEditor, bp::bases< SireMol::Editor<SireMol::MolEditor, SireMol::Molecule>, SireMol::Molecule, SireMol::MoleculeView, SireBase::Property > > MolEditor_exposer_t; MolEditor_exposer_t MolEditor_exposer = MolEditor_exposer_t( "MolEditor", "This class is used to edit non-structural parts of a molecule\n(e.g. its name, number, properties etc.). To add, move or remove\natoms, residues, CutGroups, chains or segments, you need to\nuse a MolStructureEditor (which is created for you automatically\nby member functions that perform such editing)\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") ); bp::scope MolEditor_scope( MolEditor_exposer ); MolEditor_exposer.def( bp::init< SireMol::Molecule const & >(( bp::arg("molecule") ), "Construct an editor to edit a copy of molecule") ); MolEditor_exposer.def( bp::init< SireMol::MolEditor const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMol::MolEditor::add typedef ::SireMol::AtomStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::AtomName const & ) const; add_function_type add_function_value( &::SireMol::MolEditor::add ); MolEditor_exposer.def( "add" , add_function_value , ( bp::arg("atom") ) , "Add an atom called name and return an editor that can\nbe used to edit it" ); } { //::SireMol::MolEditor::add typedef ::SireMol::AtomStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::AtomNum const & ) const; add_function_type add_function_value( &::SireMol::MolEditor::add ); MolEditor_exposer.def( "add" , add_function_value , ( bp::arg("atom") ) , "Add an atom with number number and return an editor that\ncan be used to edit it" ); } { //::SireMol::MolEditor::add typedef ::SireMol::ResStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::ResName const & ) const; add_function_type add_function_value( &::SireMol::MolEditor::add ); MolEditor_exposer.def( "add" , add_function_value , ( bp::arg("residue") ) , "Add a residue called name and return an editor that can\nbe used to edit it" ); } { //::SireMol::MolEditor::add typedef ::SireMol::ResStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::ResNum const & ) const; add_function_type add_function_value( &::SireMol::MolEditor::add ); MolEditor_exposer.def( "add" , add_function_value , ( bp::arg("residue") ) , "Add a residue with number number and return an editor that\ncan be used to edit it" ); } { //::SireMol::MolEditor::add typedef ::SireMol::CGStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::CGName const & ) const; add_function_type add_function_value( &::SireMol::MolEditor::add ); MolEditor_exposer.def( "add" , add_function_value , ( bp::arg("cutgroup") ) , "Add a CutGroup called name and return an editor that can\nbe used to edit it" ); } { //::SireMol::MolEditor::add typedef ::SireMol::ChainStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::ChainName const & ) const; add_function_type add_function_value( &::SireMol::MolEditor::add ); MolEditor_exposer.def( "add" , add_function_value , ( bp::arg("chain") ) , "Add a chain called name and return an editor that can\nbe used to edit it" ); } { //::SireMol::MolEditor::add typedef ::SireMol::SegStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::SegName const & ) const; add_function_type add_function_value( &::SireMol::MolEditor::add ); MolEditor_exposer.def( "add" , add_function_value , ( bp::arg("segment") ) , "Add a segment called name and return an editor that can\nbe used to edit it" ); } { //::SireMol::MolEditor::commit typedef ::SireMol::Molecule ( ::SireMol::MolEditor::*commit_function_type)( ) const; commit_function_type commit_function_value( &::SireMol::MolEditor::commit ); MolEditor_exposer.def( "commit" , commit_function_value , "Commit these changes and return a copy of the\nedited molecule" ); } { //::SireMol::MolEditor::operator= typedef ::SireMol::MolEditor & ( ::SireMol::MolEditor::*assign_function_type)( ::SireMol::Molecule const & ) ; assign_function_type assign_function_value( &::SireMol::MolEditor::operator= ); MolEditor_exposer.def( "assign" , assign_function_value , ( bp::arg("molecule") ) , bp::return_self< >() , "" ); } { //::SireMol::MolEditor::operator= typedef ::SireMol::MolEditor & ( ::SireMol::MolEditor::*assign_function_type)( ::SireMol::MolEditor const & ) ; assign_function_type assign_function_value( &::SireMol::MolEditor::operator= ); MolEditor_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } { //::SireMol::MolEditor::remove typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*remove_function_type)( ::SireMol::AtomID const & ) const; remove_function_type remove_function_value( &::SireMol::MolEditor::remove ); MolEditor_exposer.def( "remove" , remove_function_value , ( bp::arg("atomid") ) , "Remove all atoms from this molecule that have the ID atomid.\nThis does nothing if there are no atoms with this ID.\nThis returns an editor that can be used to further edit\nthe molecule" ); } { //::SireMol::MolEditor::remove typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*remove_function_type)( ::SireMol::CGID const & ) const; remove_function_type remove_function_value( &::SireMol::MolEditor::remove ); MolEditor_exposer.def( "remove" , remove_function_value , ( bp::arg("cgid") ) , "Remove all CutGroups from this molecule that have the ID atomid.\nThis does nothing if there are no CutGroups with this ID.\nThis returns an editor that can be used to further edit\nthe molecule" ); } { //::SireMol::MolEditor::remove typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*remove_function_type)( ::SireMol::ResID const & ) const; remove_function_type remove_function_value( &::SireMol::MolEditor::remove ); MolEditor_exposer.def( "remove" , remove_function_value , ( bp::arg("resid") ) , "Remove all residues from this molecule that have the ID atomid.\nThis does nothing if there are no residues with this ID.\nThis returns an editor that can be used to further edit\nthe molecule" ); } { //::SireMol::MolEditor::remove typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*remove_function_type)( ::SireMol::ChainID const & ) const; remove_function_type remove_function_value( &::SireMol::MolEditor::remove ); MolEditor_exposer.def( "remove" , remove_function_value , ( bp::arg("chainid") ) , "Remove all chains from this molecule that have the ID atomid.\nThis does nothing if there are no chains with this ID.\nThis returns an editor that can be used to further edit\nthe molecule" ); } { //::SireMol::MolEditor::remove typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*remove_function_type)( ::SireMol::SegID const & ) const; remove_function_type remove_function_value( &::SireMol::MolEditor::remove ); MolEditor_exposer.def( "remove" , remove_function_value , ( bp::arg("segid") ) , "Remove all segments from this molecule that have the ID atomid.\nThis does nothing if there are no segments with this ID.\nThis returns an editor that can be used to further edit\nthe molecule" ); } { //::SireMol::MolEditor::removeAllAtoms typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*removeAllAtoms_function_type)( ) const; removeAllAtoms_function_type removeAllAtoms_function_value( &::SireMol::MolEditor::removeAllAtoms ); MolEditor_exposer.def( "removeAllAtoms" , removeAllAtoms_function_value , "Remove all atoms from this molecule. This returns an editor that\ncan be used to further edit the structure of this molecule" ); } { //::SireMol::MolEditor::removeAllChains typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*removeAllChains_function_type)( ) const; removeAllChains_function_type removeAllChains_function_value( &::SireMol::MolEditor::removeAllChains ); MolEditor_exposer.def( "removeAllChains" , removeAllChains_function_value , "Remove all chains from this molecule. This returns an editor that\ncan be used to further edit the structure of this molecule" ); } { //::SireMol::MolEditor::removeAllCutGroups typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*removeAllCutGroups_function_type)( ) const; removeAllCutGroups_function_type removeAllCutGroups_function_value( &::SireMol::MolEditor::removeAllCutGroups ); MolEditor_exposer.def( "removeAllCutGroups" , removeAllCutGroups_function_value , "Remove all CutGroups from this molecule. This returns an editor that\ncan be used to further edit the structure of this molecule" ); } { //::SireMol::MolEditor::removeAllResidues typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*removeAllResidues_function_type)( ) const; removeAllResidues_function_type removeAllResidues_function_value( &::SireMol::MolEditor::removeAllResidues ); MolEditor_exposer.def( "removeAllResidues" , removeAllResidues_function_value , "Remove all residues from this molecule. This returns an editor that\ncan be used to further edit the structure of this molecule" ); } { //::SireMol::MolEditor::removeAllSegments typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*removeAllSegments_function_type)( ) const; removeAllSegments_function_type removeAllSegments_function_value( &::SireMol::MolEditor::removeAllSegments ); MolEditor_exposer.def( "removeAllSegments" , removeAllSegments_function_value , "Remove all segments from this molecule. This returns an editor that\ncan be used to further edit the structure of this molecule" ); } { //::SireMol::MolEditor::rename typedef ::SireMol::MolEditor & ( ::SireMol::MolEditor::*rename_function_type)( ::QString const & ) ; rename_function_type rename_function_value( &::SireMol::MolEditor::rename ); MolEditor_exposer.def( "rename" , rename_function_value , ( bp::arg("name") ) , bp::return_self< >() , "Rename this molecule to newname" ); } { //::SireMol::MolEditor::renumber typedef ::SireMol::MolEditor & ( ::SireMol::MolEditor::*renumber_function_type)( ) ; renumber_function_type renumber_function_value( &::SireMol::MolEditor::renumber ); MolEditor_exposer.def( "renumber" , renumber_function_value , bp::return_self< >() , "Give this molecule a new, unique ID number" ); } { //::SireMol::MolEditor::renumber typedef ::SireMol::MolEditor & ( ::SireMol::MolEditor::*renumber_function_type)( ::SireMol::MolNum ) ; renumber_function_type renumber_function_value( &::SireMol::MolEditor::renumber ); MolEditor_exposer.def( "renumber" , renumber_function_value , ( bp::arg("newnum") ) , bp::return_self< >() , "Give this molecule the ID number newnum" ); } { //::SireMol::MolEditor::toString typedef ::QString ( ::SireMol::MolEditor::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMol::MolEditor::toString ); MolEditor_exposer.def( "toString" , toString_function_value , "Return a string representation of this editor" ); } { //::SireMol::MolEditor::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::MolEditor::typeName ); MolEditor_exposer.def( "typeName" , typeName_function_value , "" ); } MolEditor_exposer.staticmethod( "typeName" ); MolEditor_exposer.def( "__copy__", &__copy__); MolEditor_exposer.def( "__deepcopy__", &__copy__); MolEditor_exposer.def( "clone", &__copy__); MolEditor_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::MolEditor >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); MolEditor_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::MolEditor >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); MolEditor_exposer.def( "__str__", &__str__< ::SireMol::MolEditor > ); MolEditor_exposer.def( "__repr__", &__str__< ::SireMol::MolEditor > ); } }
void register_RestraintFF_class(){ { //::SireMM::RestraintFF typedef bp::class_< SireMM::RestraintFF, bp::bases< SireFF::FF3D, SireFF::G1FF, SireFF::FF, SireMol::MolGroupsBase, SireBase::Property > > RestraintFF_exposer_t; RestraintFF_exposer_t RestraintFF_exposer = RestraintFF_exposer_t( "RestraintFF", bp::init< >() ); bp::scope RestraintFF_scope( RestraintFF_exposer ); RestraintFF_exposer.def( bp::init< QString const & >(( bp::arg("name") )) ); RestraintFF_exposer.def( bp::init< SireMM::RestraintFF const & >(( bp::arg("other") )) ); { //::SireMM::RestraintFF::add typedef bool ( ::SireMM::RestraintFF::*add_function_type )( ::SireMM::Restraint3D const & ) ; add_function_type add_function_value( &::SireMM::RestraintFF::add ); RestraintFF_exposer.def( "add" , add_function_value , ( bp::arg("restraint") ) ); } { //::SireMM::RestraintFF::builtinSymbols typedef ::SireCAS::Symbols ( ::SireMM::RestraintFF::*builtinSymbols_function_type )( ) const; builtinSymbols_function_type builtinSymbols_function_value( &::SireMM::RestraintFF::builtinSymbols ); RestraintFF_exposer.def( "builtinSymbols" , builtinSymbols_function_value ); } { //::SireMM::RestraintFF::components typedef ::SireMM::RestraintComponent const & ( ::SireMM::RestraintFF::*components_function_type )( ) const; components_function_type components_function_value( &::SireMM::RestraintFF::components ); RestraintFF_exposer.def( "components" , components_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::RestraintFF::contains typedef bool ( ::SireMM::RestraintFF::*contains_function_type )( ::SireMM::Restraint3D const & ) const; contains_function_type contains_function_value( &::SireMM::RestraintFF::contains ); RestraintFF_exposer.def( "contains" , contains_function_value , ( bp::arg("restraint") ) ); } { //::SireMM::RestraintFF::containsProperty typedef bool ( ::SireMM::RestraintFF::*containsProperty_function_type )( ::QString const & ) const; containsProperty_function_type containsProperty_function_value( &::SireMM::RestraintFF::containsProperty ); RestraintFF_exposer.def( "containsProperty" , containsProperty_function_value , ( bp::arg("name") ) ); } { //::SireMM::RestraintFF::differentiate typedef ::SireMM::RestraintFF ( ::SireMM::RestraintFF::*differentiate_function_type )( ::SireCAS::Symbol const & ) const; differentiate_function_type differentiate_function_value( &::SireMM::RestraintFF::differentiate ); RestraintFF_exposer.def( "differentiate" , differentiate_function_value , ( bp::arg("symbol") ) ); } { //::SireMM::RestraintFF::field typedef void ( ::SireMM::RestraintFF::*field_function_type )( ::SireFF::FieldTable &,double ) ; field_function_type field_function_value( &::SireMM::RestraintFF::field ); RestraintFF_exposer.def( "field" , field_function_value , ( bp::arg("fieldtable"), bp::arg("scale_field")=1 ) ); } { //::SireMM::RestraintFF::field typedef void ( ::SireMM::RestraintFF::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,double ) ; field_function_type field_function_value( &::SireMM::RestraintFF::field ); RestraintFF_exposer.def( "field" , field_function_value , ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("scale_field")=1 ) ); } { //::SireMM::RestraintFF::field typedef void ( ::SireMM::RestraintFF::*field_function_type )( ::SireFF::FieldTable &,::SireFF::Probe const &,double ) ; field_function_type field_function_value( &::SireMM::RestraintFF::field ); RestraintFF_exposer.def( "field" , field_function_value , ( bp::arg("fieldtable"), bp::arg("probe"), bp::arg("scale_field")=1 ) ); } { //::SireMM::RestraintFF::field typedef void ( ::SireMM::RestraintFF::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ; field_function_type field_function_value( &::SireMM::RestraintFF::field ); RestraintFF_exposer.def( "field" , field_function_value , ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_field")=1 ) ); } { //::SireMM::RestraintFF::force typedef void ( ::SireMM::RestraintFF::*force_function_type )( ::SireFF::ForceTable &,double ) ; force_function_type force_function_value( &::SireMM::RestraintFF::force ); RestraintFF_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) ); } { //::SireMM::RestraintFF::force typedef void ( ::SireMM::RestraintFF::*force_function_type )( ::SireFF::ForceTable &,::SireCAS::Symbol const &,double ) ; force_function_type force_function_value( &::SireMM::RestraintFF::force ); RestraintFF_exposer.def( "force" , force_function_value , ( bp::arg("forcetable"), bp::arg("symbol"), bp::arg("scale_force")=1 ) ); } { //::SireMM::RestraintFF::getValue typedef double ( ::SireMM::RestraintFF::*getValue_function_type )( ::SireCAS::Symbol const & ) const; getValue_function_type getValue_function_value( &::SireMM::RestraintFF::getValue ); RestraintFF_exposer.def( "getValue" , getValue_function_value , ( bp::arg("symbol") ) ); } { //::SireMM::RestraintFF::hasValue typedef bool ( ::SireMM::RestraintFF::*hasValue_function_type )( ::SireCAS::Symbol const & ) const; hasValue_function_type hasValue_function_value( &::SireMM::RestraintFF::hasValue ); RestraintFF_exposer.def( "hasValue" , hasValue_function_value , ( bp::arg("symbol") ) ); } { //::SireMM::RestraintFF::mustNowRecalculateFromScratch typedef void ( ::SireMM::RestraintFF::*mustNowRecalculateFromScratch_function_type )( ) ; mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::SireMM::RestraintFF::mustNowRecalculateFromScratch ); RestraintFF_exposer.def( "mustNowRecalculateFromScratch" , mustNowRecalculateFromScratch_function_value ); } { //::SireMM::RestraintFF::nRestraints typedef int ( ::SireMM::RestraintFF::*nRestraints_function_type )( ) const; nRestraints_function_type nRestraints_function_value( &::SireMM::RestraintFF::nRestraints ); RestraintFF_exposer.def( "nRestraints" , nRestraints_function_value ); } RestraintFF_exposer.def( bp::self != bp::self ); { //::SireMM::RestraintFF::operator= typedef ::SireMM::RestraintFF & ( ::SireMM::RestraintFF::*assign_function_type )( ::SireMM::RestraintFF const & ) ; assign_function_type assign_function_value( &::SireMM::RestraintFF::operator= ); RestraintFF_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } RestraintFF_exposer.def( bp::self == bp::self ); { //::SireMM::RestraintFF::potential typedef void ( ::SireMM::RestraintFF::*potential_function_type )( ::SireFF::PotentialTable &,double ) ; potential_function_type potential_function_value( &::SireMM::RestraintFF::potential ); RestraintFF_exposer.def( "potential" , potential_function_value , ( bp::arg("potentialtable"), bp::arg("scale_potential")=1 ) ); } { //::SireMM::RestraintFF::potential typedef void ( ::SireMM::RestraintFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,double ) ; potential_function_type potential_function_value( &::SireMM::RestraintFF::potential ); RestraintFF_exposer.def( "potential" , potential_function_value , ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("scale_potential")=1 ) ); } { //::SireMM::RestraintFF::potential typedef void ( ::SireMM::RestraintFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireFF::Probe const &,double ) ; potential_function_type potential_function_value( &::SireMM::RestraintFF::potential ); RestraintFF_exposer.def( "potential" , potential_function_value , ( bp::arg("potentialtable"), bp::arg("probe"), bp::arg("scale_potential")=1 ) ); } { //::SireMM::RestraintFF::potential typedef void ( ::SireMM::RestraintFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ; potential_function_type potential_function_value( &::SireMM::RestraintFF::potential ); RestraintFF_exposer.def( "potential" , potential_function_value , ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_potential")=1 ) ); } { //::SireMM::RestraintFF::properties typedef ::SireBase::Properties const & ( ::SireMM::RestraintFF::*properties_function_type )( ) const; properties_function_type properties_function_value( &::SireMM::RestraintFF::properties ); RestraintFF_exposer.def( "properties" , properties_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMM::RestraintFF::property typedef ::SireBase::Property const & ( ::SireMM::RestraintFF::*property_function_type )( ::QString const & ) const; property_function_type property_function_value( &::SireMM::RestraintFF::property ); RestraintFF_exposer.def( "property" , property_function_value , ( bp::arg("name") ) , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::RestraintFF::remove typedef bool ( ::SireMM::RestraintFF::*remove_function_type )( ::SireMM::Restraint3D const & ) ; remove_function_type remove_function_value( &::SireMM::RestraintFF::remove ); RestraintFF_exposer.def( "remove" , remove_function_value , ( bp::arg("restraint") ) ); } { //::SireMM::RestraintFF::removeRestraintAt typedef void ( ::SireMM::RestraintFF::*removeRestraintAt_function_type )( int ) ; removeRestraintAt_function_type removeRestraintAt_function_value( &::SireMM::RestraintFF::removeRestraintAt ); RestraintFF_exposer.def( "removeRestraintAt" , removeRestraintAt_function_value , ( bp::arg("i") ) ); } { //::SireMM::RestraintFF::restraintAt typedef ::SireMM::Restraint3D const & ( ::SireMM::RestraintFF::*restraintAt_function_type )( int ) const; restraintAt_function_type restraintAt_function_value( &::SireMM::RestraintFF::restraintAt ); RestraintFF_exposer.def( "restraintAt" , restraintAt_function_value , ( bp::arg("i") ) , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::RestraintFF::restraints typedef ::QVector< SireBase::PropPtr< SireMM::Restraint3D > > ( ::SireMM::RestraintFF::*restraints_function_type )( ) const; restraints_function_type restraints_function_value( &::SireMM::RestraintFF::restraints ); RestraintFF_exposer.def( "restraints" , restraints_function_value ); } { //::SireMM::RestraintFF::setProperty typedef bool ( ::SireMM::RestraintFF::*setProperty_function_type )( ::QString const &,::SireBase::Property const & ) ; setProperty_function_type setProperty_function_value( &::SireMM::RestraintFF::setProperty ); RestraintFF_exposer.def( "setProperty" , setProperty_function_value , ( bp::arg("name"), bp::arg("property") ) ); } { //::SireMM::RestraintFF::setSpace typedef bool ( ::SireMM::RestraintFF::*setSpace_function_type )( ::SireVol::Space const & ) ; setSpace_function_type setSpace_function_value( &::SireMM::RestraintFF::setSpace ); RestraintFF_exposer.def( "setSpace" , setSpace_function_value , ( bp::arg("space") ) ); } { //::SireMM::RestraintFF::setValue typedef bool ( ::SireMM::RestraintFF::*setValue_function_type )( ::SireCAS::Symbol const &,double ) ; setValue_function_type setValue_function_value( &::SireMM::RestraintFF::setValue ); RestraintFF_exposer.def( "setValue" , setValue_function_value , ( bp::arg("symbol"), bp::arg("value") ) ); } { //::SireMM::RestraintFF::space typedef ::SireVol::Space const & ( ::SireMM::RestraintFF::*space_function_type )( ) const; space_function_type space_function_value( &::SireMM::RestraintFF::space ); RestraintFF_exposer.def( "space" , space_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMM::RestraintFF::symbols typedef ::SireCAS::Symbols ( ::SireMM::RestraintFF::*symbols_function_type )( ) const; symbols_function_type symbols_function_value( &::SireMM::RestraintFF::symbols ); RestraintFF_exposer.def( "symbols" , symbols_function_value ); } { //::SireMM::RestraintFF::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMM::RestraintFF::typeName ); RestraintFF_exposer.def( "typeName" , typeName_function_value ); } { //::SireMM::RestraintFF::userSymbols typedef ::SireCAS::Symbols ( ::SireMM::RestraintFF::*userSymbols_function_type )( ) const; userSymbols_function_type userSymbols_function_value( &::SireMM::RestraintFF::userSymbols ); RestraintFF_exposer.def( "userSymbols" , userSymbols_function_value ); } { //::SireMM::RestraintFF::userValues typedef ::SireCAS::Values ( ::SireMM::RestraintFF::*userValues_function_type )( ) const; userValues_function_type userValues_function_value( &::SireMM::RestraintFF::userValues ); RestraintFF_exposer.def( "userValues" , userValues_function_value ); } RestraintFF_exposer.staticmethod( "typeName" ); RestraintFF_exposer.def( "__copy__", &__copy__); RestraintFF_exposer.def( "__deepcopy__", &__copy__); RestraintFF_exposer.def( "clone", &__copy__); RestraintFF_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::RestraintFF >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); RestraintFF_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::RestraintFF >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); RestraintFF_exposer.def( "__str__", &__str__< ::SireMM::RestraintFF > ); RestraintFF_exposer.def( "__repr__", &__str__< ::SireMM::RestraintFF > ); RestraintFF_exposer.def( "__len__", &__len_count< ::SireMM::RestraintFF > ); } }
void register_TI_class(){ { //::SireAnalysis::TI typedef bp::class_< SireAnalysis::TI, bp::bases< SireBase::Property > > TI_exposer_t; TI_exposer_t TI_exposer = TI_exposer_t( "TI", bp::init< >() ); bp::scope TI_scope( TI_exposer ); TI_exposer.def( bp::init< SireAnalysis::Gradients const & >(( bp::arg("gradients") )) ); TI_exposer.def( bp::init< QList< SireAnalysis::Gradients > const & >(( bp::arg("gradients") )) ); TI_exposer.def( bp::init< SireAnalysis::TI const & >(( bp::arg("other") )) ); { //::SireAnalysis::TI::add typedef void ( ::SireAnalysis::TI::*add_function_type )( ::QMap< double, SireMaths::AverageAndStddev > const & ) ; add_function_type add_function_value( &::SireAnalysis::TI::add ); TI_exposer.def( "add" , add_function_value , ( bp::arg("gradients") ) ); } { //::SireAnalysis::TI::add typedef void ( ::SireAnalysis::TI::*add_function_type )( ::QMap< double, SireMaths::FreeEnergyAverage > const & ) ; add_function_type add_function_value( &::SireAnalysis::TI::add ); TI_exposer.def( "add" , add_function_value , ( bp::arg("gradients") ) ); } { //::SireAnalysis::TI::add typedef void ( ::SireAnalysis::TI::*add_function_type )( ::QMap< double, SireMaths::FreeEnergyAverage > const &,double ) ; add_function_type add_function_value( &::SireAnalysis::TI::add ); TI_exposer.def( "add" , add_function_value , ( bp::arg("gradients"), bp::arg("delta_lambda") ) ); } { //::SireAnalysis::TI::add typedef void ( ::SireAnalysis::TI::*add_function_type )( ::QMap< double, SireMaths::FreeEnergyAverage > const &,::QMap< double, SireMaths::FreeEnergyAverage > const &,double ) ; add_function_type add_function_value( &::SireAnalysis::TI::add ); TI_exposer.def( "add" , add_function_value , ( bp::arg("forwards"), bp::arg("backwards"), bp::arg("delta_lambda") ) ); } { //::SireAnalysis::TI::add typedef void ( ::SireAnalysis::TI::*add_function_type )( ::SireAnalysis::Gradients const & ) ; add_function_type add_function_value( &::SireAnalysis::TI::add ); TI_exposer.def( "add" , add_function_value , ( bp::arg("gradients") ) ); } { //::SireAnalysis::TI::at typedef ::SireAnalysis::Gradients ( ::SireAnalysis::TI::*at_function_type )( int ) const; at_function_type at_function_value( &::SireAnalysis::TI::at ); TI_exposer.def( "at" , at_function_value , ( bp::arg("i") ) ); } { //::SireAnalysis::TI::clear typedef void ( ::SireAnalysis::TI::*clear_function_type )( ) ; clear_function_type clear_function_value( &::SireAnalysis::TI::clear ); TI_exposer.def( "clear" , clear_function_value ); } { //::SireAnalysis::TI::count typedef int ( ::SireAnalysis::TI::*count_function_type )( ) const; count_function_type count_function_value( &::SireAnalysis::TI::count ); TI_exposer.def( "count" , count_function_value ); } { //::SireAnalysis::TI::gradients typedef ::QList< SireAnalysis::Gradients > ( ::SireAnalysis::TI::*gradients_function_type )( ) const; gradients_function_type gradients_function_value( &::SireAnalysis::TI::gradients ); TI_exposer.def( "gradients" , gradients_function_value ); } { //::SireAnalysis::TI::lambdaValues typedef ::QList< double > ( ::SireAnalysis::TI::*lambdaValues_function_type )( ) const; lambdaValues_function_type lambdaValues_function_value( &::SireAnalysis::TI::lambdaValues ); TI_exposer.def( "lambdaValues" , lambdaValues_function_value ); } { //::SireAnalysis::TI::merge typedef ::SireAnalysis::Gradients ( ::SireAnalysis::TI::*merge_function_type )( int,int ) const; merge_function_type merge_function_value( &::SireAnalysis::TI::merge ); TI_exposer.def( "merge" , merge_function_value , ( bp::arg("start"), bp::arg("end") ) ); } { //::SireAnalysis::TI::merge typedef ::SireAnalysis::Gradients ( ::SireAnalysis::TI::*merge_function_type )( ::QList< int > ) const; merge_function_type merge_function_value( &::SireAnalysis::TI::merge ); TI_exposer.def( "merge" , merge_function_value , ( bp::arg("indicies") ) ); } { //::SireAnalysis::TI::nIterations typedef int ( ::SireAnalysis::TI::*nIterations_function_type )( ) const; nIterations_function_type nIterations_function_value( &::SireAnalysis::TI::nIterations ); TI_exposer.def( "nIterations" , nIterations_function_value ); } { //::SireAnalysis::TI::nLambdaValues typedef int ( ::SireAnalysis::TI::*nLambdaValues_function_type )( ) const; nLambdaValues_function_type nLambdaValues_function_value( &::SireAnalysis::TI::nLambdaValues ); TI_exposer.def( "nLambdaValues" , nLambdaValues_function_value ); } { //::SireAnalysis::TI::nSamples typedef ::qint64 ( ::SireAnalysis::TI::*nSamples_function_type )( ) const; nSamples_function_type nSamples_function_value( &::SireAnalysis::TI::nSamples ); TI_exposer.def( "nSamples" , nSamples_function_value ); } TI_exposer.def( bp::self != bp::self ); { //::SireAnalysis::TI::operator= typedef ::SireAnalysis::TI & ( ::SireAnalysis::TI::*assign_function_type )( ::SireAnalysis::TI const & ) ; assign_function_type assign_function_value( &::SireAnalysis::TI::operator= ); TI_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } TI_exposer.def( bp::self == bp::self ); { //::SireAnalysis::TI::operator[] typedef ::SireAnalysis::Gradients ( ::SireAnalysis::TI::*__getitem___function_type )( int ) const; __getitem___function_type __getitem___function_value( &::SireAnalysis::TI::operator[] ); TI_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) ); } { //::SireAnalysis::TI::removeAt typedef void ( ::SireAnalysis::TI::*removeAt_function_type )( int ) ; removeAt_function_type removeAt_function_value( &::SireAnalysis::TI::removeAt ); TI_exposer.def( "removeAt" , removeAt_function_value , ( bp::arg("i") ) ); } { //::SireAnalysis::TI::removeRange typedef void ( ::SireAnalysis::TI::*removeRange_function_type )( int,int ) ; removeRange_function_type removeRange_function_value( &::SireAnalysis::TI::removeRange ); TI_exposer.def( "removeRange" , removeRange_function_value , ( bp::arg("start"), bp::arg("end") ) ); } { //::SireAnalysis::TI::rollingAverage typedef ::QList< SireAnalysis::Gradients > ( ::SireAnalysis::TI::*rollingAverage_function_type )( int ) const; rollingAverage_function_type rollingAverage_function_value( &::SireAnalysis::TI::rollingAverage ); TI_exposer.def( "rollingAverage" , rollingAverage_function_value , ( bp::arg("niterations") ) ); } { //::SireAnalysis::TI::set typedef void ( ::SireAnalysis::TI::*set_function_type )( int,::QMap< double, SireMaths::AverageAndStddev > const & ) ; set_function_type set_function_value( &::SireAnalysis::TI::set ); TI_exposer.def( "set" , set_function_value , ( bp::arg("i"), bp::arg("gradients") ) ); } { //::SireAnalysis::TI::set typedef void ( ::SireAnalysis::TI::*set_function_type )( int,::QMap< double, SireMaths::FreeEnergyAverage > const & ) ; set_function_type set_function_value( &::SireAnalysis::TI::set ); TI_exposer.def( "set" , set_function_value , ( bp::arg("i"), bp::arg("gradients") ) ); } { //::SireAnalysis::TI::set typedef void ( ::SireAnalysis::TI::*set_function_type )( int,::QMap< double, SireMaths::FreeEnergyAverage > const &,double ) ; set_function_type set_function_value( &::SireAnalysis::TI::set ); TI_exposer.def( "set" , set_function_value , ( bp::arg("i"), bp::arg("gradients"), bp::arg("delta_lambda") ) ); } { //::SireAnalysis::TI::set typedef void ( ::SireAnalysis::TI::*set_function_type )( int,::QMap< double, SireMaths::FreeEnergyAverage > const &,::QMap< double, SireMaths::FreeEnergyAverage > const &,double ) ; set_function_type set_function_value( &::SireAnalysis::TI::set ); TI_exposer.def( "set" , set_function_value , ( bp::arg("i"), bp::arg("forwards"), bp::arg("backwards"), bp::arg("delta_lambda") ) ); } { //::SireAnalysis::TI::set typedef void ( ::SireAnalysis::TI::*set_function_type )( int,::SireAnalysis::Gradients const & ) ; set_function_type set_function_value( &::SireAnalysis::TI::set ); TI_exposer.def( "set" , set_function_value , ( bp::arg("i"), bp::arg("gradients") ) ); } { //::SireAnalysis::TI::size typedef int ( ::SireAnalysis::TI::*size_function_type )( ) const; size_function_type size_function_value( &::SireAnalysis::TI::size ); TI_exposer.def( "size" , size_function_value ); } { //::SireAnalysis::TI::toString typedef ::QString ( ::SireAnalysis::TI::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireAnalysis::TI::toString ); TI_exposer.def( "toString" , toString_function_value ); } { //::SireAnalysis::TI::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireAnalysis::TI::typeName ); TI_exposer.def( "typeName" , typeName_function_value ); } { //::SireAnalysis::TI::what typedef char const * ( ::SireAnalysis::TI::*what_function_type )( ) const; what_function_type what_function_value( &::SireAnalysis::TI::what ); TI_exposer.def( "what" , what_function_value ); } TI_exposer.staticmethod( "typeName" ); TI_exposer.def( "__copy__", &__copy__); TI_exposer.def( "__deepcopy__", &__copy__); TI_exposer.def( "clone", &__copy__); TI_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::TI >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); TI_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::TI >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); TI_exposer.def( "__str__", &__str__< ::SireAnalysis::TI > ); TI_exposer.def( "__repr__", &__str__< ::SireAnalysis::TI > ); TI_exposer.def( "__len__", &__len_size< ::SireAnalysis::TI > ); } }
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_ResStructureEditor_class(){ { //::SireMol::ResStructureEditor typedef bp::class_< SireMol::ResStructureEditor > ResStructureEditor_exposer_t; ResStructureEditor_exposer_t ResStructureEditor_exposer = ResStructureEditor_exposer_t( "ResStructureEditor", "This is the class used to edit a residues structure\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") ); bp::scope ResStructureEditor_scope( ResStructureEditor_exposer ); ResStructureEditor_exposer.def( bp::init< SireMol::Residue const & >(( bp::arg("residue") ), "Construct an editor to edit the structure of a copy of the\nresidue residue") ); ResStructureEditor_exposer.def( bp::init< SireMol::StructureEditor const &, SireMol::ResIdx >(( bp::arg("data"), bp::arg("residx") ), "Construct an editor to edit the residue at index residx in the\neditor whose data is in data\nThrow: SireError::invalid_index\n") ); ResStructureEditor_exposer.def( bp::init< SireMol::ResStructureEditor const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMol::ResStructureEditor::add typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*add_function_type)( ::SireMol::AtomName const & ) ; add_function_type add_function_value( &::SireMol::ResStructureEditor::add ); ResStructureEditor_exposer.def( "add" , add_function_value , ( bp::arg("atomname") ) , "Add a new atom called name to this residue - this returns\nan editor that can be used to further edit this atom" ); } { //::SireMol::ResStructureEditor::add typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*add_function_type)( ::SireMol::AtomNum ) ; add_function_type add_function_value( &::SireMol::ResStructureEditor::add ); ResStructureEditor_exposer.def( "add" , add_function_value , ( bp::arg("atomnum") ) , "Add a new atom with the number number to this residue - this\nreturns an editor that can be used to further edit this atom" ); } { //::SireMol::ResStructureEditor::atom typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*atom_function_type)( int ) ; atom_function_type atom_function_value( &::SireMol::ResStructureEditor::atom ); ResStructureEditor_exposer.def( "atom" , atom_function_value , ( bp::arg("i") ) , "Return an editor for the ith atom in this residue\nThrow: SireError::invalid_index\n" ); } { //::SireMol::ResStructureEditor::atom typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*atom_function_type)( ::SireMol::AtomID const & ) ; atom_function_type atom_function_value( &::SireMol::ResStructureEditor::atom ); ResStructureEditor_exposer.def( "atom" , atom_function_value , ( bp::arg("atomid") ) , "Return an editor for the atom with ID == atomid in\nthis residue\nThrow: SireMol::missing_atom\nThrow: SireMol::duplicate_atom\nThrow: SireError::invalid_index\n" ); } { //::SireMol::ResStructureEditor::chain typedef ::SireMol::ChainStructureEditor ( ::SireMol::ResStructureEditor::*chain_function_type)( ) ; chain_function_type chain_function_value( &::SireMol::ResStructureEditor::chain ); ResStructureEditor_exposer.def( "chain" , chain_function_value , "Return an editor for the chain that contains this residue" ); } { //::SireMol::ResStructureEditor::commit typedef ::SireMol::Residue ( ::SireMol::ResStructureEditor::*commit_function_type)( ) const; commit_function_type commit_function_value( &::SireMol::ResStructureEditor::commit ); ResStructureEditor_exposer.def( "commit" , commit_function_value , "Commit the changes made by this editor and return the updated residue" ); } { //::SireMol::ResStructureEditor::index typedef ::SireMol::ResIdx ( ::SireMol::ResStructureEditor::*index_function_type)( ) const; index_function_type index_function_value( &::SireMol::ResStructureEditor::index ); ResStructureEditor_exposer.def( "index" , index_function_value , "Return the index of this residue in the molecule" ); } { //::SireMol::ResStructureEditor::molecule typedef ::SireMol::MolStructureEditor ( ::SireMol::ResStructureEditor::*molecule_function_type)( ) ; molecule_function_type molecule_function_value( &::SireMol::ResStructureEditor::molecule ); ResStructureEditor_exposer.def( "molecule" , molecule_function_value , "Return an editor for the molecule that contains this residue" ); } { //::SireMol::ResStructureEditor::nAtoms typedef int ( ::SireMol::ResStructureEditor::*nAtoms_function_type)( ) const; nAtoms_function_type nAtoms_function_value( &::SireMol::ResStructureEditor::nAtoms ); ResStructureEditor_exposer.def( "nAtoms" , nAtoms_function_value , "Return the number of atoms in this residue - this may be zero" ); } { //::SireMol::ResStructureEditor::name typedef ::SireMol::ResName const & ( ::SireMol::ResStructureEditor::*name_function_type)( ) const; name_function_type name_function_value( &::SireMol::ResStructureEditor::name ); ResStructureEditor_exposer.def( "name" , name_function_value , bp::return_value_policy<bp::clone_const_reference>() , "Return the name of this residue" ); } { //::SireMol::ResStructureEditor::number typedef ::SireMol::ResNum ( ::SireMol::ResStructureEditor::*number_function_type)( ) const; number_function_type number_function_value( &::SireMol::ResStructureEditor::number ); ResStructureEditor_exposer.def( "number" , number_function_value , "Return the number of this residue" ); } { //::SireMol::ResStructureEditor::operator= typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*assign_function_type)( ::SireMol::Residue const & ) ; assign_function_type assign_function_value( &::SireMol::ResStructureEditor::operator= ); ResStructureEditor_exposer.def( "assign" , assign_function_value , ( bp::arg("residue") ) , bp::return_self< >() , "" ); } { //::SireMol::ResStructureEditor::operator= typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*assign_function_type)( ::SireMol::ResStructureEditor const & ) ; assign_function_type assign_function_value( &::SireMol::ResStructureEditor::operator= ); ResStructureEditor_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } { //::SireMol::ResStructureEditor::reindex typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*reindex_function_type)( ::SireMol::ResIdx ) ; reindex_function_type reindex_function_value( &::SireMol::ResStructureEditor::reindex ); ResStructureEditor_exposer.def( "reindex" , reindex_function_value , ( bp::arg("index") ) , bp::return_self< >() , "Change the index of this residue to newidx. If this\nis larger than the number of residues in the molecule\nthen this residue is moved to the end" ); } { //::SireMol::ResStructureEditor::remove typedef ::SireMol::MolStructureEditor ( ::SireMol::ResStructureEditor::*remove_function_type)( ) ; remove_function_type remove_function_value( &::SireMol::ResStructureEditor::remove ); ResStructureEditor_exposer.def( "remove" , remove_function_value , bp::return_self< >() , "Completely remove this residue from the molecule - this returns\na MolStructureEditor that can be used to further edit the molecule" ); } { //::SireMol::ResStructureEditor::remove typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*remove_function_type)( ::SireMol::AtomID const & ) ; remove_function_type remove_function_value( &::SireMol::ResStructureEditor::remove ); ResStructureEditor_exposer.def( "remove" , remove_function_value , ( bp::arg("atomid") ) , bp::return_self< >() , "Remove all atoms with ID atomid from this residue\nThrow: SireMol::missing_atom\nThrow: SireError::invalid_index\n" ); } { //::SireMol::ResStructureEditor::remove typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*remove_function_type)( int ) ; remove_function_type remove_function_value( &::SireMol::ResStructureEditor::remove ); ResStructureEditor_exposer.def( "remove" , remove_function_value , ( bp::arg("i") ) , bp::return_self< >() , "Remove the ith atom from this residue\nThrow: SireError::invalid_index\n" ); } { //::SireMol::ResStructureEditor::rename typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*rename_function_type)( ::SireMol::ResName const & ) ; rename_function_type rename_function_value( &::SireMol::ResStructureEditor::rename ); ResStructureEditor_exposer.def( "rename" , rename_function_value , ( bp::arg("name") ) , bp::return_self< >() , "Rename this residue to newname" ); } { //::SireMol::ResStructureEditor::renumber typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*renumber_function_type)( ::SireMol::ResNum ) ; renumber_function_type renumber_function_value( &::SireMol::ResStructureEditor::renumber ); ResStructureEditor_exposer.def( "renumber" , renumber_function_value , ( bp::arg("number") ) , bp::return_self< >() , "Renumber this residue to newnum" ); } { //::SireMol::ResStructureEditor::reparent typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*reparent_function_type)( ::SireMol::ChainID const & ) ; reparent_function_type reparent_function_value( &::SireMol::ResStructureEditor::reparent ); ResStructureEditor_exposer.def( "reparent" , reparent_function_value , ( bp::arg("chainid") ) , bp::return_self< >() , "Move this residue into the chain with ID chainid\nThrow: SireMol::missing_chain\nThrow: SireMol::duplicate_chain\nThrow: SireError::invalid_index\n" ); } { //::SireMol::ResStructureEditor::select typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*select_function_type)( int ) ; select_function_type select_function_value( &::SireMol::ResStructureEditor::select ); ResStructureEditor_exposer.def( "select" , select_function_value , ( bp::arg("i") ) , "Return an editor for the ith atom in this residue\nThrow: SireError::invalid_index\n" ); } { //::SireMol::ResStructureEditor::select typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*select_function_type)( ::SireMol::AtomID const & ) ; select_function_type select_function_value( &::SireMol::ResStructureEditor::select ); ResStructureEditor_exposer.def( "select" , select_function_value , ( bp::arg("atomid") ) , "Return an editor for the atom with ID == atomid in\nthis residue\nThrow: SireMol::missing_atom\nThrow: SireMol::duplicate_atom\nThrow: SireError::invalid_index\n" ); } { //::SireMol::ResStructureEditor::selectedAll typedef bool ( ::SireMol::ResStructureEditor::*selectedAll_function_type)( ) const; selectedAll_function_type selectedAll_function_value( &::SireMol::ResStructureEditor::selectedAll ); ResStructureEditor_exposer.def( "selectedAll" , selectedAll_function_value , "Is this editor editing the entire molecule?" ); } { //::SireMol::ResStructureEditor::toString typedef ::QString ( ::SireMol::ResStructureEditor::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMol::ResStructureEditor::toString ); ResStructureEditor_exposer.def( "toString" , toString_function_value , "Return a string representation of this editor" ); } { //::SireMol::ResStructureEditor::transfer typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*transfer_function_type)( ::SireMol::AtomID const &,::SireMol::ResID const & ) ; transfer_function_type transfer_function_value( &::SireMol::ResStructureEditor::transfer ); ResStructureEditor_exposer.def( "transfer" , transfer_function_value , ( bp::arg("atomid"), bp::arg("resid") ) , bp::return_self< >() , "Transfer all atoms that match the ID atomid into the residue that\nmatches the ID resid\nThrow: SireMol::missing_atom\nThrow: SireMol::missing_residue\nThrow: SireMol::duplicate_residue\nThrow: SireError::invalid_index\n" ); } { //::SireMol::ResStructureEditor::transfer typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*transfer_function_type)( int,::SireMol::ResID const & ) ; transfer_function_type transfer_function_value( &::SireMol::ResStructureEditor::transfer ); ResStructureEditor_exposer.def( "transfer" , transfer_function_value , ( bp::arg("i"), bp::arg("resid") ) , bp::return_self< >() , "Transfer the ith atom from this residue into the residue that\nmatches the ID resid\nThrow: SireMol::missing_residue\nThrow: SireMol::duplicate_residue\nThrow: SireError::invalid_index\n" ); } { //::SireMol::ResStructureEditor::transferAll typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*transferAll_function_type)( ::SireMol::ResID const & ) ; transferAll_function_type transferAll_function_value( &::SireMol::ResStructureEditor::transferAll ); ResStructureEditor_exposer.def( "transferAll" , transferAll_function_value , ( bp::arg("resid") ) , bp::return_self< >() , "Transfer all atoms from this residue into the residue with ID resid\nThrow: SireMol::missing_residue\nThrow: SireMol::duplicate_residue\nThrow: SireError::invalid_index\n" ); } { //::SireMol::ResStructureEditor::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::ResStructureEditor::typeName ); ResStructureEditor_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMol::ResStructureEditor::what typedef char const * ( ::SireMol::ResStructureEditor::*what_function_type)( ) const; what_function_type what_function_value( &::SireMol::ResStructureEditor::what ); ResStructureEditor_exposer.def( "what" , what_function_value , "" ); } ResStructureEditor_exposer.staticmethod( "typeName" ); ResStructureEditor_exposer.def( "__copy__", &__copy__); ResStructureEditor_exposer.def( "__deepcopy__", &__copy__); ResStructureEditor_exposer.def( "clone", &__copy__); ResStructureEditor_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ResStructureEditor >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ResStructureEditor_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ResStructureEditor >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ResStructureEditor_exposer.def( "__str__", &__str__< ::SireMol::ResStructureEditor > ); ResStructureEditor_exposer.def( "__repr__", &__str__< ::SireMol::ResStructureEditor > ); } }