CaloCellGroup Class Reference

#include <CaloCellGroup.h>

Collaboration diagram for CaloCellGroup:

Public Member Functions
	CaloCellGroup ()
bool	setDefinition (const CaloCell_Base_ID *caloCellId, const std::string &definition, MsgStream &logStr)
bool	inGroup (const Identifier id) const
const std::vector< float > &	getValue () const
void	printDef () const

Private Types
enum	Fields {   LAYER , REGION , ETA , PHI ,   NFIELDS }

Static Private Member Functions
static void	complain (MsgStream &, const std::string &)

Private Attributes
bool	m_pos
bool	m_neg
bool	m_emb
bool	m_emecow
bool	m_emeciw
bool	m_hec
bool	m_fcal
std::vector< std::pair< int, int > >	m_fieldBoundaries
std::vector< float >	m_values
const CaloCell_Base_ID *	m_caloCellId

Detailed Description

Definition at line 11 of file CaloCellGroup.h.

Member Enumeration Documentation

Fields

enum CaloCellGroup::Fields

private

Enumerator
LAYER
REGION
ETA
PHI
NFIELDS

Definition at line 28 of file CaloCellGroup.h.

              {
    LAYER,
    REGION,
    ETA,
    PHI,
    NFIELDS
  };

Constructor & Destructor Documentation

CaloCellGroup()

CaloCellGroup::CaloCellGroup

(

)

Definition at line 10 of file CaloCellGroup.cxx.

                             :
  m_pos(false),
  m_neg(false),
  m_emb(false),
  m_emecow(false),
  m_emeciw(false),
  m_hec(false),
  m_fcal(false),
  m_caloCellId(nullptr)
{
}

Member Function Documentation

complain()

void CaloCellGroup::complain ( MsgStream & logStr, const std::string & problem )

staticprivate

Definition at line 219 of file CaloCellGroup.cxx.

                                                                        {
  logStr << MSG::ERROR << "Malformed definition string '"<<problem << "'" << endmsg;
}

getValue()

const std::vector< float > & CaloCellGroup::getValue ( ) const

inline

Definition at line 20 of file CaloCellGroup.h.

{return m_values;}

inGroup()

bool CaloCellGroup::inGroup

(

const Identifier

id

)

const

Definition at line 166 of file CaloCellGroup.cxx.

                                                     {
  //std::cout << "Check if in Group..";
  if (!m_caloCellId) {
    //throw exception;
    //std::cout << "No Calo Cell Id" << std::endl;
    return false;
  };
 
  if (!m_caloCellId->is_lar(id))  
    return false;  //Not a lar cell
  
  //std::cout << "have calo..";
 
  if (m_caloCellId->is_em_barrel(id) && !m_emb) return false;
  if (m_caloCellId->is_em_endcap_inner(id) && !m_emeciw) return false;
  if (m_caloCellId->is_em_endcap_outer(id) && !m_emecow) return false;
  if (m_caloCellId->is_hec(id) && !m_hec) return false;
  if (m_caloCellId->is_fcal(id) && !m_fcal) return false;
 
  //std::cout << "have subcalo..";
 
  //Check side
  const int pn=m_caloCellId->pos_neg(id);
  if (pn<0 && !m_neg) return false;
  if (pn>0 && !m_pos) return false;
 
  //std::cout << "have side..";
 
  const int layer=m_caloCellId->sampling(id);
  if (layer<m_fieldBoundaries[0].first || layer>m_fieldBoundaries[0].second) return false;
 
  //std::cout << "have layer..";
 
  const int region=m_caloCellId->region(id);
  if (region<m_fieldBoundaries[1].first || region>m_fieldBoundaries[1].second) return false;
 
  //std::cout << "have region..";
 
  const int eta=m_caloCellId->eta(id);
  if (eta<m_fieldBoundaries[2].first || eta>m_fieldBoundaries[2].second) return false;
 
 
  //std::cout << "have eta..";
 
  const int phi=m_caloCellId->phi(id);
  if (phi<m_fieldBoundaries[3].first || phi>m_fieldBoundaries[3].second) return false;
 
  //std::cout << "have phi..match! ";
  return true;
}

