Exemplo n.º 1
0
void register_QMFF_class(){

    { //::Squire::QMFF
        typedef bp::class_< Squire::QMFF, bp::bases< SireFF::FF3D, SireFF::G1FF, SireFF::FF, SireMol::MolGroupsBase, SireBase::Property > > QMFF_exposer_t;
        QMFF_exposer_t QMFF_exposer = QMFF_exposer_t( "QMFF", bp::init< >() );
        bp::scope QMFF_scope( QMFF_exposer );
        QMFF_exposer.def( bp::init< QString const & >(( bp::arg("name") )) );
        QMFF_exposer.def( bp::init< Squire::QMFF const & >(( bp::arg("other") )) );
        { //::Squire::QMFF::components
        
            typedef ::Squire::QMComponent const & ( ::Squire::QMFF::*components_function_type )(  ) const;
            components_function_type components_function_value( &::Squire::QMFF::components );
            
            QMFF_exposer.def( 
                "components"
                , components_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::Squire::QMFF::containsProperty
        
            typedef bool ( ::Squire::QMFF::*containsProperty_function_type )( ::QString const & ) const;
            containsProperty_function_type containsProperty_function_value( &::Squire::QMFF::containsProperty );
            
            QMFF_exposer.def( 
                "containsProperty"
                , containsProperty_function_value
                , ( bp::arg("name") ) );
        
        }
        { //::Squire::QMFF::energy
        
            typedef void ( ::Squire::QMFF::*energy_function_type )( ::SireFF::EnergyTable &,double ) ;
            energy_function_type energy_function_value( &::Squire::QMFF::energy );
            
            QMFF_exposer.def( 
                "energy"
                , energy_function_value
                , ( bp::arg("energytable"), bp::arg("scale_energy")=1 ) );
        
        }
        { //::Squire::QMFF::energy
        
            typedef void ( ::Squire::QMFF::*energy_function_type )( ::SireFF::EnergyTable &,::SireCAS::Symbol const &,double ) ;
            energy_function_type energy_function_value( &::Squire::QMFF::energy );
            
            QMFF_exposer.def( 
                "energy"
                , energy_function_value
                , ( bp::arg("energytable"), bp::arg("symbol"), bp::arg("scale_energy")=1 ) );
        
        }
        { //::Squire::QMFF::energyCommandFile
        
            typedef ::QString ( ::Squire::QMFF::*energyCommandFile_function_type )(  ) const;
            energyCommandFile_function_type energyCommandFile_function_value( &::Squire::QMFF::energyCommandFile );
            
            QMFF_exposer.def( 
                "energyCommandFile"
                , energyCommandFile_function_value );
        
        }
        { //::Squire::QMFF::field
        
            typedef void ( ::Squire::QMFF::*field_function_type )( ::SireFF::FieldTable &,double ) ;
            field_function_type field_function_value( &::Squire::QMFF::field );
            
            QMFF_exposer.def( 
                "field"
                , field_function_value
                , ( bp::arg("fieldtable"), bp::arg("scale_field")=1 ) );
        
        }
        { //::Squire::QMFF::field
        
            typedef void ( ::Squire::QMFF::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,double ) ;
            field_function_type field_function_value( &::Squire::QMFF::field );
            
            QMFF_exposer.def( 
                "field"
                , field_function_value
                , ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("scale_field")=1 ) );
        
        }
        { //::Squire::QMFF::field
        
            typedef void ( ::Squire::QMFF::*field_function_type )( ::SireFF::FieldTable &,::SireFF::Probe const &,double ) ;
            field_function_type field_function_value( &::Squire::QMFF::field );
            
            QMFF_exposer.def( 
                "field"
                , field_function_value
                , ( bp::arg("fieldtable"), bp::arg("probe"), bp::arg("scale_field")=1 ) );
        
        }
        { //::Squire::QMFF::field
        
            typedef void ( ::Squire::QMFF::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ;
            field_function_type field_function_value( &::Squire::QMFF::field );
            
            QMFF_exposer.def( 
                "field"
                , field_function_value
                , ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_field")=1 ) );
        
        }
        { //::Squire::QMFF::fieldCommandFile
        
            typedef ::QString ( ::Squire::QMFF::*fieldCommandFile_function_type )( ::SireFF::FieldTable const & ) const;
            fieldCommandFile_function_type fieldCommandFile_function_value( &::Squire::QMFF::fieldCommandFile );
            
            QMFF_exposer.def( 
                "fieldCommandFile"
                , fieldCommandFile_function_value
                , ( bp::arg("fieldtable") ) );
        
        }
        { //::Squire::QMFF::fieldCommandFile
        
            typedef ::QString ( ::Squire::QMFF::*fieldCommandFile_function_type )( ::SireFF::FieldTable const &,::SireFF::Probe const & ) const;
            fieldCommandFile_function_type fieldCommandFile_function_value( &::Squire::QMFF::fieldCommandFile );
            
            QMFF_exposer.def( 
                "fieldCommandFile"
                , fieldCommandFile_function_value
                , ( bp::arg("fieldtable"), bp::arg("probe") ) );
        
        }
        { //::Squire::QMFF::force
        
            typedef void ( ::Squire::QMFF::*force_function_type )( ::SireFF::ForceTable &,double ) ;
            force_function_type force_function_value( &::Squire::QMFF::force );
            
            QMFF_exposer.def( 
                "force"
                , force_function_value
                , ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) );
        
        }
        { //::Squire::QMFF::force
        
            typedef void ( ::Squire::QMFF::*force_function_type )( ::SireFF::ForceTable &,::SireCAS::Symbol const &,double ) ;
            force_function_type force_function_value( &::Squire::QMFF::force );
            
            QMFF_exposer.def( 
                "force"
                , force_function_value
                , ( bp::arg("forcetable"), bp::arg("symbol"), bp::arg("scale_force")=1 ) );
        
        }
        { //::Squire::QMFF::forceCommandFile
        
            typedef ::QString ( ::Squire::QMFF::*forceCommandFile_function_type )( ::SireFF::ForceTable const & ) const;
            forceCommandFile_function_type forceCommandFile_function_value( &::Squire::QMFF::forceCommandFile );
            
            QMFF_exposer.def( 
                "forceCommandFile"
                , forceCommandFile_function_value
                , ( bp::arg("forcetable") ) );
        
        }
        { //::Squire::QMFF::mustNowRecalculateFromScratch
        
            typedef void ( ::Squire::QMFF::*mustNowRecalculateFromScratch_function_type )(  ) ;
            mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::Squire::QMFF::mustNowRecalculateFromScratch );
            
            QMFF_exposer.def( 
                "mustNowRecalculateFromScratch"
                , mustNowRecalculateFromScratch_function_value );
        
        }
        QMFF_exposer.def( bp::self != bp::self );
        { //::Squire::QMFF::operator=
        
            typedef ::Squire::QMFF & ( ::Squire::QMFF::*assign_function_type )( ::Squire::QMFF const & ) ;
            assign_function_type assign_function_value( &::Squire::QMFF::operator= );
            
            QMFF_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        QMFF_exposer.def( bp::self == bp::self );
        { //::Squire::QMFF::parameters
        
            typedef ::SireFF::detail::AtomicParameters3D< SireMol::Element > ( ::Squire::QMFF::*parameters_function_type )(  ) const;
            parameters_function_type parameters_function_value( &::Squire::QMFF::parameters );
            
            QMFF_exposer.def( 
                "parameters"
                , parameters_function_value );
        
        }
        { //::Squire::QMFF::potential
        
            typedef void ( ::Squire::QMFF::*potential_function_type )( ::SireFF::PotentialTable &,double ) ;
            potential_function_type potential_function_value( &::Squire::QMFF::potential );
            
            QMFF_exposer.def( 
                "potential"
                , potential_function_value
                , ( bp::arg("potentialtable"), bp::arg("scale_potential")=1 ) );
        
        }
        { //::Squire::QMFF::potential
        
            typedef void ( ::Squire::QMFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,double ) ;
            potential_function_type potential_function_value( &::Squire::QMFF::potential );
            
            QMFF_exposer.def( 
                "potential"
                , potential_function_value
                , ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("scale_potential")=1 ) );
        
        }
        { //::Squire::QMFF::potential
        
            typedef void ( ::Squire::QMFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireFF::Probe const &,double ) ;
            potential_function_type potential_function_value( &::Squire::QMFF::potential );
            
            QMFF_exposer.def( 
                "potential"
                , potential_function_value
                , ( bp::arg("potentialtable"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );
        
        }
        { //::Squire::QMFF::potential
        
            typedef void ( ::Squire::QMFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ;
            potential_function_type potential_function_value( &::Squire::QMFF::potential );
            
            QMFF_exposer.def( 
                "potential"
                , potential_function_value
                , ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );
        
        }
        { //::Squire::QMFF::potentialCommandFile
        
            typedef ::QString ( ::Squire::QMFF::*potentialCommandFile_function_type )( ::SireFF::PotentialTable const & ) const;
            potentialCommandFile_function_type potentialCommandFile_function_value( &::Squire::QMFF::potentialCommandFile );
            
            QMFF_exposer.def( 
                "potentialCommandFile"
                , potentialCommandFile_function_value
                , ( bp::arg("pottable") ) );
        
        }
        { //::Squire::QMFF::potentialCommandFile
        
            typedef ::QString ( ::Squire::QMFF::*potentialCommandFile_function_type )( ::SireFF::PotentialTable const &,::SireFF::Probe const & ) const;
            potentialCommandFile_function_type potentialCommandFile_function_value( &::Squire::QMFF::potentialCommandFile );
            
            QMFF_exposer.def( 
                "potentialCommandFile"
                , potentialCommandFile_function_value
                , ( bp::arg("pottable"), bp::arg("probe") ) );
        
        }
        { //::Squire::QMFF::properties
        
            typedef ::SireBase::Properties const & ( ::Squire::QMFF::*properties_function_type )(  ) const;
            properties_function_type properties_function_value( &::Squire::QMFF::properties );
            
            QMFF_exposer.def( 
                "properties"
                , properties_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::Squire::QMFF::property
        
            typedef ::SireBase::Property const & ( ::Squire::QMFF::*property_function_type )( ::QString const & ) const;
            property_function_type property_function_value( &::Squire::QMFF::property );
            
            QMFF_exposer.def( 
                "property"
                , property_function_value
                , ( bp::arg("name") )
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::Squire::QMFF::quantumProgram
        
            typedef ::Squire::QMProgram const & ( ::Squire::QMFF::*quantumProgram_function_type )(  ) const;
            quantumProgram_function_type quantumProgram_function_value( &::Squire::QMFF::quantumProgram );
            
            QMFF_exposer.def( 
                "quantumProgram"
                , quantumProgram_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::Squire::QMFF::setProperty
        
            typedef bool ( ::Squire::QMFF::*setProperty_function_type )( ::QString const &,::SireBase::Property const & ) ;
            setProperty_function_type setProperty_function_value( &::Squire::QMFF::setProperty );
            
            QMFF_exposer.def( 
                "setProperty"
                , setProperty_function_value
                , ( bp::arg("name"), bp::arg("property") ) );
        
        }
        { //::Squire::QMFF::setQuantumProgram
        
            typedef bool ( ::Squire::QMFF::*setQuantumProgram_function_type )( ::Squire::QMProgram const & ) ;
            setQuantumProgram_function_type setQuantumProgram_function_value( &::Squire::QMFF::setQuantumProgram );
            
            QMFF_exposer.def( 
                "setQuantumProgram"
                , setQuantumProgram_function_value
                , ( bp::arg("qmprog") ) );
        
        }
        { //::Squire::QMFF::setSpace
        
            typedef bool ( ::Squire::QMFF::*setSpace_function_type )( ::SireVol::Space const & ) ;
            setSpace_function_type setSpace_function_value( &::Squire::QMFF::setSpace );
            
            QMFF_exposer.def( 
                "setSpace"
                , setSpace_function_value
                , ( bp::arg("space") ) );
        
        }
        { //::Squire::QMFF::setZeroEnergy
        
            typedef bool ( ::Squire::QMFF::*setZeroEnergy_function_type )( ::SireUnits::Dimension::MolarEnergy ) ;
            setZeroEnergy_function_type setZeroEnergy_function_value( &::Squire::QMFF::setZeroEnergy );
            
            QMFF_exposer.def( 
                "setZeroEnergy"
                , setZeroEnergy_function_value
                , ( bp::arg("zero_energy") ) );
        
        }
        { //::Squire::QMFF::space
        
            typedef ::SireVol::Space const & ( ::Squire::QMFF::*space_function_type )(  ) const;
            space_function_type space_function_value( &::Squire::QMFF::space );
            
            QMFF_exposer.def( 
                "space"
                , space_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::Squire::QMFF::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::Squire::QMFF::typeName );
            
            QMFF_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::Squire::QMFF::what
        
            typedef char const * ( ::Squire::QMFF::*what_function_type )(  ) const;
            what_function_type what_function_value( &::Squire::QMFF::what );
            
            QMFF_exposer.def( 
                "what"
                , what_function_value );
        
        }
        { //::Squire::QMFF::zeroEnergy
        
            typedef ::SireUnits::Dimension::MolarEnergy ( ::Squire::QMFF::*zeroEnergy_function_type )(  ) const;
            zeroEnergy_function_type zeroEnergy_function_value( &::Squire::QMFF::zeroEnergy );
            
            QMFF_exposer.def( 
                "zeroEnergy"
                , zeroEnergy_function_value );
        
        }
        QMFF_exposer.staticmethod( "typeName" );
        QMFF_exposer.def( "__copy__", &__copy__);
        QMFF_exposer.def( "__deepcopy__", &__copy__);
        QMFF_exposer.def( "clone", &__copy__);
        QMFF_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::Squire::QMFF >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        QMFF_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::Squire::QMFF >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        QMFF_exposer.def( "__str__", &__str__< ::Squire::QMFF > );
        QMFF_exposer.def( "__repr__", &__str__< ::Squire::QMFF > );
        QMFF_exposer.def( "__len__", &__len_count< ::Squire::QMFF > );
    }

}
Exemplo n.º 2
0
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 > );
    }

}
Exemplo n.º 3
0
void register_CLJSoftFunction_class(){

    { //::SireMM::CLJSoftFunction
        typedef bp::class_< SireMM::CLJSoftFunction, bp::bases< SireMM::CLJCutoffFunction, SireMM::CLJFunction, SireBase::Property >, boost::noncopyable > CLJSoftFunction_exposer_t;
        CLJSoftFunction_exposer_t CLJSoftFunction_exposer = CLJSoftFunction_exposer_t( "CLJSoftFunction", "This is the base class of all soft-core CLJ functions that have a cutoff\n\nAuthor: Christopher Woods\n", bp::no_init );
        bp::scope CLJSoftFunction_scope( CLJSoftFunction_exposer );
        { //::SireMM::CLJSoftFunction::alpha
        
            typedef float ( ::SireMM::CLJSoftFunction::*alpha_function_type)(  ) const;
            alpha_function_type alpha_function_value( &::SireMM::CLJSoftFunction::alpha );
            
            CLJSoftFunction_exposer.def( 
                "alpha"
                , alpha_function_value
                , "Return the soft-core alpha value. A value of 0 is a completely hard\npotential, while increasing values of alpha will increasingly soften\nthe potential" );
        
        }
        { //::SireMM::CLJSoftFunction::containsProperty
        
            typedef bool ( ::SireMM::CLJSoftFunction::*containsProperty_function_type)( ::QString const & ) const;
            containsProperty_function_type containsProperty_function_value( &::SireMM::CLJSoftFunction::containsProperty );
            
            CLJSoftFunction_exposer.def( 
                "containsProperty"
                , containsProperty_function_value
                , ( bp::arg("name") )
                , "Return whether or not this function contains a property called name" );
        
        }
        { //::SireMM::CLJSoftFunction::coulombPower
        
            typedef float ( ::SireMM::CLJSoftFunction::*coulombPower_function_type)(  ) const;
            coulombPower_function_type coulombPower_function_value( &::SireMM::CLJSoftFunction::coulombPower );
            
            CLJSoftFunction_exposer.def( 
                "coulombPower"
                , coulombPower_function_value
                , "Return the soft-core coulomb_power parameter. This is used to soften\nthe electrostatic interactions" );
        
        }
        { //::SireMM::CLJSoftFunction::isSoftened
        
            typedef bool ( ::SireMM::CLJSoftFunction::*isSoftened_function_type)(  ) const;
            isSoftened_function_type isSoftened_function_value( &::SireMM::CLJSoftFunction::isSoftened );
            
            CLJSoftFunction_exposer.def( 
                "isSoftened"
                , isSoftened_function_value
                , "Return whether or not this is a softened function" );
        
        }
        { //::SireMM::CLJSoftFunction::properties
        
            typedef ::SireBase::Properties ( ::SireMM::CLJSoftFunction::*properties_function_type)(  ) const;
            properties_function_type properties_function_value( &::SireMM::CLJSoftFunction::properties );
            
            CLJSoftFunction_exposer.def( 
                "properties"
                , properties_function_value
                , "Return the properties that can be set in this function" );
        
        }
        { //::SireMM::CLJSoftFunction::property
        
            typedef ::SireBase::PropertyPtr ( ::SireMM::CLJSoftFunction::*property_function_type)( ::QString const & ) const;
            property_function_type property_function_value( &::SireMM::CLJSoftFunction::property );
            
            CLJSoftFunction_exposer.def( 
                "property"
                , property_function_value
                , ( bp::arg("name") )
                , "Return the value of the property with name name" );
        
        }
        { //::SireMM::CLJSoftFunction::setAlpha
        
            typedef void ( ::SireMM::CLJSoftFunction::*setAlpha_function_type)( float ) ;
            setAlpha_function_type setAlpha_function_value( &::SireMM::CLJSoftFunction::setAlpha );
            
            CLJSoftFunction_exposer.def( 
                "setAlpha"
                , setAlpha_function_value
                , ( bp::arg("alpha") )
                , "Set the soft-core alpha parameter" );
        
        }
        { //::SireMM::CLJSoftFunction::setCoulombPower
        
            typedef void ( ::SireMM::CLJSoftFunction::*setCoulombPower_function_type)( float ) ;
            setCoulombPower_function_type setCoulombPower_function_value( &::SireMM::CLJSoftFunction::setCoulombPower );
            
            CLJSoftFunction_exposer.def( 
                "setCoulombPower"
                , setCoulombPower_function_value
                , ( bp::arg("power") )
                , "Set the soft-core coulomb power parameter" );
        
        }
        { //::SireMM::CLJSoftFunction::setProperty
        
            typedef ::SireMM::CLJFunctionPtr ( ::SireMM::CLJSoftFunction::*setProperty_function_type)( ::QString const &,::SireBase::Property const & ) const;
            setProperty_function_type setProperty_function_value( &::SireMM::CLJSoftFunction::setProperty );
            
            CLJSoftFunction_exposer.def( 
                "setProperty"
                , setProperty_function_value
                , ( bp::arg("name"), bp::arg("value") )
                , "Set the property with name name to value value" );
        
        }
        { //::SireMM::CLJSoftFunction::setShiftDelta
        
            typedef void ( ::SireMM::CLJSoftFunction::*setShiftDelta_function_type)( float ) ;
            setShiftDelta_function_type setShiftDelta_function_value( &::SireMM::CLJSoftFunction::setShiftDelta );
            
            CLJSoftFunction_exposer.def( 
                "setShiftDelta"
                , setShiftDelta_function_value
                , ( bp::arg("shift") )
                , "Set the soft-core shift delta parameter" );
        
        }
        { //::SireMM::CLJSoftFunction::shiftDelta
        
            typedef float ( ::SireMM::CLJSoftFunction::*shiftDelta_function_type)(  ) const;
            shiftDelta_function_type shiftDelta_function_value( &::SireMM::CLJSoftFunction::shiftDelta );
            
            CLJSoftFunction_exposer.def( 
                "shiftDelta"
                , shiftDelta_function_value
                , "Return the soft-core shift_delta parameter. This is used to soften\nthe LJ interactions" );
        
        }
        { //::SireMM::CLJSoftFunction::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::CLJSoftFunction::typeName );
            
            CLJSoftFunction_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        CLJSoftFunction_exposer.staticmethod( "typeName" );
        CLJSoftFunction_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJSoftFunction >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJSoftFunction_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJSoftFunction >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJSoftFunction_exposer.def( "__str__", &__str__< ::SireMM::CLJSoftFunction > );
        CLJSoftFunction_exposer.def( "__repr__", &__str__< ::SireMM::CLJSoftFunction > );
    }

}
Exemplo n.º 4
0
void register_InterGroupCLJFFBase_class(){

    { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >
        typedef bp::class_< SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >, bp::bases< SireMM::CLJPotentialInterface<SireMM::InterCLJPotential>, SireFF::G2FF, SireFF::FF, SireMol::MolGroupsBase, SireBase::Property > > InterGroupCLJFFBase_exposer_t;
        InterGroupCLJFFBase_exposer_t InterGroupCLJFFBase_exposer = InterGroupCLJFFBase_exposer_t( "InterGroupCLJFFBase", "", bp::init< >("") );
        bp::scope InterGroupCLJFFBase_scope( InterGroupCLJFFBase_exposer );
        InterGroupCLJFFBase_exposer.def( bp::init< QString const & >(( bp::arg("name") ), "") );
        InterGroupCLJFFBase_exposer.def( bp::init< SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > const & >(( bp::arg("other") ), "") );
        { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::components
        
            typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t;
            typedef ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::Components const & ( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*components_function_type)(  ) const;
            components_function_type components_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::components );
            
            InterGroupCLJFFBase_exposer.def( 
                "components"
                , components_function_value
                , bp::return_value_policy<bp::clone_const_reference>()
                , "" );
        
        }
        { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::containsProperty
        
            typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t;
            typedef bool ( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*containsProperty_function_type)( ::QString const & ) const;
            containsProperty_function_type containsProperty_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::containsProperty );
            
            InterGroupCLJFFBase_exposer.def( 
                "containsProperty"
                , containsProperty_function_value
                , ( bp::arg("name") )
                , "" );
        
        }
        { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::mustNowRecalculateFromScratch
        
            typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t;
            typedef void ( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*mustNowRecalculateFromScratch_function_type)(  ) ;
            mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::mustNowRecalculateFromScratch );
            
            InterGroupCLJFFBase_exposer.def( 
                "mustNowRecalculateFromScratch"
                , mustNowRecalculateFromScratch_function_value
                , "" );
        
        }
        InterGroupCLJFFBase_exposer.def( bp::self != bp::self );
        { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::operator=
        
            typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t;
            typedef ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > & ( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*assign_function_type)( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > const & ) ;
            assign_function_type assign_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::operator= );
            
            InterGroupCLJFFBase_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        InterGroupCLJFFBase_exposer.def( bp::self == bp::self );
        { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::properties
        
            typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t;
            typedef ::SireBase::Properties const & ( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*properties_function_type)(  ) const;
            properties_function_type properties_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::properties );
            
            InterGroupCLJFFBase_exposer.def( 
                "properties"
                , properties_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::property
        
            typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t;
            typedef ::SireBase::Property const & ( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*property_function_type)( ::QString const & ) const;
            property_function_type property_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::property );
            
            InterGroupCLJFFBase_exposer.def( 
                "property"
                , property_function_value
                , ( bp::arg("name") )
                , bp::return_value_policy<bp::clone_const_reference>()
                , "" );
        
        }
        { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::setProperty
        
            typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t;
            typedef bool ( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*setProperty_function_type)( ::QString const &,::SireBase::Property const & ) ;
            setProperty_function_type setProperty_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::setProperty );
            
            InterGroupCLJFFBase_exposer.def( 
                "setProperty"
                , setProperty_function_value
                , ( bp::arg("name"), bp::arg("property") )
                , "" );
        
        }
        { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::typeName
        
            typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t;
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::typeName );
            
            InterGroupCLJFFBase_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::what
        
            typedef SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > > exported_class_t;
            typedef char const * ( ::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireFF::Inter2B2GFF< SireMM::CLJPotentialInterface< SireMM::InterCLJPotential > >::what );
            
            InterGroupCLJFFBase_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        InterGroupCLJFFBase_exposer.staticmethod( "typeName" );
        InterGroupCLJFFBase_exposer.def( "__copy__", &__copy__);
        InterGroupCLJFFBase_exposer.def( "__deepcopy__", &__copy__);
        InterGroupCLJFFBase_exposer.def( "clone", &__copy__);
        InterGroupCLJFFBase_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::Inter2B2GFF<SireMM::CLJPotentialInterface<SireMM::InterCLJPotential> > >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        InterGroupCLJFFBase_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::Inter2B2GFF<SireMM::CLJPotentialInterface<SireMM::InterCLJPotential> > >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        InterGroupCLJFFBase_exposer.def( "__str__", &__str__< ::SireFF::Inter2B2GFF<SireMM::CLJPotentialInterface<SireMM::InterCLJPotential> > > );
        InterGroupCLJFFBase_exposer.def( "__repr__", &__str__< ::SireFF::Inter2B2GFF<SireMM::CLJPotentialInterface<SireMM::InterCLJPotential> > > );
        InterGroupCLJFFBase_exposer.def( "__len__", &__len_count< ::SireFF::Inter2B2GFF<SireMM::CLJPotentialInterface<SireMM::InterCLJPotential> > > );
    }

}
void register_CLJPotentialInterface_IntraSoftCLJPotential__class(){

    { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >
        typedef bp::class_< SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >, boost::noncopyable > CLJPotentialInterface_IntraSoftCLJPotential__exposer_t;
        CLJPotentialInterface_IntraSoftCLJPotential__exposer_t CLJPotentialInterface_IntraSoftCLJPotential__exposer = CLJPotentialInterface_IntraSoftCLJPotential__exposer_t( "CLJPotentialInterface_IntraSoftCLJPotential_", "", bp::no_init );
        bp::scope CLJPotentialInterface_IntraSoftCLJPotential__scope( CLJPotentialInterface_IntraSoftCLJPotential__exposer );
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::combiningRules
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef ::QString const & ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*combiningRules_function_type)(  ) const;
            combiningRules_function_type combiningRules_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::combiningRules );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "combiningRules"
                , combiningRules_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::containsProperty
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef bool ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*containsProperty_function_type)( ::QString const & ) const;
            containsProperty_function_type containsProperty_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::containsProperty );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "containsProperty"
                , containsProperty_function_value
                , ( bp::arg("name") )
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::parameters
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef ::SireMM::IntraSoftCLJPotential::ParameterNames ( *parameters_function_type )(  );
            parameters_function_type parameters_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::parameters );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "parameters"
                , parameters_function_value
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::properties
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef ::SireBase::Properties const & ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*properties_function_type)(  ) const;
            properties_function_type properties_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::properties );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "properties"
                , properties_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::property
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef ::SireBase::Property const & ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*property_function_type)( ::QString const & ) const;
            property_function_type property_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::property );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "property"
                , property_function_value
                , ( bp::arg("name") )
                , bp::return_value_policy<bp::clone_const_reference>()
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::reactionFieldDielectric
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef double ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*reactionFieldDielectric_function_type)(  ) const;
            reactionFieldDielectric_function_type reactionFieldDielectric_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::reactionFieldDielectric );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "reactionFieldDielectric"
                , reactionFieldDielectric_function_value
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setCombiningRules
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef bool ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*setCombiningRules_function_type)( ::QString const & ) ;
            setCombiningRules_function_type setCombiningRules_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setCombiningRules );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "setCombiningRules"
                , setCombiningRules_function_value
                , ( bp::arg("combiningrules") )
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setProperty
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef bool ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*setProperty_function_type)( ::QString const &,::SireBase::Property const & ) ;
            setProperty_function_type setProperty_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setProperty );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "setProperty"
                , setProperty_function_value
                , ( bp::arg("name"), bp::arg("value") )
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setReactionFieldDielectric
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef bool ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*setReactionFieldDielectric_function_type)( double ) ;
            setReactionFieldDielectric_function_type setReactionFieldDielectric_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setReactionFieldDielectric );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "setReactionFieldDielectric"
                , setReactionFieldDielectric_function_value
                , ( bp::arg("dielectric") )
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setShiftElectrostatics
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef bool ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*setShiftElectrostatics_function_type)( bool ) ;
            setShiftElectrostatics_function_type setShiftElectrostatics_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setShiftElectrostatics );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "setShiftElectrostatics"
                , setShiftElectrostatics_function_value
                , ( bp::arg("switchelectro") )
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setSpace
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef bool ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*setSpace_function_type)( ::SireVol::Space const & ) ;
            setSpace_function_type setSpace_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setSpace );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "setSpace"
                , setSpace_function_value
                , ( bp::arg("new_space") )
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setSwitchingFunction
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef bool ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*setSwitchingFunction_function_type)( ::SireMM::SwitchingFunction const & ) ;
            setSwitchingFunction_function_type setSwitchingFunction_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setSwitchingFunction );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "setSwitchingFunction"
                , setSwitchingFunction_function_value
                , ( bp::arg("new_switchfunc") )
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setUseAtomisticCutoff
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef bool ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*setUseAtomisticCutoff_function_type)( bool ) ;
            setUseAtomisticCutoff_function_type setUseAtomisticCutoff_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setUseAtomisticCutoff );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "setUseAtomisticCutoff"
                , setUseAtomisticCutoff_function_value
                , ( bp::arg("switchatomistic") )
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setUseGroupCutoff
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef bool ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*setUseGroupCutoff_function_type)( bool ) ;
            setUseGroupCutoff_function_type setUseGroupCutoff_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setUseGroupCutoff );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "setUseGroupCutoff"
                , setUseGroupCutoff_function_value
                , ( bp::arg("switchgroup") )
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setUseReactionField
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef bool ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*setUseReactionField_function_type)( bool ) ;
            setUseReactionField_function_type setUseReactionField_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::setUseReactionField );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "setUseReactionField"
                , setUseReactionField_function_value
                , ( bp::arg("switchrf") )
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::shiftElectrostatics
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef bool ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*shiftElectrostatics_function_type)(  ) const;
            shiftElectrostatics_function_type shiftElectrostatics_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::shiftElectrostatics );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "shiftElectrostatics"
                , shiftElectrostatics_function_value
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::space
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef ::SireVol::Space const & ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*space_function_type)(  ) const;
            space_function_type space_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::space );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "space"
                , space_function_value
                , bp::return_value_policy<bp::clone_const_reference>()
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::switchingFunction
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef ::SireMM::SwitchingFunction const & ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*switchingFunction_function_type)(  ) const;
            switchingFunction_function_type switchingFunction_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::switchingFunction );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "switchingFunction"
                , switchingFunction_function_value
                , bp::return_value_policy<bp::clone_const_reference>()
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::useAtomisticCutoff
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef bool ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*useAtomisticCutoff_function_type)(  ) const;
            useAtomisticCutoff_function_type useAtomisticCutoff_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::useAtomisticCutoff );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "useAtomisticCutoff"
                , useAtomisticCutoff_function_value
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::useGroupCutoff
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef bool ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*useGroupCutoff_function_type)(  ) const;
            useGroupCutoff_function_type useGroupCutoff_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::useGroupCutoff );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "useGroupCutoff"
                , useGroupCutoff_function_value
                , "" );
        
        }
        { //::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::useReactionField
        
            typedef SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential > exported_class_t;
            typedef bool ( ::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::*useReactionField_function_type)(  ) const;
            useReactionField_function_type useReactionField_function_value( &::SireMM::CLJPotentialInterface< SireMM::IntraSoftCLJPotential >::useReactionField );
            
            CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( 
                "useReactionField"
                , useReactionField_function_value
                , "" );
        
        }
        CLJPotentialInterface_IntraSoftCLJPotential__exposer.staticmethod( "parameters" );
        CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJPotentialInterface<SireMM::IntraSoftCLJPotential> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJPotentialInterface<SireMM::IntraSoftCLJPotential> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( "__str__", &pvt_get_name);
        CLJPotentialInterface_IntraSoftCLJPotential__exposer.def( "__repr__", &pvt_get_name);
    }

}
Exemplo n.º 6
0
void register_PolariseChargesFF_class(){

    { //::SireSystem::PolariseChargesFF
        typedef bp::class_< SireSystem::PolariseChargesFF, bp::bases< SireFF::G1FF, SireFF::FF, SireMol::MolGroupsBase, SireBase::Property > > PolariseChargesFF_exposer_t;
        PolariseChargesFF_exposer_t PolariseChargesFF_exposer = PolariseChargesFF_exposer_t( "PolariseChargesFF", bp::init< >() );
        bp::scope PolariseChargesFF_scope( PolariseChargesFF_exposer );
        PolariseChargesFF_exposer.def( bp::init< SireSystem::PolariseCharges const & >(( bp::arg("constraint") )) );
        PolariseChargesFF_exposer.def( bp::init< QString const &, SireSystem::PolariseCharges const & >(( bp::arg("name"), bp::arg("constraint") )) );
        PolariseChargesFF_exposer.def( bp::init< SireSystem::PolariseChargesFF const & >(( bp::arg("other") )) );
        { //::SireSystem::PolariseChargesFF::components
        
            typedef ::SireFF::SingleComponent const & ( ::SireSystem::PolariseChargesFF::*components_function_type )(  ) const;
            components_function_type components_function_value( &::SireSystem::PolariseChargesFF::components );
            
            PolariseChargesFF_exposer.def( 
                "components"
                , components_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireSystem::PolariseChargesFF::containsProperty
        
            typedef bool ( ::SireSystem::PolariseChargesFF::*containsProperty_function_type )( ::QString const & ) const;
            containsProperty_function_type containsProperty_function_value( &::SireSystem::PolariseChargesFF::containsProperty );
            
            PolariseChargesFF_exposer.def( 
                "containsProperty"
                , containsProperty_function_value
                , ( bp::arg("name") ) );
        
        }
        { //::SireSystem::PolariseChargesFF::mustNowRecalculateFromScratch
        
            typedef void ( ::SireSystem::PolariseChargesFF::*mustNowRecalculateFromScratch_function_type )(  ) ;
            mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::SireSystem::PolariseChargesFF::mustNowRecalculateFromScratch );
            
            PolariseChargesFF_exposer.def( 
                "mustNowRecalculateFromScratch"
                , mustNowRecalculateFromScratch_function_value );
        
        }
        PolariseChargesFF_exposer.def( bp::self != bp::self );
        { //::SireSystem::PolariseChargesFF::operator=
        
            typedef ::SireSystem::PolariseChargesFF & ( ::SireSystem::PolariseChargesFF::*assign_function_type )( ::SireSystem::PolariseChargesFF const & ) ;
            assign_function_type assign_function_value( &::SireSystem::PolariseChargesFF::operator= );
            
            PolariseChargesFF_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        PolariseChargesFF_exposer.def( bp::self == bp::self );
        { //::SireSystem::PolariseChargesFF::properties
        
            typedef ::SireBase::Properties const & ( ::SireSystem::PolariseChargesFF::*properties_function_type )(  ) const;
            properties_function_type properties_function_value( &::SireSystem::PolariseChargesFF::properties );
            
            PolariseChargesFF_exposer.def( 
                "properties"
                , properties_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireSystem::PolariseChargesFF::property
        
            typedef ::SireBase::Property const & ( ::SireSystem::PolariseChargesFF::*property_function_type )( ::QString const & ) const;
            property_function_type property_function_value( &::SireSystem::PolariseChargesFF::property );
            
            PolariseChargesFF_exposer.def( 
                "property"
                , property_function_value
                , ( bp::arg("name") )
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireSystem::PolariseChargesFF::setProperty
        
            typedef bool ( ::SireSystem::PolariseChargesFF::*setProperty_function_type )( ::QString const &,::SireBase::Property const & ) ;
            setProperty_function_type setProperty_function_value( &::SireSystem::PolariseChargesFF::setProperty );
            
            PolariseChargesFF_exposer.def( 
                "setProperty"
                , setProperty_function_value
                , ( bp::arg("name"), bp::arg("property") ) );
        
        }
        { //::SireSystem::PolariseChargesFF::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireSystem::PolariseChargesFF::typeName );
            
            PolariseChargesFF_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        PolariseChargesFF_exposer.staticmethod( "typeName" );
        PolariseChargesFF_exposer.def( "__copy__", &__copy__);
        PolariseChargesFF_exposer.def( "__deepcopy__", &__copy__);
        PolariseChargesFF_exposer.def( "clone", &__copy__);
        PolariseChargesFF_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::PolariseChargesFF >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        PolariseChargesFF_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::PolariseChargesFF >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        PolariseChargesFF_exposer.def( "__str__", &__str__< ::SireSystem::PolariseChargesFF > );
        PolariseChargesFF_exposer.def( "__repr__", &__str__< ::SireSystem::PolariseChargesFF > );
        PolariseChargesFF_exposer.def( "__len__", &__len_count< ::SireSystem::PolariseChargesFF > );
    }

}
void register_CoulombPotentialInterface_InterCoulombPotential__class(){

    { //::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >
        typedef bp::class_< SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >, boost::noncopyable > CoulombPotentialInterface_InterCoulombPotential__exposer_t;
        CoulombPotentialInterface_InterCoulombPotential__exposer_t CoulombPotentialInterface_InterCoulombPotential__exposer = CoulombPotentialInterface_InterCoulombPotential__exposer_t( "CoulombPotentialInterface_InterCoulombPotential_", "", bp::no_init );
        bp::scope CoulombPotentialInterface_InterCoulombPotential__scope( CoulombPotentialInterface_InterCoulombPotential__exposer );
        { //::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::containsProperty
        
            typedef SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential > exported_class_t;
            typedef bool ( ::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::*containsProperty_function_type)( ::QString const & ) const;
            containsProperty_function_type containsProperty_function_value( &::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::containsProperty );
            
            CoulombPotentialInterface_InterCoulombPotential__exposer.def( 
                "containsProperty"
                , containsProperty_function_value
                , ( bp::arg("name") )
                , "" );
        
        }
        { //::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::parameters
        
            typedef SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential > exported_class_t;
            typedef ::SireMM::InterCoulombPotential::ParameterNames ( *parameters_function_type )(  );
            parameters_function_type parameters_function_value( &::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::parameters );
            
            CoulombPotentialInterface_InterCoulombPotential__exposer.def( 
                "parameters"
                , parameters_function_value
                , "" );
        
        }
        { //::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::properties
        
            typedef SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential > exported_class_t;
            typedef ::SireBase::Properties const & ( ::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::*properties_function_type)(  ) const;
            properties_function_type properties_function_value( &::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::properties );
            
            CoulombPotentialInterface_InterCoulombPotential__exposer.def( 
                "properties"
                , properties_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::property
        
            typedef SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential > exported_class_t;
            typedef ::SireBase::Property const & ( ::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::*property_function_type)( ::QString const & ) const;
            property_function_type property_function_value( &::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::property );
            
            CoulombPotentialInterface_InterCoulombPotential__exposer.def( 
                "property"
                , property_function_value
                , ( bp::arg("name") )
                , bp::return_value_policy<bp::clone_const_reference>()
                , "" );
        
        }
        { //::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::setProperty
        
            typedef SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential > exported_class_t;
            typedef bool ( ::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::*setProperty_function_type)( ::QString const &,::SireBase::Property const & ) ;
            setProperty_function_type setProperty_function_value( &::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::setProperty );
            
            CoulombPotentialInterface_InterCoulombPotential__exposer.def( 
                "setProperty"
                , setProperty_function_value
                , ( bp::arg("name"), bp::arg("value") )
                , "" );
        
        }
        { //::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::setShiftElectrostatics
        
            typedef SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential > exported_class_t;
            typedef bool ( ::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::*setShiftElectrostatics_function_type)( bool ) ;
            setShiftElectrostatics_function_type setShiftElectrostatics_function_value( &::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::setShiftElectrostatics );
            
            CoulombPotentialInterface_InterCoulombPotential__exposer.def( 
                "setShiftElectrostatics"
                , setShiftElectrostatics_function_value
                , ( bp::arg("switchelectro") )
                , "" );
        
        }
        { //::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::setSpace
        
            typedef SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential > exported_class_t;
            typedef bool ( ::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::*setSpace_function_type)( ::SireVol::Space const & ) ;
            setSpace_function_type setSpace_function_value( &::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::setSpace );
            
            CoulombPotentialInterface_InterCoulombPotential__exposer.def( 
                "setSpace"
                , setSpace_function_value
                , ( bp::arg("new_space") )
                , "" );
        
        }
        { //::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::setSwitchingFunction
        
            typedef SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential > exported_class_t;
            typedef bool ( ::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::*setSwitchingFunction_function_type)( ::SireMM::SwitchingFunction const & ) ;
            setSwitchingFunction_function_type setSwitchingFunction_function_value( &::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::setSwitchingFunction );
            
            CoulombPotentialInterface_InterCoulombPotential__exposer.def( 
                "setSwitchingFunction"
                , setSwitchingFunction_function_value
                , ( bp::arg("new_switchfunc") )
                , "" );
        
        }
        { //::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::shiftElectrostatics
        
            typedef SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential > exported_class_t;
            typedef bool ( ::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::*shiftElectrostatics_function_type)(  ) const;
            shiftElectrostatics_function_type shiftElectrostatics_function_value( &::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::shiftElectrostatics );
            
            CoulombPotentialInterface_InterCoulombPotential__exposer.def( 
                "shiftElectrostatics"
                , shiftElectrostatics_function_value
                , "" );
        
        }
        { //::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::space
        
            typedef SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential > exported_class_t;
            typedef ::SireVol::Space const & ( ::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::*space_function_type)(  ) const;
            space_function_type space_function_value( &::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::space );
            
            CoulombPotentialInterface_InterCoulombPotential__exposer.def( 
                "space"
                , space_function_value
                , bp::return_value_policy<bp::clone_const_reference>()
                , "" );
        
        }
        { //::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::switchingFunction
        
            typedef SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential > exported_class_t;
            typedef ::SireMM::SwitchingFunction const & ( ::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::*switchingFunction_function_type)(  ) const;
            switchingFunction_function_type switchingFunction_function_value( &::SireMM::CoulombPotentialInterface< SireMM::InterCoulombPotential >::switchingFunction );
            
            CoulombPotentialInterface_InterCoulombPotential__exposer.def( 
                "switchingFunction"
                , switchingFunction_function_value
                , bp::return_value_policy<bp::clone_const_reference>()
                , "" );
        
        }
        CoulombPotentialInterface_InterCoulombPotential__exposer.staticmethod( "parameters" );
        CoulombPotentialInterface_InterCoulombPotential__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CoulombPotentialInterface<SireMM::InterCoulombPotential> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CoulombPotentialInterface_InterCoulombPotential__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CoulombPotentialInterface<SireMM::InterCoulombPotential> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CoulombPotentialInterface_InterCoulombPotential__exposer.def( "__str__", &pvt_get_name);
        CoulombPotentialInterface_InterCoulombPotential__exposer.def( "__repr__", &pvt_get_name);
    }

}
void register_CLJSoftIntraRFFunction_class(){

    { //::SireMM::CLJSoftIntraRFFunction
        typedef bp::class_< SireMM::CLJSoftIntraRFFunction, bp::bases< SireMM::CLJSoftIntraFunction, SireMM::CLJIntraFunction, SireMM::CLJCutoffFunction, SireMM::CLJFunction, SireBase::Property > > CLJSoftIntraRFFunction_exposer_t;
        CLJSoftIntraRFFunction_exposer_t CLJSoftIntraRFFunction_exposer = CLJSoftIntraRFFunction_exposer_t( "CLJSoftIntraRFFunction", bp::init< >() );
        bp::scope CLJSoftIntraRFFunction_scope( CLJSoftIntraRFFunction_exposer );
        CLJSoftIntraRFFunction_exposer.def( bp::init< SireUnits::Dimension::Length >(( bp::arg("cutoff") )) );
        CLJSoftIntraRFFunction_exposer.def( bp::init< SireUnits::Dimension::Length, SireUnits::Dimension::Length >(( bp::arg("coul_cutoff"), bp::arg("lj_cutoff") )) );
        CLJSoftIntraRFFunction_exposer.def( bp::init< SireVol::Space const &, SireUnits::Dimension::Length >(( bp::arg("space"), bp::arg("cutoff") )) );
        CLJSoftIntraRFFunction_exposer.def( bp::init< SireVol::Space const &, SireUnits::Dimension::Length, SireUnits::Dimension::Length >(( bp::arg("space"), bp::arg("coul_cutoff"), bp::arg("lj_cutoff") )) );
        CLJSoftIntraRFFunction_exposer.def( bp::init< SireUnits::Dimension::Length, SireMM::CLJFunction::COMBINING_RULES >(( bp::arg("cutoff"), bp::arg("combining_rules") )) );
        CLJSoftIntraRFFunction_exposer.def( bp::init< SireUnits::Dimension::Length, SireUnits::Dimension::Length, SireMM::CLJFunction::COMBINING_RULES >(( bp::arg("coul_cutoff"), bp::arg("lj_cutoff"), bp::arg("combining_rules") )) );
        CLJSoftIntraRFFunction_exposer.def( bp::init< SireVol::Space const &, SireMM::CLJFunction::COMBINING_RULES >(( bp::arg("space"), bp::arg("combining_rules") )) );
        CLJSoftIntraRFFunction_exposer.def( bp::init< SireVol::Space const &, SireUnits::Dimension::Length, SireMM::CLJFunction::COMBINING_RULES >(( bp::arg("space"), bp::arg("cutoff"), bp::arg("combining_rules") )) );
        CLJSoftIntraRFFunction_exposer.def( bp::init< SireVol::Space const &, SireUnits::Dimension::Length, SireUnits::Dimension::Length, SireMM::CLJFunction::COMBINING_RULES >(( bp::arg("space"), bp::arg("coul_cutoff"), bp::arg("lj_cutoff"), bp::arg("combining_rules") )) );
        CLJSoftIntraRFFunction_exposer.def( bp::init< SireMM::CLJSoftIntraRFFunction const & >(( bp::arg("other") )) );
        { //::SireMM::CLJSoftIntraRFFunction::containsProperty
        
            typedef bool ( ::SireMM::CLJSoftIntraRFFunction::*containsProperty_function_type )( ::QString const & ) const;
            containsProperty_function_type containsProperty_function_value( &::SireMM::CLJSoftIntraRFFunction::containsProperty );
            
            CLJSoftIntraRFFunction_exposer.def( 
                "containsProperty"
                , containsProperty_function_value
                , ( bp::arg("name") ) );
        
        }
        { //::SireMM::CLJSoftIntraRFFunction::defaultRFFunction
        
            typedef ::SireMM::CLJFunctionPtr ( *defaultRFFunction_function_type )(  );
            defaultRFFunction_function_type defaultRFFunction_function_value( &::SireMM::CLJSoftIntraRFFunction::defaultRFFunction );
            
            CLJSoftIntraRFFunction_exposer.def( 
                "defaultRFFunction"
                , defaultRFFunction_function_value );
        
        }
        { //::SireMM::CLJSoftIntraRFFunction::dielectric
        
            typedef float ( ::SireMM::CLJSoftIntraRFFunction::*dielectric_function_type )(  ) const;
            dielectric_function_type dielectric_function_value( &::SireMM::CLJSoftIntraRFFunction::dielectric );
            
            CLJSoftIntraRFFunction_exposer.def( 
                "dielectric"
                , dielectric_function_value );
        
        }
        CLJSoftIntraRFFunction_exposer.def( bp::self != bp::self );
        { //::SireMM::CLJSoftIntraRFFunction::operator=
        
            typedef ::SireMM::CLJSoftIntraRFFunction & ( ::SireMM::CLJSoftIntraRFFunction::*assign_function_type )( ::SireMM::CLJSoftIntraRFFunction const & ) ;
            assign_function_type assign_function_value( &::SireMM::CLJSoftIntraRFFunction::operator= );
            
            CLJSoftIntraRFFunction_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        CLJSoftIntraRFFunction_exposer.def( bp::self == bp::self );
        { //::SireMM::CLJSoftIntraRFFunction::properties
        
            typedef ::SireBase::Properties ( ::SireMM::CLJSoftIntraRFFunction::*properties_function_type )(  ) const;
            properties_function_type properties_function_value( &::SireMM::CLJSoftIntraRFFunction::properties );
            
            CLJSoftIntraRFFunction_exposer.def( 
                "properties"
                , properties_function_value );
        
        }
        { //::SireMM::CLJSoftIntraRFFunction::property
        
            typedef ::SireBase::PropertyPtr ( ::SireMM::CLJSoftIntraRFFunction::*property_function_type )( ::QString const & ) const;
            property_function_type property_function_value( &::SireMM::CLJSoftIntraRFFunction::property );
            
            CLJSoftIntraRFFunction_exposer.def( 
                "property"
                , property_function_value
                , ( bp::arg("name") ) );
        
        }
        { //::SireMM::CLJSoftIntraRFFunction::setDielectric
        
            typedef void ( ::SireMM::CLJSoftIntraRFFunction::*setDielectric_function_type )( float ) ;
            setDielectric_function_type setDielectric_function_value( &::SireMM::CLJSoftIntraRFFunction::setDielectric );
            
            CLJSoftIntraRFFunction_exposer.def( 
                "setDielectric"
                , setDielectric_function_value
                , ( bp::arg("dielectric") ) );
        
        }
        { //::SireMM::CLJSoftIntraRFFunction::setProperty
        
            typedef ::SireMM::CLJFunctionPtr ( ::SireMM::CLJSoftIntraRFFunction::*setProperty_function_type )( ::QString const &,::SireBase::Property const & ) const;
            setProperty_function_type setProperty_function_value( &::SireMM::CLJSoftIntraRFFunction::setProperty );
            
            CLJSoftIntraRFFunction_exposer.def( 
                "setProperty"
                , setProperty_function_value
                , ( bp::arg("name"), bp::arg("value") ) );
        
        }
        { //::SireMM::CLJSoftIntraRFFunction::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::CLJSoftIntraRFFunction::typeName );
            
            CLJSoftIntraRFFunction_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMM::CLJSoftIntraRFFunction::what
        
            typedef char const * ( ::SireMM::CLJSoftIntraRFFunction::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMM::CLJSoftIntraRFFunction::what );
            
            CLJSoftIntraRFFunction_exposer.def( 
                "what"
                , what_function_value );
        
        }
        CLJSoftIntraRFFunction_exposer.staticmethod( "defaultRFFunction" );
        CLJSoftIntraRFFunction_exposer.staticmethod( "typeName" );
        CLJSoftIntraRFFunction_exposer.def( "__copy__", &__copy__);
        CLJSoftIntraRFFunction_exposer.def( "__deepcopy__", &__copy__);
        CLJSoftIntraRFFunction_exposer.def( "clone", &__copy__);
        CLJSoftIntraRFFunction_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJSoftIntraRFFunction >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJSoftIntraRFFunction_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJSoftIntraRFFunction >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJSoftIntraRFFunction_exposer.def( "__str__", &__str__< ::SireMM::CLJSoftIntraRFFunction > );
        CLJSoftIntraRFFunction_exposer.def( "__repr__", &__str__< ::SireMM::CLJSoftIntraRFFunction > );
    }

}
Exemplo n.º 9
0
void register_IntraFF_class(){

    { //::SireMM::IntraFF
        typedef bp::class_< SireMM::IntraFF, bp::bases< SireFF::G1FF, SireFF::FF, SireMol::MolGroupsBase, SireBase::Property > > IntraFF_exposer_t;
        IntraFF_exposer_t IntraFF_exposer = IntraFF_exposer_t( "IntraFF", "This forcefield is used to calculate the intramolecular\ncoulomb and LJ energy of the contained molecules. Note\nthat this is the coulomb and LJ energy of the non-bonded\natoms only, i.e. it does not contain the scaled\n1-4 coulomb and LJ energies. These should be calculated\nseparately, e.g. via additional terms added to InternalFF\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
        bp::scope IntraFF_scope( IntraFF_exposer );
        IntraFF_exposer.def( bp::init< QString const & >(( bp::arg("name") ), "Construct, specifying the name of the forcefield") );
        IntraFF_exposer.def( bp::init< SireMM::IntraFF const & >(( bp::arg("other") ), "Copy constructor") );
        { //::SireMM::IntraFF::accept
        
            typedef void ( ::SireMM::IntraFF::*accept_function_type)(  ) ;
            accept_function_type accept_function_value( &::SireMM::IntraFF::accept );
            
            IntraFF_exposer.def( 
                "accept"
                , accept_function_value
                , "Tell the forcefield that the last move was accepted. This tells the\nforcefield to make permanent any temporary changes that were used a workspace\nto avoid memory allocation during a move" );
        
        }
        { //::SireMM::IntraFF::cljFunction
        
            typedef ::SireMM::CLJIntraFunction const & ( ::SireMM::IntraFF::*cljFunction_function_type)(  ) const;
            cljFunction_function_type cljFunction_function_value( &::SireMM::IntraFF::cljFunction );
            
            IntraFF_exposer.def( 
                "cljFunction"
                , cljFunction_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the function used to calculate the energy" );
        
        }
        { //::SireMM::IntraFF::cljFunction
        
            typedef ::SireMM::CLJIntraFunction const & ( ::SireMM::IntraFF::*cljFunction_function_type)( ::QString ) const;
            cljFunction_function_type cljFunction_function_value( &::SireMM::IntraFF::cljFunction );
            
            IntraFF_exposer.def( 
                "cljFunction"
                , cljFunction_function_value
                , ( bp::arg("key") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the CLJFunction associated with the passed key" );
        
        }
        { //::SireMM::IntraFF::cljFunctionKeys
        
            typedef ::QStringList ( ::SireMM::IntraFF::*cljFunctionKeys_function_type)(  ) const;
            cljFunctionKeys_function_type cljFunctionKeys_function_value( &::SireMM::IntraFF::cljFunctionKeys );
            
            IntraFF_exposer.def( 
                "cljFunctionKeys"
                , cljFunctionKeys_function_value
                , "Return the keys of all CLJFunctions added to this forcefield" );
        
        }
        { //::SireMM::IntraFF::cljFunctions
        
            typedef ::QHash< QString, SireBase::PropPtr< SireMM::CLJFunction > > ( ::SireMM::IntraFF::*cljFunctions_function_type)(  ) const;
            cljFunctions_function_type cljFunctions_function_value( &::SireMM::IntraFF::cljFunctions );
            
            IntraFF_exposer.def( 
                "cljFunctions"
                , cljFunctions_function_value
                , "Return the hash of all CLJFunctions in this forcefield, indexed by their key" );
        
        }
        { //::SireMM::IntraFF::components
        
            typedef ::SireMM::MultiCLJComponent const & ( ::SireMM::IntraFF::*components_function_type)(  ) const;
            components_function_type components_function_value( &::SireMM::IntraFF::components );
            
            IntraFF_exposer.def( 
                "components"
                , components_function_value
                , bp::return_value_policy<bp::clone_const_reference>()
                , "Return the energy components of this forcefield" );
        
        }
        { //::SireMM::IntraFF::containsProperty
        
            typedef bool ( ::SireMM::IntraFF::*containsProperty_function_type)( ::QString const & ) const;
            containsProperty_function_type containsProperty_function_value( &::SireMM::IntraFF::containsProperty );
            
            IntraFF_exposer.def( 
                "containsProperty"
                , containsProperty_function_value
                , ( bp::arg("name") )
                , "Return whether or not this forcefield contains the property property" );
        
        }
        { //::SireMM::IntraFF::disableParallelCalculation
        
            typedef void ( ::SireMM::IntraFF::*disableParallelCalculation_function_type)(  ) ;
            disableParallelCalculation_function_type disableParallelCalculation_function_value( &::SireMM::IntraFF::disableParallelCalculation );
            
            IntraFF_exposer.def( 
                "disableParallelCalculation"
                , disableParallelCalculation_function_value
                , "Turn off use of a multicore parallel calculation of the energy.\nThis may be quicker if you have few atoms in the forcefield,\nor if you are only planning on allocating one core per forcefield" );
        
        }
        { //::SireMM::IntraFF::disableReproducibleCalculation
        
            typedef void ( ::SireMM::IntraFF::*disableReproducibleCalculation_function_type)(  ) ;
            disableReproducibleCalculation_function_type disableReproducibleCalculation_function_value( &::SireMM::IntraFF::disableReproducibleCalculation );
            
            IntraFF_exposer.def( 
                "disableReproducibleCalculation"
                , disableReproducibleCalculation_function_value
                , "Turn off an energy summing algorithm that guarantees the same energy\nregardless of whether a single core or multicore calculation is being\nperformed (i.e. rounding errors in both cases will not be identical)" );
        
        }
        { //::SireMM::IntraFF::enableParallelCalculation
        
            typedef void ( ::SireMM::IntraFF::*enableParallelCalculation_function_type)(  ) ;
            enableParallelCalculation_function_type enableParallelCalculation_function_value( &::SireMM::IntraFF::enableParallelCalculation );
            
            IntraFF_exposer.def( 
                "enableParallelCalculation"
                , enableParallelCalculation_function_value
                , "Turn on use of a multicore parallel calculation of the energy.\nThis is on by default, and spreads the energy calculations over\navailable cores" );
        
        }
        { //::SireMM::IntraFF::enableReproducibleCalculation
        
            typedef void ( ::SireMM::IntraFF::*enableReproducibleCalculation_function_type)(  ) ;
            enableReproducibleCalculation_function_type enableReproducibleCalculation_function_value( &::SireMM::IntraFF::enableReproducibleCalculation );
            
            IntraFF_exposer.def( 
                "enableReproducibleCalculation"
                , enableReproducibleCalculation_function_value
                , "Turn on an energy summing algorithm that guarantees the same energy\nregardless of whether a single core or multicore calculation is being\nperformed (i.e. rounding errors in both cases will be identical)" );
        
        }
        { //::SireMM::IntraFF::mustNowRecalculateFromScratch
        
            typedef void ( ::SireMM::IntraFF::*mustNowRecalculateFromScratch_function_type)(  ) ;
            mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::SireMM::IntraFF::mustNowRecalculateFromScratch );
            
            IntraFF_exposer.def( 
                "mustNowRecalculateFromScratch"
                , mustNowRecalculateFromScratch_function_value
                , "Signal that this forcefield must now be recalculated from scratch" );
        
        }
        { //::SireMM::IntraFF::nCLJFunctions
        
            typedef int ( ::SireMM::IntraFF::*nCLJFunctions_function_type)(  ) const;
            nCLJFunctions_function_type nCLJFunctions_function_value( &::SireMM::IntraFF::nCLJFunctions );
            
            IntraFF_exposer.def( 
                "nCLJFunctions"
                , nCLJFunctions_function_value
                , "Return the number of CLJ functions in this forcefield. There should always\nbe at least one" );
        
        }
        { //::SireMM::IntraFF::needsAccepting
        
            typedef bool ( ::SireMM::IntraFF::*needsAccepting_function_type)(  ) const;
            needsAccepting_function_type needsAccepting_function_value( &::SireMM::IntraFF::needsAccepting );
            
            IntraFF_exposer.def( 
                "needsAccepting"
                , needsAccepting_function_value
                , "Return whether or not this forcefield is using a temporary workspace that\nneeds to be accepted" );
        
        }
        IntraFF_exposer.def( bp::self != bp::self );
        { //::SireMM::IntraFF::operator=
        
            typedef ::SireMM::IntraFF & ( ::SireMM::IntraFF::*assign_function_type)( ::SireMM::IntraFF const & ) ;
            assign_function_type assign_function_value( &::SireMM::IntraFF::operator= );
            
            IntraFF_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        IntraFF_exposer.def( bp::self == bp::self );
        { //::SireMM::IntraFF::properties
        
            typedef ::SireBase::Properties const & ( ::SireMM::IntraFF::*properties_function_type)(  ) const;
            properties_function_type properties_function_value( &::SireMM::IntraFF::properties );
            
            IntraFF_exposer.def( 
                "properties"
                , properties_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return all of the properties of this function" );
        
        }
        { //::SireMM::IntraFF::property
        
            typedef ::SireBase::Property const & ( ::SireMM::IntraFF::*property_function_type)( ::QString const & ) const;
            property_function_type property_function_value( &::SireMM::IntraFF::property );
            
            IntraFF_exposer.def( 
                "property"
                , property_function_value
                , ( bp::arg("name") )
                , bp::return_value_policy<bp::clone_const_reference>()
                , "Return the value of the forcefield property with name name" );
        
        }
        { //::SireMM::IntraFF::removeAllCLJFunctions
        
            typedef void ( ::SireMM::IntraFF::*removeAllCLJFunctions_function_type)(  ) ;
            removeAllCLJFunctions_function_type removeAllCLJFunctions_function_value( &::SireMM::IntraFF::removeAllCLJFunctions );
            
            IntraFF_exposer.def( 
                "removeAllCLJFunctions"
                , removeAllCLJFunctions_function_value
                , "Function to remove all of the CLJFunctions (except for the default function)" );
        
        }
        { //::SireMM::IntraFF::removeCLJFunctionAt
        
            typedef void ( ::SireMM::IntraFF::*removeCLJFunctionAt_function_type)( ::QString ) ;
            removeCLJFunctionAt_function_type removeCLJFunctionAt_function_value( &::SireMM::IntraFF::removeCLJFunctionAt );
            
            IntraFF_exposer.def( 
                "removeCLJFunctionAt"
                , removeCLJFunctionAt_function_value
                , ( bp::arg("key") )
                , "Remove the CLJ function with key key - note that you cannot remove\nthe default CLJ function" );
        
        }
        { //::SireMM::IntraFF::setCLJFunction
        
            typedef void ( ::SireMM::IntraFF::*setCLJFunction_function_type)( ::SireMM::CLJIntraFunction const & ) ;
            setCLJFunction_function_type setCLJFunction_function_value( &::SireMM::IntraFF::setCLJFunction );
            
            IntraFF_exposer.def( 
                "setCLJFunction"
                , setCLJFunction_function_value
                , ( bp::arg("cljfunc") )
                , "Function used to set the CLJIntraFunction used to calculate\nthe intramolecular energy" );
        
        }
        { //::SireMM::IntraFF::setCLJFunction
        
            typedef void ( ::SireMM::IntraFF::*setCLJFunction_function_type)( ::QString,::SireMM::CLJIntraFunction const & ) ;
            setCLJFunction_function_type setCLJFunction_function_value( &::SireMM::IntraFF::setCLJFunction );
            
            IntraFF_exposer.def( 
                "setCLJFunction"
                , setCLJFunction_function_value
                , ( bp::arg("key"), bp::arg("cljfunc") )
                , "Set the CLJFunction with key key equal to cljfunc" );
        
        }
        { //::SireMM::IntraFF::setProperty
        
            typedef bool ( ::SireMM::IntraFF::*setProperty_function_type)( ::QString const &,::SireBase::Property const & ) ;
            setProperty_function_type setProperty_function_value( &::SireMM::IntraFF::setProperty );
            
            IntraFF_exposer.def( 
                "setProperty"
                , setProperty_function_value
                , ( bp::arg("name"), bp::arg("property") )
                , "Set the forcefield property called name to the value property. Note that\nthis only affects the default CLJFunction. Additional functions must\nbe configured before adding them to the forcefield" );
        
        }
        { //::SireMM::IntraFF::setUseParallelCalculation
        
            typedef void ( ::SireMM::IntraFF::*setUseParallelCalculation_function_type)( bool ) ;
            setUseParallelCalculation_function_type setUseParallelCalculation_function_value( &::SireMM::IntraFF::setUseParallelCalculation );
            
            IntraFF_exposer.def( 
                "setUseParallelCalculation"
                , setUseParallelCalculation_function_value
                , ( bp::arg("on") )
                , "Set whether or not to use a multicore parallel algorithm\nto calculate the energy" );
        
        }
        { //::SireMM::IntraFF::setUseReproducibleCalculation
        
            typedef void ( ::SireMM::IntraFF::*setUseReproducibleCalculation_function_type)( bool ) ;
            setUseReproducibleCalculation_function_type setUseReproducibleCalculation_function_value( &::SireMM::IntraFF::setUseReproducibleCalculation );
            
            IntraFF_exposer.def( 
                "setUseReproducibleCalculation"
                , setUseReproducibleCalculation_function_value
                , ( bp::arg("on") )
                , "Switch on or off use of an energy summing algorithm that guarantees the\nsame energy regardless of whether a single core or multicore calculation\nis being performed" );
        
        }
        { //::SireMM::IntraFF::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::IntraFF::typeName );
            
            IntraFF_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireMM::IntraFF::usesParallelCalculation
        
            typedef bool ( ::SireMM::IntraFF::*usesParallelCalculation_function_type)(  ) const;
            usesParallelCalculation_function_type usesParallelCalculation_function_value( &::SireMM::IntraFF::usesParallelCalculation );
            
            IntraFF_exposer.def( 
                "usesParallelCalculation"
                , usesParallelCalculation_function_value
                , "Return whether or not a parallel algorithm is used to calculate energies" );
        
        }
        { //::SireMM::IntraFF::usesReproducibleCalculation
        
            typedef bool ( ::SireMM::IntraFF::*usesReproducibleCalculation_function_type)(  ) const;
            usesReproducibleCalculation_function_type usesReproducibleCalculation_function_value( &::SireMM::IntraFF::usesReproducibleCalculation );
            
            IntraFF_exposer.def( 
                "usesReproducibleCalculation"
                , usesReproducibleCalculation_function_value
                , "Return whether or not a reproducible energy summing algorithm is being\nused to accumulate the energies" );
        
        }
        { //::SireMM::IntraFF::what
        
            typedef char const * ( ::SireMM::IntraFF::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireMM::IntraFF::what );
            
            IntraFF_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        IntraFF_exposer.staticmethod( "typeName" );
        IntraFF_exposer.def( "__copy__", &__copy__);
        IntraFF_exposer.def( "__deepcopy__", &__copy__);
        IntraFF_exposer.def( "clone", &__copy__);
        IntraFF_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::IntraFF >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        IntraFF_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::IntraFF >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        IntraFF_exposer.def( "__str__", &__str__< ::SireMM::IntraFF > );
        IntraFF_exposer.def( "__repr__", &__str__< ::SireMM::IntraFF > );
        IntraFF_exposer.def( "__len__", &__len_count< ::SireMM::IntraFF > );
    }

}
Exemplo n.º 10
0
void register_CLJIntraFunction_class(){

    { //::SireMM::CLJIntraFunction
        typedef bp::class_< SireMM::CLJIntraFunction, bp::bases< SireMM::CLJCutoffFunction, SireMM::CLJFunction, SireBase::Property >, boost::noncopyable > CLJIntraFunction_exposer_t;
        CLJIntraFunction_exposer_t CLJIntraFunction_exposer = CLJIntraFunction_exposer_t( "CLJIntraFunction", bp::no_init );
        bp::scope CLJIntraFunction_scope( CLJIntraFunction_exposer );
        { //::SireMM::CLJIntraFunction::connectivity
        
            typedef ::SireMol::Connectivity const & ( ::SireMM::CLJIntraFunction::*connectivity_function_type )(  ) const;
            connectivity_function_type connectivity_function_value( &::SireMM::CLJIntraFunction::connectivity );
            
            CLJIntraFunction_exposer.def( 
                "connectivity"
                , connectivity_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMM::CLJIntraFunction::containsProperty
        
            typedef bool ( ::SireMM::CLJIntraFunction::*containsProperty_function_type )( ::QString const & ) const;
            containsProperty_function_type containsProperty_function_value( &::SireMM::CLJIntraFunction::containsProperty );
            
            CLJIntraFunction_exposer.def( 
                "containsProperty"
                , containsProperty_function_value
                , ( bp::arg("name") ) );
        
        }
        { //::SireMM::CLJIntraFunction::properties
        
            typedef ::SireBase::Properties ( ::SireMM::CLJIntraFunction::*properties_function_type )(  ) const;
            properties_function_type properties_function_value( &::SireMM::CLJIntraFunction::properties );
            
            CLJIntraFunction_exposer.def( 
                "properties"
                , properties_function_value );
        
        }
        { //::SireMM::CLJIntraFunction::property
        
            typedef ::SireBase::PropertyPtr ( ::SireMM::CLJIntraFunction::*property_function_type )( ::QString const & ) const;
            property_function_type property_function_value( &::SireMM::CLJIntraFunction::property );
            
            CLJIntraFunction_exposer.def( 
                "property"
                , property_function_value
                , ( bp::arg("name") ) );
        
        }
        { //::SireMM::CLJIntraFunction::setConnectivity
        
            typedef void ( ::SireMM::CLJIntraFunction::*setConnectivity_function_type )( ::SireMol::Connectivity const & ) ;
            setConnectivity_function_type setConnectivity_function_value( &::SireMM::CLJIntraFunction::setConnectivity );
            
            CLJIntraFunction_exposer.def( 
                "setConnectivity"
                , setConnectivity_function_value
                , ( bp::arg("connectivity") ) );
        
        }
        { //::SireMM::CLJIntraFunction::setConnectivity
        
            typedef void ( ::SireMM::CLJIntraFunction::*setConnectivity_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) ;
            setConnectivity_function_type setConnectivity_function_value( &::SireMM::CLJIntraFunction::setConnectivity );
            
            CLJIntraFunction_exposer.def( 
                "setConnectivity"
                , setConnectivity_function_value
                , ( bp::arg("molecule"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMM::CLJIntraFunction::setProperty
        
            typedef ::SireMM::CLJFunctionPtr ( ::SireMM::CLJIntraFunction::*setProperty_function_type )( ::QString const &,::SireBase::Property const & ) const;
            setProperty_function_type setProperty_function_value( &::SireMM::CLJIntraFunction::setProperty );
            
            CLJIntraFunction_exposer.def( 
                "setProperty"
                , setProperty_function_value
                , ( bp::arg("name"), bp::arg("value") ) );
        
        }
        { //::SireMM::CLJIntraFunction::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::CLJIntraFunction::typeName );
            
            CLJIntraFunction_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        CLJIntraFunction_exposer.staticmethod( "typeName" );
        CLJIntraFunction_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJIntraFunction >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJIntraFunction_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJIntraFunction >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJIntraFunction_exposer.def( "__str__", &__str__< ::SireMM::CLJIntraFunction > );
        CLJIntraFunction_exposer.def( "__repr__", &__str__< ::SireMM::CLJIntraFunction > );
    }

}
Exemplo n.º 11
0
void register_IntraFF_class(){

    { //::SireMM::IntraFF
        typedef bp::class_< SireMM::IntraFF, bp::bases< SireFF::G1FF, SireFF::FF, SireMol::MolGroupsBase, SireBase::Property > > IntraFF_exposer_t;
        IntraFF_exposer_t IntraFF_exposer = IntraFF_exposer_t( "IntraFF", bp::init< >() );
        bp::scope IntraFF_scope( IntraFF_exposer );
        IntraFF_exposer.def( bp::init< QString const & >(( bp::arg("name") )) );
        IntraFF_exposer.def( bp::init< SireMM::IntraFF const & >(( bp::arg("other") )) );
        { //::SireMM::IntraFF::accept
        
            typedef void ( ::SireMM::IntraFF::*accept_function_type )(  ) ;
            accept_function_type accept_function_value( &::SireMM::IntraFF::accept );
            
            IntraFF_exposer.def( 
                "accept"
                , accept_function_value );
        
        }
        { //::SireMM::IntraFF::cljFunction
        
            typedef ::SireMM::CLJIntraFunction const & ( ::SireMM::IntraFF::*cljFunction_function_type )(  ) const;
            cljFunction_function_type cljFunction_function_value( &::SireMM::IntraFF::cljFunction );
            
            IntraFF_exposer.def( 
                "cljFunction"
                , cljFunction_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMM::IntraFF::cljFunction
        
            typedef ::SireMM::CLJIntraFunction const & ( ::SireMM::IntraFF::*cljFunction_function_type )( ::QString ) const;
            cljFunction_function_type cljFunction_function_value( &::SireMM::IntraFF::cljFunction );
            
            IntraFF_exposer.def( 
                "cljFunction"
                , cljFunction_function_value
                , ( bp::arg("key") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMM::IntraFF::cljFunctionKeys
        
            typedef ::QStringList ( ::SireMM::IntraFF::*cljFunctionKeys_function_type )(  ) const;
            cljFunctionKeys_function_type cljFunctionKeys_function_value( &::SireMM::IntraFF::cljFunctionKeys );
            
            IntraFF_exposer.def( 
                "cljFunctionKeys"
                , cljFunctionKeys_function_value );
        
        }
        { //::SireMM::IntraFF::cljFunctions
        
            typedef ::QHash< QString, SireBase::PropPtr< SireMM::CLJFunction > > ( ::SireMM::IntraFF::*cljFunctions_function_type )(  ) const;
            cljFunctions_function_type cljFunctions_function_value( &::SireMM::IntraFF::cljFunctions );
            
            IntraFF_exposer.def( 
                "cljFunctions"
                , cljFunctions_function_value );
        
        }
        { //::SireMM::IntraFF::components
        
            typedef ::SireMM::MultiCLJComponent const & ( ::SireMM::IntraFF::*components_function_type )(  ) const;
            components_function_type components_function_value( &::SireMM::IntraFF::components );
            
            IntraFF_exposer.def( 
                "components"
                , components_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMM::IntraFF::containsProperty
        
            typedef bool ( ::SireMM::IntraFF::*containsProperty_function_type )( ::QString const & ) const;
            containsProperty_function_type containsProperty_function_value( &::SireMM::IntraFF::containsProperty );
            
            IntraFF_exposer.def( 
                "containsProperty"
                , containsProperty_function_value
                , ( bp::arg("name") ) );
        
        }
        { //::SireMM::IntraFF::disableParallelCalculation
        
            typedef void ( ::SireMM::IntraFF::*disableParallelCalculation_function_type )(  ) ;
            disableParallelCalculation_function_type disableParallelCalculation_function_value( &::SireMM::IntraFF::disableParallelCalculation );
            
            IntraFF_exposer.def( 
                "disableParallelCalculation"
                , disableParallelCalculation_function_value );
        
        }
        { //::SireMM::IntraFF::disableReproducibleCalculation
        
            typedef void ( ::SireMM::IntraFF::*disableReproducibleCalculation_function_type )(  ) ;
            disableReproducibleCalculation_function_type disableReproducibleCalculation_function_value( &::SireMM::IntraFF::disableReproducibleCalculation );
            
            IntraFF_exposer.def( 
                "disableReproducibleCalculation"
                , disableReproducibleCalculation_function_value );
        
        }
        { //::SireMM::IntraFF::enableParallelCalculation
        
            typedef void ( ::SireMM::IntraFF::*enableParallelCalculation_function_type )(  ) ;
            enableParallelCalculation_function_type enableParallelCalculation_function_value( &::SireMM::IntraFF::enableParallelCalculation );
            
            IntraFF_exposer.def( 
                "enableParallelCalculation"
                , enableParallelCalculation_function_value );
        
        }
        { //::SireMM::IntraFF::enableReproducibleCalculation
        
            typedef void ( ::SireMM::IntraFF::*enableReproducibleCalculation_function_type )(  ) ;
            enableReproducibleCalculation_function_type enableReproducibleCalculation_function_value( &::SireMM::IntraFF::enableReproducibleCalculation );
            
            IntraFF_exposer.def( 
                "enableReproducibleCalculation"
                , enableReproducibleCalculation_function_value );
        
        }
        { //::SireMM::IntraFF::mustNowRecalculateFromScratch
        
            typedef void ( ::SireMM::IntraFF::*mustNowRecalculateFromScratch_function_type )(  ) ;
            mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::SireMM::IntraFF::mustNowRecalculateFromScratch );
            
            IntraFF_exposer.def( 
                "mustNowRecalculateFromScratch"
                , mustNowRecalculateFromScratch_function_value );
        
        }
        { //::SireMM::IntraFF::nCLJFunctions
        
            typedef int ( ::SireMM::IntraFF::*nCLJFunctions_function_type )(  ) const;
            nCLJFunctions_function_type nCLJFunctions_function_value( &::SireMM::IntraFF::nCLJFunctions );
            
            IntraFF_exposer.def( 
                "nCLJFunctions"
                , nCLJFunctions_function_value );
        
        }
        { //::SireMM::IntraFF::needsAccepting
        
            typedef bool ( ::SireMM::IntraFF::*needsAccepting_function_type )(  ) const;
            needsAccepting_function_type needsAccepting_function_value( &::SireMM::IntraFF::needsAccepting );
            
            IntraFF_exposer.def( 
                "needsAccepting"
                , needsAccepting_function_value );
        
        }
        IntraFF_exposer.def( bp::self != bp::self );
        { //::SireMM::IntraFF::operator=
        
            typedef ::SireMM::IntraFF & ( ::SireMM::IntraFF::*assign_function_type )( ::SireMM::IntraFF const & ) ;
            assign_function_type assign_function_value( &::SireMM::IntraFF::operator= );
            
            IntraFF_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        IntraFF_exposer.def( bp::self == bp::self );
        { //::SireMM::IntraFF::properties
        
            typedef ::SireBase::Properties const & ( ::SireMM::IntraFF::*properties_function_type )(  ) const;
            properties_function_type properties_function_value( &::SireMM::IntraFF::properties );
            
            IntraFF_exposer.def( 
                "properties"
                , properties_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMM::IntraFF::property
        
            typedef ::SireBase::Property const & ( ::SireMM::IntraFF::*property_function_type )( ::QString const & ) const;
            property_function_type property_function_value( &::SireMM::IntraFF::property );
            
            IntraFF_exposer.def( 
                "property"
                , property_function_value
                , ( bp::arg("name") )
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMM::IntraFF::removeAllCLJFunctions
        
            typedef void ( ::SireMM::IntraFF::*removeAllCLJFunctions_function_type )(  ) ;
            removeAllCLJFunctions_function_type removeAllCLJFunctions_function_value( &::SireMM::IntraFF::removeAllCLJFunctions );
            
            IntraFF_exposer.def( 
                "removeAllCLJFunctions"
                , removeAllCLJFunctions_function_value );
        
        }
        { //::SireMM::IntraFF::removeCLJFunctionAt
        
            typedef void ( ::SireMM::IntraFF::*removeCLJFunctionAt_function_type )( ::QString ) ;
            removeCLJFunctionAt_function_type removeCLJFunctionAt_function_value( &::SireMM::IntraFF::removeCLJFunctionAt );
            
            IntraFF_exposer.def( 
                "removeCLJFunctionAt"
                , removeCLJFunctionAt_function_value
                , ( bp::arg("key") ) );
        
        }
        { //::SireMM::IntraFF::setCLJFunction
        
            typedef void ( ::SireMM::IntraFF::*setCLJFunction_function_type )( ::SireMM::CLJIntraFunction const & ) ;
            setCLJFunction_function_type setCLJFunction_function_value( &::SireMM::IntraFF::setCLJFunction );
            
            IntraFF_exposer.def( 
                "setCLJFunction"
                , setCLJFunction_function_value
                , ( bp::arg("cljfunc") ) );
        
        }
        { //::SireMM::IntraFF::setCLJFunction
        
            typedef void ( ::SireMM::IntraFF::*setCLJFunction_function_type )( ::QString,::SireMM::CLJIntraFunction const & ) ;
            setCLJFunction_function_type setCLJFunction_function_value( &::SireMM::IntraFF::setCLJFunction );
            
            IntraFF_exposer.def( 
                "setCLJFunction"
                , setCLJFunction_function_value
                , ( bp::arg("key"), bp::arg("cljfunc") ) );
        
        }
        { //::SireMM::IntraFF::setProperty
        
            typedef bool ( ::SireMM::IntraFF::*setProperty_function_type )( ::QString const &,::SireBase::Property const & ) ;
            setProperty_function_type setProperty_function_value( &::SireMM::IntraFF::setProperty );
            
            IntraFF_exposer.def( 
                "setProperty"
                , setProperty_function_value
                , ( bp::arg("name"), bp::arg("property") ) );
        
        }
        { //::SireMM::IntraFF::setUseParallelCalculation
        
            typedef void ( ::SireMM::IntraFF::*setUseParallelCalculation_function_type )( bool ) ;
            setUseParallelCalculation_function_type setUseParallelCalculation_function_value( &::SireMM::IntraFF::setUseParallelCalculation );
            
            IntraFF_exposer.def( 
                "setUseParallelCalculation"
                , setUseParallelCalculation_function_value
                , ( bp::arg("on") ) );
        
        }
        { //::SireMM::IntraFF::setUseReproducibleCalculation
        
            typedef void ( ::SireMM::IntraFF::*setUseReproducibleCalculation_function_type )( bool ) ;
            setUseReproducibleCalculation_function_type setUseReproducibleCalculation_function_value( &::SireMM::IntraFF::setUseReproducibleCalculation );
            
            IntraFF_exposer.def( 
                "setUseReproducibleCalculation"
                , setUseReproducibleCalculation_function_value
                , ( bp::arg("on") ) );
        
        }
        { //::SireMM::IntraFF::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::IntraFF::typeName );
            
            IntraFF_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMM::IntraFF::usesParallelCalculation
        
            typedef bool ( ::SireMM::IntraFF::*usesParallelCalculation_function_type )(  ) const;
            usesParallelCalculation_function_type usesParallelCalculation_function_value( &::SireMM::IntraFF::usesParallelCalculation );
            
            IntraFF_exposer.def( 
                "usesParallelCalculation"
                , usesParallelCalculation_function_value );
        
        }
        { //::SireMM::IntraFF::usesReproducibleCalculation
        
            typedef bool ( ::SireMM::IntraFF::*usesReproducibleCalculation_function_type )(  ) const;
            usesReproducibleCalculation_function_type usesReproducibleCalculation_function_value( &::SireMM::IntraFF::usesReproducibleCalculation );
            
            IntraFF_exposer.def( 
                "usesReproducibleCalculation"
                , usesReproducibleCalculation_function_value );
        
        }
        { //::SireMM::IntraFF::what
        
            typedef char const * ( ::SireMM::IntraFF::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMM::IntraFF::what );
            
            IntraFF_exposer.def( 
                "what"
                , what_function_value );
        
        }
        IntraFF_exposer.staticmethod( "typeName" );
        IntraFF_exposer.def( "__copy__", &__copy__);
        IntraFF_exposer.def( "__deepcopy__", &__copy__);
        IntraFF_exposer.def( "clone", &__copy__);
        IntraFF_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::IntraFF >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        IntraFF_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::IntraFF >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        IntraFF_exposer.def( "__str__", &__str__< ::SireMM::IntraFF > );
        IntraFF_exposer.def( "__repr__", &__str__< ::SireMM::IntraFF > );
        IntraFF_exposer.def( "__len__", &__len_count< ::SireMM::IntraFF > );
    }

}
Exemplo n.º 12
0
void register_CLJCutoffFunction_class(){

    { //::SireMM::CLJCutoffFunction
        typedef bp::class_< SireMM::CLJCutoffFunction, bp::bases< SireMM::CLJFunction, SireBase::Property >, boost::noncopyable > CLJCutoffFunction_exposer_t;
        CLJCutoffFunction_exposer_t CLJCutoffFunction_exposer = CLJCutoffFunction_exposer_t( "CLJCutoffFunction", "This is the base class of all CLJ functions that have a cutoff\n\nAuthor: Christopher Woods\n", bp::no_init );
        bp::scope CLJCutoffFunction_scope( CLJCutoffFunction_exposer );
        { //::SireMM::CLJCutoffFunction::containsProperty
        
            typedef bool ( ::SireMM::CLJCutoffFunction::*containsProperty_function_type)( ::QString const & ) const;
            containsProperty_function_type containsProperty_function_value( &::SireMM::CLJCutoffFunction::containsProperty );
            
            CLJCutoffFunction_exposer.def( 
                "containsProperty"
                , containsProperty_function_value
                , ( bp::arg("name") )
                , "Return whether or not this function contains a property called name" );
        
        }
        { //::SireMM::CLJCutoffFunction::coulombCutoff
        
            typedef ::SireUnits::Dimension::Length ( ::SireMM::CLJCutoffFunction::*coulombCutoff_function_type)(  ) const;
            coulombCutoff_function_type coulombCutoff_function_value( &::SireMM::CLJCutoffFunction::coulombCutoff );
            
            CLJCutoffFunction_exposer.def( 
                "coulombCutoff"
                , coulombCutoff_function_value
                , "Return the coulomb cutoff distance" );
        
        }
        { //::SireMM::CLJCutoffFunction::hasCutoff
        
            typedef bool ( ::SireMM::CLJCutoffFunction::*hasCutoff_function_type)(  ) const;
            hasCutoff_function_type hasCutoff_function_value( &::SireMM::CLJCutoffFunction::hasCutoff );
            
            CLJCutoffFunction_exposer.def( 
                "hasCutoff"
                , hasCutoff_function_value
                , "Return whether or not this function has a cutoff" );
        
        }
        { //::SireMM::CLJCutoffFunction::ljCutoff
        
            typedef ::SireUnits::Dimension::Length ( ::SireMM::CLJCutoffFunction::*ljCutoff_function_type)(  ) const;
            ljCutoff_function_type ljCutoff_function_value( &::SireMM::CLJCutoffFunction::ljCutoff );
            
            CLJCutoffFunction_exposer.def( 
                "ljCutoff"
                , ljCutoff_function_value
                , "Return the LJ cutoff distance" );
        
        }
        { //::SireMM::CLJCutoffFunction::properties
        
            typedef ::SireBase::Properties ( ::SireMM::CLJCutoffFunction::*properties_function_type)(  ) const;
            properties_function_type properties_function_value( &::SireMM::CLJCutoffFunction::properties );
            
            CLJCutoffFunction_exposer.def( 
                "properties"
                , properties_function_value
                , "Return the properties that can be set in this function" );
        
        }
        { //::SireMM::CLJCutoffFunction::property
        
            typedef ::SireBase::PropertyPtr ( ::SireMM::CLJCutoffFunction::*property_function_type)( ::QString const & ) const;
            property_function_type property_function_value( &::SireMM::CLJCutoffFunction::property );
            
            CLJCutoffFunction_exposer.def( 
                "property"
                , property_function_value
                , ( bp::arg("name") )
                , "Return the value of the property with name name" );
        
        }
        { //::SireMM::CLJCutoffFunction::setCoulombCutoff
        
            typedef void ( ::SireMM::CLJCutoffFunction::*setCoulombCutoff_function_type)( ::SireUnits::Dimension::Length ) ;
            setCoulombCutoff_function_type setCoulombCutoff_function_value( &::SireMM::CLJCutoffFunction::setCoulombCutoff );
            
            CLJCutoffFunction_exposer.def( 
                "setCoulombCutoff"
                , setCoulombCutoff_function_value
                , ( bp::arg("distance") )
                , "Set the coulomb cutoff to the specified distance" );
        
        }
        { //::SireMM::CLJCutoffFunction::setCutoff
        
            typedef void ( ::SireMM::CLJCutoffFunction::*setCutoff_function_type)( ::SireUnits::Dimension::Length ) ;
            setCutoff_function_type setCutoff_function_value( &::SireMM::CLJCutoffFunction::setCutoff );
            
            CLJCutoffFunction_exposer.def( 
                "setCutoff"
                , setCutoff_function_value
                , ( bp::arg("distance") )
                , "Set the coulomb and LJ cutoff distances to distance" );
        
        }
        { //::SireMM::CLJCutoffFunction::setCutoff
        
            typedef void ( ::SireMM::CLJCutoffFunction::*setCutoff_function_type)( ::SireUnits::Dimension::Length,::SireUnits::Dimension::Length ) ;
            setCutoff_function_type setCutoff_function_value( &::SireMM::CLJCutoffFunction::setCutoff );
            
            CLJCutoffFunction_exposer.def( 
                "setCutoff"
                , setCutoff_function_value
                , ( bp::arg("coulomb_cutoff"), bp::arg("lj_cutoff") )
                , "Set the coulomb and LJ cutoff distances to the specified values" );
        
        }
        { //::SireMM::CLJCutoffFunction::setLJCutoff
        
            typedef void ( ::SireMM::CLJCutoffFunction::*setLJCutoff_function_type)( ::SireUnits::Dimension::Length ) ;
            setLJCutoff_function_type setLJCutoff_function_value( &::SireMM::CLJCutoffFunction::setLJCutoff );
            
            CLJCutoffFunction_exposer.def( 
                "setLJCutoff"
                , setLJCutoff_function_value
                , ( bp::arg("distance") )
                , "Set the LJ cutoff to the specified distance" );
        
        }
        { //::SireMM::CLJCutoffFunction::setProperty
        
            typedef ::SireMM::CLJFunctionPtr ( ::SireMM::CLJCutoffFunction::*setProperty_function_type)( ::QString const &,::SireBase::Property const & ) const;
            setProperty_function_type setProperty_function_value( &::SireMM::CLJCutoffFunction::setProperty );
            
            CLJCutoffFunction_exposer.def( 
                "setProperty"
                , setProperty_function_value
                , ( bp::arg("name"), bp::arg("value") )
                , "Set the property with name name to value value" );
        
        }
        { //::SireMM::CLJCutoffFunction::toString
        
            typedef ::QString ( ::SireMM::CLJCutoffFunction::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireMM::CLJCutoffFunction::toString );
            
            CLJCutoffFunction_exposer.def( 
                "toString"
                , toString_function_value
                , "" );
        
        }
        { //::SireMM::CLJCutoffFunction::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::CLJCutoffFunction::typeName );
            
            CLJCutoffFunction_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        CLJCutoffFunction_exposer.staticmethod( "typeName" );
        CLJCutoffFunction_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJCutoffFunction >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJCutoffFunction_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJCutoffFunction >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJCutoffFunction_exposer.def( "__str__", &__str__< ::SireMM::CLJCutoffFunction > );
        CLJCutoffFunction_exposer.def( "__repr__", &__str__< ::SireMM::CLJCutoffFunction > );
    }

}
Exemplo n.º 13
0
void register_CLJCutoffFunction_class(){

    { //::SireMM::CLJCutoffFunction
        typedef bp::class_< SireMM::CLJCutoffFunction, bp::bases< SireMM::CLJFunction, SireBase::Property >, boost::noncopyable > CLJCutoffFunction_exposer_t;
        CLJCutoffFunction_exposer_t CLJCutoffFunction_exposer = CLJCutoffFunction_exposer_t( "CLJCutoffFunction", bp::no_init );
        bp::scope CLJCutoffFunction_scope( CLJCutoffFunction_exposer );
        { //::SireMM::CLJCutoffFunction::containsProperty
        
            typedef bool ( ::SireMM::CLJCutoffFunction::*containsProperty_function_type )( ::QString const & ) const;
            containsProperty_function_type containsProperty_function_value( &::SireMM::CLJCutoffFunction::containsProperty );
            
            CLJCutoffFunction_exposer.def( 
                "containsProperty"
                , containsProperty_function_value
                , ( bp::arg("name") ) );
        
        }
        { //::SireMM::CLJCutoffFunction::coulombCutoff
        
            typedef ::SireUnits::Dimension::Length ( ::SireMM::CLJCutoffFunction::*coulombCutoff_function_type )(  ) const;
            coulombCutoff_function_type coulombCutoff_function_value( &::SireMM::CLJCutoffFunction::coulombCutoff );
            
            CLJCutoffFunction_exposer.def( 
                "coulombCutoff"
                , coulombCutoff_function_value );
        
        }
        { //::SireMM::CLJCutoffFunction::hasCutoff
        
            typedef bool ( ::SireMM::CLJCutoffFunction::*hasCutoff_function_type )(  ) const;
            hasCutoff_function_type hasCutoff_function_value( &::SireMM::CLJCutoffFunction::hasCutoff );
            
            CLJCutoffFunction_exposer.def( 
                "hasCutoff"
                , hasCutoff_function_value );
        
        }
        { //::SireMM::CLJCutoffFunction::ljCutoff
        
            typedef ::SireUnits::Dimension::Length ( ::SireMM::CLJCutoffFunction::*ljCutoff_function_type )(  ) const;
            ljCutoff_function_type ljCutoff_function_value( &::SireMM::CLJCutoffFunction::ljCutoff );
            
            CLJCutoffFunction_exposer.def( 
                "ljCutoff"
                , ljCutoff_function_value );
        
        }
        { //::SireMM::CLJCutoffFunction::properties
        
            typedef ::SireBase::Properties ( ::SireMM::CLJCutoffFunction::*properties_function_type )(  ) const;
            properties_function_type properties_function_value( &::SireMM::CLJCutoffFunction::properties );
            
            CLJCutoffFunction_exposer.def( 
                "properties"
                , properties_function_value );
        
        }
        { //::SireMM::CLJCutoffFunction::property
        
            typedef ::SireBase::PropertyPtr ( ::SireMM::CLJCutoffFunction::*property_function_type )( ::QString const & ) const;
            property_function_type property_function_value( &::SireMM::CLJCutoffFunction::property );
            
            CLJCutoffFunction_exposer.def( 
                "property"
                , property_function_value
                , ( bp::arg("name") ) );
        
        }
        { //::SireMM::CLJCutoffFunction::setCoulombCutoff
        
            typedef void ( ::SireMM::CLJCutoffFunction::*setCoulombCutoff_function_type )( ::SireUnits::Dimension::Length ) ;
            setCoulombCutoff_function_type setCoulombCutoff_function_value( &::SireMM::CLJCutoffFunction::setCoulombCutoff );
            
            CLJCutoffFunction_exposer.def( 
                "setCoulombCutoff"
                , setCoulombCutoff_function_value
                , ( bp::arg("distance") ) );
        
        }
        { //::SireMM::CLJCutoffFunction::setCutoff
        
            typedef void ( ::SireMM::CLJCutoffFunction::*setCutoff_function_type )( ::SireUnits::Dimension::Length ) ;
            setCutoff_function_type setCutoff_function_value( &::SireMM::CLJCutoffFunction::setCutoff );
            
            CLJCutoffFunction_exposer.def( 
                "setCutoff"
                , setCutoff_function_value
                , ( bp::arg("distance") ) );
        
        }
        { //::SireMM::CLJCutoffFunction::setCutoff
        
            typedef void ( ::SireMM::CLJCutoffFunction::*setCutoff_function_type )( ::SireUnits::Dimension::Length,::SireUnits::Dimension::Length ) ;
            setCutoff_function_type setCutoff_function_value( &::SireMM::CLJCutoffFunction::setCutoff );
            
            CLJCutoffFunction_exposer.def( 
                "setCutoff"
                , setCutoff_function_value
                , ( bp::arg("coulomb_cutoff"), bp::arg("lj_cutoff") ) );
        
        }
        { //::SireMM::CLJCutoffFunction::setLJCutoff
        
            typedef void ( ::SireMM::CLJCutoffFunction::*setLJCutoff_function_type )( ::SireUnits::Dimension::Length ) ;
            setLJCutoff_function_type setLJCutoff_function_value( &::SireMM::CLJCutoffFunction::setLJCutoff );
            
            CLJCutoffFunction_exposer.def( 
                "setLJCutoff"
                , setLJCutoff_function_value
                , ( bp::arg("distance") ) );
        
        }
        { //::SireMM::CLJCutoffFunction::setProperty
        
            typedef ::SireMM::CLJFunctionPtr ( ::SireMM::CLJCutoffFunction::*setProperty_function_type )( ::QString const &,::SireBase::Property const & ) const;
            setProperty_function_type setProperty_function_value( &::SireMM::CLJCutoffFunction::setProperty );
            
            CLJCutoffFunction_exposer.def( 
                "setProperty"
                , setProperty_function_value
                , ( bp::arg("name"), bp::arg("value") ) );
        
        }
        { //::SireMM::CLJCutoffFunction::toString
        
            typedef ::QString ( ::SireMM::CLJCutoffFunction::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMM::CLJCutoffFunction::toString );
            
            CLJCutoffFunction_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMM::CLJCutoffFunction::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::CLJCutoffFunction::typeName );
            
            CLJCutoffFunction_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        CLJCutoffFunction_exposer.staticmethod( "typeName" );
        CLJCutoffFunction_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJCutoffFunction >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJCutoffFunction_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJCutoffFunction >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJCutoffFunction_exposer.def( "__str__", &__str__< ::SireMM::CLJCutoffFunction > );
        CLJCutoffFunction_exposer.def( "__repr__", &__str__< ::SireMM::CLJCutoffFunction > );
    }

}