ATLAS Offline Software
Public Member Functions | Private Attributes | Friends | List of all members
LArHVIdMapping Class Reference

#include <LArHVIdMapping.h>

Collaboration diagram for LArHVIdMapping:

Public Member Functions

 LArHVIdMapping ()=delete
 
 LArHVIdMapping (const CaloCell_ID *caloId, const LArHVLineID *hvId, const LArElectrodeID *elId)
 
const HWIdentifier getLArHVLineID (HWIdentifier &electrodeId) const
 Return the LArHVLineID corresponding to a given LArElectrodeId. More...
 
void getElectrodeInCell (const Identifier &offId, std::vector< HWIdentifier > &elecId) const
 
void getHVLineInCell (const Identifier &offId, std::vector< HWIdentifier > &hvlineId) const
 Returns a vector<HVLineID> given an input offlineID. More...
 
const std::vector< HWIdentifier > & getLArElectrodeIDvec (HWIdentifier &hvlineId) const
 Return a vector of LArElectrodeID corresponding to a given LArHVLineID. More...
 
int getCellModule (const Identifier &offId) const
 returns the Module of a given offId More...
 
int getCellEtaSector (const Identifier &offId) const
 
int getCellPhiSector (const Identifier &offId) const
 
std::pair< int, int > getCellElectrodeMinMax (const Identifier &offId) const
 

Private Attributes

const CaloCell_ID * m_caloHelper
 
const LArEM_ID * m_emHelper
 
const LArHEC_ID * m_hecHelper
 
const LArFCAL_ID * m_fcalHelper
 
const LArHVLineID * m_hvlineHelper
 
const LArElectrodeID * m_electrodeHelper
 
std::map< HWIdentifier, HWIdentifier > m_electrode_hvline_map
 
std::map< HWIdentifier, std::vector< HWIdentifier > > m_hvline_electrode_map
 
const std::vector< HWIdentifier > m_invalid
 

Friends

class LArHVIdMappingAlg
 

Detailed Description

Definition at line 21 of file LArHVIdMapping.h.

Constructor & Destructor Documentation

◆ LArHVIdMapping() [1/2]

LArHVIdMapping::LArHVIdMapping ( )
delete

◆ LArHVIdMapping() [2/2]

LArHVIdMapping::LArHVIdMapping ( const CaloCell_ID *  caloId,
const LArHVLineID *  hvId,
const LArElectrodeID *  elId 
)

Definition at line 11 of file LArHVIdMapping.cxx.

11  :
12  m_caloHelper(caloId), m_hvlineHelper(hvId), m_electrodeHelper(elId)
13 
14 {
15  m_emHelper = m_caloHelper->em_idHelper();
16  m_hecHelper = m_caloHelper->hec_idHelper();
17  m_fcalHelper = m_caloHelper->fcal_idHelper();
18 }

Member Function Documentation

◆ getCellElectrodeMinMax()

std::pair< int, int > LArHVIdMapping::getCellElectrodeMinMax ( const Identifier &  offId) const

Definition at line 1404 of file LArHVIdMapping.cxx.

