CMS 3D CMS Logo

EcalTrigPrimFunctionalAlgo Class Reference

EcalTrigPrimFunctionalAlgo is the main algorithm class for TPG It coordinates all the aother algorithms Structure is as close as possible to electronics. More...

#include <SimCalorimetry/EcalTrigPrimAlgos/interface/EcalTrigPrimFunctionalAlgo.h>

List of all members.

Public Member Functions

 EcalTrigPrimFunctionalAlgo (const edm::EventSetup &setup, int binofmax, bool tcpFormat, bool barrelOnly, bool debug, bool famos)
void run (const edm::EventSetup &, const EEDigiCollection *col, EcalTrigPrimDigiCollection &result, EcalTrigPrimDigiCollection &resultTcp)
void run (const edm::EventSetup &, const EBDigiCollection *col, EcalTrigPrimDigiCollection &result, EcalTrigPrimDigiCollection &resultTcp)
void run_part1_EB (EBDigiCollection const *col)
void run_part1_EE (EEDigiCollection const *col)
template<class Coll>
void run_part2 (const edm::EventSetup &, Coll const *col, std::vector< std::vector< std::pair< int, std::vector< typename Coll::Digi > > > > &towerMap, EcalTrigPrimDigiCollection &result, EcalTrigPrimDigiCollection &resultTcp)
void setPointers (const EcalTPGLinearizationConst *ecaltpLin, const EcalTPGPedestals *ecaltpPed, const EcalTPGSlidingWindow *ecaltpgSlidW, const EcalTPGWeightIdMap *ecaltpgWeightMap, const EcalTPGWeightGroup *ecaltpgWeightGroup, const EcalTPGFineGrainStripEE *ecaltpgFgStripEE)
void setPointers2 (const EcalTPGFineGrainEBGroup *ecaltpgFgEBGroup, const EcalTPGLutGroup *ecaltpgLutGroup, const EcalTPGLutIdMap *ecaltpgLut, const EcalTPGFineGrainEBIdMap *ecaltpgFineGrainEB, const EcalTPGFineGrainTowerEE *ecaltpgFineGrainTowerEE)
virtual ~EcalTrigPrimFunctionalAlgo ()

Private Types

enum  { nbMaxStrips_ = 5 }
enum  { nbMaxXtals_ = 5 }

Private Member Functions

template<class T>
void clean (std::vector< std::vector< std::pair< int, std::vector< T > > > > &towerMap)
template<class Coll>
void fillMap (Coll const *col, std::vector< std::vector< std::pair< int, std::vector< typename Coll::Digi > > > > &towerMap)
int findStripNr (const EEDetId &id)
int findStripNr (const EBDetId &id)
int getIndex (const EEDigiCollection *, EcalTrigTowerDetId &id)
int getIndex (const EBDigiCollection *, EcalTrigTowerDetId &id)
void init (const edm::EventSetup &)
template<class T>
void initStructures (std::vector< std::vector< std::pair< int, std::vector< T > > > > &towMap)

Private Attributes

bool barrelOnly_
int binOfMaximum_
bool debug_
EcalFenixStrip * estrip_
EcalFenixTcp * etcp_
edm::ESHandle
< EcalTrigTowerConstituentsMap > 		eTTmap_
bool famos_
std::vector< std::pair< int,
EcalTrigTowerDetId > > 		hitTowers_
int maxNrSamples_
int nrTowers_
std::vector< std::vector< int > > striptp_
bool tcpFormat_
const CaloSubdetectorGeometry * theEndcapGeometry
const EcalElectronicsMapping * theMapping_
float threshold
std::vector< std::vector
< std::pair< int, std::vector
< EBDataFrame > > > > 		towerMapEB_
std::vector< std::vector
< std::pair< int, std::vector
< EEDataFrame > > > > 		towerMapEE_
std::vector
< EcalTriggerPrimitiveSample > 		towtp2_
std::vector
< EcalTriggerPrimitiveSample > 		towtp_

Static Private Attributes

static const unsigned int maxNrSamplesOut_ = 10
static const unsigned int maxNrTowers_ = 2448
static const unsigned int maxNrTPs_ = 2448
static const unsigned int nrSamples_ = 5

