CaloGeometryFromFile Class Reference

#include <CaloGeometryFromFile.h>

Inheritance diagram for CaloGeometryFromFile:

Collaboration diagram for CaloGeometryFromFile:

Public Member Functions
	CaloGeometryFromFile ()
bool	LoadGeometryFromFile (const std::string &fileName, const std::string &treeName, const std::string &hashFileName="/eos/atlas/atlascerngroupdisk/proj-simul/" "CaloGeometry/cellId_vs_cellHashId_map.txt")
bool	LoadFCalGeometryFromFiles (const std::array< std::string, 3 > &fileNames)
void	DrawFCalGraph (int isam, int color)
virtual bool	PostProcessGeometry ()
virtual void Validate	ATLAS_NOT_THREAD_SAFE (int nrnd=100)
virtual const CaloDetDescrElement *	getDDE (Identifier identify)
virtual const CaloDetDescrElement *	getDDE (int sampling, Identifier identify)
virtual const CaloDetDescrElement *	getDDE (int sampling, float eta, float phi, float *distance=0, int *steps=0)
virtual const CaloDetDescrElement *	getFCalDDE (int sampling, float x, float y, float z, float *distance=0, int *steps=0)
bool	getClosestFCalCellIndex (int sampling, float x, float y, int &ieta, int &iphi, int *steps=0)
double	deta (int sample, double eta) const
void	minmaxeta (int sample, double eta, double &mineta, double &maxeta) const
double	rzmid (int sample, double eta) const
double	rzent (int sample, double eta) const
double	rzext (int sample, double eta) const
double	rmid (int sample, double eta) const
double	rent (int sample, double eta) const
double	rext (int sample, double eta) const
double	zmid (int sample, double eta) const
double	zent (int sample, double eta) const
double	zext (int sample, double eta) const
double	rpos (int sample, double eta, int subpos=CaloSubPos::SUBPOS_MID) const
double	zpos (int sample, double eta, int subpos=CaloSubPos::SUBPOS_MID) const
double	rzpos (int sample, double eta, int subpos=CaloSubPos::SUBPOS_MID) const
bool	isCaloBarrel (int sample) const
TGraphErrors *	GetGraph (unsigned int sample) const
void	SetDoGraphs (bool dographs=true)
bool	DoGraphs () const
TGraph *	DrawGeoSampleForPhi0 (int sample, int calocol, bool print=false)
TCanvas *	DrawGeoForPhi0 ()
FCAL_ChannelMap *	GetFCAL_ChannelMap ()
void	SetFCal_ChannelMap (const FCAL_ChannelMap *fcal_ChannnelMap)
virtual void	PrintMapInfo (int i, int j)

Static Public Member Functions
static std::string	SamplingName (int sample)

Static Public Attributes
static const int	MAX_SAMPLING = CaloCell_ID_FCS::MaxSample
static const Identifier	m_debug_identify
static std::atomic< bool >	m_debug =false

Protected Member Functions
virtual void	addcell (const CaloDetDescrElement *cell)
virtual void	post_process (int layer)
virtual void	InitRZmaps ()

Protected Attributes
t_cellmap	m_cells
std::vector< t_cellmap >	m_cells_in_sampling
std::vector< t_eta_cellmap >	m_cells_in_sampling_for_phi0
std::vector< std::vector< CaloGeometryLookup * > >	m_cells_in_regions
std::vector< bool >	m_isCaloBarrel
std::vector< double >	m_min_eta_sample [2]
std::vector< double >	m_max_eta_sample [2]
std::vector< FSmap< double, double > >	m_rmid_map [2]
std::vector< FSmap< double, double > >	m_zmid_map [2]
std::vector< FSmap< double, double > >	m_rent_map [2]
std::vector< FSmap< double, double > >	m_zent_map [2]
std::vector< FSmap< double, double > >	m_rext_map [2]
std::vector< FSmap< double, double > >	m_zext_map [2]
bool	m_dographs
std::vector< TGraphErrors * >	m_graph_layers
FCAL_ChannelMap	m_FCal_ChannelMap
std::vector< double >	m_FCal_rmin
std::vector< double >	m_FCal_rmax

Private Member Functions
void	calculateFCalRminRmax ()
bool	checkFCalGeometryConsistency ()

Detailed Description

Definition at line 10 of file CaloGeometryFromFile.h.

Constructor & Destructor Documentation

CaloGeometryFromFile()

CaloGeometryFromFile::CaloGeometryFromFile

(

)

Definition at line 21 of file CaloGeometryFromFile.cxx.

: CaloGeometry() {}

Member Function Documentation

addcell()

void CaloGeometry::addcell ( const CaloDetDescrElement *  cell )

protectedvirtualinherited

Definition at line 67 of file CaloGeometry.cxx.

{
  int sampling=cell->getSampling();
  Identifier identify=cell->identify();
  
  m_cells[identify]=cell;
  m_cells_in_sampling[sampling][identify]=cell;
  
  //m_cells[identify]= new CaloDetDescrElement(*cell);
  //m_cells_in_sampling[sampling][identify]= new CaloDetDescrElement(*cell);
  
  CaloGeometryLookup* lookup=nullptr;
  for(unsigned int i=0;i<m_cells_in_regions[sampling].size();++i) {
    if(m_cells_in_regions[sampling][i]->IsCompatible(cell)) {
      lookup=m_cells_in_regions[sampling][i];
      //cout<<sampling<<":  found compatible map"<<endl;
      break;
    }
  }
  if(!lookup) {
    lookup=new CaloGeometryLookup(m_cells_in_regions[sampling].size());
    m_cells_in_regions[sampling].push_back(lookup);
  }
  lookup->add(cell);
}

ATLAS_NOT_THREAD_SAFE()

virtual void Validate CaloGeometry::ATLAS_NOT_THREAD_SAFE ( int  nrnd = 100 )

virtualinherited

Implements ICaloGeometry.

calculateFCalRminRmax()

void CaloGeometryFromFile::calculateFCalRminRmax ( )

private

Definition at line 307 of file CaloGeometryFromFile.cxx.

{
 
  m_FCal_rmin.resize(3, FLT_MAX);
  m_FCal_rmax.resize(3, 0.);
 
  double x(0.), y(0.), r(0.);
  for (int imap = 1; imap <= 3; imap++)
    for (auto it = m_FCal_ChannelMap.begin(imap);
         it != m_FCal_ChannelMap.end(imap); it++) {
      x = it->second.x();
      y = it->second.y();
      r = sqrt(x * x + y * y);
      if (r < m_FCal_rmin[imap - 1])
        m_FCal_rmin[imap - 1] = r;
      if (r > m_FCal_rmax[imap - 1])
        m_FCal_rmax[imap - 1] = r;
    }
}

checkFCalGeometryConsistency()

bool CaloGeometryFromFile::checkFCalGeometryConsistency ( )

privatevirtual

Reimplemented from CaloGeometry.

Definition at line 327 of file CaloGeometryFromFile.cxx.

