[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;
}
//______________________________________________________________________
AliITSMapA2::AliITSMapA2(const AliITSMapA2 &source) : AliITSMapA1(source),
fHitMapD(source.fHitMapD),
fMapThresholdD(source.fMapThresholdD),
fScaleSizeX(source.fScaleSizeX),
fScaleSizeZ(source.fScaleSizeZ){
    //     Copy Constructor 

}
//______________________________________________________________________
AliITSMapA2& AliITSMapA2::operator=(const AliITSMapA2 &source) {
    //    Assignment operator
  this->~AliITSMapA2();
  new(this) AliITSMapA2(source);
  return *this;

}

//______________________________________________________________________
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	AliITSMapA2::AliITSMapA2(const AliITSMapA2 &source) : AliITSMapA1(source),
	112	fHitMapD(source.fHitMapD),
	113	fMapThresholdD(source.fMapThresholdD),
	114	fScaleSizeX(source.fScaleSizeX),
	115	fScaleSizeZ(source.fScaleSizeZ){
	116	// Copy Constructor
	117
	118	}
	119	//______________________________________________________________________
	120	AliITSMapA2& AliITSMapA2::operator=(const AliITSMapA2 &source) {
	121	// Assignment operator
	122	this->~AliITSMapA2();
	123	new(this) AliITSMapA2(source);
	124	return *this;
	125
	126	}
	127
	128	//______________________________________________________________________
	129	void AliITSMapA2::ClearMap(){
	130	//clear array
	131
	132	memset(fHitMapD,0,sizeof(Double_t)*fMaxIndex);
	133	}
	134	//______________________________________________________________________
	135	void AliITSMapA2::FillMap(){
	136	// fills signal map from digits - apply a threshold for signal
	137
	138	if (!fObjects) return;
	139
	140	Int_t ndigits = fObjects->GetEntriesFast();
	141	if (!ndigits) return;
	142
	143	AliITSdigit *dig;
	144	for (Int_t ndig=0; ndig<ndigits; ndig++) {
	145	dig = (AliITSdigit*)fObjects->UncheckedAt(ndig);
	146	Double_t signal = (Double_t)(dig->GetSignal());
	147	if (signal > fMapThresholdD) SetHit(dig->GetCoord1(),dig->GetCoord2(),signal);
	148	} // end for ndig
	149	}
	150	//______________________________________________________________________
	151	void AliITSMapA2::FlagHit(Int_t iz, Int_t ix){
	152	//flag an entry
	153
	154	fHitMapD[CheckedIndex(iz, ix)]=
	155	-1000.*TMath::Abs((Int_t)(fHitMapD[CheckedIndex(iz, ix)])+1.);
	156	}
	157	//______________________________________________________________________
	158	TObject* AliITSMapA2::GetHit(Int_t i, Int_t /* dummy */) const {
	159	//return a pointer to the 1D histogram
	160
	161	if (fObjects) {
	162	return fObjects->UncheckedAt(i);
	163	} else return NULL;
	164	}
	165	//______________________________________________________________________
	166	Double_t AliITSMapA2::GetSignal(Int_t index) const {
	167	//get signal in a cell
	168
	169	if (index<fMaxIndex) return (index <0) ? 0. : fHitMapD[index];
	170	else return 0.;
	171	}
	172	//______________________________________________________________________
	173	FlagType AliITSMapA2::TestHit(Int_t iz, Int_t ix){
	174	// check if the entry has already been flagged
	175
	176	if (CheckedIndex(iz, ix) < 0) return kEmpty;
	177	Int_t inf=(Int_t)fHitMapD[CheckedIndex(iz, ix)];
	178
	179	if (inf <= -1000) {
	180	return kUsed;
	181	} else if (inf == 0) {
	182	return kEmpty;
	183	} else {
	184	return kUnused;
	185	} // end if inf...
	186	}
	187	//______________________________________________________________________
	188	void AliITSMapA2::FillMapFromHist(){
	189	// fills map from 1D histograms
	190
	191	if (!fObjects) return;
	192
	193	// an example
	194	for( Int_t i=0; i<fNobjects; i++) {
	195	TH1F hist =(TH1F )fObjects->UncheckedAt(i);
	196	Int_t nsamples = hist->GetNbinsX();
	197	for( Int_t j=0; j<nsamples; j++) {
	198	Double_t signal = (Double_t)(hist->GetBinContent(j+1));
	199	if (signal > fMapThresholdD) SetHit(i,j,signal);
	200	} // end for j
	201	} // end for i
	202	}
	203	//______________________________________________________________________
	204	void AliITSMapA2::FillHist(){
	205	// fill 1D histograms from map
	206
	207	if (!fObjects \|\| fScaleSizeX != 1) return;
	208
	209	// an example
	210	for( Int_t i=0; i<fNobjects; i++) {
	211	TH1F hist =(TH1F )fObjects->UncheckedAt(i);
	212	for( Int_t j=0; j<fNpx; j++) {
	213	Double_t signal=GetSignal(i,j);
	214	if (signal > fMapThresholdD) hist->Fill((Float_t)j,signal);
	215	} // end for j
	216	} // end for i
	217	}
	218	//______________________________________________________________________
	219	void AliITSMapA2::ResetHist(){
	220	// Reset histograms
	221
	222	if (!fObjects) return;
	223
	224	for( Int_t i=0; i<fNobjects; i++) {
	225	if ((fObjects)[i]) ((TH1F)(*fObjects)[i])->Reset();
	226	} // end for i
	227	}
	228	//______________________________________________________________________
	229	void AliITSMapA2::AddSignal(Int_t iz,Int_t ix,Double_t sig){
	230	// Addes sig to cell iz. equivalent to the very common
	231	// sig = fMapA2->GetSignal(iz,ix) + sig; fMapA2->SetHit(iz,ix,sig);
	232
	233
	234	Int_t index=GetHitIndex(iz,ix);
	235	if(index<0) return;
	236	fHitMapD[CheckedIndex(iz, ix)] += sig;
	237	}