Detailed Description

EcalTrigPrimFunctionalAlgo is the main algorithm class for TPG It coordinates all the aother algorithms Structure is as close as possible to electronics.

EcalTrigPrimFunctionalAlgo is the main algorithm class for TPG It coordinates all the aother algorithms Structure is very close to electronics.

Author:
Ursula Berthon, Stephanie Baffioni, LLR Palaiseau
Version:
1st Version may 2006

2nd Version jul 2006

3rd Version sep 2007 introducing new Records closer to the db

Author:
Ursula Berthon, Stephanie Baffioni, LLR Palaiseau
Version:
1st Version may 2006

2nd Version jul 2006

Definition at line 48 of file EcalTrigPrimFunctionalAlgo.h.

Member Enumeration Documentation

anonymous enum [private]

Enumerator:
nbMaxStrips_ 

Definition at line 131 of file EcalTrigPrimFunctionalAlgo.h.

00131 {nbMaxStrips_=5};

anonymous enum [private]

Enumerator:
nbMaxXtals_ 

Definition at line 132 of file EcalTrigPrimFunctionalAlgo.h.

00132 {nbMaxXtals_=5};

Constructor & Destructor Documentation

EcalTrigPrimFunctionalAlgo::EcalTrigPrimFunctionalAlgo ( const edm::EventSetup &  setup,
int  binofmax,
bool  tcpFormat,
bool  barrelOnly,
bool  debug,
bool  famos 
) [explicit]

Definition at line 51 of file EcalTrigPrimFunctionalAlgo.cc.

References famos_, init(), and maxNrSamples_.

00051                                                                                                                                                     : binOfMaximum_(binofmax),
00052   tcpFormat_(tcpFormat), barrelOnly_(barrelOnly), debug_(debug), famos_(famos)
00053 
00054 {
00055  if (famos_) maxNrSamples_=1;  //get from input??
00056  else maxNrSamples_=10;
00057  this->init(setup);
00058 }

EcalTrigPrimFunctionalAlgo::~EcalTrigPrimFunctionalAlgo (  )  [virtual]

Definition at line 90 of file EcalTrigPrimFunctionalAlgo.cc.

References estrip_, and etcp_.

00091 {
00092     delete estrip_;
00093     delete etcp_;
00094 }

Member Function Documentation

template<class T>
void EcalTrigPrimFunctionalAlgo::clean ( std::vector< std::vector< std::pair< int, std::vector< T > > > > &  towerMap  )  [inline, private]

Definition at line 274 of file EcalTrigPrimFunctionalAlgo.h.

References i, j, maxNrTowers_, and nbMaxStrips_.

Referenced by run_part1_EB(), and run_part1_EE().

00274                                                                                                    {  
00275   // clean internal data structures
00276   for (unsigned int i=0;i<maxNrTowers_;++i) 
00277     for (int j=0;j<nbMaxStrips_ ;++j) (towMap[i])[j].first=0;
00278   return;
00279 }

template<class Coll>
void EcalTrigPrimFunctionalAlgo::fillMap ( Coll const *  col,
std::vector< std::vector< std::pair< int, std::vector< typename Coll::Digi > > > > &  towerMap 
) [inline, private]

Definition at line 233 of file EcalTrigPrimFunctionalAlgo.h.

References findStripNr(), first, getIndex(), hitTowers_, i, index, LogDebug, nbMaxXtals_, nrTowers_, and edm::second().

Referenced by run_part1_EB(), and run_part1_EE().

