//_____________________________________________________________
-AliITSBeamTestDigitizer::AliITSBeamTestDigitizer():TTask()
-{
+AliITSBeamTestDigitizer::AliITSBeamTestDigitizer():TTask(),
+fEvIn(0),
+fEvFin(0),
+fRunNumber(-1),
+fDATEEvType(7),
+fFlagHeader(kTRUE),
+fFlagInit(kFALSE),
+fOptDate(kFALSE),
+fDigitsFileName(0),
+fRawdataFileName(0),
+fPeriod(kNov04),
+fRunLoader(0),
+fLoader(0),
+fHeader(0){
//
// Default constructor
//
- fRunLoader = 0;
- fLoader =0;
- fEvIn=0;
- fEvFin=0;
- fFlagHeader=kTRUE;
- fDATEEvType=7;
- fRunNumber=-1;
SetFlagInit();
SetOptDate();
- fPeriod=kNov04;
}
//_____________________________________________________________
- AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const Text_t* name, const Text_t* title, Char_t* opt,const char* filename):TTask(name,title)
+AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const Text_t* name, const Text_t* title, Char_t* opt,const char* filename):TTask(name,title),
+fEvIn(0),
+fEvFin(0),
+fRunNumber(-1),
+fDATEEvType(7),
+fFlagHeader(kTRUE),
+fFlagInit(kFALSE),
+fOptDate(kFALSE),
+fDigitsFileName(0),
+fRawdataFileName(0),
+fPeriod(kNov04),
+fRunLoader(0),
+fLoader(0),
+fHeader(0)
{
//
// Standard constructor
//
- fRunLoader=0;
- fLoader=0;
- fEvIn=0;
- fEvFin=0;
- fDATEEvType=7;
- fFlagHeader=kTRUE;
- fRunNumber=-1;
SetOptDate();
TString choice(opt);
}
//_____________________________________________________________
- AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const Text_t* name, const Text_t* title, Int_t run, Char_t* opt,const char* filename):TTask(name,title)
-
-{
+AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const Text_t* name, const Text_t* title, Int_t run, Char_t* opt,const char* filename):TTask(name,title),
+fEvIn(0),
+fEvFin(0),
+fRunNumber(run),
+fDATEEvType(7),
+fFlagHeader(kTRUE),
+fFlagInit(kFALSE),
+fOptDate(kFALSE),
+fDigitsFileName(0),
+fRawdataFileName(0),
+fPeriod(kNov04),
+fRunLoader(0),
+fLoader(0),
+fHeader(0){
//
// Constructor
//
- fRunLoader=0;
- fLoader=0;
- fEvIn=0;
- fEvFin=0;
- fDATEEvType=7;
- fFlagHeader=kTRUE;
- fRunNumber=run;
SetOptDate();
TString choice(opt);
Bool_t aug04 = choice.Contains("Aug04");
//______________________________________________________________________
-AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const AliITSBeamTestDigitizer &bt):TTask(bt){
+AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const AliITSBeamTestDigitizer &bt):TTask(bt),
+fEvIn(bt.fEvIn),
+fEvFin(bt.fEvFin),
+fRunNumber(bt.fRunNumber),
+fDATEEvType(bt.fDATEEvType),
+fFlagHeader(bt.fFlagHeader),
+fFlagInit(bt.fFlagInit),
+fOptDate(bt.fOptDate),
+fDigitsFileName(bt.fDigitsFileName),
+fRawdataFileName(bt.fRawdataFileName),
+fPeriod(bt.fPeriod),
+fRunLoader(bt.fRunLoader),
+fLoader(bt.fLoader),
+fHeader(bt.fHeader){
// Copy constructor.
- //not allowed
- if(this==&bt) return;
- Error("Copy constructor",
- "You are not allowed to make a copy of the AliITSBeamTestDigitizer");
- exit(1);
-
}
//______________________________________________________________________
AliITSBeamTestDigitizer& AliITSBeamTestDigitizer::operator=(const AliITSBeamTestDigitizer &source){
- // Assignment operator. This is a function which is not allowed to be
- // done to the ITS beam test digitizer. It exits with an error.
- // Inputs:
- if(this==&source) return *this;
- Error("operator=","You are not allowed to make a copy of the AliITSBeamTestDigitizer");
- exit(1);
- return *this; //fake return
+ // Assignment operator.
+ this->~AliITSBeamTestDigitizer();
+ new(this) AliITSBeamTestDigitizer(source);
+ return *this;
}
SelectVertexer(" ");
SetRunNumber();
}
-/*
+
//______________________________________________________________________
-AliITSDetTypeRec::AliITSDetTypeRec(const AliITSDetTypeRec & rec):TObject(rec)
+AliITSDetTypeRec::AliITSDetTypeRec(const AliITSDetTypeRec & rec):TObject(rec),
+fNMod(rec.fNMod),
+fReconstruction(rec.fReconstruction),
+fSegmentation(rec.fSegmentation),
+fCalibration(rec.fCalibration),
+fPreProcess(rec.fPreProcess),
+fPostProcess(rec.fPostProcess),
+fDigits(rec.fDigits),
+fNdtype(rec.fNdtype),
+fCtype(rec.fCtype),
+fNctype(rec.fNctype),
+fRecPoints(rec.fRecPoints),
+fNRecPoints(rec.fNRecPoints),
+fSelectedVertexer(rec.fSelectedVertexer),
+fLoader(rec.fLoader),
+fRunNumber(rec.fRunNumber),
+fFirstcall(rec.fFirstcall)
{
// Copy constructor.
- Error("Copy constructor","Copy constructor not allowed");
+
}
//______________________________________________________________________
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;
+ // Assignment operator.
+ this->~AliITSDetTypeRec();
+ new(this) AliITSDetTypeRec(source);
+ return *this;
}
-*/
+
//_____________________________________________________________________
AliITSDetTypeRec::~AliITSDetTypeRec(){
//Destructor
fDigits=0;
}
//----------------------------------------------------------------------
-AliITSDetTypeSim::AliITSDetTypeSim(const AliITSDetTypeSim &source) : TObject(source){
+AliITSDetTypeSim::AliITSDetTypeSim(const AliITSDetTypeSim &source) : TObject(source),
+fSimulation(source.fSimulation), // [NDet]
+fSegmentation(source.fSegmentation), // [NDet]
+fCalibration(source.fCalibration), // [NMod]
+fPreProcess(source.fPreProcess), // [] e.g. Fill fHitModule with hits
+fPostProcess(source.fPostProcess), // [] e.g. Wright Raw data
+fNSDigits(source.fNSDigits), //! number of SDigits
+fSDigits(source.fSDigits), //! [NMod][NSDigits]
+fNDigits(source.fNDigits), //! number of Digits
+fRunNumber(source.fRunNumber), //! Run number (to access DB)
+fDigits(source.fDigits), //! [NMod][NDigits]
+fHitClassName(source.fHitClassName), // String with Hit class name.
+fSDigClassName(source.fSDigClassName),// String with SDigit class name.
+fDigClassName(), // String with digit class name.
+fLoader(source.fLoader), // local pointer to loader
+fFirstcall(source.fFirstcall)
+{
// Copy Constructor for object AliITSDetTypeSim not allowed
-
- if(this==&source) return;
- Error("Copy constructor",
- "You are not allowed to make a copy of the AliITSDetTypeSim");
- exit(1);
+ for(Int_t i=0;i<fgkNdettypes;i++){
+ fDigClassName[i] = source.fDigClassName[i];
+ }
}
//----------------------------------------------------------------------
AliITSDetTypeSim& AliITSDetTypeSim::operator=(const AliITSDetTypeSim &source){
// The = operator for object AliITSDetTypeSim
- if(&source==this) return *this;
- Error("operator=",
- "You are not allowed to make a copy of the AliITSDetTypeSIm");
- exit(1);
- return *this;
+ this->~AliITSDetTypeSim();
+ new(this) AliITSDetTypeSim(source);
+ return *this;
}
//______________________________________________________________________
ClassImp(AliITSDigitizer)
//______________________________________________________________________
-AliITSDigitizer::AliITSDigitizer() : AliDigitizer(){
+AliITSDigitizer::AliITSDigitizer() : AliDigitizer(),
+fITS(0),
+fModActive(0),
+fInit(kFALSE),
+fRoif(-1),
+fRoiifile(0),
+fFlagFirstEv(kTRUE){
// Default constructor. Assign fITS since it is never written out from
// here.
// Inputs:
// Return:
// A blank AliITSDigitizer class.
- fITS = 0;
- fModActive = 0;
- fRoif = -1;
- fRoiifile = 0;
- fInit = kFALSE;
- fFlagFirstEv =kTRUE;
}
//______________________________________________________________________
-AliITSDigitizer::AliITSDigitizer(AliRunDigitizer *mngr) : AliDigitizer(mngr){
+AliITSDigitizer::AliITSDigitizer(AliRunDigitizer *mngr) : AliDigitizer(mngr),
+fITS(0),
+fModActive(0),
+fInit(kFALSE),
+fRoif(-1),
+fRoiifile(0),
+fFlagFirstEv(kTRUE){
// Standard constructor. Assign fITS since it is never written out from
// here.
// Inputs:
// Return:
// An AliItSDigitizer class.
- fITS = 0;
- fModActive = 0;
- fRoif = -1;
- fRoiifile = 0;
- fInit = kFALSE;
- fFlagFirstEv =kTRUE;
}
//______________________________________________________________________
-AliITSDigitizer::AliITSDigitizer(const AliITSDigitizer &/*rec*/):AliDigitizer(/*rec*/){
+//AliITSDigitizer::AliITSDigitizer(const AliITSDigitizer &/*rec*/):AliDigitizer(/*rec*/){
// Copy constructor.
- Error("Copy constructor","Copy constructor not allowed");
+// Error("Copy constructor","Copy constructor not allowed");
-}
+//}
//______________________________________________________________________
AliITSDigitizer& AliITSDigitizer::operator=(const AliITSDigitizer& /*source*/){
// Assignment operator. This is a function which is not allowed to be
ClassImp(AliITSFDigitizer)
//______________________________________________________________________
-AliITSFDigitizer::AliITSFDigitizer() : AliDigitizer(){
+AliITSFDigitizer::AliITSFDigitizer() : AliDigitizer(),
+fITS(0),
+fInit(kFALSE){
//
// Default constructor.
//
- fITS = 0;
- fInit = kFALSE;
}
//______________________________________________________________________
-AliITSFDigitizer::AliITSFDigitizer(AliRunDigitizer *mngr) : AliDigitizer(mngr){
+AliITSFDigitizer::AliITSFDigitizer(AliRunDigitizer *mngr) : AliDigitizer(mngr),
+fITS(0),
+fInit(kFALSE){
//
// Standard constructor.
//
- fITS = 0;
- fInit = kFALSE;
}
//______________________________________________________________________
-AliITSFDigitizer::AliITSFDigitizer(const AliITSFDigitizer &/*rec*/):AliDigitizer(/*rec*/){
+AliITSFDigitizer::AliITSFDigitizer(const AliITSFDigitizer &rec):AliDigitizer(rec),
+fITS(rec.fITS),
+fInit(rec.fInit){
// Copy constructor.
-
- Error("Copy constructor","Copy constructor not allowed");
}
//______________________________________________________________________
//____________________________________________________________________
-AliITSMultReconstructor::AliITSMultReconstructor() {
+AliITSMultReconstructor::AliITSMultReconstructor():
+fGeometry(0),
+fClustersLay1(0),
+fClustersLay2(0),
+fTracklets(0),
+fAssociationFlag(0),
+fNClustersLay1(0),
+fNClustersLay2(0),
+fNTracklets(0),
+fPhiWindow(0),
+fZetaWindow(0),
+fOnlyOneTrackletPerC2(0),
+fHistOn(0),
+fhClustersDPhiAcc(0),
+fhClustersDThetaAcc(0),
+fhClustersDZetaAcc(0),
+fhClustersDPhiAll(0),
+fhClustersDThetaAll(0),
+fhClustersDZetaAll(0),
+fhDPhiVsDThetaAll(0),
+fhDPhiVsDThetaAcc(0),
+fhDPhiVsDZetaAll(0),
+fhDPhiVsDZetaAcc(0),
+fhetaTracklets(0),
+fhphiTracklets(0),
+fhetaClustersLay1(0),
+fhphiClustersLay1(0){
// Method to reconstruct the charged particles multiplicity with the
// SPD (tracklets).
}
//______________________________________________________________________
-AliITSMultReconstructor::AliITSMultReconstructor(const AliITSMultReconstructor &mr) : TObject(mr) {
+AliITSMultReconstructor::AliITSMultReconstructor(const AliITSMultReconstructor &mr) : TObject(mr),
+fGeometry(mr.fGeometry),
+fClustersLay1(mr.fClustersLay1),
+fClustersLay2(mr.fClustersLay2),
+fTracklets(mr.fTracklets),
+fAssociationFlag(mr.fAssociationFlag),
+fNClustersLay1(mr.fNClustersLay1),
+fNClustersLay2(mr.fNClustersLay2),
+fNTracklets(mr.fNTracklets),
+fPhiWindow(mr.fPhiWindow),
+fZetaWindow(mr.fZetaWindow),
+fOnlyOneTrackletPerC2(mr.fOnlyOneTrackletPerC2),
+fHistOn(mr.fHistOn),
+fhClustersDPhiAcc(mr.fhClustersDPhiAcc),
+fhClustersDThetaAcc(mr.fhClustersDThetaAcc),
+fhClustersDZetaAcc(mr.fhClustersDZetaAcc),
+fhClustersDPhiAll(mr.fhClustersDPhiAll),
+fhClustersDThetaAll(mr.fhClustersDThetaAll),
+fhClustersDZetaAll(mr.fhClustersDZetaAll),
+fhDPhiVsDThetaAll(mr.fhDPhiVsDThetaAll),
+fhDPhiVsDThetaAcc(mr.fhDPhiVsDThetaAcc),
+fhDPhiVsDZetaAll(mr.fhDPhiVsDZetaAll),
+fhDPhiVsDZetaAcc(mr.fhDPhiVsDZetaAcc),
+fhetaTracklets(mr.fhetaTracklets),
+fhphiTracklets(mr.fhphiTracklets),
+fhetaClustersLay1(mr.fhetaClustersLay1),
+fhphiClustersLay1(mr.fhphiClustersLay1) {
// Copy constructor
- // Copies are not allowed. The method is protected to avoid misuse.
- Error("AliITSMultReconstructor","Copy constructor not allowed\n");
+
}
//______________________________________________________________________
-AliITSMultReconstructor& AliITSMultReconstructor::operator=(const AliITSMultReconstructor& /* mr */){
+AliITSMultReconstructor& AliITSMultReconstructor::operator=(const AliITSMultReconstructor& mr){
// Assignment operator
- // Assignment is not allowed. The method is protected to avoid misuse.
- Error("= operator","Assignment operator not allowed\n");
+ this->~AliITSMultReconstructor();
+ new(this) AliITSMultReconstructor(mr);
return *this;
}
protected:
AliITSMultReconstructor(const AliITSMultReconstructor& mr);
- AliITSMultReconstructor& operator=(const AliITSMultReconstructor& /* mr */);
+ AliITSMultReconstructor& operator=(const AliITSMultReconstructor& mr);
AliITSgeom* fGeometry; // ITS geometry
/////////////////////////////////////////
// Class for SDD digits preprocessing //
+// //
+// //
////////////////////////////////////////
#include "AliITSPreprocessorSDD.h"
const Int_t AliITSPreprocessorSDD::fgkNumberOfSDD = 260;
const Int_t AliITSPreprocessorSDD::fgkNumberOfChannels = 512;
-const char* AliITSPreprocessorSDD::fgkNameHistoPedestals ="hpedestal";
-const char* AliITSPreprocessorSDD::fgkNameHistoNoise="hnoise";
-
+const TString AliITSPreprocessorSDD::fgkNameHistoPedestals = "hpedestal";
+const TString AliITSPreprocessorSDD::fgkNameHistoNoise = "hnoise";
ClassImp(AliITSPreprocessorSDD)
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);
+ sprintf(namehisto,"%s_%d",fgkNameHistoPedestals.Data(),imod);
+ sprintf(namehisto2,"%s_%d",fgkNameHistoNoise.Data(),imod);
TH1F* hbas = (TH1F*)f1->Get(namehisto);
TH1F* hnoi = (TH1F*)f2->Get(namehisto2);
for(Int_t ien=0;ien<fgkNumberOfChannels;ien++){
public:
AliITSPreprocessorSDD(const char* detector, AliShuttleInterface* shuttle):
- AliPreprocessor(detector,shuttle){;}
+ AliPreprocessor(detector,shuttle){SetName("SDD");}
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.
+ static const TString fgkNameHistoPedestals; //name of ped. histo
+ static const TString fgkNameHistoNoise; //name of noise histo
+ ClassDef(AliITSPreprocessorSDD,2) // Alice ITS-SDD preprocessor.
};
ClassImp(AliITSTableSSD)
////////////////////////////////////////////////////////////////////////
-// Version: 0
-// Origin: Massimo Masera
-// March 2002
-//
+// Version: 0 //
+// Origin: Massimo Masera //
+// March 2002 //
+// //
// AliITSTableSSD is used by AliITSsimulationSSD class to fill the AliITSpList
// object starting from the map with energy depositions
-
+////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------
-AliITSTableSSD::AliITSTableSSD() : TObject(){
+AliITSTableSSD::AliITSTableSSD() : TObject(),
+fDim(0),
+fArray(0){
// Default Constructor
- fDim=0;
- fArray=0;
for(Int_t i=0;i<2;i++){
fCurrUse[i]=0;
fCurrFil[i]=0;
}
}
//----------------------------------------------------------------------
-AliITSTableSSD::AliITSTableSSD(const AliITSTableSSD & source):TObject(source){
+AliITSTableSSD::AliITSTableSSD(const AliITSTableSSD & source):TObject(source),
+fDim(source.fDim),
+fArray(source.fArray){
// Copy constructor
if(this == &source) return;
- fDim=source.fDim;
fArray = new Int_t [fDim];
fCurrUse[0]=(source.fCurrUse)[0];
fCurrUse[1]=(source.fCurrUse)[1];
return *this;
}
//----------------------------------------------------------------------
-AliITSTableSSD::AliITSTableSSD(Int_t noelem) : TObject(){
+AliITSTableSSD::AliITSTableSSD(Int_t noelem) : TObject(),
+fDim(0),
+fArray(0){
// Standard constructor
fDim=noelem*2;
fArray = new Int_t [fDim];
}
//----------------------------------------------------------------------
void AliITSTableSSD::Clear(){
+ //clear arrays
fCurrUse[0]= 0;
fCurrUse[1] = 0;
fCurrFil[0]= 0;
/* Copyright(c) 2002-2003, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
+///////////////////////////////////////////////////////////
+// AliITSTableSSD is used by AliITSsimulationSSD class to//
+//fill the AliITSpList object starting from the map with//
+//energy depositions //
+///////////////////////////////////////////////////////////
+
#include "Rtypes.h"
#include <TObject.h>
virtual void Clear(Option_t*) {TObject::Clear();}
private:
- Int_t SearchValue(Int_t *arr, Int_t refer, Int_t max){
+ Int_t SearchValue(Int_t *arr, Int_t refer, Int_t max) const{
for(Int_t i=0;i<max;i++)if(arr[i]==refer)return i;
return -1;}
private:
//______________________________________________________________________
ClassImp(AliITSTrigger)
////////////////////////////////////////////////////////////////////////
-//
-// Version 1
-// Modified by D. Elia, C. Jorgensen
-// March 2006
-//
-// Version 0
-// Written by J. Conrad, E. Lopez Torres
-// October 2005
-//
-// AliITSTrigger: implementation of the SPD Fast-OR based triggers.
-//
+// //
+// Version 1 //
+// Modified by D. Elia, C. Jorgensen //
+// March 2006 //
+// //
+// Version 0 //
+// Written by J. Conrad, E. Lopez Torres //
+// October 2005 //
+// //
+// AliITSTrigger: implementation of the SPD Fast-OR based triggers. //
+// //
////////////////////////////////////////////////////////////////////////
//______________________________________________________________________
AliITSTrigger::AliITSTrigger()
- : AliTriggerDetector()
-{
- SetName("ITS");
- CreateInputs();
+ : AliTriggerDetector(),
+fGlobalFOThreshold(1),
+fHighMultFOThreshold(150){
+
+ //standard constructor
+ SetName("ITS");
+ CreateInputs();
- // set parameters to define trigger condition thresholds
- fGlobalFOThreshold = 1;
- fHighMultFOThreshold = 150;
+ // set parameters to define trigger condition thresholds
+ //fGlobalFOThreshold = 1;
+ //fHighMultFOThreshold = 150;
}
//______________________________________________________________________
// Constructor and Destructor
//______________________________________________________________________
-AliITSdcsSSD::AliITSdcsSSD(){
+ AliITSdcsSSD::AliITSdcsSSD():
+fCouplingPR(0),
+fCouplingPL(0),
+fCouplingNR(0),
+fCouplingNL(0),
+fNstrips(0),
+fNInvalid(0),
+fISigma(0),
+fInvalidP(0),
+fInvalidN(0){
// Default Constructor
- fInvalidP = 0;
- fInvalidN = 0;
}
//______________________________________________________________________
-AliITSdcsSSD::AliITSdcsSSD(AliITSsegmentation *seg, AliITSCalibration *resp){
+AliITSdcsSSD::AliITSdcsSSD(AliITSsegmentation *seg, AliITSCalibration *resp):
+fCouplingPR(0),
+fCouplingPL(0),
+fCouplingNR(0),
+fCouplingNL(0),
+fNstrips(0),
+fNInvalid(0),
+fISigma(0),
+fInvalidP(0),
+fInvalidN(0){
// Standard constructor
fNstrips =(Float_t) (((AliITSsegmentationSSD*)seg)->Npx());
delete fInvalidN;
}
//______________________________________________________________________
-AliITSdcsSSD::AliITSdcsSSD(const AliITSdcsSSD &source) : TObject(source){
+AliITSdcsSSD::AliITSdcsSSD(const AliITSdcsSSD &source) : TObject(source),
+fCouplingPR(source.fCouplingPR),
+fCouplingPL(source.fCouplingPL),
+fCouplingNR(source.fCouplingNR),
+fCouplingNL(source.fCouplingNL),
+fNstrips(source.fNstrips),
+fNInvalid(source.fNInvalid),
+fISigma(source.fISigma),
+fInvalidP(source.fInvalidP),
+fInvalidN(source.fInvalidN){
// Copy Constructor
- if(&source == this) return;
-
- this->fCouplingPR = source.fCouplingPR;
- this->fCouplingPL = source.fCouplingPL;
- this->fCouplingNR = source.fCouplingNR;
- this->fCouplingNL = source.fCouplingNL;
- this->fNstrips = source.fNstrips;
- this->fNInvalid = source.fNInvalid;
- this->fISigma = source.fISigma;
- this->fInvalidP = source.fInvalidP;
- this->fInvalidN = source.fInvalidN;
-
- return;
}
//_________________________________________________________________________
AliITSdcsSSD& AliITSdcsSSD::operator=(const AliITSdcsSSD &source) {
return power;
}
-AliITSetfSDD::AliITSetfSDD() {
+AliITSetfSDD::AliITSetfSDD():
+fTimeDelay(0),
+fSamplingTime(0),
+fT0(0),
+fDf(0.),
+fA0(0.) ,
+fZeroM(0),
+fZeroR(0),
+fZeroI(0),
+fPoleM(0),
+fPoleR(0),
+fPoleI(0),
+fTfR(0),
+fTfI(0),
+fWR(0),
+fWI(0){
// Default constructor
- fTimeDelay = 0.;
- fSamplingTime = 0.;
- fT0 = 0.;
- fDf = 0.;
- fA0 = 0.;
- fZeroM = 0;
- fZeroR = 0;
- fPoleM = 0;
- fPoleR = 0;
- fPoleI = 0;
- fTfR = 0;
- fTfI = 0;
- fWR = 0;
- fWI = 0;
}
-AliITSetfSDD::AliITSetfSDD(Double_t timestep, Int_t amplif)
+AliITSetfSDD::AliITSetfSDD(Double_t timestep, Int_t amplif):
+fTimeDelay(0),
+fSamplingTime(0),
+fT0(0),
+fDf(0.),
+fA0(0.) ,
+fZeroM(0),
+fZeroR(0),
+fZeroI(0),
+fPoleM(0),
+fPoleR(0),
+fPoleI(0),
+fTfR(0),
+fTfI(0),
+fWR(0),
+fWI(0)
{
// Standard constructor. sampling time in ns
}
-//______________________________________________________________________
-AliITSetfSDD::AliITSetfSDD(const AliITSetfSDD &obj) : TObject(obj) {
- // Copy constructor
- // Copies are not allowed. The method is protected to avoid misuse.
- Error("AliITSetfSDD","Copy constructor not allowed\n");
-}
-
-//______________________________________________________________________
-AliITSetfSDD& AliITSetfSDD::operator=(const AliITSetfSDD& /* obj */){
- // Assignment operator
- // Assignment is not allowed. The method is protected to avoid misuse.
- Error("= operator","Assignment operator not allowed\n");
- return *this;
-}
AliITSetfSDD::~AliITSetfSDD(){
// Destructor
//
////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________________
-AliITShit::AliITShit():AliHit(){
+AliITShit::AliITShit():AliHit(),
+fStatus(0),
+fLayer(0),
+fLadder(0),
+fDet(0),
+fPx(0.0),
+fPy(0.0),
+fPz(0.0),
+fDestep(0.0),
+fTof(0.0),
+fStatus0(0),
+fx0(0.0),
+fy0(0.0),
+fz0(0.0),
+ft0(0.0){
// Default Constructor
// Zero data member just to be safe.
// Intputs:
// Return:
// A default created AliITShit class.
- fStatus = 0; // Track Status
- fLayer = 0; // Layer number
- fLadder = 0; // Ladder number
- fDet = 0; // Detector number
- fPx = 0.0; // PX of particle at the point of the hit
- fPy = 0.0; // PY of particle at the point of the hit
- fPz = 0.0; // PZ of particle at the point of the hit
- fDestep = 0.0; // Energy deposited in the current step
- fTof = 0.0; // Time of flight at the point of the hit
- fStatus0 = 0; // zero status bit by default.
- fx0 = 0.0; // Starting point of this step
- fy0 = 0.0; // Starting point of this step
- fz0 = 0.0; // Starting point of this step
- ft0 = 0.0; // Starting point of this step
}
AliITShit::AliITShit(Int_t shunt,Int_t track,Int_t *vol,Float_t edep,
Float_t tof,TLorentzVector &x,TLorentzVector &x0,
- TLorentzVector &p) : AliHit(shunt, track){
+ TLorentzVector &p) : AliHit(shunt, track),
+fStatus(vol[3]),
+fLayer(vol[0]),
+fLadder(vol[2]),
+fDet(vol[1]),
+fPx(p.Px()),
+fPy(p.Py()),
+fPz(p.Pz()),
+fDestep(edep),
+fTof(tof),
+fStatus0(vol[4]),
+fx0(x0.X()),
+fy0(x0.Y()),
+fz0(x0.Z()),
+ft0(x0.T()){
////////////////////////////////////////////////////////////////////////
// Create ITS hit
// The creator of the AliITShit class. The variables shunt and
// Return:
// A default created AliITShit class.
- fLayer = vol[0]; // Layer number
- fLadder = vol[2]; // Ladder number
- fDet = vol[1]; // Detector number
- fStatus = vol[3]; // Track status flags
- fStatus0 = vol[4]; // Track status flag for start position.
+
+
fX = x.X(); // Track X global position
fY = x.Y(); // Track Y global position
fZ = x.Z(); // Track Z global position
- fPx = p.Px(); // Track X Momentum
- fPy = p.Py(); // Track Y Momentum
- fPz = p.Pz(); // Track Z Momentum
- fDestep = edep; // Track dE/dx for this step
- fTof = tof ; // Track Time of Flight for this step
- fx0 = x0.X(); // Track X global position
- fy0 = x0.Y(); // Track Y global position
- fz0 = x0.Z(); // Track Z global position
- ft0 = x0.T(); // Starting point of this step
}
//______________________________________________________________________
AliITShit::AliITShit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
- AliHit(shunt, track){
+ AliHit(shunt, track),
+fStatus(vol[3]),
+fLayer(vol[0]),
+fLadder(vol[2]),
+fDet(vol[1]),
+fPx(hits[3]),
+fPy(hits[4]),
+fPz(hits[5]),
+fDestep(hits[6]),
+fTof(hits[7]),
+fStatus0(0),
+fx0(0.0),
+fy0(0.0),
+fz0(0.0),
+ft0(0.0){
////////////////////////////////////////////////////////////////////////
// Create ITS hit
// The creator of the AliITShit class. The variables shunt and
// none.
// Return:
// A standard created AliITShit class.
- fLayer = vol[0]; // Layer number
- fLadder = vol[2]; // Ladder number
- fDet = vol[1]; // Detector number
- fStatus = vol[3]; // Track status flags
fX = hits[0]; // Track X global position
fY = hits[1]; // Track Y global position
fZ = hits[2]; // Track Z global position
- fPx = hits[3]; // Track X Momentum
- fPy = hits[4]; // Track Y Momentum
- fPz = hits[5]; // Track Z Momentum
- fDestep = hits[6]; // Track dE/dx for this step
- fTof = hits[7]; // Track Time of Flight for this step
- fStatus0 = 0;// Track Status of Starting point
- fx0 = 0.0; // Starting point of this step
- fy0 = 0.0; // Starting point of this step
- fz0 = 0.0; // Starting point of this step
- ft0 = 0.0; // Starting point of this step
}
//______________________________________________________________________
void AliITShit::GetPositionL(Float_t &x,Float_t &y,Float_t &z){
// Constructors and deconstructor
//________________________________________________________________________
//
-AliITSmodule::AliITSmodule() {
+AliITSmodule::AliITSmodule():
+fITS(0),
+fIndex(0),
+fHitsM(0),
+fTrackIndex(0),
+fHitIndex(0) {
// constructor
- fHitsM = 0;
- fTrackIndex = 0;
- fHitIndex = 0;
- fITS = 0;
-
}
//_________________________________________________________________________
-AliITSmodule::AliITSmodule(Int_t index) {
+AliITSmodule::AliITSmodule(Int_t index):
+fITS(0),
+fIndex(index),
+fHitsM(0),
+fTrackIndex(0),
+fHitIndex(0) {
// constructor
- fIndex = index;
fHitsM = new TObjArray();
fTrackIndex = new TArrayI(16);
fHitIndex = new TArrayI(16);
fITS = 0; // We don't delete this pointer since it is just a copy.
}
//____________________________________________________________________________
-AliITSmodule::AliITSmodule(const AliITSmodule &source):TObject(source){
+AliITSmodule::AliITSmodule(const AliITSmodule &source):TObject(source),
+fITS(source.fITS),
+fIndex(source.fIndex),
+fHitsM(source.fHitsM),
+fTrackIndex(source.fTrackIndex),
+fHitIndex(source.fHitIndex){
////////////////////////////////////////////////////////////////////////
// Copy Constructor
////////////////////////////////////////////////////////////////////////
- Error("AliITSmodule","AliITSmodule class has not to be copied! Exit.");
- exit(1);
+
}
//_____________________________________________________________________________
AliITSmodule& AliITSmodule::operator=(const AliITSmodule &source){
////////////////////////////////////////////////////////////////////////
// Assignment operator
////////////////////////////////////////////////////////////////////////
- if(&source == this) return *this;
- Error("AliITSmodule","AliITSmodule class has not to be copied! Exit.");
- exit(1);
- return *this; // fake return neded on Sun
+ this->~AliITSmodule();
+ new(this) AliITSmodule(source);
+ return *this;
}
//_________________________________________________________________________
//
#include "AliITS.h"
#include "AliITSsDigitize.h"
#include "AliITSgeom.h"
-
+
+/////////////////////////////////////////////////////////
+// //
+// //
+// //
+/////////////////////////////////////////////////////////
ClassImp(AliITSsDigitize)
//______________________________________________________________________
-AliITSsDigitize::AliITSsDigitize(){
+AliITSsDigitize::AliITSsDigitize():
+fInit(kFALSE),
+fEnt(0),
+fEnt0(0),
+fITS(0),
+fRunLoader(0x0){
// Default constructor.
// Inputs:
// none.
// Return:
// A zero-ed constructed AliITSsDigitize class.
- fRunLoader = 0x0;
- fITS = 0;
fDet[0] = fDet[1] = fDet[2] = kTRUE;
- fInit = kFALSE;
}
//______________________________________________________________________
-AliITSsDigitize::AliITSsDigitize(const char* filename){
+AliITSsDigitize::AliITSsDigitize(const char* filename):
+fInit(),
+fEnt(0),
+fEnt0(0),
+fITS(0),
+fRunLoader(0x0){
// Standard constructor.
// Inputs:
// const char* filename filename containing the digits to be
return fInit;
}
//______________________________________________________________________
-Bool_t AliITSsDigitize::InitSDig(){
+Bool_t AliITSsDigitize::InitSDig() const {
// Sets up SDigitization part of AliITSDetType..
// Inputs:
// none.
-#ifndef ALIITSSDIGITIZATION_H
-#define ALIITSSDIGITIATION_H
+#ifndef ALIITSSDIGITIZE_H
+#define ALIITSSDIGITIZE_H
/* Copyright (c) 1998-2001, ALICE Experiment at CERN, All rights reserved *
* See cxx source for full Copyright notice */
/*
$Id$
*/
+/////////////////////////////////////////////////////////
+// //
+// //
+// //
+/////////////////////////////////////////////////////////
#include <TTask.h>
virtual Bool_t Init();
virtual void Exec(const Option_t *opt="ALL");
private:
- Bool_t InitSDig(); // Standard SDigitization initilization.
+ Bool_t InitSDig() const; // Standard SDigitization initilization.
private:
// TFile *fFile; //! pointer to the file contatining the hits and
// // and will contain the SDigits
+ AliITSsDigitize(const AliITSsDigitize &source); // copy constructor
+ AliITSsDigitize& operator=(const AliITSsDigitize &source); // operator=
+
Bool_t fDet[3]; //! logical specifing which detectors to reconstruct.
Bool_t fInit; //! True if Init was sucessfull, else false.
//______________________________________________________________________
AliITSsimulation::AliITSsimulation(): TObject(),
+fDetType(0),
fpList(0),
fModule(0),
fEvent(0),
// none.
// Return:
// a default constructed AliITSsimulation class
- fDetType = 0;
}
//______________________________________________________________________
AliITSsimulation::AliITSsimulation(AliITSDetTypeSim *dettyp): TObject(),
+fDetType(dettyp),
fpList(0),
fModule(0),
fEvent(0),
// none.
// Return:
// a default constructed AliITSsimulation class
- fDetType = dettyp;
}
//__________________________________________________________________________
AliITSsimulation::~AliITSsimulation(){
}
}
//__________________________________________________________________________
-AliITSsimulation::AliITSsimulation(const AliITSsimulation &s) : TObject(s){
+AliITSsimulation::AliITSsimulation(const AliITSsimulation &s) : TObject(s),
+fDetType(s.fDetType),
+fpList(s.fpList),
+fModule(s.fModule),
+fEvent(s.fEvent),
+fDebug(s.fDebug){
// Copy Constructor
// Inputs:
// const AliITSsimulation &s simulation class to copy from
// a standard constructed AliITSsimulation class with values the same
// as that of s.
- *this = s;
- return;
}
//_________________________________________________________________________
{
public:
- AliITSsimulationFastPoints(); // default constructor
+ AliITSsimulationFastPoints(); // default constructor
virtual ~AliITSsimulationFastPoints() {;}
+ virtual AliITSsimulation& operator=(const AliITSsimulation&){return *this;}
void CreateFastRecPoints(AliITSmodule *mod,Int_t module,TRandom *rndm,
TClonesArray* recp);
void CreateFastRecPoints(Int_t module,TClonesArray* recp);
ClassImp(AliITSsimulationFastPointsV0)
-AliITSsimulationFastPointsV0::AliITSsimulationFastPointsV0()
-{
+AliITSsimulationFastPointsV0::AliITSsimulationFastPointsV0():
+fNrecp(0),
+fSx(0),
+fSz(0){
// default constructor
- fSx = 0;
- fSz = 0;
}
-AliITSsimulationFastPointsV0::AliITSsimulationFastPointsV0(const char *dataType){
+AliITSsimulationFastPointsV0::AliITSsimulationFastPointsV0(const char *dataType):
+fNrecp(0),
+fSx(0),
+fSz(0){
//constructor
Info("AliITSsimulationFastPointsV0","Standard constructor %s",dataType);
fSx = new AliITSstatistics(2);
fSz = new AliITSstatistics(2);
}
//______________________________________________________________________
-AliITSsimulationFastPointsV0::AliITSsimulationFastPointsV0(const AliITSsimulationFastPointsV0 &/*rec*/):AliITSsimulation(/*rec*/){
+AliITSsimulationFastPointsV0::AliITSsimulationFastPointsV0(const AliITSsimulationFastPointsV0 & rec):AliITSsimulation(rec),
+fNrecp(rec.fNrecp),
+fSx(rec.fSx),
+fSz(rec.fSz){
// Copy constructor.
- Error("Copy constructor","Copy constructor not allowed");
-
}
//______________________________________________________________________
-AliITSsimulationFastPointsV0& AliITSsimulationFastPointsV0::operator=(const AliITSsimulationFastPointsV0& /*source*/){
- // Assignment operator. This is a function which is not allowed to be
- // done.
- Error("operator=","Assignment operator not allowed\n");
- return *this;
+AliITSsimulationFastPointsV0& AliITSsimulationFastPointsV0::operator=(const AliITSsimulationFastPointsV0& /*source*/){
+ // Assignment operator
+ Error("operator=","Assignment operator not allowed");
+ return *this;
}
//----------------------------------------------------------
public:
AliITSsimulationFastPointsV0(); // default constructor
AliITSsimulationFastPointsV0(const char *dataType); // standard constructor
- AliITSsimulationFastPointsV0(const AliITSsimulationFastPointsV0 &);
+ AliITSsimulationFastPointsV0(const AliITSsimulationFastPointsV0 &rec);
AliITSsimulationFastPointsV0 & operator=(const AliITSsimulationFastPointsV0 &);
virtual AliITSsimulation& operator=(const AliITSsimulation &)
{return *this;};
fHis(0),
fD(),
fT1(),
+fT2(),
fTol(),
fTreeB(0),
+fParam(0),
fFileName(),
fFlag(kFALSE),
fCheckNoise(kFALSE),
SetCheckNoise();
}
//______________________________________________________________________
-AliITSsimulationSDD::AliITSsimulationSDD(AliITSsimulationSDD &source) :
- AliITSsimulation(source){
+AliITSsimulationSDD::AliITSsimulationSDD(const AliITSsimulationSDD &source) :
+ AliITSsimulation(source),
+fITS(source.fITS),
+fHitMap2(source.fHitMap2),
+fHitSigMap2(source.fHitSigMap2),
+fHitNoiMap2(source.fHitNoiMap2),
+fStream(source.fStream),
+fElectronics(source.fElectronics),
+fInZR(source.fInZR),
+fInZI(source.fInZI),
+fOutZR(source.fOutZR),
+fOutZI(source.fOutZI),
+fAnodeFire(source.fAnodeFire),
+fHis(source.fHis),
+fD(source.fD),
+fT1(source.fT1),
+fT2(source.fT2),
+fTol(source.fTol),
+fTreeB(source.fTreeB),
+fParam(source.fParam),
+fFileName(source.fFileName),
+fFlag(source.fFlag),
+fCheckNoise(source.fCheckNoise),
+fCrosstalkFlag(source.fCrosstalkFlag),
+fDoFFT(source.fDoFFT),
+fNofMaps(source.fNofMaps),
+fMaxNofSamples(source.fMaxNofSamples),
+fScaleSize(source.fScaleSize){
// Copy constructor to satify Coding roules only.
- if(this==&source) return;
- Error("AliITSsimulationSDD","Not allowed to make a copy of "
- "AliITSsimulationSDD Using default creater instead");
- AliITSsimulationSDD();
}
//______________________________________________________________________
AliITSsimulationSDD& AliITSsimulationSDD::operator=(const AliITSsimulationSDD &src){
//Standard Constructor
AliITSsimulationSDD(AliITSDetTypeSim* dettyp);
// Copy operator
- AliITSsimulationSDD(AliITSsimulationSDD &source);
+ AliITSsimulationSDD(const AliITSsimulationSDD &source);
virtual ~AliITSsimulationSDD(); // Destructor
// = operator
AliITSsimulationSDD& operator=(const AliITSsimulationSDD &source);
//______________________________________________________________________
AliITSsimulationSPD::AliITSsimulationSPD(const
AliITSsimulationSPD
- &s) : AliITSsimulation(s){
+ &s) : AliITSsimulation(s),
+fHis(s.fHis),
+fSPDname(s.fSPDname),
+fCoupling(s.fCoupling){
// Copy Constructor
// Inputs:
// AliITSsimulationSPD &s The original class for which
// none.
// Return:
- *this = s;
- return;
}
//______________________________________________________________________
AliITSsimulationSPD& AliITSsimulationSPD::operator=(const
}
//______________________________________________________________________
AliITSsimulationSSD::AliITSsimulationSSD(const AliITSsimulationSSD &source):
- AliITSsimulation(source){
+ AliITSsimulation(source),
+fMapA2(source.fMapA2),
+fIonE(source.fIonE),
+fDifConst(),
+fDriftVel(){
// copy constructor
-
- *this = source;
+ fDifConst[0] = source.fDifConst[0];
+ fDifConst[1] = source.fDifConst[1];
+ fDriftVel[0] = source.fDriftVel[0];
+ fDriftVel[1] = source.fDriftVel[1];
}
//______________________________________________________________________
AliITSsimulationSSD::~AliITSsimulationSSD() {
ClassImp(AliITSstatistics)
//
-AliITSstatistics::AliITSstatistics() : TObject(){
+AliITSstatistics::AliITSstatistics() : TObject(),
+fN(0),
+fOrder(0),
+fX(0),
+fW(0){
//
// default contructor
//
- fX = 0;
- fW = 0;
- fN = 0;
- fOrder = 0;
- return;
}
-AliITSstatistics::AliITSstatistics(Int_t order) : TObject(){
+AliITSstatistics::AliITSstatistics(Int_t order) : TObject(),
+fN(0),
+fOrder(order),
+fX(0),
+fW(0){
//
// contructor to a specific order in the moments
//
- fOrder = order;
fX = new Double_t[order];
fW = new Double_t[order];
for(Int_t i=0;i<order;i++) {fX[i] = 0.0; fW[i] = 0.0;}
- fN = 0;
return;
}
fOrder = 0;
}
//_______________________________________________________________
-AliITSstatistics& AliITSstatistics::operator=(AliITSstatistics &source){
+AliITSstatistics& AliITSstatistics::operator=(const AliITSstatistics &source){
// operator =
if(this==&source) return *this;
return *this;
}
//_______________________________________________________________
-AliITSstatistics::AliITSstatistics(AliITSstatistics &source) : TObject(source){
+AliITSstatistics::AliITSstatistics(const AliITSstatistics &source) : TObject(source),
+fN(0),
+fOrder(0),
+fX(0),
+fW(0){
// Copy constructor
if(this==&source) return;
public:
AliITSstatistics();
AliITSstatistics(Int_t order);
- AliITSstatistics(AliITSstatistics &source); // copy constructor
- AliITSstatistics& operator=(AliITSstatistics &source); // operator=
+ AliITSstatistics(const AliITSstatistics &source); // copy constructor
+ AliITSstatistics& operator=(const AliITSstatistics &source); // operator=
virtual ~AliITSstatistics();
void Reset();
void AddValue(Double_t x,Double_t w);
Double_t GetNth(Int_t order);
Double_t GetMean() {// returns the mean
return GetNth(1);};
- Int_t GetN(){// returns the number of entries
+ Int_t GetN() const{// returns the number of entries
return fN;
};
- Int_t GetOrder(){// returns the order of the moment of the distribution
+ Int_t GetOrder() const {// returns the order of the moment of the distribution
return fOrder;
};
- Double_t GetXN(Int_t order){// returns X^N
+ Double_t GetXN(Int_t order) const{// returns X^N
return fX[order-1];
};
- Double_t GetWN(Int_t order){// returns W^N
+ Double_t GetWN(Int_t order)const {// returns W^N
return fW[order-1];
};
Double_t GetRMS();
ClassImp(AliITSvBeamTestITS04)
//_____________________________________________________________
-AliITSvBeamTestITS04::AliITSvBeamTestITS04() : AliITS()
-{
+ AliITSvBeamTestITS04::AliITSvBeamTestITS04() : AliITS(),
+fITSmotherVolume(0),
+fNspd(fgkNumberOfSPD),
+fNsdd(fgkNumberOfSDD),
+fNssd(fgkNumberOfSSD),
+fGeomDetOut(kFALSE),
+fGeomDetIn(kFALSE){
//
// Constructor
//
- SetNumberOfSPD(fgkNumberOfSPD);
- SetNumberOfSDD(fgkNumberOfSDD);
- SetNumberOfSSD(fgkNumberOfSSD);
+ // SetNumberOfSPD(fgkNumberOfSPD);
+ // SetNumberOfSDD(fgkNumberOfSDD);
+ // SetNumberOfSSD(fgkNumberOfSSD);
fIdN = 3;
fIdName = new TString[fIdN];
for(Int_t i=0; i<fIdN; i++) fIdSens[i] = 0;
//for writing out geometry
- fGeomDetOut = kFALSE;
+ //fGeomDetOut = kFALSE;
// for reading in geometry (JC)
- fGeomDetIn = kFALSE;
+ //fGeomDetIn = kFALSE;
for(Int_t a=0;a<60;a++) fWrite[a] = '\0';
}
//_____________________________________________________________
AliITSvBeamTestITS04::AliITSvBeamTestITS04(const char* name,const char *title)
- : AliITS(name,title)
+ : AliITS(name,title),
+fITSmotherVolume(0),
+fNspd(fgkNumberOfSPD),
+fNsdd(fgkNumberOfSDD),
+fNssd(fgkNumberOfSSD),
+fGeomDetOut(kFALSE),
+fGeomDetIn(kFALSE)
{
//
// Constructor
//
- SetNumberOfSPD(fgkNumberOfSPD);
- SetNumberOfSDD(fgkNumberOfSDD);
- SetNumberOfSSD(fgkNumberOfSSD);
+ //SetNumberOfSPD(fgkNumberOfSPD);
+ //SetNumberOfSDD(fgkNumberOfSDD);
+ //SetNumberOfSSD(fgkNumberOfSSD);
fIdN = 3;
fIdName = new TString[fIdN];
for(Int_t i=0; i<fIdN; i++) fIdSens[i] = 0;
//for writing out geometry
- fGeomDetOut = kFALSE; // Don't write .det file
+ //fGeomDetOut = kFALSE; // Don't write .det file
// for reading in geometry (JC)
- fGeomDetIn = kFALSE;
+ //fGeomDetIn = kFALSE;
for(Int_t a=0;a<60;a++) fWrite[a] = '\0';
}
//______________________________________________________________________
-AliITSvBeamTestITS04::AliITSvBeamTestITS04(const AliITSvBeamTestITS04 &source) : AliITS(source){
- //Copy constructor (dummy)
- if(&source == this) return;
- Warning("Copy Constructor","Not allowed to copy AliITSvSDD03");
- return;
+AliITSvBeamTestITS04::AliITSvBeamTestITS04(const AliITSvBeamTestITS04 &source) : AliITS(source),
+fITSmotherVolume(source.fITSmotherVolume),
+fNspd(source.fNspd),
+fNsdd(source.fNsdd),
+fNssd(source.fNssd),
+fGeomDetOut(source.fGeomDetOut),
+fGeomDetIn(source.fGeomDetIn){
+ //Copy constructor
+
}
//______________________________________________________________________
AliITSvBeamTestITS04& AliITSvBeamTestITS04::operator=(const AliITSvBeamTestITS04 &source){
ClassImp(AliITSvPPRcoarseasymm)
//_____________________________________________________________________________
-AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm() {
+AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm():
+fMajorVersion(9),
+fMinorVersion(0),
+fRails(0),
+fSuppMat(0) {
////////////////////////////////////////////////////////////////////////
// Standard default constructor for the ITS version 6.
////////////////////////////////////////////////////////////////////////
fIdN = 0;
fIdName = 0;
fIdSens = 0;
- fMajorVersion = 9;
- fMinorVersion = 0;
}
//_____________________________________________________________________________
-AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm(const char *name, const char *title) : AliITS(name, title){
+AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm(const char *name, const char *title) : AliITS(name, title),
+fMajorVersion(9),
+fMinorVersion(0),
+fRails(0),
+fSuppMat(0) {
////////////////////////////////////////////////////////////////////////
// Standard constructor for the ITS version 6.
////////////////////////////////////////////////////////////////////////
fIdName[5] = "ITS6";
fIdSens = new Int_t[fIdN];
for (Int_t i=0;i<fIdN;i++) fIdSens[i]=0;
- fMajorVersion = 9;
- fMinorVersion = 0;
}
//____________________________________________________________________________
AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm(const AliITSvPPRcoarseasymm &s) :
- AliITS(s){
+ AliITS(s),
+fMajorVersion(s.fMajorVersion),
+fMinorVersion(s.fMinorVersion),
+fRails(s.fRails),
+fSuppMat(s.fSuppMat){
////////////////////////////////////////////////////////////////////////
// Copy Constructor for ITS version 6.
////////////////////////////////////////////////////////////////////////
- if(&s == this) return;
- Warning("Copy Constructor","Not allowed to copy AliITSvPPRcoarseasymm");
- return;
}
//_____________________________________________________________________________
AliITSvPPRcoarseasymm& AliITSvPPRcoarseasymm::operator=(const AliITSvPPRcoarseasymm &source){
virtual void SetSupportMaterial(Int_t v=0){
// Set material of the services supports
fSuppMat = v;}
- virtual Int_t GetRails(){
+ virtual Int_t GetRails() const {
// Get flag for rails
return fRails;}
- virtual Int_t GetSupportMaterial(){
+ virtual Int_t GetSupportMaterial() const{
// Get material of the services supports
return fSuppMat;}
virtual Int_t GetMajorVersion() const {// return Major Version Number
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff