PPM crate/module/channel to eta/phi/layer mappings. More...

#include <PpmMappingTool.h>

Inheritance diagram for LVL1::PpmMappingTool:

Collaboration diagram for LVL1::PpmMappingTool:

Public Member Functions
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual bool	mapping (int crate, int module, int channel, double &eta, double &phi, int &layer) const override
	Return eta, phi and layer mapping for given crate/module/channel.
virtual bool	mapping (double eta, double phi, int layer, int &crate, int &module, int &channel) const override
	Return crate, module and channel mapping for given eta/phi/layer.

Private Types
typedef std::pair< double, double >	Offsets
typedef std::array< ChannelCoordinate, s_channels >	CoordinateMap
typedef std::pair< Offsets, const CoordinateMap * >	ModuleInfo
typedef std::array< ModuleInfo, s_modules >	ModuleMap
typedef std::array< ModuleMap, s_crates >	CrateMap
typedef std::pair< unsigned int, unsigned int >	ChannelIds
typedef std::map< unsigned int, ChannelIds >	EtaPhiMap

Private Member Functions
void	setupMap ()
	Set up crate/module map.
void	setupInverseMap ()
	Set up eta/phi map.
void	addCoords (int nrows, int ncols, double etaGran, double phiGran, double etaOffset, double phiOffset, const int in, const int out, int incr, ChannelCoordinate::CaloLayer layer, CoordinateMap &coordMap)
	Add entries to a coordinate map.
void	addMods (int crate, int modOffset, int nrows, int ncols, double etaBase, double phiBase, double etaRange, double phiRange, const CoordinateMap *coordMap)
	Add a block of similar modules to a crate.
double	etaSim (const ChannelCoordinate &coord) const
	Correction for Had FCAL eta which is adjusted to EM value in TriggerTower.
unsigned int	etaPhiKey (double eta, double phi) const
	Simple eta/phi key.

Private Attributes
std::array< ModuleMap, s_crates >	m_crateInfo
	Pointer to crate/module map.
std::vector< std::unique_ptr< CoordinateMap > >	m_coordMaps
	Vector of CoordinateMaps.
EtaPhiMap	m_etaPhiMap
	Pointer to inverse map.

Static Private Attributes
static const int	s_crates = 8
static const int	s_modules = 16
static const int	s_channels = 64

Detailed Description

PPM crate/module/channel to eta/phi/layer mappings.

The inputs and crate layouts come from "Level-1 Calorimeter Trigger: Cable Mappings and Crate Layouts from Analogue Inputs to Processors" version 1.6. The input-output mapping comes from Steve Hillier's online decoder.

Author: Peter Faulkner

Definition at line 36 of file PpmMappingTool.h.

Member Typedef Documentation

◆ ChannelIds

typedef std::pair< unsigned int, unsigned int > LVL1::PpmMappingTool::ChannelIds

private

Definition at line 64 of file PpmMappingTool.h.

◆ CoordinateMap

typedef std::array< ChannelCoordinate, s_channels> LVL1::PpmMappingTool::CoordinateMap

private

Definition at line 59 of file PpmMappingTool.h.

◆ CrateMap

typedef std::array< ModuleMap, s_crates > LVL1::PpmMappingTool::CrateMap

private

Definition at line 62 of file PpmMappingTool.h.

◆ EtaPhiMap

typedef std::map< unsigned int, ChannelIds > LVL1::PpmMappingTool::EtaPhiMap

private

Definition at line 65 of file PpmMappingTool.h.

◆ ModuleInfo

typedef std::pair< Offsets, const CoordinateMap* > LVL1::PpmMappingTool::ModuleInfo

private

Definition at line 60 of file PpmMappingTool.h.

◆ ModuleMap

typedef std::array< ModuleInfo, s_modules > LVL1::PpmMappingTool::ModuleMap

private

Definition at line 61 of file PpmMappingTool.h.

◆ Offsets

typedef std::pair< double, double > LVL1::PpmMappingTool::Offsets

