effc++ warnings corrected
authorfca <fca@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 16 Mar 2008 22:22:11 +0000 (22:22 +0000)
committerfca <fca@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 16 Mar 2008 22:22:11 +0000 (22:22 +0000)
35 files changed:
ACORDE/AliACORDECalibData.cxx
ACORDE/AliACORDECalibData.h
EVE/EveBase/AliEveCosmicRayFitter.cxx
EVE/EveHLT/AliEveHOMERSource.h
EVE/EveHLT/AliEveHOMERSourceMap.cxx
EVE/EveHLT/AliEveHOMERSourceMap.h
FMD/AliFMDQADataMakerRec.cxx
FMD/AliFMDQADataMakerSim.cxx
HLT/BASE/AliHLTMessage.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.cxx
HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.cxx
HMPID/AliHMPIDCluster.h
HMPID/AliHMPIDParam.cxx
HMPID/AliHMPIDRawStream.cxx
HMPID/AliHMPIDRecon.cxx
HMPID/AliHMPIDReconHTA.cxx
HMPID/AliHMPIDTracker.cxx
PWG0/dNdEta/dNdEtaAnalysis.cxx
PWG0/esdTrackCuts/AliESDtrackCuts.cxx
PWG2/AOD/AliAnalysisTaskPWG2ESDfilter.cxx
PWG2/AliESDtrackCuts.cxx
T0/AliT0CalibLaserData.cxx
T0/AliT0CalibTimeEq.cxx
T0/AliT0QADataMakerSim.h
TTherminator/TTherminator.cxx
TTherminator/Therminator/Integrator.cxx
TTherminator/Therminator/Parser.cxx
TTherminator/Therminator/ParticleType.cxx
VZERO/AliVZERO.cxx
VZERO/AliVZEROBuffer.cxx
VZERO/AliVZERODataDCS.cxx
VZERO/AliVZERODataDCS.h
VZERO/AliVZERODigitizer.cxx
VZERO/AliVZEROPreprocessor.h
ZDC/AliZDCRawStream.cxx

index 37a4739..879475e 100644 (file)
@@ -46,7 +46,12 @@ void AliACORDECalibData::Reset()
 }
 
 //________________________________________________________________
-AliACORDECalibData::AliACORDECalibData(const char* name)
+AliACORDECalibData::AliACORDECalibData(const char* name) :
+  TNamed(),
+  fHits(0),
+  fTHits(0),
+  fMultiHits(0),
+  fTMultiHits(0)
 {
   TString namst = "Calib_";
   namst += name;
@@ -57,7 +62,11 @@ AliACORDECalibData::AliACORDECalibData(const char* name)
 
 //________________________________________________________________
 AliACORDECalibData::AliACORDECalibData(const AliACORDECalibData& calibda) :
-  TNamed(calibda)
+  TNamed(calibda),
+  fHits(0),
+  fTHits(0),
+  fMultiHits(0),
+  fTMultiHits(0)
 {
 // copy constructor
 
@@ -72,7 +81,7 @@ AliACORDECalibData::AliACORDECalibData(const AliACORDECalibData& calibda) :
   }
 }
 //_______________________________________________________________
