[u/mrichter/AliRoot.git] / ITS / AliITSMapA2.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 <TH1.h>
#include <TObjArray.h>

#include "AliITSMapA2.h"
#include "AliITSsegmentation.h"
#include "AliITSdigit.h"

////////////////////////////////////////////////////////////////////////
//  Map Class for ITS. Implementation A2. In this implementation, the //
// 2 dimensional (iz,ix) map is filled with Double precision floating //
// point values. Since this class is derived for AliITSMapA1 it also  //
// has all of the functionality of that class as well. 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(AliITSMapA2)

//______________________________________________________________________
AliITSMapA2::AliITSMapA2():
fHitMapD(0),
fMapThresholdD(0),
fScaleSizeX(0),
fScaleSizeZ(0){
    // default constructor

    fSegmentation  = 0;
    fNpz           = 0;
    fNpx           = 0;
    fMaxIndex      = 0;
    fObjects       = 0;
    fNobjects      = 0;
}
//______________________________________________________________________
AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg):
fHitMapD(0),
fMapThresholdD(0),
fScaleSizeX(1),
fScaleSizeZ(1){
    //constructor

    fSegmentation  = seg;
    fNpz           = fSegmentation->Npz();
    fNpx           = fSegmentation->Npx();
    fMaxIndex      = fNpz*fNpx+fNpx;       // 2 halves of detector
    fHitMapD       = new Double_t[fMaxIndex+1];
    fObjects       = 0;
    fNobjects      = 0;
    ClearMap();
}
//______________________________________________________________________
AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg,
			 Int_t scalesizeX, Int_t scalesizeZ):
fHitMapD(0),
fMapThresholdD(0),
fScaleSizeX(scalesizeX),
fScaleSizeZ(scalesizeZ){
    //constructor

    fSegmentation  = seg;
    fNpz           = fScaleSizeZ*fSegmentation->Npz();
    fNpx           = fScaleSizeX*fSegmentation->Npx();
    fMaxIndex      = fNpz*fNpx+fNpx;             // 2 halves of detector
    fHitMapD       = new Double_t[fMaxIndex+1];
    fObjects       = 0;
    fNobjects      = 0;
    ClearMap();
}
//______________________________________________________________________
AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg, TObjArray *obj, 
			 Double_t thresh):
fHitMapD(0),
fMapThresholdD(thresh),
fScaleSizeX(1),
fScaleSizeZ(1){
    //constructor

    fNobjects      = 0;
    fSegmentation  = seg;
    fNpz           = fSegmentation->Npz();
    fNpx           = fSegmentation->Npx();
    fMaxIndex      = fNpz*fNpx+fNpx;             // 2 halves of detector  
    fHitMapD       = new Double_t[fMaxIndex+1];
    fObjects       =  obj;
    if (fObjects) fNobjects = fObjects->GetEntriesFast();
    ClearMap();
}
//______________________________________________________________________
AliITSMapA2::~AliITSMapA2(){
    //destructor

    if (fHitMapD) delete[] fHitMapD;
}


