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_NullRestraint_class() {
{ //::SireMM::NullRestraint
typedef bp::class_< SireMM::NullRestraint, bp::bases< SireMM::Restraint3D, SireMM::Restraint, SireBase::Property > > NullRestraint_exposer_t;
NullRestraint_exposer_t NullRestraint_exposer = NullRestraint_exposer_t( "NullRestraint", bp::init< >() );
bp::scope NullRestraint_scope( NullRestraint_exposer );
NullRestraint_exposer.def( bp::init< SireMM::NullRestraint const & >(( bp::arg("other") )) );
{ //::SireMM::NullRestraint::builtinSymbols
typedef ::SireCAS::Symbols ( ::SireMM::NullRestraint::*builtinSymbols_function_type )( ) const;
builtinSymbols_function_type builtinSymbols_function_value( &::SireMM::NullRestraint::builtinSymbols );
NullRestraint_exposer.def(
"builtinSymbols"
, builtinSymbols_function_value );
}
{ //::SireMM::NullRestraint::builtinValues
typedef ::SireCAS::Values ( ::SireMM::NullRestraint::*builtinValues_function_type )( ) const;
builtinValues_function_type builtinValues_function_value( &::SireMM::NullRestraint::builtinValues );
NullRestraint_exposer.def(
"builtinValues"
, builtinValues_function_value );
}
{ //::SireMM::NullRestraint::contains
typedef bool ( ::SireMM::NullRestraint::*contains_function_type )( ::SireMol::MolNum ) const;
contains_function_type contains_function_value( &::SireMM::NullRestraint::contains );
NullRestraint_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMM::NullRestraint::contains
typedef bool ( ::SireMM::NullRestraint::*contains_function_type )( ::SireMol::MolID const & ) const;
contains_function_type contains_function_value( &::SireMM::NullRestraint::contains );
NullRestraint_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molid") ) );
}
{ //::SireMM::NullRestraint::differentiate
typedef ::SireMM::RestraintPtr ( ::SireMM::NullRestraint::*differentiate_function_type )( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireMM::NullRestraint::differentiate );
NullRestraint_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireMM::NullRestraint::energy
typedef ::SireUnits::Dimension::MolarEnergy ( ::SireMM::NullRestraint::*energy_function_type )( ) const;
energy_function_type energy_function_value( &::SireMM::NullRestraint::energy );
NullRestraint_exposer.def(
"energy"
, energy_function_value );
}
{ //::SireMM::NullRestraint::force
typedef void ( ::SireMM::NullRestraint::*force_function_type )( ::SireFF::MolForceTable &,double ) const;
force_function_type force_function_value( &::SireMM::NullRestraint::force );
NullRestraint_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) );
}
{ //::SireMM::NullRestraint::force
typedef void ( ::SireMM::NullRestraint::*force_function_type )( ::SireFF::ForceTable &,double ) const;
force_function_type force_function_value( &::SireMM::NullRestraint::force );
NullRestraint_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) );
}
{ //::SireMM::NullRestraint::getValue
typedef double ( ::SireMM::NullRestraint::*getValue_function_type )( ::SireCAS::Symbol const & ) const;
getValue_function_type getValue_function_value( &::SireMM::NullRestraint::getValue );
NullRestraint_exposer.def(
"getValue"
, getValue_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireMM::NullRestraint::hasValue
typedef bool ( ::SireMM::NullRestraint::*hasValue_function_type )( ::SireCAS::Symbol const & ) const;
hasValue_function_type hasValue_function_value( &::SireMM::NullRestraint::hasValue );
NullRestraint_exposer.def(
"hasValue"
, hasValue_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireMM::NullRestraint::molecules
typedef ::SireMol::Molecules ( ::SireMM::NullRestraint::*molecules_function_type )( ) const;
molecules_function_type molecules_function_value( &::SireMM::NullRestraint::molecules );
NullRestraint_exposer.def(
"molecules"
, molecules_function_value );
}
NullRestraint_exposer.def( bp::self != bp::self );
{ //::SireMM::NullRestraint::operator=
typedef ::SireMM::NullRestraint & ( ::SireMM::NullRestraint::*assign_function_type )( ::SireMM::NullRestraint const & ) ;
assign_function_type assign_function_value( &::SireMM::NullRestraint::operator= );
NullRestraint_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
NullRestraint_exposer.def( bp::self == bp::self );
{ //::SireMM::NullRestraint::setValue
typedef void ( ::SireMM::NullRestraint::*setValue_function_type )( ::SireCAS::Symbol const &,double ) ;
setValue_function_type setValue_function_value( &::SireMM::NullRestraint::setValue );
NullRestraint_exposer.def(
"setValue"
, setValue_function_value
, ( bp::arg("symbol"), bp::arg("value") ) );
}
{ //::SireMM::NullRestraint::symbols
typedef ::SireCAS::Symbols ( ::SireMM::NullRestraint::*symbols_function_type )( ) const;
symbols_function_type symbols_function_value( &::SireMM::NullRestraint::symbols );
NullRestraint_exposer.def(
"symbols"
, symbols_function_value );
}
{ //::SireMM::NullRestraint::toString
typedef ::QString ( ::SireMM::NullRestraint::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMM::NullRestraint::toString );
NullRestraint_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMM::NullRestraint::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::NullRestraint::typeName );
NullRestraint_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMM::NullRestraint::update
typedef void ( ::SireMM::NullRestraint::*update_function_type )( ::SireMol::MoleculeData const & ) ;
update_function_type update_function_value( &::SireMM::NullRestraint::update );
NullRestraint_exposer.def(
"update"
, update_function_value
, ( bp::arg("moldata") ) );
}
{ //::SireMM::NullRestraint::update
typedef void ( ::SireMM::NullRestraint::*update_function_type )( ::SireMol::Molecules const & ) ;
update_function_type update_function_value( &::SireMM::NullRestraint::update );
NullRestraint_exposer.def(
"update"
, update_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMM::NullRestraint::userSymbols
typedef ::SireCAS::Symbols ( ::SireMM::NullRestraint::*userSymbols_function_type )( ) const;
userSymbols_function_type userSymbols_function_value( &::SireMM::NullRestraint::userSymbols );
NullRestraint_exposer.def(
"userSymbols"
, userSymbols_function_value );
}
{ //::SireMM::NullRestraint::userValues
typedef ::SireCAS::Values ( ::SireMM::NullRestraint::*userValues_function_type )( ) const;
userValues_function_type userValues_function_value( &::SireMM::NullRestraint::userValues );
NullRestraint_exposer.def(
"userValues"
, userValues_function_value );
}
{ //::SireMM::NullRestraint::usesMoleculesIn
typedef bool ( ::SireMM::NullRestraint::*usesMoleculesIn_function_type )( ::SireFF::ForceTable const & ) const;
usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::NullRestraint::usesMoleculesIn );
NullRestraint_exposer.def(
"usesMoleculesIn"
, usesMoleculesIn_function_value
, ( bp::arg("forcetable") ) );
}
{ //::SireMM::NullRestraint::usesMoleculesIn
typedef bool ( ::SireMM::NullRestraint::*usesMoleculesIn_function_type )( ::SireMol::Molecules const & ) const;
usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::NullRestraint::usesMoleculesIn );
NullRestraint_exposer.def(
"usesMoleculesIn"
, usesMoleculesIn_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMM::NullRestraint::values
typedef ::SireCAS::Values ( ::SireMM::NullRestraint::*values_function_type )( ) const;
values_function_type values_function_value( &::SireMM::NullRestraint::values );
NullRestraint_exposer.def(
"values"
, values_function_value );
}
NullRestraint_exposer.staticmethod( "typeName" );
NullRestraint_exposer.def( "__copy__", &__copy__);
NullRestraint_exposer.def( "__deepcopy__", &__copy__);
NullRestraint_exposer.def( "clone", &__copy__);
NullRestraint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::NullRestraint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullRestraint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::NullRestraint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullRestraint_exposer.def( "__str__", &__str__< ::SireMM::NullRestraint > );
NullRestraint_exposer.def( "__repr__", &__str__< ::SireMM::NullRestraint > );
}
}
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_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 > );
}
}