/data/refman/pasoursint/CMSSW_6_1_2_SLHC4_patch1/src/DQM/RPCMonitorClient/src/RPCLinkSynchroStat.cc

Go to the documentation of this file.

#include "DQM/RPCMonitorClient/interface/RPCLinkSynchroStat.h"
#include "CondFormats/RPCObjects/interface/RPCReadOutMapping.h"
#include "CondFormats/RPCObjects/interface/LinkBoardSpec.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include <algorithm>
#include <sstream>
#include <iostream>
#include <iomanip>

bool RPCLinkSynchroStat::LessLinkName::operator()(const BoardAndCounts& o1, const BoardAndCounts& o2) { return o1.first < o2.first; }
bool RPCLinkSynchroStat::LessCountSum::operator()(const BoardAndCounts& o1, const BoardAndCounts& o2) { return o1.second.sum()< o2.second.sum(); }

void RPCLinkSynchroStat::add(const std::string & lbName, const unsigned int *hits)
{
  LinkBoard lb(lbName);
  SynchroCounts counts(hits);
  for (std::vector<BoardAndCounts>::iterator it = theLinkStatMap.begin(); it != theLinkStatMap.end(); ++it)  if (it->first == lb) it->second += counts;
}

int RPCLinkSynchroStat::LinkBoard::add(const ChamberAndPartition & part) 
{
  for (std::vector<ChamberAndPartition>::const_iterator it=theChamberAndPartitions.begin(); it != theChamberAndPartitions.end(); ++it) {
    if( (*it)==part) return 1;
  }
  theChamberAndPartitions.push_back(part);
  return 0;
}

int RPCLinkSynchroStat::LinkBoard::add(const LinkBoardElectronicIndex & ele) 
{
  for (std::vector<LinkBoardElectronicIndex>::const_iterator it=theElePaths.begin(); it != theElePaths.end(); ++it) {
    if (    it->dccId == ele.dccId
         && it->dccInputChannelNum == ele.dccInputChannelNum
         && it->tbLinkInputNum == ele.tbLinkInputNum
         && it->lbNumInLink == ele.lbNumInLink) return 1; 
  }
  theElePaths.push_back(ele);
  return 0;
}

unsigned int RPCLinkSynchroStat::SynchroCounts::firstHit() const
{
  for (unsigned int i=0; i <8 ; ++i) if(theCounts[i]) return i;
  return 8;
}

void  RPCLinkSynchroStat::SynchroCounts::set(unsigned int bxDiff)
{
  if (bxDiff < 8) theCounts[bxDiff]=1;
}

void  RPCLinkSynchroStat::SynchroCounts::increment(unsigned int bxDiff)
{
  if (bxDiff < 8) theCounts[bxDiff]++;
}

RPCLinkSynchroStat::SynchroCounts & RPCLinkSynchroStat::SynchroCounts::operator+=(const SynchroCounts &rhs)
{
  for (unsigned int i=0; i<8; ++i) theCounts[i]+=rhs.theCounts[i];
  return *this;
}

unsigned int  RPCLinkSynchroStat::SynchroCounts::mom0() const
{ unsigned int result = 0; for (unsigned int i=0; i<8; ++i) result += theCounts[i]; return result; }

double  RPCLinkSynchroStat::SynchroCounts::mom1() const
{ double result = 0.; for (unsigned int i=0; i<8; ++i) result += i*theCounts[i]; return result; }

double  RPCLinkSynchroStat::SynchroCounts::mean() const
{ unsigned int sum = mom0(); return sum==0 ? 0. : mom1()/sum; }

double  RPCLinkSynchroStat::SynchroCounts::rms() const
{
  double result = 0.;
  int      sum = mom0();
  if (sum==0) return 0.;
  double mean = mom1()/sum;
  for (int i=0; i<8; ++i) result += theCounts[i]*(mean-i)*(mean-i);
  result /= sum;
  return sqrt(result);
}

std::string  RPCLinkSynchroStat::SynchroCounts::print() const
{
  std::ostringstream str;
  str<<" mean: "<<std::setw(8)<<mean();
  str<<" rms: "<<std::setw(8)<<rms();
  str<<" counts:"; for (int i=0; i<8; ++i) str<<" "<<std::setw(4)<<theCounts[i];
  return str.str();
}