{
 
  unsigned long long phi_index, eta_index;
  float x, y, dx, dy;
  long id;
 
  long mask1[]{0x34, 0x34, 0x35};
  long mask2[]{0x36, 0x36, 0x37};
 
  m_FCal_rmin.resize(3, FLT_MAX);
  m_FCal_rmax.resize(3, 0.);
 
  for (int imap = 1; imap <= 3; imap++) {
 
    int sampling = imap + 20;
 
    if ((int)m_cells_in_sampling[sampling].size()
        != 2
               * std::distance(m_FCal_ChannelMap.begin(imap),
                               m_FCal_ChannelMap.end(imap))) {
      std::cout
          << "Error: Incompatibility between FCalChannel map and GEO file: "
             "Different number of cells in m_cells_in_sampling and "
             "FCal_ChannelMap"
          << std::endl;
      std::cout << "m_cells_in_sampling: "
                << m_cells_in_sampling[sampling].size() << std::endl;
      std::cout << "FCal_ChannelMap: "
                << 2
                       * std::distance(m_FCal_ChannelMap.begin(imap),
                                       m_FCal_ChannelMap.end(imap))
                << std::endl;
      return false;
    }
 
    for (auto it = m_FCal_ChannelMap.begin(imap);
         it != m_FCal_ChannelMap.end(imap); it++) {
 
      phi_index = it->first & 0xffff;
      eta_index = it->first >> 16;
      x = it->second.x();
      y = it->second.y();
      m_FCal_ChannelMap.tileSize(imap, eta_index, phi_index, dx, dy);
 
      id = (mask1[imap - 1] << 12) + (eta_index << 5) + 2 * phi_index;
 
      if (imap == 2)
        id += (8 << 8);
 
      Identifier id1((unsigned long long)(id << 44));
      const CaloDetDescrElement *DDE1 = getDDE(id1);
 
      id = (mask2[imap - 1] << 12) + (eta_index << 5) + 2 * phi_index;
      if (imap == 2)
        id += (8 << 8);
      Identifier id2((unsigned long long)(id << 44));
      const CaloDetDescrElement *DDE2 = getDDE(id2);
 
      if (!TMath::AreEqualRel(x, DDE1->x(), 1.E-8)
          || !TMath::AreEqualRel(y, DDE1->y(), 1.E-8)
          || !TMath::AreEqualRel(x, DDE2->x(), 1.E-8)
          || !TMath::AreEqualRel(y, DDE2->y(), 1.E-8)) {
        std::cout
            << "Error: Incompatibility between FCalChannel map and GEO file \n"
            << x << " " << DDE1->x() << " " << DDE2->x() << y << " "
            << DDE1->y() << " " << DDE2->y() << std::endl;
        return false;
      }
    }
  }
 
  return true;
}

deta()

double CaloGeometry::deta ( int  sample, double  eta  ) const

virtualinherited

Implements ICaloGeometry.

Definition at line 752 of file CaloGeometry.cxx.

{
  int side=0;
  if(eta>0) side=1;
 
  double mineta=m_min_eta_sample[side][sample];
  double maxeta=m_max_eta_sample[side][sample];
 
  if(eta<mineta)
  {
    return fabs(eta-mineta);
  }
  else if(eta>maxeta)
  {
   return fabs(eta-maxeta);
    }
    else
    {
   double d1=fabs(eta-mineta);
   double d2=fabs(eta-maxeta);
   if(d1<d2) return -d1;
   else return -d2;
  }
}

DoGraphs()

bool CaloGeometry::DoGraphs ( ) const

inlineinherited

Definition at line 67 of file CaloGeometry.h.

{return m_dographs;};

DrawFCalGraph()

void CaloGeometryFromFile::DrawFCalGraph	(	int	isam,
		int	color
	)

Definition at line 276 of file CaloGeometryFromFile.cxx.

{
 
  std::stringstream ss;
  ss << "FCal" << isam - 20 << std::endl;
 
  const int size = m_cells_in_sampling[isam].size();
 
  std::vector<double> x;
  std::vector<double> y;
  x.reserve(size);
  y.reserve(size);
 
  for (auto it = m_cells_in_sampling[isam].begin();
       it != m_cells_in_sampling[isam].end(); it++) {
    x.push_back(it->second->x());
    y.push_back(it->second->y());
  }
 
  TGraph *graph = new TGraph(size, &x[0], &y[0]);
  graph->SetLineColor(color);
  graph->SetTitle(ss.str().c_str());
  graph->SetMarkerStyle(21);
  graph->SetMarkerColor(color);
  graph->SetMarkerSize(0.5);
  graph->GetXaxis()->SetTitle("x [mm]");
  graph->GetYaxis()->SetTitle("y [mm]");
 
  graph->Draw("AP");
}

DrawGeoForPhi0()

TCanvas * CaloGeometry::DrawGeoForPhi0 ( )

inherited

Definition at line 440 of file CaloGeometry.cxx.

{
  TCanvas* c=new TCanvas("CaloGeoForPhi0","Calo geometry for #phi~0");
  TH2D* hcalolayout=new TH2D("hcalolayoutPhi0","Reconstruction geometry: calorimeter layout;z [mm];r [mm]",50,-7000,7000,50,0,4000);
  hcalolayout->Draw();
  hcalolayout->SetStats(0);
  hcalolayout->GetYaxis()->SetTitleOffset(1.4);
  
  TLegend* leg=new TLegend(0.30,0.13,0.70,0.37);
  leg->SetFillStyle(0);
  leg->SetFillColor(10);
  leg->SetBorderSize(1);
  leg->SetNColumns(2);
 
  for(int sample=0;sample<MAX_SAMPLING;++sample) {
    TGraph* gr=DrawGeoSampleForPhi0(sample,CaloGeometry_calocol[sample],(sample==17));
    if(gr) {
      std::string sname=Form("Sampling %2d : ",sample);
      sname+=SamplingName(sample);
      leg->AddEntry(gr,sname.c_str(),"LF");
    }
  }
  leg->Draw();
  return c;
}

DrawGeoSampleForPhi0()

TGraph * CaloGeometry::DrawGeoSampleForPhi0 ( int  sample, int  calocol, bool  print = false  )

inherited

Definition at line 349 of file CaloGeometry.cxx.