//______________________________________________________________________
void AliITSMapA2::ClearMap(){
    //clear array

    memset(fHitMapD,0,sizeof(Double_t)*fMaxIndex);
}
//______________________________________________________________________
void  AliITSMapA2::FillMap(){
    // fills signal map from digits - apply a threshold for signal
  
    if (!fObjects) return;

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

    AliITSdigit *dig;
    for (Int_t ndig=0; ndig<ndigits; ndig++) {
	dig = (AliITSdigit*)fObjects->UncheckedAt(ndig);
	Double_t signal = (Double_t)(dig->GetSignal());
	if (signal > fMapThresholdD) SetHit(dig->GetCoord1(),dig->GetCoord2(),signal);
    } // end for ndig
}
//______________________________________________________________________
void AliITSMapA2::FlagHit(Int_t iz, Int_t ix){
  //flag an entry

    fHitMapD[CheckedIndex(iz, ix)]=
                -1000.*TMath::Abs((Int_t)(fHitMapD[CheckedIndex(iz, ix)])+1.);
}
//______________________________________________________________________
TObject* AliITSMapA2::GetHit(Int_t i, Int_t /* dummy */) const {
  //return a pointer to the 1D histogram

    if (fObjects) {
	return fObjects->UncheckedAt(i);
    } else return NULL;
}
//______________________________________________________________________
Double_t AliITSMapA2::GetSignal(Int_t index) const {
    //get signal in a cell 

    if (index<fMaxIndex) return (index <0) ? 0. : fHitMapD[index];
    else return 0.;
}
//______________________________________________________________________
FlagType AliITSMapA2::TestHit(Int_t iz, Int_t ix){
    // check if the entry has already been flagged

    if (CheckedIndex(iz, ix) < 0) return kEmpty;
    Int_t inf=(Int_t)fHitMapD[CheckedIndex(iz, ix)];
    
    if (inf <= -1000) {
	return kUsed;
    } else if (inf == 0) {
	return kEmpty;
    } else {
	return kUnused;
    } // end if inf...
}
//______________________________________________________________________
void  AliITSMapA2::FillMapFromHist(){
    // fills map from 1D histograms

    if (!fObjects) return;

    // an example
    for( Int_t i=0; i<fNobjects; i++) {
	TH1F *hist =(TH1F *)fObjects->UncheckedAt(i);
	Int_t nsamples = hist->GetNbinsX();
	for( Int_t j=0; j<nsamples; j++) {
	    Double_t signal = (Double_t)(hist->GetBinContent(j+1));
	    if (signal > fMapThresholdD) SetHit(i,j,signal);
	} // end for j
    } // end for i
}
//______________________________________________________________________
void  AliITSMapA2::FillHist(){
    // fill 1D histograms from map

    if (!fObjects || fScaleSizeX != 1) return;

    // an example
    for( Int_t i=0; i<fNobjects; i++) {
	TH1F *hist =(TH1F *)fObjects->UncheckedAt(i);
	for( Int_t j=0; j<fNpx; j++) {
	    Double_t signal=GetSignal(i,j);
	    if (signal > fMapThresholdD) hist->Fill((Float_t)j,signal);
	} // end for j
    } // end for i
}
//______________________________________________________________________
void  AliITSMapA2::ResetHist(){
    // Reset histograms

    if (!fObjects) return;

    for( Int_t i=0; i<fNobjects; i++) {
	if ((*fObjects)[i])    ((TH1F*)(*fObjects)[i])->Reset();
    } // end for i
}
//______________________________________________________________________
void AliITSMapA2::AddSignal(Int_t iz,Int_t ix,Double_t sig){
    // Addes sig to cell iz. equivalent to the very common
    // sig = fMapA2->GetSignal(iz,ix) + sig; fMapA2->SetHit(iz,ix,sig);


    Int_t index=GetHitIndex(iz,ix);
    if(index<0) return;
    fHitMapD[CheckedIndex(iz, ix)] += sig;    
}
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
	16	#include <TH1.h>
	17	#include <TObjArray.h>
	18
	19	#include "AliITSMapA2.h"
	20	#include "AliITSsegmentation.h"
	21	#include "AliITSdigit.h"
	22
	23	////////////////////////////////////////////////////////////////////////
	24	// Map Class for ITS. Implementation A2. In this implementation, the //
	25	// 2 dimensional (iz,ix) map is filled with Double precision floating //
	26	// point values. Since this class is derived for AliITSMapA1 it also //
	27	// has all of the functionality of that class as well. For each //
	28	// cell a corresponding TObject, a hit, can also be stored. //
	29	// The detector geometry is accessed via the that detectors //
	30	// segmentation class and stored here for conveniance. //
	31	////////////////////////////////////////////////////////////////////////
	32
	33	ClassImp(AliITSMapA2)
	34
	35	//______________________________________________________________________
	36	AliITSMapA2::AliITSMapA2():
	37	fHitMapD(0),
	38	fMapThresholdD(0),
	39	fScaleSizeX(0),
	40	fScaleSizeZ(0){
	41	// default constructor
	42
	43	fSegmentation = 0;
	44	fNpz = 0;
	45	fNpx = 0;
	46	fMaxIndex = 0;
	47	fObjects = 0;
	48	fNobjects = 0;
	49	}
	50	//______________________________________________________________________
	51	AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg):
	52	fHitMapD(0),
	53	fMapThresholdD(0),
	54	fScaleSizeX(1),
	55	fScaleSizeZ(1){
	56	//constructor
	57
	58	fSegmentation = seg;
	59	fNpz = fSegmentation->Npz();
	60	fNpx = fSegmentation->Npx();
	61	fMaxIndex = fNpz*fNpx+fNpx; // 2 halves of detector
	62	fHitMapD = new Double_t[fMaxIndex+1];
	63	fObjects = 0;
	64	fNobjects = 0;
	65	ClearMap();
	66	}
	67	//______________________________________________________________________
	68	AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg,
	69	Int_t scalesizeX, Int_t scalesizeZ):
	70	fHitMapD(0),
	71	fMapThresholdD(0),
	72	fScaleSizeX(scalesizeX),
	73	fScaleSizeZ(scalesizeZ){
	74	//constructor
	75
	76	fSegmentation = seg;
	77	fNpz = fScaleSizeZ*fSegmentation->Npz();
	78	fNpx = fScaleSizeX*fSegmentation->Npx();
	79	fMaxIndex = fNpz*fNpx+fNpx; // 2 halves of detector
	80	fHitMapD = new Double_t[fMaxIndex+1];
	81	fObjects = 0;
	82	fNobjects = 0;
	83	ClearMap();
	84	}
	85	//______________________________________________________________________
	86	AliITSMapA2::AliITSMapA2(AliITSsegmentation seg, TObjArray obj,
	87	Double_t thresh):
	88	fHitMapD(0),
	89	fMapThresholdD(thresh),
	90	fScaleSizeX(1),
	91	fScaleSizeZ(1){
	92	//constructor
	93
	94	fNobjects = 0;
	95	fSegmentation = seg;
	96	fNpz = fSegmentation->Npz();
	97	fNpx = fSegmentation->Npx();
	98	fMaxIndex = fNpz*fNpx+fNpx; // 2 halves of detector
	99	fHitMapD = new Double_t[fMaxIndex+1];
	100	fObjects = obj;
	101	if (fObjects) fNobjects = fObjects->GetEntriesFast();
	102	ClearMap();
	103	}
	104	//______________________________________________________________________
	105	AliITSMapA2::~AliITSMapA2(){
	106	//destructor
	107
	108	if (fHitMapD) delete[] fHitMapD;
	109	}
	110
	111
	112	//______________________________________________________________________
	113	void AliITSMapA2::ClearMap(){
	114	//clear array
	115
	116	memset(fHitMapD,0,sizeof(Double_t)*fMaxIndex);
	117	}
	118	//______________________________________________________________________
	119	void AliITSMapA2::FillMap(){
	120	// fills signal map from digits - apply a threshold for signal
	121
	122	if (!fObjects) return;
	123
	124	Int_t ndigits = fObjects->GetEntriesFast();
	125	if (!ndigits) return;
	126
	127	AliITSdigit *dig;
	128	for (Int_t ndig=0; ndig<ndigits; ndig++) {
	129	dig = (AliITSdigit*)fObjects->UncheckedAt(ndig);
	130	Double_t signal = (Double_t)(dig->GetSignal());
	131	if (signal > fMapThresholdD) SetHit(dig->GetCoord1(),dig->GetCoord2(),signal);
	132	} // end for ndig
	133	}
	134	//______________________________________________________________________
	135	void AliITSMapA2::FlagHit(Int_t iz, Int_t ix){
	136	//flag an entry
	137
	138	fHitMapD[CheckedIndex(iz, ix)]=
	139	-1000.*TMath::Abs((Int_t)(fHitMapD[CheckedIndex(iz, ix)])+1.);
	140	}
	141	//______________________________________________________________________
	142	TObject* AliITSMapA2::GetHit(Int_t i, Int_t /* dummy */) const {
	143	//return a pointer to the 1D histogram
	144
	145	if (fObjects) {
	146	return fObjects->UncheckedAt(i);
	147	} else return NULL;
	148	}
	149	//______________________________________________________________________
	150	Double_t AliITSMapA2::GetSignal(Int_t index) const {
	151	//get signal in a cell
	152
	153	if (index<fMaxIndex) return (index <0) ? 0. : fHitMapD[index];
	154	else return 0.;
	155	}
	156	//______________________________________________________________________
	157	FlagType AliITSMapA2::TestHit(Int_t iz, Int_t ix){
	158	// check if the entry has already been flagged
	159
	160	if (CheckedIndex(iz, ix) < 0) return kEmpty;
	161	Int_t inf=(Int_t)fHitMapD[CheckedIndex(iz, ix)];
	162
	163	if (inf <= -1000) {
	164	return kUsed;
	165	} else if (inf == 0) {
	166	return kEmpty;
	167	} else {
	168	return kUnused;
	169	} // end if inf...
	170	}
	171	//______________________________________________________________________
	172	void AliITSMapA2::FillMapFromHist(){
	173	// fills map from 1D histograms
	174
	175	if (!fObjects) return;
	176
	177	// an example
	178	for( Int_t i=0; i<fNobjects; i++) {
	179	TH1F hist =(TH1F )fObjects->UncheckedAt(i);
	180	Int_t nsamples = hist->GetNbinsX();
	181	for( Int_t j=0; j<nsamples; j++) {
	182	Double_t signal = (Double_t)(hist->GetBinContent(j+1));
	183	if (signal > fMapThresholdD) SetHit(i,j,signal);
	184	} // end for j
	185	} // end for i
	186	}
	187	//______________________________________________________________________
	188	void AliITSMapA2::FillHist(){
	189	// fill 1D histograms from map
	190
	191	if (!fObjects \|\| fScaleSizeX != 1) return;
	192
	193	// an example
	194	for( Int_t i=0; i<fNobjects; i++) {
	195	TH1F hist =(TH1F )fObjects->UncheckedAt(i);
	196	for( Int_t j=0; j<fNpx; j++) {
	197	Double_t signal=GetSignal(i,j);
	198	if (signal > fMapThresholdD) hist->Fill((Float_t)j,signal);
	199	} // end for j
	200	} // end for i
	201	}
	202	//______________________________________________________________________
	203	void AliITSMapA2::ResetHist(){
	204	// Reset histograms
	205
	206	if (!fObjects) return;
	207
	208	for( Int_t i=0; i<fNobjects; i++) {
	209	if ((fObjects)[i]) ((TH1F)(*fObjects)[i])->Reset();
	210	} // end for i
	211	}
	212	//______________________________________________________________________
	213	void AliITSMapA2::AddSignal(Int_t iz,Int_t ix,Double_t sig){
	214	// Addes sig to cell iz. equivalent to the very common
	215	// sig = fMapA2->GetSignal(iz,ix) + sig; fMapA2->SetHit(iz,ix,sig);
	216
	217
	218	Int_t index=GetHitIndex(iz,ix);
	219	if(index<0) return;
	220	fHitMapD[CheckedIndex(iz, ix)] += sig;
	221	}