[u/mrichter/AliRoot.git] / ITS / AliITSMapA1.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 <TObjArray.h>
#include "AliITSMapA1.h"
#include "AliITSsegmentation.h"
#include "AliITSdigit.h"

////////////////////////////////////////////////////////////////////////
//  Map Class for ITS. Implementation A1. In this implementation, the //
// 2 dimensional (iz,ix) map is filled with integers values. For each //
// cell a corresponding TObject, a hit, can also be stored.           //
//  The detector geometry is accessed via the that detectors          //
// segmentation class and stored here for conveniance.                //
////////////////////////////////////////////////////////////////////////

ClassImp(AliITSMapA1)
//______________________________________________________________________
AliITSMapA1::AliITSMapA1():
fSegmentation(0),
fNpx(0),
fNpz(0),
fObjects(0),
fNobjects(0),
fMaxIndex(0),
fMapThresholdArr(0),
fHitMap(0),
fMapThreshold(0){
    // default constructor

}
//______________________________________________________________________
AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg):
fSegmentation(seg),
fNpx(0),
fNpz(0),
fObjects(0),
fNobjects(0),
fMaxIndex(0),
fMapThresholdArr(0),
fHitMap(0),
fMapThreshold(0){
    //constructor

    fNpz          = fSegmentation->Npz();
    fNpx          = fSegmentation->Npx();
    fMaxIndex     = fNpz*fNpx+fNpx;             // 2 halves of detector
    fHitMap       = new Int_t[fMaxIndex];
    ClearMap();
}
//______________________________________________________________________
AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg, TObjArray *obj):
fSegmentation(seg),
fNpx(0),
fNpz(0),
fObjects(obj),
fNobjects(0),
fMaxIndex(0),
fMapThresholdArr(0),
fHitMap(0),
fMapThreshold(0){
    //constructor

  fNpz          = fSegmentation->Npz();
  fNpx          = fSegmentation->Npx();
  fMaxIndex     = fNpz*fNpx+fNpx;             // 2 halves of detector
  fHitMap       = new Int_t[fMaxIndex];
  if(fObjects) fNobjects = fObjects->GetEntriesFast();
  ClearMap();
}
//______________________________________________________________________
AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg, TObjArray *obj, Int_t thr):
fSegmentation(seg),
fNpx(0),
fNpz(0),
fObjects(obj),
fNobjects(0),
fMaxIndex(0),
fMapThresholdArr(0),
fHitMap(0),
fMapThreshold(thr){
    //constructor

  fNpz          = fSegmentation->Npz();
  fNpx          = fSegmentation->Npx();
  fMaxIndex     = fNpz*fNpx+fNpx;             // 2 halves of detector
  fHitMap       = new Int_t[fMaxIndex];
  if(fObjects) fNobjects = fObjects->GetEntriesFast();
  ClearMap();
}
//______________________________________________________________________
AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg, TObjArray *obj, TArrayI thr):
fSegmentation(seg),
fNpx(0),
fNpz(0),
fObjects(obj),
fNobjects(0),
fMaxIndex(0),
fMapThresholdArr(thr),
fHitMap(0),
fMapThreshold(0){
    //constructor

  fNpz          = fSegmentation->Npz();
  fNpx          = fSegmentation->Npx();
  fMaxIndex     = fNpz*fNpx+fNpx;             // 2 halves of detector
  fHitMap       = new Int_t[fMaxIndex];
  if(fObjects) fNobjects = fObjects->GetEntriesFast();
  ClearMap();
}

