[u/mrichter/AliRoot.git] / TRD / AliTRDCalibraMode.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * 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.                  *
 **************************************************************************/

/* $Id$ */

/////////////////////////////////////////////////////////////////////////////////
//                                                                             
// AliTRDCalibraMode                                                             
//                                                                             
// This class is for the modes of the TRD calibration.        
// The user has to choose with the functions SetNz and SetNrphi
// the precision of the calibration. 
// Author:
//   R. Bailhache (R.Bailhache@gsi.de)
//                            
//Begin_Html
/*
<br>
<CENTER>
<TABLE border=1>
<TR><TD><center>Nz</center></TD><TD><center> 0 </center></TD><TD><center> 1 </center></TD><TD><center> 2 </center></TD><TD><center> 3 </center></TD><TD><center> 4 </center></TD></TR>
<TR><TD><CENTER>group of row pads per detector</CENTER></TD><TD><CENTER>1</CENTER></TD><TD><CENTER>2</CENTER></TD><TD><CENTER>4</CENTER></TD><TD><CENTER>6(chamb2)<br> 8(others chambers)</CENTER></TD><TD><CENTER>12 (chamb2)<br> 16 (chamb0)</CENTER></TD></TR>
<TR><TD><CENTER>row pads per group</CENTER></TD><TD><CENTER>12 (chamb2)<br> 16 (chamb0)</CENTER></TD><TD><CENTER>6 (chamb2)<br> 8 (chamb0)</CENTER></TD><TD><CENTER>3 (chamb2)<br> 4 (chamb0)</CENTER></TD><TD><CENTER>2</CENTER></TD><TD><CENTER>1</CENTER></TD></TR>
<TR><TD><CENTER>~distance [cm]</CENTER></TD><TD><CENTER>106 (chamb2)<br> 130 (chamb0)</CENTER></TD><TD><CENTER>53 (chamb2)<br> 65 (chamb0)</CENTER></TD><TD><CENTER>26.5 (chamb2)<br> 32.5 (chamb0)</CENTER></TD><TD><CENTER>17 (chamb2)<br> 17 (chamb0)</CENTER></TD><TD><CENTER>9 (chamb2)<br> 9 (chamb0)</CENTER></TD></TR>
<CAPTION>In the z direction</CAPTION>
</TABLE>
</CENTER>
<CENTER>
<br>
<TABLE border=1>
<TR><TD><center>Nrphi</center></TD><TD><center> 0 </center></TD><TD><center> 1 </center></TD><TD><center> 2 </center></TD><TD><center> 3 </center></TD><TD><center> 4 </center></TD><TD><center> 5 </center></TD><TD><center> 6 </center></TD></TR>
<TR><TD><CENTER>group of col pads per detector</CENTER></TD><TD><CENTER>1</CENTER></TD><TD><CENTER>2</CENTER></TD><TD><CENTER>4</CENTER></TD><TD><CENTER>8</CENTER></TD><TD><CENTER>16</CENTER></TD><TD><center>36</center></TD><TD><center>144</center></TD></TR>
<TR><TD><CENTER>col pads per group</CENTER></TD><TD><CENTER>144</CENTER></TD><TD><CENTER>72</CENTER></TD><TD><CENTER>36</CENTER></TD><TD><CENTER>18</CENTER></TD><TD><CENTER>9</CENTER></TD><TD><center>4</center></TD><TD><center>1</center></TD></TR>
<TR><TD><CENTER>~distance [cm]</CENTER></TD><TD><CENTER>113.4</CENTER></TD><TD><CENTER>56.7</CENTER></TD><TD><CENTER>25.3</CENTER></TD><TD><CENTER>14.3</CENTER></TD><TD><CENTER>7.25</CENTER></TD><TD><center>3.2</center></TD><TD><center>0.8</center></TD></TR>
<CAPTION>In the rphi direction</CAPTION>
</TABLE>
</CENTER>
<br>
*/
//End_Html 
//
//
// Moreover two other more general granularities:
// It can not work with AliTRDCalibraVector
// 10 corresponds to per supermodule
// 100 all together
//                            
//////////////////////////////////////////////////////////////////////////////////////