1420 {// get getCell1stElectrode start
1421  //ATH_MSG_VERBOSE("[getCellElectrodeMinMax] Entering..." );
1422 
1423  int l_bec=99;
1424  int l_sampling=-99;
1425  int l_region=-99;
1426  //int l_eta=-99;
1427  int l_phi=-99;
1428 
1429  if( m_caloHelper->is_em( offId ) ){
1430  l_bec = m_emHelper->barrel_ec(offId);
1431  l_sampling = m_emHelper->sampling(offId);
1432  l_region = m_emHelper->region(offId);
1433  //l_eta = m_emHelper->eta(offId);
1434  l_phi = m_emHelper->phi(offId);
1435  }
1436  else if( m_caloHelper->is_hec( offId ) ){
1437  l_bec = m_hecHelper->pos_neg(offId)*10; // +-20
1438  l_sampling = m_hecHelper->sampling(offId);
1439  l_region = m_hecHelper->region(offId);
1440  //l_eta = m_hecHelper->eta(offId);
1441  l_phi = m_hecHelper->phi(offId);
1442  }
1443  else if( m_caloHelper->is_fcal( offId ) ){
1444  l_bec = m_fcalHelper->pos_neg(offId)*20; // +-40
1445  }
1446  // Output argument
1447  // ===============
1448  int ElecMin=-99;
1449  int ElecMax=-99;
1450  if( abs(l_bec) == 1 )
1451  {// if in BARREL
1452  if( l_bec == 1 ) {
1453  // EMBARREL SIDE A
1454  if( l_sampling == 0 || ( l_sampling == 1 && l_region == 0) ){
1455  // ========================================
1456  // - 64 cells-in-phi per SIDE
1457  // - 4 cells-in-phi per MODULE
1458  // - 64 electrodes-in-phi per MODULE
1459  // --> 4 cells of 16 electrodes per CELL
1460  // Examples in *ATLAS* (not H8)
1461  // --> Cell #0 ==> MOD A01 FT=-1 ELEC 0-15
1462  // --> Cell #1 ==> MOD A01 FT=-1 ELEC 16-31
1463  // --> Cell #2 ==> MOD A01 FT=0 ELEC 32-47
1464  // --> Cell #3 ==> MOD A01 FT=0 ELEC 48-64
1465  // ========================================
1466  int phi_module = int((l_phi+2)/4);
1467  int phi_local = l_phi+2 - 4*phi_module;
1468  ElecMin = phi_local*16;
1469  ElecMax = ElecMin + 16-1;
1470  /*
1471  ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMB"
1472  << " Side A " << l_bec
1473  << " Sampling= " << l_sampling
1474  << " Region= " << l_region
1475  << " Module= A" << phi_module
1476  << " Phi/Module= " << phi_local
1477  << " Electrode=[" << ElecMin << "." << ElecMax << "]"
1478  );
1479  */
1480  if( l_sampling == 0 ){
1481  ElecMin = 0;
1482  ElecMax = 0;
1483  }
1484 
1485  }
1486  else if( (l_sampling == 1 && l_region == 1) || l_sampling == 2 || l_sampling == 3 ){
1487  // ==========================================
1488  // - 256 cells-in-phi per SIDE
1489  // - 16 cells-in-phi per MODULE
1490  // - 64 electrode's planes per MODULE
1491  // --> 16 cells of 4 electrodes per CELL
1492  // ==========================================
1493  // --> Cell #0 ==> MOD A01 FT=-1 ELEC 00-03
1494  // --> Cell #1 ==> MOD A01 FT=-1 ELEC 04-07
1495  // --> Cell #2 ==> MOD A01 FT=-1 ELEC 08-11
1496  // --> Cell #3 ==> MOD A01 FT=-1 ELEC 12-15
1497  // --> Cell #4 ==> MOD A01 FT=-1 ELEC 16-19
1498  // --> Cell #5 ==> MOD A01 FT=-1 ELEC 20-23
1499  // --> Cell #6 ==> MOD A01 FT=-1 ELEC 24-27
1500  // --> Cell #7 ==> MOD A01 FT=-1 ELEC 28-31
1501  // --> Cell #8 ==> MOD A01 FT=0 ELEC 32-35
1502  // --> Cell #9 ==> MOD A01 FT=0 ELEC 36-39
1503  // --> Cell#10 ==> MOD A01 FT=0 ELEC 40-43
1504  // --> Cell#11 ==> MOD A01 FT=0 ELEC 44-47
1505  // --> Cell#12 ==> MOD A01 FT=0 ELEC 48-51
1506  // --> Cell#13 ==> MOD A01 FT=0 ELEC 52-55
1507  // --> Cell#14 ==> MOD A01 FT=0 ELEC 56-59
1508  // --> Cell#15 ==> MOD A01 FT=0 ELEC 60-63
1509  // ==========================================
1510  int phi_module = int((l_phi+8)/16);
1511  // shift of 8 cells because Module #0 is rotated by half-module
1512  int phi_local = l_phi+8 - 16*phi_module;
1513  ElecMin = phi_local * 4;
1514  ElecMax = ElecMin + 4 - 1;
1515  /*
1516  ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMB"
1517  << " Side A " << l_bec
1518  << " Sampling= " << l_sampling
1519  << " Region= " << l_region
1520  << " Phi/Module= " << phi_local
1521  << " Module= A" << phi_module
1522  << " Electrode=[" << ElecMin << "." << ElecMax << "]"
1523  );
1524  */
1525  }
1526  }
1527 
1528  else if( l_bec == -1){
1529  //=====================
1530  //=====================
1531  // EMBARREL SIDE C
1532  //=====================
1533  //=====================
1534  // Phi in module is reversed going from left to right
1535  // in the MODULE frame
1536  if( l_sampling == 0 || ( l_sampling == 1 && l_region == 0) ){
1537  // ========================================
1538  // SAMPLING 0
1539  // - 64 cells-in-phi per DETECTOR
1540  // - 4 cells-in-phi per MODULE
1541  // - 64 electrodes-in-phi per MODULE
1542  // --> 4 cells of 16 electrodes per CELL
1543  // ========================================
1544  // --> Cell #0 ==> MOD C01 FT=-1 ELEC 0-15
1545  // --> Cell #1 ==> MOD C01 FT=-1 ELEC 16-31
1546  // --> Cell #2 ==> MOD C01 FT=0 ELEC 32-47
1547  // --> Cell #3 ==> MOD C01 FT=0 ELEC 48-64
1548  // ========================================
1549  int phi_module = int((l_phi+2)/4);
1550  int phi_local = (l_phi+2 - 4*phi_module) ;
1551  ElecMin = 48-phi_local*16;
1552  ElecMax = ElecMin + 16 - 1;
1553  /*
1554  ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMB"
1555  << " Side C " << l_bec
1556  << " Sampling= " << l_sampling
1557  << " Region= " << l_region
1558  << " Module= C" << phi_module
1559  << " Phi/Module= " << phi_local
1560  << " Electrode=[" << ElecMin << "." << ElecMax << "]"
1561  );
1562  */
1563  if( l_sampling == 0 ){
1564  ElecMin = 0;
1565  ElecMax = 0;
1566  }
1567  }
1568  else if( (l_sampling == 1 && l_region == 1) || l_sampling == 2 || l_sampling == 3 ){
1569  //===========================================
1570  // - 256 cells-in-phi per SIDE
1571  // - 16 cells-in-phi per MODULE
1572  // - 64 electrodes-in-phi per MODULE
1573  // --> 16 cells of 4 electrodes per CELL
1574  // Cell[electrodes]: 0[0,3],1[4,7],2[8,11],3[12,15]..etc...
1575  //===========================================
1576  // --> Cell #0 ==> MOD C01 FT=-1 ELEC 00-03
1577  // --> Cell #1 ==> MOD C01 FT=-1 ELEC 04-07
1578  // --> Cell #2 ==> MOD C01 FT=-1 ELEC 08-11
1579  // --> Cell #3 ==> MOD C01 FT=-1 ELEC 12-15
1580  // --> Cell #4 ==> MOD C01 FT=-1 ELEC 16-19
1581  // --> Cell #5 ==> MOD C01 FT=-1 ELEC 20-23
1582  // --> Cell #6 ==> MOD C01 FT=-1 ELEC 24-27
1583  // --> Cell #7 ==> MOD C01 FT=-1 ELEC 28-31
1584  // --> Cell #8 ==> MOD C01 FT=0 ELEC 32-35
1585  // --> Cell #9 ==> MOD C01 FT=0 ELEC 36-39
1586  // --> Cell#10 ==> MOD C01 FT=0 ELEC 40-43
1587  // --> Cell#11 ==> MOD C01 FT=0 ELEC 44-47
1588  // --> Cell#12 ==> MOD C01 FT=0 ELEC 48-51
1589  // --> Cell#13 ==> MOD C01 FT=0 ELEC 52-55
1590  // --> Cell#14 ==> MOD C01 FT=0 ELEC 56-59
1591  // --> Cell#15 ==> MOD C01 FT=0 ELEC 60-63
1592  //===========================================
1593  int phi_module = int((l_phi+8)/16);
1594  int phi_local = (l_phi+8 - 16*phi_module);
1595  // Just to get the right MOD id (electrode plane is idem to A-side)
1596  // Do not use to compute local Phi
1597  if( phi_module <= 8){
1598  phi_module = 8 - phi_module;
1599  }
1600  else{
1601  phi_module = 24 - phi_module;
1602  }
1603  ElecMin = 60-phi_local * 4;
1604  ElecMax = ElecMin + 4 - 1;
1605  /*
1606  ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMB"
1607  << " Side C " << l_bec
1608  << " Sampling= " << l_sampling
1609  << " Region= " << l_region
1610  << " Module= C" << phi_module
1611  << " Phi/Module= " << phi_local
1612  << " Electrode=[" << ElecMin << "." << ElecMax << "]"
1613  );
1614  */
1615  }
1616  }
1617  }
1618  // ======================================
1619  // ======================================
1620  // EM ENDCAP (A+C SIDES)
1621  // ======================================
1622  // ======================================
1623  else if(abs(l_bec) == 2 || abs(l_bec) == 3){
1624  // EMEC
1625  if( l_bec == 2 ){// bec==2
1626  //======================
1627  // A-SIDE / OUTER WHEEL
1628  //======================
1629  if( l_sampling == 0 ||
1630  (l_sampling == 1 && l_region >= 0 && l_region <= 5) ){
1631  //=============================
1632  // 64 cells per SIDE
1633  // 8 Modules per SIDE
1634  // -> 8 cells / module
1635  // 768 electrodes for 64 cells
1636  // -> 96 electrodes per module
1637  // -> 12 electrodes per cell
1638  //=============================
1639  // --> Cell #0 ==> ELEC 00-11
1640  // --> Cell #1 ==> ELEC 12-23
1641  // --> Cell #2 ==> ELEC 24-35
1642  // --> Cell #3 ==> ELEC 36-47
1643  // --> Cell #4 ==> ELEC 48-59
1644  // --> Cell #5 ==> ELEC 60-71
1645  // --> Cell #6 ==> ELEC 72-83
1646  // --> Cell #7 ==> ELEC 84-95
1647  //=============================
1648  int phi_module = int(l_phi/8);
1649  int phi_local = l_phi - 8*phi_module;
1650  ElecMin = phi_local * 12;
1651  ElecMax = ElecMin + 12 - 1;
1652  /*
1653  ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMEC"
1654  << " Side A " << l_bec
1655  << " Sampling= " << l_sampling
1656  << " Region= " << l_region
1657  << " Module= A" << phi_module
1658  << " FT= " << phi_local
1659  << " Electrode=[" << ElecMin << "." << ElecMax << "]"
1660  );
1661  */
1662 
1663  }
1664  else if( l_sampling == 2 || l_sampling == 3){
1665  //=============================
1666  // 256 cells per SIDE
1667  // 8 Modules per SIDE
1668  // --> 32 cells per module
1669  // 768 electrodes for 256 cells
1670  // --> 96 electrodes per module
1671  // --> 3 electrodes per cell
1672  //=============================
1673  // --> Cell #0 ==> ELEC 00-02
1674  // --> Cell #1 ==> ELEC 03-05
1675  // --> Cell #2 ==> ELEC 06-08
1676  // ...
1677  // --> Cell #31 => ELEC 92-95
1678  //=============================
1679  int phi_module = int(l_phi/32);
1680  int phi_local = l_phi - 32*phi_module;
1681  ElecMin = phi_local*3;
1682  ElecMax = ElecMin+3-1;
1683  /*
1684  ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMEC"
1685  << " Side A " << l_bec
1686  << " Sampling= " << l_sampling
1687  << " Region= " << l_region
1688  << " Module= A" << phi_module
1689  << " Phi/Module= " << phi_local
1690  << " Electrode=[" << ElecMin << "." << ElecMax << "]"
1691  );
1692 
1693  */
1694  }
1695  }
1696  else if( l_bec == 3 ){
1697  // =================
1698  // INNER WHEEL
1699  // =================
1700  if( l_sampling == 1 || l_sampling == 2 || l_sampling == 0 ){
1701  //====================================
1702  // 64 cells per SIDE
1703  // 8 module per SIDE
1704  // -> 8 cells per Module
1705  // 256 electrodes for 8 modules
1706  // --> 32 electrodes per module
1707  // --> 4 electrodes per cell
1708  //====================================
1709  // --> Cell #0 ==> ELEC 00-03
1710  // --> Cell #1 ==> ELEC 04-07
1711  // --> Cell #2 ==> ELEC 08-11
1712  // ...
1713  // --> Cell #7 ==> ELEC 28-31
1714  //====================================
1715  int phi_module = int(l_phi/8);
1716  int phi_local = l_phi - 8*phi_module;
1717  ElecMin = phi_local *4;
1718  ElecMax = ElecMin + 4 - 1;
1719  /*
1720  ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMEC"
1721  << " Side A " << l_bec
1722  << " Sampling= " << l_sampling
1723  << " Region= " << l_region
1724  << " Module= A" << phi_module
1725  << " Phi/Module= " << phi_local
1726  << " Electrode=[" << ElecMin << "." << ElecMax << "]"
1727  );
1728  */
1729  }
1730  }
1731  else if( l_bec == -2 ){
1732  //========================
1733  // C-SIDE OUTER WHEEL
1734  //========================
1735  if( l_sampling == 0 || (l_sampling == 1 && l_region >= 0 && l_region <= 5) ){
1736  //=============================
1737  // 64 cells per SIDE
1738  // 8 Modules per SIDE
1739  // -> 8 cells / module
1740  // 768 electrodes for 64 cells
1741  // -> 96 electrodes per module
1742  // -> 12 electrodes per cell
1743  //=============================
1744  // --> Cell #0 ==> ELEC 00-11
1745  // --> Cell #1 ==> ELEC 12-23
1746  // --> Cell #2 ==> ELEC 24-35
1747  // --> Cell #3 ==> ELEC 36-47
1748  // --> Cell #4 ==> ELEC 48-59
1749  // --> Cell #5 ==> ELEC 60-71
1750  // --> Cell #6 ==> ELEC 72-83
1751  // --> Cell #7 ==> ELEC 84-95
1752  //=============================
1753  int phi_module = int(l_phi/8);
1754  int phi_local = 7 - (l_phi - 8*phi_module);
1755  ElecMin = phi_local * 12;
1756  ElecMax = ElecMin + 12 - 1;
1757  /*
1758  ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMEC"
1759  << " Side C " << l_bec
1760  << " Sampling= " << l_sampling
1761  << " Region= " << l_region
1762  << " Module= C" << phi_module
1763  << " Phi/Module= " << phi_local
1764  << " Electrode=[" << ElecMin << "." << ElecMax << "]"
1765  );
1766 
1767  */
1768  }
1769  else if( l_sampling == 2 || l_sampling == 3){
1770  //=============================
1771  // 256 cells per SIDE
1772  // 8 Modules per SIDE
1773  // --> 32 cells per module
1774  // 768 electrodes for 256 cells
1775  // --> 96 electrodes per module
1776  // --> 3 electrodes per cell
1777  //=============================
1778  // --> Cell #0 ==> ELEC 00-02
1779  // --> Cell #1 ==> ELEC 03-05
1780  // --> Cell #2 ==> ELEC 06-08
1781  // ...
1782  // --> Cell #31 => ELEC 92-95
1783  //=============================
1784  int phi_module = int(l_phi/32);
1785  int phi_local = 31 - (l_phi - 32*phi_module);
1786  ElecMin = phi_local*3;
1787  ElecMax = ElecMin + 3 - 1;
1788  /*
1789  ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMEC"
1790  << " Side C " << l_bec
1791  << " Sampling= " << l_sampling
1792  << " Region= " << l_region
1793  << " Module= C" << phi_module
1794  << " Phi/Module= " << phi_local
1795  << " Electrode=[" << ElecMin << "." << ElecMax << "]"
1796  );
1797  */
1798  }
1799  }
1800  else if( l_bec == -3 ){
1801  // INNER WHEEL C
1802  if( l_sampling == 1 || l_sampling == 2 || l_sampling == 0 ){
1803  // 256 electrodes for 64 cells
1804  // --> 8 cells per module
1805  // --> 32 electrodes per module
1806  // --> 4 electrodes per cell
1807  int phi_module = int(l_phi/8);
1808  int phi_local = l_phi - 8*phi_module;
1809  ElecMin = 28 - phi_local *4;
1810  ElecMax = ElecMin + 4 -1;
1811  /*
1812  ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMEC"
1813  << " Side C " << l_bec
1814  << " Sampling= " << l_sampling
1815  << " Region= " << l_region
1816  << " Module= C" << phi_module
1817  << " Phi/Module= " << phi_local
1818  << " Electrode=[" << ElecMin << "." << ElecMax << "]"
1819  );
1820  */
1821  }
1822  }
1823  }
1824  else if( abs(l_bec)==20 ){// HEC
1825  //==========================
1826  // HEC wheels
1827  //==========================
1828  // Sampling 0 & 1 : 1st wheel
1829  // Sampling 2 & 3 : 2nd wheel
1830  // l_region 0 : Outer
1831  // region 1 : Inner
1832  //==========================
1833  if( l_sampling == 0){
1834  // ======================
1835  // Sampling 0 , region 0
1836  // * 1st wheel *
1837  // 64 cells per SIDE
1838  // 32 module per SIDE
1839  // -> 2 cells in phi per Module
1840  // 8 electrode's planes
1841  // -> 8 electrode's planes per cell !
1842  // ================================
1843  // Made using Fig. 8-1 in TDR 96-41
1844  // ================================
1845  //ElecMin = l_eta+1;
1846  //ElecMax = ElecMin + 4;
1847  ElecMin = 1;
1848  ElecMax = 8;
1849  // Note : idem for region 0 and region 1
1850  }
1851  else if( l_sampling == 1){
1852  // ====================
1853  // sampling 1 l_region 0
1854  // * 1st wheel *
1855  // 64 cells in phi per SIDE
1856  // 10 cells in eta per SIDE
1857  // 32 modules per SIDE
1858  // -> 2x10 cells per module
1859  // 16 electrode's planes per module
1860  // ================================
1861  // Made using Fig. 8-1 in TDR 96-41
1862  // ================================
1863  ElecMin = 9;
1864  ElecMax =24;
1865  // Note : idem for region 0 and region 1
1866  }
1867  else if( l_sampling == 2){
1868  // ====================
1869  // sampling 2 region 0
1870  // * 2nd wheel *
1871  // 64 cells in phi per SIDE
1872  // 10 cells in eta per SIDE
1873  // 32 modules in phi per SIDE
1874  // 16 electrode's plane
1875  // ================================
1876  // Made using Fig. 8-1 in TDR 96-41
1877  // ================================
1878  // Note : idem for region 0 and region 1
1879  ElecMin = 25;
1880  ElecMax = 32;
1881  }
1882  else if( l_sampling == 3){
1883  // ==============================
1884  // index starting at 2 thus the 32-2=20
1885  // 2 cells in phi per module
1886  // 8 electrode per module
1887  // ie: 4 electrodes per cell
1888  // ==============================
1889  // Note : idem for region 0 and region 1
1890  ElecMin = 33;
1891  ElecMax = 40;
1892  }
1893  } // HEC
1894  else if( abs(l_bec)==40 ){// FCAL
1895  ElecMin = 0;
1896  ElecMax = 0;
1897  }
1898  else{
1899  //msg(MSG::WARNING)
1900  // << "[getCellElectrodeMinMax] Detector unknown .."
1901  // << endmsg;
1902  }
1903  //ATH_MSG_DEBUG("[getCellElectrodeMinMax] Exiting..." );
1904  std::pair<int, int> electrodeMinMax( ElecMin, ElecMax);
1905  return electrodeMinMax;
1906 }

