void register_DihedralRestraint_class(){
{ //::SireMM::DihedralRestraint
typedef bp::class_< SireMM::DihedralRestraint, bp::bases< SireMM::Restraint3D, SireMM::Restraint, SireBase::Property > > DihedralRestraint_exposer_t;
DihedralRestraint_exposer_t DihedralRestraint_exposer = DihedralRestraint_exposer_t( "DihedralRestraint", "This is a restraint that operates on the dihedral angle between\nfour SireMM::Point objects (e.g. four atoms in a molecule)\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope DihedralRestraint_scope( DihedralRestraint_exposer );
DihedralRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("restraint") ), "Construct a restraint that acts on the angle within the\nthree points point0, point1 and point2 (theta == a(012)),\nrestraining the angle within these points using the expression\nrestraint") );
DihedralRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const &, SireCAS::Values const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("restraint"), bp::arg("values") ), "Construct a restraint that acts on the angle within the\nthree points point0, point1 and point2 (theta == a(012)),\nrestraining the angle within these points using the expression\nrestraint") );
DihedralRestraint_exposer.def( bp::init< SireMM::DihedralRestraint const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMM::DihedralRestraint::builtinSymbols
typedef ::SireCAS::Symbols ( ::SireMM::DihedralRestraint::*builtinSymbols_function_type)( ) const;
builtinSymbols_function_type builtinSymbols_function_value( &::SireMM::DihedralRestraint::builtinSymbols );
DihedralRestraint_exposer.def(
"builtinSymbols"
, builtinSymbols_function_value
, "Return the built-in symbols for this restraint" );
}
{ //::SireMM::DihedralRestraint::builtinValues
typedef ::SireCAS::Values ( ::SireMM::DihedralRestraint::*builtinValues_function_type)( ) const;
builtinValues_function_type builtinValues_function_value( &::SireMM::DihedralRestraint::builtinValues );
DihedralRestraint_exposer.def(
"builtinValues"
, builtinValues_function_value
, "Return the values of the built-in symbols of this restraint" );
}
{ //::SireMM::DihedralRestraint::contains
typedef bool ( ::SireMM::DihedralRestraint::*contains_function_type)( ::SireMol::MolNum ) const;
contains_function_type contains_function_value( &::SireMM::DihedralRestraint::contains );
DihedralRestraint_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molnum") )
, "Return whether or not this restraint affects the molecule\nwith number molnum" );
}
{ //::SireMM::DihedralRestraint::contains
typedef bool ( ::SireMM::DihedralRestraint::*contains_function_type)( ::SireMol::MolID const & ) const;
contains_function_type contains_function_value( &::SireMM::DihedralRestraint::contains );
DihedralRestraint_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molid") )
, "Return whether or not this restraint affects the molecule\nwith ID molid" );
}
{ //::SireMM::DihedralRestraint::differentialRestraintFunction
typedef ::SireCAS::Expression const & ( ::SireMM::DihedralRestraint::*differentialRestraintFunction_function_type)( ) const;
differentialRestraintFunction_function_type differentialRestraintFunction_function_value( &::SireMM::DihedralRestraint::differentialRestraintFunction );
DihedralRestraint_exposer.def(
"differentialRestraintFunction"
, differentialRestraintFunction_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the function used to calculate the restraint force" );
}
{ //::SireMM::DihedralRestraint::differentiate
typedef ::SireMM::RestraintPtr ( ::SireMM::DihedralRestraint::*differentiate_function_type)( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireMM::DihedralRestraint::differentiate );
DihedralRestraint_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") )
, "Return the differential of this restraint with respect to\nthe symbol symbol\nThrow: SireCAS::unavailable_differential\n" );
}
{ //::SireMM::DihedralRestraint::force
typedef void ( ::SireMM::DihedralRestraint::*force_function_type)( ::SireFF::MolForceTable &,double ) const;
force_function_type force_function_value( &::SireMM::DihedralRestraint::force );
DihedralRestraint_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 )
, "Calculate the force acting on the molecule in the forcetable forcetable\ncaused by this restraint, and add it on to the forcetable scaled by\nscale_force" );
}
{ //::SireMM::DihedralRestraint::force
typedef void ( ::SireMM::DihedralRestraint::*force_function_type)( ::SireFF::ForceTable &,double ) const;
force_function_type force_function_value( &::SireMM::DihedralRestraint::force );
DihedralRestraint_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 )
, "Calculate the force acting on the molecules in the forcetable forcetable\ncaused by this restraint, and add it on to the forcetable scaled by\nscale_force" );
}
{ //::SireMM::DihedralRestraint::halfHarmonic
typedef ::SireMM::DihedralRestraint ( *halfHarmonic_function_type )( ::SireFF::PointRef const &,::SireFF::PointRef const &,::SireFF::PointRef const &,::SireFF::PointRef const &,::SireUnits::Dimension::Angle const &,::SireMM::HarmonicAngleForceConstant const & );
halfHarmonic_function_type halfHarmonic_function_value( &::SireMM::DihedralRestraint::halfHarmonic );
DihedralRestraint_exposer.def(
"halfHarmonic"
, halfHarmonic_function_value
, ( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("angle"), bp::arg("force_constant") )
, "Return a distance restraint that applied a half-harmonic potential\nbetween the points point0 and point1 above a distance distance\nusing a force constant force_constant" );
}
{ //::SireMM::DihedralRestraint::harmonic
typedef ::SireMM::DihedralRestraint ( *harmonic_function_type )( ::SireFF::PointRef const &,::SireFF::PointRef const &,::SireFF::PointRef const &,::SireFF::PointRef const &,::SireMM::HarmonicAngleForceConstant const & );
harmonic_function_type harmonic_function_value( &::SireMM::DihedralRestraint::harmonic );
DihedralRestraint_exposer.def(
"harmonic"
, harmonic_function_value
, ( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("force_constant") )
, "Return a distance restraint that applies a harmonic potential between\nthe points point0 and point1 using a force constant force_constant" );
}
{ //::SireMM::DihedralRestraint::molecules
typedef ::SireMol::Molecules ( ::SireMM::DihedralRestraint::*molecules_function_type)( ) const;
molecules_function_type molecules_function_value( &::SireMM::DihedralRestraint::molecules );
DihedralRestraint_exposer.def(
"molecules"
, molecules_function_value
, "Return the molecules used in this restraint" );
}
{ //::SireMM::DihedralRestraint::nPoints
typedef int ( ::SireMM::DihedralRestraint::*nPoints_function_type)( ) const;
nPoints_function_type nPoints_function_value( &::SireMM::DihedralRestraint::nPoints );
DihedralRestraint_exposer.def(
"nPoints"
, nPoints_function_value
, "This restraint involves four points" );
}
DihedralRestraint_exposer.def( bp::self != bp::self );
{ //::SireMM::DihedralRestraint::operator=
typedef ::SireMM::DihedralRestraint & ( ::SireMM::DihedralRestraint::*assign_function_type)( ::SireMM::DihedralRestraint const & ) ;
assign_function_type assign_function_value( &::SireMM::DihedralRestraint::operator= );
DihedralRestraint_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
DihedralRestraint_exposer.def( bp::self == bp::self );
{ //::SireMM::DihedralRestraint::phi
typedef ::SireCAS::Symbol const & ( *phi_function_type )( );
phi_function_type phi_function_value( &::SireMM::DihedralRestraint::phi );
DihedralRestraint_exposer.def(
"phi"
, phi_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the symbol that represents the dihedral angle between the points (phi)" );
}
{ //::SireMM::DihedralRestraint::point
typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point_function_type)( int ) const;
point_function_type point_function_value( &::SireMM::DihedralRestraint::point );
DihedralRestraint_exposer.def(
"point"
, point_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the ith point" );
}
{ //::SireMM::DihedralRestraint::point0
typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point0_function_type)( ) const;
point0_function_type point0_function_value( &::SireMM::DihedralRestraint::point0 );
DihedralRestraint_exposer.def(
"point0"
, point0_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the first point" );
}
{ //::SireMM::DihedralRestraint::point1
typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point1_function_type)( ) const;
point1_function_type point1_function_value( &::SireMM::DihedralRestraint::point1 );
DihedralRestraint_exposer.def(
"point1"
, point1_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the second point" );
}
{ //::SireMM::DihedralRestraint::point2
typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point2_function_type)( ) const;
point2_function_type point2_function_value( &::SireMM::DihedralRestraint::point2 );
DihedralRestraint_exposer.def(
"point2"
, point2_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the third point" );
}
{ //::SireMM::DihedralRestraint::point3
typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point3_function_type)( ) const;
point3_function_type point3_function_value( &::SireMM::DihedralRestraint::point3 );
DihedralRestraint_exposer.def(
"point3"
, point3_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the fourth point" );
}
{ //::SireMM::DihedralRestraint::setSpace
typedef void ( ::SireMM::DihedralRestraint::*setSpace_function_type)( ::SireVol::Space const & ) ;
setSpace_function_type setSpace_function_value( &::SireMM::DihedralRestraint::setSpace );
DihedralRestraint_exposer.def(
"setSpace"
, setSpace_function_value
, ( bp::arg("space") )
, "Set the space used to evaluate the energy of this restraint\nThrow: SireVol::incompatible_space\n" );
}
{ //::SireMM::DihedralRestraint::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::DihedralRestraint::typeName );
DihedralRestraint_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMM::DihedralRestraint::update
typedef void ( ::SireMM::DihedralRestraint::*update_function_type)( ::SireMol::MoleculeData const & ) ;
update_function_type update_function_value( &::SireMM::DihedralRestraint::update );
DihedralRestraint_exposer.def(
"update"
, update_function_value
, ( bp::arg("moldata") )
, "Update the points of this restraint using new molecule data from moldata\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMM::DihedralRestraint::update
typedef void ( ::SireMM::DihedralRestraint::*update_function_type)( ::SireMol::Molecules const & ) ;
update_function_type update_function_value( &::SireMM::DihedralRestraint::update );
DihedralRestraint_exposer.def(
"update"
, update_function_value
, ( bp::arg("molecules") )
, "Update the points of this restraint using new molecule data from molecules\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMM::DihedralRestraint::usesMoleculesIn
typedef bool ( ::SireMM::DihedralRestraint::*usesMoleculesIn_function_type)( ::SireFF::ForceTable const & ) const;
usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DihedralRestraint::usesMoleculesIn );
DihedralRestraint_exposer.def(
"usesMoleculesIn"
, usesMoleculesIn_function_value
, ( bp::arg("forcetable") )
, "Return whether or not this restraint involves any of the molecules\nthat are in the forcetable forcetable" );
}
{ //::SireMM::DihedralRestraint::usesMoleculesIn
typedef bool ( ::SireMM::DihedralRestraint::*usesMoleculesIn_function_type)( ::SireMol::Molecules const & ) const;
usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DihedralRestraint::usesMoleculesIn );
DihedralRestraint_exposer.def(
"usesMoleculesIn"
, usesMoleculesIn_function_value
, ( bp::arg("molecules") )
, "Return whether or not this restraint involves any of the molecules\nin molecules" );
}
DihedralRestraint_exposer.staticmethod( "halfHarmonic" );
DihedralRestraint_exposer.staticmethod( "harmonic" );
DihedralRestraint_exposer.staticmethod( "phi" );
DihedralRestraint_exposer.staticmethod( "typeName" );
DihedralRestraint_exposer.def( "__copy__", &__copy__);
DihedralRestraint_exposer.def( "__deepcopy__", &__copy__);
DihedralRestraint_exposer.def( "clone", &__copy__);
DihedralRestraint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::DihedralRestraint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DihedralRestraint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::DihedralRestraint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DihedralRestraint_exposer.def( "__str__", &__str__< ::SireMM::DihedralRestraint > );
DihedralRestraint_exposer.def( "__repr__", &__str__< ::SireMM::DihedralRestraint > );
}
}
void register_GridInfo_class(){
{ //::SireVol::GridInfo
typedef bp::class_< SireVol::GridInfo > GridInfo_exposer_t;
GridInfo_exposer_t GridInfo_exposer = GridInfo_exposer_t( "GridInfo", bp::init< >() );
bp::scope GridInfo_scope( GridInfo_exposer );
GridInfo_exposer.def( bp::init< SireVol::AABox const &, SireUnits::Dimension::Length >(( bp::arg("dimensions"), bp::arg("spacing") )) );
GridInfo_exposer.def( bp::init< SireVol::GridInfo const & >(( bp::arg("other") )) );
{ //::SireVol::GridInfo::arrayToGridIndex
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*arrayToGridIndex_function_type )( int ) const;
arrayToGridIndex_function_type arrayToGridIndex_function_value( &::SireVol::GridInfo::arrayToGridIndex );
GridInfo_exposer.def(
"arrayToGridIndex"
, arrayToGridIndex_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::at
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::at
typedef int ( ::SireVol::GridInfo::*at_function_type )( ::SireVol::GridIndex const & ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::at
typedef int ( ::SireVol::GridInfo::*at_function_type )( int,int,int ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("k") ) );
}
{ //::SireVol::GridInfo::at
typedef int ( ::SireVol::GridInfo::*at_function_type )( ::SireMaths::Vector const & ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::box
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( int ) const;
box_function_type box_function_value( &::SireVol::GridInfo::box );
GridInfo_exposer.def(
"box"
, box_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::box
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( ::SireVol::GridIndex const & ) const;
box_function_type box_function_value( &::SireVol::GridInfo::box );
GridInfo_exposer.def(
"box"
, box_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::box
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( ::SireMaths::Vector const & ) const;
box_function_type box_function_value( &::SireVol::GridInfo::box );
GridInfo_exposer.def(
"box"
, box_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::closestIndexTo
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*closestIndexTo_function_type )( ::SireMaths::Vector const & ) const;
closestIndexTo_function_type closestIndexTo_function_value( &::SireVol::GridInfo::closestIndexTo );
GridInfo_exposer.def(
"closestIndexTo"
, closestIndexTo_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::contains
typedef bool ( ::SireVol::GridInfo::*contains_function_type )( ::SireMaths::Vector const & ) const;
contains_function_type contains_function_value( &::SireVol::GridInfo::contains );
GridInfo_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::count
typedef int ( ::SireVol::GridInfo::*count_function_type )( ) const;
count_function_type count_function_value( &::SireVol::GridInfo::count );
GridInfo_exposer.def(
"count"
, count_function_value );
}
{ //::SireVol::GridInfo::dimX
typedef ::qint32 ( ::SireVol::GridInfo::*dimX_function_type )( ) const;
dimX_function_type dimX_function_value( &::SireVol::GridInfo::dimX );
GridInfo_exposer.def(
"dimX"
, dimX_function_value );
}
{ //::SireVol::GridInfo::dimY
typedef ::qint32 ( ::SireVol::GridInfo::*dimY_function_type )( ) const;
dimY_function_type dimY_function_value( &::SireVol::GridInfo::dimY );
GridInfo_exposer.def(
"dimY"
, dimY_function_value );
}
{ //::SireVol::GridInfo::dimZ
typedef ::qint32 ( ::SireVol::GridInfo::*dimZ_function_type )( ) const;
dimZ_function_type dimZ_function_value( &::SireVol::GridInfo::dimZ );
GridInfo_exposer.def(
"dimZ"
, dimZ_function_value );
}
{ //::SireVol::GridInfo::dimensions
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*dimensions_function_type )( ) const;
dimensions_function_type dimensions_function_value( &::SireVol::GridInfo::dimensions );
GridInfo_exposer.def(
"dimensions"
, dimensions_function_value );
}
{ //::SireVol::GridInfo::getitem
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*getitem_function_type )( int ) const;
getitem_function_type getitem_function_value( &::SireVol::GridInfo::getitem );
GridInfo_exposer.def(
"getitem"
, getitem_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::gridToArrayIndex
typedef int ( ::SireVol::GridInfo::*gridToArrayIndex_function_type )( int,int,int ) const;
gridToArrayIndex_function_type gridToArrayIndex_function_value( &::SireVol::GridInfo::gridToArrayIndex );
GridInfo_exposer.def(
"gridToArrayIndex"
, gridToArrayIndex_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("k") ) );
}
{ //::SireVol::GridInfo::gridToArrayIndex
typedef int ( ::SireVol::GridInfo::*gridToArrayIndex_function_type )( ::SireVol::GridIndex const & ) const;
gridToArrayIndex_function_type gridToArrayIndex_function_value( &::SireVol::GridInfo::gridToArrayIndex );
GridInfo_exposer.def(
"gridToArrayIndex"
, gridToArrayIndex_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::indexOf
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*indexOf_function_type )( int,::SireVol::GridInfo const & ) const;
indexOf_function_type indexOf_function_value( &::SireVol::GridInfo::indexOf );
GridInfo_exposer.def(
"indexOf"
, indexOf_function_value
, ( bp::arg("i"), bp::arg("grid") ) );
}
{ //::SireVol::GridInfo::indexOf
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*indexOf_function_type )( ::SireVol::GridIndex const &,::SireVol::GridInfo const & ) const;
indexOf_function_type indexOf_function_value( &::SireVol::GridInfo::indexOf );
GridInfo_exposer.def(
"indexOf"
, indexOf_function_value
, ( bp::arg("idx"), bp::arg("grid") ) );
}
{ //::SireVol::GridInfo::isEmpty
typedef bool ( ::SireVol::GridInfo::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireVol::GridInfo::isEmpty );
GridInfo_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireVol::GridInfo::nPoints
typedef int ( ::SireVol::GridInfo::*nPoints_function_type )( ) const;
nPoints_function_type nPoints_function_value( &::SireVol::GridInfo::nPoints );
GridInfo_exposer.def(
"nPoints"
, nPoints_function_value );
}
GridInfo_exposer.def( bp::self != bp::self );
{ //::SireVol::GridInfo::operator=
typedef ::SireVol::GridInfo & ( ::SireVol::GridInfo::*assign_function_type )( ::SireVol::GridInfo const & ) ;
assign_function_type assign_function_value( &::SireVol::GridInfo::operator= );
GridInfo_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
GridInfo_exposer.def( bp::self == bp::self );
{ //::SireVol::GridInfo::operator[]
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] );
GridInfo_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::operator[]
typedef int ( ::SireVol::GridInfo::*__getitem___function_type )( ::SireVol::GridIndex const & ) const;
__getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] );
GridInfo_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::operator[]
typedef int ( ::SireVol::GridInfo::*__getitem___function_type )( ::SireMaths::Vector const & ) const;
__getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] );
GridInfo_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::point
typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( int ) const;
point_function_type point_function_value( &::SireVol::GridInfo::point );
GridInfo_exposer.def(
"point"
, point_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::point
typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( ::SireVol::GridIndex const & ) const;
point_function_type point_function_value( &::SireVol::GridInfo::point );
GridInfo_exposer.def(
"point"
, point_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::point
typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( ::SireMaths::Vector const & ) const;
point_function_type point_function_value( &::SireVol::GridInfo::point );
GridInfo_exposer.def(
"point"
, point_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::pointToArrayIndex
typedef int ( ::SireVol::GridInfo::*pointToArrayIndex_function_type )( ::SireMaths::Vector const & ) const;
pointToArrayIndex_function_type pointToArrayIndex_function_value( &::SireVol::GridInfo::pointToArrayIndex );
GridInfo_exposer.def(
"pointToArrayIndex"
, pointToArrayIndex_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef void ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::Vector const &,::QVector< int > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("point"), bp::arg("indicies") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef void ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::Vector const &,::QVector< int > &,::QVector< float > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("point"), bp::arg("indicies"), bp::arg("weights") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef int ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::QVector< SireMaths::MultiInt > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("indicies") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef int ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::QVector< SireMaths::MultiInt > &,::QVector< SireMaths::MultiFloat > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("indicies"), bp::arg("weights") ) );
}
{ //::SireVol::GridInfo::pointToGridIndex
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*pointToGridIndex_function_type )( ::SireMaths::Vector const & ) const;
pointToGridIndex_function_type pointToGridIndex_function_value( &::SireVol::GridInfo::pointToGridIndex );
GridInfo_exposer.def(
"pointToGridIndex"
, pointToGridIndex_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::redimension
typedef ::QVector< float > ( ::SireVol::GridInfo::*redimension_function_type )( ::QVector< float > const &,::SireVol::GridInfo const & ) const;
redimension_function_type redimension_function_value( &::SireVol::GridInfo::redimension );
GridInfo_exposer.def(
"redimension"
, redimension_function_value
, ( bp::arg("values"), bp::arg("new_grid") ) );
}
{ //::SireVol::GridInfo::size
typedef int ( ::SireVol::GridInfo::*size_function_type )( ) const;
size_function_type size_function_value( &::SireVol::GridInfo::size );
GridInfo_exposer.def(
"size"
, size_function_value );
}
{ //::SireVol::GridInfo::spacing
typedef ::SireUnits::Dimension::Length ( ::SireVol::GridInfo::*spacing_function_type )( ) const;
spacing_function_type spacing_function_value( &::SireVol::GridInfo::spacing );
GridInfo_exposer.def(
"spacing"
, spacing_function_value );
}
{ //::SireVol::GridInfo::toString
typedef ::QString ( ::SireVol::GridInfo::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireVol::GridInfo::toString );
GridInfo_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireVol::GridInfo::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireVol::GridInfo::typeName );
GridInfo_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireVol::GridInfo::what
typedef char const * ( ::SireVol::GridInfo::*what_function_type )( ) const;
what_function_type what_function_value( &::SireVol::GridInfo::what );
GridInfo_exposer.def(
"what"
, what_function_value );
}
GridInfo_exposer.staticmethod( "typeName" );
GridInfo_exposer.def( "__copy__", &__copy__);
GridInfo_exposer.def( "__deepcopy__", &__copy__);
GridInfo_exposer.def( "clone", &__copy__);
GridInfo_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::GridInfo >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GridInfo_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::GridInfo >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GridInfo_exposer.def( "__str__", &__str__< ::SireVol::GridInfo > );
GridInfo_exposer.def( "__repr__", &__str__< ::SireVol::GridInfo > );
GridInfo_exposer.def( "__len__", &__len_size< ::SireVol::GridInfo > );
GridInfo_exposer.def( "__getitem__", &::SireVol::GridInfo::getitem );
}
}
void register_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_TripleDistanceComponent_class() {
{ //::SireSystem::TripleDistanceComponent
typedef bp::class_< SireSystem::TripleDistanceComponent, bp::bases< SireSystem::GeometryComponent, SireSystem::Constraint, SireBase::Property > > TripleDistanceComponent_exposer_t;
TripleDistanceComponent_exposer_t TripleDistanceComponent_exposer = TripleDistanceComponent_exposer_t( "TripleDistanceComponent", bp::init< >() );
bp::scope TripleDistanceComponent_scope( TripleDistanceComponent_exposer );
TripleDistanceComponent_exposer.def( bp::init< SireCAS::Symbol const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("constrained_symbol"), bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("point4"), bp::arg("point5"), bp::arg("map")=SireBase::PropertyMap() )) );
TripleDistanceComponent_exposer.def( bp::init< SireCAS::Symbol const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("constrained_symbol"), bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("point4"), bp::arg("point5"), bp::arg("geometry_expression"), bp::arg("map")=SireBase::PropertyMap() )) );
TripleDistanceComponent_exposer.def( bp::init< SireSystem::TripleDistanceComponent const & >(( bp::arg("other") )) );
{ //::SireSystem::TripleDistanceComponent::nPoints
typedef int ( ::SireSystem::TripleDistanceComponent::*nPoints_function_type )( ) const;
nPoints_function_type nPoints_function_value( &::SireSystem::TripleDistanceComponent::nPoints );
TripleDistanceComponent_exposer.def(
"nPoints"
, nPoints_function_value );
}
TripleDistanceComponent_exposer.def( bp::self != bp::self );
{ //::SireSystem::TripleDistanceComponent::operator=
typedef ::SireSystem::TripleDistanceComponent & ( ::SireSystem::TripleDistanceComponent::*assign_function_type )( ::SireSystem::TripleDistanceComponent const & ) ;
assign_function_type assign_function_value( &::SireSystem::TripleDistanceComponent::operator= );
TripleDistanceComponent_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
TripleDistanceComponent_exposer.def( bp::self == bp::self );
{ //::SireSystem::TripleDistanceComponent::point
typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point_function_type )( int ) const;
point_function_type point_function_value( &::SireSystem::TripleDistanceComponent::point );
TripleDistanceComponent_exposer.def(
"point"
, point_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::point0
typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point0_function_type )( ) const;
point0_function_type point0_function_value( &::SireSystem::TripleDistanceComponent::point0 );
TripleDistanceComponent_exposer.def(
"point0"
, point0_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::point1
typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point1_function_type )( ) const;
point1_function_type point1_function_value( &::SireSystem::TripleDistanceComponent::point1 );
TripleDistanceComponent_exposer.def(
"point1"
, point1_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::point2
typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point2_function_type )( ) const;
point2_function_type point2_function_value( &::SireSystem::TripleDistanceComponent::point2 );
TripleDistanceComponent_exposer.def(
"point2"
, point2_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::point3
typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point3_function_type )( ) const;
point3_function_type point3_function_value( &::SireSystem::TripleDistanceComponent::point3 );
TripleDistanceComponent_exposer.def(
"point3"
, point3_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::point4
typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point4_function_type )( ) const;
point4_function_type point4_function_value( &::SireSystem::TripleDistanceComponent::point4 );
TripleDistanceComponent_exposer.def(
"point4"
, point4_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::point5
typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point5_function_type )( ) const;
point5_function_type point5_function_value( &::SireSystem::TripleDistanceComponent::point5 );
TripleDistanceComponent_exposer.def(
"point5"
, point5_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::r01
typedef ::SireCAS::Symbol const & ( *r01_function_type )( );
r01_function_type r01_function_value( &::SireSystem::TripleDistanceComponent::r01 );
TripleDistanceComponent_exposer.def(
"r01"
, r01_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::r23
typedef ::SireCAS::Symbol const & ( *r23_function_type )( );
r23_function_type r23_function_value( &::SireSystem::TripleDistanceComponent::r23 );
TripleDistanceComponent_exposer.def(
"r23"
, r23_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::r45
typedef ::SireCAS::Symbol const & ( *r45_function_type )( );
r45_function_type r45_function_value( &::SireSystem::TripleDistanceComponent::r45 );
TripleDistanceComponent_exposer.def(
"r45"
, r45_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::TripleDistanceComponent::toString
typedef ::QString ( ::SireSystem::TripleDistanceComponent::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireSystem::TripleDistanceComponent::toString );
TripleDistanceComponent_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireSystem::TripleDistanceComponent::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireSystem::TripleDistanceComponent::typeName );
TripleDistanceComponent_exposer.def(
"typeName"
, typeName_function_value );
}
TripleDistanceComponent_exposer.staticmethod( "r01" );
TripleDistanceComponent_exposer.staticmethod( "r23" );
TripleDistanceComponent_exposer.staticmethod( "r45" );
TripleDistanceComponent_exposer.staticmethod( "typeName" );
TripleDistanceComponent_exposer.def( "__copy__", &__copy__);
TripleDistanceComponent_exposer.def( "__deepcopy__", &__copy__);
TripleDistanceComponent_exposer.def( "clone", &__copy__);
TripleDistanceComponent_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::TripleDistanceComponent >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
TripleDistanceComponent_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::TripleDistanceComponent >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
TripleDistanceComponent_exposer.def( "__str__", &__str__< ::SireSystem::TripleDistanceComponent > );
TripleDistanceComponent_exposer.def( "__repr__", &__str__< ::SireSystem::TripleDistanceComponent > );
}
}
void register_AngleComponent_class(){
{ //::SireSystem::AngleComponent
typedef bp::class_< SireSystem::AngleComponent, bp::bases< SireSystem::GeometryComponent, SireSystem::Constraint, SireBase::Property > > AngleComponent_exposer_t;
AngleComponent_exposer_t AngleComponent_exposer = AngleComponent_exposer_t( "AngleComponent", "This is a constraint that constrains a symbol to equal the\nvalue of an expression that involves an angle between three points\nor atoms\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope AngleComponent_scope( AngleComponent_exposer );
AngleComponent_exposer.def( bp::init< SireCAS::Symbol const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("constrained_symbol"), bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to set the value of constrained_symbol equal to the\nangle between the three points point0, point1 and point2") );
AngleComponent_exposer.def( bp::init< SireCAS::Symbol const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("constrained_symbol"), bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("geometry_expression"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to set the value of constrained_symbol equal to the\nexpression based on the angles within the three points\npoint0, point1 and point2") );
AngleComponent_exposer.def( bp::init< SireSystem::AngleComponent const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireSystem::AngleComponent::nPoints
typedef int ( ::SireSystem::AngleComponent::*nPoints_function_type)( ) const;
nPoints_function_type nPoints_function_value( &::SireSystem::AngleComponent::nPoints );
AngleComponent_exposer.def(
"nPoints"
, nPoints_function_value
, "Return the number of points (3)" );
}
AngleComponent_exposer.def( bp::self != bp::self );
{ //::SireSystem::AngleComponent::operator=
typedef ::SireSystem::AngleComponent & ( ::SireSystem::AngleComponent::*assign_function_type)( ::SireSystem::AngleComponent const & ) ;
assign_function_type assign_function_value( &::SireSystem::AngleComponent::operator= );
AngleComponent_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
AngleComponent_exposer.def( bp::self == bp::self );
{ //::SireSystem::AngleComponent::point
typedef ::SireFF::Point const & ( ::SireSystem::AngleComponent::*point_function_type)( int ) const;
point_function_type point_function_value( &::SireSystem::AngleComponent::point );
AngleComponent_exposer.def(
"point"
, point_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the ith point\nThrow: SireError::invalid_index\n" );
}
{ //::SireSystem::AngleComponent::point0
typedef ::SireFF::Point const & ( ::SireSystem::AngleComponent::*point0_function_type)( ) const;
point0_function_type point0_function_value( &::SireSystem::AngleComponent::point0 );
AngleComponent_exposer.def(
"point0"
, point0_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the first point between which the angle is calculated" );
}
{ //::SireSystem::AngleComponent::point1
typedef ::SireFF::Point const & ( ::SireSystem::AngleComponent::*point1_function_type)( ) const;
point1_function_type point1_function_value( &::SireSystem::AngleComponent::point1 );
AngleComponent_exposer.def(
"point1"
, point1_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the second point between which the angle is calculated" );
}
{ //::SireSystem::AngleComponent::point2
typedef ::SireFF::Point const & ( ::SireSystem::AngleComponent::*point2_function_type)( ) const;
point2_function_type point2_function_value( &::SireSystem::AngleComponent::point2 );
AngleComponent_exposer.def(
"point2"
, point2_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the third point between which the angle is calculated" );
}
{ //::SireSystem::AngleComponent::r01
typedef ::SireCAS::Symbol const & ( *r01_function_type )( );
r01_function_type r01_function_value( &::SireSystem::AngleComponent::r01 );
AngleComponent_exposer.def(
"r01"
, r01_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the symbol that represents the 0-1 distance" );
}
{ //::SireSystem::AngleComponent::r02
typedef ::SireCAS::Symbol const & ( *r02_function_type )( );
r02_function_type r02_function_value( &::SireSystem::AngleComponent::r02 );
AngleComponent_exposer.def(
"r02"
, r02_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the symbol that represents the 0-2 distance" );
}
{ //::SireSystem::AngleComponent::r12
typedef ::SireCAS::Symbol const & ( *r12_function_type )( );
r12_function_type r12_function_value( &::SireSystem::AngleComponent::r12 );
AngleComponent_exposer.def(
"r12"
, r12_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the symbol that represents the 1-2 distance" );
}
{ //::SireSystem::AngleComponent::theta
typedef ::SireCAS::Symbol const & ( *theta_function_type )( );
theta_function_type theta_function_value( &::SireSystem::AngleComponent::theta );
AngleComponent_exposer.def(
"theta"
, theta_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the symbol that represents the central angle between\nthe three points" );
}
{ //::SireSystem::AngleComponent::theta012
typedef ::SireCAS::Symbol const & ( *theta012_function_type )( );
theta012_function_type theta012_function_value( &::SireSystem::AngleComponent::theta012 );
AngleComponent_exposer.def(
"theta012"
, theta012_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the symbol that represents the angle 012 between\nthe three points" );
}
{ //::SireSystem::AngleComponent::theta021
typedef ::SireCAS::Symbol const & ( *theta021_function_type )( );
theta021_function_type theta021_function_value( &::SireSystem::AngleComponent::theta021 );
AngleComponent_exposer.def(
"theta021"
, theta021_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the symbol that represents the angle 021 between\nthe three points" );
}
{ //::SireSystem::AngleComponent::theta102
typedef ::SireCAS::Symbol const & ( *theta102_function_type )( );
theta102_function_type theta102_function_value( &::SireSystem::AngleComponent::theta102 );
AngleComponent_exposer.def(
"theta102"
, theta102_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the symbol that represents the angle 102 between\nthe three points" );
}
{ //::SireSystem::AngleComponent::toString
typedef ::QString ( ::SireSystem::AngleComponent::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireSystem::AngleComponent::toString );
AngleComponent_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireSystem::AngleComponent::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireSystem::AngleComponent::typeName );
AngleComponent_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
AngleComponent_exposer.staticmethod( "r01" );
AngleComponent_exposer.staticmethod( "r02" );
AngleComponent_exposer.staticmethod( "r12" );
AngleComponent_exposer.staticmethod( "theta" );
AngleComponent_exposer.staticmethod( "theta012" );
AngleComponent_exposer.staticmethod( "theta021" );
AngleComponent_exposer.staticmethod( "theta102" );
AngleComponent_exposer.staticmethod( "typeName" );
AngleComponent_exposer.def( "__copy__", &__copy__);
AngleComponent_exposer.def( "__deepcopy__", &__copy__);
AngleComponent_exposer.def( "clone", &__copy__);
AngleComponent_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::AngleComponent >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AngleComponent_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::AngleComponent >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AngleComponent_exposer.def( "__str__", &__str__< ::SireSystem::AngleComponent > );
AngleComponent_exposer.def( "__repr__", &__str__< ::SireSystem::AngleComponent > );
}
}
void register_IDAssigner_class(){
{ //::SireSystem::IDAssigner
typedef bp::class_< SireSystem::IDAssigner, bp::bases< SireBase::Property > > IDAssigner_exposer_t;
IDAssigner_exposer_t IDAssigner_exposer = IDAssigner_exposer_t( "IDAssigner", "This class uses the machinery of the identity point to\npick out molecules that are associated with identity points.\nThis is useful if you want to monitor a property or energy,\nbut dont actually want to change the coordinates of atoms\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope IDAssigner_scope( IDAssigner_exposer );
IDAssigner_exposer.def( bp::init< SireFF::PointRef const &, SireMol::MoleculeGroup const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("point"), bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ), "Constructor") );
IDAssigner_exposer.def( bp::init< QVector< SireBase::PropPtr< SireFF::Point > > const &, SireMol::MoleculeGroup const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("points"), bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to find the identity of the molecules from\nmolgroup that match the points in points -\nthis creates a list of n molecules, where the ith molecule\nis matched to the ith point") );
IDAssigner_exposer.def( bp::init< SireFF::PointRef const &, SireMol::MoleculeGroup const &, SireVol::Space const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("point"), bp::arg("molgroup"), bp::arg("space"), bp::arg("map")=SireBase::PropertyMap() ), "Constructor") );
IDAssigner_exposer.def( bp::init< QVector< SireBase::PropPtr< SireFF::Point > > const &, SireMol::MoleculeGroup const &, SireVol::Space const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("points"), bp::arg("molgroup"), bp::arg("space"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to find the identity of the molecules from\nmolgroup that match the points in points -\nthis creates a list of n molecules, where the ith molecule\nis matched to the ith point") );
IDAssigner_exposer.def( bp::init< SireSystem::IDAssigner const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireSystem::IDAssigner::identifiedMolecules
typedef ::QVector< SireMol::PartialMolecule > ( ::SireSystem::IDAssigner::*identifiedMolecules_function_type)( ) const;
identifiedMolecules_function_type identifiedMolecules_function_value( &::SireSystem::IDAssigner::identifiedMolecules );
IDAssigner_exposer.def(
"identifiedMolecules"
, identifiedMolecules_function_value
, "Returns the list of identified molecules from the system,\nwhich are returned in the same order as the list of identity points\n" );
}
{ //::SireSystem::IDAssigner::moleculeGroup
typedef ::SireMol::MoleculeGroup const & ( ::SireSystem::IDAssigner::*moleculeGroup_function_type)( ) const;
moleculeGroup_function_type moleculeGroup_function_value( &::SireSystem::IDAssigner::moleculeGroup );
IDAssigner_exposer.def(
"moleculeGroup"
, moleculeGroup_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the molecule group operated on by this constraint" );
}
{ //::SireSystem::IDAssigner::nPoints
typedef int ( ::SireSystem::IDAssigner::*nPoints_function_type)( ) const;
nPoints_function_type nPoints_function_value( &::SireSystem::IDAssigner::nPoints );
IDAssigner_exposer.def(
"nPoints"
, nPoints_function_value
, "Return the number of identity points (and thus the number of\nidentified molecules)" );
}
IDAssigner_exposer.def( bp::self != bp::self );
{ //::SireSystem::IDAssigner::operator=
typedef ::SireSystem::IDAssigner & ( ::SireSystem::IDAssigner::*assign_function_type)( ::SireSystem::IDAssigner const & ) ;
assign_function_type assign_function_value( &::SireSystem::IDAssigner::operator= );
IDAssigner_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
IDAssigner_exposer.def( bp::self == bp::self );
{ //::SireSystem::IDAssigner::points
typedef ::QVector< SireBase::PropPtr< SireFF::Point > > ( ::SireSystem::IDAssigner::*points_function_type)( ) const;
points_function_type points_function_value( &::SireSystem::IDAssigner::points );
IDAssigner_exposer.def(
"points"
, points_function_value
, "Return the points used to identify the molecules" );
}
{ //::SireSystem::IDAssigner::propertyMap
typedef ::SireBase::PropertyMap const & ( ::SireSystem::IDAssigner::*propertyMap_function_type)( ) const;
propertyMap_function_type propertyMap_function_value( &::SireSystem::IDAssigner::propertyMap );
IDAssigner_exposer.def(
"propertyMap"
, propertyMap_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the property map used to find the properties required\nby this constraint" );
}
{ //::SireSystem::IDAssigner::space
typedef ::SireVol::Space const & ( ::SireSystem::IDAssigner::*space_function_type)( ) const;
space_function_type space_function_value( &::SireSystem::IDAssigner::space );
IDAssigner_exposer.def(
"space"
, space_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the space used to calculate distances between the molecules\nand the identity points" );
}
{ //::SireSystem::IDAssigner::toString
typedef ::QString ( ::SireSystem::IDAssigner::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireSystem::IDAssigner::toString );
IDAssigner_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this assigner" );
}
{ //::SireSystem::IDAssigner::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireSystem::IDAssigner::typeName );
IDAssigner_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireSystem::IDAssigner::update
typedef void ( ::SireSystem::IDAssigner::*update_function_type)( ::SireSystem::System const & ) ;
update_function_type update_function_value( &::SireSystem::IDAssigner::update );
IDAssigner_exposer.def(
"update"
, update_function_value
, ( bp::arg("system") )
, "Update the assigner with the passed system." );
}
{ //::SireSystem::IDAssigner::what
typedef char const * ( ::SireSystem::IDAssigner::*what_function_type)( ) const;
what_function_type what_function_value( &::SireSystem::IDAssigner::what );
IDAssigner_exposer.def(
"what"
, what_function_value
, "" );
}
IDAssigner_exposer.staticmethod( "typeName" );
IDAssigner_exposer.def( "__copy__", &__copy__);
IDAssigner_exposer.def( "__deepcopy__", &__copy__);
IDAssigner_exposer.def( "clone", &__copy__);
IDAssigner_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::IDAssigner >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
IDAssigner_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::IDAssigner >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
IDAssigner_exposer.def( "__str__", &__str__< ::SireSystem::IDAssigner > );
IDAssigner_exposer.def( "__repr__", &__str__< ::SireSystem::IDAssigner > );
}
}
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_DoubleDistanceRestraint_class(){
{ //::SireMM::DoubleDistanceRestraint
typedef bp::class_< SireMM::DoubleDistanceRestraint, bp::bases< SireMM::Restraint3D, SireMM::Restraint, SireBase::Property > > DoubleDistanceRestraint_exposer_t;
DoubleDistanceRestraint_exposer_t DoubleDistanceRestraint_exposer = DoubleDistanceRestraint_exposer_t( "DoubleDistanceRestraint", bp::init< >() );
bp::scope DoubleDistanceRestraint_scope( DoubleDistanceRestraint_exposer );
DoubleDistanceRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("restraint") )) );
DoubleDistanceRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const &, SireCAS::Values const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("restraint"), bp::arg("values") )) );
DoubleDistanceRestraint_exposer.def( bp::init< SireMM::DoubleDistanceRestraint const & >(( bp::arg("other") )) );
{ //::SireMM::DoubleDistanceRestraint::builtinSymbols
typedef ::SireCAS::Symbols ( ::SireMM::DoubleDistanceRestraint::*builtinSymbols_function_type )( ) const;
builtinSymbols_function_type builtinSymbols_function_value( &::SireMM::DoubleDistanceRestraint::builtinSymbols );
DoubleDistanceRestraint_exposer.def(
"builtinSymbols"
, builtinSymbols_function_value );
}
{ //::SireMM::DoubleDistanceRestraint::builtinValues
typedef ::SireCAS::Values ( ::SireMM::DoubleDistanceRestraint::*builtinValues_function_type )( ) const;
builtinValues_function_type builtinValues_function_value( &::SireMM::DoubleDistanceRestraint::builtinValues );
DoubleDistanceRestraint_exposer.def(
"builtinValues"
, builtinValues_function_value );
}
{ //::SireMM::DoubleDistanceRestraint::contains
typedef bool ( ::SireMM::DoubleDistanceRestraint::*contains_function_type )( ::SireMol::MolNum ) const;
contains_function_type contains_function_value( &::SireMM::DoubleDistanceRestraint::contains );
DoubleDistanceRestraint_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMM::DoubleDistanceRestraint::contains
typedef bool ( ::SireMM::DoubleDistanceRestraint::*contains_function_type )( ::SireMol::MolID const & ) const;
contains_function_type contains_function_value( &::SireMM::DoubleDistanceRestraint::contains );
DoubleDistanceRestraint_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molid") ) );
}
{ //::SireMM::DoubleDistanceRestraint::differentialRestraintFunction01
typedef ::SireCAS::Expression const & ( ::SireMM::DoubleDistanceRestraint::*differentialRestraintFunction01_function_type )( ) const;
differentialRestraintFunction01_function_type differentialRestraintFunction01_function_value( &::SireMM::DoubleDistanceRestraint::differentialRestraintFunction01 );
DoubleDistanceRestraint_exposer.def(
"differentialRestraintFunction01"
, differentialRestraintFunction01_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMM::DoubleDistanceRestraint::differentialRestraintFunction23
typedef ::SireCAS::Expression const & ( ::SireMM::DoubleDistanceRestraint::*differentialRestraintFunction23_function_type )( ) const;
differentialRestraintFunction23_function_type differentialRestraintFunction23_function_value( &::SireMM::DoubleDistanceRestraint::differentialRestraintFunction23 );
DoubleDistanceRestraint_exposer.def(
"differentialRestraintFunction23"
, differentialRestraintFunction23_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMM::DoubleDistanceRestraint::differentiate
typedef ::SireMM::RestraintPtr ( ::SireMM::DoubleDistanceRestraint::*differentiate_function_type )( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireMM::DoubleDistanceRestraint::differentiate );
DoubleDistanceRestraint_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireMM::DoubleDistanceRestraint::force
typedef void ( ::SireMM::DoubleDistanceRestraint::*force_function_type )( ::SireFF::MolForceTable &,double ) const;
force_function_type force_function_value( &::SireMM::DoubleDistanceRestraint::force );
DoubleDistanceRestraint_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) );
}
{ //::SireMM::DoubleDistanceRestraint::force
typedef void ( ::SireMM::DoubleDistanceRestraint::*force_function_type )( ::SireFF::ForceTable &,double ) const;
force_function_type force_function_value( &::SireMM::DoubleDistanceRestraint::force );
DoubleDistanceRestraint_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) );
}
{ //::SireMM::DoubleDistanceRestraint::molecules
typedef ::SireMol::Molecules ( ::SireMM::DoubleDistanceRestraint::*molecules_function_type )( ) const;
molecules_function_type molecules_function_value( &::SireMM::DoubleDistanceRestraint::molecules );
DoubleDistanceRestraint_exposer.def(
"molecules"
, molecules_function_value );
}
{ //::SireMM::DoubleDistanceRestraint::nPoints
typedef int ( ::SireMM::DoubleDistanceRestraint::*nPoints_function_type )( ) const;
nPoints_function_type nPoints_function_value( &::SireMM::DoubleDistanceRestraint::nPoints );
DoubleDistanceRestraint_exposer.def(
"nPoints"
, nPoints_function_value );
}
DoubleDistanceRestraint_exposer.def( bp::self != bp::self );
{ //::SireMM::DoubleDistanceRestraint::operator=
typedef ::SireMM::DoubleDistanceRestraint & ( ::SireMM::DoubleDistanceRestraint::*assign_function_type )( ::SireMM::DoubleDistanceRestraint const & ) ;
assign_function_type assign_function_value( &::SireMM::DoubleDistanceRestraint::operator= );
DoubleDistanceRestraint_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
DoubleDistanceRestraint_exposer.def( bp::self == bp::self );
{ //::SireMM::DoubleDistanceRestraint::point
typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point_function_type )( int ) const;
point_function_type point_function_value( &::SireMM::DoubleDistanceRestraint::point );
DoubleDistanceRestraint_exposer.def(
"point"
, point_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::DoubleDistanceRestraint::point0
typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point0_function_type )( ) const;
point0_function_type point0_function_value( &::SireMM::DoubleDistanceRestraint::point0 );
DoubleDistanceRestraint_exposer.def(
"point0"
, point0_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::DoubleDistanceRestraint::point1
typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point1_function_type )( ) const;
point1_function_type point1_function_value( &::SireMM::DoubleDistanceRestraint::point1 );
DoubleDistanceRestraint_exposer.def(
"point1"
, point1_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::DoubleDistanceRestraint::point2
typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point2_function_type )( ) const;
point2_function_type point2_function_value( &::SireMM::DoubleDistanceRestraint::point2 );
DoubleDistanceRestraint_exposer.def(
"point2"
, point2_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::DoubleDistanceRestraint::point3
typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point3_function_type )( ) const;
point3_function_type point3_function_value( &::SireMM::DoubleDistanceRestraint::point3 );
DoubleDistanceRestraint_exposer.def(
"point3"
, point3_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::DoubleDistanceRestraint::r01
typedef ::SireCAS::Symbol const & ( *r01_function_type )( );
r01_function_type r01_function_value( &::SireMM::DoubleDistanceRestraint::r01 );
DoubleDistanceRestraint_exposer.def(
"r01"
, r01_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::DoubleDistanceRestraint::r23
typedef ::SireCAS::Symbol const & ( *r23_function_type )( );
r23_function_type r23_function_value( &::SireMM::DoubleDistanceRestraint::r23 );
DoubleDistanceRestraint_exposer.def(
"r23"
, r23_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::DoubleDistanceRestraint::setSpace
typedef void ( ::SireMM::DoubleDistanceRestraint::*setSpace_function_type )( ::SireVol::Space const & ) ;
setSpace_function_type setSpace_function_value( &::SireMM::DoubleDistanceRestraint::setSpace );
DoubleDistanceRestraint_exposer.def(
"setSpace"
, setSpace_function_value
, ( bp::arg("space") ) );
}
{ //::SireMM::DoubleDistanceRestraint::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::DoubleDistanceRestraint::typeName );
DoubleDistanceRestraint_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMM::DoubleDistanceRestraint::update
typedef void ( ::SireMM::DoubleDistanceRestraint::*update_function_type )( ::SireMol::MoleculeData const & ) ;
update_function_type update_function_value( &::SireMM::DoubleDistanceRestraint::update );
DoubleDistanceRestraint_exposer.def(
"update"
, update_function_value
, ( bp::arg("moldata") ) );
}
{ //::SireMM::DoubleDistanceRestraint::update
typedef void ( ::SireMM::DoubleDistanceRestraint::*update_function_type )( ::SireMol::Molecules const & ) ;
update_function_type update_function_value( &::SireMM::DoubleDistanceRestraint::update );
DoubleDistanceRestraint_exposer.def(
"update"
, update_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMM::DoubleDistanceRestraint::usesMoleculesIn
typedef bool ( ::SireMM::DoubleDistanceRestraint::*usesMoleculesIn_function_type )( ::SireFF::ForceTable const & ) const;
usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DoubleDistanceRestraint::usesMoleculesIn );
DoubleDistanceRestraint_exposer.def(
"usesMoleculesIn"
, usesMoleculesIn_function_value
, ( bp::arg("forcetable") ) );
}
{ //::SireMM::DoubleDistanceRestraint::usesMoleculesIn
typedef bool ( ::SireMM::DoubleDistanceRestraint::*usesMoleculesIn_function_type )( ::SireMol::Molecules const & ) const;
usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DoubleDistanceRestraint::usesMoleculesIn );
DoubleDistanceRestraint_exposer.def(
"usesMoleculesIn"
, usesMoleculesIn_function_value
, ( bp::arg("molecules") ) );
}
DoubleDistanceRestraint_exposer.staticmethod( "r01" );
DoubleDistanceRestraint_exposer.staticmethod( "r23" );
DoubleDistanceRestraint_exposer.staticmethod( "typeName" );
DoubleDistanceRestraint_exposer.def( "__copy__", &__copy__);
DoubleDistanceRestraint_exposer.def( "__deepcopy__", &__copy__);
DoubleDistanceRestraint_exposer.def( "clone", &__copy__);
DoubleDistanceRestraint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::DoubleDistanceRestraint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DoubleDistanceRestraint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::DoubleDistanceRestraint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DoubleDistanceRestraint_exposer.def( "__str__", &__str__< ::SireMM::DoubleDistanceRestraint > );
DoubleDistanceRestraint_exposer.def( "__repr__", &__str__< ::SireMM::DoubleDistanceRestraint > );
}
}
