Fixed compiler warnings with regards to copy construtors and unused variabls
authornilsen <nilsen@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 14 Aug 2003 20:24:52 +0000 (20:24 +0000)
committernilsen <nilsen@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 14 Aug 2003 20:24:52 +0000 (20:24 +0000)
and paramters.

67 files changed:
ITS/AliITS.cxx
ITS/AliITS.h
ITS/AliITSClusterFinder.cxx
ITS/AliITSClusterFinder.h
ITS/AliITSClusterFinderSPD.cxx
ITS/AliITSClusterFinderSPDdubna.cxx
ITS/AliITSClusterFinderSSD.cxx
ITS/AliITSDDLRawData.cxx
ITS/AliITSDetType.cxx
ITS/AliITSFDigitizer.cxx
ITS/AliITSGeant3Geometry.h
ITS/AliITSHuffman.cxx
ITS/AliITSMapA1.cxx
ITS/AliITSMapA2.cxx
ITS/AliITSRawCluster.cxx
ITS/AliITSRawData.cxx
ITS/AliITSRecPoint.h
ITS/AliITSclusterSSD.cxx
ITS/AliITSclusterSSD.h
ITS/AliITSdcsSSD.cxx
ITS/AliITSdcsSSD.h
ITS/AliITSdigit.cxx
ITS/AliITSdigit.h
ITS/AliITSgeom.cxx
ITS/AliITSgeomMatrix.cxx
ITS/AliITSgeomSDD.cxx
ITS/AliITSgeomSDD.h
ITS/AliITSgeomSPD.cxx
ITS/AliITSgeomSSD.cxx
ITS/AliITSmodule.cxx
ITS/AliITSmodule.h
ITS/AliITSpList.cxx
ITS/AliITSpList.h
ITS/AliITSpackageSSD.cxx
ITS/AliITSreconstruction.cxx
ITS/AliITSresponse.h
ITS/AliITSresponseSDD.h
ITS/AliITSresponseSPDdubna.h
ITS/AliITSresponseSSD.cxx
ITS/AliITSresponseSSD.h
ITS/AliITSsegmentation.h
ITS/AliITSsegmentationSDD.cxx
ITS/AliITSsegmentationSDD.h
ITS/AliITSsegmentationSPD.cxx
ITS/AliITSsegmentationSPD.h
ITS/AliITSsegmentationSSD.cxx
ITS/AliITSsegmentationSSD.h
ITS/AliITSsimulation.cxx
ITS/AliITSsimulation.h
ITS/AliITSsimulationFastPointsV0.cxx
ITS/AliITSsimulationSDD.cxx
ITS/AliITSsimulationSDD.h
ITS/AliITSsimulationSPD.cxx
ITS/AliITSsimulationSPDdubna.cxx
ITS/AliITSsimulationSSD.cxx
ITS/AliITSstatistics.cxx
ITS/AliITSstatistics2.cxx
ITS/AliITSv1.cxx
ITS/AliITSv5.cxx
ITS/AliITSv5asymm.cxx
ITS/AliITSv5symm.cxx
ITS/AliITSvPPRasymm.cxx
ITS/AliITSvPPRasymmFMD.cxx
ITS/AliITSvPPRcoarseasymm.cxx
ITS/AliITSvPPRcoarsesymm.cxx
ITS/AliITSvSPD02.cxx
ITS/AliITSvtest.cxx

index 9477175..3d29a55 100644 (file)
@@ -275,7 +275,7 @@ AliITS::~AliITS(){
     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:
@@ -738,6 +738,7 @@ void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,
     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);