-void AliACORDECalibData::Draw()
+void AliACORDECalibData::Draw(Option_t *)
 {
  
 
index 6ff7924..f5f0512 100644 (file)
@@ -30,7 +30,7 @@ class AliACORDECalibData: public TNamed {
   void AddHTHits(TH1D *Histo){fTHits=(TH1D*)Histo->Clone("Total Hits");}//Total Hits 
   void AddHMultiHits(TH1D  *Histo){fMultiHits=(TH1D*)Histo->Clone("MultiHits");}//
   void AddHTMultiHits(TH1D *Histo){fTMultiHits=(TH1D*)Histo->Clone("Total Multi Hits");}
-  void Draw();
+  void Draw(Option_t *option="");
 
 
  protected:
index b22de44..8bad243 100644 (file)
@@ -338,7 +338,7 @@ void AliEveCosmicRayFitter::DrawDebugGraph()
     //fGraphLinear3->SetPointError(i, TMath::Abs(x[i])*0.001, TMath::Abs(yCoor)*0.05, TMath::Abs(zCoor)*0.05);
   }
   
-  TCanvas * canvas;
+  TCanvas * canvas=0;
   if (gPad) gPad->Clear();
   else if (gPad==0 || gPad->GetCanvas()->IsEditable() == kFALSE) {
     canvas = new TCanvas("canvas", "CosmicRayFitter", 800, 800);
index 1906874..1b304b3 100644 (file)
@@ -26,6 +26,7 @@ private:
 public:
   struct SourceId
   {
+    SourceId(): fDet(), fSDet(), fSSDet(), fType() {}
     TString fDet, fSDet, fSSDet, fType;
 
     struct CmpByDet
index e77e187..e7aef31 100644 (file)
@@ -62,7 +62,8 @@ void AliEveHOMERSourceMap::PrintXXX()
 /******************************************************************************/
 
 AliEveHOMERSourceMapByDet::AliEveHOMERSourceMapByDet(ESourceGrouping_e grouping) :
-  AliEveHOMERSourceMap(grouping)
+  AliEveHOMERSourceMap(grouping),
+  fMap()
 {}
 
 TString AliEveHOMERSourceMapByDet::iterator_imp::description()
@@ -119,7 +120,8 @@ void AliEveHOMERSourceMapByDet::FillMap(TList* handles, Bool_t def_state)
 /******************************************************************************/
 
 AliEveHOMERSourceMapByType::AliEveHOMERSourceMapByType(ESourceGrouping_e grouping) :
-  AliEveHOMERSourceMap(grouping)
+  AliEveHOMERSourceMap(grouping),
+  fMap()
 {}
 
 TString AliEveHOMERSourceMapByType::iterator_imp::description()
index 5f75d45..5b8e51f 100644 (file)
@@ -40,6 +40,7 @@ public:
     iterator_imp_base* m_imp;
 
     iterator()                       :  m_imp(0)   {}
+    iterator(const iterator& it)     :  m_imp(it.m_imp->clone())  {}
     iterator(iterator_imp_base* imp) :  m_imp(imp) {}
     ~iterator() { delete m_imp; }
 
index 478afdb..34e8100 100644 (file)
@@ -56,7 +56,7 @@ AliFMDQADataMakerRec::AliFMDQADataMakerRec() :
 }
 
 //_____________________________________________________________________
-AliFMDQADataMakerRec::AliFMDQADataMakerRec(const AliFMDQADataMakerRec& qadm) 
+AliFMDQADataMakerRec::AliFMDQADataMakerRec(const AliFMDQADataMakerRec& /*qadm*/) 
   : AliQADataMakerRec()
 {
   // copy ctor 
@@ -179,7 +179,7 @@ void AliFMDQADataMakerRec::MakeDigits(TTree * digitTree)
 }
 
 //_____________________________________________________________________
-void AliFMDQADataMakerRec::MakeRaws(AliRawReader* rawReader)
+void AliFMDQADataMakerRec::MakeRaws(AliRawReader* /*rawReader*/)
 {
   
 }
index 1e8f9b2..6a5b5d4 100644 (file)
@@ -53,7 +53,7 @@ AliFMDQADataMakerSim::AliFMDQADataMakerSim()
 }
 
 //_____________________________________________________________________
-AliFMDQADataMakerSim::AliFMDQADataMakerSim(const AliFMDQADataMakerSim& qadm) 
+AliFMDQADataMakerSim::AliFMDQADataMakerSim(const AliFMDQADataMakerSim& /*qadm*/) 
   : AliQADataMakerSim()
 {
   //copy ctor 
index 4f1ccda..b3d0404 100644 (file)
@@ -47,7 +47,13 @@ AliHLTMessage::AliHLTMessage(UInt_t what)
 # else
   TBuffer(kWrite),
 # endif
-  AliHLTLogging()
+  AliHLTLogging(),
+  fWhat(what),
+  fClass(0),
+  fCompress(0),
+  fBufComp(0),
+  fBufCompCur(0),
+  fCompPos(0)
 {
    // Create a AliHLTMessage object for storing objects. The "what" integer
    // describes the type of message. Predifined ROOT system message types
@@ -63,14 +69,8 @@ AliHLTMessage::AliHLTMessage(UInt_t what)
    UInt_t   reserved = 0;
    *this << reserved;
 
-   fWhat  = what;
    *this << what;
 
-   fClass      = 0;
-   fCompress   = 0;
-   fBufComp    = 0;
-   fBufCompCur = 0;
-   fCompPos    = 0;
 }
 
 //______________________________________________________________________________
@@ -81,7 +81,13 @@ AliHLTMessage::AliHLTMessage(void *buf, Int_t bufsize)
 # else
   TBuffer(kRead, bufsize, buf, 0),
 # endif
-  AliHLTLogging()
+  AliHLTLogging(),
+  fWhat(0),
+  fClass(0),
+  fCompress(0),
+  fBufComp(0),
+  fBufCompCur(0),
+  fCompPos(0)
 {
    // Create a AliHLTMessage object for reading objects. The objects will be
    // read from buf. Use the What() method to get the message type.
@@ -91,11 +97,6 @@ AliHLTMessage::AliHLTMessage(void *buf, Int_t bufsize)
 
    *this >> fWhat;
 
-   fCompress   = 0;
-   fBufComp    = 0;
-   fBufCompCur = 0;
-   fCompPos    = 0;
-
    if (fWhat & kMESS_ZIP) {
       // if buffer has kMESS_ZIP set, move it to fBufComp and uncompress
       fBufComp    = fBuffer;
index 2371319..7e32f92 100644 (file)
@@ -25,7 +25,7 @@
 #include "TMath.h"
 //#include "Riostream.h"
 #include <vector>
-#include <algo.h>
+#include <algorithm>
 #include "TStopwatch.h"
 //#define DRAW
 
index 6d7c1c1..0d71764 100644 (file)
@@ -62,6 +62,7 @@ AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent()
 
 AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent(const AliHLTTPCCATrackerComponent&)
   :
+  AliHLTProcessor(),
   fTracker(NULL),
   fBField(0)
 {
@@ -175,7 +176,7 @@ int AliHLTTPCCATrackerComponent::DoEvent
 ( 
  const AliHLTComponentEventData& evtData, 
  const AliHLTComponentBlockData* blocks, 
- AliHLTComponentTriggerData& trigData, 
+ AliHLTComponentTriggerData& /*trigData*/, 
  AliHLTUInt8_t* outputPtr, 
  AliHLTUInt32_t& size, 
  vector<AliHLTComponentBlockData>& outputBlocks )
@@ -270,8 +271,8 @@ int AliHLTTPCCATrackerComponent::DoEvent
     if( !fTracker ) fTracker = new AliHLTTPCCATracker;
     Int_t iSec = slice;
     Double_t inRmin = 83.65; 
-    Double_t inRmax = 133.3;
-    Double_t outRmin = 133.5; 
+    //    Double_t inRmax = 133.3;
+    //    Double_t outRmin = 133.5; 
     Double_t outRmax = 247.7;
     Double_t plusZmin = 0.0529937; 
     Double_t plusZmax = 249.778; 
@@ -284,8 +285,8 @@ int AliHLTTPCCATrackerComponent::DoEvent
     Double_t zMin =  zPlus ?plusZmin :minusZmin;
     Double_t zMax =  zPlus ?plusZmax :minusZmax;
     //TPCZmin = -249.645, ZMax = 249.778    
-    Double_t rMin =  inRmin;
-    Double_t rMax =  outRmax;
+    //    Double_t rMin =  inRmin;
+    //    Double_t rMax =  outRmax;
     Int_t NRows = AliHLTTPCTransform::GetNRows();
         
     Double_t padPitch = 0.4;
index f7d2c11..28f7c4b 100644 (file)
@@ -22,10 +22,8 @@ public:
   enum EClusterStatus {kFrm,kCoG,kLo1,kUnf,kMax,kNot,kEdg,kSi1,kNoLoc,kAbn,kEmp=-1};      //status flags    
       AliHMPIDCluster():AliCluster3D(),
                           fCh(-1),fSi(-1),fSt(kEmp),fBox(-1),fNlocMax(-1),fMaxQpad(-1),fMaxQ(-1),fQRaw(0),
-                          fQ(0),fErrQ(-1),fXX(0),fErrX(-1),fYY(0),fErrY(-1),fChi2(-1),fDigs(0) 
+                          fQ(0),fErrQ(-1),fXX(0),fErrX(-1),fYY(0),fErrY(-1),fChi2(-1),fDigs(0),fParam(AliHMPIDParam::Instance())
       {
-        AliHMPIDParam *pParam=AliHMPIDParam::Instance();
-        fParam = pParam;
       }//ctor
   
 
@@ -33,7 +31,7 @@ public:
                         fCh(c.fCh),fSi(c.fSi),fSt(c.fSt),fBox(c.fBox),fNlocMax(c.fNlocMax),fMaxQpad(c.fMaxQpad),fMaxQ(c.fMaxQ),fQRaw(c.fQRaw),
                         fQ (c.fQ ),fErrQ(c.fErrQ),
                         fXX (c.fXX ),fErrX(c.fErrX),
-                        fYY (c.fYY ),fErrY(c.fErrY),fChi2(c.fChi2),fDigs(0)                  {}//copy ctor
+                        fYY (c.fYY ),fErrY(c.fErrY),fChi2(c.fChi2),fDigs(0),fParam(c.fParam)                  {}//copy ctor
    virtual ~AliHMPIDCluster();//dtor   {if(fDigs) delete fDigs; fDigs=0;}
 //framework part                   
          void           Draw   (Option_t *opt=""                                  );                       //overloaded TObject::Print() to draw cluster in current canvas
index 7afbebf..1657e7b 100644 (file)
@@ -48,7 +48,9 @@ AliHMPIDParam* AliHMPIDParam::fgInstance=0x0;        //singleton pointer
 Int_t AliHMPIDParam::fgSigmas=4;
 
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-AliHMPIDParam::AliHMPIDParam(Bool_t noGeo=kFALSE):TNamed("HmpidParam","default version") 
+AliHMPIDParam::AliHMPIDParam(Bool_t noGeo=kFALSE):
+  TNamed("HmpidParam","default version"),
+  fX(0), fY(0), fRadNmean(0)
 {
 // Here all the intitializition is taken place when AliHMPIDParam::Instance() is invoked for the first time.
 // In particular, matrices to be used for LORS<->MARS trasnformations are initialized from TGeo structure.    
index 0d260e7..2c1bcd9 100644 (file)
@@ -165,7 +165,7 @@ Bool_t AliHMPIDRawStream::Next()
   */
 
   fPosition = 0;
-  Bool_t status;
+  Bool_t status=kTRUE;
   Int_t  rawDataSize=0;        
   if(fRawReader->GetType() == 7 || fRawReader->GetType() == 8 )  {           //New: Select Physics events, Old: Raw data size is not 0 and not 47148 (pedestal)
     fDDLNumber = fRawReader->GetDDLID();
index 0432e29..4b19568 100644 (file)
 #include <AliESDtrack.h>     //CkovAngle()
 
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-AliHMPIDRecon::AliHMPIDRecon():TTask("RichRec","RichPat")
+AliHMPIDRecon::AliHMPIDRecon():
+  TTask("RichRec","RichPat"),
+  fPhotCnt(-1),
+  fPhotFlag(0),
+  fPhotCkov(0),
+  fPhotPhi(0),
+  fPhotWei(0),
+  fCkovSigma2(0),
+  fIsWEIGHT(kFALSE),
+  fDTheta(0.001),
+  fWindowWidth(0.045),
+  fRingArea(0),
+  fRingAcc(0),
+  fTrkDir(0,0,1),  // Just for test
+  fTrkPos(30,40),  // Just for test
+  fMipPos(0),
+  fPc(0),
+  fParam(AliHMPIDParam::Instance())
 {
 //..
 //init of data members
 //..
   
-  fPhotCnt  = -1;
-  fPhotFlag = 0x0;
-  fPhotCkov = 0x0;
-  fPhotPhi  = 0x0;
-  fPhotWei  = 0x0;
-  fCkovSigma2 = 0;
-  fIsWEIGHT = kFALSE;
-  fDTheta   = 0.001;
-  fWindowWidth = 0.045;
-  fTrkDir = TVector3(0,0,1); // init just for test
-  fTrkPos = TVector2(30,40); // init just for test
-  
-  AliHMPIDParam *pParam=AliHMPIDParam::Instance();
-  fParam = pParam;
-  
   fParam->SetRefIdx(fParam->MeanIdxRad()); // initialization of ref index to a default one
 }
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
index 9fc813b..2c37ec3 100644 (file)
 TH2I* AliHMPIDReconHTA::fgDatabase = 0x0;
 
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-AliHMPIDReconHTA::AliHMPIDReconHTA():TTask("RichRec","RichPat")
+AliHMPIDReconHTA::AliHMPIDReconHTA():
+  TTask("RichRec","RichPat"),
+  fMipX(-999),
+  fMipY(-999),
+  fMipQ(-999),
+  fRadX(-999),
+  fRadY(-999),
+  fIdxMip(0),
+  fNClu(0),
+  fXClu(0),
+  fYClu(0),
+  fClCk(0),
+  fThTrkFit(-999),
+  fPhTrkFit(-999),
+  fCkovFit(-999),
+  fCkovSig2(0),
+  fParam(AliHMPIDParam::Instance())
 {
 //..
 //hidden algorithm
 //..
-  fMipX=fMipY=fThTrkFit=fPhTrkFit=fCkovFit=fMipQ=fRadX=fRadY=-999;
-  fIdxMip=fNClu=0;
-  fCkovSig2=0;
-  fXClu = 0x0;
-  fYClu = 0x0;
-  fClCk = 0x0;
-  
-  fParam=AliHMPIDParam::Instance();
-  
   fParam->SetRefIdx(fParam->MeanIdxRad()); // initialization of ref index to a default one
   if(!fgDatabase) InitDatabase();
 }
@@ -506,7 +513,7 @@ void AliHMPIDReconHTA::InitDatabase()
   
   AliInfo(Form("database HTA is being built.Please, wait..."));
 //  
-  Double_t x[3],y[3];
+  Double_t x[3]={0,0,0},y[3];
 
   AliHMPIDRecon rec;
 
index c132522..f271805 100644 (file)
 //.
 ClassImp(AliHMPIDTracker)
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-AliHMPIDTracker::AliHMPIDTracker():AliTracker()
+AliHMPIDTracker::AliHMPIDTracker():
+  AliTracker(),
+  fClu(new TObjArray(AliHMPIDParam::kMaxCh+1))  
 {
 // ctor. Create TObjArray of TClonesArray of AliHMPIDCluster  
 // 
 //  
-  fClu=new TObjArray(AliHMPIDParam::kMaxCh+1);  fClu->SetOwner(kTRUE);
+  fClu->SetOwner(kTRUE);
   for(int i=AliHMPIDParam::kMinCh;i<=AliHMPIDParam::kMaxCh;i++) fClu->AddAt(new TClonesArray("AliHMPIDCluster"),i);
 }//ctor
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    
index 6af4d8e..c308a48 100644 (file)
@@ -116,6 +116,7 @@ dNdEtaAnalysis::~dNdEtaAnalysis()
 dNdEtaAnalysis::dNdEtaAnalysis(const dNdEtaAnalysis &c) :
   TNamed(c),
   fData(0),
+  fMult(0),
   fPtDist(0)
 {
   //
index c6e985c..17f856d 100644 (file)
@@ -85,6 +85,7 @@ AliESDtrackCuts::AliESDtrackCuts(const Char_t* name, const Char_t* title) : AliA
   fRapMin(0),
   fRapMax(0),
   fHistogramsOn(0),
+  ffDTheoretical(0),
   fhCutStatistics(0),         
   fhCutCorrelation(0)
 {
index 94030a0..2f200dd 100644 (file)
@@ -225,11 +225,11 @@ void AliAnalysisTaskPWG2ESDfilter::Exec(Option_t */*option*/)
     Int_t nV0s      = fESD->GetNumberOfV0s();
     Int_t nCascades = fESD->GetNumberOfCascades();
     Int_t nKinks    = fESD->GetNumberOfKinks();
-    Int_t nVertices = nV0s + nCascades + nKinks + 1 /* = prim. vtx*/;
-    Int_t nJets     = 0;
-    Int_t nCaloClus = fESD->GetNumberOfCaloClusters();
-    Int_t nFmdClus  = 0;
-    Int_t nPmdClus  = fESD->GetNumberOfPmdTracks();
+    //    Int_t nVertices = nV0s + nCascades + nKinks + 1 /* = prim. vtx*/;
+    //    Int_t nJets     = 0;
+    //    Int_t nCaloClus = fESD->GetNumberOfCaloClusters();
+    //    Int_t nFmdClus  = 0;
+    //    Int_t nPmdClus  = fESD->GetNumberOfPmdTracks();
     
     printf("   NV0=%d  NCASCADES=%d  NKINKS=%d\n", nV0s, nCascades, nKinks);
 
index 5b9ae64..b51efc8 100644 (file)
@@ -108,6 +108,7 @@ AliESDtrackCuts::AliESDtrackCuts(Char_t* name, Char_t* title) : TNamed(name,titl
   fRapMin(0),
   fRapMax(0),
   fHistogramsOn(0),
+  ffDTheoretical(0),
   fhCutStatistics(0),         
   fhCutCorrelation(0)
 {
index 2bec7be..2e8c6b7 100644 (file)
@@ -31,7 +31,7 @@
 #include "AliT0RawReader.h"
 #include "TGLabel.h"
 #include "TGFileDialog.h"
-#include <iostream.h>
+#include <iostream>
 
 #include "AliT0CalibLaserData.h"
 
index 0ad81ca..e37a82a 100644 (file)
@@ -29,7 +29,7 @@
 #include <TF1.h>
 #include <TSpectrum.h>
 #include <TProfile.h>
-#include "iostream.h"
+#include <iostream>
 
 ClassImp(AliT0CalibTimeEq)
 
index 06b3e8d..59eac2c 100644 (file)
@@ -34,7 +34,9 @@ private:
   virtual void   InitHits() ;      //book hit QA histo 
   virtual void   InitDigits() ;    //book Digit QA histo
   virtual void   MakeHits(TTree * hits) ;       //Fill hit QA histo
+  virtual void   MakeHits(TClonesArray *) {}       //Dummy for the moment
   virtual void   MakeDigits(TTree* digitsTree) ;   //Fill Digit QA histo
+  virtual void   MakeDigits(TClonesArray *) {}       //Dummy for the moment
   virtual void   EndOfDetectorCycle(AliQA::TASKINDEX, TObjArray * list) ;
   virtual void   StartOfDetectorCycle() ;
   ClassDef(AliT0QADataMakerSim,1)  // description 
index 365af39..6574c2c 100644 (file)
@@ -55,6 +55,7 @@ TTherminator::TTherminator():
   fPartDB = new ParticleDB();
 }
 TTherminator::TTherminator(const TTherminator & therm) :
+  TGenerator(therm),
   fCalka(0),
   fEvent(0),
   fPartDB(0)
@@ -221,7 +222,7 @@ void        TTherminator::GenerateEvent()
     }  
 }
 
-Int_t       TTherminator::ImportParticles(TClonesArray *particles, Option_t *option)
+Int_t       TTherminator::ImportParticles(TClonesArray *particles, Option_t */*option*/)
 {
   // Import particles from a generated event into an external array
   if (particles == 0) return 0;
@@ -255,7 +256,7 @@ Int_t       TTherminator::ImportParticles(TClonesArray *particles, Option_t *opt
   return nump;
 }
 
-TObjArray*  TTherminator::ImportParticles(Option_t *option)
+TObjArray*  TTherminator::ImportParticles(Option_t */*option*/)
 {
   // Import generated particles into an internal array
   Int_t nump = 0;
index d0ff2bb..4195b89 100644 (file)
@@ -332,7 +332,7 @@ Integrator::Generate(ParticleType *aPartType, int aPartCount, Particle ***oParti
   tFMax = aPartType->GetFMax();
 
   (*oParticles) = (Particle **) malloc(sizeof(Particle *) * aPartCount);
-  Particle *tBuf;
+  Particle *tBuf=0;
   
   while (tIter<aPartCount)
     {
index 571fa44..8a36863 100644 (file)
@@ -110,7 +110,7 @@ int Parser::GetParticleNumber(int i)
 
 void Parser::ReadInput()
 {
-  int j,tPartIter,l,tIter2, tIter; //variables
+  int j,tPartIter=0,l,tIter2, tIter; //variables
   char str[50];
   char str1[20];
   double spin1,spin2,value;
index 7bd7fa3..9279ad8 100644 (file)
@@ -71,7 +71,7 @@ ParticleType::~ParticleType()
     delete mTable;
 }
 
-void ParticleType::WriteParticle(int i)
+void ParticleType::WriteParticle(int /*i*/)
 {
     mMass=-1;
     mStrangeness=-1;
index 10dd358..ae6ab75 100755 (executable)
@@ -361,8 +361,8 @@ void AliVZERO::Digits2Raw()
          buffer->WriteMBFlags();   
          buffer->WriteBeamScalers(); 
       } 
-      for(Int_t kChannel = kChannel=0; kChannel < 8; kChannel++) {
-          buffer->WriteTiming(kChannel, ADC[kChannel], Time[kChannel]); 
+      for(Int_t iChannel=0; iChannel < 8; iChannel++) {
+          buffer->WriteTiming(iChannel, ADC[iChannel], Time[iChannel]); 
       }
 
     // End of decoding of one CIU card
@@ -419,6 +419,7 @@ Bool_t AliVZERO::Raw2SDigits(AliRawReader* rawReader){
 
   timer.Stop();
   timer.Print();
+  return kTRUE;
 }
 
 
index 529e758..8bc090e 100644 (file)
@@ -131,13 +131,13 @@ void AliVZEROBuffer::WriteBunchNumbers() {
 }
 
 //_____________________________________________________________________________
-void AliVZEROBuffer::WriteChannel(Int_t cell, UInt_t ADC, UInt_t Time){
+void AliVZEROBuffer::WriteChannel(Int_t cell, UInt_t ADC, UInt_t /*Time*/){
   // It writes VZERO charge information into a raw data file. 
   // Being called by Digits2Raw
   
   UInt_t data = 0;
   
-  if (ADC < 0 || ADC > 1023) {
+  if (/*ADC < 0 || */ ADC > 1023) {
       AliInfo(Form("ADC saturated: %d. Truncating to 1023",ADC));
       ADC = 1023;
   }
@@ -227,7 +227,7 @@ void AliVZEROBuffer::WriteBeamScalers() {
 }
 
 //_____________________________________________________________________________
-void AliVZEROBuffer::WriteTiming(Int_t cell, UInt_t ADC, UInt_t Time){
+void AliVZEROBuffer::WriteTiming(Int_t /*cell*/, UInt_t /* ADC*/, UInt_t Time){
   // It writes the timing information into a raw data file. 
   // Being called by Digits2Raw
 
index f463fb2..7d53f93 100644 (file)
@@ -167,7 +167,7 @@ void AliVZERODataDCS::Introduce(UInt_t numAlias, const TObjArray* aliasArr)const
 
   // method to introduce new aliases
 
-  int entries=entries = aliasArr->GetEntries();
+  int entries=aliasArr->GetEntries();
   AliInfo(Form("************ Alias: %s **********",fAliasNames[numAlias].Data()));
   AliInfo(Form("       %d DP values collected",entries));
 
index 2b7d959..f089a67 100644 (file)
@@ -46,6 +46,9 @@ public:
   Float_t* GetWidthHV()   const {return (float*)fWidthHV;}
 
 private:
+  AliVZERODataDCS(const AliVZERODataDCS&); // Not implemented
+  AliVZERODataDCS& operator=(const AliVZERODataDCS&); // Not implemented
+
   void Init();
   void Introduce(UInt_t numAlias, const TObjArray* aliasArr) const;
   void CreateGraph(int i, int dim, const Double_t *x, const Double_t *y);
index 25c0a14..f73ebca 100644 (file)
@@ -115,8 +115,8 @@ Bool_t AliVZERODigitizer::Init()
   // Initialises the Digit array
   fDigits = new TClonesArray ("AliVZEROdigit", 1000);
   
-  TGeoHMatrix *im = AliGeomManager::GetMatrix("VZERO/V0C");
-//  im->Print();
+  //  TGeoHMatrix *im = AliGeomManager::GetMatrix("VZERO/V0C");
+  //  im->Print();
   
   return kTRUE;
 }
@@ -252,17 +252,17 @@ void AliVZERODigitizer::Exec(Option_t* /*option*/)
 // Also adds the ADC pedestals taken out of the calibration data base
        
    for (Int_t j=0; j<16; j++){
-       adc[j]  = map [j] + gRandom->Gaus(adc_pedestal[j], adc_sigma[j]);
+        adc[j]  = static_cast<Int_t>(map [j] + gRandom->Gaus(adc_pedestal[j], adc_sigma[j]));
        time2[j]= time[j];}
        
    for (Int_t j=48; j<80; j++){
-       adc[j-16]  = map [j] 
-                  + gRandom->Gaus(adc_pedestal[j-16],adc_sigma[j-16]);
+        adc[j-16]  = static_cast<Int_t>(map [j] 
+                                       + gRandom->Gaus(adc_pedestal[j-16],adc_sigma[j-16]));
        time2[j-16]= time[j]; }
        
    for (Int_t j=0; j<16; j++){
-       adc[16+j] = map [16+2*j]+ map [16+2*j+1] 
-                 + gRandom->Gaus(adc_pedestal[16+j], adc_sigma[16+j]);
+        adc[16+j] = static_cast<Int_t>(map [16+2*j]+ map [16+2*j+1] 
+                                      + gRandom->Gaus(adc_pedestal[16+j], adc_sigma[16+j]));
        Float_t min_time = TMath::Min(time [16+2*j],time [16+2*j+1]);
        time2[16+j] = min_time;
        if(min_time==0.0){time2[16+j]=TMath::Max(time[16+2*j],time[16+2*j+1]);}
index b87b933..9e94a01 100644 (file)
@@ -19,6 +19,10 @@ class AliVZEROPreprocessor : public AliPreprocessor
     virtual UInt_t Process(TMap* dcsAliasMap);
 
     AliVZERODataDCS *fData;    // CDB class that stores the data
+
+ private:
+    AliVZEROPreprocessor(const AliVZEROPreprocessor&); // Not implemented
+    AliVZEROPreprocessor& operator=(const AliVZEROPreprocessor&); // Not implemented
     
     ClassDef(AliVZEROPreprocessor, 0);
 };
index 807220e..d1379b2 100644 (file)
@@ -51,6 +51,7 @@ AliZDCRawStream::AliZDCRawStream(AliRawReader* rawReader) :
 //_____________________________________________________________________________
 AliZDCRawStream::AliZDCRawStream(const AliZDCRawStream& stream) :
   TObject(stream),
+  fRawReader(stream.fRawReader),
   fRawADC(stream.GetADCRaw()),
   fADCModule(stream.GetADCModule()),    
   fADCChannel(stream.GetADCChannel()),