DTCompactMapWriter.cc

Go to the documentation of this file.

//----------------------
// This Class' Header --
//----------------------
#include "CondTools/DT/interface/DTCompactMapWriter.h"

//-------------------------------
// Collaborating Class Headers --
//-------------------------------

 
//---------------
// C++ Headers --
//---------------
#include <string>
#include <vector>
#include <map>
#include <algorithm>
#include <iostream>
#include <fstream>


class DTROSChannelId {
 public:
  DTROSChannelId( int ddu, int ros, int channel );
  int     dduId() const;
  int     rosId() const;
  int channelId() const;
 private:
  int     ddu_id;
  int     ros_id;
  int channel_id;
};

DTROSChannelId::DTROSChannelId( int ddu, int ros, int channel ):
     ddu_id(     ddu ),
     ros_id(     ros ),
 channel_id( channel ) {
}

int DTROSChannelId::dduId() const {
  return ddu_id;
}

int DTROSChannelId::rosId() const {
  return ros_id;
}

int DTROSChannelId::channelId() const {
  return channel_id;
}

class DTROSChannelCompare {
 public:
  bool operator()( const DTROSChannelId& idl,
                   const DTROSChannelId& idr ) const;
 private:
};

bool DTROSChannelCompare::operator()( const DTROSChannelId& idl,
                                       const DTROSChannelId& idr ) const {
  if ( idl.    dduId() < idr.    dduId() ) return true;
  if ( idl.    dduId() > idr.    dduId() ) return false;
  if ( idl.    rosId() < idr.    rosId() ) return true;
  if ( idl.    rosId() > idr.    rosId() ) return false;
  if ( idl.channelId() < idr.channelId() ) return true;
  if ( idl.channelId() > idr.channelId() ) return false;
  return false;
}


class DTROBCardId {
 public:
  DTROBCardId( int wheel, int sector, int station, int rob );
  int   wheelId() const;
  int  sectorId() const;
  int stationId() const;
  int     robId() const;
 private:
  int   wheel_id;
  int  sector_id;
  int station_id;
  int     rob_id;
};

DTROBCardId::DTROBCardId( int wheel, int sector, int station, int rob ):
   wheel_id(   wheel ),
  sector_id(  sector ),
 station_id( station ),
     rob_id(     rob ) {
}

int DTROBCardId::wheelId() const {
  return wheel_id;
}

int DTROBCardId::sectorId() const {
  return sector_id;
}

int DTROBCardId::stationId() const {
  return station_id;
}

int DTROBCardId::robId() const {
  return rob_id;
}


class DTROBCardCompare {
 public:
  bool operator()( const DTROBCardId& idl,
                   const DTROBCardId& idr ) const;
 private:
};

bool DTROBCardCompare::operator()( const DTROBCardId& idl,
                                    const DTROBCardId& idr ) const {
  if ( idl.  wheelId() < idr.  wheelId() ) return true;
  if ( idl.  wheelId() > idr.  wheelId() ) return false;
  if ( idl. sectorId() < idr. sectorId() ) return true;
  if ( idl. sectorId() > idr. sectorId() ) return false;
  if ( idl.stationId() < idr.stationId() ) return true;
  if ( idl.stationId() > idr.stationId() ) return false;
  if ( idl.    robId() < idr.    robId() ) return true;
  if ( idl.    robId() > idr.    robId() ) return false;
  return false;
}


class DTTDCChannelId {
 public:
  DTTDCChannelId( int tdc, int channel );
  int     tdcId() const;
  int channelId() const;
 private:
  int     tdc_id;
  int channel_id;
};

DTTDCChannelId::DTTDCChannelId( int tdc, int channel ):
     tdc_id(     tdc ),
 channel_id( channel ) {
}

int DTTDCChannelId::tdcId() const {
  return tdc_id;
}

int DTTDCChannelId::channelId() const {
  return channel_id;
}


class DTTDCChannelCompare {
 public:
  bool operator()( const DTTDCChannelId& idl,
                   const DTTDCChannelId& idr ) const;
 private:
};

bool DTTDCChannelCompare::operator()( const DTTDCChannelId& idl,
                                       const DTTDCChannelId& idr ) const {
  if ( idl.    tdcId() < idr.    tdcId() ) return true;
  if ( idl.    tdcId() > idr.    tdcId() ) return false;
  if ( idl.channelId() < idr.channelId() ) return true;
  if ( idl.channelId() > idr.channelId() ) return false;
  return false;
}