@@ -1345,7 +1346,7 @@ void AliITS::MakeTreeC(Option_t *option){
   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");
@@ -1681,31 +1682,31 @@ void AliITS::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt){
   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
 
 
index 2c5a572..a21cfe6 100644 (file)
@@ -44,7 +44,7 @@ class AliITS : public AliDetector {
     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);
index 2f43b9e..214a823 100644 (file)
@@ -78,7 +78,8 @@ AliITSClusterFinder::~AliITSClusterFinder(){
     fNPeaks       = 0;
 }
 //__________________________________________________________________________
-AliITSClusterFinder::AliITSClusterFinder(const AliITSClusterFinder &source){
+AliITSClusterFinder::AliITSClusterFinder(const AliITSClusterFinder &source) :
+    TObject(source){
     //     Copy Constructor 
     if(&source == this) return;
     this->fDigits = source.fDigits;
index baa57d9..5e4ac22 100644 (file)
@@ -70,13 +70,9 @@ class AliITSClusterFinder :public TObject{
     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;
@@ -95,18 +91,12 @@ class AliITSClusterFinder :public TObject{
     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
index b550858..ff953df 100644 (file)
@@ -54,8 +54,8 @@ AliITSClusterFinderSPD::AliITSClusterFinderSPD(){
     SetDz();
 }
 //_____________________________________________________________________
-AliITSClusterFinderSPD::AliITSClusterFinderSPD(const AliITSClusterFinderSPD 
-                                              &source){
+AliITSClusterFinderSPD::AliITSClusterFinderSPD(
+         const AliITSClusterFinderSPD &source): AliITSClusterFinder(source){
     //     Copy Constructor 
 
     if(&source == this) return;
index 69c7a45..37b6804 100644 (file)
@@ -81,8 +81,8 @@ AliITSClusterFinderSPDdubna &AliITSClusterFinderSPDdubna::operator=(const
     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:
index b2481af..ec4f80d 100644 (file)
@@ -557,6 +557,7 @@ Bool_t AliITSClusterFinderSSD::CreateNewRecPoint(Float_t P,Float_t dP,
 
     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();
index 8bece0a..417b34c 100644 (file)
@@ -44,7 +44,8 @@ AliITSDDLRawData::AliITSDDLRawData(){
 
 ////////////////////////////////////////////////////////////////////////////////////////
 
-AliITSDDLRawData::AliITSDDLRawData(const AliITSDDLRawData &source){
+AliITSDDLRawData::AliITSDDLRawData(const AliITSDDLRawData &source) : 
+    TObject(source){
   //Copy Constructor
   this->fIndex=source.fIndex;
   this->fHalfStaveModule=source.fHalfStaveModule;
index 4ae07d9..4f39364 100644 (file)
@@ -48,7 +48,7 @@ AliITSDetType::~AliITSDetType(){
     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;
index 341cf68..f0eef6c 100644 (file)
@@ -95,67 +95,64 @@ void AliITSFDigitizer::Exec(Option_t* opt){
 //      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();
 }
 ////////////////////////////////////////////////////////////////////////
index 41def9b..0a89c24 100644 (file)
@@ -12,9 +12,9 @@ class AliITSGeant3Geometry : public TObject {
  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);
index 76a67dc..5455f51 100644 (file)
@@ -36,7 +36,7 @@ AliITSHNode::AliITSHNode(UChar_t sym, ULong_t freq)
 }
 
 //__________________________________________________________________________
-AliITSHNode::AliITSHNode(const AliITSHNode &source){
+AliITSHNode::AliITSHNode(const AliITSHNode &source) : TObject(source){
   //     Copy Constructor 
   if(&source == this) return;
   this->fSymbol = source.fSymbol;
@@ -112,7 +112,7 @@ AliITSHTable::AliITSHTable(Int_t size)
 }
 
 //__________________________________________________________________________
-AliITSHTable::AliITSHTable(const AliITSHTable &source){
+AliITSHTable::AliITSHTable(const AliITSHTable &source) : TObject(source){
   //     Copy Constructor 
   if(&source == this) return;
   this->fSize = source.fSize;
index fdb73de..78ac731 100644 (file)
@@ -108,7 +108,7 @@ AliITSMapA1& AliITSMapA1::operator=(const AliITSMapA1 &source) {
     return *this;
 }
 //______________________________________________________________________
-AliITSMapA1::AliITSMapA1(const AliITSMapA1 &source){
+AliITSMapA1::AliITSMapA1(const AliITSMapA1 &source) : AliITSMap(source){
     //     Copy Constructor
 
     *this = source;
index 5993b05..ae7e1b1 100644 (file)
@@ -105,7 +105,7 @@ AliITSMapA2::~AliITSMapA2(){
     if (fHitMapD) delete[] fHitMapD;
 }
 //______________________________________________________________________
-AliITSMapA2::AliITSMapA2(const AliITSMapA2 &source){
+AliITSMapA2::AliITSMapA2(const AliITSMapA2 &source) : AliITSMapA1(source){
     //     Copy Constructor 
 
     if(&source == this) return;
@@ -161,6 +161,7 @@ void AliITSMapA2::FlagHit(Int_t iz, Int_t ix){
 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;
index a486539..b38f58d 100644 (file)
@@ -61,7 +61,8 @@ AliITSRawClusterSDD::AliITSRawClusterSDD(Int_t wing,
     fZ = AnodeOffset/10000.;
 }
 //______________________________________________________________________
-AliITSRawClusterSDD::AliITSRawClusterSDD( const AliITSRawClusterSDD & source){
+AliITSRawClusterSDD::AliITSRawClusterSDD(const AliITSRawClusterSDD & source):
+    AliITSRawCluster(source){
     // copy constructor
 
     fWing          = source.fWing;
@@ -206,6 +207,7 @@ Bool_t AliITSRawClusterSPD::Brother(AliITSRawClusterSPD* cluster,
     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;
@@ -235,6 +237,7 @@ ClassImp(AliITSRawClusterSSD)
 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;
index 2168e93..1b07edf 100644 (file)
@@ -40,7 +40,7 @@ AliITSInStream::~AliITSInStream()
 }
 
 //__________________________________________________________________________
-AliITSInStream::AliITSInStream(const AliITSInStream &source){
+AliITSInStream::AliITSInStream(const AliITSInStream &source) : TObject(source){
   //     Copy Constructor 
   if(&source == this) return;
   this->fStreamLen = source.fStreamLen;
@@ -108,7 +108,7 @@ AliITSOutStream::~AliITSOutStream()
 }
 
 //__________________________________________________________________________
-AliITSOutStream::AliITSOutStream(const AliITSOutStream &source){
+AliITSOutStream::AliITSOutStream(const AliITSOutStream &source):TObject(source){
   //     Copy Constructor 
   if(&source == this) return;
   this->fStreamLen = source.fStreamLen;
index d82b19f..5784499 100644 (file)
@@ -39,8 +39,7 @@ class AliITSRecPoint : public TObject {
     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
index ee057a7..a1d5c6e 100644 (file)
@@ -64,7 +64,8 @@ AliITSclusterSSD::~AliITSclusterSSD(){
     delete fCrossedClusterIndexes;
 }
 //______________________________________________________________________
-AliITSclusterSSD::AliITSclusterSSD(const AliITSclusterSSD &OneSCluster){
+AliITSclusterSSD::AliITSclusterSSD(const AliITSclusterSSD &OneSCluster) : 
+    TObject(OneSCluster){
     // copy constructor
 
     if (this == &OneSCluster) return;
index be874c9..60b08be 100644 (file)
@@ -27,11 +27,10 @@ class AliITSclusterSSD : public TObject{
     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
@@ -42,8 +41,8 @@ class AliITSclusterSSD : public TObject{
     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
@@ -52,7 +51,7 @@ class AliITSclusterSSD : public TObject{
      //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();
@@ -66,16 +65,12 @@ class AliITSclusterSSD : public TObject{
        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;}
index d046ef4..3ec6e48 100644 (file)
@@ -55,7 +55,7 @@ AliITSdcsSSD::~AliITSdcsSSD() {
     delete fInvalidN;
 }
 //______________________________________________________________________
-AliITSdcsSSD::AliITSdcsSSD(const AliITSdcsSSD &source){
+AliITSdcsSSD::AliITSdcsSSD(const AliITSdcsSSD &source) : TObject(source){
     //     Copy Constructor 
 
     if(&source == this) return;
index b9c10ca..545d868 100644 (file)
@@ -56,22 +56,16 @@ class AliITSdcsSSD: public TObject {
     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:
     //_____________________________________________
index 6edea78..80c9dbf 100644 (file)
@@ -303,7 +303,8 @@ AliITSTransientDigit::AliITSTransientDigit(Float_t phys,const Int_t *digits):
     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;
index bc06f5f..0d1563e 100644 (file)
@@ -34,9 +34,9 @@ class AliITSdigit: public TObject  {
     // 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
index c459a7d..f80c83e 100644 (file)
@@ -539,7 +539,7 @@ AliITSgeom::AliITSgeom(const char *filename){
     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:
index cc9c43e..c3d932b 100644 (file)
@@ -63,9 +63,10 @@ AliITSgeomMatrix::AliITSgeomMatrix(){
     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;
index 5e8da1c..00263b5 100644 (file)
@@ -111,7 +111,7 @@ AliITSgeomSDD::~AliITSgeomSDD(){
     fAnodeLowEdgeR = 0;
 }
 //________________________________________________________________________
-AliITSgeomSDD::AliITSgeomSDD(AliITSgeomSDD &source){
+AliITSgeomSDD::AliITSgeomSDD(AliITSgeomSDD &source) : TObject(source){
     // Copy constructor
     Int_t i;
 
@@ -688,6 +688,11 @@ _____________________________________________
     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];
index 076b57e..db5bc81 100644 (file)
@@ -40,9 +40,11 @@ class AliITSgeomSDD: public TObject {
     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)
index d9a3850..8ce1cfe 100644 (file)
@@ -81,7 +81,7 @@ void AliITSgeomSPD::ReSetBins(Float_t dy,Int_t nx,Float_t *bx,
     return;
 }
 //______________________________________________________________________
-AliITSgeomSPD::AliITSgeomSPD(AliITSgeomSPD &source){
+AliITSgeomSPD::AliITSgeomSPD(AliITSgeomSPD &source) : TObject(source){
     // Copy constructor
 
     *this = source; // just use the = operator for now.
@@ -343,6 +343,11 @@ AliITSgeomSPD425Short::AliITSgeomSPD425Short(Int_t npar,Float_t *par) :
     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) 
index 434ac2b..08df6b2 100644 (file)
@@ -94,7 +94,8 @@ AliITSgeomSSD::~AliITSgeomSSD(){
     fAngleP = 0.0;
     fAngleN = 0.0;
 }
-AliITSgeomSSD::AliITSgeomSSD(const AliITSgeomSSD &source){
+//______________________________________________________________________
+AliITSgeomSSD::AliITSgeomSSD(const AliITSgeomSSD &source) : TObject(source){
 ////////////////////////////////////////////////////////////////////////
 //    copy  constructor
 ////////////////////////////////////////////////////////////////////////
@@ -167,7 +168,11 @@ void AliITSgeomSSD::Local2Det(Float_t x,Float_t z,Int_t &a,Int_t &c){
 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;
 }
 //______________________________________________________________________
@@ -324,6 +329,11 @@ AliITSgeomSSD275and75::AliITSgeomSSD275and75(Int_t npar,Float_t *par) :
     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];
@@ -385,6 +395,11 @@ AliITSgeomSSD75and275::AliITSgeomSSD75and275(Int_t npar,Float_t *par) :
     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];
index 15bf9c5..f2d1d7d 100644 (file)
@@ -74,7 +74,7 @@ AliITSmodule::~AliITSmodule() {
     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 
 ////////////////////////////////////////////////////////////////////////
@@ -86,9 +86,10 @@ AliITSmodule& AliITSmodule::operator=(const AliITSmodule &source){
 ////////////////////////////////////////////////////////////////////////
 //    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
 }
 //_________________________________________________________________________
 // 
@@ -118,6 +119,7 @@ Double_t AliITSmodule::PathLength(Int_t index,AliITShit *itsHit1,
    Float_t  x2g,y2g,z2g;
    Double_t s;
 
+   index = 0;
    itsHit1->GetPositionG(x1g,y1g,z1g);
    itsHit2->GetPositionG(x2g,y2g,z2g);
 
@@ -136,6 +138,7 @@ void AliITSmodule::PathLength(Int_t index,
   // path length
     static Float_t x0,y0,z0;
 
+    index = 0;
     if ((status&0x0002)!=0){ // entering
        x0 = x;
        y0 = y;
index 74b76e3..56171b9 100644 (file)
@@ -108,8 +108,8 @@ class AliITSmodule:public TObject{
     // 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.
index a88d19c..9d3a58e 100644 (file)
@@ -140,7 +140,7 @@ AliITSpList& AliITSpList::operator=(const AliITSpList &source){
     return *this;
 }
 //______________________________________________________________________
-AliITSpList::AliITSpList(AliITSpList &source){
+AliITSpList::AliITSpList(AliITSpList &source) : AliITSMap(source){
     // Copy operator
     // Inputs:
     //    AliITSpList &source   A AliITSpList Object
@@ -347,7 +347,7 @@ AliITSpListItem& AliITSpListItem::operator=(const AliITSpListItem &source){
     return *this;
 }
 //______________________________________________________________________
-AliITSpListItem::AliITSpListItem(AliITSpListItem &source){
+AliITSpListItem::AliITSpListItem(AliITSpListItem &source) : TObject(source){
     // Copy operator
     // Inputs:
     //    AliITSpListItem &source   A AliITSpListItem Object
index ea29f9f..24efb7e 100644 (file)
@@ -213,11 +213,11 @@ class AliITSpList: public AliITSMap {
     // 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){
index e49498b..53ffb77 100644 (file)
@@ -86,8 +86,8 @@ AliITSpackageSSD::~AliITSpackageSSD()
 }
 /*******************************************************/
 
-AliITSpackageSSD::AliITSpackageSSD(const AliITSpackageSSD &package)
-{
+AliITSpackageSSD::AliITSpackageSSD(const AliITSpackageSSD &package) : 
+    TObject(package){
   // copy constractor
   Int_t i;  //iterator
  
index 10ff479..684fc6d 100644 (file)
@@ -271,5 +271,7 @@ void AliITSreconstruction::Exec(const Option_t *opt){
 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());
 }
index 40847b1..d8298da 100644 (file)
@@ -26,22 +26,22 @@ class AliITSresponse : public TObject {
     //
 
     // 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;}
 
@@ -55,7 +55,7 @@ class AliITSresponse : public TObject {
     // 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]
@@ -71,7 +71,7 @@ class AliITSresponse : public TObject {
     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
@@ -86,7 +86,7 @@ class AliITSresponse : public TObject {
     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
@@ -97,34 +97,34 @@ class AliITSresponse : public TObject {
     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
@@ -149,17 +149,17 @@ class AliITSresponse : public TObject {
     // 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]
index c0e6136..b16b478 100644 (file)
@@ -131,7 +131,7 @@ class AliITSresponseSDD : public AliITSresponse {
     }
     // 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.;}
index 99178af..24d08c2 100644 (file)
@@ -17,14 +17,13 @@ class AliITSresponseSPDdubna :  public AliITSresponse {
     //
     // 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
index 627d51d..da4e804 100644 (file)
@@ -82,7 +82,8 @@ AliITSresponseSSD& AliITSresponseSSD::operator=(const AliITSresponseSSD &src) {
     return *this;
 }
 //_________________________________________________________________________
-AliITSresponseSSD::AliITSresponseSSD(const AliITSresponseSSD &src) {
+AliITSresponseSSD::AliITSresponseSSD(const AliITSresponseSSD &src) :
+    AliITSresponse(src) {
     // copy constructor
 
     *this = src;
index 522178e..901fb8e 100644 (file)
@@ -19,11 +19,11 @@ class AliITSresponseSSD : public AliITSresponse {
 
     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.) {
index 1d6d550..ad9f590 100644 (file)
@@ -16,34 +16,34 @@ public TObject {
     // 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() {}
     //
@@ -77,16 +77,14 @@ public TObject {
     //
     // 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
@@ -95,14 +93,13 @@ public TObject {
     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*) {}
@@ -112,8 +109,3 @@ public TObject {
     ClassDef(AliITSsegmentation,1) //Segmentation virtual base class 
 };
 #endif
-
-
-
-
-
index bacca61..e1306ba 100644 (file)
@@ -163,7 +163,7 @@ void AliITSsegmentationSDD::Print(Option_t *opt) const {
   // 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;
index d1da200..ceff3de 100644 (file)
@@ -19,8 +19,8 @@ public AliITSsegmentation {
     // 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  
@@ -64,9 +64,9 @@ public AliITSsegmentation {
     // 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;}
@@ -75,19 +75,18 @@ public AliITSsegmentation {
 
     //
     // 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
@@ -100,14 +99,13 @@ public AliITSsegmentation {
     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*) {}
index 2d2fe58..2b0baad 100644 (file)
@@ -42,7 +42,9 @@ Float_t AliITSsegmentationSPD::ZFromCol300(Int_t col) {
 //_____________________________________________________________________________
 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) {
@@ -208,7 +210,8 @@ AliITSsegmentationSPD& AliITSsegmentationSPD::operator=(AliITSsegmentationSPD &s
    return *this;
 }
 //____________________________________________________________________________
-AliITSsegmentationSPD::AliITSsegmentationSPD(AliITSsegmentationSPD &source){
+AliITSsegmentationSPD::AliITSsegmentationSPD(AliITSsegmentationSPD &source) :
+    AliITSsegmentation(source){
   // copy constructor
    *this = source;
 }
index a420652..020f6b6 100644 (file)
@@ -36,9 +36,9 @@ public AliITSsegmentation {
     // 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
index af1b94d..af66025 100644 (file)
@@ -64,7 +64,8 @@ AliITSsegmentationSSD& AliITSsegmentationSSD::operator=(
     return *this;     
 }
 //______________________________________________________________________
-AliITSsegmentationSSD::AliITSsegmentationSSD(AliITSsegmentationSSD &source){
+AliITSsegmentationSSD::AliITSsegmentationSSD(AliITSsegmentationSSD &source):
+    AliITSsegmentation(source){
     // copy constructor
     *this = source;
 }
index 912682b..2cab9e8 100644 (file)
@@ -22,12 +22,11 @@ public AliITSsegmentation {
                         {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;}
 
@@ -51,9 +50,9 @@ public AliITSsegmentation {
     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);
index 2a40f90..167dadd 100644 (file)
@@ -34,7 +34,8 @@ AliITSsimulation::~AliITSsimulation(){
     delete fpList;
 }
 //__________________________________________________________________________
-AliITSsimulation::AliITSsimulation(const AliITSsimulation &source){
+AliITSsimulation::AliITSsimulation(const AliITSsimulation &source) : 
+    TObject(source){
     //     Copy Constructor 
  
     if(&source == this) return;
index 2ad8e98..cc1c3d2 100644 (file)
@@ -43,11 +43,11 @@ class AliITSsimulation : public TObject {
     // *****************  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.
@@ -58,10 +58,10 @@ class AliITSsimulation : public TObject {
 
     // **************** 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
index 2b74b9a..828c447 100644 (file)
@@ -57,6 +57,7 @@ void AliITSsimulationFastPointsV0::CreateFastRecPoints(AliITSmodule *mod,Int_t m
   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
@@ -115,7 +116,7 @@ void AliITSsimulationFastPointsV0::AddSPD(Float_t &e,
   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 ",
index 26bfc9a..25084f7 100644 (file)
@@ -164,7 +164,8 @@ AliITSsimulationSDD::AliITSsimulationSDD(){
     SetCheckNoise();
 }
 //______________________________________________________________________
-AliITSsimulationSDD::AliITSsimulationSDD(AliITSsimulationSDD &source){
+AliITSsimulationSDD::AliITSsimulationSDD(AliITSsimulationSDD &source) :
+    AliITSsimulation(source){
     // Copy constructor to satify Coding roules only.
 
     if(this==&source) return;
index bc0e770..57981c1 100644 (file)
@@ -126,7 +126,8 @@ class AliITSsimulationSDD : public AliITSsimulation {
     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
index 3082870..e53090f 100644 (file)
@@ -108,7 +108,8 @@ AliITSsimulationSPD::~AliITSsimulationSPD() {
     } // end if
 }
 //______________________________________________________________________
-AliITSsimulationSPD::AliITSsimulationSPD(const AliITSsimulationSPD &source){
+AliITSsimulationSPD::AliITSsimulationSPD(const AliITSsimulationSPD &source) :
+    AliITSsimulation(source){
     // Copy Constructor
 
     if(&source == this) return;
@@ -182,6 +183,7 @@ void AliITSsimulationSPD::SDigitiseModule(AliITSmodule *mod, Int_t dummy0,
     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
@@ -208,6 +210,7 @@ void AliITSsimulationSPD::DigitiseModule(AliITSmodule *mod, Int_t dummy0,
     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();
@@ -625,6 +628,7 @@ void AliITSsimulationSPD::CreateDigit(Int_t module,AliITSpList *pList) {
     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++) {
index 65a9c51..29a1cda 100644 (file)
@@ -98,7 +98,8 @@ AliITSsimulationSPDdubna::~AliITSsimulationSPDdubna(){
 //______________________________________________________________________
 AliITSsimulationSPDdubna::AliITSsimulationSPDdubna(const 
                                                   AliITSsimulationSPDdubna 
-                                                  &source){
+                                                  &source):
+    AliITSsimulation(source){
     //     Copy Constructor 
     if(&source == this) return;
     this->fMapA2 = source.fMapA2;
@@ -160,6 +161,7 @@ void AliITSsimulationSPDdubna::SDigitiseModule(AliITSmodule *mod, Int_t mask,
 
     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);
@@ -247,7 +249,7 @@ void AliITSsimulationSPDdubna::DigitiseModule(AliITSmodule *mod, Int_t module,
     //  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();
@@ -280,6 +282,7 @@ void AliITSsimulationSPDdubna::UpdateMapSignal(Int_t iz, Int_t ix, Int_t trk,
     //    none
 
 //    fMapA2->AddSignal(iz, ix, signal);
+    module = fModule; // remove unused variable warning.
     pList->AddSignal(iz+1,ix+1, trk, ht, fModule, signal);
 }
 //______________________________________________________________________
@@ -305,6 +308,7 @@ void AliITSsimulationSPDdubna::UpdateMapNoise(Int_t iz,
     //    none
 
 //    fMapA2->AddSignal(iz, ix, noise);
+    sig = 0.0; // remove unused variable warning.
     pList->AddNoise(iz+1,ix+1, fModule, noise);
 }
 //______________________________________________________________________
@@ -325,6 +329,7 @@ void AliITSsimulationSPDdubna::HitToSDigit(AliITSmodule *mod, Int_t module,
     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
@@ -430,6 +435,7 @@ void AliITSsimulationSPDdubna::SpreadCharge(Double_t x0,Double_t y0,
     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;
@@ -535,7 +541,7 @@ void AliITSsimulationSPDdubna::HitToSDigitOld(AliITSmodule *mod, Int_t module,
     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
index 427f38c..b6729a3 100644 (file)
@@ -116,7 +116,8 @@ AliITSsimulationSSD& AliITSsimulationSSD::operator=(
   return *this;
 }
 //______________________________________________________________________
-AliITSsimulationSSD::AliITSsimulationSSD(const AliITSsimulationSSD &source){
+AliITSsimulationSSD::AliITSsimulationSSD(const AliITSsimulationSSD &source):
+    AliITSsimulation(source){
   // copy constructor
 
   *this = source;
@@ -164,6 +165,7 @@ void AliITSsimulationSSD::DigitiseModule(AliITSmodule *mod,
   // Digitizes hits for one SSD module
   Int_t module     = mod->GetIndex();
 
+  dummy0 = dummy1 = 0;  // remove unused variable warning.
   HitsToAnalogDigits(mod,fpList);
   SDigitToDigit(module,fpList);
 
@@ -175,12 +177,13 @@ void AliITSsimulationSSD::SDigitiseModule(AliITSmodule *mod,Int_t dummy0,
                                           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){
@@ -259,8 +262,9 @@ void AliITSsimulationSSD::HitToDigit(Int_t module, Double_t x0, Double_t y0,
        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;
index 954e4ac..1d17da6 100644 (file)
@@ -73,7 +73,7 @@ AliITSstatistics& AliITSstatistics::operator=(AliITSstatistics &source){
          return *this;
 }
 //_______________________________________________________________
-AliITSstatistics::AliITSstatistics(AliITSstatistics &source){
+AliITSstatistics::AliITSstatistics(AliITSstatistics &source) : TObject(source){
 // Copy constructor
 
      if(this==&source) return;
index 00391fa..705f21b 100644 (file)
@@ -82,7 +82,8 @@ AliITSstatistics2& AliITSstatistics2::operator=(AliITSstatistics2 &source){
          return *this;
 }
 //_______________________________________________________________
-AliITSstatistics2::AliITSstatistics2(AliITSstatistics2 &source){
+AliITSstatistics2::AliITSstatistics2(AliITSstatistics2 &source):
+    TObject(source){
 // Copy constructor
 
      if(this==&source) return;
index e80b9d9..30e28c4 100644 (file)
@@ -95,7 +95,7 @@ AliITSv1::AliITSv1(const char *name, const char *title) : AliITS(name, title){
 
 }
 //____________________________________________________________________________
-AliITSv1::AliITSv1(const AliITSv1 &source){
+AliITSv1::AliITSv1(const AliITSv1 &source) : AliITS(source){
 ////////////////////////////////////////////////////////////////////////
 //     Copy Constructor for ITS version 1.
 ////////////////////////////////////////////////////////////////////////
index 33dcbf7..118733e 100644 (file)
@@ -109,7 +109,7 @@ AliITSv5::AliITSv5(const char *name, const char *title) : AliITS(name, title){
     strncpy(fWrite,fEuclidGeomDet,60);
 }
 //____________________________________________________________________________
-AliITSv5::AliITSv5(const AliITSv5 &source){
+AliITSv5::AliITSv5(const AliITSv5 &source) : AliITS(source){
 ////////////////////////////////////////////////////////////////////////
 //     Copy Constructor for ITS version 5.
 ////////////////////////////////////////////////////////////////////////
index 1798365..27e3e6d 100644 (file)
@@ -109,7 +109,7 @@ AliITSv5asymm::AliITSv5asymm(const char *name, const char *title) : AliITS(name,
     strncpy(fWrite,fEuclidGeomDet,60);
 }
 //____________________________________________________________________________
-AliITSv5asymm::AliITSv5asymm(const AliITSv5asymm &source){
+AliITSv5asymm::AliITSv5asymm(const AliITSv5asymm &source):AliITS(source){
 ////////////////////////////////////////////////////////////////////////
 //     Copy Constructor for ITS version 5.
 ////////////////////////////////////////////////////////////////////////
index 8ab7f01..76b180e 100644 (file)
@@ -109,7 +109,7 @@ AliITSv5symm::AliITSv5symm(const char *name, const char *title) : AliITS(name, t
     strncpy(fWrite,fEuclidGeomDet,60);
 }
 //____________________________________________________________________________
-AliITSv5symm::AliITSv5symm(const AliITSv5symm &source){
+AliITSv5symm::AliITSv5symm(const AliITSv5symm &source) : AliITS(source){
 ////////////////////////////////////////////////////////////////////////
 //     Copy Constructor for ITS version 5.
 ////////////////////////////////////////////////////////////////////////
index 66082c6..5a90b75 100644 (file)
@@ -128,7 +128,7 @@ AliITSvPPRasymm::AliITSvPPRasymm(const char *name, const char *title) : AliITS(n
     strncpy(fWrite,fEuclidGeomDet,60);
 }
 //____________________________________________________________________________
-AliITSvPPRasymm::AliITSvPPRasymm(const AliITSvPPRasymm &source){
+AliITSvPPRasymm::AliITSvPPRasymm(const AliITSvPPRasymm &source):AliITS(source){
 ////////////////////////////////////////////////////////////////////////
 //     Copy Constructor for ITS version 8.
 ////////////////////////////////////////////////////////////////////////
index d894f84..504bc49 100644 (file)
@@ -115,6 +115,7 @@ AliITSvPPRasymmFMD::AliITSvPPRasymmFMD(const char *name, const char *title)
 
     fIdN = 6;
     fIdName = new TString[fIdN];
+    fIdName[0] = name; // removes warning message
     fIdName[0] = "ITS1";
     fIdName[1] = "ITS2";
     fIdName[2] = "ITS3";
@@ -140,7 +141,8 @@ AliITSvPPRasymmFMD::AliITSvPPRasymmFMD(const char *name, const char *title)
     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.
index 1d23c17..fd09028 100644 (file)
@@ -82,11 +82,12 @@ AliITSvPPRcoarseasymm::AliITSvPPRcoarseasymm(const char *name, const char *title
     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;
 }
index 52355b9..b3c94e2 100644 (file)
@@ -82,11 +82,12 @@ AliITSvPPRcoarsesymm::AliITSvPPRcoarsesymm(const char *name, const char *title)
     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;
 }
index 3f0e1f3..245cf22 100644 (file)
@@ -122,7 +122,7 @@ AliITSvSPD02::AliITSvSPD02(const char *title) : AliITS("ITS", title){
     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.
index f9b2bef..cd062e6 100644 (file)
@@ -67,7 +67,7 @@ AliITSvtest::AliITSvtest() {
     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.
 ////////////////////////////////////////////////////////////////////////