[u/mrichter/AliRoot.git] / ITS / AliITSMisalignMaker.cxx

/**************************************************************************
 * Copyright(c) 1998-2007, 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$  */

//========================================================================
//
// This class is a helper, producing ITS aligmnent objects.
// It provides also some useful functions
// See the parameters of the misalignment at the end of this script.
//
// Main author: L. Gaudichet
// Contact: andrea.dainese@lnl.infn.it
//
//========================================================================

#include <TRandom3.h>
#include <TClonesArray.h>
#include <TMath.h>


#include "AliLog.h"
#include "AliAlignObjParams.h"
#include "AliITSMisalignMaker.h"


ClassImp(AliITSMisalignMaker)
  
const Int_t AliITSMisalignMaker::fgkNLadders[AliITSMisalignMaker::kNLayers] = {20,40,14,22,34,38};
const Int_t AliITSMisalignMaker::fgkNDetectors[AliITSMisalignMaker::kNLayers] = {4,4,6,8,22,25};


//________________________________________________________________________
AliITSMisalignMaker::AliITSMisalignMaker():
  fRnd(),
  fInd(0),
  fAlobj(TClonesArray("AliAlignObjParams",4000)),
  fStrSPD("ITS/SPD"),
  fStrSDD("ITS/SDD"),
  fStrSSD("ITS/SSD"),
  fStrStave("/Stave"),
  fStrHalfStave("/HalfStave"),
  fStrLadder("/Ladder"),
  fStrSector("/Sector"),
  fStrSensor("/Sensor")
{
  fRnd.SetSeed(23472341);
}
//________________________________________________________________________
Int_t AliITSMisalignMaker::AddAlignObj(char* name,Double_t dx,Double_t dy,Double_t dz,
				Double_t dpsi,Double_t dtheta,Double_t dphi,Bool_t unif) {

  Double_t vx,vy,vz,vpsi,vtheta,vphi;

  if(!unif) {
    vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value 
    vy = GaussCut(0,dy/3.,dy);
    vz = GaussCut(0,dz/3.,dz);
    vpsi   = GaussCut(0,dpsi/3.,  dpsi );
    vtheta = GaussCut(0,dtheta/3.,dtheta);
    vphi   = GaussCut(0,dphi/3.,  dphi);
  } else {
    vx = fRnd.Uniform(-dx,dx);
    vy = fRnd.Uniform(-dy,dy);
    vz = fRnd.Uniform(-dz,dz);
    vpsi = fRnd.Uniform(-dpsi,dpsi);
    vtheta = fRnd.Uniform(-dtheta,dtheta);
    vphi = fRnd.Uniform(-dphi,dphi);
  }

  new(fAlobj[fInd]) AliAlignObjParams(name,0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE);

  AliAlignObjParams* its_alobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
  its_alobj->ApplyToGeometry();

  fInd++;

  return kTRUE;
}


//________________________________________________________________________
Int_t AliITSMisalignMaker::AddAlignObj(Int_t lay,Double_t dx,Double_t dy,Double_t dz,
				 Double_t dpsi,Double_t dtheta,Double_t dphi,Bool_t unif) {
  
  // misalignment at the level of ladders/modules
  lay+=1; // layers are numbered from 1 to 6 in AliGeomManager

  printf("LAYER %d  MODULES %d\n",lay,AliGeomManager::LayerSize(lay));

  for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(lay); iModule++) {

    Double_t vx,vy,vz,vpsi,vtheta,vphi;
    
    if(!unif) {
      vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value 
      vy = GaussCut(0,dy/3.,dy);
      vz = GaussCut(0,dz/3.,dz);
      vpsi   = GaussCut(0,dpsi/3.,  dpsi );
      vtheta = GaussCut(0,dtheta/3.,dtheta);
      vphi   = GaussCut(0,dphi/3.,  dphi);
    } else {
      vx = fRnd.Uniform(-dx,dx);
      vy = fRnd.Uniform(-dy,dy);
      vz = fRnd.Uniform(-dz,dz);
      vpsi = fRnd.Uniform(-dpsi,dpsi);
      vtheta = fRnd.Uniform(-dtheta,dtheta);
      vphi = fRnd.Uniform(-dphi,dphi);
    }
    
    UShort_t volid = AliGeomManager::LayerToVolUID(lay,iModule);
    const char *symname = AliGeomManager::SymName(volid);
    
    new(fAlobj[fInd]) AliAlignObjParams(symname,volid,vx,vy,vz,vpsi,vtheta,vphi,kFALSE);
    AliAlignObjParams* its_alobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
    its_alobj->ApplyToGeometry();
    fInd++; 
  }

  return kTRUE;
}


