ODMatrix.h

Go to the documentation of this file.

/****************************************************************************/
// An O/D (origin/destination) matrix
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright 2001-2010 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This program is free software; you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation; either version 2 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef ODMatrix_h
#define ODMatrix_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#include <iostream>
#include <sstream>
#include <fstream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <algorithm>
#include <string>
#include <utils/common/SUMOTime.h>
#include "ODCell.h"
#include "ODDistrictCont.h"
#include <utils/distribution/Distribution_Points.h>


// ===========================================================================
// class declarations
// ===========================================================================
class OutputDevice;


// ===========================================================================
// class definitions
// ===========================================================================
class ODMatrix {
public:
    ODMatrix(const ODDistrictCont &dc) throw();


    ~ODMatrix() throw();


    void add(SUMOReal vehicleNumber, SUMOTime begin,
             SUMOTime end, const std::string &origin, const std::string &destination,
             const std::string &vehicleType) throw();


    void write(SUMOTime begin, SUMOTime end,
               OutputDevice &dev, bool uniform, bool noVtype,
               const std::string &prefix) throw();


    SUMOReal getNoLoaded() const throw();


    SUMOReal getNoWritten() const throw();


    SUMOReal getNoDiscarded() const throw();


    void applyCurve(const Distribution_Points &ps) throw();


protected:
    struct ODVehicle {
        std::string id;
        SUMOTime depart;
        ODCell* cell;
        std::string from;
        std::string to;

    };


    typedef std::vector<ODCell*> CellVector;


    SUMOReal computeEmissions(ODCell *cell,
                              size_t &vehName, std::vector<ODVehicle> &into, bool uniform,
                              const std::string &prefix) throw();


    void applyCurve(const Distribution_Points &ps, ODCell *cell,
                    CellVector &newCells) throw();


protected:
    CellVector myContainer;

    const ODDistrictCont &myDistricts;

    SUMOReal myNoLoaded;

    SUMOReal myNoWritten;

    SUMOReal myNoDiscarded;


    class cell_by_begin_sorter {
    public:
        explicit cell_by_begin_sorter() { }


        int operator()(ODCell *p1, ODCell *p2) const {
            if (p1->begin == p2->begin) {
                if (p1->origin == p2->origin) {
                    return p1->destination < p2->destination;
                }
                return p1->origin < p2->origin;
            }
            return p1->begin<p2->begin;
        }

    };


    class descending_departure_comperator {
    public:
        descending_departure_comperator() { }


        bool operator()(const ODVehicle &p1, const ODVehicle &p2) const {
            if (p1.depart==p2.depart) {
                return p1.id>p2.id;
            }
            return p1.depart>p2.depart;
        }

    };

private:
    ODMatrix(const ODMatrix &s);

    ODMatrix &operator=(const ODMatrix &s);

};


#endif

/****************************************************************************/