bool RPCLinkSynchroStat::SynchroCounts::operator==(const SynchroCounts &o) const
{
  for (unsigned int idx=0; idx <8; ++idx) if (theCounts[idx] != o.theCounts[idx]) return false;
  return true;
}





RPCLinkSynchroStat::RPCLinkSynchroStat(bool useFirstFitOnly)
  : theUseFirstHitOnly(useFirstFitOnly)
{
  for (unsigned int i1=0; i1<=MAXDCCINDEX; ++i1) {
    for (unsigned int i2=0; i2<=MAXRBCINDEX; i2++) {
      for (unsigned int i3=0; i3 <=MAXLINKINDEX; ++i3) {
        for (unsigned int i4=0; i4<=MAXLBINDEX; ++i4) {
          theLinkStatNavi[i1][i2][i3][i4]=0;
        }
      }
    }
  }
  theLinkStatMap.push_back( std::make_pair(LinkBoard("Dummy"), SynchroCounts()) );
}

void RPCLinkSynchroStat::init(const RPCReadOutMapping* theCabling, bool addChamberInfo)
{
  if (!theCabling) return;
  std::vector<const DccSpec*> dccs = theCabling->dccList();
  for (std::vector<const DccSpec*>::const_iterator it1= dccs.begin(); it1!= dccs.end(); ++it1) {
    const std::vector<TriggerBoardSpec> & rmbs = (*it1)->triggerBoards();
    for (std::vector<TriggerBoardSpec>::const_iterator it2 = rmbs.begin(); it2 != rmbs.end(); ++it2) {
      const  std::vector<LinkConnSpec> & links = it2->linkConns();
      for (std::vector<LinkConnSpec>::const_iterator it3 = links.begin(); it3 != links.end(); ++it3) {
        const  std::vector<LinkBoardSpec> & lbs = it3->linkBoards();
        for (std::vector<LinkBoardSpec>::const_iterator it4=lbs.begin(); it4 != lbs.end(); ++it4) {
          LinkBoardElectronicIndex ele = { (*it1)->id(), it2->dccInputChannelNum(), it3->triggerBoardInputNumber(), it4->linkBoardNumInLink()}; 
          LinkBoard linkBoard(it4->linkBoardName());
          BoardAndCounts candid = std::make_pair(linkBoard,SynchroCounts());              
          std::vector<BoardAndCounts>::iterator candid_place = lower_bound(theLinkStatMap.begin(), theLinkStatMap.end(), candid, LessLinkName());
          if (candid_place != theLinkStatMap.end() && candid.first == candid_place->first) {
            candid_place->first.add(ele);
          } 
          else {
            candid_place = theLinkStatMap.insert(candid_place,candid);
            candid_place->first.add(ele);
            if (addChamberInfo) {
            const  std::vector<FebConnectorSpec> & febs = it4->febs(); 
            for (std::vector<FebConnectorSpec>::const_iterator it5=febs.begin(); it5!= febs.end(); ++it5) {
              std::string chamberName = it5->chamber().chamberLocationName();
              std::string partitionName = it5->feb().localEtaPartitionName();
              LinkBoard::ChamberAndPartition chamberAndPartition = std::make_pair(chamberName, partitionName);
              candid_place->first.add(chamberAndPartition);
            }
            } 
          }
        }
      } 
    }
  }
  for (unsigned int idx=0; idx<theLinkStatMap.size(); ++idx) {
    const std::vector<LinkBoardElectronicIndex> &paths= theLinkStatMap[idx].first.paths();
    for  (std::vector<LinkBoardElectronicIndex>::const_iterator it=paths.begin(); it!= paths.end();++it) {
      theLinkStatNavi[it->dccId-DCCINDEXSHIFT][it->dccInputChannelNum][it->tbLinkInputNum][it->lbNumInLink]=idx;
    }
  }
//  LogTrace("RPCLinkSynchroStat") <<" SIZE OF LINKS IS: " << theLinkStatMap.size() << endl;
}

