#include <HGCalBestChoiceCodecImpl.h>

Public Types
typedef HGCalBestChoiceDataPayload	data_type

Public Member Functions
uint32_t	adcnBits () const

double	adcsaturation () const

void	bestChoiceSelect (data_type &)

size_t	dataLength () const

data_type	decode (const std::vector< bool > &) const

std::vector< bool >	encode (const data_type &) const

	HGCalBestChoiceCodecImpl (const edm::ParameterSet &conf)

void	linearize (const std::vector< HGCDataFrame< HGCalDetId, HGCSample >> &, std::vector< std::pair< HGCalDetId, uint32_t > > &)

double	linLSB () const

size_t	nData () const

uint32_t	tdcnBits () const

double	tdcOnsetfC () const

double	tdcsaturation () const

uint32_t	triggerCellSaturationBits () const

void	triggerCellSums (const HGCalTriggerGeometryBase &, const std::vector< std::pair< HGCalDetId, uint32_t > > &, data_type &)

uint32_t	triggerCellTruncationBits () const

Private Attributes
double	adcLSB_

uint32_t	adcnBits_

double	adcsaturation_

size_t	dataLength_

double	linLSB_

size_t	nCellsInModule_

size_t	nData_

double	tdcLSB_

uint32_t	tdcnBits_

double	tdcOnsetfC_

double	tdcsaturation_

uint32_t	triggerCellSaturationBits_

uint32_t	triggerCellTruncationBits_

Detailed Description

Definition at line 27 of file HGCalBestChoiceCodecImpl.h.

Member Typedef Documentation

typedef HGCalBestChoiceDataPayload HGCalBestChoiceCodecImpl::data_type

Definition at line 30 of file HGCalBestChoiceCodecImpl.h.

Constructor & Destructor Documentation

HGCalBestChoiceCodecImpl::HGCalBestChoiceCodecImpl ( const edm::ParameterSet & conf )

Definition at line 6 of file HGCalBestChoiceCodecImpl.cc.

References adcLSB_, adcnBits_, adcsaturation_, dataLength_, nCellsInModule_, nData_, funct::pow(), tdcLSB_, tdcnBits_, tdcsaturation_, triggerCellSaturationBits_, and triggerCellTruncationBits_.

                                                                               :
     nData_(conf.getParameter<uint32_t>("NData")),
     dataLength_(conf.getParameter<uint32_t>("DataLength")),
     nCellsInModule_(data_type::size),
     linLSB_(conf.getParameter<double>("linLSB")),
     adcsaturation_(conf.getParameter<double>("adcsaturation")),
     adcnBits_(conf.getParameter<uint32_t>("adcnBits")),
     tdcsaturation_(conf.getParameter<double>("tdcsaturation")), 
     tdcnBits_(conf.getParameter<uint32_t>("tdcnBits")), 
     tdcOnsetfC_(conf.getParameter<double>("tdcOnsetfC")),
     triggerCellTruncationBits_(conf.getParameter<uint32_t>("triggerCellTruncationBits"))
 /*****************************************************************/
 {
   // Cannot have more selected cells than the max number of cells
   if(nData_>nCellsInModule_) nData_ = nCellsInModule_;
   adcLSB_ =  adcsaturation_/pow(2.,adcnBits_);
   tdcLSB_ =  tdcsaturation_/pow(2.,tdcnBits_);
   triggerCellSaturationBits_ = triggerCellTruncationBits_ + dataLength_;
 }

Member Function Documentation

uint32_t HGCalBestChoiceCodecImpl::adcnBits ( ) const

inline

Definition at line 50 of file HGCalBestChoiceCodecImpl.h.

References adcnBits_.

Referenced by HGCalBestChoiceCodec::setDataPayloadImpl().

50 {return adcnBits_;}

HGCalBestChoiceCodecImpl::adcnBits_

uint32_t adcnBits_

Definition: HGCalBestChoiceCodecImpl.h:64

