ATLAS Offline Software
Public Types | Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
RPC_CondCabling::EtaCMA Class Reference

#include <EtaCMA.h>

Inheritance diagram for RPC_CondCabling::EtaCMA:
Collaboration diagram for RPC_CondCabling::EtaCMA:

Public Types

enum  CMAconfiguration { Simulation, Atlas }
 
typedef std::list< const CMAparameters * > CMAlist
 

Public Member Functions

 EtaCMA (const parseParams &parse)
 
 EtaCMA (const EtaCMA &)
 
virtual ~EtaCMA ()
 
EtaCMA & operator= (const EtaCMA &)
 
const RPClink & pivot_RPCs (void) const
 
const RPClink & lowPt_RPCs (void) const
 
const RPClink & highPt_RPCs (void) const
 
bool inversion (void) const
 
bool setup (SectorLogicSetup &, MsgStream &)
 
bool operator== (const CMAparameters &) const
 
bool operator== (const CMAidentity &) const
 
CMAparameters & operator+= (const CMAparameters &)
 
const CMAidentity & id () const
 
const CMAprogram * lowPt_program () const
 
const CMAprogram * highPt_program () const
 
int pivot_start_ch () const
 
int pivot_start_st () const
 
int pivot_stop_ch () const
 
int pivot_stop_st () const
 
int lowPt_start_co () const
 
int lowPt_stop_co () const
 
int lowPt_number_co () const
 
int highPt_start_co () const
 
int highPt_stop_co () const
 
int highPt_number_co () const
 
int lowPt_start_st () const
 
int lowPt_start_ch () const
 
int lowPt_stop_st () const
 
int lowPt_stop_ch () const
 
int highPt_start_st () const
 
int highPt_start_ch () const
 
int highPt_stop_st () const
 
int highPt_stop_ch () const
 
int active_pivot_chs () const
 
int active_lowPt_chs () const
 
int active_highPt_chs () const
 
int pivot_station () const
 
int lowPt_station () const
 
int highPt_station () const
 
int pivot_rpc_read () const
 
int lowPt_rpc_read () const
 
int highPt_rpc_read () const
 
unsigned int first_pivot_code () const
 
unsigned int last_pivot_code () const
 
unsigned int first_lowPt_code () const
 
unsigned int last_lowPt_code () const
 
unsigned int first_highPt_code () const
 
unsigned int last_highPt_code () const
 
CMAconfiguration conf_type () const
 
unsigned int first_pivot_channel () const
 
unsigned int last_pivot_channel () const
 
unsigned int first_lowPt_channel () const
 
unsigned int last_lowPt_channel () const
 
unsigned int first_highPt_channel () const
 
unsigned int last_highPt_channel () const
 
virtual void Print (std::ostream &, bool) const override
 
void Print (std::ostream &, bool, int layer) const
 
bool isAtlas () const
 
bool give_connection (int, int, CMAinput &, int &, int &) const
 
bool get_channel (CMAinput, int, int &, int &) const
 
bool get_cabling (CMAinput, int, int, int, unsigned int &) const
 
const CMAparameters * test (CMAinput, int) const
 
CMAinput whichCMAinput (int) const
 
int whichCMAstation (CMAinput input) const
 
bool correct (L1RPCcabCorrection type, CMAinput it, unsigned int layer, unsigned short int Ch1, unsigned short int Ch2, short int num) const
 
void give_strip_code (unsigned int logic_sector, unsigned short int lh, unsigned short int ijk, unsigned short int Channel, std::list< unsigned int > &StripCodes) const
 
int number () const
 
int station () const
 
int sector_type () const
 
std::string error_header () const
 
std::string no_connection_error (const std::string &, int) const
 
ObjectType tag () const
 
std::string name () const
 

Static Public Attributes

static constexpr int pivot_channels = 32
 
static constexpr int confirm_channels = 64
 

Protected Member Functions

void create_pivot_map (int)
 
void create_lowPt_map (int)
 
void create_highPt_map (int)
 
std::string noMoreChannels (const std::string &stat)
 
std::string two_obj_error_message (const std::string &, CMAparameters *)
 
std::string no_confirm_error (int)
 
std::string no_wor_readout (int, int)
 
std::string error (const std::string &)
 

Protected Attributes

std::unique_ptr< CMAidentity > m_id
 
int m_lowPt_start_st {-1}
 
int m_lowPt_start_ch {-1}
 
int m_lowPt_stop_st {-1}
 
int m_lowPt_stop_ch {-1}
 
int m_highPt_start_st {-1}
 
int m_highPt_start_ch {-1}
 
int m_highPt_stop_st {-1}
 
int m_highPt_stop_ch {-1}
 
int m_active_pivot_chs {0}
 
int m_active_lowPt_chs {0}
 
int m_active_highPt_chs {0}
 
int m_pivot_rpc_read {0}
 
int m_lowPt_rpc_read {0}
 
int m_highPt_rpc_read {0}
 
unsigned int m_first_pivot_code {0}
 
unsigned int m_last_pivot_code {0}
 
unsigned int m_first_lowPt_code {0}
 
unsigned int m_last_lowPt_code {0}
 
unsigned int m_first_highPt_code {0}
 
unsigned int m_last_highPt_code {0}
 
int(* m_pivot )[2][pivot_channels] {}
 
int(* m_lowPt )[2][confirm_channels] {}
 
int(* m_highPt )[2][confirm_channels] {}
 
std::unique_ptr< CMAprogram > m_lowPt_program
 
std::unique_ptr< CMAprogram > m_highPt_program
 
CMAconfiguration m_conf_type {CMAparameters::Atlas}
 

Private Types

typedef std::map< int, RPCchamber *, std::less< int > > RPClink
 

Private Member Functions

bool cable_CMA_channels (HalfType)
 
bool connect (SectorLogicSetup &)
 
bool doInversion (SectorLogicSetup &)
 
bool got_confirm_cabling (SectorLogicSetup &, int)
 
bool end_at_RPC_Z_boundary (void) const
 
bool begin_at_RPC_Z_boundary (void) const
 
void showDt (std::ostream &, int layer) const
 
void showMt (char[][90], int, TrigType, int layer) const
 
void reset_pivot_cabling ()
 
void reset_lowPt_cabling ()
 
void reset_highPt_cabling ()
 

Private Attributes

RPClink m_pivot_RPCs
 
RPClink m_lowPt_RPCs
 
RPClink m_highPt_RPCs
 
bool m_inversion {false}
 
defineParams m_params {}
 
int m_number {0}
 
int m_station {0}
 
int m_sector_type {0}
 
ObjectType m_tag
 
std::string m_name
 

Detailed Description

Definition at line 20 of file EtaCMA.h.

Member Typedef Documentation

◆ CMAlist

typedef std::list<const CMAparameters*> CMAparameters::CMAlist
inherited

Definition at line 24 of file CMAparameters.h.

◆ RPClink

typedef std::map<int, RPCchamber*, std::less<int> > RPC_CondCabling::EtaCMA::RPClink
private

Definition at line 22 of file EtaCMA.h.

Member Enumeration Documentation

◆ CMAconfiguration

enum CMAparameters::CMAconfiguration
inherited
Enumerator
Simulation 
Atlas 

Definition at line 23 of file CMAparameters.h.

23 { Simulation, Atlas };

Constructor & Destructor Documentation

◆ EtaCMA() [1/2]

EtaCMA::EtaCMA ( const parseParams &  parse)

Definition at line 18 of file EtaCMA.cxx.

19  : CMAparameters(parse)
20 {
21  m_pivot_rpc_read = 1;
22  m_lowPt_rpc_read = 1;
23  m_highPt_rpc_read = 1;
24  m_conf_type = CMAparameters::Atlas;
25 
26  create_pivot_map(m_pivot_rpc_read);
27  create_lowPt_map(m_lowPt_rpc_read);
28  create_highPt_map(m_highPt_rpc_read);
29 }

◆ EtaCMA() [2/2]

EtaCMA::EtaCMA ( const EtaCMA &  cma)

Definition at line 31 of file EtaCMA.cxx.

32  : CMAparameters(cma),
33  m_pivot_RPCs (cma.pivot_RPCs()),
34  m_lowPt_RPCs (cma.lowPt_RPCs()),
35  m_highPt_RPCs (cma.highPt_RPCs()),
36  m_inversion (cma.inversion())
37 {
38  m_conf_type = CMAparameters::Atlas;
39 }

◆ ~EtaCMA()

EtaCMA::~EtaCMA ( )
virtualdefault

Member Function Documentation

◆ active_highPt_chs()

int CMAparameters::active_highPt_chs ( ) const
inherited

Definition at line 46 of file CMAparameters.cxx.

46 { return m_active_highPt_chs; }

◆ active_lowPt_chs()

int CMAparameters::active_lowPt_chs ( ) const
inherited

Definition at line 45 of file CMAparameters.cxx.

45 { return m_active_lowPt_chs; }

◆ active_pivot_chs()

int CMAparameters::active_pivot_chs ( ) const
inherited

Definition at line 44 of file CMAparameters.cxx.

44 { return m_active_pivot_chs; }

◆ begin_at_RPC_Z_boundary()

bool EtaCMA::begin_at_RPC_Z_boundary ( void  ) const
private

Definition at line 532 of file EtaCMA.cxx.

532  {
533  return pivot_start_st() == 1;
534 }

◆ cable_CMA_channels()

bool EtaCMA::cable_CMA_channels ( HalfType  side)
private

Definition at line 55 of file EtaCMA.cxx.

55  {
56  if (pivot_station()) // Check and connect strips with Pivot matrix channels
57  {
58  for (int i = pivot_start_ch(); i <= pivot_stop_ch(); ++i) {
59  int strip_number = (m_active_pivot_chs) ? 1 : pivot_start_st();
60  RPClink::iterator found = m_pivot_RPCs.find(i);
61  RPCchamber* rpc = (*found).second;
62  int final_strip = rpc->eta_strips();
63  if (i == pivot_stop_ch()) final_strip = pivot_stop_st();
64  do {
65  if (m_active_pivot_chs == pivot_channels) {
66  REPORT_MESSAGE_WITH_CONTEXT(MSG::ERROR, "EtaCMA") << noMoreChannels("Pivot");
67  return false;
68  }
69 
70  int st_effective = strip_number - 1;
71  if (!i && side == Negative) st_effective = abs(st_effective - final_strip) - 1;
72 
73  if (rpc->ijk_etaReadout() == 1) {
74  m_pivot[0][0][m_active_pivot_chs] = i * 100 + st_effective;
75  m_pivot[0][1][m_active_pivot_chs] = 10000 + i * 100 + st_effective;
76  } else {
77  m_pivot[0][1][m_active_pivot_chs] = i * 100 + st_effective;
78  m_pivot[0][0][m_active_pivot_chs] = 10000 + i * 100 + st_effective;
79  }
80  rpc->add_eta_channel(st_effective);
81  ++m_active_pivot_chs;
82  } while (++strip_number <= final_strip);
83  }
84  // Set first and last connectors code
85  int code = pivot_station() * 100000 + 2 * 100000000;
86  m_first_pivot_code = code + m_pivot[0][0][0];
87  m_last_pivot_code = code + m_pivot[0][0][m_active_pivot_chs - 1];
88  }
89  if (lowPt_station() && lowPt_number_co() != -1) {
90  for (int i = lowPt_start_ch(); i <= lowPt_stop_ch(); ++i) {
91  int strip_number = (m_active_lowPt_chs) ? 1 : lowPt_start_st();
92  RPClink::iterator found = m_lowPt_RPCs.find(i);
93  RPCchamber* rpc = (*found).second;
94  int final_strip = rpc->eta_strips();
95  if (i == lowPt_stop_ch()) final_strip = lowPt_stop_st();
96  do {
97  if (m_active_lowPt_chs == confirm_channels) {
98  REPORT_MESSAGE_WITH_CONTEXT(MSG::ERROR, "EtaCMA") << noMoreChannels("Low Pt");
99  return false;
100  }
101 
102  int st_effective = strip_number - 1;
103  if (!i && side == Negative) st_effective = abs(st_effective - final_strip) - 1;
104 
105  if (rpc->ijk_etaReadout() == 1) {
106  m_lowPt[0][0][m_active_lowPt_chs] = i * 100 + st_effective;
107  m_lowPt[0][1][m_active_lowPt_chs] = 10000 + i * 100 + st_effective;
108  } else {
109  m_lowPt[0][1][m_active_lowPt_chs] = i * 100 + st_effective;
110  m_lowPt[0][0][m_active_lowPt_chs] = 10000 + i * 100 + st_effective;
111  }
112  rpc->add_eta_channel(st_effective);
113  ++m_active_lowPt_chs;
114  } while (++strip_number <= final_strip);
115  }
116  // Set first and last connectors code
117  int code = lowPt_station() * 100000 + 2 * 100000000;
118  m_first_lowPt_code = code + m_lowPt[0][0][0];
119  m_last_lowPt_code = code + m_lowPt[0][0][m_active_lowPt_chs - 1];
120  }
121  if (highPt_station() && highPt_number_co() != -1) {
122  for (int i = highPt_start_ch(); i <= highPt_stop_ch(); ++i) {
123  int strip_number = (m_active_highPt_chs) ? 1 : highPt_start_st();
124  RPClink::iterator found = m_highPt_RPCs.find(i);
125  RPCchamber* rpc = (*found).second;
126  int final_strip = rpc->eta_strips();
127  if (i == highPt_stop_ch()) final_strip = highPt_stop_st();
128  do {
129  if (m_active_highPt_chs == confirm_channels) {
130  REPORT_MESSAGE_WITH_CONTEXT(MSG::ERROR, "EtaCMA") << noMoreChannels("High Pt");
131  return false;
132  }
133 
134  int st_effective = strip_number - 1;
135  if (!i && side == Negative) st_effective = abs(st_effective - final_strip) - 1;
136 
137  if (rpc->ijk_etaReadout() == 1) {
138  m_highPt[0][0][m_active_highPt_chs] = i * 100 + st_effective;
139  m_highPt[0][1][m_active_highPt_chs] = 10000 + i * 100 + st_effective;
140  } else {
141  m_highPt[0][1][m_active_highPt_chs] = i * 100 + st_effective;
142  m_highPt[0][0][m_active_highPt_chs] = 10000 + i * 100 + st_effective;
143  }
144  rpc->add_eta_channel(st_effective);
145  ++m_active_highPt_chs;
146  } while (++strip_number <= final_strip);
147  }
148  // Set first and last connectors code
149  int code = highPt_station() * 100000 + 2 * 100000000;
150  m_first_highPt_code = code + m_highPt[0][0][0];
151  m_last_highPt_code = code + m_highPt[0][0][m_active_highPt_chs - 1];
152  }
153  return true;
154 }