class DTPhysicalWireId {
 public:
  DTPhysicalWireId( int superlayer, int layer, int cell );
  int superlayerId() const;
  int      layerId() const;
  int       cellId() const;
 private:
  int superlayer_id;
  int      layer_id;
  int       cell_id;
};

DTPhysicalWireId::DTPhysicalWireId( int superlayer, int layer, int cell ):
 superlayer_id( superlayer ),
      layer_id(      layer ),
       cell_id(       cell ) {
}

int DTPhysicalWireId::superlayerId() const {
  return superlayer_id;
}

int DTPhysicalWireId::layerId() const {
  return layer_id;
}

int DTPhysicalWireId::cellId() const {
  return cell_id;
}


class DTPhysicalWireCompare {
 public:
  bool operator()( const DTPhysicalWireId& idl,
                   const DTPhysicalWireId& idr ) const;
 private:
};

bool DTPhysicalWireCompare::operator()( const DTPhysicalWireId& idl,
                                         const DTPhysicalWireId& idr ) const {
  if ( idl.superlayerId() < idr.superlayerId() ) return true;
  if ( idl.superlayerId() > idr.superlayerId() ) return false;
  if ( idl.     layerId() < idr.     layerId() ) return true;
  if ( idl.     layerId() > idr.     layerId() ) return false;
  if ( idl.      cellId() < idr.      cellId() ) return true;
  if ( idl.      cellId() > idr.      cellId() ) return false;
  return false;
}


class DTMapElementIdentifiers {
 public:
  static int defaultIdValue;
  static int ROSMapIdOffset;
  static int ROBMapIdOffset;
  static int TDCMapIdOffset;
};

int DTMapElementIdentifiers::defaultIdValue = 0x7fffffff;
int DTMapElementIdentifiers::ROSMapIdOffset = 2000001000;
int DTMapElementIdentifiers::ROBMapIdOffset = 2000002000;
int DTMapElementIdentifiers::TDCMapIdOffset = 2000003000;


void DTCompactMapWriter::buildSteering( std::istream& jobDesc ) {
  // template maps and lists, name and type
  std::string map_type( "dummy_string" );
  std::string map_file( "dummy_string" );
  std::string map_list( "dummy_string" );

  // ros-rob and tdc-cell maps
  std::map<DTROBCardId,
           int,
           DTROBCardCompare> tdc_idm;
  std::map<DTROSChannelId,DTROBCardId,DTROSChannelCompare> ros_map;
  std::map<DTROSChannelId,DTROBCardId,DTROSChannelCompare> rob_map;

  int rob_count = 1;
  int ros_count = 1;

  // parse job description file and loop over map templates and lists
  bool jobEnd = false;
  int max_line_length = 1000;
  char* job_line = new char[max_line_length];
  while ( jobDesc.getline( job_line, max_line_length ) ) {
    // parse job description line
    char* ptr_line = job_line;
    char* end_line = job_line + max_line_length;
    while( ptr_line < end_line ) {
      // get description command key
      // remove leading blanks
      while ( *ptr_line == ' ' ) ptr_line++;
      std::string key( ptr_line );
      int off_blank = key.find( " " );
      int off_equal = key.find( "=" );
      if ( off_equal < 0 ) off_equal = max_line_length;
      if ( off_blank < 0 ) off_blank = key.length();
      int ioff = ( off_blank < off_equal ? off_blank : off_equal );
      key.erase( ioff++, key.length() );
      // go to command value
      ptr_line += ++off_equal;
      // exit loop at end of description file
      if ( (jobEnd = ( key == "end" ) ) ) break;
      // get description command value
      while ( *ptr_line == ' ' ) ptr_line++;
      std::string val( ptr_line );
      int off_value = val.find( " " );
      if ( ( off_value > 0 ) &&
           ( off_value < static_cast<int>( val.length() ) ) )
      val.erase( off_value++, val.length() );
      // go to next token
      ptr_line += off_value;
      // set type, template or list file name
      if ( key == "type" ) map_type = val;
      if ( key ==  "map" ) map_file = val;
      if ( key == "list" ) map_list = val;
    }
    if ( jobEnd ) break;

    // open map list file
    std::ifstream lfile( map_list.c_str() );

    bool write;
    // store TDC maps
    if ( map_type == "TDC" ) {
      // loop over TDC map list for concerned wheels and sectors
      int station = 0;
      int  wheel;
      int sector;
      write = true;
      while ( lfile >>  wheel
                    >> sector
                    >> station ) fillTDCMap( map_file,
                                               wheel, sector,
                                             tdc_idm, station,
                                           rob_count, write );
      ++rob_count;
    }

    // store ROS maps
    if ( map_type == "ROS" ) {
      // loop over ROS map list for concerned ddu, ros, wheel and sector 
      int    ddu;
      int    ros;
      int  wheel;
      int sector;
      write = true;
      while ( lfile >> ddu
                    >> ros
                    >> wheel
                    >> sector ) fillROSMap( map_file,
                                                ddu,      ros,
                                              wheel,   sector,
                                            ros_map, rob_map,
                                          ros_count,    write );
      ++ros_count;
    }

  }
  delete[] job_line;

  // merge ROS and TDC maps
  fillReadOutMap( ros_count, tdc_idm, ros_map, rob_map );

  return;

}

