Muon::nsw::MapperSTG Class Reference

#include <MapperSTG.h>

Collaboration diagram for Muon::nsw::MapperSTG:

Public Member Functions
	MapperSTG ()
virtual	~MapperSTG ()
uint16_t	nchannels (uint8_t channel_type, uint8_t sector_type, uint8_t feb_radius, uint8_t layer) const
uint16_t	channel_number (uint8_t channel_type, uint8_t sector_type, uint8_t feb_radius, uint8_t layer, uint16_t vmm, uint16_t vmm_chan) const
bool	vmm_info (uint8_t channel_type, uint8_t sector_type, uint8_t mod_radius, uint8_t layer, uint16_t channel_number, uint16_t &vmm, uint16_t &vmm_chan) const
bool	elink_info (uint8_t channel_type, uint8_t sector_type, uint8_t mod_radius, uint8_t layer, uint16_t channel_number, uint &elink) const
uint16_t	geoVmmToRocVmm (uint16_t geoVMM) const
uint16_t	AB_to_Athena_channel_number (uint8_t channel_type, uint8_t sector_type, uint8_t feb_radius, uint8_t layer, uint16_t channel_number) const
uint16_t	Athena_to_AB_channel_number (uint8_t channel_type, uint8_t sector_type, uint8_t feb_radius, uint8_t layer, uint16_t channel_number) const
uint16_t	NSWID_to_Athena_channel_number (uint8_t channel_type, uint8_t sector_type, uint8_t feb_radius, uint8_t layer, uint16_t channel_number, bool sideA) const
uint16_t	Athena_to_NSWID_channel_number (uint8_t channel_type, uint8_t sector_type, uint8_t feb_radius, uint8_t layer, uint16_t channel_number, bool sideA) const

Static Public Member Functions
static uint16_t	private_id (uint8_t channel_type, uint8_t sector_type, uint8_t feb_radius, uint8_t layer)

Detailed Description

Definition at line 17 of file MapperSTG.h.

Constructor & Destructor Documentation

MapperSTG()

Muon::nsw::MapperSTG::MapperSTG ( )

inline

Definition at line 20 of file MapperSTG.h.

{};

~MapperSTG()

virtual Muon::nsw::MapperSTG::~MapperSTG ( )

inlinevirtual

Definition at line 21 of file MapperSTG.h.

{};

Member Function Documentation

AB_to_Athena_channel_number()

uint16_t Muon::nsw::MapperSTG::AB_to_Athena_channel_number	(	uint8_t	channel_type,
		uint8_t	sector_type,
		uint8_t	feb_radius,
		uint8_t	layer,
		uint16_t	channel_number
	)		const

Definition at line 119 of file MapperSTG.cxx.

{
  // Convert an Adapter-Board channel number into ATHENA channel index.
 
  if (channel_number == 0) return channel_number; // invalid (e.g. case of disconnected channel)
 
  if (channel_type == OFFLINE_CHANNEL_TYPE_WIRE) {
    
    // AB:     wire#1 is on the gas-inlet side; right (left) hand side for pivot (confirm) wedges when looking from the IP.
    // Athena: wire#1 is on the left-hand side both for pivot and confirm wedges.
    bool isPivot = (sector_type == 0)^(layer < 4);
    if (isPivot) channel_number = nchannels(channel_type, sector_type, feb_radius, layer) - channel_number + 1;
 
  } else if (channel_type == OFFLINE_CHANNEL_TYPE_PAD) {
 
    // AB:     pad#1 is on left (right) hand side for even (odd) layers when looking from the IP (counting layers from 0).
    // Athena: pad#1 is on the right-hand side.
    uint16_t pid = private_id(channel_type, sector_type, feb_radius, layer);
    std::pair<uint16_t, uint16_t> pad_grid = s_stgc_pad_grid.at(pid);
 
    uint16_t padRow_AB  = (channel_number - 1)/pad_grid.second + 1;
    uint16_t padCol_AB  = (channel_number - 1)%pad_grid.second + 1;
    uint16_t padRow_ATH = pad_grid.first - padRow_AB + 1;
    uint16_t padCol_ATH = (layer%2==0) ? pad_grid.second - padCol_AB + 1 : padCol_AB; // layer is in [0,7]
      
    // Athena pad numbering assumes 18 eta rows (even if a quadruplet has less)
    channel_number = (padCol_ATH - 1)*18 + padRow_ATH;
  }
  
  return channel_number; 
}

