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

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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Implementation of the class for bad channel treatment in the tracker //
// Stores 1 status bit for each SPD pixel and SDD anode:                //
//  0 = bad channel                                                     //
//  1 = good channel                                                    //
// Dead and noisy channels are read from AliITSCalibration objects      //
// Origin: F.Prino, Torino, prino@to.infn.it                            //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "AliITSChannelStatus.h"
#include "AliITSCalibrationSPD.h"
#include "AliITSCalibrationSDD.h"
#include "AliCDBEntry.h"
#include "AliLog.h"

ClassImp(AliITSChannelStatus)


//______________________________________________________________________
AliITSChannelStatus::AliITSChannelStatus():
TObject(),
fSPDChannelStatus(0),
fSDDChannelStatus(0)
{
  // default constructor 
  UInt_t nSPDchan=kSPDModules*kSPDNpxPerModule*kSPDNpzPerModule;
  fSPDChannelStatus=new TBits(nSPDchan);
  UInt_t nSDDchan=kSDDModules*kSDDAnodesPerModule;
  fSDDChannelStatus=new TBits(nSDDchan);
  InitDefaults();
}
//______________________________________________________________________
AliITSChannelStatus::AliITSChannelStatus(AliCDBManager *cdb):
TObject(),
fSPDChannelStatus(0),
fSDDChannelStatus(0)
{
  AliCDBEntry* spdEntryD = cdb->Get("ITS/Calib/SPDDead");
  if (!spdEntryD) AliFatal("Cannot get CDB entry for SPDDead");
  TObjArray* deadArrSPD = (TObjArray*)spdEntryD->GetObject();
  if (!deadArrSPD) AliFatal("No object found in SPDDead file");

  AliCDBEntry* spdEntryN = cdb->Get("ITS/Calib/SPDNoisy");
  if (!spdEntryN) AliFatal("Cannot get CDB entry for SPDNoisy");
  TObjArray* noisArrSPD = (TObjArray*)spdEntryN->GetObject();
  if (!noisArrSPD) AliFatal("No object found in SPDNoisy file");

  AliCDBEntry* sddEntry = cdb->Get("ITS/Calib/CalibSDD");
  if (!sddEntry) AliFatal("Cannot get CDB entry for CalibSDD");
  TObjArray* calArrSDD = (TObjArray*)sddEntry->GetObject();
  if (!calArrSDD) AliFatal("No object found in CalibSDD file");

  UInt_t nSPDchan=kSPDModules*kSPDNpxPerModule*kSPDNpzPerModule;
  fSPDChannelStatus=new TBits(nSPDchan);
  UInt_t nSDDchan=kSDDModules*kSDDAnodesPerModule;
  fSDDChannelStatus=new TBits(nSDDchan);
  InitFromOCDB(deadArrSPD,noisArrSPD,calArrSDD);
}
//______________________________________________________________________
AliITSChannelStatus::AliITSChannelStatus(AliITSDetTypeRec *dtrec):
TObject(),
fSPDChannelStatus(0),
fSDDChannelStatus(0)
{
  UInt_t nSPDchan=kSPDModules*kSPDNpxPerModule*kSPDNpzPerModule;
  fSPDChannelStatus=new TBits(nSPDchan);
  
  UInt_t nSDDchan=kSDDModules*kSDDAnodesPerModule;
  fSDDChannelStatus=new TBits(nSDDchan);
  
  // SPD modules
  for(Int_t imod=0; imod<kSPDModules; imod++){
    for(Int_t ix=0; ix<kSPDNpxPerModule; ix++){
      for(Int_t iz=0; iz<kSPDNpzPerModule; iz++){
	Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
	fSPDChannelStatus->SetBitNumber(index,kTRUE);
      }
    }
    Int_t ix,iz;

    // Mask SPD dead pixels
    AliITSCalibrationSPD* deadspd=(AliITSCalibrationSPD*)dtrec->GetSPDDeadModel(imod);
    for(Int_t ipix=0; ipix<deadspd->GetNrBad();ipix++){
      deadspd->GetBadPixel(ipix,ix,iz);
      Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
      fSPDChannelStatus->SetBitNumber(index,kFALSE);      
    }
    // Mask SPD noisy pixels
    AliITSCalibrationSPD* noisspd=(AliITSCalibrationSPD*)dtrec->GetCalibrationModel(imod);
    for(Int_t ipix=0; ipix<noisspd->GetNrBad();ipix++){
      noisspd->GetBadPixel(ipix,ix,iz);
      Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
      fSPDChannelStatus->SetBitNumber(index,kFALSE);
    }
  }

  // SDD modules
  for(Int_t imod=0; imod<kSDDModules; imod++){
    AliITSCalibrationSDD* calsdd=(AliITSCalibrationSDD*)dtrec->GetCalibrationModel(imod+kSPDModules);
    for(Int_t ian=0; ian<kSDDAnodesPerModule; ian++){
      Bool_t cstatus=kTRUE;
      if(calsdd->IsBadChannel(ian)) cstatus=kFALSE;
      Int_t index=imod*kSDDAnodesPerModule+ian;
      fSDDChannelStatus->SetBitNumber(index,cstatus);
    }
  }
}
//______________________________________________________________________
void  AliITSChannelStatus::InitDefaults(){
  // fill bitmaps setting all channels as good
  for(Int_t imod=0; imod<kSPDModules; imod++){
    for(Int_t ix=0; ix<kSPDNpxPerModule; ix++){
      for(Int_t iz=0; iz<kSPDNpzPerModule; iz++){
	Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
	fSPDChannelStatus->SetBitNumber(index,kTRUE);
      }
    }
  }
  for(Int_t imod=0; imod<kSDDModules; imod++){
    for(Int_t ian=0; ian<kSDDAnodesPerModule; ian++){
      Int_t index=imod*kSDDAnodesPerModule+ian;
      fSDDChannelStatus->SetBitNumber(index,kTRUE);
    }
  }
}
//______________________________________________________________________
void AliITSChannelStatus::InitFromOCDB(TObjArray* deadArrSPD, TObjArray* noisArrSPD, TObjArray* calArrSDD){
// fills bitmaps from arrays of AliITSCalibrationSXD objects

  // SPD modules
  for(Int_t imod=0; imod<kSPDModules; imod++){
    for(Int_t ix=0; ix<kSPDNpxPerModule; ix++){
      for(Int_t iz=0; iz<kSPDNpzPerModule; iz++){
	Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
	fSPDChannelStatus->SetBitNumber(index,kTRUE);
      }
    }
    Int_t ix,iz;

    // Mask SPD dead pixels
    AliITSCalibrationSPD* deadspd=(AliITSCalibrationSPD*)deadArrSPD->At(imod);
    for(Int_t ipix=0; ipix<deadspd->GetNrBad();ipix++){
      deadspd->GetBadPixel(ipix,ix,iz);
      Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
      fSPDChannelStatus->SetBitNumber(index,kFALSE);      
    }

    // Mask SPD noisy pixels
    AliITSCalibrationSPD* noisspd=(AliITSCalibrationSPD*)noisArrSPD->At(imod);
    for(Int_t ipix=0; ipix<noisspd->GetNrBad();ipix++){
      noisspd->GetBadPixel(ipix,ix,iz);
      Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
      fSPDChannelStatus->SetBitNumber(index,kFALSE);
    }
  }

  // SDD modules
  for(Int_t imod=0; imod<kSDDModules; imod++){
    AliITSCalibrationSDD* calsdd=(AliITSCalibrationSDD*)calArrSDD->At(imod);
    for(Int_t ian=0; ian<kSDDAnodesPerModule; ian++){
      Bool_t cstatus=kTRUE;
      if(calsdd->IsBadChannel(ian)) cstatus=kFALSE;
      Int_t index=imod*kSDDAnodesPerModule+ian;
      fSDDChannelStatus->SetBitNumber(index,cstatus);
    }
  }
}
//______________________________________________________________________
AliITSChannelStatus::AliITSChannelStatus(const AliITSChannelStatus& cstatus):
TObject(),
fSPDChannelStatus(cstatus.fSPDChannelStatus),
fSDDChannelStatus(cstatus.fSDDChannelStatus)
{
  // copy constructor 
}
//______________________________________________________________________
AliITSChannelStatus& AliITSChannelStatus::operator=(const AliITSChannelStatus& cstatus)
{
  // assignment operator
  this->~AliITSChannelStatus();
  new(this) AliITSChannelStatus(cstatus);
  return *this;
}