void DTCompactMapWriter::fillTDCMap( const std::string& map_file,
                                      int wheel, int sector,
                                      std::map<DTROBCardId,
                                               int,
                                               DTROBCardCompare>& tdc_idm,
                                      int stationId,
                                      int map_count, bool& write ) {

  // template map file name
  std::ifstream ifile( map_file.c_str() );

  // get station number
  int station;
  int     rob;
  station = stationId;
  ifile >> rob;
  DTROBCardId key( wheel, sector, station, rob );
  tdc_idm.insert( std::pair<DTROBCardId,int>( key, map_count ) );
  if ( !write ) return;
  // loop over TDC channels and cells
  int superlayer;
  int      layer;
  int       wire;
  int        tdc;
  int    channel;
  while ( ifile >>        tdc
                >>    channel
                >> superlayer
                >>      layer
                >>       wire ) {
    // set ROB card, TDC channel and cell identifiers
    DTTDCChannelId tdcChannel( tdc, channel );
    DTPhysicalWireId physicalWire( superlayer, layer, wire );
    // look for rob card connection map
    std::cout << DTMapElementIdentifiers::TDCMapIdOffset << " "
              <<                               map_count << " "
              <<                                     rob << " "
              <<                                     tdc << " "
              <<                                 channel << " "
              << DTMapElementIdentifiers::defaultIdValue << " "
              << DTMapElementIdentifiers::defaultIdValue << " "
              << DTMapElementIdentifiers::defaultIdValue << " "
              <<                              superlayer << " "
              <<                                   layer << " "
              <<                                    wire
              << std::endl;

  }
  write = false;
  return;
}

void DTCompactMapWriter::fillROSMap( const std::string& map_file,
                                      int   ddu, int    ros,
                                      int whdef, int secdef,
                                      std::map<DTROSChannelId,
                                               DTROBCardId,
                                               DTROSChannelCompare>& ddu_map,
                                      std::map<DTROSChannelId,
                                               DTROBCardId,
                                               DTROSChannelCompare>& ros_map,
                                      int map_count,
                                      bool& write ) {

  DTROSChannelId rosBoard( ddu, ros, 0 );
  DTROBCardId    sectorId( whdef, secdef, 0, map_count );
  ddu_map.insert( std::pair<DTROSChannelId,DTROBCardId>( rosBoard,
                                                           sectorId ) );

  // template map file name
  std::ifstream ifile( map_file.c_str() );

  // loop over ROS channels and ROBs
  int channel;
  int wheel;
  int sector;
  int station;
  int rob;
  DTROSChannelId rosChanMap( ddu, ros, 0 );
  if ( !write ) return;
  while ( ifile >> channel
                >>   wheel
                >>  sector
                >> station
                >>     rob ) {
    // set sector to default unless specified
    if ( !sector ) sector = DTMapElementIdentifiers::defaultIdValue;
    if ( ! wheel )  wheel = DTMapElementIdentifiers::defaultIdValue;
    // set ROS channel and ROB identifiers
    DTROSChannelId rosChannel( ddu, ros, channel );
    DTROBCardId robCard( wheel, sector, station, rob );
    // store ROS channel to ROB connection into map
    ros_map.insert( std::pair<DTROSChannelId,DTROBCardId>( rosChannel,
                                                             robCard ) );
  }
  write = false;

  return;
}