//________________________________________________________________________
Int_t AliITSMisalignMaker::AddAlignObj(Int_t lay,Int_t ladd,Double_t dx,Double_t dy,Double_t dz,
				 Double_t dpsi,Double_t dtheta,Double_t dphi,Bool_t unif) {

  // misalignment at the level of half-staves/ladders (ladd=-1 means that all ladders are scanned)

  Double_t vx,vy,vz,vpsi,vtheta,vphi;
  
  Int_t laddMin = ladd;
  Int_t laddMax = laddMin+1;
  if (ladd<0) {
    laddMin = 0;
    laddMax = fgkNLadders[lay];
  }

  for (Int_t iLadd=laddMin; iLadd<laddMax; iLadd++) {

    Int_t nHS = 1; 
    if (lay<2) nHS = 2;
    for (Int_t iHalfStave=0; iHalfStave<nHS; iHalfStave++) {
      
      if(!unif) {
	vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value 
	vy = GaussCut(0,dy/3.,dy);
	vz = GaussCut(0,dz/3.,dz);
	vpsi   = GaussCut(0,dpsi/3.,  dpsi );
	vtheta = GaussCut(0,dtheta/3.,dtheta);
	vphi   = GaussCut(0,dphi/3.,  dphi);
      } else {
	vx = fRnd.Uniform(-dx,dx);
	vy = fRnd.Uniform(-dy,dy);
	vz = fRnd.Uniform(-dz,dz);
	vpsi = fRnd.Uniform(-dpsi,dpsi);
	vtheta = fRnd.Uniform(-dtheta,dtheta);
	vphi = fRnd.Uniform(-dphi,dphi);
      }

      TString name = GetHalfStaveLadderSymbName(lay,iLadd,iHalfStave);
      new(fAlobj[fInd]) AliAlignObjParams(name.Data(),0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE);
      AliAlignObjParams* its_alobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
      its_alobj->ApplyToGeometry();
      fInd++;
    }
  }
  
  return kTRUE;
}


//________________________________________________________________________
Int_t AliITSMisalignMaker::AddSectorAlignObj(Int_t sectMin,Int_t sectMax,
				       Double_t dx,Double_t dy,Double_t dz,
				       Double_t dpsi,Double_t dtheta,Double_t dphi,
				       Double_t xShift,Double_t yShift,Double_t zShift,
				       Double_t psiShift,Double_t thetaShift,Double_t phiShift,Bool_t unif) {

  // misalignment at the level of SPD sectors and half-barrels
 
  if ((sectMin<1) || (sectMax>10)) return kFALSE;
  Double_t vx,vy,vz,vpsi,vtheta,vphi;
  Double_t tr[3],rot[3];  

  for (Int_t iSect = sectMin-1; iSect<sectMax; iSect++) {

    // first, apply sector level misalignment    
    if(!unif) {
      vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value 
      vy = GaussCut(0,dy/3.,dy);
      vz = GaussCut(0,dz/3.,dz);
      vpsi   = GaussCut(0,dpsi/3.,  dpsi );
      vtheta = GaussCut(0,dtheta/3.,dtheta);
      vphi   = GaussCut(0,dphi/3.,  dphi);
    } else {
      vx = fRnd.Uniform(-dx,dx);
      vy = fRnd.Uniform(-dy,dy);
      vz = fRnd.Uniform(-dz,dz);
      vpsi = fRnd.Uniform(-dpsi,dpsi);
      vtheta = fRnd.Uniform(-dtheta,dtheta);
      vphi = fRnd.Uniform(-dphi,dphi);
    }

    TString name = GetSymbName(0);
    name += fStrSector;
    name += iSect;


    AliAlignObjParams aaop(name.Data(),0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE); // set them as local
    aaop.GetPars(tr,rot); // global

    // then, apply half-barrel level misalignment
    tr[0] += xShift;
    tr[1] += yShift;
    tr[2] += zShift;
    rot[0] += psiShift;
    rot[1] += thetaShift;
    rot[2] += phiShift;

    new(fAlobj[fInd]) AliAlignObjParams(name.Data(),0,tr[0],tr[1],tr[2],rot[0],rot[1],rot[2],kTRUE); // set them as global

    AliAlignObjParams* its_alobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
    its_alobj->ApplyToGeometry();
    fInd++;
  }
  return kTRUE;
}

