#include <Phase2TrackerDigiProducer.h>

Inheritance diagram for Phase2Tracker::Phase2TrackerDigiProducer:

Classes
class	Registry

Public Member Functions
virtual void	beginJob () override

virtual void	beginRun (edm::Run const &, edm::EventSetup const &) override

virtual void	endJob () override

	Phase2TrackerDigiProducer (const edm::ParameterSet &pset)
	constructor More...

virtual void	produce (edm::Event &, const edm::EventSetup &) override

	~Phase2TrackerDigiProducer ()
	default constructor More...

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Attributes
const Phase2TrackerCabling *	cabling_

uint32_t	cacheId_

DetIdCollection	detids_

std::vector< Phase2TrackerDigi >	proc_work_digis_

std::vector< Registry >	proc_work_registry_

unsigned int	runNumber_

edm::EDGetTokenT < FEDRawDataCollection >	token_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 24 of file Phase2TrackerDigiProducer.h.

Constructor & Destructor Documentation

Phase2Tracker::Phase2TrackerDigiProducer::Phase2TrackerDigiProducer ( const edm::ParameterSet & pset )

constructor

Definition at line 25 of file Phase2TrackerDigiProducer.cc.

References edm::ParameterSet::getParameter(), and token_.

                                                                                     :
     runNumber_(0),
     cabling_(0),
     cacheId_(0)
   {
     // define product
     produces< edm::DetSetVector<Phase2TrackerDigi> >("ProcessedRaw");
     token_ = consumes<FEDRawDataCollection>(pset.getParameter<edm::InputTag>("ProductLabel"));
   }

Phase2Tracker::Phase2TrackerDigiProducer::~Phase2TrackerDigiProducer ( )

default constructor

Definition at line 35 of file Phase2TrackerDigiProducer.cc.

36 {

37 }

Member Function Documentation

void Phase2Tracker::Phase2TrackerDigiProducer::beginJob ( void )

overridevirtual

Reimplemented from edm::EDProducer.

Definition at line 39 of file Phase2TrackerDigiProducer.cc.

40 {

41 }

void Phase2Tracker::Phase2TrackerDigiProducer::beginRun	(	edm::Run const &	run,
		edm::EventSetup const &	es
	)

overridevirtual

Reimplemented from edm::EDProducer.

Definition at line 43 of file Phase2TrackerDigiProducer.cc.

References EnergyCorrector::c, cabling_, edm::EventSetup::get(), and edm::ESHandle< class >::product().

   {
     // fetch cabling from event setup
     edm::ESHandle<Phase2TrackerCabling> c;
     es.get<Phase2TrackerCablingRcd>().get( c );
     cabling_ = c.product();
   }

void Phase2Tracker::Phase2TrackerDigiProducer::endJob ( void )

overridevirtual

Reimplemented from edm::EDProducer.

Definition at line 51 of file Phase2TrackerDigiProducer.cc.

52 {

53 }

void Phase2Tracker::Phase2TrackerDigiProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	es
	)

overridevirtual

Implements edm::EDProducer.