private

Definition at line 58 of file PpmMappingTool.h.

Member Function Documentation

◆ addCoords()

void LVL1::PpmMappingTool::addCoords	(	int	nrows,
		int	ncols,
		double	etaGran,
		double	phiGran,
		double	etaOffset,
		double	phiOffset,
		const int *	in,
		const int *	out,
		int	incr,
		ChannelCoordinate::CaloLayer	layer,
		CoordinateMap &	coordMap )

private

Add entries to a coordinate map.

Definition at line 414 of file PpmMappingTool.cxx.

{
  for (int row = 0; row < nrows; ++row) {
    const double phi = (double(row) + 0.5) * phiGran + phiOffset;
    for (int col = 0; col < ncols; ++col) {
      const double eta = (double(col) + 0.5) * etaGran + etaOffset;
      const int channel = out[in[row*ncols+col]-1] + incr;
      assert (channel < s_channels);
      coordMap[channel] = ChannelCoordinate(layer, eta, phi, etaGran, phiGran);
    }
  }
}

◆ addMods()

void LVL1::PpmMappingTool::addMods	(	int	crate,
		int	modOffset,
		int	nrows,
		int	ncols,
		double	etaBase,
		double	phiBase,
		double	etaRange,
		double	phiRange,
		const CoordinateMap *	coordMap )

private

Add a block of similar modules to a crate.

Definition at line 432 of file PpmMappingTool.cxx.

{
  assert (crate < static_cast<int>(m_crateInfo.size()));
  ModuleMap& modMap = m_crateInfo[crate];
  for (int row = 0; row < nrows; ++row) {
    for (int col = 0; col < ncols; ++col) {
      const int module = row*4 + col + modOffset;
      const double etaOffset = etaRange * double(col) + etaBase;
      const double phiOffset = phiRange * double(row) + phiBase;
      Offsets off(etaOffset, phiOffset);
      modMap[module] = ModuleInfo (off, coordMap);
    }
  }
}

◆ etaPhiKey()

unsigned int LVL1::PpmMappingTool::etaPhiKey	(	double	eta,
		double	phi ) const

private

Simple eta/phi key.

Definition at line 466 of file PpmMappingTool.cxx.

{
  const double etaOffsets[5] = { 0., 2.5, 3.1, 3.2, 4.9 };
  const double etaGrans[4]   = { 0.1, 0.2, 0.1, 0.425 };
  const double phiGrans[4]   = { M_PI/32., M_PI/16., M_PI/16., M_PI/8. };
  const int side = (eta < 0.) ? 0 : 1;
  int region = 0;
  int ieta   = 0;
  int iphi   = 0;
  const double absEta = fabs(eta);
  for (int i = 0; i < 4; ++i) {
    if (absEta < etaOffsets[i+1]) {
      region = i;
      ieta   = int((absEta - etaOffsets[i]) / etaGrans[i]);
      iphi   = int(phi / phiGrans[i]);
      break;
    }
  }
  unsigned int key = (side << 20) + (region << 16) + (ieta << 8) + iphi;
  return key;
}

◆ etaSim()

double LVL1::PpmMappingTool::etaSim ( const ChannelCoordinate & coord ) const

private

Correction for Had FCAL eta which is adjusted to EM value in TriggerTower.

Definition at line 452 of file PpmMappingTool.cxx.

{
  double eta = coord.eta();
  const ChannelCoordinate::CaloLayer layer = coord.layer();
  if (layer == ChannelCoordinate::FCAL2 || layer == ChannelCoordinate::FCAL3) {
    const double etaCorrection = coord.etaGranularity()/4.;
    if (layer == ChannelCoordinate::FCAL2) eta -= etaCorrection;
    else eta += etaCorrection;
  }
  return eta;
}

◆ finalize()

StatusCode LVL1::PpmMappingTool::finalize ( )

overridevirtual

Definition at line 30 of file PpmMappingTool.cxx.

{
  return StatusCode::SUCCESS;
}