double HGCalBestChoiceCodecImpl::adcsaturation ( ) const

inline

Definition at line 49 of file HGCalBestChoiceCodecImpl.h.

References adcsaturation_.

Referenced by HGCalBestChoiceCodec::setDataPayloadImpl().

49 {return adcsaturation_;}

HGCalBestChoiceCodecImpl::adcsaturation_

double adcsaturation_

Definition: HGCalBestChoiceCodecImpl.h:63

void HGCalBestChoiceCodecImpl::bestChoiceSelect ( data_type & data )

Definition at line 158 of file HGCalBestChoiceCodecImpl.cc.

References a, b, Exception, i, nCellsInModule_, nData_, and HGCalBestChoiceDataPayload::payload.

Referenced by HGCalBestChoiceCodec::setDataPayloadImpl().

 {
     // Store data payload in vector for energy sorting. Then refill the data payload after trigger
     // cell selection.
     // Probably not the most efficient way.
     // Should check in the firmware how cells with the same energy are sorted
 
     // copy for sorting
     std::vector< std::pair<uint32_t, uint32_t> > sortedtriggercells; // value, ID
     sortedtriggercells.reserve(nCellsInModule_);
     for(size_t i=0; i<nCellsInModule_; i++)
     {
         sortedtriggercells.push_back(std::make_pair(data.payload[i], i));
     }
     // sort, reverse order
     sort(sortedtriggercells.begin(), sortedtriggercells.end(),
             [](const std::pair<uint32_t, uint32_t>& a, 
                 const  std::pair<uint32_t, uint32_t>& b) -> bool
             { 
                 return a > b; 
             } 
             );
     // keep only the first trigger cells
     for(size_t i=nData_; i<nCellsInModule_; i++)
     {
         sortedtriggercells.at(i).first = 0;
     }
     for(const auto& value_id : sortedtriggercells)
     {
         if(value_id.second>=nCellsInModule_)
         {
             throw cms::Exception("BadGeometry")
                 << "Number of trigger cells in module too large for available data payload\n";
         }
         data.payload.at(value_id.second) = value_id.first;
     }
 }

size_t HGCalBestChoiceCodecImpl::dataLength ( ) const

inline

Definition at line 47 of file HGCalBestChoiceCodecImpl.h.

References dataLength_.

Referenced by HGCalBestChoiceCodec::setDataPayloadImpl().

47 {return dataLength_;}

HGCalBestChoiceCodecImpl::dataLength_

size_t dataLength_

Definition: HGCalBestChoiceCodecImpl.h:60

HGCalBestChoiceCodecImpl::data_type HGCalBestChoiceCodecImpl::decode ( const std::vector< bool > & data ) const

Definition at line 62 of file HGCalBestChoiceCodecImpl.cc.

References b, EnergyCorrector::c, data, Exception, i, cmsHarvester::index, HGCalBestChoiceDataPayload::payload, HGCalBestChoiceDataPayload::reset(), mps_fire::result, and relativeConstraints::value.

 {
     data_type result;
     result.reset();
     if(data.size()!=nCellsInModule_+dataLength_*nData_)
     {
         throw cms::Exception("BadData") 
             << "decode: data length ("<<data.size()<<") inconsistent with codec parameters:\n"\
             << "      : Map size = "<<nCellsInModule_<<"\n"\
             << "      : Number of energy values = "<<nData_<<"\n"\
             << "      : Energy value length = "<<dataLength_<<"\n";
     }
     size_t c = 0;
     for(size_t b=0; b<nCellsInModule_; b++)
     {
         if(data[b])
         {
             uint32_t value = 0;
             for(size_t i=0;i<dataLength_;i++)
             {
                 size_t index = nCellsInModule_+c*dataLength_+i; 
                 if(data[index]) value |= (0x1<<i);
             }
             c++;
             result.payload[b] = value;
         }
     }
     return result;
 }

std::vector< bool > HGCalBestChoiceCodecImpl::encode ( const data_type & data ) const