{
  if (sample < CaloSampling::PreSamplerB || sample >= CaloSampling::Unknown) {
    return nullptr;
  }
  TGraph* firstgr=nullptr;
  cout<<"Start sample "<<sample<<" ("<<SamplingName(sample)<<")"<<endl;
  int ngr=0;
  for(t_eta_cellmap::iterator calo_iter=m_cells_in_sampling_for_phi0[sample].begin();calo_iter!=m_cells_in_sampling_for_phi0[sample].end();++calo_iter) {
    const CaloDetDescrElement* theDDE=(*calo_iter).second;
    if(theDDE) {
      TVector3 cv;
      TGraph* gr=new TGraph(5);
      gr->SetLineColor(TMath::Abs(calocol));
      gr->SetFillColor(TMath::Abs(calocol));
      if(calocol<0) {
        gr->SetFillStyle(1001);
      } else {
        gr->SetFillStyle(0);
      }
      gr->SetLineWidth(2);
      double r=theDDE->r();
      double dr=theDDE->dr();
      double x=theDDE->x();
      double dx=theDDE->dx();
      double y=theDDE->y();
      double dy=theDDE->dy();
      double z=theDDE->z();
      double dz=theDDE->dz()*2;
      double eta=theDDE->eta();
      double deta=theDDE->deta();
      
      if(CaloSampling::PreSamplerB<=sample && sample<=CaloSampling::EMB3) {
       dr*=2;
      }
      if(print) {
        cout<<"sample="<<sample<<" r="<<r<<" dr="<<dr<<" eta="<<eta<<" deta="<<deta<<" x="<<x<<" y="<<y<<" z="<<z<<" dz="<<dz<<endl;
      }
      if(isCaloBarrel(sample)) {
        cv.SetPtEtaPhi(r-dr/2,eta-deta/2,0);
        gr->SetPoint(0,cv.Z(),cv.Pt());
        gr->SetPoint(4,cv.Z(),cv.Pt());
        cv.SetPtEtaPhi(r-dr/2,eta+deta/2,0);
        gr->SetPoint(1,cv.Z(),cv.Pt());
        cv.SetPtEtaPhi(r+dr/2,eta+deta/2,0);
        gr->SetPoint(2,cv.Z(),cv.Pt());
        cv.SetPtEtaPhi(r+dr/2,eta-deta/2,0);
        gr->SetPoint(3,cv.Z(),cv.Pt());
      } else {
        if(sample<CaloSampling::FCAL0) {
          cv.SetPtEtaPhi(1,eta-deta/2,0);cv*=(z-dz/2)/cv.Z();
          gr->SetPoint(0,cv.Z(),cv.Pt());
          gr->SetPoint(4,cv.Z(),cv.Pt());
          cv.SetPtEtaPhi(1,eta+deta/2,0);cv*=(z-dz/2)/cv.Z();
          gr->SetPoint(1,cv.Z(),cv.Pt());
          cv.SetPtEtaPhi(1,eta+deta/2,0);cv*=(z+dz/2)/cv.Z();
          gr->SetPoint(2,cv.Z(),cv.Pt());
          cv.SetPtEtaPhi(1,eta-deta/2,0);cv*=(z+dz/2)/cv.Z();
          gr->SetPoint(3,cv.Z(),cv.Pt());
        } else {
          double minr=r;
          double maxr=r;
          for(double px=x-dx/2;px<=x+dx/2;px+=dx) {
            for(double py=y-dy/2;py<=y+dy/2;py+=dy) {
              double pr=TMath::Sqrt(px*px+py*py);
              minr=TMath::Min(minr,pr);
              maxr=TMath::Max(maxr,pr);
            }
          }
          cv.SetXYZ(minr,0,z-dz/2);
          gr->SetPoint(0,cv.Z(),cv.Pt());
          gr->SetPoint(4,cv.Z(),cv.Pt());
          cv.SetXYZ(maxr,0,z-dz/2);
          gr->SetPoint(1,cv.Z(),cv.Pt());
          cv.SetXYZ(maxr,0,z+dz/2);
          gr->SetPoint(2,cv.Z(),cv.Pt());
          cv.SetXYZ(minr,0,z+dz/2);
          gr->SetPoint(3,cv.Z(),cv.Pt());
        }  
      }
      //if(calocol[sample]>0) gr->Draw("Lsame");
      // else gr->Draw("LFsame");
      gr->Draw("LFsame");
      if(ngr==0) firstgr=gr;
      ++ngr;
    }
  }  
  cout<<"Done sample "<<sample<<" ("<<SamplingName(sample)<<")="<<ngr<<endl;
  return firstgr;
}

getClosestFCalCellIndex()

bool CaloGeometry::getClosestFCalCellIndex ( int  sampling, float  x, float  y, int &  ieta, int &  iphi, int *  steps = 0  )

inherited

Definition at line 592 of file CaloGeometry.cxx.

                                                                                                      {
  
  double rmin = m_FCal_rmin[sampling-21];
  double rmax = m_FCal_rmax[sampling-21];
  int isam=sampling-20;
  double a=1.;
  const double b=0.01;
  const int nmax=100;
  int i=0;
  
  const double r = sqrt(x*x +y*y);
  if(r==0.) return false;
  const double r_inverse=1./r;
  
  if((r/rmax)>(rmin*r_inverse)){
    x=x*rmax*r_inverse;
    y=y*rmax*r_inverse;
    while((!m_FCal_ChannelMap.getTileID(isam, a*x, a*y, ieta, iphi)) && i<nmax){
      a-=b;
      i++;
    }
  }
  else {
    x=x*rmin*r_inverse;
    y=y*rmin*r_inverse;
    while((!m_FCal_ChannelMap.getTileID(isam, a*x, a*y, ieta, iphi)) && i<nmax){
      a+=b;
      i++;
    }
    
  }
  if(steps)*steps=i+1;
  return i<nmax;
}

getDDE() [1/3]

const CaloDetDescrElement * CaloGeometry::getDDE ( Identifier  identify )

virtualinherited

Implements ICaloGeometry.

Definition at line 466 of file CaloGeometry.cxx.

{
  return m_cells[identify];
}

getDDE() [2/3]

const CaloDetDescrElement * CaloGeometry::getDDE ( int  sampling, float  eta, float  phi, float *  distance = 0, int *  steps = 0  )

virtualinherited

Implements ICaloGeometry.

Definition at line 475 of file CaloGeometry.cxx.

{
  if(sampling<0) return nullptr;
  if(sampling>=MAX_SAMPLING) return nullptr;
  if(m_cells_in_regions[sampling].empty()) return nullptr;
  
  float dist = 0;
  const CaloDetDescrElement* bestDDE=nullptr;
  if(!distance) distance=&dist;
  *distance=+10000000;
  int intsteps;
  int beststeps;
  if(steps) beststeps=(*steps);
   else beststeps=0;
  
  if(sampling<21) {
    for(int skip_range_check=0;skip_range_check<=1;++skip_range_check) {
      for(unsigned int j=0;j<m_cells_in_regions[sampling].size();++j) {
        if(!skip_range_check) {
          if(eta<m_cells_in_regions[sampling][j]->mineta()) continue;
          if(eta>m_cells_in_regions[sampling][j]->maxeta()) continue;
        }  
        if(steps) intsteps=(*steps);
         else intsteps=0;
        if(m_debug) {
          cout<<"CaloGeometry::getDDE : check map"<<j<<" skip_range_check="<<skip_range_check<<endl;
        }
        float newdist;
        const CaloDetDescrElement* newDDE=m_cells_in_regions[sampling][j]->getDDE(eta,phi,&newdist,&intsteps);
        if(m_debug) {
          cout<<"CaloGeometry::getDDE : map"<<j<<" dist="<<newdist<<" best dist="<<*distance<<" steps="<<intsteps<<endl;
        }
        if(newdist<*distance) {
          bestDDE=newDDE;
          *distance=newdist;
          if(steps) beststeps=intsteps;
          if(newdist<-0.1) break; //stop, we are well within the hit cell
        }
      }
      if(bestDDE) break;
    }
  } else {
        return nullptr;
    //for(int skip_range_check=0;skip_range_check<=1;++skip_range_check) {
      //for(unsigned int j=0;j<m_cells_in_regions[sampling].size();++j) {
        //if(!skip_range_check) {
          //if(eta<m_cells_in_regions[sampling][j]->minx()) continue;
          //if(eta>m_cells_in_regions[sampling][j]->maxx()) continue;
          //if(phi<m_cells_in_regions[sampling][j]->miny()) continue;
          //if(phi>m_cells_in_regions[sampling][j]->maxy()) continue;
        //}  
        //if(steps) intsteps=*steps;
         //else intsteps=0;
        //if(m_debug) {
          //cout<<"CaloGeometry::getDDE : check map"<<j<<" skip_range_check="<<skip_range_check<<endl;
        //}
        //float newdist;
        //const CaloGeoDetDescrElement* newDDE=m_cells_in_regions[sampling][j]->getDDE(eta,phi,&newdist,&intsteps);
        //if(m_debug) {
          //cout<<"CaloGeometry::getDDE : map"<<j<<" dist="<<newdist<<" best dist="<<*distance<<" steps="<<intsteps<<endl;
        //}
        //if(newdist<*distance) {
          //bestDDE=newDDE;
          //*distance=newdist;
          //if(steps) beststeps=intsteps;
          //if(newdist<-0.1) break; //stop, we are well within the hit cell
        //}
      //}
      //if(bestDDE) break;
    //}  
  }
  if(steps) *steps=beststeps;
  return bestDDE;
}

getDDE() [3/3]

const CaloDetDescrElement * CaloGeometry::getDDE ( int  sampling, Identifier  identify  )

virtualinherited

Definition at line 470 of file CaloGeometry.cxx.

{
  return m_cells_in_sampling[sampling][identify];
}

GetFCAL_ChannelMap()

