[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;
}

//______________________________________________________________________
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	//______________________________________________________________________
	131	void AliITSMapA1::ClearMap(){
	132	//clear array
	133
	134	memset(fHitMap,0,sizeof(int)*fMaxIndex);
	135	}
	136	//______________________________________________________________________
	137	void AliITSMapA1::SetArray(TObjArray *obj){
	138	// set array of objects
	139
	140	fObjects = obj;
	141	if (fObjects) fNobjects = fObjects->GetEntriesFast();
	142	}
	143	//______________________________________________________________________
	144	Int_t AliITSMapA1::CheckedIndex(Int_t iz, Int_t ix) const {
	145	//check boundaries and return an index in array
	146	Int_t index=fNpx*iz+ix;
	147
	148	//if (index > fMaxIndex) {
	149	if (index > fMaxIndex \|\| index < 0) {
	150	printf("\n \n \n Try to read/write outside array !!!!"
	151	" \n \n %d %d %d %d %d %d \n",iz,ix,fMaxIndex,index,fNpz,fNpx);
	152	// force crash
	153	return -1;
	154	} else {
	155	return index;
	156	} // end if index>max or < 0
	157	}
	158	//______________________________________________________________________
	159	void AliITSMapA1::FillMap(){
	160	// fill array with digits indices
	161
	162	Int_t ndigits = fObjects->GetEntriesFast();
	163	if (!ndigits) return;
	164
	165	AliITSdigit *dig;
	166	for (Int_t ndig=0; ndig<ndigits; ndig++) {
	167	dig = (AliITSdigit*)fObjects->UncheckedAt(ndig);
	168	if(dig->GetSignal() > fMapThreshold) {
	169	SetHit(dig->GetCoord1(),dig->GetCoord2(),ndig);
	170	} // end if fSignal > fMapthreshold
	171	} // end for ndig
	172	}
	173	//______________________________________________________________________
	174	void AliITSMapA1::FillMap2(){
	175	// fill array with digits indices
	176
	177	Int_t ndigits = fObjects->GetEntriesFast();
	178	if (!ndigits) return;
	179
	180	AliITSdigit *dig;
	181	for (Int_t ndig=0; ndig<ndigits; ndig++) {
	182	dig = (AliITSdigit*)fObjects->UncheckedAt(ndig);
	183	if(dig->GetSignal() > fMapThresholdArr[dig->GetCoord1()]) {
	184	SetHit(dig->GetCoord1(),dig->GetCoord2(),ndig);
	185	} // end if fSignal > fMapthreshold
	186	} // end for ndig
	187	}
	188
	189	//______________________________________________________________________
	190	void AliITSMapA1::SetHit(Int_t iz, Int_t ix, Int_t idigit){
	191	// set the digit index at a certain position in array
	192
	193	fHitMap[CheckedIndex(iz, ix)]=idigit+1;
	194	}
	195	//______________________________________________________________________
	196	void AliITSMapA1::DeleteHit(Int_t iz, Int_t ix){
	197	// delete an entry in array
	198
	199	fHitMap[CheckedIndex(iz, ix)]=0;
	200	}
	201	//______________________________________________________________________
	202	void AliITSMapA1::FlagHit(Int_t iz, Int_t ix){
	203	// flag an entry in array
	204
	205	fHitMap[CheckedIndex(iz, ix)] = -TMath::Abs(fHitMap[CheckedIndex(iz, ix)]);
	206	}
	207	//______________________________________________________________________
	208	Int_t AliITSMapA1::GetHitIndex(Int_t iz, Int_t ix) const {
	209	// return the digit index from a specific entry in array
	210
	211	return TMath::Abs(fHitMap[CheckedIndex(iz, ix)])-1;
	212	}
	213	//______________________________________________________________________
	214	TObject* AliITSMapA1::GetHit(Int_t iz, Int_t ix) const {
	215	// return the pointer to the digit
	216
	217	Int_t index=GetHitIndex(iz,ix);
	218	// Force crash if index does not exist !
	219	return (index <0) ? 0 : fObjects->UncheckedAt(GetHitIndex(iz,ix));
	220	}
	221	//______________________________________________________________________
	222	Double_t AliITSMapA1::GetSignal(Int_t iz, Int_t ix) const{
	223	// get a pad signal
	224	Double_t signal;
	225
	226	AliITSdigit dig = (AliITSdigit)GetHit(iz,ix);
	227	if(dig) signal=(Double_t)dig->GetSignal();
	228	else signal=0.;
	229	return signal;
	230	}
	231	//______________________________________________________________________
	232	FlagType AliITSMapA1::TestHit(Int_t iz, Int_t ix) {
	233	// check whether the digit has already been flagged
	234
	235	if (CheckedIndex(iz, ix) < 0) return kEmpty;
	236	Int_t inf=fHitMap[CheckedIndex(iz, ix)];
	237	if (inf < 0) {
	238	return kUsed;
	239	} else if (inf == 0) {
	240	return kEmpty;
	241	} else {
	242	return kUnused;
	243	} // end if inf
	244	}
	245