void register_LJPerturbation_class(){
{ //::SireMM::LJPerturbation
typedef bp::class_< SireMM::LJPerturbation, bp::bases< SireMol::Perturbation, SireBase::Property > > LJPerturbation_exposer_t;
LJPerturbation_exposer_t LJPerturbation_exposer = LJPerturbation_exposer_t( "LJPerturbation", "This is a perturbation that maps LJ parameters for a molecule\nfrom an initial to a final state\n\nAuthor: Christopher Woods\n", bp::init< bp::optional< SireBase::PropertyMap const & > >(( bp::arg("map")=SireBase::PropertyMap() ), "Constructor - this creates a LJ perturbation that\nperturbs from LJs in initial_LJ to LJs in\nfinal_LJ, placing the current LJs in LJ,\nand using Perturbation::defaultEquation() to map the\nsigma and epsilon values of the LJ.") );
bp::scope LJPerturbation_scope( LJPerturbation_exposer );
bp::enum_< SireMM::LJPerturbation::MapType>("MapType")
.value("MAP_SIGMA_AND_EPSILON", SireMM::LJPerturbation::MAP_SIGMA_AND_EPSILON)
.value("MAP_RMIN_AND_EPSILON", SireMM::LJPerturbation::MAP_RMIN_AND_EPSILON)
.value("MAP_A_AND_B", SireMM::LJPerturbation::MAP_A_AND_B)
.export_values()
;
LJPerturbation_exposer.def( bp::init< SireMM::LJPerturbation::MapType, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("maptype"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation") );
LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("mapping_function"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") );
LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, SireMM::LJPerturbation::MapType, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("mapping_function"), bp::arg("maptype"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") );
LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("sigma_mapping_function"), bp::arg("epsilon_mapping_function"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") );
LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, SireCAS::Expression const &, SireMM::LJPerturbation::MapType, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("sigma_mapping_function"), bp::arg("epsilon_mapping_function"), bp::arg("maptype"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") );
LJPerturbation_exposer.def( bp::init< SireMM::LJPerturbation const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMM::LJPerturbation::A_MappingFunction
typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*A_MappingFunction_function_type)( ) const;
A_MappingFunction_function_type A_MappingFunction_function_value( &::SireMM::LJPerturbation::A_MappingFunction );
LJPerturbation_exposer.def(
"A_MappingFunction"
, A_MappingFunction_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the function used to map A\nThrow: SireError::invalid_state\n" );
}
{ //::SireMM::LJPerturbation::B_MappingFunction
typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*B_MappingFunction_function_type)( ) const;
B_MappingFunction_function_type B_MappingFunction_function_value( &::SireMM::LJPerturbation::B_MappingFunction );
LJPerturbation_exposer.def(
"B_MappingFunction"
, B_MappingFunction_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the function used to map B\nThrow: SireError::invalid_state\n" );
}
{ //::SireMM::LJPerturbation::epsilonMappingFunction
typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*epsilonMappingFunction_function_type)( ) const;
epsilonMappingFunction_function_type epsilonMappingFunction_function_value( &::SireMM::LJPerturbation::epsilonMappingFunction );
LJPerturbation_exposer.def(
"epsilonMappingFunction"
, epsilonMappingFunction_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the function used to map epsilon\nThrow: SireError::invalid_state\n" );
}
{ //::SireMM::LJPerturbation::mapAB
typedef bool ( ::SireMM::LJPerturbation::*mapAB_function_type)( ) const;
mapAB_function_type mapAB_function_value( &::SireMM::LJPerturbation::mapAB );
LJPerturbation_exposer.def(
"mapAB"
, mapAB_function_value
, "Return whether or not this maps A and B" );
}
{ //::SireMM::LJPerturbation::mapRMinEpsilon
typedef bool ( ::SireMM::LJPerturbation::*mapRMinEpsilon_function_type)( ) const;
mapRMinEpsilon_function_type mapRMinEpsilon_function_value( &::SireMM::LJPerturbation::mapRMinEpsilon );
LJPerturbation_exposer.def(
"mapRMinEpsilon"
, mapRMinEpsilon_function_value
, "Return whether or not this maps r_min and epsilon" );
}
{ //::SireMM::LJPerturbation::mapSigmaEpsilon
typedef bool ( ::SireMM::LJPerturbation::*mapSigmaEpsilon_function_type)( ) const;
mapSigmaEpsilon_function_type mapSigmaEpsilon_function_value( &::SireMM::LJPerturbation::mapSigmaEpsilon );
LJPerturbation_exposer.def(
"mapSigmaEpsilon"
, mapSigmaEpsilon_function_value
, "Return whether or not this maps sigma and epsilon" );
}
{ //::SireMM::LJPerturbation::mappingFunction
typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*mappingFunction_function_type)( ) const;
mappingFunction_function_type mappingFunction_function_value( &::SireMM::LJPerturbation::mappingFunction );
LJPerturbation_exposer.def(
"mappingFunction"
, mappingFunction_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the mapping function\nThrow: SireError::invalid_state\n" );
}
LJPerturbation_exposer.def( bp::self != bp::self );
{ //::SireMM::LJPerturbation::operator=
typedef ::SireMM::LJPerturbation & ( ::SireMM::LJPerturbation::*assign_function_type)( ::SireMM::LJPerturbation const & ) ;
assign_function_type assign_function_value( &::SireMM::LJPerturbation::operator= );
LJPerturbation_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
LJPerturbation_exposer.def( bp::self == bp::self );
{ //::SireMM::LJPerturbation::rMinMappingFunction
typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*rMinMappingFunction_function_type)( ) const;
rMinMappingFunction_function_type rMinMappingFunction_function_value( &::SireMM::LJPerturbation::rMinMappingFunction );
LJPerturbation_exposer.def(
"rMinMappingFunction"
, rMinMappingFunction_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the function used to map r_min\nThrow: SireError::invalid_state\n" );
}
{ //::SireMM::LJPerturbation::recreate
typedef ::SireMol::PerturbationPtr ( ::SireMM::LJPerturbation::*recreate_function_type)( ::SireCAS::Expression const & ) const;
recreate_function_type recreate_function_value( &::SireMM::LJPerturbation::recreate );
LJPerturbation_exposer.def(
"recreate"
, recreate_function_value
, ( bp::arg("mapping_function") )
, "" );
}
{ //::SireMM::LJPerturbation::recreate
typedef ::SireMol::PerturbationPtr ( ::SireMM::LJPerturbation::*recreate_function_type)( ::SireCAS::Expression const &,::SireBase::PropertyMap const & ) const;
recreate_function_type recreate_function_value( &::SireMM::LJPerturbation::recreate );
LJPerturbation_exposer.def(
"recreate"
, recreate_function_value
, ( bp::arg("mapping_function"), bp::arg("map") )
, "" );
}
{ //::SireMM::LJPerturbation::requiredProperties
typedef ::QSet< QString > ( ::SireMM::LJPerturbation::*requiredProperties_function_type)( ) const;
requiredProperties_function_type requiredProperties_function_value( &::SireMM::LJPerturbation::requiredProperties );
LJPerturbation_exposer.def(
"requiredProperties"
, requiredProperties_function_value
, "Return the properties required or changed by this perturbation" );
}
{ //::SireMM::LJPerturbation::sigmaMappingFunction
typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*sigmaMappingFunction_function_type)( ) const;
sigmaMappingFunction_function_type sigmaMappingFunction_function_value( &::SireMM::LJPerturbation::sigmaMappingFunction );
LJPerturbation_exposer.def(
"sigmaMappingFunction"
, sigmaMappingFunction_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the function used to map sigma\nThrow: SireError::invalid_state\n" );
}
{ //::SireMM::LJPerturbation::substitute
typedef ::SireMol::PerturbationPtr ( ::SireMM::LJPerturbation::*substitute_function_type)( ::SireCAS::Identities const & ) const;
substitute_function_type substitute_function_value( &::SireMM::LJPerturbation::substitute );
LJPerturbation_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" );
}
{ //::SireMM::LJPerturbation::toString
typedef ::QString ( ::SireMM::LJPerturbation::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMM::LJPerturbation::toString );
LJPerturbation_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this perturbation" );
}
{ //::SireMM::LJPerturbation::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::LJPerturbation::typeName );
LJPerturbation_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMM::LJPerturbation::wouldChange
typedef bool ( ::SireMM::LJPerturbation::*wouldChange_function_type)( ::SireMol::Molecule const &,::SireCAS::Values const & ) const;
wouldChange_function_type wouldChange_function_value( &::SireMM::LJPerturbation::wouldChange );
LJPerturbation_exposer.def(
"wouldChange"
, wouldChange_function_value
, ( bp::arg("molecule"), bp::arg("values") )
, "Return whether or not this perturbation with the passed values would\nchange the molecule molecule" );
}
LJPerturbation_exposer.staticmethod( "typeName" );
LJPerturbation_exposer.def( "__copy__", &__copy__);
LJPerturbation_exposer.def( "__deepcopy__", &__copy__);
LJPerturbation_exposer.def( "clone", &__copy__);
LJPerturbation_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::LJPerturbation >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
LJPerturbation_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::LJPerturbation >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
LJPerturbation_exposer.def( "__str__", &__str__< ::SireMM::LJPerturbation > );
LJPerturbation_exposer.def( "__repr__", &__str__< ::SireMM::LJPerturbation > );
}
}
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_TwoAtomPerturbation_class(){
{ //::SireMM::TwoAtomPerturbation
typedef bp::class_< SireMM::TwoAtomPerturbation, bp::bases< SireMM::InternalPerturbation, SireMol::Perturbation, SireBase::Property > > TwoAtomPerturbation_exposer_t;
TwoAtomPerturbation_exposer_t TwoAtomPerturbation_exposer = TwoAtomPerturbation_exposer_t( "TwoAtomPerturbation", bp::init< >() );
bp::scope TwoAtomPerturbation_scope( TwoAtomPerturbation_exposer );
TwoAtomPerturbation_exposer.def( bp::init< SireMol::AtomID const &, SireMol::AtomID const &, SireCAS::Expression const &, SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("atom0"), bp::arg("atom1"), bp::arg("initial_form"), bp::arg("final_form"), bp::arg("map")=SireBase::PropertyMap() )) );
TwoAtomPerturbation_exposer.def( bp::init< SireMol::AtomID const &, SireMol::AtomID const &, SireCAS::Expression const &, SireCAS::Expression const &, SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("atom0"), bp::arg("atom1"), bp::arg("initial_form"), bp::arg("final_form"), bp::arg("mapping_function"), bp::arg("map")=SireBase::PropertyMap() )) );
TwoAtomPerturbation_exposer.def( bp::init< SireMol::AtomID const &, SireMol::AtomID const &, SireCAS::Expression const &, SireCAS::Identities const &, SireCAS::Identities const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("atom0"), bp::arg("atom1"), bp::arg("base_expression"), bp::arg("initial_forms"), bp::arg("final_forms"), bp::arg("map")=SireBase::PropertyMap() )) );
TwoAtomPerturbation_exposer.def( bp::init< SireMol::AtomID const &, SireMol::AtomID const &, SireCAS::Expression const &, SireCAS::Identities const &, SireCAS::Identities const &, SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("atom0"), bp::arg("atom1"), bp::arg("base_expression"), bp::arg("initial_forms"), bp::arg("final_forms"), bp::arg("mapping_function"), bp::arg("map")=SireBase::PropertyMap() )) );
TwoAtomPerturbation_exposer.def( bp::init< SireMM::TwoAtomPerturbation const & >(( bp::arg("other") )) );
{ //::SireMM::TwoAtomPerturbation::atom0
typedef ::SireMol::AtomID const & ( ::SireMM::TwoAtomPerturbation::*atom0_function_type )( ) const;
atom0_function_type atom0_function_value( &::SireMM::TwoAtomPerturbation::atom0 );
TwoAtomPerturbation_exposer.def(
"atom0"
, atom0_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::TwoAtomPerturbation::atom1
typedef ::SireMol::AtomID const & ( ::SireMM::TwoAtomPerturbation::*atom1_function_type )( ) const;
atom1_function_type atom1_function_value( &::SireMM::TwoAtomPerturbation::atom1 );
TwoAtomPerturbation_exposer.def(
"atom1"
, atom1_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
TwoAtomPerturbation_exposer.def( bp::self != bp::self );
{ //::SireMM::TwoAtomPerturbation::operator=
typedef ::SireMM::TwoAtomPerturbation & ( ::SireMM::TwoAtomPerturbation::*assign_function_type )( ::SireMM::TwoAtomPerturbation const & ) ;
assign_function_type assign_function_value( &::SireMM::TwoAtomPerturbation::operator= );
TwoAtomPerturbation_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
TwoAtomPerturbation_exposer.def( bp::self == bp::self );
{ //::SireMM::TwoAtomPerturbation::requiredProperties
typedef ::QSet< QString > ( ::SireMM::TwoAtomPerturbation::*requiredProperties_function_type )( ) const;
requiredProperties_function_type requiredProperties_function_value( &::SireMM::TwoAtomPerturbation::requiredProperties );
TwoAtomPerturbation_exposer.def(
"requiredProperties"
, requiredProperties_function_value );
}
{ //::SireMM::TwoAtomPerturbation::toString
typedef ::QString ( ::SireMM::TwoAtomPerturbation::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMM::TwoAtomPerturbation::toString );
TwoAtomPerturbation_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMM::TwoAtomPerturbation::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::TwoAtomPerturbation::typeName );
TwoAtomPerturbation_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMM::TwoAtomPerturbation::wouldChange
typedef bool ( ::SireMM::TwoAtomPerturbation::*wouldChange_function_type )( ::SireMol::Molecule const &,::SireCAS::Values const & ) const;
wouldChange_function_type wouldChange_function_value( &::SireMM::TwoAtomPerturbation::wouldChange );
TwoAtomPerturbation_exposer.def(
"wouldChange"
, wouldChange_function_value
, ( bp::arg("molecule"), bp::arg("values") ) );
}
TwoAtomPerturbation_exposer.staticmethod( "typeName" );
TwoAtomPerturbation_exposer.def( "__copy__", &__copy__);
TwoAtomPerturbation_exposer.def( "__deepcopy__", &__copy__);
TwoAtomPerturbation_exposer.def( "clone", &__copy__);
TwoAtomPerturbation_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::TwoAtomPerturbation >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
TwoAtomPerturbation_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::TwoAtomPerturbation >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
TwoAtomPerturbation_exposer.def( "__str__", &__str__< ::SireMM::TwoAtomPerturbation > );
TwoAtomPerturbation_exposer.def( "__repr__", &__str__< ::SireMM::TwoAtomPerturbation > );
}
}