Athena_to_AB_channel_number()

uint16_t Muon::nsw::MapperSTG::Athena_to_AB_channel_number	(	uint8_t	channel_type,
		uint8_t	sector_type,
		uint8_t	feb_radius,
		uint8_t	layer,
		uint16_t	channel_number
	)		const

Definition at line 153 of file MapperSTG.cxx.

{
  // Convert a channel index according to ATHENA numbering convention
  // into the Adapter-Board channel number.
  
  if (channel_number == 0) return channel_number; // invalid (e.g. case of disconnected channel)
 
  if (channel_type == OFFLINE_CHANNEL_TYPE_WIRE) {
    
    // AB:     wire#1 is on the gas-inlet side; right (left) hand side for pivot (confirm) wedges when looking from the IP.
    // Athena: wire#1 is on the left-hand side both for pivot and confirm wedges.
    bool isPivot = (sector_type == 0)^(layer < 4);
    if (isPivot) channel_number = nchannels(channel_type, sector_type, feb_radius, layer) - channel_number + 1;
  
  } else if (channel_type == OFFLINE_CHANNEL_TYPE_PAD) {
 
    // AB:     pad#1 is on left (right) hand side for even (odd) layers when looking from the IP (counting layers from 0).
    // Athena: pad#1 is on the right-hand side.
    uint16_t pid = private_id(channel_type, sector_type, feb_radius, layer);
    std::pair<uint16_t, uint16_t> pad_grid = s_stgc_pad_grid.at(pid);
    
    // Athena pad numbering assumes 18 eta rows (even if a quadruplet has less)
    uint16_t padRow_ATH = (channel_number - 1)%18 + 1;
    uint16_t padCol_ATH = (channel_number - 1)/18 + 1;
    uint16_t padRow_AB  = pad_grid.first - padRow_ATH + 1;
    uint16_t padCol_AB  = (layer%2==0) ? pad_grid.second - padCol_ATH + 1 : padCol_ATH;  // layer is in [0,7]
 
    channel_number = (padRow_AB - 1)*pad_grid.second + padCol_AB;
  }
 
  return channel_number;  
}

Athena_to_NSWID_channel_number()

uint16_t Muon::nsw::MapperSTG::Athena_to_NSWID_channel_number	(	uint8_t	channel_type,
		uint8_t	sector_type,
		uint8_t	feb_radius,
		uint8_t	layer,
		uint16_t	channel_number,
		bool	sideA
	)		const

Definition at line 222 of file MapperSTG.cxx.

{
  // Convert a channel index according to ATHENA numbering convention
  // into NSWID channel index.
 
  if (channel_number == 0) return channel_number; // invalid (e.g. case of disconnected channel)
 
  // In NSWID numbering wires and pads follow ATLAS phi. 
  if (channel_type == OFFLINE_CHANNEL_TYPE_WIRE) {
    
    // NSWID:  wire#1 is on the left (right) hand side for A-side (C-side) when looking from the IP.
    // Athena: wire#1 is on the left-hand side both for A- and C-side.
    if (!sideA) channel_number = nchannels(channel_type, sector_type, feb_radius, layer) - channel_number + 1;
 
  } else if (channel_type == OFFLINE_CHANNEL_TYPE_PAD) {
 
    // NSWID:  pad#1 is on the left (right) hand side for A-side (C-side) when looking from the IP.
    // Athena: pad#1 is on the right-hand side both for A- and C-side.
    uint16_t pid = private_id(channel_type, sector_type, feb_radius, layer);
    std::pair<uint16_t, uint16_t> pad_grid = s_stgc_pad_grid.at(pid);
    
    // Athena pad numbering assumes 18 eta rows (even if a quadruplet has less)
    uint16_t padRow     = (channel_number - 1)%18 + 1;
    uint16_t padCol_ATH = (channel_number - 1)/18 + 1;
    uint16_t padCol_NSW = (sideA) ? pad_grid.second - padCol_ATH + 1 : padCol_ATH;
    channel_number = (padRow - 1)*pad_grid.second + padCol_NSW;
  }
 
  return channel_number;  
}