//______________________________________________________________________
AliITSMapA1::~AliITSMapA1(){
    //destructor

    if(fHitMap) delete[] fHitMap;
}
//_________________________________________________________________________
AliITSMapA1& AliITSMapA1::operator=(const AliITSMapA1 &source) {
    //    Assignment operator

  this->~AliITSMapA1();
  new(this) AliITSMapA1(source);
  return *this;
}
//______________________________________________________________________
AliITSMapA1::AliITSMapA1(const AliITSMapA1 &source) : AliITSMap(source),
fSegmentation(source.fSegmentation),
fNpx(source.fNpx),
fNpz(source.fNpz),
fObjects(source.fObjects),
fNobjects(source.fNobjects),
fMaxIndex(source.fMaxIndex),
fMapThresholdArr(source.fMapThresholdArr),
fHitMap(source.fHitMap),
fMapThreshold(source.fMapThreshold){
  //     Copy Constructor
  
}
//______________________________________________________________________
void AliITSMapA1::ClearMap(){
    //clear array

    memset(fHitMap,0,sizeof(int)*fMaxIndex);
}
//______________________________________________________________________
void AliITSMapA1::SetArray(TObjArray *obj){
    // set array of objects

    fObjects =  obj;
    if (fObjects) fNobjects = fObjects->GetEntriesFast();
}
//______________________________________________________________________
Int_t AliITSMapA1::CheckedIndex(Int_t iz, Int_t ix) const {
    //check boundaries and return an index in array
    Int_t index=fNpx*iz+ix;

    //if (index > fMaxIndex) {
    if (index > fMaxIndex || index < 0) {
	printf("\n \n \n Try to read/write outside array !!!!"
	       " \n \n %d %d %d %d %d %d \n",iz,ix,fMaxIndex,index,fNpz,fNpx);
	// force crash
	return  -1;
    } else {
	return index;
    } // end if index>max or < 0
}
//______________________________________________________________________
void  AliITSMapA1::FillMap(){
    // fill array with digits indices

    Int_t ndigits = fObjects->GetEntriesFast();
    if (!ndigits) return;

    AliITSdigit *dig;
    for (Int_t ndig=0; ndig<ndigits; ndig++) {
	dig = (AliITSdigit*)fObjects->UncheckedAt(ndig);
	if(dig->GetSignal() > fMapThreshold) {
	    SetHit(dig->GetCoord1(),dig->GetCoord2(),ndig);
	} // end if fSignal > fMapthreshold
    } // end for ndig
}
//______________________________________________________________________
void  AliITSMapA1::FillMap2(){
    // fill array with digits indices

    Int_t ndigits = fObjects->GetEntriesFast();
    if (!ndigits) return;

    AliITSdigit *dig;
    for (Int_t ndig=0; ndig<ndigits; ndig++) {
	dig = (AliITSdigit*)fObjects->UncheckedAt(ndig);
	if(dig->GetSignal() > fMapThresholdArr[dig->GetCoord1()]) {
	    SetHit(dig->GetCoord1(),dig->GetCoord2(),ndig);
	} // end if fSignal > fMapthreshold
    } // end for ndig
}

