Fixing some shadow variables warnings
authorlaphecet <laphecet@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 20 May 2008 21:00:35 +0000 (21:00 +0000)
committerlaphecet <laphecet@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 20 May 2008 21:00:35 +0000 (21:00 +0000)
13 files changed:
MUON/AliMUONCDB.cxx
MUON/AliMUONClusterFinderMLEM.cxx
MUON/AliMUONClusterSplitterMLEM.cxx
MUON/AliMUONHit.cxx
MUON/AliMUONPadStatusMapMaker.cxx
MUON/AliMUONPainterContourMaker.cxx
MUON/AliMUONPreClusterFinderV2.cxx
MUON/AliMUONRawWriter.cxx
MUON/AliMUONSDigitizerV2.cxx
MUON/AliMUONTrackerData.cxx
MUON/mapping/AliMpDEVisu.cxx
MUON/mapping/AliMpExMap.cxx
MUON/mapping/AliMpExMap.h

index 0c21366..6fcf7bb 100644 (file)
@@ -798,10 +798,10 @@ AliMUONCDB::MakeNeighbourStore(AliMUONVStore& neighbourStore)
             
         for ( Int_t i = 0; i < nofPadNeighbours; ++i )
         {
-          AliMpPad* pad = static_cast<AliMpPad*>(tmp.UncheckedAt(i));
+          AliMpPad* p = static_cast<AliMpPad*>(tmp.UncheckedAt(i));
           Int_t x;
 //          Bool_t ok =
-          calibParam->PackValues(pad->GetLocation().GetFirst(),pad->GetLocation().GetSecond(),x);
+          calibParam->PackValues(p->GetLocation().GetFirst(),p->GetLocation().GetSecond(),x);
 //          if (!ok)
 //          {
 //            AliError("Could not pack value. Something is seriously wrong. Please check");
index 24254a8..d48820a 100644 (file)
@@ -891,8 +891,8 @@ Bool_t AliMUONClusterFinderMLEM::MainLoop(AliMUONCluster& cluster, Int_t iSimple
 
     for (Int_t ipix = 0; ipix < nPix; ++ipix) 
     {
-      AliMUONPad* pixPtr = Pixel(ipix);
-      fHistMlem->Fill(pixPtr->Coord(0),pixPtr->Coord(1),pixPtr->Charge());
+      AliMUONPad* pixPtr2 = Pixel(ipix);
+      fHistMlem->Fill(pixPtr2->Coord(0),pixPtr2->Coord(1),pixPtr2->Charge());
     }
 
     // Check if the total charge of pixels is too low
@@ -952,10 +952,10 @@ Bool_t AliMUONClusterFinderMLEM::MainLoop(AliMUONCluster& cluster, Int_t iSimple
     nPix = 0;
     for (Int_t ipix = 0; ipix < nPix1; ++ipix) 
     {
-      AliMUONPad* pixPtr = Pixel(ipix);
+      AliMUONPad* pixPtr2 = Pixel(ipix);
       if ( nPix >= npadOK  // too many pixels already
            ||
-           pixPtr->Charge() < pixMin && pixPtr->Status() != fgkMustKeep // too low charge
+           pixPtr2->Charge() < pixMin && pixPtr2->Status() != fgkMustKeep // too low charge
            ) 
       { 
         RemovePixel(ipix);
@@ -965,36 +965,36 @@ Bool_t AliMUONClusterFinderMLEM::MainLoop(AliMUONCluster& cluster, Int_t iSimple
       {
         if (!i) 
         {
-          pixPtr->SetCharge(10);
-          pixPtr->SetSize(indx, pixPtr->Size(indx)/2);
-          width = -pixPtr->Size(indx);
-          pixPtr->Shift(indx, width);
+          pixPtr2->SetCharge(10);
+          pixPtr2->SetSize(indx, pixPtr2->Size(indx)/2);
+          width = -pixPtr2->Size(indx);
+          pixPtr2->Shift(indx, width);
           // Shift pixel position
           if (ix) 
           {
             ix = 0;
             for (Int_t j = 0; j < 2; ++j) 
             {
-              shift[j] = pixPtr->Coord(j) - xyCOG[j];
-              shift[j] -= ((Int_t)(shift[j]/pixPtr->Size(j)/2))*pixPtr->Size(j)*2;
+              shift[j] = pixPtr2->Coord(j) - xyCOG[j];
+              shift[j] -= ((Int_t)(shift[j]/pixPtr2->Size(j)/2))*pixPtr2->Size(j)*2;
             }
           } // if (ix)
-          pixPtr->Shift(0, -shift[0]);
-          pixPtr->Shift(1, -shift[1]);
+          pixPtr2->Shift(0, -shift[0]);
+          pixPtr2->Shift(1, -shift[1]);
          ++nPix;
         } 
         else if (nPix < npadOK)
         {
-          pixPtr = new AliMUONPad(*pixPtr);
-          pixPtr->Shift(indx, -2*width);
-         pixPtr->SetStatus(fgkZero);
-          fPixArray->Add(pixPtr);
+          pixPtr2 = new AliMUONPad(*pixPtr2);
+          pixPtr2->Shift(indx, -2*width);
+         pixPtr2->SetStatus(fgkZero);
+          fPixArray->Add(pixPtr2);
          ++nPix;
         } 
        else continue; // skip adjustment of histo limits
         for (Int_t j = 0; j < 4; ++j) 
         {
-          xylim[j] = TMath::Min (xylim[j], (j%2 ? -1 : 1)*pixPtr->Coord(j/2));
+          xylim[j] = TMath::Min (xylim[j], (j%2 ? -1 : 1)*pixPtr2->Coord(j/2));
         }
       } // for (Int_t i=0; i<2;
     } // for (Int_t ipix=0;
@@ -1012,18 +1012,18 @@ Bool_t AliMUONClusterFinderMLEM::MainLoop(AliMUONCluster& cluster, Int_t iSimple
 
     if (nPix < npadOK)
     {
-      AliMUONPad* pixPtr = Pixel(0);
+      AliMUONPad* pixPtr2 = Pixel(0);
       // add pixels if the maximum is at the limit of pixel area:
       // start from Y-direction
       Int_t j = 0;
       for (Int_t i = 3; i > -1; --i) 
       {
         if (nPix < npadOK && 
-            TMath::Abs((i%2 ? -1 : 1)*xylim[i]-xyCOG[i/2]) < pixPtr->Size(i/2)) 
+            TMath::Abs((i%2 ? -1 : 1)*xylim[i]-xyCOG[i/2]) < pixPtr2->Size(i/2)) 
         {
           //AliMUONPad* p = static_cast<AliMUONPad*>(pixPtr->Clone());
-          AliMUONPad* p = new AliMUONPad(*pixPtr);
-          p->SetCoord(i/2, xyCOG[i/2]+(i%2 ? 2:-2)*pixPtr->Size(i/2));
+          AliMUONPad* p = new AliMUONPad(*pixPtr2);
+          p->SetCoord(i/2, xyCOG[i/2]+(i%2 ? 2:-2)*pixPtr2->Size(i/2));
          xylim[i] = p->Coord(i/2) * (i%2 ? -1 : 1); // update histo limits
           j = TMath::Even (i/2);
           p->SetCoord(j, xyCOG[j]);
@@ -1052,11 +1052,11 @@ Bool_t AliMUONClusterFinderMLEM::MainLoop(AliMUONCluster& cluster, Int_t iSimple
   // Mark pixels which should be removed
   for (Int_t i = 0; i < nPix; ++i) 
   {
-    AliMUONPad* pixPtr = Pixel(i);
-    charge = pixPtr->Charge();
+    AliMUONPad* pixPtr2 = Pixel(i);
+    charge = pixPtr2->Charge();
     if (charge < thresh) 
     {
-      pixPtr->SetCharge(-charge);
+      pixPtr2->SetCharge(-charge);
     }
   }
 
@@ -1064,11 +1064,11 @@ Bool_t AliMUONClusterFinderMLEM::MainLoop(AliMUONCluster& cluster, Int_t iSimple
   Int_t near = 0;
   for (Int_t i = 0; i < nPix; ++i) 
   {
-    AliMUONPad* pixPtr = Pixel(i);
-    charge = pixPtr->Charge();
+    AliMUONPad* pixPtr2 = Pixel(i);
+    charge = pixPtr2->Charge();
     if (charge > 0) continue;
-    near = FindNearest(pixPtr);
-    pixPtr->SetCharge(0);
+    near = FindNearest(pixPtr2);
+    pixPtr2->SetCharge(0);
     probi[i] = 0; // make it "invisible"
     AliMUONPad* pnear = Pixel(near);
     pnear->SetCharge(pnear->Charge() + (-charge));
@@ -1082,10 +1082,10 @@ Bool_t AliMUONClusterFinderMLEM::MainLoop(AliMUONCluster& cluster, Int_t iSimple
   // Update histogram
   for (Int_t i = 0; i < nPix; ++i) 
   {
-    AliMUONPad* pixPtr = Pixel(i);
-    Int_t ix = fHistMlem->GetXaxis()->FindBin(pixPtr->Coord(0));
-    Int_t iy = fHistMlem->GetYaxis()->FindBin(pixPtr->Coord(1));
-    fHistMlem->SetBinContent(ix, iy, pixPtr->Charge());
+    AliMUONPad* pixPtr2 = Pixel(i);
+    Int_t ix = fHistMlem->GetXaxis()->FindBin(pixPtr2->Coord(0));
+    Int_t iy = fHistMlem->GetYaxis()->FindBin(pixPtr2->Coord(1));
+    fHistMlem->SetBinContent(ix, iy, pixPtr2->Charge());
   }
 
   // Try to split into clusters
index 5449077..bb92014 100644 (file)
@@ -56,9 +56,9 @@ const Double_t AliMUONClusterSplitterMLEM::fgkCouplMin = 1.e-2; // threshold on
 
 //_____________________________________________________________________________
 AliMUONClusterSplitterMLEM::AliMUONClusterSplitterMLEM(Int_t detElemId, 
-                                                       TObjArray* fPixArray) 
+                                                       TObjArray* pixArray) 
 : TObject(),
-fPixArray(fPixArray),
+fPixArray(pixArray),
 fMathieson(0x0),
 fDetElemId(detElemId),
 fNpar(0),
index 64ef97f..a396b37 100644 (file)
@@ -90,7 +90,7 @@ AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits)
 
 //___________________________________________
 AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t detElemId, Int_t idpart, 
-                      Float_t X, Float_t Y, Float_t Z, Float_t tof, Float_t momentum, 
+                      Float_t x, Float_t y, Float_t z, Float_t tof, Float_t momentum, 
                       Float_t theta, Float_t phi, Float_t length, Float_t destep)
   : AliHit(shunt, track),
     fDetElemId(detElemId),
@@ -111,16 +111,16 @@ AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t detElemId, Int_t idpart,
     fZref(0)
 {
 /// Constructor
-    fX         = X;
-    fY         = Y;
-    fZ         = Z;
+    fX         = x;
+    fY         = y;
+    fZ         = z;
 }
 
 //-----------------------------------------------------------------------------------------------
 AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t detElemId, Int_t idpart, 
-                      Float_t X, Float_t Y, Float_t Z, Float_t tof, Float_t momentum, 
+                      Float_t x, Float_t y, Float_t z, Float_t tof, Float_t momentum, 
                       Float_t theta, Float_t phi, Float_t length, Float_t destep,
-                      Float_t Xref,Float_t Yref,Float_t Zref)
+                      Float_t xref,Float_t yref,Float_t zref)
   : AliHit(shunt, track),
     fDetElemId(detElemId),
     fParticle(idpart),
@@ -135,15 +135,15 @@ AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t detElemId, Int_t idpart,
     fPx(momentum * TMath::Sin(theta) * TMath::Cos(phi)),
     fPy(momentum * TMath::Sin(theta) * TMath::Sin(phi)),
     fPz(momentum * TMath::Cos(theta)),
-    fXref(Xref),
-    fYref(Yref),
-    fZref(Zref)
+    fXref(xref),
+    fYref(yref),
+    fZref(zref)
 {
 /// Constructor
 
-    fX         = X;
-    fY         = Y;
-    fZ         = Z;
+    fX         = x;
+    fY         = y;
+    fZ         = z;
 }
 
 //-----------------------------------------------------------------------------------------------
index 0d5904e..3543949 100644 (file)
@@ -142,9 +142,9 @@ AliMUONPadStatusMapMaker::ComputeStatusMap(Int_t detElemId, Int_t manuId) const
       // Compute the statusmap related to the status of neighbouring
       // pads. An invalid pad means "outside of edges".
             
-      Int_t x = neighbours->ValueAsIntFast(manuChannel,i);      
+      Int_t y = neighbours->ValueAsIntFast(manuChannel,i);      
       Int_t m,c;
-      neighbours->UnpackValue(x,m,c);
+      neighbours->UnpackValue(y,m,c);
       if ( c < 0 ) continue;
       Int_t status = 0;
       if ( !m )
index 89530a8..e218693 100644 (file)
@@ -210,16 +210,16 @@ AliMUONPainterContourMaker::AddSegments(TObjArray& segments,
       Double_t x2 = line->GetX()[i+1];
       Double_t y2 = line->GetY()[i+1];
       
-      TLine* line = new TLine(x1,y1,x2,y2);
+      TLine* l = new TLine(x1,y1,x2,y2);
       
-      if ( !HasLine(segments,*line) )
+      if ( !HasLine(segments,*l) )
       {
-        segments.Add(line);      
-        AliDebug(1,Form("Adding line %s",LineAsString(*line).Data()));
+        segments.Add(l);      
+        AliDebug(1,Form("Adding line %s",LineAsString(*l).Data()));
       }
       else
       {
-        AliDebug(1,Form("Line %s is already there",LineAsString(*line).Data()));
+        AliDebug(1,Form("Line %s is already there",LineAsString(*l).Data()));
       }      
     }
   }
@@ -491,23 +491,23 @@ AliMUONPainterContourMaker::SplitSegments(TObjArray& segments) const
         Double_t xmin(FLT_MAX), ymin(FLT_MAX);
         Double_t xmax(-FLT_MAX), ymax(-FLT_MAX);
 
-        for ( Int_t i = 0; i < 4; ++i )
+        for ( Int_t k = 0; k < 4; ++k )
         {
-          xmin = TMath::Min(x[i],xmin);
-          ymin = TMath::Min(y[i],ymin);
-          xmax = TMath::Max(x[i],xmax);
-          ymax = TMath::Max(y[i],ymax);
+          xmin = TMath::Min(x[k],xmin);
+          ymin = TMath::Min(y[k],ymin);
+          xmax = TMath::Max(x[k],xmax);
+          ymax = TMath::Max(y[k],ymax);
         }
         
         TLine fullLine(xmin,ymin,xmax,ymax);
         
-        for ( Int_t i = 0; i < 4; ++i )
+        for ( Int_t i1 = 0; i1 < 4; ++i1 )
         {
-          for ( Int_t j = i+1; j < 4; ++j )
+          for ( Int_t j1 = i1+1; j1 < 4; ++j1 )
           {
-            if ( TMath::Abs(i-j) != 2 ) 
+            if ( TMath::Abs(i1-j1) != 2 ) 
             {
-              TLine test(x[i],y[i],x[j],y[j]);
+              TLine test(x[i1],y[i1],x[j1],y[j1]);
 
               Bool_t isFullLine = IsEqual(test,fullLine);
               
index f830ece..3acf863 100644 (file)
@@ -124,15 +124,15 @@ AliMUONPreClusterFinderV2::AddPad(AliMUONCluster& cluster, AliMUONPad* pad)
   Int_t nn = fSegmentations[pad->Cathode()]->GetNeighbours(p,neighbours);
   for (Int_t in = 0; in < nn; ++in) 
   {
-    AliMpPad* p = static_cast<AliMpPad*>(neighbours.At(in));
+    AliMpPad* p1 = static_cast<AliMpPad*>(neighbours.At(in));
     
-    TIter next(&padArray);
+    TIter next2(&padArray);
     AliMUONPad* p2;
     
-    while ( ( p2 = static_cast<AliMUONPad*>(next()) ) )
+    while ( ( p2 = static_cast<AliMUONPad*>(next2()) ) )
     {
-        if ( !p2->IsUsed() && p2->Ix()==p->GetIndices().GetFirst() 
-             && p2->Iy() == p->GetIndices().GetSecond() &&
+        if ( !p2->IsUsed() && p2->Ix()==p1->GetIndices().GetFirst() 
+             && p2->Iy() == p1->GetIndices().GetSecond() &&
              p2->Cathode() == pad->Cathode() )
         {
           AddPad(cluster,p2);
@@ -186,8 +186,8 @@ AliMUONPreClusterFinderV2::NextCluster()
   if (!pad) // protection against no pad in first cathode, which might happen
   {
     // try other cathode
-    TIter next(fPads[1]);
-    while (  ( pad = static_cast<AliMUONPad*>(next())) && pad->IsUsed() );
+    TIter next2(fPads[1]);
+    while (  ( pad = static_cast<AliMUONPad*>(next2())) && pad->IsUsed() );
     if (!pad) 
     {
       // we are done.
index 670a7e0..532b63b 100644 (file)
@@ -340,10 +340,10 @@ AliMUONRawWriter::WriteTrackerDDL(AliMpExMap& busPatchMap, Int_t iDDL)
     for (Int_t iDsp = 0; iDsp < iDspMax; ++iDsp) 
     {
       // DSP header
-      Int_t length = fDspHeader->GetHeaderLength();
-      memcpy(&fBuffer[index],fDspHeader->GetHeader(),length*4);
+      Int_t dspHeaderLength = fDspHeader->GetHeaderLength();
+      memcpy(&fBuffer[index],fDspHeader->GetHeader(),dspHeaderLength*4);
       Int_t indexDsp = index;
-      index += length; 
+      index += dspHeaderLength; 
       
       // 5 buspatches max per DSP
       for (Int_t i = 0; i < iBusPerDSP[iDsp]; ++i) 
@@ -363,14 +363,14 @@ AliMUONRawWriter::WriteTrackerDDL(AliMpExMap& busPatchMap, Int_t iDDL)
         if (busStructPtr) 
         {
           // add bus patch structure header
-          Int_t length = busStructPtr->GetHeaderLength();
-          memcpy(&fBuffer[index],busStructPtr->GetHeader(),length*4);
-          index += length;
+          Int_t busHeaderLength = busStructPtr->GetHeaderLength();
+          memcpy(&fBuffer[index],busStructPtr->GetHeader(),busHeaderLength*4);
+          index += busHeaderLength;
           
           // add bus patch data
-          length = busStructPtr->GetLength();
-          memcpy(&fBuffer[index],busStructPtr->GetData(),length*4);
-          index += length;
+          Int_t busLength = busStructPtr->GetLength();
+          memcpy(&fBuffer[index],busStructPtr->GetData(),busLength*4);
+          index += busLength;
         } 
         else 
         {
index 1de726c..015c7c9 100644 (file)
@@ -168,9 +168,9 @@ AliMUONSDigitizerV2::Exec(Option_t*)
         TList digits;        
         response->DisIntegrate(*hit,digits);
         
-        TIter next(&digits);
+        TIter nextd(&digits);
         AliMUONVDigit* d;
-        while ( ( d = (AliMUONVDigit*)next() ) )
+        while ( ( d = (AliMUONVDigit*)nextd() ) )
         {
           // Update some sdigit information that could not be known
           // by the DisIntegrate method
index 655a285..99d97e4 100644 (file)
@@ -1043,13 +1043,13 @@ AliMUONTrackerData::Value(const AliMUONVCalibParam& param, Int_t i, Int_t dim) c
   }
   else
   {
-    Double_t n = occ;
+    Double_t nn = occ;
     
-    if ( n > 1.0 ) 
+    if ( nn > 1.0 ) 
     {
-      Double_t mean = param.ValueAsDouble(i,dim-1)/n;
+      Double_t mean = param.ValueAsDouble(i,dim-1)/nn;
     
-      return TMath::Sqrt(TMath::Abs((value-n*mean*mean)/(n-1.0)));
+      return TMath::Sqrt(TMath::Abs((value-nn*mean*mean)/(nn-1.0)));
     }
     else
     {
index e3980d1..db3c018 100644 (file)
@@ -837,8 +837,8 @@ void AliMpDEVisu::PopUpManuMotif(AliMpSector* sector)
     
     for (Int_t iRowSeg = 0; iRowSeg < sector->GetRow(iRow)->GetNofRowSegments(); ++iRowSeg){
       
-      for (Int_t iRowSeg = 0; iRowSeg < row->GetNofRowSegments(); ++iRowSeg) {
-        AliMpVRowSegment *rowSegment = row->GetRowSegment(iRowSeg);
+      for (Int_t iRowSeg2 = 0; iRowSeg2 < row->GetNofRowSegments(); ++iRowSeg2) {
+        AliMpVRowSegment *rowSegment = row->GetRowSegment(iRowSeg2);
         
         for (Int_t iMotif = 0; iMotif < rowSegment->GetNofMotifs(); ++iMotif){
           
index 24a5fb9..4320c59 100644 (file)
@@ -365,3 +365,25 @@ void AliMpExMap::Streamer(TBuffer &R__b)
     AliMpExMap::Class()->WriteBuffer(R__b, this);
   }
 }
+
+//_____________________________________________________________________________
+void AliMpExMap::Print(Option_t* opt) const
+{
+  /// print out
+  cout << Form("fMap size/capacity %d/%d",fMap.GetSize(),fMap.Capacity()) 
+    << Form(" fObjects.GetSize/Entries %d/%d",fObjects.GetSize(),fObjects.GetEntries()) 
+  << Form(" fKeys.GetSize %d",fKeys.GetSize()) << endl;
+  
+  TString sopt(opt);
+  sopt.ToUpper();
+  
+  if ( sopt.Contains("FULL") ) 
+  {
+    TIter next(&fObjects);
+    TObject* o;
+    while ( ( o = next() ) )
+    {
+      o->Print();
+    }
+  }
+}
index dcefbc8..bf5a046 100644 (file)
@@ -66,6 +66,8 @@ class AliMpExMap : public TObject
 
     void Copy(TObject& dest) const;
     
+  virtual void Print(Option_t* opt="") const;
+
   private:  
     // methods
     void FillMap();