LCE_CellList Class Reference

Collaboration diagram for LCE_CellList:

Classes
struct	thrCounter_t

Public Member Functions
void	setFlaggingThresholds (const float hitsPerLB, const unsigned upperCountThr, const double lowerEThr, const unsigned lowerCountThr, const double upperEThr)
void	setListingThresholds (const unsigned minNSeen, const unsigned minAboveSigNoise)
void	readDefectLBList (const char *LBfile)
bool	checkBadLBList (const unsigned lumiBlock) const
std::vector< LCE_CellList::thrCounter_t >	buildList (const char *inputfile, const float nSigma, const float Ethr, const float QThr, unsigned &nLBsSeen) const
void	writeList (const char *filename, const std::vector< LCE_CellList::thrCounter_t > &celllist) const
void	addFlags (std::vector< LCE_CellList::thrCounter_t > &celllist, const unsigned nLBsSeen) const
bool	applySelection (const LCE_CellList::thrCounter_t &counter) const
std::string	partitionName (const short caloId, const short slot) const
void	printThresholds () const

Private Attributes
std::set< unsigned >	m_badLBs
float	m_hitCountPerLBThreshold =0.01
unsigned	m_UpperCountThreshold =50
unsigned	m_LowerCountThreshold =20
double	m_LowerCellEnergyThreshold =1000.0
double	m_UpperCellEnergyThreshold =50000.0
unsigned	m_minNSeen =10
unsigned	m_minAboveSigNoise =1

Detailed Description

Definition at line 37 of file LCE_CellList.cxx.

Member Function Documentation

addFlags()

void LCE_CellList::addFlags	(	std::vector< LCE_CellList::thrCounter_t > &	celllist,
		const unsigned	nLBsSeen ) const

Definition at line 220 of file LCE_CellList.cxx.

                                                                                                         {
  for (thrCounter_t& counter : celllist) {
    counter.MeanCellHitCut=(counter.nAboveAbsE> m_hitCountPerLBThreshold*nLBsSeen);
    counter.EventEnergyCut= ((counter.nAboveSigNoise > m_UpperCountThreshold && (counter.Esum/counter.nAboveSigNoise) > m_LowerCellEnergyThreshold) ||
                 (counter.nAboveSigNoise > m_LowerCountThreshold && (counter.Esum/counter.nAboveSigNoise  > m_UpperCellEnergyThreshold)));
      
    }
 
}

applySelection()

bool LCE_CellList::applySelection

(

const LCE_CellList::thrCounter_t &

counter

)

const

Definition at line 232 of file LCE_CellList.cxx.

                                                                               {
  return counter.nSeen > m_minNSeen && counter.nAboveSigNoise > m_minAboveSigNoise;
}

buildList()

std::vector< LCE_CellList::thrCounter_t > LCE_CellList::buildList	(	const char *	inputfile,
		const float	nSigma,
		const float	Ethr,
		const float	QThr,
		unsigned &	nLBsSeen ) const

Definition at line 165 of file LCE_CellList.cxx.

                                                                                                                                                                     {
 
  std::vector<thrCounter_t> retvec;
  
  std::set<unsigned> nLBsSeenSet;
 
  std::unique_ptr<LArSamples::Interface> tuple = Interface::open(inputfile);
  const unsigned nchannels = tuple->nChannels();
 
  retvec.reserve(nchannels);
 
  for (unsigned ichan=0;ichan<nchannels;++ichan) {
    const LArSamples::History* hist = tuple->cellHistory(ichan);
    if (!hist) continue;
    const LArSamples::CellInfo* cellInfo = hist->cellInfo();
    const int nEvents=hist->nData();
 
    thrCounter_t cnt(cellInfo->onlid());
    cnt.FT=cellInfo->feedThrough();
    cnt.slot=cellInfo->slot();
    cnt.channel=cellInfo->channel();
    cnt.caloid=cellInfo->calo();
    cnt.layer=cellInfo->layer();
 
    for (int iEvent=0;iEvent<nEvents;++iEvent) {
      const LArSamples::Data* data = hist->data(iEvent);
      const LArSamples::EventData& Evdata = data->eventData();
      unsigned lumiBlock = Evdata.lumiBlock();
      if (checkBadLBList(lumiBlock)) continue; //skip bad LBs
 
 
      const double energy= data->energy();
      const double noise = data->noise();
      const double quality = data->quality();
 
      cnt.nSeen++;
      if (energy > nSigma * noise)  cnt.nAboveSigNoise++;
      if (energy > Ethr) cnt.nAboveAbsE++;
      if (quality > Qthr) cnt.nAboveQ++;
      if (!cnt.bc_status) cnt.bc_status=data->status();
      cnt.Esum+=energy;
      cnt.LBs.insert(lumiBlock);
      nLBsSeenSet.insert(lumiBlock);
    }//End loop over events
 
    if (cnt.nSeen>0) retvec.emplace_back(cnt);
  }//end loop over channels
  
  nLBsSeen=nLBsSeenSet.size();
  std::cout << "Evaluated a total of " << nLBsSeen << "LBs" << std::endl;
 
  return retvec;
 
}

