void register_Ensemble_class(){
{ //::SireMove::Ensemble
typedef bp::class_< SireMove::Ensemble, bp::bases< SireBase::Property > > Ensemble_exposer_t;
Ensemble_exposer_t Ensemble_exposer = Ensemble_exposer_t( "Ensemble", "This class describes the ensemble that will be created by\na collection of moves (e.g. will the moves sample at constant\nvolume or temperature?)\n\nAuthor: Christopher Woods\n", bp::init< >("Construct an NVE ensemble") );
bp::scope Ensemble_scope( Ensemble_exposer );
Ensemble_exposer.def( bp::init< SireMove::Ensemble const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMove::Ensemble::MuVT
typedef ::SireMove::Ensemble ( *MuVT_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::Pressure const & );
MuVT_function_type MuVT_function_value( &::SireMove::Ensemble::MuVT );
Ensemble_exposer.def(
"MuVT"
, MuVT_function_value
, ( bp::arg("temperature"), bp::arg("fugacity") )
, "Return the MuVT ensemble for the temperature temperature and\nthe fugacity fugacity" );
}
{ //::SireMove::Ensemble::MuVT
typedef ::SireMove::Ensemble ( *MuVT_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::MolarEnergy const & );
MuVT_function_type MuVT_function_value( &::SireMove::Ensemble::MuVT );
Ensemble_exposer.def(
"MuVT"
, MuVT_function_value
, ( bp::arg("temperature"), bp::arg("chemical_potential") )
, "Return the MuVT ensemble for the temperature temperature and\nthe chemical potential chemical_potential" );
}
{ //::SireMove::Ensemble::NPT
typedef ::SireMove::Ensemble ( *NPT_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::Pressure const & );
NPT_function_type NPT_function_value( &::SireMove::Ensemble::NPT );
Ensemble_exposer.def(
"NPT"
, NPT_function_value
, ( bp::arg("temperature"), bp::arg("pressure") )
, "Return the NPT ensemble for the temperature temperature and\nthe pressure pressure" );
}
{ //::SireMove::Ensemble::NVE
typedef ::SireMove::Ensemble ( *NVE_function_type )( );
NVE_function_type NVE_function_value( &::SireMove::Ensemble::NVE );
Ensemble_exposer.def(
"NVE"
, NVE_function_value
, "Return the NVE ensemble" );
}
{ //::SireMove::Ensemble::NVT
typedef ::SireMove::Ensemble ( *NVT_function_type )( ::SireUnits::Dimension::Temperature const & );
NVT_function_type NVT_function_value( &::SireMove::Ensemble::NVT );
Ensemble_exposer.def(
"NVT"
, NVT_function_value
, ( bp::arg("temperature") )
, "Return the NVT ensemble for the temperature temperature" );
}
{ //::SireMove::Ensemble::canonical
typedef ::SireMove::Ensemble ( *canonical_function_type )( ::SireUnits::Dimension::Temperature const & );
canonical_function_type canonical_function_value( &::SireMove::Ensemble::canonical );
Ensemble_exposer.def(
"canonical"
, canonical_function_value
, ( bp::arg("temperature") )
, "Syntactic sugar to return the NVT ensemble" );
}
{ //::SireMove::Ensemble::chemicalPotential
typedef ::SireUnits::Dimension::MolarEnergy ( ::SireMove::Ensemble::*chemicalPotential_function_type)( ) const;
chemicalPotential_function_type chemicalPotential_function_value( &::SireMove::Ensemble::chemicalPotential );
Ensemble_exposer.def(
"chemicalPotential"
, chemicalPotential_function_value
, "Return the chemical potential of this ensemble\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMove::Ensemble::fugacity
typedef ::SireUnits::Dimension::Pressure ( ::SireMove::Ensemble::*fugacity_function_type)( ) const;
fugacity_function_type fugacity_function_value( &::SireMove::Ensemble::fugacity );
Ensemble_exposer.def(
"fugacity"
, fugacity_function_value
, "Return the fugacity of this ensemble\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMove::Ensemble::grandCanonical
typedef ::SireMove::Ensemble ( *grandCanonical_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::Pressure const & );
grandCanonical_function_type grandCanonical_function_value( &::SireMove::Ensemble::grandCanonical );
Ensemble_exposer.def(
"grandCanonical"
, grandCanonical_function_value
, ( bp::arg("temperature"), bp::arg("fugacity") )
, "Syntactic sugar to return the MuVT ensemble" );
}
{ //::SireMove::Ensemble::grandCanonical
typedef ::SireMove::Ensemble ( *grandCanonical_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::MolarEnergy const & );
grandCanonical_function_type grandCanonical_function_value( &::SireMove::Ensemble::grandCanonical );
Ensemble_exposer.def(
"grandCanonical"
, grandCanonical_function_value
, ( bp::arg("temperature"), bp::arg("chemical_potential") )
, "Syntactic sugar to return the MuVT ensemble" );
}
{ //::SireMove::Ensemble::isCanonical
typedef bool ( ::SireMove::Ensemble::*isCanonical_function_type)( ) const;
isCanonical_function_type isCanonical_function_value( &::SireMove::Ensemble::isCanonical );
Ensemble_exposer.def(
"isCanonical"
, isCanonical_function_value
, "Return whether or not this is the canonical (NVT) ensemble" );
}
{ //::SireMove::Ensemble::isConstantChemicalPotential
typedef bool ( ::SireMove::Ensemble::*isConstantChemicalPotential_function_type)( ) const;
isConstantChemicalPotential_function_type isConstantChemicalPotential_function_value( &::SireMove::Ensemble::isConstantChemicalPotential );
Ensemble_exposer.def(
"isConstantChemicalPotential"
, isConstantChemicalPotential_function_value
, "Return whether the chemical potential is constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantEnergy
typedef bool ( ::SireMove::Ensemble::*isConstantEnergy_function_type)( ) const;
isConstantEnergy_function_type isConstantEnergy_function_value( &::SireMove::Ensemble::isConstantEnergy );
Ensemble_exposer.def(
"isConstantEnergy"
, isConstantEnergy_function_value
, "Return whether or not energy is a constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantFugacity
typedef bool ( ::SireMove::Ensemble::*isConstantFugacity_function_type)( ) const;
isConstantFugacity_function_type isConstantFugacity_function_value( &::SireMove::Ensemble::isConstantFugacity );
Ensemble_exposer.def(
"isConstantFugacity"
, isConstantFugacity_function_value
, "Return whether the chemical potential is constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantNParticles
typedef bool ( ::SireMove::Ensemble::*isConstantNParticles_function_type)( ) const;
isConstantNParticles_function_type isConstantNParticles_function_value( &::SireMove::Ensemble::isConstantNParticles );
Ensemble_exposer.def(
"isConstantNParticles"
, isConstantNParticles_function_value
, "Return whether or not the number of particles is constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantPressure
typedef bool ( ::SireMove::Ensemble::*isConstantPressure_function_type)( ) const;
isConstantPressure_function_type isConstantPressure_function_value( &::SireMove::Ensemble::isConstantPressure );
Ensemble_exposer.def(
"isConstantPressure"
, isConstantPressure_function_value
, "Return whether or not pressure is a constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantTemperature
typedef bool ( ::SireMove::Ensemble::*isConstantTemperature_function_type)( ) const;
isConstantTemperature_function_type isConstantTemperature_function_value( &::SireMove::Ensemble::isConstantTemperature );
Ensemble_exposer.def(
"isConstantTemperature"
, isConstantTemperature_function_value
, "Return whether or not temperature is a constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantVolume
typedef bool ( ::SireMove::Ensemble::*isConstantVolume_function_type)( ) const;
isConstantVolume_function_type isConstantVolume_function_value( &::SireMove::Ensemble::isConstantVolume );
Ensemble_exposer.def(
"isConstantVolume"
, isConstantVolume_function_value
, "Return whether or not volume is a constant in this ensemble" );
}
{ //::SireMove::Ensemble::isGrandCanonical
typedef bool ( ::SireMove::Ensemble::*isGrandCanonical_function_type)( ) const;
isGrandCanonical_function_type isGrandCanonical_function_value( &::SireMove::Ensemble::isGrandCanonical );
Ensemble_exposer.def(
"isGrandCanonical"
, isGrandCanonical_function_value
, "Return whether or not this is the grand canonical (MuVT) ensemble" );
}
{ //::SireMove::Ensemble::isIsothermalIsobaric
typedef bool ( ::SireMove::Ensemble::*isIsothermalIsobaric_function_type)( ) const;
isIsothermalIsobaric_function_type isIsothermalIsobaric_function_value( &::SireMove::Ensemble::isIsothermalIsobaric );
Ensemble_exposer.def(
"isIsothermalIsobaric"
, isIsothermalIsobaric_function_value
, "Return whether or not this is the isothermal-isobaric (NPT) ensemble" );
}
{ //::SireMove::Ensemble::isMicroCanonical
typedef bool ( ::SireMove::Ensemble::*isMicroCanonical_function_type)( ) const;
isMicroCanonical_function_type isMicroCanonical_function_value( &::SireMove::Ensemble::isMicroCanonical );
Ensemble_exposer.def(
"isMicroCanonical"
, isMicroCanonical_function_value
, "Return whether or not this is the microcanonical (NVE) ensemble" );
}
{ //::SireMove::Ensemble::isMuVT
typedef bool ( ::SireMove::Ensemble::*isMuVT_function_type)( ) const;
isMuVT_function_type isMuVT_function_value( &::SireMove::Ensemble::isMuVT );
Ensemble_exposer.def(
"isMuVT"
, isMuVT_function_value
, "Return whether or not this is the MuVT ensemble" );
}
{ //::SireMove::Ensemble::isNPT
typedef bool ( ::SireMove::Ensemble::*isNPT_function_type)( ) const;
isNPT_function_type isNPT_function_value( &::SireMove::Ensemble::isNPT );
Ensemble_exposer.def(
"isNPT"
, isNPT_function_value
, "Return whether or not this is the NPT ensemble" );
}
{ //::SireMove::Ensemble::isNVE
typedef bool ( ::SireMove::Ensemble::*isNVE_function_type)( ) const;
isNVE_function_type isNVE_function_value( &::SireMove::Ensemble::isNVE );
Ensemble_exposer.def(
"isNVE"
, isNVE_function_value
, "Return whether or not this is the NVE ensemble" );
}
{ //::SireMove::Ensemble::isNVT
typedef bool ( ::SireMove::Ensemble::*isNVT_function_type)( ) const;
isNVT_function_type isNVT_function_value( &::SireMove::Ensemble::isNVT );
Ensemble_exposer.def(
"isNVT"
, isNVT_function_value
, "Return whether or not this is the NVT ensemble" );
}
{ //::SireMove::Ensemble::isothermalIsobaric
typedef ::SireMove::Ensemble ( *isothermalIsobaric_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::Pressure const & );
isothermalIsobaric_function_type isothermalIsobaric_function_value( &::SireMove::Ensemble::isothermalIsobaric );
Ensemble_exposer.def(
"isothermalIsobaric"
, isothermalIsobaric_function_value
, ( bp::arg("temperature"), bp::arg("pressure") )
, "Syntactic sugar to return the NPT ensemble" );
}
{ //::SireMove::Ensemble::merge
typedef ::SireMove::Ensemble ( ::SireMove::Ensemble::*merge_function_type)( ::SireMove::Ensemble const & ) const;
merge_function_type merge_function_value( &::SireMove::Ensemble::merge );
Ensemble_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("other") )
, "Merge this ensemble with other. This tries to find an ensemble\nthat satisfies both, e.g. merging NVE with NVT will give NVT,\nwhile merging NVE with NPT would give NPT." );
}
{ //::SireMove::Ensemble::merge
typedef ::SireMove::Ensemble ( *merge_function_type )( ::SireMove::Ensemble const &,::SireMove::Ensemble const & );
merge_function_type merge_function_value( &::SireMove::Ensemble::merge );
Ensemble_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("e0"), bp::arg("e1") )
, "Merge the two ensembles e0 and e1 together. This tries to find an ensemble\nthat satisfies both, e.g. merging NVE with NVT will give NVT,\nwhile merging NVE with NPT would give NPT." );
}
{ //::SireMove::Ensemble::microcanonical
typedef ::SireMove::Ensemble ( *microcanonical_function_type )( );
microcanonical_function_type microcanonical_function_value( &::SireMove::Ensemble::microcanonical );
Ensemble_exposer.def(
"microcanonical"
, microcanonical_function_value
, "Syntactic sugar to return the NVE ensemble" );
}
{ //::SireMove::Ensemble::name
typedef ::QString ( ::SireMove::Ensemble::*name_function_type)( ) const;
name_function_type name_function_value( &::SireMove::Ensemble::name );
Ensemble_exposer.def(
"name"
, name_function_value
, "Return the name of this ensemble (if it has a name)" );
}
Ensemble_exposer.def( bp::self != bp::self );
{ //::SireMove::Ensemble::operator=
typedef ::SireMove::Ensemble & ( ::SireMove::Ensemble::*assign_function_type)( ::SireMove::Ensemble const & ) ;
assign_function_type assign_function_value( &::SireMove::Ensemble::operator= );
Ensemble_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
Ensemble_exposer.def( bp::self == bp::self );
{ //::SireMove::Ensemble::pressure
typedef ::SireUnits::Dimension::Pressure ( ::SireMove::Ensemble::*pressure_function_type)( ) const;
pressure_function_type pressure_function_value( &::SireMove::Ensemble::pressure );
Ensemble_exposer.def(
"pressure"
, pressure_function_value
, "Return the pressure of this ensemble\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMove::Ensemble::shortHand
typedef ::QString ( ::SireMove::Ensemble::*shortHand_function_type)( ) const;
shortHand_function_type shortHand_function_value( &::SireMove::Ensemble::shortHand );
Ensemble_exposer.def(
"shortHand"
, shortHand_function_value
, "Return the shorthand string for this ensemble (e.g. NVT)" );
}
{ //::SireMove::Ensemble::temperature
typedef ::SireUnits::Dimension::Temperature ( ::SireMove::Ensemble::*temperature_function_type)( ) const;
temperature_function_type temperature_function_value( &::SireMove::Ensemble::temperature );
Ensemble_exposer.def(
"temperature"
, temperature_function_value
, "Return the temperature of this ensemble\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMove::Ensemble::toString
typedef ::QString ( ::SireMove::Ensemble::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMove::Ensemble::toString );
Ensemble_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this ensemble" );
}
{ //::SireMove::Ensemble::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMove::Ensemble::typeName );
Ensemble_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
Ensemble_exposer.staticmethod( "MuVT" );
Ensemble_exposer.staticmethod( "NPT" );
Ensemble_exposer.staticmethod( "NVE" );
Ensemble_exposer.staticmethod( "NVT" );
Ensemble_exposer.staticmethod( "canonical" );
Ensemble_exposer.staticmethod( "grandCanonical" );
Ensemble_exposer.staticmethod( "isothermalIsobaric" );
Ensemble_exposer.staticmethod( "merge" );
Ensemble_exposer.staticmethod( "microcanonical" );
Ensemble_exposer.staticmethod( "typeName" );
Ensemble_exposer.def( "__copy__", &__copy__);
Ensemble_exposer.def( "__deepcopy__", &__copy__);
Ensemble_exposer.def( "clone", &__copy__);
Ensemble_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::Ensemble >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Ensemble_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::Ensemble >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Ensemble_exposer.def( "__str__", &__str__< ::SireMove::Ensemble > );
Ensemble_exposer.def( "__repr__", &__str__< ::SireMove::Ensemble > );
}
}
void register_BennettsRatios_class(){
{ //::SireAnalysis::BennettsRatios
typedef bp::class_< SireAnalysis::BennettsRatios, bp::bases< SireBase::Property > > BennettsRatios_exposer_t;
BennettsRatios_exposer_t BennettsRatios_exposer = BennettsRatios_exposer_t( "BennettsRatios", bp::init< >() );
bp::scope BennettsRatios_scope( BennettsRatios_exposer );
BennettsRatios_exposer.def( bp::init< QList< double > const &, QMap< double, SireMaths::BennettsFreeEnergyAverage > const &, QMap< double, SireMaths::BennettsFreeEnergyAverage > const & >(( bp::arg("windows"), bp::arg("forwards_ratios"), bp::arg("backwards_ratios") )) );
BennettsRatios_exposer.def( bp::init< SireAnalysis::BennettsRatios const & >(( bp::arg("other") )) );
{ //::SireAnalysis::BennettsRatios::backwardsData
typedef ::QMap< double, SireMaths::BennettsFreeEnergyAverage > ( ::SireAnalysis::BennettsRatios::*backwardsData_function_type )( ) const;
backwardsData_function_type backwardsData_function_value( &::SireAnalysis::BennettsRatios::backwardsData );
BennettsRatios_exposer.def(
"backwardsData"
, backwardsData_function_value );
}
{ //::SireAnalysis::BennettsRatios::backwardsRatios
typedef ::QMap< double, SireMaths::BennettsFreeEnergyAverage > ( ::SireAnalysis::BennettsRatios::*backwardsRatios_function_type )( ) const;
backwardsRatios_function_type backwardsRatios_function_value( &::SireAnalysis::BennettsRatios::backwardsRatios );
BennettsRatios_exposer.def(
"backwardsRatios"
, backwardsRatios_function_value );
}
{ //::SireAnalysis::BennettsRatios::constants
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::BennettsRatios::*constants_function_type )( ) const;
constants_function_type constants_function_value( &::SireAnalysis::BennettsRatios::constants );
BennettsRatios_exposer.def(
"constants"
, constants_function_value );
}
{ //::SireAnalysis::BennettsRatios::denominators
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::BennettsRatios::*denominators_function_type )( ) const;
denominators_function_type denominators_function_value( &::SireAnalysis::BennettsRatios::denominators );
BennettsRatios_exposer.def(
"denominators"
, denominators_function_value );
}
{ //::SireAnalysis::BennettsRatios::forwardsData
typedef ::QMap< double, SireMaths::BennettsFreeEnergyAverage > ( ::SireAnalysis::BennettsRatios::*forwardsData_function_type )( ) const;
forwardsData_function_type forwardsData_function_value( &::SireAnalysis::BennettsRatios::forwardsData );
BennettsRatios_exposer.def(
"forwardsData"
, forwardsData_function_value );
}
{ //::SireAnalysis::BennettsRatios::forwardsRatios
typedef ::QMap< double, SireMaths::BennettsFreeEnergyAverage > ( ::SireAnalysis::BennettsRatios::*forwardsRatios_function_type )( ) const;
forwardsRatios_function_type forwardsRatios_function_value( &::SireAnalysis::BennettsRatios::forwardsRatios );
BennettsRatios_exposer.def(
"forwardsRatios"
, forwardsRatios_function_value );
}
{ //::SireAnalysis::BennettsRatios::integrate
typedef ::SireAnalysis::PMF ( ::SireAnalysis::BennettsRatios::*integrate_function_type )( ) const;
integrate_function_type integrate_function_value( &::SireAnalysis::BennettsRatios::integrate );
BennettsRatios_exposer.def(
"integrate"
, integrate_function_value );
}
{ //::SireAnalysis::BennettsRatios::isEmpty
typedef bool ( ::SireAnalysis::BennettsRatios::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireAnalysis::BennettsRatios::isEmpty );
BennettsRatios_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireAnalysis::BennettsRatios::lambdaValues
typedef ::QList< double > ( ::SireAnalysis::BennettsRatios::*lambdaValues_function_type )( ) const;
lambdaValues_function_type lambdaValues_function_value( &::SireAnalysis::BennettsRatios::lambdaValues );
BennettsRatios_exposer.def(
"lambdaValues"
, lambdaValues_function_value );
}
{ //::SireAnalysis::BennettsRatios::merge
typedef ::SireAnalysis::BennettsRatios ( *merge_function_type )( ::QList< SireAnalysis::BennettsRatios > const & );
merge_function_type merge_function_value( &::SireAnalysis::BennettsRatios::merge );
BennettsRatios_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("deltas") ) );
}
{ //::SireAnalysis::BennettsRatios::nLambdaValues
typedef int ( ::SireAnalysis::BennettsRatios::*nLambdaValues_function_type )( ) const;
nLambdaValues_function_type nLambdaValues_function_value( &::SireAnalysis::BennettsRatios::nLambdaValues );
BennettsRatios_exposer.def(
"nLambdaValues"
, nLambdaValues_function_value );
}
{ //::SireAnalysis::BennettsRatios::nSamples
typedef ::qint64 ( ::SireAnalysis::BennettsRatios::*nSamples_function_type )( ) const;
nSamples_function_type nSamples_function_value( &::SireAnalysis::BennettsRatios::nSamples );
BennettsRatios_exposer.def(
"nSamples"
, nSamples_function_value );
}
{ //::SireAnalysis::BennettsRatios::nWindows
typedef int ( ::SireAnalysis::BennettsRatios::*nWindows_function_type )( ) const;
nWindows_function_type nWindows_function_value( &::SireAnalysis::BennettsRatios::nWindows );
BennettsRatios_exposer.def(
"nWindows"
, nWindows_function_value );
}
{ //::SireAnalysis::BennettsRatios::numerators
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::BennettsRatios::*numerators_function_type )( ) const;
numerators_function_type numerators_function_value( &::SireAnalysis::BennettsRatios::numerators );
BennettsRatios_exposer.def(
"numerators"
, numerators_function_value );
}
BennettsRatios_exposer.def( bp::self != bp::self );
BennettsRatios_exposer.def( bp::self + bp::self );
{ //::SireAnalysis::BennettsRatios::operator=
typedef ::SireAnalysis::BennettsRatios & ( ::SireAnalysis::BennettsRatios::*assign_function_type )( ::SireAnalysis::BennettsRatios const & ) ;
assign_function_type assign_function_value( &::SireAnalysis::BennettsRatios::operator= );
BennettsRatios_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
BennettsRatios_exposer.def( bp::self == bp::self );
{ //::SireAnalysis::BennettsRatios::sum
typedef ::SireAnalysis::PMF ( ::SireAnalysis::BennettsRatios::*sum_function_type )( ) const;
sum_function_type sum_function_value( &::SireAnalysis::BennettsRatios::sum );
BennettsRatios_exposer.def(
"sum"
, sum_function_value );
}
{ //::SireAnalysis::BennettsRatios::temperature
typedef ::SireUnits::Dimension::Temperature ( ::SireAnalysis::BennettsRatios::*temperature_function_type )( ) const;
temperature_function_type temperature_function_value( &::SireAnalysis::BennettsRatios::temperature );
BennettsRatios_exposer.def(
"temperature"
, temperature_function_value );
}
{ //::SireAnalysis::BennettsRatios::toString
typedef ::QString ( ::SireAnalysis::BennettsRatios::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireAnalysis::BennettsRatios::toString );
BennettsRatios_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireAnalysis::BennettsRatios::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireAnalysis::BennettsRatios::typeName );
BennettsRatios_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireAnalysis::BennettsRatios::values
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::BennettsRatios::*values_function_type )( ) const;
values_function_type values_function_value( &::SireAnalysis::BennettsRatios::values );
BennettsRatios_exposer.def(
"values"
, values_function_value );
}
{ //::SireAnalysis::BennettsRatios::what
typedef char const * ( ::SireAnalysis::BennettsRatios::*what_function_type )( ) const;
what_function_type what_function_value( &::SireAnalysis::BennettsRatios::what );
BennettsRatios_exposer.def(
"what"
, what_function_value );
}
{ //::SireAnalysis::BennettsRatios::windows
typedef ::QList< double > ( ::SireAnalysis::BennettsRatios::*windows_function_type )( ) const;
windows_function_type windows_function_value( &::SireAnalysis::BennettsRatios::windows );
BennettsRatios_exposer.def(
"windows"
, windows_function_value );
}
BennettsRatios_exposer.staticmethod( "merge" );
BennettsRatios_exposer.staticmethod( "typeName" );
BennettsRatios_exposer.def( "__copy__", &__copy__);
BennettsRatios_exposer.def( "__deepcopy__", &__copy__);
BennettsRatios_exposer.def( "clone", &__copy__);
BennettsRatios_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::BennettsRatios >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
BennettsRatios_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::BennettsRatios >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
BennettsRatios_exposer.def( "__str__", &__str__< ::SireAnalysis::BennettsRatios > );
BennettsRatios_exposer.def( "__repr__", &__str__< ::SireAnalysis::BennettsRatios > );
}
}
void register_ComponentGradients_class(){
{ //::SireAnalysis::ComponentGradients
typedef bp::class_< SireAnalysis::ComponentGradients, bp::bases< SireBase::Property > > ComponentGradients_exposer_t;
ComponentGradients_exposer_t ComponentGradients_exposer = ComponentGradients_exposer_t( "ComponentGradients", "This class is used to hold the individual free energy gradients\nfor each of the components collected by the SireSystem::FreeEnergyMonitor\nclass\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope ComponentGradients_scope( ComponentGradients_exposer );
ComponentGradients_exposer.def( bp::init< QMap< double, SireSystem::FreeEnergyMonitor > const &, bp::optional< bool > >(( bp::arg("gradients"), bp::arg("conserve_memory")=(bool)(true) ), "Construct from the passed map of component monitors") );
ComponentGradients_exposer.def( bp::init< QList< SireSystem::FreeEnergyMonitor > const &, bp::optional< bool > >(( bp::arg("gradients"), bp::arg("conserve_memory")=(bool)(true) ), "Construct from the passed list of component monitors") );
ComponentGradients_exposer.def( bp::init< SireAnalysis::ComponentGradients const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireAnalysis::ComponentGradients::conserveMemory
typedef void ( ::SireAnalysis::ComponentGradients::*conserveMemory_function_type)( ) ;
conserveMemory_function_type conserveMemory_function_value( &::SireAnalysis::ComponentGradients::conserveMemory );
ComponentGradients_exposer.def(
"conserveMemory"
, conserveMemory_function_value
, "This function reduces the memory used by this object by ensuring that\nthe FreeEnergyMonitor at each lambda value uses the copy of the\nmolecules used at the first lambda value" );
}
{ //::SireAnalysis::ComponentGradients::conserveMemory
typedef void ( ::SireAnalysis::ComponentGradients::*conserveMemory_function_type)( ::SireAnalysis::ComponentGradients const & ) ;
conserveMemory_function_type conserveMemory_function_value( &::SireAnalysis::ComponentGradients::conserveMemory );
ComponentGradients_exposer.def(
"conserveMemory"
, conserveMemory_function_value
, ( bp::arg("other") )
, "This function conserves memory by copying in all of the shared molecule\ndata etc. from other into this object" );
}
{ //::SireAnalysis::ComponentGradients::coulombGradientsAt
typedef ::SireAnalysis::Gradients ( ::SireAnalysis::ComponentGradients::*coulombGradientsAt_function_type)( int ) const;
coulombGradientsAt_function_type coulombGradientsAt_function_value( &::SireAnalysis::ComponentGradients::coulombGradientsAt );
ComponentGradients_exposer.def(
"coulombGradientsAt"
, coulombGradientsAt_function_value
, ( bp::arg("i") )
, "Return the set of coulomb free energy gradients for the ith free energy component" );
}
{ //::SireAnalysis::ComponentGradients::coulombValues
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::ComponentGradients::*coulombValues_function_type)( int ) const;
coulombValues_function_type coulombValues_function_value( &::SireAnalysis::ComponentGradients::coulombValues );
ComponentGradients_exposer.def(
"coulombValues"
, coulombValues_function_value
, ( bp::arg("i") )
, "Return the actual values of the coulomb free energy gradients of the ith component" );
}
{ //::SireAnalysis::ComponentGradients::data
typedef ::QMap< double, SireSystem::FreeEnergyMonitor > ( ::SireAnalysis::ComponentGradients::*data_function_type)( ) const;
data_function_type data_function_value( &::SireAnalysis::ComponentGradients::data );
ComponentGradients_exposer.def(
"data"
, data_function_value
, "Return the raw data for all of the free energy components" );
}
{ //::SireAnalysis::ComponentGradients::deltaLambda
typedef double ( ::SireAnalysis::ComponentGradients::*deltaLambda_function_type)( ) const;
deltaLambda_function_type deltaLambda_function_value( &::SireAnalysis::ComponentGradients::deltaLambda );
ComponentGradients_exposer.def(
"deltaLambda"
, deltaLambda_function_value
, "Return the value of delta lambda used to approximate the free energy gradients" );
}
{ //::SireAnalysis::ComponentGradients::gradientsAt
typedef ::SireAnalysis::Gradients ( ::SireAnalysis::ComponentGradients::*gradientsAt_function_type)( int ) const;
gradientsAt_function_type gradientsAt_function_value( &::SireAnalysis::ComponentGradients::gradientsAt );
ComponentGradients_exposer.def(
"gradientsAt"
, gradientsAt_function_value
, ( bp::arg("i") )
, "Return the set of free energy gradients for the ith free energy component" );
}
{ //::SireAnalysis::ComponentGradients::integrate
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrate_function_type)( int ) const;
integrate_function_type integrate_function_value( &::SireAnalysis::ComponentGradients::integrate );
ComponentGradients_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("i") )
, "Integrate the free energy gradients of the ith component\nand return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrate
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrate_function_type)( int,int ) const;
integrate_function_type integrate_function_value( &::SireAnalysis::ComponentGradients::integrate );
ComponentGradients_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("i"), bp::arg("order") )
, "Integrate the free energy gradients of the ith component to order order and\nreturn the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrate
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrate_function_type)( int,double,double ) const;
integrate_function_type integrate_function_value( &::SireAnalysis::ComponentGradients::integrate );
ComponentGradients_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max") )
, "Integrate the free energy gradients of the ith component between the range\nrange_min to range_max, and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrate
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrate_function_type)( int,double,double,int ) const;
integrate_function_type integrate_function_value( &::SireAnalysis::ComponentGradients::integrate );
ComponentGradients_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max"), bp::arg("order") )
, "Integrate the free energy gradients of the ith component to order order\nbetween the range range_min to range_max and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateCoulomb
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateCoulomb_function_type)( int ) const;
integrateCoulomb_function_type integrateCoulomb_function_value( &::SireAnalysis::ComponentGradients::integrateCoulomb );
ComponentGradients_exposer.def(
"integrateCoulomb"
, integrateCoulomb_function_value
, ( bp::arg("i") )
, "Integrate the coulomb free energy gradients of the ith component\nand return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateCoulomb
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateCoulomb_function_type)( int,int ) const;
integrateCoulomb_function_type integrateCoulomb_function_value( &::SireAnalysis::ComponentGradients::integrateCoulomb );
ComponentGradients_exposer.def(
"integrateCoulomb"
, integrateCoulomb_function_value
, ( bp::arg("i"), bp::arg("order") )
, "Integrate the coulomb free energy gradients of the ith component to order order and\nreturn the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateCoulomb
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateCoulomb_function_type)( int,double,double ) const;
integrateCoulomb_function_type integrateCoulomb_function_value( &::SireAnalysis::ComponentGradients::integrateCoulomb );
ComponentGradients_exposer.def(
"integrateCoulomb"
, integrateCoulomb_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max") )
, "Integrate the coulomb free energy gradients of the ith component between the range\nrange_min to range_max, and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateCoulomb
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateCoulomb_function_type)( int,double,double,int ) const;
integrateCoulomb_function_type integrateCoulomb_function_value( &::SireAnalysis::ComponentGradients::integrateCoulomb );
ComponentGradients_exposer.def(
"integrateCoulomb"
, integrateCoulomb_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max"), bp::arg("order") )
, "Integrate the coulomb free energy gradients of the ith component to order order\nbetween the range range_min to range_max and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateLJ
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateLJ_function_type)( int ) const;
integrateLJ_function_type integrateLJ_function_value( &::SireAnalysis::ComponentGradients::integrateLJ );
ComponentGradients_exposer.def(
"integrateLJ"
, integrateLJ_function_value
, ( bp::arg("i") )
, "Integrate the LJ free energy gradients of the ith component\nand return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateLJ
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateLJ_function_type)( int,int ) const;
integrateLJ_function_type integrateLJ_function_value( &::SireAnalysis::ComponentGradients::integrateLJ );
ComponentGradients_exposer.def(
"integrateLJ"
, integrateLJ_function_value
, ( bp::arg("i"), bp::arg("order") )
, "Integrate the LJ free energy gradients of the ith component to order order and\nreturn the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateLJ
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateLJ_function_type)( int,double,double ) const;
integrateLJ_function_type integrateLJ_function_value( &::SireAnalysis::ComponentGradients::integrateLJ );
ComponentGradients_exposer.def(
"integrateLJ"
, integrateLJ_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max") )
, "Integrate the LJ free energy gradients of the ith component between the range\nrange_min to range_max, and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::integrateLJ
typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateLJ_function_type)( int,double,double,int ) const;
integrateLJ_function_type integrateLJ_function_value( &::SireAnalysis::ComponentGradients::integrateLJ );
ComponentGradients_exposer.def(
"integrateLJ"
, integrateLJ_function_value
, ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max"), bp::arg("order") )
, "Integrate the LJ free energy gradients of the ith component to order order\nbetween the range range_min to range_max and return the resulting PMF" );
}
{ //::SireAnalysis::ComponentGradients::isCompatible
typedef bool ( ::SireAnalysis::ComponentGradients::*isCompatible_function_type)( ::SireAnalysis::ComponentGradients const & ) const;
isCompatible_function_type isCompatible_function_value( &::SireAnalysis::ComponentGradients::isCompatible );
ComponentGradients_exposer.def(
"isCompatible"
, isCompatible_function_value
, ( bp::arg("other") )
, "Return whether or not this set of gradients is compatible with the ones\nprovided in other" );
}
{ //::SireAnalysis::ComponentGradients::isEmpty
typedef bool ( ::SireAnalysis::ComponentGradients::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireAnalysis::ComponentGradients::isEmpty );
ComponentGradients_exposer.def(
"isEmpty"
, isEmpty_function_value
, "Return whether or not this set is empty" );
}
{ //::SireAnalysis::ComponentGradients::lambdaValues
typedef ::QList< double > ( ::SireAnalysis::ComponentGradients::*lambdaValues_function_type)( ) const;
lambdaValues_function_type lambdaValues_function_value( &::SireAnalysis::ComponentGradients::lambdaValues );
ComponentGradients_exposer.def(
"lambdaValues"
, lambdaValues_function_value
, "Return the lambda values over which all of the components were collected" );
}
{ //::SireAnalysis::ComponentGradients::ljGradientsAt
typedef ::SireAnalysis::Gradients ( ::SireAnalysis::ComponentGradients::*ljGradientsAt_function_type)( int ) const;
ljGradientsAt_function_type ljGradientsAt_function_value( &::SireAnalysis::ComponentGradients::ljGradientsAt );
ComponentGradients_exposer.def(
"ljGradientsAt"
, ljGradientsAt_function_value
, ( bp::arg("i") )
, "Return the set of LJ free energy gradients for the ith free energy component" );
}
{ //::SireAnalysis::ComponentGradients::ljValues
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::ComponentGradients::*ljValues_function_type)( int ) const;
ljValues_function_type ljValues_function_value( &::SireAnalysis::ComponentGradients::ljValues );
ComponentGradients_exposer.def(
"ljValues"
, ljValues_function_value
, ( bp::arg("i") )
, "Return the actual values of the LJ free energy gradients of the ith component" );
}
{ //::SireAnalysis::ComponentGradients::merge
typedef ::SireAnalysis::ComponentGradients ( *merge_function_type )( ::QList< SireAnalysis::ComponentGradients > const & );
merge_function_type merge_function_value( &::SireAnalysis::ComponentGradients::merge );
ComponentGradients_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("gradients") )
, "Merge together all of the passed gradients. Note that they must all be compatible\nwith one another, otherwise an exception will be raised" );
}
{ //::SireAnalysis::ComponentGradients::nComponents
typedef int ( ::SireAnalysis::ComponentGradients::*nComponents_function_type)( ) const;
nComponents_function_type nComponents_function_value( &::SireAnalysis::ComponentGradients::nComponents );
ComponentGradients_exposer.def(
"nComponents"
, nComponents_function_value
, "Return the number of free energy components (number of molecule views whose\nfree energy of interaction was recorded)" );
}
{ //::SireAnalysis::ComponentGradients::nLambdaValues
typedef int ( ::SireAnalysis::ComponentGradients::*nLambdaValues_function_type)( ) const;
nLambdaValues_function_type nLambdaValues_function_value( &::SireAnalysis::ComponentGradients::nLambdaValues );
ComponentGradients_exposer.def(
"nLambdaValues"
, nLambdaValues_function_value
, "Return the number of lambda values over which the free energy components have\nbeen recorded" );
}
{ //::SireAnalysis::ComponentGradients::nSamples
typedef ::qint64 ( ::SireAnalysis::ComponentGradients::*nSamples_function_type)( ) const;
nSamples_function_type nSamples_function_value( &::SireAnalysis::ComponentGradients::nSamples );
ComponentGradients_exposer.def(
"nSamples"
, nSamples_function_value
, "Return the number of samples used to form all of the average components" );
}
ComponentGradients_exposer.def( bp::self != bp::self );
ComponentGradients_exposer.def( bp::self + bp::self );
{ //::SireAnalysis::ComponentGradients::operator=
typedef ::SireAnalysis::ComponentGradients & ( ::SireAnalysis::ComponentGradients::*assign_function_type)( ::SireAnalysis::ComponentGradients const & ) ;
assign_function_type assign_function_value( &::SireAnalysis::ComponentGradients::operator= );
ComponentGradients_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
ComponentGradients_exposer.def( bp::self == bp::self );
{ //::SireAnalysis::ComponentGradients::temperature
typedef ::SireUnits::Dimension::Temperature ( ::SireAnalysis::ComponentGradients::*temperature_function_type)( ) const;
temperature_function_type temperature_function_value( &::SireAnalysis::ComponentGradients::temperature );
ComponentGradients_exposer.def(
"temperature"
, temperature_function_value
, "Return the temperature at which all of the components were collected" );
}
{ //::SireAnalysis::ComponentGradients::toString
typedef ::QString ( ::SireAnalysis::ComponentGradients::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireAnalysis::ComponentGradients::toString );
ComponentGradients_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireAnalysis::ComponentGradients::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireAnalysis::ComponentGradients::typeName );
ComponentGradients_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireAnalysis::ComponentGradients::values
typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::ComponentGradients::*values_function_type)( int ) const;
values_function_type values_function_value( &::SireAnalysis::ComponentGradients::values );
ComponentGradients_exposer.def(
"values"
, values_function_value
, ( bp::arg("i") )
, "Return the actual values of the free energy gradients of the ith component" );
}
{ //::SireAnalysis::ComponentGradients::viewAt
typedef ::SireMol::PartialMolecule ( ::SireAnalysis::ComponentGradients::*viewAt_function_type)( int ) const;
viewAt_function_type viewAt_function_value( &::SireAnalysis::ComponentGradients::viewAt );
ComponentGradients_exposer.def(
"viewAt"
, viewAt_function_value
, ( bp::arg("i") )
, "Return the ith view that corresponds to the ith free energy component.\nNote that this returns the view in the numerically first (lowest) lambda\nvalue. Use viewAt(int i, double lamval) if you want to specify the lambda\nvalue from which you want to extract the view." );
}
{ //::SireAnalysis::ComponentGradients::viewAt
typedef ::SireMol::PartialMolecule ( ::SireAnalysis::ComponentGradients::*viewAt_function_type)( int,double ) const;
viewAt_function_type viewAt_function_value( &::SireAnalysis::ComponentGradients::viewAt );
ComponentGradients_exposer.def(
"viewAt"
, viewAt_function_value
, ( bp::arg("i"), bp::arg("lamval") )
, "Return the ith view from lambda value lamval that corresponds to the\nith free energy component." );
}
{ //::SireAnalysis::ComponentGradients::what
typedef char const * ( ::SireAnalysis::ComponentGradients::*what_function_type)( ) const;
what_function_type what_function_value( &::SireAnalysis::ComponentGradients::what );
ComponentGradients_exposer.def(
"what"
, what_function_value
, "" );
}
ComponentGradients_exposer.staticmethod( "merge" );
ComponentGradients_exposer.staticmethod( "typeName" );
ComponentGradients_exposer.def( "__copy__", &__copy__);
ComponentGradients_exposer.def( "__deepcopy__", &__copy__);
ComponentGradients_exposer.def( "clone", &__copy__);
ComponentGradients_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::ComponentGradients >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ComponentGradients_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::ComponentGradients >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ComponentGradients_exposer.def( "__str__", &__str__< ::SireAnalysis::ComponentGradients > );
ComponentGradients_exposer.def( "__repr__", &__str__< ::SireAnalysis::ComponentGradients > );
}
}
void register_HMCVelGen_class(){
{ //::SireMove::HMCVelGen
typedef bp::class_< SireMove::HMCVelGen, bp::bases< SireMove::VelocityGenerator, SireBase::Property >, boost::noncopyable > HMCVelGen_exposer_t;
HMCVelGen_exposer_t HMCVelGen_exposer = HMCVelGen_exposer_t( "HMCVelGen", bp::no_init );
bp::scope HMCVelGen_scope( HMCVelGen_exposer );
{ //::SireMove::HMCVelGen::generate
typedef double ( ::SireMove::HMCVelGen::*generate_function_type )( ::SireSystem::System const &,::SireMove::MolecularDynamics & ) ;
generate_function_type generate_function_value( &::SireMove::HMCVelGen::generate );
HMCVelGen_exposer.def(
"generate"
, generate_function_value
, ( bp::arg("system"), bp::arg("md") ) );
}
{ //::SireMove::HMCVelGen::getBias
typedef double ( ::SireMove::HMCVelGen::*getBias_function_type )( ::SireMove::MolecularDynamics const & ) ;
getBias_function_type getBias_function_value( &::SireMove::HMCVelGen::getBias );
HMCVelGen_exposer.def(
"getBias"
, getBias_function_value
, ( bp::arg("md") ) );
}
{ //::SireMove::HMCVelGen::setGenerator
typedef void ( ::SireMove::HMCVelGen::*setGenerator_function_type )( ::SireMaths::RanGenerator const & ) ;
setGenerator_function_type setGenerator_function_value( &::SireMove::HMCVelGen::setGenerator );
HMCVelGen_exposer.def(
"setGenerator"
, setGenerator_function_value
, ( bp::arg("generator") ) );
}
{ //::SireMove::HMCVelGen::setTemperature
typedef void ( ::SireMove::HMCVelGen::*setTemperature_function_type )( ::SireUnits::Dimension::Temperature ) ;
setTemperature_function_type setTemperature_function_value( &::SireMove::HMCVelGen::setTemperature );
HMCVelGen_exposer.def(
"setTemperature"
, setTemperature_function_value
, ( bp::arg("temperature") ) );
}
{ //::SireMove::HMCVelGen::temperature
typedef ::SireUnits::Dimension::Temperature ( ::SireMove::HMCVelGen::*temperature_function_type )( ) const;
temperature_function_type temperature_function_value( &::SireMove::HMCVelGen::temperature );
HMCVelGen_exposer.def(
"temperature"
, temperature_function_value );
}
HMCVelGen_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::HMCVelGen >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
HMCVelGen_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::HMCVelGen >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
HMCVelGen_exposer.def( "__str__", &__str__< ::SireMove::HMCVelGen > );
HMCVelGen_exposer.def( "__repr__", &__str__< ::SireMove::HMCVelGen > );
}
}