◆ getCellEtaSector()

int LArHVIdMapping::getCellEtaSector ( const Identifier &  offId) const

Definition at line 720 of file LArHVIdMapping.cxx.

732 {// Start of getHVEtaSector()
733  //ATH_MSG_VERBOSE("Entering getCellEtaSector ...." );
734 
735  std::string l_version = m_emHelper->dictionaryVersion();
736 
737  // Returned Value
738  int l_bec =-99;
739  int sampling=-99;
740  int region =-99;
741  int ieta =-99;
742  // Identify the Helper to be used
743  // =====================================
744  if( m_caloHelper->is_em( offId ) ){
745  l_bec = m_emHelper->barrel_ec(offId);
746  sampling = m_emHelper->sampling(offId);
747  region = m_emHelper->region(offId);
748  ieta = m_emHelper->eta(offId);
749  }
750  else if( m_caloHelper->is_hec( offId ) ){
751  l_bec = m_hecHelper->pos_neg(offId)*10;
752  sampling = m_hecHelper->sampling(offId);
753  region = m_hecHelper->region(offId);
754  ieta = m_hecHelper->eta(offId);
755  }
756  else if( m_caloHelper->is_fcal( offId ) ){
757  l_bec = m_fcalHelper->pos_neg(offId)*20;
758  sampling = m_fcalHelper->module(offId);
759  }
760 
761  // Output argument
762  // =====================================
763  int hvEta=-99;
764 
765  // Construct heEta
766  // =====================================
767  if( abs(l_bec) == 1 ){
768  // BARREL
769  if( sampling == 1 )
770  {// FRONT sampling
771  if( region == 0 ){
772  if( ieta >= 0 && ieta < 64 ){
773  hvEta=1;
774  }
775  else if( ieta >=64 && ieta < 128 ){
776  hvEta=2;
777  }
778  else if( ieta >=128 && ieta < 192 ){
779  hvEta=3;
780  }
781  else if( ieta >=192 && ieta < 256 ){
782  hvEta=4;
783  }
784  else if( ieta >=256 && ieta < 320 ){
785  hvEta=5;
786  }
787  else if( ieta >=320 && ieta < 384 ){
788  hvEta=6;
789  }
790  else if( ieta >=384 && ieta < 448 ){
791  hvEta=7;
792  }
793  }
794  else if( region == 1){
795  hvEta=7;
796  }
797  else {
798  //msg(MSG::WARNING) << "==> Invalid HV Eta-Sector for sampling=" << sampling << " Region=" << region << " I(eta)="<< ieta << endmsg;
799  }
800  }
801  else if( sampling == 2 ){
802  // MIDDLE Sampling in Barrel
803  // ----------------------
804  //
805  if( region == 0 ){
806  if( ieta >= 0 && ieta < 8 ){
807  hvEta=1;
808  }
809  else if( ieta >=8 && ieta < 16 ){
810  hvEta=2;
811  }
812  else if( ieta >=16 && ieta < 24 ){
813  hvEta=3;
814  }
815  else if( ieta >=24 && ieta < 32 ){
816  hvEta=4;
817  }
818  else if( ieta >=32 && ieta < 40 ){
819  hvEta=5;
820  }
821  else if( ieta >=40 && ieta < 48 ){
822  hvEta=6;
823  }
824  else if( ieta >=48 && ieta < 57 ){
825  hvEta=7;
826  }
827  }
828  else if( region == 1)
829  {
830  hvEta=7; // to be checked with Francesco
831 
832  }
833  else{
834  //msg(MSG::WARNING) << "==> Invalid HV Eta-Sector for sampling=" << sampling << " Region=" << region << " I(eta)="<< ieta << endmsg;
835  }
836  }
837  else if( sampling == 3 ){
838  // BACK Sampling in Barrel
839  // -----------------------
840  //
841  if( region == 0 ){
842  if( ieta >= 0 && ieta < 4 ){
843  hvEta=1;
844  }
845  else if( ieta >=4 && ieta < 8 ){
846  hvEta=2;
847  }
848  else if( ieta >=8 && ieta < 12 ){
849  hvEta=3;
850  }
851  else if( ieta >=12 && ieta < 16 ){
852  hvEta=4;
853  }
854  else if( ieta >=16 && ieta < 20 ){
855  hvEta=5;
856  }
857  else if( ieta >=20 && ieta < 24 ){
858  hvEta=6;
859  }
860  else if( ieta >=24 && ieta < 28 ){
861  hvEta=7;
862  }
863  }
864  else if( region == 1){
865  //msg(MSG::WARNING) << "==> Invalid HV Eta-Sector for sampling=" << sampling << " Region=" << region << " I(eta)="<< ieta << endmsg;
866  }
867  else{
868  //msg(MSG::WARNING) << "==> Invalid HV Eta-Sector for sampling=" << sampling << " Region=" << region << " I(eta)="<< ieta << endmsg;
869  }
870  }
871 
872  else if( sampling == 0 ){
873  // PreSampler Sampling in Barrel
874  // -----------------------------
875  if( region == 0 ){
876  // OKed by JY Hostachy
877  if( ieta <= 60 ){
878  if( ieta >= 0 && ieta < 15 ){
879  hvEta=1;
880  }
881  else if( ieta >=15 && ieta <30 ){
882  hvEta=2;
883  }
884  else if( ieta >=30 && ieta < 45 ){
885  hvEta=3;
886  }
887  else if( ieta >=45 && ieta < 61 ){
888  hvEta=4;
889  }
890  }
891  else{
892  //msg(MSG::WARNING) << "Not in EMBPS..i(eta)=" << ieta << endmsg;
893  }
894  }
895  }
896  else {
897  //msg(MSG::WARNING) << "Not in Barrel ..." << endmsg;
898  }
899  }
900  else if( abs(l_bec) == 2 || abs(l_bec) == 3){
901  // ENDCAP EMEC
902  // -----------
903  //
904  if( sampling == 3 ){
905  // Sampling 3 OUTER Wheel
906  // -----------------------
907  // Validated on NOV-25-2004 with Djama (CPPM)
908  //
909  if( ieta >= 0 && ieta <= 1){
910  hvEta=1;
911  }
912  else if(ieta >=2 && ieta <= 5){
913  hvEta=2;
914  }
915  else if(ieta >=6 && ieta <= 9){
916  hvEta=3;
917  }
918  else if(ieta >=10 && ieta <= 11){
919  hvEta=4;
920  }
921  else if(ieta >=12 && ieta <= 15){
922  hvEta=5;
923  }
924  else if(ieta >=16 && ieta <= 19){
925  hvEta=6;
926  }
927  }
928  else if( sampling == 2 && abs(l_bec) == 2 ){
929  // Sampling 2 OUTER Wheel
930  // ----------------------
931  //
932  // Validated on NOV-25-2004 with Djama (CPPM)
933  //
934  if(region == 0){
935  hvEta =0;
936  }
937  else if( region == 1 ){
938  // region 1 Sampling 2
939  if( ieta >=0 && ieta <= 2){
940  hvEta=0;
941  }
942  else if( ieta >=3 && ieta <= 6){
943  hvEta=1;
944  }
945  else if( ieta >=7 && ieta <= 15){
946  hvEta=2;
947  }
948  else if( ieta >=16 && ieta <= 23){
949  hvEta=3;
950  }
951  else if( ieta >=24 && ieta <= 27){
952  hvEta=4;
953  }
954  else if( ieta >=28 && ieta <= 35){
955  hvEta=5;
956  }
957  else if( ieta >=36 && ieta <= 42){
958  hvEta=6;
959  }
960  }
961  }
962 
963  else if( sampling == 2 && abs(l_bec) == 3 ){
964  // Sampling 2 INNER Wheel
965  // -----------------------
966  //
967  // Validated on NOV-25-2004 with Djama (CPPM)
968  //
969  if( ieta >=0 && ieta <= 2){
970  hvEta=7;
971  }
972  else if( ieta >=3 && ieta <= 6){
973  hvEta=8;
974  }
975  }
976 
977  else if( sampling == 1 && abs(l_bec) == 3 ){
978  // Sampling 1 INNER Wheel
979  // -----------------------
980  //
981  // Validated on NOV-25-2004 with Djama (CPPM)
982  //
983  if( ieta >=0 && ieta <= 2){
984  hvEta=7;
985  }
986  else if( ieta >=3 && ieta <= 6){
987  hvEta=8;
988  }
989  }
990 
991  else if( sampling == 1 && abs(l_bec) == 2 ){
992  // Sampling 1 OUTER Wheel
993  // -----------------------
994  //
995  if( region == 0 || region == 1)
996  {// 1.375 < eta < 1.5
997  hvEta=0;
998  }
999  else if( region == 2 ){
1000  if( ieta >= 0 && ieta <= 31)
1001  {
1002  // 1.5 < eta < 1.6
1003  hvEta = 1;
1004  }
1005  else if( ieta <= 95) {
1006  // 1.6 < eta < 1.8
1007  hvEta = 2;
1008  }
1009  }
1010  else if(region == 3){
1011  // 1.8 < eta < 2.0
1012  hvEta = 3;
1013  }
1014  else if(region == 4){
1015  // 2.0 < eta < 2.4
1016  if( ieta >=0 && ieta <= 15 ){
1017  // 2.0 < eta < 2.1
1018  hvEta = 4;
1019  }
1020  else if( ieta >= 16 && ieta <= 47 ){
1021  // 2.1 < eta < 2.3
1022  hvEta = 5;
1023  }
1024  else if( ieta >= 48 && ieta <= 63 ){
1025  // 2.3 < eta < 2.4
1026  hvEta = 6;
1027  }
1028  }
1029  else if( region == 5 ){
1030  // 2.4 < eta < 2.5
1031  hvEta = 6;
1032  }
1033  }
1034  }
1035 
1036 
1037  else if( abs(l_bec)== 20 ){
1038  // HEC Wheels
1039  //-----------
1040  if( sampling == 0 ){
1041  hvEta = 1;
1042  }
1043  else if( sampling == 1){
1044  hvEta = 2;
1045  }
1046  else if( sampling == 2){
1047  hvEta = 3;
1048  }
1049  else if( sampling == 3){
1050  hvEta = 4;
1051  }
1052  }
1053  // ============================
1054  // FCAL eta bins
1055  // eta = [0,62] in Module 1
1056  // eta = [0,31] in Module 2
1057  // eta = [0,15] in Module 3
1058  // ============================
1059  else if( abs(l_bec)== 40 ){
1060  // FCAL Wheels
1061  //-----------
1062  if( sampling == 1 ){
1063  hvEta = 1;
1064  }
1065  else if( sampling == 2 ){
1066  hvEta = 2;
1067  }
1068  else if( sampling == 3 ){
1069  hvEta = 3;
1070  }
1071  else{
1072  //msg(MSG::WARNING)
1073  // << "[getCellEtaSector] invalid FCAL input cell.." << endmsg;
1074  }
1075  }
1076  else{
1077  //msg(MSG::WARNING) << "[getCellModule] Detector unknown ! " << endmsg;
1078  }
1079  // Output
1080  //ATH_MSG_DEBUG("Closing getCellEtaSector ...." );
1081  return hvEta;
1082 }