◆ conf_type()

CMAparameters::CMAconfiguration CMAparameters::conf_type ( ) const
inherited

Definition at line 63 of file CMAparameters.cxx.

63 { return m_conf_type; }

◆ connect()

bool EtaCMA::connect ( SectorLogicSetup &  setup)
private

Definition at line 156 of file EtaCMA.cxx.

156  {
157  if (pivot_station()) // Check and connect Pivot chambers
158  {
159  for (int i = pivot_start_ch(); i <= pivot_stop_ch(); ++i) {
160  RPCchamber* rpc = setup.find_chamber(pivot_station(), i);
161  if (rpc) {
162  rpc->add_cma(this);
163  m_pivot_RPCs.insert(RPClink::value_type(i, rpc));
164  } else {
165  REPORT_MESSAGE_WITH_CONTEXT(MSG::ERROR, "EtaCMA") << no_connection_error("RPC - pivot", i);
166  return false;
167  }
168  }
169  }
170 
171  if (lowPt_station() && lowPt_number_co() != -1) { // Check and connect Low Pt chambers
172  if (got_confirm_cabling(setup, lowPt_station())) {
173  ++m_lowPt_start_st; // RPC strips starts from 1!
174  for (int i = m_lowPt_start_ch; i <= m_lowPt_stop_ch; ++i) {
175  RPCchamber* rpc = setup.find_chamber(lowPt_station(), i);
176  if (rpc) {
177  rpc->add_cma(this);
178  m_lowPt_RPCs.insert(RPClink::value_type(i, rpc));
179  } else {
180  REPORT_MESSAGE_WITH_CONTEXT(MSG::ERROR, "EtaCMA") << no_connection_error("RPC - low Pt", i);
181  return false;
182  }
183  if (i == m_lowPt_stop_ch) m_lowPt_stop_st += rpc->strips_in_Eta_Conn();
184  }
185  } else {
186  REPORT_MESSAGE_WITH_CONTEXT(MSG::ERROR, "EtaCMA") << no_confirm_error(lowPt_station());
187  return false;
188  }
189  }
190 
191  if (highPt_station() && highPt_number_co() != -1) { // Check and connect High Pt chambers
192  if (got_confirm_cabling(setup, highPt_station())) {
193  ++m_highPt_start_st; // RPC strips starts from 1!
194  for (int i = m_highPt_start_ch; i <= m_highPt_stop_ch; ++i) {
195  RPCchamber* rpc = setup.find_chamber(highPt_station(), i);
196  if (rpc) {
197  rpc->add_cma(this);
198  m_highPt_RPCs.insert(RPClink::value_type(i, rpc));
199  } else {
200  REPORT_MESSAGE_WITH_CONTEXT(MSG::ERROR, "EtaCMA") << no_connection_error("RPC - high Pt", i);
201  return false;
202  }
203  if (i == m_highPt_stop_ch) m_highPt_stop_st += rpc->strips_in_Eta_Conn();
204  }
205  } else {
206  REPORT_MESSAGE_WITH_CONTEXT(MSG::ERROR, "EtaCMA") << no_confirm_error(highPt_station());
207  return false;
208  }
209  }
210  return true;
211 }

◆ correct()

bool CMAparameters::correct ( L1RPCcabCorrection  type,
CMAinput  it,
unsigned int  layer,
unsigned short int  Ch1,
unsigned short int  Ch2,
short int  num 
) const
inherited

Definition at line 646 of file CMAparameters.cxx.

647  {
648  if (Ch1 > Ch2) return false;
649 
650  int worlo = 0;
651  int maxch = 0;
652  int* map = nullptr;
653 
654  switch (it) {
655  case Pivot:
656  map = reinterpret_cast<int*>(m_pivot);
657  maxch = pivot_channels;
658  worlo = m_pivot_rpc_read;
659  break;
660 
661  case LowPt:
662  map = reinterpret_cast<int*>(m_lowPt);
663  maxch = confirm_channels;
664  worlo = m_lowPt_rpc_read;
665  break;
666 
667  case HighPt:
668  map = reinterpret_cast<int*>(m_highPt);
669  maxch = confirm_channels;
670  worlo = m_highPt_rpc_read;
671  break;
672 
673  default: return false;
674  }
675 
676  switch (type) {
677  case Inversion:
678 
679  num = Ch2 - Ch1 + 1;
680  for (int i = 0; i < worlo; ++i) {
681  for (unsigned short int j = 0; j < num / 2; ++j) {
682  int pos1 = i * 2 * maxch + layer * maxch + Ch1 + j;
683  int pos2 = i * 2 * maxch + layer * maxch + Ch2 - j;
684  int tmp = *(map + pos1);
685  *(map + pos1) = *(map + pos2);
686  *(map + pos2) = tmp;
687  }
688  }
689 
690  break;
691 
692  case Swap:
693 
694  if (Ch1 + num - 1 >= Ch2) return false;
695  for (int i = 0; i < worlo; ++i) {
696  for (unsigned short int j = 0; j < num; ++j) {
697  int pos1 = i * 2 * maxch + layer * maxch + Ch1 + j;
698  int pos2 = i * 2 * maxch + layer * maxch + Ch2 + j;
699  int tmp = *(map + pos1);
700  *(map + pos1) = *(map + pos2);
701  *(map + pos2) = tmp;
702  }
703  }
704 
705  break;
706 
707  case Suppression:
708 
709  num = Ch2 - Ch1 + 1;
710  for (int i = 0; i < worlo; ++i) {
711  for (unsigned short int j = 0; j < num; ++j) {
712  int pos = i * 2 * maxch + layer * maxch + Ch1 + j;
713  *(map + pos) = -1;
714  }
715  }
716 
717  break;
718 
719  case Shift:
720  for (int i = 0; i < worlo; ++i) {
721  if (num / abs(num) == 1) {
722  unsigned short int piv = Ch1 + num;
723 
724  for (unsigned short int j = Ch1; j < piv; ++j) {
725  int pos = i * 2 * maxch + layer * maxch + j;
726  *(map + pos) = -1;
727  }
728 
729  for (unsigned short int j = piv; j <= Ch2; ++j) {
730  int pos = i * 2 * maxch + layer * maxch + j;
731 
732  *(map + pos - num) = *(map + pos);
733  *(map + pos) = -1;
734  }
735  }
736  if (num / abs(num) == -1) {
737  unsigned short int ch = Ch2;
738  short int piv = Ch2 - abs(num) + 1;
739  short int stop = Ch1 + num;
740  if (stop < 0) stop = 0;
741  do {
742  int pos = i * 2 * maxch + layer * maxch + ch;
743  *(map + pos) = -1;
744  --ch;
745  } while (ch > piv);
746 
747  do {
748  int pos = i * 2 * maxch + layer * maxch + piv - 1;
749 
750  *(map + pos + (int)abs(num)) = *(map + pos);
751  *(map + pos) = -1;
752  --piv;
753  } while (piv > stop);
754  }
755  }
756 
757  break;
758 
759  default: return false;
760  }
761 
762  return true;
763 }

◆ create_highPt_map()

void CMAparameters::create_highPt_map ( int  rpc_to_read)
protectedinherited

Definition at line 245 of file CMAparameters.cxx.

245  {
246  if (!m_highPt) {
247  m_highPt = new int[rpc_to_read][2][confirm_channels];
248  for (int i = 0; i < rpc_to_read; ++i)
249  for (int j = 0; j < 2; ++j)
250  for (int k = 0; k < confirm_channels; ++k) m_highPt[i][j][k] = -1;
251  }
252 }

◆ create_lowPt_map()

void CMAparameters::create_lowPt_map ( int  rpc_to_read)
protectedinherited

Definition at line 236 of file CMAparameters.cxx.

236  {
237  if (!m_lowPt) {
238  m_lowPt = new int[rpc_to_read][2][confirm_channels];
239  for (int i = 0; i < rpc_to_read; ++i)
240  for (int j = 0; j < 2; ++j)
241  for (int k = 0; k < confirm_channels; ++k) m_lowPt[i][j][k] = -1;
242  }
243 }

◆ create_pivot_map()

void CMAparameters::create_pivot_map ( int  rpc_to_read)
protectedinherited

Definition at line 227 of file CMAparameters.cxx.

227  {
228  if (!m_pivot) {
229  m_pivot = new int[rpc_to_read][2][pivot_channels];
230  for (int i = 0; i < rpc_to_read; ++i)
231  for (int j = 0; j < 2; ++j)
232  for (int k = 0; k < pivot_channels; ++k) m_pivot[i][j][k] = -1;
233  }
234 }

◆ doInversion()

bool EtaCMA::doInversion ( SectorLogicSetup &  setup)
private

Definition at line 480 of file EtaCMA.cxx.

480  {
481  SectorLogicSetup::SECTORlist Sectors = setup.sectors();
482  SectorLogicSetup::SECTORlist::const_iterator it = Sectors.begin();
483  int sector = *it;
484 
485  RPClink::const_iterator rpc;
486  if (lowPt_station() && lowPt_number_co() != -1) {
487  rpc = m_lowPt_RPCs.begin();
488  if ((*rpc).second->inversion(sector)) {
489  m_inversion = true;
490  correct(Inversion, LowPt, 0, first_lowPt_channel(), last_lowPt_channel(), 0);
491  correct(Inversion, LowPt, 1, first_lowPt_channel(), last_lowPt_channel(), 0);
492  int tmp = m_first_lowPt_code;
493  m_first_lowPt_code = m_last_lowPt_code;
494  m_last_lowPt_code = tmp;
495  }
496  }
497 
498  if (pivot_station()) {
499  rpc = m_pivot_RPCs.begin();
500  if ((*rpc).second->inversion(sector)) {
501  m_inversion = true;
502  correct(Inversion, Pivot, 0, first_pivot_channel(), last_pivot_channel(), 0);
503  correct(Inversion, Pivot, 1, first_pivot_channel(), last_pivot_channel(), 0);
504  int tmp = m_first_pivot_code;
505  m_first_pivot_code = m_last_pivot_code;
506  m_last_pivot_code = tmp;
507  }
508  }
509 
510  if (highPt_station() && highPt_number_co() != -1) {
511  rpc = m_highPt_RPCs.begin();
512  if ((*rpc).second->inversion(sector)) {
513  m_inversion = true;
514  correct(Inversion, HighPt, 0, first_highPt_channel(), last_highPt_channel(), 0);
515  correct(Inversion, HighPt, 1, first_highPt_channel(), last_highPt_channel(), 0);
516  int tmp = m_first_highPt_code;
517  m_first_highPt_code = m_last_highPt_code;
518  m_last_highPt_code = tmp;
519  }
520  }
521 
522  if (m_inversion) m_id->inversion();
523 
524  return true;
525 }