FCAL_ChannelMap* CaloGeometry::GetFCAL_ChannelMap ( )

inlineinherited

Definition at line 72 of file CaloGeometry.h.

{return &m_FCal_ChannelMap;}

getFCalDDE()

const CaloDetDescrElement * CaloGeometry::getFCalDDE ( int  sampling, float  x, float  y, float  z, float *  distance = 0, int *  steps = 0  )

virtualinherited

Implements ICaloGeometry.

Definition at line 550 of file CaloGeometry.cxx.

                                                                                                                  {
  int isam = sampling - 20;
  int iphi(-100000),ieta(-100000);
  Long64_t mask1[]{0x34,0x34,0x35};
  Long64_t mask2[]{0x36,0x36,0x37};
  bool found = m_FCal_ChannelMap.getTileID(isam, x, y, ieta, iphi);
  if(steps && found) *steps=0;
  if(!found) {
    //cout << "Warning: Hit is not matched with any FCal cell! Looking for the closest cell" << endl;
    found = getClosestFCalCellIndex(sampling, x, y, ieta, iphi,steps);
  }
  if(!found) {
    cout << "Error: Unable to find the closest FCal cell!" << endl;
    return nullptr;
  }
  
  
  //cout << "CaloGeometry::getFCalDDE: x:" << x << " y: " << y << " ieta: " << ieta << " iphi: " << iphi << " cmap->x(): " << m_FCal_ChannelMap.x(isam,ieta,iphi) << " cmap->y(): " << m_FCal_ChannelMap.y(isam,ieta,iphi) << endl;
  Long64_t id = (ieta << 5) + 2*iphi;
  if(isam==2)id+= (8<<8);
  
  
  
  if(z>0) id+=(mask2[isam-1] << 12);
  else id+=(mask1[isam-1] << 12);
  
  id = id << 44; 
  Identifier identify((unsigned long long)id);
  const CaloDetDescrElement* foundcell=m_cells[identify];
 
  // Report the shortest distance in x or y to the face of the cell if outside the cell.
  // If inside the cell this will be negative and be the shortest distance to a cell face.
  float dist = 0;
  if(!distance) distance=&dist;
  float distanceX = abs(foundcell->x()-x) - foundcell->dx()/2;
  float distanceY = abs(foundcell->y()-y) - foundcell->dy()/2;
  *distance = max(distanceX,distanceY);
  
  return foundcell;
}

GetGraph()

TGraphErrors* CaloGeometry::GetGraph ( unsigned int  sample ) const

inlineinherited

Definition at line 65 of file CaloGeometry.h.

{return m_graph_layers[sample];};

InitRZmaps()

void CaloGeometry::InitRZmaps ( )

protectedvirtualinherited

Definition at line 197 of file CaloGeometry.cxx.

{
  FSmap< double , double > rz_map_eta [2][MAX_SAMPLING];
  FSmap< double , double > rz_map_rmid[2][MAX_SAMPLING];
  FSmap< double , double > rz_map_zmid[2][MAX_SAMPLING];
  FSmap< double , double > rz_map_rent[2][MAX_SAMPLING];
  FSmap< double , double > rz_map_zent[2][MAX_SAMPLING];
  FSmap< double , double > rz_map_rext[2][MAX_SAMPLING];
  FSmap< double , double > rz_map_zext[2][MAX_SAMPLING];
  FSmap< double , int    > rz_map_n   [2][MAX_SAMPLING];
 
 
  for(unsigned int side=0;side<=1;++side) for(unsigned int sample=0;sample<MAX_SAMPLING;++sample)
  {
    m_min_eta_sample[side][sample]=+1000;
    m_max_eta_sample[side][sample]=-1000;
  }  
  
  
  for(t_cellmap::iterator calo_iter=m_cells.begin();calo_iter!=m_cells.end();++calo_iter)
  {
    const CaloDetDescrElement* theDDE=(*calo_iter).second;
    if(theDDE)
    {
      unsigned int sample=theDDE->getSampling();
 
      int side=0;
      int sign_side=-1;
      double eta_raw=theDDE->eta_raw();
      if(eta_raw>0) {
        side=1;
        sign_side=+1;
      }
      
      if(!m_cells_in_sampling_for_phi0[sample][eta_raw]) {
        m_cells_in_sampling_for_phi0[sample][eta_raw]=theDDE;
      } else {
        if(TMath::Abs(theDDE->phi()) < TMath::Abs(m_cells_in_sampling_for_phi0[sample][eta_raw]->phi())) {
          m_cells_in_sampling_for_phi0[sample][eta_raw]=theDDE;
        }
      }  
      
      double min_eta=theDDE->eta()-theDDE->deta()/2;
      double max_eta=theDDE->eta()+theDDE->deta()/2;
      if(min_eta<m_min_eta_sample[side][sample]) m_min_eta_sample[side][sample]=min_eta;
      if(max_eta>m_max_eta_sample[side][sample]) m_max_eta_sample[side][sample]=max_eta;
      
      if(rz_map_eta[side][sample].find(eta_raw)==rz_map_eta[side][sample].end()) {
        rz_map_eta [side][sample][eta_raw]=0;
        rz_map_rmid[side][sample][eta_raw]=0;
        rz_map_zmid[side][sample][eta_raw]=0;
        rz_map_rent[side][sample][eta_raw]=0;
        rz_map_zent[side][sample][eta_raw]=0;
        rz_map_rext[side][sample][eta_raw]=0;
        rz_map_zext[side][sample][eta_raw]=0;
        rz_map_n   [side][sample][eta_raw]=0;
      }
      rz_map_eta [side][sample][eta_raw]+=theDDE->eta();
      rz_map_rmid[side][sample][eta_raw]+=theDDE->r();
      rz_map_zmid[side][sample][eta_raw]+=theDDE->z();
      double drh=theDDE->dr()/2;
      double dzh=theDDE->dz();
      if(sample<=CaloSampling::EMB3) { // ensure we have a valid sampling
        drh=theDDE->dr();
      } 
      // An `else` would be good here since we can't continue with a *bad* sampling...
      // Should most likely handle the situation nicely rather than with a crash.
 
      rz_map_rent[side][sample][eta_raw]+=theDDE->r()-drh;
      rz_map_zent[side][sample][eta_raw]+=theDDE->z()-dzh*sign_side;
      rz_map_rext[side][sample][eta_raw]+=theDDE->r()+drh;
      rz_map_zext[side][sample][eta_raw]+=theDDE->z()+dzh*sign_side;
      rz_map_n   [side][sample][eta_raw]++;
      
    }
  }
  
  for(int side=0;side<=1;++side)
  {
   for(int sample=0;sample<MAX_SAMPLING;++sample)
   {
 
    if(!rz_map_n[side][sample].empty())
    {
      for(FSmap< double , int >::iterator iter=rz_map_n[side][sample].begin();iter!=rz_map_n[side][sample].end();++iter)
      {
        double eta_raw=iter->first;
        if(iter->second<1)
        {
          //ATH_MSG_WARNING("rz-map for side="<<side<<" sample="<<sample<<" eta_raw="<<eta_raw<<" : #cells="<<iter->second<<" !!!");
        }
        else
        {
          double eta =rz_map_eta[side][sample][eta_raw]/iter->second;
          double rmid=rz_map_rmid[side][sample][eta_raw]/iter->second;
          double zmid=rz_map_zmid[side][sample][eta_raw]/iter->second;
          double rent=rz_map_rent[side][sample][eta_raw]/iter->second;
          double zent=rz_map_zent[side][sample][eta_raw]/iter->second;
          double rext=rz_map_rext[side][sample][eta_raw]/iter->second;
          double zext=rz_map_zext[side][sample][eta_raw]/iter->second;
          
          m_rmid_map[side][sample][eta]=rmid;
          m_zmid_map[side][sample][eta]=zmid;
          m_rent_map[side][sample][eta]=rent;
          m_zent_map[side][sample][eta]=zent;
          m_rext_map[side][sample][eta]=rext;
          m_zext_map[side][sample][eta]=zext;
        }
      }
      //ATH_MSG_DEBUG("rz-map for side="<<side<<" sample="<<sample<<" #etas="<<m_rmid_map[side][sample].size());
     }
    else
    {
     std::cout<<"rz-map for side="<<side<<" sample="<<sample<<" is empty!!!"<<std::endl;
    }
   } //sample
  } //side
  
  if(DoGraphs()) {
    for(int sample=0;sample<MAX_SAMPLING;++sample) {
      m_graph_layers[sample]=new TGraphErrors(rz_map_n[0][sample].size()+rz_map_n[1][sample].size());
      m_graph_layers[sample]->SetMarkerColor(TMath::Abs(CaloGeometry_calocol[sample]));
      m_graph_layers[sample]->SetLineColor(TMath::Abs(CaloGeometry_calocol[sample]));
      int np=0;
      for(int side=0;side<=1;++side) {
        for(FSmap< double , int >::iterator iter=rz_map_n[side][sample].begin();iter!=rz_map_n[side][sample].end();++iter) {
          double eta_raw=iter->first;
          int sign_side=-1;
          if(eta_raw>0) sign_side=+1;
          //double eta =rz_map_eta[side][sample][eta_raw]/iter->second;
          double rmid=rz_map_rmid[side][sample][eta_raw]/iter->second;
          double zmid=rz_map_zmid[side][sample][eta_raw]/iter->second;
          //double rent=rz_map_rent[side][sample][eta_raw]/iter->second;
          //double zent=rz_map_zent[side][sample][eta_raw]/iter->second;
          double rext=rz_map_rext[side][sample][eta_raw]/iter->second;
          double zext=rz_map_zext[side][sample][eta_raw]/iter->second;
          m_graph_layers[sample]->SetPoint(np,zmid,rmid);
          /*
          if(isCaloBarrel(sample)) {
            m_graph_layers[sample]->SetPointError(np,0,rext-rmid);
          } else {
            m_graph_layers[sample]->SetPointError(np,(zext-zent)*sign_side,0);
          }
          */
          m_graph_layers[sample]->SetPointError(np,(zext-zmid)*sign_side,rext-rmid);
          ++np;
        }
      }  
    }
  }
}

