Data.hpp

Go to the documentation of this file.

/****************************************************************
 * DATA.HPP
 * 
 * This file contains all the data related class and methods.
 * 
 * Authors: J. Barthelemy and L. Hollaert
 * Date   : 17 july 2012
 ****************************************************************/

#ifndef DATA_HPP_
#define DATA_HPP_

#include <iostream>
#include <fstream>
#include <sstream>
#include <map>
#include <vector>
#include <limits>
#include <string>
#include <stdexcept>
#include <boost/tokenizer.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
#include <math.h>
#include "repast_hpc/Properties.h"
#include "repast_hpc/RepastProcess.h"
#include "Network.hpp"
#include "tinyxml2.hpp"
#include "Random.hpp"
#include "repast_hpc/TDataSource.h"
#include "repast_hpc/SVDataSet.h"


const int MODEL_AGENT_IND_TYPE = 0;     
const int MODEL_AGENT_HH_TYPE  = 1;     


template <typename T>
class Singleton {

protected:

  Singleton () {}

  ~Singleton () {}

public:


  static void makeInstance ( repast::Properties aProps ) {
    if (NULL == _singleton)  {
      _singleton = new T(aProps);
    }
  }


  static T *getInstance () {
    if (NULL == _singleton)    {
      std::cerr << "No instance already created!" << std::endl;
    }
    return (static_cast<T*> (_singleton));
  }

  static void kill () {
    if (NULL != _singleton) {
      delete _singleton;
      _singleton = NULL;
    }
  }

private:

  static T *_singleton;    

};

template <typename T> T *Singleton<T>::_singleton = NULL;


class Data : public Singleton<Data> {

  friend class Singleton<Data>;

private:

  std::map<int, std::vector<long> >    _mun_age_men;              
  std::map<int, std::vector<long> >    _mun_age_women;            
  std::map<int, float>                 _death_age_men;            
  std::map<int, float>                 _death_age_women;          
  std::map<int, float>                 _birth_age;                          
  std::map<int, float>                       _birth_men;                      
  std::multimap<int, long>             _map_ins_node;             
  std::map<long,int>                   _map_node_ins;             
  std::map<int,char>                   _map_act_intToChar;        
  std::map<char,int>                   _map_act_charToInt;        
  std::map<int,dist_param_mixture>     _map_act_dist_par_dist;    
  std::map<int,dist_param_mixture>     _map_act_tdep_par_dist;    
  std::map<int, dist_param_mixture_2d> _map_act_start_x_dur;      
  dist_param_mixture_2d                _act_dist_x_dur_trip_dist; 
  Network                              _network;                  
  std::map<int, long>                  _indic_mun_size;           
  std::map<int, int>                   _map_ins_id_mun;           
  std::map<int, int>                   _map_id_mun_ins;           
  repast::Properties                   _props;                    

public:


  Data( repast::Properties aProps ) {

    if (repast::RepastProcess::instance()->rank() == 0) {
      std::cout << "Data reading" << std::endl;
    }

    // Models properties

    this->_props = aProps;

    // Socio-demographics data

    read_mun_age_men();
    read_mun_age_women();
    read_death_age();
    read_birth_age();

    // Network data

    read_node_ins();
    read_network();
    read_indicators();
    read_ins_id_mun();

    // Activity model data

    read_activity_cdb();
    read_distribution_parameters_distance();
    read_distribution_parameters_start_duration();
    read_distribution_parameters_distance_x_duration_trip();
    read_distribution_parameters_house_tdep();


  }

  virtual ~Data() {};

  void read_mun_age_men();

  void read_mun_age_women();

  void read_death_age();

  void read_birth_age();

  void read_node_ins();

  void read_activity_cdb();

  void read_network();

  void read_distribution_parameters_distance();

  void read_distribution_parameters_house_tdep();

  void read_distribution_parameters_start_duration();

  void read_distribution_parameters_distance_x_duration_trip();

  void read_indicators();

  void read_ins_id_mun();


  std::vector<long int> getMunAge(int municipality, char gender);


  float getDeathProba(char gender, int age);


  float getBirthProba(int age);


  float getBirthsex(int age);


  std::vector<long> getNodesIdFromIns(int aIns);


  long getOneNodeIdFromIns(int aIns);


  dist_param_mixture getActDistParDist(int aActivityType );




  dist_param_mixture getActHouseTDepParDist(int aActivityType );



  dist_param_mixture getActDurationCondiStartParDist(int aActivityType, int aStartTime);


  dist_param_mixture getDurationCondiDistTripParDist(int aDistance);


  const Network & getNetwork() const {
    return _network;
  }


  const std::map<char, int>& getMapActCharToInt() const {
    return _map_act_charToInt;
  }


  const std::map<int, char>& getMapActIntToChar() const {
    return _map_act_intToChar;
  }


  const std::map<int, int>& getMapInsIdMun() const {
    return _map_ins_id_mun;
  }


  const std::map<int, int>& getMapIdMunIns() const {
    return _map_id_mun_ins;
  }

};



class AggregateSum : public repast::TDataSource<int> {

private :
  int _sum;   

public :

  AggregateSum();

  virtual ~AggregateSum() {};

  void increment();

  void reset();


  int getData();

};


//  Some useful routines.  //


inline std::string secToTime( float n_sec ) {

  unsigned long n_sec_int = (unsigned long) floor(n_sec);

  std::ostringstream result;

  unsigned int hour = n_sec_int / 3600;
  unsigned int min  = (n_sec_int / 60) % 60;
  unsigned int sec  = n_sec_int % 60;

  result << hour << ":" << min << ":" << sec;

  return result.str();

};


inline unsigned int secToHour( float n_sec ) {
  return (unsigned long)floor(n_sec / 3600);
};


inline unsigned int secToHalfHour( float n_sec ) {
  return (unsigned long)floor(n_sec / 1800);
};


long int linesCount(std::string filename);


template<typename T> std::vector<T> split(const std::string & msg,
                                     const std::string & separators) {

  std::vector<T> result;                                         // resulting vector
  T         token;                                               // one token of the string
  boost::char_separator<char> sep(separators.c_str());           // separator

  boost::tokenizer<boost::char_separator<char> > tok(msg, sep);  // token's generation

  // string decomposition into token
  for (boost::tokenizer<boost::char_separator<char> >::const_iterator i = tok.begin(); i != tok.end(); i++) {
    std::stringstream s(*i);
    string s_string = s.str();                                   // getting the string
    boost::algorithm::trim(s_string);                            // removing trailing blanks
    token = boost::lexical_cast<T>( s_string );                  // casting operator
    result.push_back(token);                                     // pushing the casted string to the vector of results
  }

  // returning the resulting decomposition
  return result;
}

#endif /* DATA_HPP_ */