monitor.h

Go to the documentation of this file.

/***************************************************************************
                          monitor.h  -  description
                             -------------------
    begin                : Tue May 14 2002
    copyright            : (C) 2002 by Peter Haase
    email                : mail@p-haase.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This library 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 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library 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 this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef TRANSMISSION_MONITOR_HEADER
#define TRANSMISSION_MONITOR_HEADER


#include <iostream>
#include <fstream>
#include <string>
#include <stdexcept>
#include "misc.h"
#include "phbib.h"
#include "signals.h"
#include "basicdevice.h"




namespace simthlib
{


class TransmissionMonitor : public simth::Device
{
  public:

    enum InputTypes {BIT_BIT, BIT_LLR, LLR_LLR, LLR_BIT};

    long int minBits_;
    long int maxBits_;
    long int minErrors_;

    InputTypes inputCombination;

    // These two need to be public because they have to be called from
    // outside of this class.
    virtual void setXValue(double newXValue) = 0;
    virtual void setX2Value(double newX2Value) = 0;

  protected:

    long int minBits() const {return minBits_;}
    long int maxBits() const {return maxBits_;}
    long int minErrors() const {return minErrors_;}

    virtual double xValue() const = 0;
    virtual double x2Value() const = 0;

    virtual void record(const simth::BitSeq& bits,
            const simth::BitSeq& recBits) = 0;

    void writeGnuplotFile(const std::string& gnuplotFilename,
              const std::string& dataFilename, bool append = false);

    void writePositionGnuplotFile(const std::string& gnuplotFilename,
                                  const std::string& positionDataFilename,
                                  bool append = false) const;

  public:

    TransmissionMonitor(int ID, simth::DeviceSystemIntf *syst, 
            const simth::PropertyList& pl);

    virtual long int errors() const = 0;


    virtual void record(const simth::BitSeq& bits,
            const simth::BitSeq& recBits, double xValue) = 0;

    virtual void process();

    virtual void updateInputLengths();
    virtual void updateOutputLengths();

    virtual void refresh();

    virtual void print(std::ostream &os) const;

    virtual void startOfSimulation();

    static void init(const std::string& filename, simth::Device** dev,
                     simth::DeviceSystemIntf* sysPtr, int ID,
                     const std::string& regionQualifier = "");
};


class TransmissionMonitorFile : public TransmissionMonitor
{
    const std::string errFilename_;


    //the number of compared bits in the current xValue step:
    long int numBits;
    //the number of detected errors in the current xValue step:
    long int numErrors;

    //the number of compared bits in the current loop (is
    //set to 0 if reset is called)
    long int currentNumBits_;
    //the number of errors occured in the current loop (is
    //set to 0 if reset is called)
    long int currentNumErrors_;

    long int packetErrors;
    long int numPackets;

    //the current xValue:
    double currXValue;

    //the current x2Value:
    double currX2Value;

    std::ofstream outStr;

    bool isHeaderPrinted;

    // for mean and standard deviation:
    bool refresh_statistics;
    unsigned nr_refresh;
    double cumul_ber;
    double cumul_ber_squared;

    long int countErrors(const simth::BitSeq& bits, const simth::BitSeq& recBits);
    void printHeader();

  protected:
    std::string errFilename() const {return errFilename_;}

    virtual double xValue() const {return currXValue;}
    virtual double x2Value() const {return currX2Value;}

    //writes the stored information to outStr and resets the information
    void writeStoredErrorInfoToFile();

    long int currentNumBits() const {return currentNumBits_;}
    long int currentNumErrors() const {return currentNumErrors_;}
    virtual bool stopSimulation();
    virtual void record(const simth::BitSeq& bits,const simth::BitSeq& recBits);
  public:
    TransmissionMonitorFile(int ID, simth::DeviceSystemIntf *syst, const simth::PropertyList& pl);

    virtual ~TransmissionMonitorFile();

    virtual long int errors() const {return numErrors;};
    virtual void record(const simth::BitSeq& bits,const simth::BitSeq& recBits, double xValue);
    virtual void endOfSimulation();

    virtual void setXValue(double newXValue);
    virtual void setX2Value(double newX2Value);
    virtual void refresh();
    virtual void reset();
};



class ErrorPositionMonitor : public TransmissionMonitorFile
{
    const std::string posFilename;
    std::ofstream posStr;
  protected:
    simth::checkedVector<int> errorPositions;
    size_t accumulate_bits;

    void writeErrorPositionInfoToFile();
    std::string getPosFilename() const {return posFilename;}
  public:
    ErrorPositionMonitor(int ID, simth::DeviceSystemIntf *syst, 
             const simth::PropertyList& pl);
    virtual ~ErrorPositionMonitor();
    virtual void record(const simth::BitSeq& bits,const simth::BitSeq& recBits, double xValue);
    virtual void endOfSimulation();
};

class ErrorPositionPipe : public ErrorPositionMonitor
{
  public:
    ErrorPositionPipe(int ID, simth::DeviceSystemIntf *syst, const simth::PropertyList& pl);
    ~ErrorPositionPipe();
    void endOfSimulation();

    void process();

    void updateInputLengths();
    void updateOutputLengths();

};



class TransmissionMonitorGnuplot : public TransmissionMonitorFile
{
    const std::string gnuplotFilename;
    void writeGnuplotFile();
  protected:
    std::string getGnuplotFilename() const {return gnuplotFilename;}
  public:
    TransmissionMonitorGnuplot(int ID, simth::DeviceSystemIntf *syst, const simth::PropertyList& pl);

    virtual void display() const;

    virtual void endOfSimulation();
};

class ErrorPositionMonitorGnuplot : public ErrorPositionMonitor
{
    const std::string gnuplotFilename;
    const std::string positionGnuplotFilename;
    void writeGnuplotFile();
    void writePositionGnuplotFile();
  protected:
    std::string getGnuplotFilename() const {return gnuplotFilename;}
    std::string getPositionGnuplotFilename() const {return positionGnuplotFilename;}
  public:
    ErrorPositionMonitorGnuplot(int ID, simth::DeviceSystemIntf *syst, const simth::PropertyList& pl);

    virtual void display() const;

    virtual void endOfSimulation();
};


}



#endif

---