void DTCompactMapWriter::cloneROS(  std::map<DTROSChannelId,
                                              DTROBCardId,
                                              DTROSChannelCompare>& ros_m,
                                     std::map<DTROSChannelId,
                                              DTROBCardId,
                                              DTROSChannelCompare>& ros_a,
                                     int ddu_o, int ros_o,
                                     int ddu_f, int ros_f ) {

  std::map<DTROSChannelId,
           DTROBCardId,
           DTROSChannelCompare>:: const_iterator ros_iter = ros_m.begin();
  std::map<DTROSChannelId,
           DTROBCardId,
           DTROSChannelCompare>:: const_iterator ros_iend = ros_m.end();
  while ( ros_iter != ros_iend ) {
    const std::pair<DTROSChannelId,DTROBCardId>& rosLink = *ros_iter++;
    const DTROSChannelId& rosChannelId = rosLink.first;
    const DTROBCardId&    robCardId    = rosLink.second;
    if ( rosChannelId.dduId() != ddu_o ) continue;
    if ( rosChannelId.rosId() != ros_o ) continue;
    const DTROSChannelId  rosChanNewId( ddu_f, ros_f,
                                         rosChannelId.channelId() );
    ros_a.insert( std::pair<DTROSChannelId,DTROBCardId>( rosChanNewId,
                                                           robCardId ) );
  }
  return;  
}

void DTCompactMapWriter::appendROS( std::map<DTROSChannelId,
                                              DTROBCardId,
                                              DTROSChannelCompare>& ros_m,
                                     std::map<DTROSChannelId,
                                              DTROBCardId,
                                              DTROSChannelCompare>& ros_a ) {

  std::map<DTROSChannelId,
           DTROBCardId,
           DTROSChannelCompare>:: const_iterator ros_iter = ros_a.begin();
  std::map<DTROSChannelId,
           DTROBCardId,
           DTROSChannelCompare>:: const_iterator ros_iend = ros_a.end();
  while ( ros_iter != ros_iend ) ros_m.insert( *ros_iter++ );
  return;  
}