◆ initialize()

StatusCode LVL1::PpmMappingTool::initialize ( )

overridevirtual

Definition at line 21 of file PpmMappingTool.cxx.

{
  msg(MSG::INFO) << "Initializing " << name() << endmsg;
  setupMap();
  setupInverseMap();
 
  return StatusCode::SUCCESS;
}

◆ mapping() [1/2]

bool LVL1::PpmMappingTool::mapping	(	double	eta,
		double	phi,
		int	layer,
		int &	crate,
		int &	module,
		int &	channel ) const

overridevirtual

Return crate, module and channel mapping for given eta/phi/layer.

Definition at line 65 of file PpmMappingTool.cxx.

{
  const unsigned int invalidChanId = s_crates*s_modules*s_channels;
 
  const unsigned int key = etaPhiKey(eta, phi);
  EtaPhiMap::const_iterator iter = m_etaPhiMap.find(key);
  if (iter == m_etaPhiMap.end()) {
    msg(MSG::WARNING) << "Invalid eta/phi: " << eta
                      << "/" << phi << endmsg;
    return false;
  }
  const ChannelIds& ids(iter->second);
  const unsigned int chanId = (layer == 0) ? ids.first : ids.second;
  if (chanId == invalidChanId) {
    msg(MSG::WARNING) << "Invalid ChanId - shouldn't happen" << endmsg;
    return false;
  }
  crate   = chanId / (s_channels * s_modules);
  module  = (chanId / s_channels) % s_modules;
  channel = chanId % s_channels;
  return true;
}

◆ mapping() [2/2]

bool LVL1::PpmMappingTool::mapping	(	int	crate,
		int	module,
		int	channel,
		double &	eta,
		double &	phi,
		int &	layer ) const

overridevirtual

Return eta, phi and layer mapping for given crate/module/channel.

Definition at line 37 of file PpmMappingTool.cxx.

{
  if (crate < 0 || crate >= s_crates || module < 0 || module >= s_modules ||
      channel < 0 || channel >= s_channels) return false;
 
  const ModuleMap& modMap = m_crateInfo[crate];
  const ModuleInfo& modInfo = modMap[module];
  const double etaOffset     = modInfo.first.first;
  const double phiOffset     = modInfo.first.second;
  const CoordinateMap* currentMap    = modInfo.second;
 
  if (!currentMap) return false;
 
  // Set the output
 
  ChannelCoordinate relCoord = (*currentMap)[channel];
  if (relCoord.layer() == ChannelCoordinate::NONE) return false;
 
  relCoord.setEta(relCoord.eta() + etaOffset);
  eta   = etaSim(relCoord);
  phi   = relCoord.phi() + phiOffset;
  layer = (relCoord.layer() == ChannelCoordinate::EM) ? 0 : 1;
  return true;
}

◆ setupInverseMap()

void LVL1::PpmMappingTool::setupInverseMap ( )

private

Set up eta/phi map.

Definition at line 383 of file PpmMappingTool.cxx.

{
  const unsigned int invalidChanId = s_crates*s_modules*s_channels;
 
  for (int cr = 0; cr < s_crates; ++cr) {
    for (int mod = 0; mod < s_modules; ++mod) {
      for (int chan = 0; chan < s_channels; ++chan) {
        double tmpEta, tmpPhi;
    int tmpLayer;
    if (mapping(cr, mod, chan, tmpEta, tmpPhi, tmpLayer)) {
      const unsigned int key    = etaPhiKey(tmpEta, tmpPhi);
      const unsigned int chanId = (cr * s_modules + mod) * s_channels + chan;
      EtaPhiMap::iterator iter = m_etaPhiMap.find(key);
      if (iter == m_etaPhiMap.end()) {
        ChannelIds ids(invalidChanId, invalidChanId);
        if (tmpLayer == 0) ids.first  = chanId;
            else               ids.second = chanId;
        m_etaPhiMap.insert(std::make_pair(key, ids));
          } else {
        ChannelIds& ids(iter->second);
        if (tmpLayer == 0) ids.first  = chanId;
            else               ids.second = chanId;
          }
        }
      }
    }
  }
}

