/data/refman/pasoursint/CMSSW_5_3_10_patch1/src/L1Trigger/L1GctAnalyzer/src/GctFibreAnalyzer.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    GctFibreAnalyzer
// Class:      GctFibreAnalyzer
// 
//
// Original Author:  Alex Tapper
//         Created:  Thu Jul 12 14:21:06 CEST 2007
// $Id: GctFibreAnalyzer.cc,v 1.17 2011/01/19 07:32:18 elmer Exp $
//
//

#include "FWCore/MessageLogger/interface/MessageLogger.h" // Logger
#include "FWCore/Utilities/interface/Exception.h" // Exceptions

// Include file
#include "L1Trigger/L1GctAnalyzer/interface/GctFibreAnalyzer.h"

// Data format
#include "DataFormats/L1GlobalCaloTrigger/interface/L1GctCollections.h"

GctFibreAnalyzer::GctFibreAnalyzer(const edm::ParameterSet& iConfig):
  m_fibreSource(iConfig.getUntrackedParameter<edm::InputTag>("FibreSource")),
  m_doLogicalID(iConfig.getUntrackedParameter<bool>("doLogicalID")),
  m_doCounter(iConfig.getUntrackedParameter<bool>("doCounter")),
  m_numZeroEvents(0),
  m_numInconsistentPayloadEvents(0),
  m_numConsistentEvents(0)
{
}

GctFibreAnalyzer::~GctFibreAnalyzer()
{
  edm::LogInfo("Zero Fibreword events") << "Total number of events with zero fibrewords: " << m_numZeroEvents;
  edm::LogInfo("Inconsistent Payload events") << "Total number of events with inconsistent payloads: " << m_numInconsistentPayloadEvents;
  if(m_doCounter){edm::LogInfo("Successful events") << "Total number of Successful events: " << m_numConsistentEvents;}
}

void GctFibreAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
{
  using namespace edm;
  
  Handle<L1GctFibreCollection> fibre;
  iEvent.getByLabel(m_fibreSource,fibre);

  bool bc0= false;
  int flag_for_zeroes = 0;
  int flag_for_inconsistent_events = 0;
  unsigned int flag_for_consistency = 0;
  int flag_for_consistent_events = 0;

  for (L1GctFibreCollection::const_iterator f=fibre->begin(); f!=fibre->end(); f++){
        
    if (f->data()!=0)
      {
        if(m_doCounter) 
          {
            if(f==fibre->begin()) {flag_for_consistency = f->data();}
            else if(flag_for_consistency == f->data()){flag_for_consistent_events++;}
          }

        // Check for corrupt fibre data
        if (!CheckFibreWord(*f)){
          edm::LogInfo("GCT fibre data error") << "Missing phase bit (clock) in fibre data " << (*f);
        }
    
        // Check for BC0
        if (CheckForBC0(*f) && (f==fibre->begin())) {
          bc0=true;
        }

        // Check for mismatch between fibres
        if ((bc0 && !CheckForBC0(*f)) ||
            (!bc0 && CheckForBC0(*f))){
          edm::LogInfo("GCT fibre data error") << "BC0 mismatch in fibre data " << (*f);
        }

        // Check logical ID pattern
        if (m_doLogicalID) CheckLogicalID(*f);

        // Check counter pattern
        if (m_doCounter) CheckCounter(*f);

        flag_for_zeroes = 1;    
      }
    else 
      {
        //this basically checks that all the data is 0s by the time it gets to the last iteration
        if(flag_for_zeroes == 0 && f==(fibre->end()-1)) {m_numZeroEvents++;}
        //if the zero flag is set to 1 and it managed to find its way into here then something is wrong!
        if(flag_for_zeroes == 1) {flag_for_inconsistent_events++;}
      }

  }
  //check for inconsistent events i.e. those with one(or more) zeroes, and the rest data
  if(flag_for_inconsistent_events != 0) {m_numInconsistentPayloadEvents++;}
  //check for consistent events with the counter
  if(m_doCounter && flag_for_consistent_events != 0) {m_numConsistentEvents++;}
}

bool GctFibreAnalyzer::CheckForBC0(const L1GctFibreWord fibre)
{
  // Check for BC0 on this event
  if (fibre.data() & 0x8000){
    return true;
  } else {
    return false;
  }
}

bool GctFibreAnalyzer::CheckFibreWord(const L1GctFibreWord fibre)
{
  // Check that the phase or clock bit (MSB bit on cycle 1) is set as it should be
  if (fibre.data() & 0x80000000){
    return true;
  } else {
    return false;
  }
}