00235 {
00236   typedef typename Coll::Digi Digi;
00237 
00238   // implementation for Barrel and Endcap
00239 
00240   if (col) {
00241     nrTowers_=0;
00242     LogDebug("EcalTPG") <<"Fill mapping, Collection size = "<<col->size();
00243     for(unsigned int i = 0; i < col->size() ; ++i) {
00244       Digi samples((*col)[i]); 
00245       EcalTrigTowerDetId coarser=(*eTTmap_).towerOf(samples.id());
00246       int index=getIndex(col,coarser);
00247       int stripnr=findStripNr(samples.id());
00248 
00249       int filled=0;
00250       for (unsigned int ij=0;ij<towerMap[index].size();++ij) filled+=towerMap[index][ij].first;
00251       if (!filled) {
00252         hitTowers_[nrTowers_++]=std::pair <int,EcalTrigTowerDetId>(index,coarser);
00253       }
00254 
00255       //FIXME: temporary protection
00256       int ncryst=towerMap[index][stripnr-1].first;
00257       if (ncryst>=nbMaxXtals_ ) {
00258         edm::LogError("EcalTrigPrimFunctionAlgo")<<"! Too many xtals for TT "<<coarser<<" stripnr "<<stripnr<<" xtalid "<<samples.id() ;
00259         continue;
00260       }
00261       ((towerMap[index])[stripnr-1].second)[ncryst]=samples;
00262       (towerMap[index])[stripnr-1].first++;
00263     }
00264   
00265     LogDebug("EcalTPG")<<"fillMap"<<"[EcalTrigPrimFunctionalAlgo] (found " 
00266                        << col->size() << " frames in "<< towerMap.size() << " towers) ";
00267   }
00268   else {
00269     LogDebug("EcalTPG")<<"FillMap - FillMap Collection size=0 !!!!";
00270   }
00271 }

int EcalTrigPrimFunctionalAlgo::findStripNr ( const EEDetId &  id  )  [private]

Definition at line 122 of file EcalTrigPrimFunctionalAlgo.cc.

References EcalElectronicsMapping::getTriggerElectronicsId(), EcalTriggerElectronicsId::pseudoStripId(), and theMapping_.

00122                                                              {
00123   int stripnr;
00124   const EcalTriggerElectronicsId elId = theMapping_->getTriggerElectronicsId(id);
00125   stripnr=elId.pseudoStripId();
00126   return stripnr;
00127 }

int EcalTrigPrimFunctionalAlgo::findStripNr ( const EBDetId &  id  )  [private]

Definition at line 114 of file EcalTrigPrimFunctionalAlgo.cc.

References n, and nbMaxStrips_.

Referenced by fillMap().

00114                                                              {
00115   int stripnr;
00116   int n=((id.ic()-1)%100)/20; //20 corresponds to 4 * ecal_barrel_crystals_per_strip FIXME!!
00117   if (id.ieta()<0) stripnr = n+1;
00118   else stripnr =nbMaxStrips_ - n; 
00119   return stripnr;
00120 }

int EcalTrigPrimFunctionalAlgo::getIndex ( const EEDigiCollection *  ,
EcalTrigTowerDetId &  id 
) [inline, private]

Definition at line 93 of file EcalTrigPrimFunctionalAlgo.h.

00093                                                                   {
00094     int ind=(id.ietaAbs()-18)*72 + id.iphi();
00095     if (id.zside()<0) ind+=792;
00096     return ind;
00097   }

int EcalTrigPrimFunctionalAlgo::getIndex ( const EBDigiCollection *  ,
EcalTrigTowerDetId &  id 
) [inline, private]

Definition at line 91 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by fillMap().

00091 {return id.hashedIndex();}

void EcalTrigPrimFunctionalAlgo::init ( const edm::EventSetup &  setup  )  [private]

Definition at line 61 of file EcalTrigPrimFunctionalAlgo.cc.

References barrelOnly_, binOfMaximum_, debug_, estrip_, etcp_, eTTmap_, famos_, edm::EventSetup::get(), hitTowers_, initStructures(), maxNrSamples_, maxNrSamplesOut_, maxNrTowers_, nbMaxStrips_, nbMaxXtals_, edm::ESHandle< T >::product(), tcpFormat_, theEndcapGeometry, theMapping_, towerMapEB_, towerMapEE_, towtp2_, and towtp_.

Referenced by EcalTrigPrimFunctionalAlgo().