#include "AliLog.h"

#include "AliTRDCalibraMode.h"
#include "AliTRDgeometry.h"

ClassImp(AliTRDCalibraMode)

//______________________________________________________________________________________
AliTRDCalibraMode::AliTRDCalibraMode()
  :TObject()
  ,fGeo(0)
{
  //
  // Default constructor
  //

  for (Int_t i = 0; i < 3; i++) {
    fNz[i]    = 0;
    fNrphi[i] = 0;
  }

  for (Int_t k = 0; k < 3; k++) {
    fDetChamb2[k] = 0;
    fDetChamb0[k] = 0;
  }

  for (Int_t i = 0; i < 3; i++) {
    fRowMin[i]    = -1;
    fRowMax[i]    = -1;
    fColMax[i]    = -1;
    fColMin[i]    = -1;
    fNnZ[i]       = -1;
    fNnRphi[i]    = -1;
    fNfragZ[i]    = -1;
    fNfragRphi[i] = -1;
    fXbins[i]     = -1;
  }
  
  fGeo = new AliTRDgeometry();
 
}

//______________________________________________________________________________________
AliTRDCalibraMode::AliTRDCalibraMode(const AliTRDCalibraMode &c)
  :TObject(c)
  ,fGeo(0)
{
  //
  // Copy constructor
  //

  for(Int_t k = 0; k < 3; k++){
    fNz[k]        = c.fNz[k];
    fNrphi[k]     = c.fNrphi[k];
    fNnZ[k]       = c.fNnZ[k];
    fNnRphi[k]    = c.fNnRphi[k];
    fNfragZ[k]    = c.fNfragZ[k];
    fNfragRphi[k] = c.fNfragRphi[k];
    fRowMin[k]    = c.fRowMin[k];
    fRowMax[k]    = c.fRowMax[k];
    fColMin[k]    = c.fColMin[k];
    fColMax[k]    = c.fColMax[k];
    fXbins[k]     = c.fXbins[k];
    fDetChamb0[k] = c.fDetChamb0[k];
    fDetChamb2[k] = c.fDetChamb2[k];
  }

  if (fGeo) {
    delete fGeo;
  }
  fGeo = new AliTRDgeometry();

}

//____________________________________________________________________________________
AliTRDCalibraMode::~AliTRDCalibraMode()
{
  //
  // AliTRDCalibraMode destructor
  //

  if (fGeo) {
    delete fGeo;
  }

}

//_____________________________________________________________________________
void AliTRDCalibraMode::SetPerSuperModule(Int_t i)
{
  //
  // Set the mode of calibration group per supermodule
  // 

  fNz[i] = 10;
  fNrphi[i] = 10; 
}

//_____________________________________________________________________________
void AliTRDCalibraMode::SetAllTogether(Int_t i)
{
  //
  // Set the mode of calibration group all together
  // 

  fNz[i] = 100;
  fNrphi[i] = 100; 
}

//_____________________________________________________________________________
void AliTRDCalibraMode::SetNz(Int_t i, Short_t Nz)
{
  //
  // Set the mode of calibration group in the z direction for the parameter i
  // 

  if ((Nz >= 0) && 
      (Nz <  5)) {
    fNz[i] = Nz; 
  }
  else {
    AliInfo("You have to choose between 0 and 4.");
  }

}

//_____________________________________________________________________________
void AliTRDCalibraMode::SetNrphi(Int_t i, Short_t Nrphi)
{
  //
  // Set the mode of calibration group in the rphi direction for the parameter i
  //
 
  if ((Nrphi >= 0) && 
      (Nrphi <  7)) {
    fNrphi[i] = Nrphi; 
  }
  else {
    AliInfo("You have to choose between 0 and 6 or 10/100.");
  }

}