Definition at line 55 of file Phase2TrackerDigiProducer.cc.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

   {
     // empty vectors for the next event
     proc_work_registry_.clear();    
     proc_work_digis_.clear();
 
     // Retrieve FEDRawData collection
     edm::Handle<FEDRawDataCollection> buffers;
     event.getByToken( token_, buffers );
 
     // Analyze strip tracker FED buffers in data
     size_t fedIndex;
     for( fedIndex = Phase2Tracker::FED_ID_MIN; fedIndex < Phase2Tracker::CMS_FED_ID_MAX; ++fedIndex )
     {
       const FEDRawData& fed = buffers->FEDData(fedIndex);
       if(fed.size()!=0)
       {
     // construct buffer
     Phase2Tracker:: Phase2TrackerFEDBuffer* buffer = 0;
     buffer = new Phase2Tracker::Phase2TrackerFEDBuffer(fed.data(),fed.size());
 
         #ifdef EDM_ML_DEBUG
         std::ostringstream ss;
     ss << " -------------------------------------------- " << endl;
     ss << " buffer debug ------------------------------- " << endl;
     ss << " -------------------------------------------- " << endl;
     ss << " buffer size : " << buffer->bufferSize() << endl;
     ss << " fed id      : " << fedIndex << endl;
     ss << " -------------------------------------------- " << endl;
     ss << " tracker header debug ------------------------" << endl;
     ss << " -------------------------------------------- " << endl;
         LogTrace("Phase2TrackerDigiProducer") << ss.str(); ss.clear(); ss.str("");
 
     Phase2TrackerFEDHeader tr_header = buffer->trackerHeader();
     ss << " Version  : " << hex << setw(2) << (int) tr_header.getDataFormatVersion() << endl;
     ss << " Mode     : " << hex << setw(2) << tr_header.getDebugMode() << endl;
     ss << " Type     : " << hex << setw(2) << (int) tr_header.getEventType() << endl;
     ss << " Readout  : " << hex << setw(2) << tr_header.getReadoutMode() << endl;
         ss << " Condition Data : " << ( tr_header.getConditionData() ? "Present" : "Absent") << "\n";
         ss << " Data Type      : " << ( tr_header.getDataType() ? "Real" : "Fake" ) << "\n";
     ss << " Status   : " << hex << setw(16)<< (int) tr_header.getGlibStatusCode() << endl;
     ss << " FE stat  : " ;
     for(int i=15; i>=0; i--)
     {
       if((tr_header.frontendStatus())[i])
       {
         ss << "1";
       }
       else
       {
         ss << "0";
       }
     }
     ss << endl;
     ss << " Nr CBC   : " << hex << setw(16)<< (int) tr_header.getNumberOfCBC() << endl;
     ss << " CBC stat : ";
     for(int i=0; i<tr_header.getNumberOfCBC(); i++)
     {
       ss << hex << setw(2) << (int) tr_header.CBCStatus()[i] << " ";
     }
     ss << endl;
         LogTrace("Phase2TrackerDigiProducer") << ss.str(); ss.clear(); ss.str("");
     ss << " -------------------------------------------- " << endl;
     ss << " Payload  ----------------------------------- " << endl;
     ss << " -------------------------------------------- " << endl;
     #endif
 
     // loop channels
     int ichan = 0;
     for ( int ife = 0; ife < MAX_FE_PER_FED; ife++ )
     {
       for ( int icbc = 0; icbc < MAX_CBC_PER_FE; icbc++ )
       {
         const Phase2TrackerFEDChannel& channel = buffer->channel(ichan);
         if(channel.length() > 0)
         {
               // get fedid from cabling
               const Phase2TrackerModule mod = cabling_->findFedCh(std::make_pair(fedIndex, ife));
               uint32_t detid = mod.getDetid();
               #ifdef EDM_ML_DEBUG
               ss << dec << " id from cabling : " << detid << endl;
               ss << dec << " reading channel : " << icbc << " on FE " << ife;
           ss << dec << " with length  : " << (int) channel.length() << endl;
           #endif
 
               // container for this channel's digis
               std::vector<Phase2TrackerDigi> stripsTop;
               std::vector<Phase2TrackerDigi> stripsBottom;
 
               // unpacking data
           Phase2TrackerFEDRawChannelUnpacker unpacker = Phase2TrackerFEDRawChannelUnpacker(channel);
           while (unpacker.hasData())
           {
         if(unpacker.stripOn())
         { 
                   if (unpacker.stripIndex()%2) 
                   {
             stripsTop.push_back(Phase2TrackerDigi( (int) (STRIPS_PER_CBC*icbc + unpacker.stripIndex())/2, 0));
                     #ifdef EDM_ML_DEBUG
                     ss << "t";
                 #endif
                   }
                   else 
                   {
                     stripsBottom.push_back(Phase2TrackerDigi( (int) (STRIPS_PER_CBC*icbc + unpacker.stripIndex())/2, 0));
                     #ifdef EDM_ML_DEBUG
                     ss << "b";
                 #endif
                   }
         } 
                 else
         { 
                   #ifdef EDM_ML_DEBUG
                   ss << "_";
               #endif
         }
         unpacker++;
           }
               #ifdef EDM_ML_DEBUG
           ss << endl;
               LogTrace("Phase2TrackerDigiProducer") << ss.str(); ss.clear(); ss.str("");
           #endif
 
               // store beginning and end of this digis for this detid and add this registry to the list
               // and store data
               Registry regItemTop(detid+1, STRIPS_PER_CBC*icbc/2, proc_work_digis_.size(), stripsTop.size());
               proc_work_registry_.push_back(regItemTop);
               proc_work_digis_.insert(proc_work_digis_.end(),stripsTop.begin(),stripsTop.end());
               Registry regItemBottom(detid+2, STRIPS_PER_CBC*icbc/2, proc_work_digis_.size(), stripsBottom.size());
               proc_work_registry_.push_back(regItemBottom);
               proc_work_digis_.insert(proc_work_digis_.end(),stripsBottom.begin(),stripsBottom.end());
         }
         ichan ++;
       }
     } // end loop on channels
         // store digis in edm collections
         std::sort( proc_work_registry_.begin(), proc_work_registry_.end() );
         std::vector< edm::DetSet<Phase2TrackerDigi> > sorted_and_merged;
 
         edm::DetSetVector<Phase2TrackerDigi>* pr = new edm::DetSetVector<Phase2TrackerDigi>();
 
         std::vector<Registry>::iterator it = proc_work_registry_.begin(), it2 = it+1, end = proc_work_registry_.end();
         while (it < end) 
         {
           sorted_and_merged.push_back( edm::DetSet<Phase2TrackerDigi>(it->detid) );
           std::vector<Phase2TrackerDigi> & digis = sorted_and_merged.back().data;
           // first count how many digis we have
           size_t len = it->length;
           for (it2 = it+1; (it2 != end) && (it2->detid == it->detid); ++it2) { len += it2->length; }
           // reserve memory 
           digis.reserve(len);
           // push them in
           for (it2 = it+0; (it2 != end) && (it2->detid == it->detid); ++it2) 
           {
             digis.insert( digis.end(), & proc_work_digis_[it2->index], & proc_work_digis_[it2->index + it2->length] );
           }
           it = it2;
         }
 
         edm::DetSetVector<Phase2TrackerDigi> proc_raw_dsv( sorted_and_merged, true );
         pr->swap( proc_raw_dsv );
         std::auto_ptr< edm::DetSetVector<Phase2TrackerDigi> > pr_dsv(pr);
         event.put( pr_dsv, "ProcessedRaw" );
         delete buffer;
         }
      }   
    } 