channel_number()

uint16_t Muon::nsw::MapperSTG::channel_number	(	uint8_t	channel_type,
		uint8_t	sector_type,
		uint8_t	feb_radius,
		uint8_t	layer,
		uint16_t	vmm,
		uint16_t	vmm_chan
	)		const

Definition at line 9 of file MapperSTG.cxx.

{
  // Returns the detector-channel index according to ATHENA conventions.
 
  int counter {1};
  int chan = vmm * Muon::nsw::VMM_channels + vmm_chan;
  const auto& ranges = Muon::nsw::s_stgc_channel_map.at( private_id(channel_type, sector_type, feb_radius, layer) );
 
  for (const auto& range : ranges) {
    int chanFirst = range[0]*Muon::nsw::VMM_channels + range[1];
    int chanLast  = range[2]*Muon::nsw::VMM_channels + range[3];
    int increment = chanLast >= chanFirst ? 1 : -1;
      
    if ( (chan - chanFirst)*(chan - chanLast) <= 0 ) {
      uint16_t offline_channel = counter + increment*(chan - chanFirst);
      return AB_to_Athena_channel_number(channel_type, sector_type, feb_radius, layer, offline_channel);
    }
 
    counter += increment*(chanLast - chanFirst) + 1;
  }
  
  return 0; // disconnected vmm channel
}

elink_info()

bool Muon::nsw::MapperSTG::elink_info	(	uint8_t	channel_type,
		uint8_t	sector_type,
		uint8_t	mod_radius,
		uint8_t	layer,
		uint16_t	channel_number,
		uint &	elink
	)		const

Definition at line 83 of file MapperSTG.cxx.

{
  if(mod_radius>0) {elink = 0; return true;} // The boards on Q2 and Q3 are only read out by one elink per board
  uint16_t vmm{0}, vmm_chan{0};
  if(!vmm_info (channel_type, sector_type, mod_radius, layer, channel_number, vmm, vmm_chan)) return false;
  if(channel_type==OFFLINE_CHANNEL_TYPE_STRIP){
    if(geoVmmToRocVmm(vmm) < 4){
      elink=0; 
      return true;
    } else{
      elink=2; 
      return true;
    }
  } else if (channel_type==OFFLINE_CHANNEL_TYPE_WIRE || channel_type==OFFLINE_CHANNEL_TYPE_PAD){
    if(geoVmmToRocVmm(vmm)==2){
      elink=0;
      return true;
    } else{
      elink=2;
      return true;
    }
  } 
  elink = 0;
  return false;
}

geoVmmToRocVmm()

uint16_t Muon::nsw::MapperSTG::geoVmmToRocVmm

(

uint16_t

geoVMM

)

const

Definition at line 112 of file MapperSTG.cxx.

                                                              {
      constexpr uint16_t vmmRemap[8] = { 2, 3, 0, 1, 5, 4, 6, 7 };
      return vmmRemap[VMM];
  }

nchannels()

uint16_t Muon::nsw::MapperSTG::nchannels	(	uint8_t	channel_type,
		uint8_t	sector_type,
		uint8_t	feb_radius,
		uint8_t	layer
	)		const

Definition at line 35 of file MapperSTG.cxx.

{
  uint16_t pid = private_id(channel_type, sector_type, feb_radius, layer);
  const auto& ranges = s_stgc_channel_map.at(pid);
 
  int counter{0};
  for (const auto& range : ranges) {
    int chanFirst = range[0]*Muon::nsw::VMM_channels + range[1]; // custom id for the first channel in the range
    int chanLast  = range[2]*Muon::nsw::VMM_channels + range[3]; // custom id for the last channel in the range
    int increment = chanLast >= chanFirst ? 1 : -1;
    counter += increment*(chanLast - chanFirst) + 1; // number of channels in the range
  }
 
  return counter;
}

