void register_ChargeConstraint_class(){
{ //::SireSystem::ChargeConstraint
typedef bp::class_< SireSystem::ChargeConstraint, bp::bases< SireSystem::MoleculeConstraint, SireSystem::Constraint, SireBase::Property >, boost::noncopyable > ChargeConstraint_exposer_t;
ChargeConstraint_exposer_t ChargeConstraint_exposer = ChargeConstraint_exposer_t( "ChargeConstraint", bp::no_init );
bp::scope ChargeConstraint_scope( ChargeConstraint_exposer );
{ //::SireSystem::ChargeConstraint::moleculeGroup
typedef ::SireMol::MoleculeGroup const & ( ::SireSystem::ChargeConstraint::*moleculeGroup_function_type )( ) const;
moleculeGroup_function_type moleculeGroup_function_value( &::SireSystem::ChargeConstraint::moleculeGroup );
ChargeConstraint_exposer.def(
"moleculeGroup"
, moleculeGroup_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::ChargeConstraint::propertyMap
typedef ::SireBase::PropertyMap const & ( ::SireSystem::ChargeConstraint::*propertyMap_function_type )( ) const;
propertyMap_function_type propertyMap_function_value( &::SireSystem::ChargeConstraint::propertyMap );
ChargeConstraint_exposer.def(
"propertyMap"
, propertyMap_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireSystem::ChargeConstraint::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireSystem::ChargeConstraint::typeName );
ChargeConstraint_exposer.def(
"typeName"
, typeName_function_value );
}
ChargeConstraint_exposer.staticmethod( "typeName" );
ChargeConstraint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::ChargeConstraint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChargeConstraint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::ChargeConstraint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChargeConstraint_exposer.def( "__str__", &__str__< ::SireSystem::ChargeConstraint > );
ChargeConstraint_exposer.def( "__repr__", &__str__< ::SireSystem::ChargeConstraint > );
}
}
void register_Perturbation_class(){
{ //::SireMol::Perturbation
typedef bp::class_< SireMol::Perturbation, bp::bases< SireBase::Property >, boost::noncopyable > Perturbation_exposer_t;
Perturbation_exposer_t Perturbation_exposer = Perturbation_exposer_t( "Perturbation", "This is the base class of all perturbation objects. A Perturbation\nis a rule for changing a property of a molecule with respect\nto a driving (reaction) coordinate. Perturbations can be used\nto implement single topology free energy calculations\n\nAuthor: Christopher Woods\n", bp::no_init );
bp::scope Perturbation_scope( Perturbation_exposer );
{ //::SireMol::Perturbation::children
typedef ::QList< SireBase::PropPtr< SireMol::Perturbation > > ( ::SireMol::Perturbation::*children_function_type)( ) const;
children_function_type children_function_value( &::SireMol::Perturbation::children );
Perturbation_exposer.def(
"children"
, children_function_value
, "Return all of the child perturbations that make up\nthis perturbation" );
}
{ //::SireMol::Perturbation::defaultFunction
typedef ::SireCAS::Expression const & ( *defaultFunction_function_type )( );
defaultFunction_function_type defaultFunction_function_value( &::SireMol::Perturbation::defaultFunction );
Perturbation_exposer.def(
"defaultFunction"
, defaultFunction_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the default mapping equation for the perturbations - this\nlinearly maps from the initial values at lambda=0 to the\nfinal value at lambda=1" );
}
{ //::SireMol::Perturbation::mappingFunction
typedef ::SireCAS::Expression const & ( ::SireMol::Perturbation::*mappingFunction_function_type)( ) const;
mappingFunction_function_type mappingFunction_function_value( &::SireMol::Perturbation::mappingFunction );
Perturbation_exposer.def(
"mappingFunction"
, mappingFunction_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the equation used to control the mapping from the\nthe initial value (represented using symbols().initial()) to\nthe final value (represented using symbols().final()) as a\nfunction of the reaction coordinate (which is normally\nrepresented using symbols().lambda())" );
}
{ //::SireMol::Perturbation::null
typedef ::SireMol::NullPerturbation const & ( *null_function_type )( );
null_function_type null_function_value( &::SireMol::Perturbation::null );
Perturbation_exposer.def(
"null"
, null_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::Perturbation::perturb
typedef ::SireMol::Molecule ( ::SireMol::Perturbation::*perturb_function_type)( ::SireMol::Molecule const &,::SireCAS::Values const & ) const;
perturb_function_type perturb_function_value( &::SireMol::Perturbation::perturb );
Perturbation_exposer.def(
"perturb"
, perturb_function_value
, ( bp::arg("molecule"), bp::arg("values") )
, "Perturb the passed molecule, returning the result\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\nThrow: SireError:incompatible_error\n" );
}
{ //::SireMol::Perturbation::propertyMap
typedef ::SireBase::PropertyMap const & ( ::SireMol::Perturbation::*propertyMap_function_type)( ) const;
propertyMap_function_type propertyMap_function_value( &::SireMol::Perturbation::propertyMap );
Perturbation_exposer.def(
"propertyMap"
, propertyMap_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the property map used to find the properties used,\nand affected by this perturbation" );
}
{ //::SireMol::Perturbation::recreate
typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*recreate_function_type)( ) const;
recreate_function_type recreate_function_value( &::SireMol::Perturbation::recreate );
Perturbation_exposer.def(
"recreate"
, recreate_function_value
, "Recreate this perturbation - this has the same effect as .clone()" );
}
{ //::SireMol::Perturbation::recreate
typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*recreate_function_type)( ::SireCAS::Expression const & ) const;
recreate_function_type recreate_function_value( &::SireMol::Perturbation::recreate );
Perturbation_exposer.def(
"recreate"
, recreate_function_value
, ( bp::arg("mapping_function") )
, "Recreate this perturbation, replacing its current mapping function\nwith mapping_function" );
}
{ //::SireMol::Perturbation::recreate
typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*recreate_function_type)( ::SireBase::PropertyMap const & ) const;
recreate_function_type recreate_function_value( &::SireMol::Perturbation::recreate );
Perturbation_exposer.def(
"recreate"
, recreate_function_value
, ( bp::arg("map") )
, "Recreate this perturbation, replacing the current property map with map" );
}
{ //::SireMol::Perturbation::recreate
typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*recreate_function_type)( ::SireCAS::Expression const &,::SireBase::PropertyMap const & ) const;
recreate_function_type recreate_function_value( &::SireMol::Perturbation::recreate );
Perturbation_exposer.def(
"recreate"
, recreate_function_value
, ( bp::arg("mapping_function"), bp::arg("map") )
, "Recreate this perturbation, replacing both the mapping function and\nthe property map" );
}
{ //::SireMol::Perturbation::requiredProperties
typedef ::QSet< QString > ( ::SireMol::Perturbation::*requiredProperties_function_type)( ) const;
requiredProperties_function_type requiredProperties_function_value( &::SireMol::Perturbation::requiredProperties );
Perturbation_exposer.def(
"requiredProperties"
, requiredProperties_function_value
, "" );
}
{ //::SireMol::Perturbation::requiredSymbols
typedef ::QSet< SireCAS::Symbol > ( ::SireMol::Perturbation::*requiredSymbols_function_type)( ) const;
requiredSymbols_function_type requiredSymbols_function_value( &::SireMol::Perturbation::requiredSymbols );
Perturbation_exposer.def(
"requiredSymbols"
, requiredSymbols_function_value
, "Return all of the symbols that need to be supplied\nto the mapping function (i.e. ignoring symbols().initial()\nand symbols().final() )" );
}
{ //::SireMol::Perturbation::substitute
typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*substitute_function_type)( ::SireCAS::Symbol const &,::SireCAS::Symbol const & ) const;
substitute_function_type substitute_function_value( &::SireMol::Perturbation::substitute );
Perturbation_exposer.def(
"substitute"
, substitute_function_value
, ( bp::arg("old_symbol"), bp::arg("new_symbol") )
, "Substitute the symbol old_symbol with the symbol new_symbol\nin all of the mapping functions used by this perturbation. This is\nuseful if, for example, you want to switch from using\nlambda to control the perturbation to using alpha, e.g.\n" );
}
{ //::SireMol::Perturbation::substitute
typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*substitute_function_type)( ::SireCAS::Identities const & ) const;
substitute_function_type substitute_function_value( &::SireMol::Perturbation::substitute );
Perturbation_exposer.def(
"substitute"
, substitute_function_value
, ( bp::arg("identities") )
, "Substitute the identities in identities in all of the mapping functions\nused by this perturbation. This is useful if, for example, you want to\nswitch from using lambda to control the perturbation to using alpha, e.g.\n" );
}
{ //::SireMol::Perturbation::symbols
typedef ::SireMol::PerturbationSymbols const & ( *symbols_function_type )( );
symbols_function_type symbols_function_value( &::SireMol::Perturbation::symbols );
Perturbation_exposer.def(
"symbols"
, symbols_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the symbols object that contains the symbols used\nby the mapping equation" );
}
{ //::SireMol::Perturbation::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::Perturbation::typeName );
Perturbation_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMol::Perturbation::wouldChange
typedef bool ( ::SireMol::Perturbation::*wouldChange_function_type)( ::SireMol::Molecule const &,::SireCAS::Values const & ) const;
wouldChange_function_type wouldChange_function_value( &::SireMol::Perturbation::wouldChange );
Perturbation_exposer.def(
"wouldChange"
, wouldChange_function_value
, ( bp::arg("molecule"), bp::arg("values") )
, "" );
}
Perturbation_exposer.staticmethod( "defaultFunction" );
Perturbation_exposer.staticmethod( "null" );
Perturbation_exposer.staticmethod( "symbols" );
Perturbation_exposer.staticmethod( "typeName" );
Perturbation_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Perturbation >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Perturbation_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Perturbation >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Perturbation_exposer.def( "__str__", &__str__< ::SireMol::Perturbation > );
Perturbation_exposer.def( "__repr__", &__str__< ::SireMol::Perturbation > );
}
}
void register_CLJ14Group_class(){
{ //::SireMM::CLJ14Group
typedef bp::class_< SireMM::CLJ14Group > CLJ14Group_exposer_t;
CLJ14Group_exposer_t CLJ14Group_exposer = CLJ14Group_exposer_t( "CLJ14Group", bp::init< >() );
bp::scope CLJ14Group_scope( CLJ14Group_exposer );
CLJ14Group_exposer.def( bp::init< SireMol::MoleculeView const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("molecule"), bp::arg("map")=SireBase::PropertyMap() )) );
CLJ14Group_exposer.def( bp::init< SireMol::MoleculeView const &, SireMM::CLJFunction::COMBINING_RULES, bool, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("molecule"), bp::arg("combining_rules"), bp::arg("is_strict"), bp::arg("map")=SireBase::PropertyMap() )) );
CLJ14Group_exposer.def( bp::init< SireMM::CLJ14Group const & >(( bp::arg("other") )) );
{ //::SireMM::CLJ14Group::add
typedef void ( ::SireMM::CLJ14Group::*add_function_type )( ::SireMol::MoleculeView const & ) ;
add_function_type add_function_value( &::SireMM::CLJ14Group::add );
CLJ14Group_exposer.def(
"add"
, add_function_value
, ( bp::arg("new_molecule") ) );
}
{ //::SireMM::CLJ14Group::add
typedef void ( ::SireMM::CLJ14Group::*add_function_type )( ::SireMol::AtomSelection const & ) ;
add_function_type add_function_value( &::SireMM::CLJ14Group::add );
CLJ14Group_exposer.def(
"add"
, add_function_value
, ( bp::arg("new_selection") ) );
}
{ //::SireMM::CLJ14Group::combiningRules
typedef ::SireMM::CLJFunction::COMBINING_RULES ( ::SireMM::CLJ14Group::*combiningRules_function_type )( ) const;
combiningRules_function_type combiningRules_function_value( &::SireMM::CLJ14Group::combiningRules );
CLJ14Group_exposer.def(
"combiningRules"
, combiningRules_function_value );
}
{ //::SireMM::CLJ14Group::energy
typedef ::boost::tuples::tuple< double, double, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > ( ::SireMM::CLJ14Group::*energy_function_type )( ) ;
energy_function_type energy_function_value( &::SireMM::CLJ14Group::energy );
CLJ14Group_exposer.def(
"energy"
, energy_function_value );
}
{ //::SireMM::CLJ14Group::isNull
typedef bool ( ::SireMM::CLJ14Group::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireMM::CLJ14Group::isNull );
CLJ14Group_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireMM::CLJ14Group::isStrict
typedef bool ( ::SireMM::CLJ14Group::*isStrict_function_type )( ) const;
isStrict_function_type isStrict_function_value( &::SireMM::CLJ14Group::isStrict );
CLJ14Group_exposer.def(
"isStrict"
, isStrict_function_value );
}
{ //::SireMM::CLJ14Group::molecule
typedef ::SireMol::MoleculeView const & ( ::SireMM::CLJ14Group::*molecule_function_type )( ) const;
molecule_function_type molecule_function_value( &::SireMM::CLJ14Group::molecule );
CLJ14Group_exposer.def(
"molecule"
, molecule_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::CLJ14Group::mustNowRecalculateFromScratch
typedef void ( ::SireMM::CLJ14Group::*mustNowRecalculateFromScratch_function_type )( ) ;
mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::SireMM::CLJ14Group::mustNowRecalculateFromScratch );
CLJ14Group_exposer.def(
"mustNowRecalculateFromScratch"
, mustNowRecalculateFromScratch_function_value );
}
{ //::SireMM::CLJ14Group::mustReallyRecalculateFromScratch
typedef void ( ::SireMM::CLJ14Group::*mustReallyRecalculateFromScratch_function_type )( ) ;
mustReallyRecalculateFromScratch_function_type mustReallyRecalculateFromScratch_function_value( &::SireMM::CLJ14Group::mustReallyRecalculateFromScratch );
CLJ14Group_exposer.def(
"mustReallyRecalculateFromScratch"
, mustReallyRecalculateFromScratch_function_value );
}
CLJ14Group_exposer.def( bp::self != bp::self );
{ //::SireMM::CLJ14Group::operator=
typedef ::SireMM::CLJ14Group & ( ::SireMM::CLJ14Group::*assign_function_type )( ::SireMM::CLJ14Group const & ) ;
assign_function_type assign_function_value( &::SireMM::CLJ14Group::operator= );
CLJ14Group_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
CLJ14Group_exposer.def( bp::self == bp::self );
{ //::SireMM::CLJ14Group::propertyMap
typedef ::SireBase::PropertyMap ( ::SireMM::CLJ14Group::*propertyMap_function_type )( ) const;
propertyMap_function_type propertyMap_function_value( &::SireMM::CLJ14Group::propertyMap );
CLJ14Group_exposer.def(
"propertyMap"
, propertyMap_function_value );
}
{ //::SireMM::CLJ14Group::recalculatingFromScratch
typedef bool ( ::SireMM::CLJ14Group::*recalculatingFromScratch_function_type )( ) const;
recalculatingFromScratch_function_type recalculatingFromScratch_function_value( &::SireMM::CLJ14Group::recalculatingFromScratch );
CLJ14Group_exposer.def(
"recalculatingFromScratch"
, recalculatingFromScratch_function_value );
}
{ //::SireMM::CLJ14Group::remove
typedef void ( ::SireMM::CLJ14Group::*remove_function_type )( ::SireMol::AtomSelection const & ) ;
remove_function_type remove_function_value( &::SireMM::CLJ14Group::remove );
CLJ14Group_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("new_selection") ) );
}
{ //::SireMM::CLJ14Group::remove
typedef void ( ::SireMM::CLJ14Group::*remove_function_type )( ::SireMol::MoleculeView const & ) ;
remove_function_type remove_function_value( &::SireMM::CLJ14Group::remove );
CLJ14Group_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("new_molecule") ) );
}
{ //::SireMM::CLJ14Group::setArithmeticCombiningRules
typedef void ( ::SireMM::CLJ14Group::*setArithmeticCombiningRules_function_type )( bool ) ;
setArithmeticCombiningRules_function_type setArithmeticCombiningRules_function_value( &::SireMM::CLJ14Group::setArithmeticCombiningRules );
CLJ14Group_exposer.def(
"setArithmeticCombiningRules"
, setArithmeticCombiningRules_function_value
, ( bp::arg("on") ) );
}
{ //::SireMM::CLJ14Group::setCombiningRules
typedef void ( ::SireMM::CLJ14Group::*setCombiningRules_function_type )( ::SireMM::CLJFunction::COMBINING_RULES ) ;
setCombiningRules_function_type setCombiningRules_function_value( &::SireMM::CLJ14Group::setCombiningRules );
CLJ14Group_exposer.def(
"setCombiningRules"
, setCombiningRules_function_value
, ( bp::arg("rules") ) );
}
{ //::SireMM::CLJ14Group::setGeometricCombiningRules
typedef void ( ::SireMM::CLJ14Group::*setGeometricCombiningRules_function_type )( bool ) ;
setGeometricCombiningRules_function_type setGeometricCombiningRules_function_value( &::SireMM::CLJ14Group::setGeometricCombiningRules );
CLJ14Group_exposer.def(
"setGeometricCombiningRules"
, setGeometricCombiningRules_function_value
, ( bp::arg("on") ) );
}
{ //::SireMM::CLJ14Group::setStrict
typedef bool ( ::SireMM::CLJ14Group::*setStrict_function_type )( bool ) ;
setStrict_function_type setStrict_function_value( &::SireMM::CLJ14Group::setStrict );
CLJ14Group_exposer.def(
"setStrict"
, setStrict_function_value
, ( bp::arg("isstrict") ) );
}
{ //::SireMM::CLJ14Group::toString
typedef ::QString ( ::SireMM::CLJ14Group::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMM::CLJ14Group::toString );
CLJ14Group_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMM::CLJ14Group::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::CLJ14Group::typeName );
CLJ14Group_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMM::CLJ14Group::update
typedef void ( ::SireMM::CLJ14Group::*update_function_type )( ::SireMol::MoleculeView const & ) ;
update_function_type update_function_value( &::SireMM::CLJ14Group::update );
CLJ14Group_exposer.def(
"update"
, update_function_value
, ( bp::arg("new_molecule") ) );
}
{ //::SireMM::CLJ14Group::updateSelection
typedef void ( ::SireMM::CLJ14Group::*updateSelection_function_type )( ::SireMol::AtomSelection const & ) ;
updateSelection_function_type updateSelection_function_value( &::SireMM::CLJ14Group::updateSelection );
CLJ14Group_exposer.def(
"updateSelection"
, updateSelection_function_value
, ( bp::arg("selection") ) );
}
{ //::SireMM::CLJ14Group::usingArithmeticCombiningRules
typedef bool ( ::SireMM::CLJ14Group::*usingArithmeticCombiningRules_function_type )( ) const;
usingArithmeticCombiningRules_function_type usingArithmeticCombiningRules_function_value( &::SireMM::CLJ14Group::usingArithmeticCombiningRules );
CLJ14Group_exposer.def(
"usingArithmeticCombiningRules"
, usingArithmeticCombiningRules_function_value );
}
{ //::SireMM::CLJ14Group::usingGeometricCombiningRules
typedef bool ( ::SireMM::CLJ14Group::*usingGeometricCombiningRules_function_type )( ) const;
usingGeometricCombiningRules_function_type usingGeometricCombiningRules_function_value( &::SireMM::CLJ14Group::usingGeometricCombiningRules );
CLJ14Group_exposer.def(
"usingGeometricCombiningRules"
, usingGeometricCombiningRules_function_value );
}
{ //::SireMM::CLJ14Group::what
typedef char const * ( ::SireMM::CLJ14Group::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMM::CLJ14Group::what );
CLJ14Group_exposer.def(
"what"
, what_function_value );
}
{ //::SireMM::CLJ14Group::wouldChangeProperties
typedef bool ( ::SireMM::CLJ14Group::*wouldChangeProperties_function_type )( ::SireBase::PropertyMap const & ) const;
wouldChangeProperties_function_type wouldChangeProperties_function_value( &::SireMM::CLJ14Group::wouldChangeProperties );
CLJ14Group_exposer.def(
"wouldChangeProperties"
, wouldChangeProperties_function_value
, ( bp::arg("map") ) );
}
CLJ14Group_exposer.staticmethod( "typeName" );
CLJ14Group_exposer.def( "__copy__", &__copy__);
CLJ14Group_exposer.def( "__deepcopy__", &__copy__);
CLJ14Group_exposer.def( "clone", &__copy__);
CLJ14Group_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJ14Group >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJ14Group_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJ14Group >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJ14Group_exposer.def( "__str__", &__str__< ::SireMM::CLJ14Group > );
CLJ14Group_exposer.def( "__repr__", &__str__< ::SireMM::CLJ14Group > );
}
}
void register_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_CloseMols_class() {
{ //::SireSystem::CloseMols
typedef bp::class_< SireSystem::CloseMols > CloseMols_exposer_t;
CloseMols_exposer_t CloseMols_exposer = CloseMols_exposer_t( "CloseMols", bp::init< >() );
bp::scope CloseMols_scope( CloseMols_exposer );
CloseMols_exposer.def( bp::init< SireFF::PointRef const &, SireMol::MoleculeGroup const &, bp::optional< int, SireBase::PropertyMap const & > >(( bp::arg("point"), bp::arg("molgroup"), bp::arg("nclosest")=(int)(1), bp::arg("map")=SireBase::PropertyMap() )) );
CloseMols_exposer.def( bp::init< SireFF::PointRef const &, SireMol::MoleculeGroup const &, SireVol::Space const &, bp::optional< int, SireBase::PropertyMap const & > >(( bp::arg("point"), bp::arg("molgroup"), bp::arg("space"), bp::arg("nclosest")=(int)(1), bp::arg("map")=SireBase::PropertyMap() )) );
CloseMols_exposer.def( bp::init< SireSystem::CloseMols const & >(( bp::arg("other") )) );
{ //::SireSystem::CloseMols::closeMolecules
typedef ::QHash< SireMol::MolNum, double > const & ( ::SireSystem::CloseMols::*closeMolecules_function_type )( ) const;
closeMolecules_function_type closeMolecules_function_value( &::SireSystem::CloseMols::closeMolecules );
CloseMols_exposer.def(
"closeMolecules"
, closeMolecules_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireSystem::CloseMols::isClose
typedef bool ( ::SireSystem::CloseMols::*isClose_function_type )( ::SireMol::MolNum ) const;
isClose_function_type isClose_function_value( &::SireSystem::CloseMols::isClose );
CloseMols_exposer.def(
"isClose"
, isClose_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireSystem::CloseMols::moleculeGroup
typedef ::SireMol::MoleculeGroup const & ( ::SireSystem::CloseMols::*moleculeGroup_function_type )( ) const;
moleculeGroup_function_type moleculeGroup_function_value( &::SireSystem::CloseMols::moleculeGroup );
CloseMols_exposer.def(
"moleculeGroup"
, moleculeGroup_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::CloseMols::nClosest
typedef int ( ::SireSystem::CloseMols::*nClosest_function_type )( ) const;
nClosest_function_type nClosest_function_value( &::SireSystem::CloseMols::nClosest );
CloseMols_exposer.def(
"nClosest"
, nClosest_function_value );
}
CloseMols_exposer.def( bp::self != bp::self );
{ //::SireSystem::CloseMols::operator=
typedef ::SireSystem::CloseMols & ( ::SireSystem::CloseMols::*assign_function_type )( ::SireSystem::CloseMols const & ) ;
assign_function_type assign_function_value( &::SireSystem::CloseMols::operator= );
CloseMols_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
CloseMols_exposer.def( bp::self == bp::self );
{ //::SireSystem::CloseMols::point
typedef ::SireFF::Point const & ( ::SireSystem::CloseMols::*point_function_type )( ) const;
point_function_type point_function_value( &::SireSystem::CloseMols::point );
CloseMols_exposer.def(
"point"
, point_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::CloseMols::propertyMap
typedef ::SireBase::PropertyMap const & ( ::SireSystem::CloseMols::*propertyMap_function_type )( ) const;
propertyMap_function_type propertyMap_function_value( &::SireSystem::CloseMols::propertyMap );
CloseMols_exposer.def(
"propertyMap"
, propertyMap_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireSystem::CloseMols::space
typedef ::SireVol::Space const & ( ::SireSystem::CloseMols::*space_function_type )( ) const;
space_function_type space_function_value( &::SireSystem::CloseMols::space );
CloseMols_exposer.def(
"space"
, space_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::CloseMols::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireSystem::CloseMols::typeName );
CloseMols_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireSystem::CloseMols::update
typedef bool ( ::SireSystem::CloseMols::*update_function_type )( ::SireSystem::System const & ) ;
update_function_type update_function_value( &::SireSystem::CloseMols::update );
CloseMols_exposer.def(
"update"
, update_function_value
, ( bp::arg("system") ) );
}
{ //::SireSystem::CloseMols::update
typedef bool ( ::SireSystem::CloseMols::*update_function_type )( ::SireSystem::System const &,::SireMol::MolNum ) ;
update_function_type update_function_value( &::SireSystem::CloseMols::update );
CloseMols_exposer.def(
"update"
, update_function_value
, ( bp::arg("system"), bp::arg("changed_mol") ) );
}
{ //::SireSystem::CloseMols::update
typedef bool ( ::SireSystem::CloseMols::*update_function_type )( ::SireSystem::System const &,::SireMol::Molecules const & ) ;
update_function_type update_function_value( &::SireSystem::CloseMols::update );
CloseMols_exposer.def(
"update"
, update_function_value
, ( bp::arg("system"), bp::arg("molecules") ) );
}
{ //::SireSystem::CloseMols::what
typedef char const * ( ::SireSystem::CloseMols::*what_function_type )( ) const;
what_function_type what_function_value( &::SireSystem::CloseMols::what );
CloseMols_exposer.def(
"what"
, what_function_value );
}
CloseMols_exposer.staticmethod( "typeName" );
CloseMols_exposer.def( "__copy__", &__copy__);
CloseMols_exposer.def( "__deepcopy__", &__copy__);
CloseMols_exposer.def( "clone", &__copy__);
CloseMols_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::CloseMols >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CloseMols_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::CloseMols >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CloseMols_exposer.def( "__str__", &pvt_get_name);
CloseMols_exposer.def( "__repr__", &pvt_get_name);
}
}
void register_SpaceWrapper_class(){
{ //::SireSystem::SpaceWrapper
typedef bp::class_< SireSystem::SpaceWrapper, bp::bases< SireSystem::MoleculeConstraint, SireSystem::Constraint, SireBase::Property > > SpaceWrapper_exposer_t;
SpaceWrapper_exposer_t SpaceWrapper_exposer = SpaceWrapper_exposer_t( "SpaceWrapper", bp::init< >() );
bp::scope SpaceWrapper_scope( SpaceWrapper_exposer );
SpaceWrapper_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() )) );
SpaceWrapper_exposer.def( bp::init< SireSystem::SpaceWrapper const & >(( bp::arg("other") )) );
{ //::SireSystem::SpaceWrapper::moleculeGroup
typedef ::SireMol::MoleculeGroup const & ( ::SireSystem::SpaceWrapper::*moleculeGroup_function_type )( ) const;
moleculeGroup_function_type moleculeGroup_function_value( &::SireSystem::SpaceWrapper::moleculeGroup );
SpaceWrapper_exposer.def(
"moleculeGroup"
, moleculeGroup_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
SpaceWrapper_exposer.def( bp::self != bp::self );
{ //::SireSystem::SpaceWrapper::operator=
typedef ::SireSystem::SpaceWrapper & ( ::SireSystem::SpaceWrapper::*assign_function_type )( ::SireSystem::SpaceWrapper const & ) ;
assign_function_type assign_function_value( &::SireSystem::SpaceWrapper::operator= );
SpaceWrapper_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
SpaceWrapper_exposer.def( bp::self == bp::self );
{ //::SireSystem::SpaceWrapper::point
typedef ::SireFF::Point const & ( ::SireSystem::SpaceWrapper::*point_function_type )( ) const;
point_function_type point_function_value( &::SireSystem::SpaceWrapper::point );
SpaceWrapper_exposer.def(
"point"
, point_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireSystem::SpaceWrapper::propertyMap
typedef ::SireBase::PropertyMap const & ( ::SireSystem::SpaceWrapper::*propertyMap_function_type )( ) const;
propertyMap_function_type propertyMap_function_value( &::SireSystem::SpaceWrapper::propertyMap );
SpaceWrapper_exposer.def(
"propertyMap"
, propertyMap_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireSystem::SpaceWrapper::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireSystem::SpaceWrapper::typeName );
SpaceWrapper_exposer.def(
"typeName"
, typeName_function_value );
}
SpaceWrapper_exposer.staticmethod( "typeName" );
SpaceWrapper_exposer.def( "__copy__", &__copy__);
SpaceWrapper_exposer.def( "__deepcopy__", &__copy__);
SpaceWrapper_exposer.def( "clone", &__copy__);
SpaceWrapper_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::SpaceWrapper >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
SpaceWrapper_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::SpaceWrapper >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
SpaceWrapper_exposer.def( "__str__", &__str__< ::SireSystem::SpaceWrapper > );
SpaceWrapper_exposer.def( "__repr__", &__str__< ::SireSystem::SpaceWrapper > );
}
}