//_______________________________________________________________________________________
void AliTRDCalibraMode::ModePadCalibration(Int_t iChamb, Int_t i)
{
  //
  // Definition of the calibration mode
  // from Nz and Nrphi, the number of row and col pads per calibration groups are setted
  //


  fNnZ[i]    = 0;
  fNnRphi[i] = 0;
  
  if (((fNz[i] == 0) || (fNz[i] == 10) || (fNz[i] == 100)) && (iChamb == 2)) {
    fNnZ[i] = 12;
  }
  if (((fNz[i] == 0) || (fNz[i] == 10) || (fNz[i] == 100)) && (iChamb != 2)) {
    fNnZ[i] = 16;
  }  
  if ((fNz[i] == 1) && (iChamb == 2)) {
    fNnZ[i] = 6;
  }
  if ((fNz[i] == 1) && (iChamb != 2)) {
    fNnZ[i] = 8;
  }
  if ((fNz[i] == 2) && (iChamb == 2)) {
    fNnZ[i] = 3;
  }
  if ((fNz[i] == 2) && (iChamb != 2)) {
    fNnZ[i] = 4;
  }
  if (fNz[i] == 3) {
    fNnZ[i] = 2;
  }
  if (fNz[i] == 4) {
    fNnZ[i] = 1;
  }
   
  if ((fNrphi[i] == 0) || (fNrphi[i] == 10) || (fNrphi[i] == 100)) {
    fNnRphi[i] = 144;
  }
  if (fNrphi[i] == 1) {
    fNnRphi[i] = 72;
  } 
  if (fNrphi[i] == 2) {
    fNnRphi[i] = 36;
  } 
  if (fNrphi[i] == 3) {
    fNnRphi[i] = 18;
  } 
  if (fNrphi[i] == 4) {
    fNnRphi[i] = 9;
  } 
  if (fNrphi[i] == 5) {
    fNnRphi[i] = 4;
  } 
  if (fNrphi[i] == 6) {
    fNnRphi[i] = 1;
  } 

}

//_____________________________________________________________________________________________
Bool_t AliTRDCalibraMode::ModePadFragmentation(Int_t iLayer,Int_t iStack, Int_t iSect, Int_t i)
{
  //
  // Definition of the calibration mode
  // From the number of row and col pads per calibration groups the
  // number of calibration groups are setted
  //

  fNfragZ[i]    = 0;
  fNfragRphi[i] = 0;

  // A little geometry:
  Int_t rowMax = fGeo->GetRowMax(iLayer,iStack,iSect);
  Int_t colMax = fGeo->GetColMax(iLayer);
  
  // The fragmentation
  if (fNnZ[i]    != 0) {
    fNfragZ[i]    = (Int_t) rowMax / fNnZ[i];
  }

  if (fNnRphi[i] != 0) {
    fNfragRphi[i] = (Int_t) colMax / fNnRphi[i];
  }

  return kTRUE;

}

//_____________________________________________________________________________
void AliTRDCalibraMode::ReconstructionRowPadGroup(Int_t idect, Int_t i)
{
  //
  // For the calibration group idect in a detector calculate the
  // first and last row pad and col pad.
  // The pads in the interval will have the same calibrated coefficients
  //

  Int_t posc = -1;
  Int_t posr = -1;
  fRowMin[i] = -1;
  fRowMax[i] = -1;
  fColMin[i] = -1;
  fColMax[i] = -1;
  
  if (fNfragZ[i]    != 0) {
    posc = (Int_t) idect / fNfragZ[i];
  }
  if (fNfragRphi[i] != 0) {
    posr = (Int_t) idect % fNfragZ[i];
  }
  fRowMin[i] = posr     * fNnZ[i];
  fRowMax[i] = (posr+1) * fNnZ[i];
  fColMin[i] = posc     * fNnRphi[i];
  fColMax[i] = (posc+1) * fNnRphi[i];

}