//______________________________________________________________________
AliITSChannelStatus::~AliITSChannelStatus(){
  // destructor
  if(fSPDChannelStatus) delete fSPDChannelStatus;
  if(fSDDChannelStatus) delete fSDDChannelStatus;
}

//______________________________________________________________________
Bool_t AliITSChannelStatus::CheckBounds(Int_t imod, Int_t iz, Int_t ix) const {
  // check for out of bounds
  if(imod<0 || imod>=kSPDModules+kSDDModules){
    AliError(Form("Module number out of range 0-%d",kSPDModules+kSDDModules));
    return kFALSE;
  }
  if(imod<kSPDModules){
    if(ix<0 || ix>=kSPDNpxPerModule || iz<0 || iz>=kSPDNpzPerModule){
      AliError("SPD: Pixel number out of range");
      return kFALSE;
    }
  }else{
    if(iz<0 || iz>=kSDDAnodesPerModule){
      AliError("SDD: anode number out of range");
      return kFALSE;
    }
  }
  return kTRUE;
}
//______________________________________________________________________
Bool_t AliITSChannelStatus::GetChannelStatus(Int_t imod, Int_t iz, Int_t ix) const {
  // return status of inquired channel
  if(CheckBounds(imod,iz,ix)==kFALSE) return kFALSE;
  if(imod<kSPDModules){
    Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
    return fSPDChannelStatus->TestBitNumber(index);
  }else{
    imod-=kSPDModules;
    Int_t index=imod*kSDDAnodesPerModule+iz;
    return fSDDChannelStatus->TestBitNumber(index);    
  }
}
//______________________________________________________________________
void AliITSChannelStatus::SetChannelStatus(Bool_t cstatus, Int_t imod, Int_t iz, Int_t ix){
  // set status for given channel
  if(CheckBounds(imod,iz,ix)==kFALSE) return;
  if(imod<kSPDModules){
    Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
    fSPDChannelStatus->SetBitNumber(index,cstatus);
  }else{
    imod-=kSPDModules;
    Int_t index=imod*kSDDAnodesPerModule+iz;
    fSDDChannelStatus->SetBitNumber(index,cstatus);
  }
}
Commit	Line	Data
4a60ccc4	1	/**************************************************************************
	2	* Copyright(c) 2007-2009, 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
23197852	16	/* $Id:$ */
4a60ccc4	17
	18	//////////////////////////////////////////////////////////////////////////
	19	// //
	20	// Implementation of the class for bad channel treatment in the tracker //
	21	// Stores 1 status bit for each SPD pixel and SDD anode: //
	22	// 0 = bad channel //
	23	// 1 = good channel //