checkBadLBList()

bool LCE_CellList::checkBadLBList ( const unsigned lumiBlock ) const

inline

Definition at line 74 of file LCE_CellList.cxx.

                                                             {
    return (m_badLBs.find(lumiBlock)!=m_badLBs.end());
}

partitionName()

std::string LCE_CellList::partitionName	(	const short	caloId,
		const short	slot ) const

Definition at line 271 of file LCE_CellList.cxx.

                                                                                 {
 
  std::string name;
  std::string slayer=std::to_string(layer);
  std::string side;
 
  switch (caloId) {
  case EMB_C:
    name="EMB";
    side="C";
    if (layer==0) slayer="P";
    break;
  case EMB_A:
    name="EMB";
    side="A";
    if (layer==0) slayer="P";
    break;
 
  case EMEC_INNER_C:
  case EMEC_OUTER_C:
    name="EMEC";
    side="C";
    if (layer==0) slayer="P";
    break;
 
  case EMEC_INNER_A:
  case EMEC_OUTER_A:
    name="EMEC";
    side="A";
    if (layer==0) slayer="P";
    break;
    
  case HEC_A:
    name="HEC";
    side="A";
    break;
 
  case HEC_C:
    name="HEC";
    side="C";
    break;
      
  case FCAL_A:
    name="FCAL";
    side="A";
    break;
 
  case FCAL_C:
    name="FCAL";
    side="C";
    break;
 
  default:
    name="UNKNOWN";
    slayer="";
  }
 
  return name+slayer+side;
}

printThresholds()

void LCE_CellList::printThresholds

(

)

const

Definition at line 122 of file LCE_CellList.cxx.

                                          {
  printf ("Listing Thresholds:\n");
  printf ("\tMin number of appearences in LCE ntuple: %u\n",m_minNSeen);
  printf ("\tMin mumber of events with E> n Sigma Noise: %u\n", m_minAboveSigNoise);
  printf ("Flagging Thresholds:\n");
  printf ("\tMin number of events > sigNoise: %.3f * nLumiBlocks\n",m_hitCountPerLBThreshold);
  printf ("\tUpper count threshold for event energy cut %u\n", m_UpperCountThreshold);
  printf ("\tLower count threshold for event energy cut %u\n", m_LowerCountThreshold);
  printf ("\tUpper mean energy threshold for event energy cut %.2f MeV\n", m_UpperCellEnergyThreshold);
  printf ("\tLower mean energy threshold for event energy cut %.2f MeV\n",m_LowerCellEnergyThreshold);
}

readDefectLBList()

void LCE_CellList::readDefectLBList

(

const char *

LBfile

)

Definition at line 136 of file LCE_CellList.cxx.

                                                      {
 
  if (!m_badLBs.empty()) 
    printf("Appending to already-existing list of bad lumi-blocks of size %zu\n",m_badLBs.size());
    
 
  std::ifstream infile(LBfile);
  std::string line;
 
  // assume single-line format with coma-separated LBs (from python)                                                                                                                
  std::getline(infile,line,'\n');
  if (line.empty()) {
    printf("No bad LBs found in file %s\n" ,(const char*)LBfile);
    return;
  }
 
  for (size_t pos=0;pos!=std::string::npos;pos=line.find(',',pos)) {
    if (pos) pos++; //Jump over comma if not the first iteration
    //std::cout << "Parsing " << line.c_str()+pos << std::endl;
    unsigned LB=std::atoi(line.c_str()+pos);
    m_badLBs.insert(LB);
  }
  
  printf("Number of bad lumi-blocks: %d\n",(int)m_badLBs.size());
 
  return;
}