//_____________________________________________________________________________
void AliTRDCalibraMode::CalculXBins(Int_t idect, Int_t i)
{
  //
  // For the detector idect calcul the first Xbins
  //

  fXbins[i] = 0;
  AliDebug(2, Form("detector: %d", idect));

  // Total
  if((fNz[i] == 100) && (fNrphi[i] == 100)) {
    fXbins[i] = 0;
    return; 
  }

  // In which sector?
  Int_t sector = GetSector(idect);
 
 
  // First per supermodule
  if((fNz[i] == 10) && (fNrphi[i] == 10)) {
    fXbins[i] = sector;
    return;
  }
  
  fXbins[i] += sector*(6*fDetChamb2[i]+6*4*fDetChamb0[i]);

  // In which stack?
  Int_t stack = GetStack(idect);
  Int_t kc      = 0;
  while (kc < stack) {
    if (kc == 2) {
      fXbins[i] += 6 * fDetChamb2[i];
    }
    else {
      fXbins[i] += 6 * fDetChamb0[i];
    }
    kc ++;
  }
  
  // In which layer?
  Int_t layer = GetLayer(idect);
  if (stack == 2) {
    fXbins[i] += layer*fDetChamb2[i];
  }
  else {
    fXbins[i] += layer*fDetChamb0[i];
  }
 
}

//_____________________________________________________________________________
void AliTRDCalibraMode::ResetMinMax(Int_t i)
{
  //
  // Reset fRowMin fRowMax fColMin fColMax [i]
  //

  fRowMin[i] = -1;
  fRowMax[i] = -1;
  fColMin[i] = -1;
  fColMax[i] = -1;
 
}

//_____________________________________________________________________________
void AliTRDCalibraMode::SetDetChamb0(Int_t i)
{
  //
  // Set the number of calibration group per detector != 2
  //

  fDetChamb0[i] = fNfragZ[i] * fNfragRphi[i];  
 
}

//_____________________________________________________________________________
void AliTRDCalibraMode::SetDetChamb2(Int_t i)
{
  //
  // Set the number of calibration group per detector == 2
  //

  fDetChamb2[i] = fNfragZ[i] * fNfragRphi[i];  
 
}

//_____________________________________________________________________________
Int_t AliTRDCalibraMode::GetLayer(Int_t d) const
{
  //
  // Reconstruct the plane number from the detector number
  //

  return ((Int_t) (d % 6));

}

//_____________________________________________________________________________
Int_t AliTRDCalibraMode::GetStack(Int_t d) const
{
  //
  // Reconstruct the stack number from the detector number
  //

  const Int_t kNlayer = 6;

  return ((Int_t) (d % 30) / kNlayer);

}

//_____________________________________________________________________________
Int_t AliTRDCalibraMode::GetSector(Int_t d) const
{
  //
  // Reconstruct the sector number from the detector number
  //

  Int_t fg = 30;

  return ((Int_t) (d / fg));

}
Commit	Line	Data
55a288e5	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id$ */
	17
	18	/////////////////////////////////////////////////////////////////////////////////
	19	//
	20	// AliTRDCalibraMode
	21	//
	22	// This class is for the modes of the TRD calibration.
0bc7827a	23	// The user has to choose with the functions SetNz and SetNrphi
	24	// the precision of the calibration.
	25	// Author:
	26	// R. Bailhache (R.Bailhache@gsi.de)
	27	//
55a288e5	28	//Begin_Html
	29	/*
	30	<br>
	31	<CENTER>
	32	<TABLE border=1>
	33	<TR><TD><center>Nz</center></TD><TD><center> 0 </center></TD><TD><center> 1 </center></TD><TD><center> 2 </center></TD><TD><center> 3 </center></TD><TD><center> 4 </center></TD></TR>
	34	<TR><TD><CENTER>group of row pads per detector</CENTER></TD><TD><CENTER>1</CENTER></TD><TD><CENTER>2</CENTER></TD><TD><CENTER>4</CENTER></TD><TD><CENTER>6(chamb2)<br> 8(others chambers)</CENTER></TD><TD><CENTER>12 (chamb2)<br> 16 (chamb0)</CENTER></TD></TR>
	35	<TR><TD><CENTER>row pads per group</CENTER></TD><TD><CENTER>12 (chamb2)<br> 16 (chamb0)</CENTER></TD><TD><CENTER>6 (chamb2)<br> 8 (chamb0)</CENTER></TD><TD><CENTER>3 (chamb2)<br> 4 (chamb0)</CENTER></TD><TD><CENTER>2</CENTER></TD><TD><CENTER>1</CENTER></TD></TR>
	36	<TR><TD><CENTER>~distance [cm]</CENTER></TD><TD><CENTER>106 (chamb2)<br> 130 (chamb0)</CENTER></TD><TD><CENTER>53 (chamb2)<br> 65 (chamb0)</CENTER></TD><TD><CENTER>26.5 (chamb2)<br> 32.5 (chamb0)</CENTER></TD><TD><CENTER>17 (chamb2)<br> 17 (chamb0)</CENTER></TD><TD><CENTER>9 (chamb2)<br> 9 (chamb0)</CENTER></TD></TR>
	37	<CAPTION>In the z direction</CAPTION>
	38	</TABLE>
	39	</CENTER>
	40	<CENTER>
	41	<br>
	42	<TABLE border=1>
	43	<TR><TD><center>Nrphi</center></TD><TD><center> 0 </center></TD><TD><center> 1 </center></TD><TD><center> 2 </center></TD><TD><center> 3 </center></TD><TD><center> 4 </center></TD><TD><center> 5 </center></TD><TD><center> 6 </center></TD></TR>
	44	<TR><TD><CENTER>group of col pads per detector</CENTER></TD><TD><CENTER>1</CENTER></TD><TD><CENTER>2</CENTER></TD><TD><CENTER>4</CENTER></TD><TD><CENTER>8</CENTER></TD><TD><CENTER>16</CENTER></TD><TD><center>36</center></TD><TD><center>144</center></TD></TR>
	45	<TR><TD><CENTER>col pads per group</CENTER></TD><TD><CENTER>144</CENTER></TD><TD><CENTER>72</CENTER></TD><TD><CENTER>36</CENTER></TD><TD><CENTER>18</CENTER></TD><TD><CENTER>9</CENTER></TD><TD><center>4</center></TD><TD><center>1</center></TD></TR>
	46	<TR><TD><CENTER>~distance [cm]</CENTER></TD><TD><CENTER>113.4</CENTER></TD><TD><CENTER>56.7</CENTER></TD><TD><CENTER>25.3</CENTER></TD><TD><CENTER>14.3</CENTER></TD><TD><CENTER>7.25</CENTER></TD><TD><center>3.2</center></TD><TD><center>0.8</center></TD></TR>
	47	<CAPTION>In the rphi direction</CAPTION>
	48	</TABLE>
	49	</CENTER>
	50	<br>
	51	*/
	52	//End_Html
	53	//
64942b85	54	//
	55	// Moreover two other more general granularities:
	56	// It can not work with AliTRDCalibraVector
	57	// 10 corresponds to per supermodule
	58	// 100 all together
55a288e5	59	//
55a288e5	60	//////////////////////////////////////////////////////////////////////////////////////
	61
	62	#include "AliLog.h"
	63
	64	#include "AliTRDCalibraMode.h"
f162af62	65	#include "AliTRDgeometry.h"
55a288e5	66
	67	ClassImp(AliTRDCalibraMode)
	68
	69	//______________________________________________________________________________________
	70	AliTRDCalibraMode::AliTRDCalibraMode()
	71	:TObject()
f162af62	72	,fGeo(0)
55a288e5	73	{
	74	//
	75	// Default constructor
	76	//
	77
	78	for (Int_t i = 0; i < 3; i++) {
	79	fNz[i] = 0;
	80	fNrphi[i] = 0;
	81	}
	82
	83	for (Int_t k = 0; k < 3; k++) {
	84	fDetChamb2[k] = 0;
	85	fDetChamb0[k] = 0;
	86	}
	87
	88	for (Int_t i = 0; i < 3; i++) {
	89	fRowMin[i] = -1;
	90	fRowMax[i] = -1;
	91	fColMax[i] = -1;
	92	fColMin[i] = -1;
	93	fNnZ[i] = -1;
	94	fNnRphi[i] = -1;
	95	fNfragZ[i] = -1;
	96	fNfragRphi[i] = -1;
	97	fXbins[i] = -1;
	98	}
f162af62	99
	100	fGeo = new AliTRDgeometry();
	101
55a288e5	102	}
	103
	104	//______________________________________________________________________________________
	105	AliTRDCalibraMode::AliTRDCalibraMode(const AliTRDCalibraMode &c)
	106	:TObject(c)