isCaloBarrel()

bool CaloGeometry::isCaloBarrel ( int  sample ) const

inlinevirtualinherited

Implements ICaloGeometry.

Definition at line 62 of file CaloGeometry.h.

{return m_isCaloBarrel[sample];};

LoadFCalGeometryFromFiles()

bool CaloGeometryFromFile::LoadFCalGeometryFromFiles

(

const std::array< std::string, 3 > &

fileNames

)

Definition at line 184 of file CaloGeometryFromFile.cxx.

{
  std::vector<std::unique_ptr<std::istream>> electrodes;
  std::vector<std::unique_ptr<std::streambuf>> electrodesBuf;
  electrodes.reserve(3);
  electrodesBuf.reserve(3);
 
  for (uint16_t i = 0; i < 3; i++) {
    const std::string &file = fileNames[i];
#ifdef ENABLE_XROOTD_SUPPORT
    if (file.find("root://") != std::string::npos) {
      electrodesBuf.emplace_back(std::make_unique<XrdStreamBuf>(file));
      electrodes.emplace_back(std::make_unique<std::istream>(electrodesBuf.back().get()));
    } else {
#endif
      std::unique_ptr<std::ifstream> directStream = std::make_unique<std::ifstream>(file);
      if (!directStream->is_open()) {
        std::cout << "Error: Could not open " << file << std::endl;
        throw std::runtime_error("Could not open file");
      }
      electrodes.push_back(std::move(directStream));
#ifdef ENABLE_XROOTD_SUPPORT
    }
#endif
  }
 
  int thisTubeId;
  int thisTubeI;
  int thisTubeJ;
  // int    thisTubeID;
  // int    thisTubeMod;
  double thisTubeX;
  double thisTubeY;
  TString tubeName;
 
  // int second_column;
  std::string seventh_column;
  std::string eight_column;
  int ninth_column;
 
  int i;
  for (int imodule = 1; imodule <= 3; imodule++) {
    std::cout << "Loading FCal electrode #" << imodule << std::endl;
 
    i = 0;
    while (1) {
 
      (*electrodes[imodule - 1]) >> tubeName;
      if (electrodes[imodule - 1]->eof())
        break;
      (*electrodes[imodule - 1]) >> thisTubeId; // ?????
      (*electrodes[imodule - 1]) >> thisTubeI;
      (*electrodes[imodule - 1]) >> thisTubeJ;
      (*electrodes[imodule - 1]) >> thisTubeX;
      (*electrodes[imodule - 1]) >> thisTubeY;
      (*electrodes[imodule - 1]) >> seventh_column;
      (*electrodes[imodule - 1]) >> eight_column;
      (*electrodes[imodule - 1]) >> ninth_column;
 
      tubeName.ReplaceAll("'", "");
      std::string tubeNamestring = tubeName.Data();
 
      std::istringstream tileStream1(std::string(tubeNamestring, 1, 1));
      std::istringstream tileStream2(std::string(tubeNamestring, 3, 2));
      std::istringstream tileStream3(std::string(tubeNamestring, 6, 3));
      int a1 = 0, a2 = 0, a3 = 0;
      if (tileStream1)
        tileStream1 >> a1;
      if (tileStream2)
        tileStream2 >> a2;
      if (tileStream3)
        tileStream3 >> a3;
 
      std::stringstream s;
 
      m_FCal_ChannelMap.add_tube(tubeNamestring, imodule, thisTubeId, thisTubeI,
                                 thisTubeJ, thisTubeX, thisTubeY,
                                 seventh_column);
 
      i++;
    }
  }
 
  m_FCal_ChannelMap.finish(); // Creates maps
 
  electrodes.clear();
  electrodesBuf.clear();
 
  this->calculateFCalRminRmax();
  return this->checkFCalGeometryConsistency();
}

LoadGeometryFromFile()

bool CaloGeometryFromFile::LoadGeometryFromFile	(	const std::string &	fileName,
		const std::string &	treeName,
		const std::string &	hashFileName = "/eos/atlas/atlascerngroupdisk/proj-simul/" "CaloGeometry/cellId_vs_cellHashId_map.txt"
	)

Definition at line 23 of file CaloGeometryFromFile.cxx.