setFlaggingThresholds()

void LCE_CellList::setFlaggingThresholds	(	const float	hitsPerLB,
		const unsigned	upperCountThr,
		const double	lowerEThr,
		const unsigned	lowerCountThr,
		const double	upperEThr )

Definition at line 107 of file LCE_CellList.cxx.

                                                                                                                                                                          {
    m_hitCountPerLBThreshold=hitsPerLB;
    m_UpperCountThreshold = upperCountThr;
    m_LowerCountThreshold = lowerCountThr;
    m_LowerCellEnergyThreshold = lowerEThr;
    m_UpperCellEnergyThreshold = upperEThr;
  }

setListingThresholds()

void LCE_CellList::setListingThresholds	(	const unsigned	minNSeen,
		const unsigned	minAboveSigNoise )

Definition at line 116 of file LCE_CellList.cxx.

                                                                                                 {
  m_minNSeen=minNSeen;
  m_minAboveSigNoise=minAboveSigNoise;
}

writeList()

void LCE_CellList::writeList	(	const char *	filename,
		const std::vector< LCE_CellList::thrCounter_t > &	celllist ) const

Definition at line 237 of file LCE_CellList.cxx.

                                                                                                                 {
  FILE* pFile = fopen (textfilename , "w");
  if (!pFile) {
    std::cerr << "Cannot open output file " << textfilename << "\n";
    exit(1);
  }
  //               0          1        2      3       4         5                 6             7               8         9       10  
  fprintf(pFile,"onlid // partition // FT // Slot // channel // nAboveSigNoise // nAboveAbsE // MeanE [GeV] // fracQ4k // nLBs // Algoflag\n");
 
  for (const auto& cnt : cellList) {
    if (applySelection(cnt)) {
      unsigned flag=0;
      if (cnt.EventEnergyCut) {
    flag=1;
    if (cnt.MeanCellHitCut) flag=2;
      }
      //Expected format (by WDE):
      //online id Partition FT Slot Chan nEvt>10Sig nEvt>1GeV, MeanE, fracQ4k, nLBs, 
      //             0           1     2     3     4     5     6     7      8       9      10   
      fprintf(pFile,"0x%8.8x \t %7s \t %i \t %i \t %i \t %i \t %i \t %.3f \t %.3f \t %u \t %u", 
          cnt.onlId, partitionName(cnt.caloid,cnt.layer).c_str(), 
          cnt.FT, cnt.slot, cnt.channel, cnt.nAboveSigNoise, cnt.nAboveAbsE,
          cnt.Esum/(1000.0*cnt.nSeen), (float)cnt.nAboveQ/cnt.nSeen, 
          (unsigned)cnt.LBs.size(), flag );
      
 
      fprintf(pFile,"\n");
    }
  }
  fclose(pFile);
  return;
}

Member Data Documentation

m_badLBs

std::set<unsigned> LCE_CellList::m_badLBs

private

Definition at line 91 of file LCE_CellList.cxx.

m_hitCountPerLBThreshold

float LCE_CellList::m_hitCountPerLBThreshold =0.01

private

Definition at line 94 of file LCE_CellList.cxx.

m_LowerCellEnergyThreshold

double LCE_CellList::m_LowerCellEnergyThreshold =1000.0

private

Definition at line 97 of file LCE_CellList.cxx.

m_LowerCountThreshold

unsigned LCE_CellList::m_LowerCountThreshold =20

private

Definition at line 96 of file LCE_CellList.cxx.

m_minAboveSigNoise

unsigned LCE_CellList::m_minAboveSigNoise =1

private

Definition at line 102 of file LCE_CellList.cxx.

m_minNSeen

unsigned LCE_CellList::m_minNSeen =10

private

Definition at line 101 of file LCE_CellList.cxx.

m_UpperCellEnergyThreshold

double LCE_CellList::m_UpperCellEnergyThreshold =50000.0

private

Definition at line 98 of file LCE_CellList.cxx.

m_UpperCountThreshold

unsigned LCE_CellList::m_UpperCountThreshold =50

private

Definition at line 95 of file LCE_CellList.cxx.

---

The documentation for this class was generated from the following file:

• LCE_CellList.cxx