void GctFibreAnalyzer::CheckCounter(const L1GctFibreWord fibre)
{
  // Remove MSB from both cycles
  int cycle0Data, cycle1Data;
  
  cycle0Data = fibre.data() & 0x7FFF;
  cycle1Data = (fibre.data() >> 16) & 0x7FFF;

  // Check to see if fibre numbers are consistent
  if ((cycle0Data+1)!=cycle1Data){
    edm::LogInfo("GCT fibre data error") << "Fibre data not incrementing in cycles 0 and 1 "
                                         << " Cycle 0 data=" << cycle0Data
                                         << " Cycle 1 data=" << cycle1Data
                                         << " " << fibre;      
  }  
  
  // For now just write out the data
  edm::LogInfo("GCT fibre counter data") << " Fibre data: cycle0=" << cycle0Data 
                                         << " cycle1=" << cycle1Data
                                         << " " << fibre;
}

void GctFibreAnalyzer::CheckLogicalID(const L1GctFibreWord fibre)
{
  //added by Jad Marrouche, May 08

  unsigned ref_jf_link[] = {1,2,3,4,1,2,3,4};
  //this array lists the link number ordering we expect from the 3 JFs in positive eta
  //below, we modify indices 2 and 3 from 3,4 to 1,2 to represent negative eta

  unsigned ref_eta0_link[] = {3,4,3,4,3,4};
  //this array lists the link number ordering we expect from the ETA0

  unsigned ref_jf_type[] = {2,2,3,3,1,1,1,1};
  //this array lists the SC_type ordering we expect for the JFs

  unsigned ref_eta0_type[] = {2,2,2,2,2,2};
  //this array lists the SC_type ordering we expect for the ETA0 (for consistency)

  int eta_region, rct_phi_region, leaf_phi_region, jf_type, elec_type, local_source_card_id, source_card_id_read, source_card_id_expected;

  // Check that data in cycle 0 and cycle 1 are equal
  if ((fibre.data()&0x7FFF)!=((fibre.data()&0x7FFF0000)>>16)){
    edm::LogInfo("GCT fibre data error") << "Fibre data different on cycles 0 and 1 " << fibre;
  }

  //fibre.block() gives 0x90c etc
  //fibre.index() runs from 0 to 6/8

  if((fibre.block() >> 10) & 0x1 ) 
    {
      eta_region = 0;           //negative eta region           
      ref_jf_link[2] = 1; //modify indices to represent neg_eta fibre mapping
      ref_jf_link[3] = 2;       
    }   
  else eta_region = 1;  //positive eta region 

  if(((fibre.block() >> 8) & 0x7) == 0 || ((fibre.block() >> 8) & 0x7) == 4)    //i.e. electron leaf cards
    {
        
      if((fibre.block() & 0xFF)==0x04)          elec_type=1;
      else if((fibre.block() & 0xFF)==0x84)     elec_type=0;
      else throw cms::Exception("Unknown GCT fibre data block ") << fibre.block(); //else something screwed up   
        
      rct_phi_region = (fibre.index() / 3) + (4*elec_type);

      local_source_card_id = (4*eta_region);
        
      source_card_id_expected = (8 * rct_phi_region) + local_source_card_id;
        
      source_card_id_read = (fibre.data() >> 8) & 0x7F;
                
      if(source_card_id_expected != source_card_id_read ) 
        {
          edm::LogInfo("GCT fibre data error") << "Electron Source Card IDs do not match "  
                                               << "Expected ID = " << source_card_id_expected
                                               << " ID read from data = " << source_card_id_read
                                               << " " << fibre; //screwed up
        }

      if( (fibre.data() & 0xFF) != (unsigned int)(2 + fibre.index()%3))
        {
          edm::LogInfo("GCT fibre data error") << "Electron Fibres do not match "  
                                               << "Expected Fibre = " << (2 + fibre.index()%3)
                                               << " Fibre read from data = " << (fibre.data() & 0xFF)
                                               << " " << fibre; //screwed up
        }


    }
  else  //i.e. jet leaf cards
    {
      //the reason we use these values for eta_region is so it is easy to add 4 to the local source card ID
      //remember that 0x9.. 0xA.. and 0xB.. are +ve eta block headers
      //whereas 0xD.., 0xE.. and 0xF.. are -ve eta
      //can distinguish between them using the above mask and shift

      if((fibre.block() & 0xFF)==0x04)          jf_type=1;      //JF2
      else if((fibre.block() & 0xFF)==0x0C)     jf_type=2;      //JF3
      else if((fibre.block() & 0xFF)==0x84)     jf_type=-1;     //ETA0
      else if((fibre.block() & 0xFF)==0x8C)     jf_type=0;      //JF1
      else throw cms::Exception("Unknown GCT fibre data block ") << fibre.block(); //else something screwed up   

      //edm::LogInfo("JF Type Info") << "JF TYPE = " << jf_type << " block = " << fibre;        //INFO ONLY

      leaf_phi_region = ((fibre.block() >> 8) & 0x7)-1;         //0,1,2,3,4,5 for leaf cards
      if(eta_region == 0) leaf_phi_region--;            //need to do this because block index goes 9.. A.. B.. D.. E.. F.. - 8 and C are reserved for electron leafs which are dealt with above
      if(leaf_phi_region <0 || leaf_phi_region >5) throw cms::Exception("Unknown Leaf Card ") << fibre.block(); 
      //throw exception if number is outside 0-5 which means something screwed up
      //if(leaf_phi_region <0 || leaf_phi_region >5) edm::LogInfo("GCT fibre data error") << "Unknown leaf card " << fibre;
      //write to logger if number is outside 0-5 which means something screwed up

      if(jf_type == -1)
        {
          //in this case fibre.index() runs from 0-5
          //JF1 comes first, followed by JF2 and JF3
        
          if(fibre.index() <=5 )        //the compiler warning is because fibre.index() is unsigned int and hence is always >=0
            {
              rct_phi_region = ( (8 + ((leaf_phi_region%3)*3) + (fibre.index() / 2) ) % 9);
              //fibre.index()/2 will give 0 for 0,1 1 for 2,3 and 2 for 4,5
                
              //local_source_card_id = ref_eta0_type[ fibre.index() ] + (4 * (1 % eta_region));
              //take the ones complement of the eta_region because this is the shared part (i.e. other eta0 region)
              //this is done by (1 % eta_region) since 1%0 = 1 and 1%1=0
                          //FLAWED - since 1%0 is a floating point exception you idiot!

                          local_source_card_id = ref_eta0_type[ fibre.index() ] + (4 + (eta_region * -4));
                          //this gives what you want - adds 4 when eta_region = 0 (neg) and adds 0 when eta_region = 1 (pos)
        
              source_card_id_expected = (8 * rct_phi_region) + local_source_card_id;
              //from GCT_refdoc_v2_2.pdf
                
              source_card_id_read = (fibre.data() >> 8) & 0x7F;
                
              if(source_card_id_expected != source_card_id_read ) 
                {
                  edm::LogInfo("GCT fibre data error") << "ETA0 Source Card IDs do not match "  
                                                       << "Expected ID = " << source_card_id_expected
                                                       << " ID read from data = " << source_card_id_read
                                                       << " " << fibre; //screwed up
                }

              if( (fibre.data() & 0xFF) != ref_eta0_link[fibre.index()])
                {
                  edm::LogInfo("GCT fibre data error") << "ETA0 Fibres do not match "  
                                                       << "Expected Fibre = " << ref_eta0_link[fibre.index()]
                                                       << " Fibre read from data = " << (fibre.data() & 0xFF)
                                                       << " " << fibre; //screwed up
                }
            }
          else edm::LogInfo("GCT fibre data error") << "ETA0 Fibre index out of bounds " << fibre;
          //edm::LogInfo("Fibre Index Info") << "ETA0 Fibre index = " << fibre.index();
        }


      if(jf_type >=0) 
        {
          if(fibre.index() <=7 )
            {
              rct_phi_region = ( (8 + ((leaf_phi_region%3)*3) + jf_type ) % 9);         //see table below

              /*
                Leaf Card       |       RCT crate       |       Jet Finder
                ___________________________________________
                LC3     |       LC0     |       17      |       8       |       JF1
                |               |       9       |       0       |       JF2
                |               |       10      |       1       |       JF3
                ___________________________________________
                LC4     |       LC1     |       11      |       2       |       JF1
                |               |       12      |       3       |       JF2
                |               |       13      |       4       |       JF3
                ___________________________________________
                LC5     |       LC2     |       14      |       5       |       JF1
                |               |       15      |       6       |       JF2
                |               |       16      |       7       |       JF3
                ___________________________________________
                The phase results in the 17/8 being at the top
                This can be adjusted as necessary by changing
                the number 8 added before modulo 9 operation
              */

              local_source_card_id = ref_jf_type[ fibre.index() ] + (4 * eta_region);

              //since the SC sharing scheme renumbers SC 7 as SC3:
              if(local_source_card_id == 7) local_source_card_id = 3;
              //there is probably a more elegant way to do this

              source_card_id_expected = (8 * rct_phi_region) + local_source_card_id;

              source_card_id_read = (fibre.data() >> 8) & 0x7F;

              if(source_card_id_expected != source_card_id_read ) 
                {
                  edm::LogInfo("GCT fibre data error") << "Source Card IDs do not match "  
                                                       << "Expected ID = " << source_card_id_expected
                                                       << " ID read from data = " << source_card_id_read
                                                       << " " << fibre; //screwed up
                }

              if( (fibre.data() & 0xFF) != ref_jf_link[fibre.index()])
                {
                  edm::LogInfo("GCT fibre data error") << "Fibres do not match "  
                                                       << "Expected Fibre = " << ref_jf_link[fibre.index()]
                                                       << " Fibre read from data = " << (fibre.data() & 0xFF)
                                                       << " " << fibre; //screwed up
                }
            }
          else edm::LogInfo("GCT fibre data error") << "Fibre index out of bounds " << fibre;
        }

    }


}