{
  std::map<uint64_t, uint64_t> cellId_vs_cellHashId_map;
 
  std::unique_ptr<std::istream> hashStream{};
  std::unique_ptr<std::streambuf> hashStreamBuf{};
#ifdef ENABLE_XROOTD_SUPPORT
  if (hashFileName.find("root://") != std::string::npos) {
    hashStreamBuf = std::make_unique<XrdStreamBuf>(hashFileName);
    hashStream = std::make_unique<std::istream>(hashStreamBuf.get());
  } else {
#endif
    std::unique_ptr<std::ifstream> hashStreamDirect = std::make_unique<std::ifstream>(hashFileName);
    if (!hashStreamDirect->is_open()) {
      std::cout << "Error: Could not open " << hashFileName << std::endl;
      throw std::runtime_error("Could not open file");
    }
    hashStream = std::move(hashStreamDirect);
#ifdef ENABLE_XROOTD_SUPPORT
  }
#endif
 
  std::cout << "Loading cellId_vs_cellHashId_map" << std::endl;
 
  int i = 0;
  uint64_t id, hash_id;
  while (!hashStream->eof()) {
    i++;
 
    *hashStream >> id >> hash_id;
    cellId_vs_cellHashId_map[id] = hash_id;
    if (i % 10000 == 0)
      std::cout << "Line: " << i << " id " << std::hex << id << " hash_id "
                << std::dec << hash_id << std::endl;
  }
 
  std::cout << "Done." << std::endl;
 
  auto f = std::unique_ptr<TFile>(TFile::Open(fileName.c_str()));
  if (!f) {
    std::cerr << "Error: Could not open file '" << fileName << "'" << std::endl;
    return false;
  }
    TTree *tree = (TTree*)f->Get(treeName.c_str());
  if (!tree)
    return false;
 
  TTree *fChain = tree;
 
  CaloDetDescrElement cell;
 
  // List of branches
  TBranch *b_identifier; 
  TBranch *b_calosample; 
  TBranch *b_eta;        
  TBranch *b_phi;        
  TBranch *b_r;          
  TBranch *b_eta_raw;    
  TBranch *b_phi_raw;    
  TBranch *b_r_raw;      
  TBranch *b_x;          
  TBranch *b_y;          
  TBranch *b_z;          
  TBranch *b_x_raw;      
  TBranch *b_y_raw;      
  TBranch *b_z_raw;      
  TBranch *b_deta;       
  TBranch *b_dphi;       
  TBranch *b_dr;         
  TBranch *b_dx;         
  TBranch *b_dy;         
  TBranch *b_dz;         
 
  fChain->SetMakeClass(1);
  fChain->SetBranchAddress("identifier", &cell.m_identify, &b_identifier);
  fChain->SetBranchAddress("calosample", &cell.m_calosample, &b_calosample);
  fChain->SetBranchAddress("eta", &cell.m_eta, &b_eta);
  fChain->SetBranchAddress("phi", &cell.m_phi, &b_phi);
  fChain->SetBranchAddress("r", &cell.m_r, &b_r);
  fChain->SetBranchAddress("eta_raw", &cell.m_eta_raw, &b_eta_raw);
  fChain->SetBranchAddress("phi_raw", &cell.m_phi_raw, &b_phi_raw);
  fChain->SetBranchAddress("r_raw", &cell.m_r_raw, &b_r_raw);
  fChain->SetBranchAddress("x", &cell.m_x, &b_x);
  fChain->SetBranchAddress("y", &cell.m_y, &b_y);
  fChain->SetBranchAddress("z", &cell.m_z, &b_z);
  fChain->SetBranchAddress("x_raw", &cell.m_x_raw, &b_x_raw);
  fChain->SetBranchAddress("y_raw", &cell.m_y_raw, &b_y_raw);
  fChain->SetBranchAddress("z_raw", &cell.m_z_raw, &b_z_raw);
  fChain->SetBranchAddress("deta", &cell.m_deta, &b_deta);
  fChain->SetBranchAddress("dphi", &cell.m_dphi, &b_dphi);
  fChain->SetBranchAddress("dr", &cell.m_dr, &b_dr);
  fChain->SetBranchAddress("dx", &cell.m_dx, &b_dx);
  fChain->SetBranchAddress("dy", &cell.m_dy, &b_dy);
  fChain->SetBranchAddress("dz", &cell.m_dz, &b_dz);
 
  Long64_t nentries = fChain->GetEntriesFast();
  for (Long64_t jentry = 0; jentry < nentries; jentry++) {
    Long64_t ientry = fChain->LoadTree(jentry);
    if (ientry < 0)
      break;
    fChain->GetEntry(jentry);
 
    if (cellId_vs_cellHashId_map.find(cell.m_identify)
        != cellId_vs_cellHashId_map.end()) {
      cell.m_hash_id = cellId_vs_cellHashId_map[cell.m_identify];
      if (cell.m_hash_id != jentry)
        std::cout << jentry << " : ERROR hash=" << cell.m_hash_id << std::endl;
    } else
      std::cout << std::endl
                << "ERROR: Cell id not found in the cellId_vs_cellHashId_map!!!"
                << std::endl
                << std::endl;
 
    const CaloDetDescrElement *pcell = new CaloDetDescrElement(cell);
    this->addcell(pcell);
 
    if (jentry % 25000 == 0) {
      std::cout << "Checking loading cells from file" << std::endl
                << jentry << " : " << pcell->getSampling() << ", "
                << pcell->identify() << std::endl;
 
    }
  }
 
  f->Close();
  bool ok = PostProcessGeometry();
 
  std::cout << "Result of PostProcessGeometry(): " << ok << std::endl;
 
  const CaloDetDescrElement *mcell = 0;
  unsigned long long cellid64(3179554531063103488);
  Identifier cellid(cellid64);
  mcell = this->getDDE(cellid); // This is working also for the FCal
 
  std::cout << "\n \n";
  std::cout << "Testing whether CaloGeoGeometry is loaded properly"
            << std::endl;
  if (!mcell) {
    std::cout << "Cell is not found" << std::endl;
  }
  else {
    std::cout << "Identifier " << mcell->identify() << " sampling "
              << mcell->getSampling() << " eta: " << mcell->eta()
              << " phi: " << mcell->phi() << " CaloDetDescrElement=" << mcell
              << std::endl
              << std::endl;
 
    const CaloDetDescrElement *mcell2
      = this->getDDE(mcell->getSampling(), mcell->eta(), mcell->phi());
    std::cout << "Identifier " << mcell2->identify() << " sampling "
              << mcell2->getSampling() << " eta: " << mcell2->eta()
              << " phi: " << mcell2->phi() << " CaloDetDescrElement=" << mcell2
              << std::endl
              << std::endl;
  }
 
  return ok;
}

minmaxeta()

void CaloGeometry::minmaxeta ( int  sample, double  eta, double &  mineta, double &  maxeta  ) const

virtualinherited

Implements ICaloGeometry.

Definition at line 778 of file CaloGeometry.cxx.

{
  int side=0;
  if(eta>0) side=1;
  
  mineta=m_min_eta_sample[side][sample];
  maxeta=m_max_eta_sample[side][sample];
}

post_process()

void CaloGeometry::post_process ( int  layer )

protectedvirtualinherited

Definition at line 121 of file CaloGeometry.cxx.