◆ end_at_RPC_Z_boundary()

bool EtaCMA::end_at_RPC_Z_boundary ( void  ) const
private

Definition at line 527 of file EtaCMA.cxx.

527  {
528  RPClink::const_iterator found = m_pivot_RPCs.find(pivot_stop_ch());
529  return (*found).second->eta_strips() == pivot_stop_st();
530 }

◆ error()

std::string CMAparameters::error ( const std::string &  str)
protectedinherited

Definition at line 549 of file CMAparameters.cxx.

549  {
550  std::ostringstream disp;
551  disp << this->error_header()
552  << this->id() << str;
553  return disp.str();
554 }

◆ error_header()

std::string CablingObject::error_header ( ) const
inherited

Definition at line 22 of file CablingObject.cxx.

22  {
23  std::ostringstream disp;
24  disp << "Error in Sector Type " << m_sector_type;
25  if (m_station > 0) disp << ", station " << m_station;
26  disp << ":" << std::endl;
27  return disp.str();
28 }

◆ first_highPt_channel()

unsigned int CMAparameters::first_highPt_channel ( ) const
inherited

Definition at line 894 of file CMAparameters.cxx.

894  {
895  for (int ch = 0; ch < confirm_channels; ++ch) {
896  for (int i = 0; i < m_highPt_rpc_read; ++i) {
897  int CabCode = m_highPt[i][0][ch];
898  if (CabCode != -1) return ch;
899  }
900  }
901  return 999;
902 }

◆ first_highPt_code()

unsigned int CMAparameters::first_highPt_code ( ) const
inherited

Definition at line 60 of file CMAparameters.cxx.

60 { return m_first_highPt_code; }

◆ first_lowPt_channel()

unsigned int CMAparameters::first_lowPt_channel ( ) const
inherited

Definition at line 874 of file CMAparameters.cxx.

874  {
875  for (int ch = 0; ch < confirm_channels; ++ch) {
876  for (int i = 0; i < m_lowPt_rpc_read; ++i) {
877  int CabCode = m_lowPt[i][0][ch];
878  if (CabCode != -1) return ch;
879  }
880  }
881  return 999;
882 }

◆ first_lowPt_code()

unsigned int CMAparameters::first_lowPt_code ( ) const
inherited

Definition at line 58 of file CMAparameters.cxx.

58 { return m_first_lowPt_code; }

◆ first_pivot_channel()

unsigned int CMAparameters::first_pivot_channel ( ) const
inherited

Definition at line 854 of file CMAparameters.cxx.

854  {
855  for (int ch = 0; ch < pivot_channels; ++ch) {
856  for (int i = 0; i < m_pivot_rpc_read; ++i) {
857  int CabCode = m_pivot[i][0][ch];
858  if (CabCode != -1) return ch;
859  }
860  }
861  return 999;
862 }

◆ first_pivot_code()

unsigned int CMAparameters::first_pivot_code ( ) const
inherited

Definition at line 56 of file CMAparameters.cxx.

56 { return m_first_pivot_code; }

◆ get_cabling()

bool CMAparameters::get_cabling ( CMAinput  IO,
int  WOR,
int  ly,
int  ch,
unsigned int &  code 
) const
inherited

Definition at line 614 of file CMAparameters.cxx.

614  {
615  int* strips = nullptr;
616  int channels = 0;
617 
618  if (ly >= 2) return false;
619 
620  if (IO == Pivot && m_pivot) {
621  channels = pivot_channels;
622  if (WOR >= m_pivot_rpc_read) return false;
623  strips = reinterpret_cast<int*>(m_pivot);
624  } else if (IO == LowPt && m_lowPt) {
625  channels = confirm_channels;
626  if (WOR >= m_lowPt_rpc_read) return false;
627  strips = reinterpret_cast<int*>(m_lowPt);
628  } else if (IO == HighPt && m_highPt) {
629  channels = confirm_channels;
630  if (WOR >= m_highPt_rpc_read) return false;
631  strips = reinterpret_cast<int*>(m_highPt);
632  } else
633  return false;
634 
635  if (ch >= channels) return false;
636 
637  int position = WOR * (2 * channels) + ly * (channels) + ch;
638 
639  if (*(strips + position) < 0) return false;
640 
641  code = *(strips + position);
642 
643  return true;
644 }

◆ get_channel()

bool CMAparameters::get_channel ( CMAinput  IO,
int  cab_code,
int &  ly,
int &  ch 
) const
inherited

Definition at line 583 of file CMAparameters.cxx.

583  {
584  int* strips = nullptr;
585  int nstrips = 0;
586  int channels = 0;
587 
588  if (IO == Pivot && m_pivot) {
589  channels = pivot_channels;
590  nstrips = pivot_channels * m_pivot_rpc_read * 2;
591  strips = reinterpret_cast<int*>(m_pivot);
592  } else if (IO == LowPt && m_lowPt) {
593  channels = confirm_channels;
594  nstrips = confirm_channels * m_lowPt_rpc_read * 2;
595  strips = reinterpret_cast<int*>(m_lowPt);
596  } else if (IO == HighPt && m_highPt) {
597  channels = confirm_channels;
598  nstrips = confirm_channels * m_highPt_rpc_read * 2;
599  strips = reinterpret_cast<int*>(m_highPt);
600  } else
601  return false;
602 
603  for (int i = 0; i < nstrips; ++i) {
604  if (strips[i] == cab_code) {
605  ch = i % channels;
606  ly = (i / channels) % 2;
607  return true;
608  }
609  }
610 
611  return false;
612 }

◆ give_connection()

bool CMAparameters::give_connection ( int  station,
int  cab_code,
CMAinput &  IO,
int &  ly,
int &  ch 
) const
inherited

Definition at line 578 of file CMAparameters.cxx.

578  {
579  IO = whichCMAinput(station);
580  return get_channel(IO, cab_code, ly, ch);
581 }

◆ give_strip_code()

void CMAparameters::give_strip_code ( unsigned int  logic_sector,
unsigned short int  lh,
unsigned short int  ijk,
unsigned short int  Channel,
std::list< unsigned int > &  StripCodes 
) const
inherited

Definition at line 765 of file CMAparameters.cxx.

766  {
767  RPCdecoder deco;
768 
769  if (ijk == 0 || ijk == 1) {
770  for (int i = 0; i < m_pivot_rpc_read; ++i) {
771  int CabCode = m_pivot[i][ijk][Channel];
772  if (CabCode >= 0) {
773  int strip_number = CabCode % 100;
774  int rpc_z_index = (CabCode / 100) % 100;
775  int rpc_layer = (CabCode / 10000) % 10;
776  if (deco(this->id().type(), logic_sector, this->whichCMAstation(Pivot), rpc_layer, rpc_z_index, strip_number)) {
777  StripCodes.push_back(deco.code());
778  }
779  }
780  }
781  }
782 
783  if (ijk == 2 || ijk == 3) {
784  if (lh == 1) {
785  for (int i = 0; i < m_highPt_rpc_read; ++i) {
786  int CabCode = m_highPt[i][0][Channel + 32 * (ijk % 2)];
787  if (CabCode >= 0) {
788  int strip_number = CabCode % 100;
789  int rpc_z_index = (CabCode / 100) % 100;
790  int rpc_layer = (CabCode / 10000) % 10;
791  if (deco(this->id().type(), logic_sector, this->whichCMAstation(HighPt), rpc_layer, rpc_z_index, strip_number)) {
792  StripCodes.push_back(deco.code());
793  }
794  }
795  }
796  } else {
797  for (int i = 0; i < m_lowPt_rpc_read; ++i) {
798  int CabCode = m_lowPt[i][0][Channel + 32 * (ijk % 2)];
799  if (CabCode >= 0) {
800  int strip_number = CabCode % 100;
801  int rpc_z_index = (CabCode / 100) % 100;
802  int rpc_layer = (CabCode / 10000) % 10;
803  if (deco(this->id().type(), logic_sector, this->whichCMAstation(LowPt), rpc_layer, rpc_z_index, strip_number)) {
804  StripCodes.push_back(deco.code());
805  }
806  }
807  }
808  }
809  }
810 
811  if (ijk == 4 || ijk == 5) {
812  if (lh == 1) {
813  for (int i = 0; i < m_highPt_rpc_read; ++i) {
814  int CabCode = m_highPt[i][1][Channel + 32 * (ijk % 2)];
815  if (CabCode >= 0) {
816  int strip_number = CabCode % 100;
817  int rpc_z_index = (CabCode / 100) % 100;
818  int rpc_layer = (CabCode / 10000) % 10;
819  if (deco(this->id().type(), logic_sector, this->whichCMAstation(HighPt), rpc_layer, rpc_z_index, strip_number)) {
820  StripCodes.push_back(deco.code());
821  }
822  }
823  }
824  } else {
825  for (int i = 0; i < m_lowPt_rpc_read; ++i) {
826  int CabCode = m_lowPt[i][1][Channel + 32 * (ijk % 2)];
827  if (CabCode >= 0) {
828  int strip_number = CabCode % 100;
829  int rpc_z_index = (CabCode / 100) % 100;
830  int rpc_layer = (CabCode / 10000) % 10;
831  if (deco(this->id().type(), logic_sector, this->whichCMAstation(LowPt), rpc_layer, rpc_z_index, strip_number)) {
832  StripCodes.push_back(deco.code());
833  }
834  }
835  }
836  }
837  }
838 
839  if (ijk == 6) {
840  for (int i = 0; i < m_pivot_rpc_read; ++i) {
841  int CabCode = m_pivot[i][0][Channel];
842  if (CabCode >= 0) {
843  int strip_number = CabCode % 100;
844  int rpc_z_index = (CabCode / 100) % 100;
845  int rpc_layer = (CabCode / 10000) % 10;
846  if (deco(this->id().type(), logic_sector, this->whichCMAstation(Pivot), rpc_layer, rpc_z_index, strip_number)) {
847  StripCodes.push_back(deco.code());
848  }
849  }
850  }
851  }
852 }

◆ got_confirm_cabling()

bool EtaCMA::got_confirm_cabling ( SectorLogicSetup &  setup,
int  stat 
)
private

Definition at line 213 of file EtaCMA.cxx.

213  {
214  int l;
215  if (stat == lowPt_station()) {
216  bool result = setup.local_conn_add(Eta, stat, lowPt_start_co(), l, m_lowPt_start_ch, m_lowPt_start_st) &&
217  setup.local_conn_add(Eta, stat, lowPt_stop_co(), l, m_lowPt_stop_ch, m_lowPt_stop_st);
218  if ((!m_lowPt_start_ch || !m_lowPt_stop_ch) && setup.side() == NoHalf) {
219  REPORT_MESSAGE_WITH_CONTEXT(MSG::ERROR, "EvenPhiCMA") << "Sector Type must belong "
220  "to a specific side when RPC chamber is in between eta 0";
221  return false;
222  }
223  return result;
224  } else if (stat == highPt_station()) {
225  bool result = setup.local_conn_add(Eta, stat, highPt_start_co(), l, m_highPt_start_ch, m_highPt_start_st) &&
226  setup.local_conn_add(Eta, stat, highPt_stop_co(), l, m_highPt_stop_ch, m_highPt_stop_st);
227  if ((!m_highPt_start_ch || !m_highPt_stop_ch) && setup.side() == NoHalf) {
228  REPORT_MESSAGE_WITH_CONTEXT(MSG::ERROR, "EvenPhiCMA") << "Sector Type must belong "
229  "to a specific side when RPC chamber is in between eta 0";
230  return false;
231  }
232  return result;
233 
234  } else {
235  REPORT_MESSAGE_WITH_CONTEXT(MSG::ERROR, "EvenPhiCMA") << "Station n. " << stat
236  << " don't give input to CMA confirm planes!";
237  return false;
238  }
239 }