00061                                                                  {
00062   if (!barrelOnly_) {
00063     edm::ESHandle<CaloGeometry> theGeometry;
00064     edm::ESHandle<CaloSubdetectorGeometry> theEndcapGeometry_handle;
00065     setup.get<CaloGeometryRecord>().get( theGeometry );
00066     setup.get<EcalEndcapGeometryRecord>().get("EcalEndcap",theEndcapGeometry_handle);
00067     theEndcapGeometry = &(*theEndcapGeometry_handle);
00068     setup.get<IdealGeometryRecord>().get(eTTmap_);
00069   }
00070   // endcap mapping
00071   edm::ESHandle< EcalElectronicsMapping > ecalmapping;
00072   setup.get< EcalMappingRcd >().get(ecalmapping);
00073   theMapping_ = ecalmapping.product();
00074 
00075   //create main sub algos
00076   estrip_= new EcalFenixStrip(setup,theMapping_,debug_,famos_,maxNrSamples_,nbMaxXtals_);
00077   etcp_ = new EcalFenixTcp(setup,tcpFormat_,debug_,famos_,binOfMaximum_,maxNrSamples_,nbMaxStrips_) ;
00078 
00079   // initialise data structures
00080   initStructures(towerMapEB_);
00081   initStructures(towerMapEE_);
00082 
00083   hitTowers_.resize(maxNrTowers_);
00084   towtp_.resize(maxNrSamplesOut_);
00085   towtp2_.resize(maxNrSamplesOut_);
00086   
00087 }

template<class T>
void EcalTrigPrimFunctionalAlgo::initStructures ( std::vector< std::vector< std::pair< int, std::vector< T > > > > &  towMap  )  [inline, private]

Definition at line 282 of file EcalTrigPrimFunctionalAlgo.h.

References i, maxNrSamples_, maxNrTowers_, nbMaxStrips_, nbMaxXtals_, and striptp_.

Referenced by init().

00282                                                                                                             {  
00283   //initialise internal data structures
00284 
00285   std::vector <T> vec0(nbMaxXtals_ );
00286   std::vector<std::pair<int,std::vector<T> > > vec1(nbMaxStrips_);
00287   for (int i=0;i<nbMaxStrips_ ;++i) vec1[i]=std::pair<int,std::vector<T> >(0,vec0);
00288   towMap.resize(maxNrTowers_); 
00289   for (unsigned int i=0;i<maxNrTowers_;++i) towMap[i]=vec1;
00290   
00291   std::vector<int> vecint(maxNrSamples_);
00292   striptp_.resize(nbMaxStrips_);
00293   for (int i=0;i<nbMaxStrips_;++i) striptp_[i]=vecint;
00294   
00295 }

void EcalTrigPrimFunctionalAlgo::run ( const edm::EventSetup &  setup,
const EEDigiCollection *  col,
EcalTrigPrimDigiCollection &  result,
EcalTrigPrimDigiCollection &  resultTcp 
)

Definition at line 105 of file EcalTrigPrimFunctionalAlgo.cc.

References run_part1_EE(), run_part2(), and towerMapEE_.

00108 {
00109 
00110   run_part1_EE(col);
00111   run_part2(setup, col,towerMapEE_,result,resultTcp);
00112 }

void EcalTrigPrimFunctionalAlgo::run ( const edm::EventSetup &  setup,
const EBDigiCollection *  col,
EcalTrigPrimDigiCollection &  result,
EcalTrigPrimDigiCollection &  resultTcp 
)

Definition at line 96 of file EcalTrigPrimFunctionalAlgo.cc.

References run_part1_EB(), run_part2(), and towerMapEB_.

Referenced by EcalTrigPrimProducer::produce().

00099 {
00100   run_part1_EB(col);
00101   run_part2(setup,col,towerMapEB_,result,resultTcp);
00102 }

void EcalTrigPrimFunctionalAlgo::run_part1_EB ( EBDigiCollection const *  col  ) 

Definition at line 130 of file EcalTrigPrimFunctionalAlgo.cc.

References clean(), fillMap(), and towerMapEB_.

Referenced by run().

00130                                                                          {
00131   clean(towerMapEB_);
00132   // loop over dataframes and fill map 
00133   fillMap(col,towerMapEB_);
00134 }

void EcalTrigPrimFunctionalAlgo::run_part1_EE ( EEDigiCollection const *  col  ) 

Definition at line 136 of file EcalTrigPrimFunctionalAlgo.cc.

