[u/mrichter/AliRoot.git] / HLT / PHOS / AliHLTPHOSMapper.cxx

/**************************************************************************
 * This file is property of and copyright by the Experimental Nuclear     *
 * Physics Group, Dep. of Physics                                         *
 * University of Oslo, Norway, 2006                                       *
 *                                                                        * 
 * Author: Per Thomas Hille perthi@fys.uio.no for the ALICE DCS Project.  *
 * Contributors are mentioned in the code where appropriate.              *
 * Please report bugs to perthi@fys.uio.no                                * 
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

#include "AliHLTPHOSMapper.h"

AliHLTPHOSMapper::AliHLTPHOSMapper()
{
  //  printf("\nCreating new mapper\n");
  InitAltroMapping(0); 
}

void 
AliHLTPHOSMapper::GenerateACL(int startZ, int endZ, int startX, int endX, int modID, int acl[RCUS_PER_MODULE][256], unsigned long int afl[RCUS_PER_MODULE])
{

  for(int i=0; i<RCUS_PER_MODULE; i++)
    {
      for(int j=0; j<256; j++)
	{
	  acl[i][j] = 0;
	}
    }

  int index;
  int aclIndex;

  int rcu = 99;
  int branch = 99;
  int card = 99;;
  int altro = 99;
  int channel = 99;
  int csp = 99;

  for(int i = startZ; i <= endZ; i++)
    {
      for(int j = startX; j <= endX; j++)
	{
	  for(int k = 0; k < PHOS_GAINS; k++)
	    {
	      index = geo2hdw[modID][k][j][i]; 
	      rcu = ALTRO_MAP[index].rcu;
	      branch = ALTRO_MAP[index].branch;
	      card = ALTRO_MAP[index].card;
	      altro = ALTRO_MAP[index].chip;  
	      channel = ALTRO_MAP[index].chan;
	      csp = ALTRO_MAP[index].csp;
	  
	      if(altro > 0)
		{
		  altro = altro + 1; //to fix bug in mp
		}

	      aclIndex = branch*128+(card +1)*8+altro;
	      acl[rcu][aclIndex] =  acl[rcu][aclIndex] | 1<<channel;
	      afl[rcu] = (long int)afl[rcu] | (1<< ((long int)(card+1) +(long int)branch*16));
	    }
	}
    }
}

void 
AliHLTPHOSMapper::AddCsp(int csp, int chip, int chHi, int chLo, int numHi, int numLo)
{
  // Find row & col by CSP
  int col = csp / 16;
  int row = csp % 16;
  //In 2004 beam test was also: if(row>7)row=23-row;
  // Check if arguments Ok
  assert((col>=0)&&(col<2));
  assert((row>=0)&&(row<16));
  assert((csp>=0)&&(csp<32));
  assert((numHi>=0)&&(numHi<64));
  assert((numLo>=0)&&(numLo<64));
  assert((chHi>=0)&&(chHi<FEE_CHANS));
  assert((chLo>=0)&&(chLo<FEE_CHANS));
  assert((chip>=0)&&(chip<FEE_ALTROS));
  // Fill CSP array
  CSP_MAP[chip][chHi].row=row;	CSP_MAP[chip][chLo].row=row;
  CSP_MAP[chip][chHi].col=col;	CSP_MAP[chip][chLo].col=col;
  CSP_MAP[chip][chHi].gain=1;	CSP_MAP[chip][chLo].gain=0;
  CSP_MAP[chip][chHi].csp=csp;	CSP_MAP[chip][chLo].csp=csp;
  CSP_MAP[chip][chHi].num=numHi;	CSP_MAP[chip][chLo].num=numLo;
}

 /////////////////////////////////////////////////////////////////
 // Initialize CSP mapping table.
 // Note we use (0,1,2,3) instead of (0,2,3,4) ALTRO chip numbers.
 // So strange numbers we have due to well known RCU firmware bug.
 /////////////////////////////////////////////////////////////////
void 
AliHLTPHOSMapper::InitAltroCspMapping()
{
  // T1	csp	chip	chHi	chLo	numHi	numLo
  AddCsp(	0,	1,	10,	11,	26,	27);
  AddCsp(	1,	1,	14,	15,	30,	31);
  AddCsp(	2,	1,	5,	4,	21,	20);
  AddCsp(	3,	1,	1,	0,	17,	16);
  AddCsp(	4,	2,	1,	0,	33,	32);
  AddCsp(	5,	2,	5,	4,	37,	36);
  AddCsp(	6,	2,	14,	15,	46,	47);
  AddCsp(	7,	2,	10,	11,	42,	43);
  // T2	csp	chip	chHi	chLo	numHi	numLo
  AddCsp(	8,	0,	10,	11,	10,	11);
  AddCsp(	9,	0,	14,	15,	14,	15);
  AddCsp(	10,	0,	5,	4,	5,	4);
  AddCsp(	11,	0,	1,	0,	1,	0);
  AddCsp(	12,	3,	1,	0,	49,	48);
  AddCsp(	13,	3,	5,	4,	53,	52);
  AddCsp(	14,	3,	14,	15,	62,	63);
  AddCsp(	15,	3,	10,	11,	58,	59);
  // T3	csp	chip	chHi	chLo	numHi	numLo
  AddCsp(	16,	1,	8,	9,	24,	25);
  AddCsp(	17,	1,	12,	13,	28,	29);
  AddCsp(	18,	1,	7,	6,	23,	22);
  AddCsp(	19,	1,	3,	2,	19,	18);
  AddCsp(	20,	2,	3,	2,	35,	34);
  AddCsp(	21,	2,	7,	6,	39,	38);
  AddCsp(	22,	2,	12,	13,	44,	45);
  AddCsp(	23,	2,	8,	9,	40,	41);
  // T4	csp	chip	chHi	chLo	numHi	numLo
  AddCsp(	24,	0,	8,	9,	8,	9);
  AddCsp(	25,	0,	12,	13,	12,	13);
  AddCsp(	26,	0,	7,	6,	7,	6);
  AddCsp(	27,	0,	3,	2,	3,	2);
  AddCsp(	28,	3,	3,	2,	51,	50);
  AddCsp(	29,	3,	7,	6,	55,	54);
  AddCsp(	30,	3,	12,	13,	60,	61);
  AddCsp(	31,	3,	8,	9,	56,	57);
} 

//void
//AliHLTPHOSMapper::GeomToAFL(int startZ, int endZ, int startX, int endX, int rcuZ, int rcuX)
//{
//  
//
//}

//inline int 
int
AliHLTPHOSMapper::Geo2hid(int mod, int gain, int row, int col)
{ 
  return mod*100000+gain*10000+row*100+col; 
}

//inline int 
int 
AliHLTPHOSMapper::Hid2mod(int hid)	
{ 
  return hid/100000;		
}


//inline int 
int 
AliHLTPHOSMapper::Hid2gain(int hid)	
{ 
  return (hid/10000)%10;	
}

//inline int 
int 
AliHLTPHOSMapper::Hid2row(int hid)	
{ 
  return (hid/100)%100;		
}

//inline int 
int 
AliHLTPHOSMapper::Hid2col(int hid)	
{ 
  return hid%100;  
}

////////////////////////////////////////////////////////////////////////
// ALTRO mapping first time initialization (do it once in startup time).
////////////////////////////////////////////////////////////////////////


//inline void 
//AliHLTPHOSMapper::initAltroMapping(int saveMapping=0)
//       initAltroMapping(int)'
void 
AliHLTPHOSMapper::InitAltroMapping(int saveMapping)
{
  //
  // Init CSP mapping first.
  //
  InitAltroCspMapping();
  //

  // Clear index arrays
  //
  for(int m=0; m<PHOS_MODS; m++)
    for(int g=0; g<PHOS_GAINS;g++)
      for(int r=0; r<PHOS_ROWS; r++)
	for(int c=0; c<PHOS_COLS; c++)
	  {	
	    geo2hdw[m][g][r][c]=-1; 
	  }
  
  for(int m=0; m<PHOS_MODS;   m++)
    for(int r=0; r<FEE_RCUS;    r++)
      for(int b=0; b<FEE_BRANCHS; b++)
	for(int f=0; f<FEE_FECS;    f++)
	  for(int a=0; a<FEE_ALTROS;  a++)
	    for(int c=0; c<FEE_CHANS;   c++)
	      { 
		hdw2geo[m][r][b][f][a][c]=-1; 
	      }
  //
  // Fill all FEE cards via formula
  //
  int index=0;
  for(int m=0; m<PHOS_MODS;   m++)
    for(int r=0; r<FEE_RCUS;    r++)
      for(int b=0; b<FEE_BRANCHS; b++)
	for(int f=0; f<FEE_FECS;    f++)
	  for(int a=0; a<FEE_ALTROS;  a++)
	    for(int c=0; c<FEE_CHANS;   c++)
	      {
		int row  = (r/2)*32 + b*16 + CSP_MAP[a][c].row;
		int col  = (r%2)*28 + f*2  + CSP_MAP[a][c].col;
		int gain = CSP_MAP[a][c].gain;
		int csp  = CSP_MAP[a][c].csp;
		int num  = CSP_MAP[a][c].num;
		ALTRO_MAP[index].mod=m;
		ALTRO_MAP[index].row=row;
		ALTRO_MAP[index].col=col;
		ALTRO_MAP[index].gain=gain;
		ALTRO_MAP[index].rcu=r;
		ALTRO_MAP[index].branch=b;
		ALTRO_MAP[index].card=f;
		ALTRO_MAP[index].chip=a;
		ALTRO_MAP[index].chan=c;
		ALTRO_MAP[index].csp=csp;
		ALTRO_MAP[index].num=num;
		ALTRO_MAP[index].hid=Geo2hid(m,gain,row,col);
		hdw2geo[m][r][b][f][a][c]=index;
		if((row>=0)&&(row<PHOS_ROWS))
		  if((col>=0)&&(col<PHOS_COLS))
		    if((gain>=0)&&(gain<PHOS_GAINS)) geo2hdw[m][gain][row][col]=index;
		index++;
	      }
 
  //
  // Check if geo2hdw map table is filled
  //
  for(int m=0; m<PHOS_MODS; m++)
    for(int g=0; g<PHOS_GAINS;g++)
      for(int r=0; r<PHOS_ROWS; r++)
	for(int c=0; c<PHOS_COLS; c++) 
	  {
	    assert(geo2hdw[m][g][r][c] >= 0);
	  }
  //
  // Check if hdw2geo map table is filled
  //
  for(int m=0; m<PHOS_MODS;   m++)
    for(int r=0; r<FEE_RCUS;    r++)
      for(int b=0; b<FEE_BRANCHS; b++)
	for(int f=0; f<FEE_FECS;    f++)
	  for(int a=0; a<FEE_ALTROS;  a++)
	    for(int c=0; c<FEE_CHANS;   c++) 
	      {
		assert(hdw2geo[m][r][b][f][a][c] >= 0);
	      }
}

////////////////////////////////////////////////////////////////////////
// Return histogramm id from histogramm name or -1 on error.
// extractHid("hMax011426")=11426;
////////////////////////////////////////////////////////////////////////
//inline int 
int 
AliHLTPHOSMapper::ExtractHid(char *objName){
  //  char *perr= NULL;
 char *perr= 0;
  if(strlen(objName)<7) return -1;
  int hid=strtol(&objName[strlen(objName)-6],&perr,10);
  if(strlen(perr))return -1;
  return hid;
}

////////////////////////////////////////////////////////////////////////
// Print geometry and hardware information for given histogramm
// printHistMapInfo("hMax011426");
// hid     mod     gain    row     col     rcu     bran    fee     chip    chan    csp     num
// 011426  0       1       14      26      0       0       13      3       14      14      62
////////////////////////////////////////////////////////////////////////
//inline void 
void 
AliHLTPHOSMapper::PrintHistMapInfo(char *objName){
  int hid=ExtractHid(objName);
  if(hid>=0){
    int mod=Hid2mod(hid);
    int gain=Hid2gain(hid);
    int row=Hid2row(hid);
    int col=Hid2col(hid);
    int index=geo2hdw[mod][gain][row][col]; assert(index>=0);
    int rcu  = ALTRO_MAP[index].rcu;
    int bran = ALTRO_MAP[index].branch;
    int fec  = ALTRO_MAP[index].card;
    int chip = ALTRO_MAP[index].chip;
    int chan = ALTRO_MAP[index].chan;
    int csp  = ALTRO_MAP[index].csp;
    int num  = ALTRO_MAP[index].num;
    printf("%s attributes:\nhid\tmod\tgain\trow\tcol\trcu\tbran\tfee\tchip\tchan\tcsp\tnum\n",objName);
    printf("%06d\t%d\t%d\t%02d\t%02d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",hid,mod,gain,row,col,rcu,bran,fec,chip,chan,csp,num);
  }
}
Commit	Line	Data
2f09efe8	1	/**************************************************************************
	2	* This file is property of and copyright by the Experimental Nuclear *
	3	* Physics Group, Dep. of Physics *
	4	* University of Oslo, Norway, 2006 *
	5	* *
	6	* Author: Per Thomas Hille perthi@fys.uio.no for the ALICE DCS Project. *
	7	* Contributors are mentioned in the code where appropriate. *
	8	* Please report bugs to perthi@fys.uio.no *
	9	* *
	10	* Permission to use, copy, modify and distribute this software and its *
	11	* documentation strictly for non-commercial purposes is hereby granted *
	12	* without fee, provided that the above copyright notice appears in all *
	13	* copies and that both the copyright notice and this permission notice *
	14	* appear in the supporting documentation. The authors make no claims *
	15	* about the suitability of this software for any purpose. It is *
	16	* provided "as is" without express or implied warranty. *
	17	**************************************************************************/
	18
	19	#include "AliHLTPHOSMapper.h"
	20
	21	AliHLTPHOSMapper::AliHLTPHOSMapper()
	22	{
	23	// printf("\nCreating new mapper\n");
	24	InitAltroMapping(0);
	25	}
	26
	27	void
	28	AliHLTPHOSMapper::GenerateACL(int startZ, int endZ, int startX, int endX, int modID, int acl[RCUS_PER_MODULE][256], unsigned long int afl[RCUS_PER_MODULE])
	29	{
	30
	31	for(int i=0; i<RCUS_PER_MODULE; i++)
	32	{
	33	for(int j=0; j<256; j++)
	34	{
	35	acl[i][j] = 0;
	36	}
	37	}
	38
	39	int index;
	40	int aclIndex;
	41
	42	int rcu = 99;
	43	int branch = 99;
	44	int card = 99;;
	45	int altro = 99;
	46	int channel = 99;
	47	int csp = 99;
	48
	49	for(int i = startZ; i <= endZ; i++)
	50	{
	51	for(int j = startX; j <= endX; j++)
	52	{
	53	for(int k = 0; k < PHOS_GAINS; k++)
	54	{
	55	index = geo2hdw[modID][k][j][i];
	56	rcu = ALTRO_MAP[index].rcu;
	57	branch = ALTRO_MAP[index].branch;
	58	card = ALTRO_MAP[index].card;
	59	altro = ALTRO_MAP[index].chip;
	60	channel = ALTRO_MAP[index].chan;
	61	csp = ALTRO_MAP[index].csp;
	62
	63	if(altro > 0)
	64	{
65	altro = altro + 1; //to fix bug in mp
66	}
67
68	aclIndex = branch128+(card +1)8+altro;
69	acl[rcu][aclIndex] = acl[rcu][aclIndex] \| 1<<channel;
70	afl[rcu] = (long int)afl[rcu] \| (1<< ((long int)(card+1) +(long int)branch*16));
71	}
72	}
73	}
74	}
75
76	void
77	AliHLTPHOSMapper::AddCsp(int csp, int chip, int chHi, int chLo, int numHi, int numLo)
78	{
79	// Find row & col by CSP
80	int col = csp / 16;
81	int row = csp % 16;
82	//In 2004 beam test was also: if(row>7)row=23-row;
83	// Check if arguments Ok
84	assert((col>=0)&&(col<2));
85	assert((row>=0)&&(row<16));
86	assert((csp>=0)&&(csp<32));
87	assert((numHi>=0)&&(numHi<64));
88	assert((numLo>=0)&&(numLo<64));
89	assert((chHi>=0)&&(chHi<FEE_CHANS));
90	assert((chLo>=0)&&(chLo<FEE_CHANS));
91	assert((chip>=0)&&(chip<FEE_ALTROS));
92	// Fill CSP array
93	CSP_MAP[chip][chHi].row=row; CSP_MAP[chip][chLo].row=row;
94	CSP_MAP[chip][chHi].col=col; CSP_MAP[chip][chLo].col=col;
95	CSP_MAP[chip][chHi].gain=1; CSP_MAP[chip][chLo].gain=0;
96	CSP_MAP[chip][chHi].csp=csp; CSP_MAP[chip][chLo].csp=csp;
97	CSP_MAP[chip][chHi].num=numHi; CSP_MAP[chip][chLo].num=numLo;
98	}
99
100	/////////////////////////////////////////////////////////////////
101	// Initialize CSP mapping table.
102	// Note we use (0,1,2,3) instead of (0,2,3,4) ALTRO chip numbers.
103	// So strange numbers we have due to well known RCU firmware bug.
104	/////////////////////////////////////////////////////////////////
105	void
106	AliHLTPHOSMapper::InitAltroCspMapping()
107	{
108	// T1 csp chip chHi chLo numHi numLo
109	AddCsp( 0, 1, 10, 11, 26, 27);
110	AddCsp( 1, 1, 14, 15, 30, 31);
111	AddCsp( 2, 1, 5, 4, 21, 20);
112	AddCsp( 3, 1, 1, 0, 17, 16);
113	AddCsp( 4, 2, 1, 0, 33, 32);
114	AddCsp( 5, 2, 5, 4, 37, 36);
115	AddCsp( 6, 2, 14, 15, 46, 47);
116	AddCsp( 7, 2, 10, 11, 42, 43);
117	// T2 csp chip chHi chLo numHi numLo
118	AddCsp( 8, 0, 10, 11, 10, 11);
119	AddCsp( 9, 0, 14, 15, 14, 15);
120	AddCsp( 10, 0, 5, 4, 5, 4);
121	AddCsp( 11, 0, 1, 0, 1, 0);
122	AddCsp( 12, 3, 1, 0, 49, 48);
123	AddCsp( 13, 3, 5, 4, 53, 52);
124	AddCsp( 14, 3, 14, 15, 62, 63);
125	AddCsp( 15, 3, 10, 11, 58, 59);
126	// T3 csp chip chHi chLo numHi numLo
127	AddCsp( 16, 1, 8, 9, 24, 25);
128	AddCsp( 17, 1, 12, 13, 28, 29);
129	AddCsp( 18, 1, 7, 6, 23, 22);
130	AddCsp( 19, 1, 3, 2, 19, 18);
131	AddCsp( 20, 2, 3, 2, 35, 34);
132	AddCsp( 21, 2, 7, 6, 39, 38);
133	AddCsp( 22, 2, 12, 13, 44, 45);
134	AddCsp( 23, 2, 8, 9, 40, 41);
135	// T4 csp chip chHi chLo numHi numLo
136	AddCsp( 24, 0, 8, 9, 8, 9);
137	AddCsp( 25, 0, 12, 13, 12, 13);
138	AddCsp( 26, 0, 7, 6, 7, 6);
139	AddCsp( 27, 0, 3, 2, 3, 2);
140	AddCsp( 28, 3, 3, 2, 51, 50);
141	AddCsp( 29, 3, 7, 6, 55, 54);
142	AddCsp( 30, 3, 12, 13, 60, 61);
143	AddCsp( 31, 3, 8, 9, 56, 57);
144	}
145
146	//void
147	//AliHLTPHOSMapper::GeomToAFL(int startZ, int endZ, int startX, int endX, int rcuZ, int rcuX)
148	//{
149	//
150	//
151	//}
152
153	//inline int
154	int
155	AliHLTPHOSMapper::Geo2hid(int mod, int gain, int row, int col)
156	{
157	return mod100000+gain10000+row*100+col;
158	}
159
160	//inline int
161	int
162	AliHLTPHOSMapper::Hid2mod(int hid)
163	{
164	return hid/100000;
165	}
166
167
168	//inline int
169	int
170	AliHLTPHOSMapper::Hid2gain(int hid)
171	{
172	return (hid/10000)%10;
173	}
174
175	//inline int
176	int
177	AliHLTPHOSMapper::Hid2row(int hid)
178	{
179	return (hid/100)%100;
180	}
181
182	//inline int
183	int
184	AliHLTPHOSMapper::Hid2col(int hid)
185	{
186	return hid%100;
187	}
188
189	////////////////////////////////////////////////////////////////////////
190	// ALTRO mapping first time initialization (do it once in startup time).
191	////////////////////////////////////////////////////////////////////////
192
193
194
195	//inline void
196	//AliHLTPHOSMapper::initAltroMapping(int saveMapping=0)
197	// initAltroMapping(int)'
198	void
199	AliHLTPHOSMapper::InitAltroMapping(int saveMapping)
200	{
201	//
202	// Init CSP mapping first.
203	//
204	InitAltroCspMapping();
205	//
206
207	// Clear index arrays
208	//
209	for(int m=0; m<PHOS_MODS; m++)
210	for(int g=0; g<PHOS_GAINS;g++)
211	for(int r=0; r<PHOS_ROWS; r++)
212	for(int c=0; c<PHOS_COLS; c++)
213	{
214	geo2hdw[m][g][r][c]=-1;
215	}
216
217	for(int m=0; m<PHOS_MODS; m++)
218	for(int r=0; r<FEE_RCUS; r++)
219	for(int b=0; b<FEE_BRANCHS; b++)
220	for(int f=0; f<FEE_FECS; f++)
221	for(int a=0; a<FEE_ALTROS; a++)
222	for(int c=0; c<FEE_CHANS; c++)
223	{
224	hdw2geo[m][r][b][f][a][c]=-1;
225	}
226	//
227	// Fill all FEE cards via formula
228	//
229	int index=0;
230	for(int m=0; m<PHOS_MODS; m++)
231	for(int r=0; r<FEE_RCUS; r++)
232	for(int b=0; b<FEE_BRANCHS; b++)
233	for(int f=0; f<FEE_FECS; f++)
234	for(int a=0; a<FEE_ALTROS; a++)
235	for(int c=0; c<FEE_CHANS; c++)
236	{
237	int row = (r/2)32 + b16 + CSP_MAP[a][c].row;
238	int col = (r%2)28 + f2 + CSP_MAP[a][c].col;
239	int gain = CSP_MAP[a][c].gain;
240	int csp = CSP_MAP[a][c].csp;
241	int num = CSP_MAP[a][c].num;
242	ALTRO_MAP[index].mod=m;
243	ALTRO_MAP[index].row=row;
244	ALTRO_MAP[index].col=col;
245	ALTRO_MAP[index].gain=gain;
246	ALTRO_MAP[index].rcu=r;
247	ALTRO_MAP[index].branch=b;
248	ALTRO_MAP[index].card=f;
249	ALTRO_MAP[index].chip=a;
250	ALTRO_MAP[index].chan=c;
251	ALTRO_MAP[index].csp=csp;
252	ALTRO_MAP[index].num=num;
253	ALTRO_MAP[index].hid=Geo2hid(m,gain,row,col);
254	hdw2geo[m][r][b][f][a][c]=index;
255	if((row>=0)&&(row<PHOS_ROWS))
256	if((col>=0)&&(col<PHOS_COLS))
257	if((gain>=0)&&(gain<PHOS_GAINS)) geo2hdw[m][gain][row][col]=index;
258	index++;
259	}
260
261	//
262	// Check if geo2hdw map table is filled
263	//
264	for(int m=0; m<PHOS_MODS; m++)
265	for(int g=0; g<PHOS_GAINS;g++)
266	for(int r=0; r<PHOS_ROWS; r++)
267	for(int c=0; c<PHOS_COLS; c++)
268	{
269	assert(geo2hdw[m][g][r][c] >= 0);
270	}
271	//
272	// Check if hdw2geo map table is filled
273	//
274	for(int m=0; m<PHOS_MODS; m++)
275	for(int r=0; r<FEE_RCUS; r++)
276	for(int b=0; b<FEE_BRANCHS; b++)
277	for(int f=0; f<FEE_FECS; f++)
278	for(int a=0; a<FEE_ALTROS; a++)
279	for(int c=0; c<FEE_CHANS; c++)
280	{
281	assert(hdw2geo[m][r][b][f][a][c] >= 0);
282	}
283	}
284
285	////////////////////////////////////////////////////////////////////////
286	// Return histogramm id from histogramm name or -1 on error.
287	// extractHid("hMax011426")=11426;
288	////////////////////////////////////////////////////////////////////////
289	//inline int
290	int
291	AliHLTPHOSMapper::ExtractHid(char *objName){
292	// char *perr= NULL;
293	char *perr= 0;
294	if(strlen(objName)<7) return -1;
295	int hid=strtol(&objName[strlen(objName)-6],&perr,10);
296	if(strlen(perr))return -1;
297	return hid;
298	}
299
300	////////////////////////////////////////////////////////////////////////
301	// Print geometry and hardware information for given histogramm
302	// printHistMapInfo("hMax011426");
303	// hid mod gain row col rcu bran fee chip chan csp num
304	// 011426 0 1 14 26 0 0 13 3 14 14 62
305	////////////////////////////////////////////////////////////////////////
306	//inline void
307	void
308	AliHLTPHOSMapper::PrintHistMapInfo(char *objName){
309	int hid=ExtractHid(objName);
310	if(hid>=0){
311	int mod=Hid2mod(hid);
312	int gain=Hid2gain(hid);
313	int row=Hid2row(hid);
314	int col=Hid2col(hid);
315	int index=geo2hdw[mod][gain][row][col]; assert(index>=0);
316	int rcu = ALTRO_MAP[index].rcu;
317	int bran = ALTRO_MAP[index].branch;
318	int fec = ALTRO_MAP[index].card;
319	int chip = ALTRO_MAP[index].chip;
320	int chan = ALTRO_MAP[index].chan;
321	int csp = ALTRO_MAP[index].csp;
322	int num = ALTRO_MAP[index].num;
323	printf("%s attributes:\nhid\tmod\tgain\trow\tcol\trcu\tbran\tfee\tchip\tchan\tcsp\tnum\n",objName);
324	printf("%06d\t%d\t%d\t%02d\t%02d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",hid,mod,gain,row,col,rcu,bran,fec,chip,chan,csp,num);
325	}
326	}