//________________________________________________________________________
Double_t AliITSMisalignMaker::GaussCut(Double_t mean,Double_t sigma,Double_t absMax) {

  Double_t val = fRnd.Gaus(mean,sigma);
  while (TMath::Abs(val)>absMax)
    val = fRnd.Gaus(mean,sigma);
  return val;
}

//________________________________________________________________________
TString AliITSMisalignMaker::GetSymbName(Int_t layer) const {

  // be careful : SPD0 and SPD1 are not physically separated 
  TString name;
  switch (layer) {
  case 0:
  case 1: name = fStrSPD; name += layer; break;
  case 2:
  case 3: name = fStrSDD; name += layer; break;
  case 4:
  case 5: name = fStrSSD; name += layer; break;
  default: AliFatal("Wrong layer index");
  }
  return name;
}

//________________________________________________________________________
TString AliITSMisalignMaker::GetHalfStaveLadderSymbName(Int_t layer,Int_t ladd,Int_t halfStave) const {

  // Get logical names at the level of half-staves (SPD) or ladders (SDD and SSD)

  TString name = GetSymbName(layer);
  if (layer==0) { // SPD1

    int sector = ladd/2;
    name += fStrSector;
    name += sector;
    int stave = ladd-sector*2;
    name += fStrStave;
    name += stave;
    name += fStrHalfStave;
    name += halfStave;
  }
  else if (layer==1) { // SPD2

    int sector = ladd/4;
    name += fStrSector;
    name += sector;
    int stave = ladd-sector*4;
    name += fStrStave;
    name += stave;
    name += fStrHalfStave;
    name += halfStave;
  }
  else if (layer>=2 && layer<=5) { // SDD and SSD
    name += fStrLadder;
    name += ladd;
  } 
  else {
    AliFatal("Wrong layer index");
  }
  return name;
}