References clean(), fillMap(), and towerMapEE_.

Referenced by run().

00136                                                                          {
00137   clean(towerMapEE_);
00138   // loop over dataframes and fill map 
00139   fillMap(col,towerMapEE_);
00140 }

template<class Coll>
void EcalTrigPrimFunctionalAlgo::run_part2 ( const edm::EventSetup &  setup,
Coll const *  col,
std::vector< std::vector< std::pair< int, std::vector< typename Coll::Digi > > > > &  towerMap,
EcalTrigPrimDigiCollection &  result,
EcalTrigPrimDigiCollection &  resultTcp 
) [inline]

Definition at line 138 of file EcalTrigPrimFunctionalAlgo.h.

References binOfMaximum_, EcalTriggerPrimitiveDigi::compressedEt(), dummy, EcalEndcap, estrip_, etcp_, first, hitTowers_, i, EcalTrigTowerDetId::ietaAbs(), index, EcalTrigTowerDetId::iphi(), LogDebug, nrSamples_, nrTowers_, phi, EcalFenixTcp::process(), EcalFenixStrip::process(), edm::SortedCollection< T, SORT >::push_back(), edm::second(), EcalTriggerPrimitiveDigi::setSample(), EcalTriggerPrimitiveDigi::setSize(), striptp_, EcalTrigTowerDetId::subDet(), tcpFormat_, towtp2_, towtp_, and EcalTrigTowerDetId::zside().

Referenced by run().

00141 {
00142   typedef typename Coll::Digi Digi;
00143  
00144   // prepare writing of TP-s
00145 
00146   int firstSample = binOfMaximum_-1 -nrSamples_/2;
00147   int lastSample = binOfMaximum_-1 +nrSamples_/2;
00148   int nrTP=0;
00149   std::vector<typename Coll::Digi> dummy;
00150   EcalTriggerPrimitiveDigi tptow[2];
00151   EcalTriggerPrimitiveDigi tptowTcp[2];
00152 
00153   for(int itow=0;itow<nrTowers_;++itow) 
00154     {
00155 
00156       int index=hitTowers_[itow].first;
00157       const EcalTrigTowerDetId &thisTower=hitTowers_[itow].second;
00158 
00159       // loop over all strips assigned to this trigger tower
00160       int nstr=0;
00161       for(unsigned int i = 0; i < towerMap[itow].size();++i)
00162         {
00163           std::vector<Digi> &df = (towerMap[index])[i].second;//vector of dataframes for this strip, size; nr of crystals/strip
00164 
00165           if ((towerMap[index])[i].first > 0) {  
00166             estrip_->process(setup,df,(towerMap[index])[i].first,striptp_[nstr++]);
00167           }
00168         }//loop over strips in one tower
00169 
00170       bool isInInnerRings=false;
00171       if (thisTower.subDet()==EcalEndcap && (thisTower.ietaAbs()==27 || thisTower.ietaAbs()==28 )) isInInnerRings=true;
00172       etcp_->process(setup,dummy,striptp_,nstr,towtp_,towtp2_,isInInnerRings,thisTower);
00173 
00174       // prepare TP-s
00175       // special treatment for 2 inner endcap rings
00176       int nrTowers;
00177       if (isInInnerRings)
00178         {
00179           nrTowers=2;
00180           int phi=2*((thisTower.iphi()-1)/2);
00181           tptow[0]=EcalTriggerPrimitiveDigi(EcalTrigTowerDetId(thisTower.zside(),thisTower.subDet(),thisTower.ietaAbs(),phi+1));
00182           tptow[1]=EcalTriggerPrimitiveDigi(EcalTrigTowerDetId(thisTower.zside(),thisTower.subDet(),thisTower.ietaAbs(),phi+2));
00183           if (tcpFormat_){
00184             tptowTcp[0]=EcalTriggerPrimitiveDigi(EcalTrigTowerDetId(thisTower.zside(),thisTower.subDet(),thisTower.ietaAbs(),phi+1));
00185             tptowTcp[1]=EcalTriggerPrimitiveDigi(EcalTrigTowerDetId(thisTower.zside(),thisTower.subDet(),thisTower.ietaAbs(),phi+2));
00186           }
00187         }else {
00188           nrTowers=1;
00189           tptow[0]=EcalTriggerPrimitiveDigi(thisTower);
00190           if (tcpFormat_)   tptowTcp[0]=EcalTriggerPrimitiveDigi(thisTower);
00191         }
00192 
00193       // now fill in
00194       for (int nrt=0;nrt<nrTowers;nrt++) {
00195         (tptow[nrt]).setSize(nrSamples_);
00196         if (towtp_.size()<nrSamples_)  {  //FIXME: only once
00197           edm::LogWarning("") <<"Too few samples produced, nr is "<<towtp_.size();
00198           break;
00199         }
00200         int isam=0;
00201         for (int i=firstSample;i<=lastSample;++i) {
00202           tptow[nrt].setSample(isam++,EcalTriggerPrimitiveSample(towtp_[i]));
00203         }
00204         nrTP++;
00205         LogDebug("EcalTPG") <<" For tower "<<itow<<" created TP nr "<<nrTP<<" with Et "<<tptow[nrt].compressedEt();
00206         result.push_back(tptow[nrt]);
00207       }
00208 
00209       if (tcpFormat_) {
00210 
00211         for (int nrt=0;nrt<nrTowers;nrt++) {
00212           tptowTcp[nrt].setSize(nrSamples_);
00213           if (towtp2_.size()<nrSamples_)  {  //FIXME: only once
00214             edm::LogWarning("") <<"Too few samples produced, nr is "<<towtp2_.size();
00215             break;
00216           }
00217           int isam=0;
00218           for (int i=firstSample;i<=lastSample;++i) {
00219             if (nrTowers<=1)  tptowTcp[nrt].setSample(isam++,EcalTriggerPrimitiveSample(towtp2_[i]));
00220             else {
00221               int et=towtp2_[i].compressedEt()/2;
00222               tptowTcp[nrt].setSample(isam++,EcalTriggerPrimitiveSample(et,towtp2_[i].fineGrain(),towtp2_[i].ttFlag()));
00223             }
00224           }
00225           resultTcp.push_back(tptowTcp[nrt]);
00226         }
00227       }
00228     } 
00229   return;
00230 }

