void register_LJNBPairs_class() {
{ //::SireMM::LJNBPairs
typedef bp::class_< SireMM::LJNBPairs, bp::bases< SireMM::AtomPairs<SireMM::LJScaleFactor>, SireMol::MoleculeProperty, SireMol::MolViewProperty, SireBase::Property > > LJNBPairs_exposer_t;
LJNBPairs_exposer_t LJNBPairs_exposer = LJNBPairs_exposer_t( "LJNBPairs", bp::init< >() );
bp::scope LJNBPairs_scope( LJNBPairs_exposer );
LJNBPairs_exposer.def( bp::init< SireMol::MoleculeView const &, bp::optional< SireMM::LJScaleFactor const & > >(( bp::arg("molview"), bp::arg("default_scale")=SireMM::LJScaleFactor(1.0e+0) )) );
LJNBPairs_exposer.def( bp::init< SireMol::MoleculeInfoData const &, bp::optional< SireMM::LJScaleFactor const & > >(( bp::arg("molinfo"), bp::arg("default_scale")=SireMM::LJScaleFactor(1.0e+0) )) );
LJNBPairs_exposer.def( bp::init< SireMM::CLJNBPairs const & >(( bp::arg("cljpairs") )) );
LJNBPairs_exposer.def( bp::init< SireMM::LJNBPairs const & >(( bp::arg("other") )) );
LJNBPairs_exposer.def( bp::self != bp::self );
{ //::SireMM::LJNBPairs::operator=
typedef ::SireMM::LJNBPairs & ( ::SireMM::LJNBPairs::*assign_function_type )( ::SireMM::LJNBPairs const & ) ;
assign_function_type assign_function_value( &::SireMM::LJNBPairs::operator= );
LJNBPairs_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireMM::LJNBPairs::operator=
typedef ::SireMM::LJNBPairs & ( ::SireMM::LJNBPairs::*assign_function_type )( ::SireMM::CLJNBPairs const & ) ;
assign_function_type assign_function_value( &::SireMM::LJNBPairs::operator= );
LJNBPairs_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("cljpairs") )
, bp::return_self< >() );
}
LJNBPairs_exposer.def( bp::self == bp::self );
{ //::SireMM::LJNBPairs::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::LJNBPairs::typeName );
LJNBPairs_exposer.def(
"typeName"
, typeName_function_value );
}
LJNBPairs_exposer.staticmethod( "typeName" );
LJNBPairs_exposer.def( "__copy__", &__copy__);
LJNBPairs_exposer.def( "__deepcopy__", &__copy__);
LJNBPairs_exposer.def( "clone", &__copy__);
LJNBPairs_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::LJNBPairs >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
LJNBPairs_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::LJNBPairs >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
LJNBPairs_exposer.def( "__str__", &__str__< ::SireMM::LJNBPairs > );
LJNBPairs_exposer.def( "__repr__", &__str__< ::SireMM::LJNBPairs > );
}
}
void register_CheckPoint_class(){
{ //::SireSystem::CheckPoint
typedef bp::class_< SireSystem::CheckPoint, bp::bases< SireBase::Property > > CheckPoint_exposer_t;
CheckPoint_exposer_t CheckPoint_exposer = CheckPoint_exposer_t( "CheckPoint", bp::init< >() );
bp::scope CheckPoint_scope( CheckPoint_exposer );
CheckPoint_exposer.def( bp::init< SireSystem::System const & >(( bp::arg("system") )) );
CheckPoint_exposer.def( bp::init< SireSystem::CheckPoint const & >(( bp::arg("other") )) );
CheckPoint_exposer.def( bp::self != bp::self );
{ //::SireSystem::CheckPoint::operator=
typedef ::SireSystem::CheckPoint & ( ::SireSystem::CheckPoint::*assign_function_type )( ::SireSystem::System const & ) ;
assign_function_type assign_function_value( &::SireSystem::CheckPoint::operator= );
CheckPoint_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("system") )
, bp::return_self< >() );
}
{ //::SireSystem::CheckPoint::operator=
typedef ::SireSystem::CheckPoint & ( ::SireSystem::CheckPoint::*assign_function_type )( ::SireSystem::CheckPoint const & ) ;
assign_function_type assign_function_value( &::SireSystem::CheckPoint::operator= );
CheckPoint_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
CheckPoint_exposer.def( bp::self == bp::self );
{ //::SireSystem::CheckPoint::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireSystem::CheckPoint::typeName );
CheckPoint_exposer.def(
"typeName"
, typeName_function_value );
}
CheckPoint_exposer.staticmethod( "typeName" );
CheckPoint_exposer.def( "__copy__", &__copy__);
CheckPoint_exposer.def( "__deepcopy__", &__copy__);
CheckPoint_exposer.def( "clone", &__copy__);
CheckPoint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::CheckPoint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CheckPoint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::CheckPoint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CheckPoint_exposer.def( "__str__", &__str__< ::SireSystem::CheckPoint > );
CheckPoint_exposer.def( "__repr__", &__str__< ::SireSystem::CheckPoint > );
}
}
void register_VelocitiesFromProperty_class(){
{ //::SireMove::VelocitiesFromProperty
typedef bp::class_< SireMove::VelocitiesFromProperty, bp::bases< SireMove::VelocityGenerator, SireBase::Property > > VelocitiesFromProperty_exposer_t;
VelocitiesFromProperty_exposer_t VelocitiesFromProperty_exposer = VelocitiesFromProperty_exposer_t( "VelocitiesFromProperty", "This is a velocity generator that extracts velocities from a\nspecified molecular property\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope VelocitiesFromProperty_scope( VelocitiesFromProperty_exposer );
VelocitiesFromProperty_exposer.def( bp::init< SireBase::PropertyName const & >(( bp::arg("property") ), "Construct to get the velocities from the property property") );
VelocitiesFromProperty_exposer.def( bp::init< SireMove::VelocitiesFromProperty const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMove::VelocitiesFromProperty::generate
typedef ::SireMol::AtomVelocities ( ::SireMove::VelocitiesFromProperty::*generate_function_type)( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
generate_function_type generate_function_value( &::SireMove::VelocitiesFromProperty::generate );
VelocitiesFromProperty_exposer.def(
"generate"
, generate_function_value
, ( bp::arg("molview"), bp::arg("map")=SireBase::PropertyMap() )
, "Return the velocities from the specified property" );
}
VelocitiesFromProperty_exposer.def( bp::self != bp::self );
{ //::SireMove::VelocitiesFromProperty::operator=
typedef ::SireMove::VelocitiesFromProperty & ( ::SireMove::VelocitiesFromProperty::*assign_function_type)( ::SireMove::VelocitiesFromProperty const & ) ;
assign_function_type assign_function_value( &::SireMove::VelocitiesFromProperty::operator= );
VelocitiesFromProperty_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
VelocitiesFromProperty_exposer.def( bp::self == bp::self );
{ //::SireMove::VelocitiesFromProperty::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMove::VelocitiesFromProperty::typeName );
VelocitiesFromProperty_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
VelocitiesFromProperty_exposer.staticmethod( "typeName" );
VelocitiesFromProperty_exposer.def( "__copy__", &__copy__);
VelocitiesFromProperty_exposer.def( "__deepcopy__", &__copy__);
VelocitiesFromProperty_exposer.def( "clone", &__copy__);
VelocitiesFromProperty_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::VelocitiesFromProperty >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
VelocitiesFromProperty_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::VelocitiesFromProperty >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
VelocitiesFromProperty_exposer.def( "__str__", &__str__< ::SireMove::VelocitiesFromProperty > );
VelocitiesFromProperty_exposer.def( "__repr__", &__str__< ::SireMove::VelocitiesFromProperty > );
}
}
void register_HistogramValue_class(){
{ //::SireMaths::HistogramValue
typedef bp::class_< SireMaths::HistogramValue, bp::bases< SireMaths::HistogramBin > > HistogramValue_exposer_t;
HistogramValue_exposer_t HistogramValue_exposer = HistogramValue_exposer_t( "HistogramValue", "This class represents a single histogram bin with its associated value", bp::init< >("Null constructor") );
bp::scope HistogramValue_scope( HistogramValue_exposer );
HistogramValue_exposer.def( bp::init< SireMaths::HistogramBin const &, double >(( bp::arg("bin"), bp::arg("value") ), "Construct the value for the bin bin equal to value") );
HistogramValue_exposer.def( bp::init< SireMaths::HistogramValue const & >(( bp::arg("other") ), "Copy constructor") );
HistogramValue_exposer.def( bp::self != bp::self );
{ //::SireMaths::HistogramValue::operator=
typedef ::SireMaths::HistogramValue & ( ::SireMaths::HistogramValue::*assign_function_type)( ::SireMaths::HistogramValue const & ) ;
assign_function_type assign_function_value( &::SireMaths::HistogramValue::operator= );
HistogramValue_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
HistogramValue_exposer.def( bp::self == bp::self );
{ //::SireMaths::HistogramValue::toString
typedef ::QString ( ::SireMaths::HistogramValue::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMaths::HistogramValue::toString );
HistogramValue_exposer.def(
"toString"
, toString_function_value
, "Return a string representation" );
}
{ //::SireMaths::HistogramValue::value
typedef double ( ::SireMaths::HistogramValue::*value_function_type)( ) const;
value_function_type value_function_value( &::SireMaths::HistogramValue::value );
HistogramValue_exposer.def(
"value"
, value_function_value
, "Return the value of the bin" );
}
HistogramValue_exposer.def( "__copy__", &__copy__);
HistogramValue_exposer.def( "__deepcopy__", &__copy__);
HistogramValue_exposer.def( "clone", &__copy__);
HistogramValue_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::HistogramValue >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
HistogramValue_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::HistogramValue >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
HistogramValue_exposer.def( "__str__", &__str__< ::SireMaths::HistogramValue > );
HistogramValue_exposer.def( "__repr__", &__str__< ::SireMaths::HistogramValue > );
}
}
void register_StringProperty_class(){
{ //::SireBase::StringProperty
typedef bp::class_< SireBase::StringProperty, bp::bases< SireBase::Property > > StringProperty_exposer_t;
StringProperty_exposer_t StringProperty_exposer = StringProperty_exposer_t( "StringProperty", bp::init< >() );
bp::scope StringProperty_scope( StringProperty_exposer );
StringProperty_exposer.def( bp::init< QString const & >(( bp::arg("s") )) );
StringProperty_exposer.def( bp::init< SireBase::StringProperty const & >(( bp::arg("other") )) );
StringProperty_exposer.def( bp::self != bp::self );
{ //::SireBase::StringProperty::operator=
typedef ::SireBase::StringProperty & ( ::SireBase::StringProperty::*assign_function_type )( ::SireBase::StringProperty const & ) ;
assign_function_type assign_function_value( &::SireBase::StringProperty::operator= );
StringProperty_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
StringProperty_exposer.def( bp::self == bp::self );
{ //::SireBase::StringProperty::toString
typedef ::QString ( ::SireBase::StringProperty::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireBase::StringProperty::toString );
StringProperty_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireBase::StringProperty::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireBase::StringProperty::typeName );
StringProperty_exposer.def(
"typeName"
, typeName_function_value );
}
StringProperty_exposer.staticmethod( "typeName" );
StringProperty_exposer.def( "__copy__", &__copy__);
StringProperty_exposer.def( "__deepcopy__", &__copy__);
StringProperty_exposer.def( "clone", &__copy__);
StringProperty_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::StringProperty >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
StringProperty_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::StringProperty >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
StringProperty_exposer.def( "__str__", &__str__< ::SireBase::StringProperty > );
StringProperty_exposer.def( "__repr__", &__str__< ::SireBase::StringProperty > );
}
}
void register_NullAccumulator_class(){
{ //::SireMaths::NullAccumulator
typedef bp::class_< SireMaths::NullAccumulator, bp::bases< SireMaths::Accumulator, SireBase::Property > > NullAccumulator_exposer_t;
NullAccumulator_exposer_t NullAccumulator_exposer = NullAccumulator_exposer_t( "NullAccumulator", bp::init< >() );
bp::scope NullAccumulator_scope( NullAccumulator_exposer );
NullAccumulator_exposer.def( bp::init< SireMaths::NullAccumulator const & >(( bp::arg("other") )) );
{ //::SireMaths::NullAccumulator::accumulate
typedef void ( ::SireMaths::NullAccumulator::*accumulate_function_type )( double ) ;
accumulate_function_type accumulate_function_value( &::SireMaths::NullAccumulator::accumulate );
NullAccumulator_exposer.def(
"accumulate"
, accumulate_function_value
, ( bp::arg("value") ) );
}
NullAccumulator_exposer.def( bp::self != bp::self );
{ //::SireMaths::NullAccumulator::operator=
typedef ::SireMaths::NullAccumulator & ( ::SireMaths::NullAccumulator::*assign_function_type )( ::SireMaths::NullAccumulator const & ) ;
assign_function_type assign_function_value( &::SireMaths::NullAccumulator::operator= );
NullAccumulator_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
NullAccumulator_exposer.def( bp::self == bp::self );
{ //::SireMaths::NullAccumulator::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMaths::NullAccumulator::typeName );
NullAccumulator_exposer.def(
"typeName"
, typeName_function_value );
}
NullAccumulator_exposer.staticmethod( "typeName" );
NullAccumulator_exposer.def( "__copy__", &__copy__);
NullAccumulator_exposer.def( "__deepcopy__", &__copy__);
NullAccumulator_exposer.def( "clone", &__copy__);
NullAccumulator_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::NullAccumulator >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullAccumulator_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::NullAccumulator >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullAccumulator_exposer.def( "__str__", &__str__< ::SireMaths::NullAccumulator > );
NullAccumulator_exposer.def( "__repr__", &__str__< ::SireMaths::NullAccumulator > );
}
}
void register_NullVelocityGenerator_class(){
{ //::SireMove::NullVelocityGenerator
typedef bp::class_< SireMove::NullVelocityGenerator, bp::bases< SireMove::VelocityGenerator, SireBase::Property > > NullVelocityGenerator_exposer_t;
NullVelocityGenerator_exposer_t NullVelocityGenerator_exposer = NullVelocityGenerator_exposer_t( "NullVelocityGenerator", bp::init< >() );
bp::scope NullVelocityGenerator_scope( NullVelocityGenerator_exposer );
NullVelocityGenerator_exposer.def( bp::init< SireMove::NullVelocityGenerator const & >(( bp::arg("other") )) );
{ //::SireMove::NullVelocityGenerator::generate
typedef ::SireMol::AtomVelocities ( ::SireMove::NullVelocityGenerator::*generate_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
generate_function_type generate_function_value( &::SireMove::NullVelocityGenerator::generate );
NullVelocityGenerator_exposer.def(
"generate"
, generate_function_value
, ( bp::arg("molview"), bp::arg("map")=SireBase::PropertyMap() ) );
}
NullVelocityGenerator_exposer.def( bp::self != bp::self );
{ //::SireMove::NullVelocityGenerator::operator=
typedef ::SireMove::NullVelocityGenerator & ( ::SireMove::NullVelocityGenerator::*assign_function_type )( ::SireMove::NullVelocityGenerator const & ) ;
assign_function_type assign_function_value( &::SireMove::NullVelocityGenerator::operator= );
NullVelocityGenerator_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
NullVelocityGenerator_exposer.def( bp::self == bp::self );
{ //::SireMove::NullVelocityGenerator::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMove::NullVelocityGenerator::typeName );
NullVelocityGenerator_exposer.def(
"typeName"
, typeName_function_value );
}
NullVelocityGenerator_exposer.staticmethod( "typeName" );
NullVelocityGenerator_exposer.def( "__copy__", &__copy__);
NullVelocityGenerator_exposer.def( "__deepcopy__", &__copy__);
NullVelocityGenerator_exposer.def( "clone", &__copy__);
NullVelocityGenerator_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::NullVelocityGenerator >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullVelocityGenerator_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::NullVelocityGenerator >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullVelocityGenerator_exposer.def( "__str__", &__str__< ::SireMove::NullVelocityGenerator > );
NullVelocityGenerator_exposer.def( "__repr__", &__str__< ::SireMove::NullVelocityGenerator > );
}
}
void register_NullQM_class(){
{ //::Squire::NullQM
typedef bp::class_< Squire::NullQM, bp::bases< Squire::QMProgram, SireBase::Property > > NullQM_exposer_t;
NullQM_exposer_t NullQM_exposer = NullQM_exposer_t( "NullQM", bp::init< >() );
bp::scope NullQM_scope( NullQM_exposer );
NullQM_exposer.def( bp::init< Squire::NullQM const & >(( bp::arg("other") )) );
NullQM_exposer.def( bp::self != bp::self );
{ //::Squire::NullQM::operator=
typedef ::Squire::NullQM & ( ::Squire::NullQM::*assign_function_type )( ::Squire::NullQM const & ) ;
assign_function_type assign_function_value( &::Squire::NullQM::operator= );
NullQM_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
NullQM_exposer.def( bp::self == bp::self );
{ //::Squire::NullQM::supportsLatticeCharges
typedef bool ( ::Squire::NullQM::*supportsLatticeCharges_function_type )( ) const;
supportsLatticeCharges_function_type supportsLatticeCharges_function_value( &::Squire::NullQM::supportsLatticeCharges );
NullQM_exposer.def(
"supportsLatticeCharges"
, supportsLatticeCharges_function_value );
}
{ //::Squire::NullQM::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::Squire::NullQM::typeName );
NullQM_exposer.def(
"typeName"
, typeName_function_value );
}
NullQM_exposer.staticmethod( "typeName" );
NullQM_exposer.def( "__copy__", &__copy__);
NullQM_exposer.def( "__deepcopy__", &__copy__);
NullQM_exposer.def( "clone", &__copy__);
NullQM_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::Squire::NullQM >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullQM_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::Squire::NullQM >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullQM_exposer.def( "__str__", &__str__< ::Squire::NullQM > );
NullQM_exposer.def( "__repr__", &__str__< ::Squire::NullQM > );
}
}
void register_NullIO_class(){
{ //::SireIO::NullIO
typedef bp::class_< SireIO::NullIO, bp::bases< SireIO::IOBase, SireBase::Property > > NullIO_exposer_t;
NullIO_exposer_t NullIO_exposer = NullIO_exposer_t( "NullIO", "This is the null writer - this writes nothing\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope NullIO_scope( NullIO_exposer );
NullIO_exposer.def( bp::init< SireIO::NullIO const & >(( bp::arg("other") ), "Copy constructor") );
NullIO_exposer.def( bp::self != bp::self );
{ //::SireIO::NullIO::operator=
typedef ::SireIO::NullIO & ( ::SireIO::NullIO::*assign_function_type)( ::SireIO::NullIO const & ) ;
assign_function_type assign_function_value( &::SireIO::NullIO::operator= );
NullIO_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
NullIO_exposer.def( bp::self == bp::self );
{ //::SireIO::NullIO::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireIO::NullIO::typeName );
NullIO_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
NullIO_exposer.staticmethod( "typeName" );
NullIO_exposer.def( "__copy__", &__copy__);
NullIO_exposer.def( "__deepcopy__", &__copy__);
NullIO_exposer.def( "clone", &__copy__);
NullIO_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireIO::NullIO >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullIO_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireIO::NullIO >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullIO_exposer.def( "__str__", &__str__< ::SireIO::NullIO > );
NullIO_exposer.def( "__repr__", &__str__< ::SireIO::NullIO > );
}
}
void register_ResidueBeading_class(){
{ //::SireMol::ResidueBeading
typedef bp::class_< SireMol::ResidueBeading, bp::bases< SireMol::Beading, SireMol::MolViewProperty, SireBase::Property > > ResidueBeading_exposer_t;
ResidueBeading_exposer_t ResidueBeading_exposer = ResidueBeading_exposer_t( "ResidueBeading", "This is a beading function that breaks a molecule into beads\nwith one bead per residue\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope ResidueBeading_scope( ResidueBeading_exposer );
ResidueBeading_exposer.def( bp::init< SireMol::ResidueBeading const & >(( bp::arg("other") ), "Copy constructor") );
ResidueBeading_exposer.def( bp::self != bp::self );
{ //::SireMol::ResidueBeading::operator=
typedef ::SireMol::ResidueBeading & ( ::SireMol::ResidueBeading::*assign_function_type)( ::SireMol::ResidueBeading const & ) ;
assign_function_type assign_function_value( &::SireMol::ResidueBeading::operator= );
ResidueBeading_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
ResidueBeading_exposer.def( bp::self == bp::self );
{ //::SireMol::ResidueBeading::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::ResidueBeading::typeName );
ResidueBeading_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
ResidueBeading_exposer.staticmethod( "typeName" );
ResidueBeading_exposer.def( "__copy__", &__copy__);
ResidueBeading_exposer.def( "__deepcopy__", &__copy__);
ResidueBeading_exposer.def( "clone", &__copy__);
ResidueBeading_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ResidueBeading >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ResidueBeading_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ResidueBeading >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ResidueBeading_exposer.def( "__str__", &__str__< ::SireMol::ResidueBeading > );
ResidueBeading_exposer.def( "__repr__", &__str__< ::SireMol::ResidueBeading > );
}
}
void register_MoleculeBeading_class(){
{ //::SireMol::MoleculeBeading
typedef bp::class_< SireMol::MoleculeBeading, bp::bases< SireMol::Beading, SireMol::MolViewProperty, SireBase::Property > > MoleculeBeading_exposer_t;
MoleculeBeading_exposer_t MoleculeBeading_exposer = MoleculeBeading_exposer_t( "MoleculeBeading", "MoleculeBeading is used to create a single bead that contains\nall of the atoms of the molecule. This is typically used for\nsmall molecules, such as small solvents, where multiple beads\nper molecule would not be sensible\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope MoleculeBeading_scope( MoleculeBeading_exposer );
MoleculeBeading_exposer.def( bp::init< SireMol::MoleculeBeading const & >(( bp::arg("other") ), "Copy constructor") );
MoleculeBeading_exposer.def( bp::self != bp::self );
{ //::SireMol::MoleculeBeading::operator=
typedef ::SireMol::MoleculeBeading & ( ::SireMol::MoleculeBeading::*assign_function_type)( ::SireMol::MoleculeBeading const & ) ;
assign_function_type assign_function_value( &::SireMol::MoleculeBeading::operator= );
MoleculeBeading_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
MoleculeBeading_exposer.def( bp::self == bp::self );
{ //::SireMol::MoleculeBeading::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::MoleculeBeading::typeName );
MoleculeBeading_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
MoleculeBeading_exposer.staticmethod( "typeName" );
MoleculeBeading_exposer.def( "__copy__", &__copy__);
MoleculeBeading_exposer.def( "__deepcopy__", &__copy__);
MoleculeBeading_exposer.def( "clone", &__copy__);
MoleculeBeading_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::MoleculeBeading >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MoleculeBeading_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::MoleculeBeading >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MoleculeBeading_exposer.def( "__str__", &__str__< ::SireMol::MoleculeBeading > );
MoleculeBeading_exposer.def( "__repr__", &__str__< ::SireMol::MoleculeBeading > );
}
}
void register_GridPotentialTable_class(){
{ //::SireFF::GridPotentialTable
typedef bp::class_< SireFF::GridPotentialTable > GridPotentialTable_exposer_t;
GridPotentialTable_exposer_t GridPotentialTable_exposer = GridPotentialTable_exposer_t( "GridPotentialTable", "A GridPotentialTable contains the potentials at point specified by a grid", bp::init< >("Null constructor") );
bp::scope GridPotentialTable_scope( GridPotentialTable_exposer );
GridPotentialTable_exposer.def( bp::init< SireVol::Grid const & >(( bp::arg("grid") ), "Construct to hold the potential at each of the points of the passed grid") );
GridPotentialTable_exposer.def( bp::init< SireFF::GridPotentialTable const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireFF::GridPotentialTable::add
typedef void ( ::SireFF::GridPotentialTable::*add_function_type)( int,::SireUnits::Dimension::MolarEnergy const & ) ;
add_function_type add_function_value( &::SireFF::GridPotentialTable::add );
GridPotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("ipoint"), bp::arg("potential") )
, "Add the potential potential onto the potential for the ipointth grid point\nThrow: SireError::invalid_index\n" );
}
{ //::SireFF::GridPotentialTable::add
typedef void ( ::SireFF::GridPotentialTable::*add_function_type)( ::SireFF::GridPotentialTable const & ) ;
add_function_type add_function_value( &::SireFF::GridPotentialTable::add );
GridPotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("other") )
, "Add the potential in other onto that for this table - this only\nadds the potential if the two grids are identical" );
}
{ //::SireFF::GridPotentialTable::add
typedef void ( ::SireFF::GridPotentialTable::*add_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
add_function_type add_function_value( &::SireFF::GridPotentialTable::add );
GridPotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("potential") )
, "Add the potential potential to all of the points in this table" );
}
{ //::SireFF::GridPotentialTable::at
typedef ::SireUnits::Dimension::MolarEnergy const & ( ::SireFF::GridPotentialTable::*at_function_type)( int ) const;
at_function_type at_function_value( &::SireFF::GridPotentialTable::at );
GridPotentialTable_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the potential value of the ith grid point\nThrow: SireError::invalid_index\n" );
}
{ //::SireFF::GridPotentialTable::count
typedef int ( ::SireFF::GridPotentialTable::*count_function_type)( ) const;
count_function_type count_function_value( &::SireFF::GridPotentialTable::count );
GridPotentialTable_exposer.def(
"count"
, count_function_value
, "Return the number of grid points (and thus potential values)" );
}
{ //::SireFF::GridPotentialTable::divide
typedef void ( ::SireFF::GridPotentialTable::*divide_function_type)( double ) ;
divide_function_type divide_function_value( &::SireFF::GridPotentialTable::divide );
GridPotentialTable_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("value") )
, "Divide the potential at all of the points in this table by value" );
}
{ //::SireFF::GridPotentialTable::grid
typedef ::SireVol::Grid const & ( ::SireFF::GridPotentialTable::*grid_function_type)( ) const;
grid_function_type grid_function_value( &::SireFF::GridPotentialTable::grid );
GridPotentialTable_exposer.def(
"grid"
, grid_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the grid that contains the points at which the potential is\nevaluated - the order of points in the grid is the same as the order\nof potential values in this table" );
}
{ //::SireFF::GridPotentialTable::initialise
typedef void ( ::SireFF::GridPotentialTable::*initialise_function_type)( ) ;
initialise_function_type initialise_function_value( &::SireFF::GridPotentialTable::initialise );
GridPotentialTable_exposer.def(
"initialise"
, initialise_function_value
, "Initialise the potential at each grid point to equal 0" );
}
{ //::SireFF::GridPotentialTable::multiply
typedef void ( ::SireFF::GridPotentialTable::*multiply_function_type)( double ) ;
multiply_function_type multiply_function_value( &::SireFF::GridPotentialTable::multiply );
GridPotentialTable_exposer.def(
"multiply"
, multiply_function_value
, ( bp::arg("value") )
, "Multiply the potential at all of the points in this table by value" );
}
{ //::SireFF::GridPotentialTable::nPoints
typedef int ( ::SireFF::GridPotentialTable::*nPoints_function_type)( ) const;
nPoints_function_type nPoints_function_value( &::SireFF::GridPotentialTable::nPoints );
GridPotentialTable_exposer.def(
"nPoints"
, nPoints_function_value
, "Return the number of grid points (and thus potential values)" );
}
GridPotentialTable_exposer.def( bp::self != bp::self );
GridPotentialTable_exposer.def( bp::self * bp::other< double >() );
GridPotentialTable_exposer.def( bp::self + bp::self );
GridPotentialTable_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
GridPotentialTable_exposer.def( bp::self - bp::self );
GridPotentialTable_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
GridPotentialTable_exposer.def( -bp::self );
GridPotentialTable_exposer.def( bp::self / bp::other< double >() );
{ //::SireFF::GridPotentialTable::operator=
typedef ::SireFF::GridPotentialTable & ( ::SireFF::GridPotentialTable::*assign_function_type)( ::SireFF::GridPotentialTable const & ) ;
assign_function_type assign_function_value( &::SireFF::GridPotentialTable::operator= );
GridPotentialTable_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
{ //::SireFF::GridPotentialTable::operator=
typedef ::SireFF::GridPotentialTable & ( ::SireFF::GridPotentialTable::*assign_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
assign_function_type assign_function_value( &::SireFF::GridPotentialTable::operator= );
GridPotentialTable_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("potential") )
, bp::return_self< >()
, "" );
}
GridPotentialTable_exposer.def( bp::self == bp::self );
{ //::SireFF::GridPotentialTable::operator[]
typedef ::SireUnits::Dimension::MolarEnergy & ( ::SireFF::GridPotentialTable::*__getitem___function_type)( int ) ;
__getitem___function_type __getitem___function_value( &::SireFF::GridPotentialTable::operator[] );
GridPotentialTable_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_internal_reference< >()
, "" );
}
{ //::SireFF::GridPotentialTable::operator[]
typedef ::SireUnits::Dimension::MolarEnergy const & ( ::SireFF::GridPotentialTable::*__getitem___function_type)( int ) const;
__getitem___function_type __getitem___function_value( &::SireFF::GridPotentialTable::operator[] );
GridPotentialTable_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireFF::GridPotentialTable::setAll
typedef void ( ::SireFF::GridPotentialTable::*setAll_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
setAll_function_type setAll_function_value( &::SireFF::GridPotentialTable::setAll );
GridPotentialTable_exposer.def(
"setAll"
, setAll_function_value
, ( bp::arg("potential") )
, "Set the potential at all of the points in this table equal to potential" );
}
{ //::SireFF::GridPotentialTable::subtract
typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type)( int,::SireUnits::Dimension::MolarEnergy const & ) ;
subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract );
GridPotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("ipoint"), bp::arg("potential") )
, "Subtract the potential potential from the potential for the ipointth grid point\nThrow: SireError::invalid_index\n" );
}
{ //::SireFF::GridPotentialTable::subtract
typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type)( ::SireFF::GridPotentialTable const & ) ;
subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract );
GridPotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("other") )
, "Subtract the potential in other from that for this table - this only\nsubtracts the potential if the two grids are identical" );
}
{ //::SireFF::GridPotentialTable::subtract
typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract );
GridPotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("potential") )
, "Subtract the potential potential from all of the points in this table" );
}
{ //::SireFF::GridPotentialTable::toVector
typedef ::QVector< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > > ( ::SireFF::GridPotentialTable::*toVector_function_type)( ) const;
toVector_function_type toVector_function_value( &::SireFF::GridPotentialTable::toVector );
GridPotentialTable_exposer.def(
"toVector"
, toVector_function_value
, "Return the array of potential values - the order is the same\nas the order of points in the grid" );
}
{ //::SireFF::GridPotentialTable::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireFF::GridPotentialTable::typeName );
GridPotentialTable_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
GridPotentialTable_exposer.staticmethod( "typeName" );
GridPotentialTable_exposer.def( "__copy__", &__copy__);
GridPotentialTable_exposer.def( "__deepcopy__", &__copy__);
GridPotentialTable_exposer.def( "clone", &__copy__);
GridPotentialTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::GridPotentialTable >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GridPotentialTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::GridPotentialTable >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GridPotentialTable_exposer.def( "__str__", &pvt_get_name);
GridPotentialTable_exposer.def( "__repr__", &pvt_get_name);
GridPotentialTable_exposer.def( "__len__", &__len_count< ::SireFF::GridPotentialTable > );
}
}
void register_SegStringProperty_class(){
{ //::SireMol::SegProperty< QString >
typedef bp::class_< SireMol::SegProperty< QString >, bp::bases< SireMol::SegProp, SireMol::MolViewProperty, SireBase::Property > > SegStringProperty_exposer_t;
SegStringProperty_exposer_t SegStringProperty_exposer = SegStringProperty_exposer_t( "SegStringProperty", bp::init< >() );
bp::scope SegStringProperty_scope( SegStringProperty_exposer );
SegStringProperty_exposer.def( bp::init< SireMol::MoleculeInfoData const & >(( bp::arg("molinfo") )) );
SegStringProperty_exposer.def( bp::init< QVector< QString > const & >(( bp::arg("values") )) );
SegStringProperty_exposer.def( bp::init< SireMol::SegProperty< QString > const & >(( bp::arg("other") )) );
{ //::SireMol::SegProperty< QString >::array
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::QVector< QString > const & ( ::SireMol::SegProperty< QString >::*array_function_type )( ) const;
array_function_type array_function_value( &::SireMol::SegProperty< QString >::array );
SegStringProperty_exposer.def(
"array"
, array_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::SegProperty< QString >::assertCanConvert
typedef SireMol::SegProperty< QString > exported_class_t;
typedef void ( ::SireMol::SegProperty< QString >::*assertCanConvert_function_type )( ::QVariant const & ) const;
assertCanConvert_function_type assertCanConvert_function_value( &::SireMol::SegProperty< QString >::assertCanConvert );
SegStringProperty_exposer.def(
"assertCanConvert"
, assertCanConvert_function_value
, ( bp::arg("value") ) );
}
{ //::SireMol::SegProperty< QString >::assignFrom
typedef SireMol::SegProperty< QString > exported_class_t;
typedef void ( ::SireMol::SegProperty< QString >::*assignFrom_function_type )( ::SireMol::SegProperty< QVariant > const & ) ;
assignFrom_function_type assignFrom_function_value( &::SireMol::SegProperty< QString >::assignFrom );
SegStringProperty_exposer.def(
"assignFrom"
, assignFrom_function_value
, ( bp::arg("values") ) );
}
{ //::SireMol::SegProperty< QString >::at
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::QString const & ( ::SireMol::SegProperty< QString >::*at_function_type )( ::SireMol::SegIdx const & ) const;
at_function_type at_function_value( &::SireMol::SegProperty< QString >::at );
SegStringProperty_exposer.def(
"at"
, at_function_value
, ( bp::arg("segidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::SegProperty< QString >::canConvert
typedef SireMol::SegProperty< QString > exported_class_t;
typedef bool ( ::SireMol::SegProperty< QString >::*canConvert_function_type )( ::QVariant const & ) const;
canConvert_function_type canConvert_function_value( &::SireMol::SegProperty< QString >::canConvert );
SegStringProperty_exposer.def(
"canConvert"
, canConvert_function_value
, ( bp::arg("value") ) );
}
{ //::SireMol::SegProperty< QString >::count
typedef SireMol::SegProperty< QString > exported_class_t;
typedef int ( ::SireMol::SegProperty< QString >::*count_function_type )( ) const;
count_function_type count_function_value( &::SireMol::SegProperty< QString >::count );
SegStringProperty_exposer.def(
"count"
, count_function_value );
}
{ //::SireMol::SegProperty< QString >::fromVariant
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::SireMol::SegProperty< QString > ( *fromVariant_function_type )( ::SireMol::SegProperty< QVariant > const & );
fromVariant_function_type fromVariant_function_value( &::SireMol::SegProperty< QString >::fromVariant );
SegStringProperty_exposer.def(
"fromVariant"
, fromVariant_function_value
, ( bp::arg("values") ) );
}
{ //::SireMol::SegProperty< QString >::get
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::QString const & ( ::SireMol::SegProperty< QString >::*get_function_type )( ::SireMol::SegIdx const & ) const;
get_function_type get_function_value( &::SireMol::SegProperty< QString >::get );
SegStringProperty_exposer.def(
"get"
, get_function_value
, ( bp::arg("segidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::SegProperty< QString >::isCompatibleWith
typedef SireMol::SegProperty< QString > exported_class_t;
typedef bool ( ::SireMol::SegProperty< QString >::*isCompatibleWith_function_type )( ::SireMol::MoleculeInfoData const & ) const;
isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::SegProperty< QString >::isCompatibleWith );
SegStringProperty_exposer.def(
"isCompatibleWith"
, isCompatibleWith_function_value
, ( bp::arg("molinfo") ) );
}
{ //::SireMol::SegProperty< QString >::isEmpty
typedef SireMol::SegProperty< QString > exported_class_t;
typedef bool ( ::SireMol::SegProperty< QString >::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMol::SegProperty< QString >::isEmpty );
SegStringProperty_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireMol::SegProperty< QString >::nSegments
typedef SireMol::SegProperty< QString > exported_class_t;
typedef int ( ::SireMol::SegProperty< QString >::*nSegments_function_type )( ) const;
nSegments_function_type nSegments_function_value( &::SireMol::SegProperty< QString >::nSegments );
SegStringProperty_exposer.def(
"nSegments"
, nSegments_function_value );
}
SegStringProperty_exposer.def( bp::self != bp::self );
{ //::SireMol::SegProperty< QString >::operator=
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::SireMol::SegProperty< QString > & ( ::SireMol::SegProperty< QString >::*assign_function_type )( ::SireMol::SegProperty< QString > const & ) ;
assign_function_type assign_function_value( &::SireMol::SegProperty< QString >::operator= );
SegStringProperty_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
SegStringProperty_exposer.def( bp::self == bp::self );
{ //::SireMol::SegProperty< QString >::operator[]
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::QString const & ( ::SireMol::SegProperty< QString >::*__getitem___function_type )( ::SireMol::SegIdx const & ) const;
__getitem___function_type __getitem___function_value( &::SireMol::SegProperty< QString >::operator[] );
SegStringProperty_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("segidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::SegProperty< QString >::set
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::SireMol::SegProperty< QString > & ( ::SireMol::SegProperty< QString >::*set_function_type )( ::SireMol::SegIdx,::QString const & ) ;
set_function_type set_function_value( &::SireMol::SegProperty< QString >::set );
SegStringProperty_exposer.def(
"set"
, set_function_value
, ( bp::arg("segidx"), bp::arg("value") )
, bp::return_self< >() );
}
{ //::SireMol::SegProperty< QString >::size
typedef SireMol::SegProperty< QString > exported_class_t;
typedef int ( ::SireMol::SegProperty< QString >::*size_function_type )( ) const;
size_function_type size_function_value( &::SireMol::SegProperty< QString >::size );
SegStringProperty_exposer.def(
"size"
, size_function_value );
}
{ //::SireMol::SegProperty< QString >::toString
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::QString ( ::SireMol::SegProperty< QString >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::SegProperty< QString >::toString );
SegStringProperty_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::SegProperty< QString >::toVariant
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::SireMol::SegProperty< QVariant > ( ::SireMol::SegProperty< QString >::*toVariant_function_type )( ) const;
toVariant_function_type toVariant_function_value( &::SireMol::SegProperty< QString >::toVariant );
SegStringProperty_exposer.def(
"toVariant"
, toVariant_function_value );
}
{ //::SireMol::SegProperty< QString >::typeName
typedef SireMol::SegProperty< QString > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::SegProperty< QString >::typeName );
SegStringProperty_exposer.def(
"typeName"
, typeName_function_value );
}
SegStringProperty_exposer.staticmethod( "fromVariant" );
SegStringProperty_exposer.staticmethod( "typeName" );
SegStringProperty_exposer.def( "__copy__", &__copy__);
SegStringProperty_exposer.def( "__deepcopy__", &__copy__);
SegStringProperty_exposer.def( "clone", &__copy__);
SegStringProperty_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::SegProperty<QString> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
SegStringProperty_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::SegProperty<QString> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
SegStringProperty_exposer.def( "__str__", &__str__< ::SireMol::SegProperty<QString> > );
SegStringProperty_exposer.def( "__repr__", &__str__< ::SireMol::SegProperty<QString> > );
SegStringProperty_exposer.def( "__len__", &__len_size< ::SireMol::SegProperty<QString> > );
}
}
void register_Mover_ViewsOfMol__class(){
{ //::SireMol::Mover< SireMol::ViewsOfMol >
typedef bp::class_< SireMol::Mover< SireMol::ViewsOfMol >, bp::bases< SireMol::MoverBase, SireMol::ViewsOfMol, SireMol::MoleculeView, SireBase::Property > > Mover_ViewsOfMol__exposer_t;
Mover_ViewsOfMol__exposer_t Mover_ViewsOfMol__exposer = Mover_ViewsOfMol__exposer_t( "Mover_ViewsOfMol_", bp::init< >() );
bp::scope Mover_ViewsOfMol__scope( Mover_ViewsOfMol__exposer );
Mover_ViewsOfMol__exposer.def( bp::init< SireMol::ViewsOfMol const & >(( bp::arg("view") )) );
Mover_ViewsOfMol__exposer.def( bp::init< SireMol::ViewsOfMol const &, SireMol::AtomSelection const & >(( bp::arg("view"), bp::arg("movable_atoms") )) );
Mover_ViewsOfMol__exposer.def( bp::init< SireMol::Mover< SireMol::ViewsOfMol > const & >(( bp::arg("other") )) );
{ //::SireMol::Mover< SireMol::ViewsOfMol >::align
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*align_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) ;
align_function_type align_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::align );
Mover_ViewsOfMol__exposer.def(
"align"
, align_function_value
, ( bp::arg("other"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::align
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*align_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const &,::SireBase::PropertyMap const & ) ;
align_function_type align_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::align );
Mover_ViewsOfMol__exposer.def(
"align"
, align_function_value
, ( bp::arg("other"), bp::arg("map0"), bp::arg("map1") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::align
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*align_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const & ) ;
align_function_type align_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::align );
Mover_ViewsOfMol__exposer.def(
"align"
, align_function_value
, ( bp::arg("other"), bp::arg("matcher"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::align
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*align_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const &,::SireBase::PropertyMap const & ) ;
align_function_type align_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::align );
Mover_ViewsOfMol__exposer.def(
"align"
, align_function_value
, ( bp::arg("other"), bp::arg("matcher"), bp::arg("map0"), bp::arg("map1") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::alignTo
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*alignTo_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const & ) ;
alignTo_function_type alignTo_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::alignTo );
Mover_ViewsOfMol__exposer.def(
"alignTo"
, alignTo_function_value
, ( bp::arg("other"), bp::arg("matcher"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::alignTo
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*alignTo_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const &,::SireBase::PropertyMap const & ) ;
alignTo_function_type alignTo_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::alignTo );
Mover_ViewsOfMol__exposer.def(
"alignTo"
, alignTo_function_value
, ( bp::arg("other"), bp::arg("matcher"), bp::arg("map0"), bp::arg("map1") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::alignTo
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*alignTo_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomSelection const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const & ) ;
alignTo_function_type alignTo_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::alignTo );
Mover_ViewsOfMol__exposer.def(
"alignTo"
, alignTo_function_value
, ( bp::arg("other"), bp::arg("aligning_atoms"), bp::arg("matcher"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::alignTo
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*alignTo_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomSelection const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const &,::SireBase::PropertyMap const & ) ;
alignTo_function_type alignTo_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::alignTo );
Mover_ViewsOfMol__exposer.def(
"alignTo"
, alignTo_function_value
, ( bp::arg("other"), bp::arg("aligning_atoms"), bp::arg("matcher"), bp::arg("map0"), bp::arg("map1") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::change
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::BondID const &,::SireUnits::Dimension::PhysUnit< 0, 1, 0, 0, 0, 0, 0 >,::SireBase::PropertyMap const & ) ;
change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change );
Mover_ViewsOfMol__exposer.def(
"change"
, change_function_value
, ( bp::arg("bond"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::change
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::AngleID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change );
Mover_ViewsOfMol__exposer.def(
"change"
, change_function_value
, ( bp::arg("angle"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::change
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::DihedralID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change );
Mover_ViewsOfMol__exposer.def(
"change"
, change_function_value
, ( bp::arg("dihedral"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::change
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::BondID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change );
Mover_ViewsOfMol__exposer.def(
"change"
, change_function_value
, ( bp::arg("bond"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::change
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::ImproperID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change );
Mover_ViewsOfMol__exposer.def(
"change"
, change_function_value
, ( bp::arg("improper"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::changeFrame
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*changeFrame_function_type )( ::SireMaths::AxisSet const &,::SireMaths::AxisSet const &,::SireBase::PropertyMap const & ) ;
changeFrame_function_type changeFrame_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::changeFrame );
Mover_ViewsOfMol__exposer.def(
"changeFrame"
, changeFrame_function_value
, ( bp::arg("from_frame"), bp::arg("to_frame"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::commit
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::ViewsOfMol ( ::SireMol::Mover< SireMol::ViewsOfMol >::*commit_function_type )( ) const;
commit_function_type commit_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::commit );
Mover_ViewsOfMol__exposer.def(
"commit"
, commit_function_value );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::mapInto
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*mapInto_function_type )( ::SireMaths::AxisSet const &,::SireBase::PropertyMap const & ) ;
mapInto_function_type mapInto_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::mapInto );
Mover_ViewsOfMol__exposer.def(
"mapInto"
, mapInto_function_value
, ( bp::arg("axes"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::operator=
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*assign_function_type )( ::SireMol::Mover< SireMol::ViewsOfMol > const & ) ;
assign_function_type assign_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::operator= );
Mover_ViewsOfMol__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::operator=
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*assign_function_type )( ::SireMol::ViewsOfMol const & ) ;
assign_function_type assign_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::operator= );
Mover_ViewsOfMol__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::rotate
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*rotate_function_type )( ::SireMaths::Quaternion const &,::SireMaths::Vector const &,::SireBase::PropertyMap const & ) ;
rotate_function_type rotate_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::rotate );
Mover_ViewsOfMol__exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("quat"), bp::arg("point"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::rotate
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*rotate_function_type )( ::SireMaths::Matrix const &,::SireMaths::Vector const &,::SireBase::PropertyMap const & ) ;
rotate_function_type rotate_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::rotate );
Mover_ViewsOfMol__exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("rotmat"), bp::arg("point"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::set
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*set_function_type )( ::SireMol::BondID const &,::SireUnits::Dimension::PhysUnit< 0, 1, 0, 0, 0, 0, 0 >,::SireBase::PropertyMap const & ) ;
set_function_type set_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::set );
Mover_ViewsOfMol__exposer.def(
"set"
, set_function_value
, ( bp::arg("bond"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::set
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*set_function_type )( ::SireMol::AngleID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
set_function_type set_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::set );
Mover_ViewsOfMol__exposer.def(
"set"
, set_function_value
, ( bp::arg("angle"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::set
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*set_function_type )( ::SireMol::DihedralID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
set_function_type set_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::set );
Mover_ViewsOfMol__exposer.def(
"set"
, set_function_value
, ( bp::arg("dihedral"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::set
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*set_function_type )( ::SireMol::ImproperID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
set_function_type set_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::set );
Mover_ViewsOfMol__exposer.def(
"set"
, set_function_value
, ( bp::arg("improper"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::setAll
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*setAll_function_type )( ::SireMol::DihedralID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
setAll_function_type setAll_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::setAll );
Mover_ViewsOfMol__exposer.def(
"setAll"
, setAll_function_value
, ( bp::arg("dihedral"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::toString
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::QString ( ::SireMol::Mover< SireMol::ViewsOfMol >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::toString );
Mover_ViewsOfMol__exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::transform
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*transform_function_type )( ::SireMaths::Transform const &,::SireBase::PropertyMap const & ) ;
transform_function_type transform_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::transform );
Mover_ViewsOfMol__exposer.def(
"transform"
, transform_function_value
, ( bp::arg("transform"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::translate
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*translate_function_type )( ::SireMaths::Vector const &,::SireBase::PropertyMap const & ) ;
translate_function_type translate_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::translate );
Mover_ViewsOfMol__exposer.def(
"translate"
, translate_function_value
, ( bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::typeName
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::typeName );
Mover_ViewsOfMol__exposer.def(
"typeName"
, typeName_function_value );
}
Mover_ViewsOfMol__exposer.staticmethod( "typeName" );
Mover_ViewsOfMol__exposer.def( "__copy__", &__copy__);
Mover_ViewsOfMol__exposer.def( "__deepcopy__", &__copy__);
Mover_ViewsOfMol__exposer.def( "clone", &__copy__);
Mover_ViewsOfMol__exposer.def( "__str__", &__str__< ::SireMol::Mover<SireMol::ViewsOfMol> > );
Mover_ViewsOfMol__exposer.def( "__repr__", &__str__< ::SireMol::Mover<SireMol::ViewsOfMol> > );
Mover_ViewsOfMol__exposer.def( "__len__", &__len_count< ::SireMol::Mover<SireMol::ViewsOfMol> > );
}
}
void register_AtomEditorBase_class(){
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >
typedef bp::class_< SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >, bp::bases< SireMol::Atom, SireMol::MoleculeView, SireBase::Property >, boost::noncopyable > AtomEditorBase_exposer_t;
AtomEditorBase_exposer_t AtomEditorBase_exposer = AtomEditorBase_exposer_t( "AtomEditorBase", bp::no_init );
bp::scope AtomEditorBase_scope( AtomEditorBase_exposer );
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::atom
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::AtomEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*atom_function_type )( ) ;
atom_function_type atom_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::atom );
AtomEditorBase_exposer.def(
"atom"
, atom_function_value );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::atom
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::AtomEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*atom_function_type )( ::SireMol::AtomID const &,::SireBase::PropertyMap const & ) ;
atom_function_type atom_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::atom );
AtomEditorBase_exposer.def(
"atom"
, atom_function_value
, ( bp::arg("atomid"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::chain
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::ChainEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*chain_function_type )( ) ;
chain_function_type chain_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::chain );
AtomEditorBase_exposer.def(
"chain"
, chain_function_value );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::chain
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::ChainEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*chain_function_type )( ::SireMol::ChainID const &,::SireBase::PropertyMap const & ) ;
chain_function_type chain_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::chain );
AtomEditorBase_exposer.def(
"chain"
, chain_function_value
, ( bp::arg("chainid"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::cutGroup
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::CGEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*cutGroup_function_type )( ) ;
cutGroup_function_type cutGroup_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::cutGroup );
AtomEditorBase_exposer.def(
"cutGroup"
, cutGroup_function_value );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::cutGroup
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::CGEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*cutGroup_function_type )( ::SireMol::CGID const &,::SireBase::PropertyMap const & ) ;
cutGroup_function_type cutGroup_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::cutGroup );
AtomEditorBase_exposer.def(
"cutGroup"
, cutGroup_function_value
, ( bp::arg("cgid"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::molecule
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::MolEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*molecule_function_type )( ) ;
molecule_function_type molecule_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::molecule );
AtomEditorBase_exposer.def(
"molecule"
, molecule_function_value );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::operator=
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > & ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*assign_function_type )( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > const & ) ;
assign_function_type assign_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::operator= );
AtomEditorBase_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::operator=
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > & ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*assign_function_type )( ::SireMol::Atom const & ) ;
assign_function_type assign_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::operator= );
AtomEditorBase_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::removeMetadata
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::AtomEditor & ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*removeMetadata_function_type )( ::SireBase::PropertyName const & ) ;
removeMetadata_function_type removeMetadata_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::removeMetadata );
AtomEditorBase_exposer.def(
"removeMetadata"
, removeMetadata_function_value
, ( bp::arg("metakey") )
, bp::return_self< >() );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::removeMetadata
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::AtomEditor & ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*removeMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) ;
removeMetadata_function_type removeMetadata_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::removeMetadata );
AtomEditorBase_exposer.def(
"removeMetadata"
, removeMetadata_function_value
, ( bp::arg("key"), bp::arg("metakey") )
, bp::return_self< >() );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::removeProperty
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::AtomEditor & ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*removeProperty_function_type )( ::SireBase::PropertyName const & ) ;
removeProperty_function_type removeProperty_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::removeProperty );
AtomEditorBase_exposer.def(
"removeProperty"
, removeProperty_function_value
, ( bp::arg("key") )
, bp::return_self< >() );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::residue
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::ResEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*residue_function_type )( ) ;
residue_function_type residue_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::residue );
AtomEditorBase_exposer.def(
"residue"
, residue_function_value );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::residue
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::ResEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*residue_function_type )( ::SireMol::ResID const &,::SireBase::PropertyMap const & ) ;
residue_function_type residue_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::residue );
AtomEditorBase_exposer.def(
"residue"
, residue_function_value
, ( bp::arg("resid"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::segment
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::SegEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*segment_function_type )( ) ;
segment_function_type segment_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::segment );
AtomEditorBase_exposer.def(
"segment"
, segment_function_value );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::segment
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::SegEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*segment_function_type )( ::SireMol::SegID const &,::SireBase::PropertyMap const & ) ;
segment_function_type segment_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::segment );
AtomEditorBase_exposer.def(
"segment"
, segment_function_value
, ( bp::arg("segid"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::AtomEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*select_function_type )( ::SireMol::AtomID const &,::SireBase::PropertyMap const & ) ;
select_function_type select_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select );
AtomEditorBase_exposer.def(
"select"
, select_function_value
, ( bp::arg("atomid"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::CGEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*select_function_type )( ::SireMol::CGID const &,::SireBase::PropertyMap const & ) ;
select_function_type select_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select );
AtomEditorBase_exposer.def(
"select"
, select_function_value
, ( bp::arg("cgid"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::ResEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*select_function_type )( ::SireMol::ResID const &,::SireBase::PropertyMap const & ) ;
select_function_type select_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select );
AtomEditorBase_exposer.def(
"select"
, select_function_value
, ( bp::arg("resid"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::ChainEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*select_function_type )( ::SireMol::ChainID const &,::SireBase::PropertyMap const & ) ;
select_function_type select_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select );
AtomEditorBase_exposer.def(
"select"
, select_function_value
, ( bp::arg("chainid"), bp::arg("map")=SireBase::PropertyMap() ) );
}
{ //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select
typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
typedef ::SireMol::SegEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*select_function_type )( ::SireMol::SegID const &,::SireBase::PropertyMap const & ) ;
select_function_type select_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select );
AtomEditorBase_exposer.def(
"select"
, select_function_value
, ( bp::arg("segid"), bp::arg("map")=SireBase::PropertyMap() ) );
}
AtomEditorBase_exposer.def( "_set_property_SireMM_LJParameter",
&SireMol::AtomEditorBase::setProperty< SireMM::LJParameter >, bp::return_self< >() );
AtomEditorBase_exposer.def( "_set_metadata_SireMM_LJParameter", &set_Metadata_SireMM_AtomLJs_function1, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_metadata_SireMM_LJParameter", &set_Metadata_SireMM_AtomLJs_function2, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_property_SireUnits_Dimension_Volume",
&SireMol::AtomEditorBase::setProperty< SireUnits::Dimension::Volume >, bp::return_self< >() );
AtomEditorBase_exposer.def( "_set_metadata_SireUnits_Dimension_Volume", &set_Metadata_SireMol_AtomPolarisabilities_function1, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_metadata_SireUnits_Dimension_Volume", &set_Metadata_SireMol_AtomPolarisabilities_function2, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_property_SireUnits_Dimension_MolarEnergy",
&SireMol::AtomEditorBase::setProperty< SireUnits::Dimension::MolarEnergy >, bp::return_self< >() );
AtomEditorBase_exposer.def( "_set_metadata_SireUnits_Dimension_MolarEnergy", &set_Metadata_SireMol_AtomEnergies_function1, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_metadata_SireUnits_Dimension_MolarEnergy", &set_Metadata_SireMol_AtomEnergies_function2, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_property_SireMaths_Vector",
&SireMol::AtomEditorBase::setProperty< SireMaths::Vector >, bp::return_self< >() );
AtomEditorBase_exposer.def( "_set_metadata_SireMaths_Vector", &set_Metadata_SireMol_AtomCoords_function1, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_metadata_SireMaths_Vector", &set_Metadata_SireMol_AtomCoords_function2, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_property_SireMaths_Vector3D_SireUnits_Dimension_Force_",
&SireMol::AtomEditorBase::setProperty< SireMaths::Vector3D<SireUnits::Dimension::Force> >, bp::return_self< >() );
AtomEditorBase_exposer.def( "_set_metadata_SireMaths_Vector3D_SireUnits_Dimension_Force_", &set_Metadata_SireMol_AtomForces_function1, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_metadata_SireMaths_Vector3D_SireUnits_Dimension_Force_", &set_Metadata_SireMol_AtomForces_function2, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_property_SireMol_BeadNum",
&SireMol::AtomEditorBase::setProperty< SireMol::BeadNum >, bp::return_self< >() );
AtomEditorBase_exposer.def( "_set_metadata_SireMol_BeadNum", &set_Metadata_SireMol_AtomBeads_function1, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_metadata_SireMol_BeadNum", &set_Metadata_SireMol_AtomBeads_function2, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_property_SireMaths_Vector3D_SireUnits_Dimension_Velocity_",
&SireMol::AtomEditorBase::setProperty< SireMaths::Vector3D<SireUnits::Dimension::Velocity> >, bp::return_self< >() );
AtomEditorBase_exposer.def( "_set_metadata_SireMaths_Vector3D_SireUnits_Dimension_Velocity_", &set_Metadata_SireMol_AtomVelocities_function1, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_metadata_SireMaths_Vector3D_SireUnits_Dimension_Velocity_", &set_Metadata_SireMol_AtomVelocities_function2, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_property_SireUnits_Dimension_Charge",
&SireMol::AtomEditorBase::setProperty< SireUnits::Dimension::Charge >, bp::return_self< >() );
AtomEditorBase_exposer.def( "_set_metadata_SireUnits_Dimension_Charge", &set_Metadata_SireMol_AtomCharges_function1, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_metadata_SireUnits_Dimension_Charge", &set_Metadata_SireMol_AtomCharges_function2, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_property_SireMol_Element",
&SireMol::AtomEditorBase::setProperty< SireMol::Element >, bp::return_self< >() );
AtomEditorBase_exposer.def( "_set_metadata_SireMol_Element", &set_Metadata_SireMol_AtomElements_function1, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_metadata_SireMol_Element", &set_Metadata_SireMol_AtomElements_function2, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_property_SireUnits_Dimension_MolarMass",
&SireMol::AtomEditorBase::setProperty< SireUnits::Dimension::MolarMass >, bp::return_self< >() );
AtomEditorBase_exposer.def( "_set_metadata_SireUnits_Dimension_MolarMass", &set_Metadata_SireMol_AtomMasses_function1, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_metadata_SireUnits_Dimension_MolarMass", &set_Metadata_SireMol_AtomMasses_function2, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_property_QString",
&SireMol::AtomEditorBase::setProperty< QString >, bp::return_self< >() );
AtomEditorBase_exposer.def( "_set_metadata_QString", &set_Metadata_SireMol_AtomStringProperty_function1, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_metadata_QString", &set_Metadata_SireMol_AtomStringProperty_function2, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_property_qint64",
&SireMol::AtomEditorBase::setProperty< qint64 >, bp::return_self< >() );
AtomEditorBase_exposer.def( "_set_metadata_qint64", &set_Metadata_SireMol_AtomIntProperty_function1, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_metadata_qint64", &set_Metadata_SireMol_AtomIntProperty_function2, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_property_double",
&SireMol::AtomEditorBase::setProperty< double >, bp::return_self< >() );
AtomEditorBase_exposer.def( "_set_metadata_double", &set_Metadata_SireMol_AtomFloatProperty_function1, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_metadata_double", &set_Metadata_SireMol_AtomFloatProperty_function2, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_property_QVariant",
&SireMol::AtomEditorBase::setProperty< QVariant >, bp::return_self< >() );
AtomEditorBase_exposer.def( "_set_metadata_QVariant", &set_Metadata_SireMol_AtomVariantProperty_function1, bp::return_self< >());
AtomEditorBase_exposer.def( "_set_metadata_QVariant", &set_Metadata_SireMol_AtomVariantProperty_function2, bp::return_self< >());
AtomEditorBase_exposer.def( "__str__", &__str__< ::SireMol::Editor<SireMol::AtomEditor, SireMol::Atom> > );
AtomEditorBase_exposer.def( "__repr__", &__str__< ::SireMol::Editor<SireMol::AtomEditor, SireMol::Atom> > );
}
}
void register_MultiVector_class(){
{ //::SireMaths::MultiVector
typedef bp::class_< SireMaths::MultiVector > MultiVector_exposer_t;
MultiVector_exposer_t MultiVector_exposer = MultiVector_exposer_t( "MultiVector", "\nThis is a vectorised version of Vector, e.g. x, y, and z\nare held as MultiDouble objects, meaning that this is a\npacked vector of vectors\n\nAuthor: Christopher Woods\n", bp::init< >("") );
bp::scope MultiVector_scope( MultiVector_exposer );
MultiVector_exposer.def( bp::init< SireMaths::MultiDouble const & >(( bp::arg("value") ), "Copy constructor") );
MultiVector_exposer.def( bp::init< SireMaths::MultiDouble const &, SireMaths::MultiDouble const &, SireMaths::MultiDouble const & >(( bp::arg("x"), bp::arg("y"), bp::arg("z") ), "") );
MultiVector_exposer.def( bp::init< SireMaths::Vector const *, int >(( bp::arg("array"), bp::arg("size") ), "Construct from an array of Vectors. This array cannot be greater\nthan MultiDouble::size()") );
MultiVector_exposer.def( bp::init< QVector< SireMaths::Vector > const & >(( bp::arg("array") ), "Construct from an array of Vectors. This array cannot be greater\nthan MultiDouble::size()") );
MultiVector_exposer.def( bp::init< SireMaths::MultiVector const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMaths::MultiVector::angle
typedef ::SireMaths::MultiDouble ( *angle_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
angle_function_type angle_function_value( &::SireMaths::MultiVector::angle );
MultiVector_exposer.def(
"angle"
, angle_function_value
, ( bp::arg("v0"), bp::arg("v1") )
, "Return the angle between vectors v0 and v1 - this is the smallest\nangle, and will always lie between 0 and 180 degrees" );
}
{ //::SireMaths::MultiVector::angle
typedef ::SireMaths::MultiDouble ( *angle_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
angle_function_type angle_function_value( &::SireMaths::MultiVector::angle );
MultiVector_exposer.def(
"angle"
, angle_function_value
, ( bp::arg("v0"), bp::arg("v1"), bp::arg("v2") )
, "Return the angle between v0-v1-v2 (treating the vectors as points in space)" );
}
{ //::SireMaths::MultiVector::at
typedef ::SireMaths::Vector ( ::SireMaths::MultiVector::*at_function_type)( int ) const;
at_function_type at_function_value( &::SireMaths::MultiVector::at );
MultiVector_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, "Access the ith vector in the MultiVector" );
}
{ //::SireMaths::MultiVector::b
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*b_function_type)( ) const;
b_function_type b_function_value( &::SireMaths::MultiVector::b );
MultiVector_exposer.def(
"b"
, b_function_value
, "Return the components via rgb (limited between 0 and 1)" );
}
{ //::SireMaths::MultiVector::bearing
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearing_function_type)( ) const;
bearing_function_type bearing_function_value( &::SireMaths::MultiVector::bearing );
MultiVector_exposer.def(
"bearing"
, bearing_function_value
, "Return the bearing of this vector against (0,1,0) (north) on the xy plane" );
}
{ //::SireMaths::MultiVector::bearingXY
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearingXY_function_type)( ::SireMaths::MultiVector const & ) const;
bearingXY_function_type bearingXY_function_value( &::SireMaths::MultiVector::bearingXY );
MultiVector_exposer.def(
"bearingXY"
, bearingXY_function_value
, ( bp::arg("v") )
, "Return the bearing of this vector against v on the xy plane" );
}
{ //::SireMaths::MultiVector::bearingXZ
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearingXZ_function_type)( ::SireMaths::MultiVector const & ) const;
bearingXZ_function_type bearingXZ_function_value( &::SireMaths::MultiVector::bearingXZ );
MultiVector_exposer.def(
"bearingXZ"
, bearingXZ_function_value
, ( bp::arg("v") )
, "Return the bearing of this vector against v on the xz plane" );
}
{ //::SireMaths::MultiVector::bearingYZ
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearingYZ_function_type)( ::SireMaths::MultiVector const & ) const;
bearingYZ_function_type bearingYZ_function_value( &::SireMaths::MultiVector::bearingYZ );
MultiVector_exposer.def(
"bearingYZ"
, bearingYZ_function_value
, ( bp::arg("v") )
, "Return the bearing of this vector against v on the yz plane" );
}
{ //::SireMaths::MultiVector::count
typedef int ( *count_function_type )( );
count_function_type count_function_value( &::SireMaths::MultiVector::count );
MultiVector_exposer.def(
"count"
, count_function_value
, "Return the number of vectors in this MultiVector" );
}
{ //::SireMaths::MultiVector::cross
typedef ::SireMaths::MultiVector ( *cross_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
cross_function_type cross_function_value( &::SireMaths::MultiVector::cross );
MultiVector_exposer.def(
"cross"
, cross_function_value
, ( bp::arg("v0"), bp::arg("v1") )
, "Return the cross product of v0 and v1" );
}
{ //::SireMaths::MultiVector::dihedral
typedef ::SireMaths::MultiDouble ( *dihedral_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const &,::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
dihedral_function_type dihedral_function_value( &::SireMaths::MultiVector::dihedral );
MultiVector_exposer.def(
"dihedral"
, dihedral_function_value
, ( bp::arg("v0"), bp::arg("v1"), bp::arg("v2"), bp::arg("v3") )
, "Return the dihedral angle between v0-v1-v2-v3 (treating the vectors as points)" );
}
{ //::SireMaths::MultiVector::direction
typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*direction_function_type)( ) const;
direction_function_type direction_function_value( &::SireMaths::MultiVector::direction );
MultiVector_exposer.def(
"direction"
, direction_function_value
, "Return the unit vector pointing in the direction of this vector" );
}
{ //::SireMaths::MultiVector::distance
typedef ::SireMaths::MultiDouble ( *distance_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
distance_function_type distance_function_value( &::SireMaths::MultiVector::distance );
MultiVector_exposer.def(
"distance"
, distance_function_value
, ( bp::arg("v1"), bp::arg("v2") )
, "Return the distance between two vectors" );
}
{ //::SireMaths::MultiVector::distance2
typedef ::SireMaths::MultiDouble ( *distance2_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
distance2_function_type distance2_function_value( &::SireMaths::MultiVector::distance2 );
MultiVector_exposer.def(
"distance2"
, distance2_function_value
, ( bp::arg("v1"), bp::arg("v2") )
, "Return the distance squared between two vectors" );
}
{ //::SireMaths::MultiVector::dot
typedef ::SireMaths::MultiDouble ( *dot_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
dot_function_type dot_function_value( &::SireMaths::MultiVector::dot );
MultiVector_exposer.def(
"dot"
, dot_function_value
, ( bp::arg("v0"), bp::arg("v1") )
, "Return the dot product of v0 and v1" );
}
{ //::SireMaths::MultiVector::fromArray
typedef ::QVector< SireMaths::MultiVector > ( *fromArray_function_type )( ::SireMaths::Vector const *,int );
fromArray_function_type fromArray_function_value( &::SireMaths::MultiVector::fromArray );
MultiVector_exposer.def(
"fromArray"
, fromArray_function_value
, ( bp::arg("array"), bp::arg("size") )
, "Convert the passed array of vectors into an array of MultiVectors" );
}
{ //::SireMaths::MultiVector::fromArray
typedef ::QVector< SireMaths::MultiVector > ( *fromArray_function_type )( ::QVector< SireMaths::Vector > const & );
fromArray_function_type fromArray_function_value( &::SireMaths::MultiVector::fromArray );
MultiVector_exposer.def(
"fromArray"
, fromArray_function_value
, ( bp::arg("array") )
, "Convert the passed array of vectors into an array of MultiVectors" );
}
{ //::SireMaths::MultiVector::g
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*g_function_type)( ) const;
g_function_type g_function_value( &::SireMaths::MultiVector::g );
MultiVector_exposer.def(
"g"
, g_function_value
, "Return the components via rgb (limited between 0 and 1)" );
}
{ //::SireMaths::MultiVector::generate
typedef ::SireMaths::MultiVector ( *generate_function_type )( ::SireMaths::MultiDouble const &,::SireMaths::MultiVector const &,::SireMaths::MultiDouble const &,::SireMaths::MultiVector const &,::SireMaths::MultiDouble const &,::SireMaths::MultiVector const & );
generate_function_type generate_function_value( &::SireMaths::MultiVector::generate );
MultiVector_exposer.def(
"generate"
, generate_function_value
, ( bp::arg("dst"), bp::arg("v1"), bp::arg("ang"), bp::arg("v2"), bp::arg("dih"), bp::arg("v3") )
, "Generate a vector, v0, that has distance dst v0-v1, angle ang v0-v1-v2,\nand dihedral dih v0-v1-v2-v3" );
}
{ //::SireMaths::MultiVector::getitem
typedef ::SireMaths::Vector ( ::SireMaths::MultiVector::*getitem_function_type)( int ) const;
getitem_function_type getitem_function_value( &::SireMaths::MultiVector::getitem );
MultiVector_exposer.def(
"getitem"
, getitem_function_value
, ( bp::arg("i") )
, "Access the ith vector in the MultiVector" );
}
{ //::SireMaths::MultiVector::invDistance
typedef ::SireMaths::MultiDouble ( *invDistance_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
invDistance_function_type invDistance_function_value( &::SireMaths::MultiVector::invDistance );
MultiVector_exposer.def(
"invDistance"
, invDistance_function_value
, ( bp::arg("v1"), bp::arg("v2") )
, "Return the 1 distance between two vectors" );
}
{ //::SireMaths::MultiVector::invDistance2
typedef ::SireMaths::MultiDouble ( *invDistance2_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
invDistance2_function_type invDistance2_function_value( &::SireMaths::MultiVector::invDistance2 );
MultiVector_exposer.def(
"invDistance2"
, invDistance2_function_value
, ( bp::arg("v1"), bp::arg("v2") )
, "Return 1 distance2 between two vectors" );
}
{ //::SireMaths::MultiVector::invLength
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*invLength_function_type)( ) const;
invLength_function_type invLength_function_value( &::SireMaths::MultiVector::invLength );
MultiVector_exposer.def(
"invLength"
, invLength_function_value
, "" );
}
{ //::SireMaths::MultiVector::invLength2
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*invLength2_function_type)( ) const;
invLength2_function_type invLength2_function_value( &::SireMaths::MultiVector::invLength2 );
MultiVector_exposer.def(
"invLength2"
, invLength2_function_value
, "Return the inverse length squared" );
}
{ //::SireMaths::MultiVector::length
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*length_function_type)( ) const;
length_function_type length_function_value( &::SireMaths::MultiVector::length );
MultiVector_exposer.def(
"length"
, length_function_value
, "" );
}
{ //::SireMaths::MultiVector::length2
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*length2_function_type)( ) const;
length2_function_type length2_function_value( &::SireMaths::MultiVector::length2 );
MultiVector_exposer.def(
"length2"
, length2_function_value
, "" );
}
{ //::SireMaths::MultiVector::magnitude
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*magnitude_function_type)( ) const;
magnitude_function_type magnitude_function_value( &::SireMaths::MultiVector::magnitude );
MultiVector_exposer.def(
"magnitude"
, magnitude_function_value
, "Return the length of this vector" );
}
{ //::SireMaths::MultiVector::manhattanLength
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*manhattanLength_function_type)( ) const;
manhattanLength_function_type manhattanLength_function_value( &::SireMaths::MultiVector::manhattanLength );
MultiVector_exposer.def(
"manhattanLength"
, manhattanLength_function_value
, "Return the manhattan length of the vector" );
}
{ //::SireMaths::MultiVector::max
typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*max_function_type)( ::SireMaths::MultiVector const & ) const;
max_function_type max_function_value( &::SireMaths::MultiVector::max );
MultiVector_exposer.def(
"max"
, max_function_value
, ( bp::arg("other") )
, "Return a vector that has the maximum xyz components out of this\nand other" );
}
{ //::SireMaths::MultiVector::min
typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*min_function_type)( ::SireMaths::MultiVector const & ) const;
min_function_type min_function_value( &::SireMaths::MultiVector::min );
MultiVector_exposer.def(
"min"
, min_function_value
, ( bp::arg("other") )
, "Return a vector that has the minimum components" );
}
{ //::SireMaths::MultiVector::normalise
typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*normalise_function_type)( ) const;
normalise_function_type normalise_function_value( &::SireMaths::MultiVector::normalise );
MultiVector_exposer.def(
"normalise"
, normalise_function_value
, "Return a normalised form of the vector" );
}
MultiVector_exposer.def( bp::self != bp::self );
MultiVector_exposer.def( -bp::self );
{ //::SireMaths::MultiVector::operator=
typedef ::SireMaths::MultiVector & ( ::SireMaths::MultiVector::*assign_function_type)( ::SireMaths::MultiVector const & ) ;
assign_function_type assign_function_value( &::SireMaths::MultiVector::operator= );
MultiVector_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
MultiVector_exposer.def( bp::self == bp::self );
{ //::SireMaths::MultiVector::operator[]
typedef ::SireMaths::Vector ( ::SireMaths::MultiVector::*__getitem___function_type)( int ) const;
__getitem___function_type __getitem___function_value( &::SireMaths::MultiVector::operator[] );
MultiVector_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, "" );
}
{ //::SireMaths::MultiVector::quickSet
typedef void ( ::SireMaths::MultiVector::*quickSet_function_type)( int,::SireMaths::Vector const & ) ;
quickSet_function_type quickSet_function_value( &::SireMaths::MultiVector::quickSet );
MultiVector_exposer.def(
"quickSet"
, quickSet_function_value
, ( bp::arg("i"), bp::arg("val") )
, "Quickly set the values of the vector, without checking the index is valid" );
}
{ //::SireMaths::MultiVector::r
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*r_function_type)( ) const;
r_function_type r_function_value( &::SireMaths::MultiVector::r );
MultiVector_exposer.def(
"r"
, r_function_value
, "Return the components via rgb (limited between 0 and 1)" );
}
{ //::SireMaths::MultiVector::set
typedef void ( ::SireMaths::MultiVector::*set_function_type)( ::SireMaths::MultiDouble const &,::SireMaths::MultiDouble const &,::SireMaths::MultiDouble const & ) ;
set_function_type set_function_value( &::SireMaths::MultiVector::set );
MultiVector_exposer.def(
"set"
, set_function_value
, ( bp::arg("x"), bp::arg("y"), bp::arg("z") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::set
typedef void ( ::SireMaths::MultiVector::*set_function_type)( int,::SireMaths::Vector const & ) ;
set_function_type set_function_value( &::SireMaths::MultiVector::set );
MultiVector_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setB
typedef void ( ::SireMaths::MultiVector::*setB_function_type)( ::SireMaths::MultiDouble const & ) ;
setB_function_type setB_function_value( &::SireMaths::MultiVector::setB );
MultiVector_exposer.def(
"setB"
, setB_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setG
typedef void ( ::SireMaths::MultiVector::*setG_function_type)( ::SireMaths::MultiDouble const & ) ;
setG_function_type setG_function_value( &::SireMaths::MultiVector::setG );
MultiVector_exposer.def(
"setG"
, setG_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setMax
typedef void ( ::SireMaths::MultiVector::*setMax_function_type)( ::SireMaths::MultiVector const & ) ;
setMax_function_type setMax_function_value( &::SireMaths::MultiVector::setMax );
MultiVector_exposer.def(
"setMax"
, setMax_function_value
, ( bp::arg("other") )
, "Set this Vector so that it has the maximum xyz components out of\nthis and other (e.g. this->x = max(this->x(),other.x() etc.)" );
}
{ //::SireMaths::MultiVector::setMin
typedef void ( ::SireMaths::MultiVector::*setMin_function_type)( ::SireMaths::MultiVector const & ) ;
setMin_function_type setMin_function_value( &::SireMaths::MultiVector::setMin );
MultiVector_exposer.def(
"setMin"
, setMin_function_value
, ( bp::arg("other") )
, "Set this Vector so that it has the minimum xyz components" );
}
{ //::SireMaths::MultiVector::setR
typedef void ( ::SireMaths::MultiVector::*setR_function_type)( ::SireMaths::MultiDouble const & ) ;
setR_function_type setR_function_value( &::SireMaths::MultiVector::setR );
MultiVector_exposer.def(
"setR"
, setR_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setX
typedef void ( ::SireMaths::MultiVector::*setX_function_type)( ::SireMaths::MultiDouble const & ) ;
setX_function_type setX_function_value( &::SireMaths::MultiVector::setX );
MultiVector_exposer.def(
"setX"
, setX_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setY
typedef void ( ::SireMaths::MultiVector::*setY_function_type)( ::SireMaths::MultiDouble const & ) ;
setY_function_type setY_function_value( &::SireMaths::MultiVector::setY );
MultiVector_exposer.def(
"setY"
, setY_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setZ
typedef void ( ::SireMaths::MultiVector::*setZ_function_type)( ::SireMaths::MultiDouble const & ) ;
setZ_function_type setZ_function_value( &::SireMaths::MultiVector::setZ );
MultiVector_exposer.def(
"setZ"
, setZ_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::size
typedef int ( *size_function_type )( );
size_function_type size_function_value( &::SireMaths::MultiVector::size );
MultiVector_exposer.def(
"size"
, size_function_value
, "Return the number of vectors in this MultiVector" );
}
{ //::SireMaths::MultiVector::swap
typedef void ( *swap_function_type )( ::SireMaths::MultiVector &,int,::SireMaths::MultiVector &,int );
swap_function_type swap_function_value( &::SireMaths::MultiVector::swap );
MultiVector_exposer.def(
"swap"
, swap_function_value
, ( bp::arg("v0"), bp::arg("idx0"), bp::arg("v1"), bp::arg("idx1") )
, "Swap the values of the value at index idx0 in f0 with the value at index idx in f1" );
}
{ //::SireMaths::MultiVector::toString
typedef ::QString ( ::SireMaths::MultiVector::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMaths::MultiVector::toString );
MultiVector_exposer.def(
"toString"
, toString_function_value
, "Return a QString representation of the vector" );
}
{ //::SireMaths::MultiVector::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMaths::MultiVector::typeName );
MultiVector_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMaths::MultiVector::what
typedef char const * ( ::SireMaths::MultiVector::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMaths::MultiVector::what );
MultiVector_exposer.def(
"what"
, what_function_value
, "" );
}
{ //::SireMaths::MultiVector::x
typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*x_function_type)( ) const;
x_function_type x_function_value( &::SireMaths::MultiVector::x );
MultiVector_exposer.def(
"x"
, x_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMaths::MultiVector::y
typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*y_function_type)( ) const;
y_function_type y_function_value( &::SireMaths::MultiVector::y );
MultiVector_exposer.def(
"y"
, y_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMaths::MultiVector::z
typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*z_function_type)( ) const;
z_function_type z_function_value( &::SireMaths::MultiVector::z );
MultiVector_exposer.def(
"z"
, z_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
MultiVector_exposer.staticmethod( "angle" );
MultiVector_exposer.staticmethod( "count" );
MultiVector_exposer.staticmethod( "cross" );
MultiVector_exposer.staticmethod( "dihedral" );
MultiVector_exposer.staticmethod( "distance" );
MultiVector_exposer.staticmethod( "distance2" );
MultiVector_exposer.staticmethod( "dot" );
MultiVector_exposer.staticmethod( "fromArray" );
MultiVector_exposer.staticmethod( "generate" );
MultiVector_exposer.staticmethod( "invDistance" );
MultiVector_exposer.staticmethod( "invDistance2" );
MultiVector_exposer.staticmethod( "size" );
MultiVector_exposer.staticmethod( "swap" );
MultiVector_exposer.staticmethod( "typeName" );
MultiVector_exposer.def( bp::self * bp::other< SireMaths::MultiDouble >() );
MultiVector_exposer.def( bp::self * bp::other< SireMaths::MultiQuaternion >() );
MultiVector_exposer.def( bp::self + bp::self );
MultiVector_exposer.def( bp::self - bp::self );
MultiVector_exposer.def( bp::self / bp::other< SireMaths::MultiDouble >() );
MultiVector_exposer.def( "__copy__", &__copy__);
MultiVector_exposer.def( "__deepcopy__", &__copy__);
MultiVector_exposer.def( "clone", &__copy__);
MultiVector_exposer.def( "__str__", &__str__< ::SireMaths::MultiVector > );
MultiVector_exposer.def( "__repr__", &__str__< ::SireMaths::MultiVector > );
MultiVector_exposer.def( "__len__", &__len_size< ::SireMaths::MultiVector > );
MultiVector_exposer.def( "__getitem__", &::SireMaths::MultiVector::getitem );
}
}
void register_CLJWorkspace_class(){
{ //::SireMM::CLJWorkspace
typedef bp::class_< SireMM::CLJWorkspace > CLJWorkspace_exposer_t;
CLJWorkspace_exposer_t CLJWorkspace_exposer = CLJWorkspace_exposer_t( "CLJWorkspace", "This class provides a workspace in which to hold the details of the changes\nthat occur in a CLJ forcefield during a Monte Carlo move. The class is optimised\nto avoid copying or duplicating data during Sires copy-on-write copying\n(e.g. the memory allocated in a workspace will always be available for the\nnew copy of a forcefield rather than the old, which, if things work correctly,\nwill mean that there should be no memory allocation during simple MC moves...)\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope CLJWorkspace_scope( CLJWorkspace_exposer );
CLJWorkspace_exposer.def( bp::init< SireMM::CLJWorkspace const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMM::CLJWorkspace::accept
typedef void ( ::SireMM::CLJWorkspace::*accept_function_type)( ::SireMM::CLJBoxes & ) ;
accept_function_type accept_function_value( &::SireMM::CLJWorkspace::accept );
CLJWorkspace_exposer.def(
"accept"
, accept_function_value
, ( bp::arg("boxes") )
, "Accept this workspace - this clears the recalc_from_scratch flag as it\nsignals that we have put the CLJBoxes into a sane state" );
}
{ //::SireMM::CLJWorkspace::at
typedef ::SireMM::CLJDelta const & ( ::SireMM::CLJWorkspace::*at_function_type)( int ) const;
at_function_type at_function_value( &::SireMM::CLJWorkspace::at );
CLJWorkspace_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the ith delta" );
}
{ //::SireMM::CLJWorkspace::changedAtoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*changedAtoms_function_type)( ) const;
changedAtoms_function_type changedAtoms_function_value( &::SireMM::CLJWorkspace::changedAtoms );
CLJWorkspace_exposer.def(
"changedAtoms"
, changedAtoms_function_value
, "Merge all of the deltas together into a single set of changed CLJAtoms that\ncan be used for the change in energy calculation" );
}
{ //::SireMM::CLJWorkspace::clear
typedef void ( ::SireMM::CLJWorkspace::*clear_function_type)( ) ;
clear_function_type clear_function_value( &::SireMM::CLJWorkspace::clear );
CLJWorkspace_exposer.def(
"clear"
, clear_function_value
, "Clear this workspace" );
}
{ //::SireMM::CLJWorkspace::commit
typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJWorkspace::*commit_function_type)( ::SireMM::CLJBoxes &,::SireMM::CLJDelta const & ) ;
commit_function_type commit_function_value( &::SireMM::CLJWorkspace::commit );
CLJWorkspace_exposer.def(
"commit"
, commit_function_value
, ( bp::arg("boxes"), bp::arg("delta") )
, "Commit the changes in the passed delta into the passed CLJBoxes" );
}
{ //::SireMM::CLJWorkspace::count
typedef int ( ::SireMM::CLJWorkspace::*count_function_type)( ) const;
count_function_type count_function_value( &::SireMM::CLJWorkspace::count );
CLJWorkspace_exposer.def(
"count"
, count_function_value
, "Return the number of deltas" );
}
{ //::SireMM::CLJWorkspace::getitem
typedef ::SireMM::CLJDelta ( ::SireMM::CLJWorkspace::*getitem_function_type)( int ) const;
getitem_function_type getitem_function_value( &::SireMM::CLJWorkspace::getitem );
CLJWorkspace_exposer.def(
"getitem"
, getitem_function_value
, ( bp::arg("i") )
, "Return the ith delta" );
}
{ //::SireMM::CLJWorkspace::isEmpty
typedef bool ( ::SireMM::CLJWorkspace::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMM::CLJWorkspace::isEmpty );
CLJWorkspace_exposer.def(
"isEmpty"
, isEmpty_function_value
, "Return whether or not this workspace is empty" );
}
{ //::SireMM::CLJWorkspace::isSingleID
typedef bool ( ::SireMM::CLJWorkspace::*isSingleID_function_type)( ) const;
isSingleID_function_type isSingleID_function_value( &::SireMM::CLJWorkspace::isSingleID );
CLJWorkspace_exposer.def(
"isSingleID"
, isSingleID_function_value
, "Return whether or not this workspace contains deltas with a single\nID (a single CLJAtoms ID)" );
}
{ //::SireMM::CLJWorkspace::merge
typedef ::boost::tuples::tuple< SireMM::CLJAtoms, SireMM::CLJAtoms, SireMM::CLJAtoms, 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::CLJWorkspace::*merge_function_type)( ) const;
merge_function_type merge_function_value( &::SireMM::CLJWorkspace::merge );
CLJWorkspace_exposer.def(
"merge"
, merge_function_value
, "Merge all of the deltas together to return the tuple of the\nchanged, old and new atoms. This is equivalent to calling\nchangedAtoms(), oldAtoms() and newAtoms() and placing them\ninto a tuple. This is more efficient than three separate calls" );
}
{ //::SireMM::CLJWorkspace::mustRecalculateFromScratch
typedef void ( ::SireMM::CLJWorkspace::*mustRecalculateFromScratch_function_type)( ::SireMM::CLJBoxes & ) ;
mustRecalculateFromScratch_function_type mustRecalculateFromScratch_function_value( &::SireMM::CLJWorkspace::mustRecalculateFromScratch );
CLJWorkspace_exposer.def(
"mustRecalculateFromScratch"
, mustRecalculateFromScratch_function_value
, ( bp::arg("boxes") )
, "Tell the workspace that we are now recalculating everything from scratch" );
}
{ //::SireMM::CLJWorkspace::nDeltas
typedef int ( ::SireMM::CLJWorkspace::*nDeltas_function_type)( ) const;
nDeltas_function_type nDeltas_function_value( &::SireMM::CLJWorkspace::nDeltas );
CLJWorkspace_exposer.def(
"nDeltas"
, nDeltas_function_value
, "Return the number of deltas in this workspace" );
}
{ //::SireMM::CLJWorkspace::needsAccepting
typedef bool ( ::SireMM::CLJWorkspace::*needsAccepting_function_type)( ) const;
needsAccepting_function_type needsAccepting_function_value( &::SireMM::CLJWorkspace::needsAccepting );
CLJWorkspace_exposer.def(
"needsAccepting"
, needsAccepting_function_value
, "Return whether or not this workspace needs accepting" );
}
{ //::SireMM::CLJWorkspace::newAtoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*newAtoms_function_type)( ) const;
newAtoms_function_type newAtoms_function_value( &::SireMM::CLJWorkspace::newAtoms );
CLJWorkspace_exposer.def(
"newAtoms"
, newAtoms_function_value
, "Merge all of the new atoms from the deltas together into a single\nset of new CLJAtoms that can be used for the change in energy calculation" );
}
{ //::SireMM::CLJWorkspace::oldAtoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*oldAtoms_function_type)( ) const;
oldAtoms_function_type oldAtoms_function_value( &::SireMM::CLJWorkspace::oldAtoms );
CLJWorkspace_exposer.def(
"oldAtoms"
, oldAtoms_function_value
, "Merge all of the old atoms from the deltas together into a single\nset of old CLJAtoms that can be used for the change in energy calculation" );
}
CLJWorkspace_exposer.def( bp::self != bp::self );
{ //::SireMM::CLJWorkspace::operator=
typedef ::SireMM::CLJWorkspace & ( ::SireMM::CLJWorkspace::*assign_function_type)( ::SireMM::CLJWorkspace const & ) ;
assign_function_type assign_function_value( &::SireMM::CLJWorkspace::operator= );
CLJWorkspace_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
CLJWorkspace_exposer.def( bp::self == bp::self );
{ //::SireMM::CLJWorkspace::operator[]
typedef ::SireMM::CLJDelta const & ( ::SireMM::CLJWorkspace::*__getitem___function_type)( int ) const;
__getitem___function_type __getitem___function_value( &::SireMM::CLJWorkspace::operator[] );
CLJWorkspace_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMM::CLJWorkspace::push
typedef ::SireMM::CLJDelta ( ::SireMM::CLJWorkspace::*push_function_type)( ::SireMM::CLJBoxes &,::QVector< SireMM::CLJBoxIndex > const &,::SireMM::CLJAtoms const &,::SireMM::CLJDelta const & ) ;
push_function_type push_function_value( &::SireMM::CLJWorkspace::push );
CLJWorkspace_exposer.def(
"push"
, push_function_value
, ( bp::arg("boxes"), bp::arg("old_atoms"), bp::arg("new_atoms"), bp::arg("old_delta") )
, "Push the passed change onto the workspace. This changes the atoms in the\npassed CLJBoxes from their values in old_atoms to their values in the\npassed new_atoms. The last CLJDelta used for these atoms is supplied as\nold_delta, and this returns the new CLJDelta for these atoms." );
}
{ //::SireMM::CLJWorkspace::recalculatingFromScratch
typedef bool ( ::SireMM::CLJWorkspace::*recalculatingFromScratch_function_type)( ) const;
recalculatingFromScratch_function_type recalculatingFromScratch_function_value( &::SireMM::CLJWorkspace::recalculatingFromScratch );
CLJWorkspace_exposer.def(
"recalculatingFromScratch"
, recalculatingFromScratch_function_value
, "Return whether or not we are recalculating everything from scratch" );
}
{ //::SireMM::CLJWorkspace::removeSameIDAtoms
typedef void ( ::SireMM::CLJWorkspace::*removeSameIDAtoms_function_type)( ::SireMM::CLJBoxes & ) ;
removeSameIDAtoms_function_type removeSameIDAtoms_function_value( &::SireMM::CLJWorkspace::removeSameIDAtoms );
CLJWorkspace_exposer.def(
"removeSameIDAtoms"
, removeSameIDAtoms_function_value
, ( bp::arg("boxes") )
, "Internal function used to fully remove atoms that have not been\nremoved because they all have the same ID. This is used when the\noptimisation of not removing same ID atoms would break the energy\ncalculation, e.g. if we have multiple CLJGroups and have multiple\nchanged IDs across these groups" );
}
{ //::SireMM::CLJWorkspace::revert
typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJWorkspace::*revert_function_type)( ::SireMM::CLJBoxes &,::SireMM::CLJDelta const & ) ;
revert_function_type revert_function_value( &::SireMM::CLJWorkspace::revert );
CLJWorkspace_exposer.def(
"revert"
, revert_function_value
, ( bp::arg("boxes"), bp::arg("delta") )
, "Revert the changes supplied in the passed delta" );
}
{ //::SireMM::CLJWorkspace::size
typedef int ( ::SireMM::CLJWorkspace::*size_function_type)( ) const;
size_function_type size_function_value( &::SireMM::CLJWorkspace::size );
CLJWorkspace_exposer.def(
"size"
, size_function_value
, "Return the number of deltas" );
}
{ //::SireMM::CLJWorkspace::toString
typedef ::QString ( ::SireMM::CLJWorkspace::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMM::CLJWorkspace::toString );
CLJWorkspace_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireMM::CLJWorkspace::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::CLJWorkspace::typeName );
CLJWorkspace_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMM::CLJWorkspace::what
typedef char const * ( ::SireMM::CLJWorkspace::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMM::CLJWorkspace::what );
CLJWorkspace_exposer.def(
"what"
, what_function_value
, "" );
}
CLJWorkspace_exposer.staticmethod( "typeName" );
CLJWorkspace_exposer.def( "__copy__", &__copy__);
CLJWorkspace_exposer.def( "__deepcopy__", &__copy__);
CLJWorkspace_exposer.def( "clone", &__copy__);
CLJWorkspace_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJWorkspace >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJWorkspace_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJWorkspace >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJWorkspace_exposer.def( "__str__", &__str__< ::SireMM::CLJWorkspace > );
CLJWorkspace_exposer.def( "__repr__", &__str__< ::SireMM::CLJWorkspace > );
CLJWorkspace_exposer.def( "__len__", &__len_size< ::SireMM::CLJWorkspace > );
CLJWorkspace_exposer.def( "__getitem__", &::SireMM::CLJWorkspace::getitem );
}
}
void register_Specify_SegID__class(){
{ //::SireID::Specify< SireMol::SegID >
typedef bp::class_< SireID::Specify< SireMol::SegID >, bp::bases< SireMol::SegID, SireID::ID > > Specify_SegID__exposer_t;
Specify_SegID__exposer_t Specify_SegID__exposer = Specify_SegID__exposer_t( "Specify_SegID_", bp::init< >() );
bp::scope Specify_SegID__scope( Specify_SegID__exposer );
Specify_SegID__exposer.def( bp::init< SireMol::SegID const &, qint32 >(( bp::arg("id"), bp::arg("i") )) );
Specify_SegID__exposer.def( bp::init< SireMol::SegID const &, qint32, qint32 >(( bp::arg("id"), bp::arg("i"), bp::arg("j") )) );
Specify_SegID__exposer.def( bp::init< SireID::Specify< SireMol::SegID > const & >(( bp::arg("other") )) );
{ //::SireID::Specify< SireMol::SegID >::hash
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::uint ( ::SireID::Specify< SireMol::SegID >::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireID::Specify< SireMol::SegID >::hash );
Specify_SegID__exposer.def(
"hash"
, hash_function_value );
}
{ //::SireID::Specify< SireMol::SegID >::isNull
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef bool ( ::SireID::Specify< SireMol::SegID >::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireID::Specify< SireMol::SegID >::isNull );
Specify_SegID__exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireID::Specify< SireMol::SegID >::map
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::QList< SireMol::SegIdx > ( ::SireID::Specify< SireMol::SegID >::*map_function_type )( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireID::Specify< SireMol::SegID >::map );
Specify_SegID__exposer.def(
"map"
, map_function_value
, ( bp::arg("obj") ) );
}
Specify_SegID__exposer.def( bp::self != bp::self );
Specify_SegID__exposer.def( bp::self != bp::other< SireID::ID >() );
{ //::SireID::Specify< SireMol::SegID >::operator()
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__call___function_type )( int ) const;
__call___function_type __call___function_value( &::SireID::Specify< SireMol::SegID >::operator() );
Specify_SegID__exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i") ) );
}
{ //::SireID::Specify< SireMol::SegID >::operator()
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__call___function_type )( int,int ) const;
__call___function_type __call___function_value( &::SireID::Specify< SireMol::SegID >::operator() );
Specify_SegID__exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i"), bp::arg("j") ) );
}
{ //::SireID::Specify< SireMol::SegID >::operator=
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::SireID::Specify< SireMol::SegID > & ( ::SireID::Specify< SireMol::SegID >::*assign_function_type )( ::SireID::Specify< SireMol::SegID > const & ) ;
assign_function_type assign_function_value( &::SireID::Specify< SireMol::SegID >::operator= );
Specify_SegID__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Specify_SegID__exposer.def( bp::self == bp::self );
Specify_SegID__exposer.def( bp::self == bp::other< SireID::ID >() );
{ //::SireID::Specify< SireMol::SegID >::operator[]
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireID::Specify< SireMol::SegID >::operator[] );
Specify_SegID__exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") ) );
}
{ //::SireID::Specify< SireMol::SegID >::toString
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef ::QString ( ::SireID::Specify< SireMol::SegID >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireID::Specify< SireMol::SegID >::toString );
Specify_SegID__exposer.def(
"toString"
, toString_function_value );
}
{ //::SireID::Specify< SireMol::SegID >::typeName
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireID::Specify< SireMol::SegID >::typeName );
Specify_SegID__exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireID::Specify< SireMol::SegID >::what
typedef SireID::Specify< SireMol::SegID > exported_class_t;
typedef char const * ( ::SireID::Specify< SireMol::SegID >::*what_function_type )( ) const;
what_function_type what_function_value( &::SireID::Specify< SireMol::SegID >::what );
Specify_SegID__exposer.def(
"what"
, what_function_value );
}
Specify_SegID__exposer.staticmethod( "typeName" );
Specify_SegID__exposer.def( "__copy__", &__copy__);
Specify_SegID__exposer.def( "__deepcopy__", &__copy__);
Specify_SegID__exposer.def( "clone", &__copy__);
Specify_SegID__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Specify<SireMol::SegID> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Specify_SegID__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Specify<SireMol::SegID> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Specify_SegID__exposer.def( "__str__", &__str__< ::SireID::Specify<SireMol::SegID> > );
Specify_SegID__exposer.def( "__repr__", &__str__< ::SireID::Specify<SireMol::SegID> > );
}
}
void register_Expression_class(){
{ //::SireCAS::Expression
typedef bp::class_< SireCAS::Expression > Expression_exposer_t;
Expression_exposer_t Expression_exposer = Expression_exposer_t( "Expression", bp::init< >() );
bp::scope Expression_scope( Expression_exposer );
Expression_exposer.def( bp::init< int >(( bp::arg("constant") )) );
Expression_exposer.def( bp::init< SireMaths::Rational const & >(( bp::arg("constant") )) );
Expression_exposer.def( bp::init< double >(( bp::arg("constant") )) );
Expression_exposer.def( bp::init< SireMaths::Complex const & >(( bp::arg("constant") )) );
Expression_exposer.def( bp::init< SireCAS::ExpressionBase const & >(( bp::arg("base") )) );
Expression_exposer.def( bp::init< SireCAS::ExBase const & >(( bp::arg("base") )) );
Expression_exposer.def( bp::init< SireCAS::Expression const & >(( bp::arg("other") )) );
{ //::SireCAS::Expression::add
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireCAS::Expression const & ) const;
add_function_type add_function_value( &::SireCAS::Expression::add );
Expression_exposer.def(
"add"
, add_function_value
, ( bp::arg("ex") ) );
}
{ //::SireCAS::Expression::add
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( double ) const;
add_function_type add_function_value( &::SireCAS::Expression::add );
Expression_exposer.def(
"add"
, add_function_value
, ( bp::arg("val") ) );
}
{ //::SireCAS::Expression::add
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireMaths::Complex const & ) const;
add_function_type add_function_value( &::SireCAS::Expression::add );
Expression_exposer.def(
"add"
, add_function_value
, ( bp::arg("val") ) );
}
{ //::SireCAS::Expression::base
typedef ::SireCAS::ExpressionBase const & ( ::SireCAS::Expression::*base_function_type )( ) const;
base_function_type base_function_value( &::SireCAS::Expression::base );
Expression_exposer.def(
"base"
, base_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireCAS::Expression::children
typedef ::SireCAS::Expressions ( ::SireCAS::Expression::*children_function_type )( ) const;
children_function_type children_function_value( &::SireCAS::Expression::children );
Expression_exposer.def(
"children"
, children_function_value );
}
{ //::SireCAS::Expression::conjugate
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*conjugate_function_type )( ) const;
conjugate_function_type conjugate_function_value( &::SireCAS::Expression::conjugate );
Expression_exposer.def(
"conjugate"
, conjugate_function_value );
}
{ //::SireCAS::Expression::cubed
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*cubed_function_type )( ) const;
cubed_function_type cubed_function_value( &::SireCAS::Expression::cubed );
Expression_exposer.def(
"cubed"
, cubed_function_value );
}
{ //::SireCAS::Expression::diff
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*diff_function_type )( ::SireCAS::Symbol const &,int ) const;
diff_function_type diff_function_value( &::SireCAS::Expression::diff );
Expression_exposer.def(
"diff"
, diff_function_value
, ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) );
}
{ //::SireCAS::Expression::differentiate
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*differentiate_function_type )( ::SireCAS::Symbol const &,int ) const;
differentiate_function_type differentiate_function_value( &::SireCAS::Expression::differentiate );
Expression_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) );
}
{ //::SireCAS::Expression::divide
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireCAS::Expression const & ) const;
divide_function_type divide_function_value( &::SireCAS::Expression::divide );
Expression_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("ex") ) );
}
{ //::SireCAS::Expression::divide
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( double ) const;
divide_function_type divide_function_value( &::SireCAS::Expression::divide );
Expression_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("val") ) );
}
{ //::SireCAS::Expression::divide
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireMaths::Complex const & ) const;
divide_function_type divide_function_value( &::SireCAS::Expression::divide );
Expression_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("val") ) );
}
{ //::SireCAS::Expression::evaluate
typedef double ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::Values const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate );
Expression_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Expression::evaluate
typedef ::SireMaths::Complex ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate );
Expression_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Expression::expand
typedef ::QList< SireCAS::Factor > ( ::SireCAS::Expression::*expand_function_type )( ::SireCAS::Symbol const & ) const;
expand_function_type expand_function_value( &::SireCAS::Expression::expand );
Expression_exposer.def(
"expand"
, expand_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Expression::factor
typedef double ( ::SireCAS::Expression::*factor_function_type )( ) const;
factor_function_type factor_function_value( &::SireCAS::Expression::factor );
Expression_exposer.def(
"factor"
, factor_function_value );
}
{ //::SireCAS::Expression::functions
typedef ::SireCAS::Functions ( ::SireCAS::Expression::*functions_function_type )( ) const;
functions_function_type functions_function_value( &::SireCAS::Expression::functions );
Expression_exposer.def(
"functions"
, functions_function_value );
}
{ //::SireCAS::Expression::hash
typedef ::uint ( ::SireCAS::Expression::*hash_function_type )( ) const;
hash_function_type hash_function_value( &::SireCAS::Expression::hash );
Expression_exposer.def(
"hash"
, hash_function_value );
}
{ //::SireCAS::Expression::integ
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integ_function_type )( ::SireCAS::Symbol const & ) const;
integ_function_type integ_function_value( &::SireCAS::Expression::integ );
Expression_exposer.def(
"integ"
, integ_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Expression::integrate
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integrate_function_type )( ::SireCAS::Symbol const & ) const;
integrate_function_type integrate_function_value( &::SireCAS::Expression::integrate );
Expression_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Expression::invert
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*invert_function_type )( ) const;
invert_function_type invert_function_value( &::SireCAS::Expression::invert );
Expression_exposer.def(
"invert"
, invert_function_value );
}
{ //::SireCAS::Expression::isComplex
typedef bool ( ::SireCAS::Expression::*isComplex_function_type )( ) const;
isComplex_function_type isComplex_function_value( &::SireCAS::Expression::isComplex );
Expression_exposer.def(
"isComplex"
, isComplex_function_value );
}
{ //::SireCAS::Expression::isCompound
typedef bool ( ::SireCAS::Expression::*isCompound_function_type )( ) const;
isCompound_function_type isCompound_function_value( &::SireCAS::Expression::isCompound );
Expression_exposer.def(
"isCompound"
, isCompound_function_value );
}
{ //::SireCAS::Expression::isConstant
typedef bool ( ::SireCAS::Expression::*isConstant_function_type )( ) const;
isConstant_function_type isConstant_function_value( &::SireCAS::Expression::isConstant );
Expression_exposer.def(
"isConstant"
, isConstant_function_value );
}
{ //::SireCAS::Expression::isFunction
typedef bool ( ::SireCAS::Expression::*isFunction_function_type )( ::SireCAS::Symbol const & ) const;
isFunction_function_type isFunction_function_value( &::SireCAS::Expression::isFunction );
Expression_exposer.def(
"isFunction"
, isFunction_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireCAS::Expression::isZero
typedef bool ( ::SireCAS::Expression::*isZero_function_type )( ) const;
isZero_function_type isZero_function_value( &::SireCAS::Expression::isZero );
Expression_exposer.def(
"isZero"
, isZero_function_value );
}
{ //::SireCAS::Expression::multiply
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireCAS::Expression const & ) const;
multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply );
Expression_exposer.def(
"multiply"
, multiply_function_value
, ( bp::arg("ex") ) );
}
{ //::SireCAS::Expression::multiply
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( double ) const;
multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply );
Expression_exposer.def(
"multiply"
, multiply_function_value
, ( bp::arg("val") ) );
}
{ //::SireCAS::Expression::multiply
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireMaths::Complex const & ) const;
multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply );
Expression_exposer.def(
"multiply"
, multiply_function_value
, ( bp::arg("val") ) );
}
{ //::SireCAS::Expression::negate
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*negate_function_type )( ) const;
negate_function_type negate_function_value( &::SireCAS::Expression::negate );
Expression_exposer.def(
"negate"
, negate_function_value );
}
Expression_exposer.def( bp::self != bp::self );
{ //::SireCAS::Expression::operator()
typedef double ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::Values const & ) const;
__call___function_type __call___function_value( &::SireCAS::Expression::operator() );
Expression_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("values") ) );
}
{ //::SireCAS::Expression::operator()
typedef ::SireMaths::Complex ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::ComplexValues const & ) const;
__call___function_type __call___function_value( &::SireCAS::Expression::operator() );
Expression_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("values") ) );
}
Expression_exposer.def( -bp::self );
{ //::SireCAS::Expression::operator=
typedef ::SireCAS::Expression & ( ::SireCAS::Expression::*assign_function_type )( ::SireCAS::Expression const & ) ;
assign_function_type assign_function_value( &::SireCAS::Expression::operator= );
Expression_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Expression_exposer.def( bp::self == bp::self );
{ //::SireCAS::Expression::pow
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( int ) const;
pow_function_type pow_function_value( &::SireCAS::Expression::pow );
Expression_exposer.def(
"pow"
, pow_function_value
, ( bp::arg("n") ) );
}
{ //::SireCAS::Expression::pow
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Rational const & ) const;
pow_function_type pow_function_value( &::SireCAS::Expression::pow );
Expression_exposer.def(
"pow"
, pow_function_value
, ( bp::arg("n") ) );
}
{ //::SireCAS::Expression::pow
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( double ) const;
pow_function_type pow_function_value( &::SireCAS::Expression::pow );
Expression_exposer.def(
"pow"
, pow_function_value
, ( bp::arg("n") ) );
}
{ //::SireCAS::Expression::pow
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Complex const & ) const;
pow_function_type pow_function_value( &::SireCAS::Expression::pow );
Expression_exposer.def(
"pow"
, pow_function_value
, ( bp::arg("n") ) );
}
{ //::SireCAS::Expression::pow
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireCAS::Expression const & ) const;
pow_function_type pow_function_value( &::SireCAS::Expression::pow );
Expression_exposer.def(
"pow"
, pow_function_value
, ( bp::arg("n") ) );
}
{ //::SireCAS::Expression::root
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*root_function_type )( int ) const;
root_function_type root_function_value( &::SireCAS::Expression::root );
Expression_exposer.def(
"root"
, root_function_value
, ( bp::arg("n") ) );
}
{ //::SireCAS::Expression::series
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*series_function_type )( ::SireCAS::Symbol const &,int ) const;
series_function_type series_function_value( &::SireCAS::Expression::series );
Expression_exposer.def(
"series"
, series_function_value
, ( bp::arg("symbol"), bp::arg("order") ) );
}
{ //::SireCAS::Expression::simplify
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*simplify_function_type )( int ) const;
simplify_function_type simplify_function_value( &::SireCAS::Expression::simplify );
Expression_exposer.def(
"simplify"
, simplify_function_value
, ( bp::arg("options")=(int)(0) ) );
}
{ //::SireCAS::Expression::squared
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*squared_function_type )( ) const;
squared_function_type squared_function_value( &::SireCAS::Expression::squared );
Expression_exposer.def(
"squared"
, squared_function_value );
}
{ //::SireCAS::Expression::substitute
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*substitute_function_type )( ::SireCAS::Identities const & ) const;
substitute_function_type substitute_function_value( &::SireCAS::Expression::substitute );
Expression_exposer.def(
"substitute"
, substitute_function_value
, ( bp::arg("identities") ) );
}
{ //::SireCAS::Expression::subtract
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireCAS::Expression const & ) const;
subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract );
Expression_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("ex") ) );
}
{ //::SireCAS::Expression::subtract
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( double ) const;
subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract );
Expression_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("val") ) );
}
{ //::SireCAS::Expression::subtract
typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireMaths::Complex const & ) const;
subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract );
Expression_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("val") ) );
}
{ //::SireCAS::Expression::symbols
typedef ::SireCAS::Symbols ( ::SireCAS::Expression::*symbols_function_type )( ) const;
symbols_function_type symbols_function_value( &::SireCAS::Expression::symbols );
Expression_exposer.def(
"symbols"
, symbols_function_value );
}
{ //::SireCAS::Expression::toString
typedef ::QString ( ::SireCAS::Expression::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireCAS::Expression::toString );
Expression_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireCAS::Expression::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireCAS::Expression::typeName );
Expression_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireCAS::Expression::what
typedef char const * ( ::SireCAS::Expression::*what_function_type )( ) const;
what_function_type what_function_value( &::SireCAS::Expression::what );
Expression_exposer.def(
"what"
, what_function_value );
}
Expression_exposer.staticmethod( "typeName" );
Expression_exposer.def( bp::self * bp::other< SireMaths::Complex >() );
Expression_exposer.def( bp::other< SireMaths::Complex >() * bp::self );
Expression_exposer.def( bp::self * bp::other< double >() );
Expression_exposer.def( bp::other< double >() * bp::self );
Expression_exposer.def( bp::self * bp::self );
Expression_exposer.def( bp::self * bp::other< SireCAS::ExBase >() );
Expression_exposer.def( bp::other< SireMaths::Complex >() + bp::self );
Expression_exposer.def( bp::self + bp::other< SireMaths::Complex >() );
Expression_exposer.def( bp::other< double >() + bp::self );
Expression_exposer.def( bp::self + bp::other< double >() );
Expression_exposer.def( bp::self + bp::self );
Expression_exposer.def( bp::self + bp::other< SireCAS::ExBase >() );
Expression_exposer.def( bp::other< double >() - bp::self );
Expression_exposer.def( bp::self - bp::other< double >() );
Expression_exposer.def( bp::self - bp::self );
Expression_exposer.def( bp::self - bp::other< SireCAS::ExBase >() );
Expression_exposer.def( bp::other< SireMaths::Complex >() / bp::self );
Expression_exposer.def( bp::self / bp::other< SireMaths::Complex >() );
Expression_exposer.def( bp::other< double >() / bp::self );
Expression_exposer.def( bp::self / bp::other< double >() );
Expression_exposer.def( bp::self / bp::self );
Expression_exposer.def( bp::self / bp::other< SireCAS::ExBase >() );
Expression_exposer.def( self + self );
Expression_exposer.def( self - self );
Expression_exposer.def( self * self );
Expression_exposer.def( self / self );
Expression_exposer.def( other<double>() + self );
Expression_exposer.def( other<double>() - self );
Expression_exposer.def( other<double>() * self );
Expression_exposer.def( other<double>() / self );
Expression_exposer.def( self + other<double>() );
Expression_exposer.def( self - other<double>() );
Expression_exposer.def( self * other<double>() );
Expression_exposer.def( self / other<double>() );
Expression_exposer.def( other<SireMaths::Complex>() + self );
Expression_exposer.def( other<SireMaths::Complex>() - self );
Expression_exposer.def( other<SireMaths::Complex>() * self );
Expression_exposer.def( other<SireMaths::Complex>() / self );
Expression_exposer.def( self + other<SireMaths::Complex>() );
Expression_exposer.def( self - other<SireMaths::Complex>() );
Expression_exposer.def( self * other<SireMaths::Complex>() );
Expression_exposer.def( self / other<SireMaths::Complex>() );
Expression_exposer.def( other<SireCAS::ExBase>() + self );
Expression_exposer.def( other<SireCAS::ExBase>() - self );
Expression_exposer.def( other<SireCAS::ExBase>() * self );
Expression_exposer.def( other<SireCAS::ExBase>() / self );
Expression_exposer.def( self + other<SireCAS::ExBase>() );
Expression_exposer.def( self - other<SireCAS::ExBase>() );
Expression_exposer.def( self * other<SireCAS::ExBase>() );
Expression_exposer.def( self / other<SireCAS::ExBase>() );
Expression_exposer.def( "__copy__", &__copy__);
Expression_exposer.def( "__deepcopy__", &__copy__);
Expression_exposer.def( "clone", &__copy__);
Expression_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Expression >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Expression_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Expression >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Expression_exposer.def( "__str__", &__str__< ::SireCAS::Expression > );
Expression_exposer.def( "__repr__", &__str__< ::SireCAS::Expression > );
}
}
void register_DihedralRestraint_class(){
{ //::SireMM::DihedralRestraint
typedef bp::class_< SireMM::DihedralRestraint, bp::bases< SireMM::Restraint3D, SireMM::Restraint, SireBase::Property > > DihedralRestraint_exposer_t;
DihedralRestraint_exposer_t DihedralRestraint_exposer = DihedralRestraint_exposer_t( "DihedralRestraint", "This is a restraint that operates on the dihedral angle between\nfour SireMM::Point objects (e.g. four atoms in a molecule)\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope DihedralRestraint_scope( DihedralRestraint_exposer );
DihedralRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("restraint") ), "Construct a restraint that acts on the angle within the\nthree points point0, point1 and point2 (theta == a(012)),\nrestraining the angle within these points using the expression\nrestraint") );
DihedralRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const &, SireCAS::Values const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("restraint"), bp::arg("values") ), "Construct a restraint that acts on the angle within the\nthree points point0, point1 and point2 (theta == a(012)),\nrestraining the angle within these points using the expression\nrestraint") );
DihedralRestraint_exposer.def( bp::init< SireMM::DihedralRestraint const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMM::DihedralRestraint::builtinSymbols
typedef ::SireCAS::Symbols ( ::SireMM::DihedralRestraint::*builtinSymbols_function_type)( ) const;
builtinSymbols_function_type builtinSymbols_function_value( &::SireMM::DihedralRestraint::builtinSymbols );
DihedralRestraint_exposer.def(
"builtinSymbols"
, builtinSymbols_function_value
, "Return the built-in symbols for this restraint" );
}
{ //::SireMM::DihedralRestraint::builtinValues
typedef ::SireCAS::Values ( ::SireMM::DihedralRestraint::*builtinValues_function_type)( ) const;
builtinValues_function_type builtinValues_function_value( &::SireMM::DihedralRestraint::builtinValues );
DihedralRestraint_exposer.def(
"builtinValues"
, builtinValues_function_value
, "Return the values of the built-in symbols of this restraint" );
}
{ //::SireMM::DihedralRestraint::contains
typedef bool ( ::SireMM::DihedralRestraint::*contains_function_type)( ::SireMol::MolNum ) const;
contains_function_type contains_function_value( &::SireMM::DihedralRestraint::contains );
DihedralRestraint_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molnum") )
, "Return whether or not this restraint affects the molecule\nwith number molnum" );
}
{ //::SireMM::DihedralRestraint::contains
typedef bool ( ::SireMM::DihedralRestraint::*contains_function_type)( ::SireMol::MolID const & ) const;
contains_function_type contains_function_value( &::SireMM::DihedralRestraint::contains );
DihedralRestraint_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molid") )
, "Return whether or not this restraint affects the molecule\nwith ID molid" );
}
{ //::SireMM::DihedralRestraint::differentialRestraintFunction
typedef ::SireCAS::Expression const & ( ::SireMM::DihedralRestraint::*differentialRestraintFunction_function_type)( ) const;
differentialRestraintFunction_function_type differentialRestraintFunction_function_value( &::SireMM::DihedralRestraint::differentialRestraintFunction );
DihedralRestraint_exposer.def(
"differentialRestraintFunction"
, differentialRestraintFunction_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the function used to calculate the restraint force" );
}
{ //::SireMM::DihedralRestraint::differentiate
typedef ::SireMM::RestraintPtr ( ::SireMM::DihedralRestraint::*differentiate_function_type)( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireMM::DihedralRestraint::differentiate );
DihedralRestraint_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") )
, "Return the differential of this restraint with respect to\nthe symbol symbol\nThrow: SireCAS::unavailable_differential\n" );
}
{ //::SireMM::DihedralRestraint::force
typedef void ( ::SireMM::DihedralRestraint::*force_function_type)( ::SireFF::MolForceTable &,double ) const;
force_function_type force_function_value( &::SireMM::DihedralRestraint::force );
DihedralRestraint_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 )
, "Calculate the force acting on the molecule in the forcetable forcetable\ncaused by this restraint, and add it on to the forcetable scaled by\nscale_force" );
}
{ //::SireMM::DihedralRestraint::force
typedef void ( ::SireMM::DihedralRestraint::*force_function_type)( ::SireFF::ForceTable &,double ) const;
force_function_type force_function_value( &::SireMM::DihedralRestraint::force );
DihedralRestraint_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 )
, "Calculate the force acting on the molecules in the forcetable forcetable\ncaused by this restraint, and add it on to the forcetable scaled by\nscale_force" );
}
{ //::SireMM::DihedralRestraint::halfHarmonic
typedef ::SireMM::DihedralRestraint ( *halfHarmonic_function_type )( ::SireFF::PointRef const &,::SireFF::PointRef const &,::SireFF::PointRef const &,::SireFF::PointRef const &,::SireUnits::Dimension::Angle const &,::SireMM::HarmonicAngleForceConstant const & );
halfHarmonic_function_type halfHarmonic_function_value( &::SireMM::DihedralRestraint::halfHarmonic );
DihedralRestraint_exposer.def(
"halfHarmonic"
, halfHarmonic_function_value
, ( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("angle"), bp::arg("force_constant") )
, "Return a distance restraint that applied a half-harmonic potential\nbetween the points point0 and point1 above a distance distance\nusing a force constant force_constant" );
}
{ //::SireMM::DihedralRestraint::harmonic
typedef ::SireMM::DihedralRestraint ( *harmonic_function_type )( ::SireFF::PointRef const &,::SireFF::PointRef const &,::SireFF::PointRef const &,::SireFF::PointRef const &,::SireMM::HarmonicAngleForceConstant const & );
harmonic_function_type harmonic_function_value( &::SireMM::DihedralRestraint::harmonic );
DihedralRestraint_exposer.def(
"harmonic"
, harmonic_function_value
, ( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("force_constant") )
, "Return a distance restraint that applies a harmonic potential between\nthe points point0 and point1 using a force constant force_constant" );
}
{ //::SireMM::DihedralRestraint::molecules
typedef ::SireMol::Molecules ( ::SireMM::DihedralRestraint::*molecules_function_type)( ) const;
molecules_function_type molecules_function_value( &::SireMM::DihedralRestraint::molecules );
DihedralRestraint_exposer.def(
"molecules"
, molecules_function_value
, "Return the molecules used in this restraint" );
}
{ //::SireMM::DihedralRestraint::nPoints
typedef int ( ::SireMM::DihedralRestraint::*nPoints_function_type)( ) const;
nPoints_function_type nPoints_function_value( &::SireMM::DihedralRestraint::nPoints );
DihedralRestraint_exposer.def(
"nPoints"
, nPoints_function_value
, "This restraint involves four points" );
}
DihedralRestraint_exposer.def( bp::self != bp::self );
{ //::SireMM::DihedralRestraint::operator=
typedef ::SireMM::DihedralRestraint & ( ::SireMM::DihedralRestraint::*assign_function_type)( ::SireMM::DihedralRestraint const & ) ;
assign_function_type assign_function_value( &::SireMM::DihedralRestraint::operator= );
DihedralRestraint_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
DihedralRestraint_exposer.def( bp::self == bp::self );
{ //::SireMM::DihedralRestraint::phi
typedef ::SireCAS::Symbol const & ( *phi_function_type )( );
phi_function_type phi_function_value( &::SireMM::DihedralRestraint::phi );
DihedralRestraint_exposer.def(
"phi"
, phi_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the symbol that represents the dihedral angle between the points (phi)" );
}
{ //::SireMM::DihedralRestraint::point
typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point_function_type)( int ) const;
point_function_type point_function_value( &::SireMM::DihedralRestraint::point );
DihedralRestraint_exposer.def(
"point"
, point_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the ith point" );
}
{ //::SireMM::DihedralRestraint::point0
typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point0_function_type)( ) const;
point0_function_type point0_function_value( &::SireMM::DihedralRestraint::point0 );
DihedralRestraint_exposer.def(
"point0"
, point0_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the first point" );
}
{ //::SireMM::DihedralRestraint::point1
typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point1_function_type)( ) const;
point1_function_type point1_function_value( &::SireMM::DihedralRestraint::point1 );
DihedralRestraint_exposer.def(
"point1"
, point1_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the second point" );
}
{ //::SireMM::DihedralRestraint::point2
typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point2_function_type)( ) const;
point2_function_type point2_function_value( &::SireMM::DihedralRestraint::point2 );
DihedralRestraint_exposer.def(
"point2"
, point2_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the third point" );
}
{ //::SireMM::DihedralRestraint::point3
typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point3_function_type)( ) const;
point3_function_type point3_function_value( &::SireMM::DihedralRestraint::point3 );
DihedralRestraint_exposer.def(
"point3"
, point3_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the fourth point" );
}
{ //::SireMM::DihedralRestraint::setSpace
typedef void ( ::SireMM::DihedralRestraint::*setSpace_function_type)( ::SireVol::Space const & ) ;
setSpace_function_type setSpace_function_value( &::SireMM::DihedralRestraint::setSpace );
DihedralRestraint_exposer.def(
"setSpace"
, setSpace_function_value
, ( bp::arg("space") )
, "Set the space used to evaluate the energy of this restraint\nThrow: SireVol::incompatible_space\n" );
}
{ //::SireMM::DihedralRestraint::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::DihedralRestraint::typeName );
DihedralRestraint_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMM::DihedralRestraint::update
typedef void ( ::SireMM::DihedralRestraint::*update_function_type)( ::SireMol::MoleculeData const & ) ;
update_function_type update_function_value( &::SireMM::DihedralRestraint::update );
DihedralRestraint_exposer.def(
"update"
, update_function_value
, ( bp::arg("moldata") )
, "Update the points of this restraint using new molecule data from moldata\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMM::DihedralRestraint::update
typedef void ( ::SireMM::DihedralRestraint::*update_function_type)( ::SireMol::Molecules const & ) ;
update_function_type update_function_value( &::SireMM::DihedralRestraint::update );
DihedralRestraint_exposer.def(
"update"
, update_function_value
, ( bp::arg("molecules") )
, "Update the points of this restraint using new molecule data from molecules\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMM::DihedralRestraint::usesMoleculesIn
typedef bool ( ::SireMM::DihedralRestraint::*usesMoleculesIn_function_type)( ::SireFF::ForceTable const & ) const;
usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DihedralRestraint::usesMoleculesIn );
DihedralRestraint_exposer.def(
"usesMoleculesIn"
, usesMoleculesIn_function_value
, ( bp::arg("forcetable") )
, "Return whether or not this restraint involves any of the molecules\nthat are in the forcetable forcetable" );
}
{ //::SireMM::DihedralRestraint::usesMoleculesIn
typedef bool ( ::SireMM::DihedralRestraint::*usesMoleculesIn_function_type)( ::SireMol::Molecules const & ) const;
usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DihedralRestraint::usesMoleculesIn );
DihedralRestraint_exposer.def(
"usesMoleculesIn"
, usesMoleculesIn_function_value
, ( bp::arg("molecules") )
, "Return whether or not this restraint involves any of the molecules\nin molecules" );
}
DihedralRestraint_exposer.staticmethod( "halfHarmonic" );
DihedralRestraint_exposer.staticmethod( "harmonic" );
DihedralRestraint_exposer.staticmethod( "phi" );
DihedralRestraint_exposer.staticmethod( "typeName" );
DihedralRestraint_exposer.def( "__copy__", &__copy__);
DihedralRestraint_exposer.def( "__deepcopy__", &__copy__);
DihedralRestraint_exposer.def( "clone", &__copy__);
DihedralRestraint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::DihedralRestraint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DihedralRestraint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::DihedralRestraint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DihedralRestraint_exposer.def( "__str__", &__str__< ::SireMM::DihedralRestraint > );
DihedralRestraint_exposer.def( "__repr__", &__str__< ::SireMM::DihedralRestraint > );
}
}
void register_AtomMultiMatcher_class(){
{ //::SireMol::AtomMultiMatcher
typedef bp::class_< SireMol::AtomMultiMatcher, bp::bases< SireMol::AtomMatcher, SireBase::Property > > AtomMultiMatcher_exposer_t;
AtomMultiMatcher_exposer_t AtomMultiMatcher_exposer = AtomMultiMatcher_exposer_t( "AtomMultiMatcher", "This is an atom matcher combines several sub-AtomMatchers together\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope AtomMultiMatcher_scope( AtomMultiMatcher_exposer );
AtomMultiMatcher_exposer.def( bp::init< SireMol::AtomMatcher const & >(( bp::arg("matcher") ), "Construct from a single match") );
AtomMultiMatcher_exposer.def( bp::init< SireMol::AtomMatcher const &, SireMol::AtomMatcher const & >(( bp::arg("m0"), bp::arg("m1") ), "Construct from a pair of matches") );
AtomMultiMatcher_exposer.def( bp::init< SireMol::AtomMultiMatcher const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMol::AtomMultiMatcher::isNull
typedef bool ( ::SireMol::AtomMultiMatcher::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireMol::AtomMultiMatcher::isNull );
AtomMultiMatcher_exposer.def(
"isNull"
, isNull_function_value
, "Return whether or not this matcher is null (cannot be used for matching)" );
}
AtomMultiMatcher_exposer.def( bp::self != bp::self );
{ //::SireMol::AtomMultiMatcher::operator=
typedef ::SireMol::AtomMultiMatcher & ( ::SireMol::AtomMultiMatcher::*assign_function_type)( ::SireMol::AtomMultiMatcher const & ) ;
assign_function_type assign_function_value( &::SireMol::AtomMultiMatcher::operator= );
AtomMultiMatcher_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
AtomMultiMatcher_exposer.def( bp::self == bp::self );
{ //::SireMol::AtomMultiMatcher::toString
typedef ::QString ( ::SireMol::AtomMultiMatcher::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::AtomMultiMatcher::toString );
AtomMultiMatcher_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireMol::AtomMultiMatcher::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::AtomMultiMatcher::typeName );
AtomMultiMatcher_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMol::AtomMultiMatcher::what
typedef char const * ( ::SireMol::AtomMultiMatcher::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMol::AtomMultiMatcher::what );
AtomMultiMatcher_exposer.def(
"what"
, what_function_value
, "" );
}
AtomMultiMatcher_exposer.staticmethod( "typeName" );
AtomMultiMatcher_exposer.def( "__copy__", &__copy__);
AtomMultiMatcher_exposer.def( "__deepcopy__", &__copy__);
AtomMultiMatcher_exposer.def( "clone", &__copy__);
AtomMultiMatcher_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::AtomMultiMatcher >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AtomMultiMatcher_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::AtomMultiMatcher >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AtomMultiMatcher_exposer.def( "__str__", &__str__< ::SireMol::AtomMultiMatcher > );
AtomMultiMatcher_exposer.def( "__repr__", &__str__< ::SireMol::AtomMultiMatcher > );
}
}
void register_ExBase_class(){
{ //::SireCAS::ExBase
typedef bp::class_< SireCAS::ExBase, boost::noncopyable > ExBase_exposer_t;
ExBase_exposer_t ExBase_exposer = ExBase_exposer_t( "ExBase", "\nPure-virtual base class of all of the parts of mathematical expressions.\n\nThis class provides the atom of SireCAS. ExBase objects are combined together\nto form complete expressions. All constants, functions and symbols are derived\nfrom this object.\n\nThis class is an example of an implicitly shared, self-managed object, and\nis designed so that it can be held by SharedPolyPointer (indeed,\nExpressionBase is just a proxy for SharedPolyPointer<ExBase>).\n\nAuthor: Christopher Woods\n", bp::no_init );
bp::scope ExBase_scope( ExBase_exposer );
{ //::SireCAS::ExBase::children
typedef ::SireCAS::Expressions ( ::SireCAS::ExBase::*children_function_type)( ) const;
children_function_type children_function_value( &::SireCAS::ExBase::children );
ExBase_exposer.def(
"children"
, children_function_value
, "Return the child expressions of this Expression" );
}
{ //::SireCAS::ExBase::conjugate
typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*conjugate_function_type)( ) const;
conjugate_function_type conjugate_function_value( &::SireCAS::ExBase::conjugate );
ExBase_exposer.def(
"conjugate"
, conjugate_function_value
, "Return the complex conjugate of this expression" );
}
{ //::SireCAS::ExBase::differentiate
typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*differentiate_function_type)( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireCAS::ExBase::differentiate );
ExBase_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") )
, "Return an expression that the differential of this ExBase\nwith respect to symbol. Note an exception may\nbe thrown if this ExBase cannot be differentiated.\nThrow: SireCAS::unavailable_differential\n" );
}
{ //::SireCAS::ExBase::evaluate
typedef double ( ::SireCAS::ExBase::*evaluate_function_type)( ::SireCAS::Values const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::ExBase::evaluate );
ExBase_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") )
, "Evaluate this ExBase using values values. Any\nmissing symbols are assumed to equal zero.\n\nNote that an exception will be thrown if the result of the\nevaluation of this, or one of its children, is complex.\n\nThrow: SireMaths::domain_error\n" );
}
{ //::SireCAS::ExBase::evaluate
typedef ::SireMaths::Complex ( ::SireCAS::ExBase::*evaluate_function_type)( ::SireCAS::ComplexValues const & ) const;
evaluate_function_type evaluate_function_value( &::SireCAS::ExBase::evaluate );
ExBase_exposer.def(
"evaluate"
, evaluate_function_value
, ( bp::arg("values") )
, "Evaluate this ExBase using the complex values values.\nAny missing symbols are assumed to equal zero." );
}
{ //::SireCAS::ExBase::expand
typedef ::QList< SireCAS::Factor > ( ::SireCAS::ExBase::*expand_function_type)( ::SireCAS::Symbol const & ) const;
expand_function_type expand_function_value( &::SireCAS::ExBase::expand );
ExBase_exposer.def(
"expand"
, expand_function_value
, ( bp::arg("symbol") )
, "Rearrange this expression into the form\nm x^i + n x^j + ... + constant\nand return the factors and powers of x\n\nThrow: SireCAS::rearrangement_error\n" );
}
{ //::SireCAS::ExBase::functions
typedef ::SireCAS::Functions ( ::SireCAS::ExBase::*functions_function_type)( ) const;
functions_function_type functions_function_value( &::SireCAS::ExBase::functions );
ExBase_exposer.def(
"functions"
, functions_function_value
, "Return the set of Functions that appear in this ExBase" );
}
{ //::SireCAS::ExBase::hash
typedef ::uint ( ::SireCAS::ExBase::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireCAS::ExBase::hash );
ExBase_exposer.def(
"hash"
, hash_function_value
, "Return a hash of this object - return a combination of the\nidentifying magic for the class and a hash for its contents." );
}
{ //::SireCAS::ExBase::integrate
typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*integrate_function_type)( ::SireCAS::Symbol const & ) const;
integrate_function_type integrate_function_value( &::SireCAS::ExBase::integrate );
ExBase_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("symbol") )
, "Return the indefinite integral of this ExBase with respect to\nsymbol. This is not guaranteed to work() and will return an\nexpression of the form Sum( integral(exbase) + integral_constant ).\nIf it doesnt work then an exception will be throw.\nThrow: SireCAS::unavailable_integral\n" );
}
{ //::SireCAS::ExBase::isComplex
typedef bool ( ::SireCAS::ExBase::*isComplex_function_type)( ) const;
isComplex_function_type isComplex_function_value( &::SireCAS::ExBase::isComplex );
ExBase_exposer.def(
"isComplex"
, isComplex_function_value
, "Return whether or not this expression contains any complex (imaginary)\nparts" );
}
{ //::SireCAS::ExBase::isCompound
typedef bool ( ::SireCAS::ExBase::*isCompound_function_type)( ) const;
isCompound_function_type isCompound_function_value( &::SireCAS::ExBase::isCompound );
ExBase_exposer.def(
"isCompound"
, isCompound_function_value
, "Return whether or not this is a compound expression, and thus as such\nrequires brackets placed around it when it is printed. Examples include\nSum, Product and Power. For most other functions it is safe to leave\nthis as false." );
}
{ //::SireCAS::ExBase::isConstant
typedef bool ( ::SireCAS::ExBase::*isConstant_function_type)( ) const;
isConstant_function_type isConstant_function_value( &::SireCAS::ExBase::isConstant );
ExBase_exposer.def(
"isConstant"
, isConstant_function_value
, "Return whether or not this is a constant expression (does not\ndepend on any symbols)" );
}
{ //::SireCAS::ExBase::isFunction
typedef bool ( ::SireCAS::ExBase::*isFunction_function_type)( ::SireCAS::Symbol const & ) const;
isFunction_function_type isFunction_function_value( &::SireCAS::ExBase::isFunction );
ExBase_exposer.def(
"isFunction"
, isFunction_function_value
, ( bp::arg("arg0") )
, "Return whether or not this is a function of the passed Symbol" );
}
ExBase_exposer.def( bp::self != bp::self );
ExBase_exposer.def( -bp::self );
{ //::SireCAS::ExBase::operator=
typedef ::SireCAS::ExBase & ( ::SireCAS::ExBase::*assign_function_type)( ::SireCAS::ExBase const & ) ;
assign_function_type assign_function_value( &::SireCAS::ExBase::operator= );
ExBase_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("arg0") )
, bp::return_self< >()
, "Assignment operator" );
}
ExBase_exposer.def( bp::self == bp::self );
{ //::SireCAS::ExBase::series
typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*series_function_type)( ::SireCAS::Symbol const &,int ) const;
series_function_type series_function_value( &::SireCAS::ExBase::series );
ExBase_exposer.def(
"series"
, series_function_value
, ( bp::arg("symbol"), bp::arg("n") )
, "Return a series expansion of this expression with respect to\nsymbol, if possible, to order\nn. This is not guaranteed to work, and will return this expression\nunchanged if it doesnt work. If it is expanded, then a series\nwill be returned, together with an estimate of the error (e.g. O(x^2))" );
}
{ //::SireCAS::ExBase::simplify
typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*simplify_function_type)( int ) const;
simplify_function_type simplify_function_value( &::SireCAS::ExBase::simplify );
ExBase_exposer.def(
"simplify"
, simplify_function_value
, ( bp::arg("options")=(int)(0) )
, "Try to simplify this expression. This will try to use known mathematical\nidentities to convert complex expressions down to more simple ones.\nIf SireCAS::UNSAFE_COMPLEX_SIMPLIFICATIONS is true, then identities\nthat are not safe for complex math are used, e.g. z = sin(arcsin(z))." );
}
{ //::SireCAS::ExBase::substitute
typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*substitute_function_type)( ::SireCAS::Identities const & ) const;
substitute_function_type substitute_function_value( &::SireCAS::ExBase::substitute );
ExBase_exposer.def(
"substitute"
, substitute_function_value
, ( bp::arg("identities") )
, "Return an expression that has the identities in identities\nsubstituted into this expression" );
}
{ //::SireCAS::ExBase::symbols
typedef ::SireCAS::Symbols ( ::SireCAS::ExBase::*symbols_function_type)( ) const;
symbols_function_type symbols_function_value( &::SireCAS::ExBase::symbols );
ExBase_exposer.def(
"symbols"
, symbols_function_value
, "Return the set of Symbols that appear in this ExBase" );
}
{ //::SireCAS::ExBase::toOpenMMString
typedef ::QString ( ::SireCAS::ExBase::*toOpenMMString_function_type)( ) const;
toOpenMMString_function_type toOpenMMString_function_value( &::SireCAS::ExBase::toOpenMMString );
ExBase_exposer.def(
"toOpenMMString"
, toOpenMMString_function_value
, "Return a string representation of this object in the OpenMM syntax" );
}
{ //::SireCAS::ExBase::toString
typedef ::QString ( ::SireCAS::ExBase::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireCAS::ExBase::toString );
ExBase_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this object" );
}
{ //::SireCAS::ExBase::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireCAS::ExBase::typeName );
ExBase_exposer.def(
"typeName"
, typeName_function_value
, "Return the name of this class type" );
}
{ //::SireCAS::ExBase::what
typedef char const * ( ::SireCAS::ExBase::*what_function_type)( ) const;
what_function_type what_function_value( &::SireCAS::ExBase::what );
ExBase_exposer.def(
"what"
, what_function_value
, "Return the name of the type of this ExBase object" );
}
ExBase_exposer.staticmethod( "typeName" );
ExBase_exposer.def( bp::self * bp::self );
ExBase_exposer.def( bp::self * bp::other< SireCAS::Expression >() );
ExBase_exposer.def( bp::self * bp::other< double >() );
ExBase_exposer.def( bp::other< double >() * bp::self );
ExBase_exposer.def( bp::self * bp::other< SireMaths::Complex >() );
ExBase_exposer.def( bp::self + bp::self );
ExBase_exposer.def( bp::self + bp::other< SireCAS::Expression >() );
ExBase_exposer.def( bp::self + bp::other< double >() );
ExBase_exposer.def( bp::other< double >() + bp::self );
ExBase_exposer.def( bp::self + bp::other< SireMaths::Complex >() );
ExBase_exposer.def( bp::self - bp::self );
ExBase_exposer.def( bp::self - bp::other< SireCAS::Expression >() );
ExBase_exposer.def( bp::self - bp::other< double >() );
ExBase_exposer.def( bp::other< double >() - bp::self );
ExBase_exposer.def( bp::self - bp::other< SireMaths::Complex >() );
ExBase_exposer.def( bp::self / bp::self );
ExBase_exposer.def( bp::self / bp::other< SireCAS::Expression >() );
ExBase_exposer.def( bp::self / bp::other< double >() );
ExBase_exposer.def( bp::other< double >() / bp::self );
ExBase_exposer.def( bp::self / bp::other< SireMaths::Complex >() );
ExBase_exposer.def( self + self );
ExBase_exposer.def( self - self );
ExBase_exposer.def( self * self );
ExBase_exposer.def( self / self );
ExBase_exposer.def( other<double>() + self );
ExBase_exposer.def( other<double>() - self );
ExBase_exposer.def( other<double>() * self );
ExBase_exposer.def( other<double>() / self );
ExBase_exposer.def( self + other<double>() );
ExBase_exposer.def( self - other<double>() );
ExBase_exposer.def( self * other<double>() );
ExBase_exposer.def( self / other<double>() );
ExBase_exposer.def( other<SireMaths::Complex>() + self );
ExBase_exposer.def( other<SireMaths::Complex>() - self );
ExBase_exposer.def( other<SireMaths::Complex>() * self );
ExBase_exposer.def( other<SireMaths::Complex>() / self );
ExBase_exposer.def( self + other<SireMaths::Complex>() );
ExBase_exposer.def( self - other<SireMaths::Complex>() );
ExBase_exposer.def( self * other<SireMaths::Complex>() );
ExBase_exposer.def( self / other<SireMaths::Complex>() );
ExBase_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::ExBase >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ExBase_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::ExBase >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ExBase_exposer.def( "__str__", &__str__< ::SireCAS::ExBase > );
ExBase_exposer.def( "__repr__", &__str__< ::SireCAS::ExBase > );
ExBase_exposer.def( "__hash__", &::SireCAS::ExBase::hash );
}
}
void register_CoordGroupArray_class(){
{ //::SireVol::CoordGroupArray
typedef bp::class_< SireVol::CoordGroupArray > CoordGroupArray_exposer_t;
CoordGroupArray_exposer_t CoordGroupArray_exposer = CoordGroupArray_exposer_t( "CoordGroupArray", "This class holds an array of CoordGroups. While you could\nof course just use a QVector<CoordGroup>, this array\noptimises the memory layout of all of the CoordGroups\nso that they all lie contiguously along the same piece\nof memory (and indeed, all of the AABoxes are grouped\ntogether, while all of the coordinates are grouped together).\n\nThe memory packing means that this array is much more\nlimited than a QVector<CoordGroup>, i.e. you cant\nadd or remove CoordGroups from the array, and you cant\ndo anything to the contained CoordGroups except for\nchange their coordinates.\n\nThis class is really meant to be used as a fast container\nthat allow rapid iteration over all of the contained\nCoordGroups coordinates\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope CoordGroupArray_scope( CoordGroupArray_exposer );
CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroup const & >(( bp::arg("cgroup") ), "Construct an array that holds just the passed CoordGroup") );
CoordGroupArray_exposer.def( bp::init< QVector< QVector< SireMaths::Vector > > const & >(( bp::arg("points") ), "Construct from a double-vector") );
CoordGroupArray_exposer.def( bp::init< QVector< SireVol::CoordGroup > const & >(( bp::arg("cgroups") ), "Construct from an array of CoordGroups") );
CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroupArray const &, SireVol::CoordGroupArray const & >(( bp::arg("array0"), bp::arg("array1") ), "Construct from a pair of CoordGroupArrays") );
CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireVol::CoordGroupArray::aaBox
typedef ::SireVol::AABox ( ::SireVol::CoordGroupArray::*aaBox_function_type)( ) const;
aaBox_function_type aaBox_function_value( &::SireVol::CoordGroupArray::aaBox );
CoordGroupArray_exposer.def(
"aaBox"
, aaBox_function_value
, "Return an AABox that complete encompasses all of the CoordGroups\nin this array" );
}
{ //::SireVol::CoordGroupArray::append
typedef void ( ::SireVol::CoordGroupArray::*append_function_type)( ::SireVol::CoordGroup const & ) ;
append_function_type append_function_value( &::SireVol::CoordGroupArray::append );
CoordGroupArray_exposer.def(
"append"
, append_function_value
, ( bp::arg("cgroup") )
, "Append the passed CoordGroup onto the end of this array" );
}
{ //::SireVol::CoordGroupArray::append
typedef void ( ::SireVol::CoordGroupArray::*append_function_type)( ::SireVol::CoordGroupArray const & ) ;
append_function_type append_function_value( &::SireVol::CoordGroupArray::append );
CoordGroupArray_exposer.def(
"append"
, append_function_value
, ( bp::arg("cgroups") )
, "Append the passed CoordGroups onto the end of this array" );
}
{ //::SireVol::CoordGroupArray::assertValidCoordGroup
typedef void ( ::SireVol::CoordGroupArray::*assertValidCoordGroup_function_type)( ::quint32 ) const;
assertValidCoordGroup_function_type assertValidCoordGroup_function_value( &::SireVol::CoordGroupArray::assertValidCoordGroup );
CoordGroupArray_exposer.def(
"assertValidCoordGroup"
, assertValidCoordGroup_function_value
, ( bp::arg("i") )
, "Assert that the index i points to a valid CoordGroup\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::assertValidCoordinate
typedef void ( ::SireVol::CoordGroupArray::*assertValidCoordinate_function_type)( ::quint32 ) const;
assertValidCoordinate_function_type assertValidCoordinate_function_value( &::SireVol::CoordGroupArray::assertValidCoordinate );
CoordGroupArray_exposer.def(
"assertValidCoordinate"
, assertValidCoordinate_function_value
, ( bp::arg("i") )
, "Assert that the index i points a valid coordinate\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::assertValidIndex
typedef void ( ::SireVol::CoordGroupArray::*assertValidIndex_function_type)( ::quint32 ) const;
assertValidIndex_function_type assertValidIndex_function_value( &::SireVol::CoordGroupArray::assertValidIndex );
CoordGroupArray_exposer.def(
"assertValidIndex"
, assertValidIndex_function_value
, ( bp::arg("i") )
, "Assert that the index i points to a valid CoordGroup\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::at
typedef ::SireVol::CoordGroup const & ( ::SireVol::CoordGroupArray::*at_function_type)( ::quint32 ) const;
at_function_type at_function_value( &::SireVol::CoordGroupArray::at );
CoordGroupArray_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "Return a reference to the ith CoordGroup\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::changeFrame
typedef void ( ::SireVol::CoordGroupArray::*changeFrame_function_type)( ::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
changeFrame_function_type changeFrame_function_value( &::SireVol::CoordGroupArray::changeFrame );
CoordGroupArray_exposer.def(
"changeFrame"
, changeFrame_function_value
, ( bp::arg("from_frame"), bp::arg("to_frame") )
, "Change all of the coordinates in this array from the\ncoordinate frame from_frame to the coordinate frame to_frame" );
}
{ //::SireVol::CoordGroupArray::changeFrame
typedef void ( ::SireVol::CoordGroupArray::*changeFrame_function_type)( ::quint32,::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
changeFrame_function_type changeFrame_function_value( &::SireVol::CoordGroupArray::changeFrame );
CoordGroupArray_exposer.def(
"changeFrame"
, changeFrame_function_value
, ( bp::arg("i"), bp::arg("from_frame"), bp::arg("to_frame") )
, "Change all of the coordinates in the ith CoordGroup from\nthe coordinate frame from_frame to the coordinate frame\nto_frame\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::count
typedef int ( ::SireVol::CoordGroupArray::*count_function_type)( ) const;
count_function_type count_function_value( &::SireVol::CoordGroupArray::count );
CoordGroupArray_exposer.def(
"count"
, count_function_value
, "Return the number of CoordGroups in this array" );
}
{ //::SireVol::CoordGroupArray::isEmpty
typedef bool ( ::SireVol::CoordGroupArray::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireVol::CoordGroupArray::isEmpty );
CoordGroupArray_exposer.def(
"isEmpty"
, isEmpty_function_value
, "Return whether or not this array is empty" );
}
{ //::SireVol::CoordGroupArray::mapInto
typedef void ( ::SireVol::CoordGroupArray::*mapInto_function_type)( ::SireMaths::AxisSet const & ) ;
mapInto_function_type mapInto_function_value( &::SireVol::CoordGroupArray::mapInto );
CoordGroupArray_exposer.def(
"mapInto"
, mapInto_function_value
, ( bp::arg("axes") )
, "Map all of the coordinates in this array into the coordinate\nframe represented by axes" );
}
{ //::SireVol::CoordGroupArray::mapInto
typedef void ( ::SireVol::CoordGroupArray::*mapInto_function_type)( ::quint32,::SireMaths::AxisSet const & ) ;
mapInto_function_type mapInto_function_value( &::SireVol::CoordGroupArray::mapInto );
CoordGroupArray_exposer.def(
"mapInto"
, mapInto_function_value
, ( bp::arg("i"), bp::arg("axes") )
, "Map all of the coordinates of the CoordGroup at index i\ninto the coordinate frame represented by axes\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::merge
typedef ::SireVol::CoordGroup ( ::SireVol::CoordGroupArray::*merge_function_type)( ) const;
merge_function_type merge_function_value( &::SireVol::CoordGroupArray::merge );
CoordGroupArray_exposer.def(
"merge"
, merge_function_value
, "Merge this array of CoordGroups back into a single CoordGroup" );
}
{ //::SireVol::CoordGroupArray::nCoordGroups
typedef int ( ::SireVol::CoordGroupArray::*nCoordGroups_function_type)( ) const;
nCoordGroups_function_type nCoordGroups_function_value( &::SireVol::CoordGroupArray::nCoordGroups );
CoordGroupArray_exposer.def(
"nCoordGroups"
, nCoordGroups_function_value
, "Return the number of CoordGroups in this array" );
}
{ //::SireVol::CoordGroupArray::nCoords
typedef int ( ::SireVol::CoordGroupArray::*nCoords_function_type)( ) const;
nCoords_function_type nCoords_function_value( &::SireVol::CoordGroupArray::nCoords );
CoordGroupArray_exposer.def(
"nCoords"
, nCoords_function_value
, "Return the number of coordinates in this array" );
}
CoordGroupArray_exposer.def( bp::self != bp::self );
{ //::SireVol::CoordGroupArray::operator=
typedef ::SireVol::CoordGroupArray & ( ::SireVol::CoordGroupArray::*assign_function_type)( ::SireVol::CoordGroupArray const & ) ;
assign_function_type assign_function_value( &::SireVol::CoordGroupArray::operator= );
CoordGroupArray_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
CoordGroupArray_exposer.def( bp::self == bp::self );
{ //::SireVol::CoordGroupArray::operator[]
typedef ::SireVol::CoordGroup const & ( ::SireVol::CoordGroupArray::*__getitem___function_type)( ::quint32 ) const;
__getitem___function_type __getitem___function_value( &::SireVol::CoordGroupArray::operator[] );
CoordGroupArray_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireVol::CoordGroupArray::remove
typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::quint32 ) ;
remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove );
CoordGroupArray_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i") )
, "Remove the ith CoordGroup from the array" );
}
{ //::SireVol::CoordGroupArray::remove
typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::quint32,int ) ;
remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove );
CoordGroupArray_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i"), bp::arg("count") )
, "Remove count CoordGroups from the array, starting with the ith CoordGroup" );
}
{ //::SireVol::CoordGroupArray::remove
typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::QVarLengthArray< unsigned int, 256 > const & ) ;
remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove );
CoordGroupArray_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("idxs") )
, "Remove the specified CoordGroups from the array" );
}
{ //::SireVol::CoordGroupArray::rotate
typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
CoordGroupArray_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("quat"), bp::arg("point") )
, "Rotate all of the coordinates in this array using the quaternion\nquat around the point point" );
}
{ //::SireVol::CoordGroupArray::rotate
typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
CoordGroupArray_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("rotmat"), bp::arg("point") )
, "Rotate all of coordinates in this array using the matrix rotmat\nabout the point point" );
}
{ //::SireVol::CoordGroupArray::rotate
typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::quint32,::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
CoordGroupArray_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("i"), bp::arg("quat"), bp::arg("point") )
, "Rotate all of the coordinates in the CoordGroup at index i using\nthe quaternion quat about the point point\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::rotate
typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::quint32,::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
CoordGroupArray_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("i"), bp::arg("rotmat"), bp::arg("point") )
, "Rotate all of the coordinates in the CoordGroup at index i using\nthe matrix rotmat about the point point\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::size
typedef int ( ::SireVol::CoordGroupArray::*size_function_type)( ) const;
size_function_type size_function_value( &::SireVol::CoordGroupArray::size );
CoordGroupArray_exposer.def(
"size"
, size_function_value
, "Return the number of CoordGroups in this array" );
}
{ //::SireVol::CoordGroupArray::toString
typedef ::QString ( ::SireVol::CoordGroupArray::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireVol::CoordGroupArray::toString );
CoordGroupArray_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this array" );
}
{ //::SireVol::CoordGroupArray::transform
typedef void ( ::SireVol::CoordGroupArray::*transform_function_type)( ::SireMaths::Transform const & ) ;
transform_function_type transform_function_value( &::SireVol::CoordGroupArray::transform );
CoordGroupArray_exposer.def(
"transform"
, transform_function_value
, ( bp::arg("t") )
, "Transform all of coordinates in this array using the transformation t" );
}
{ //::SireVol::CoordGroupArray::transform
typedef void ( ::SireVol::CoordGroupArray::*transform_function_type)( ::quint32,::SireMaths::Transform const & ) ;
transform_function_type transform_function_value( &::SireVol::CoordGroupArray::transform );
CoordGroupArray_exposer.def(
"transform"
, transform_function_value
, ( bp::arg("i"), bp::arg("t") )
, "Transform all of the coordinates in the CoordGroup at index i using\nthe transformation t\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::translate
typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::SireMaths::Vector const & ) ;
translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate );
CoordGroupArray_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("delta") )
, "Translate all of the coordinates in this array by delta" );
}
{ //::SireVol::CoordGroupArray::translate
typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::quint32,::SireMaths::Vector const & ) ;
translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate );
CoordGroupArray_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("i"), bp::arg("delta") )
, "Translate all of the coordinates in the ith CoordGroup by delta" );
}
{ //::SireVol::CoordGroupArray::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireVol::CoordGroupArray::typeName );
CoordGroupArray_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireVol::CoordGroupArray::update
typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireVol::CoordGroup const & ) ;
update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
CoordGroupArray_exposer.def(
"update"
, update_function_value
, ( bp::arg("i"), bp::arg("cgroup") )
, "Update the CoordGroup at index i so that it is equal to cgroup. Note\nthat cgroup must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
}
{ //::SireVol::CoordGroupArray::update
typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::QVector< SireMaths::Vector > const & ) ;
update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
CoordGroupArray_exposer.def(
"update"
, update_function_value
, ( bp::arg("i"), bp::arg("coords") )
, "Update the CoordGroup at index i so that it has coordinates coords\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
}
{ //::SireVol::CoordGroupArray::update
typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireMaths::Vector const *,int ) ;
update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
CoordGroupArray_exposer.def(
"update"
, update_function_value
, ( bp::arg("i"), bp::arg("coords"), bp::arg("ncoords") )
, "Update the CoordGroup at index i so that it has coordinates coords\n(there are ncoords coordinates in this array)\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
}
{ //::SireVol::CoordGroupArray::what
typedef char const * ( ::SireVol::CoordGroupArray::*what_function_type)( ) const;
what_function_type what_function_value( &::SireVol::CoordGroupArray::what );
CoordGroupArray_exposer.def(
"what"
, what_function_value
, "" );
}
CoordGroupArray_exposer.staticmethod( "typeName" );
CoordGroupArray_exposer.def( "__copy__", &__copy__);
CoordGroupArray_exposer.def( "__deepcopy__", &__copy__);
CoordGroupArray_exposer.def( "clone", &__copy__);
CoordGroupArray_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::CoordGroupArray >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CoordGroupArray_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::CoordGroupArray >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CoordGroupArray_exposer.def( "__str__", &__str__< ::SireVol::CoordGroupArray > );
CoordGroupArray_exposer.def( "__repr__", &__str__< ::SireVol::CoordGroupArray > );
CoordGroupArray_exposer.def( "__len__", &__len_size< ::SireVol::CoordGroupArray > );
}
}
void register_InterGroupLJFF_class() {
{ //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >
typedef bp::class_< SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >, bp::bases< SireFF::FF3D, SireFF::Inter2B2GFF<SireMM::LJPotentialInterface<SireMM::InterLJPotential> >, SireMM::LJPotentialInterface<SireMM::InterLJPotential>, SireFF::G2FF, SireFF::FF, SireMol::MolGroupsBase, SireBase::Property > > InterGroupLJFF_exposer_t;
InterGroupLJFF_exposer_t InterGroupLJFF_exposer = InterGroupLJFF_exposer_t( "InterGroupLJFF", bp::init< >() );
bp::scope InterGroupLJFF_scope( InterGroupLJFF_exposer );
InterGroupLJFF_exposer.def( bp::init< QString const & >(( bp::arg("name") )) );
InterGroupLJFF_exposer.def( bp::init< SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > const & >(( bp::arg("other") )) );
{ //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::energy
typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*energy_function_type )( ::SireFF::EnergyTable &,double ) ;
energy_function_type energy_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::energy );
InterGroupLJFF_exposer.def(
"energy"
, energy_function_value
, ( bp::arg("energytable"), bp::arg("scale_energy")=1 ) );
}
{ //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::energy
typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*energy_function_type )( ::SireFF::EnergyTable &,::SireCAS::Symbol const &,double ) ;
energy_function_type energy_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::energy );
InterGroupLJFF_exposer.def(
"energy"
, energy_function_value
, ( bp::arg("energytable"), bp::arg("symbol"), bp::arg("scale_energy")=1 ) );
}
{ //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field
typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*field_function_type )( ::SireFF::FieldTable &,double ) ;
field_function_type field_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field );
InterGroupLJFF_exposer.def(
"field"
, field_function_value
, ( bp::arg("fieldtable"), bp::arg("scale_field")=1 ) );
}
{ //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field
typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,double ) ;
field_function_type field_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field );
InterGroupLJFF_exposer.def(
"field"
, field_function_value
, ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("scale_field")=1 ) );
}
{ //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field
typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*field_function_type )( ::SireFF::FieldTable &,::SireFF::Probe const &,double ) ;
field_function_type field_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field );
InterGroupLJFF_exposer.def(
"field"
, field_function_value
, ( bp::arg("fieldtable"), bp::arg("probe"), bp::arg("scale_field")=1 ) );
}
{ //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field
typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ;
field_function_type field_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::field );
InterGroupLJFF_exposer.def(
"field"
, field_function_value
, ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_field")=1 ) );
}
{ //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::force
typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*force_function_type )( ::SireFF::ForceTable &,double ) ;
force_function_type force_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::force );
InterGroupLJFF_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) );
}
{ //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::force
typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*force_function_type )( ::SireFF::ForceTable &,::SireCAS::Symbol const &,double ) ;
force_function_type force_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::force );
InterGroupLJFF_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("symbol"), bp::arg("scale_force")=1 ) );
}
InterGroupLJFF_exposer.def( bp::self != bp::self );
{ //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::operator=
typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
typedef ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > & ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*assign_function_type )( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > const & ) ;
assign_function_type assign_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::operator= );
InterGroupLJFF_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
InterGroupLJFF_exposer.def( bp::self == bp::self );
{ //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential
typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,double ) ;
potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential );
InterGroupLJFF_exposer.def(
"potential"
, potential_function_value
, ( bp::arg("potentialtable"), bp::arg("scale_potential")=1 ) );
}
{ //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential
typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,double ) ;
potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential );
InterGroupLJFF_exposer.def(
"potential"
, potential_function_value
, ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("scale_potential")=1 ) );
}
{ //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential
typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,::SireFF::Probe const &,double ) ;
potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential );
InterGroupLJFF_exposer.def(
"potential"
, potential_function_value
, ( bp::arg("potentialtable"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );
}
{ //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential
typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
typedef void ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ;
potential_function_type potential_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::potential );
InterGroupLJFF_exposer.def(
"potential"
, potential_function_value
, ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );
}
{ //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::typeName
typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::typeName );
InterGroupLJFF_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::what
typedef SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > > exported_class_t;
typedef char const * ( ::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::*what_function_type )( ) const;
what_function_type what_function_value( &::SireFF::Inter2B2G3DFF< SireMM::LJPotentialInterface< SireMM::InterLJPotential > >::what );
InterGroupLJFF_exposer.def(
"what"
, what_function_value );
}
InterGroupLJFF_exposer.staticmethod( "typeName" );
InterGroupLJFF_exposer.def( "__copy__", &__copy__);
InterGroupLJFF_exposer.def( "__deepcopy__", &__copy__);
InterGroupLJFF_exposer.def( "clone", &__copy__);
InterGroupLJFF_exposer.def( "__str__", &__str__< ::SireFF::Inter2B2G3DFF<SireMM::LJPotentialInterface<SireMM::InterLJPotential> > > );
InterGroupLJFF_exposer.def( "__repr__", &__str__< ::SireFF::Inter2B2G3DFF<SireMM::LJPotentialInterface<SireMM::InterLJPotential> > > );
InterGroupLJFF_exposer.def( "__len__", &__len_count< ::SireFF::Inter2B2G3DFF<SireMM::LJPotentialInterface<SireMM::InterLJPotential> > > );
}
}
void register_GeneralUnit_class(){
{ //::SireUnits::Dimension::GeneralUnit
typedef bp::class_< SireUnits::Dimension::GeneralUnit, bp::bases< SireUnits::Dimension::Unit > > GeneralUnit_exposer_t;
GeneralUnit_exposer_t GeneralUnit_exposer = GeneralUnit_exposer_t( "GeneralUnit", bp::init< >() );
bp::scope GeneralUnit_scope( GeneralUnit_exposer );
GeneralUnit_exposer.def( bp::init< SireUnits::Dimension::GeneralUnit const & >(( bp::arg("other") )) );
{ //::SireUnits::Dimension::GeneralUnit::ANGLE
typedef int ( ::SireUnits::Dimension::GeneralUnit::*ANGLE_function_type )( ) const;
ANGLE_function_type ANGLE_function_value( &::SireUnits::Dimension::GeneralUnit::ANGLE );
GeneralUnit_exposer.def(
"ANGLE"
, ANGLE_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::CHARGE
typedef int ( ::SireUnits::Dimension::GeneralUnit::*CHARGE_function_type )( ) const;
CHARGE_function_type CHARGE_function_value( &::SireUnits::Dimension::GeneralUnit::CHARGE );
GeneralUnit_exposer.def(
"CHARGE"
, CHARGE_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::LENGTH
typedef int ( ::SireUnits::Dimension::GeneralUnit::*LENGTH_function_type )( ) const;
LENGTH_function_type LENGTH_function_value( &::SireUnits::Dimension::GeneralUnit::LENGTH );
GeneralUnit_exposer.def(
"LENGTH"
, LENGTH_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::MASS
typedef int ( ::SireUnits::Dimension::GeneralUnit::*MASS_function_type )( ) const;
MASS_function_type MASS_function_value( &::SireUnits::Dimension::GeneralUnit::MASS );
GeneralUnit_exposer.def(
"MASS"
, MASS_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::QUANTITY
typedef int ( ::SireUnits::Dimension::GeneralUnit::*QUANTITY_function_type )( ) const;
QUANTITY_function_type QUANTITY_function_value( &::SireUnits::Dimension::GeneralUnit::QUANTITY );
GeneralUnit_exposer.def(
"QUANTITY"
, QUANTITY_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::TEMPERATURE
typedef int ( ::SireUnits::Dimension::GeneralUnit::*TEMPERATURE_function_type )( ) const;
TEMPERATURE_function_type TEMPERATURE_function_value( &::SireUnits::Dimension::GeneralUnit::TEMPERATURE );
GeneralUnit_exposer.def(
"TEMPERATURE"
, TEMPERATURE_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::TIME
typedef int ( ::SireUnits::Dimension::GeneralUnit::*TIME_function_type )( ) const;
TIME_function_type TIME_function_value( &::SireUnits::Dimension::GeneralUnit::TIME );
GeneralUnit_exposer.def(
"TIME"
, TIME_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::invert
typedef ::SireUnits::Dimension::GeneralUnit ( ::SireUnits::Dimension::GeneralUnit::*invert_function_type )( ) const;
invert_function_type invert_function_value( &::SireUnits::Dimension::GeneralUnit::invert );
GeneralUnit_exposer.def(
"invert"
, invert_function_value );
}
GeneralUnit_exposer.def( bp::self != bp::self );
GeneralUnit_exposer.def( bp::self * bp::self );
GeneralUnit_exposer.def( bp::self * bp::other< double >() );
GeneralUnit_exposer.def( bp::self * bp::other< int >() );
GeneralUnit_exposer.def( bp::self *= bp::self );
GeneralUnit_exposer.def( bp::self + bp::self );
GeneralUnit_exposer.def( -bp::self );
GeneralUnit_exposer.def( bp::self - bp::self );
GeneralUnit_exposer.def( bp::self / bp::self );
GeneralUnit_exposer.def( bp::self / bp::other< double >() );
GeneralUnit_exposer.def( bp::self / bp::other< int >() );
GeneralUnit_exposer.def( bp::self /= bp::self );
{ //::SireUnits::Dimension::GeneralUnit::operator=
typedef ::SireUnits::Dimension::GeneralUnit & ( ::SireUnits::Dimension::GeneralUnit::*assign_function_type )( ::SireUnits::Dimension::GeneralUnit const & ) ;
assign_function_type assign_function_value( &::SireUnits::Dimension::GeneralUnit::operator= );
GeneralUnit_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
GeneralUnit_exposer.def( bp::self == bp::self );
{ //::SireUnits::Dimension::GeneralUnit::to
typedef double ( ::SireUnits::Dimension::GeneralUnit::*to_function_type )( ::SireUnits::Dimension::TempBase const & ) const;
to_function_type to_function_value( &::SireUnits::Dimension::GeneralUnit::to );
GeneralUnit_exposer.def(
"to"
, to_function_value
, ( bp::arg("other") ) );
}
{ //::SireUnits::Dimension::GeneralUnit::to
typedef double ( ::SireUnits::Dimension::GeneralUnit::*to_function_type )( ::SireUnits::Dimension::GeneralUnit const & ) const;
to_function_type to_function_value( &::SireUnits::Dimension::GeneralUnit::to );
GeneralUnit_exposer.def(
"to"
, to_function_value
, ( bp::arg("other") ) );
}
{ //::SireUnits::Dimension::GeneralUnit::toString
typedef ::QString ( ::SireUnits::Dimension::GeneralUnit::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireUnits::Dimension::GeneralUnit::toString );
GeneralUnit_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::typeName
typedef ::QString ( ::SireUnits::Dimension::GeneralUnit::*typeName_function_type )( ) const;
typeName_function_type typeName_function_value( &::SireUnits::Dimension::GeneralUnit::typeName );
GeneralUnit_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireUnits::Dimension::GeneralUnit::what
typedef ::QString ( ::SireUnits::Dimension::GeneralUnit::*what_function_type )( ) const;
what_function_type what_function_value( &::SireUnits::Dimension::GeneralUnit::what );
GeneralUnit_exposer.def(
"what"
, what_function_value );
}
GeneralUnit_exposer.def( bp::other<double>() * bp::self );
GeneralUnit_exposer.def( bp::other<double>() / bp::self );
GeneralUnit_exposer.def( "__copy__", &__copy__);
GeneralUnit_exposer.def( "__deepcopy__", &__copy__);
GeneralUnit_exposer.def( "clone", &__copy__);
GeneralUnit_exposer.def( "__str__", &__str__< ::SireUnits::Dimension::GeneralUnit > );
GeneralUnit_exposer.def( "__repr__", &__str__< ::SireUnits::Dimension::GeneralUnit > );
}
}
void register_GridInfo_class(){
{ //::SireVol::GridInfo
typedef bp::class_< SireVol::GridInfo > GridInfo_exposer_t;
GridInfo_exposer_t GridInfo_exposer = GridInfo_exposer_t( "GridInfo", bp::init< >() );
bp::scope GridInfo_scope( GridInfo_exposer );
GridInfo_exposer.def( bp::init< SireVol::AABox const &, SireUnits::Dimension::Length >(( bp::arg("dimensions"), bp::arg("spacing") )) );
GridInfo_exposer.def( bp::init< SireVol::GridInfo const & >(( bp::arg("other") )) );
{ //::SireVol::GridInfo::arrayToGridIndex
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*arrayToGridIndex_function_type )( int ) const;
arrayToGridIndex_function_type arrayToGridIndex_function_value( &::SireVol::GridInfo::arrayToGridIndex );
GridInfo_exposer.def(
"arrayToGridIndex"
, arrayToGridIndex_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::at
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::at
typedef int ( ::SireVol::GridInfo::*at_function_type )( ::SireVol::GridIndex const & ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::at
typedef int ( ::SireVol::GridInfo::*at_function_type )( int,int,int ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("k") ) );
}
{ //::SireVol::GridInfo::at
typedef int ( ::SireVol::GridInfo::*at_function_type )( ::SireMaths::Vector const & ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::box
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( int ) const;
box_function_type box_function_value( &::SireVol::GridInfo::box );
GridInfo_exposer.def(
"box"
, box_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::box
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( ::SireVol::GridIndex const & ) const;
box_function_type box_function_value( &::SireVol::GridInfo::box );
GridInfo_exposer.def(
"box"
, box_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::box
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( ::SireMaths::Vector const & ) const;
box_function_type box_function_value( &::SireVol::GridInfo::box );
GridInfo_exposer.def(
"box"
, box_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::closestIndexTo
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*closestIndexTo_function_type )( ::SireMaths::Vector const & ) const;
closestIndexTo_function_type closestIndexTo_function_value( &::SireVol::GridInfo::closestIndexTo );
GridInfo_exposer.def(
"closestIndexTo"
, closestIndexTo_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::contains
typedef bool ( ::SireVol::GridInfo::*contains_function_type )( ::SireMaths::Vector const & ) const;
contains_function_type contains_function_value( &::SireVol::GridInfo::contains );
GridInfo_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::count
typedef int ( ::SireVol::GridInfo::*count_function_type )( ) const;
count_function_type count_function_value( &::SireVol::GridInfo::count );
GridInfo_exposer.def(
"count"
, count_function_value );
}
{ //::SireVol::GridInfo::dimX
typedef ::qint32 ( ::SireVol::GridInfo::*dimX_function_type )( ) const;
dimX_function_type dimX_function_value( &::SireVol::GridInfo::dimX );
GridInfo_exposer.def(
"dimX"
, dimX_function_value );
}
{ //::SireVol::GridInfo::dimY
typedef ::qint32 ( ::SireVol::GridInfo::*dimY_function_type )( ) const;
dimY_function_type dimY_function_value( &::SireVol::GridInfo::dimY );
GridInfo_exposer.def(
"dimY"
, dimY_function_value );
}
{ //::SireVol::GridInfo::dimZ
typedef ::qint32 ( ::SireVol::GridInfo::*dimZ_function_type )( ) const;
dimZ_function_type dimZ_function_value( &::SireVol::GridInfo::dimZ );
GridInfo_exposer.def(
"dimZ"
, dimZ_function_value );
}
{ //::SireVol::GridInfo::dimensions
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*dimensions_function_type )( ) const;
dimensions_function_type dimensions_function_value( &::SireVol::GridInfo::dimensions );
GridInfo_exposer.def(
"dimensions"
, dimensions_function_value );
}
{ //::SireVol::GridInfo::getitem
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*getitem_function_type )( int ) const;
getitem_function_type getitem_function_value( &::SireVol::GridInfo::getitem );
GridInfo_exposer.def(
"getitem"
, getitem_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::gridToArrayIndex
typedef int ( ::SireVol::GridInfo::*gridToArrayIndex_function_type )( int,int,int ) const;
gridToArrayIndex_function_type gridToArrayIndex_function_value( &::SireVol::GridInfo::gridToArrayIndex );
GridInfo_exposer.def(
"gridToArrayIndex"
, gridToArrayIndex_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("k") ) );
}
{ //::SireVol::GridInfo::gridToArrayIndex
typedef int ( ::SireVol::GridInfo::*gridToArrayIndex_function_type )( ::SireVol::GridIndex const & ) const;
gridToArrayIndex_function_type gridToArrayIndex_function_value( &::SireVol::GridInfo::gridToArrayIndex );
GridInfo_exposer.def(
"gridToArrayIndex"
, gridToArrayIndex_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::indexOf
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*indexOf_function_type )( int,::SireVol::GridInfo const & ) const;
indexOf_function_type indexOf_function_value( &::SireVol::GridInfo::indexOf );
GridInfo_exposer.def(
"indexOf"
, indexOf_function_value
, ( bp::arg("i"), bp::arg("grid") ) );
}
{ //::SireVol::GridInfo::indexOf
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*indexOf_function_type )( ::SireVol::GridIndex const &,::SireVol::GridInfo const & ) const;
indexOf_function_type indexOf_function_value( &::SireVol::GridInfo::indexOf );
GridInfo_exposer.def(
"indexOf"
, indexOf_function_value
, ( bp::arg("idx"), bp::arg("grid") ) );
}
{ //::SireVol::GridInfo::isEmpty
typedef bool ( ::SireVol::GridInfo::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireVol::GridInfo::isEmpty );
GridInfo_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireVol::GridInfo::nPoints
typedef int ( ::SireVol::GridInfo::*nPoints_function_type )( ) const;
nPoints_function_type nPoints_function_value( &::SireVol::GridInfo::nPoints );
GridInfo_exposer.def(
"nPoints"
, nPoints_function_value );
}
GridInfo_exposer.def( bp::self != bp::self );
{ //::SireVol::GridInfo::operator=
typedef ::SireVol::GridInfo & ( ::SireVol::GridInfo::*assign_function_type )( ::SireVol::GridInfo const & ) ;
assign_function_type assign_function_value( &::SireVol::GridInfo::operator= );
GridInfo_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
GridInfo_exposer.def( bp::self == bp::self );
{ //::SireVol::GridInfo::operator[]
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] );
GridInfo_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::operator[]
typedef int ( ::SireVol::GridInfo::*__getitem___function_type )( ::SireVol::GridIndex const & ) const;
__getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] );
GridInfo_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::operator[]
typedef int ( ::SireVol::GridInfo::*__getitem___function_type )( ::SireMaths::Vector const & ) const;
__getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] );
GridInfo_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::point
typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( int ) const;
point_function_type point_function_value( &::SireVol::GridInfo::point );
GridInfo_exposer.def(
"point"
, point_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::point
typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( ::SireVol::GridIndex const & ) const;
point_function_type point_function_value( &::SireVol::GridInfo::point );
GridInfo_exposer.def(
"point"
, point_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::point
typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( ::SireMaths::Vector const & ) const;
point_function_type point_function_value( &::SireVol::GridInfo::point );
GridInfo_exposer.def(
"point"
, point_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::pointToArrayIndex
typedef int ( ::SireVol::GridInfo::*pointToArrayIndex_function_type )( ::SireMaths::Vector const & ) const;
pointToArrayIndex_function_type pointToArrayIndex_function_value( &::SireVol::GridInfo::pointToArrayIndex );
GridInfo_exposer.def(
"pointToArrayIndex"
, pointToArrayIndex_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef void ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::Vector const &,::QVector< int > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("point"), bp::arg("indicies") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef void ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::Vector const &,::QVector< int > &,::QVector< float > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("point"), bp::arg("indicies"), bp::arg("weights") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef int ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::QVector< SireMaths::MultiInt > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("indicies") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef int ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::QVector< SireMaths::MultiInt > &,::QVector< SireMaths::MultiFloat > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("indicies"), bp::arg("weights") ) );
}
{ //::SireVol::GridInfo::pointToGridIndex
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*pointToGridIndex_function_type )( ::SireMaths::Vector const & ) const;
pointToGridIndex_function_type pointToGridIndex_function_value( &::SireVol::GridInfo::pointToGridIndex );
GridInfo_exposer.def(
"pointToGridIndex"
, pointToGridIndex_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::redimension
typedef ::QVector< float > ( ::SireVol::GridInfo::*redimension_function_type )( ::QVector< float > const &,::SireVol::GridInfo const & ) const;
redimension_function_type redimension_function_value( &::SireVol::GridInfo::redimension );
GridInfo_exposer.def(
"redimension"
, redimension_function_value
, ( bp::arg("values"), bp::arg("new_grid") ) );
}
{ //::SireVol::GridInfo::size
typedef int ( ::SireVol::GridInfo::*size_function_type )( ) const;
size_function_type size_function_value( &::SireVol::GridInfo::size );
GridInfo_exposer.def(
"size"
, size_function_value );
}
{ //::SireVol::GridInfo::spacing
typedef ::SireUnits::Dimension::Length ( ::SireVol::GridInfo::*spacing_function_type )( ) const;
spacing_function_type spacing_function_value( &::SireVol::GridInfo::spacing );
GridInfo_exposer.def(
"spacing"
, spacing_function_value );
}
{ //::SireVol::GridInfo::toString
typedef ::QString ( ::SireVol::GridInfo::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireVol::GridInfo::toString );
GridInfo_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireVol::GridInfo::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireVol::GridInfo::typeName );
GridInfo_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireVol::GridInfo::what
typedef char const * ( ::SireVol::GridInfo::*what_function_type )( ) const;
what_function_type what_function_value( &::SireVol::GridInfo::what );
GridInfo_exposer.def(
"what"
, what_function_value );
}
GridInfo_exposer.staticmethod( "typeName" );
GridInfo_exposer.def( "__copy__", &__copy__);
GridInfo_exposer.def( "__deepcopy__", &__copy__);
GridInfo_exposer.def( "clone", &__copy__);
GridInfo_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::GridInfo >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GridInfo_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::GridInfo >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GridInfo_exposer.def( "__str__", &__str__< ::SireVol::GridInfo > );
GridInfo_exposer.def( "__repr__", &__str__< ::SireVol::GridInfo > );
GridInfo_exposer.def( "__len__", &__len_size< ::SireVol::GridInfo > );
GridInfo_exposer.def( "__getitem__", &::SireVol::GridInfo::getitem );
}
}
void register_ChainsWithRes_class(){
{ //::SireMol::ChainsWithRes
typedef bp::class_< SireMol::ChainsWithRes, bp::bases< SireMol::ChainID, SireID::ID > > ChainsWithRes_exposer_t;
ChainsWithRes_exposer_t ChainsWithRes_exposer = ChainsWithRes_exposer_t( "ChainsWithRes", "This ID class identifies chains that contain residues that\nmatch the passed ResID\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope ChainsWithRes_scope( ChainsWithRes_exposer );
ChainsWithRes_exposer.def( bp::init< SireMol::ResID const & >(( bp::arg("resid") ), "Construct from the passed residue ID") );
ChainsWithRes_exposer.def( bp::init< SireMol::ChainsWithRes const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMol::ChainsWithRes::hash
typedef ::uint ( ::SireMol::ChainsWithRes::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireMol::ChainsWithRes::hash );
ChainsWithRes_exposer.def(
"hash"
, hash_function_value
, "Return a hash of this identifier" );
}
{ //::SireMol::ChainsWithRes::isNull
typedef bool ( ::SireMol::ChainsWithRes::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireMol::ChainsWithRes::isNull );
ChainsWithRes_exposer.def(
"isNull"
, isNull_function_value
, "Is this selection null?" );
}
{ //::SireMol::ChainsWithRes::map
typedef ::QList< SireMol::ChainIdx > ( ::SireMol::ChainsWithRes::*map_function_type)( ::SireMol::MolInfo const & ) const;
map_function_type map_function_value( &::SireMol::ChainsWithRes::map );
ChainsWithRes_exposer.def(
"map"
, map_function_value
, ( bp::arg("molinfo") )
, "Map this ID to the list of indicies of chains that match this ID\nThrow: SireMol::missing_chain\nThrow: SireError::invalid_index\n" );
}
ChainsWithRes_exposer.def( bp::self != bp::self );
{ //::SireMol::ChainsWithRes::operator=
typedef ::SireMol::ChainsWithRes & ( ::SireMol::ChainsWithRes::*assign_function_type)( ::SireMol::ChainsWithRes const & ) ;
assign_function_type assign_function_value( &::SireMol::ChainsWithRes::operator= );
ChainsWithRes_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
ChainsWithRes_exposer.def( bp::self == bp::other< SireID::ID >() );
ChainsWithRes_exposer.def( bp::self == bp::self );
{ //::SireMol::ChainsWithRes::resID
typedef ::SireMol::ResID const & ( ::SireMol::ChainsWithRes::*resID_function_type)( ) const;
resID_function_type resID_function_value( &::SireMol::ChainsWithRes::resID );
ChainsWithRes_exposer.def(
"resID"
, resID_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the residue ID" );
}
{ //::SireMol::ChainsWithRes::toString
typedef ::QString ( ::SireMol::ChainsWithRes::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::ChainsWithRes::toString );
ChainsWithRes_exposer.def(
"toString"
, toString_function_value
, "Return a string representatio of this ID" );
}
{ //::SireMol::ChainsWithRes::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::ChainsWithRes::typeName );
ChainsWithRes_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMol::ChainsWithRes::what
typedef char const * ( ::SireMol::ChainsWithRes::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMol::ChainsWithRes::what );
ChainsWithRes_exposer.def(
"what"
, what_function_value
, "" );
}
ChainsWithRes_exposer.staticmethod( "typeName" );
ChainsWithRes_exposer.def( "__copy__", &__copy__);
ChainsWithRes_exposer.def( "__deepcopy__", &__copy__);
ChainsWithRes_exposer.def( "clone", &__copy__);
ChainsWithRes_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ChainsWithRes >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChainsWithRes_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ChainsWithRes >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChainsWithRes_exposer.def( "__str__", &__str__< ::SireMol::ChainsWithRes > );
ChainsWithRes_exposer.def( "__repr__", &__str__< ::SireMol::ChainsWithRes > );
ChainsWithRes_exposer.def( "__hash__", &::SireMol::ChainsWithRes::hash );
}
}
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_Molecules_class(){
{ //::SireMol::Molecules
typedef bp::class_< SireMol::Molecules, bp::bases< SireBase::Property > > Molecules_exposer_t;
Molecules_exposer_t Molecules_exposer = Molecules_exposer_t( "Molecules", bp::init< >() );
bp::scope Molecules_scope( Molecules_exposer );
Molecules_exposer.def( bp::init< SireMol::MoleculeView const & >(( bp::arg("molecule") )) );
Molecules_exposer.def( bp::init< SireMol::ViewsOfMol const & >(( bp::arg("molviews") )) );
Molecules_exposer.def( bp::init< SireMol::Molecules const & >(( bp::arg("other") )) );
{ //::SireMol::Molecules::add
typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::MoleculeView const & ) ;
add_function_type add_function_value( &::SireMol::Molecules::add );
Molecules_exposer.def(
"add"
, add_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::add
typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::ViewsOfMol const & ) ;
add_function_type add_function_value( &::SireMol::Molecules::add );
Molecules_exposer.def(
"add"
, add_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::add
typedef void ( ::SireMol::Molecules::*add_function_type )( ::SireMol::Molecules const & ) ;
add_function_type add_function_value( &::SireMol::Molecules::add );
Molecules_exposer.def(
"add"
, add_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::addIfUnique
typedef bool ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::MoleculeView const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique );
Molecules_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::addIfUnique
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::ViewsOfMol const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique );
Molecules_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::addIfUnique
typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*addIfUnique_function_type )( ::SireMol::Molecules const & ) ;
addIfUnique_function_type addIfUnique_function_value( &::SireMol::Molecules::addIfUnique );
Molecules_exposer.def(
"addIfUnique"
, addIfUnique_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::assertContains
typedef void ( ::SireMol::Molecules::*assertContains_function_type )( ::SireMol::MolNum ) const;
assertContains_function_type assertContains_function_value( &::SireMol::Molecules::assertContains );
Molecules_exposer.def(
"assertContains"
, assertContains_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::at
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*at_function_type )( ::SireMol::MolNum ) const;
at_function_type at_function_value( &::SireMol::Molecules::at );
Molecules_exposer.def(
"at"
, at_function_value
, ( bp::arg("molnum") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::at
typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*at_function_type )( ::boost::tuples::tuple< SireMol::MolNum, SireID::Index, 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 > const & ) const;
at_function_type at_function_value( &::SireMol::Molecules::at );
Molecules_exposer.def(
"at"
, at_function_value
, ( bp::arg("viewidx") ) );
}
{ //::SireMol::Molecules::at
typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*at_function_type )( ::SireMol::MolNum,int ) const;
at_function_type at_function_value( &::SireMol::Molecules::at );
Molecules_exposer.def(
"at"
, at_function_value
, ( bp::arg("molnum"), bp::arg("idx") ) );
}
{ //::SireMol::Molecules::back
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*back_function_type )( ) const;
back_function_type back_function_value( &::SireMol::Molecules::back );
Molecules_exposer.def(
"back"
, back_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::begin
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*begin_function_type )( ) const;
begin_function_type begin_function_value( &::SireMol::Molecules::begin );
Molecules_exposer.def(
"begin"
, begin_function_value );
}
{ //::SireMol::Molecules::clear
typedef void ( ::SireMol::Molecules::*clear_function_type )( ) ;
clear_function_type clear_function_value( &::SireMol::Molecules::clear );
Molecules_exposer.def(
"clear"
, clear_function_value );
}
{ //::SireMol::Molecules::constBegin
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constBegin_function_type )( ) const;
constBegin_function_type constBegin_function_value( &::SireMol::Molecules::constBegin );
Molecules_exposer.def(
"constBegin"
, constBegin_function_value );
}
{ //::SireMol::Molecules::constEnd
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constEnd_function_type )( ) const;
constEnd_function_type constEnd_function_value( &::SireMol::Molecules::constEnd );
Molecules_exposer.def(
"constEnd"
, constEnd_function_value );
}
{ //::SireMol::Molecules::constFind
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*constFind_function_type )( ::SireMol::MolNum ) const;
constFind_function_type constFind_function_value( &::SireMol::Molecules::constFind );
Molecules_exposer.def(
"constFind"
, constFind_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::contains
typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::MolNum ) const;
contains_function_type contains_function_value( &::SireMol::Molecules::contains );
Molecules_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::contains
typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::MoleculeView const & ) const;
contains_function_type contains_function_value( &::SireMol::Molecules::contains );
Molecules_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::contains
typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::ViewsOfMol const & ) const;
contains_function_type contains_function_value( &::SireMol::Molecules::contains );
Molecules_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::contains
typedef bool ( ::SireMol::Molecules::*contains_function_type )( ::SireMol::Molecules const & ) const;
contains_function_type contains_function_value( &::SireMol::Molecules::contains );
Molecules_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::count
typedef int ( ::SireMol::Molecules::*count_function_type )( ) const;
count_function_type count_function_value( &::SireMol::Molecules::count );
Molecules_exposer.def(
"count"
, count_function_value );
}
{ //::SireMol::Molecules::end
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*end_function_type )( ) const;
end_function_type end_function_value( &::SireMol::Molecules::end );
Molecules_exposer.def(
"end"
, end_function_value );
}
{ //::SireMol::Molecules::find
typedef ::SireBase::ChunkedHash< SireMol::MolNum, SireMol::ViewsOfMol, 100 >::const_iterator ( ::SireMol::Molecules::*find_function_type )( ::SireMol::MolNum ) const;
find_function_type find_function_value( &::SireMol::Molecules::find );
Molecules_exposer.def(
"find"
, find_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::first
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*first_function_type )( ) const;
first_function_type first_function_value( &::SireMol::Molecules::first );
Molecules_exposer.def(
"first"
, first_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::front
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*front_function_type )( ) const;
front_function_type front_function_value( &::SireMol::Molecules::front );
Molecules_exposer.def(
"front"
, front_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::intersects
typedef bool ( ::SireMol::Molecules::*intersects_function_type )( ::SireMol::MoleculeView const & ) const;
intersects_function_type intersects_function_value( &::SireMol::Molecules::intersects );
Molecules_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::intersects
typedef bool ( ::SireMol::Molecules::*intersects_function_type )( ::SireMol::Molecules const & ) const;
intersects_function_type intersects_function_value( &::SireMol::Molecules::intersects );
Molecules_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("other") ) );
}
{ //::SireMol::Molecules::isEmpty
typedef bool ( ::SireMol::Molecules::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMol::Molecules::isEmpty );
Molecules_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireMol::Molecules::last
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*last_function_type )( ) const;
last_function_type last_function_value( &::SireMol::Molecules::last );
Molecules_exposer.def(
"last"
, last_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::molNums
typedef ::QSet< SireMol::MolNum > ( ::SireMol::Molecules::*molNums_function_type )( ) const;
molNums_function_type molNums_function_value( &::SireMol::Molecules::molNums );
Molecules_exposer.def(
"molNums"
, molNums_function_value );
}
{ //::SireMol::Molecules::molecule
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*molecule_function_type )( ::SireMol::MolNum ) const;
molecule_function_type molecule_function_value( &::SireMol::Molecules::molecule );
Molecules_exposer.def(
"molecule"
, molecule_function_value
, ( bp::arg("molnum") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::nMolecules
typedef int ( ::SireMol::Molecules::*nMolecules_function_type )( ) const;
nMolecules_function_type nMolecules_function_value( &::SireMol::Molecules::nMolecules );
Molecules_exposer.def(
"nMolecules"
, nMolecules_function_value );
}
{ //::SireMol::Molecules::nViews
typedef int ( ::SireMol::Molecules::*nViews_function_type )( ) const;
nViews_function_type nViews_function_value( &::SireMol::Molecules::nViews );
Molecules_exposer.def(
"nViews"
, nViews_function_value );
}
{ //::SireMol::Molecules::nViews
typedef int ( ::SireMol::Molecules::*nViews_function_type )( ::SireMol::MolNum ) const;
nViews_function_type nViews_function_value( &::SireMol::Molecules::nViews );
Molecules_exposer.def(
"nViews"
, nViews_function_value
, ( bp::arg("molnum") ) );
}
Molecules_exposer.def( bp::self != bp::self );
Molecules_exposer.def( bp::self + bp::self );
Molecules_exposer.def( bp::self - bp::self );
{ //::SireMol::Molecules::operator=
typedef ::SireMol::Molecules & ( ::SireMol::Molecules::*assign_function_type )( ::SireMol::Molecules const & ) ;
assign_function_type assign_function_value( &::SireMol::Molecules::operator= );
Molecules_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Molecules_exposer.def( bp::self == bp::self );
{ //::SireMol::Molecules::operator[]
typedef ::SireMol::ViewsOfMol const & ( ::SireMol::Molecules::*__getitem___function_type )( ::SireMol::MolNum ) const;
__getitem___function_type __getitem___function_value( &::SireMol::Molecules::operator[] );
Molecules_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("molnum") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::Molecules::operator[]
typedef ::SireMol::PartialMolecule ( ::SireMol::Molecules::*__getitem___function_type )( ::boost::tuples::tuple< SireMol::MolNum, SireID::Index, 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 > const & ) const;
__getitem___function_type __getitem___function_value( &::SireMol::Molecules::operator[] );
Molecules_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("viewidx") ) );
}
{ //::SireMol::Molecules::remove
typedef bool ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::MoleculeView const & ) ;
remove_function_type remove_function_value( &::SireMol::Molecules::remove );
Molecules_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::remove
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::ViewsOfMol const & ) ;
remove_function_type remove_function_value( &::SireMol::Molecules::remove );
Molecules_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::remove
typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::Molecules const & ) ;
remove_function_type remove_function_value( &::SireMol::Molecules::remove );
Molecules_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::remove
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*remove_function_type )( ::SireMol::MolNum ) ;
remove_function_type remove_function_value( &::SireMol::Molecules::remove );
Molecules_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMol::Molecules::removeAll
typedef bool ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::MoleculeView const & ) ;
removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
Molecules_exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::removeAll
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::ViewsOfMol const & ) ;
removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
Molecules_exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::removeAll
typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*removeAll_function_type )( ::SireMol::Molecules const & ) ;
removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
Molecules_exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::removeAll
typedef bool ( ::SireMol::Molecules::*removeAll_function_type )( ) ;
removeAll_function_type removeAll_function_value( &::SireMol::Molecules::removeAll );
Molecules_exposer.def(
"removeAll"
, removeAll_function_value );
}
{ //::SireMol::Molecules::removeDuplicates
typedef bool ( ::SireMol::Molecules::*removeDuplicates_function_type )( ) ;
removeDuplicates_function_type removeDuplicates_function_value( &::SireMol::Molecules::removeDuplicates );
Molecules_exposer.def(
"removeDuplicates"
, removeDuplicates_function_value );
}
{ //::SireMol::Molecules::reserve
typedef void ( ::SireMol::Molecules::*reserve_function_type )( int ) ;
reserve_function_type reserve_function_value( &::SireMol::Molecules::reserve );
Molecules_exposer.def(
"reserve"
, reserve_function_value
, ( bp::arg("nmolecules") ) );
}
{ //::SireMol::Molecules::toString
typedef ::QString ( ::SireMol::Molecules::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::Molecules::toString );
Molecules_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::Molecules::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::Molecules::typeName );
Molecules_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::Molecules::unite
typedef bool ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::MoleculeView const & ) ;
unite_function_type unite_function_value( &::SireMol::Molecules::unite );
Molecules_exposer.def(
"unite"
, unite_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::unite
typedef ::SireMol::ViewsOfMol ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::ViewsOfMol const & ) ;
unite_function_type unite_function_value( &::SireMol::Molecules::unite );
Molecules_exposer.def(
"unite"
, unite_function_value
, ( bp::arg("molviews") ) );
}
{ //::SireMol::Molecules::unite
typedef ::QList< SireMol::ViewsOfMol > ( ::SireMol::Molecules::*unite_function_type )( ::SireMol::Molecules const & ) ;
unite_function_type unite_function_value( &::SireMol::Molecules::unite );
Molecules_exposer.def(
"unite"
, unite_function_value
, ( bp::arg("other") ) );
}
{ //::SireMol::Molecules::uniteViews
typedef bool ( ::SireMol::Molecules::*uniteViews_function_type )( ) ;
uniteViews_function_type uniteViews_function_value( &::SireMol::Molecules::uniteViews );
Molecules_exposer.def(
"uniteViews"
, uniteViews_function_value );
}
{ //::SireMol::Molecules::update
typedef bool ( ::SireMol::Molecules::*update_function_type )( ::SireMol::MoleculeData const & ) ;
update_function_type update_function_value( &::SireMol::Molecules::update );
Molecules_exposer.def(
"update"
, update_function_value
, ( bp::arg("moldata") ) );
}
{ //::SireMol::Molecules::update
typedef bool ( ::SireMol::Molecules::*update_function_type )( ::SireMol::MoleculeView const & ) ;
update_function_type update_function_value( &::SireMol::Molecules::update );
Molecules_exposer.def(
"update"
, update_function_value
, ( bp::arg("molview") ) );
}
{ //::SireMol::Molecules::update
typedef ::QList< SireMol::Molecule > ( ::SireMol::Molecules::*update_function_type )( ::SireMol::Molecules const & ) ;
update_function_type update_function_value( &::SireMol::Molecules::update );
Molecules_exposer.def(
"update"
, update_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMol::Molecules::what
typedef char const * ( ::SireMol::Molecules::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMol::Molecules::what );
Molecules_exposer.def(
"what"
, what_function_value );
}
Molecules_exposer.staticmethod( "typeName" );
Molecules_exposer.def( "__copy__", &__copy__);
Molecules_exposer.def( "__deepcopy__", &__copy__);
Molecules_exposer.def( "clone", &__copy__);
Molecules_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Molecules >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Molecules_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Molecules >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Molecules_exposer.def( "__str__", &__str__< ::SireMol::Molecules > );
Molecules_exposer.def( "__repr__", &__str__< ::SireMol::Molecules > );
Molecules_exposer.def( "__len__", &__len_count< ::SireMol::Molecules > );
}
}
void register_RestraintFF_class(){
{ //::SireMM::RestraintFF
typedef bp::class_< SireMM::RestraintFF, bp::bases< SireFF::FF3D, SireFF::G1FF, SireFF::FF, SireMol::MolGroupsBase, SireBase::Property > > RestraintFF_exposer_t;
RestraintFF_exposer_t RestraintFF_exposer = RestraintFF_exposer_t( "RestraintFF", bp::init< >() );
bp::scope RestraintFF_scope( RestraintFF_exposer );
RestraintFF_exposer.def( bp::init< QString const & >(( bp::arg("name") )) );
RestraintFF_exposer.def( bp::init< SireMM::RestraintFF const & >(( bp::arg("other") )) );
{ //::SireMM::RestraintFF::add
typedef bool ( ::SireMM::RestraintFF::*add_function_type )( ::SireMM::Restraint3D const & ) ;
add_function_type add_function_value( &::SireMM::RestraintFF::add );
RestraintFF_exposer.def(
"add"
, add_function_value
, ( bp::arg("restraint") ) );
}
{ //::SireMM::RestraintFF::builtinSymbols
typedef ::SireCAS::Symbols ( ::SireMM::RestraintFF::*builtinSymbols_function_type )( ) const;
builtinSymbols_function_type builtinSymbols_function_value( &::SireMM::RestraintFF::builtinSymbols );
RestraintFF_exposer.def(
"builtinSymbols"
, builtinSymbols_function_value );
}
{ //::SireMM::RestraintFF::components
typedef ::SireMM::RestraintComponent const & ( ::SireMM::RestraintFF::*components_function_type )( ) const;
components_function_type components_function_value( &::SireMM::RestraintFF::components );
RestraintFF_exposer.def(
"components"
, components_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::RestraintFF::contains
typedef bool ( ::SireMM::RestraintFF::*contains_function_type )( ::SireMM::Restraint3D const & ) const;
contains_function_type contains_function_value( &::SireMM::RestraintFF::contains );
RestraintFF_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("restraint") ) );
}
{ //::SireMM::RestraintFF::containsProperty
typedef bool ( ::SireMM::RestraintFF::*containsProperty_function_type )( ::QString const & ) const;
containsProperty_function_type containsProperty_function_value( &::SireMM::RestraintFF::containsProperty );
RestraintFF_exposer.def(
"containsProperty"
, containsProperty_function_value
, ( bp::arg("name") ) );
}
{ //::SireMM::RestraintFF::differentiate
typedef ::SireMM::RestraintFF ( ::SireMM::RestraintFF::*differentiate_function_type )( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireMM::RestraintFF::differentiate );
RestraintFF_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireMM::RestraintFF::field
typedef void ( ::SireMM::RestraintFF::*field_function_type )( ::SireFF::FieldTable &,double ) ;
field_function_type field_function_value( &::SireMM::RestraintFF::field );
RestraintFF_exposer.def(
"field"
, field_function_value
, ( bp::arg("fieldtable"), bp::arg("scale_field")=1 ) );
}
{ //::SireMM::RestraintFF::field
typedef void ( ::SireMM::RestraintFF::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,double ) ;
field_function_type field_function_value( &::SireMM::RestraintFF::field );
RestraintFF_exposer.def(
"field"
, field_function_value
, ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("scale_field")=1 ) );
}
{ //::SireMM::RestraintFF::field
typedef void ( ::SireMM::RestraintFF::*field_function_type )( ::SireFF::FieldTable &,::SireFF::Probe const &,double ) ;
field_function_type field_function_value( &::SireMM::RestraintFF::field );
RestraintFF_exposer.def(
"field"
, field_function_value
, ( bp::arg("fieldtable"), bp::arg("probe"), bp::arg("scale_field")=1 ) );
}
{ //::SireMM::RestraintFF::field
typedef void ( ::SireMM::RestraintFF::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ;
field_function_type field_function_value( &::SireMM::RestraintFF::field );
RestraintFF_exposer.def(
"field"
, field_function_value
, ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_field")=1 ) );
}
{ //::SireMM::RestraintFF::force
typedef void ( ::SireMM::RestraintFF::*force_function_type )( ::SireFF::ForceTable &,double ) ;
force_function_type force_function_value( &::SireMM::RestraintFF::force );
RestraintFF_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) );
}
{ //::SireMM::RestraintFF::force
typedef void ( ::SireMM::RestraintFF::*force_function_type )( ::SireFF::ForceTable &,::SireCAS::Symbol const &,double ) ;
force_function_type force_function_value( &::SireMM::RestraintFF::force );
RestraintFF_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("symbol"), bp::arg("scale_force")=1 ) );
}
{ //::SireMM::RestraintFF::getValue
typedef double ( ::SireMM::RestraintFF::*getValue_function_type )( ::SireCAS::Symbol const & ) const;
getValue_function_type getValue_function_value( &::SireMM::RestraintFF::getValue );
RestraintFF_exposer.def(
"getValue"
, getValue_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireMM::RestraintFF::hasValue
typedef bool ( ::SireMM::RestraintFF::*hasValue_function_type )( ::SireCAS::Symbol const & ) const;
hasValue_function_type hasValue_function_value( &::SireMM::RestraintFF::hasValue );
RestraintFF_exposer.def(
"hasValue"
, hasValue_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireMM::RestraintFF::mustNowRecalculateFromScratch
typedef void ( ::SireMM::RestraintFF::*mustNowRecalculateFromScratch_function_type )( ) ;
mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::SireMM::RestraintFF::mustNowRecalculateFromScratch );
RestraintFF_exposer.def(
"mustNowRecalculateFromScratch"
, mustNowRecalculateFromScratch_function_value );
}
{ //::SireMM::RestraintFF::nRestraints
typedef int ( ::SireMM::RestraintFF::*nRestraints_function_type )( ) const;
nRestraints_function_type nRestraints_function_value( &::SireMM::RestraintFF::nRestraints );
RestraintFF_exposer.def(
"nRestraints"
, nRestraints_function_value );
}
RestraintFF_exposer.def( bp::self != bp::self );
{ //::SireMM::RestraintFF::operator=
typedef ::SireMM::RestraintFF & ( ::SireMM::RestraintFF::*assign_function_type )( ::SireMM::RestraintFF const & ) ;
assign_function_type assign_function_value( &::SireMM::RestraintFF::operator= );
RestraintFF_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
RestraintFF_exposer.def( bp::self == bp::self );
{ //::SireMM::RestraintFF::potential
typedef void ( ::SireMM::RestraintFF::*potential_function_type )( ::SireFF::PotentialTable &,double ) ;
potential_function_type potential_function_value( &::SireMM::RestraintFF::potential );
RestraintFF_exposer.def(
"potential"
, potential_function_value
, ( bp::arg("potentialtable"), bp::arg("scale_potential")=1 ) );
}
{ //::SireMM::RestraintFF::potential
typedef void ( ::SireMM::RestraintFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,double ) ;
potential_function_type potential_function_value( &::SireMM::RestraintFF::potential );
RestraintFF_exposer.def(
"potential"
, potential_function_value
, ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("scale_potential")=1 ) );
}
{ //::SireMM::RestraintFF::potential
typedef void ( ::SireMM::RestraintFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireFF::Probe const &,double ) ;
potential_function_type potential_function_value( &::SireMM::RestraintFF::potential );
RestraintFF_exposer.def(
"potential"
, potential_function_value
, ( bp::arg("potentialtable"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );
}
{ //::SireMM::RestraintFF::potential
typedef void ( ::SireMM::RestraintFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ;
potential_function_type potential_function_value( &::SireMM::RestraintFF::potential );
RestraintFF_exposer.def(
"potential"
, potential_function_value
, ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );
}
{ //::SireMM::RestraintFF::properties
typedef ::SireBase::Properties const & ( ::SireMM::RestraintFF::*properties_function_type )( ) const;
properties_function_type properties_function_value( &::SireMM::RestraintFF::properties );
RestraintFF_exposer.def(
"properties"
, properties_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMM::RestraintFF::property
typedef ::SireBase::Property const & ( ::SireMM::RestraintFF::*property_function_type )( ::QString const & ) const;
property_function_type property_function_value( &::SireMM::RestraintFF::property );
RestraintFF_exposer.def(
"property"
, property_function_value
, ( bp::arg("name") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::RestraintFF::remove
typedef bool ( ::SireMM::RestraintFF::*remove_function_type )( ::SireMM::Restraint3D const & ) ;
remove_function_type remove_function_value( &::SireMM::RestraintFF::remove );
RestraintFF_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("restraint") ) );
}
{ //::SireMM::RestraintFF::removeRestraintAt
typedef void ( ::SireMM::RestraintFF::*removeRestraintAt_function_type )( int ) ;
removeRestraintAt_function_type removeRestraintAt_function_value( &::SireMM::RestraintFF::removeRestraintAt );
RestraintFF_exposer.def(
"removeRestraintAt"
, removeRestraintAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireMM::RestraintFF::restraintAt
typedef ::SireMM::Restraint3D const & ( ::SireMM::RestraintFF::*restraintAt_function_type )( int ) const;
restraintAt_function_type restraintAt_function_value( &::SireMM::RestraintFF::restraintAt );
RestraintFF_exposer.def(
"restraintAt"
, restraintAt_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::RestraintFF::restraints
typedef ::QVector< SireBase::PropPtr< SireMM::Restraint3D > > ( ::SireMM::RestraintFF::*restraints_function_type )( ) const;
restraints_function_type restraints_function_value( &::SireMM::RestraintFF::restraints );
RestraintFF_exposer.def(
"restraints"
, restraints_function_value );
}
{ //::SireMM::RestraintFF::setProperty
typedef bool ( ::SireMM::RestraintFF::*setProperty_function_type )( ::QString const &,::SireBase::Property const & ) ;
setProperty_function_type setProperty_function_value( &::SireMM::RestraintFF::setProperty );
RestraintFF_exposer.def(
"setProperty"
, setProperty_function_value
, ( bp::arg("name"), bp::arg("property") ) );
}
{ //::SireMM::RestraintFF::setSpace
typedef bool ( ::SireMM::RestraintFF::*setSpace_function_type )( ::SireVol::Space const & ) ;
setSpace_function_type setSpace_function_value( &::SireMM::RestraintFF::setSpace );
RestraintFF_exposer.def(
"setSpace"
, setSpace_function_value
, ( bp::arg("space") ) );
}
{ //::SireMM::RestraintFF::setValue
typedef bool ( ::SireMM::RestraintFF::*setValue_function_type )( ::SireCAS::Symbol const &,double ) ;
setValue_function_type setValue_function_value( &::SireMM::RestraintFF::setValue );
RestraintFF_exposer.def(
"setValue"
, setValue_function_value
, ( bp::arg("symbol"), bp::arg("value") ) );
}
{ //::SireMM::RestraintFF::space
typedef ::SireVol::Space const & ( ::SireMM::RestraintFF::*space_function_type )( ) const;
space_function_type space_function_value( &::SireMM::RestraintFF::space );
RestraintFF_exposer.def(
"space"
, space_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::RestraintFF::symbols
typedef ::SireCAS::Symbols ( ::SireMM::RestraintFF::*symbols_function_type )( ) const;
symbols_function_type symbols_function_value( &::SireMM::RestraintFF::symbols );
RestraintFF_exposer.def(
"symbols"
, symbols_function_value );
}
{ //::SireMM::RestraintFF::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::RestraintFF::typeName );
RestraintFF_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMM::RestraintFF::userSymbols
typedef ::SireCAS::Symbols ( ::SireMM::RestraintFF::*userSymbols_function_type )( ) const;
userSymbols_function_type userSymbols_function_value( &::SireMM::RestraintFF::userSymbols );
RestraintFF_exposer.def(
"userSymbols"
, userSymbols_function_value );
}
{ //::SireMM::RestraintFF::userValues
typedef ::SireCAS::Values ( ::SireMM::RestraintFF::*userValues_function_type )( ) const;
userValues_function_type userValues_function_value( &::SireMM::RestraintFF::userValues );
RestraintFF_exposer.def(
"userValues"
, userValues_function_value );
}
RestraintFF_exposer.staticmethod( "typeName" );
RestraintFF_exposer.def( "__copy__", &__copy__);
RestraintFF_exposer.def( "__deepcopy__", &__copy__);
RestraintFF_exposer.def( "clone", &__copy__);
RestraintFF_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::RestraintFF >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
RestraintFF_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::RestraintFF >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
RestraintFF_exposer.def( "__str__", &__str__< ::SireMM::RestraintFF > );
RestraintFF_exposer.def( "__repr__", &__str__< ::SireMM::RestraintFF > );
RestraintFF_exposer.def( "__len__", &__len_count< ::SireMM::RestraintFF > );
}
}