//________________________________________________________________________
TString AliITSMisalignMaker::GetSymbName(Int_t layer,Int_t ladd) const {

  // Get logical names at the level of staves / ladders

  TString name = GetSymbName(layer);
  if (layer==0) { // SPD1

    int sector = ladd/2;
    name += fStrSector;
    name += sector;
    int stave = ladd-sector*2;
    name += fStrStave;
    name += stave;
  }
  else if (layer==1) { // SPD2

    int sector = ladd/4;
    name += fStrSector;
    name += sector;
    int stave = ladd-sector*4;
    name += fStrStave;
    name += stave;
  }
  else if (layer>=2 && layer<=5) { // SDD and SSD
    name += fStrLadder;
    name += ladd;
  }
  else {
    AliFatal("Wrong layer index");
  }
  return name;
}
/*
//________________________________________________________________________
TString AliITSMisalignMaker::GetSymbName(Int_t layer,Int_t ladd,Int_t mod) const {

  // Get logical names at the level of SPD ladders / SDD and SSD modules

  Int_t halfStave = mod/2;
  TString name = GetHalfStaveLadderSymbName(layer,ladd,halfStave);

  if (layer<2) { // SPD
    name += fStrLadder;
    name += mod;
  } 
  else if (layer>=2 && layer<=5) { // SDD and SSD
    name += fStrSensor;
    name += mod;
  }
  else {
    AliFatal("Wrong layer index");
  }
  return name;
}
*/
Commit	Line	Data
3b61c716	1	/**************************************************************************
	2	* Copyright(c) 1998-2007, 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
b5cec7b2	16	/* $Id$ */
3b61c716	17
	18	//========================================================================
	19	//
	20	// This class is a helper, producing ITS aligmnent objects.
	21	// It provides also some useful functions
	22	// See the parameters of the misalignment at the end of this script.
	23	//
	24	// Main author: L. Gaudichet
	25	// Contact: andrea.dainese@lnl.infn.it
	26	//
	27	//========================================================================
	28
	29	#include <TRandom3.h>
	30	#include <TClonesArray.h>
	31	#include <TMath.h>
	32
	33
	34	#include "AliLog.h"
	35	#include "AliAlignObjParams.h"
	36	#include "AliITSMisalignMaker.h"
	37
	38
	39	ClassImp(AliITSMisalignMaker)
	40
	41	const Int_t AliITSMisalignMaker::fgkNLadders[AliITSMisalignMaker::kNLayers] = {20,40,14,22,34,38};
	42	const Int_t AliITSMisalignMaker::fgkNDetectors[AliITSMisalignMaker::kNLayers] = {4,4,6,8,22,25};
	43
	44
	45	//________________________________________________________________________
	46	AliITSMisalignMaker::AliITSMisalignMaker():
	47	fRnd(),
	48	fInd(0),
	49	fAlobj(TClonesArray("AliAlignObjParams",4000)),
	50	fStrSPD("ITS/SPD"),
	51	fStrSDD("ITS/SDD"),
	52	fStrSSD("ITS/SSD"),
	53	fStrStave("/Stave"),
	54	fStrHalfStave("/HalfStave"),
	55	fStrLadder("/Ladder"),
	56	fStrSector("/Sector"),
	57	fStrSensor("/Sensor")
	58	{
	59	fRnd.SetSeed(23472341);
	60	}
	61	//________________________________________________________________________
	62	Int_t AliITSMisalignMaker::AddAlignObj(char* name,Double_t dx,Double_t dy,Double_t dz,
	63	Double_t dpsi,Double_t dtheta,Double_t dphi,Bool_t unif) {
	64
	65	Double_t vx,vy,vz,vpsi,vtheta,vphi;
	66
	67	if(!unif) {
	68	vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value
	69	vy = GaussCut(0,dy/3.,dy);
	70	vz = GaussCut(0,dz/3.,dz);
	71	vpsi = GaussCut(0,dpsi/3., dpsi );
	72	vtheta = GaussCut(0,dtheta/3.,dtheta);
	73	vphi = GaussCut(0,dphi/3., dphi);
	74	} else {
	75	vx = fRnd.Uniform(-dx,dx);
	76	vy = fRnd.Uniform(-dy,dy);
	77	vz = fRnd.Uniform(-dz,dz);
	78	vpsi = fRnd.Uniform(-dpsi,dpsi);
	79	vtheta = fRnd.Uniform(-dtheta,dtheta);
	80	vphi = fRnd.Uniform(-dphi,dphi);
81	}
82
83	new(fAlobj[fInd]) AliAlignObjParams(name,0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE);
84
85	AliAlignObjParams* its_alobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
86	its_alobj->ApplyToGeometry();
87
88	fInd++;
89
90	return kTRUE;
91	}
92
93
94	//________________________________________________________________________
95	Int_t AliITSMisalignMaker::AddAlignObj(Int_t lay,Double_t dx,Double_t dy,Double_t dz,
96	Double_t dpsi,Double_t dtheta,Double_t dphi,Bool_t unif) {
97
98	// misalignment at the level of ladders/modules
b5cec7b2	99	lay+=1; // layers are numbered from 1 to 6 in AliGeomManager
3b61c716	100
b5cec7b2	101	printf("LAYER %d MODULES %d\n",lay,AliGeomManager::LayerSize(lay));
3b61c716	102
b5cec7b2	103	for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(lay); iModule++) {
3b61c716	104
b5cec7b2	105	Double_t vx,vy,vz,vpsi,vtheta,vphi;
	106
	107	if(!unif) {
	108	vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value
	109	vy = GaussCut(0,dy/3.,dy);
	110	vz = GaussCut(0,dz/3.,dz);
	111	vpsi = GaussCut(0,dpsi/3., dpsi );
	112	vtheta = GaussCut(0,dtheta/3.,dtheta);
	113	vphi = GaussCut(0,dphi/3., dphi);
	114	} else {
	115	vx = fRnd.Uniform(-dx,dx);
	116	vy = fRnd.Uniform(-dy,dy);
	117	vz = fRnd.Uniform(-dz,dz);
	118	vpsi = fRnd.Uniform(-dpsi,dpsi);
	119	vtheta = fRnd.Uniform(-dtheta,dtheta);
	120	vphi = fRnd.Uniform(-dphi,dphi);
3b61c716	121	}
b5cec7b2	122
	123	UShort_t volid = AliGeomManager::LayerToVolUID(lay,iModule);
	124	const char *symname = AliGeomManager::SymName(volid);
	125
	126	new(fAlobj[fInd]) AliAlignObjParams(symname,volid,vx,vy,vz,vpsi,vtheta,vphi,kFALSE);
	127	AliAlignObjParams* its_alobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
	128	its_alobj->ApplyToGeometry();
	129	fInd++;
3b61c716	130	}
	131
	132	return kTRUE;
	133	}
	134
	135
	136	//________________________________________________________________________
	137	Int_t AliITSMisalignMaker::AddAlignObj(Int_t lay,Int_t ladd,Double_t dx,Double_t dy,Double_t dz,
	138	Double_t dpsi,Double_t dtheta,Double_t dphi,Bool_t unif) {
	139
	140	// misalignment at the level of half-staves/ladders (ladd=-1 means that all ladders are scanned)
	141
	142	Double_t vx,vy,vz,vpsi,vtheta,vphi;
	143
	144	Int_t laddMin = ladd;
	145	Int_t laddMax = laddMin+1;
	146	if (ladd<0) {
	147	laddMin = 0;
	148	laddMax = fgkNLadders[lay];
	149	}
	150
	151	for (Int_t iLadd=laddMin; iLadd<laddMax; iLadd++) {
	152
	153	Int_t nHS = 1;
	154	if (lay<2) nHS = 2;
	155	for (Int_t iHalfStave=0; iHalfStave<nHS; iHalfStave++) {
	156
	157	if(!unif) {
	158	vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value
	159	vy = GaussCut(0,dy/3.,dy);
	160	vz = GaussCut(0,dz/3.,dz);
	161	vpsi = GaussCut(0,dpsi/3., dpsi );
	162	vtheta = GaussCut(0,dtheta/3.,dtheta);
	163	vphi = GaussCut(0,dphi/3., dphi);
	164	} else {
	165	vx = fRnd.Uniform(-dx,dx);
	166	vy = fRnd.Uniform(-dy,dy);
	167	vz = fRnd.Uniform(-dz,dz);
	168	vpsi = fRnd.Uniform(-dpsi,dpsi);
	169	vtheta = fRnd.Uniform(-dtheta,dtheta);
	170	vphi = fRnd.Uniform(-dphi,dphi);
	171	}
	172
	173	TString name = GetHalfStaveLadderSymbName(lay,iLadd,iHalfStave);
	174	new(fAlobj[fInd]) AliAlignObjParams(name.Data(),0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE);
	175	AliAlignObjParams* its_alobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
	176	its_alobj->ApplyToGeometry();
	177	fInd++;
	178	}
	179	}
	180
	181	return kTRUE;
	182	}
	183
	184
	185	//________________________________________________________________________
	186	Int_t AliITSMisalignMaker::AddSectorAlignObj(Int_t sectMin,Int_t sectMax,
	187	Double_t dx,Double_t dy,Double_t dz,
	188	Double_t dpsi,Double_t dtheta,Double_t dphi,
	189	Double_t xShift,Double_t yShift,Double_t zShift,
	190	Double_t psiShift,Double_t thetaShift,Double_t phiShift,Bool_t unif) {
	191
	192	// misalignment at the level of SPD sectors and half-barrels
	193
194	if ((sectMin<1) \|\| (sectMax>10)) return kFALSE;
195	Double_t vx,vy,vz,vpsi,vtheta,vphi;
196	Double_t tr[3],rot[3];
197
198	for (Int_t iSect = sectMin-1; iSect<sectMax; iSect++) {
199
200	// first, apply sector level misalignment
201	if(!unif) {
202	vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value
203	vy = GaussCut(0,dy/3.,dy);
204	vz = GaussCut(0,dz/3.,dz);
205	vpsi = GaussCut(0,dpsi/3., dpsi );
206	vtheta = GaussCut(0,dtheta/3.,dtheta);
207	vphi = GaussCut(0,dphi/3., dphi);
208	} else {
209	vx = fRnd.Uniform(-dx,dx);
210	vy = fRnd.Uniform(-dy,dy);
211	vz = fRnd.Uniform(-dz,dz);
212	vpsi = fRnd.Uniform(-dpsi,dpsi);
213	vtheta = fRnd.Uniform(-dtheta,dtheta);
214	vphi = fRnd.Uniform(-dphi,dphi);
215	}
216
217	TString name = GetSymbName(0);
218	name += fStrSector;
219	name += iSect;
220
221
222	AliAlignObjParams aaop(name.Data(),0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE); // set them as local
223	aaop.GetPars(tr,rot); // global
224
225	// then, apply half-barrel level misalignment
226	tr[0] += xShift;
227	tr[1] += yShift;
228	tr[2] += zShift;
229	rot[0] += psiShift;
230	rot[1] += thetaShift;
231	rot[2] += phiShift;
232
233	new(fAlobj[fInd]) AliAlignObjParams(name.Data(),0,tr[0],tr[1],tr[2],rot[0],rot[1],rot[2],kTRUE); // set them as global
234
235	AliAlignObjParams* its_alobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
236	its_alobj->ApplyToGeometry();
237	fInd++;
238	}
239	return kTRUE;
240	}
241
242	//________________________________________________________________________
243	Double_t AliITSMisalignMaker::GaussCut(Double_t mean,Double_t sigma,Double_t absMax) {
244
245	Double_t val = fRnd.Gaus(mean,sigma);
246	while (TMath::Abs(val)>absMax)
247	val = fRnd.Gaus(mean,sigma);
248	return val;
249	}
250
251	//________________________________________________________________________
252	TString AliITSMisalignMaker::GetSymbName(Int_t layer) const {
253
254	// be careful : SPD0 and SPD1 are not physically separated
255	TString name;
256	switch (layer) {
257	case 0:
258	case 1: name = fStrSPD; name += layer; break;
259	case 2:
260	case 3: name = fStrSDD; name += layer; break;
261	case 4:
262	case 5: name = fStrSSD; name += layer; break;
263	default: AliFatal("Wrong layer index");
264	}
265	return name;
266	}
267
268	//________________________________________________________________________
269	TString AliITSMisalignMaker::GetHalfStaveLadderSymbName(Int_t layer,Int_t ladd,Int_t halfStave) const {
270
271	// Get logical names at the level of half-staves (SPD) or ladders (SDD and SSD)
272
273	TString name = GetSymbName(layer);
274	if (layer==0) { // SPD1
275
276	int sector = ladd/2;
277	name += fStrSector;
278	name += sector;
279	int stave = ladd-sector*2;
280	name += fStrStave;
281	name += stave;
282	name += fStrHalfStave;
283	name += halfStave;
284	}
285	else if (layer==1) { // SPD2
286
287	int sector = ladd/4;
288	name += fStrSector;
289	name += sector;
290	int stave = ladd-sector*4;
291	name += fStrStave;
292	name += stave;
293	name += fStrHalfStave;
294	name += halfStave;
295	}
296	else if (layer>=2 && layer<=5) { // SDD and SSD
297	name += fStrLadder;
298	name += ladd;
299	}
300	else {
301	AliFatal("Wrong layer index");
302	}
303	return name;
304	}
305
306	//________________________________________________________________________
307	TString AliITSMisalignMaker::GetSymbName(Int_t layer,Int_t ladd) const {
308
309	// Get logical names at the level of staves / ladders
310
311	TString name = GetSymbName(layer);
312	if (layer==0) { // SPD1
313
314	int sector = ladd/2;
315	name += fStrSector;
316	name += sector;
317	int stave = ladd-sector*2;
318	name += fStrStave;
319	name += stave;
320	}
321	else if (layer==1) { // SPD2
322
323	int sector = ladd/4;
324	name += fStrSector;
325	name += sector;
326	int stave = ladd-sector*4;
327	name += fStrStave;
328	name += stave;
329	}
330	else if (layer>=2 && layer<=5) { // SDD and SSD
331	name += fStrLadder;
332	name += ladd;
333	}
334	else {
335	AliFatal("Wrong layer index");
336	}
337	return name;
338	}
b5cec7b2	339	/*
3b61c716	340	//________________________________________________________________________
	341	TString AliITSMisalignMaker::GetSymbName(Int_t layer,Int_t ladd,Int_t mod) const {
	342
	343	// Get logical names at the level of SPD ladders / SDD and SSD modules
	344
	345	Int_t halfStave = mod/2;
	346	TString name = GetHalfStaveLadderSymbName(layer,ladd,halfStave);
	347
	348	if (layer<2) { // SPD
	349	name += fStrLadder;
	350	name += mod;
	351	}
	352	else if (layer>=2 && layer<=5) { // SDD and SSD
	353	name += fStrSensor;
	354	name += mod;
	355	}
	356	else {
	357	AliFatal("Wrong layer index");
	358	}
	359	return name;
	360	}
b5cec7b2	361	*/