Definition at line 29 of file HGCalBestChoiceCodecImpl.cc.

References data, Exception, i, mps_fire::result, and relativeConstraints::value.

 {
     // First nCellsInModule_ bits are encoding the map of selected trigger cells
     // Followed by nData_ words of dataLength_ bits, corresponding to energy/transverse energy of
     // the selected trigger cells
     std::vector<bool> result(nCellsInModule_ + dataLength_*nData_, 0);
     size_t idata = 0;
     for(size_t itc=0; itc<nCellsInModule_; itc++)
     {
         uint32_t value = data.payload.at(itc);
         result[itc] = (value>0 ? 1 : 0);
         if(value>0)
         {
             if(idata>=nData_)
             {
                 throw cms::Exception("BadData") 
                     << "encode: Number of non-zero trigger cells larger than codec parameter\n"\
                     << "      : Number of energy values = "<<nData_<<"\n";
             }
             // Saturate and truncate energy values
             if(value+1>(0x1u<<triggerCellSaturationBits_)) value = (0x1<<triggerCellSaturationBits_)-1;
             for(size_t i=0; i<dataLength_; i++)
             {
                 result[nCellsInModule_ + idata*dataLength_ + i] = static_cast<bool>(value & (0x1<<(i+triggerCellTruncationBits_)));// remove the lowest bits (=triggerCellTruncationBits_)
             }
             idata++;
         }
     }
     return result;
 }

void HGCalBestChoiceCodecImpl::linearize	(	const std::vector< HGCDataFrame< HGCalDetId, HGCSample >> &	dataframes,
		std::vector< std::pair< HGCalDetId, uint32_t > > &	linearized_dataframes
	)

Definition at line 95 of file HGCalBestChoiceCodecImpl.cc.

References adcLSB_, data, linLSB_, universalConfigTemplate::mode, tdcLSB_, and tdcOnsetfC_.

Referenced by HGCalBestChoiceCodec::setDataPayloadImpl().

 {
     double amplitude; uint32_t amplitude_int;
    
 
     for(const auto& frame : dataframes) {//loop on DIGI
         if (frame[2].mode()) {//TOT mode
             amplitude =( floor(tdcOnsetfC_/adcLSB_) + 1.0 )* adcLSB_ + double(frame[2].data()) * tdcLSB_;
         }
         else {//ADC mode
             amplitude = double(frame[2].data()) * adcLSB_;
         }
 
         amplitude_int = uint32_t (floor(amplitude/linLSB_+0.5));  
         if (amplitude_int>65535) amplitude_int = 65535;
 
         linearized_dataframes.push_back(std::make_pair (frame.id(), amplitude_int));
     }
 }

double HGCalBestChoiceCodecImpl::linLSB ( ) const

inline

Definition at line 48 of file HGCalBestChoiceCodecImpl.h.

References linLSB_.

Referenced by HGCalBestChoiceCodec::setDataPayloadImpl().

48 {return linLSB_;}

HGCalBestChoiceCodecImpl::linLSB_

double linLSB_

Definition: HGCalBestChoiceCodecImpl.h:62

size_t HGCalBestChoiceCodecImpl::nData ( ) const

inline

Definition at line 46 of file HGCalBestChoiceCodecImpl.h.

References nData_.

46 {return nData_;}

HGCalBestChoiceCodecImpl::nData_

size_t nData_

Definition: HGCalBestChoiceCodecImpl.h:59

uint32_t HGCalBestChoiceCodecImpl::tdcnBits ( ) const

inline

Definition at line 52 of file HGCalBestChoiceCodecImpl.h.

References tdcnBits_.

Referenced by HGCalBestChoiceCodec::setDataPayloadImpl().

52 {return tdcnBits_;}

HGCalBestChoiceCodecImpl::tdcnBits_

uint32_t tdcnBits_

Definition: HGCalBestChoiceCodecImpl.h:66

double HGCalBestChoiceCodecImpl::tdcOnsetfC ( ) const