◆ getCellModule()

int LArHVIdMapping::getCellModule ( const Identifier &  offId) const

returns the Module of a given offId

Definition at line 398 of file LArHVIdMapping.cxx.

408 {// Start of getCellModule
409  //======================================
410  //ATH_MSG_VERBOSE("Entering getCellModule " );
411 
412  int bec =-99;
413  int sampling =-99;
414  int region =-99;
415  int phi =-99;
416  //int module =-99;
417  // Returned Value
418  // =====================================
419  int ModuleID =-99;
420 
421  // Identify the Helper to be used
422  // =====================================
423  if( m_caloHelper->is_em( offId ) ){
424  bec = m_emHelper->barrel_ec(offId);
425  sampling = m_emHelper->sampling(offId);
426  region = m_emHelper->region(offId);
427  phi = m_emHelper->phi(offId);
428  //ATH_MSG_DEBUG("[getCellModule] processing an EM cell.." );
429  }
430  else if( m_caloHelper->is_hec( offId ) ){
431  bec = m_hecHelper->pos_neg(offId)*10;
432  sampling = m_hecHelper->sampling(offId);
433  region = m_hecHelper->region(offId);
434  phi = m_hecHelper->phi(offId);
435  //ATH_MSG_DEBUG("[getCellModule] processing an HEC cell.." );
436  }
437  else if( m_caloHelper->is_fcal( offId )){
438  bec = m_fcalHelper->pos_neg(offId)*20;
439  sampling = m_fcalHelper->module(offId);
440  //module = m_fcalHelper->module(offId);
441  phi = m_fcalHelper->phi(offId);
442  //ATH_MSG_DEBUG("[getCellModule] processing an FCAL cell.." );
443  }
444 
445  // Now determine the Module ID
446  if( abs(bec) == 1 ){
447  // EM BARREL
448  // ===========================================================================
449  // x being the ATLAS x direction (pointing towards the center of the collider)
450  // we have :
451  // SIDE - C (z<0) SIDE - A (z>0)
452  // ------------- --------------
453  // C04 A04
454  // C03 C05 A05 A03
455  // C02 C06 A06 A02
456  // C01 C07 A07 A01
457  // C00----------C08-->X A08----------A00---> X
458  // C15 C09 A09 A15
459  // C14 C10 A10 A14
460  // C13 C11 A11 A13
461  // C12 A12
462  //============================================================================
463  if( bec == 1 ){
464  // A-WHEEL
465  // =======
466  if( sampling == 0 ){
467  // ------------------------------
468  // 32 Modules of two cells in phi
469  // ------------------------------
470  int phi_module=int(phi/2);
471  ModuleID = phi_module;
472  }
473  else if( sampling == 1 && region == 0 ){
474  // -----------------------------
475  // 16 Modules of 4 cells in phi
476  // -----------------------------
477  int phi_module = int((phi+2)/4);
478  if( phi_module == 16 ){
479  ModuleID = 0;
480  }
481  else{
482  ModuleID = phi_module;
483  }
484  }
485  else if( sampling == 2 || sampling == 3 || (sampling == 1 && region == 1 ) ){
486  // -----------------------------
487  // 16 Modules of 16 cells in phi
488  // -----------------------------
489  int phi_module = int((phi+8)/16);
490  if( phi_module == 16 ){
491  ModuleID=0;
492  }
493  else{
494  ModuleID=phi_module;
495  }
496  }
497  }
498 
499  else if( bec == -1 ){
500  // C-WHEEL
501  // =======
502  if( sampling == 0 ){
503  // ------------------------------
504  // 32 Modules of two cells in phi
505  // ------------------------------
506  int phi_module=int(phi/2);
507  if( phi_module <= 15 ){
508  phi_module = 15 - phi_module;
509  }
510  else{
511  phi_module = 47 - phi_module;
512  }
513  ModuleID = phi_module;
514  }
515  else if( sampling == 1 && region == 0 ){
516  // -----------------------------
517  // 16 Modules of 4 cells in phi
518  // -----------------------------
519  int phi_module = int((phi+2)/4);
520  if( phi_module <= 8){
521  phi_module = 8 - phi_module;
522  }
523  else{
524  phi_module = 24 - phi_module;
525  }
526  ModuleID = phi_module;
527  }
528  else if( sampling == 2 || sampling == 3 || (sampling == 1 && region == 1 ) ){
529  // -----------------------------
530  // 16 Modules of 16 cells in phi
531  // -----------------------------
532  int phi_module = int((phi+8)/16);
533  if( phi_module <= 8){
534  phi_module = 8 - phi_module;
535  }
536  else{
537  phi_module = 24 - phi_module;
538  }
539  ModuleID = phi_module;
540  }
541  }
542  }
543 
544  else if( abs(bec) == 2 || abs(bec) == 3){
545  // EMEC
546  // ----
547  //
548  // x being the ATLAS x direction (pointing towards the center of the collider)
549  // we have :
550  // SIDE - C SIDE - A
551  // -------- -----------
552  //
553  // ECC1 ECC2 ECA2 ECA1
554  //
555  // ECC0 ECC3 ECA3 ECA0
556  // -------------> X -----------> X
557  // ECC7 ECC4 ECA4 ECA7
558  //
559  // ECC6 ECC5 ECA5 ECA6
560  //
561  //
562  if( bec > 0 ){
563  // SIDE - A
564  if( sampling == 0 || sampling == 1 ||
565  (sampling == 2 && abs(bec) == 3 ) ){
566  // -------------------------------
567  // 8 Modules of 8 cells in phi
568  // -------------------------------
569  // Sampling 0, 1 (inner+outer) & 2 region 0 (inner)
570  //
571  int phi_local = int(phi/8);
572  ModuleID = phi_local;
573  }
574  else if( (sampling == 2 && abs(bec) == 2) || (sampling == 3 && abs(bec) == 2)){
575  // ----------------------------------------
576  // 8 Modules of 32 cells in phi
577  // ----------------------------------------
578  // Sampling 2 & 3 ( outer wheel) in [0,255]
579  //
580  int phi_local = int(phi/32);
581  ModuleID = phi_local;
582  }
583  }
584  else{
585  // SIDE-C
586  if( sampling == 0 || sampling == 1 ||
587  (sampling == 2 && abs(bec) == 3 ) ){
588  // ------------------------------
589  // 8 Modules of 8 cells in phi
590  // -------------------------------
591  // Sampling 0, 1 & 2( inner wheel) in [0,63]
592  //
593  int rev_phi=-99;
594  int phi_local = int(phi/8);
595  if( phi_local == 0 ){rev_phi = 3;}
596  if( phi_local == 1 ){rev_phi = 2;}
597  if( phi_local == 2 ){rev_phi = 1;}
598  if( phi_local == 3 ){rev_phi = 0;}
599  if( phi_local == 4 ){rev_phi = 7;}
600  if( phi_local == 5 ){rev_phi = 6;}
601  if( phi_local == 6 ){rev_phi = 5;}
602  if( phi_local == 7 ){rev_phi = 4;}
603  ModuleID = rev_phi;
604  }
605  else if( (sampling == 2 && abs(bec) == 2) || (sampling == 3 && abs(bec) == 2)){
606  // ----------------------------------------
607  // 8 Modules of 32 cells in phi
608  // ----------------------------------------
609  // Sampling 2 & 3 ( outer wheel) in [0,255]
610  //
611  int rev_phi=-99;
612  int phi_local = int(phi/32);
613  if( phi_local == 0 ){rev_phi = 3;}
614  if( phi_local == 1 ){rev_phi = 2;}
615  if( phi_local == 2 ){rev_phi = 1;}
616  if( phi_local == 3 ){rev_phi = 0;}
617  if( phi_local == 4 ){rev_phi = 7;}
618  if( phi_local == 5 ){rev_phi = 6;}
619  if( phi_local == 6 ){rev_phi = 5;}
620  if( phi_local == 7 ){rev_phi = 4;}
621  ModuleID = rev_phi;
622  }
623  }
624  }
625 
626 
627  else if( abs(bec) == 20 ){
628  // HEC Detector
629  // ============
630  if( bec > 0){
631  // WHEEL A
632  if( region == 0 ){
633  // OUTER WHEEL
634  // ----------------------------
635  // 32 Modules of 2 cells in phi
636  // ----------------------------
637  int phi_module=int(phi/2);
638  ModuleID = phi_module;
639  }
640  else if( region == 1){
641  // INNER WHEEL
642  // ----------------------------
643  // 32 Modules of 1 cells in phi
644  // ----------------------------
645  int phi_module=int(phi);
646  ModuleID = phi_module;
647  }
648  }
649  else if( bec < 0){
650  // WHEEL C
651  if( region == 0 ){
652  // OUTER WHEEL
653  // -----------
654  int phi_module=int(phi/2);
655  if( phi_module <= 15 ){
656  phi_module = 15 - phi_module;
657  }
658  else{
659  phi_module = 47 - phi_module;
660  }
661  ModuleID = phi_module;
662  }
663  else if( region == 1){
664  // INNER WHEEL
665  // -----------
666  int phi_module=int(phi);
667  if( phi_module <= 15 ){
668  phi_module = 15 - phi_module;
669  }
670  else{
671  phi_module = 47 - phi_module;
672  }
673  ModuleID = phi_module;
674  }
675  }
676  }
677  // ===========================================================================
678  // x being the ATLAS x direction (pointing towards the center of the collider)
679  // we have :
680  // SIDE - C (z<0) SIDE - A (z>0)
681  // ------------- --------------
682  // C04 A04
683  // C03 C05 A05 A03
684  // C02 C06 A06 A02
685  // C01 C07 A07 A01
686  // C00----------C08-->X A08----------A00---> X
687  // C15 C09 A09 A15
688  // C14 C10 A10 A14
689  // C13 C11 A11 A13
690  // C12 A12
691  //============================================================================
692 
693  else if( abs(bec) == 40 ){
694  // FCAL Detector
695  // ==============
696  // FCAL-Module 1 : EM
697  // FCAL-Module 2,3 : Hadronic
698  // -> 16 cells in phi per Module
699  // ==============================
700  if( sampling == 1){
701  ModuleID = int(phi);
702  }
703  else if( sampling == 2 ){
704  ModuleID = int(phi/2);
705  }
706  else if( sampling == 3){
707  ModuleID = int(phi/4);
708  }
709  }
710  else{
711  //msg(MSG::WARNING) << " -->> Invalid MODULE returned " << endmsg;
712  }
713  //ATH_MSG_DEBUG("Closing getCellModule " );
714  return ModuleID;
715 }