◆ highPt_number_co()

int CMAparameters::highPt_number_co ( ) const
inherited

Definition at line 32 of file CMAparameters.cxx.

32 { return m_params.highPtNumCo; }

◆ highPt_program()

const CMAprogram * CMAparameters::highPt_program ( ) const
inherited

Definition at line 19 of file CMAparameters.cxx.

19 { return m_highPt_program.get(); }

◆ highPt_rpc_read()

int CMAparameters::highPt_rpc_read ( ) const
inherited

Definition at line 54 of file CMAparameters.cxx.

54 { return m_highPt_rpc_read; }

◆ highPt_RPCs()

const RPClink& RPC_CondCabling::EtaCMA::highPt_RPCs ( void  ) const
inline

Definition at line 46 of file EtaCMA.h.

46 { return m_highPt_RPCs; }

◆ highPt_start_ch()

int CMAparameters::highPt_start_ch ( ) const
inherited

Definition at line 40 of file CMAparameters.cxx.

40 { return m_highPt_start_ch; }

◆ highPt_start_co()

int CMAparameters::highPt_start_co ( ) const
inherited

Definition at line 30 of file CMAparameters.cxx.

30 { return m_params.highPtStartCo; }

◆ highPt_start_st()

int CMAparameters::highPt_start_st ( ) const
inherited

Definition at line 39 of file CMAparameters.cxx.

39 { return m_highPt_start_st; }

◆ highPt_station()

int CMAparameters::highPt_station ( ) const
inherited

Definition at line 50 of file CMAparameters.cxx.

50 { return m_params.highPtStation; }

◆ highPt_stop_ch()

int CMAparameters::highPt_stop_ch ( ) const
inherited

Definition at line 42 of file CMAparameters.cxx.

42 { return m_highPt_stop_ch; }

◆ highPt_stop_co()

int CMAparameters::highPt_stop_co ( ) const
inherited

Definition at line 31 of file CMAparameters.cxx.

31 { return m_params.highPtStopCo; }

◆ highPt_stop_st()

int CMAparameters::highPt_stop_st ( ) const
inherited

Definition at line 41 of file CMAparameters.cxx.

41 { return m_highPt_stop_st; }

◆ id()

const CMAidentity & CMAparameters::id ( ) const
inherited

Definition at line 17 of file CMAparameters.cxx.

17 { return *m_id; }

◆ inversion()

bool RPC_CondCabling::EtaCMA::inversion ( void  ) const
inline

Definition at line 48 of file EtaCMA.h.

48 { return m_inversion; }

◆ isAtlas()

bool CMAparameters::isAtlas ( ) const
inherited

Definition at line 15 of file CMAparameters.cxx.

15 { return m_conf_type == Atlas; }

◆ last_highPt_channel()

unsigned int CMAparameters::last_highPt_channel ( ) const
inherited

Definition at line 904 of file CMAparameters.cxx.

904  {
905  for (int ch = confirm_channels - 1; ch >= 0; --ch) {
906  for (int i = 0; i < m_highPt_rpc_read; ++i) {
907  int CabCode = m_highPt[i][0][ch];
908  if (CabCode != -1) return ch;
909  }
910  }
911  return 999;
912 }

◆ last_highPt_code()

unsigned int CMAparameters::last_highPt_code ( ) const
inherited

Definition at line 61 of file CMAparameters.cxx.

61 { return m_last_highPt_code; }

◆ last_lowPt_channel()

unsigned int CMAparameters::last_lowPt_channel ( ) const
inherited

Definition at line 884 of file CMAparameters.cxx.

884  {
885  for (int ch = confirm_channels - 1; ch >= 0; --ch) {
886  for (int i = 0; i < m_lowPt_rpc_read; ++i) {
887  int CabCode = m_lowPt[i][0][ch];
888  if (CabCode != -1) return ch;
889  }
890  }
891  return 999;
892 }

◆ last_lowPt_code()

unsigned int CMAparameters::last_lowPt_code ( ) const
inherited

Definition at line 59 of file CMAparameters.cxx.

59 { return m_last_lowPt_code; }

◆ last_pivot_channel()

unsigned int CMAparameters::last_pivot_channel ( ) const
inherited

Definition at line 864 of file CMAparameters.cxx.

864  {
865  for (int ch = pivot_channels - 1; ch >= 0; --ch) {
866  for (int i = 0; i < m_pivot_rpc_read; ++i) {
867  int CabCode = m_pivot[i][0][ch];
868  if (CabCode != -1) return ch;
869  }
870  }
871  return 999;
872 }

◆ last_pivot_code()

unsigned int CMAparameters::last_pivot_code ( ) const
inherited

Definition at line 57 of file CMAparameters.cxx.

57 { return m_last_pivot_code; }

◆ lowPt_number_co()

int CMAparameters::lowPt_number_co ( ) const
inherited

Definition at line 28 of file CMAparameters.cxx.

28 { return m_params.lowPtNumCo; }

◆ lowPt_program()

const CMAprogram * CMAparameters::lowPt_program ( ) const
inherited

Definition at line 18 of file CMAparameters.cxx.

18 { return m_lowPt_program.get(); }

◆ lowPt_rpc_read()

int CMAparameters::lowPt_rpc_read ( ) const
inherited

Definition at line 53 of file CMAparameters.cxx.

53 { return m_lowPt_rpc_read; }

◆ lowPt_RPCs()

const RPClink& RPC_CondCabling::EtaCMA::lowPt_RPCs ( void  ) const
inline

Definition at line 45 of file EtaCMA.h.

45 { return m_lowPt_RPCs; }

◆ lowPt_start_ch()

int CMAparameters::lowPt_start_ch ( ) const
inherited

Definition at line 35 of file CMAparameters.cxx.

35 { return m_lowPt_start_ch; }

◆ lowPt_start_co()

int CMAparameters::lowPt_start_co ( ) const
inherited

Definition at line 26 of file CMAparameters.cxx.

26 { return m_params.lowPtStartCo; }

◆ lowPt_start_st()

int CMAparameters::lowPt_start_st ( ) const
inherited

Definition at line 34 of file CMAparameters.cxx.

34 { return m_lowPt_start_st; }

◆ lowPt_station()

int CMAparameters::lowPt_station ( ) const
inherited

Definition at line 49 of file CMAparameters.cxx.

49 { return m_params.lowPtStation; }

◆ lowPt_stop_ch()

int CMAparameters::lowPt_stop_ch ( ) const
inherited

Definition at line 37 of file CMAparameters.cxx.

37 { return m_lowPt_stop_ch; }

◆ lowPt_stop_co()

int CMAparameters::lowPt_stop_co ( ) const
inherited

Definition at line 27 of file CMAparameters.cxx.

27 { return m_params.lowPtStopCo; }

◆ lowPt_stop_st()

int CMAparameters::lowPt_stop_st ( ) const
inherited

Definition at line 36 of file CMAparameters.cxx.

36 { return m_lowPt_stop_st; }

◆ name()

std::string BaseObject::name ( ) const
inlineinherited

Definition at line 23 of file BaseObject.h.

23 { return m_name; }

◆ no_confirm_error()

std::string CMAparameters::no_confirm_error ( int  stat)
protectedinherited

Definition at line 524 of file CMAparameters.cxx.

524  {
525  std::ostringstream disp;
526  disp << this->error_header();
527 
528  if (stat == lowPt_station()) {
529  disp << "Low Pt cabling inconsistence (cabling from connector " << m_params.lowPtStartCo << " to connector " << m_params.lowPtStopCo
530  << ") for" << std::endl
531  << *this;
532  } else if (stat == highPt_station()) {
533  disp << "High Pt cabling inconsistence (cabling from connector " << m_params.highPtStartCo << " to connector "
534  << m_params.highPtStopCo << ") for" << std::endl
535  << *this;
536  }
537  return disp.str();
538 }

◆ no_connection_error()

std::string CablingObject::no_connection_error ( const std::string &  conn_name,
int  num 
) const
inherited

Definition at line 30 of file CablingObject.cxx.

30  {
31  std::ostringstream disp;
32  disp << error_header() << name() << " n. " << number() << " is supposed to receive input from " << conn_name << " n. " << num << " which doesn't exist!";
33  return disp.str();
34 }

◆ no_wor_readout()

std::string CMAparameters::no_wor_readout ( int  num,
int  stat 
)
protectedinherited

Definition at line 540 of file CMAparameters.cxx.

540  {
541  std::ostringstream disp;
542  disp << this->error_header();
543 
544  disp << this->id() << " receives input from" << std::endl
545  << " RPC chamber n. " << num << " of station " << stat << " which has no Wired OR readout!";
546  return disp.str();
547 }

◆ noMoreChannels()

std::string CMAparameters::noMoreChannels ( const std::string &  stat)
protectedinherited

Definition at line 481 of file CMAparameters.cxx.

481  {
482  int max_channels = 0;
483  if (stat == "Pivot")
484  max_channels = pivot_channels;
485  else
486  max_channels = confirm_channels;
487 
488  std::ostringstream disp;
489  disp << "Error in Sector Type " << this->sector_type() << ":" << std::endl
490  << this->id() << " attempted to receive more than " << max_channels << " channels for " << stat << " side";
491  return disp.str();
492 }

◆ number()

int CablingObject::number ( ) const
inherited

Definition at line 12 of file CablingObject.cxx.

12 { return m_number; }

◆ operator+=()

CMAparameters & CMAparameters::operator+= ( const CMAparameters &  cma)
inherited

Definition at line 262 of file CMAparameters.cxx.

262  {
263  if (m_params.pivotStartChan == -1) m_params.pivotStartChan = cma.pivot_start_ch();
264  if (m_params.pivotStartStation == -1) m_params.pivotStartStation = cma.pivot_start_st();
265  if (m_params.pivotStopChan == -1) m_params.pivotStopChan = cma.pivot_stop_ch();
266  if (m_params.pivotStopStation == -1) m_params.pivotStopStation = cma.pivot_stop_st();
267 
268  if (m_params.lowPtStartCo == -1) m_params.lowPtStartCo = cma.lowPt_start_co();
269  if (m_params.lowPtStopCo == -1) m_params.lowPtStopCo = cma.lowPt_stop_co();
270  if (m_params.lowPtNumCo == -1) m_params.lowPtNumCo = cma.lowPt_number_co();
271 
272  if (m_params.highPtStartCo == -1) m_params.highPtStartCo = cma.highPt_start_co();
273  if (m_params.highPtStopCo == -1) m_params.highPtStopCo = cma.highPt_stop_co();
274  if (m_params.highPtNumCo == -1) m_params.highPtNumCo = cma.highPt_number_co();
275 
276  if (m_params.lowPtStation == 0) m_params.lowPtStation = cma.lowPt_station();
277  if (m_params.pivotStation == 0) m_params.pivotStation = cma.pivot_station();
278  if (m_params.highPtStation == 0) m_params.highPtStation = cma.highPt_station();
279 
280  if (m_lowPt_start_st == -1) m_lowPt_start_st = cma.lowPt_start_st();
281  if (m_lowPt_start_ch == -1) m_lowPt_start_ch = cma.lowPt_start_ch();
282  if (m_lowPt_stop_st == -1) m_lowPt_stop_st = cma.lowPt_stop_st();
283  if (m_lowPt_stop_ch == -1) m_lowPt_stop_ch = cma.lowPt_stop_ch();
284 
285  if (m_highPt_start_st == -1) m_highPt_start_st = cma.highPt_start_st();
286  if (m_highPt_start_ch == -1) m_highPt_start_ch = cma.highPt_start_ch();
287  if (m_highPt_stop_st == -1) m_highPt_stop_st = cma.highPt_stop_st();
288  if (m_highPt_stop_ch == -1) m_highPt_stop_ch = cma.highPt_stop_ch();
289 
290  return *this;
291 }