23197852	24	// Dead and noisy channels are read from AliITSCalibration objects //
4a60ccc4	25	// Origin: F.Prino, Torino, prino@to.infn.it //
	26	// //
	27	//////////////////////////////////////////////////////////////////////////
	28
	29	#include "AliITSChannelStatus.h"
	30	#include "AliITSCalibrationSPD.h"
	31	#include "AliITSCalibrationSDD.h"
	32	#include "AliCDBEntry.h"
	33	#include "AliLog.h"
	34
	35	ClassImp(AliITSChannelStatus)
	36
	37
	38	//______________________________________________________________________
	39	AliITSChannelStatus::AliITSChannelStatus():
	40	TObject(),
	41	fSPDChannelStatus(0),
	42	fSDDChannelStatus(0)
	43	{
	44	// default constructor
	45	UInt_t nSPDchan=kSPDModuleskSPDNpxPerModulekSPDNpzPerModule;
	46	fSPDChannelStatus=new TBits(nSPDchan);
	47	UInt_t nSDDchan=kSDDModules*kSDDAnodesPerModule;
	48	fSDDChannelStatus=new TBits(nSDDchan);
	49	InitDefaults();
	50	}
	51	//______________________________________________________________________
	52	AliITSChannelStatus::AliITSChannelStatus(AliCDBManager *cdb):
	53	TObject(),
	54	fSPDChannelStatus(0),
	55	fSDDChannelStatus(0)
	56	{
	57	AliCDBEntry* spdEntryD = cdb->Get("ITS/Calib/SPDDead");
	58	if (!spdEntryD) AliFatal("Cannot get CDB entry for SPDDead");
	59	TObjArray* deadArrSPD = (TObjArray*)spdEntryD->GetObject();
	60	if (!deadArrSPD) AliFatal("No object found in SPDDead file");
	61
	62	AliCDBEntry* spdEntryN = cdb->Get("ITS/Calib/SPDNoisy");
	63	if (!spdEntryN) AliFatal("Cannot get CDB entry for SPDNoisy");
	64	TObjArray* noisArrSPD = (TObjArray*)spdEntryN->GetObject();
	65	if (!noisArrSPD) AliFatal("No object found in SPDNoisy file");
	66
	67	AliCDBEntry* sddEntry = cdb->Get("ITS/Calib/CalibSDD");
	68	if (!sddEntry) AliFatal("Cannot get CDB entry for CalibSDD");
	69	TObjArray* calArrSDD = (TObjArray*)sddEntry->GetObject();
	70	if (!calArrSDD) AliFatal("No object found in CalibSDD file");
	71
	72	UInt_t nSPDchan=kSPDModuleskSPDNpxPerModulekSPDNpzPerModule;
	73	fSPDChannelStatus=new TBits(nSPDchan);
	74	UInt_t nSDDchan=kSDDModules*kSDDAnodesPerModule;
	75	fSDDChannelStatus=new TBits(nSDDchan);
	76	InitFromOCDB(deadArrSPD,noisArrSPD,calArrSDD);
	77	}
	78	//______________________________________________________________________
23197852	79	AliITSChannelStatus::AliITSChannelStatus(AliITSDetTypeRec *dtrec):
	80	TObject(),
	81	fSPDChannelStatus(0),
	82	fSDDChannelStatus(0)
	83	{
	84	UInt_t nSPDchan=kSPDModuleskSPDNpxPerModulekSPDNpzPerModule;
	85	fSPDChannelStatus=new TBits(nSPDchan);
	86
	87	UInt_t nSDDchan=kSDDModules*kSDDAnodesPerModule;
	88	fSDDChannelStatus=new TBits(nSDDchan);
	89
	90	// SPD modules
	91	for(Int_t imod=0; imod<kSPDModules; imod++){
	92	for(Int_t ix=0; ix<kSPDNpxPerModule; ix++){
	93	for(Int_t iz=0; iz<kSPDNpzPerModule; iz++){
	94	Int_t index=imodkSPDNpxPerModulekSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
	95	fSPDChannelStatus->SetBitNumber(index,kTRUE);
	96	}
	97	}
	98	Int_t ix,iz;
	99
	100	// Mask SPD dead pixels
	101	AliITSCalibrationSPD* deadspd=(AliITSCalibrationSPD*)dtrec->GetSPDDeadModel(imod);
	102	for(Int_t ipix=0; ipix<deadspd->GetNrBad();ipix++){
	103	deadspd->GetBadPixel(ipix,ix,iz);
	104	Int_t index=imodkSPDNpxPerModulekSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
	105	fSPDChannelStatus->SetBitNumber(index,kFALSE);
	106	}
	107	// Mask SPD noisy pixels
	108	AliITSCalibrationSPD* noisspd=(AliITSCalibrationSPD*)dtrec->GetCalibrationModel(imod);
	109	for(Int_t ipix=0; ipix<noisspd->GetNrBad();ipix++){
	110	noisspd->GetBadPixel(ipix,ix,iz);
	111	Int_t index=imodkSPDNpxPerModulekSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
	112	fSPDChannelStatus->SetBitNumber(index,kFALSE);
	113	}
	114	}
	115
	116	// SDD modules
	117	for(Int_t imod=0; imod<kSDDModules; imod++){
	118	AliITSCalibrationSDD* calsdd=(AliITSCalibrationSDD*)dtrec->GetCalibrationModel(imod+kSPDModules);
	119	for(Int_t ian=0; ian<kSDDAnodesPerModule; ian++){
	120	Bool_t cstatus=kTRUE;
	121	if(calsdd->IsBadChannel(ian)) cstatus=kFALSE;
	122	Int_t index=imod*kSDDAnodesPerModule+ian;
	123	fSDDChannelStatus->SetBitNumber(index,cstatus);
	124	}
	125	}
	126	}
	127	//______________________________________________________________________