void EcalTrigPrimFunctionalAlgo::setPointers ( const EcalTPGLinearizationConst *  ecaltpLin,
const EcalTPGPedestals *  ecaltpPed,
const EcalTPGSlidingWindow *  ecaltpgSlidW,
const EcalTPGWeightIdMap *  ecaltpgWeightMap,
const EcalTPGWeightGroup *  ecaltpgWeightGroup,
const EcalTPGFineGrainStripEE *  ecaltpgFgStripEE 
) [inline]

Definition at line 66 of file EcalTrigPrimFunctionalAlgo.h.

References estrip_, and EcalFenixStrip::setPointers().

Referenced by EcalTrigPrimProducer::getRecords().

00066                                                                                                                                                                                                                                                                                        {
00067     estrip_->setPointers(ecaltpPed,ecaltpLin,ecaltpgWeightMap,ecaltpgWeightGroup,ecaltpgSlidW,ecaltpgFgStripEE);
00068 
00069   }

void EcalTrigPrimFunctionalAlgo::setPointers2 ( const EcalTPGFineGrainEBGroup *  ecaltpgFgEBGroup,
const EcalTPGLutGroup *  ecaltpgLutGroup,
const EcalTPGLutIdMap *  ecaltpgLut,
const EcalTPGFineGrainEBIdMap *  ecaltpgFineGrainEB,
const EcalTPGFineGrainTowerEE *  ecaltpgFineGrainTowerEE 
) [inline]

Definition at line 70 of file EcalTrigPrimFunctionalAlgo.h.

References etcp_, and EcalFenixTcp::setPointers().

Referenced by EcalTrigPrimProducer::getRecords().

00074                                                                               {
00075     etcp_->setPointers(ecaltpgFgEBGroup,ecaltpgLutGroup,ecaltpgLut,ecaltpgFineGrainEB,ecaltpgFineGrainTowerEE);
00076   }