◆ getCellPhiSector()

int LArHVIdMapping::getCellPhiSector ( const Identifier &  offId) const

Definition at line 1088 of file LArHVIdMapping.cxx.

1104 {// Start of getCellPhiSector()
1105  //ATH_MSG_VERBOSE("Entering getCellPhiSector ...." );
1106  //
1107  // Get relevant offline fields
1108  //
1109  int bec =99;
1110  int sampling=-99;
1111  int region =-99;
1112  int phi =-99;
1113 
1114  if( m_caloHelper->is_em( offId ) ){
1115  bec = m_emHelper->barrel_ec(offId);
1116  sampling = m_emHelper->sampling(offId);
1117  region = m_emHelper->region(offId);
1118  phi = m_emHelper->phi(offId);
1119  }
1120  else if( m_caloHelper->is_hec( offId ) ){
1121  bec = m_hecHelper->pos_neg(offId)*10;
1122  }
1123  else if( m_caloHelper->is_fcal( offId ) ){
1124  bec = m_fcalHelper->pos_neg(offId)*20; // ie: +/-40
1125  }
1126  // Output Argument
1127  int hvPhi=-2;
1128  //
1129  //*** Note*** :
1130  //
1131  // For EMB, Feedthrough (FT) takes value -1 and 0
1132  // Instead, we encode these values as:
1133  // FT = -1 --> hvPhiSector = 1
1134  // FT = 0 --> hvPhiSector = 0
1135  //
1136  if( abs(bec) == 1){
1137  // EMBARREL
1138  //----------
1139  if( bec == 1){
1140  // WHEEL-A
1141  //--------
1142  if( sampling == 0 ){
1143  // ------------------------------
1144  // EMBPS : phiSector not relevant
1145  // ------------------------------
1146  hvPhi = 0;
1147  }
1148  if( sampling == 1 && region == 0 ){
1149  // ---------------------------------
1150  // EM1 Region 0: phi-cells in [0,63]
1151  // ---------------------------------
1152  //
1153  int phi_local = int(phi);
1154  for(int ift=0; ift<= 15; ift++){
1155  if( phi_local == ift*4 || phi_local == 1+ift*4 ){
1156  hvPhi = 0;
1157  }
1158  if( phi_local == 2+ift*4 || phi_local == 3+ift*4 ){
1159  hvPhi = 1;
1160  }
1161  }
1162  }
1163  else if( sampling == 2 || sampling == 3 || (sampling == 1 && region == 1 ) ){
1164  // ----------------------------------------------
1165  // FRONT Region 1 + MIDDLE + BACK Phi in [0,255]
1166  // ----------------------------------------------
1167  int phi_local = int(phi);
1168  for( int ift=0; ift<= 15; ift++){
1169  for( int i=0; i<=7; i++){
1170  if( phi_local == i+ift*16 ){
1171  hvPhi = 0;
1172  }
1173  }
1174  for( int i=8; i<=15; i++){
1175  if( phi_local == i+ift*16 ){
1176  hvPhi = 1;
1177  }
1178  }
1179  }
1180  }
1181  }
1182 
1183  else if( bec == -1){
1184  // WHEEL-C
1185  //--------
1186  if( sampling == 0 ){
1187  // ------------------------------
1188  // EMBPS : phiSector not relevant
1189  // ------------------------------
1190  hvPhi = 0;
1191  }
1192  if( sampling == 1 && region == 0 ){
1193  // ---------------------------------------
1194  // FRONT (Region 0): phi-cells in [0,63]
1195  // ---------------------------------------
1196  int phi_local = int(phi);
1197  for(int ift=0; ift<= 15; ift++){
1198  if( phi_local == ift*4 || phi_local == 1+ift*4 ){
1199  hvPhi = 1;
1200  }
1201  if( phi_local == 2+ift*4 || phi_local == 3+ift*4 ){
1202  hvPhi = 0;
1203  }
1204  }
1205  }
1206  else if( sampling == 2 || sampling == 3 || (sampling == 1 && region == 1 ) ){
1207  // FRONT Region 1 + MIDDLE + BACK Phi in [0,255]
1208  int phi_local = int(phi);
1209  for( int ift=0; ift<= 15; ift++){
1210  for( int i=0; i<=7; i++){
1211  if( phi_local == i+ift*16 ){
1212  hvPhi = 1;
1213  }
1214  }
1215  for( int i=8; i<=15; i++){
1216  if( phi_local == i+ift*16 ){
1217  hvPhi = 0;
1218  }
1219  }
1220  }
1221  }
1222  }
1223  }
1224 
1225  else if( abs(bec) == 2 || abs(bec) == 3 ){
1226  // EMEC
1227  if( bec > 0 ){
1228  // WHEEL-A
1229  if( sampling == 1 && abs(bec) == 2 ){
1230  // ====================================
1231  // Sampling 1 OUTER Wheel
1232  // =====================================
1233  // 64 cells per SIDE
1234  // 8 Modules per side
1235  // --> 8 cells / module
1236  // 4 FT per module [1,4]
1237  // --> 2 cells / FT
1238  // =====================================
1239  int imod=int(phi/8);
1240  int phi_local = phi - imod*8;
1241  if( phi_local == 0 || phi_local == 1){
1242  hvPhi = 1;
1243  }
1244  else if( phi_local == 2 || phi_local == 3){
1245  hvPhi = 2;
1246  }
1247  else if( phi_local == 4 || phi_local == 5){
1248  hvPhi = 3;
1249  }
1250  else if( phi_local == 6 || phi_local == 7){
1251  hvPhi = 4;
1252  }
1253  }
1254  if( sampling == 1 && abs(bec) == 3 ){
1255  // Sampling 1 INNER Wheel (FT in [1,8])
1256  // ------------------------------------
1257  //
1258  int imod=int(phi/8);
1259  int phi_local = phi-imod*8;
1260  hvPhi = phi_local+1;
1261  }
1262  else if( sampling == 2 && abs(bec) == 3 ){
1263  //
1264  // Sampling 2 Inner Wheel (FT in [1,8])
1265  // ------------------------------------
1266  //
1267  int imod=int(phi/8);
1268  int phi_local = phi - imod*8;
1269  hvPhi = phi_local+1;
1270  }
1271  else if( sampling == 2 && abs(bec) == 2 ){
1272  //
1273  // Sampling 2 Outer Wheel (FT in [1,4])
1274  // ------------------------------------
1275  //
1276  int imod = (phi/32);
1277  int phi_local= phi-imod*32;
1278  if( phi_local >= 0 && phi_local <= 7 ){
1279  hvPhi = 1;
1280  }
1281  else if( phi_local >= 8 && phi_local <= 15 ){
1282  hvPhi = 2;
1283  }
1284  else if( phi_local >= 16 && phi_local <= 23 ){
1285  hvPhi = 3;
1286  }
1287  else if( phi_local >= 24 && phi_local <= 31 ){
1288  hvPhi = 4;
1289  }
1290  }
1291  else if( sampling == 3 ){
1292  //
1293  // Sampling 3 Outer Wheel (FT in [1,4])
1294  // ------------------------------------
1295  //
1296  int imod = (phi/32);
1297  int phi_local= phi-imod*32;
1298  if( phi_local >= 0 && phi_local <= 7 ){
1299  hvPhi = 1;
1300  }
1301  else if( phi_local >= 8 && phi_local <= 15 ){
1302  hvPhi = 2;
1303  }
1304  else if( phi_local >= 16 && phi_local <= 23 ){
1305  hvPhi = 3;
1306  }
1307  else if( phi_local >= 24 && phi_local <= 31 ){
1308  hvPhi = 4;
1309  }
1310  }
1311  }
1312  else if( bec < 0 ){
1313  // WHEEL-C
1314  if( sampling == 1 && abs(bec) == 2 ){
1315  // Sampling 1 OUTER Wheel (FT in [1,4])
1316  // ------------------------------------
1317  int imod=int(phi/8);
1318  int phi_local = phi-imod*8;
1319  if( phi_local == 0 || phi_local == 1){
1320  hvPhi = 4;
1321  }
1322  else if( phi_local == 2 || phi_local == 3){
1323  hvPhi = 3;
1324  }
1325  else if( phi_local == 4 || phi_local == 5){
1326  hvPhi = 2;
1327  }
1328  else if( phi_local == 6 || phi_local == 7){
1329  hvPhi = 1;
1330  }
1331  }
1332  if( sampling == 1 && abs(bec) == 3 ){
1333  // Sampling 1 INNER Wheel (FT in [1,8])
1334  // ------------------------------------
1335  //
1336  int imod=int(phi/8);
1337  int phi_local = phi - imod*8;
1338  hvPhi = 8-(phi_local);
1339  }
1340  else if( sampling == 2 && abs(bec) == 3 ){
1341  // Sampling 2 Inner Wheel (FT in [1,8])
1342  // ------------------------------------
1343  int imod=int(phi/8);
1344  int phi_local = phi-imod*8;
1345  hvPhi = 8-(phi_local);
1346  }
1347  else if( sampling == 2 && abs(bec) == 2 ){
1348  // Sampling 2 Outer Wheel (FT in [1,4])
1349  // ------------------------------------
1350  int imod = (phi/32);
1351  int phi_local= phi-imod*32;
1352  if( phi_local >= 0 && phi_local <= 7 ){
1353  hvPhi = 4;
1354  }
1355  else if( phi_local >= 8 && phi_local <= 15 ){
1356  hvPhi = 3;
1357  }
1358  else if( phi_local >= 16 && phi_local <= 23 ){
1359  hvPhi = 2;
1360  }
1361  else if( phi_local >= 24 && phi_local <= 31 ){
1362  hvPhi = 1;
1363  }
1364  }
1365  else if( sampling == 3 ){
1366  // Sampling 3 Outer Wheel (FT in [1,4])
1367  // ------------------------------------
1368  int imod = (phi/32);
1369  int phi_local= phi-imod*32;
1370  if( phi_local >= 0 && phi_local <= 7 ){
1371  hvPhi = 4;
1372  }
1373  else if( phi_local >= 8 && phi_local <= 15 ){
1374  hvPhi = 3;
1375  }
1376  else if( phi_local >= 16 && phi_local <= 23 ){
1377  hvPhi = 2;
1378  }
1379  else if( phi_local >= 24 && phi_local <= 31 ){
1380  hvPhi = 1;
1381  }
1382  }
1383  }
1384  }
1385 
1386  else if( abs(bec)==20){
1387  // HEC detector
1388  //------------
1389  // Note: not used because we use the 32 modules instead
1390  hvPhi = 0;
1391  }
1392  else if( abs(bec)==40){
1393  // FCAL detector
1394  //------------
1395  // Note: not used
1396  hvPhi = 0;
1397  }
1398  //ATH_MSG_DEBUG("Closing getCellPhiSector ...." );
1399  return hvPhi;
1400 }