4a60ccc4	128	void AliITSChannelStatus::InitDefaults(){
	129	// fill bitmaps setting all channels as good
	130	for(Int_t imod=0; imod<kSPDModules; imod++){
	131	for(Int_t ix=0; ix<kSPDNpxPerModule; ix++){
	132	for(Int_t iz=0; iz<kSPDNpzPerModule; iz++){
	133	Int_t index=imodkSPDNpxPerModulekSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
	134	fSPDChannelStatus->SetBitNumber(index,kTRUE);
	135	}
	136	}
	137	}
	138	for(Int_t imod=0; imod<kSDDModules; imod++){
	139	for(Int_t ian=0; ian<kSDDAnodesPerModule; ian++){
	140	Int_t index=imod*kSDDAnodesPerModule+ian;
	141	fSDDChannelStatus->SetBitNumber(index,kTRUE);
	142	}
	143	}
	144	}
	145	//______________________________________________________________________
	146	void AliITSChannelStatus::InitFromOCDB(TObjArray* deadArrSPD, TObjArray* noisArrSPD, TObjArray* calArrSDD){
	147	// fills bitmaps from arrays of AliITSCalibrationSXD objects
	148
	149	// SPD modules
	150	for(Int_t imod=0; imod<kSPDModules; imod++){
	151	for(Int_t ix=0; ix<kSPDNpxPerModule; ix++){
	152	for(Int_t iz=0; iz<kSPDNpzPerModule; iz++){
	153	Int_t index=imodkSPDNpxPerModulekSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
	154	fSPDChannelStatus->SetBitNumber(index,kTRUE);
	155	}
	156	}
	157	Int_t ix,iz;
	158
	159	// Mask SPD dead pixels
	160	AliITSCalibrationSPD* deadspd=(AliITSCalibrationSPD*)deadArrSPD->At(imod);
	161	for(Int_t ipix=0; ipix<deadspd->GetNrBad();ipix++){
	162	deadspd->GetBadPixel(ipix,ix,iz);
	163	Int_t index=imodkSPDNpxPerModulekSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
	164	fSPDChannelStatus->SetBitNumber(index,kFALSE);
	165	}
	166
	167	// Mask SPD noisy pixels
	168	AliITSCalibrationSPD* noisspd=(AliITSCalibrationSPD*)noisArrSPD->At(imod);
	169	for(Int_t ipix=0; ipix<noisspd->GetNrBad();ipix++){
	170	noisspd->GetBadPixel(ipix,ix,iz);
	171	Int_t index=imodkSPDNpxPerModulekSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
	172	fSPDChannelStatus->SetBitNumber(index,kFALSE);
	173	}
	174	}
	175
	176	// SDD modules
	177	for(Int_t imod=0; imod<kSDDModules; imod++){
	178	AliITSCalibrationSDD* calsdd=(AliITSCalibrationSDD*)calArrSDD->At(imod);
	179	for(Int_t ian=0; ian<kSDDAnodesPerModule; ian++){
	180	Bool_t cstatus=kTRUE;
	181	if(calsdd->IsBadChannel(ian)) cstatus=kFALSE;
	182	Int_t index=imod*kSDDAnodesPerModule+ian;
	183	fSDDChannelStatus->SetBitNumber(index,cstatus);
	184	}
	185	}
	186	}
	187	//______________________________________________________________________
	188	AliITSChannelStatus::AliITSChannelStatus(const AliITSChannelStatus& cstatus):
	189	TObject(),
	190	fSPDChannelStatus(cstatus.fSPDChannelStatus),
	191	fSDDChannelStatus(cstatus.fSDDChannelStatus)
