/*
$Log$
+Revision 1.2 2005/11/03 13:09:19 hristov
+Removing meaningless const declarations (linuxicc)
+
Revision 1.1 2005/10/11 12:31:50 masera
Preprocessor classes for SPD (Paul Nilsson)
//__________________________________________________________________________
AliITSBadChannelsSPD::AliITSBadChannelsSPD(const AliITSBadChannelsSPD &bc) :
- TObject(bc)
-{
+ TObject(bc),
+fIndexArraySize(bc.fIndexArraySize),
+fBadChannelsArraySize(bc.fBadChannelsArraySize),
+fIndexArray(0),
+fBadChannelsArray(0){
// Default copy constructor
- // Copy array sizes
- fIndexArraySize = bc.fIndexArraySize;
- fBadChannelsArraySize = bc.fBadChannelsArraySize;
-
// Create new arrays
fIndexArray = new Int_t[fIndexArraySize];
fBadChannelsArray = new Int_t[fBadChannelsArraySize];
//______________________________________________________________________
AliITSCalibration::AliITSCalibration(const AliITSCalibration &ob):
- TObject(ob)
+TObject(ob),
+fDataType(ob.fDataType),
+fdv(ob.fdv),
+fN(ob.fN),
+fT(ob.fT),
+fGeVcharge(ob.fGeVcharge),
+fResponse(ob.fResponse)
{
// Copy constructor
- // not implemented
- AliWarning("Copy constructor not implemented!");
-}
+}
+/*
//______________________________________________________________________________
AliITSCalibration& AliITSCalibration::operator= (const AliITSCalibration& source)
{
// Asignment operator
- // not implemented
- if(this==&source) return *this;
- AliWarning("Asignment operator not implemented!");
+ this->~AliITSCalibration();
+ new(this) AliITSCalibration(source);
+ return *this;
- ((TObject *)this)->operator=(source);
- return *this;
}
-
+*/
//______________________________________________________________________
Double_t AliITSCalibration::MobilityElectronSiEmp() const {
// Computes the electron mobility in cm^2/volt-sec. Taken from SILVACO
", Channel " << v+1 << " = " << fGain[t][u][v] << endl;
}
}
+
//______________________________________________________________________
void AliITSCalibrationSDD::Print(){
// Print SDD response Parameters
fCouplRow(fgkCouplRowDefault),
fBiasVoltage(fgkBiasVoltageDefault),
fNrDead(0),
-fNrNoisy(0){
+fDeadChannels(0),
+fNrNoisy(0),
+fNoisyChannels(0){
// constructor
SetThresholds(fgkThreshDefault,fgkSigmaDefault);
ClassImp(AliITSCalibrationSSD)
//______________________________________________________________________
-AliITSCalibrationSSD::AliITSCalibrationSSD(){
+AliITSCalibrationSSD::AliITSCalibrationSSD():
+fNPar(0),
+fDetPar(0),
+fNoiseP(0),
+fNoiseN(0),
+fSigmaP(0),
+fSigmaN(0),
+fGainP(0),
+fGainN(0),
+fNoisP(0),
+fNoisN(0),
+fNoisePThreshold(0),
+fNoisyPChannelsList(0),
+fNoiseNThreshold(0),
+fNoisyNChannelsList(0),
+fDeadNChannelsList(0),
+fDeadPChannelsList(0){
// Default Constructor
- fDetPar = 0;
- fNPar = 0;
- fNoiseP = 0;
- fNoiseN = 0;
- fSigmaP = 0;
- fSigmaN = 0;
SetNoiseParam(fgkNoisePDefault,fgkNoiseNDefault);
}
//______________________________________________________________________
-AliITSCalibrationSSD::AliITSCalibrationSSD(const char *dataType){
+AliITSCalibrationSSD::AliITSCalibrationSSD(const char *dataType):
+fNPar(0),
+fDetPar(0),
+fNoiseP(0),
+fNoiseN(0),
+fSigmaP(0),
+fSigmaN(0),
+fGainP(0),
+fGainN(0),
+fNoisP(0),
+fNoisN(0),
+fNoisePThreshold(0),
+fNoisyPChannelsList(0),
+fNoiseNThreshold(0),
+fNoisyNChannelsList(0),
+fDeadNChannelsList(0),
+fDeadPChannelsList(0){
// constructor
SetNoiseParam(fgkNoisePDefault,fgkNoiseNDefault);
delete [] fDetPar;
}
//______________________________________________________________________
-AliITSCalibrationSSD& AliITSCalibrationSSD::operator=(const AliITSCalibrationSSD &src) {
- // = operator.
-
- if(&src == this) return *this;
-
- this->fNPar = src.fNPar;
- for(Int_t i=0;i<this->fNPar;i++) this->fDetPar[i] = src.fDetPar[i];
- this->fNoiseP = src.fNoiseP;
- this->fNoiseN = src.fNoiseN;
- this->fSigmaP = src.fSigmaP;
- this->fSigmaN = src.fSigmaN;
- this->fDataType = src.fDataType;
-
- return *this;
-}
-//_________________________________________________________________________
-AliITSCalibrationSSD::AliITSCalibrationSSD(const AliITSCalibrationSSD &src) :
- AliITSCalibration(src) {
- // copy constructor
-
- *this = src;
-}
-//______________________________________________________________________
void AliITSCalibrationSSD::SetDetParam(Double_t *par){
// set det param
Int_t i;
/*
$Log$
+Revision 1.2 2005/11/03 13:09:19 hristov
+Removing meaningless const declarations (linuxicc)
+
Revision 1.1 2005/10/11 12:31:50 masera
Preprocessor classes for SPD (Paul Nilsson)
//__________________________________________________________________________
AliITSChannelSPD::AliITSChannelSPD(const AliITSChannelSPD &ch) :
- TObject(ch)
-{
+ TObject(ch),
+fColumn(ch.fColumn),
+fRow(ch.fRow){
// Copy constructor
- fColumn = ch.fColumn;
- fRow = ch.fRow;
}
//__________________________________________________________________________
}
//__________________________________________________________________________
-AliITSChannelSPD::AliITSChannelSPD(Int_t column, Int_t row)
-{
+AliITSChannelSPD::AliITSChannelSPD(Int_t column, Int_t row):
+fColumn(column),
+fRow(row){
// Constructor for already existing channel
- fColumn = column;
- fRow = row;
+
}
fModule(0),
fDigits(0),
fNdigits(0),
+fDetTypeRec(dettyp),
fClusters(0),
fNRawClusters(0),
fMap(0),
SetNperMax();
SetClusterSize();
SetDeclusterFlag();
- fDetTypeRec = dettyp;
}
//----------------------------------------------------------------------
AliITSClusterFinder::AliITSClusterFinder(AliITSDetTypeRec* dettyp,
SetClusterSize();
SetDeclusterFlag();
}
+/*
//______________________________________________________________________
AliITSClusterFinder::AliITSClusterFinder(const AliITSClusterFinder &source) : TObject(source) {
// Copy constructor
// Copies are not allowed. The method is protected to avoid misuse.
Fatal("AliITSClusterFinder","Copy constructor not allowed\n");
}
+*/
//______________________________________________________________________
-AliITSClusterFinder& AliITSClusterFinder::operator=(const AliITSClusterFinder& /* source */){
+//AliITSClusterFinder& AliITSClusterFinder::operator=(const AliITSClusterFinder& /* source */){
// Assignment operator
// Assignment is not allowed. The method is protected to avoid misuse.
- Fatal("= operator","Assignment operator not allowed\n");
- return *this;
-}
+// Fatal("= operator","Assignment operator not allowed\n");
+// return *this;
+//}
//----------------------------------------------------------------------
AliITSClusterFinder::~AliITSClusterFinder(){
void InitGeometry();
protected:
- // methods
- AliITSClusterFinder(const AliITSClusterFinder &source); // copy constructor
- // assignment operator
- AliITSClusterFinder& operator=(const AliITSClusterFinder &source);
// data members
Int_t fDebug; //! Debug flag/level
Int_t fNdet[2200]; // detector index
Int_t fNlayer[2200]; // detector layer
+ private:
+ AliITSClusterFinder(const AliITSClusterFinder &source); // copy constructor
+ // assignment operator
+ AliITSClusterFinder& operator=(const AliITSClusterFinder &source);
+
ClassDef(AliITSClusterFinder,6) //Class for clustering and reconstruction of space points
};
SetDx();
SetDz();
}
-
+/*
//______________________________________________________________________
AliITSClusterFinderSPD::AliITSClusterFinderSPD(const AliITSClusterFinderSPD &source) : AliITSClusterFinder(source) {
// Copy constructor
// Copies are not allowed. The method is protected to avoid misuse.
Fatal("AliITSClusterFinderSPD","Copy constructor not allowed\n");
}
-
+*/
//______________________________________________________________________
-AliITSClusterFinderSPD& AliITSClusterFinderSPD::operator=(const AliITSClusterFinderSPD& /* source */){
+//AliITSClusterFinderSPD& AliITSClusterFinderSPD::operator=(const AliITSClusterFinderSPD& /* source */){
// Assignment operator
// Assignment is not allowed. The method is protected to avoid misuse.
- Fatal("= operator","Assignment operator not allowed\n");
- return *this;
-}
+ //Fatal("= operator","Assignment operator not allowed\n");
+ //return *this;
+//}
//______________________________________________________________________
void AliITSClusterFinderSPD::FindRawClusters(Int_t module){
// input of Cluster Finder
AliITSClusterFinderSSD();
AliITSClusterFinderSSD(AliITSDetTypeRec* dettyp);
AliITSClusterFinderSSD(AliITSDetTypeRec* dettyp, TClonesArray *digits);
+
// AliITSClusterFinderSSD(AliITSsegmentation *seg, TClonesArray *digits);
virtual ~AliITSClusterFinderSSD();
void FindRawClusters(Int_t module);
protected:
- virtual AliITSsegmentationSSD* GetSeg()const{
+
+ AliITSClusterFinderSSD(const AliITSClusterFinderSSD &source); // Copy constructor
+ AliITSClusterFinderSSD& operator=(const AliITSClusterFinderSSD &source);// = operator
+
+ virtual AliITSsegmentationSSD* GetSeg()const{
return (AliITSsegmentationSSD*)fDetTypeRec->GetSegmentationModel(2);}
void InitReconstruction();
Bool_t CreateNewRecPoint(Float_t P, Float_t dP, Float_t N, Float_t dN,
extern AliRun *gAlice;
-AliITSClusterFinderV2::AliITSClusterFinderV2(AliITSDetTypeRec* dettyp):AliITSClusterFinder(dettyp){
+AliITSClusterFinderV2::AliITSClusterFinderV2(AliITSDetTypeRec* dettyp):AliITSClusterFinder(dettyp),
+fNModules(0),
+fEvent(0){
//Default constructor
- fEvent = 0;
- fModule = 0;
fNModules = dettyp->GetITSgeom()->GetIndexMax();
}
-
+/*
//______________________________________________________________________
AliITSClusterFinderV2::AliITSClusterFinderV2(const AliITSClusterFinderV2 &source) : AliITSClusterFinder(source) {
// Copy constructor
// Copies are not allowed. The method is protected to avoid misuse.
Fatal("AliITSClusterFinderV2","Copy constructor not allowed\n");
}
-
+*/
//______________________________________________________________________
-AliITSClusterFinderV2& AliITSClusterFinderV2::operator=(const AliITSClusterFinderV2& /* source */){
+//AliITSClusterFinderV2& AliITSClusterFinderV2::operator=(const AliITSClusterFinderV2& /* source */){
// Assignment operator
// Assignment is not allowed. The method is protected to avoid misuse.
- Fatal("= operator","Assignment operator not allowed\n");
- return *this;
-}
+ //Fatal("= operator","Assignment operator not allowed\n");
+ //return *this;
+//}
//______________________________________________________________________
};
class AliBin {
public:
- AliBin() {fIndex=0; fQ=0; fMask=0xFFFFFFFE;}
+ AliBin():fIndex(0),fMask(0xFFFFFFFE),fQ(0){}
void SetIndex(UInt_t idx) {fIndex=idx;}
void SetQ(UShort_t q) {fQ=q;}
void SetMask(UInt_t m) {fMask=m;}
extern AliRun *gAlice;
-AliITSClusterFinderV2SDD::AliITSClusterFinderV2SDD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp){
+AliITSClusterFinderV2SDD::AliITSClusterFinderV2SDD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp),
+fNySDD(256),
+fNzSDD(256),
+fYpitchSDD(0.01825),
+fZpitchSDD(0.02940),
+fHwSDD(3.5085),
+fHlSDD(3.7632),
+fYoffSDD(0.0425){
//Default constructor
- fNySDD=256; fNzSDD=256;
- fYpitchSDD=0.01825;
- fZpitchSDD=0.02940;
- fHwSDD=3.5085; fHlSDD=3.7632;
- fYoffSDD=0.0425;
-
-
}
extern AliRun *gAlice;
-AliITSClusterFinderV2SPD::AliITSClusterFinderV2SPD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp){
+AliITSClusterFinderV2SPD::AliITSClusterFinderV2SPD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp),
+fLastSPD1(0),
+fNySPD(256),
+fNzSPD(160),
+fYpitchSPD(0.0050),
+fZ1pitchSPD(0.0425),
+fZ2pitchSPD(0.0625),
+fHwSPD(0.64),
+fHlSPD(3.48){
//Default constructor
fLastSPD1=fDetTypeRec->GetITSgeom()->GetModuleIndex(2,1,1)-1;
-
- fNySPD=256; fNzSPD=160;
- fYpitchSPD=0.0050;
- fZ1pitchSPD=0.0425; fZ2pitchSPD=0.0625;
- fHwSPD=0.64; fHlSPD=3.48;
fYSPD[0]=0.5*fYpitchSPD;
for (Int_t m=1; m<fNySPD; m++) fYSPD[m]=fYSPD[m-1]+fYpitchSPD;
fZSPD[0]=fZ1pitchSPD;
ClassImp(AliITSClusterFinderV2SSD)
-AliITSClusterFinderV2SSD::AliITSClusterFinderV2SSD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp){
+AliITSClusterFinderV2SSD::AliITSClusterFinderV2SSD(AliITSDetTypeRec* dettyp):AliITSClusterFinderV2(dettyp),
+fLastSSD1(0),
+fYpitchSSD(0.0095),
+fHwSSD(3.65),
+fHlSSD(2.00),
+fTanP(0.0275),
+fTanN(0.0075){
//Default constructor
fLastSSD1=fDetTypeRec->GetITSgeom()->GetModuleIndex(6,1,1)-1;
- fYpitchSSD=0.0095;
- fHwSSD=3.65;
- fHlSSD=2.00;
- fTanP=0.0275;
- fTanN=0.0075;
-
-
}
ClassImp(AliITSDDLRawData)
////////////////////////////////////////////////////////////////////////////////////////
-AliITSDDLRawData::AliITSDDLRawData(){
+AliITSDDLRawData::AliITSDDLRawData():
+fVerbose(0),
+fIndex(-1),
+fHalfStaveModule(-1){
//Default constructor
- fIndex=-1;
- fHalfStaveModule=-1;
- fVerbose=0;
+
}
////////////////////////////////////////////////////////////////////////////////////////
AliITSDDLRawData::AliITSDDLRawData(const AliITSDDLRawData &source) :
- TObject(source){
+ TObject(source),
+fVerbose(source.fVerbose),
+fIndex(source.fIndex),
+fHalfStaveModule(source.fHalfStaveModule){
//Copy Constructor
- this->fIndex=source.fIndex;
- this->fHalfStaveModule=source.fHalfStaveModule;
- this->fVerbose=source.fVerbose;
- return;
}
////////////////////////////////////////////////////////////////////////////////////////
#include "TTree.h"
#include "AliCDBManager.h"
-#include "AliCDBStorage.h"
#include "AliCDBEntry.h"
#include "AliITSClusterFinder.h"
#include "AliITSClusterFinderV2.h"
ClassImp(AliITSDetTypeRec)
//________________________________________________________________
-AliITSDetTypeRec::AliITSDetTypeRec(): TObject(){
+AliITSDetTypeRec::AliITSDetTypeRec(): TObject(),
+fNMod(0),
+fReconstruction(0),
+fSegmentation(0),
+fCalibration(0),
+fPreProcess(0),
+fPostProcess(0),
+fDigits(0),
+fNdtype(0),
+fCtype(0),
+fNctype(0),
+fRecPoints(0),
+fNRecPoints(0),
+fSelectedVertexer(),
+fLoader(0),
+fRunNumber(0),
+fFirstcall(kTRUE){
// Default Constructor
// Inputs:
// none.
// none.
// Return:
// A properly zero-ed AliITSDetTypeRec class.
- fReconstruction = 0;
- fSegmentation = 0;
- fCalibration = 0;
- fPreProcess = 0;
- fPostProcess = 0;
- fDigits = 0;;
+
for(Int_t i=0; i<3; i++){
fClusterClassName[i]=0;
fDigClassName[i]=0;
fRecPointClassName[i]=0;
}
- fNdtype = 0;
- fCtype = 0;
- fNMod = 0;
- fNctype = 0;
- fRecPoints = 0;
- fNRecPoints = 0;
+
SelectVertexer(" ");
- fLoader = 0;
- fRunNumber = 0;
- fFirstcall = kTRUE;
+
}
//________________________________________________________________
-AliITSDetTypeRec::AliITSDetTypeRec(AliITSLoader *loader): TObject(){
+AliITSDetTypeRec::AliITSDetTypeRec(AliITSLoader *loader): TObject(),
+fNMod(0),
+fReconstruction(0),
+fSegmentation(0),
+fCalibration(0),
+fPreProcess(0),
+fPostProcess(0),
+fDigits(0),
+fNdtype(0),
+fCtype(0),
+fNctype(0),
+fRecPoints(0),
+fNRecPoints(0),
+fSelectedVertexer(),
+fLoader(loader),
+fRunNumber(0),
+fFirstcall(kTRUE){
// Standard Constructor
// Inputs:
// none.
//
fReconstruction = new TObjArray(fgkNdettypes);
- fSegmentation = 0;
- fCalibration = 0;
- fPreProcess = 0;
- fPostProcess = 0;
fDigits = new TObjArray(fgkNdettypes);
for(Int_t i=0; i<3; i++){
fClusterClassName[i]=0;
fNctype[i]=0;
}
- SelectVertexer(" ");
- fLoader = loader;
-
+ SelectVertexer(" ");
SetRunNumber();
- fFirstcall = kTRUE;
}
+/*
//______________________________________________________________________
-AliITSDetTypeRec::AliITSDetTypeRec(const AliITSDetTypeRec &/*rec*/):TObject(/*rec*/){
- // Copy constructor.
+AliITSDetTypeRec::AliITSDetTypeRec(const AliITSDetTypeRec & rec):TObject(rec)
+{
+ // Copy constructor.
Error("Copy constructor","Copy constructor not allowed");
-
}
//______________________________________________________________________
-AliITSDetTypeRec& AliITSDetTypeRec::operator=(const AliITSDetTypeRec& /*source*/){
+AliITSDetTypeRec& AliITSDetTypeRec::operator=(const AliITSDetTypeRec& source){
// Assignment operator. This is a function which is not allowed to be
// done.
Error("operator=","Assignment operator not allowed\n");
return *this;
-}
+}
+*/
//_____________________________________________________________________
AliITSDetTypeRec::~AliITSDetTypeRec(){
-
//Destructor
if(fReconstruction){
if(!entrySPD || !entrySDD || !entrySSD || !entry2SPD || !entry2SDD || !entry2SSD){
AliWarning("Calibration object retrieval failed! Dummy calibration will be used.");
- AliCDBStorage *localStor =
- AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
+ AliCDBStorage *origStorage = AliCDBManager::Instance()->GetDefaultStorage();
+ AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
- entrySPD = localStor->Get("ITS/Calib/CalibSPD", run);
- entrySDD = localStor->Get("ITS/Calib/CalibSDD", run);
- entrySSD = localStor->Get("ITS/Calib/CalibSSD", run);
- entry2SPD = localStor->Get("ITS/Calib/RespSPD", run);
- entry2SDD = localStor->Get("ITS/Calib/RespSDD", run);
- entry2SSD = localStor->Get("ITS/Calib/RespSSD", run);
+ entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSPD", run);
+ entrySDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD", run);
+ entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD", run);
+ entry2SPD = AliCDBManager::Instance()->Get("ITS/Calib/RespSPD", run);
+ entry2SDD = AliCDBManager::Instance()->Get("ITS/Calib/RespSDD", run);
+ entry2SSD = AliCDBManager::Instance()->Get("ITS/Calib/RespSSD", run);
+
+ AliCDBManager::Instance()->SetDefaultStorage(origStorage);
}
- if(!entrySPD || !entrySDD || !entrySSD || !entry2SPD || !entry2SDD || !entry2SSD){
- AliError("Calibration data was not found in $ALICE_ROOT!");
- return kFALSE;
- }
TObjArray *calSPD = (TObjArray *)entrySPD->GetObject();
if(!isCacheActive)entrySPD->SetObject(NULL);
public:
AliITSDetTypeRec(); // Default constructor
AliITSDetTypeRec(AliITSLoader *loader); // Standard constructor
- AliITSDetTypeRec(const AliITSDetTypeRec& rec);
- AliITSDetTypeRec& operator=(const AliITSDetTypeRec &source);
-
+
virtual ~AliITSDetTypeRec(); // Proper Destructor
AliITSgeom* GetITSgeom()const{return GetLoader()->GetITSgeom();}
private:
// private methods
+ AliITSDetTypeRec(const AliITSDetTypeRec& rec);
+ AliITSDetTypeRec& operator=(const AliITSDetTypeRec &source);
+
virtual void SetLoader(AliITSLoader* loader) {fLoader=loader;}
static const Int_t fgkNdettypes; // number of det. types
static const Int_t fgkDefaultNModulesSPD; // Total numbers of SPD modules by default
//_____________________________________________________________
-AliITSEventHeader::AliITSEventHeader():AliDetectorEventHeader()
+ AliITSEventHeader::AliITSEventHeader():AliDetectorEventHeader(),
+fEventTypeSDD(),
+fJitterSDD(0)
{
//
// Defaulst Constructor
fMiniEvId[idet]=0;
fSubDet[idet]=0;
fVersion[idet]=0;
- fJitterSDD=0;
}
}
//_____________________________________________________________
-AliITSEventHeader::AliITSEventHeader(const char* name):AliDetectorEventHeader(name)
+AliITSEventHeader::AliITSEventHeader(const char* name):AliDetectorEventHeader(name),
+fEventTypeSDD(),
+fJitterSDD(-123)
{
//
// Constructor
fMiniEvId[idet]=0;
fSubDet[idet]=0;
fVersion[idet]=0;
- fJitterSDD=-123;
}
ClassImp(AliITSIOTrack)
-AliITSIOTrack::AliITSIOTrack() {
+AliITSIOTrack::AliITSIOTrack():
+fLab(-3),
+fTPCLab(-3),
+fX(0.),
+fY(0.),
+fZ(0.),
+fPx(0.),
+fPy(0.),
+fPz(0.),
+fStateVPhi(0.),
+fStateVZ(0.),
+fStateVD(0.),
+fStateVTgl(0.),
+fStateVC(0.),
+fRadius(0.),
+fPid(0),
+fCharge(0),
+fMass(0.),
+fDz(0.),
+fdEdx(0.),
+fC00(0.),
+fC10(0.),
+fC11(0.),
+fC20(0.),
+fC21(0.),
+fC22(0.),
+fC30(0.),
+fC31(0.),
+fC32(0.),
+fC33(0.),
+fC40(0.),
+fC41(0.),
+fC42(0.),
+fC43(0.),
+fC44(0.) {
//Origin A. Badala' and G.S. Pappalardo: e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
// default constructor
- fLab=-3;
- fTPCLab=-3;
- fX=fZ=fY=0.;
- fPx=fPy=fPz=0.;
- fDz=0.;
- for (Int_t i=0;i<6;i++) {fIdModules[i]=fIdPoints[i]=-1; fIdPoints[i]=-1;}
- fStateVPhi=0.; fStateVZ=0.; fStateVD=0.; fStateVTgl=0.; fStateVC=0.;
- fRadius=0.; fCharge=0;
- fMass =0.;
- fdEdx=0.;
- fPid=0;
- fC00=fC10=fC11=fC20=fC21=fC22=fC30=fC31=fC32=fC33=fC40=fC41=fC42=fC43=fC44=0.;
+ for (Int_t i=0;i<6;i++) {fIdModules[i]=fIdPoints[i]=-1; fIdPoints[i]=-1;}
}
ClassImp(AliITSLoader)
/**********************************************************************/
- AliITSLoader::AliITSLoader():AliLoader(){
+ AliITSLoader::AliITSLoader():AliLoader(),
+fITSpid(0),
+fGeom(0){
// Default constructor
- fITSpid = 0;
- fGeom = 0;
}
/*********************************************************************/
AliITSLoader::AliITSLoader(const Char_t *name,const Char_t *topfoldername):
-AliLoader(name,topfoldername){
- //ctor
+AliLoader(name,topfoldername),
+fITSpid(0),
+fGeom(0){
+ //Constructor
AliDataLoader* rawClustersDataLoader = new AliDataLoader(
fDetectorName + ".RawCl.root",fgkDefaultRawClustersContainerName,
"Raw Clusters");
fDataLoaders->Add(cascadeDataLoader);
cascadeDataLoader->SetEventFolder(fEventFolder);
cascadeDataLoader->SetFolder(GetDetectorDataFolder());
- fITSpid=0;
- fGeom = 0;
}
/**********************************************************************/
AliITSLoader::AliITSLoader(const Char_t *name,TFolder *topfolder):
-AliLoader(name,topfolder) {
+ AliLoader(name,topfolder),
+fITSpid(0),
+fGeom(0){
//ctor
AliDataLoader* rawClustersDataLoader = new AliDataLoader(
fDetectorName + ".RawCl.root",fgkDefaultRawClustersContainerName,
fDataLoaders->Add(cascadeDataLoader);
cascadeDataLoader->SetEventFolder(fEventFolder);
cascadeDataLoader->SetFolder(GetDetectorDataFolder());
- fITSpid = 0;
- fGeom = 0;
-}
-
-//______________________________________________________________________
-AliITSLoader::AliITSLoader(const AliITSLoader &ob) : AliLoader(ob) {
- // Copy constructor
- // Copies are not allowed. The method is protected to avoid misuse.
- Error("AliITSLoader","Copy constructor not allowed\n");
}
-//______________________________________________________________________
-AliITSLoader& AliITSLoader::operator=(const AliITSLoader& /* ob */){
- // Assignment operator
- // Assignment is not allowed. The method is protected to avoid misuse.
- Error("= operator","Assignment operator not allowed\n");
- return *this;
-}
/**********************************************************************/
AliITSLoader::~AliITSLoader(){
UnloadCascades();
dl = GetCascadeDataLoader();
fDataLoaders->Remove(dl);
+
if(fGeom)delete fGeom;
fGeom = 0;
}
AliITSLoader();
AliITSLoader(const Char_t *name,const Char_t *topfoldername);
AliITSLoader(const Char_t *name,TFolder *topfolder);
- AliITSLoader(const AliITSLoader &ob); // copy constructor
- AliITSLoader& operator=(const AliITSLoader & /* source */); // ass.
-
virtual ~AliITSLoader();
void AdoptITSpid(AliITSpidESD* pid) {fITSpid=pid;}
protected:
+ AliITSLoader(const AliITSLoader &ob); // copy constructor
+ AliITSLoader& operator=(const AliITSLoader & /* source */); // ass.
+
// METHODS
virtual void MakeRawClustersContainer() {GetRawClLoader()->MakeTree();}
Int_t PostRawClusters(){
static const TString fgkDefaultCascadeContainerName; //default fo cascade container name
AliITSpidESD* fITSpid; //! pointer for ITS pid
AliITSgeom *fGeom; //! pointer to the ITS geometry class
+
+
ClassDef(AliITSLoader,5) // Loader for additional ITS specific trees.
};
ClassImp(AliITSMapA1)
//______________________________________________________________________
-AliITSMapA1::AliITSMapA1(){
+AliITSMapA1::AliITSMapA1():
+fSegmentation(0),
+fNpx(0),
+fNpz(0),
+fObjects(0),
+fNobjects(0),
+fMaxIndex(0),
+fMapThresholdArr(0),
+fHitMap(0),
+fMapThreshold(0){
// default constructor
- fSegmentation = 0;
- fNpz = 0;
- fNpx = 0;
- fMaxIndex = 0;
- fHitMap = 0;
- fObjects = 0;
- fNobjects = 0;
- fMapThreshold = 0;
- fMapThresholdArr = 0;
}
//______________________________________________________________________
-AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg){
+AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg):
+fSegmentation(seg),
+fNpx(0),
+fNpz(0),
+fObjects(0),
+fNobjects(0),
+fMaxIndex(0),
+fMapThresholdArr(0),
+fHitMap(0),
+fMapThreshold(0){
//constructor
- fSegmentation = seg;
fNpz = fSegmentation->Npz();
fNpx = fSegmentation->Npx();
fMaxIndex = fNpz*fNpx+fNpx; // 2 halves of detector
fHitMap = new Int_t[fMaxIndex];
- fObjects = 0;
- fNobjects = 0;
- fMapThreshold = 0;
- fMapThresholdArr = 0;
ClearMap();
}
//______________________________________________________________________
-AliITSMapA1::AliITSMapA1(AliITSsegmentation *seg, TObjArray *obj){
+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
- fNobjects = 0;
- fSegmentation = seg;
- fNpz = fSegmentation->Npz();
- fNpx = fSegmentation->Npx();
- fMaxIndex = fNpz*fNpx+fNpx; // 2 halves of detector
- fHitMap = new Int_t[fMaxIndex];
- fObjects = obj;
- if(fObjects) fNobjects = fObjects->GetEntriesFast();
- fMapThreshold = 0;
- fMapThresholdArr = 0;
- ClearMap();
+ 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){
+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
- fNobjects = 0;
- fSegmentation = seg;
- fNpz = fSegmentation->Npz();
- fNpx = fSegmentation->Npx();
- fMaxIndex = fNpz*fNpx+fNpx; // 2 halves of detector
- fHitMap = new Int_t[fMaxIndex];
- fObjects = obj;
- if(fObjects) fNobjects = fObjects->GetEntriesFast();
- fMapThreshold = thr;
- ClearMap();
+ 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){
+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
- fNobjects = 0;
- fSegmentation = seg;
- fNpz = fSegmentation->Npz();
- fNpx = fSegmentation->Npx();
- fMaxIndex = fNpz*fNpx+fNpx; // 2 halves of detector
- fHitMap = new Int_t[fMaxIndex];
- fObjects = obj;
- if(fObjects) fNobjects = fObjects->GetEntriesFast();
- fMapThreshold = 0;
- fMapThresholdArr = thr;
- ClearMap();
+ 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::operator=(const AliITSMapA1 &source) {
// Assignment operator
- if(&source == this) return *this;
-
- this->fNpx = source.fNpx;
- this->fNpz = source.fNpz;
- this->fObjects = source.fObjects;
- this->fNobjects = source.fNobjects;
- this->fMaxIndex = source.fMaxIndex;
- this->fHitMap = source.fHitMap;
- this->fMapThreshold = source.fMapThreshold;
- this->fMapThresholdArr = source.fMapThresholdArr;
- return *this;
+ this->~AliITSMapA1();
+ new(this) AliITSMapA1(source);
+ return *this;
}
//______________________________________________________________________
-AliITSMapA1::AliITSMapA1(const AliITSMapA1 &source) : AliITSMap(source){
- // Copy Constructor
-
- *this = source;
+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(){
ClassImp(AliITSMapA2)
//______________________________________________________________________
-AliITSMapA2::AliITSMapA2(){
+AliITSMapA2::AliITSMapA2():
+fHitMapD(0),
+fMapThresholdD(0),
+fScaleSizeX(0),
+fScaleSizeZ(0){
// default constructor
fSegmentation = 0;
fNpz = 0;
fNpx = 0;
fMaxIndex = 0;
- fHitMapD = 0;
fObjects = 0;
fNobjects = 0;
- fMapThresholdD =0.;
}
//______________________________________________________________________
-AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg){
+AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg):
+fHitMapD(0),
+fMapThresholdD(0),
+fScaleSizeX(1),
+fScaleSizeZ(1){
//constructor
- fScaleSizeZ = 1;
- fScaleSizeX = 1;
fSegmentation = seg;
fNpz = fSegmentation->Npz();
fNpx = fSegmentation->Npx();
fMaxIndex = fNpz*fNpx+fNpx; // 2 halves of detector
fHitMapD = new Double_t[fMaxIndex+1];
- fMapThresholdD = 0.;
fObjects = 0;
fNobjects = 0;
ClearMap();
}
//______________________________________________________________________
AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg,
- Int_t scalesizeX, Int_t scalesizeZ){
+ Int_t scalesizeX, Int_t scalesizeZ):
+fHitMapD(0),
+fMapThresholdD(0),
+fScaleSizeX(scalesizeX),
+fScaleSizeZ(scalesizeZ){
//constructor
fSegmentation = seg;
- fScaleSizeX = scalesizeX;
- fScaleSizeZ = scalesizeZ;
fNpz = fScaleSizeZ*fSegmentation->Npz();
fNpx = fScaleSizeX*fSegmentation->Npx();
fMaxIndex = fNpz*fNpx+fNpx; // 2 halves of detector
fHitMapD = new Double_t[fMaxIndex+1];
- fMapThresholdD = 0.;
fObjects = 0;
fNobjects = 0;
ClearMap();
}
//______________________________________________________________________
AliITSMapA2::AliITSMapA2(AliITSsegmentation *seg, TObjArray *obj,
- Double_t thresh){
+ Double_t thresh):
+fHitMapD(0),
+fMapThresholdD(thresh),
+fScaleSizeX(1),
+fScaleSizeZ(1){
//constructor
fNobjects = 0;
- fScaleSizeZ = 1;
- fScaleSizeX = 1;
fSegmentation = seg;
fNpz = fSegmentation->Npz();
fNpx = fSegmentation->Npx();
fHitMapD = new Double_t[fMaxIndex+1];
fObjects = obj;
if (fObjects) fNobjects = fObjects->GetEntriesFast();
- fMapThresholdD = thresh;
ClearMap();
}
//______________________________________________________________________
if (fHitMapD) delete[] fHitMapD;
}
//______________________________________________________________________
-AliITSMapA2::AliITSMapA2(const AliITSMapA2 &source) : AliITSMapA1(source){
+AliITSMapA2::AliITSMapA2(const AliITSMapA2 &source) : AliITSMapA1(source),
+fHitMapD(source.fHitMapD),
+fMapThresholdD(source.fMapThresholdD),
+fScaleSizeX(source.fScaleSizeX),
+fScaleSizeZ(source.fScaleSizeZ){
// Copy Constructor
- if(&source == this) return;
-
- this->fMapThresholdD = source.fMapThresholdD;
- this->fScaleSizeX = source.fScaleSizeX;
- this->fScaleSizeZ = source.fScaleSizeZ;
- this->fHitMapD = source.fHitMapD;
- return;
}
//______________________________________________________________________
AliITSMapA2& AliITSMapA2::operator=(const AliITSMapA2 &source) {
// Assignment operator
+ this->~AliITSMapA2();
+ new(this) AliITSMapA2(source);
+ return *this;
- if(&source == this) return *this;
-
- this->fMapThresholdD = source.fMapThresholdD;
- this->fScaleSizeX = source.fScaleSizeX;
- this->fScaleSizeZ = source.fScaleSizeZ;
- this->fHitMapD = source.fHitMapD;
- return *this;
}
+
//______________________________________________________________________
void AliITSMapA2::ClearMap(){
//clear array
--- /dev/null
+/////////////////////////////////////////
+// Class for SDD digits preprocessing //
+////////////////////////////////////////
+
+#include "AliITSPreprocessorSDD.h"
+#include "AliITSCalibrationSDD.h"
+#include "AliShuttleInterface.h"
+#include "AliCDBMetaData.h"
+#include "TObjArray.h"
+#include "TH1F.h"
+#include "AliLog.h"
+#include "TFile.h"
+
+const Int_t AliITSPreprocessorSDD::fgkNumberOfSDD = 260;
+const Int_t AliITSPreprocessorSDD::fgkNumberOfChannels = 512;
+const char* AliITSPreprocessorSDD::fgkNameHistoPedestals ="hpedestal";
+const char* AliITSPreprocessorSDD::fgkNameHistoNoise="hnoise";
+
+ClassImp(AliITSPreprocessorSDD)
+
+
+UInt_t AliITSPreprocessorSDD::Process(TMap*/* dcsAliasMap*/){
+
+ //preprocessing.
+
+ UInt_t result = 0;
+ const char* filename = GetFile(kDAQ,"PEDESTALS","GDC");
+ const char* filenamen= GetFile(kDAQ,"NOISE","GDC");
+ const char* filenamed= GetFile(kDAQ,"DEADCHANNELS","GDC");
+ TFile* f1 = TFile::Open(filename,"r");
+ TFile* f2 = TFile::Open(filenamen,"r");
+ Char_t namehisto[20];
+ Char_t namehisto2[20];
+
+ FILE* filed = fopen(filenamed,"read");
+ Int_t numOfBadChannels[fgkNumberOfSDD];
+ Int_t** badCh = new Int_t*[fgkNumberOfSDD];
+
+ Char_t row[50];
+ Int_t nSDD=0;
+ Char_t str[20];
+ char dims[1];
+ Int_t dim;
+ sprintf(str,"MODULE=%d",0);
+ while(!feof(filed)){
+ fscanf(filed,"%s\n",row);
+ if(strcmp(row,str)==0){
+ fscanf(filed,"%s %d\n",dims,&dim);
+ badCh[nSDD] = new Int_t[dim];
+ numOfBadChannels[nSDD]=dim;
+ for(Int_t ibad=0;ibad<dim;ibad++){
+ fscanf(filed,"%d\n",&badCh[nSDD][ibad]);
+ }
+ }
+ nSDD++;
+ sprintf(str,"MODULE=%d",nSDD);
+ }
+
+
+
+ AliCDBMetaData *md1= new AliCDBMetaData(); // metaData describing the object
+ md1->SetObjectClassName("AliITSCalibration");
+ md1->SetResponsible("Elisabetta Crescio");
+ md1->SetBeamPeriod(0);
+ md1->SetAliRootVersion("head September 2005"); //root version
+ md1->SetComment("This is a test");
+
+ TObjArray respSDD(260);
+ respSDD.SetOwner(kFALSE);
+
+ for(Int_t imod=0;imod<fgkNumberOfSDD;imod++){
+ AliITSCalibrationSDD *cal = new AliITSCalibrationSDD("simulated");
+ cal->SetDeadChannels(numOfBadChannels[imod]);
+ for(Int_t ich=0;ich<numOfBadChannels[imod];ich++){
+ cal->SetBadChannel(ich,badCh[imod][ich]);
+ }
+ sprintf(namehisto,"%s_%d",fgkNameHistoPedestals,imod);
+ sprintf(namehisto2,"%s_%d",fgkNameHistoNoise,imod);
+ TH1F* hbas = (TH1F*)f1->Get(namehisto);
+ TH1F* hnoi = (TH1F*)f2->Get(namehisto2);
+ for(Int_t ien=0;ien<fgkNumberOfChannels;ien++){
+ cal->SetBaseline(ien,hbas->GetBinContent(ien+1));
+ cal->SetNoiseAfterElectronics(ien,hnoi->GetBinContent(ien+1));
+ }
+ respSDD.Add(cal);
+ }
+
+ result = Store("Calib","Data",&respSDD,md1);
+
+ for(Int_t i=0;i<fgkNumberOfSDD;i++){
+ delete badCh[i];
+ }
+ delete [] badCh;
+ f1->Close();
+ f2->Close();
+ fclose(filed);
+ return result;
+
+}
--- /dev/null
+#ifndef ALIITSPREPROCESSORSDD_H
+#define ALIITSPREPROCESSORSDD_H
+
+////////////////////////////////////////////////////
+// Class for the //
+// SDD beam test digit preprocessing //
+// Origin: E. Crescio - crescio@to.infn.it //
+// //
+////////////////////////////////////////////////////
+
+
+#include "AliPreprocessor.h"
+
+
+class AliITSPreprocessorSDD : public AliPreprocessor {
+
+
+ public:
+
+ AliITSPreprocessorSDD(const char* detector, AliShuttleInterface* shuttle):
+ AliPreprocessor(detector,shuttle){;}
+ virtual ~AliITSPreprocessorSDD(){;}
+
+
+
+ protected:
+
+ virtual UInt_t Process(TMap* dcsAliasMap);
+
+ static const Int_t fgkNumberOfSDD; // number of SDD modules
+ static const Int_t fgkNumberOfChannels; // number of channels per module
+ static const char* fgkNameHistoPedestals; // name of pedestal histogram
+ static const char* fgkNameHistoNoise; // name of noise histogram
+
+ ClassDef(AliITSPreprocessorSDD,1) // Alice ITS-SDD preprocessor.
+
+ };
+
+
+
+#endif
+
+
#include "AliCDBEntry.h"
#include "AliITSCalibrationSPD.h"
ClassImp(AliITSPreprocessorSPD)
-
-
//__________________________________________________________________________
AliITSPreprocessorSPD::AliITSPreprocessorSPD(void):
- fITSLoader(0x0),
- fRunLoader(0x0),
- fThresholdRatio(5.),
- fThreshold(5),
- fMaximumNumberOfEvents(1000000),
- fHighestModuleNumber(0),
- fSelectedAlgorithm(kOptimizedForRealData),
- fGeometryMode(kALICEGeometry),
- fNumberOfBadChannels(0),
- fInit(kFALSE),
- fVMEMode(kFALSE),
- fDigitsHistogram(0),
- fBadChannelsObjArray(0),
- fBadChannelsIntArray(0),
- fBadChannelsIndexArray(0),
- fBadChannelsContainer(0)
+fITSLoader(0x0),
+fRunLoader(0x0),
+fThresholdRatio(5.),
+fThreshold(5),
+fMaximumNumberOfEvents(1000000),
+fNumberOfModules(0),
+fHighestModuleNumber(0),
+fNumberOfColumns(0),
+fNumberOfRows(0),
+fSelectedAlgorithm(kOptimizedForRealData),
+fGeometryMode(kALICEGeometry),
+fNumberOfBadChannels(0),
+ fIndex(0),
+fInit(kFALSE),
+fVMEMode(kFALSE),
+fDigitsHistogram(0),
+fBadChannelsObjArray(0),
+fBadChannelsIntArray(0),
+fBadChannelsIndexArray(0),
+fBadChannelsContainer(0)
{
// Default constructor for the SPD preprocessor
//
const char *fileNameg, const Int_t maxNumberOfEvents):
fITSLoader(0x0),
fRunLoader(0x0),
- fInit(kFALSE)
+ fThresholdRatio(0),
+ fThreshold(0),
+ fMaximumNumberOfEvents(1000000),
+ fNumberOfModules(0),
+ fHighestModuleNumber(0),
+ fNumberOfColumns(0),
+ fNumberOfRows(0),
+ fSelectedAlgorithm(kOptimizedForRealData),
+ fGeometryMode(kALICEGeometry),
+ fNumberOfBadChannels(0),
+ fIndex(0),
+ fInit(kFALSE),
+ fVMEMode(kFALSE),
+ fDigitsHistogram(0),
+ fBadChannelsObjArray(0),
+ fBadChannelsIntArray(0),
+ fBadChannelsIndexArray(0),
+ fBadChannelsContainer(0)
{
// Standard constructor for the SPD preprocessor
//
//__________________________________________________________________________
AliITSPreprocessorSPD::AliITSPreprocessorSPD(const AliITSPreprocessorSPD &prep) :
- TTask(prep)
+TTask(prep),
+ fITSLoader(prep.fITSLoader),
+ fRunLoader(prep.fRunLoader),
+ fThresholdRatio(prep.fThresholdRatio),
+ fThreshold(prep.fThreshold),
+ fMaximumNumberOfEvents(prep.fMaximumNumberOfEvents),
+ fNumberOfModules(prep.fNumberOfModules),
+ fHighestModuleNumber(prep.fHighestModuleNumber),
+ fNumberOfColumns(prep.fNumberOfColumns),
+ fNumberOfRows(prep.fNumberOfRows),
+ fSelectedAlgorithm(prep.fSelectedAlgorithm),
+ fGeometryMode(prep.fGeometryMode),
+ fNumberOfBadChannels(prep.fNumberOfBadChannels),
+ fIndex(prep.fIndex),
+ fInit(prep.fInit),
+ fVMEMode(prep.fVMEMode),
+ fDigitsHistogram(prep.fDigitsHistogram),
+ fBadChannelsObjArray(prep.fBadChannelsObjArray),
+ fBadChannelsIntArray(prep.fBadChannelsIntArray),
+ fBadChannelsIndexArray(prep.fBadChannelsIndexArray),
+ fBadChannelsContainer(prep.fBadChannelsContainer)
{
// Default copy constructor
// Notice that only pointer addresses are copied!
// Memory allocations of new objects are not done.
- fITSLoader = prep.fITSLoader;
- fRunLoader = prep.fRunLoader;
- fThresholdRatio = prep.fThresholdRatio;
- fThreshold = prep.fThreshold;
- fMaximumNumberOfEvents = prep.fMaximumNumberOfEvents;
- fHighestModuleNumber = prep.fHighestModuleNumber;
- fSelectedAlgorithm = prep.fSelectedAlgorithm;
- fGeometryMode = prep.fGeometryMode;
- fNumberOfBadChannels = prep.fNumberOfBadChannels;
- fInit = prep.fInit;
- fVMEMode = prep.fVMEMode;
- fDigitsHistogram = prep.fDigitsHistogram;
- fBadChannelsObjArray = prep.fBadChannelsObjArray;
- fBadChannelsIntArray = prep.fBadChannelsIntArray;
- fBadChannelsIndexArray = prep.fBadChannelsIndexArray;
- fBadChannelsContainer = prep.fBadChannelsContainer;
+
}
AliInfo("Storing bad channels");
- AliCDBEntry *entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSPD", runNumber);
+ if(!AliCDBManager::Instance()->IsDefaultStorageSet()) {
+ AliWarning("No storage set! Will use dummy one");
+ AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
+ }
+
+ AliCDBEntry *entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSPD", runNumber);
if(!entrySPD){
AliWarning("Calibration object retrieval failed! Dummy calibration will be used.");
+ AliCDBStorage *origStorage = AliCDBManager::Instance()->GetDefaultStorage();
+ AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
- AliCDBStorage *localStor = AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
- entrySPD = localStor->Get("ITS/Calib/CalibSPD", runNumber);
- if(!entrySPD){
- AliFatal("Cannot find SPD calibration entry!");
- return kFALSE;
- }
+ entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSPD", runNumber);
+ AliCDBManager::Instance()->SetDefaultStorage(origStorage);
}
TObjArray *respSPD = (TObjArray *)entrySPD->GetObject();
}
}
-
- AliCDBStorage *storage = AliCDBManager::Instance()->GetDefaultStorage();
- if(!storage) {
- AliWarning("No default storage set! Will use dummy one");
- storage = AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
- if(!storage) AliFatal("Could not even set dummy storage! Something very strange is happening...");
- }
-
- status = storage->Put(entrySPD);
+
+ AliCDBManager::Instance()->Put(entrySPD);
entrySPD->SetObject(NULL);
entrySPD->SetOwner(kTRUE);
delete entrySPD;
+ status=kTRUE;
return status;
}
ClassImp(AliITSRad)
//______________________________________________________________________
-AliITSRad::AliITSRad() {
+AliITSRad::AliITSRad():
+imax(0),
+jmax(0),
+fmrad1(0),
+fmrad2(0),
+fmrad3(0),
+fmrad4(0),
+fmrad5(0),
+fmrad6(0) {
// Default constructor
-
- fmrad1 = 0;
- fmrad2 = 0;
- fmrad3 = 0;
- fmrad4 = 0;
- fmrad5 = 0;
- fmrad6 = 0;
}
-AliITSRad::AliITSRad(Int_t iimax, Int_t jjmax) {
+AliITSRad::AliITSRad(Int_t iimax, Int_t jjmax):
+imax(0),
+jmax(0),
+fmrad1(0),
+fmrad2(0),
+fmrad3(0),
+fmrad4(0),
+fmrad5(0),
+fmrad6(0){
imax=iimax;
jmax=jjmax;
private:
+ AliITSRad(const AliITSRad &source); // copy constructor
+ // assignment operator
+ AliITSRad& operator=(const AliITSRad &source);
+
Int_t imax; // first dimension of the matrices
Int_t jmax; // second dimension of the matrices
////////////////////////////////////////////////////
ClassImp(AliITSRawCluster)
//______________________________________________________________________
- AliITSRawCluster::AliITSRawCluster(){
-// default constructor
- fMultiplicity = 0;
+ AliITSRawCluster::AliITSRawCluster():
+fMultiplicity(0){
+ // default constructor
}
//_____________________________________________________________________________
-AliITSInStream::AliITSInStream()
-{
+AliITSInStream::AliITSInStream():
+fStreamLen(0),
+fInStream(0){
//default constructor
- fStreamLen=0;
- fInStream=0;
}
//_____________________________________________________________________________
-AliITSInStream::AliITSInStream(UInt_t length)
-{
+AliITSInStream::AliITSInStream(UInt_t length):
+fStreamLen(length),
+fInStream(0){
//
// Creates a stream of unsigned chars
//
- fStreamLen = length;
- fInStream = new UChar_t[length];
-
+ fInStream = new UChar_t[length];
ClearStream();
}
}
//__________________________________________________________________________
-AliITSInStream::AliITSInStream(const AliITSInStream &source) : TObject(source){
+AliITSInStream::AliITSInStream(const AliITSInStream &source) : TObject(source),
+fStreamLen(source.fStreamLen),
+fInStream(source.fInStream){
// Copy Constructor
- if(&source == this) return;
- this->fStreamLen = source.fStreamLen;
- this->fInStream = source.fInStream;
- return;
+
}
//_________________________________________________________________________
//_______________________________________________________________________
- AliITSOutStream::AliITSOutStream() {
+AliITSOutStream::AliITSOutStream():
+fStreamLen(0),
+fOutStream(0){
//default constructor
- fStreamLen=0;
- fOutStream=0;
+
}
//__________________________________________________________________________
-AliITSOutStream::AliITSOutStream(UInt_t length) {
+AliITSOutStream::AliITSOutStream(UInt_t length):
+fStreamLen(length),
+fOutStream(0){
//
// Creates a stream of unsigned chars
//
- fStreamLen = length;
fOutStream = new UInt_t[length];
ClearStream();
}
//__________________________________________________________________________
-AliITSOutStream::AliITSOutStream(const AliITSOutStream &source):TObject(source){
+AliITSOutStream::AliITSOutStream(const AliITSOutStream &source):TObject(source),
+fStreamLen(source.fStreamLen),
+fOutStream(source.fOutStream){
// Copy Constructor
- if(&source == this) return;
- this->fStreamLen = source.fStreamLen;
- this->fOutStream = source.fOutStream;
- return;
+
}
//_________________________________________________________________________
ClassImp(AliITSRawStream)
-AliITSRawStream::AliITSRawStream(AliRawReader* rawReader)
+AliITSRawStream::AliITSRawStream(AliRawReader* rawReader):
+fRawReader(rawReader),
+fModuleID(-1),
+fPrevModuleID(-1),
+fCoord1(-1),
+fCoord2(-1),
+fSignal(-1)
{
// create an object to read ITS raw digits
- fRawReader = rawReader;
- fModuleID = fPrevModuleID = fCoord1 = fCoord2 = fSignal = -1;
}
AliITSRawStream::AliITSRawStream(const AliITSRawStream& stream) :
- TObject(stream)
+ TObject(stream),
+fRawReader(stream.fRawReader),
+fModuleID(stream.fModuleID),
+fPrevModuleID(stream.fPrevModuleID),
+fCoord1(stream.fCoord1),
+fCoord2(stream.fCoord2),
+fSignal(stream.fSignal)
{
- Fatal("AliITSRawStream", "copy constructor not implemented");
+ //copy constructor
}
AliITSRawStream& AliITSRawStream::operator = (const AliITSRawStream&
const UInt_t AliITSRawStreamSDD::fgkCodeLength[8] = {8, 18, 2, 3, 4, 5, 6, 7};
AliITSRawStreamSDD::AliITSRawStreamSDD(AliRawReader* rawReader) :
- AliITSRawStream(rawReader)
-{
+ AliITSRawStream(rawReader),
+fData(0),
+fSkip(0),
+fEventId(0),
+fCarlosId(0),
+fChannel(0),
+fJitter(0){
// create an object to read ITS SDD raw digits
- fData = 0;
- fSkip = 0;
- fEventId = 0;
- fCarlosId = 0;
- fChannel = 0;
- fJitter = 0;
for(Int_t i=0;i<2;i++){
fChannelData[i]=0;
fLastBit[i]=0;
AliITSRawStreamSSD::AliITSRawStreamSSD(AliRawReader* rawReader) :
- AliITSRawStream(rawReader)
+ AliITSRawStream(rawReader),
+fData(0)
{
// create an object to read ITS SSD raw digits
AliITSRawStreamSSDv1::AliITSRawStreamSSDv1(AliRawReader* rawReader) :
- AliITSRawStreamSSD(rawReader)
-{
+ AliITSRawStreamSSD(rawReader),
+fADModule(0),
+fADC(0){
// create an object to read ITS SSD raw digits
- fADC =0;
- fADModule=0;
fRawReader->SelectEquipment(17,102,102);
}
ClassImp(AliITSRecPoint)
//_____________________________________________________________
-AliITSRecPoint::AliITSRecPoint(): AliCluster() {
+AliITSRecPoint::AliITSRecPoint(): AliCluster(),
+fXloc(0),
+fZloc(0),
+fdEdX(0),
+fIndex(0),
+fQ(0),
+fLayer(0),
+fNz(0),
+fNy(0),
+fChargeRatio(0),
+fType(0),
+fDeltaProb(0),
+fGeom(0){
// default creator
- fXloc=fZloc=fdEdX=0.;
- fQ=0; fLayer=0; fNz=fNy=1; fType=0; fDeltaProb=0;fChargeRatio=0;
- fGeom=0;
}
//_____________________________________________________________
-AliITSRecPoint::AliITSRecPoint(AliITSgeom* geom): AliCluster() {
+AliITSRecPoint::AliITSRecPoint(AliITSgeom* geom): AliCluster(),
+fXloc(0),
+fZloc(0),
+fdEdX(0),
+fIndex(0),
+fQ(0),
+fLayer(0),
+fNz(0),
+fNy(0),
+fChargeRatio(0),
+fType(0),
+fDeltaProb(0),
+fGeom(geom) {
// default creator
- fXloc=fZloc=fdEdX=0.;
- fQ=0; fLayer=0; fNz=fNy=1; fType=0; fDeltaProb=0;fChargeRatio=0;
- fGeom=geom;
+
}
//________________________________________________________________________
-AliITSRecPoint::AliITSRecPoint(Int_t module,AliITSgeom* geom,Int_t *lab,Float_t *hit, Int_t *info):AliCluster(lab,hit){
+AliITSRecPoint::AliITSRecPoint(Int_t module,AliITSgeom* geom,Int_t *lab,Float_t *hit, Int_t *info):AliCluster(lab,hit),
+fXloc(0),
+fZloc(0),
+fdEdX(0),
+fIndex(lab[3]),
+fQ(hit[4]),
+fLayer(info[2]),
+fNz(info[1]),
+fNy(info[0]),
+fChargeRatio(0),
+fType(0),
+fDeltaProb(0),
+fGeom(geom)
+{
//standard constructor used in AliITSClusterFinderV2
- fIndex=lab[3];
- fQ=hit[4];
- fNy = info[0];
- fNz = info[1];
- fLayer = info[2];
- fChargeRatio = 0;
+
+
fType=0;
fDeltaProb=0.;
}
//_______________________________________________________________________
-AliITSRecPoint::AliITSRecPoint(const AliITSRecPoint& pt):AliCluster(pt){
+AliITSRecPoint::AliITSRecPoint(const AliITSRecPoint& pt):AliCluster(pt),
+fXloc(pt.fXloc),
+fZloc(pt.fZloc),
+fdEdX(pt.fdEdX),
+fIndex(pt.fIndex),
+fQ(pt.fQ),
+fLayer(pt.fLayer),
+fNz(pt.fNz),
+fNy(pt.fNy),
+fChargeRatio(pt.fChargeRatio),
+fType(pt.fType),
+fDeltaProb(pt.fDeltaProb),
+fGeom(pt.fGeom){
//Copy constructor
- fXloc = pt.fXloc;
- fZloc = pt.fZloc;
- fdEdX = pt.fdEdX;
- fIndex= pt.fIndex;
- fQ = pt.fQ;
- fNy = pt.fNy;
- fNz = pt.fNz;
- fLayer = pt.fLayer;
- fChargeRatio = pt.fChargeRatio;
- fType = pt.fType;
- fDeltaProb = pt.fDeltaProb;
- fGeom = pt.fGeom;
}
//______________________________________________________________________
-AliITSRecPoint& AliITSRecPoint::operator=(const AliITSRecPoint& /* source */){
+AliITSRecPoint& AliITSRecPoint::operator=(const AliITSRecPoint& source){
// Assignment operator
- // Assignment is not allowed. The method is protected to avoid misuse.
- Fatal("= operator","Assignment operator not allowed\n");
+
+ this->~AliITSRecPoint();
+ new(this) AliITSRecPoint(source);
return *this;
+
}
//________________________________________________________________________
-AliITSRecPoint::AliITSRecPoint(Int_t *lab,Float_t *hit, Int_t *info):AliCluster(lab,hit){
+AliITSRecPoint::AliITSRecPoint(Int_t *lab,Float_t *hit, Int_t *info):AliCluster(lab,hit),
+fXloc(0),
+fZloc(0),
+fdEdX(0),
+fIndex(lab[3]),
+fQ(hit[4]),
+fLayer(info[2]),
+fNz(info[1]),
+fNy(info[0]),
+fChargeRatio(0),
+fType(0),
+fDeltaProb(0),
+fGeom(0){
//standard constructor used in AliITSClusterFinderV2
- fXloc=fZloc=fdEdX=0.;
- fIndex=lab[3];
- fQ=hit[4];
- fNy = info[0];
- fNz = info[1];
- fLayer = info[2];
- fChargeRatio = 0;
- fType=0;
- fDeltaProb=0.;
- fGeom = 0;
}
//----------------------------------------------------------------------
//______________________________________________________________________
AliITSTransientDigit::AliITSTransientDigit(Float_t phys,const Int_t *digits):
- AliITSdigitSDD(phys,digits) {
+ AliITSdigitSDD(phys,digits),
+fTrackList(0) {
// Creates a digit object in a list of digits to be updated
fTrackList = new TObjArray;
}
//__________________________________________________________________________
AliITSTransientDigit::AliITSTransientDigit(const AliITSTransientDigit &source):
- AliITSdigitSDD(source){
+ AliITSdigitSDD(source),
+fTrackList(source.fTrackList){
// Copy Constructor
- if(&source == this) return;
- this->fTrackList = source.fTrackList;
- return;
}
//_________________________________________________________________________
AliITSTransientDigit& AliITSTransientDigit::operator=(
const AliITSTransientDigit &source) {
// Assignment operator
- if(&source == this) return *this;
- this->fTrackList = source.fTrackList;
- return *this;
+ this->~AliITSTransientDigit();
+ new(this) AliITSTransientDigit(source);
+ return *this;
+
}
//______________________________________________________________________
void AliITSTransientDigit::Print(ostream *os){
class AliITSTransientDigit : public AliITSdigitSDD {
public:
- AliITSTransientDigit() {/*default constructor*/fTrackList=0;}
+ AliITSTransientDigit() : fTrackList(0) {}
// Standard constructor with digits and "phys"
AliITSTransientDigit(Float_t phys,const Int_t *digits);
virtual ~AliITSTransientDigit(){/*destructor delets TObjArray fTracklist */
ClassImp(AliITSclusterSSD)
//______________________________________________________________________
-AliITSclusterSSD::AliITSclusterSSD(){
+AliITSclusterSSD::AliITSclusterSSD():
+fSide(kTRUE),
+fDigits(0),
+fNDigits(0),
+fDigitsIndex(0),
+fNCrosses(0),
+fCrossedClusterIndexes(0),
+fLeftNeighbour(kFALSE),
+fRightNeighbour(kFALSE),
+fConsumed(kFALSE),
+fTotalSignal(-1),
+fNTracks(-1){
// default constructor
-
- fSide = kTRUE;
- fDigits = 0;
- fNDigits = 0;
- fDigitsIndex = 0;
- fNCrosses = 0;
- fTotalSignal = -1;
- fNTracks = -1;
- fLeftNeighbour = kFALSE;
- fRightNeighbour = kFALSE;
- fCrossedClusterIndexes = 0;
- fConsumed=kFALSE;
}
//______________________________________________________________________
AliITSclusterSSD::AliITSclusterSSD(Int_t ndigits, Int_t *DigitIndexes,
- TObjArray *Digits, Bool_t side){
+ TObjArray *Digits, Bool_t side):
+fSide(side),
+fDigits(Digits),
+fNDigits(ndigits),
+fDigitsIndex(0),
+fNCrosses(0),
+fCrossedClusterIndexes(0),
+fLeftNeighbour(kFALSE),
+fRightNeighbour(kFALSE),
+fConsumed(kFALSE),
+fTotalSignal(-1),
+fNTracks(-1){
// non-default constructor
- fNDigits = ndigits;
- fDigits = Digits;
- fSide = side;
fDigitsIndex = new TArrayI(fNDigits,DigitIndexes );
- fNCrosses = 0;
fCrossedClusterIndexes = new TArrayI(300);
- fLeftNeighbour = kFALSE;
- fRightNeighbour = kFALSE;
- fTotalSignal =-1;
- fNTracks = -1;
- fConsumed=kFALSE;
}
//______________________________________________________________________
AliITSclusterSSD::~AliITSclusterSSD(){
}
//______________________________________________________________________
AliITSclusterSSD::AliITSclusterSSD(const AliITSclusterSSD &OneSCluster) :
- TObject(OneSCluster){
+TObject(OneSCluster),
+fSide(OneSCluster.fSide),
+fDigits(OneSCluster.fDigits),
+fNDigits(OneSCluster.fNDigits),
+fDigitsIndex(0),
+fNCrosses(OneSCluster.fNCrosses),
+fCrossedClusterIndexes(0),
+fLeftNeighbour(OneSCluster.fLeftNeighbour),
+fRightNeighbour(OneSCluster.fRightNeighbour),
+fConsumed(OneSCluster.fConsumed),
+fTotalSignal(-1),
+fNTracks(-1){
// copy constructor
- if (this == &OneSCluster) return;
- fNDigits = OneSCluster.fNDigits;
- fSide=OneSCluster.fSide;
- fDigits=OneSCluster.fDigits;
fDigitsIndex = new TArrayI(fNDigits);
- fLeftNeighbour = OneSCluster.fLeftNeighbour;
- fRightNeighbour = OneSCluster.fRightNeighbour;
fTotalSignal =-1;
fNTracks = -1;
- fNCrosses = OneSCluster.fNCrosses;
- fConsumed = OneSCluster.fConsumed;
Int_t i;
for (i = 0; i< fNCrosses ; i++){
fCrossedClusterIndexes[i] = OneSCluster.fCrossedClusterIndexes[i];
#include "AliITSclusterV2.h"
ClassImp(AliITSclusterV2)
+//_______________________________________________________
+AliITSclusterV2::AliITSclusterV2() : AliCluster(),
+fIndex(0),
+fQ(0),
+fLayer(0),
+fNz(0),
+fNy(0),
+fChargeRatio(0),
+fType(0),
+fDeltaProb(0) {
+ //default constructor
+}
+
+//_______________________________________________________
+AliITSclusterV2::AliITSclusterV2(Int_t *lab,Float_t *hit, Int_t *info) : AliCluster(lab,hit),
+fIndex(lab[3]),
+fQ(hit[4]),
+fLayer(info[2]),
+fNz(info[1]),
+fNy(info[0]),
+fChargeRatio(0),
+fType(0),
+fDeltaProb(0){
+ //standard constructor
+}
//_____________________________________________________________________________
class AliITSclusterV2 : public AliCluster {
public:
- AliITSclusterV2() : AliCluster() {
- fQ=0; fLayer=0; fNz=fNy=1; fType=0; fDeltaProb=0;
- }
- AliITSclusterV2(Int_t *lab,Float_t *hit, Int_t *info) : AliCluster(lab,hit) {
- fIndex=lab[3];
- fQ=hit[4];
- fNy = info[0];
- fNz = info[1];
- fLayer = info[2];
- fChargeRatio = 0;
- fType=0;
- fDeltaProb=0.;
- }
-
+ AliITSclusterV2();
+ AliITSclusterV2(Int_t *lab,Float_t *hit, Int_t *info);
void Use(Int_t = 0) {fQ=-fQ;}
void UnUse() {fQ=TMath::Abs(fQ);}
void SetQ(Float_t q) {fQ=q;}
extern AliRun *gAlice;
-AliITSclustererV2::AliITSclustererV2(const AliITSgeom *geom) {
+AliITSclustererV2::AliITSclustererV2():
+fNModules(0),
+fEvent(0),
+fI(0),
+fLastSPD1(0),
+fNySPD(0),
+fNzSPD(0),
+fYpitchSPD(0),
+fZ1pitchSPD(0),
+fZ2pitchSPD(0),
+fHwSPD(0),
+fHlSPD(0),
+fNySDD(0),
+fNzSDD(0),
+fYpitchSDD(0),
+fZpitchSDD(0),
+fHwSDD(0),
+fHlSDD(0),
+fYoffSDD(0),
+fLastSSD1(0),
+fYpitchSSD(0),
+fHwSSD(0),
+fHlSSD(0),
+fTanP(0),
+fTanN(0){
+ //default constructor
+ }
+AliITSclustererV2::AliITSclustererV2(const AliITSgeom *geom):
+fNModules(0),
+fEvent(0),
+fI(0),
+fLastSPD1(0),
+fNySPD(256),
+fNzSPD(160),
+fYpitchSPD(0.0050),
+fZ1pitchSPD(0.0425),
+fZ2pitchSPD(0.0625),
+fHwSPD(0.64),
+fHlSPD(3.48),
+fNySDD(256),
+fNzSDD(256),
+fYpitchSDD(0.01825),
+fZpitchSDD(0.02940),
+fHwSDD(3.5085),
+fHlSDD(3.7632),
+fYoffSDD(0.0425),
+fLastSSD1(0),
+fYpitchSSD(0.0095),
+fHwSSD(3.65),
+fHlSSD(2.00),
+fTanP(0.0275),
+fTanN(0.0075) {
//------------------------------------------------------------
// Standard constructor
//------------------------------------------------------------
AliITSgeom *g=(AliITSgeom*)geom;
- fEvent=0;
- fI=0;
-
Int_t mmax=geom->GetIndexMax();
if (mmax>2200) {
Fatal("AliITSclustererV2","Too many ITS subdetectors !");
//SPD geometry
fLastSPD1=g->GetModuleIndex(2,1,1)-1;
- fNySPD=256; fNzSPD=160;
- fYpitchSPD=0.0050;
- fZ1pitchSPD=0.0425; fZ2pitchSPD=0.0625;
- fHwSPD=0.64; fHlSPD=3.48;
fYSPD[0]=0.5*fYpitchSPD;
for (m=1; m<fNySPD; m++) fYSPD[m]=fYSPD[m-1]+fYpitchSPD;
fZSPD[0]=fZ1pitchSPD;
fZSPD[m]-=dz;
}
- //SDD geometry
- fNySDD=256; fNzSDD=256;
- fYpitchSDD=0.01825;
- fZpitchSDD=0.02940;
- fHwSDD=3.5085; fHlSDD=3.7632;
- fYoffSDD=0.0425;
-
//SSD geometry
fLastSSD1=g->GetModuleIndex(6,1,1)-1;
- fYpitchSSD=0.0095;
- fHwSSD=3.65;
- fHlSSD=2.00;
- fTanP=0.0275;
- fTanN=0.0075;
}
class AliITSclustererV2 : public TObject {
public:
- AliITSclustererV2(){ fEvent=0; fI=0;}
+ AliITSclustererV2();
AliITSclustererV2(const AliITSgeom *geom);
void SetEvent(Int_t event) { fEvent=event; }
};
class AliBin {
public:
- AliBin() {fIndex=0; fQ=0; fMask=0xFFFFFFFE;}
+ AliBin():fIndex(0),fMask(0xFFFFFFFE),fQ(0) {}
void SetIndex(UInt_t idx) {fIndex=idx;}
void SetQ(UShort_t q) {fQ=q;}
void SetMask(UInt_t m) {fMask=m;}
#include "AliITSdigit.h"
+
//______________________________________________________________________
ClassImp(AliITSdigit)
-AliITSdigit::AliITSdigit(const Int_t *digits) {
+
+AliITSdigit::AliITSdigit():
+fCoord1(0),
+fCoord2(0),
+fSignal(0){
+ //default constructor. zero all values.
+}
+
+
+AliITSdigit::AliITSdigit(const Int_t *digits):
+fCoord1(digits[0]),
+fCoord2(digits[1]),
+fSignal(digits[2]){
// Creates a real data digit object
- fCoord1 = digits[0];
- fCoord2 = digits[1];
- fSignal = digits[2];
}
//______________________________________________________________________
void AliITSdigit::Print(ostream *os) {
class TArrayI;
class TArrayF;
+
//______________________________________________________________________
class AliITSdigit: public TObject {
public:
- AliITSdigit() {//default constructor. zero all values.
- fSignal=fCoord1=fCoord2=0;}
+ AliITSdigit();
//Standard Constructor. Fills class from array digits
AliITSdigit(const Int_t *digits);
//Destructor
//______________________________________________________________________
-AliITSdigitSDD::AliITSdigitSDD():AliITSdigit(){
+AliITSdigitSDD::AliITSdigitSDD():AliITSdigit(),
+fPhysics(0),
+fSignalExpanded(0){
// default constructor, zero coordinates and set array
// elements to clearly unphysical values. A value of 0 may
// be a valide track of hit number.
for(i=0;i<fgkSsdd;i++) fTracks[i] = -3;
for(i=0;i<fgkSsdd;i++) fHits[i] = -1;
- fPhysics = 0;
for(i=0;i<fgkSsdd;i++) fTcharges[i] = 0;
SetSignalExpanded(-1000);
}
//________________________________________________________________________
-AliITSdigitSDD::AliITSdigitSDD(Float_t phys,const Int_t *digits): AliITSdigit(digits){
+AliITSdigitSDD::AliITSdigitSDD(Float_t phys,const Int_t *digits): AliITSdigit(digits),
+fPhysics(phys),
+fSignalExpanded(0){
// Creates a simulated SDD digit object to be updated
- fPhysics = phys;
SetSignalExpanded(-1000);
}
//_____________________________________________________________________________
AliITSdigitSDD::AliITSdigitSDD(Float_t phys,const Int_t *digits,
const Int_t *tracks,const Int_t *hits,
- const Float_t *charges):AliITSdigit(digits){
+ const Float_t *charges):AliITSdigit(digits),
+fPhysics(0),
+fSignalExpanded(0){
// standard constructor
InitObject(phys,tracks,hits,charges);
}
//_____________________________________________________________________________
AliITSdigitSDD::AliITSdigitSDD( Float_t phys,const Int_t *digits,
- const Int_t *tracks,const Int_t *hits,const Float_t *charges, Int_t sige): AliITSdigit(digits) {
+ const Int_t *tracks,const Int_t *hits,const Float_t *charges, Int_t sige): AliITSdigit(digits),
+fPhysics(0),
+fSignalExpanded(0){
//constructor setting also fSignalExpanded
InitObject(phys,tracks,hits,charges);
//_____________________________________________________________________________
AliITSdigitSDD::AliITSdigitSDD( Float_t phys,const Int_t *digits,
const Int_t *tracks,const Int_t *hits,const Float_t *charges,
- AliITSCalibrationSDD* resp): AliITSdigit(digits) {
+ AliITSCalibrationSDD* resp): AliITSdigit(digits),
+fPhysics(0),
+fSignalExpanded(0){
//constructor setting fSignalExpanded through AliITSCalibrationSDD
InitObject(phys,tracks,hits,charges);
ClassImp(AliITSdigitSPD)
//______________________________________________________________________
-AliITSdigitSPD::AliITSdigitSPD():AliITSdigit(){
+AliITSdigitSPD::AliITSdigitSPD():AliITSdigit(),
+fSignalSPD(0){
// default constructor, zero coordinates and set array
// elements to clearly unphysical values. A value of 0 may
// be a valide track of hit number.
for(i=0;i<fgkSspd;i++) fHits[i] = -1;
}
//______________________________________________________________________
-AliITSdigitSPD::AliITSdigitSPD(const Int_t *digits){
+AliITSdigitSPD::AliITSdigitSPD(const Int_t *digits):
+fSignalSPD(digits[2]){
// Creates a SPD digit object
Int_t i;
fCoord1 = digits[0];
fCoord2 = digits[1];
fSignal = 1;
- fSignalSPD = digits[2];
-}
+ }
//______________________________________________________________________
AliITSdigitSPD::AliITSdigitSPD(const Int_t *digits,const Int_t *tracks,
- const Int_t *hits){
+ const Int_t *hits):
+fSignalSPD(digits[2]){
// Creates a simulated SPD digit object
for(Int_t i=0; i<fgkSspd; i++) {
fCoord1 = digits[0];
fCoord2 = digits[1];
fSignal = 1;
- fSignalSPD = digits[2];
}
//______________________________________________________________________
Int_t AliITSdigitSPD::GetListOfTracks(TArrayI &t){
fShape.SetOwner(kTRUE);
return;
}
+
//______________________________________________________________________
AliITSgeom::AliITSgeom(Int_t itype,Int_t nlayers,const Int_t *nlads,
const Int_t *ndets,Int_t mods):
}
//______________________________________________________________________
-AliITSgeom::AliITSgeom(const AliITSgeom &source) : TObject(source){
+AliITSgeom::AliITSgeom(const AliITSgeom &source) : TObject(source),
+fVersion(source.fVersion),
+fTrans(source.fTrans),
+fNmodules(source.fNmodules),
+fNlayers(source.fNlayers),
+fNlad(source.fNlad),
+fNdet(source.fNdet),
+fGm(source.fGm),
+fShape(source.fShape)
+{
// The copy constructor for the AliITSgeom class. It calls the
// = operator function. See the = operator function for more details.
// Inputs:
// Return:
// none.
- *this = source; // Just use the = operator for now.
- return;
+ *this = source; // Just use the = operator for now.
+ return;
}
//______________________________________________________________________
AliITSgeom(const char *filename); // Constructor
AliITSgeom(Int_t itype,Int_t nlayers,const Int_t *nlads,const Int_t *ndets,
Int_t nmods); // Constructor
+ AliITSgeom(const AliITSgeom &source); // Copy constructor
+ AliITSgeom& operator=(const AliITSgeom &source);// = operator
virtual ~AliITSgeom(); // Default destructor
// Zero and reinitilizes this class.
void Init(Int_t itype,Int_t nlayers,const Int_t *nlads,
void TrackingV2ToDetL(Int_t md,Float_t yin,Float_t zin,Float_t &xout,Float_t &zout);
- protected:
- AliITSgeom(const AliITSgeom &source); // Copy constructor
- AliITSgeom& operator=(const AliITSgeom &source);// = operator
private:
TString fVersion; // Transformation version.
}// end for i
fm[0][0] = fm[1][1] = fm[2][2] = 1.0;
}
-/*
+
//----------------------------------------------------------------------
-AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &sourse) :
- TObject(sourse){
+AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &source) :
+ TObject(source),
+fDetectorIndex(source.fDetectorIndex),
+fCylR(source.fCylR),
+fCylPhi(source.fCylPhi),
+fPath(source.fPath){
// The standard Copy constructor. This make a full / proper copy of
// this class.
// Inputs:
// Return:
// A copy constructes AliITSgeomMatrix class.
Int_t i,j;
-
- this->fDetectorIndex = sourse.fDetectorIndex;
for(i=0;i<3;i++){
- this->fid[i] = sourse.fid[i];
- this->frot[i] = sourse.frot[i];
- this->ftran[i] = sourse.ftran[i];
- this->fCylR = sourse.fCylR;
- this->fCylPhi = sourse.fCylPhi;
- for(j=0;j<3;j++) this->fm[i][j] = sourse.fm[i][j];
+ this->fid[i] = source.fid[i];
+ this->frot[i] = source.frot[i];
+ this->ftran[i] = source.ftran[i];
+ for(j=0;j<3;j++) this->fm[i][j] = source.fm[i][j];
}// end for i
- this->fPath = sourse.fPath;
}
//----------------------------------------------------------------------
-void AliITSgeomMatrix::operator=(const AliITSgeomMatrix &sourse){
+AliITSgeomMatrix& AliITSgeomMatrix::operator=(const AliITSgeomMatrix &source){
// The standard = operator. This make a full / proper copy of
// this class.
// The standard Copy constructor. This make a full / proper copy of
// none.
// Return:
// A copy of the source AliITSgeomMatrix class.
- Int_t i,j;
+ if(this == &source)return *this;
+ Int_t i,j;
- this->fDetectorIndex = sourse.fDetectorIndex;
- for(i=0;i<3;i++){
- this->fid[i] = sourse.fid[i];
- this->frot[i] = sourse.frot[i];
- this->ftran[i] = sourse.ftran[i];
- this->fCylR = sourse.fCylR;
- this->fCylPhi = sourse.fCylPhi;
- for(j=0;j<3;j++) this->fm[i][j] = sourse.fm[i][j];
- }// end for i
- this->fPath = sourse.fPath;
+ this->fDetectorIndex = source.fDetectorIndex;
+ this->fCylR = source.fCylR;
+ this->fCylPhi = source.fCylPhi;
+ for(i=0;i<3;i++){
+ this->fid[i] = source.fid[i];
+ this->frot[i] = source.frot[i];
+ this->ftran[i] = source.ftran[i];
+
+ for(j=0;j<3;j++) this->fm[i][j] = source.fm[i][j];
+ }
+ this->fPath = source.fPath;
+ return *this;
}
-*/
+
//----------------------------------------------------------------------
AliITSgeomMatrix::AliITSgeomMatrix(Int_t idt,const Int_t id[3],
const Double_t rot[3],const Double_t tran[3]):
AliITSgeomMatrix(const Double_t rotd[6]/*degrees GEANT angles*/,
Int_t idt,const Int_t id[3],
const Double_t tran[3]);
+ // Copy constructor
+ AliITSgeomMatrix(const AliITSgeomMatrix &source);
+ // Assignment operator
+ AliITSgeomMatrix& operator=(const AliITSgeomMatrix &source);
virtual ~AliITSgeomMatrix(){}; // default constructor.
// Prints a line describing the output format of the function Print.
void PrintComment(ostream *os) const;
void MakeFigures() const;
//
private: // private functions
- // Copy constructor
- AliITSgeomMatrix(const AliITSgeomMatrix &source);
- // Assignment operator
- void operator=(const AliITSgeomMatrix &sourse); // copy
// Given the rotation matrix fm it fills the rotation angles frot
void MatrixFromAngle();
// Given the rotation angles frot it fills the rotation matrix fm
fAnodeLowEdgeR = 0;
}
//________________________________________________________________________
-AliITSgeomSDD::AliITSgeomSDD(AliITSgeomSDD &source) : TObject(source){
- // Copy constructor
- Int_t i;
-
- if(this==&source) return;
- fName=source.fName;
- fTitle=source.fTitle;
- fMat=source.fMat;
- fDx=source.fDx;
- fDy=source.fDy;
- fDz=source.fDz;
- this->fPeriod = source.fPeriod;
- this->fDvelocity = source.fDvelocity;
- this->fNAnodesL = source.fNAnodesL;
- this->fNAnodesR = source.fNAnodesR;
- this->fAnodeXL = source.fAnodeXL;
- this->fAnodeXR = source.fAnodeXR;
- if(fAnodeLowEdgeL!=0) delete fAnodeLowEdgeL;
- this->fAnodeLowEdgeL = new Float_t[fNAnodesL];
- if(fAnodeLowEdgeR!=0) delete fAnodeLowEdgeR;
- this->fAnodeLowEdgeR = new Float_t[fNAnodesR];
- for(i=0;i<fNAnodesL;i++)this->fAnodeLowEdgeL[i] = source.fAnodeLowEdgeL[i];
- for(i=0;i<fNAnodesR;i++)this->fAnodeLowEdgeR[i] = source.fAnodeLowEdgeR[i];
- return;
+AliITSgeomSDD::AliITSgeomSDD(AliITSgeomSDD &source) : TObject(source),
+fPeriod(source.fPeriod),
+fDvelocity(source.fDvelocity),
+fNAnodesL(source.fNAnodesL),
+fNAnodesR(source.fNAnodesR),
+fAnodeXL(source.fAnodeXL),
+fAnodeXR(source.fAnodeXR),
+fAnodeLowEdgeL(0),
+fAnodeLowEdgeR(0),
+fName(source.fName),
+fTitle(source.fTitle),
+fMat(source.fMat),
+fDx(source.fDx),
+fDy(source.fDy),
+fDz(source.fDz){
+ // Copy constructor
+ fAnodeLowEdgeL = new Float_t[fNAnodesL];
+ fAnodeLowEdgeR = new Float_t[fNAnodesR];
+ for(Int_t i=0;i<fNAnodesL;i++) fAnodeLowEdgeL[i] = source.fAnodeLowEdgeL[i];
+ for(Int_t i=0;i<fNAnodesR;i++) fAnodeLowEdgeR[i] = source.fAnodeLowEdgeR[i];
+
}
//________________________________________________________________________
AliITSgeomSDD& AliITSgeomSDD::operator=(AliITSgeomSDD &source){
// = operator
- Int_t i;
- if(this==&source) return *this;
- fName=source.fName;
- fTitle=source.fTitle;
- fMat=source.fMat;
- fDx=source.fDx;
- fDy=source.fDy;
- fDz=source.fDz;
- this->fPeriod = source.fPeriod;
- this->fDvelocity = source.fDvelocity;
- this->fNAnodesL = source.fNAnodesL;
- this->fNAnodesR = source.fNAnodesR;
- this->fNAnodesR = source.fNAnodesR;
- this->fAnodeXL = source.fAnodeXL;
- this->fAnodeXR = source.fAnodeXR;
- if(fAnodeLowEdgeL!=0) delete fAnodeLowEdgeL;
- this->fAnodeLowEdgeL = new Float_t[fNAnodesL];
- if(fAnodeLowEdgeR!=0) delete fAnodeLowEdgeR;
- this->fAnodeLowEdgeR = new Float_t[fNAnodesR];
- for(i=0;i<fNAnodesL;i++)this->fAnodeLowEdgeL[i] = source.fAnodeLowEdgeL[i];
- for(i=0;i<fNAnodesR;i++)this->fAnodeLowEdgeR[i] = source.fAnodeLowEdgeR[i];
- return *this;
+ this->~AliITSgeomSDD();
+ new(this) AliITSgeomSDD(source);
+ return *this;
+
}
//______________________________________________________________________
void AliITSgeomSDD::Local2Det(Float_t xl,Float_t zl,Int_t &a,Int_t &t,Int_t &s){
return;
}
//______________________________________________________________________
-AliITSgeomSPD::AliITSgeomSPD(AliITSgeomSPD &source) : TObject(source){
+AliITSgeomSPD::AliITSgeomSPD(AliITSgeomSPD &source) : TObject(source),
+fName(source.fName),
+fTitle(source.fTitle),
+fMat(source.fMat),
+fDx(source.fDx),
+fDy(source.fDy),
+fDz(source.fDz),
+fNbinx(source.fNbinx),
+fNbinz(source.fNbinz),
+fLowBinEdgeX(0),
+fLowBinEdgeZ(0){
// Copy constructor
+ InitLowBinEdgeX();
+ InitLowBinEdgeZ();
+ for(Int_t i=0;i<fNbinx;i++) fLowBinEdgeX[i] = source.fLowBinEdgeX[i];
+ for(Int_t i=0;i<fNbinz;i++) fLowBinEdgeZ[i] = source.fLowBinEdgeZ[i];
- *this = source; // just use the = operator for now.
- return;
+
}
//______________________________________________________________________
AliITSgeomSPD& AliITSgeomSPD::operator=(AliITSgeomSPD &source){
// = operator
- Int_t i;
-
- if(&source == this) return *this;
- fName=source.fName;
- fTitle=source.fTitle;
- fMat=source.fMat;
- fDx=source.fDx;
- fDy=source.fDy;
- fDz=source.fDz;
- if(this->fLowBinEdgeX) delete[] (this->fLowBinEdgeX);
- if(this->fLowBinEdgeZ) delete[] (this->fLowBinEdgeZ);
- this->fNbinx = source.fNbinx;
- this->fNbinz = source.fNbinz;
- this->InitLowBinEdgeX();
- this->InitLowBinEdgeZ();
- for(i=0;i<fNbinx;i++) this->fLowBinEdgeX[i] = source.fLowBinEdgeX[i];
- for(i=0;i<fNbinz;i++) this->fLowBinEdgeZ[i] = source.fLowBinEdgeZ[i];
- return *this;
+ this->~AliITSgeomSPD();
+ new(this) AliITSgeomSPD(source);
+ return *this;
}
//______________________________________________________________________
AliITSgeomSPD::~AliITSgeomSPD(){
fAngleN = 0.0;
}
//______________________________________________________________________
-AliITSgeomSSD::AliITSgeomSSD(const AliITSgeomSSD &source) : TObject(source){
+AliITSgeomSSD::AliITSgeomSSD(const AliITSgeomSSD &source) : TObject(source),
+fName(source.fName),fTitle(source.fTitle),fMat(source.fMat),fDx(source.fDx),fDy(source.fDy),fDz(source.fDz),fNp(source.fNp),fNn(source.fNn),fLowEdgeP(0),fLowEdgeN(0),fAngleP(source.fAngleP),fAngleN(source.fAngleN){
////////////////////////////////////////////////////////////////////////
// copy constructor
////////////////////////////////////////////////////////////////////////
Int_t i;
- if(this == &source) return;
- fName = source.fName;
- fTitle = source.fTitle;
- fMat = source.fMat;
- fDx = source.fDx;
- fDy = source.fDy;
- fDz = source.fDz;
- this->fNp = source.fNp;
- this->fNn = source.fNn;
- delete fLowEdgeP;
- delete fLowEdgeN;
- this->fAngleP = source.fAngleP;
- this->fAngleN = source.fAngleN;
fLowEdgeP = new Float_t[fNp];
fLowEdgeN = new Float_t[fNn];
for(i=0;i<fNp;i++) this->fLowEdgeP[i] = source.fLowEdgeP[i];
////////////////////////////////////////////////////////////////////////
// assignment operator
////////////////////////////////////////////////////////////////////////
- Int_t i;
- if(this == &source) return *this;
- fName = source.fName;
- fTitle = source.fTitle;
- fMat = source.fMat;
- fDx = source.fDx;
- fDy = source.fDy;
- fDz = source.fDz;
- this->fNp = source.fNp;
- this->fNn = source.fNn;
- delete fLowEdgeP;
- delete fLowEdgeN;
- this->fAngleP = source.fAngleP;
- this->fAngleN = source.fAngleN;
- fLowEdgeP = new Float_t[fNp];
- fLowEdgeN = new Float_t[fNn];
- for(i=0;i<fNp;i++) this->fLowEdgeP[i] = source.fLowEdgeP[i];
- for(i=0;i<fNn;i++) this->fLowEdgeN[i] = source.fLowEdgeN[i];
- return *this;
+ this->~AliITSgeomSSD();
+ new(this) AliITSgeomSSD(source);
+ return *this;
+
}
//______________________________________________________________________
void AliITSgeomSSD::Local2Det(Float_t x,Float_t z,Int_t &a,Int_t &c){
ClassImp(AliITSpList)
//______________________________________________________________________
-AliITSpList::AliITSpList(){
+AliITSpList::AliITSpList():
+fNi(0),
+fNj(0),
+fa(0),
+fEntries(0){
// Default constructor
// Inputs:
// none.
// Return:
// A zeroed/empty AliITSpList class.
- fNi = 0;
- fNj = 0;
- fa = 0;
}
//______________________________________________________________________
-AliITSpList::AliITSpList(Int_t imax,Int_t jmax){
+AliITSpList::AliITSpList(Int_t imax,Int_t jmax):
+fNi(imax),
+fNj(jmax),
+fa(0),
+fEntries(0){
// Standard constructor
// Inputs:
// none.
// Return:
// A setup AliITSpList class.
- fNi = imax;
- fNj = jmax;
- fEntries = 0;
fa = new TClonesArray("AliITSpListItem",fNi*fNj);
}
//______________________________________________________________________
// Return:
// A copied AliITSpList object.
- if(this == &source) return *this;
-
- if(this->fa!=0){ // if this->fa exists delete it first.
- fa->Delete();
- delete fa;
- fa = 0;
- } // end if this->fa!=0
- this->fNi = source.fNi;
- this->fNj = source.fNj;
- this->fa = new TClonesArray(*(source.fa));
- this->fEntries = source.fEntries;
-
- return *this;
+ this->~AliITSpList();
+ new(this) AliITSpList(source);
+ return *this;
}
//______________________________________________________________________
-AliITSpList::AliITSpList(const AliITSpList &source) : AliITSMap(source){
+AliITSpList::AliITSpList(const AliITSpList &source) : AliITSMap(source),
+fNi(source.fNi),fNj(source.fNj),fa(0),fEntries(source.fEntries){
// Copy constructor
- fNi = source.fNi;
- fNj = source.fNj;
fa = new TClonesArray(*(source.fa));
- fEntries = source.fEntries;
}
//______________________________________________________________________
void AliITSpList::AddItemTo(Int_t fileIndex, AliITSpListItem *pl) {
//************************************************************************
ClassImp(AliITSpListItem)
//______________________________________________________________________
-AliITSpListItem::AliITSpListItem(){
+AliITSpListItem::AliITSpListItem():
+fmodule(-1),
+findex(-1),
+fTsignal(0.0),
+fNoise(0.0),
+fSignalAfterElect(0.0){
// Default constructor
// Inputs:
// none.
// Return:
// A zeroed/empty AliITSpListItem class.
- fmodule = -1;
- findex = -1;
for(Int_t i=0;i<this->fgksize;i++){
this->fTrack[i] = -2;
this->fHits[i] = -1;
this->fSignal[i] = 0.0;
} // end if i
- fTsignal = 0.0;
- fNoise = 0.0;
- fSignalAfterElect = 0.0;
}
//______________________________________________________________________
-AliITSpListItem::AliITSpListItem(Int_t module,Int_t index,Double_t noise){
+AliITSpListItem::AliITSpListItem(Int_t module,Int_t index,Double_t noise):
+fmodule(module),
+findex(index),
+fTsignal(0.0),
+fNoise(noise),
+fSignalAfterElect(0.0){
// Standard noise constructor
// Inputs:
// Int_t module The module where this noise occurred
// Return:
// A setup and noise filled AliITSpListItem class.
- this->fmodule = module;
- this->findex = index;
for(Int_t i=0;i<this->fgksize;i++){
this->fTrack[i] = -2;
this->fSignal[i] = 0.0;
this->fHits[i] = -1;
} // end if i
- this->fTsignal = 0.0;
- this->fSignalAfterElect = 0.0;
- this->fNoise = noise;
}
//______________________________________________________________________
AliITSpListItem::AliITSpListItem(Int_t track,Int_t hit,Int_t module,
- Int_t index,Double_t signal){
+ Int_t index,Double_t signal):
+fmodule(module),
+findex(index),
+fTsignal(signal),
+fNoise(0.0),
+fSignalAfterElect(0.0){
// Standard signal constructor
// Inputs:
// Int_t track The track number which produced this signal
// Return:
// A setup and signal filled AliITSpListItem class.
- this->fmodule = module;
- this->findex = index;
this->fTrack[0] = track;
this->fHits[0] = hit;
this->fSignal[0] = signal;
this->fSignal[i] = 0.0;
this->fHits[i] = -1;
} // end if i
- this->fTsignal = signal;
- this->fNoise = 0.0;
- this->fSignalAfterElect = 0.0;
}
//______________________________________________________________________
AliITSpListItem::~AliITSpListItem(){
// none.
// Return:
// A copied AliITSpListItem object
- Int_t i;
-
- if(this == &source) return *this;
+ this->~AliITSpListItem();
+ new(this) AliITSpListItem(source);
+ return *this;
- this->fmodule = source.fmodule;
- this->findex = source.findex;
- for(i=0;i<this->fgksize;i++){
- this->fTrack[i] = source.fTrack[i];
- this->fSignal[i] = source.fSignal[i];
- this->fHits[i] = source.fHits[i];
- } // end if i
- this->fTsignal = source.fTsignal;
- this->fNoise = source.fNoise;
- this->fSignalAfterElect = source.fSignalAfterElect;
- /*
- cout <<"this fTrack[0-9]=";
- for(i=0;i<this->fgksize;i++) cout <<this->fTrack[i]<<",";
- cout <<" fHits[0-9]=";
- for(i=0;i<this->fgksize;i++) cout <<this->fHits[i]<<",";
- cout <<" fSignal[0-9]=";
- for(i=0;i<this->fgksize;i++) cout <<this->fSignal[i]<<",";
- cout << endl;
- cout <<"source fTrack[0-9]=";
- for(i=0;i<this->fgksize;i++) cout <<source.fTrack[i]<<",";
- cout <<" fHits[0-9]=";
- for(i=0;i<this->fgksize;i++) cout <<source.fHits[i]<<",";
- cout <<" fSignal[0-9]=";
- for(i=0;i<this->fgksize;i++) cout <<source.fSignal[i]<<",";
- cout << endl;
- */
- return *this;
}
//______________________________________________________________________
-AliITSpListItem::AliITSpListItem(AliITSpListItem &source) : TObject(source){
+AliITSpListItem::AliITSpListItem(const AliITSpListItem &source) :
+TObject(source),
+fmodule(source.fmodule),
+findex(source.findex),
+fTsignal(source.fTsignal),
+fNoise(source.fNoise),
+fSignalAfterElect(source.fSignalAfterElect){
// Copy operator
// Inputs:
// AliITSpListItem &source A AliITSpListItem Object
// none.
// Return:
// A copied AliITSpListItem object
+
+ for(Int_t i=0;i<this->fgksize;i++){
+ this->fTrack[i] = source.fTrack[i];
+ this->fSignal[i] = source.fSignal[i];
+ this->fHits[i] = source.fHits[i];
+ } // end if i
- *this = source;
}
//______________________________________________________________________
void AliITSpListItem::AddSignal(Int_t track,Int_t hit,Int_t module,
// Class destrutor
virtual ~AliITSpListItem();
// Copy Oporator
- AliITSpListItem(AliITSpListItem &source);
+ AliITSpListItem(const AliITSpListItem &source);
// = Opoerator
virtual AliITSpListItem& operator=(const AliITSpListItem &source);
// Returns the signal value in the list of signals
//skowron@if.pw.edu.pl
//
//--------------------------------------------------------------------------
-AliITSpackageSSD::AliITSpackageSSD()
-{
+AliITSpackageSSD::AliITSpackageSSD():
+fClustersN(0),
+fClustersP(0),
+fNclustersN(0),
+fNclustersP(0),
+fClusterNIndexes(0),
+fClusterPIndexes(0){
// constructor
- fNclustersN=0;
- fClusterNIndexes = 0;
-
- fNclustersP=0;
- fClusterPIndexes = 0;
- if (fgkDebug) cout<<"Default Ctor was used\n>>>>>>>>>>>>>><<<<<<<<<<<<<";
}
/*******************************************************/
AliITSpackageSSD::AliITSpackageSSD
- (TClonesArray *clustersP, TClonesArray *clustersN)
-{
+(TClonesArray *clustersP, TClonesArray *clustersN):
+fClustersN(clustersN),
+fClustersP(clustersP),
+fNclustersN(0),
+fNclustersP(0),
+fClusterNIndexes(0),
+fClusterPIndexes(0){
// constructor
fClustersP=clustersP;
fClustersN=clustersN;
/*******************************************************/
-AliITSpackageSSD::AliITSpackageSSD
- ( Int_t len, TClonesArray *clustersP, TClonesArray *clustersN)
-{
+AliITSpackageSSD::AliITSpackageSSD(Int_t len, TClonesArray *clustersP, TClonesArray *clustersN):
+fClustersN(clustersN),
+fClustersP(clustersP),
+fNclustersN(0),
+fNclustersP(0),
+fClusterNIndexes(0),
+fClusterPIndexes(0){
// constructor
fClustersP=clustersP;
fClustersN=clustersN;
/*******************************************************/
AliITSpackageSSD::AliITSpackageSSD(const AliITSpackageSSD &package) :
- TObject(package){
+ TObject(package),
+fClustersN(package.fClustersN),
+fClustersP(package.fClustersP),
+fNclustersN(package.fNclustersN),
+fNclustersP(package.fNclustersP),
+fClusterNIndexes(0),
+fClusterPIndexes(0){
// copy constractor
Int_t i; //iterator
- if (this == &package) return;
- fClustersN = package.fClustersN;
- fClustersP = package.fClustersP;
-
- fNclustersN= package.fNclustersN;
- fNclustersP= package.fNclustersP;
-
for ( i =0; i<fNclustersN;i++)
{
fClusterNIndexes[i]= package.fClusterNIndexes[i];
fClusterPIndexes[i]= package.fClusterPIndexes[i];
}
- if (fgkDebug) cout << "Copying function was used\n<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>";
-
- return;
}
/*******************************************************/
ClassImp(AliITSresponseSPD)
//______________________________________________________________________
AliITSresponseSPD::AliITSresponseSPD():
- AliITSresponse(){
-
+ AliITSresponse(),
+fCouplCol(0),
+fCouplRow(0),
+fCouplOpt(0),
+fEccDiff(0){
// constructor
SetCouplingParam(fgkCouplingColDefault,fgkCouplingRowDefault);
ClassImp(AliITSresponseSSD)
//______________________________________________________________________
-AliITSresponseSSD::AliITSresponseSSD():AliITSresponse(){
+AliITSresponseSSD::AliITSresponseSSD():AliITSresponse(),
+fADCpereV(0),
+fCouplingPR(0),
+fCouplingPL(0),
+fCouplingNR(0),
+fCouplingNL(9),
+fZSThreshold(0),
+fOption1(),
+fOption2(){
// Default Constructor
SetDiffCoeff(fgkDiffCoeffDefault,0.);
}
//______________________________________________________________________
-AliITSresponseSSD::AliITSresponseSSD(const AliITSresponseSSD &ob) : AliITSresponse(ob) {
+AliITSresponseSSD::AliITSresponseSSD(const AliITSresponseSSD &ob) : AliITSresponse(ob),
+fADCpereV(ob.fADCpereV),
+fCouplingPR(ob.fCouplingPR),
+fCouplingPL(ob.fCouplingPL),
+fCouplingNR(ob.fCouplingNR),
+fCouplingNL(ob.fCouplingNL),
+fZSThreshold(ob.fZSThreshold),
+fOption1(ob.fOption1),
+fOption2(ob.fOption2) {
// Copy constructor
- // Copies are not allowed. The method is protected to avoid misuse.
- Error("AliITSresponseSSD","Copy constructor not allowed\n");
+
}
//______________________________________________________________________
-AliITSresponseSSD& AliITSresponseSSD::operator=(const AliITSresponseSSD& /* ob */){
+AliITSresponseSSD& AliITSresponseSSD::operator=(const AliITSresponseSSD& ob){
// Assignment operator
- // Assignment is not allowed. The method is protected to avoid misuse.
- Error("= operator","Assignment operator not allowed\n");
+ this->~AliITSresponseSSD();
+ new(this) AliITSresponseSSD(ob);
return *this;
}
ClassImp(AliITSsegmentation)
//_____________________________________________________________
-AliITSsegmentation::AliITSsegmentation(){
+AliITSsegmentation::AliITSsegmentation():
+fDx(0),
+fDz(0),
+fDy(0),
+fGeom(0),
+fCorr(0){
// Default constructor
- SetDetSize(0.,0.,0.);
- fGeom = 0;
- fCorr = 0;
+
}
//_____________________________________________________________
}
//______________________________________________________________________
AliITSsegmentation::AliITSsegmentation(const AliITSsegmentation &source):
- TObject(source){
+ TObject(source),
+fDx(0),
+fDz(0),
+fDy(0),
+fGeom(0),
+fCorr(0){
// copy constructor
source.Copy(*this);
}
ClassImp(AliITSsegmentationSDD)
//----------------------------------------------------------------------
AliITSsegmentationSDD::AliITSsegmentationSDD(AliITSgeom* geom,
- AliITSCalibration *resp){
+ AliITSCalibration *resp):
+fNsamples(0),
+fNanodes(0),
+fPitch(0),
+fTimeStep(0),
+fDriftSpeed(0){
// constructor
fGeom=geom;
AliITSCalibrationSDD* sp = (AliITSCalibrationSDD*)resp;
}
//______________________________________________________________________
-AliITSsegmentationSDD::AliITSsegmentationSDD() : AliITSsegmentation(){
+AliITSsegmentationSDD::AliITSsegmentationSDD() : AliITSsegmentation(),
+fNsamples(0),
+fNanodes(0),
+fPitch(0),
+fTimeStep(0),
+fDriftSpeed(0){
// Default constructor
fDriftSpeed=0;
SetDetSize(fgkDxDefault,fgkDzDefault,fgkDyDefault);
//____________________________________________________________________________
AliITSsegmentationSDD::AliITSsegmentationSDD(const AliITSsegmentationSDD &source) :
- AliITSsegmentation(source){
+ AliITSsegmentation(source),
+fNsamples(0),
+fNanodes(0),
+fPitch(0),
+fTimeStep(0),
+fDriftSpeed(0){
// copy constructor
source.Copy(*this);
}
ClassImp(AliITSsegmentationSPD)
//_____________________________________________________________________________
- AliITSsegmentationSPD::AliITSsegmentationSPD(): AliITSsegmentation(){
+ AliITSsegmentationSPD::AliITSsegmentationSPD(): AliITSsegmentation(),
+fNpx(0),
+fNpz(0){
// Default constructor
- fNpx = 0;
- fNpz = 0;
for(Int_t k=0; k<256; k++){
fCellSizeX[k] = 0.;
fCellSizeZ[k] = 0.;
return pitchz;
}
//______________________________________________________________________
-AliITSsegmentationSPD::AliITSsegmentationSPD(AliITSgeom *gm){
+AliITSsegmentationSPD::AliITSsegmentationSPD(AliITSgeom *gm):
+fNpx(0),
+fNpz(0){
// Constructor
fCorr=0;
- fNpx = 0;
- fNpz = 0;
Init();
fGeom = gm;
}
//____________________________________________________________________________
AliITSsegmentationSPD::AliITSsegmentationSPD(const AliITSsegmentationSPD &source) :
- AliITSsegmentation(source){
+ AliITSsegmentation(source),
+fNpx(0),
+fNpz(0){
// copy constructor
source.Copy(*this);
}
const Int_t AliITSsegmentationSSD::fgkNstripsDefault = 768;
ClassImp(AliITSsegmentationSSD)
-AliITSsegmentationSSD::AliITSsegmentationSSD(): AliITSsegmentation(){
+AliITSsegmentationSSD::AliITSsegmentationSSD(): AliITSsegmentation(),
+fNstrips(0),
+fStereoP(0),
+fStereoN(0),
+fPitch(0),
+fStereoPl5(0),
+fStereoNl5(0),
+fStereoPl6(0),
+fStereoNl6(0),
+fLayer(0){
// default constructor
}
//----------------------------------------------------------------------
-AliITSsegmentationSSD::AliITSsegmentationSSD(AliITSgeom *geom){
+AliITSsegmentationSSD::AliITSsegmentationSSD(AliITSgeom *geom):
+fNstrips(0),
+fStereoP(0),
+fStereoN(0),
+fPitch(0),
+fStereoPl5(0),
+fStereoNl5(0),
+fStereoPl6(0),
+fStereoNl6(0),
+fLayer(0){
// constuctor
fGeom = geom;
fCorr = 0;
}
//______________________________________________________________________
AliITSsegmentationSSD::AliITSsegmentationSSD(const AliITSsegmentationSSD &source):
- AliITSsegmentation(source){
+ AliITSsegmentation(source),
+fNstrips(0),
+fStereoP(0),
+fStereoN(0),
+fPitch(0),
+fStereoPl5(0),
+fStereoNl5(0),
+fStereoPl6(0),
+fStereoNl6(0),
+fLayer(0){
// copy constructor
source.Copy(*this);
}
virtual void SetSegmentationModel(Int_t dt, AliITSsegmentation *seg){fDetType->SetSegmentationModel(dt,seg);}
virtual AliITSsegmentation* GetSegmentationModel(Int_t dt){return fDetType->GetSegmentationModel(dt);}
-
-private:
+ private:
- virtual AliITSsimulation& operator=(const AliITSsimulation &)
- {return *this;}
-
+
virtual void SetSigmaRPhi(Double_t sigmarphi[6]);
virtual void SetSigmaZ(Double_t sigmaz[6]);
virtual void SetSigmaDe(Double_t sigmade[6]);
Double_t ThrDe(Int_t layer) const {return fThrDe[layer-1];}
-private:
-
Double_t fSigmaRPhi[6]; // Sigmas in rphi for the 6 layers
Double_t fSigmaZ[6]; // Sigmas in Z for the 6 layers
Double_t fSigmaDe[6]; // Sigmas in energy loss for the 6 layers
#pragma link C++ class AliITSRawStreamSSD+;
#pragma link C++ class AliITSRawStreamSSDv1+;
#pragma link C++ class AliITSEventHeader+;
-// SPD preprocessing
-#pragma link C++ class AliITSBadChannelsAuxSPD+;
-#pragma link C++ class AliITSBadChannelsSPD+;
-#pragma link C++ class AliITSChannelSPD+;
-#pragma link C++ class AliITSPreprocessorSPD+;
+
#endif
#pragma link C++ class AliITSBeamTestDigitizer+;
//multiplicity
#pragma link C++ class AliITSMultReconstructor+;
+// SPD and SDD preprocessing
+#pragma link C++ class AliITSBadChannelsAuxSPD+;
+#pragma link C++ class AliITSBadChannelsSPD+;
+#pragma link C++ class AliITSChannelSPD+;
+#pragma link C++ class AliITSPreprocessorSPD+;
+#pragma link C++ class AliITSPreprocessorSDD+;
#endif
AliITSEventHeader.cxx \
AliITSRawStreamSSDv1.cxx \
AliITSRawData.cxx \
- AliITSBadChannelsAuxSPD.cxx \
- AliITSBadChannelsSPD.cxx \
- AliITSChannelSPD.cxx \
- AliITSPreprocessorSPD.cxx \
HDRS:= $(SRCS:.cxx=.h)
AliITSBeamTestDigSPD.cxx \
AliITSBeamTestDigSSD.cxx \
AliITSBeamTestDigitizer.cxx \
- AliITSMultReconstructor.cxx
+ AliITSMultReconstructor.cxx \
+ AliITSPreprocessorSPD.cxx \
+ AliITSBadChannelsAuxSPD.cxx \
+ AliITSBadChannelsSPD.cxx \
+ AliITSChannelSPD.cxx \
+ AliITSPreprocessorSDD.cxx
HDRS:= $(SRCS:.cxx=.h)
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff