and paramters.
if (fITSgeom) delete fITSgeom;
}
//______________________________________________________________________
-AliITS::AliITS(AliITS &source){
+AliITS::AliITS(const AliITS &source) : AliDetector(source){
// Copy constructor. This is a function which is not allowed to be
// done to the ITS. It exits with an error.
// Inputs:
static TFile *file;
const char *addBgr = strstr(option,"Add");
+ evnt = nmodules; // Dummy use of variables to remove warnings
if (addBgr ) {
if(first) {
file=new TFile(filename);
AliITSLoader *pITSLoader = (AliITSLoader*)fLoader;
if (pITSLoader == 0x0) {
- Error("MakeTreeC","fLoader == 0x0");
+ Error("MakeTreeC","fLoader == 0x0 option=%s",option);
return;
}
if (pITSLoader->TreeC() == 0x0) pITSLoader->MakeTree("C");
AliITSDetType *iDetType = 0;
Int_t id,module,first=0;
for(module=0;module<geom->GetIndexMax();module++){
- id = geom->GetModuleType(module);
- if (!all && !det[id]) continue;
- if(det[id]) first = geom->GetStartDet(id);
- iDetType = DetType(id);
- rec = (AliITSClusterFinder*)iDetType->GetReconstructionModel();
- TClonesArray *itsDigits = this->DigitsAddress(id);
- if (!rec) {
- Error("DigitsToRecPoints",
- "The reconstruction class was not instanciated!");
- exit(1);
- } // end if !rec
- this->ResetDigits();
- TTree *TD = pITSloader->TreeD();
- if (all) {
- TD->GetEvent(lastentry+module);
- }
- else {
- TD->GetEvent(lastentry+(module-first));
- }
- Int_t ndigits = itsDigits->GetEntriesFast();
- if (ndigits) rec->FindRawClusters(module);
- pITSloader->TreeR()->Fill();
- ResetRecPoints();
- treeC->Fill();
- ResetClusters();
+ id = geom->GetModuleType(module);
+ if (!all && !det[id]) continue;
+ if(det[id]) first = geom->GetStartDet(id);
+ iDetType = DetType(id);
+ rec = (AliITSClusterFinder*)iDetType->GetReconstructionModel();
+ TClonesArray *itsDigits = this->DigitsAddress(id);
+ if (!rec) {
+ Error("DigitsToRecPoints",
+ "The reconstruction class was not instanciated! event=%d",
+ evNumber);
+ exit(1);
+ } // end if !rec
+ this->ResetDigits();
+ TTree *TD = pITSloader->TreeD();
+ if (all) {
+ TD->GetEvent(lastentry+module);
+ }else {
+ TD->GetEvent(lastentry+(module-first));
+ }
+ Int_t ndigits = itsDigits->GetEntriesFast();
+ if (ndigits) rec->FindRawClusters(module);
+ pITSloader->TreeR()->Fill();
+ ResetRecPoints();
+ treeC->Fill();
+ ResetClusters();
} // end for module
AliITS(); // Default creator.
AliITS(const char *name, const char *title); // standard Creator
virtual ~AliITS(); // destructor
- AliITS(AliITS &source); // copy constructor. Not to be used!
+ AliITS(const AliITS &source); // copy constructor. Not to be used!
AliITS& operator=(AliITS &source); // = operator. Not to be used!
virtual Int_t IsVersion() const {return 1;}
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
fNPeaks = 0;
}
//__________________________________________________________________________
-AliITSClusterFinder::AliITSClusterFinder(const AliITSClusterFinder &source){
+AliITSClusterFinder::AliITSClusterFinder(const AliITSClusterFinder &source) :
+ TObject(source){
// Copy Constructor
if(&source == this) return;
this->fDigits = source.fDigits;
virtual Bool_t IsNeighbor(TObjArray *digs,Int_t i,Int_t j[]) const;
// Given a cluster of digits, creates the nessesary RecPoint. May also
// do some peak separation.
- virtual void CreateRecPoints(TObjArray *cluster,Int_t mod){};
- virtual void FindCluster(Int_t i, Int_t j, AliITSRawCluster *c) {
- // find cluster
- }
- virtual void Decluster(AliITSRawCluster *cluster) {
- // Decluster
- }
+ virtual void CreateRecPoints(TObjArray *,Int_t){};
+ virtual void FindCluster(Int_t,Int_t,AliITSRawCluster *) {}// find cluster
+ virtual void Decluster(AliITSRawCluster *) {}// Decluster
virtual void SetNperMax(Int_t npermax=3) {
// Set max. Number of cells per local cluster
fNperMax = npermax;
virtual void CorrectCOG(){
// correct COG
}
- virtual Bool_t Centered(AliITSRawCluster *cluster) const {
- // cluster
+ virtual Bool_t Centered(AliITSRawCluster *) const {// cluster
return kTRUE;
}
- virtual void SplitByLocalMaxima(AliITSRawCluster *cluster) {
- // split by local maxima
- }
- virtual void FillCluster(AliITSRawCluster *cluster, Int_t) {
- // fiil cluster
- }
- virtual void FillCluster(AliITSRawCluster *cluster) {
- // fill cluster
+ virtual void SplitByLocalMaxima(AliITSRawCluster *){}//split by local maxima
+ virtual void FillCluster(AliITSRawCluster *,Int_t) {}// fiil cluster
+ virtual void FillCluster(AliITSRawCluster *cluster) {// fill cluster
FillCluster(cluster,1);
}
// set the fitting methods in the derived classes
SetDz();
}
//_____________________________________________________________________
-AliITSClusterFinderSPD::AliITSClusterFinderSPD(const AliITSClusterFinderSPD
- &source){
+AliITSClusterFinderSPD::AliITSClusterFinderSPD(
+ const AliITSClusterFinderSPD &source): AliITSClusterFinder(source){
// Copy Constructor
if(&source == this) return;
return *this;
}
//______________________________________________________________________
-AliITSClusterFinderSPDdubna::AliITSClusterFinderSPDdubna(const
- AliITSClusterFinderSPDdubna &s){
+AliITSClusterFinderSPDdubna::AliITSClusterFinderSPDdubna(
+ const AliITSClusterFinderSPDdubna &s): AliITSClusterFinder(s){
// The Copy constructortor the class AliITSClusterFinderSPDdugna
// It calles the = operator.
// Inputs:
if (GetCrossing(P,N)) {
//GetCrossingError(dP,dN);
+ dP = dN = prob = 0.0; // to remove unused variable warning.
AliITSRawClusterSSD cnew;
Int_t nstripsP=clusterP->GetNumOfDigits();
Int_t nstripsN=clusterN->GetNumOfDigits();
////////////////////////////////////////////////////////////////////////////////////////
-AliITSDDLRawData::AliITSDDLRawData(const AliITSDDLRawData &source){
+AliITSDDLRawData::AliITSDDLRawData(const AliITSDDLRawData &source) :
+ TObject(source){
//Copy Constructor
this->fIndex=source.fIndex;
this->fHalfStaveModule=source.fHalfStaveModule;
if(fReconst!=0) delete fReconst; fReconst = 0;
}
//______________________________________________________________________
-AliITSDetType::AliITSDetType(const AliITSDetType &source){
+AliITSDetType::AliITSDetType(const AliITSDetType &source) : TObject(source){
// Copy Constructor
if(&source == this) return;
// Option_t * opt "deb" ... more verbose output
//
- AliITSsimulationFastPoints *sim = new AliITSsimulationFastPoints();
- AliRunLoader* outrl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
- if (outrl == 0x0)
- {
- Error("Exec","Can not find Run Loader in output folder.");
- return;
- }
-
- AliLoader* outgime = outrl->GetLoader("ITSLoader");
- if (outgime == 0x0)
- {
- Error("Exec","Can not get TOF Loader from Output Run Loader.");
- return;
- }
-
- TTree* outputTreeR = outgime->TreeR();
- if (outputTreeR == 0x0)
- {
- outgime->MakeTree("R");
- outputTreeR = outgime->TreeR();
- }
-
- TClonesArray *recPoints = fITS->RecPoints();
+ AliITSsimulationFastPoints *sim = new AliITSsimulationFastPoints();
+ AliRunLoader* outrl = AliRunLoader::GetRunLoader(
+ fManager->GetOutputFolderName());
+ if (outrl == 0x0){
+ Error("Exec","Can not find Run Loader in output folder.");
+ return;
+ }
+ AliLoader* outgime = outrl->GetLoader("ITSLoader");
+ if (outgime == 0x0){
+ Error("Exec","Can not get TOF Loader from Output Run Loader.");
+ return;
+ }
+ if(strstr(opt,"deb"){
+ Info("Exec","sim=%p, outrl=%p, outgime=%p",sim,outrl,outgime);
+ }
+ TTree* outputTreeR = outgime->TreeR();
+ if (outputTreeR == 0x0){
+ outgime->MakeTree("R");
+ outputTreeR = outgime->TreeR();
+ }
+ TClonesArray *recPoints = fITS->RecPoints();
// TBranch *branch =
- fITS->MakeBranchInTree(outputTreeR,"ITSRecPointsF",&recPoints,4000,0);
+ fITS->MakeBranchInTree(outputTreeR,"ITSRecPointsF",&recPoints,4000,0);
- Int_t nModules;
- fITS->InitModules(-1,nModules);
+ Int_t nModules;
+ fITS->InitModules(-1,nModules);
// load hits into modules
- for (Int_t iFile = 0; iFile < fManager->GetNinputs(); iFile++)
- {
- AliRunLoader* rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(iFile));
- if (rl == 0x0)
- {
- Error("Exec","Can not find Run Loader in input %d folder.",iFile);
- return;
- }
+ for (Int_t iFile = 0; iFile < fManager->GetNinputs(); iFile++){
+ AliRunLoader* rl = AliRunLoader::GetRunLoader(
+ fManager->GetInputFolderName(iFile));
+ if (rl == 0x0){
+ Error("Exec","Can not find Run Loader in input %d folder.",iFile);
+ return;
+ }
- AliLoader* gime = rl->GetLoader("ITSLoader");
- if (gime == 0x0)
- {
- Error("Exec","Can not get TOF Loader from Input %d Run Loader.",iFile);
- return;
- }
+ AliLoader* gime = rl->GetLoader("ITSLoader");
+ if (gime == 0x0){
+ Error("Exec","Can not get TOF Loader from Input %d Run Loader.",
+ iFile);
+ return;
+ }
- gime->LoadHits();
- fITS->FillModules(gime->TreeH(),fManager->GetMask(iFile));
- gime->UnloadHits();
- }
+ gime->LoadHits();
+ fITS->FillModules(gime->TreeH(),fManager->GetMask(iFile));
+ gime->UnloadHits();
+ }
// transform hits to fast rec points
- AliITSgeom *geom = fITS->GetITSgeom();
- for(Int_t moduleIndex = 0; moduleIndex < geom->GetIndexMax(); moduleIndex++){
- sim->CreateFastRecPoints(moduleIndex);
-// branch->Fill();
- outputTreeR->Fill();
- fITS->ResetRecPoints();
- }
- outrl->WriteRecPoints("OVERWRITE");
+ AliITSgeom *geom = fITS->GetITSgeom();
+ for(Int_t moduleIndex = 0; moduleIndex<geom->GetIndexMax(); moduleIndex++){
+ sim->CreateFastRecPoints(moduleIndex);
+// branch->Fill();
+ outputTreeR->Fill();
+ fITS->ResetRecPoints();
+ }
+ outrl->WriteRecPoints("OVERWRITE");
// outputTreeR->AutoSave();
}
////////////////////////////////////////////////////////////////////////
public:
AliITSGeant3Geometry();
virtual ~AliITSGeant3Geometry(){}
- AliITSGeant3Geometry(const AliITSGeant3Geometry&) {}
- AliITSGeant3Geometry & operator=(const AliITSGeant3Geometry&)
- {return *this;}
+ AliITSGeant3Geometry(const AliITSGeant3Geometry &s) : TObject(s) {}
+ AliITSGeant3Geometry & operator=(const AliITSGeant3Geometry &s)
+ {if(&s==this) return *this; return *this;}
// Return number of children for volume idvol
Int_t NChildren(Int_t idvol);
}
//__________________________________________________________________________
-AliITSHNode::AliITSHNode(const AliITSHNode &source){
+AliITSHNode::AliITSHNode(const AliITSHNode &source) : TObject(source){
// Copy Constructor
if(&source == this) return;
this->fSymbol = source.fSymbol;
}
//__________________________________________________________________________
-AliITSHTable::AliITSHTable(const AliITSHTable &source){
+AliITSHTable::AliITSHTable(const AliITSHTable &source) : TObject(source){
// Copy Constructor
if(&source == this) return;
this->fSize = source.fSize;
return *this;
}
//______________________________________________________________________
-AliITSMapA1::AliITSMapA1(const AliITSMapA1 &source){
+AliITSMapA1::AliITSMapA1(const AliITSMapA1 &source) : AliITSMap(source){
// Copy Constructor
*this = source;
if (fHitMapD) delete[] fHitMapD;
}
//______________________________________________________________________
-AliITSMapA2::AliITSMapA2(const AliITSMapA2 &source){
+AliITSMapA2::AliITSMapA2(const AliITSMapA2 &source) : AliITSMapA1(source){
// Copy Constructor
if(&source == this) return;
TObject* AliITSMapA2::GetHit(Int_t i, Int_t dummy){
//return a pointer to the 1D histogram
+ dummy = 0; // added to remove unused variable warning.
if (fObjects) {
return fObjects->UncheckedAt(i);
} else return NULL;
fZ = AnodeOffset/10000.;
}
//______________________________________________________________________
-AliITSRawClusterSDD::AliITSRawClusterSDD( const AliITSRawClusterSDD & source){
+AliITSRawClusterSDD::AliITSRawClusterSDD(const AliITSRawClusterSDD & source):
+ AliITSRawCluster(source){
// copy constructor
fWing = source.fWing;
Bool_t test2 = kFALSE;
Bool_t test3 = kFALSE;
+ dx = dz = 0; // to remove unused variable warning.
// Diagonal clusters are included:
if(fXStop >= (cluster->XStart() -1) &&
fXStart <= (cluster->XStop()+1)) test2 = kTRUE;
AliITSRawClusterSSD::AliITSRawClusterSSD(Float_t Prob,Int_t Sp,Int_t Sn) {
// constructor
+ Prob = 0.0; // added to remove unused variable warning.
//fProbability = Prob;
fMultiplicity = Sp;
fMultiplicityN = Sn;
}
//__________________________________________________________________________
-AliITSInStream::AliITSInStream(const AliITSInStream &source){
+AliITSInStream::AliITSInStream(const AliITSInStream &source) : TObject(source){
// Copy Constructor
if(&source == this) return;
this->fStreamLen = source.fStreamLen;
}
//__________________________________________________________________________
-AliITSOutStream::AliITSOutStream(const AliITSOutStream &source){
+AliITSOutStream::AliITSOutStream(const AliITSOutStream &source):TObject(source){
// Copy Constructor
if(&source == this) return;
this->fStreamLen = source.fStreamLen;
void Use() { //if fQ<0 cluster is already associated with a track
fQ=-fQ;}
Int_t IsUsed() const {return (fQ<0) ? 1 : 0;} // checks Use condision
- Int_t Compare(const TObject *o) const { //to be defined
- return 0;}
+ Int_t Compare(const TObject *) const {return 0;} //to be defined
// Prints out the content of this class in ASCII format.
void Print(ostream *os);
// Reads in the content of this class in the format of Print
delete fCrossedClusterIndexes;
}
//______________________________________________________________________
-AliITSclusterSSD::AliITSclusterSSD(const AliITSclusterSSD &OneSCluster){
+AliITSclusterSSD::AliITSclusterSSD(const AliITSclusterSSD &OneSCluster) :
+ TObject(OneSCluster){
// copy constructor
if (this == &OneSCluster) return;
AliITSclusterSSD(Int_t ndigits, Int_t *DigitIndexes,
TObjArray *Digits, Bool_t side);
AliITSclusterSSD(const AliITSclusterSSD &source);
- AliITSclusterSSD& operator=( const AliITSclusterSSD & source);
+ AliITSclusterSSD& operator=( const AliITSclusterSSD & source);
void AddDigit(Int_t index){//adds on digit
(*fDigitsIndex)[fNDigits++]=index;}
- TObjArray* GetPointer2Digits(){// comment to be written
- return fDigits;}
+ TObjArray* GetPointer2Digits(){return fDigits;}// comment to be written
void SetPointer2Digits(TObjArray *digits){// comment to be written
fDigits = digits;}
Int_t GetNumOfDigits(){//Returns number of digits that creates this cluster
Int_t GetDigitIndex (Int_t digit) {// comment to be written
return (*fDigitsIndex)[digit];}
Int_t GetDigitStripNo(Int_t digit);
- Int_t GetFirstDigitStripNo(){// comment to be written
- return GetDigitStripNo(0);}
+ // comment to be written
+ Int_t GetFirstDigitStripNo(){return GetDigitStripNo(0);}
Int_t GetLastDigitStripNo(){// comment to be written
return GetDigitStripNo(fNDigits-1);}
//splits this one side cluster for two
//return index of cluster that it crosses with
Int_t GetCross(Int_t crIndex);
Int_t GetCrossNo() {// Returns number of crosses
- return fNCrosses;}
+ return fNCrosses;}
void DelCross(Int_t index);
Double_t GetPosition();
Double_t GetPositionError();
return fLeftNeighbour;}
void SetRightNeighbour(Bool_t nei) {// comment to be written
fRightNeighbour=nei;}
- void SetLeftNeighbour(Bool_t nei) {// comment to be written
- fLeftNeighbour=nei;}
- void SetNTracks(Int_t ntracks) {// set ntracks
- fNTracks=ntracks;}
- Int_t GetNTracks(){// comment to be written
- return fNTracks;}
- Bool_t GetSide(){// comment to be written
- return fSide;}
- Int_t CheckSatus(Int_t *tracks){//check if digits comes from the same track
- return 0;}
+ //comment to be written
+ void SetLeftNeighbour(Bool_t nei){fLeftNeighbour=nei;}
+ void SetNTracks(Int_t ntracks) {fNTracks=ntracks;}// set ntracks
+ Int_t GetNTracks(){return fNTracks;}// comment to be written
+ Bool_t GetSide(){return fSide;}// comment to be written
+ Int_t CheckSatus(Int_t *){return 0;}//check if dig's comes from same track
Int_t *GetTracks(Int_t &nt);
void Consume(){// comment
fConsumed = kTRUE;}
delete fInvalidN;
}
//______________________________________________________________________
-AliITSdcsSSD::AliITSdcsSSD(const AliITSdcsSSD &source){
+AliITSdcsSSD::AliITSdcsSSD(const AliITSdcsSSD &source) : TObject(source){
// Copy Constructor
if(&source == this) return;
Int_t GetNInvalidP(); //Number of invalid P strips
Int_t GetNInvalidN(); //Number of invalid N strips
// Creating invalid strips
- void SetInvalidP(Int_t strip, Bool_t side){//Set invalid if true
- }
- void SetInvalidN(Int_t strip, Bool_t side){//Set invalid if true
- }
+ void SetInvalidP(Int_t,Bool_t){}//Set invalid if true
+ void SetInvalidN(Int_t,Bool_t){}//Set invalid if true
Float_t GetCouplingPR() {// couplings
- return fCouplingPR;
- }
+ return fCouplingPR;}
Float_t GetCouplingPL() {// couplings
- return fCouplingPL;
- }
+ return fCouplingPL;}
Float_t GetCouplingNR() {// couplings
- return fCouplingNR;
- }
+ return fCouplingNR;}
Float_t GetCouplingNL() {// couplings
- return fCouplingNL;
- }
+ return fCouplingNL;}
protected:
//_____________________________________________
fTrackList = new TObjArray;
}
//__________________________________________________________________________
-AliITSTransientDigit::AliITSTransientDigit(const AliITSTransientDigit &source){
+AliITSTransientDigit::AliITSTransientDigit(const AliITSTransientDigit &source):
+ AliITSdigitSDD(source){
// Copy Constructor
if(&source == this) return;
this->fTrackList = source.fTrackList;
// AliITSmodule).
virtual Int_t *GetHits() {return 0;}
// returns track number kept in the array element i of fTracks
- virtual Int_t GetTrack(Int_t i) const {return 0;}
+ virtual Int_t GetTrack(Int_t) const {return 0;}
// returns hit number kept in the array element i of fHits
- virtual Int_t GetHit(Int_t i) const {return 0;}
+ virtual Int_t GetHit(Int_t) const {return 0;}
virtual Int_t GetCoord1() const {return fCoord1;} // returns fCoord1
virtual Int_t GetCoord2() const {return fCoord2;} // returns fCoord2
virtual Int_t GetSignal() const {return fSignal;} // returns fSignal
fclose(pf);
}
//______________________________________________________________________
-AliITSgeom::AliITSgeom(AliITSgeom &source){
+AliITSgeom::AliITSgeom(AliITSgeom &source) : TObject(source){
// The copy constructor for the AliITSgeom class. It calls the
// = operator function. See the = operator function for more details.
// Inputs are:
fm[0][0] = fm[1][1] = fm[2][2] = 1.0;
}
//----------------------------------------------------------------------
-AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &sourse){
+AliITSgeomMatrix::AliITSgeomMatrix(const AliITSgeomMatrix &sourse) :
+ TObject(sourse){
////////////////////////////////////////////////////////////////////////
-// The standard copy constructor. This make a full / proper copy of
+// The standard Copy constructor. This make a full / proper copy of
// this class.
////////////////////////////////////////////////////////////////////////
Int_t i,j;
fAnodeLowEdgeR = 0;
}
//________________________________________________________________________
-AliITSgeomSDD::AliITSgeomSDD(AliITSgeomSDD &source){
+AliITSgeomSDD::AliITSgeomSDD(AliITSgeomSDD &source) : TObject(source){
// Copy constructor
Int_t i;
Float_t anodeLowEdges[kNAnodes+1];
Int_t i;
+ if(npar<3){
+ Error("AliITSgeomSDD256","npar=%d<3. array par must be [3] or greater",
+ npar);
+ return;
+ } // end if
// cout << "AliITSgeomSDD256 default creator called: start" << end;
anodeLowEdges[0] = kAnodesZ;
for(i=0;i<kNAnodes;i++)anodeLowEdges[i+1] = kAnodePitch+anodeLowEdges[i];
virtual Float_t GetDz() const {// Get TBRIK Dz
if(fShapeSDD!=0) return fShapeSDD->GetDz();
else return 0.0;}
- virtual Float_t GetAnodeX(Int_t a,Int_t s) const { // returns X position of anode
- if(s==0) return fAnodeXL; else return fAnodeXR;}
- virtual Float_t GetAnodeZ(Int_t a,Int_t s)const { // returns X position of anode
+ virtual Float_t GetAnodeX(Int_t a,Int_t s) const {
+ // returns X position of anode
+ a = 0; if(s==0) return fAnodeXL; else return fAnodeXR;}
+ virtual Float_t GetAnodeZ(Int_t a,Int_t s)const {
+ // returns X position of anode
if(s==0) return 0.5*(fAnodeLowEdgeL[a]+fAnodeLowEdgeL[a+1]);
else return 0.5*(fAnodeLowEdgeR[a]+fAnodeLowEdgeR[a+1]);}
virtual void SetNAnodesL(Int_t s)
return;
}
//______________________________________________________________________
-AliITSgeomSPD::AliITSgeomSPD(AliITSgeomSPD &source){
+AliITSgeomSPD::AliITSgeomSPD(AliITSgeomSPD &source) : TObject(source){
// Copy constructor
*this = source; // just use the = operator for now.
for(i=0;i<knbinz;i++) dz += binSizeZ[i];
dz *= 0.5;
+ if(npar<3){
+ Error("AliITSgeomSPD425Short",
+ "npar=%d<3 array par must be at least [3] or larger",npar);
+ return;
+ } // end if
SetShape("ActiveSPD","Active volume of SPD","SPD SI DET",
par[0],par[1],par[2]);
if(TMath::Abs(dx-kdx)>1.0E-4 || TMath::Abs(dz-kdz)>1.0E-4)
fAngleP = 0.0;
fAngleN = 0.0;
}
-AliITSgeomSSD::AliITSgeomSSD(const AliITSgeomSSD &source){
+//______________________________________________________________________
+AliITSgeomSSD::AliITSgeomSSD(const AliITSgeomSSD &source) : TObject(source){
////////////////////////////////////////////////////////////////////////
// copy constructor
////////////////////////////////////////////////////////////////////////
void AliITSgeomSSD::Det2Local(Int_t a,Int_t c,Float_t &x,Float_t &z){
// Float_t d,b;
// Int_t i;
+ // use AliITSsegmentationSSD.
+ x=a;
+ z=c;
+ Error("Det2Locat","Use AliITSsegmentationSSD");
return;
}
//______________________________________________________________________
Float_t *leA,*leC; // array of low edges anode and cathorde.
Int_t i;
+ if(npar<3){
+ Error("AliITSgeomSSD275and75",
+ "npar=%d<3. array par must be [3] or larger.",npar);
+ return;
+ } // end if
leA = new Float_t[kNstrips+1];
leC = new Float_t[kNstrips+1];
leA[0] = -kDxyz[0];
Float_t *leA,*leC; // array of low edges anode and cathorde.
Int_t i;
+ if(npar<3){
+ Error("AliITSgeomSSD75and275",
+ "npar=%d<3. array par must be [3] or larger.",npar);
+ return;
+ } // end if
leA = new Float_t[kNstrips+1];
leC = new Float_t[kNstrips+1];
leA[0] = -kDxyz[0];
fITS = 0; // We don't delete this pointer since it is just a copy.
}
//____________________________________________________________________________
-AliITSmodule::AliITSmodule(const AliITSmodule &source){
+AliITSmodule::AliITSmodule(const AliITSmodule &source):TObject(source){
////////////////////////////////////////////////////////////////////////
// Copy Constructor
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
// Assignment operator
////////////////////////////////////////////////////////////////////////
- Error("AliITSmodule","AliITSmodule class has not to be copied! Exit.");
- exit(1);
- return *this; // fake return neded on Sun
+ if(&source == this) return *this;
+ Error("AliITSmodule","AliITSmodule class has not to be copied! Exit.");
+ exit(1);
+ return *this; // fake return neded on Sun
}
//_________________________________________________________________________
//
Float_t x2g,y2g,z2g;
Double_t s;
+ index = 0;
itsHit1->GetPositionG(x1g,y1g,z1g);
itsHit2->GetPositionG(x2g,y2g,z2g);
// path length
static Float_t x0,y0,z0;
+ index = 0;
if ((status&0x0002)!=0){ // entering
x0 = x;
y0 = y;
// through a volume.
Bool_t MedianHitL(AliITShit *h1,AliITShit *h2,
Float_t &x,Float_t &y,Float_t &z);
- void MedianHitL(Int_t index, AliITShit *itsHit1, AliITShit *itsHit2,
- Float_t &xMl, Float_t &yMl, Float_t &zMl){};
+ void MedianHitL(Int_t,AliITShit *,AliITShit *,Float_t &,Float_t &,
+ Float_t &){};
Double_t PathLength(Int_t index, AliITShit *itsHit1, AliITShit *itsHit2);
// returns both the track and hit index numbers for the given hit. Hits
// are kept on file according to their track index and hit index numbers.
return *this;
}
//______________________________________________________________________
-AliITSpList::AliITSpList(AliITSpList &source){
+AliITSpList::AliITSpList(AliITSpList &source) : AliITSMap(source){
// Copy operator
// Inputs:
// AliITSpList &source A AliITSpList Object
return *this;
}
//______________________________________________________________________
-AliITSpListItem::AliITSpListItem(AliITSpListItem &source){
+AliITSpListItem::AliITSpListItem(AliITSpListItem &source) : TObject(source){
// Copy operator
// Inputs:
// AliITSpListItem &source A AliITSpListItem Object
// Fill pList from digits. Not functional yet
void FillMap(){;}
// Sets threshold for significance. Not of relavance in this case.
- void SetThreshold(Int_t i){;}
+ void SetThreshold(Int_t i){i=0;}
// Sets a single hit. Not of relavance in this case.
- void SetHit(Int_t i,Int_t j,Int_t k){;}
+ void SetHit(Int_t i,Int_t j,Int_t k){i=j=k=0;}
// Flags a hit. Not of relavence in this case.
- void FlagHit(Int_t i,Int_t j){;}
+ void FlagHit(Int_t i,Int_t j){i=j=0;}
// returns the i,j index numbers from the liniarized index computed
// from GetIndex above.
void GetCell(Int_t index,Int_t &i,Int_t &j){
}
/*******************************************************/
-AliITSpackageSSD::AliITSpackageSSD(const AliITSpackageSSD &package)
-{
+AliITSpackageSSD::AliITSpackageSSD(const AliITSpackageSSD &package) :
+ TObject(package){
// copy constractor
Int_t i; //iterator
void AliITSreconstruction::SetOutputFile(TString filename){
// Set a file name for recpoints. Used only if this file is not the file
// containing digits. This obj is deleted by AliRun.
- Error("SetOutputFile","Use AliLoader::SetRecPointsFileName(TString&)instead");
+ Error("SetOutputFile",
+ "Use AliLoader::SetRecPointsFileName(TString&)instead filename=%s",
+ filename.Data());
}
//
// Set Electronics
- virtual void SetElectronics(Int_t p1) {}
+ virtual void SetElectronics(Int_t) {}
// Get Electronics
virtual Int_t Electronics() {return 0;}
// Set maximum Adc-count value
- virtual void SetMaxAdc(Float_t p1) {}
+ virtual void SetMaxAdc(Float_t) {}
// Get maximum Adc-count value
virtual Float_t MaxAdc() {return 0.;}
// Set maximum Adc-top value
- virtual void SetDynamicRange(Float_t p1) {}
+ virtual void SetDynamicRange(Float_t) {}
// Get maximum Adc-top value
virtual Float_t DynamicRange() {return 0.0;}
// Set Charge Loss Linear Coefficient
- virtual void SetChargeLoss(Float_t p1) {}
+ virtual void SetChargeLoss(Float_t) {}
// Get Charge Loss Linear Coefficient
virtual Float_t ChargeLoss() {return 0.0;}
// Get temperature [degree K]
virtual Float_t Temperature() {return fT;}
// Type of data - real or simulated
- virtual void SetDataType(const char *data) {}
+ virtual void SetDataType(const char *) {}
// Set the impurity concentrations in [#/cm^3]
virtual void SetImpurity(Double_t n=0.0){fN = n;}
// Returns the impurity consentration in [#/cm^3]
virtual const char *DataType() const {return "";}
// Set parameters options: "same" or read from "file" or "SetInvalid" or...
- virtual void SetParamOptions(const char* opt1,const char* opt2) {}
+ virtual void SetParamOptions(const char*,const char*) {}
// Set noise parameters
virtual void SetNoiseParam(Float_t, Float_t) {}
// Number of parameters to be set
virtual void GetNoiseParam(Float_t&, Float_t&) {}
// Zero-suppression option - could be 1D, 2D or non-ZeroSuppressed
- virtual void SetZeroSupp(const char* opt) {}
+ virtual void SetZeroSupp(const char*) {}
// Get zero-suppression option
virtual const char *ZeroSuppOption() const {return "";}
// Set thresholds
virtual Int_t MinVal() {return 0;};
// Set filenames
- virtual void SetFilenames(const char *f1,const char *f2,const char *f3) {}
+ virtual void SetFilenames(const char *,const char *,const char *) {}
// Filenames
virtual void Filenames(char*,char*,char*) {}
virtual Float_t DriftSpeed() {return 0.;}
virtual Bool_t OutputOption() {return kFALSE;}
virtual Bool_t Do10to8() {return kTRUE;}
- virtual void GiveCompressParam(Int_t *x) {}
+ virtual void GiveCompressParam(Int_t *) {}
//
// Detector type response methods
// Set number of sigmas over which cluster disintegration is performed
- virtual void SetNSigmaIntegration(Float_t p1) {}
+ virtual void SetNSigmaIntegration(Float_t) {}
// Get number of sigmas over which cluster disintegration is performed
virtual Float_t NSigmaIntegration() {return 0.;}
// Set number of bins for the gaussian lookup table
- virtual void SetNLookUp(Int_t p1) {}
+ virtual void SetNLookUp(Int_t) {}
// Get number of bins for the gaussian lookup table
virtual Int_t GausNLookUp() {return 0;}
// Get scaling factor for bin i-th from the gaussian lookup table
virtual Float_t GausLookUp(Int_t) {return 0.;}
// Set sigmas of the charge spread function
- virtual void SetSigmaSpread(Float_t p1, Float_t p2) {}
+ virtual void SetSigmaSpread(Float_t, Float_t) {}
// Get sigmas for the charge spread
- virtual void SigmaSpread(Float_t &s1, Float_t &s2) {}
+ virtual void SigmaSpread(Float_t &,Float_t &) {}
// Pulse height from scored quantity (eloss)
- virtual Float_t IntPH(Float_t eloss) {return 0.;}
+ virtual Float_t IntPH(Float_t) {return 0.;}
// Charge disintegration
virtual Float_t IntXZ(AliITSsegmentation *) {return 0.;}
// Electron mobility in Si. [cm^2/(Volt Sec)]. T in degree K, N in #/cm^3
// electrons or holes through a distance l [cm] caused by an applied
// voltage v [volt] through a distance d [cm] in any material at a
// temperature T [degree K].
- virtual Double_t SigmaDiffusion3D(Double_t l);
+ virtual Double_t SigmaDiffusion3D(Double_t);
// Returns the Gaussian sigma == <x^2 +y^2+z^2> [cm^2] due to the
// defusion of electrons or holes through a distance l [cm] caused by an
// applied voltage v [volt] through a distance d [cm] in any material at a
// temperature T [degree K].
- virtual Double_t SigmaDiffusion2D(Double_t l);
+ virtual Double_t SigmaDiffusion2D(Double_t);
// Returns the Gaussian sigma == <x^2+z^2> [cm^2] due to the defusion of
// electrons or holes through a distance l [cm] caused by an applied
// voltage v [volt] through a distance d [cm] in any material at a
// temperature T [degree K].
- virtual Double_t SigmaDiffusion1D(Double_t l);
+ virtual Double_t SigmaDiffusion1D(Double_t);
private:
Double_t fdv; // The parameter d/v where d is the disance over which the
// the potential v is applied d/v [cm/volts]
}
// Get number of intervals in which the gaussian lookup table is divided
Int_t GausNLookUp() {return fNcomps;}
- Float_t IntPH(Float_t eloss) {// Pulse height from scored quantity (eloss)
+ Float_t IntPH(Float_t) {// Pulse height from scored quantity (eloss)
return 0.;}
Float_t IntXZ(AliITSsegmentation *) {// Charge disintegration
return 0.;}
//
// Configuration methods
//
- virtual void SetDiffCoeff(Float_t p1=7.877e-3/*0.00433*/,Float_t dummy=0.) {
+ virtual void SetDiffCoeff(Float_t p1=7.877e-3/*0.00433*/,Float_t dummy=0.){
// Diffusion coefficient
- fDiffCoeff = p1;
- }
+ fDiffCoeff = p1;dummy = 0.;}
virtual Double_t DiffusionSigma(Double_t dy);
virtual void DiffCoeff(Float_t &diffc,Float_t &dummy) {
// Get diffusion coefficient
- diffc= fDiffCoeff;
+ diffc= fDiffCoeff;dummy = 0.0;
}
virtual void SetNoiseParam(Float_t n=200., Float_t b=0.) {
// set noise and baseline
return *this;
}
//_________________________________________________________________________
-AliITSresponseSSD::AliITSresponseSSD(const AliITSresponseSSD &src) {
+AliITSresponseSSD::AliITSresponseSSD(const AliITSresponseSSD &src) :
+ AliITSresponse(src) {
// copy constructor
*this = src;
virtual void SetDiffCoeff(Float_t p1=0.,Float_t dummy=0.) {
// Diffusion coefficient
- fDiffCoeff=p1;
+ fDiffCoeff=p1;dummy = 0.0;
}
virtual void DiffCoeff(Float_t &diffc,Float_t &dummy) {
// Get diffusion coefficient
- diffc= fDiffCoeff;
+ diffc= fDiffCoeff;dummy = 0.0;
}
virtual void SetNoiseParam(Float_t np=420., Float_t nn=625.) {
// Set Detector Segmentation Parameters
//
// Detector size
- virtual void SetDetSize(Float_t Dx, Float_t Dz, Float_t Dy) {}
+ virtual void SetDetSize(Float_t,Float_t,Float_t) {}
// Cell size
- virtual void SetPadSize(Float_t p1, Float_t p2) {}
+ virtual void SetPadSize(Float_t,Float_t) {}
// Maximum number of cells along the two coordinates
- virtual void SetNPads(Int_t p1, Int_t p2) {}
+ virtual void SetNPads(Int_t,Int_t) {}
// Returns the maximum number of cells (digits) posible
virtual Int_t GetNPads(){return 0;}
// Set angles - find a generic name fit for other detectors as well
// might be useful for beam test setups (3 angles ?)
- virtual void SetAngles(Float_t p1, Float_t p2) {}
+ virtual void SetAngles(Float_t, Float_t) {}
// Set layer
- virtual void SetLayer(Int_t l) {}
+ virtual void SetLayer(Int_t) {}
// Transform from real to cell coordinates
- virtual void GetPadIxz(Float_t x ,Float_t z ,Int_t &ix,Int_t &iz) {}
+ virtual void GetPadIxz(Float_t,Float_t,Int_t &,Int_t &) {}
// Transform from cell to real coordinates
- virtual void GetPadCxz(Int_t ix, Int_t iz, Float_t &x ,Float_t &z ) {}
+ virtual void GetPadCxz(Int_t,Int_t,Float_t &,Float_t &) {}
// Transform from real global to local coordinates
- virtual void GetLocal(Int_t module,Float_t *g ,Float_t *l) {}
+ virtual void GetLocal(Int_t,Float_t *,Float_t *) {}
// Transform from real local to global coordinates
- virtual void GetGlobal(Int_t module,Float_t *l ,Float_t *g) {}
+ virtual void GetGlobal(Int_t,Float_t *,Float_t *) {}
// Local transformation of real local coordinates -
- virtual void GetPadTxz(Float_t &x ,Float_t &z) {}
+ virtual void GetPadTxz(Float_t &,Float_t &) {}
// Transformation from Geant cm detector center local coordinates
// to detector segmentation/cell coordiantes starting from (0,0).
- virtual void LocalToDet(Float_t x,Float_t z,Int_t &ix,Int_t &iz){}
+ virtual void LocalToDet(Float_t,Float_t,Int_t &,Int_t &){}
// Transformation from detector segmentation/cell coordiantes starting
// from (0,0) to Geant cm detector center local coordinates.
- virtual void DetToLocal(Int_t ix,Int_t iz,Float_t &x,Float_t &z){}
+ virtual void DetToLocal(Int_t,Int_t,Float_t &,Float_t &){}
// Initialisation
virtual void Init() {}
//
//
// Iterate over cells
// Initialiser
- virtual void FirstPad
- (Float_t xhit, Float_t zhit, Float_t dx, Float_t dz) {}
+ virtual void FirstPad(Float_t,Float_t,Float_t,Float_t) {}
// Stepper
virtual void NextPad() {}
// Condition
virtual Int_t MorePads() {return 0;}
//
// Get next neighbours
- virtual void Neighbours(Int_t iX, Int_t iZ, Int_t* Nlist,
- Int_t Xlist[10], Int_t Zlist[10]) {}
+ virtual void Neighbours(Int_t,Int_t,Int_t*,Int_t[10],Int_t[10]) {}
//
// Current cell cursor during disintegration
// x-coordinate
virtual Int_t Iz() {return 0;}
//
// Signal Generation Condition during Stepping
- virtual Int_t SigGenCond(Float_t x, Float_t y, Float_t z) {return 0;}
+ virtual Int_t SigGenCond(Float_t,Float_t,Float_t) {return 0;}
// Initialise signal generation at coord (x,y,z)
- virtual void SigGenInit(Float_t x, Float_t y, Float_t z) {}
+ virtual void SigGenInit(Float_t,Float_t,Float_t) {}
// Current integration limits
- virtual void IntegrationLimits
- (Float_t& x1, Float_t& x2, Float_t& z1, Float_t& z2) {}
+ virtual void IntegrationLimits(Float_t&,Float_t&,Float_t&,Float_t&) {}
// Test points for auto calibration
- virtual void GiveTestPoints(Int_t &n, Float_t *x, Float_t *z) {}
+ virtual void GiveTestPoints(Int_t &,Float_t *,Float_t *) {}
// Function for systematic corrections
// Set the correction function
virtual void SetCorrFunc(Int_t, TF1*) {}
ClassDef(AliITSsegmentation,1) //Segmentation virtual base class
};
#endif
-
-
-
-
-
// Print SDD segmentation Parameters
cout << "**************************************************" << endl;
- cout << " Silicon Drift Detector Segmentation Parameters " << endl;
+ cout << " Silicon Drift Detector Segmentation Parameters " << opt << endl;
cout << "**************************************************" << endl;
cout << "Number of Time Samples: " << fNsamples << endl;
cout << "Number of Anodes: " << fNanodes << endl;
// Set Detector Segmentation Parameters
//
// Detector size : x,z,y
- virtual void SetDetSize
- (Float_t p1=35085., Float_t p2=75264., Float_t p3= 300.)
+ virtual void SetDetSize(Float_t p1=35085.,Float_t p2=75264.,
+ Float_t p3=300.)
{fDx=p1; fDz=p2; fDy=p3;}
// Cell size dz*dx
// Detector thickness
virtual Float_t Dy() {return fDy;}
// Cell size in x
- virtual Float_t Dpx(Int_t dummy) {return fTimeStep;}
+ virtual Float_t Dpx(Int_t) {return fTimeStep;}
// Cell size in z
- virtual Float_t Dpz(Int_t dummy) {return fPitch;}
+ virtual Float_t Dpz(Int_t) {return fPitch;}
// Maximum number of samples in x
virtual Int_t Npx() {return fNsamples;}
//
// Get next neighbours
- virtual void Neighbours
- (Int_t iX, Int_t iZ, Int_t* Nlist, Int_t Xlist[10], Int_t Zlist[10]);
+ virtual void Neighbours(Int_t iX,Int_t iZ,Int_t* Nlist,Int_t Xlist[10],
+ Int_t Zlist[10]);
// Set cell position
- virtual void SetPad(Int_t, Int_t) {}
+ virtual void SetPad(Int_t,Int_t) {}
// Set hit position
- virtual void SetHit(Float_t, Float_t) {}
+ virtual void SetHit(Float_t,Float_t) {}
//
// Iterate over cells
// Initialiser
- virtual void FirstPad
- (Float_t xhit, Float_t zhit, Float_t dx, Float_t dz) {}
+ virtual void FirstPad(Float_t,Float_t,Float_t,Float_t){}
// Stepper
virtual void NextPad() {}
// Condition
virtual Int_t Iz() {return 0;}
//
// Signal Generation Condition during Stepping
- virtual Int_t SigGenCond(Float_t x, Float_t y, Float_t z) {return 0;}
+ virtual Int_t SigGenCond(Float_t,Float_t,Float_t){return 0;}
// Initialise signal generation at coord (x,y,z)
- virtual void SigGenInit(Float_t x, Float_t y, Float_t z) {}
+ virtual void SigGenInit(Float_t,Float_t,Float_t){}
// Current integration limits
- virtual void IntegrationLimits
- (Float_t& x1, Float_t& x2, Float_t& z1, Float_t& z2) {}
+ virtual void IntegrationLimits(Float_t&,Float_t&,Float_t&,Float_t&) {}
// Test points for auto calibration
- virtual void GiveTestPoints(Int_t &n, Float_t *x, Float_t *z) {}
+ virtual void GiveTestPoints(Int_t &, Float_t *, Float_t *) {}
// Function for systematic corrections
// Set the correction function
virtual void SetCorrFunc(Int_t, TF1*) {}
//_____________________________________________________________________________
Float_t AliITSsegmentationSPD::ZpitchFromCol300(Int_t col) {
// returns Z pixel pitch for 300 micron pixels.
- return 300.0;
+
+ col = 0; // done to remove unused variable warning.
+ return 300.0;
}
//_____________________________________________________________________________
Float_t AliITSsegmentationSPD::ColFromZ(Float_t z) {
return *this;
}
//____________________________________________________________________________
-AliITSsegmentationSPD::AliITSsegmentationSPD(AliITSsegmentationSPD &source){
+AliITSsegmentationSPD::AliITSsegmentationSPD(AliITSsegmentationSPD &source) :
+ AliITSsegmentation(source){
// copy constructor
*this = source;
}
// Transform from pixel to real coordinates
virtual void GetPadCxz(Int_t ix,Int_t iz,Float_t &x,Float_t &z);
// Transform from real global to local coordinates
- virtual void GetLocal(Int_t module,Float_t *g ,Float_t *l) {}
+ //virtual void GetLocal(Int_t module,Float_t *g ,Float_t *l) {}
// Transform from real local to global coordinates
- virtual void GetGlobal(Int_t module,Float_t *l ,Float_t *g) {}
+ //virtual void GetGlobal(Int_t module,Float_t *l ,Float_t *g) {}
// Local transformation of real local coordinates -
virtual void GetPadTxz(Float_t &x ,Float_t &z);
// Transformation from Geant cm detector center local coordinates
return *this;
}
//______________________________________________________________________
-AliITSsegmentationSSD::AliITSsegmentationSSD(AliITSsegmentationSSD &source){
+AliITSsegmentationSSD::AliITSsegmentationSSD(AliITSsegmentationSSD &source):
+ AliITSsegmentation(source){
// copy constructor
*this = source;
}
{fDx=p1; fDz=p2; fDy=p3;}
// Strip size
- virtual void SetPadSize(Float_t pitch=95., Float_t dummy=1.)
- {fPitch=pitch;}
+ virtual void SetPadSize(Float_t pitch=95.,Float_t d=1.0)
+ {fPitch=pitch;d=1.;}
// Maximum number of strips along the two coordinates
- virtual void SetNPads(Int_t p1=768, Int_t dummy=1)
- {fNstrips=p1;}
+ virtual void SetNPads(Int_t p1=768,Int_t d=1){fNstrips=p1;d=1;}
// Returns the maximum number of cells (digits) posible
virtual Int_t GetNPads(){return 2*fNstrips;}
virtual void GetPadTxz(Float_t &x , Float_t &z);
// Transform from real global to local coordinates
- virtual void GetLocal(Int_t module,Float_t *g ,Float_t *l) {}
+ virtual void GetLocal(Int_t,Float_t *,Float_t *) {}
// Transform from real local to global coordinates
- virtual void GetGlobal(Int_t module,Float_t *l ,Float_t *g) {}
+ virtual void GetGlobal(Int_t,Float_t *,Float_t *) {}
// Transformation from Geant cm detector center local coordinates
// to detector P and N side strip numbers..
virtual void LocalToDet(Float_t x,Float_t z,Int_t &iP,Int_t &iN);
delete fpList;
}
//__________________________________________________________________________
-AliITSsimulation::AliITSsimulation(const AliITSsimulation &source){
+AliITSsimulation::AliITSsimulation(const AliITSsimulation &source) :
+ TObject(source){
// Copy Constructor
if(&source == this) return;
// ***************** Hits -> SDigits ******************
// digitize module using the "slow" detector simulator creating
// summable digits.
- virtual void SDigitiseModule(AliITSmodule *mod,Int_t module,Int_t event){;}
+ virtual void SDigitiseModule(AliITSmodule *,Int_t,Int_t){;}
// ***************** sum of SDigits -> Digits **********
// Reset module arrays (maps), etc
- virtual void InitSimulationModule( Int_t module, Int_t event ){;}
+ virtual void InitSimulationModule(Int_t,Int_t){;}
// add (sum) a new list of summable digits to module,
// add an offset (mask) to the track numbers. Returns kTRUE if there
// is a "good" signal in this module.
// **************** Hits -> Digits *********************
// digitize module using the "slow" detector simulator creating digits.
- virtual void DigitiseModule(AliITSmodule *mod,Int_t module,Int_t event) {;}
+ virtual void DigitiseModule(AliITSmodule *,Int_t,Int_t) {;}
// digitizes module using the "fast" detector simulator.
- virtual void CreateFastRecPoints(AliITSmodule *mod,Int_t module,
- TRandom *rndm) {}
+ virtual void CreateFastRecPoints(AliITSmodule *,Int_t,
+ TRandom *) {;}
// Return pointer to Response model
virtual AliITSresponse* GetResponseModel(){return fResponse;}
// set pointer to Response model
Float_t x1,y1,z1;
AliITShit *hit;
+ if(rndm!=0) module=0; // fix unsued parameter warnings.
fSx->Reset(); // Start out with things clearly zeroed
fSz->Reset(); // Start out with things clearly zeroed
e = 0.; // Start out with things clearly zeroed
rpSPD.fTracks[2]=-3;
rpSPD.SetX(fSx->GetMean());
rpSPD.SetZ(fSz->GetMean());
- rpSPD.SetdEdX(0.0);
+ rpSPD.SetdEdX(e);
rpSPD.SetQ(1.0);
a1 = fSx->GetRMS(); a1 *= a1; a1 += kRMSx*kRMSx;
// if(a1>1.E5) printf("addSPD: layer=%d track #%d dedx=%e sigmaX2= %e ",
SetCheckNoise();
}
//______________________________________________________________________
-AliITSsimulationSDD::AliITSsimulationSDD(AliITSsimulationSDD &source){
+AliITSsimulationSDD::AliITSsimulationSDD(AliITSsimulationSDD &source) :
+ AliITSsimulation(source){
// Copy constructor to satify Coding roules only.
if(this==&source) return;
TObjArray* GetHistArray() {return fHis;}
// create a separate tree for background monitoring (2D)
virtual void MakeTreeB(Option_t *option="B")
- { fTreeB = new TNtuple("ntuple","2D backgr","nz:nl:nh:low:anode");}
+ { if(strstr(option,"B"))
+ fTreeB = new TNtuple("ntuple", "2D backgr","nz:nl:nh:low:anode");}
// presently a dummy routine use TreeB() instead
void GetTreeB(Int_t) { }
// Return pointer to TreeB
} // end if
}
//______________________________________________________________________
-AliITSsimulationSPD::AliITSsimulationSPD(const AliITSsimulationSPD &source){
+AliITSsimulationSPD::AliITSsimulationSPD(const AliITSsimulationSPD &source) :
+ AliITSsimulation(source){
// Copy Constructor
if(&source == this) return;
Int_t *fcolpixel = new Int_t[number];
Double_t *fenepixel = new Double_t[number];
+ dummy0 = dummy1; // remove unsued variable warning.
fModule = mod->GetIndex();
// Array of pointers to store the track index of the digits
Int_t *fcolpixel = new Int_t[number];
Double_t *fenepixel = new Double_t[number];
+ dummy0 = dummy1; // remove unsued variable warning.
// Array of pointers to store the track index of the digits
// leave +1, otherwise pList crashes when col=256, row=192
fModule = mod->GetIndex();
Float_t * charges = new Float_t[size];
Int_t j1;
+ module=0; // remove unused variable warning.
for(j1=0;j1<size;j1++){tracks[j1]=-3;hits[j1]=-1;charges[j1]=0.0;}
for (Int_t r=1;r<=GetNPixelsZ();r++) {
for (Int_t c=1;c<=GetNPixelsX();c++) {
//______________________________________________________________________
AliITSsimulationSPDdubna::AliITSsimulationSPDdubna(const
AliITSsimulationSPDdubna
- &source){
+ &source):
+ AliITSsimulation(source){
// Copy Constructor
if(&source == this) return;
this->fMapA2 = source.fMapA2;
Int_t module = 0;
+ event = 0; // remove unused variable warning.
if(!(mod->GetNhits())) return;// if module has no hits don't create Sdigits
fModule = mod->GetIndex();
HitToSDigit(mod, module, mask, fpList);
// Return:
// none
- fModule = mod->GetIndex(); //This calls the module for HitToSDigit
+ fModule = module = mod->GetIndex();//This calls the module for HitToSDigit
HitToSDigit(mod,fModule, dummy, fpList);
ChargeToSignal(fpList);
// fMapA2->ClearMap();
// none
// fMapA2->AddSignal(iz, ix, signal);
+ module = fModule; // remove unused variable warning.
pList->AddSignal(iz+1,ix+1, trk, ht, fModule, signal);
}
//______________________________________________________________________
// none
// fMapA2->AddSignal(iz, ix, noise);
+ sig = 0.0; // remove unused variable warning.
pList->AddNoise(iz+1,ix+1, fModule, noise);
}
//______________________________________________________________________
Double_t x,y,z,t,tp,st,dt=0.2,el,sig;
Double_t thick = kmictocm*GetSeg()->Dy();
+ module = dummy = pList->GetNEnteries(); // remove unused varuable warning.
if(nhits<=0) return;
for(h=0;h<nhits;h++){
#ifdef DEBUG
Float_t x,z;
Double_t x1,x2,z1,z2,s,sp;
+ y0 = ti; // remove unused variable warning.
if(sig<=0.0) {
fpList->AddSignal(iz0+1,ix0+1,t,hi,mod,el);
return;
Float_t xPitch = GetSeg()->Dpx(0);
TObjArray *fHits = mod->GetHits();
- module = mod->GetIndex();
+ module = dummy = mod->GetIndex();
Int_t nhits = fHits->GetEntriesFast();
if (!nhits) return;
#ifdef DEBUG
return *this;
}
//______________________________________________________________________
-AliITSsimulationSSD::AliITSsimulationSSD(const AliITSsimulationSSD &source){
+AliITSsimulationSSD::AliITSsimulationSSD(const AliITSsimulationSSD &source):
+ AliITSsimulation(source){
// copy constructor
*this = source;
// Digitizes hits for one SSD module
Int_t module = mod->GetIndex();
+ dummy0 = dummy1 = 0; // remove unused variable warning.
HitsToAnalogDigits(mod,fpList);
SDigitToDigit(module,fpList);
Int_t dummy1) {
// Produces Summable/Analog digits and writes them to the SDigit tree.
- HitsToAnalogDigits(mod,fpList);
+ dummy0 = dummy1 = 0; // remove unused variable warning
+ HitsToAnalogDigits(mod,fpList);
- WriteSDigits(fpList);
+ WriteSDigits(fpList);
- fpList->ClearMap();
- fMapA2->ClearMap();
+ fpList->ClearMap();
+ fMapA2->ClearMap();
}
//______________________________________________________________________
void AliITSsimulationSSD::SDigitToDigit(Int_t module,AliITSpList *pList){
y = y0 + (j+0.5)*dey;
if ( y > (GetSegmentation()->Dy()/2+10)*1.0E-4 ) {
// check if particle is within the detector
- Warning("HitToDigit","hit out of detector y0=%e,y=%e,dey=%e,j =%e",
- y0,y,dey,j);
+ Warning("HitToDigit",
+ "hit out of detector y0=%e,y=%e,dey=%e,j =%e module=%d",
+ y0,y,dey,j,module);
return;
} // end if
z = z0 + (j+0.5)*dez;
return *this;
}
//_______________________________________________________________
-AliITSstatistics::AliITSstatistics(AliITSstatistics &source){
+AliITSstatistics::AliITSstatistics(AliITSstatistics &source) : TObject(source){
// Copy constructor
if(this==&source) return;
return *this;
}
//_______________________________________________________________
-AliITSstatistics2::AliITSstatistics2(AliITSstatistics2 &source){
+AliITSstatistics2::AliITSstatistics2(AliITSstatistics2 &source):
+ TObject(source){
// Copy constructor
if(this==&source) return;
}
//____________________________________________________________________________
-AliITSv1::AliITSv1(const AliITSv1 &source){
+AliITSv1::AliITSv1(const AliITSv1 &source) : AliITS(source){
////////////////////////////////////////////////////////////////////////
// Copy Constructor for ITS version 1.
////////////////////////////////////////////////////////////////////////
strncpy(fWrite,fEuclidGeomDet,60);
}
//____________________________________________________________________________
-AliITSv5::AliITSv5(const AliITSv5 &source){
+AliITSv5::AliITSv5(const AliITSv5 &source) : AliITS(source){
////////////////////////////////////////////////////////////////////////
// Copy Constructor for ITS version 5.
////////////////////////////////////////////////////////////////////////
strncpy(fWrite,fEuclidGeomDet,60);
}
//____________________________________________________________________________
-AliITSv5asymm::AliITSv5asymm(const AliITSv5asymm &source){
+AliITSv5asymm::AliITSv5asymm(const AliITSv5asymm &source):AliITS(source){
////////////////////////////////////////////////////////////////////////
// Copy Constructor for ITS version 5.
////////////////////////////////////////////////////////////////////////
strncpy(fWrite,fEuclidGeomDet,60);
}
//____________________________________________________________________________
-AliITSv5symm::AliITSv5symm(const AliITSv5symm &source){
+AliITSv5symm::AliITSv5symm(const AliITSv5symm &source) : AliITS(source){
////////////////////////////////////////////////////////////////////////
// Copy Constructor for ITS version 5.
////////////////////////////////////////////////////////////////////////
strncpy(fWrite,fEuclidGeomDet,60);
}
//____________________________________________________________________________
-AliITSvPPRasymm::AliITSvPPRasymm(const AliITSvPPRasymm &source){
+AliITSvPPRasymm::AliITSvPPRasymm(const AliITSvPPRasymm &source):AliITS(source){
////////////////////////////////////////////////////////////////////////
// Copy Constructor for ITS version 8.
////////////////////////////////////////////////////////////////////////
fIdN = 6;
fIdName = new TString[fIdN];
+ fIdName[0] = name; // removes warning message
fIdName[0] = "ITS1";
fIdName[1] = "ITS2";
fIdName[2] = "ITS3";
strncpy(fWrite,fEuclidGeomDet,60);
}
//______________________________________________________________________
-AliITSvPPRasymmFMD::AliITSvPPRasymmFMD(const AliITSvPPRasymmFMD &source){
+AliITSvPPRasymmFMD::AliITSvPPRasymmFMD(const AliITSvPPRasymmFMD &source) :
+ AliITS(source){
// Copy Constructor for ITS version 10. This function is not to be
// used. If any other instance of this function, other than "this" is
// passed, an error message is returned.
fMinorVersion = 0;
}
//____________________________________________________________________________
-AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm(const AliITSvPPRcoarseasymm &source){
+AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm(const AliITSvPPRcoarseasymm &s) :
+ AliITS(s){
////////////////////////////////////////////////////////////////////////
// Copy Constructor for ITS version 6.
////////////////////////////////////////////////////////////////////////
- if(&source == this) return;
+ if(&s == this) return;
Warning("Copy Constructor","Not allowed to copy AliITSvPPRcoarseasymm");
return;
}
fMinorVersion = 0;
}
//____________________________________________________________________________
-AliITSvPPRcoarsesymm::AliITSvPPRcoarsesymm(const AliITSvPPRcoarsesymm &source){
+AliITSvPPRcoarsesymm::AliITSvPPRcoarsesymm(const AliITSvPPRcoarsesymm &s) :
+AliITS(s){
////////////////////////////////////////////////////////////////////////
// Copy Constructor for ITS version 7.
////////////////////////////////////////////////////////////////////////
- if(&source == this) return;
+ if(&s == this) return;
Warning("Copy Constructor","Not allowed to copy AliITSvPPRcoarsesymm");
return;
}
strncpy(fWrite,fEuclidGeomDet,60);
}
//______________________________________________________________________
-AliITSvSPD02::AliITSvSPD02(const AliITSvSPD02 &source){
+AliITSvSPD02::AliITSvSPD02(const AliITSvSPD02 &source) : AliITS(source){
////////////////////////////////////////////////////////////////////////
// Copy Constructor for ITS SPD test beam 2002 version 1.
// This class is not to be copied. Function only dummy.
for(i=0;i<60;i++) fEuclidGeomDet[i] = '\0';
}
//____________________________________________________________________________
-AliITSvtest::AliITSvtest(const AliITSvtest &source){
+AliITSvtest::AliITSvtest(const AliITSvtest &source) : AliITS(source){
////////////////////////////////////////////////////////////////////////
// Copy Constructor for ITS test version.
////////////////////////////////////////////////////////////////////////