void RPCLinkSynchroStat::add(const RPCRawSynchro::ProdItem & vItem, std::vector<LinkBoardElectronicIndex> & problems)
{
  std::vector< int > hits(theLinkStatMap.size(),0);
  std::vector<ShortLinkInfo> slis;
  for ( RPCRawSynchro::ProdItem::const_iterator it = vItem.begin(); it != vItem.end(); ++it) {
    const LinkBoardElectronicIndex & path = it->first;
    unsigned int bxDiff = it->second;
    unsigned int eleCode = (path.dccId-DCCINDEXSHIFT)*100000 + path.dccInputChannelNum*1000 + path.tbLinkInputNum*10+path.lbNumInLink;
    unsigned int idx = theLinkStatNavi[path.dccId-DCCINDEXSHIFT][path.dccInputChannelNum][path.tbLinkInputNum][path.lbNumInLink];
    if  (hits[idx]==0) {
      ShortLinkInfo sli = { idx, std::vector<unsigned int>(1, eleCode), SynchroCounts() };
      slis.push_back( sli );
      hits[idx]=slis.size();
    } 
    else {
      std::vector<unsigned int> & v = slis[hits[idx]-1].hit_paths;
      std::vector<unsigned int>::iterator iv = lower_bound (v.begin(), v.end(), eleCode);
      if (iv == v.end() || (*iv) != eleCode) v.insert(iv,eleCode);
    } 
    slis[hits[idx]-1].counts.set(bxDiff); // ensure one count per LB per BX
  }

  for (std::vector<ShortLinkInfo>::const_iterator ic = slis.begin(); ic !=slis.end(); ++ic) {
    if (theUseFirstHitOnly) {
      theLinkStatMap[ic->idx].second.increment( ic->counts.firstHit() );  // first hit only  
    } else  {
      theLinkStatMap[ic->idx].second += ic->counts;
    }
    if (theLinkStatMap[ ic->idx].first.paths().size() != ic->hit_paths.size()) {
       const std::vector<LinkBoardElectronicIndex> & paths =  theLinkStatMap[ ic->idx].first.paths();
       problems.insert(problems.end(),paths.begin(),paths.end());
    }
  }

}

std::string RPCLinkSynchroStat::dumpDelays() 
{
  std::ostringstream str;
  std::vector<BoardAndCounts> sortedStat = theLinkStatMap;
  stable_sort(sortedStat.begin(),sortedStat.end(),LessCountSum()); 
  for (unsigned int idx=0; idx<sortedStat.size(); ++idx) {
    const LinkBoard & board = sortedStat[idx].first;
    const SynchroCounts & counts = sortedStat[idx].second;

    // DUMP LINKNAME
    str << std::setw(20) << board.name();

    // DUMP COUNTS
    str <<" "<<counts.print();

    //PATHS
    str <<" paths: ";
    const std::vector<LinkBoardElectronicIndex> & paths=board.paths();
    for (std::vector<LinkBoardElectronicIndex>::const_iterator ip=paths.begin(); ip!=paths.end();++ip) 
      str<<"{"<<ip->dccId<<","<<std::setw(2)<<ip->dccInputChannelNum<<","<<std::setw(2)<<ip->tbLinkInputNum<<","<<ip->lbNumInLink<<"}";

    // DUMP CHAMBERS
    std::map<std::string,std::vector<std::string> > chMap;
    const std::vector<LinkBoard::ChamberAndPartition> & chamberAndPartitions = board.chamberAndPartitions();
    for (std::vector<LinkBoard::ChamberAndPartition>::const_iterator it=chamberAndPartitions.begin(); it!=chamberAndPartitions.end();++it) {
      std::vector<std::string> & partitions = chMap[it->first];
      if (find(partitions.begin(), partitions.end(), it->second) == partitions.end()) partitions.push_back(it->second);
    }
    str << " chambers: ";
    for (std::map<std::string,std::vector<std::string> >::const_iterator im=chMap.begin(); im != chMap.end(); ++im) {
      str <<im->first<<"(";
      for (std::vector<std::string>::const_iterator ip=im->second.begin(); ip != im->second.end(); ++ip) { str << *ip; if ((ip+1)!= (im->second.end()) ) str<<","; else str <<")"; }
    }

    
    str <<std::endl;
  }
  LogTrace("RPCLinkSynchroStat") <<"RPCLinkSynchroStat::dumpDelays,  SIZE OF LINKS IS: " << theLinkStatMap.size() << std::endl;
  return str.str();
}