◆ setupMap()

void LVL1::PpmMappingTool::setupMap ( )

private

Set up crate/module map.

Definition at line 91 of file PpmMappingTool.cxx.

{
  // Input to Output channel mappings.
  // Inputs are numbered 1-16 (x4) and outputs 0-63
  // There are four output sets obtained by adding 0,4,8,12 to out
 
  //          input =    1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16
  const int out[16] = { 19,51,35, 3,18,50,34, 2,17,49,33, 1,16,48,32, 0 };
 
  // Mapping types.
  //
  // Type 1.
  // Eta -2.4 to 2.4.  Inputs for 4x4 block
  //
  //   +----+----+----+----+
  //   | 16 | 15 | 12 | 11 |
  //   +----+----+----+----+
  //   | 13 | 14 |  9 | 10 |
  //   +----+----+----+----+ PI/8
  //   |  4 |  3 |  8 |  7 |
  //   +----+----+----+----+
  //   |  1 |  2 |  5 |  6 |
  //   +----+----+----+----+
  //            0.4
 
  const int in1[16] = { 16,15,12,11,13,14, 9,10, 4, 3, 8, 7, 1, 2, 5, 6 };
 
  // Type 2.
  // Eta 2.4 to 2.9.  4x1 plus 2x2 block
  //
  //   +----+--------+--------+
  //   | 16 |        |        |
  //   +----+   15   |   12   |
  //   | 13 |        |        |
  //   +----+--------+--------+ PI/8
  //   |  4 |        |        |
  //   +----+    3   |    8   |
  //   |  1 |        |        |
  //   +----+--------+--------+
  //              0.5
 
  const int in2a[4] = { 16,13, 4, 1 };
  const int in2b[4] = { 15,12, 3, 8 };
 
  // Type 3.
  // Eta -2.9 to -2.4.  2x2 plus 4x1 block
  //
  //   +--------+--------+----+
  //   |        |        | 11 |
  //   |   16   |   12   +----+
  //   |        |        | 10 |
  //   +--------+--------+----+ PI/8
  //   |        |        |  7 |
  //   |    4   |    8   +----+
  //   |        |        |  6 |
  //   +--------+--------+----+
  //              0.5
 
  const int in3a[4] = { 16,12, 4, 8 };
  const int in3b[4] = { 11,10, 7, 6 };
 
  // Type 4.
  // Eta 2.9 to 3.2 and -3.2 to -2.9.  4x1 plus 4x1
  //          +                 -
  //   +--------+----+   +----+--------+
  //   |        |    |   |    |        |
  //   |   16   | 15 |   | 16 |   15   |
  //   |        |    |   |    |        |
  //   +--------+----+   +----+--------+
  //   |        |    |   |    |        |
  //   |   12   | 11 |   | 12 |   11   |
  //   |        |    |   |    |        |
  //   +--------+----+   +----+--------+ PI/4
  //   |        |    |   |    |        |
  //   |    8   |  7 |   |  8 |    7   |
  //   |        |    |   |    |        |
  //   +--------+----+   +----+--------+
  //   |        |    |   |    |        |
  //   |    4   |  3 |   |  4 |    3   |
  //   |        |    |   |    |        |
  //   +--------+----+   +----+--------+
  //         0.3               0.3
 
  const int in4a[4]  = { 16,12, 8, 4 };
  const int in4b[4]  = { 15,11, 7, 3 };
 
  // Type 5.
  // Eta 3.2 to 4.9 and -4.9 to -3.2 EM FCAL.  4x4
  //
  //   +----+----+----+----+
  //   |    |    |    |    |
  //   | 16 | 15 | 14 | 13 |
  //   |    |    |    |    |
  //   +----+----+----+----+
  //   |    |    |    |    |
  //   | 12 | 11 | 10 |  9 |
  //   |    |    |    |    |
  //   +----+----+----+----+ PI/2
  //   |    |    |    |    |
  //   |  8 |  7 |  6 |  5 |
  //   |    |    |    |    |
  //   +----+----+----+----+
  //   |    |    |    |    |
  //   |  4 |  3 |  2 |  1 |
  //   |    |    |    |    |
  //   +----+----+----+----+
  //            1.7
 
  const int in5[16]  = { 16,15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
 
  // Type 6.
  // Eta 3.2 to 4.9 and -4.9 to -3.2 Had FCAL2 and FCAL3.  4x2 plus 4x2
  // NB. FCAL2 and FCAL3 have the same eta/phi coordinates.
  //          FCAL2                 FCAL3
  //   +--------+--------+   +--------+--------+
  //   |        |        |   |        |        |
  //   |   16   |   14   |   |   15   |   13   |
  //   |        |        |   |        |        |
  //   +--------+--------+   +--------+--------+
  //   |        |        |   |        |        |
  //   |   12   |   10   |   |   11   |    9   |
  //   |        |        |   |        |        |
  //   +--------+--------+   +--------+--------+ PI/2
  //   |        |        |   |        |        |
  //   |    8   |    6   |   |    7   |    5   |
  //   |        |        |   |        |        |
  //   +--------+--------+   +--------+--------+
  //   |        |        |   |        |        |
  //   |    4   |    2   |   |    3   |    1   |
  //   |        |        |   |        |        |
  //   +--------+--------+   +--------+--------+
  //           1.7                   1.7
 
  const int in6a[8]  = { 16,14,12,10, 8, 6, 4, 2 };
  const int in6b[8]  = { 15,13,11, 9, 7, 5, 3, 1 };
  
  // Construct coordinate maps for each module type
  // Four blocks of each type make up the complete map
 
  for (int i = 0; i < 12; ++i) m_coordMaps.push_back(std::make_unique<CoordinateMap>());
  for (int block = 0; block < 4; ++block) {
    const int incr = block * 4;
    std::vector<std::unique_ptr<CoordinateMap> >::iterator pos = m_coordMaps.begin();
 
    // Map 0 : Type 1 EM
    addCoords(4,4,0.1,M_PI/32.,0.,block*M_PI/8.,in1,out,incr,
              ChannelCoordinate::EM, **pos);
    ++pos;
 
    // Map 1 : Type 1 Had
    addCoords(4,4,0.1,M_PI/32.,0.,block*M_PI/8.,in1,out,incr,
              ChannelCoordinate::HAD, **pos);
    ++pos;
 
    // Map 2 : Type 2 EM
    addCoords(4,1,0.1,M_PI/32.,0.0,block*M_PI/8.,in2a,out,incr,
              ChannelCoordinate::EM, **pos);
    addCoords(2,2,0.2,M_PI/16.,0.1,block*M_PI/8.,in2b,out,incr,
              ChannelCoordinate::EM, **pos);
    ++pos;
 
    // Map 3 : Type 2 Had
    addCoords(4,1,0.1,M_PI/32.,0.0,block*M_PI/8.,in2a,out,incr,
              ChannelCoordinate::HAD, **pos);
    addCoords(2,2,0.2,M_PI/16.,0.1,block*M_PI/8.,in2b,out,incr,
              ChannelCoordinate::HAD, **pos);
    ++pos;
 
    // Map 4 : Type 3 EM
    addCoords(2,2,0.2,M_PI/16.,0.0,block*M_PI/8.,in3a,out,incr,
              ChannelCoordinate::EM, **pos);
    addCoords(4,1,0.1,M_PI/32.,0.4,block*M_PI/8.,in3b,out,incr,
              ChannelCoordinate::EM, **pos);
    ++pos;
 
    // Map 5 : Type 3 Had
    addCoords(2,2,0.2,M_PI/16.,0.0,block*M_PI/8.,in3a,out,incr,
              ChannelCoordinate::HAD, **pos);
    addCoords(4,1,0.1,M_PI/32.,0.4,block*M_PI/8.,in3b,out,incr,
              ChannelCoordinate::HAD, **pos);
    ++pos;
 
    // Map 6 : Type 4 EM positive eta
    addCoords(4,1,0.2,M_PI/16.,0.0,block*M_PI/4.,in4a,out,incr,
              ChannelCoordinate::EM, **pos);
    addCoords(4,1,0.1,M_PI/16.,0.2,block*M_PI/4.,in4b,out,incr,
              ChannelCoordinate::EM, **pos);
    ++pos;
 
    // Map 7 : Type 4 Had positive eta
    addCoords(4,1,0.2,M_PI/16.,0.0,block*M_PI/4.,in4a,out,incr,
              ChannelCoordinate::HAD, **pos);
    addCoords(4,1,0.1,M_PI/16.,0.2,block*M_PI/4.,in4b,out,incr,
              ChannelCoordinate::HAD, **pos);
    ++pos;
 
    // Map 8 : Type 4 EM negative eta
    addCoords(4,1,0.1,M_PI/16.,0.0,block*M_PI/4.,in4a,out,incr,
              ChannelCoordinate::EM, **pos);
    addCoords(4,1,0.2,M_PI/16.,0.1,block*M_PI/4.,in4b,out,incr,
              ChannelCoordinate::EM, **pos);
    ++pos;
 
    // Map 9 : Type 4 Had negative eta
    addCoords(4,1,0.1,M_PI/16.,0.0,block*M_PI/4.,in4a,out,incr,
              ChannelCoordinate::HAD, **pos);
    addCoords(4,1,0.2,M_PI/16.,0.1,block*M_PI/4.,in4b,out,incr,
              ChannelCoordinate::HAD, **pos);
    ++pos;
 
    // Map 10 : Type 5 EM FCAL
    addCoords(4,4,0.425,M_PI/8.,0.0,block*M_PI/2.,in5,out,incr,
              ChannelCoordinate::EM, **pos);
    ++pos;
 
    // Map 11 : Type 6 Had FCAL2 and FCAL3
    addCoords(4,2,0.85,M_PI/8.,0.0,block*M_PI/2.,in6a,out,incr,
              ChannelCoordinate::FCAL2, **pos);
    addCoords(4,2,0.85,M_PI/8.,0.0,block*M_PI/2.,in6b,out,incr,
              ChannelCoordinate::FCAL3, **pos);
  }
 
  // Fill crate map
 
  std::vector<std::unique_ptr<CoordinateMap> >::const_iterator pos = m_coordMaps.begin();
 
  // Map 0 : all of crates 0,1
  //         crate 2 modules 1,2,5,6,9,10,13,14
  //         crate 3 modules 2,3,6,7,10,11,14,15
  addMods(0,0,4,4, 0.0,0.0,0.4,M_PI/2.,pos->get());
  addMods(1,0,4,4,-1.6,0.0,0.4,M_PI/2.,pos->get());
  addMods(2,1,4,2, 1.6,0.0,0.4,M_PI/2.,pos->get());
  addMods(3,2,4,2,-2.4,0.0,0.4,M_PI/2.,pos->get());
  ++pos;
 
  // Map 1 : crate 4 modules 1,2,5,6,9,10,13,14
  //         crate 5 modules 2,3,6,7,10,11,14,15
  //         all of crates 6,7
  addMods(4,1,4,2, 1.6,0.0,0.4,M_PI/2.,pos->get());
  addMods(5,2,4,2,-2.4,0.0,0.4,M_PI/2.,pos->get());
  addMods(6,0,4,4, 0.0,0.0,0.4,M_PI/2.,pos->get());
  addMods(7,0,4,4,-1.6,0.0,0.4,M_PI/2.,pos->get());
  ++pos;
 
  // Map 2 : crate 2 modules 3,7,11,15
  addMods(2,3,4,1, 2.4,0.0,0.5,M_PI/2.,pos->get());
  ++pos;
 
  // Map 3 : crate 4 modules 3,7,11,15
  addMods(4,3,4,1, 2.4,0.0,0.5,M_PI/2.,pos->get());
  ++pos;
 
  // Map 4 : crate 3 modules 1,5,9,13
  addMods(3,1,4,1,-2.9,0.0,0.5,M_PI/2.,pos->get());
  ++pos;
 
  // Map 5 : crate 5 modules 1,5,9,13
  addMods(5,1,4,1,-2.9,0.0,0.5,M_PI/2.,pos->get());
  ++pos;
 
  // Map 6 : crate 2 modules 4,12
  addMods(2, 4,1,1, 2.9,0.0,0.3,M_PI,pos->get());
  addMods(2,12,1,1, 2.9,M_PI,0.3,M_PI,pos->get());
  ++pos;
 
  // Map 7 : crate 4 modules 4,12
  addMods(4, 4,1,1, 2.9,0.0,0.3,M_PI,pos->get());
  addMods(4,12,1,1, 2.9,M_PI,0.3,M_PI,pos->get());
  ++pos;
 
  // Map 8 : crate 3 modules 4,12
  addMods(3, 4,1,1,-3.2,0.0,0.3,M_PI,pos->get());
  addMods(3,12,1,1,-3.2,M_PI,0.3,M_PI,pos->get());
  ++pos;
 
  // Map 9 : crate 5 modules 4,12
  addMods(5, 4,1,1,-3.2,0.0,0.3,M_PI,pos->get());
  addMods(5,12,1,1,-3.2,M_PI,0.3,M_PI,pos->get());
  ++pos;
 
  // Map 10 : crate 4 module 0, crate 5 module 0
  addMods(4,0,1,1, 3.2,0.0,1.7,2*M_PI,pos->get());
  addMods(5,0,1,1,-4.9,0.0,1.7,2*M_PI,pos->get());
  ++pos;
 
  // Map 11 : crate 4 module 8, crate 5 module 8
  addMods(4,8,1,1, 3.2,0.0,1.7,2*M_PI,pos->get());
  addMods(5,8,1,1,-4.9,0.0,1.7,2*M_PI,pos->get());
}

Member Data Documentation

◆ m_coordMaps

std::vector<std::unique_ptr<CoordinateMap> > LVL1::PpmMappingTool::m_coordMaps

private

Vector of CoordinateMaps.

Definition at line 88 of file PpmMappingTool.h.

◆ m_crateInfo

std::array<ModuleMap, s_crates> LVL1::PpmMappingTool::m_crateInfo

private

Pointer to crate/module map.

Definition at line 86 of file PpmMappingTool.h.

◆ m_etaPhiMap

EtaPhiMap LVL1::PpmMappingTool::m_etaPhiMap

private

Pointer to inverse map.

Definition at line 90 of file PpmMappingTool.h.

◆ s_channels

const int LVL1::PpmMappingTool::s_channels = 64

staticprivate

Definition at line 55 of file PpmMappingTool.h.

◆ s_crates

const int LVL1::PpmMappingTool::s_crates = 8

staticprivate

Definition at line 53 of file PpmMappingTool.h.

◆ s_modules

const int LVL1::PpmMappingTool::s_modules = 16

staticprivate

Definition at line 54 of file PpmMappingTool.h.

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ ChannelIds

◆ CoordinateMap

◆ CrateMap

◆ EtaPhiMap

◆ ModuleInfo

◆ ModuleMap

◆ Offsets

Member Function Documentation

◆ addCoords()

◆ addMods()

◆ etaPhiKey()

◆ etaSim()

◆ finalize()

◆ initialize()

◆ mapping() [1/2]

◆ mapping() [2/2]

◆ setupInverseMap()

◆ setupMap()

Member Data Documentation

◆ m_coordMaps

◆ m_crateInfo

◆ m_etaPhiMap

◆ s_channels

◆ s_crates

◆ s_modules