log_record.hpp

Go to the documentation of this file.

/*
 *    This file is part of ACADO Toolkit.
 *
 *    ACADO Toolkit -- A Toolkit for Automatic Control and Dynamic Optimization.
 *    Copyright (C) 2008-2014 by Boris Houska, Hans Joachim Ferreau,
 *    Milan Vukov, Rien Quirynen, KU Leuven.
 *    Developed within the Optimization in Engineering Center (OPTEC)
 *    under supervision of Moritz Diehl. All rights reserved.
 *
 *    ACADO Toolkit is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 3 of the License, or (at your option) any later version.
 *
 *    ACADO Toolkit is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with ACADO Toolkit; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */


#ifndef ACADO_TOOLKIT_LOG_RECORD_HPP
#define ACADO_TOOLKIT_LOG_RECORD_HPP

#include <acado/utils/acado_utils.hpp>
#include <acado/matrix_vector/matrix_vector.hpp>
#include <acado/symbolic_expression/symbolic_expression.hpp>
#include <acado/variables_grid/variables_grid.hpp>

#include <map>
#include <iterator>

BEGIN_NAMESPACE_ACADO

class Logging;

class LogRecord
{
        friend class Logging;

        //
        // PUBLIC MEMBER FUNCTIONS:
        //
        public:

                LogRecord(      LogFrequency _frequency = LOG_AT_EACH_ITERATION,
                                        PrintScheme _printScheme = PS_DEFAULT
                                        );

                ~LogRecord( );

                returnValue operator<<( LogName _name
                                                                );

                returnValue operator<<( const Expression& _name
                                                                );

                returnValue addItem(    LogName _name,
                                                                const char* const _label = DEFAULT_LABEL
                                                                );

                returnValue addItem(    const Expression& _name,
                                                                const char* const _label = DEFAULT_LABEL
                                                                );

                inline returnValue getAll(      LogName _name,
                                                                        MatrixVariablesGrid& values
                                                                        ) const;

                inline returnValue getAll(      const Expression& _name,
                                                                        MatrixVariablesGrid& values
                                                                        ) const;


                inline returnValue getFirst(    LogName _name,
                                                                                DMatrix& firstValue
                                                                                ) const;

                inline returnValue getFirst(    const Expression& _name,
                                                                                DMatrix& firstValue
                                                                                ) const;

                inline returnValue getFirst(    LogName _name,
                                                                                VariablesGrid& firstValue
                                                                                ) const;

                inline returnValue getFirst(    const Expression& _name,
                                                                                VariablesGrid& firstValue
                                                                                ) const;


                inline returnValue getLast(     LogName _name,
                                                                        DMatrix& lastValue
                                                                        ) const;

                inline returnValue getLast(     const Expression& _name,
                                                                        DMatrix& lastValue
                                                                        ) const;

                inline returnValue getLast(     LogName _name,
                                                                        VariablesGrid& lastValue
                                                                        ) const;

                inline returnValue getLast(     const Expression& _name,
                                                                        VariablesGrid& lastValue
                                                                        ) const;


                inline returnValue setAll(      LogName _name,
                                                                        const MatrixVariablesGrid& values
                                                                        );

                inline returnValue setAll(      const Expression& _name,
                                                                        const MatrixVariablesGrid& values
                                                                        );


                inline returnValue setLast(     LogName _name,
                                                                        const DMatrix& value,
                                                                        double time = -INFTY
                                                                        );

                inline returnValue setLast(     const Expression& _name,
                                                                        const DMatrix& value,
                                                                        double time = -INFTY
                                                                        );

                inline returnValue setLast(     LogName _name,
                                                                        VariablesGrid& value,
                                                                        double time = -INFTY
                                                                        );

                inline returnValue setLast(     const Expression& _name,
                                                                        VariablesGrid& value,
                                                                        double time = -INFTY
                                                                        );

                returnValue print(      std::ostream& _stream = std::cout,
                                                        LogPrintMode _mode = PRINT_ITEM_BY_ITEM
                                                        ) const;

                returnValue printInfo( ) const;

                uint getMaxNumMatrices( ) const;

                inline uint getNumItems( ) const;

                inline BooleanType isEmpty( ) const;

                inline LogFrequency getLogFrequency( ) const;

                inline PrintScheme getPrintScheme( ) const;

                inline returnValue setLogFrequency(     LogFrequency _frequency
                                                                                                );

                inline returnValue setPrintScheme(      PrintScheme _printScheme
                                                                                        );

                inline BooleanType hasItem(     LogName _name
                                                                        ) const;

                inline BooleanType hasItem(     const Expression& _name
                                                                        ) const;

                inline BooleanType hasNonEmptyItem(     LogName _name
                                                                                        ) const;

                inline BooleanType hasNonEmptyItem(     const Expression& _name
                                                                                        ) const;


                inline uint getNumDoubles( ) const;

                returnValue getAll(     uint _name,
                                                        LogRecordItemType _type,
                                                        MatrixVariablesGrid& values
                                                        ) const;

                returnValue getFirst(   uint _name,
                                                                LogRecordItemType _type,
                                                                DMatrix& firstValue
                                                                ) const;

                returnValue getLast(    uint _name,
                                                                LogRecordItemType _type,
                                                                DMatrix& lastValue
                                                                ) const;

                returnValue setAll(     uint _name,
                                                        LogRecordItemType _type,
                                                        const MatrixVariablesGrid& values
                                                        );

                returnValue setLast(    uint _name,
                                                                LogRecordItemType _type,
                                                                const DMatrix& value,
                                                                double time = -INFTY
                                                                );


                inline BooleanType hasItem(     uint _name,
                                                                        LogRecordItemType _type
                                                                        ) const;

                inline returnValue enableWriteProtection(LogName _name);

                inline returnValue enableWriteProtection(const Expression& _name);

                inline returnValue disableWriteProtection(LogName _name);

                inline returnValue disableWriteProtection(const Expression& _name);

                returnValue updateLogRecord(    LogRecord& _record
                                                                                ) const;

    //
    // DATA MEMBERS:
    //
        protected:
                int aliasIdx;
                LogFrequency frequency;
                PrintScheme printScheme;

                struct LogRecordData
                {
                        LogRecordData()
                                : label( DEFAULT_LABEL ), writeProtection( false )
                        {}

                        LogRecordData(  const std::string& _label
                                                        )
                                : label( _label ), writeProtection( false )
                        {}

                        LogRecordData(  const MatrixVariablesGrid& _values,
                                                        const std::string& _label,
                                                        bool _writeProtection
                                                        )
                                : values( _values ), label( _label ), writeProtection( _writeProtection )
                        {}

                        MatrixVariablesGrid values;
                        std::string label;
                        bool writeProtection;
                };

                typedef std::map<std::pair<int, LogRecordItemType>, LogRecordData> LogRecordItems;
                LogRecordItems items;
};

CLOSE_NAMESPACE_ACADO

#include <acado/user_interaction/log_record.ipp>

#endif  // ACADO_TOOLKIT_LOG_RECORD_HPP

/*
 *      end of file
 */