◆ getElectrodeInCell()

void LArHVIdMapping::getElectrodeInCell ( const Identifier &  offId,
std::vector< HWIdentifier > &  elecId 
) const

Definition at line 113 of file LArHVIdMapping.cxx.

115 {//Start of getCellElectrodeIDvec
116  //ATH_MSG_VERBOSE("Entering getElectrodeInCell( offlineId ) " );
117 
118  // Get HV fields from offline fields
119  //===================================
120  int Detector = -1;
121  int Side = -9;
122  int iGapMax = -1;
123  if( m_caloHelper->is_em( offId ) ){
124  const int sampl = m_emHelper->sampling( offId );
125  const int bec = m_emHelper->barrel_ec( offId);
126  if( bec > 0 ){
127  Side = 0;}
128  else{Side = 1;}
129  if( m_caloHelper->is_em_barrel(offId) && sampl != 0 ){
130  // EMB
131  Detector = 0;
132  iGapMax = 1;
133  }
134  if( m_caloHelper->is_em_barrel(offId) && sampl == 0 ){
135  // EMBPS
136  Detector = 1;
137  iGapMax = 0;
138  }
139  if( m_caloHelper->is_em_endcap(offId) && sampl != 0 ){
140  // EMEC
141  Detector = 2;
142  iGapMax = 1;
143  }
144  if( m_caloHelper->is_em_endcap(offId) && sampl == 0 ){
145  // EMECPS
146  Detector = 3;
147  iGapMax = 0;
148  }
149  }
150  else if( m_caloHelper->is_hec( offId ) ){
151  const int bec = m_hecHelper->pos_neg(offId);
152  if( bec > 0 ){
153  Side = 0;}
154  else{Side = 1;}
155  Detector = 4;
156  iGapMax = 3;
157  }
158  else if( m_caloHelper->is_fcal( offId ) ){
159  const int bec = m_fcalHelper->pos_neg(offId);
160  Detector = 5;
161  iGapMax = 3;
162  if( bec > 0 ){
163  Side = 0;}
164  else{Side = 1;}
165  }
166 
167  // ------------------------------------------------------------
168  // Get cell localisation information in terms of HV description
169  // ------------------------------------------------------------
170  const int Module = getCellModule( offId );
171  const int EtaBin = getCellEtaSector( offId );
172  const int PhiBin = getCellPhiSector( offId );
173  const int elecmin = getCellElectrodeMinMax(offId).first;
174  const int elecmax = getCellElectrodeMinMax(offId).second;
175  // commented out, until proper messaging will be added
176  /*
177  ATH_MSG_DEBUG("[getArHVLineID] ElectrodeId=["
178  << Detector << "."
179  << Side << "."
180  << Module << "."
181  << PhiBin << "."
182  << EtaBin << ".gap_max="
183  << iGapMax << ".min="
184  << elecmin << ".max="
185  << elecmax << "]" );
186  */
187  for( int ielec=elecmin; ielec<elecmax+1; ielec++){
188  for( int iGap=0; iGap<iGapMax+1; iGap++){
189  const HWIdentifier electrodeId =
190  m_electrodeHelper->ElectrodeId(Detector,Side,Module,PhiBin,EtaBin,iGap,ielec);
191  electrodeIdVec.push_back(electrodeId);
192  }
193  }
194  //ATH_MSG_DEBUG("vector size = " << electrodeIdVec.size() );
195 }