f162af62	107	,fGeo(0)
55a288e5	108	{
	109	//
	110	// Copy constructor
	111	//
	112
cf46274d	113	for(Int_t k = 0; k < 3; k++){
	114	fNz[k] = c.fNz[k];
	115	fNrphi[k] = c.fNrphi[k];
	116	fNnZ[k] = c.fNnZ[k];
	117	fNnRphi[k] = c.fNnRphi[k];
	118	fNfragZ[k] = c.fNfragZ[k];
	119	fNfragRphi[k] = c.fNfragRphi[k];
	120	fRowMin[k] = c.fRowMin[k];
	121	fRowMax[k] = c.fRowMax[k];
	122	fColMin[k] = c.fColMin[k];
	123	fColMax[k] = c.fColMax[k];
	124	fXbins[k] = c.fXbins[k];
	125	fDetChamb0[k] = c.fDetChamb0[k];
	126	fDetChamb2[k] = c.fDetChamb2[k];
	127	}
55a288e5	128
f162af62	129	if (fGeo) {
	130	delete fGeo;
	131	}
	132	fGeo = new AliTRDgeometry();
	133
cf46274d	134	}
f162af62	135
55a288e5	136	//____________________________________________________________________________________
	137	AliTRDCalibraMode::~AliTRDCalibraMode()
	138	{
	139	//
	140	// AliTRDCalibraMode destructor
	141	//
	142
f162af62	143	if (fGeo) {
	144	delete fGeo;
	145	}
	146
55a288e5	147	}
55a288e5	148
64942b85	149	//_____________________________________________________________________________
	150	void AliTRDCalibraMode::SetPerSuperModule(Int_t i)
	151	{
	152	//
	153	// Set the mode of calibration group per supermodule
	154	//
	155
	156	fNz[i] = 10;
	157	fNrphi[i] = 10;
	158	}
	159
	160	//_____________________________________________________________________________
	161	void AliTRDCalibraMode::SetAllTogether(Int_t i)
	162	{
	163	//
	164	// Set the mode of calibration group all together
	165	//
	166
	167	fNz[i] = 100;
	168	fNrphi[i] = 100;
	169	}
	170
