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 > );
}
}