DataReducer.h

Go to the documentation of this file.

#ifndef DataReducer_h
#define DataReducer_h
 
#include "OnlineDB/EcalCondDB/interface/EcalLogicID.h"
#include "OnlineDB/EcalCondDB/interface/Tm.h"
 
// #include <list>
 
#include <vector>
#include <string>
#include <map>
#include <iostream>
#include <list>
#include <cctype>
 
// this class is used to reduce the DCS data to a
// reasonable amount of offline DB IOVs
 
template <typename T>
class DataReducer {
public:
  typedef DataReducer<T> self;
  typedef typename std::pair<EcalLogicID, T> DataItem;
  typedef typename std::map<EcalLogicID, T> DataMap;
  typedef typename std::list<std::pair<Tm, DataMap> >::iterator list_iterator;
  typedef typename std::map<EcalLogicID, T>::iterator map_iterator;
 
  template <typename U>
  class MyData {
  public:
    typedef MyData<U> self;
    bool operator<(const MyData& rhs) {
      Tm t1 = m_iData.first;
      Tm t2 = rhs.m_iData.first;
      long long diff_time = (t1.microsTime() - t2.microsTime());
      return (diff_time < 0);
    };
 
    std::pair<Tm, std::pair<EcalLogicID, U> > m_iData;
  };
 
  typedef typename std::list<MyData<T> >::iterator iterator;
 
  DataReducer() { m_printout = false; };
  ~DataReducer(){};
 
  static const int TIMELIMIT = 60;  // the time limit in seconds to consider two events in the same IOV creation
 
  void setDataList(std::list<MyData<T> > _list) {
    m_list = _list;
    m_list.sort();
  };
 
  void getReducedDataList(std::list<std::pair<Tm, DataMap> >* my_new_list) {
    /* *************************************** 
           to get reduced data list 
       *************************************** */
 
    std::cout << " we are in getReducedDataList " << std::endl;
    //  std::list< std::pair< Tm, DataMap > > my_new_list ;
    iterator i;
    std::cout << " created iterator " << std::endl;
 
    bool firstpass = true;
    unsigned int s_old = 0;
    for (i = m_list.begin(); i != m_list.end(); i++) {
      Tm t = (*i).m_iData.first;
      DataItem d = (*i).m_iData.second;
      bool new_time_change = true;
 
      DataMap the_data;
      list_iterator it_good = my_new_list->end();
 
      if (!firstpass) {
        list_iterator it;
        int last_state = -1;
        for (it = my_new_list->begin(); it != my_new_list->end(); ++it) {
          // check on the state
 
          std::pair<Tm, DataMap> pair_new_list = *it;
 
          Tm t_l = pair_new_list.first;
          DataMap dd = pair_new_list.second;
          map_iterator ip;
          for (ip = dd.begin(); ip != dd.end(); ++ip) {
            EcalLogicID ecid = ip->first;
            T dcs_dat = ip->second;
            if (ecid.getLogicID() == d.first.getLogicID())
              last_state = dcs_dat.getStatus();
          }
 
          long long diff_time = (t.microsTime() - t_l.microsTime()) / 1000000;
          if (diff_time < 0)
            diff_time = -diff_time;
          if (diff_time < TIMELIMIT) {
            // data change happened at the same moment
 
            new_time_change = false;
            // add data to the list
            the_data = pair_new_list.second;
            it_good = it;
          }
        }
 
        if (last_state != d.second.getStatus()) {
          if (!new_time_change) {
            std::pair<Tm, DataMap> pair_new_list = *it_good;
            Tm t_good = pair_new_list.first;
            the_data = pair_new_list.second;
            the_data.insert(d);
            std::pair<Tm, DataMap> pair_new_good;
            pair_new_good.first = t_good;
            pair_new_good.second = the_data;
 
            my_new_list->erase(it_good);
            my_new_list->push_back(pair_new_good);
 
          } else if (new_time_change) {
            std::pair<Tm, DataMap> p_new;
            p_new.first = t;
            DataMap a_map;
            a_map.insert(d);
            p_new.second = a_map;
            my_new_list->push_back(p_new);
          }
        }
        list_iterator it3;
        if (my_new_list->size() > s_old) {
          s_old = my_new_list->size();
          if (m_printout) {
            std::cout << "************" << std::endl;
            for (it3 = my_new_list->begin(); it3 != my_new_list->end(); ++it3) {
              std::pair<Tm, DataMap> pair_new_list3 = *it3;
              Tm t3 = pair_new_list3.first;
              std::cout << " T =" << t3.str() << std::endl;
            }
            std::cout << "************" << std::endl;
          }
        }
 
      } else {
        // first pass write it anyway
        std::pair<Tm, DataMap> p_new;
        p_new.first = t;
        DataMap a_map;
        a_map.insert(d);
        p_new.second = a_map;
        my_new_list->insert(my_new_list->begin(), p_new);
        firstpass = false;
      }
    }
 
    if (m_printout) {
      list_iterator it3;
      for (it3 = my_new_list->begin(); it3 != my_new_list->end(); ++it3) {
        std::pair<Tm, DataMap> pair_new_list3 = *it3;
        Tm t3 = pair_new_list3.first;
        std::cout << " T =" << t3.str() << std::endl;
      }
    }
  };
 
private:
  //  std::list< std::pair< Tm, DataItem >  > m_list;
  std::list<MyData<T> > m_list;
  bool m_printout;
};
 
#endif