{
  //cout<<"post processing sampling "<<sampling<<endl;
  bool found_overlap=false;
  for(unsigned int j=0;j<m_cells_in_regions[sampling].size();++j) {
    /*
    cout<<"Sample "<<sampling<<": checking map "<<j<<"/"<<m_cells_in_regions[sampling].size();
    for(unsigned int k=0;k<m_cells_in_regions[sampling].size();++k) {
      cout<<", "<<k<<":"<<m_cells_in_regions[sampling][k]->size();
    }
    cout<<endl;
    */
    for(unsigned int i=j+1;i<m_cells_in_regions[sampling].size();++i) {
      if(m_cells_in_regions[sampling][i]->has_overlap(m_cells_in_regions[sampling][j])) {
        if(!found_overlap) {
          cout<<"Sample "<<sampling<<", starting maps : "<<m_cells_in_regions[sampling].size();
          for(unsigned int k=0;k<m_cells_in_regions[sampling].size();++k) {
            cout<<", "<<k<<":"<<m_cells_in_regions[sampling][k]->size();
          }
          cout<<endl;
        }
        found_overlap=true;
        /*
        cout<<"Sample "<<sampling<<": Found overlap between map "<<j<<" and "<<i<<", "
            <<m_cells_in_regions[sampling].size()<<" total maps"<<endl;
        cout<<"  current configuration map "<<j<<"/"<<m_cells_in_regions[sampling].size();
        for(unsigned int k=0;k<m_cells_in_regions[sampling].size();++k) {
          cout<<", "<<k<<":"<<m_cells_in_regions[sampling][k]->size();
        }
        cout<<endl;
 
        PrintMapInfo(sampling,j);
        PrintMapInfo(sampling,i);
        */
        
        CaloGeometryLookup* toremove=m_cells_in_regions[sampling][i];
        toremove->merge_into_ref(m_cells_in_regions[sampling][j]);
        
        /*
        cout<<"  New ";
        PrintMapInfo(sampling,j);
        */
        
        for(unsigned int k=i;k<m_cells_in_regions[sampling].size()-1;++k) {
          m_cells_in_regions[sampling][k]=m_cells_in_regions[sampling][k+1];
          m_cells_in_regions[sampling][k]->set_index(k);
        }
        m_cells_in_regions[sampling].resize(m_cells_in_regions[sampling].size()-1);
 
        /*
        cout<<"  new configuration map "<<j<<"/"<<m_cells_in_regions[sampling].size();
        for(unsigned int k=0;k<m_cells_in_regions[sampling].size();++k) {
          cout<<", "<<k<<":"<<m_cells_in_regions[sampling][k]->size();
        }
        cout<<endl;
        */
        
        --i;
      }
    }
  }
  
  if(found_overlap) {
    cout<<"Sample "<<sampling<<", final maps : "<<m_cells_in_regions[sampling].size();
    for(unsigned int k=0;k<m_cells_in_regions[sampling].size();++k) {
      cout<<", "<<k<<":"<<m_cells_in_regions[sampling][k]->size();
    }
    cout<<endl;
  }
 
  if(found_overlap) {
    cout<<"Run another round of ";
    post_process(sampling);
  }  
}

PostProcessGeometry()

bool CaloGeometry::PostProcessGeometry ( )

virtualinherited

Implements ICaloGeometry.

Definition at line 627 of file CaloGeometry.cxx.

{
  for(int i=0;i<MAX_SAMPLING;++i) {
    post_process(i);
    for(unsigned int j=0;j<m_cells_in_regions[i].size();++j) {
      m_cells_in_regions[i][j]->post_process();
    }
    //if(i>=21) break;
  }
  
  InitRZmaps(); 
  
  /*
  cout<<"all : "<<m_cells.size()<<endl;
  for(int sampling=0;sampling<MAX_SAMPLING;++sampling) {
    cout<<"cells sampling "<<sampling<<" : "<<m_cells_in_sampling[sampling].size()<<" cells";
    cout<<", "<<m_cells_in_regions[sampling].size()<<" lookup map(s)"<<endl;
    for(unsigned int j=0;j<m_cells_in_regions[sampling].size();++j) {
      PrintMapInfo(sampling,j);
      //break;
    }
    //if(i>0) break;
  } 
  */ 
 
  return true;
}

PrintMapInfo()

void CaloGeometry::PrintMapInfo ( int  i, int  j  )

virtualinherited

Definition at line 93 of file CaloGeometry.cxx.

{
  cout<<"  map "<<j<<": "<<m_cells_in_regions[i][j]->size()<<" cells";
  if(i<21) {
    cout<<", "<<m_cells_in_regions[i][j]->cell_grid_eta()<<"*"<<m_cells_in_regions[i][j]->cell_grid_phi();
    cout<<", deta="<<m_cells_in_regions[i][j]->deta().mean()<<"+-"<<m_cells_in_regions[i][j]->deta().rms();
    cout<<", dphi="<<m_cells_in_regions[i][j]->dphi().mean()<<"+-"<<m_cells_in_regions[i][j]->dphi().rms();
    cout<<", mineta="<<m_cells_in_regions[i][j]->mineta()<<", maxeta="<<m_cells_in_regions[i][j]->maxeta();
    cout<<", minphi="<<m_cells_in_regions[i][j]->minphi()<<", maxphi="<<m_cells_in_regions[i][j]->maxphi();
    cout<<endl<<"         ";  
    cout<<", mineta_raw="<<m_cells_in_regions[i][j]->mineta_raw()<<", maxeta_raw="<<m_cells_in_regions[i][j]->maxeta_raw();
    cout<<", minphi_raw="<<m_cells_in_regions[i][j]->minphi_raw()<<", maxphi_raw="<<m_cells_in_regions[i][j]->maxphi_raw();
    cout<<endl;
  } else {
    cout<<", "<<m_cells_in_regions[i][j]->cell_grid_eta()<<"*"<<m_cells_in_regions[i][j]->cell_grid_phi();
    cout<<", dx="<<m_cells_in_regions[i][j]->dx().mean()<<"+-"<<m_cells_in_regions[i][j]->dx().rms();
    cout<<", dy="<<m_cells_in_regions[i][j]->dy().mean()<<"+-"<<m_cells_in_regions[i][j]->dy().rms();
    cout<<", mindx="<<m_cells_in_regions[i][j]->mindx();
    cout<<", mindy="<<m_cells_in_regions[i][j]->mindy();
    cout<<", minx="<<m_cells_in_regions[i][j]->minx()<<", maxx="<<m_cells_in_regions[i][j]->maxx();
    cout<<", miny="<<m_cells_in_regions[i][j]->miny()<<", maxy="<<m_cells_in_regions[i][j]->maxy();
    cout<<endl<<"         ";  
    cout<<", minx_raw="<<m_cells_in_regions[i][j]->minx_raw()<<", maxx_raw="<<m_cells_in_regions[i][j]->maxx_raw();
    cout<<", miny_raw="<<m_cells_in_regions[i][j]->miny_raw()<<", maxy_raw="<<m_cells_in_regions[i][j]->maxy_raw();
    cout<<endl;
  }
}

rent()

double CaloGeometry::rent ( int  sample, double  eta  ) const

virtualinherited

Implements ICaloGeometry.

Definition at line 812 of file CaloGeometry.cxx.

{
  int side=0;
  if(eta>0) side=1;
 
  return m_rent_map[side][sample].find_closest(eta)->second;
}

rext()

double CaloGeometry::rext ( int  sample, double  eta  ) const

virtualinherited

Implements ICaloGeometry.

Definition at line 837 of file CaloGeometry.cxx.

{
  int side=0;
  if(eta>0) side=1;
 
  return m_rext_map[side][sample].find_closest(eta)->second;
}

rmid()

double CaloGeometry::rmid ( int  sample, double  eta  ) const

virtualinherited

Implements ICaloGeometry.

Definition at line 787 of file CaloGeometry.cxx.

{
  int side=0;
  if(eta>0) side=1;
 
  return m_rmid_map[side][sample].find_closest(eta)->second;
}

rpos()

double CaloGeometry::rpos ( int  sample, double  eta, int  subpos = CaloSubPos::SUBPOS_MID  ) const

virtualinherited

Implements ICaloGeometry.

Definition at line 862 of file CaloGeometry.cxx.

{
    
  int side=0;
  if(eta>0) side=1;
   
  if(subpos==CaloSubPos::SUBPOS_ENT) return m_rent_map[side][sample].find_closest(eta)->second;
  if(subpos==CaloSubPos::SUBPOS_EXT) return m_rext_map[side][sample].find_closest(eta)->second;
    
  return m_rmid_map[side][sample].find_closest(eta)->second;
}

rzent()

double CaloGeometry::rzent ( int  sample, double  eta  ) const

virtualinherited

Implements ICaloGeometry.

Definition at line 828 of file CaloGeometry.cxx.

{
  int side=0;
  if(eta>0) side=1;
 
  if(isCaloBarrel(sample)) return m_rent_map[side][sample].find_closest(eta)->second;
   else                    return m_zent_map[side][sample].find_closest(eta)->second;
}

rzext()

double CaloGeometry::rzext ( int  sample, double  eta  ) const