printDef()

void CaloCellGroup::printDef

(

)

const

Definition at line 313 of file CaloCellGroup.cxx.

                                   {
 
  std::cout << "Values";
  for (std::size_t i=0;i<m_values.size();i++)
    std::cout << " " << m_values[i];
  std::cout << " will be used for the following region:" << std::endl;
  std::cout << "SubCalos: " <<m_emb<<m_emecow<<m_emeciw<<m_hec <<m_fcal <<std::endl;
  std::cout << "pos=" << m_pos << " neg=" << m_neg << std::endl;
  std::cout << "Layer [" << m_fieldBoundaries[0].first << " - " << m_fieldBoundaries[0].second << "]" << std::endl;
  std::cout << "Region [" << m_fieldBoundaries[1].first << " - " << m_fieldBoundaries[1].second << "]" << std::endl;
  std::cout << "Eta [" << m_fieldBoundaries[2].first << " - " << m_fieldBoundaries[2].second << "]" << std::endl;
  std::cout << "Phi [" << m_fieldBoundaries[3].first << " - " << m_fieldBoundaries[3].second << "]" << std::endl << std::endl;
}

setDefinition()

bool CaloCellGroup::setDefinition	(	const CaloCell_Base_ID *	caloCellId,
		const std::string &	definition,
		MsgStream &	logStr )