NSWID_to_Athena_channel_number()

uint16_t Muon::nsw::MapperSTG::NSWID_to_Athena_channel_number	(	uint8_t	channel_type,
		uint8_t	sector_type,
		uint8_t	feb_radius,
		uint8_t	layer,
		uint16_t	channel_number,
		bool	sideA
	)		const

Definition at line 188 of file MapperSTG.cxx.

{
  // Convert a channel index according to the NSWID numbering convention
  // into ATHENA channel index.
 
  if (channel_number == 0) return channel_number; // invalid (e.g. case of disconnected channel)
 
  // In NSWID numbering wires and pads follow ATLAS phi. 
  if (channel_type == OFFLINE_CHANNEL_TYPE_WIRE) {
 
    // NSWID:  wire#1 is on the left (right) hand side for A-side (C-side) when looking from the IP.
    // Athena: wire#1 is on the left-hand side both for A- and C-side.
    if (!sideA) channel_number = nchannels(channel_type, sector_type, feb_radius, layer) - channel_number + 1;
 
  } else if (channel_type == OFFLINE_CHANNEL_TYPE_PAD) {
 
    // NSWID:  pad#1 is on the left (right) hand side for A-side (C-side) when looking from the IP.
    // Athena: pad#1 is on the right-hand side both for A- and C-side.
    uint16_t pid = private_id(channel_type, sector_type, feb_radius, layer);
    std::pair<uint16_t, uint16_t> pad_grid = s_stgc_pad_grid.at(pid);
 
    uint16_t padRow     = (channel_number - 1)/pad_grid.second + 1;
    uint16_t padCol_NSW = (channel_number - 1)%pad_grid.second + 1;
    uint16_t padCol_ATH = (sideA) ? pad_grid.second - padCol_NSW + 1 : padCol_NSW;
 
    // Athena pad numbering assumes 18 eta rows (even if a quadruplet has less)
    channel_number = (padCol_ATH - 1)*18 + padRow;
  }
  
  return channel_number; 
}

private_id()

uint16_t Muon::nsw::MapperSTG::private_id ( uint8_t  channel_type, uint8_t  sector_type, uint8_t  feb_radius, uint8_t  layer  )

inlinestatic

Definition at line 263 of file MapperSTG.h.

{
  // an internal unique ID for every VMM channel
  return (channel_type & 0xf) << 12 | (sector_type & 0xf) << 8 | (feb_radius & 0xf) << 4 | (layer & 0xf);
}

vmm_info()

bool Muon::nsw::MapperSTG::vmm_info	(	uint8_t	channel_type,
		uint8_t	sector_type,
		uint8_t	mod_radius,
		uint8_t	layer,
		uint16_t	channel_number,
		uint16_t &	vmm,
		uint16_t &	vmm_chan
	)		const

Definition at line 53 of file MapperSTG.cxx.

{
  // Return vmm and vmm channel given the ATHENA channel index.
 
  uint16_t AB_channel = Athena_to_AB_channel_number(channel_type, sector_type, mod_radius, layer, channel_number);
 
  uint16_t pid = private_id(channel_type, sector_type, mod_radius, layer);
  const auto& ranges = s_stgc_channel_map.at(pid);
 
  int counter{1};
  for (const auto& range : ranges) {
    int chanFirst = range[0]*Muon::nsw::VMM_channels + range[1]; // custom id for the first channel in the range
    int chanLast  = range[2]*Muon::nsw::VMM_channels + range[3]; // custom id for the last channel in the range
    int increment = chanLast >= chanFirst ? 1 : -1;
    int nchan     = increment*(chanLast - chanFirst) + 1;        // number of channels in the range
      
    if (AB_channel < counter + nchan) {
      int chan = chanFirst + increment*(AB_channel - counter);
      vmm      = chan/64;
      vmm_chan = chan%64;
      return true;
    }
 
    counter += nchan;
  }
    
  return false;  
}

---

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

• MapperSTG.h
• MapperSTG.cxx