Member Data Documentation

bool EcalTrigPrimFunctionalAlgo::barrelOnly_ [private]

Definition at line 112 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by init().

int EcalTrigPrimFunctionalAlgo::binOfMaximum_ [private]

Definition at line 108 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by init(), and run_part2().

bool EcalTrigPrimFunctionalAlgo::debug_ [private]

Definition at line 113 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by init().

EcalFenixStrip* EcalTrigPrimFunctionalAlgo::estrip_ [private]

Definition at line 99 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by init(), run_part2(), setPointers(), and ~EcalTrigPrimFunctionalAlgo().

EcalFenixTcp* EcalTrigPrimFunctionalAlgo::etcp_ [private]

Definition at line 100 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by init(), run_part2(), setPointers2(), and ~EcalTrigPrimFunctionalAlgo().

edm::ESHandle<EcalTrigTowerConstituentsMap> EcalTrigPrimFunctionalAlgo::eTTmap_ [private]

Definition at line 102 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by init().

bool EcalTrigPrimFunctionalAlgo::famos_ [private]

Definition at line 114 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by EcalTrigPrimFunctionalAlgo(), and init().

std::vector<std::pair<int,EcalTrigTowerDetId> > EcalTrigPrimFunctionalAlgo::hitTowers_ [private]

Definition at line 127 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by fillMap(), init(), and run_part2().

int EcalTrigPrimFunctionalAlgo::maxNrSamples_ [private]

Definition at line 109 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by EcalTrigPrimFunctionalAlgo(), init(), and initStructures().

const unsigned int EcalTrigPrimFunctionalAlgo::maxNrSamplesOut_ = 10 [static, private]

Definition at line 117 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by init().

const unsigned int EcalTrigPrimFunctionalAlgo::maxNrTowers_ = 2448 [static, private]

Definition at line 118 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by clean(), init(), and initStructures().

const unsigned int EcalTrigPrimFunctionalAlgo::maxNrTPs_ = 2448 [static, private]

Definition at line 119 of file EcalTrigPrimFunctionalAlgo.h.

const unsigned int EcalTrigPrimFunctionalAlgo::nrSamples_ = 5 [static, private]

Definition at line 116 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by run_part2().

int EcalTrigPrimFunctionalAlgo::nrTowers_ [private]

Definition at line 121 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by fillMap(), and run_part2().

std::vector<std::vector<int> > EcalTrigPrimFunctionalAlgo::striptp_ [private]

Definition at line 124 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by initStructures(), and run_part2().

bool EcalTrigPrimFunctionalAlgo::tcpFormat_ [private]

Definition at line 111 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by init(), and run_part2().

const CaloSubdetectorGeometry* EcalTrigPrimFunctionalAlgo::theEndcapGeometry [private]

Definition at line 103 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by init().

const EcalElectronicsMapping* EcalTrigPrimFunctionalAlgo::theMapping_ [private]

Definition at line 104 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by findStripNr(), and init().

float EcalTrigPrimFunctionalAlgo::threshold [private]

Definition at line 106 of file EcalTrigPrimFunctionalAlgo.h.

std::vector<std::vector<std::pair<int,std::vector<EBDataFrame> > > > EcalTrigPrimFunctionalAlgo::towerMapEB_ [private]

Definition at line 125 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by init(), run(), and run_part1_EB().

std::vector<std::vector<std::pair<int,std::vector<EEDataFrame> > > > EcalTrigPrimFunctionalAlgo::towerMapEE_ [private]

Definition at line 126 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by init(), run(), and run_part1_EE().

std::vector<EcalTriggerPrimitiveSample> EcalTrigPrimFunctionalAlgo::towtp2_ [private]

Definition at line 129 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by init(), and run_part2().

std::vector<EcalTriggerPrimitiveSample> EcalTrigPrimFunctionalAlgo::towtp_ [private]

Definition at line 128 of file EcalTrigPrimFunctionalAlgo.h.

Referenced by init(), and run_part2().

The documentation for this class was generated from the following files:
Generated on Tue Jun 9 18:20:01 2009 for CMSSW by  doxygen 1.5.4