void DTCompactMapWriter::fillReadOutMap(
                         int ros_count,
                         std::map<DTROBCardId,
                                  int,
                                  DTROBCardCompare>& tdc_idm,
                         std::map<DTROSChannelId,
                                  DTROBCardId,
                                  DTROSChannelCompare>& ddu_map,
                         std::map<DTROSChannelId,
                                  DTROBCardId,
                                  DTROSChannelCompare>& ros_map ) {

  bool check = true;
  bool write = false;

  while ( check || write ) {
    // ROS board to sector connection map
    std::map<DTROSChannelId,
             DTROBCardId,
             DTROSChannelCompare>:: const_iterator ddu_iter = ddu_map.begin();
    std::map<DTROSChannelId,
             DTROBCardId,
             DTROSChannelCompare>:: const_iterator ddu_iend = ddu_map.end();
    // ROB card to TDC element map
    std::map<DTROBCardId,
             int,
             DTROBCardCompare>::const_iterator idt_iend = tdc_idm.end();
    // ROS channel to ROB connection map
    std::map<DTROSChannelId,
             DTROBCardId,
             DTROSChannelCompare>:: const_iterator ros_iter = ros_map.begin();
    std::map<DTROSChannelId,
             DTROBCardId,
             DTROSChannelCompare>:: const_iterator ros_iend = ros_map.end();

    check = false;
    std::map<DTROSChannelId,
             DTROBCardId,
             DTROSChannelCompare> ros_app;

    // loop over ROS channels
    while ( ros_iter != ros_iend ) {
      // get ROS channel and ROB identifiers
      const std::pair<DTROSChannelId,DTROBCardId>& rosLink = *ros_iter++;
      const DTROSChannelId& rosChannelId = rosLink.first;
      const DTROSChannelId  rosChanMapId( rosChannelId.dduId(),
                                           rosChannelId.rosId(), 0 );
      const DTROBCardId&    robCMapId    = rosLink.second;
      ddu_iter = ddu_map.find( rosChanMapId );
      int  whdef = 0;
      int secdef = 0;
      int rosMapCk = 0;
      if ( ddu_iter != ddu_iend ) {
        const DTROBCardId& sector = ddu_iter->second;
         whdef = sector.wheelId();
        secdef = sector.sectorId();
        rosMapCk = sector.robId();
      }
      else {
        std::cout << "DDU map "
                  << rosChannelId.dduId() << " "
                  << rosChannelId.rosId() << " 0 not found" << std::endl;
        continue;
      }
      int wheel   = robCMapId.  wheelId();
      int sector  = robCMapId. sectorId();
      int station = robCMapId.stationId();
      int rob     = robCMapId.    robId();
      if (  wheel != DTMapElementIdentifiers::defaultIdValue )  whdef =  wheel;
      if ( sector != DTMapElementIdentifiers::defaultIdValue ) secdef = sector;
      const DTROBCardId robCardId( whdef, secdef, station, rob );
      std::map<DTROBCardId,
               int,
               DTROBCardCompare>::const_iterator idt_iter =
                                   tdc_idm.find( robCardId );
      if ( idt_iter != idt_iend ) {
        int tdcMapId = idt_iter->second;
        ddu_iter = ddu_map.begin();
        while ( ddu_iter != ddu_iend ) {
          const std::pair<DTROSChannelId,DTROBCardId>& dduLink = *ddu_iter++;
          const DTROSChannelId& ros_id = dduLink.first;
          const DTROBCardId&    sec_id = dduLink.second;
          int whe_chk = sec_id.wheelId();
          int sec_chk = sec_id.sectorId();
          if (  wheel != DTMapElementIdentifiers::defaultIdValue )
               whe_chk =  wheel;
          if ( sector != DTMapElementIdentifiers::defaultIdValue )
               sec_chk = sector;
          if ( rosMapCk != sec_id.robId() ) continue;
          DTROBCardId robCardId( whe_chk, sec_chk,
                                  station, rob );
          idt_iter = tdc_idm.find( robCardId );
          int tdcMapCk = idt_iter->second;
          if ( ( tdcMapId != tdcMapCk ) && ( !check ) ) {
            cloneROS( ros_map, ros_app, 
                      rosChannelId.dduId(), rosChannelId.rosId(),
                      ros_id.      dduId(), ros_id.      rosId() );
            tdcMapId = tdcMapCk;
            check = true;
          }
          if ( ( tdcMapId == tdcMapCk ) && check ) {
            std::map<DTROSChannelId,
                     DTROBCardId,
                     DTROSChannelCompare>::iterator ddu_inew =
                                            ddu_map.find( ros_id );
            ddu_inew->second = DTROBCardId( sec_id.wheelId(),
                                             sec_id.sectorId(),
                                             sec_id.stationId(),
                                             ros_count );
          }
        }
        if ( check ) {
          ros_count++;
          break;
        }
        if ( write )
          std::cout << DTMapElementIdentifiers::ROSMapIdOffset << " "
                    <<                                rosMapCk << " "
                    <<                rosChannelId.channelId() << " "
                    << DTMapElementIdentifiers::defaultIdValue << " "
                    << DTMapElementIdentifiers::defaultIdValue << " "
                    <<                                   wheel << " "
                    <<                                 station << " "
                    <<                                  sector << " "
                    <<                                     rob << " "
                    << DTMapElementIdentifiers::TDCMapIdOffset << " "
                    <<                                tdcMapId << std::endl;

      }
      else {
        std::cout << "TDC map "
                  <<   wheel << " "
                  <<  sector << " "
                  << station << " "
                  <<     rob << " not found" << std::endl;
      }
    }
    appendROS( ros_map, ros_app );
    if ( !write ) {
      write = !check;
    }
    else {
      ddu_iter = ddu_map.begin();
      while ( ddu_iter != ddu_iend ) {
        const std::pair<DTROSChannelId,DTROBCardId>& dduLink = *ddu_iter++;
        const DTROSChannelId& ros_id = dduLink.first;
        const DTROBCardId&    sec_id = dduLink.second;
        std::cout <<                          ros_id.dduId() << " "
                  <<                          ros_id.rosId() << " "
                  << DTMapElementIdentifiers::defaultIdValue << " "
                  << DTMapElementIdentifiers::defaultIdValue << " "
                  << DTMapElementIdentifiers::defaultIdValue << " "
                  <<                        sec_id.wheelId() << " "
                  << DTMapElementIdentifiers::defaultIdValue << " "
                  <<                       sec_id.sectorId() << " "
                  << DTMapElementIdentifiers::defaultIdValue << " "
                  << DTMapElementIdentifiers::ROSMapIdOffset << " "
                  <<                          sec_id.robId() << std::endl;
      }
      write = false;
    }
  }

  return;
}