◆ operator=()

EtaCMA & EtaCMA::operator= ( const EtaCMA &  cma)

Definition at line 43 of file EtaCMA.cxx.

43  {
44  if (this != &cma) {
45  CMAparameters::operator=(cma);
46  m_pivot_RPCs = cma.pivot_RPCs();
47  m_lowPt_RPCs = cma.lowPt_RPCs();
48  m_highPt_RPCs = cma.highPt_RPCs();
49  m_inversion = cma.inversion();
50  m_conf_type = CMAparameters::Atlas;
51  }
52  return *this;
53 }

◆ operator==() [1/2]

bool CMAparameters::operator== ( const CMAidentity &  id) const
inherited

Definition at line 258 of file CMAparameters.cxx.

258  {
259  return this->id() == id;
260 }

◆ operator==() [2/2]

bool CMAparameters::operator== ( const CMAparameters &  cma) const
inherited

Definition at line 254 of file CMAparameters.cxx.

254  {
255  return this->id() == cma.id();
256 }

◆ pivot_rpc_read()

int CMAparameters::pivot_rpc_read ( ) const
inherited

Definition at line 52 of file CMAparameters.cxx.

52 { return m_pivot_rpc_read; }

◆ pivot_RPCs()

const RPClink& RPC_CondCabling::EtaCMA::pivot_RPCs ( void  ) const
inline

Definition at line 44 of file EtaCMA.h.

44 { return m_pivot_RPCs; }

◆ pivot_start_ch()

int CMAparameters::pivot_start_ch ( ) const
inherited

Definition at line 21 of file CMAparameters.cxx.

21 { return m_params.pivotStartChan; }

◆ pivot_start_st()

int CMAparameters::pivot_start_st ( ) const
inherited

Definition at line 22 of file CMAparameters.cxx.

22 { return m_params.pivotStartStation; }

◆ pivot_station()

int CMAparameters::pivot_station ( ) const
inherited

Definition at line 48 of file CMAparameters.cxx.

48 { return m_params.pivotStation; }

◆ pivot_stop_ch()

int CMAparameters::pivot_stop_ch ( ) const
inherited

Definition at line 23 of file CMAparameters.cxx.

23 { return m_params.pivotStopChan; }

◆ pivot_stop_st()

int CMAparameters::pivot_stop_st ( ) const
inherited

Definition at line 24 of file CMAparameters.cxx.

24 { return m_params.pivotStopStation; }

◆ Print() [1/2]

void CMAparameters::Print ( std::ostream &  stream,
bool  detail 
) const
overridevirtualinherited

Reimplemented from BaseObject.

Definition at line 476 of file CMAparameters.cxx.

477 {
478  Print (stream, detail, 0);
479 }

◆ Print() [2/2]

void CMAparameters::Print ( std::ostream &  stream,
bool  detail,
int  layer 
) const
inherited

Definition at line 449 of file CMAparameters.cxx.

450 {
451  stream << id();
452 
453  stream << " I/O " << m_params.pivotStation << ",";
454  stream << m_params.lowPtStation << "," << m_params.highPtStation << " pivot ";
455  stream.fill(48);
456  stream << "<" << std::setw(2) << pivot_start_ch();
457  stream << ":" << std::setw(2) << pivot_start_st();
458  stream << " " << std::setw(2) << pivot_stop_ch() << ":";
459  stream << std::setw(2) << pivot_stop_st() << ">" << std::endl;
460  stream << " ";
461  stream << "lowPt <" << std::setw(2);
462 
463  stream << lowPt_start_ch() << ":" << std::setw(2) << lowPt_start_st();
464  stream << " " << std::setw(2) << lowPt_stop_ch() << ":";
465  stream << std::setw(2) << lowPt_stop_st() << ">" << std::endl;
466  stream << " ";
467  stream << "highPt<" << std::setw(2);
468 
469  stream << highPt_start_ch() << ":" << std::setw(2) << highPt_start_st();
470  stream << " " << std::setw(2) << highPt_stop_ch() << ":";
471  stream << std::setw(2) << highPt_stop_st() << ">" << std::endl;
472  stream.fill(32);
473  if (detail) showDt(stream, layer);
474 }

◆ reset_highPt_cabling()

void CMAparameters::reset_highPt_cabling ( )
privateinherited

Definition at line 221 of file CMAparameters.cxx.

221  {
222  m_highPt_rpc_read = 0;
223  if (m_highPt) delete[] m_highPt;
224  m_highPt = nullptr;
225 }

◆ reset_lowPt_cabling()

void CMAparameters::reset_lowPt_cabling ( )
privateinherited

Definition at line 215 of file CMAparameters.cxx.

215  {
216  m_lowPt_rpc_read = 0;
217  if (m_lowPt) delete[] m_lowPt;
218  m_lowPt = nullptr;
219 }

◆ reset_pivot_cabling()

void CMAparameters::reset_pivot_cabling ( )
privateinherited

Definition at line 209 of file CMAparameters.cxx.

209  {
210  m_pivot_rpc_read = 0;
211  if (m_pivot) delete[] m_pivot;
212  m_pivot = nullptr;
213 }

◆ sector_type()

int CablingObject::sector_type ( ) const
inherited

Definition at line 14 of file CablingObject.cxx.

14 { return m_sector_type; }

◆ setup()

bool EtaCMA::setup ( SectorLogicSetup &  setup,
MsgStream &  log 
)

Definition at line 241 of file EtaCMA.cxx.

241  {
242  // Connect the CMA with RPC chambers
243  if (!connect(setup)) return false;
244 
245  // Check boundary of CMA channels
246  EtaCMA* prev = setup.previousCMA(*this);
247  if (prev && pivot_station()) {
248  if (pivot_start_ch() == prev->pivot_stop_ch()) {
249  if (!(pivot_start_st() == prev->pivot_stop_st() + 1)) {
250  log << MSG::ERROR << two_obj_error_message("strips mismatch", prev) << endmsg;
251  return false;
252  }
253  } else if (!(pivot_start_ch() == prev->pivot_stop_ch() + 1)) {
254  log << MSG::ERROR << two_obj_error_message("chambers mismatch", prev) << endmsg;
255  return false;
256  } else {
257  if (!prev->end_at_RPC_Z_boundary() || !begin_at_RPC_Z_boundary()) {
258  log << MSG::ERROR << two_obj_error_message("boundary mismatch", prev) << endmsg;
259  return false;
260  }
261  }
262  }
263 
264  // Build the cabling map
265  if (!cable_CMA_channels(setup.side())) return false;
266 
267  // invert the strip cabling if needed
268  if (!doInversion(setup)) return false;
269 
270  // only 1 repository allowed so far
271  std::string LVL1_configuration_repository;
272  LVL1_configuration_repository = "ATLAS.data";
273 
274  // Read the program file if exist
275  SectorLogicSetup::SECTORlist sectors = setup.sectors();
276  SectorLogicSetup::SECTORlist::const_iterator it = sectors.begin();
277 
278  char s_tag[4];
279  sprintf(s_tag, "s%02d", *it);
280 
281  char t_tag[3];
282  sprintf(t_tag, "t%1d", id().PAD_index());
283 
284  char c_tag[4] = {'_', 'c', '2', '\0'};
285  if (id().Ixx_index() == 1) c_tag[2] = '3';
286 
287  std::ifstream CMAprogLow;
288  std::istringstream CMAprogLow_COOL;
289  char name[200];
290 
291  // LB retrieve pointer to the map of the trigger roads
292  const std::map<std::string, std::string>* p_trigroads = setup.GetPtoTrigRoads();
293 
294  // Read trigger configurations from files
295 
296  if (p_trigroads == nullptr) {
297  while (!CMAprogLow.is_open() && it != sectors.end()) {
298  std::ostringstream namestr;
299 
300  std::string dir;
301  dir = setup.online_database();
302  namestr << dir << "/" << s_tag << "_" << t_tag << "_pl" << c_tag << ".txt" << std::ends; // M.C. search for local files
303 
304  namestr.str().copy(name, namestr.str().length(), 0);
305  name[namestr.str().length()] = 0;
306  if (log.level() <= MSG::DEBUG) {
307  log << "filename for the trigger roads " << name << endmsg;
308  }
309 
310  CMAprogLow.open(name);
311  ++it;
312  namestr.clear();
313  }
314  }
315  // Trigger configuration loaded from COOL
316  else {
317  while (CMAprogLow_COOL.str().empty() && it != sectors.end()) {
318  std::ostringstream namestr;
319  namestr << s_tag << "_" << t_tag << "_pl" << c_tag << ".txt" << std::ends;
320  namestr.str().copy(name, namestr.str().length(), 0);
321  name[namestr.str().length()] = 0;
322  std::map<std::string, std::string>::const_iterator itc;
323  itc = p_trigroads->find(name);
324  if (itc != p_trigroads->end()) {
325  CMAprogLow_COOL.str(itc->second.c_str());
326 
327  if (log.level() <= MSG::VERBOSE) {
328  log << MSG::VERBOSE << "EtaCMA low: key " << name << "found in the Trigger Road Map --> OK"
329  << ", EtaCMA low: key " << itc->second.c_str()
330  << ", Etacma:CMAPROGLOW " << CMAprogLow_COOL.str()
331  << endmsg;
332  }
333  }
334  ++it;
335  namestr.clear();
336  }
337  }
338  if (CMAprogLow.is_open()) {
339  std::unique_ptr<CMAprogram> program = std::make_unique<CMAprogram>(CMAprogLow, true);
340  if (program->check()) {
341  m_lowPt_program = std::move(program);
342  if (setup.cosmic()) {
343  m_lowPt_program->open_threshold(0);
344  m_lowPt_program->open_threshold(1);
345  }
346  for (unsigned int i = 0; i < 3; ++i) {
347  if (!m_lowPt_program->hasProgrammed(i)) {
348  if (log.level() <= MSG::DEBUG) {
349  log << MSG::DEBUG << s_tag << ": " << id() << ": low-pt: has threshold " << i
350  << " not programmed." << endmsg;
351  }
352  }
353  }
354  }
355  CMAprogLow.close();
356  if (log.level() <= MSG::DEBUG) {
357  log << MSG::DEBUG << "EtaCMA::setup low_pt program has been read ---- " << endmsg;
358  }
359  } else if (!CMAprogLow_COOL.str().empty()) {
360  std::unique_ptr<CMAprogram> program = std::make_unique<CMAprogram>(CMAprogLow_COOL, true);
361  if (program->check()) {
362  m_lowPt_program = std::move(program);
363  if (setup.cosmic()) {
364  m_lowPt_program->open_threshold(0);
365  m_lowPt_program->open_threshold(1);
366  }
367  for (unsigned int i = 0; i < 3; ++i) {
368  if (!m_lowPt_program->hasProgrammed(i)) {
369  if (log.level() <= MSG::DEBUG) {
370  log << MSG::DEBUG << s_tag << ": " << id() << ": low-pt: has threshold " << i
371  << " not programmed." << endmsg;
372  }
373  }
374  }
375  }
376  CMAprogLow_COOL.str("");
377  } else {
378  if (log.level() <= MSG::DEBUG) {
379  log << MSG::DEBUG << name << " not found! Putting a dummy configuration" << endmsg;
380  }
381  m_lowPt_program = std::make_unique<CMAprogram>();
382  m_lowPt_program->open_threshold(0);
383  }
384 
385  it = sectors.begin();
386  std::ifstream CMAprogHigh;
387  std::istringstream CMAprogHigh_COOL;
388 
389  if (p_trigroads == nullptr) {
390  while (!CMAprogHigh.is_open() && it != sectors.end()) {
391  std::ostringstream namestr;
392  std::string dir;
393  dir = setup.online_database();
394  namestr << dir << "/" << s_tag << "_" << t_tag << "_ph" << c_tag << ".txt" << std::ends;
395 
396  namestr.str().copy(name, namestr.str().length(), 0);
397  name[namestr.str().length()] = 0;
398  if (log.level() <= MSG::DEBUG) {
399  log << MSG::DEBUG << "filename for the trigger roads " << name << endmsg;
400  }
401  CMAprogHigh.open(name);
402  ++it;
403  namestr.clear();
404  }
405  }
406  // Trigger configuration loaded from COOL
407  else {
408  while (CMAprogHigh_COOL.str().empty() && it != sectors.end()) {
409  std::ostringstream namestr;
410  namestr << s_tag << "_" << t_tag << "_ph" << c_tag << ".txt" << std::ends;
411  namestr.str().copy(name, namestr.str().length(), 0);
412  name[namestr.str().length()] = 0;
413  std::map<std::string, std::string>::const_iterator itc;
414  itc = p_trigroads->find(name);
415  if (itc != p_trigroads->end()) {
416  if (log.level() <= MSG::VERBOSE) {
417  log << MSG::VERBOSE << "EtaCMA high: key " << name << "found in the Trigger Road Map --> OK"
418  << ", EtaCMA high: key " << itc->second.c_str() << endmsg;
419  }
420  CMAprogHigh_COOL.str(itc->second.c_str());
421  if (log.level() <= MSG::VERBOSE) {
422  log << MSG::VERBOSE << "EtaCMA:CMAPROGHIGH " << CMAprogHigh_COOL.str() << endmsg;
423  }
424  }
425  ++it;
426  namestr.clear();
427  }
428  }
429 
430  if (CMAprogHigh.is_open()) {
431  std::unique_ptr<CMAprogram> program = std::make_unique<CMAprogram>(CMAprogHigh, true);
432  if (program->check()) {
433  m_highPt_program = std::move(program);
434  if (setup.cosmic()) {
435  m_highPt_program->open_threshold(0);
436  m_highPt_program->open_threshold(1);
437  }
438  for (unsigned int i = 0; i < 3; ++i) {
439  if (!m_highPt_program->hasProgrammed(i)) {
440  if (log.level() <= MSG::DEBUG) {
441  log << MSG::DEBUG << s_tag << ": " << id() << ": high-pt: has threshold " << i
442  << " not programmed." << endmsg;
443  }
444  }
445  }
446  }
447  CMAprogHigh.close();
448  if (log.level() <= MSG::DEBUG) {
449  log << MSG::DEBUG << "EtaCMA::setup high_pt program has been read ---- " << endmsg;
450  }
451  } else if (!CMAprogHigh_COOL.str().empty()) {
452  std::unique_ptr<CMAprogram> program = std::make_unique<CMAprogram>(CMAprogHigh_COOL, true);
453  if (program->check()) {
454  m_highPt_program = std::move(program);
455  if (setup.cosmic()) {
456  m_highPt_program->open_threshold(0);
457  m_highPt_program->open_threshold(1);
458  }
459  for (unsigned int i = 0; i < 3; ++i) {
460  if (!m_highPt_program->hasProgrammed(i)) {
461  if (log.level() <= MSG::DEBUG) {
462  log << MSG::DEBUG << s_tag << ": " << id() << ": high-pt: has threshold " << i
463  << " not programmed." << endmsg;
464  }
465  }
466  }
467  }
468  CMAprogHigh_COOL.str("");
469  } else {
470  if (log.level() <= MSG::DEBUG) {
471  log << MSG::DEBUG << " not found! Putting a dummy configuration" << endmsg;
472  }
473  m_highPt_program = std::make_unique<CMAprogram>();
474  m_highPt_program->open_threshold(0);
475  }
476 
477  return true;
478 }

