Example #1
0
void register_FEP_class(){

    { //::SireAnalysis::FEP
        typedef bp::class_< SireAnalysis::FEP, bp::bases< SireBase::Property > > FEP_exposer_t;
        FEP_exposer_t FEP_exposer = FEP_exposer_t( "FEP", "This class is used to analyse the free energies that are\ncalculated during a free energy perturbation (FEP) simulation\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
        bp::scope FEP_scope( FEP_exposer );
        FEP_exposer.def( bp::init< QList< double > const &, QMap< double, SireMaths::FreeEnergyAverage > const & >(( bp::arg("windows"), bp::arg("deltas") ), "Construct to use the passed set of windows, with the free energy deltas from\neach window to the window above") );
        FEP_exposer.def( bp::init< QList< double > const &, QMap< double, SireMaths::FreeEnergyAverage > const &, QMap< double, SireMaths::FreeEnergyAverage > const & >(( bp::arg("windows"), bp::arg("forwards_deltas"), bp::arg("backwards_deltas") ), "Construct to use the passed windows, with the free energy deltas from\neach window to the window above in forwards_deltas and from the window\nbelow to each window in backwards_deltas") );
        FEP_exposer.def( bp::init< SireAnalysis::FEPDeltas const & >(( bp::arg("deltas") ), "Construct to use the passed FEP deltas") );
        FEP_exposer.def( bp::init< SireAnalysis::FEP const & >(( bp::arg("other") ), "Copy constructor") );
        { //::SireAnalysis::FEP::add
        
            typedef void ( ::SireAnalysis::FEP::*add_function_type)( ::QList< double > const &,::QMap< double, SireMaths::FreeEnergyAverage > const & ) ;
            add_function_type add_function_value( &::SireAnalysis::FEP::add );
            
            FEP_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("windows"), bp::arg("deltas") )
                , "Add the data for the next iteration, which contains the deltas for the passed windows,\nwith the free energy being for each window to the next window" );
        
        }
        { //::SireAnalysis::FEP::add
        
            typedef void ( ::SireAnalysis::FEP::*add_function_type)( ::QList< double > const &,::QMap< double, SireMaths::FreeEnergyAverage > const &,::QMap< double, SireMaths::FreeEnergyAverage > const & ) ;
            add_function_type add_function_value( &::SireAnalysis::FEP::add );
            
            FEP_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("windows"), bp::arg("forwards_deltas"), bp::arg("backwards_deltas") )
                , "Add the data for the next iteration, which contains the deltas for the passed windows,\nwith forwards_deltas containing the free energy from each window to the next window,\nand backwards_deltas containing the free energy from the previous window to each window" );
        
        }
        { //::SireAnalysis::FEP::add
        
            typedef void ( ::SireAnalysis::FEP::*add_function_type)( ::SireAnalysis::FEPDeltas const & ) ;
            add_function_type add_function_value( &::SireAnalysis::FEP::add );
            
            FEP_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("deltas") )
                , "Add the data for the next iteration" );
        
        }
        { //::SireAnalysis::FEP::at
        
            typedef ::SireAnalysis::FEPDeltas ( ::SireAnalysis::FEP::*at_function_type)( int ) const;
            at_function_type at_function_value( &::SireAnalysis::FEP::at );
            
            FEP_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("i") )
                , "Return the deltas for the ith iteration" );
        
        }
        { //::SireAnalysis::FEP::clear
        
            typedef void ( ::SireAnalysis::FEP::*clear_function_type)(  ) ;
            clear_function_type clear_function_value( &::SireAnalysis::FEP::clear );
            
            FEP_exposer.def( 
                "clear"
                , clear_function_value
                , "Remove all values from the histogram" );
        
        }
        { //::SireAnalysis::FEP::count
        
            typedef int ( ::SireAnalysis::FEP::*count_function_type)(  ) const;
            count_function_type count_function_value( &::SireAnalysis::FEP::count );
            
            FEP_exposer.def( 
                "count"
                , count_function_value
                , "Return the number of iterations" );
        
        }
        { //::SireAnalysis::FEP::deltas
        
            typedef ::QList< SireAnalysis::FEPDeltas > ( ::SireAnalysis::FEP::*deltas_function_type)(  ) const;
            deltas_function_type deltas_function_value( &::SireAnalysis::FEP::deltas );
            
            FEP_exposer.def( 
                "deltas"
                , deltas_function_value
                , "Return the deltas for all iterations" );
        
        }
        { //::SireAnalysis::FEP::lambdaValues
        
            typedef ::QList< double > ( ::SireAnalysis::FEP::*lambdaValues_function_type)(  ) const;
            lambdaValues_function_type lambdaValues_function_value( &::SireAnalysis::FEP::lambdaValues );
            
            FEP_exposer.def( 
                "lambdaValues"
                , lambdaValues_function_value
                , "Return the values of all windows" );
        
        }
        { //::SireAnalysis::FEP::merge
        
            typedef ::SireAnalysis::FEPDeltas ( ::SireAnalysis::FEP::*merge_function_type)( int,int ) const;
            merge_function_type merge_function_value( &::SireAnalysis::FEP::merge );
            
            FEP_exposer.def( 
                "merge"
                , merge_function_value
                , ( bp::arg("start"), bp::arg("end") )
                , "Merge the deltas for iterations start->end" );
        
        }
        { //::SireAnalysis::FEP::merge
        
            typedef ::SireAnalysis::FEPDeltas ( ::SireAnalysis::FEP::*merge_function_type)( ::QList< int > ) const;
            merge_function_type merge_function_value( &::SireAnalysis::FEP::merge );
            
            FEP_exposer.def( 
                "merge"
                , merge_function_value
                , ( bp::arg("indicies") )
                , "Merge the deltas at the passed indicies" );
        
        }
        { //::SireAnalysis::FEP::nIterations
        
            typedef int ( ::SireAnalysis::FEP::*nIterations_function_type)(  ) const;
            nIterations_function_type nIterations_function_value( &::SireAnalysis::FEP::nIterations );
            
            FEP_exposer.def( 
                "nIterations"
                , nIterations_function_value
                , "Return the number of iterations" );
        
        }
        { //::SireAnalysis::FEP::nLambdaValues
        
            typedef int ( ::SireAnalysis::FEP::*nLambdaValues_function_type)(  ) const;
            nLambdaValues_function_type nLambdaValues_function_value( &::SireAnalysis::FEP::nLambdaValues );
            
            FEP_exposer.def( 
                "nLambdaValues"
                , nLambdaValues_function_value
                , "Return the number of lambda values (windows)" );
        
        }
        { //::SireAnalysis::FEP::nSamples
        
            typedef ::qint64 ( ::SireAnalysis::FEP::*nSamples_function_type)(  ) const;
            nSamples_function_type nSamples_function_value( &::SireAnalysis::FEP::nSamples );
            
            FEP_exposer.def( 
                "nSamples"
                , nSamples_function_value
                , "Return the total number of samples in the simulation" );
        
        }
        { //::SireAnalysis::FEP::nWindows
        
            typedef int ( ::SireAnalysis::FEP::*nWindows_function_type)(  ) const;
            nWindows_function_type nWindows_function_value( &::SireAnalysis::FEP::nWindows );
            
            FEP_exposer.def( 
                "nWindows"
                , nWindows_function_value
                , "Return the number of windows" );
        
        }
        FEP_exposer.def( bp::self != bp::self );
        { //::SireAnalysis::FEP::operator=
        
            typedef ::SireAnalysis::FEP & ( ::SireAnalysis::FEP::*assign_function_type)( ::SireAnalysis::FEP const & ) ;
            assign_function_type assign_function_value( &::SireAnalysis::FEP::operator= );
            
            FEP_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        FEP_exposer.def( bp::self == bp::self );
        { //::SireAnalysis::FEP::operator[]
        
            typedef ::SireAnalysis::FEPDeltas ( ::SireAnalysis::FEP::*__getitem___function_type)( int ) const;
            __getitem___function_type __getitem___function_value( &::SireAnalysis::FEP::operator[] );
            
            FEP_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") )
                , "" );
        
        }
        { //::SireAnalysis::FEP::removeAt
        
            typedef void ( ::SireAnalysis::FEP::*removeAt_function_type)( int ) ;
            removeAt_function_type removeAt_function_value( &::SireAnalysis::FEP::removeAt );
            
            FEP_exposer.def( 
                "removeAt"
                , removeAt_function_value
                , ( bp::arg("i") )
                , "Remove the data for iteration i" );
        
        }
        { //::SireAnalysis::FEP::removeRange
        
            typedef void ( ::SireAnalysis::FEP::*removeRange_function_type)( int,int ) ;
            removeRange_function_type removeRange_function_value( &::SireAnalysis::FEP::removeRange );
            
            FEP_exposer.def( 
                "removeRange"
                , removeRange_function_value
                , ( bp::arg("start"), bp::arg("end") )
                , "Remove every iteration from start to end (inclusively)" );
        
        }
        { //::SireAnalysis::FEP::rollingAverage
        
            typedef ::QList< SireAnalysis::FEPDeltas > ( ::SireAnalysis::FEP::*rollingAverage_function_type)( int ) const;
            rollingAverage_function_type rollingAverage_function_value( &::SireAnalysis::FEP::rollingAverage );
            
            FEP_exposer.def( 
                "rollingAverage"
                , rollingAverage_function_value
                , ( bp::arg("niterations") )
                , "Return a list of Gradients that represents the rolling average over niterations\niterations over this TI data set. If this data set contains 100 iterations, and\nwe calculate the rolling average over 50 iterations, then the returned Gradients\nwill be the average from 1-50, then 2-51, 3-52.....51-100" );
        
        }
        { //::SireAnalysis::FEP::set
        
            typedef void ( ::SireAnalysis::FEP::*set_function_type)( int,::QList< double > const &,::QMap< double, SireMaths::FreeEnergyAverage > const & ) ;
            set_function_type set_function_value( &::SireAnalysis::FEP::set );
            
            FEP_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("i"), bp::arg("windows"), bp::arg("deltas") )
                , "Set the deltas for the ith iteration" );
        
        }
        { //::SireAnalysis::FEP::set
        
            typedef void ( ::SireAnalysis::FEP::*set_function_type)( int,::QList< double > const &,::QMap< double, SireMaths::FreeEnergyAverage > const &,::QMap< double, SireMaths::FreeEnergyAverage > const & ) ;
            set_function_type set_function_value( &::SireAnalysis::FEP::set );
            
            FEP_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("i"), bp::arg("windows"), bp::arg("forwards_deltas"), bp::arg("backwards_deltas") )
                , "Set the deltas for the ith iteration" );
        
        }
        { //::SireAnalysis::FEP::set
        
            typedef void ( ::SireAnalysis::FEP::*set_function_type)( int,::SireAnalysis::FEPDeltas const & ) ;
            set_function_type set_function_value( &::SireAnalysis::FEP::set );
            
            FEP_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("i"), bp::arg("deltas") )
                , "Set the deltas for the ith iteration" );
        
        }
        { //::SireAnalysis::FEP::size
        
            typedef int ( ::SireAnalysis::FEP::*size_function_type)(  ) const;
            size_function_type size_function_value( &::SireAnalysis::FEP::size );
            
            FEP_exposer.def( 
                "size"
                , size_function_value
                , "Return the number of iterations" );
        
        }
        { //::SireAnalysis::FEP::toString
        
            typedef ::QString ( ::SireAnalysis::FEP::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireAnalysis::FEP::toString );
            
            FEP_exposer.def( 
                "toString"
                , toString_function_value
                , "" );
        
        }
        { //::SireAnalysis::FEP::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireAnalysis::FEP::typeName );
            
            FEP_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireAnalysis::FEP::what
        
            typedef char const * ( ::SireAnalysis::FEP::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireAnalysis::FEP::what );
            
            FEP_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        { //::SireAnalysis::FEP::windows
        
            typedef ::QList< double > ( ::SireAnalysis::FEP::*windows_function_type)(  ) const;
            windows_function_type windows_function_value( &::SireAnalysis::FEP::windows );
            
            FEP_exposer.def( 
                "windows"
                , windows_function_value
                , "Return the value of all windows" );
        
        }
        FEP_exposer.staticmethod( "typeName" );
        FEP_exposer.def( "__copy__", &__copy__);
        FEP_exposer.def( "__deepcopy__", &__copy__);
        FEP_exposer.def( "clone", &__copy__);
        FEP_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::FEP >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        FEP_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::FEP >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        FEP_exposer.def( "__str__", &__str__< ::SireAnalysis::FEP > );
        FEP_exposer.def( "__repr__", &__str__< ::SireAnalysis::FEP > );
        FEP_exposer.def( "__len__", &__len_size< ::SireAnalysis::FEP > );
    }

}
void register_BennettsRatios_class(){

    { //::SireAnalysis::BennettsRatios
        typedef bp::class_< SireAnalysis::BennettsRatios, bp::bases< SireBase::Property > > BennettsRatios_exposer_t;
        BennettsRatios_exposer_t BennettsRatios_exposer = BennettsRatios_exposer_t( "BennettsRatios", bp::init< >() );
        bp::scope BennettsRatios_scope( BennettsRatios_exposer );
        BennettsRatios_exposer.def( bp::init< QList< double > const &, QMap< double, SireMaths::BennettsFreeEnergyAverage > const &, QMap< double, SireMaths::BennettsFreeEnergyAverage > const & >(( bp::arg("windows"), bp::arg("forwards_ratios"), bp::arg("backwards_ratios") )) );
        BennettsRatios_exposer.def( bp::init< SireAnalysis::BennettsRatios const & >(( bp::arg("other") )) );
        { //::SireAnalysis::BennettsRatios::backwardsData
        
            typedef ::QMap< double, SireMaths::BennettsFreeEnergyAverage > ( ::SireAnalysis::BennettsRatios::*backwardsData_function_type )(  ) const;
            backwardsData_function_type backwardsData_function_value( &::SireAnalysis::BennettsRatios::backwardsData );
            
            BennettsRatios_exposer.def( 
                "backwardsData"
                , backwardsData_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::backwardsRatios
        
            typedef ::QMap< double, SireMaths::BennettsFreeEnergyAverage > ( ::SireAnalysis::BennettsRatios::*backwardsRatios_function_type )(  ) const;
            backwardsRatios_function_type backwardsRatios_function_value( &::SireAnalysis::BennettsRatios::backwardsRatios );
            
            BennettsRatios_exposer.def( 
                "backwardsRatios"
                , backwardsRatios_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::constants
        
            typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::BennettsRatios::*constants_function_type )(  ) const;
            constants_function_type constants_function_value( &::SireAnalysis::BennettsRatios::constants );
            
            BennettsRatios_exposer.def( 
                "constants"
                , constants_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::denominators
        
            typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::BennettsRatios::*denominators_function_type )(  ) const;
            denominators_function_type denominators_function_value( &::SireAnalysis::BennettsRatios::denominators );
            
            BennettsRatios_exposer.def( 
                "denominators"
                , denominators_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::forwardsData
        
            typedef ::QMap< double, SireMaths::BennettsFreeEnergyAverage > ( ::SireAnalysis::BennettsRatios::*forwardsData_function_type )(  ) const;
            forwardsData_function_type forwardsData_function_value( &::SireAnalysis::BennettsRatios::forwardsData );
            
            BennettsRatios_exposer.def( 
                "forwardsData"
                , forwardsData_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::forwardsRatios
        
            typedef ::QMap< double, SireMaths::BennettsFreeEnergyAverage > ( ::SireAnalysis::BennettsRatios::*forwardsRatios_function_type )(  ) const;
            forwardsRatios_function_type forwardsRatios_function_value( &::SireAnalysis::BennettsRatios::forwardsRatios );
            
            BennettsRatios_exposer.def( 
                "forwardsRatios"
                , forwardsRatios_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::integrate
        
            typedef ::SireAnalysis::PMF ( ::SireAnalysis::BennettsRatios::*integrate_function_type )(  ) const;
            integrate_function_type integrate_function_value( &::SireAnalysis::BennettsRatios::integrate );
            
            BennettsRatios_exposer.def( 
                "integrate"
                , integrate_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::isEmpty
        
            typedef bool ( ::SireAnalysis::BennettsRatios::*isEmpty_function_type )(  ) const;
            isEmpty_function_type isEmpty_function_value( &::SireAnalysis::BennettsRatios::isEmpty );
            
            BennettsRatios_exposer.def( 
                "isEmpty"
                , isEmpty_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::lambdaValues
        
            typedef ::QList< double > ( ::SireAnalysis::BennettsRatios::*lambdaValues_function_type )(  ) const;
            lambdaValues_function_type lambdaValues_function_value( &::SireAnalysis::BennettsRatios::lambdaValues );
            
            BennettsRatios_exposer.def( 
                "lambdaValues"
                , lambdaValues_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::merge
        
            typedef ::SireAnalysis::BennettsRatios ( *merge_function_type )( ::QList< SireAnalysis::BennettsRatios > const & );
            merge_function_type merge_function_value( &::SireAnalysis::BennettsRatios::merge );
            
            BennettsRatios_exposer.def( 
                "merge"
                , merge_function_value
                , ( bp::arg("deltas") ) );
        
        }
        { //::SireAnalysis::BennettsRatios::nLambdaValues
        
            typedef int ( ::SireAnalysis::BennettsRatios::*nLambdaValues_function_type )(  ) const;
            nLambdaValues_function_type nLambdaValues_function_value( &::SireAnalysis::BennettsRatios::nLambdaValues );
            
            BennettsRatios_exposer.def( 
                "nLambdaValues"
                , nLambdaValues_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::nSamples
        
            typedef ::qint64 ( ::SireAnalysis::BennettsRatios::*nSamples_function_type )(  ) const;
            nSamples_function_type nSamples_function_value( &::SireAnalysis::BennettsRatios::nSamples );
            
            BennettsRatios_exposer.def( 
                "nSamples"
                , nSamples_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::nWindows
        
            typedef int ( ::SireAnalysis::BennettsRatios::*nWindows_function_type )(  ) const;
            nWindows_function_type nWindows_function_value( &::SireAnalysis::BennettsRatios::nWindows );
            
            BennettsRatios_exposer.def( 
                "nWindows"
                , nWindows_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::numerators
        
            typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::BennettsRatios::*numerators_function_type )(  ) const;
            numerators_function_type numerators_function_value( &::SireAnalysis::BennettsRatios::numerators );
            
            BennettsRatios_exposer.def( 
                "numerators"
                , numerators_function_value );
        
        }
        BennettsRatios_exposer.def( bp::self != bp::self );
        BennettsRatios_exposer.def( bp::self + bp::self );
        { //::SireAnalysis::BennettsRatios::operator=
        
            typedef ::SireAnalysis::BennettsRatios & ( ::SireAnalysis::BennettsRatios::*assign_function_type )( ::SireAnalysis::BennettsRatios const & ) ;
            assign_function_type assign_function_value( &::SireAnalysis::BennettsRatios::operator= );
            
            BennettsRatios_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        BennettsRatios_exposer.def( bp::self == bp::self );
        { //::SireAnalysis::BennettsRatios::sum
        
            typedef ::SireAnalysis::PMF ( ::SireAnalysis::BennettsRatios::*sum_function_type )(  ) const;
            sum_function_type sum_function_value( &::SireAnalysis::BennettsRatios::sum );
            
            BennettsRatios_exposer.def( 
                "sum"
                , sum_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::temperature
        
            typedef ::SireUnits::Dimension::Temperature ( ::SireAnalysis::BennettsRatios::*temperature_function_type )(  ) const;
            temperature_function_type temperature_function_value( &::SireAnalysis::BennettsRatios::temperature );
            
            BennettsRatios_exposer.def( 
                "temperature"
                , temperature_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::toString
        
            typedef ::QString ( ::SireAnalysis::BennettsRatios::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireAnalysis::BennettsRatios::toString );
            
            BennettsRatios_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireAnalysis::BennettsRatios::typeName );
            
            BennettsRatios_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::values
        
            typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::BennettsRatios::*values_function_type )(  ) const;
            values_function_type values_function_value( &::SireAnalysis::BennettsRatios::values );
            
            BennettsRatios_exposer.def( 
                "values"
                , values_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::what
        
            typedef char const * ( ::SireAnalysis::BennettsRatios::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireAnalysis::BennettsRatios::what );
            
            BennettsRatios_exposer.def( 
                "what"
                , what_function_value );
        
        }
        { //::SireAnalysis::BennettsRatios::windows
        
            typedef ::QList< double > ( ::SireAnalysis::BennettsRatios::*windows_function_type )(  ) const;
            windows_function_type windows_function_value( &::SireAnalysis::BennettsRatios::windows );
            
            BennettsRatios_exposer.def( 
                "windows"
                , windows_function_value );
        
        }
        BennettsRatios_exposer.staticmethod( "merge" );
        BennettsRatios_exposer.staticmethod( "typeName" );
        BennettsRatios_exposer.def( "__copy__", &__copy__);
        BennettsRatios_exposer.def( "__deepcopy__", &__copy__);
        BennettsRatios_exposer.def( "clone", &__copy__);
        BennettsRatios_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::BennettsRatios >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        BennettsRatios_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::BennettsRatios >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        BennettsRatios_exposer.def( "__str__", &__str__< ::SireAnalysis::BennettsRatios > );
        BennettsRatios_exposer.def( "__repr__", &__str__< ::SireAnalysis::BennettsRatios > );
    }

}
Example #3
0
void register_ComponentGradients_class(){

    { //::SireAnalysis::ComponentGradients
        typedef bp::class_< SireAnalysis::ComponentGradients, bp::bases< SireBase::Property > > ComponentGradients_exposer_t;
        ComponentGradients_exposer_t ComponentGradients_exposer = ComponentGradients_exposer_t( "ComponentGradients", "This class is used to hold the individual free energy gradients\nfor each of the components collected by the SireSystem::FreeEnergyMonitor\nclass\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
        bp::scope ComponentGradients_scope( ComponentGradients_exposer );
        ComponentGradients_exposer.def( bp::init< QMap< double, SireSystem::FreeEnergyMonitor > const &, bp::optional< bool > >(( bp::arg("gradients"), bp::arg("conserve_memory")=(bool)(true) ), "Construct from the passed map of component monitors") );
        ComponentGradients_exposer.def( bp::init< QList< SireSystem::FreeEnergyMonitor > const &, bp::optional< bool > >(( bp::arg("gradients"), bp::arg("conserve_memory")=(bool)(true) ), "Construct from the passed list of component monitors") );
        ComponentGradients_exposer.def( bp::init< SireAnalysis::ComponentGradients const & >(( bp::arg("other") ), "Copy constructor") );
        { //::SireAnalysis::ComponentGradients::conserveMemory
        
            typedef void ( ::SireAnalysis::ComponentGradients::*conserveMemory_function_type)(  ) ;
            conserveMemory_function_type conserveMemory_function_value( &::SireAnalysis::ComponentGradients::conserveMemory );
            
            ComponentGradients_exposer.def( 
                "conserveMemory"
                , conserveMemory_function_value
                , "This function reduces the memory used by this object by ensuring that\nthe FreeEnergyMonitor at each lambda value uses the copy of the\nmolecules used at the first lambda value" );
        
        }
        { //::SireAnalysis::ComponentGradients::conserveMemory
        
            typedef void ( ::SireAnalysis::ComponentGradients::*conserveMemory_function_type)( ::SireAnalysis::ComponentGradients const & ) ;
            conserveMemory_function_type conserveMemory_function_value( &::SireAnalysis::ComponentGradients::conserveMemory );
            
            ComponentGradients_exposer.def( 
                "conserveMemory"
                , conserveMemory_function_value
                , ( bp::arg("other") )
                , "This function conserves memory by copying in all of the shared molecule\ndata etc. from other into this object" );
        
        }
        { //::SireAnalysis::ComponentGradients::coulombGradientsAt
        
            typedef ::SireAnalysis::Gradients ( ::SireAnalysis::ComponentGradients::*coulombGradientsAt_function_type)( int ) const;
            coulombGradientsAt_function_type coulombGradientsAt_function_value( &::SireAnalysis::ComponentGradients::coulombGradientsAt );
            
            ComponentGradients_exposer.def( 
                "coulombGradientsAt"
                , coulombGradientsAt_function_value
                , ( bp::arg("i") )
                , "Return the set of coulomb free energy gradients for the ith free energy component" );
        
        }
        { //::SireAnalysis::ComponentGradients::coulombValues
        
            typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::ComponentGradients::*coulombValues_function_type)( int ) const;
            coulombValues_function_type coulombValues_function_value( &::SireAnalysis::ComponentGradients::coulombValues );
            
            ComponentGradients_exposer.def( 
                "coulombValues"
                , coulombValues_function_value
                , ( bp::arg("i") )
                , "Return the actual values of the coulomb free energy gradients of the ith component" );
        
        }
        { //::SireAnalysis::ComponentGradients::data
        
            typedef ::QMap< double, SireSystem::FreeEnergyMonitor > ( ::SireAnalysis::ComponentGradients::*data_function_type)(  ) const;
            data_function_type data_function_value( &::SireAnalysis::ComponentGradients::data );
            
            ComponentGradients_exposer.def( 
                "data"
                , data_function_value
                , "Return the raw data for all of the free energy components" );
        
        }
        { //::SireAnalysis::ComponentGradients::deltaLambda
        
            typedef double ( ::SireAnalysis::ComponentGradients::*deltaLambda_function_type)(  ) const;
            deltaLambda_function_type deltaLambda_function_value( &::SireAnalysis::ComponentGradients::deltaLambda );
            
            ComponentGradients_exposer.def( 
                "deltaLambda"
                , deltaLambda_function_value
                , "Return the value of delta lambda used to approximate the free energy gradients" );
        
        }
        { //::SireAnalysis::ComponentGradients::gradientsAt
        
            typedef ::SireAnalysis::Gradients ( ::SireAnalysis::ComponentGradients::*gradientsAt_function_type)( int ) const;
            gradientsAt_function_type gradientsAt_function_value( &::SireAnalysis::ComponentGradients::gradientsAt );
            
            ComponentGradients_exposer.def( 
                "gradientsAt"
                , gradientsAt_function_value
                , ( bp::arg("i") )
                , "Return the set of free energy gradients for the ith free energy component" );
        
        }
        { //::SireAnalysis::ComponentGradients::integrate
        
            typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrate_function_type)( int ) const;
            integrate_function_type integrate_function_value( &::SireAnalysis::ComponentGradients::integrate );
            
            ComponentGradients_exposer.def( 
                "integrate"
                , integrate_function_value
                , ( bp::arg("i") )
                , "Integrate the free energy gradients of the ith component\nand return the resulting PMF" );
        
        }
        { //::SireAnalysis::ComponentGradients::integrate
        
            typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrate_function_type)( int,int ) const;
            integrate_function_type integrate_function_value( &::SireAnalysis::ComponentGradients::integrate );
            
            ComponentGradients_exposer.def( 
                "integrate"
                , integrate_function_value
                , ( bp::arg("i"), bp::arg("order") )
                , "Integrate the free energy gradients of the ith component to order order and\nreturn the resulting PMF" );
        
        }
        { //::SireAnalysis::ComponentGradients::integrate
        
            typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrate_function_type)( int,double,double ) const;
            integrate_function_type integrate_function_value( &::SireAnalysis::ComponentGradients::integrate );
            
            ComponentGradients_exposer.def( 
                "integrate"
                , integrate_function_value
                , ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max") )
                , "Integrate the free energy gradients of the ith component between the range\nrange_min to range_max, and return the resulting PMF" );
        
        }
        { //::SireAnalysis::ComponentGradients::integrate
        
            typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrate_function_type)( int,double,double,int ) const;
            integrate_function_type integrate_function_value( &::SireAnalysis::ComponentGradients::integrate );
            
            ComponentGradients_exposer.def( 
                "integrate"
                , integrate_function_value
                , ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max"), bp::arg("order") )
                , "Integrate the free energy gradients of the ith component to order order\nbetween the range range_min to range_max and return the resulting PMF" );
        
        }
        { //::SireAnalysis::ComponentGradients::integrateCoulomb
        
            typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateCoulomb_function_type)( int ) const;
            integrateCoulomb_function_type integrateCoulomb_function_value( &::SireAnalysis::ComponentGradients::integrateCoulomb );
            
            ComponentGradients_exposer.def( 
                "integrateCoulomb"
                , integrateCoulomb_function_value
                , ( bp::arg("i") )
                , "Integrate the coulomb free energy gradients of the ith component\nand return the resulting PMF" );
        
        }
        { //::SireAnalysis::ComponentGradients::integrateCoulomb
        
            typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateCoulomb_function_type)( int,int ) const;
            integrateCoulomb_function_type integrateCoulomb_function_value( &::SireAnalysis::ComponentGradients::integrateCoulomb );
            
            ComponentGradients_exposer.def( 
                "integrateCoulomb"
                , integrateCoulomb_function_value
                , ( bp::arg("i"), bp::arg("order") )
                , "Integrate the coulomb free energy gradients of the ith component to order order and\nreturn the resulting PMF" );
        
        }
        { //::SireAnalysis::ComponentGradients::integrateCoulomb
        
            typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateCoulomb_function_type)( int,double,double ) const;
            integrateCoulomb_function_type integrateCoulomb_function_value( &::SireAnalysis::ComponentGradients::integrateCoulomb );
            
            ComponentGradients_exposer.def( 
                "integrateCoulomb"
                , integrateCoulomb_function_value
                , ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max") )
                , "Integrate the coulomb free energy gradients of the ith component between the range\nrange_min to range_max, and return the resulting PMF" );
        
        }
        { //::SireAnalysis::ComponentGradients::integrateCoulomb
        
            typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateCoulomb_function_type)( int,double,double,int ) const;
            integrateCoulomb_function_type integrateCoulomb_function_value( &::SireAnalysis::ComponentGradients::integrateCoulomb );
            
            ComponentGradients_exposer.def( 
                "integrateCoulomb"
                , integrateCoulomb_function_value
                , ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max"), bp::arg("order") )
                , "Integrate the coulomb free energy gradients of the ith component to order order\nbetween the range range_min to range_max and return the resulting PMF" );
        
        }
        { //::SireAnalysis::ComponentGradients::integrateLJ
        
            typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateLJ_function_type)( int ) const;
            integrateLJ_function_type integrateLJ_function_value( &::SireAnalysis::ComponentGradients::integrateLJ );
            
            ComponentGradients_exposer.def( 
                "integrateLJ"
                , integrateLJ_function_value
                , ( bp::arg("i") )
                , "Integrate the LJ free energy gradients of the ith component\nand return the resulting PMF" );
        
        }
        { //::SireAnalysis::ComponentGradients::integrateLJ
        
            typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateLJ_function_type)( int,int ) const;
            integrateLJ_function_type integrateLJ_function_value( &::SireAnalysis::ComponentGradients::integrateLJ );
            
            ComponentGradients_exposer.def( 
                "integrateLJ"
                , integrateLJ_function_value
                , ( bp::arg("i"), bp::arg("order") )
                , "Integrate the LJ free energy gradients of the ith component to order order and\nreturn the resulting PMF" );
        
        }
        { //::SireAnalysis::ComponentGradients::integrateLJ
        
            typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateLJ_function_type)( int,double,double ) const;
            integrateLJ_function_type integrateLJ_function_value( &::SireAnalysis::ComponentGradients::integrateLJ );
            
            ComponentGradients_exposer.def( 
                "integrateLJ"
                , integrateLJ_function_value
                , ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max") )
                , "Integrate the LJ free energy gradients of the ith component between the range\nrange_min to range_max, and return the resulting PMF" );
        
        }
        { //::SireAnalysis::ComponentGradients::integrateLJ
        
            typedef ::SireAnalysis::TIPMF ( ::SireAnalysis::ComponentGradients::*integrateLJ_function_type)( int,double,double,int ) const;
            integrateLJ_function_type integrateLJ_function_value( &::SireAnalysis::ComponentGradients::integrateLJ );
            
            ComponentGradients_exposer.def( 
                "integrateLJ"
                , integrateLJ_function_value
                , ( bp::arg("i"), bp::arg("range_min"), bp::arg("range_max"), bp::arg("order") )
                , "Integrate the LJ free energy gradients of the ith component to order order\nbetween the range range_min to range_max and return the resulting PMF" );
        
        }
        { //::SireAnalysis::ComponentGradients::isCompatible
        
            typedef bool ( ::SireAnalysis::ComponentGradients::*isCompatible_function_type)( ::SireAnalysis::ComponentGradients const & ) const;
            isCompatible_function_type isCompatible_function_value( &::SireAnalysis::ComponentGradients::isCompatible );
            
            ComponentGradients_exposer.def( 
                "isCompatible"
                , isCompatible_function_value
                , ( bp::arg("other") )
                , "Return whether or not this set of gradients is compatible with the ones\nprovided in other" );
        
        }
        { //::SireAnalysis::ComponentGradients::isEmpty
        
            typedef bool ( ::SireAnalysis::ComponentGradients::*isEmpty_function_type)(  ) const;
            isEmpty_function_type isEmpty_function_value( &::SireAnalysis::ComponentGradients::isEmpty );
            
            ComponentGradients_exposer.def( 
                "isEmpty"
                , isEmpty_function_value
                , "Return whether or not this set is empty" );
        
        }
        { //::SireAnalysis::ComponentGradients::lambdaValues
        
            typedef ::QList< double > ( ::SireAnalysis::ComponentGradients::*lambdaValues_function_type)(  ) const;
            lambdaValues_function_type lambdaValues_function_value( &::SireAnalysis::ComponentGradients::lambdaValues );
            
            ComponentGradients_exposer.def( 
                "lambdaValues"
                , lambdaValues_function_value
                , "Return the lambda values over which all of the components were collected" );
        
        }
        { //::SireAnalysis::ComponentGradients::ljGradientsAt
        
            typedef ::SireAnalysis::Gradients ( ::SireAnalysis::ComponentGradients::*ljGradientsAt_function_type)( int ) const;
            ljGradientsAt_function_type ljGradientsAt_function_value( &::SireAnalysis::ComponentGradients::ljGradientsAt );
            
            ComponentGradients_exposer.def( 
                "ljGradientsAt"
                , ljGradientsAt_function_value
                , ( bp::arg("i") )
                , "Return the set of LJ free energy gradients for the ith free energy component" );
        
        }
        { //::SireAnalysis::ComponentGradients::ljValues
        
            typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::ComponentGradients::*ljValues_function_type)( int ) const;
            ljValues_function_type ljValues_function_value( &::SireAnalysis::ComponentGradients::ljValues );
            
            ComponentGradients_exposer.def( 
                "ljValues"
                , ljValues_function_value
                , ( bp::arg("i") )
                , "Return the actual values of the LJ free energy gradients of the ith component" );
        
        }
        { //::SireAnalysis::ComponentGradients::merge
        
            typedef ::SireAnalysis::ComponentGradients ( *merge_function_type )( ::QList< SireAnalysis::ComponentGradients > const & );
            merge_function_type merge_function_value( &::SireAnalysis::ComponentGradients::merge );
            
            ComponentGradients_exposer.def( 
                "merge"
                , merge_function_value
                , ( bp::arg("gradients") )
                , "Merge together all of the passed gradients. Note that they must all be compatible\nwith one another, otherwise an exception will be raised" );
        
        }
        { //::SireAnalysis::ComponentGradients::nComponents
        
            typedef int ( ::SireAnalysis::ComponentGradients::*nComponents_function_type)(  ) const;
            nComponents_function_type nComponents_function_value( &::SireAnalysis::ComponentGradients::nComponents );
            
            ComponentGradients_exposer.def( 
                "nComponents"
                , nComponents_function_value
                , "Return the number of free energy components (number of molecule views whose\nfree energy of interaction was recorded)" );
        
        }
        { //::SireAnalysis::ComponentGradients::nLambdaValues
        
            typedef int ( ::SireAnalysis::ComponentGradients::*nLambdaValues_function_type)(  ) const;
            nLambdaValues_function_type nLambdaValues_function_value( &::SireAnalysis::ComponentGradients::nLambdaValues );
            
            ComponentGradients_exposer.def( 
                "nLambdaValues"
                , nLambdaValues_function_value
                , "Return the number of lambda values over which the free energy components have\nbeen recorded" );
        
        }
        { //::SireAnalysis::ComponentGradients::nSamples
        
            typedef ::qint64 ( ::SireAnalysis::ComponentGradients::*nSamples_function_type)(  ) const;
            nSamples_function_type nSamples_function_value( &::SireAnalysis::ComponentGradients::nSamples );
            
            ComponentGradients_exposer.def( 
                "nSamples"
                , nSamples_function_value
                , "Return the number of samples used to form all of the average components" );
        
        }
        ComponentGradients_exposer.def( bp::self != bp::self );
        ComponentGradients_exposer.def( bp::self + bp::self );
        { //::SireAnalysis::ComponentGradients::operator=
        
            typedef ::SireAnalysis::ComponentGradients & ( ::SireAnalysis::ComponentGradients::*assign_function_type)( ::SireAnalysis::ComponentGradients const & ) ;
            assign_function_type assign_function_value( &::SireAnalysis::ComponentGradients::operator= );
            
            ComponentGradients_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        ComponentGradients_exposer.def( bp::self == bp::self );
        { //::SireAnalysis::ComponentGradients::temperature
        
            typedef ::SireUnits::Dimension::Temperature ( ::SireAnalysis::ComponentGradients::*temperature_function_type)(  ) const;
            temperature_function_type temperature_function_value( &::SireAnalysis::ComponentGradients::temperature );
            
            ComponentGradients_exposer.def( 
                "temperature"
                , temperature_function_value
                , "Return the temperature at which all of the components were collected" );
        
        }
        { //::SireAnalysis::ComponentGradients::toString
        
            typedef ::QString ( ::SireAnalysis::ComponentGradients::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireAnalysis::ComponentGradients::toString );
            
            ComponentGradients_exposer.def( 
                "toString"
                , toString_function_value
                , "" );
        
        }
        { //::SireAnalysis::ComponentGradients::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireAnalysis::ComponentGradients::typeName );
            
            ComponentGradients_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireAnalysis::ComponentGradients::values
        
            typedef ::QVector< SireAnalysis::DataPoint > ( ::SireAnalysis::ComponentGradients::*values_function_type)( int ) const;
            values_function_type values_function_value( &::SireAnalysis::ComponentGradients::values );
            
            ComponentGradients_exposer.def( 
                "values"
                , values_function_value
                , ( bp::arg("i") )
                , "Return the actual values of the free energy gradients of the ith component" );
        
        }
        { //::SireAnalysis::ComponentGradients::viewAt
        
            typedef ::SireMol::PartialMolecule ( ::SireAnalysis::ComponentGradients::*viewAt_function_type)( int ) const;
            viewAt_function_type viewAt_function_value( &::SireAnalysis::ComponentGradients::viewAt );
            
            ComponentGradients_exposer.def( 
                "viewAt"
                , viewAt_function_value
                , ( bp::arg("i") )
                , "Return the ith view that corresponds to the ith free energy component.\nNote that this returns the view in the numerically first (lowest) lambda\nvalue. Use viewAt(int i, double lamval) if you want to specify the lambda\nvalue from which you want to extract the view." );
        
        }
        { //::SireAnalysis::ComponentGradients::viewAt
        
            typedef ::SireMol::PartialMolecule ( ::SireAnalysis::ComponentGradients::*viewAt_function_type)( int,double ) const;
            viewAt_function_type viewAt_function_value( &::SireAnalysis::ComponentGradients::viewAt );
            
            ComponentGradients_exposer.def( 
                "viewAt"
                , viewAt_function_value
                , ( bp::arg("i"), bp::arg("lamval") )
                , "Return the ith view from lambda value lamval that corresponds to the\nith free energy component." );
        
        }
        { //::SireAnalysis::ComponentGradients::what
        
            typedef char const * ( ::SireAnalysis::ComponentGradients::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireAnalysis::ComponentGradients::what );
            
            ComponentGradients_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        ComponentGradients_exposer.staticmethod( "merge" );
        ComponentGradients_exposer.staticmethod( "typeName" );
        ComponentGradients_exposer.def( "__copy__", &__copy__);
        ComponentGradients_exposer.def( "__deepcopy__", &__copy__);
        ComponentGradients_exposer.def( "clone", &__copy__);
        ComponentGradients_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::ComponentGradients >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ComponentGradients_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::ComponentGradients >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ComponentGradients_exposer.def( "__str__", &__str__< ::SireAnalysis::ComponentGradients > );
        ComponentGradients_exposer.def( "__repr__", &__str__< ::SireAnalysis::ComponentGradients > );
    }

}
Example #4
0
void register_TI_class(){

    { //::SireAnalysis::TI
        typedef bp::class_< SireAnalysis::TI, bp::bases< SireBase::Property > > TI_exposer_t;
        TI_exposer_t TI_exposer = TI_exposer_t( "TI", bp::init< >() );
        bp::scope TI_scope( TI_exposer );
        TI_exposer.def( bp::init< SireAnalysis::Gradients const & >(( bp::arg("gradients") )) );
        TI_exposer.def( bp::init< QList< SireAnalysis::Gradients > const & >(( bp::arg("gradients") )) );
        TI_exposer.def( bp::init< SireAnalysis::TI const & >(( bp::arg("other") )) );
        { //::SireAnalysis::TI::add
        
            typedef void ( ::SireAnalysis::TI::*add_function_type )( ::QMap< double, SireMaths::AverageAndStddev > const & ) ;
            add_function_type add_function_value( &::SireAnalysis::TI::add );
            
            TI_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("gradients") ) );
        
        }
        { //::SireAnalysis::TI::add
        
            typedef void ( ::SireAnalysis::TI::*add_function_type )( ::QMap< double, SireMaths::FreeEnergyAverage > const & ) ;
            add_function_type add_function_value( &::SireAnalysis::TI::add );
            
            TI_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("gradients") ) );
        
        }
        { //::SireAnalysis::TI::add
        
            typedef void ( ::SireAnalysis::TI::*add_function_type )( ::QMap< double, SireMaths::FreeEnergyAverage > const &,double ) ;
            add_function_type add_function_value( &::SireAnalysis::TI::add );
            
            TI_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("gradients"), bp::arg("delta_lambda") ) );
        
        }
        { //::SireAnalysis::TI::add
        
            typedef void ( ::SireAnalysis::TI::*add_function_type )( ::QMap< double, SireMaths::FreeEnergyAverage > const &,::QMap< double, SireMaths::FreeEnergyAverage > const &,double ) ;
            add_function_type add_function_value( &::SireAnalysis::TI::add );
            
            TI_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("forwards"), bp::arg("backwards"), bp::arg("delta_lambda") ) );
        
        }
        { //::SireAnalysis::TI::add
        
            typedef void ( ::SireAnalysis::TI::*add_function_type )( ::SireAnalysis::Gradients const & ) ;
            add_function_type add_function_value( &::SireAnalysis::TI::add );
            
            TI_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("gradients") ) );
        
        }
        { //::SireAnalysis::TI::at
        
            typedef ::SireAnalysis::Gradients ( ::SireAnalysis::TI::*at_function_type )( int ) const;
            at_function_type at_function_value( &::SireAnalysis::TI::at );
            
            TI_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireAnalysis::TI::clear
        
            typedef void ( ::SireAnalysis::TI::*clear_function_type )(  ) ;
            clear_function_type clear_function_value( &::SireAnalysis::TI::clear );
            
            TI_exposer.def( 
                "clear"
                , clear_function_value );
        
        }
        { //::SireAnalysis::TI::count
        
            typedef int ( ::SireAnalysis::TI::*count_function_type )(  ) const;
            count_function_type count_function_value( &::SireAnalysis::TI::count );
            
            TI_exposer.def( 
                "count"
                , count_function_value );
        
        }
        { //::SireAnalysis::TI::gradients
        
            typedef ::QList< SireAnalysis::Gradients > ( ::SireAnalysis::TI::*gradients_function_type )(  ) const;
            gradients_function_type gradients_function_value( &::SireAnalysis::TI::gradients );
            
            TI_exposer.def( 
                "gradients"
                , gradients_function_value );
        
        }
        { //::SireAnalysis::TI::lambdaValues
        
            typedef ::QList< double > ( ::SireAnalysis::TI::*lambdaValues_function_type )(  ) const;
            lambdaValues_function_type lambdaValues_function_value( &::SireAnalysis::TI::lambdaValues );
            
            TI_exposer.def( 
                "lambdaValues"
                , lambdaValues_function_value );
        
        }
        { //::SireAnalysis::TI::merge
        
            typedef ::SireAnalysis::Gradients ( ::SireAnalysis::TI::*merge_function_type )( int,int ) const;
            merge_function_type merge_function_value( &::SireAnalysis::TI::merge );
            
            TI_exposer.def( 
                "merge"
                , merge_function_value
                , ( bp::arg("start"), bp::arg("end") ) );
        
        }
        { //::SireAnalysis::TI::merge
        
            typedef ::SireAnalysis::Gradients ( ::SireAnalysis::TI::*merge_function_type )( ::QList< int > ) const;
            merge_function_type merge_function_value( &::SireAnalysis::TI::merge );
            
            TI_exposer.def( 
                "merge"
                , merge_function_value
                , ( bp::arg("indicies") ) );
        
        }
        { //::SireAnalysis::TI::nIterations
        
            typedef int ( ::SireAnalysis::TI::*nIterations_function_type )(  ) const;
            nIterations_function_type nIterations_function_value( &::SireAnalysis::TI::nIterations );
            
            TI_exposer.def( 
                "nIterations"
                , nIterations_function_value );
        
        }
        { //::SireAnalysis::TI::nLambdaValues
        
            typedef int ( ::SireAnalysis::TI::*nLambdaValues_function_type )(  ) const;
            nLambdaValues_function_type nLambdaValues_function_value( &::SireAnalysis::TI::nLambdaValues );
            
            TI_exposer.def( 
                "nLambdaValues"
                , nLambdaValues_function_value );
        
        }
        { //::SireAnalysis::TI::nSamples
        
            typedef ::qint64 ( ::SireAnalysis::TI::*nSamples_function_type )(  ) const;
            nSamples_function_type nSamples_function_value( &::SireAnalysis::TI::nSamples );
            
            TI_exposer.def( 
                "nSamples"
                , nSamples_function_value );
        
        }
        TI_exposer.def( bp::self != bp::self );
        { //::SireAnalysis::TI::operator=
        
            typedef ::SireAnalysis::TI & ( ::SireAnalysis::TI::*assign_function_type )( ::SireAnalysis::TI const & ) ;
            assign_function_type assign_function_value( &::SireAnalysis::TI::operator= );
            
            TI_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        TI_exposer.def( bp::self == bp::self );
        { //::SireAnalysis::TI::operator[]
        
            typedef ::SireAnalysis::Gradients ( ::SireAnalysis::TI::*__getitem___function_type )( int ) const;
            __getitem___function_type __getitem___function_value( &::SireAnalysis::TI::operator[] );
            
            TI_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireAnalysis::TI::removeAt
        
            typedef void ( ::SireAnalysis::TI::*removeAt_function_type )( int ) ;
            removeAt_function_type removeAt_function_value( &::SireAnalysis::TI::removeAt );
            
            TI_exposer.def( 
                "removeAt"
                , removeAt_function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireAnalysis::TI::removeRange
        
            typedef void ( ::SireAnalysis::TI::*removeRange_function_type )( int,int ) ;
            removeRange_function_type removeRange_function_value( &::SireAnalysis::TI::removeRange );
            
            TI_exposer.def( 
                "removeRange"
                , removeRange_function_value
                , ( bp::arg("start"), bp::arg("end") ) );
        
        }
        { //::SireAnalysis::TI::rollingAverage
        
            typedef ::QList< SireAnalysis::Gradients > ( ::SireAnalysis::TI::*rollingAverage_function_type )( int ) const;
            rollingAverage_function_type rollingAverage_function_value( &::SireAnalysis::TI::rollingAverage );
            
            TI_exposer.def( 
                "rollingAverage"
                , rollingAverage_function_value
                , ( bp::arg("niterations") ) );
        
        }
        { //::SireAnalysis::TI::set
        
            typedef void ( ::SireAnalysis::TI::*set_function_type )( int,::QMap< double, SireMaths::AverageAndStddev > const & ) ;
            set_function_type set_function_value( &::SireAnalysis::TI::set );
            
            TI_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("i"), bp::arg("gradients") ) );
        
        }
        { //::SireAnalysis::TI::set
        
            typedef void ( ::SireAnalysis::TI::*set_function_type )( int,::QMap< double, SireMaths::FreeEnergyAverage > const & ) ;
            set_function_type set_function_value( &::SireAnalysis::TI::set );
            
            TI_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("i"), bp::arg("gradients") ) );
        
        }
        { //::SireAnalysis::TI::set
        
            typedef void ( ::SireAnalysis::TI::*set_function_type )( int,::QMap< double, SireMaths::FreeEnergyAverage > const &,double ) ;
            set_function_type set_function_value( &::SireAnalysis::TI::set );
            
            TI_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("i"), bp::arg("gradients"), bp::arg("delta_lambda") ) );
        
        }
        { //::SireAnalysis::TI::set
        
            typedef void ( ::SireAnalysis::TI::*set_function_type )( int,::QMap< double, SireMaths::FreeEnergyAverage > const &,::QMap< double, SireMaths::FreeEnergyAverage > const &,double ) ;
            set_function_type set_function_value( &::SireAnalysis::TI::set );
            
            TI_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("i"), bp::arg("forwards"), bp::arg("backwards"), bp::arg("delta_lambda") ) );
        
        }
        { //::SireAnalysis::TI::set
        
            typedef void ( ::SireAnalysis::TI::*set_function_type )( int,::SireAnalysis::Gradients const & ) ;
            set_function_type set_function_value( &::SireAnalysis::TI::set );
            
            TI_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("i"), bp::arg("gradients") ) );
        
        }
        { //::SireAnalysis::TI::size
        
            typedef int ( ::SireAnalysis::TI::*size_function_type )(  ) const;
            size_function_type size_function_value( &::SireAnalysis::TI::size );
            
            TI_exposer.def( 
                "size"
                , size_function_value );
        
        }
        { //::SireAnalysis::TI::toString
        
            typedef ::QString ( ::SireAnalysis::TI::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireAnalysis::TI::toString );
            
            TI_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireAnalysis::TI::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireAnalysis::TI::typeName );
            
            TI_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireAnalysis::TI::what
        
            typedef char const * ( ::SireAnalysis::TI::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireAnalysis::TI::what );
            
            TI_exposer.def( 
                "what"
                , what_function_value );
        
        }
        TI_exposer.staticmethod( "typeName" );
        TI_exposer.def( "__copy__", &__copy__);
        TI_exposer.def( "__deepcopy__", &__copy__);
        TI_exposer.def( "clone", &__copy__);
        TI_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::TI >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        TI_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::TI >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        TI_exposer.def( "__str__", &__str__< ::SireAnalysis::TI > );
        TI_exposer.def( "__repr__", &__str__< ::SireAnalysis::TI > );
        TI_exposer.def( "__len__", &__len_size< ::SireAnalysis::TI > );
    }

}