Definition at line 23 of file CaloCellGroup.cxx.

                                                                                                                    {
  m_caloCellId=caloCellId;
  m_fieldBoundaries.clear();
  m_values.clear();
  m_emb=false;
  m_emecow=false;
  m_emeciw=false;
  m_hec=false;
  m_fcal=false;
  m_pos=false;
  m_neg=false;
    
  std::vector<std::string> subdefs(2+NFIELDS);
  std::string valuesStr;
  
  std::size_t pos1,pos2;
  pos1=definition.find('[');
  if( pos1==std::string::npos) {
    complain(logStr,definition);
    return false;
  }
 
  std::size_t i,iField=0;
  for (i=1+pos1;i<definition.size();i++) {
    char c=definition[i];
    if (isspace(c)) continue;
    if (c==']') break;
    if (c=='/') {
      //std::cout << "Subfield " << iField << ": " << subdefs[iField] << std::endl;
      iField++;
      if (iField >= subdefs.size()) break;
    }
    else
      subdefs[iField].push_back(c);
  }
  
  if (iField!=subdefs.size()-1 || i==definition.size()) {
    logStr << MSG::ERROR << "Definition String [" << definition << "] malformed. Expect " 
       << NFIELDS << " fileds separated by '/'" << endmsg;
    return false;
  }
 
  valuesStr=definition.substr(i+1);
  //std::cout << "ValueStr " << valuesStr << std::endl;
 
  //Interpret subcalo-string (first field)
  std::string& subCaloStr=subdefs[0];
  size_t len;
  pos1=0;
  do {
    pos2=subCaloStr.find(',',pos1);
    if (pos2==std::string::npos)
      len=subCaloStr.size();
    else {
      len=pos2-pos1;
      pos1=pos2+1;
    }
    if (subCaloStr.compare(pos1,len,"EMB")==0)
      m_emb=true;
    else if(subCaloStr.compare(pos1,len,"EMECIW")==0)
      m_emeciw=true;
    else if(subCaloStr.compare(pos1,len,"EMECOW")==0)
      m_emecow=true;
    else if(subCaloStr.compare(pos1,len,"HEC")==0)
      m_hec=true;
    else if(subCaloStr.compare(pos1,len,"FCAL")==0)
      m_fcal=true;
    else {
      logStr << MSG::ERROR << "Unknown sub-calo name '"<< subCaloStr.substr(pos1,len) <<"'found. " 
         << "Allowed values are EMB, EMECIW, EMECOW, HEC and FCAL" << endmsg;
      return false;
    }
  }
  while(pos2!=std::string::npos);
 
  //Interpret side-field (second field)
  if (subdefs[1].size()!=1) {
    complain(logStr,subdefs[1]);
    return false;
  }
 
  if (subdefs[1][0]=='A') 
    m_pos=true;
  else if (subdefs[1][0]=='C') 
    m_neg=true;
  else if (subdefs[1][0]=='*')
    m_pos=m_neg=true;
  else {
    logStr << MSG::ERROR << "Allowed values for side are: A,C or * (means both), found " << subdefs[1] << endmsg;
    return false;
  }
  //Interpret remaining fields
  for (std::size_t i=0;i<NFIELDS;i++) {
    std::string& subdef=subdefs[i+2];
    int lower=std::numeric_limits<int>::min();
    int upper=std::numeric_limits<int>::max();
    if (subdef.compare("*")!=0) {
      std::size_t pos1=subdef.find('-');
      if (pos1==std::string::npos) {
    if (isdigit(subdef[0])) 
      lower=upper=atol(subdef.c_str());
    else
      logStr << MSG::ERROR << "Malformed string [" << subdef << "], expected numerical value!" << endmsg;
      }
      else {//Found '-'
    std::string lStr=subdef.substr(0,pos1);
    std::string uStr=subdef.substr(pos1+1);
    if (!lStr.empty()) {
      if (isdigit(lStr[0]))
          lower=atol(lStr.c_str());
      else
        logStr << MSG::ERROR << "Malformed string [" << subdef << "], expected numerical value!" << endmsg;
        }
    if (!uStr.empty()) {
      if (isdigit(uStr[0]))
        upper=atol(uStr.c_str());
      else
        logStr << MSG::ERROR << "Malformed string [" << subdef << "], expected numerical value!" << endmsg;
        }
      }    
    }//end not *
    m_fieldBoundaries.emplace_back(lower,upper);
  }//end loop over fields
 
 
  const char* ptr1=valuesStr.c_str();
  char* ptr2;
  float val;
  //errno=0;
  do {
    val=strtof(ptr1,&ptr2);
    if (ptr1!=ptr2)
      m_values.push_back(val);
    ptr1=const_cast<const char*>(ptr2+1);
  }
  while(*ptr2!='\0');
 
  logStr << MSG::INFO << "Sussefully parsed defintion string" << endmsg;
  return true;
}

Member Data Documentation

m_caloCellId

const CaloCell_Base_ID* CaloCellGroup::m_caloCellId

private

Definition at line 55 of file CaloCellGroup.h.

m_emb

bool CaloCellGroup::m_emb

private

Definition at line 51 of file CaloCellGroup.h.

m_emeciw

bool CaloCellGroup::m_emeciw

private

Definition at line 51 of file CaloCellGroup.h.

m_emecow

bool CaloCellGroup::m_emecow

private

Definition at line 51 of file CaloCellGroup.h.

m_fcal

bool CaloCellGroup::m_fcal

private

Definition at line 51 of file CaloCellGroup.h.

m_fieldBoundaries

std::vector<std::pair<int,int> > CaloCellGroup::m_fieldBoundaries

private

Definition at line 52 of file CaloCellGroup.h.

m_hec

bool CaloCellGroup::m_hec

private

Definition at line 51 of file CaloCellGroup.h.

m_neg

bool CaloCellGroup::m_neg

private

Definition at line 50 of file CaloCellGroup.h.

m_pos

bool CaloCellGroup::m_pos

private

Definition at line 50 of file CaloCellGroup.h.

m_values

std::vector<float> CaloCellGroup::m_values

private

Definition at line 53 of file CaloCellGroup.h.

---

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

• CaloCellGroup.h
• CaloCellGroup.cxx