◆ showDt()

void CMAparameters::showDt ( std::ostream &  stream,
int  layer 
) const
privateinherited

Definition at line 293 of file CMAparameters.cxx.

293  {
294  // Set the chracters used for matrix display
295  unsigned int finish = 164;
296 
297  if (!m_pivot) {
298  stream << std::endl << "Low Pt and Hi Pt not yet connected!" << std::endl;
299  for (int i = 0; i < 80; ++i) stream << (char)finish;
300  stream << std::endl;
301  return;
302  }
303 
304  // Set memory for the display
305  int ln = (m_lowPt_rpc_read > 0) ? (m_lowPt_rpc_read - 1) * 6 + 39 : 39;
306 
307  char(*displow)[90] = new char[ln][90];
308 
309  // Show Low Pt connections
310  stream << std::endl << "Low Pt matrix connections:" << std::endl << std::endl;
311  showMt(displow, ln, Low, layer);
312 
313  // Dumping memory on output stream
314  for (int i = 0; i < ln; ++i)
315  if (displow[i][0] != '\0') stream << displow[i] << std::endl;
316 
317  delete[] displow;
318 
319  // Show Hi Pt connections
320  stream << std::endl << std::endl << "Hi Pt matrix connections:" << std::endl << std::endl;
321 
322  ln = (m_highPt_rpc_read > 0) ? (m_highPt_rpc_read - 1) * 6 + 39 : 39;
323 
324  char(*disphi)[90] = new char[ln][90];
325 
326  showMt(disphi, ln, High, layer);
327 
328  // Dumping memory on output stream
329  for (int i = 0; i < ln; ++i)
330  if (disphi[i][0] != '\0') stream << disphi[i] << std::endl;
331 
332  delete[] disphi;
333 
334  stream << std::endl;
335  for (int i = 0; i < 80; ++i) stream << (char)finish;
336  stream << std::endl;
337 }

◆ showMt()

void CMAparameters::showMt ( char  display[][90],
int  ln,
TrigType  type,
int  layer 
) const
privateinherited

Definition at line 339 of file CMAparameters.cxx.

339  {
340  // Set the chracters used for matrix display
341  unsigned int up = 19;
342  unsigned int left = 22;
343  unsigned int right = 25;
344  unsigned int middle = 18;
345  unsigned int down = 24;
346 
347  // overwritting character using pipe and minus
348  left = 124;
349  right = 124;
350  up = 45;
351  down = 45;
352 
353  // Set input for the display
354  std::ostringstream** disp = new std::ostringstream*[ln];
355 
356  for (int i = 0; i < ln; ++i) disp[i] = new std::ostringstream;
357 
358  int pivot_loop = (m_pivot_rpc_read < 4) ? m_pivot_rpc_read : 3;
359  int conf_loop = 0;
360  int(*conf)[2][confirm_channels] = nullptr;
361 
362  const CMAprogram* program = nullptr;
363 
364  if (type == Low) {
365  conf_loop = m_lowPt_rpc_read;
366  conf = m_lowPt;
367  program = this->lowPt_program();
368  } else {
369  conf_loop = m_highPt_rpc_read;
370  conf = m_highPt;
371  program = this->highPt_program();
372  }
373 
374  int shift = 6 * pivot_loop;
375 
376  for (int i = 0; i < shift; ++i) *disp[0] << " ";
377  for (int i = 0; i < confirm_channels; ++i) (std::ostream&)*disp[0] << (char)up;
378 
379  for (int i = 1; i <= pivot_channels; ++i) {
380  // Display the cabling for the pivot plane
381  for (int j = 0; j < pivot_loop; ++j) {
382  if (j) *disp[i] << "|";
383  (*disp[i]).fill(48);
384  if (m_pivot[j][layer][pivot_channels - i] >= 0) {
385  *disp[i] << std::setw(5) << m_pivot[j][layer][pivot_channels - i];
386  } else
387  *disp[i] << "*****";
388  }
389 
390  // Display the trigger window for all tresholds
391  (std::ostream&)*disp[i] << (char)left;
392  for (int j = 0; j < confirm_channels; ++j) {
393  unsigned int no_coincidence = ':';
394  if (program) {
395  const bool* registers = program->registers();
396  int third = 2 * (pivot_channels * confirm_channels) + (pivot_channels - i) * confirm_channels + j;
397  int second = third - pivot_channels * confirm_channels;
398  int first = second - pivot_channels * confirm_channels;
399 
400  if (registers[third])
401  *disp[i] << "3";
402  else if (registers[second])
403  *disp[i] << "2";
404  else if (registers[first])
405  *disp[i] << "1";
406  else
407  (std::ostream&)*disp[i] << (char)no_coincidence;
408 
409  } else
410  *disp[i] << " ";
411  }
412  (std::ostream&)*disp[i] << (char)right;
413  }
414 
415  // Display the cabling for the confirm plane
416  int start_confirm = pivot_channels + 1;
417  for (int j = 0; j < shift; ++j) *disp[start_confirm] << " ";
418  for (int i = start_confirm + 1; i < start_confirm + conf_loop * 6; ++i)
419  for (int j = 0; j < shift; ++j) *disp[i] << " ";
420 
421  for (int i = 0; i < confirm_channels; ++i) (std::ostream&)*disp[start_confirm] << (char)down;
422 
423  for (int i = 0; i < conf_loop; ++i) {
424  int start = (i) ? start_confirm + i * 6 : start_confirm + 1;
425  if (i) {
426  for (int ch = 1; ch <= confirm_channels; ++ch) (std::ostream&)*disp[start] << (char)middle;
427  ++start;
428  }
429 
430  for (int j = 0; j < 5; ++j)
431  for (int ch = 0; ch < confirm_channels; ++ch) {
432  if (conf[i][layer][ch] >= 0) {
433  (std::ostream&)*disp[start + j] << (conf[i][layer][ch] / static_cast<int>(pow(10., j))) % 10;
434  } else
435  (std::ostream&)*disp[start + j] << "*";
436  }
437  }
438 
439  for (int i = 0; i < ln; ++i) {
440  std::string tmp = (*disp[i]).str();
441  tmp.copy(display[i], tmp.length(), 0);
442  display[i][tmp.length()] = 0;
443  delete disp[i];
444  }
445 
446  delete[] disp;
447 }

◆ station()

int CablingObject::station ( ) const
inherited

Definition at line 13 of file CablingObject.cxx.

13 { return m_station; }

◆ tag()

ObjectType BaseObject::tag ( ) const
inlineinherited

Definition at line 22 of file BaseObject.h.

22 { return m_tag; }

◆ test()

const CMAparameters * CMAparameters::test ( CMAinput  input,
int  cabling_code 
) const
inherited

Definition at line 494 of file CMAparameters.cxx.

494  {
495  int* strips = nullptr;
496  int nstrips = 0;
497 
498  if (input == Pivot && m_pivot) {
499  nstrips = pivot_channels * m_pivot_rpc_read * 2;
500  strips = reinterpret_cast<int*>(m_pivot);
501  } else if (input == LowPt && m_lowPt) {
502  nstrips = confirm_channels * m_lowPt_rpc_read * 2;
503  strips = reinterpret_cast<int*>(m_lowPt);
504  } else if (input == HighPt && m_highPt) {
505  nstrips = confirm_channels * m_highPt_rpc_read * 2;
506  strips = reinterpret_cast<int*>(m_highPt);
507  } else
508  return nullptr;
509 
510  for (int i = 0; i < nstrips; ++i)
511  if (strips[i] == cabling_code) return this;
512 
513  return nullptr;
514 }

◆ two_obj_error_message()

std::string CMAparameters::two_obj_error_message ( const std::string &  msg,
CMAparameters *  cma 
)
protectedinherited

Definition at line 516 of file CMAparameters.cxx.

516  {
517  std::ostringstream disp;
518  disp << this->error_header()
519  << " " << msg << " between " << name() << " n. " << number() << " and " << cma->name() << " n. " << cma->number() << std::endl
520  << *this << *cma;
521  return disp.str();
522 }

◆ whichCMAinput()

CMAinput CMAparameters::whichCMAinput ( int  stat) const
inherited

Definition at line 556 of file CMAparameters.cxx.

556  {
557  if (stat == m_params.pivotStation)
558  return Pivot;
559  else if (stat == m_params.lowPtStation)
560  return LowPt;
561  else if (stat == m_params.highPtStation)
562  return HighPt;
563  else
564  return NoInput;
565 }

◆ whichCMAstation()

int CMAparameters::whichCMAstation ( CMAinput  input) const
inherited

Definition at line 567 of file CMAparameters.cxx.

567  {
568  if (input == CMAinput::Pivot)
569  return m_params.pivotStation;
570  else if (input == CMAinput::LowPt)
571  return m_params.lowPtStation;
572  else if (input == CMAinput::HighPt)
573  return m_params.highPtStation;
574  else
575  return 0;
576 }

Member Data Documentation

◆ confirm_channels

constexpr int CMAparameters::confirm_channels = 64
staticconstexprinherited

Definition at line 70 of file CMAparameters.h.

◆ m_active_highPt_chs

