[u/mrichter/AliRoot.git] / ITS / AliITSCalibrationSPD.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.                  *
 **************************************************************************/
#include "TArrayI.h"
#include "AliITSCalibrationSPD.h"

///////////////////////////////////////////////////////////////////////////
//  Calibration class for set:ITS                   
//  Specific subdetector implementation for         
//  Silicon pixels                                  
//
//  Modified by D. Elia, G.E. Bruno, H. Tydesjo
///////////////////////////////////////////////////////////////////////////

ClassImp(AliITSCalibrationSPD)

//______________________________________________________________________
AliITSCalibrationSPD::AliITSCalibrationSPD():
AliITSCalibration(),
fNrBad(0),
fBadChannels(0){
  // constructor

   SetDataType("simulated");
   ClearBad();
}
//____________________________________________________________________________
void AliITSCalibrationSPD::ClearBad() {
  // clear all bad pixels (single+chips)
  fBadChannels.Reset();
  fNrBad=0;
  for (UInt_t chip=0; chip<5; chip++) {
    fBadChip[chip]=kFALSE;
  }
}
//____________________________________________________________________________
void AliITSCalibrationSPD::AddBad(UInt_t col, UInt_t row) {
  // add single bad pixel 
  fBadChannels.Set(fNrBad*2+2);
  fBadChannels.AddAt(col,fNrBad*2);
  fBadChannels.AddAt(row,fNrBad*2+1);
  fNrBad++;
}
//____________________________________________________________________________
void AliITSCalibrationSPD::SetChipBad(UInt_t chip) {
  // set full chip bad
  if (chip>=5) {AliError("Wrong chip number");
  }
  else {
    fBadChip[chip]=kTRUE;
  }
}
//____________________________________________________________________________
void AliITSCalibrationSPD::UnSetChipBad(UInt_t chip) {
  // unset full chip bad
  if (chip>=5 ) {AliError("Wrong chip number");
  }
  else {
    fBadChip[chip]=kFALSE;
  }
}
//____________________________________________________________________________
Int_t AliITSCalibrationSPD::GetBadColAt(UInt_t index) const {
  // Get column of index-th bad pixel
  if ((Int_t)index<GetNrBadSingle()) {
    return fBadChannels.At(index*2);
  }
  else {
    Int_t badChipIndex=(index-GetNrBadSingle())/(32*256);
    Int_t badChipsFound =0;
    for (UInt_t chip=0; chip<5; chip++) {
      if (fBadChip[chip]) badChipsFound++;
      if (badChipIndex==badChipsFound-1) {
	Int_t badPixelIndex=(index-GetNrBadSingle())%(32*256);
	return chip*32 + badPixelIndex/256;
      }
    }
  }
  AliError(Form("Index %d is out of bounds - returning -1",index));
  return -1;
}
//____________________________________________________________________________
Int_t AliITSCalibrationSPD::GetBadRowAt(UInt_t index) const {
  // Get row of index-th bad pixel
  if ((Int_t)index<GetNrBadSingle()) {
    return fBadChannels.At(index*2+1);
  }
  else {
    Int_t badChipIndex=(index-GetNrBadSingle())/(32*256);
    Int_t badChipsFound =0;
    for (UInt_t chip=0; chip<5; chip++) {
      if (fBadChip[chip]) badChipsFound++;
      if (badChipIndex==badChipsFound-1) {
	Int_t badPixelIndex=(index-GetNrBadSingle())%(32*256);
	return badPixelIndex%256;
      }
    }
  }
  AliError(Form("Index %d is out of bounds - returning -1",index));
  return -1;
}
//____________________________________________________________________________
void AliITSCalibrationSPD::GetBadPixel(Int_t index, Int_t &row, Int_t &col) const {
  // i: is the i-th bad pixel in single bad pixel list
  // row: is the corresponding row (-1 if i is out of range)
  // col: is the corresponding column (-1 if i is out of range)
  row = -1;
  col = -1;
  if(index>=0 && index<GetNrBadSingle()){
    col = GetBadColAt(index);
    row = GetBadRowAt(index);
    return;
  }
  else {
    if (index>=0) {
      Int_t badChipIndex=(index-GetNrBadSingle())/(32*256);
      Int_t badChipsFound =0;
      for (UInt_t chip=0; chip<5; chip++) {
	if (fBadChip[chip]) badChipsFound++;
	if (badChipIndex==badChipsFound-1) {
	  Int_t badPixelIndex=(index-GetNrBadSingle())%(32*256);
	  col = chip*32 + badPixelIndex/256;
	  row = badPixelIndex%256;
	  return;
	}
      }
    }
  }
  AliError(Form("Index %d is out of bounds - nothing done",index));
}
//___________________________________________________________________________
Int_t  AliITSCalibrationSPD::GetNrBad() const {
  // Total number of bad pixels (including bad chips) in a given module
  Int_t bad=0;
  // single pixels:
  bad+=fNrBad;
  // whole chips:
  for (UInt_t chip=0; chip<5; chip++) {
    bad+=fBadChip[chip]*32*256;
  }
  return bad;
}
//___________________________________________________________________________
Int_t  AliITSCalibrationSPD::GetNrBadInChip(Int_t chip) const {
  // Total number of bad pixels (including bad chips) in a given chip: chip range [0,4]
  if(chip<0 || chip>4) {AliError("Wrong chip number"); return -1;}
  if (fBadChip[chip]) return 32*256;
  else {
    Int_t bad=0;
    for (UInt_t i=0; i<fNrBad; i++) {
      Int_t col = GetBadColAt(i);
      if (col!=-1) {
	if (GetChipIndexFromCol(col)==chip) bad++;
      }
    }
    return bad;
  }
}
//___________________________________________________________________________
Int_t  AliITSCalibrationSPD::GetNrBadInColumn(Int_t col) const {
  // Total number of bad pixels (including bad chips) in a given column: col. range [0,159]
  if(col<0 || col>159) {AliError("Wrong column number"); return -1;}
  if (fBadChip[GetChipIndexFromCol(col)]) return 256;
  else {
    Int_t bad=0;
    for (UInt_t i=0; i<fNrBad; i++) {
      if (GetBadColAt(i)==col) bad++;
    }
    return bad;
  }
}
//______________________________________________________________________
Bool_t AliITSCalibrationSPD::IsBad() const {
  // Are all chips of this module bad?
  for (UInt_t chip=0; chip<5; chip++) {
    if (!fBadChip[chip]) return kFALSE;
  }
  return kTRUE;
}
//______________________________________________________________________
Bool_t AliITSCalibrationSPD::IsChipBad(Int_t chip) const {
  // Is the full chip bad?
  return (GetNrBadInChip(chip)==32*256);
}
//______________________________________________________________________
Bool_t AliITSCalibrationSPD::IsColumnBad(Int_t col) const {
  // Is the full column bad?
  return (GetNrBadInColumn(col)==256);
}
//____________________________________________________________________________
Bool_t AliITSCalibrationSPD::IsPixelBad(Int_t col, Int_t row) const {
  // Is this pixel bad?
  if(col<0 || col>159) {AliError("Wrong column number"); return kFALSE;}
  Int_t chip = GetChipIndexFromCol(col);
  if (fBadChip[chip]) return kTRUE;
  for (UInt_t i=0; i<fNrBad; i++) { 
    if (GetBadColAt(i)==col && GetBadRowAt(i)==row) {
      return kTRUE;
    }
  }
  return kFALSE;
}
//______________________________________________________________________
Int_t AliITSCalibrationSPD::GetChipIndexFromCol(UInt_t col) const {
  // returns chip index for specific column
  if(col>=160) {AliWarning("Wrong column number"); return -1;}
  return col/32;
}
//______________________________________________________________________
void AliITSCalibrationSPD::SetNrBad(UInt_t /*nr*/) {
  // should not be used anymore !!!
  AliError("This method should not be used anymore. Use SetNrBadSingle instead!!!");
}
//______________________________________________________________________
void AliITSCalibrationSPD::Streamer(TBuffer &ruub) {
  // Stream an object of class AliITSCalibrationSPD.
  UInt_t ruus, ruuc;
  if (ruub.IsReading()) {
    Version_t ruuv = ruub.ReadVersion(&ruus, &ruuc); if (ruuv) { }
    AliITSCalibration::Streamer(ruub);
    if (ruuv >= 8) {
      ruub >> fNrBad;
      fBadChannels.Streamer(ruub);
      ruub.ReadStaticArray((bool*)fBadChip);
    }
    else {
      Double_t dummy;
      ruub >> dummy;
      ruub >> dummy;
      ruub >> dummy;
      ruub >> dummy;
      ruub >> dummy;
      ruub >> dummy;
      ruub >> dummy;
      ruub >> fNrBad;
      if (ruuv == 7) {
	fBadChannels.Streamer(ruub);
	ruub.ReadStaticArray((bool*)fBadChip);
      }
      else {
	if (ruuv == 6) {
	  fBadChannels.Streamer(ruub);
	}
	else {
	  TArrayI fBadChannelsV1;
	  fBadChannelsV1.Streamer(ruub);
	  fBadChannels.Set(fNrBad*2);
	  for (UInt_t i=0; i<fNrBad*2; i++) {
	    fBadChannels[i] = fBadChannelsV1[i];
	  }
	}
	for (UInt_t i=0; i<5; i++) {
	  fBadChip[i]=kFALSE;
	}
      }
    }
    ruub.CheckByteCount(ruus, ruuc, AliITSCalibrationSPD::IsA());
  }
  else {
    ruuc = ruub.WriteVersion(AliITSCalibrationSPD::IsA(), kTRUE);
    AliITSCalibration::Streamer(ruub);
    ruub << fNrBad;
    fBadChannels.Streamer(ruub);
    ruub.WriteArray(fBadChip, 5);
    ruub.SetByteCount(ruuc, kTRUE);
  }
}
Commit	Line	Data
	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	#include "TArrayI.h"
	16	#include "AliITSCalibrationSPD.h"
	17
	18	///////////////////////////////////////////////////////////////////////////
	19	// Calibration class for set:ITS
	20	// Specific subdetector implementation for
	21	// Silicon pixels
	22	//
	23	// Modified by D. Elia, G.E. Bruno, H. Tydesjo
	24	///////////////////////////////////////////////////////////////////////////
	25
	26	ClassImp(AliITSCalibrationSPD)
	27
	28	//______________________________________________________________________
	29	AliITSCalibrationSPD::AliITSCalibrationSPD():
	30	AliITSCalibration(),
	31	fNrBad(0),
	32	fBadChannels(0){
	33	// constructor
	34
	35	SetDataType("simulated");
	36	ClearBad();
	37	}
	38	//____________________________________________________________________________
	39	void AliITSCalibrationSPD::ClearBad() {
	40	// clear all bad pixels (single+chips)
	41	fBadChannels.Reset();
	42	fNrBad=0;
	43	for (UInt_t chip=0; chip<5; chip++) {
	44	fBadChip[chip]=kFALSE;
	45	}
	46	}
	47	//____________________________________________________________________________
	48	void AliITSCalibrationSPD::AddBad(UInt_t col, UInt_t row) {
	49	// add single bad pixel
	50	fBadChannels.Set(fNrBad*2+2);
	51	fBadChannels.AddAt(col,fNrBad*2);
	52	fBadChannels.AddAt(row,fNrBad*2+1);
	53	fNrBad++;
	54	}
	55	//____________________________________________________________________________
	56	void AliITSCalibrationSPD::SetChipBad(UInt_t chip) {
	57	// set full chip bad
	58	if (chip>=5) {AliError("Wrong chip number");
	59	}
	60	else {
	61	fBadChip[chip]=kTRUE;
	62	}
	63	}
	64	//____________________________________________________________________________
	65	void AliITSCalibrationSPD::UnSetChipBad(UInt_t chip) {
	66	// unset full chip bad
	67	if (chip>=5 ) {AliError("Wrong chip number");
	68	}
	69	else {
	70	fBadChip[chip]=kFALSE;
	71	}
	72	}
	73	//____________________________________________________________________________
	74	Int_t AliITSCalibrationSPD::GetBadColAt(UInt_t index) const {
	75	// Get column of index-th bad pixel
	76	if ((Int_t)index<GetNrBadSingle()) {
	77	return fBadChannels.At(index*2);
	78	}
	79	else {
	80	Int_t badChipIndex=(index-GetNrBadSingle())/(32*256);
	81	Int_t badChipsFound =0;
	82	for (UInt_t chip=0; chip<5; chip++) {
	83	if (fBadChip[chip]) badChipsFound++;
	84	if (badChipIndex==badChipsFound-1) {
	85	Int_t badPixelIndex=(index-GetNrBadSingle())%(32*256);
	86	return chip*32 + badPixelIndex/256;
	87	}
	88	}
	89	}
	90	AliError(Form("Index %d is out of bounds - returning -1",index));
	91	return -1;
	92	}
	93	//____________________________________________________________________________
	94	Int_t AliITSCalibrationSPD::GetBadRowAt(UInt_t index) const {
	95	// Get row of index-th bad pixel
	96	if ((Int_t)index<GetNrBadSingle()) {
	97	return fBadChannels.At(index*2+1);
	98	}
	99	else {
	100	Int_t badChipIndex=(index-GetNrBadSingle())/(32*256);
	101	Int_t badChipsFound =0;
	102	for (UInt_t chip=0; chip<5; chip++) {
	103	if (fBadChip[chip]) badChipsFound++;
	104	if (badChipIndex==badChipsFound-1) {
	105	Int_t badPixelIndex=(index-GetNrBadSingle())%(32*256);
	106	return badPixelIndex%256;
	107	}
	108	}
	109	}
	110	AliError(Form("Index %d is out of bounds - returning -1",index));
	111	return -1;
	112	}
	113	//____________________________________________________________________________
	114	void AliITSCalibrationSPD::GetBadPixel(Int_t index, Int_t &row, Int_t &col) const {
	115	// i: is the i-th bad pixel in single bad pixel list
	116	// row: is the corresponding row (-1 if i is out of range)
	117	// col: is the corresponding column (-1 if i is out of range)
	118	row = -1;
	119	col = -1;
	120	if(index>=0 && index<GetNrBadSingle()){
	121	col = GetBadColAt(index);
	122	row = GetBadRowAt(index);
	123	return;
	124	}
	125	else {
	126	if (index>=0) {
	127	Int_t badChipIndex=(index-GetNrBadSingle())/(32*256);
	128	Int_t badChipsFound =0;
	129	for (UInt_t chip=0; chip<5; chip++) {
	130	if (fBadChip[chip]) badChipsFound++;
	131	if (badChipIndex==badChipsFound-1) {
	132	Int_t badPixelIndex=(index-GetNrBadSingle())%(32*256);
	133	col = chip*32 + badPixelIndex/256;
	134	row = badPixelIndex%256;
	135	return;
	136	}
	137	}
	138	}
	139	}
	140	AliError(Form("Index %d is out of bounds - nothing done",index));
	141	}
	142	//___________________________________________________________________________
	143	Int_t AliITSCalibrationSPD::GetNrBad() const {
	144	// Total number of bad pixels (including bad chips) in a given module
	145	Int_t bad=0;
	146	// single pixels:
	147	bad+=fNrBad;
	148	// whole chips:
	149	for (UInt_t chip=0; chip<5; chip++) {
	150	bad+=fBadChip[chip]32256;
	151	}
	152	return bad;
	153	}
	154	//___________________________________________________________________________
	155	Int_t AliITSCalibrationSPD::GetNrBadInChip(Int_t chip) const {
	156	// Total number of bad pixels (including bad chips) in a given chip: chip range [0,4]
	157	if(chip<0 \|\| chip>4) {AliError("Wrong chip number"); return -1;}
	158	if (fBadChip[chip]) return 32*256;
	159	else {
	160	Int_t bad=0;
	161	for (UInt_t i=0; i<fNrBad; i++) {
	162	Int_t col = GetBadColAt(i);
	163	if (col!=-1) {
	164	if (GetChipIndexFromCol(col)==chip) bad++;
	165	}
	166	}
	167	return bad;
	168	}
	169	}
	170	//___________________________________________________________________________
	171	Int_t AliITSCalibrationSPD::GetNrBadInColumn(Int_t col) const {
	172	// Total number of bad pixels (including bad chips) in a given column: col. range [0,159]
	173	if(col<0 \|\| col>159) {AliError("Wrong column number"); return -1;}
	174	if (fBadChip[GetChipIndexFromCol(col)]) return 256;
	175	else {
	176	Int_t bad=0;
	177	for (UInt_t i=0; i<fNrBad; i++) {
	178	if (GetBadColAt(i)==col) bad++;
	179	}
	180	return bad;
	181	}
	182	}
	183	//______________________________________________________________________
	184	Bool_t AliITSCalibrationSPD::IsBad() const {
	185	// Are all chips of this module bad?
	186	for (UInt_t chip=0; chip<5; chip++) {
	187	if (!fBadChip[chip]) return kFALSE;
	188	}
	189	return kTRUE;
	190	}
	191	//______________________________________________________________________
	192	Bool_t AliITSCalibrationSPD::IsChipBad(Int_t chip) const {
	193	// Is the full chip bad?
	194	return (GetNrBadInChip(chip)==32*256);
	195	}
	196	//______________________________________________________________________
	197	Bool_t AliITSCalibrationSPD::IsColumnBad(Int_t col) const {
	198	// Is the full column bad?
	199	return (GetNrBadInColumn(col)==256);
	200	}
	201	//____________________________________________________________________________
	202	Bool_t AliITSCalibrationSPD::IsPixelBad(Int_t col, Int_t row) const {
	203	// Is this pixel bad?
	204	if(col<0 \|\| col>159) {AliError("Wrong column number"); return kFALSE;}
	205	Int_t chip = GetChipIndexFromCol(col);
	206	if (fBadChip[chip]) return kTRUE;
	207	for (UInt_t i=0; i<fNrBad; i++) {
	208	if (GetBadColAt(i)==col && GetBadRowAt(i)==row) {
	209	return kTRUE;
	210	}
	211	}
	212	return kFALSE;
	213	}
	214	//______________________________________________________________________
	215	Int_t AliITSCalibrationSPD::GetChipIndexFromCol(UInt_t col) const {
	216	// returns chip index for specific column
	217	if(col>=160) {AliWarning("Wrong column number"); return -1;}
	218	return col/32;
	219	}
	220	//______________________________________________________________________
	221	void AliITSCalibrationSPD::SetNrBad(UInt_t /nr/) {
	222	// should not be used anymore !!!
	223	AliError("This method should not be used anymore. Use SetNrBadSingle instead!!!");
	224	}
	225	//______________________________________________________________________
	226	void AliITSCalibrationSPD::Streamer(TBuffer &ruub) {
	227	// Stream an object of class AliITSCalibrationSPD.
	228	UInt_t ruus, ruuc;
	229	if (ruub.IsReading()) {
	230	Version_t ruuv = ruub.ReadVersion(&ruus, &ruuc); if (ruuv) { }
	231	AliITSCalibration::Streamer(ruub);
	232	if (ruuv >= 8) {
	233	ruub >> fNrBad;
	234	fBadChannels.Streamer(ruub);
	235	ruub.ReadStaticArray((bool*)fBadChip);
	236	}
	237	else {
	238	Double_t dummy;
	239	ruub >> dummy;
	240	ruub >> dummy;
	241	ruub >> dummy;
	242	ruub >> dummy;
	243	ruub >> dummy;
	244	ruub >> dummy;
	245	ruub >> dummy;
	246	ruub >> fNrBad;
	247	if (ruuv == 7) {
	248	fBadChannels.Streamer(ruub);
	249	ruub.ReadStaticArray((bool*)fBadChip);
	250	}
	251	else {
	252	if (ruuv == 6) {
	253	fBadChannels.Streamer(ruub);
	254	}
	255	else {
	256	TArrayI fBadChannelsV1;
	257	fBadChannelsV1.Streamer(ruub);
	258	fBadChannels.Set(fNrBad*2);
	259	for (UInt_t i=0; i<fNrBad*2; i++) {
	260	fBadChannels[i] = fBadChannelsV1[i];
	261	}
	262	}
	263	for (UInt_t i=0; i<5; i++) {
	264	fBadChip[i]=kFALSE;
	265	}
	266	}
	267	}
	268	ruub.CheckByteCount(ruus, ruuc, AliITSCalibrationSPD::IsA());
	269	}
	270	else {
	271	ruuc = ruub.WriteVersion(AliITSCalibrationSPD::IsA(), kTRUE);
	272	AliITSCalibration::Streamer(ruub);
	273	ruub << fNrBad;
	274	fBadChannels.Streamer(ruub);
	275	ruub.WriteArray(fBadChip, 5);
	276	ruub.SetByteCount(ruuc, kTRUE);
	277	}
	278	}