virtualinherited

Implements ICaloGeometry.

Definition at line 853 of file CaloGeometry.cxx.

{
  int side=0;
  if(eta>0) side=1;
 
  if(isCaloBarrel(sample)) return m_rext_map[side][sample].find_closest(eta)->second;
   else                    return m_zext_map[side][sample].find_closest(eta)->second;
}

rzmid()

double CaloGeometry::rzmid ( int  sample, double  eta  ) const

virtualinherited

Implements ICaloGeometry.

Definition at line 803 of file CaloGeometry.cxx.

{
 int side=0;
 if(eta>0) side=1;
    
 if(isCaloBarrel(sample)) return m_rmid_map[side][sample].find_closest(eta)->second;
 else                     return m_zmid_map[side][sample].find_closest(eta)->second;
}

rzpos()

double CaloGeometry::rzpos ( int  sample, double  eta, int  subpos = CaloSubPos::SUBPOS_MID  ) const

virtualinherited

Implements ICaloGeometry.

Definition at line 884 of file CaloGeometry.cxx.

{
  int side=0;
  if(eta>0) side=1;
 
  if(isCaloBarrel(sample)) {
    if(subpos==CaloSubPos::SUBPOS_ENT) return m_rent_map[side][sample].find_closest(eta)->second;
    if(subpos==CaloSubPos::SUBPOS_EXT) return m_rext_map[side][sample].find_closest(eta)->second;
    return m_rmid_map[side][sample].find_closest(eta)->second;
  } else {
    if(subpos==CaloSubPos::SUBPOS_ENT) return m_zent_map[side][sample].find_closest(eta)->second;
    if(subpos==CaloSubPos::SUBPOS_EXT) return m_zext_map[side][sample].find_closest(eta)->second;
    return m_zmid_map[side][sample].find_closest(eta)->second;
  }  
}

SamplingName()

std::string CaloGeometry::SamplingName ( int  sample )

staticinherited

Definition at line 900 of file CaloGeometry.cxx.

{
  return CaloSampling::getSamplingName(sample);
}

SetDoGraphs()

void CaloGeometry::SetDoGraphs ( bool  dographs = true )

inlineinherited

Definition at line 66 of file CaloGeometry.h.

{m_dographs=dographs;};

SetFCal_ChannelMap()

void CaloGeometry::SetFCal_ChannelMap ( const FCAL_ChannelMap *  fcal_ChannnelMap )

inlineinherited

Definition at line 73 of file CaloGeometry.h.

{m_FCal_ChannelMap=*fcal_ChannnelMap;}

zent()

double CaloGeometry::zent ( int  sample, double  eta  ) const

virtualinherited

Implements ICaloGeometry.

Definition at line 820 of file CaloGeometry.cxx.

{
  int side=0;
  if(eta>0) side=1;
 
  return m_zent_map[side][sample].find_closest(eta)->second;
}

zext()

double CaloGeometry::zext ( int  sample, double  eta  ) const

virtualinherited

Implements ICaloGeometry.

Definition at line 845 of file CaloGeometry.cxx.

{
  int side=0;
  if(eta>0) side=1;
 
  return m_zext_map[side][sample].find_closest(eta)->second;
}

zmid()

double CaloGeometry::zmid ( int  sample, double  eta  ) const

virtualinherited

Implements ICaloGeometry.

Definition at line 795 of file CaloGeometry.cxx.

{
  int side=0;
  if(eta>0) side=1;
 
  return m_zmid_map[side][sample].find_closest(eta)->second;
}

zpos()

double CaloGeometry::zpos ( int  sample, double  eta, int  subpos = CaloSubPos::SUBPOS_MID  ) const

virtualinherited

Implements ICaloGeometry.

Definition at line 874 of file CaloGeometry.cxx.

{
  int side=0;
  if(eta>0) side=1;
 
  if(subpos==CaloSubPos::SUBPOS_ENT) return m_zent_map[side][sample].find_closest(eta)->second;
  if(subpos==CaloSubPos::SUBPOS_EXT) return m_zext_map[side][sample].find_closest(eta)->second;
  return m_zmid_map[side][sample].find_closest(eta)->second;
}

Member Data Documentation

m_cells

t_cellmap CaloGeometry::m_cells

protectedinherited

Definition at line 100 of file CaloGeometry.h.

m_cells_in_regions

std::vector< std::vector< CaloGeometryLookup* > > CaloGeometry::m_cells_in_regions

protectedinherited

Definition at line 103 of file CaloGeometry.h.

m_cells_in_sampling

std::vector< t_cellmap > CaloGeometry::m_cells_in_sampling

protectedinherited

Definition at line 101 of file CaloGeometry.h.

m_cells_in_sampling_for_phi0

std::vector< t_eta_cellmap > CaloGeometry::m_cells_in_sampling_for_phi0

protectedinherited

Definition at line 102 of file CaloGeometry.h.

m_debug

std::atomic< bool > CaloGeometry::m_debug =false

staticinherited

Definition at line 32 of file CaloGeometry.h.

m_debug_identify

const Identifier CaloGeometry::m_debug_identify

staticinherited

Definition at line 31 of file CaloGeometry.h.

m_dographs

bool CaloGeometry::m_dographs

protectedinherited

Definition at line 115 of file CaloGeometry.h.

m_FCal_ChannelMap

FCAL_ChannelMap CaloGeometry::m_FCal_ChannelMap

protectedinherited

Definition at line 117 of file CaloGeometry.h.

m_FCal_rmax

std::vector<double> CaloGeometry::m_FCal_rmax

protectedinherited

Definition at line 118 of file CaloGeometry.h.

m_FCal_rmin

std::vector<double> CaloGeometry::m_FCal_rmin

protectedinherited

Definition at line 118 of file CaloGeometry.h.

m_graph_layers

std::vector< TGraphErrors* > CaloGeometry::m_graph_layers

protectedinherited

Definition at line 116 of file CaloGeometry.h.

m_isCaloBarrel

std::vector< bool > CaloGeometry::m_isCaloBarrel

protectedinherited

Definition at line 105 of file CaloGeometry.h.

m_max_eta_sample

std::vector< double > CaloGeometry::m_max_eta_sample[2]

protectedinherited

Definition at line 107 of file CaloGeometry.h.

m_min_eta_sample

std::vector< double > CaloGeometry::m_min_eta_sample[2]

protectedinherited

Definition at line 106 of file CaloGeometry.h.

m_rent_map

std::vector< FSmap< double , double > > CaloGeometry::m_rent_map[2]

protectedinherited

Definition at line 110 of file CaloGeometry.h.

m_rext_map

std::vector< FSmap< double , double > > CaloGeometry::m_rext_map[2]

protectedinherited

Definition at line 112 of file CaloGeometry.h.

m_rmid_map

std::vector< FSmap< double , double > > CaloGeometry::m_rmid_map[2]

protectedinherited

Definition at line 108 of file CaloGeometry.h.

m_zent_map

std::vector< FSmap< double , double > > CaloGeometry::m_zent_map[2]

protectedinherited

Definition at line 111 of file CaloGeometry.h.

m_zext_map

std::vector< FSmap< double , double > > CaloGeometry::m_zext_map[2]

protectedinherited

Definition at line 113 of file CaloGeometry.h.

m_zmid_map

std::vector< FSmap< double , double > > CaloGeometry::m_zmid_map[2]

protectedinherited

Definition at line 109 of file CaloGeometry.h.

MAX_SAMPLING

const int CaloGeometry::MAX_SAMPLING = CaloCell_ID_FCS::MaxSample

staticinherited

Definition at line 29 of file CaloGeometry.h.

---

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

• CaloGeometryFromFile.h
• CaloGeometryFromFile.cxx