192	{
193	// copy constructor
194	}
195	//______________________________________________________________________
196	AliITSChannelStatus& AliITSChannelStatus::operator=(const AliITSChannelStatus& cstatus)
197	{
198	// assignment operator
199	this->~AliITSChannelStatus();
200	new(this) AliITSChannelStatus(cstatus);
201	return *this;
202	}
203
204	//______________________________________________________________________
205	AliITSChannelStatus::~AliITSChannelStatus(){
206	// destructor
207	if(fSPDChannelStatus) delete fSPDChannelStatus;
208	if(fSDDChannelStatus) delete fSDDChannelStatus;
209	}
210
211	//______________________________________________________________________
212	Bool_t AliITSChannelStatus::CheckBounds(Int_t imod, Int_t iz, Int_t ix) const {
213	// check for out of bounds
214	if(imod<0 \|\| imod>=kSPDModules+kSDDModules){
215	AliError(Form("Module number out of range 0-%d",kSPDModules+kSDDModules));
216	return kFALSE;
217	}
218	if(imod<kSPDModules){
219	if(ix<0 \|\| ix>=kSPDNpxPerModule \|\| iz<0 \|\| iz>=kSPDNpzPerModule){
220	AliError("SPD: Pixel number out of range");
221	return kFALSE;
222	}
223	}else{
224	if(iz<0 \|\| iz>=kSDDAnodesPerModule){
225	AliError("SDD: anode number out of range");
226	return kFALSE;
227	}
228	}
229	return kTRUE;
230	}
231	//______________________________________________________________________
232	Bool_t AliITSChannelStatus::GetChannelStatus(Int_t imod, Int_t iz, Int_t ix) const {
233	// return status of inquired channel
234	if(CheckBounds(imod,iz,ix)==kFALSE) return kFALSE;
235	if(imod<kSPDModules){
236	Int_t index=imodkSPDNpxPerModulekSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
237	return fSPDChannelStatus->TestBitNumber(index);
238	}else{
239	imod-=kSPDModules;
240	Int_t index=imod*kSDDAnodesPerModule+iz;
241	return fSDDChannelStatus->TestBitNumber(index);
242	}
243	}
244	//______________________________________________________________________
245	void AliITSChannelStatus::SetChannelStatus(Bool_t cstatus, Int_t imod, Int_t iz, Int_t ix){
246	// set status for given channel
247	if(CheckBounds(imod,iz,ix)==kFALSE) return;
248	if(imod<kSPDModules){
249	Int_t index=imodkSPDNpxPerModulekSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
250	fSPDChannelStatus->SetBitNumber(index,cstatus);
251	}else{
252	imod-=kSPDModules;
253	Int_t index=imod*kSDDAnodesPerModule+iz;
254	fSDDChannelStatus->SetBitNumber(index,cstatus);
255	}
256	}