◆ getHVLineInCell()

void LArHVIdMapping::getHVLineInCell ( const Identifier &  offId,
std::vector< HWIdentifier > &  hvlineId 
) const

Returns a vector<HVLineID> given an input offlineID.

Definition at line 207 of file LArHVIdMapping.cxx.

209 {//Start of getHVLineInCell
210  //ATH_MSG_VERBOSE("Entering getHVLineInCell( offlineId ) " );
211 
212  hvlineIdVec.clear();
213 
214  // Get HV fields from offline fields
215  //===================================
216  int Detector = -1;
217  int Side = -9;
218  int iGapMax = 0;
219  if( m_caloHelper->is_em( offId ) ){
220  const int sampl = m_emHelper->sampling( offId );
221  const int bec = m_emHelper->barrel_ec( offId);
222  if( bec > 0 ){
223  Side = 0;}
224  else{Side = 1;
225  }
226  if( m_caloHelper->is_em_barrel(offId) && sampl != 0 ){
227  // EMB
228  Detector = 0;
229  iGapMax = 1;
230  }
231  if( m_caloHelper->is_em_barrel(offId) && sampl == 0 ){
232  // EMBPS
233  Detector = 1;
234  iGapMax = 1;
235  }
236  if( m_caloHelper->is_em_endcap(offId) && sampl != 0 ){
237  // EMEC
238  Detector = 2;
239  iGapMax = 1;
240  }
241  if( m_caloHelper->is_em_endcap(offId) && sampl == 0 ){
242  // EMECPS
243  Detector = 3;
244  iGapMax = 0;
245  }
246  }
247  else if( m_caloHelper->is_hec( offId ) ){
248  const int bec = m_hecHelper->pos_neg(offId);
249  if( bec > 0 ){
250  Side = 0;}
251  else{Side = 1;}
252  Detector = 4;
253  iGapMax = 3;
254  }
255  else if( m_caloHelper->is_fcal( offId ) ){
256  const int bec = m_fcalHelper->pos_neg(offId);
257  if( bec > 0 )
258  { Side = 0;}
259  else{Side = 1;}
260  Detector = 5;
261  iGapMax = 3;
262  }
263 
264  //ATH_MSG_DEBUG("[getHVLineInCell] identified detector det="
265  // << Detector << " (0=EMB, 1=EMBPS, 2=EMEC, 3=EMECPS, 4=HEC 5=FCAL)"
266  // );
267 
268 
269  // ------------------------------------------------------------
270  // Get cell localisation information in terms of HV description
271  // ------------------------------------------------------------
272  const int Module = getCellModule( offId );
273  const int EtaBin = getCellEtaSector( offId );
274  const int PhiBin = getCellPhiSector( offId );
275  const int elecmin = getCellElectrodeMinMax(offId).first;
276  const int elecmax = getCellElectrodeMinMax(offId).second;
277  for( int ielec=elecmin; ielec<elecmax+1; ielec++){
278  // Loop over electrodes in cell
279  /*
280  ATH_MSG_VERBOSE("[getHVLineInCell] defining electrodeId: [det="
281  << Detector << " sid="
282  << Side << " mod="
283  << Module << " phi="
284  << PhiBin << " eta="
285  << EtaBin << " ielec="
286  << ielec << "]"
287  );
288  */
289  for( int iGap=0; iGap<iGapMax+1; iGap++){
290  // Loop over gaps
291  const HWIdentifier electrodeId =
292  m_electrodeHelper->ElectrodeId(Detector,Side,Module,PhiBin,EtaBin,iGap,ielec);
293  std::map<HWIdentifier,HWIdentifier>::const_iterator elecIt =
294  m_electrode_hvline_map.find(electrodeId);
295  if(elecIt != m_electrode_hvline_map.end()){
296  // found corresponding HVline
297  HWIdentifier hvlineId = (elecIt)->second;
298 
299  // commented out, until proper messaging will be added
300  /*
301  const int dete = m_electrodeHelper->detector(electrodeId);
302  const int side = m_electrodeHelper->zside(electrodeId);
303  const int modu = m_electrodeHelper->module(electrodeId);
304  const int hvph = m_electrodeHelper->hv_phi(electrodeId);
305  const int hvet = m_electrodeHelper->hv_eta(electrodeId);
306  const int hvga = m_electrodeHelper->gap(electrodeId);
307  const int elec = m_electrodeHelper->electrode(electrodeId);
308  int part1 = m_hvlineHelper->partition(hvlineId);
309  int canl1 = m_hvlineHelper->can_line(hvlineId);
310  int cann1 = m_hvlineHelper->can_node(hvlineId);
311  int hvli1 = m_hvlineHelper->hv_line(hvlineId);
312 
313  if (msgLvl(MSG::DEBUG)) {
314  msg(MSG::DEBUG) << "[getHVLineInCell] input ElectrodeId=["
315  << dete << "." << side << "." << modu << "." << hvph
316  << "." << hvet << "." << hvga << "." << elec << "]"
317  << " corresponding hvlineID=["
318  << part1 << "." << canl1 << "."
319  << cann1 << "." << hvli1 << "] "
320  << endmsg;
321  }
322  */
323  if( hvlineIdVec.empty() ){
324  //ATH_MSG_DEBUG("[getHVLineInCell] -> first fill of vector..." );
325  hvlineIdVec.push_back(hvlineId);
326  }
327  else{
328  bool foundHvId = false;
329  std::vector<HWIdentifier>::const_iterator hv = hvlineIdVec.begin();
330  std::vector<HWIdentifier>::const_iterator hvEnd = hvlineIdVec.end();
331  for(; hv!=hvEnd;++hv){
332  HWIdentifier hvRef = *hv;
333  // commented out, until proper messaging will be added
334  /*
335  int part = m_hvlineHelper->partition(hvRef);
336  int canl = m_hvlineHelper->can_line(hvRef);
337  int cann = m_hvlineHelper->can_node(hvRef);
338  int hvli = m_hvlineHelper->hv_line(hvRef);
339 
340  ATH_MSG_DEBUG("[getHVLineInCell] -> in loop : hvRef=["
341  << part << "." << canl << "."
342  << cann << "." << hvli << "] "
343  );
344  */
345  if( hvlineId == hvRef ){
346  foundHvId = true;
347  //ATH_MSG_DEBUG("[getHVLineInCell] -> BREAK !" );
348  break;
349  }
350  }
351  if( !foundHvId ){
352  hvlineIdVec.push_back(hvlineId);
353  /*
354  ATH_MSG_DEBUG("[getHVLineInCell] -> new HV line added"
355  << "=["
356  << part1 << "." << canl1 << "."
357  << cann1 << "." << hvli1 << "] size of vector="
358  << hvlineIdVec.size()
359  );
360  */
361  }
362  else{
363  /*
364  ATH_MSG_DEBUG("[getHVLineInCell] -> HV line already IN"
365  << "=["
366  << part1 << "." << canl1 << "."
367  << cann1 << "." << hvli1 << "] size of vector="
368  << hvlineIdVec.size()
369  );
370  */
371  }
372  }
373  }
374  else{
375  /*
376  msg(MSG::WARNING) << "[getHVLineInCell] couldnot find the electrodeID in map ["
377  << Detector << " Sid="
378  << Side << " Mod="
379  << Module << " phi="
380  << PhiBin << " eta="
381  << EtaBin << " Gap="
382  << iGap << " elec_min="
383  << elecmin <<" elec_max="
384  << elecmax << "]"
385  << endmsg;
386  */
387  }
388  } // Loop over gaps
389  }// Loop over electrodes in cell
390  //ATH_MSG_DEBUG("vector size = " << hvlineIdVec.size() );
391 }

◆ getLArElectrodeIDvec()

const std::vector< HWIdentifier > & LArHVIdMapping::getLArElectrodeIDvec ( HWIdentifier &  hvlineId) const

Return a vector of LArElectrodeID corresponding to a given LArHVLineID.

Definition at line 83 of file LArHVIdMapping.cxx.

85 {// Start of getLArElectrodeIdvec()
86  //ATH_MSG_VERBOSE("Entering getLArElectrodeIDvec( hvlineId )" );
87  std::map<HWIdentifier,std::vector<HWIdentifier> >::const_iterator elecIt=m_hvline_electrode_map.find(hvlineId);
88  if( elecIt != m_hvline_electrode_map.end()){
89  return (elecIt)->second;
90  }
91  else{
92  // commented out, until proper messaging will be added
93  /*
94  int part = m_hvlineHelper->partition(hvlineId);
95  int canl = m_hvlineHelper->can_line(hvlineId);
96  int cann = m_hvlineHelper->can_node(hvlineId);
97  int hvli = m_hvlineHelper->hv_line(hvlineId);
98  msg(MSG::WARNING) << "LArHVCablingSvc: getLArElectrodeIDvec didnot find electrode to hvline ["
99  << part << "." << canl << "." << cann << "." << hvli << "]" << endmsg;
100  */
101  return(m_invalid);
102  }
103  //return m_hvmapHelper->getLArElectrodeIDvec( hvlineId );
104 }

◆ getLArHVLineID()

const HWIdentifier LArHVIdMapping::getLArHVLineID ( HWIdentifier &  electrodeId) const

Return the LArHVLineID corresponding to a given LArElectrodeId.

Definition at line 22 of file LArHVIdMapping.cxx.