//______________________________________________________________________
void  AliITSMapA1::SetHit(Int_t iz, Int_t ix, Int_t idigit){
    // set the digit index at a certain position in array

    fHitMap[CheckedIndex(iz, ix)]=idigit+1;
}
//______________________________________________________________________
void AliITSMapA1::DeleteHit(Int_t iz, Int_t ix){
    // delete an entry in array

    fHitMap[CheckedIndex(iz, ix)]=0;
}
//______________________________________________________________________
void AliITSMapA1::FlagHit(Int_t iz, Int_t ix){
    // flag an entry in array

    fHitMap[CheckedIndex(iz, ix)] = -TMath::Abs(fHitMap[CheckedIndex(iz, ix)]);
}
//______________________________________________________________________
Int_t AliITSMapA1::GetHitIndex(Int_t iz, Int_t ix) const {
    // return the digit index from a specific entry in array

    return TMath::Abs(fHitMap[CheckedIndex(iz, ix)])-1;
}
//______________________________________________________________________
TObject* AliITSMapA1::GetHit(Int_t iz, Int_t ix) const {
    // return the pointer to the digit 

    Int_t index=GetHitIndex(iz,ix);
    // Force crash if index does not exist ! 
    return (index <0) ? 0 : fObjects->UncheckedAt(GetHitIndex(iz,ix));
}
//______________________________________________________________________
Double_t AliITSMapA1::GetSignal(Int_t iz, Int_t ix) const{
    // get a pad signal
    Double_t signal;

    AliITSdigit *dig = (AliITSdigit*)GetHit(iz,ix);
    if(dig) signal=(Double_t)dig->GetSignal();
    else signal=0.;
    return signal;
}
//______________________________________________________________________
FlagType AliITSMapA1::TestHit(Int_t iz, Int_t ix)  {
    // check whether the digit has already been flagged

    if (CheckedIndex(iz, ix) < 0) return kEmpty;
    Int_t inf=fHitMap[CheckedIndex(iz, ix)]; 
    if (inf < 0) {
	return kUsed;
    } else if (inf == 0) {
	return kEmpty;
    } else {
	return kUnused;
    } // end if inf
}
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 <TObjArray.h>
	16	#include "AliITSMapA1.h"
	17	#include "AliITSsegmentation.h"
	18	#include "AliITSdigit.h"
	19
	20	////////////////////////////////////////////////////////////////////////
	21	// Map Class for ITS. Implementation A1. In this implementation, the //
	22	// 2 dimensional (iz,ix) map is filled with integers values. For each //
	23	// cell a corresponding TObject, a hit, can also be stored. //
	24	// The detector geometry is accessed via the that detectors //
	25	// segmentation class and stored here for conveniance. //
	26	////////////////////////////////////////////////////////////////////////
	27
	28	ClassImp(AliITSMapA1)
	29	//______________________________________________________________________
	30	AliITSMapA1::AliITSMapA1():
	31	fSegmentation(0),
	32	fNpx(0),
	33	fNpz(0),
	34	fObjects(0),
	35	fNobjects(0),
	36	fMaxIndex(0),
	37	fMapThresholdArr(0),
	38	fHitMap(0),
	39	fMapThreshold(0){
	40	// default constructor
	41
	42	}
	43	//______________________________________________________________________
	44	AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg):
	45	fSegmentation(seg),
	46	fNpx(0),
	47	fNpz(0),
	48	fObjects(0),
	49	fNobjects(0),
	50	fMaxIndex(0),
	51	fMapThresholdArr(0),
	52	fHitMap(0),
	53	fMapThreshold(0){
	54	//constructor
	55
	56	fNpz = fSegmentation->Npz();
	57	fNpx = fSegmentation->Npx();
	58	fMaxIndex = fNpz*fNpx+fNpx; // 2 halves of detector
	59	fHitMap = new Int_t[fMaxIndex];
	60	ClearMap();
	61	}
	62	//______________________________________________________________________
	63	AliITSMapA1::AliITSMapA1(AliITSsegmentation seg, TObjArray obj):
	64	fSegmentation(seg),
	65	fNpx(0),
	66	fNpz(0),
	67	fObjects(obj),
	68	fNobjects(0),
	69	fMaxIndex(0),
	70	fMapThresholdArr(0),
	71	fHitMap(0),
	72	fMapThreshold(0){
	73	//constructor
	74
	75	fNpz = fSegmentation->Npz();
	76	fNpx = fSegmentation->Npx();
	77	fMaxIndex = fNpz*fNpx+fNpx; // 2 halves of detector
	78	fHitMap = new Int_t[fMaxIndex];
	79	if(fObjects) fNobjects = fObjects->GetEntriesFast();
	80	ClearMap();
	81	}
	82	//______________________________________________________________________
	83	AliITSMapA1::AliITSMapA1(AliITSsegmentation seg, TObjArray obj, Int_t thr):
	84	fSegmentation(seg),
	85	fNpx(0),
	86	fNpz(0),
	87	fObjects(obj),
	88	fNobjects(0),
	89	fMaxIndex(0),
	90	fMapThresholdArr(0),
	91	fHitMap(0),
	92	fMapThreshold(thr){
	93	//constructor
	94
	95	fNpz = fSegmentation->Npz();
	96	fNpx = fSegmentation->Npx();
	97	fMaxIndex = fNpz*fNpx+fNpx; // 2 halves of detector
	98	fHitMap = new Int_t[fMaxIndex];
	99	if(fObjects) fNobjects = fObjects->GetEntriesFast();
	100	ClearMap();
	101	}
	102	//______________________________________________________________________
	103	AliITSMapA1::AliITSMapA1(AliITSsegmentation seg, TObjArray obj, TArrayI thr):
	104	fSegmentation(seg),
	105	fNpx(0),
	106	fNpz(0),
	107	fObjects(obj),
	108	fNobjects(0),
	109	fMaxIndex(0),
	110	fMapThresholdArr(thr),
	111	fHitMap(0),
	112	fMapThreshold(0){
	113	//constructor
	114
	115	fNpz = fSegmentation->Npz();
	116	fNpx = fSegmentation->Npx();
	117	fMaxIndex = fNpz*fNpx+fNpx; // 2 halves of detector
	118	fHitMap = new Int_t[fMaxIndex];
	119	if(fObjects) fNobjects = fObjects->GetEntriesFast();
	120	ClearMap();
	121	}
	122
	123	//______________________________________________________________________
	124	AliITSMapA1::~AliITSMapA1(){
	125	//destructor
	126
	127	if(fHitMap) delete[] fHitMap;
	128	}
	129	//_________________________________________________________________________
	130	AliITSMapA1& AliITSMapA1::operator=(const AliITSMapA1 &source) {
	131	// Assignment operator
	132
	133	this->~AliITSMapA1();
	134	new(this) AliITSMapA1(source);
	135	return *this;
	136	}
	137	//______________________________________________________________________
	138	AliITSMapA1::AliITSMapA1(const AliITSMapA1 &source) : AliITSMap(source),
	139	fSegmentation(source.fSegmentation),
	140	fNpx(source.fNpx),
	141	fNpz(source.fNpz),
	142	fObjects(source.fObjects),
	143	fNobjects(source.fNobjects),
	144	fMaxIndex(source.fMaxIndex),
	145	fMapThresholdArr(source.fMapThresholdArr),
	146	fHitMap(source.fHitMap),
	147	fMapThreshold(source.fMapThreshold){
	148	// Copy Constructor
	149
	150	}
	151	//______________________________________________________________________
	152	void AliITSMapA1::ClearMap(){
	153	//clear array
	154
	155	memset(fHitMap,0,sizeof(int)*fMaxIndex);
	156	}
	157	//______________________________________________________________________
	158	void AliITSMapA1::SetArray(TObjArray *obj){
	159	// set array of objects
	160
	161	fObjects = obj;
	162	if (fObjects) fNobjects = fObjects->GetEntriesFast();
	163	}
	164	//______________________________________________________________________
	165	Int_t AliITSMapA1::CheckedIndex(Int_t iz, Int_t ix) const {
	166	//check boundaries and return an index in array
	167	Int_t index=fNpx*iz+ix;
	168
	169	//if (index > fMaxIndex) {
	170	if (index > fMaxIndex \|\| index < 0) {
	171	printf("\n \n \n Try to read/write outside array !!!!"
	172	" \n \n %d %d %d %d %d %d \n",iz,ix,fMaxIndex,index,fNpz,fNpx);
	173	// force crash
	174	return -1;
	175	} else {
	176	return index;
	177	} // end if index>max or < 0
	178	}
	179	//______________________________________________________________________
	180	void AliITSMapA1::FillMap(){
	181	// fill array with digits indices
	182
	183	Int_t ndigits = fObjects->GetEntriesFast();
	184	if (!ndigits) return;
	185
	186	AliITSdigit *dig;
	187	for (Int_t ndig=0; ndig<ndigits; ndig++) {
	188	dig = (AliITSdigit*)fObjects->UncheckedAt(ndig);
	189	if(dig->GetSignal() > fMapThreshold) {
	190	SetHit(dig->GetCoord1(),dig->GetCoord2(),ndig);
	191	} // end if fSignal > fMapthreshold
	192	} // end for ndig
	193	}
	194	//______________________________________________________________________
	195	void AliITSMapA1::FillMap2(){
	196	// fill array with digits indices
	197
	198	Int_t ndigits = fObjects->GetEntriesFast();
	199	if (!ndigits) return;
	200
	201	AliITSdigit *dig;
	202	for (Int_t ndig=0; ndig<ndigits; ndig++) {
	203	dig = (AliITSdigit*)fObjects->UncheckedAt(ndig);
	204	if(dig->GetSignal() > fMapThresholdArr[dig->GetCoord1()]) {
	205	SetHit(dig->GetCoord1(),dig->GetCoord2(),ndig);
	206	} // end if fSignal > fMapthreshold
	207	} // end for ndig
	208	}
	209
	210	//______________________________________________________________________
	211	void AliITSMapA1::SetHit(Int_t iz, Int_t ix, Int_t idigit){
	212	// set the digit index at a certain position in array
	213
	214	fHitMap[CheckedIndex(iz, ix)]=idigit+1;
	215	}
	216	//______________________________________________________________________
	217	void AliITSMapA1::DeleteHit(Int_t iz, Int_t ix){
	218	// delete an entry in array
	219
	220	fHitMap[CheckedIndex(iz, ix)]=0;
	221	}
	222	//______________________________________________________________________
	223	void AliITSMapA1::FlagHit(Int_t iz, Int_t ix){
	224	// flag an entry in array
	225
	226	fHitMap[CheckedIndex(iz, ix)] = -TMath::Abs(fHitMap[CheckedIndex(iz, ix)]);
	227	}
	228	//______________________________________________________________________
	229	Int_t AliITSMapA1::GetHitIndex(Int_t iz, Int_t ix) const {
	230	// return the digit index from a specific entry in array
	231
	232	return TMath::Abs(fHitMap[CheckedIndex(iz, ix)])-1;
	233	}
	234	//______________________________________________________________________
	235	TObject* AliITSMapA1::GetHit(Int_t iz, Int_t ix) const {
	236	// return the pointer to the digit
	237
	238	Int_t index=GetHitIndex(iz,ix);
	239	// Force crash if index does not exist !
	240	return (index <0) ? 0 : fObjects->UncheckedAt(GetHitIndex(iz,ix));
	241	}
	242	//______________________________________________________________________
	243	Double_t AliITSMapA1::GetSignal(Int_t iz, Int_t ix) const{
	244	// get a pad signal
	245	Double_t signal;
	246
	247	AliITSdigit dig = (AliITSdigit)GetHit(iz,ix);
	248	if(dig) signal=(Double_t)dig->GetSignal();
	249	else signal=0.;
	250	return signal;
	251	}
	252	//______________________________________________________________________
	253	FlagType AliITSMapA1::TestHit(Int_t iz, Int_t ix) {
	254	// check whether the digit has already been flagged
	255
	256	if (CheckedIndex(iz, ix) < 0) return kEmpty;
	257	Int_t inf=fHitMap[CheckedIndex(iz, ix)];
	258	if (inf < 0) {
	259	return kUsed;
	260	} else if (inf == 0) {
	261	return kEmpty;
	262	} else {
	263	return kUnused;
	264	} // end if inf
	265	}
	266