55a288e5	171	//_____________________________________________________________________________
	172	void AliTRDCalibraMode::SetNz(Int_t i, Short_t Nz)
	173	{
	174	//
	175	// Set the mode of calibration group in the z direction for the parameter i
	176	//
	177
	178	if ((Nz >= 0) &&
	179	(Nz < 5)) {
	180	fNz[i] = Nz;
	181	}
64942b85	182	else {
64942b85	183	AliInfo("You have to choose between 0 and 4.");
55a288e5	184	}
	185
	186	}
	187
	188	//_____________________________________________________________________________
	189	void AliTRDCalibraMode::SetNrphi(Int_t i, Short_t Nrphi)
	190	{
	191	//
	192	// Set the mode of calibration group in the rphi direction for the parameter i
	193	//
	194
	195	if ((Nrphi >= 0) &&
	196	(Nrphi < 7)) {
	197	fNrphi[i] = Nrphi;
	198	}
	199	else {
64942b85	200	AliInfo("You have to choose between 0 and 6 or 10/100.");
55a288e5	201	}
	202
	203	}
	204
	205	//_______________________________________________________________________________________
	206	void AliTRDCalibraMode::ModePadCalibration(Int_t iChamb, Int_t i)
	207	{
	208	//
	209	// Definition of the calibration mode
	210	// from Nz and Nrphi, the number of row and col pads per calibration groups are setted
	211	//
	212
	213
	214	fNnZ[i] = 0;
	215	fNnRphi[i] = 0;
	216
64942b85	217	if (((fNz[i] == 0) \|\| (fNz[i] == 10) \|\| (fNz[i] == 100)) && (iChamb == 2)) {
55a288e5	218	fNnZ[i] = 12;
55a288e5	219	}
64942b85	220	if (((fNz[i] == 0) \|\| (fNz[i] == 10) \|\| (fNz[i] == 100)) && (iChamb != 2)) {
55a288e5	221	fNnZ[i] = 16;
	222	}
	223	if ((fNz[i] == 1) && (iChamb == 2)) {
	224	fNnZ[i] = 6;
	225	}
	226	if ((fNz[i] == 1) && (iChamb != 2)) {
	227	fNnZ[i] = 8;
	228	}
	229	if ((fNz[i] == 2) && (iChamb == 2)) {
	230	fNnZ[i] = 3;
	231	}
	232	if ((fNz[i] == 2) && (iChamb != 2)) {
	233	fNnZ[i] = 4;
	234	}
	235	if (fNz[i] == 3) {
	236	fNnZ[i] = 2;
	237	}
	238	if (fNz[i] == 4) {
	239	fNnZ[i] = 1;
	240	}
	241
64942b85	242	if ((fNrphi[i] == 0) \|\| (fNrphi[i] == 10) \|\| (fNrphi[i] == 100)) {
55a288e5	243	fNnRphi[i] = 144;
	244	}
	245	if (fNrphi[i] == 1) {
	246	fNnRphi[i] = 72;
	247	}
	248	if (fNrphi[i] == 2) {
	249	fNnRphi[i] = 36;
	250	}
	251	if (fNrphi[i] == 3) {
	252	fNnRphi[i] = 18;
	253	}
	254	if (fNrphi[i] == 4) {
	255	fNnRphi[i] = 9;
	256	}
	257	if (fNrphi[i] == 5) {
	258	fNnRphi[i] = 4;
	259	}
	260	if (fNrphi[i] == 6) {
	261	fNnRphi[i] = 1;
	262	}
	263
	264	}
	265
	266	//_____________________________________________________________________________________________