24 {
25 
26 
27  std::map<HWIdentifier,HWIdentifier>::const_iterator elecIt = m_electrode_hvline_map.find(electrodeId);
28  if(elecIt != m_electrode_hvline_map.end()) {
29  HWIdentifier hvlineId = (elecIt)->second;
30  // commented out, until proper messaging will be added
31  /*
32  if (msgLvl(MSG::DEBUG)) {
33  const int dete = m_electrodeHelper->detector(electrodeId);
34  const int side = m_electrodeHelper->zside(electrodeId);
35  const int modu = m_electrodeHelper->module(electrodeId);
36  const int hvph = m_electrodeHelper->hv_phi(electrodeId);
37  const int hvet = m_electrodeHelper->hv_eta(electrodeId);
38  const int hvga = m_electrodeHelper->gap(electrodeId);
39  const int elec = m_electrodeHelper->electrode(electrodeId);
40  const int part = m_hvlineHelper->partition(hvlineId);
41  const int canl = m_hvlineHelper->can_line(hvlineId);
42  const int cann = m_hvlineHelper->can_node(hvlineId);
43  const int hvli = m_hvlineHelper->hv_line(hvlineId);
44  msg(MSG::DEBUG) << "[getLArHVLineID] input ElectrodeId=["
45  << dete << "." << side << "." << modu << "." << hvph
46  << "." << hvet << "." << hvga << "." << elec << "]"
47  << " corresponding hvlineID=["
48  << part << "." << canl << "." << cann << "." << hvli << "]... OK "
49  << endmsg;
50  }//end if debug
51  */
52  return hvlineId;
53  }
54  else {
55  // commented out, until the proper messaging will be added
56  /*
57  int dete = m_electrodeHelper->detector(electrodeId);
58  int side = m_electrodeHelper->zside(electrodeId);
59  int modu = m_electrodeHelper->module(electrodeId);
60  int hvph = m_electrodeHelper->hv_phi(electrodeId);
61  int hvet = m_electrodeHelper->hv_eta(electrodeId);
62  int hvga = m_electrodeHelper->gap(electrodeId);
63  int elec = m_electrodeHelper->electrode(electrodeId);
64 
65  int part = m_hvlineHelper->partition(invalidId);
66  int canl = m_hvlineHelper->can_line(invalidId);
67  int cann = m_hvlineHelper->can_node(invalidId);
68  int hvli = m_hvlineHelper->hv_line(invalidId);
69  ATH_MSG_WARNING( "[getLArHVLineID] NO MAP for ElectrodeId=["
70  << dete << "." << side << "." << modu << "." << hvph
71  << "." << hvet << "." << hvga << "." << elec << "] returning ["
72  << part << "." << canl << "." << cann << "." << hvli << "]... OK ");
73  */
74  HWIdentifier invalidId = m_hvlineHelper->HVLineId(0,0,0,0);
75  return (invalidId);
76 
77  //return m_hvmapHelper->getLArHVLineID( electrodeId ) ;
78  }
79  // if the map exists, use the mapping object
80 }

Friends And Related Function Documentation

◆ LArHVIdMappingAlg

friend class LArHVIdMappingAlg
friend

Definition at line 23 of file LArHVIdMapping.h.

Member Data Documentation

◆ m_caloHelper

const CaloCell_ID* LArHVIdMapping::m_caloHelper
private

Definition at line 57 of file LArHVIdMapping.h.

◆ m_electrode_hvline_map

std::map<HWIdentifier,HWIdentifier> LArHVIdMapping::m_electrode_hvline_map
private

Definition at line 64 of file LArHVIdMapping.h.

◆ m_electrodeHelper

const LArElectrodeID* LArHVIdMapping::m_electrodeHelper
private

Definition at line 62 of file LArHVIdMapping.h.

◆ m_emHelper

const LArEM_ID* LArHVIdMapping::m_emHelper
private

Definition at line 58 of file LArHVIdMapping.h.

◆ m_fcalHelper

const LArFCAL_ID* LArHVIdMapping::m_fcalHelper
private

Definition at line 60 of file LArHVIdMapping.h.

◆ m_hecHelper

const LArHEC_ID* LArHVIdMapping::m_hecHelper
private

Definition at line 59 of file LArHVIdMapping.h.

◆ m_hvline_electrode_map

std::map<HWIdentifier,std::vector<HWIdentifier> > LArHVIdMapping::m_hvline_electrode_map
private

Definition at line 65 of file LArHVIdMapping.h.

◆ m_hvlineHelper

const LArHVLineID* LArHVIdMapping::m_hvlineHelper
private

Definition at line 61 of file LArHVIdMapping.h.

◆ m_invalid

const std::vector<HWIdentifier> LArHVIdMapping::m_invalid
private

Definition at line 66 of file LArHVIdMapping.h.

The documentation for this class was generated from the following files:
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
LArEM_Base_ID::phi
int phi(const Identifier id) const
return phi according to :
LArHVIdMapping::m_electrode_hvline_map
std::map< HWIdentifier, HWIdentifier > m_electrode_hvline_map
Definition: LArHVIdMapping.h:64
LArHVLineID::HVLineId
HWIdentifier HVLineId(int part, int canline, int cannode, int line) const
Create an HighVoltage line identifier from fields.
Definition: LArHVLineID.h:216
LArHEC_Base_ID::eta
int eta(const Identifier id) const
return eta [0,9] outer part [0,3] inner part
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
LArHVIdMapping::getCellEtaSector
int getCellEtaSector(const Identifier &offId) const
Definition: LArHVIdMapping.cxx:720
CaloCell_ID::em_idHelper
const LArEM_ID * em_idHelper() const
access to EM idHelper
Definition: CaloCell_ID.h:63
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
ParticleGun_SamplingFraction.bec
int bec
Definition: ParticleGun_SamplingFraction.py:89
LArHVIdMapping::m_hvline_electrode_map
std::map< HWIdentifier, std::vector< HWIdentifier > > m_hvline_electrode_map
Definition: LArHVIdMapping.h:65
LArFCAL_Base_ID::pos_neg
int pos_neg(const Identifier id) const
pos_neg : +/- 2 (A/C side)
LArHVIdMapping::m_hecHelper
const LArHEC_ID * m_hecHelper
Definition: LArHVIdMapping.h:59
CaloCell_Base_ID::is_em_endcap
bool is_em_endcap(const Identifier id) const
test if the id belongs to the EM Endcap
LArElectrodeID::ElectrodeId
HWIdentifier ElectrodeId(int det, int side, int mod, int phi, int eta, int gap, int elec) const
Create an Electrode identifier from fields.
Definition: LArElectrodeID.h:306
LArHVIdMapping::m_electrodeHelper
const LArElectrodeID * m_electrodeHelper
Definition: LArHVIdMapping.h:62
LArHVIdMapping::m_fcalHelper
const LArFCAL_ID * m_fcalHelper
Definition: LArHVIdMapping.h:60
LArHVIdMapping::getCellModule
int getCellModule(const Identifier &offId) const
returns the Module of a given offId
Definition: LArHVIdMapping.cxx:398
LArFCAL_Base_ID::module
int module(const Identifier id) const
module [1,3]
LArEM_Base_ID::region
int region(const Identifier id) const
return region according to :
LArEM_Base_ID::sampling
int sampling(const Identifier id) const
return sampling according to :
HWIdentifier
Definition: HWIdentifier.h:13
CaloCell_Base_ID::is_hec
bool is_hec(const Identifier id) const
test if the id belongs to the HEC
AtlasDetectorID::dictionaryVersion
virtual std::string dictionaryVersion(void) const override
Definition: AtlasDetectorID.cxx:347
LArEM_Base_ID::eta
int eta(const Identifier id) const
return eta according to :
CaloCell_ID::hec_idHelper
const LArHEC_ID * hec_idHelper() const
access to HEC idHelper
Definition: CaloCell_ID.h:69
LArHVIdMapping::m_caloHelper
const CaloCell_ID * m_caloHelper
Definition: LArHVIdMapping.h:57
LArFCAL_Base_ID::phi
int phi(const Identifier id) const
phi [0,15]
CaloCell_Base_ID::is_em
bool is_em(const Identifier id) const
test if the id belongs to LArEM
lumiFormat.i
int i
Definition: lumiFormat.py:92
CaloCell_Base_ID::is_fcal
bool is_fcal(const Identifier id) const
test if the id belongs to the FCAL - true also for MiniFCAL
LArHVIdMapping::m_hvlineHelper
const LArHVLineID * m_hvlineHelper
Definition: LArHVIdMapping.h:61
Side
Definition: WaferTree.h:36
LArHVIdMapping::m_emHelper
const LArEM_ID * m_emHelper
Definition: LArHVIdMapping.h:58
jet::CompCategory::Detector
@ Detector
Definition: UncertaintyEnum.h:19
CaloCell_Base_ID::is_em_barrel
bool is_em_barrel(const Identifier id) const
test if the id belongs to the EM barrel
LArEM_Base_ID::barrel_ec
int barrel_ec(const Identifier id) const
return barrel_ec according to :
LArHVIdMapping::getCellElectrodeMinMax
std::pair< int, int > getCellElectrodeMinMax(const Identifier &offId) const
Definition: LArHVIdMapping.cxx:1404
LArHVIdMapping::m_invalid
const std::vector< HWIdentifier > m_invalid
Definition: LArHVIdMapping.h:66
LArHEC_Base_ID::sampling
int sampling(const Identifier id) const
return sampling [0,3] (only 0 for supercells)
LArHVIdMapping::getCellPhiSector
int getCellPhiSector(const Identifier &offId) const
Definition: LArHVIdMapping.cxx:1088
LArHEC_Base_ID::pos_neg
int pos_neg(const Identifier id) const
return pos_neg -2 (C side) or 2 (A side)
LArHEC_Base_ID::region
int region(const Identifier id) const
return region [0,1]
CaloCell_ID::fcal_idHelper
const LArFCAL_ID * fcal_idHelper() const
access to FCAL idHelper
Definition: CaloCell_ID.h:75
LArHEC_Base_ID::phi
int phi(const Identifier id) const
return phi[0,63] outer part [0,31] inner part
Generated on Sun Jun 30 2024 21:50:26 for ATLAS Offline Software by   doxygen 1.8.18