int CMAparameters::m_active_highPt_chs {0}
protectedinherited

Definition at line 87 of file CMAparameters.h.

◆ m_active_lowPt_chs

int CMAparameters::m_active_lowPt_chs {0}
protectedinherited

Definition at line 86 of file CMAparameters.h.

◆ m_active_pivot_chs

int CMAparameters::m_active_pivot_chs {0}
protectedinherited

Definition at line 85 of file CMAparameters.h.

◆ m_conf_type

CMAconfiguration CMAparameters::m_conf_type {CMAparameters::Atlas}
protectedinherited

Definition at line 107 of file CMAparameters.h.

◆ m_first_highPt_code

unsigned int CMAparameters::m_first_highPt_code {0}
protectedinherited

Definition at line 97 of file CMAparameters.h.

◆ m_first_lowPt_code

unsigned int CMAparameters::m_first_lowPt_code {0}
protectedinherited

Definition at line 95 of file CMAparameters.h.

◆ m_first_pivot_code

unsigned int CMAparameters::m_first_pivot_code {0}
protectedinherited

Definition at line 93 of file CMAparameters.h.

◆ m_highPt

int(* CMAparameters::m_highPt)[2][confirm_channels] {}
protectedinherited

Definition at line 102 of file CMAparameters.h.

◆ m_highPt_program

std::unique_ptr<CMAprogram> CMAparameters::m_highPt_program
protectedinherited

Definition at line 105 of file CMAparameters.h.

◆ m_highPt_rpc_read

int CMAparameters::m_highPt_rpc_read {0}
protectedinherited

Definition at line 91 of file CMAparameters.h.

◆ m_highPt_RPCs

RPClink RPC_CondCabling::EtaCMA::m_highPt_RPCs
private

Definition at line 26 of file EtaCMA.h.

◆ m_highPt_start_ch

int CMAparameters::m_highPt_start_ch {-1}
protectedinherited

Definition at line 81 of file CMAparameters.h.

◆ m_highPt_start_st

int CMAparameters::m_highPt_start_st {-1}
protectedinherited

Definition at line 80 of file CMAparameters.h.

◆ m_highPt_stop_ch

int CMAparameters::m_highPt_stop_ch {-1}
protectedinherited

Definition at line 83 of file CMAparameters.h.

◆ m_highPt_stop_st

int CMAparameters::m_highPt_stop_st {-1}
protectedinherited

Definition at line 82 of file CMAparameters.h.

◆ m_id

std::unique_ptr<CMAidentity> CMAparameters::m_id
protectedinherited

Definition at line 73 of file CMAparameters.h.

◆ m_inversion

bool RPC_CondCabling::EtaCMA::m_inversion {false}
private

Definition at line 28 of file EtaCMA.h.

◆ m_last_highPt_code

unsigned int CMAparameters::m_last_highPt_code {0}
protectedinherited

Definition at line 98 of file CMAparameters.h.

◆ m_last_lowPt_code

unsigned int CMAparameters::m_last_lowPt_code {0}
protectedinherited

Definition at line 96 of file CMAparameters.h.

◆ m_last_pivot_code

unsigned int CMAparameters::m_last_pivot_code {0}
protectedinherited

Definition at line 94 of file CMAparameters.h.

◆ m_lowPt

int(* CMAparameters::m_lowPt)[2][confirm_channels] {}
protectedinherited

Definition at line 101 of file CMAparameters.h.

◆ m_lowPt_program

std::unique_ptr<CMAprogram> CMAparameters::m_lowPt_program
protectedinherited

Definition at line 104 of file CMAparameters.h.

◆ m_lowPt_rpc_read

int CMAparameters::m_lowPt_rpc_read {0}
protectedinherited

Definition at line 90 of file CMAparameters.h.

◆ m_lowPt_RPCs

RPClink RPC_CondCabling::EtaCMA::m_lowPt_RPCs
private

Definition at line 25 of file EtaCMA.h.

◆ m_lowPt_start_ch

int CMAparameters::m_lowPt_start_ch {-1}
protectedinherited

Definition at line 76 of file CMAparameters.h.

◆ m_lowPt_start_st

int CMAparameters::m_lowPt_start_st {-1}
protectedinherited

Definition at line 75 of file CMAparameters.h.

◆ m_lowPt_stop_ch

int CMAparameters::m_lowPt_stop_ch {-1}
protectedinherited

Definition at line 78 of file CMAparameters.h.

◆ m_lowPt_stop_st

int CMAparameters::m_lowPt_stop_st {-1}
protectedinherited

Definition at line 77 of file CMAparameters.h.

◆ m_name

std::string BaseObject::m_name
privateinherited

Definition at line 16 of file BaseObject.h.

◆ m_number

int CablingObject::m_number {0}
privateinherited

Definition at line 12 of file CablingObject.h.

◆ m_params

defineParams CMAparameters::m_params {}
privateinherited

Definition at line 59 of file CMAparameters.h.

◆ m_pivot

int(* CMAparameters::m_pivot)[2][pivot_channels] {}
protectedinherited

Definition at line 100 of file CMAparameters.h.

◆ m_pivot_rpc_read

int CMAparameters::m_pivot_rpc_read {0}
protectedinherited

Definition at line 89 of file CMAparameters.h.

◆ m_pivot_RPCs

RPClink RPC_CondCabling::EtaCMA::m_pivot_RPCs
private

Definition at line 24 of file EtaCMA.h.

◆ m_sector_type

int CablingObject::m_sector_type {0}
privateinherited

Definition at line 14 of file CablingObject.h.

◆ m_station

int CablingObject::m_station {0}
privateinherited

Definition at line 13 of file CablingObject.h.

◆ m_tag

ObjectType BaseObject::m_tag
privateinherited

Definition at line 15 of file BaseObject.h.

◆ pivot_channels

constexpr int CMAparameters::pivot_channels = 32
staticconstexprinherited

Definition at line 69 of file CMAparameters.h.