053767a4	267	Bool_t AliTRDCalibraMode::ModePadFragmentation(Int_t iLayer,Int_t iStack, Int_t iSect, Int_t i)
55a288e5	268	{
	269	//
	270	// Definition of the calibration mode
	271	// From the number of row and col pads per calibration groups the
	272	// number of calibration groups are setted
	273	//
	274
	275	fNfragZ[i] = 0;
	276	fNfragRphi[i] = 0;
55a288e5	277
55a288e5	278	// A little geometry:
053767a4	279	Int_t rowMax = fGeo->GetRowMax(iLayer,iStack,iSect);
053767a4	280	Int_t colMax = fGeo->GetColMax(iLayer);
55a288e5	281
	282	// The fragmentation
	283	if (fNnZ[i] != 0) {
	284	fNfragZ[i] = (Int_t) rowMax / fNnZ[i];
	285	}
	286
	287	if (fNnRphi[i] != 0) {
	288	fNfragRphi[i] = (Int_t) colMax / fNnRphi[i];
	289	}
	290
	291	return kTRUE;
	292
	293	}
	294
	295	//_____________________________________________________________________________
	296	void AliTRDCalibraMode::ReconstructionRowPadGroup(Int_t idect, Int_t i)
	297	{
	298	//
	299	// For the calibration group idect in a detector calculate the
	300	// first and last row pad and col pad.
	301	// The pads in the interval will have the same calibrated coefficients
	302	//
	303
	304	Int_t posc = -1;
	305	Int_t posr = -1;
	306	fRowMin[i] = -1;
	307	fRowMax[i] = -1;
	308	fColMin[i] = -1;
	309	fColMax[i] = -1;
	310
	311	if (fNfragZ[i] != 0) {
	312	posc = (Int_t) idect / fNfragZ[i];
	313	}
	314	if (fNfragRphi[i] != 0) {
	315	posr = (Int_t) idect % fNfragZ[i];
	316	}
	317	fRowMin[i] = posr * fNnZ[i];
	318	fRowMax[i] = (posr+1) * fNnZ[i];
	319	fColMin[i] = posc * fNnRphi[i];
	320	fColMax[i] = (posc+1) * fNnRphi[i];
	321
	322	}
	323
	324	//_____________________________________________________________________________
	325	void AliTRDCalibraMode::CalculXBins(Int_t idect, Int_t i)
	326	{
	327	//
	328	// For the detector idect calcul the first Xbins
	329	//
	330
	331	fXbins[i] = 0;
	332	AliDebug(2, Form("detector: %d", idect));
	333
64942b85	334	// Total
	335	if((fNz[i] == 100) && (fNrphi[i] == 100)) {
	336	fXbins[i] = 0;
	337	return;
	338	}
	339
55a288e5	340	// In which sector?
55a288e5	341	Int_t sector = GetSector(idect);
55a288e5	342
64942b85	343
	344	// First per supermodule
	345	if((fNz[i] == 10) && (fNrphi[i] == 10)) {
	346	fXbins[i] = sector;
	347	return;
	348	}
	349
	350	fXbins[i] += sector(6fDetChamb2[i]+64fDetChamb0[i]);
	351
053767a4	352	// In which stack?
053767a4	353	Int_t stack = GetStack(idect);
55a288e5	354	Int_t kc = 0;
053767a4	355	while (kc < stack) {
55a288e5	356	if (kc == 2) {
	357	fXbins[i] += 6 * fDetChamb2[i];
	358	}
	359	else {
	360	fXbins[i] += 6 * fDetChamb0[i];
	361	}
	362	kc ++;
	363	}
	364
053767a4	365	// In which layer?
	366	Int_t layer = GetLayer(idect);
	367	if (stack == 2) {
	368	fXbins[i] += layer*fDetChamb2[i];
55a288e5	369	}
55a288e5	370	else {
053767a4	371	fXbins[i] += layer*fDetChamb0[i];
55a288e5	372	}
	373
	374	}
	375
	376	//_____________________________________________________________________________
	377	void AliTRDCalibraMode::ResetMinMax(Int_t i)
	378	{
	379	//
	380	// Reset fRowMin fRowMax fColMin fColMax [i]
	381	//
	382
	383	fRowMin[i] = -1;
	384	fRowMax[i] = -1;
	385	fColMin[i] = -1;
	386	fColMax[i] = -1;
	387
	388	}
	389
	390	//_____________________________________________________________________________
	391	void AliTRDCalibraMode::SetDetChamb0(Int_t i)
	392	{
	393	//
	394	// Set the number of calibration group per detector != 2
	395	//
	396
	397	fDetChamb0[i] = fNfragZ[i] * fNfragRphi[i];
	398
	399	}
	400
	401	//_____________________________________________________________________________
	402	void AliTRDCalibraMode::SetDetChamb2(Int_t i)
	403	{
	404	//
	405	// Set the number of calibration group per detector == 2
	406	//
	407
	408	fDetChamb2[i] = fNfragZ[i] * fNfragRphi[i];
	409
	410	}
	411
	412	//_____________________________________________________________________________
053767a4	413	Int_t AliTRDCalibraMode::GetLayer(Int_t d) const
55a288e5	414	{
	415	//
	416	// Reconstruct the plane number from the detector number
	417	//
	418
	419	return ((Int_t) (d % 6));
	420
	421	}
	422
	423	//_____________________________________________________________________________
053767a4	424	Int_t AliTRDCalibraMode::GetStack(Int_t d) const
55a288e5	425	{
55a288e5	426	//
053767a4	427	// Reconstruct the stack number from the detector number
55a288e5	428	//
55a288e5	429
053767a4	430	const Int_t kNlayer = 6;
55a288e5	431
053767a4	432	return ((Int_t) (d % 30) / kNlayer);
55a288e5	433
	434	}
	435
	436	//_____________________________________________________________________________
	437	Int_t AliTRDCalibraMode::GetSector(Int_t d) const
	438	{
	439	//
	440	// Reconstruct the sector number from the detector number
	441	//
	442
	443	Int_t fg = 30;
	444
	445	return ((Int_t) (d / fg));
	446
	447	}