void register_HarmonicSwitchingFunction_class(){

    { //::SireMM::HarmonicSwitchingFunction
        typedef bp::class_< SireMM::HarmonicSwitchingFunction, bp::bases< SireMM::SwitchingFunction, SireBase::Property > > HarmonicSwitchingFunction_exposer_t;
        HarmonicSwitchingFunction_exposer_t HarmonicSwitchingFunction_exposer = HarmonicSwitchingFunction_exposer_t( "HarmonicSwitchingFunction", bp::init< >() );
        bp::scope HarmonicSwitchingFunction_scope( HarmonicSwitchingFunction_exposer );
        HarmonicSwitchingFunction_exposer.def( bp::init< SireUnits::Dimension::Length >(( bp::arg("cutoffdist") )) );
        HarmonicSwitchingFunction_exposer.def( bp::init< SireUnits::Dimension::Length, SireUnits::Dimension::Length >(( bp::arg("cutoffdist"), bp::arg("featherdist") )) );
        HarmonicSwitchingFunction_exposer.def( bp::init< SireUnits::Dimension::Length, SireUnits::Dimension::Length, SireUnits::Dimension::Length >(( bp::arg("cutoffdist"), bp::arg("elecfeather"), bp::arg("vdwfeather") )) );
        HarmonicSwitchingFunction_exposer.def( bp::init< SireUnits::Dimension::Length, SireUnits::Dimension::Length, SireUnits::Dimension::Length, SireUnits::Dimension::Length >(( bp::arg("eleccutoff"), bp::arg("elecfeather"), bp::arg("vdwcutoff"), bp::arg("vdwfeather") )) );
        HarmonicSwitchingFunction_exposer.def( bp::init< SireMM::HarmonicSwitchingFunction const & >(( bp::arg("other") )) );
        { //::SireMM::HarmonicSwitchingFunction::dElectrostaticScaleFactor
        
            typedef double ( ::SireMM::HarmonicSwitchingFunction::*dElectrostaticScaleFactor_function_type )( ::SireUnits::Dimension::Length ) const;
            dElectrostaticScaleFactor_function_type dElectrostaticScaleFactor_function_value( &::SireMM::HarmonicSwitchingFunction::dElectrostaticScaleFactor );
            
            HarmonicSwitchingFunction_exposer.def( 
                "dElectrostaticScaleFactor"
                , dElectrostaticScaleFactor_function_value
                , ( bp::arg("dist") ) );
        
        }
        { //::SireMM::HarmonicSwitchingFunction::dVDWScaleFactor
        
            typedef double ( ::SireMM::HarmonicSwitchingFunction::*dVDWScaleFactor_function_type )( ::SireUnits::Dimension::Length ) const;
            dVDWScaleFactor_function_type dVDWScaleFactor_function_value( &::SireMM::HarmonicSwitchingFunction::dVDWScaleFactor );
            
            HarmonicSwitchingFunction_exposer.def( 
                "dVDWScaleFactor"
                , dVDWScaleFactor_function_value
                , ( bp::arg("dist") ) );
        
        }
        { //::SireMM::HarmonicSwitchingFunction::electrostaticScaleFactor
        
            typedef double ( ::SireMM::HarmonicSwitchingFunction::*electrostaticScaleFactor_function_type )( ::SireUnits::Dimension::Length ) const;
            electrostaticScaleFactor_function_type electrostaticScaleFactor_function_value( &::SireMM::HarmonicSwitchingFunction::electrostaticScaleFactor );
            
            HarmonicSwitchingFunction_exposer.def( 
                "electrostaticScaleFactor"
                , electrostaticScaleFactor_function_value
                , ( bp::arg("dist") ) );
        
        }
        HarmonicSwitchingFunction_exposer.def( bp::self != bp::self );
        { //::SireMM::HarmonicSwitchingFunction::operator=
        
            typedef ::SireMM::HarmonicSwitchingFunction & ( ::SireMM::HarmonicSwitchingFunction::*assign_function_type )( ::SireMM::HarmonicSwitchingFunction const & ) ;
            assign_function_type assign_function_value( &::SireMM::HarmonicSwitchingFunction::operator= );
            
            HarmonicSwitchingFunction_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        HarmonicSwitchingFunction_exposer.def( bp::self == bp::self );
        { //::SireMM::HarmonicSwitchingFunction::toString
        
            typedef ::QString ( ::SireMM::HarmonicSwitchingFunction::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMM::HarmonicSwitchingFunction::toString );
            
            HarmonicSwitchingFunction_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMM::HarmonicSwitchingFunction::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::HarmonicSwitchingFunction::typeName );
            
            HarmonicSwitchingFunction_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMM::HarmonicSwitchingFunction::vdwScaleFactor
        
            typedef double ( ::SireMM::HarmonicSwitchingFunction::*vdwScaleFactor_function_type )( ::SireUnits::Dimension::Length ) const;
            vdwScaleFactor_function_type vdwScaleFactor_function_value( &::SireMM::HarmonicSwitchingFunction::vdwScaleFactor );
            
            HarmonicSwitchingFunction_exposer.def( 
                "vdwScaleFactor"
                , vdwScaleFactor_function_value
                , ( bp::arg("dist") ) );
        
        }
        HarmonicSwitchingFunction_exposer.staticmethod( "typeName" );
        HarmonicSwitchingFunction_exposer.def( "__copy__", &__copy__);
        HarmonicSwitchingFunction_exposer.def( "__deepcopy__", &__copy__);
        HarmonicSwitchingFunction_exposer.def( "clone", &__copy__);
        HarmonicSwitchingFunction_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::HarmonicSwitchingFunction >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        HarmonicSwitchingFunction_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::HarmonicSwitchingFunction >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        HarmonicSwitchingFunction_exposer.def( "__str__", &__str__< ::SireMM::HarmonicSwitchingFunction > );
        HarmonicSwitchingFunction_exposer.def( "__repr__", &__str__< ::SireMM::HarmonicSwitchingFunction > );
    }

}
예제 #2
0
void register_NoCutoff_class(){

    { //::SireMM::NoCutoff
        typedef bp::class_< SireMM::NoCutoff, bp::bases< SireMM::SwitchingFunction, SireBase::Property > > NoCutoff_exposer_t;
        NoCutoff_exposer_t NoCutoff_exposer = NoCutoff_exposer_t( "NoCutoff", "This class implements no cutoffs (e.g. there is no cutoff,\nand no switching function).\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
        bp::scope NoCutoff_scope( NoCutoff_exposer );
        NoCutoff_exposer.def( bp::init< SireMM::NoCutoff const & >(( bp::arg("other") ), "Copy constructor") );
        { //::SireMM::NoCutoff::dElectrostaticScaleFactor
        
            typedef double ( ::SireMM::NoCutoff::*dElectrostaticScaleFactor_function_type)( ::SireUnits::Dimension::Length ) const;
            dElectrostaticScaleFactor_function_type dElectrostaticScaleFactor_function_value( &::SireMM::NoCutoff::dElectrostaticScaleFactor );
            
            NoCutoff_exposer.def( 
                "dElectrostaticScaleFactor"
                , dElectrostaticScaleFactor_function_value
                , ( bp::arg("dist") )
                , "Return the derivative of the electrostatic scale factor - this\nwill always be 0 as there is no cutoff" );
        
        }
        { //::SireMM::NoCutoff::dVDWScaleFactor
        
            typedef double ( ::SireMM::NoCutoff::*dVDWScaleFactor_function_type)( ::SireUnits::Dimension::Length ) const;
            dVDWScaleFactor_function_type dVDWScaleFactor_function_value( &::SireMM::NoCutoff::dVDWScaleFactor );
            
            NoCutoff_exposer.def( 
                "dVDWScaleFactor"
                , dVDWScaleFactor_function_value
                , ( bp::arg("dist") )
                , "Return the derivative of the VDW scale factor - this will\nalways be 0 as there is no cutoff" );
        
        }
        { //::SireMM::NoCutoff::electrostaticScaleFactor
        
            typedef double ( ::SireMM::NoCutoff::*electrostaticScaleFactor_function_type)( ::SireUnits::Dimension::Length ) const;
            electrostaticScaleFactor_function_type electrostaticScaleFactor_function_value( &::SireMM::NoCutoff::electrostaticScaleFactor );
            
            NoCutoff_exposer.def( 
                "electrostaticScaleFactor"
                , electrostaticScaleFactor_function_value
                , ( bp::arg("dist") )
                , "Return the scale factor for the electrostatic energies - this\nwill always be 1.0, as there are no cutoffs" );
        
        }
        NoCutoff_exposer.def( bp::self != bp::self );
        { //::SireMM::NoCutoff::operator=
        
            typedef ::SireMM::NoCutoff & ( ::SireMM::NoCutoff::*assign_function_type)( ::SireMM::NoCutoff const & ) ;
            assign_function_type assign_function_value( &::SireMM::NoCutoff::operator= );
            
            NoCutoff_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        NoCutoff_exposer.def( bp::self == bp::self );
        { //::SireMM::NoCutoff::toString
        
            typedef ::QString ( ::SireMM::NoCutoff::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireMM::NoCutoff::toString );
            
            NoCutoff_exposer.def( 
                "toString"
                , toString_function_value
                , "Return a string representation of this switching function" );
        
        }
        { //::SireMM::NoCutoff::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::NoCutoff::typeName );
            
            NoCutoff_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireMM::NoCutoff::vdwScaleFactor
        
            typedef double ( ::SireMM::NoCutoff::*vdwScaleFactor_function_type)( ::SireUnits::Dimension::Length ) const;
            vdwScaleFactor_function_type vdwScaleFactor_function_value( &::SireMM::NoCutoff::vdwScaleFactor );
            
            NoCutoff_exposer.def( 
                "vdwScaleFactor"
                , vdwScaleFactor_function_value
                , ( bp::arg("dist") )
                , "Return the scale factor for the vdw energies - this\nwill always be 1.0, as there are no cutoffs" );
        
        }
        NoCutoff_exposer.staticmethod( "typeName" );
        NoCutoff_exposer.def( "__copy__", &__copy__);
        NoCutoff_exposer.def( "__deepcopy__", &__copy__);
        NoCutoff_exposer.def( "clone", &__copy__);
        NoCutoff_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::NoCutoff >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        NoCutoff_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::NoCutoff >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        NoCutoff_exposer.def( "__str__", &__str__< ::SireMM::NoCutoff > );
        NoCutoff_exposer.def( "__repr__", &__str__< ::SireMM::NoCutoff > );
    }

}