The documentation for this class was generated from the following files:
CMAparameters::Simulation
@ Simulation
Definition: CMAparameters.h:23
CMAparameters::two_obj_error_message
std::string two_obj_error_message(const std::string &, CMAparameters *)
Definition: CMAparameters.cxx:516
CMAparameters::highPt_start_st
int highPt_start_st() const
Definition: CMAparameters.cxx:39
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
CMAparameters::defineParams::pivotStopChan
int pivotStopChan
RPC chamber to which the RPC strip belongs.
Definition: CMAparameters.h:39
CMAparameters::m_highPt_stop_st
int m_highPt_stop_st
Definition: CMAparameters.h:82
RPCdecoder
Definition: RPCdecoder.h:13
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
CMAparameters::no_confirm_error
std::string no_confirm_error(int)
Definition: CMAparameters.cxx:524
CMAparameters::lowPt_station
int lowPt_station() const
Definition: CMAparameters.cxx:49
DiTauMassTools::TauTypes::lh
@ lh
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:49
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
CMAparameters::showMt
void showMt(char[][90], int, TrigType, int layer) const
Definition: CMAparameters.cxx:339
CMAparameters::whichCMAstation
int whichCMAstation(CMAinput input) const
Definition: CMAparameters.cxx:567
get_generator_info.result
result
Definition: get_generator_info.py:21
RPC_CondCabling::SectorLogicSetup::SECTORlist
std::list< int > SECTORlist
Definition: SectorLogicSetup.h:32
CMAparameters::defineParams::lowPtStation
int lowPtStation
RPC station number giving input to pivot chs.
Definition: CMAparameters.h:34
CMAparameters::highPt_stop_co
int highPt_stop_co() const
Definition: CMAparameters.cxx:31
CablingObject::m_station
int m_station
Definition: CablingObject.h:13
CMAparameters::highPt_start_ch
int highPt_start_ch() const
Definition: CMAparameters.cxx:40
CMAparameters::defineParams::pivotStation
int pivotStation
Definition: CMAparameters.h:33
CMAparameters::defineParams::highPtStartCo
int highPtStartCo
Number of connectors giving input to the matrix.
Definition: CMAparameters.h:46
RPC_CondCabling::RPCchamber::strips_in_Eta_Conn
int strips_in_Eta_Conn() const
Definition: RPCchamber.cxx:40
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
CMAparameters::first_lowPt_channel
unsigned int first_lowPt_channel() const
Definition: CMAparameters.cxx:874
LArBadChanBlobUtils::Channel
Identifier32::value_type Channel
Definition: LArBadChanBlobUtils.h:24
RPC_CondCabling::EtaCMA::m_inversion
bool m_inversion
Definition: EtaCMA.h:28
Pivot
@ Pivot
Definition: CMAparameters.h:18
BaseObject::m_name
std::string m_name
Definition: BaseObject.h:16
RPC_CondCabling::EtaCMA::lowPt_RPCs
const RPClink & lowPt_RPCs(void) const
Definition: EtaCMA.h:45
Inversion
@ Inversion
Definition: CMAparameters.h:19
HighPt
@ HighPt
Definition: CMAparameters.h:18
CMAparameters::CMAparameters
CMAparameters(const parseParams &parse)
Definition: CMAparameters.cxx:65
CMAparameters::m_active_lowPt_chs
int m_active_lowPt_chs
Definition: CMAparameters.h:86
RPC_CondCabling::EtaCMA::m_highPt_RPCs
RPClink m_highPt_RPCs
Definition: EtaCMA.h:26
CMAparameters::lowPt_program
const CMAprogram * lowPt_program() const
Definition: CMAparameters.cxx:18
RPC_CondCabling::EtaCMA
Definition: EtaCMA.h:20
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:14
xAOD::char
char
Definition: TrigDecision_v1.cxx:38
parse
std::map< std::string, std::string > parse(const std::string &list)
Definition: egammaLayerRecalibTool.cxx:983
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
CMAparameters::last_pivot_channel
unsigned int last_pivot_channel() const
Definition: CMAparameters.cxx:864
skel.it
it
Definition: skel.GENtoEVGEN.py:423
CMAparameters::m_first_highPt_code
unsigned int m_first_highPt_code
Definition: CMAparameters.h:97
CMAparameters::highPt_stop_ch
int highPt_stop_ch() const
Definition: CMAparameters.cxx:42
CMAparameters::m_first_pivot_code
unsigned int m_first_pivot_code
Definition: CMAparameters.h:93
CMAparameters::defineParams::lowPtStartCo
int lowPtStartCo
RPC chamber to which the RPC strip belongs.
Definition: CMAparameters.h:42
LowPt
@ LowPt
Definition: CMAparameters.h:18
CMAparameters::lowPt_stop_co
int lowPt_stop_co() const
Definition: CMAparameters.cxx:27
CMAparameters::m_pivot_rpc_read
int m_pivot_rpc_read
Definition: CMAparameters.h:89
RPC_CondCabling::RPCchamber::add_eta_channel
void add_eta_channel(int)
Definition: RPCchamber.cxx:297
CMAprogram::check
bool check(void) const
Definition: CMAprogram.h:122
CMAparameters::m_id
std::unique_ptr< CMAidentity > m_id
Definition: CMAparameters.h:73
NoHalf
@ NoHalf
Definition: RPCdef.h:9
detail
Definition: extract_histogram_tag.cxx:14
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
CMAparameters::id
const CMAidentity & id() const
Definition: CMAparameters.cxx:17
PixelModuleFeMask_create_db.stop
int stop
Definition: PixelModuleFeMask_create_db.py:76
CMAparameters::m_conf_type
CMAconfiguration m_conf_type
Definition: CMAparameters.h:107
CMAparameters::defineParams::pivotStartChan
int pivotStartChan
RPC station number giving input to High Pt ch.
Definition: CMAparameters.h:37
CMAparameters::last_lowPt_channel
unsigned int last_lowPt_channel() const
Definition: CMAparameters.cxx:884
CMAparameters::m_pivot
int(* m_pivot)[2][pivot_channels]
Definition: CMAparameters.h:100
CMAparameters::defineParams::lowPtStopCo
int lowPtStopCo
First connector (global-addr) for LowPt confirm.
Definition: CMAparameters.h:43
RPC_CondCabling::EtaCMA::cable_CMA_channels
bool cable_CMA_channels(HalfType)
Definition: EtaCMA.cxx:55
AthenaPoolTestWrite.stream
string stream
Definition: AthenaPoolTestWrite.py:12
CMAparameters::m_lowPt_rpc_read
int m_lowPt_rpc_read
Definition: CMAparameters.h:90
Swap
@ Swap
Definition: CMAparameters.h:19
CMAparameters::pivot_start_st
int pivot_start_st() const
Definition: CMAparameters.cxx:22
CMAparameters::highPt_number_co
int highPt_number_co() const
Definition: CMAparameters.cxx:32
CMAparameters::correct
bool correct(L1RPCcabCorrection type, CMAinput it, unsigned int layer, unsigned short int Ch1, unsigned short int Ch2, short int num) const
Definition: CMAparameters.cxx:646
CMAparameters::m_last_lowPt_code
unsigned int m_last_lowPt_code
Definition: CMAparameters.h:96
dq_defect_copy_defect_database.channels
def channels
Definition: dq_defect_copy_defect_database.py:56
CMAparameters::confirm_channels
static constexpr int confirm_channels
Definition: CMAparameters.h:70
CMAparameters::m_highPt_stop_ch
int m_highPt_stop_ch
Definition: CMAparameters.h:83
CMAparameters::lowPt_start_co
int lowPt_start_co() const
Definition: CMAparameters.cxx:26
TRT::Hit::side
@ side
Definition: HitInfo.h:83
RPC_CondCabling::EtaCMA::end_at_RPC_Z_boundary
bool end_at_RPC_Z_boundary(void) const
Definition: EtaCMA.cxx:527
CablingObject::station
int station() const
Definition: CablingObject.cxx:13
RPC_CondCabling::RPCchamber::ijk_etaReadout
int ijk_etaReadout() const
Definition: RPCchamber.cxx:30
CMAparameters::lowPt_start_ch
int lowPt_start_ch() const
Definition: CMAparameters.cxx:35
RPCdecoder::code
unsigned int code(void) const
Definition: RPCdecoder.h:64
CMAparameters::m_highPt
int(* m_highPt)[2][confirm_channels]
Definition: CMAparameters.h:102
CMAparameters::m_lowPt_stop_st
int m_lowPt_stop_st
Definition: CMAparameters.h:77
CMAparameters::defineParams::lowPtNumCo
int lowPtNumCo
Last connector (global-addr) for LowPt confirm.
Definition: CMAparameters.h:44
CMAparameters::m_first_lowPt_code
unsigned int m_first_lowPt_code
Definition: CMAparameters.h:95
python.ConfigurableDb.conf
def conf
Definition: ConfigurableDb.py:282
CMAparameters::defineParams::highPtStation
int highPtStation
RPC station number giving input to Low Pt ch.
Definition: CMAparameters.h:35
CMAparameters::m_active_pivot_chs
int m_active_pivot_chs
Definition: CMAparameters.h:85
CMAparameters::m_highPt_rpc_read
int m_highPt_rpc_read
Definition: CMAparameters.h:91
lumiFormat.i
int i
Definition: lumiFormat.py:92
CMAparameters::pivot_station
int pivot_station() const
Definition: CMAparameters.cxx:48
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
CMAparameters::m_active_highPt_chs
int m_active_highPt_chs
Definition: CMAparameters.h:87
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
CMAparameters::m_highPt_program
std::unique_ptr< CMAprogram > m_highPt_program
Definition: CMAparameters.h:105
PlotPulseshapeFromCool.input
input
Definition: PlotPulseshapeFromCool.py:106
CablingObject::error_header
std::string error_header() const
Definition: CablingObject.cxx:22
CalibCoolCompareRT.up
up
Definition: CalibCoolCompareRT.py:109
BaseObject::name
std::string name() const
Definition: BaseObject.h:23
CMAparameters::m_params
defineParams m_params
Definition: CMAparameters.h:59
CMAparameters::m_last_highPt_code
unsigned int m_last_highPt_code
Definition: CMAparameters.h:98
RPC_CondCabling::EtaCMA::pivot_RPCs
const RPClink & pivot_RPCs(void) const
Definition: EtaCMA.h:44
CMAparameters::operator=
CMAparameters & operator=(const CMAparameters &)
Definition: CMAparameters.cxx:138
CMAparameters::m_lowPt_stop_ch
int m_lowPt_stop_ch
Definition: CMAparameters.h:78
CMAparameters::defineParams::pivotStopStation
int pivotStopStation
Definition: CMAparameters.h:40
CMAparameters::m_lowPt
int(* m_lowPt)[2][confirm_channels]
Definition: CMAparameters.h:101
CMAparameters::highPt_program
const CMAprogram * highPt_program() const
Definition: CMAparameters.cxx:19
RPC_CondCabling::EtaCMA::highPt_RPCs
const RPClink & highPt_RPCs(void) const
Definition: EtaCMA.h:46
CMAparameters::noMoreChannels
std::string noMoreChannels(const std::string &stat)
Definition: CMAparameters.cxx:481
CMAparameters::lowPt_start_st
int lowPt_start_st() const
Definition: CMAparameters.cxx:34
CMAparameters::create_lowPt_map
void create_lowPt_map(int)
Definition: CMAparameters.cxx:236
RPC_CondCabling::EtaCMA::setup
bool setup(SectorLogicSetup &, MsgStream &)
Definition: EtaCMA.cxx:241
CablingObject::m_sector_type
int m_sector_type
Definition: CablingObject.h:14
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
CMAparameters::first_pivot_channel
unsigned int first_pivot_channel() const
Definition: CMAparameters.cxx:854
pyroot.display
display
Definition: pyroot.py:44
beamspotman.stat
stat
Definition: beamspotman.py:266
RPC_CondCabling::EtaCMA::got_confirm_cabling
bool got_confirm_cabling(SectorLogicSetup &, int)
Definition: EtaCMA.cxx:213
Negative
@ Negative
Definition: RPCdef.h:9
CMAparameters::defineParams::highPtNumCo
int highPtNumCo
Last connector (global-addr) for HiPt confirm.
Definition: CMAparameters.h:48
CMAprogram
Definition: CMAprogram.h:11
beamspotman.dir
string dir
Definition: beamspotman.py:623
trigbs_pickEvents.num
num
Definition: trigbs_pickEvents.py:76
REPORT_MESSAGE_WITH_CONTEXT
#define REPORT_MESSAGE_WITH_CONTEXT(LVL, CONTEXT_NAME)
Report a message, with an explicitly specified context name.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:345
RPC_CondCabling::EtaCMA::connect
bool connect(SectorLogicSetup &)
Definition: EtaCMA.cxx:156
pmontree.code
code
Definition: pmontree.py:443
CMAparameters::create_highPt_map
void create_highPt_map(int)
Definition: CMAparameters.cxx:245
RPC_CondCabling::EtaCMA::m_lowPt_RPCs
RPClink m_lowPt_RPCs
Definition: EtaCMA.h:25
CMAparameters::last_highPt_channel
unsigned int last_highPt_channel() const
Definition: CMAparameters.cxx:904
CMAparameters::defineParams::highPtStopCo
int highPtStopCo
First connector (global-addr) for HiPt confirm.
Definition: CMAparameters.h:47
Low
@ Low
Definition: TRIGGERidentity.h:17
CMAparameters::m_highPt_start_ch
int m_highPt_start_ch
Definition: CMAparameters.h:81
RPC_CondCabling::RPCchamber
Definition: RPCchamber.h:23
CablingObject::number
int number() const
Definition: CablingObject.cxx:12
Suppression
@ Suppression
Definition: CMAparameters.h:19
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
CablingObject::m_number
int m_number
Definition: CablingObject.h:12
RPC_CondCabling::EtaCMA::doInversion
bool doInversion(SectorLogicSetup &)
Definition: EtaCMA.cxx:480
CMAparameters::lowPt_stop_st
int lowPt_stop_st() const
Definition: CMAparameters.cxx:36
RPC_CondCabling::EtaCMA::inversion
bool inversion(void) const
Definition: EtaCMA.h:48
CMAparameters::whichCMAinput
CMAinput whichCMAinput(int) const
Definition: CMAparameters.cxx:556
CMAparameters::lowPt_stop_ch
int lowPt_stop_ch() const
Definition: CMAparameters.cxx:37
CMAparameters::m_lowPt_start_ch
int m_lowPt_start_ch
Definition: CMAparameters.h:76
RPC_CondCabling::RPCchamber::add_cma
void add_cma(const EtaCMA *)
Definition: RPCchamber.cxx:293
RPC_CondCabling::EtaCMA::begin_at_RPC_Z_boundary
bool begin_at_RPC_Z_boundary(void) const
Definition: EtaCMA.cxx:532
CMAparameters::Print
virtual void Print(std::ostream &, bool) const override
Definition: CMAparameters.cxx:476
CMAparameters::highPt_station
int highPt_station() const
Definition: CMAparameters.cxx:50
CMAparameters::first_highPt_channel
unsigned int first_highPt_channel() const
Definition: CMAparameters.cxx:894
CondAlgsOpts.found
int found
Definition: CondAlgsOpts.py:101
python.CaloScaleNoiseConfig.str
str
Definition: CaloScaleNoiseConfig.py:78
CMAparameters::m_last_pivot_code
unsigned int m_last_pivot_code
Definition: CMAparameters.h:94
lumiFormat.fill
fill
Definition: lumiFormat.py:111
NoInput
@ NoInput
Definition: CMAparameters.h:18
BaseObject::m_tag
ObjectType m_tag
Definition: BaseObject.h:15
High
@ High
Definition: TRIGGERidentity.h:17
CMAparameters::lowPt_number_co
int lowPt_number_co() const
Definition: CMAparameters.cxx:28
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
DeMoScan.first
bool first
Definition: DeMoScan.py:534
CMAparameters::highPt_stop_st
int highPt_stop_st() const
Definition: CMAparameters.cxx:41
DEBUG
#define DEBUG
Definition: page_access.h:11
RPC_CondCabling::EtaCMA::m_pivot_RPCs
RPClink m_pivot_RPCs
Definition: EtaCMA.h:24
CMAparameters::m_highPt_start_st
int m_highPt_start_st
Definition: CMAparameters.h:80
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
CMAparameters::m_lowPt_program
std::unique_ptr< CMAprogram > m_lowPt_program
Definition: CMAparameters.h:104
CMAparameters::pivot_start_ch
int pivot_start_ch() const
Definition: CMAparameters.cxx:21
CMAparameters::showDt
void showDt(std::ostream &, int layer) const
Definition: CMAparameters.cxx:293
CablingObject::no_connection_error
std::string no_connection_error(const std::string &, int) const
Definition: CablingObject.cxx:30
CMAparameters::get_channel
bool get_channel(CMAinput, int, int &, int &) const
Definition: CMAparameters.cxx:583
CMAparameters::pivot_channels
static constexpr int pivot_channels
Definition: CMAparameters.h:69
CMAparameters::defineParams::pivotStartStation
int pivotStartStation
Definition: CMAparameters.h:38
RPC_CondCabling::RPCchamber::eta_strips
int eta_strips() const
Definition: RPCchamber.cxx:22
CMAparameters::create_pivot_map
void create_pivot_map(int)
Definition: CMAparameters.cxx:227
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
CMAparameters::Atlas
@ Atlas
Definition: CMAparameters.h:23
CMAparameters::pivot_stop_ch
int pivot_stop_ch() const
Definition: CMAparameters.cxx:23
python.compareTCTs.ln
ln
Definition: compareTCTs.py:296
Shift
@ Shift
Definition: CMAparameters.h:19
CMAparameters::highPt_start_co
int highPt_start_co() const
Definition: CMAparameters.cxx:30
CablingObject::sector_type
int sector_type() const
Definition: CablingObject.cxx:14
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
CMAparameters::pivot_stop_st
int pivot_stop_st() const
Definition: CMAparameters.cxx:24
CMAprogram::registers
const bool * registers(void) const
Definition: CMAprogram.h:119
CMAparameters::m_lowPt_start_st
int m_lowPt_start_st
Definition: CMAparameters.h:75
Eta
@ Eta
Definition: RPCdef.h:8
fitman.k
k
Definition: fitman.py:528
Atlas
Definition: Atlas.UnixStandardJob.py:1
Generated on Tue Jul 2 2024 22:26:28 for ATLAS Offline Software by   doxygen 1.8.18