inline

Definition at line 53 of file HGCalBestChoiceCodecImpl.h.

References tdcOnsetfC_.

Referenced by HGCalBestChoiceCodec::setDataPayloadImpl().

53 {return tdcOnsetfC_;}

HGCalBestChoiceCodecImpl::tdcOnsetfC_

double tdcOnsetfC_

Definition: HGCalBestChoiceCodecImpl.h:67

double HGCalBestChoiceCodecImpl::tdcsaturation ( ) const

inline

Definition at line 51 of file HGCalBestChoiceCodecImpl.h.

References tdcsaturation_.

Referenced by HGCalBestChoiceCodec::setDataPayloadImpl().

51 {return tdcsaturation_;}

HGCalBestChoiceCodecImpl::tdcsaturation_

double tdcsaturation_

Definition: HGCalBestChoiceCodecImpl.h:65

uint32_t HGCalBestChoiceCodecImpl::triggerCellSaturationBits ( ) const

inline

Definition at line 55 of file HGCalBestChoiceCodecImpl.h.

References triggerCellSaturationBits_.

55 {return triggerCellSaturationBits_;}

HGCalBestChoiceCodecImpl::triggerCellSaturationBits_

uint32_t triggerCellSaturationBits_

Definition: HGCalBestChoiceCodecImpl.h:71

void HGCalBestChoiceCodecImpl::triggerCellSums	(	const HGCalTriggerGeometryBase &	geometry,
		const std::vector< std::pair< HGCalDetId, uint32_t > > &	linearized_dataframes,
		data_type &	data
	)

Definition at line 119 of file HGCalBestChoiceCodecImpl.cc.

References HLT_FULL_cff::distance, Exception, HGCalTriggerGeometryBase::getModuleFromTriggerCell(), HGCalTriggerGeometryBase::getOrderedTriggerCellsFromModule(), HGCalTriggerGeometryBase::getTriggerCellFromCell(), nCellsInModule_, HGCalBestChoiceDataPayload::payload, and relativeConstraints::value.

Referenced by HGCalBestChoiceCodec::setDataPayloadImpl().

 {
     if(linearized_dataframes.size()==0) return;
     std::map<HGCalDetId, uint32_t> payload;
     // sum energies in trigger cells
     for(const auto& frame : linearized_dataframes)
     {
         HGCalDetId cellid(frame.first);
         // find trigger cell associated to cell
         uint32_t tcid = geometry.getTriggerCellFromCell(cellid);
         HGCalDetId triggercellid( tcid );
         payload.insert( std::make_pair(triggercellid, 0) ); // do nothing if key exists already
         // FIXME: need to transform ADC and TDC to the same linear scale on 12 bits
         uint32_t value = frame.second; // 'value' has to be a 12 bit word
         payload[triggercellid] += value; // 32 bits integer should be largely enough (maximum 7 12-bits sums are done)
 
     }
     uint32_t module = geometry.getModuleFromTriggerCell(payload.begin()->first);
     HGCalTriggerGeometryBase::geom_ordered_set trigger_cells_in_module = geometry.getOrderedTriggerCellsFromModule(module);
     // fill data payload
     for(const auto& id_value : payload)
     {
         // find the index of the trigger cell in the module (not necessarily equal to .cell())
         // FIXME: std::distance is linear with size for sets (no random access). In order to have constant
         // access would require to convert the set into a vector. 
         uint32_t id = std::distance(trigger_cells_in_module.begin(),trigger_cells_in_module.find(id_value.first));
         //uint32_t id = id_value.first.cell();
         //std::cerr<<"cell id in trigger cell sum: "<<id<<"("<<id_value.first.wafer()<<","<<id_value.first.cell()<<")\n";
         if(id>=nCellsInModule_) 
         {
             throw cms::Exception("BadGeometry")
                 << "Number of trigger cells in module too large for available data payload\n";
         }
         data.payload.at(id) = id_value.second;
     }
 }