get rid of coding violations and warnings (Jochen)
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 7 Mar 2008 19:03:40 +0000 (19:03 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 7 Mar 2008 19:03:40 +0000 (19:03 +0000)
26 files changed:
HLT/TPCLib/AliHLTTPCEventStatisticsProducerComponent.cxx
HLT/TPCLib/AliHLTTPCEventStatisticsProducerComponent.h
HLT/TPCLib/AliHLTTPCRunStatisticsProducerComponent.cxx
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplay.cxx
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplay.h
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplay3D.cxx
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplay3D.h
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayCharge.cxx
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayCharge.h
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayFront.cxx
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayFront.h
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayMain.cxx
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayMain.h
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayPad.cxx
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayPad.h
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayPadRow.cxx
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayPadRow.h
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayResiduals.cxx
HLT/TPCLib/OnlineDisplay/AliHLTTPCDisplayResiduals.h
HLT/TPCLib/OnlineDisplay/Makefile.am
HLT/TPCLib/comp/AliHLTTPCCompModelAnalysis.cxx
HLT/TPCLib/comp/AliHLTTPCCompModelAnalysis.h
HLT/TPCLib/comp/AliHLTTPCCompModelConverterComponent.cxx
HLT/TPCLib/comp/AliHLTTPCCompModelDeflaterComponent.cxx
HLT/comp/AliHLTCOMPHuffmanAltroCalibComponent.cxx
HLT/trigger/AliHLTRunSummaryProducerComponent.cxx

index 95eb7fe..484768e 100644 (file)
@@ -214,7 +214,7 @@ Int_t AliHLTTPCEventStatisticsProducerComponent::DoEvent( const AliHLTComponentE
 
     HLTDebug ( "Input Data - TPC cluster - Slice/Patch: %d/%d.", slice, patch );
 
-    AddClusters( iter->fPtr , iter->fSize, (Int_t) slice, (Int_t) patch );
+    AddClusters( iter->fPtr, (Int_t) slice, (Int_t) patch );
   } // for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkClustersDataType); iter != NULL; iter = GetNextInputBlock() ) {
   
 
@@ -230,7 +230,7 @@ Int_t AliHLTTPCEventStatisticsProducerComponent::DoEvent( const AliHLTComponentE
     AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
     HLTDebug ( "Input Data - TPC track segments - Slice: %d.", slice );
 
-    AddTracks( iter->fPtr , iter->fSize, (Int_t) slice );
+    AddTracks( iter->fPtr, (Int_t) slice );
   } //   for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkTrackSegmentsDataType); iter != NULL; iter = GetNextInputBlock() ) {
   
   //
@@ -244,7 +244,7 @@ Int_t AliHLTTPCEventStatisticsProducerComponent::DoEvent( const AliHLTComponentE
     
     HLTDebug ( "Input Data - TPC track segments." );
 
-    AddTracks( iter->fPtr , iter->fSize );
+    AddTracks( iter->fPtr );
   } //   for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkTracksDataType); iter != NULL; iter = GetNextInputBlock() ) {
   
 
@@ -286,13 +286,20 @@ void AliHLTTPCEventStatisticsProducerComponent::InitializeEvent() {
 }
 
 // -- **********************************************************************************************
-void AliHLTTPCEventStatisticsProducerComponent::AddClusters( void* ptr , AliHLTUInt32_t /*size*/, Int_t slice, Int_t patch ) {
+void AliHLTTPCEventStatisticsProducerComponent::AddClusters( void* ptr, Int_t slice, Int_t patch ) {
   // see header file for class documentation
 
   const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*) ptr;
 
+  // these 2 variables have been introduced to avoid warning: unused variable in production compile
+  Int_t sliceAntiWarning = slice;
+  Int_t patchAntiWarning = patch;
+
   Int_t nSpacepoint = (Int_t) clusterData->fSpacePointCnt;
-  HLTDebug( "%d Clusters found for slice %u - patch %u\n", nSpacepoint, slice, patch );
+  HLTDebug( "%d Clusters found for slice %u - patch %u\n", nSpacepoint, sliceAntiWarning, patchAntiWarning );
+
+  sliceAntiWarning = 0;
+  patchAntiWarning = 0;
 
   // ** Add to event statistics
   fEvStat->AddNTotalCluster( nSpacepoint );
@@ -300,7 +307,7 @@ void AliHLTTPCEventStatisticsProducerComponent::AddClusters( void* ptr , AliHLTU
 }
 
 // -- **********************************************************************************************
-void AliHLTTPCEventStatisticsProducerComponent::AddTracks( void* ptr , AliHLTUInt32_t /*size*/, Int_t slice ) {
+void AliHLTTPCEventStatisticsProducerComponent::AddTracks( void* ptr, Int_t slice ) {
   // see header file for class documentation
 
   const AliHLTTPCTrackletData* trackData = (const AliHLTTPCTrackletData*) ptr;
index da9485c..c6fb6f5 100644 (file)
@@ -80,14 +80,14 @@ public:
    * @param slice Slice
    * @param patch Patch
    */
-  void AddClusters( void* ptr, AliHLTUInt32_t size, Int_t slice, Int_t patch );
+  void AddClusters( void* ptr, Int_t slice, Int_t patch );
 
   /** Add new tracks block
    * @param ptr   Pointer to data block
    * @param size  Size of data block
    * @param slice Slice, default is -1 for GlobalMerger tracks
    */
-  void AddTracks( void* ptr, AliHLTUInt32_t size, Int_t slice=-1 );     
+  void AddTracks( void* ptr, Int_t slice=-1 );     
 
   /** Process even -> get process statistics */
   void ProcessEvent();                          
index 860f432..7265df5 100644 (file)
@@ -99,7 +99,7 @@ AliHLTComponent* AliHLTTPCRunStatisticsProducerComponent::Spawn() {
 }
  
 // ------------------------------------------------------------------------------------------
-Int_t AliHLTTPCRunStatisticsProducerComponent::DoInit( int argc, const char** argv ) {
+Int_t AliHLTTPCRunStatisticsProducerComponent::DoInit( int /*argc*/, const char** /*argv*/ ) {
   // see header file for class documentation
 
   Int_t iResult = 0;
@@ -124,7 +124,8 @@ Int_t AliHLTTPCRunStatisticsProducerComponent::DoDeinit() {
 }
 
 // ------------------------------------------------------------------------------------------
-Int_t AliHLTTPCRunStatisticsProducerComponent::DoEvent( const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& trigData ) {
+Int_t AliHLTTPCRunStatisticsProducerComponent::DoEvent( const AliHLTComponentEventData& /*evtData*/,
+                                                       AliHLTComponentTriggerData& /*trigData*/ ) {
   // see header file for class documentation
 
   // ** Process EventStatistics Block
index ab169c6..951609e 100644 (file)
 using namespace std;
 #endif
 
-ClassImp(AliHLTTPCDisplay)
+ClassImp(AliHLTTPCDisplay);
+
+AliHLTTPCDisplay::AliHLTTPCDisplay( Char_t * gfile ) :
+  fTrackParam(),
+  fClusters(),
+  fTracks(),
+  fNcl(),
+  fHistrawcl(NULL),
+  fHistraw(NULL),
+  fHistpad1(NULL),
+  fHistpad2(NULL),
+  fHistpad3(NULL),
+  fHistallresidualsY(NULL),
+  fHistallresidualsZ(NULL),
+  fHistcharge(NULL),
+  fGraphresidualsY(NULL),
+  fGraphresidualsZ(NULL),
+  fGraphresidualsYLength(NULL),
+  fGraphresidualsZLength(NULL),
+  fGeom(NULL),
+  fBackColor(1),
+  fLineColor(0),
+  fKeepView(kFALSE),
+  fPad(-1),
+  fPadRow(0),
+  fSlicePadRow(0),
+  fNPads(0),
+  fNTimes(0),
+  fMinHits(0),
+  fPtThreshold(0),
+  fSelectTrackSwitch(kFALSE),
+  fSelectTrack(-1),
+  fSelectTrackSlice(0),
+  fSelectCluster(0),
+  fMinSlice(0),
+  fMaxSlice(25),
+  fSlicePair(kFALSE),
+  fSliceArray(),
+  fDrawGeo(kFALSE),
+  fcolorbin(),
+  fbinct(),
+  fpmarr(),
+  fSwitch3DCluster(kFALSE),
+  fSwitch3DTracks(kFALSE),
+  fSwitch3DPadRow(kFALSE),
+  fSwitch3DGeometry(kFALSE) 
+{
+  // constructor    
+  InitDisplay(gfile);
+}
 
 // #############################################################################
 void AliHLTTPCDisplay::InitDisplay(Char_t *gfile) {
     //constructor
     memset(fClusters,0,36*6*sizeof(AliHLTTPCSpacePointData*));
     memset(fNcl, 0, 36*6*sizeof(UInt_t)); 
-
-    fTracks = NULL;
-    fHistrawcl = NULL;
-    fHistraw = NULL;
-    fHistpad1 = NULL;
-    fHistpad2 = NULL;
-    fHistpad3 = NULL;
-    fHistallresidualsY = NULL;   
-    fHistallresidualsZ = NULL;
-    fHistcharge = NULL;
-    fGraphresidualsY = NULL;
-    fGraphresidualsZ = NULL;
-    fGraphresidualsYLength = NULL;
-    fGraphresidualsZLength = NULL;
-
-
-    fGeom = NULL;
+   
 // ---------------------------------------------------
 // In order to be backward compatible
 // ---------------------------------------------------
@@ -110,34 +143,11 @@ void AliHLTTPCDisplay::InitDisplay(Char_t *gfile) {
     //fc1 = NULL;
 #endif 
 // ---------------------------------------------------
-    fNPads = 0;
-    fNTimes = 0;
-    fMinHits = 0;
-    fPtThreshold = 0.;
-    fPad = -1;
-    fPadRow = 0;
-    fSlicePadRow = 0; 
-    fSelectTrack = -1;
-    fSelectTrackSlice = 0;
-    fSelectTrackSwitch = kFALSE;
-    fSelectCluster = 0;
-
-    fMinSlice = 0;
-    fMaxSlice = 35;
-    fSlicePair = kFALSE;
-
+   
     SetSliceArray();
-
-    fBackColor = 1; 
-    fLineColor = 0;
-    fKeepView = kFALSE;
-
-    fSwitch3DCluster = kFALSE;
-    fSwitch3DTracks = kFALSE;
-    fSwitch3DPadRow = kFALSE;
-    fSwitch3DGeometry = kFALSE;
-
+   
     AliHLTTPCTransform::SetBField(0.4);
+    
     LoadGeometrie(gfile);
 }
 
index 66da605..16a553f 100644 (file)
@@ -28,7 +28,7 @@ class AliHLTTPCTrackArray;
 class AliHLTTPCDisplay : public TObject, public AliHLTLogging {
 
  public:
-    AliHLTTPCDisplay(Char_t *gfile="$(ALIHLT_BASEDIR)/geo/alice.geom") {InitDisplay(gfile);}
+    AliHLTTPCDisplay(Char_t *gfile="$(ALIHLT_BASEDIR)/geo/alice.geom");
     virtual ~AliHLTTPCDisplay();
 
     void InitDisplay(Char_t *gfile);
@@ -142,8 +142,8 @@ class AliHLTTPCDisplay : public TObject, public AliHLTLogging {
     Bool_t LoadGeometrie(Char_t *gfile);
     void SetSliceArray();
 
-    AliHLTTPCDisplay(const AliHLTTPCDisplay &/*d*/):TObject(){;}
-    AliHLTTPCDisplay& operator=(const AliHLTTPCDisplay &/*d*/){return *this;}
+  AliHLTTPCDisplay(const AliHLTTPCDisplay &/*d*/); //:TObject(){;}
+  AliHLTTPCDisplay& operator=(const AliHLTTPCDisplay &/*d*/);//{return *this;}
     
     AliHLTTPCSpacePointData *fClusters[36][6]; 
     AliHLTTPCTrackArray *fTracks; 
index 4e6ef20..023b107 100644 (file)
@@ -90,11 +90,12 @@ using namespace std;
 ClassImp(AliHLTTPCDisplay3D)
 
 //____________________________________________________________________________________________________
-AliHLTTPCDisplay3D::AliHLTTPCDisplay3D(AliHLTTPCDisplayMain* display, Char_t* gfile ) {
+  AliHLTTPCDisplay3D::AliHLTTPCDisplay3D(AliHLTTPCDisplayMain* display, Char_t* gfile ) :
+    fTrackParam(),
+    fDisplay(display),
+    fGeom(NULL) {
     // constructor
-    fDisplay = display;
-    
-    fGeom = NULL;
+
     LoadGeometrie(gfile);
 }
 
index be15f4c..c387f5a 100644 (file)
@@ -49,6 +49,10 @@ class AliHLTTPCDisplay3D : public AliHLTLogging {
 
 // ---------------------------------------------------
  private:
+  AliHLTTPCDisplay3D (const AliHLTTPCDisplay3D&);
+  AliHLTTPCDisplay3D& operator=(const AliHLTTPCDisplay3D&);
+
+
     void LoadGeometrie(Char_t *gfile);
 
     AliHLTTPCDisplayMain* fDisplay;
index fd7b69f..8a44706 100644 (file)
@@ -46,14 +46,15 @@ using namespace std;
 ClassImp(AliHLTTPCDisplayCharge)
 
 //____________________________________________________________________________________________________
-AliHLTTPCDisplayCharge::AliHLTTPCDisplayCharge(AliHLTTPCDisplayMain* display) {
+  AliHLTTPCDisplayCharge::AliHLTTPCDisplayCharge(AliHLTTPCDisplayMain* display) :
+    fDisplay(display),
+    fHistcharge(NULL),
+    fMaxCharge(0),
+    fTmpEvent(0)  {
     // constructor
-    fDisplay = display;
 
     fBinX[0] = 0;      
     fBinX[1] = 1; 
-    fTmpEvent = 0;         
-    fMaxCharge = 0;
 
     fHistcharge = new TH1F ("fHistcharge","Cluster distribution per charge;charge;#cluster",5000,0,30000);
     fHistcharge->SetTitleSize(0.03);
@@ -145,7 +146,7 @@ void AliHLTTPCDisplayCharge::Draw(){
 }
 
 //____________________________________________________________________________________________________
-void AliHLTTPCDisplayCharge::ExecEvent(Int_t event, Int_t px, Int_t py, TObject *selected){
+void AliHLTTPCDisplayCharge::ExecEvent(Int_t event, Int_t /*px*/, Int_t /*py*/, TObject *selected){
    // Saves the Zoom Position of the Histogram 
 
    // - Mouse down on Axis : StartPoint of Range
index d1ade51..0643d06 100644 (file)
@@ -31,6 +31,9 @@ class AliHLTTPCDisplayCharge : public AliHLTLogging {
     void ExecEvent(Int_t event, Int_t x, Int_t y, TObject *selected);
 
  private:
+    AliHLTTPCDisplayCharge (const AliHLTTPCDisplayCharge&);
+    AliHLTTPCDisplayCharge& operator=(const AliHLTTPCDisplayCharge&);
+
     AliHLTTPCDisplayMain* fDisplay;
 
     TH1F *fHistcharge;             // histogram for clustercharge
index 8d9ab71..874d784 100644 (file)
@@ -45,14 +45,20 @@ using namespace std;
 ClassImp(AliHLTTPCDisplayFront)
 
 //____________________________________________________________________________________________________
-AliHLTTPCDisplayFront::AliHLTTPCDisplayFront(AliHLTTPCDisplayMain* display) {
+  AliHLTTPCDisplayFront::AliHLTTPCDisplayFront(AliHLTTPCDisplayMain* display) : 
+    fDisplay(display),
+    fCanvas(NULL),
+    fHistfront(NULL),
+    fHistfrontcl(NULL),
+    fNTimes( display->GetNTimeBins() ),
+    fBinX(),
+    fBinY(),
+    fTmpEvent(0) {
     // constructor
-    fDisplay = display;
 
-    fNTimes = display->GetNTimeBins();
-    
     fBinY[0] = 0;
     fBinY[1] = AliHLTTPCTransform::GetNRows() - 1;
+
 #if TESTCODE    
     fBinX[0] = (-4) * AliHLTTPCTransform::GetNPads(fBinY[1]);      
     fBinX[1] = (4) * AliHLTTPCTransform::GetNPads(fBinY[1]);
@@ -61,13 +67,8 @@ AliHLTTPCDisplayFront::AliHLTTPCDisplayFront(AliHLTTPCDisplayMain* display) {
     fBinX[0] = 0;      
     fBinX[1] = AliHLTTPCTransform::GetNPads(fBinY[1]);
 #endif    
-    fTmpEvent = 0;    
-    
-    Int_t fBinningFaktor = 4 ;
     
-
-
-
+    //   Int_t fBinningFaktor = 4 ;
  
 #if TESTCODE
     fHistfront = new TH2F("fHistfront","FrontView of selected slice;Pad #;Padrow #",Bins,fBinX[0],fBinX[1],fBinY[1]+1,fBinY[0],fBinY[1]);
@@ -111,8 +112,8 @@ void AliHLTTPCDisplayFront::Fill() {
   Int_t timeSwitch = fDisplay->GetFrontDataSwitch();
 
   // --- TEST CODE beginn
-  Int_t fBinning = 8; // == 1/0.125
-  Int_t fBinningFaktor = 4; // binning / 2 because of width half
+  // Int_t fBinning = 8; // == 1/0.125
+  // Int_t fBinningFaktor = 4; // binning / 2 because of width half
 
 #if TESTCODE
     // use sum
@@ -335,7 +336,7 @@ void AliHLTTPCDisplayFront::Draw(){
 }
 
 //____________________________________________________________________________________________________
-void AliHLTTPCDisplayFront::ExecEvent(Int_t event, Int_t px, Int_t py, TObject *selected){
+void AliHLTTPCDisplayFront::ExecEvent(Int_t event, Int_t/*px*/, Int_t /*py*/, TObject *selected){
    // Saves the Zoom Position of the Histogram 
 
    // - Mouse down on Axis : StartPoint of Range
index b15aba3..3c45ad5 100644 (file)
@@ -33,6 +33,9 @@ public:
   void ExecEvent(Int_t event, Int_t x, Int_t y, TObject *selected);
 
 private:
+  AliHLTTPCDisplayFront (const AliHLTTPCDisplayFront&);
+  AliHLTTPCDisplayFront& operator=(const AliHLTTPCDisplayFront&);
+
   AliHLTTPCDisplayMain* fDisplay;
   TCanvas * fCanvas;
   
index 481f7cc..6a6ca2e 100644 (file)
@@ -72,105 +72,94 @@ const Char_t* padrowID = "KPWR_LDD";   // DDL_RWPK
 ClassImp(AliHLTTPCDisplayMain)
 
 //____________________________________________________________________________________________________
-AliHLTTPCDisplayMain::AliHLTTPCDisplayMain(void* pt2GUI, void (*pt2Function)(void*, Int_t)) {
+  AliHLTTPCDisplayMain::AliHLTTPCDisplayMain(void* pt2GUI, void (*pt2Function)(void*, Int_t)) : 
+    fPt2Gui(pt2GUI),
+    fPadCallback(pt2Function),
+    fReader(NULL),
+    fTrackParam(),
+    fCanvasArray(NULL),
+    fWorkerArray(NULL),
+    fgNTimeBins(1024),  //  446 or 1024
+    fRawReaderMode(0),
+    fZeroSuppressionThreshold (10),
+    fOccupancyLimit(1.0),
+    fBField(0.4),
+    fNTimeBins(1024),
+    fEventID(0),
+    fConnect(kFALSE),
+    fExistsRawData(kFALSE),
+    fExistsClusterData(kFALSE),
+    fExistsTrackData(kFALSE),
+    fDisplayCharge(NULL),
+    fDisplayPadRow(NULL),
+    fDisplayPad(NULL),
+    fDisplay3D(NULL),
+    fDisplayResiduals(NULL),
+    fDisplayFront(NULL),
+    fCanvasCharge(NULL),
+    fCanvasPadRow(NULL),
+    fCanvasPad(NULL),
+    fCanvas3D(NULL),
+    fCanvasResiduals(NULL),
+    fCanvasFront(NULL),
+    fCanvasHits_S(NULL),
+    fCanvasQ_Track(NULL),
+    fCanvasQ_S(NULL),
+    fCanvasPadRow_Pad(NULL),
+    fTracksPerSlice(),
+    fClusters(),
+    fTracks(NULL),
+    fNcl(),
+    fMinSlice(0),
+    fMaxSlice(35),
+    fSlicePair(kFALSE),
+    fSliceArray(),
+    fSelectCluster(),
+    fZeroSuppression( kTRUE ),
+    fPad(-1),
+    fNPads( AliHLTTPCTransform::GetNPads(0) ),
+    fPadRow(0),
+    fSlicePadRow(0),
+    fSplitPadRow(kFALSE),
+    fFrontDataSwitch(2),
+    fTimeBinMin(0),
+    fTimeBinMax(1024),
+    fSplitFront(kFALSE),
+    fSelectTrackSwitch(kFALSE),
+    fSelectTrack(-1),
+    fSelectTrackSlice(0),
+    fCutHits(0),
+    fCutPt(0.),
+    fCutPsi(0.),
+    fCutLambda(0.),
+    fCut_S(0.),
+    fCutPadrow(159),
+    fKeepView(kTRUE),
+    fTheta(90.),
+    fPhi(0.),
+    fBackColor(1),
+    fLineColor(0),
+    fSwitch3DCluster(kFALSE),
+    fSwitch3DTracks(kFALSE),
+    fSwitch3DPadRow(kFALSE),
+    fSwitch3DGeometry(kTRUE),
+    fSwitch3DRaw(0) {
   //constructor
 
   AliHLTLogging::SetGlobalLoggingLevel(kHLTLogError);
 
   fCanvasArray = new TCanvas* [nCanvasTypes];
   fWorkerArray = new void* [nWorkerTypes]; 
-
-  // set N of TimeBins
-  fgNTimeBins = 1024;   //  446 or 1024
-
-  fRawReaderMode = 0;
-  fZeroSuppressionThreshold = 10;
-  fOccupancyLimit = 1.0;
-  fBField = 0.4;
-  fNTimeBins = 1024;
-
-  //callback handler
-  fPt2Gui = pt2GUI;
-  fPadCallback = pt2Function;
-       
-  fReader = NULL;
-  
-  fConnect = kFALSE;
-  fEventID = 0;
-
-  fDisplayCharge = NULL; 
-  fDisplayPadRow = NULL;
-  fDisplayPad = NULL;
-  fDisplay3D = NULL;
-  fDisplayResiduals = NULL;
-  fDisplayFront = NULL;
-
-  fCanvasCharge = NULL;
-  fCanvasPadRow = NULL;
-  fCanvasPad = NULL;
-  fCanvas3D = NULL;
-  fCanvasResiduals = NULL;
-  fCanvasFront = NULL;
-  fCanvasHits_S = NULL;
-  fCanvasQ_Track = NULL;
-  fCanvasQ_S = NULL;
-  fCanvasPadRow_Pad = NULL;
-
-
-  fExistsRawData = kFALSE;
-  fExistsClusterData = kFALSE;
-  fExistsTrackData = kFALSE;
-
+       
   memset(fClusters,0,36*6*sizeof(AliHLTTPCSpacePointData*));
   memset(fNcl, 0, 36*6*sizeof(UInt_t)); 
 
   fTracks = NULL;
 
-  fZeroSuppression = kTRUE;
-  fNPads = AliHLTTPCTransform::GetNPads(0);
-  fPad = -1;
-  fPadRow = 0;
-  fSlicePadRow = 0; 
-  fSplitPadRow = kFALSE;
-  
-  fFrontDataSwitch = 2;
-  fTimeBinMin = 0;
   fTimeBinMax = GetNTimeBins() -1;
-  fSplitFront = kFALSE;
-    
-  fSelectTrack = -1;
-  fSelectTrackSlice = 0;
-  fSelectTrackSwitch = kFALSE;
   
-  fSelectCluster = 0;
-
-  fMinSlice = 0;
-  fMaxSlice = 35;
-  fSlicePair = kFALSE;
-
   SetSliceArray();
   
-  fTheta = 90.;
-  fPhi = 0.;
-
-  fBackColor = 1;
-  fLineColor = 0;
-  fKeepView = kTRUE;
-
-  fSwitch3DCluster = kFALSE;
-  fSwitch3DTracks = kFALSE;
-  fSwitch3DPadRow = kFALSE;
-  fSwitch3DGeometry = kTRUE;
-  fSwitch3DRaw = 0;
-
-  fCutHits = 0;
-  fCutPt = 0.;
-  fCutPsi = 0.;
-  fCutLambda = 0.;
-  fCut_S = 0.;
-  fCutPadrow = 159;
-  
-
   fTrackParam.kappa = 0.;
   fTrackParam.nHits = 0;
   fTrackParam.charge = 0;
@@ -1044,7 +1033,7 @@ Int_t AliHLTTPCDisplayMain::GetGlobalTrack(Int_t slice){
 //----------------------------------------------------------------------------------------------------
 //                 EVENTS
 //____________________________________________________________________________________________________
-void AliHLTTPCDisplayMain::ExecPadEvent(Int_t event, Int_t px, Int_t py, TObject *selected){
+void AliHLTTPCDisplayMain::ExecPadEvent(Int_t event, Int_t px, Int_t /*py*/, TObject *selected){
    TCanvas *c = (TCanvas *) gTQSender;
 
    if (event == 11 &&selected->InheritsFrom("TH2F")) {
index f02147c..0ebf828 100644 (file)
@@ -389,11 +389,8 @@ Char_t GetTrackParamBfield());
   /** assignment operator prohibited */
   AliHLTTPCDisplayMain& operator=(const AliHLTTPCDisplayMain&);
 
-  //    AliHLTTPCDisplayMain(const AliHLTTPCDisplayMain &/*d*/):TObject(){;}
-  //    AliHLTTPCDisplayMain& operator=(const AliHLTTPCDisplayMain &/*d*/){return *this;}
-      
-    void SetSliceArray();          // Fill Array with slices which 
-
+  void SetSliceArray();          // Fill Array with slices which 
+  
   // ** global constants **
   Int_t fgNTimeBins;             // Number of TimeBins
   Int_t fRawReaderMode;           // raw reader mode
@@ -403,98 +400,98 @@ Char_t GetTrackParamBfield());
   Int_t fNTimeBins;
 
 
-    // **  HOMER parameter / connection / data exist **
-    ULong64_t fEventID;            // Event ID
-
-    Bool_t fConnect;               // Connection status
+  // **  HOMER parameter / connection / data exist **
+  ULong64_t fEventID;            // Event ID
+  
+  Bool_t fConnect;               // Connection status
+  
+  Bool_t fExistsRawData;         // Raw data present
+  Bool_t fExistsClusterData;     // Cluster data present
+  Bool_t fExistsTrackData;       // Track data present
+  
+  // ** pointer to display classes **
+  AliHLTTPCDisplayCharge* fDisplayCharge; 
+  AliHLTTPCDisplayPadRow* fDisplayPadRow;
+  AliHLTTPCDisplayPad* fDisplayPad;
+  AliHLTTPCDisplay3D* fDisplay3D;
+  AliHLTTPCDisplayResiduals* fDisplayResiduals;
+  AliHLTTPCDisplayFront * fDisplayFront;
   
-    Bool_t fExistsRawData;         // Raw data present
-    Bool_t fExistsClusterData;     // Cluster data present
-    Bool_t fExistsTrackData;       // Track data present
-
-    // ** pointer to display classes **
-    AliHLTTPCDisplayCharge* fDisplayCharge; 
-    AliHLTTPCDisplayPadRow* fDisplayPadRow;
-    AliHLTTPCDisplayPad* fDisplayPad;
-    AliHLTTPCDisplay3D* fDisplay3D;
-    AliHLTTPCDisplayResiduals* fDisplayResiduals;
-    AliHLTTPCDisplayFront * fDisplayFront;
-
-    // ** pointer to canvases in GUI ** 
-    TCanvas * fCanvasCharge;
-    TCanvas * fCanvasPadRow;
-    TCanvas * fCanvasPad;
-    TCanvas * fCanvas3D;
-    TCanvas * fCanvasResiduals;
-    TCanvas * fCanvasFront;
-    TCanvas * fCanvasHits_S;
-    TCanvas * fCanvasQ_Track;
-    TCanvas * fCanvasQ_S;
-    TCanvas * fCanvasPadRow_Pad;
-
-    Int_t fTracksPerSlice[36];     // TrackCount per slice
-
-    // ** cluster / tarck container **
-    AliHLTTPCSpacePointData *fClusters[36][6]; 
-    AliHLTTPCTrackArray *fTracks; 
+  // ** pointer to canvases in GUI ** 
+  TCanvas * fCanvasCharge;
+  TCanvas * fCanvasPadRow;
+  TCanvas * fCanvasPad;
+  TCanvas * fCanvas3D;
+  TCanvas * fCanvasResiduals;
+  TCanvas * fCanvasFront;
+  TCanvas * fCanvasHits_S;
+  TCanvas * fCanvasQ_Track;
+  TCanvas * fCanvasQ_S;
+  TCanvas * fCanvasPadRow_Pad;
+
+  Int_t fTracksPerSlice[36];     // TrackCount per slice
+
+  // ** cluster / tarck container **
+  AliHLTTPCSpacePointData *fClusters[36][6]; 
+  AliHLTTPCTrackArray *fTracks; 
     
-    UInt_t fNcl[36][6];            // Number of cluster
-
-    // ** selected selected slice(s) **
-    Int_t fMinSlice;               // Min slice
-    Int_t fMaxSlice;               // Max slice
-    Bool_t fSlicePair;             // Pair of slices;
-    Bool_t fSliceArray[36];        // Array if slice should be drawn or not
-
-    // ** select type of clusters **
-    Int_t fSelectCluster;          // select all=0, used=1, unused=2 cluster
-
-    // ** raw data variables **
-    Bool_t fZeroSuppression;       // enable zero suppression
-    //     -- pad/padrow
-    Int_t fPad;                    // pad
-    Int_t fNPads;                  // number of pads in row
-    Int_t fPadRow;                 // padrow
-    Int_t fSlicePadRow;            // slice where padrow is in
-    Bool_t fSplitPadRow;           // Split PadRow Canvas
+  UInt_t fNcl[36][6];            // Number of cluster
+  
+  // ** selected selected slice(s) **
+  Int_t fMinSlice;               // Min slice
+  Int_t fMaxSlice;               // Max slice
+  Bool_t fSlicePair;             // Pair of slices;
+  Bool_t fSliceArray[36];        // Array if slice should be drawn or not
+  
+  // ** select type of clusters **
+  Int_t fSelectCluster;          // select all=0, used=1, unused=2 cluster
+  
+  // ** raw data variables **
+  Bool_t fZeroSuppression;       // enable zero suppression
+  //     -- pad/padrow
+  Int_t fPad;                    // pad
+  Int_t fNPads;                  // number of pads in row
+  Int_t fPadRow;                 // padrow
+  Int_t fSlicePadRow;            // slice where padrow is in
+  Bool_t fSplitPadRow;           // Split PadRow Canvas
     //     -- front
-    Int_t fFrontDataSwitch;        // select average/sum/maximum
-    Int_t fTimeBinMin;             // min TimeBin
-    Int_t fTimeBinMax;             // max TimeBin
-    Bool_t fSplitFront;            // Split Front Canvas
-
+  Int_t fFrontDataSwitch;        // select average/sum/maximum
+  Int_t fTimeBinMin;             // min TimeBin
+  Int_t fTimeBinMax;             // max TimeBin
+  Bool_t fSplitFront;            // Split Front Canvas
+  
+  
+  
+  // ** select tracks **
+  Bool_t fSelectTrackSwitch;     // switch ti single track mode
+  Int_t fSelectTrack;            // select single track
+  Int_t fSelectTrackSlice;       // select slice for single track
+  
+  
+  // ** cuts on tracks **
+  Int_t fCutHits;
+  Float_t fCutPt;
+  Float_t fCutPsi;
+  Float_t fCutLambda;
+  Float_t fCut_S;
+  Int_t fCutPadrow;
+  
+  // ** "keepview", angles and colors for 3D view **
+  Bool_t fKeepView;              // Keep View when redisplaying
+  
+  Float_t fTheta;
+  Float_t fPhi;
+  
+  Int_t fBackColor;              // Background color
+  Int_t fLineColor;              // Line color
+  
+  // ** 3D switches **
+  Bool_t fSwitch3DCluster;
+  Bool_t fSwitch3DTracks;
+  Bool_t fSwitch3DPadRow;
+  Bool_t fSwitch3DGeometry;
+  Int_t fSwitch3DRaw;    
   
-    // ** select tracks **
-    Bool_t fSelectTrackSwitch;     // switch ti single track mode
-    Int_t fSelectTrack;            // select single track
-    Int_t fSelectTrackSlice;       // select slice for single track
-
-
-    // ** cuts on tracks **
-    Int_t fCutHits;
-    Float_t fCutPt;
-    Float_t fCutPsi;
-    Float_t fCutLambda;
-    Float_t fCut_S;
-    Int_t fCutPadrow;
-
-    // ** "keepview", angles and colors for 3D view **
-    Bool_t fKeepView;              // Keep View when redisplaying
-
-    Float_t fTheta;
-    Float_t fPhi;
-
-    Int_t fBackColor;              // Background color
-    Int_t fLineColor;              // Line color
-
-    // ** 3D switches **
-    Bool_t fSwitch3DCluster;
-    Bool_t fSwitch3DTracks;
-    Bool_t fSwitch3DPadRow;
-    Bool_t fSwitch3DGeometry;
-    Int_t fSwitch3DRaw;    
-
-    ClassDef(AliHLTTPCDisplayMain,0) //Display class
+  ClassDef(AliHLTTPCDisplayMain,0) //Display class
 };
 #endif
index 5128097..dbcd357 100644 (file)
@@ -43,15 +43,18 @@ using namespace std;
 ClassImp(AliHLTTPCDisplayPad)
 
 //____________________________________________________________________________________________________
-AliHLTTPCDisplayPad::AliHLTTPCDisplayPad(AliHLTTPCDisplayMain* display) {
+  AliHLTTPCDisplayPad::AliHLTTPCDisplayPad(AliHLTTPCDisplayMain* display) :
+    fDisplay(display),
+    fHistpad1(NULL),
+    fHistpad2(NULL),
+    fHistpad3(NULL),
+    fNTimes(  AliHLTTPCTransform::GetNTimeBins() ),
+    fBinX(),
+    fTmpEvent(0) {
     // constructor
-    fDisplay = display;
-
-    fNTimes = AliHLTTPCTransform::GetNTimeBins();
 
     fBinX[0] = 0;      
     fBinX[1] = fNTimes -1; 
-    fTmpEvent = 0;    
 
     fHistpad1 = new TH1F ("fHistpad1","Selected Pad -1;Timebin #",fNTimes,0,fNTimes-1);
     fHistpad2 = new TH1F ("fHistpad2","Selected Pad;Timebin #",fNTimes,0,fNTimes-1); 
@@ -196,7 +199,7 @@ void AliHLTTPCDisplayPad::Draw(){
 }
 
 //____________________________________________________________________________________________________
-void AliHLTTPCDisplayPad::ExecEvent(Int_t event, Int_t px, Int_t py, TObject *selected){
+void AliHLTTPCDisplayPad::ExecEvent(Int_t event, Int_t /*px*/, Int_t /*py*/, TObject *selected){
    // Saves the Zoom Position of the Histogram 
 
    // - Mouse down on Axis : StartPoint of Range
index f2f6132..a2eef4e 100644 (file)
@@ -37,6 +37,9 @@ class AliHLTTPCDisplayPad : public AliHLTLogging {
 
    
  private:
+    AliHLTTPCDisplayPad (const AliHLTTPCDisplayPad&);
+    AliHLTTPCDisplayPad& operator=(const AliHLTTPCDisplayPad&);
+
     AliHLTTPCDisplayMain* fDisplay;
 
     TH1F *fHistpad1;               // histogram for pad in padrow
index aaa8050..3cce06c 100644 (file)
@@ -48,17 +48,25 @@ using namespace std;
 ClassImp(AliHLTTPCDisplayPadRow)
 
 //____________________________________________________________________________________________________
-AliHLTTPCDisplayPadRow::AliHLTTPCDisplayPadRow(AliHLTTPCDisplayMain* display) {
+  AliHLTTPCDisplayPadRow::AliHLTTPCDisplayPadRow(AliHLTTPCDisplayMain* display) :
+    fDisplay(NULL),
+    fHistrawcl(NULL),
+    fHistraw(NULL),
+    fcolorbin(),
+    fbinct(),
+    fpmarr(),
+    fNTimes( AliHLTTPCTransform::GetNTimeBins() ),
+    fBinX(),
+    fBinY(),
+    fTmpEvent(0) {
+
     // constructor
     fDisplay = display;
 
-    fNTimes = AliHLTTPCTransform::GetNTimeBins();
-    
     fBinX[0] = 0;      
     fBinX[1] = fDisplay->GetNPads(); 
     fBinY[0] = 0;
     fBinY[1] = fNTimes -1;
-    fTmpEvent = 0;         
 
     for (Int_t ii = 0;ii < 20; ii++)
       fpmarr[ii] = 0;
@@ -117,11 +125,11 @@ void AliHLTTPCDisplayPadRow::Fill(){
 #if defined(HAVE_TPC_MAPPING)
     AliHLTTPCDigitReaderRaw digitReader(0);
 
-    bool readValue = true;
-    Int_t rowOffset = 0;
+    //    bool readValue = true;
+    //Int_t rowOffset = 0;
     
     Int_t padRow = fDisplay->GetPadRow();
-    Int_t slice = fDisplay->GetSlicePadRow();
+    //Int_t slice = fDisplay->GetSlicePadRow();
 
 #if 0
     // Initialize RAW DATA
@@ -347,7 +355,7 @@ void AliHLTTPCDisplayPadRow::Draw3D(){
 }
 
 //____________________________________________________________________________________________________
-void AliHLTTPCDisplayPadRow::ExecEvent(Int_t event, Int_t px, Int_t py, TObject *selected){
+void AliHLTTPCDisplayPadRow::ExecEvent(Int_t event, Int_t /*px*/, Int_t /*py*/, TObject *selected){
    // Saves the Zoom Position of the Histogram 
 
    // - Mouse down on Axis : StartPoint of Range
index 67308d5..f519509 100644 (file)
@@ -34,6 +34,9 @@ class AliHLTTPCDisplayPadRow : public AliHLTLogging  {
     void ExecEvent(Int_t event, Int_t x, Int_t y, TObject *selected);
 
  private:
+    AliHLTTPCDisplayPadRow (const AliHLTTPCDisplayPadRow&);
+    AliHLTTPCDisplayPadRow& operator=(const AliHLTTPCDisplayPadRow&);
+
     AliHLTTPCDisplayMain* fDisplay;
 
     TH1F *fHistrawcl;              // histogram for cluster in padrow
index 2d77a8f..32e3435 100644 (file)
@@ -60,14 +60,20 @@ using namespace std;
 ClassImp(AliHLTTPCDisplayResiduals)
 
 //____________________________________________________________________________________________________
-AliHLTTPCDisplayResiduals::AliHLTTPCDisplayResiduals(AliHLTTPCDisplayMain* display) {
+  AliHLTTPCDisplayResiduals::AliHLTTPCDisplayResiduals(AliHLTTPCDisplayMain* display):
+    fDisplay(NULL),
+    fHistallresidualsY(NULL),
+    fHistallresidualsZ(NULL),
+    fHistHits_S(NULL),
+    fHistQ_Track(NULL),
+    fHistQ_S(NULL),
+    fGraphresidualsY(NULL),
+    fGraphresidualsZ(NULL),
+    fGraphresidualsYLength(NULL) {
+
     // constructor
     fDisplay = display;
 
-    fGraphresidualsY = NULL;
-    fGraphresidualsZ = NULL;
-    fGraphresidualsYLength = NULL;
-
     fHistallresidualsY = new TH1F ("fHistallresidualsY","Y Residuals of all tracks in selected slices;residuals",5000,-100,100);
     fHistallresidualsZ = new TH1F ("fHistallresidualsZ","Z Residuals of all tracks in selected slices;residuals",5000,-100,100);
     fHistHits_S = new TH1F ("fHistHits_S","Number of cluster over track length;#Hits/s",20,0,20);
index 2bb1427..e6e21b4 100644 (file)
@@ -29,6 +29,9 @@ class AliHLTTPCDisplayResiduals {
     void Fill();
     void Save();
  private:
+    AliHLTTPCDisplayResiduals (const AliHLTTPCDisplayResiduals&);
+    AliHLTTPCDisplayResiduals& operator=(const AliHLTTPCDisplayResiduals&);
+
     AliHLTTPCDisplayMain* fDisplay;
 
     TH1F *fHistallresidualsY;          // histogram for all Y residuals
index 0a6f7e2..c310779 100644 (file)
@@ -46,7 +46,8 @@ CLASS_HDRS                    = AliHLTTPCDisplayMain.h  \
 pkginclude_HEADERS             = $(CLASS_HDRS)
 
 # version info for the library
-libAliHLTTPCDisplay_la_LIBADD  = @HOMER_INBUILT_LIB@
+libAliHLTTPCDisplay_la_LIBADD  = @HOMER_INBUILT_LIB@ \
+                                 $(top_builddir)/TPCLib/libAliHLTTPC.la
 libAliHLTTPCDisplay_la_LDFLAGS = -L@ROOTLIBDIR@ \
                                  @ROOTLIBS@ \
                                  @ALIROOT_LDFLAGS@ \
index f2825bc..70f964d 100644 (file)
@@ -401,7 +401,7 @@ Int_t AliHLTTPCCompModelAnalysis::CompareClusters(Bool_t relativedifferences)
   Int_t notcomparedclusters = 0;
 
   // create graphs out of differences and leave loop
-  TFile* clustergraphrootfile;
+  TFile* clustergraphrootfile = NULL;
   if(!fGraphFileName.IsNull())
     {
       clustergraphrootfile = new TFile(fGraphFileName, "recreate");
@@ -590,7 +590,7 @@ Int_t AliHLTTPCCompModelAnalysis::CompareClusters(Bool_t relativedifferences)
              continue;
            }
 
-         for(Int_t count=0; count < fSecondaryClusters[slicecount][patchcount]->fSpacePointCnt; count++)
+         for(Int_t count=0; count < (Int_t) fSecondaryClusters[slicecount][patchcount]->fSpacePointCnt; count++)
            {
 
              ++totalsecondary;
@@ -675,7 +675,7 @@ Int_t AliHLTTPCCompModelAnalysis::MarkTrashCluster(AliHLTTPCClusterData *discard
   return 0;
 }
 
-Bool_t AliHLTTPCCompModelAnalysis::GetTrashTrackPythiaInfo(AliHLTTPCTrack* discardedtrack)
+Bool_t AliHLTTPCCompModelAnalysis::GetTrashTrackPythiaInfo(AliHLTTPCTrack* /*discardedtrack*/ )
 {
   // see header file for class documentation
   // store information from pythia in current track list entry
@@ -684,7 +684,7 @@ Bool_t AliHLTTPCCompModelAnalysis::GetTrashTrackPythiaInfo(AliHLTTPCTrack* disca
   return 0;
 }
 
-Bool_t AliHLTTPCCompModelAnalysis::GetClusterPythiaInfo(AliHLTTPCClusterData* discardedcluster)
+Bool_t AliHLTTPCCompModelAnalysis::GetClusterPythiaInfo(AliHLTTPCClusterData* /*discardedcluster*/)
 {
   // see header file for class documentation
   // Pythia information can be
index d9cb0d9..06a6195 100644 (file)
@@ -38,6 +38,18 @@ public:
   /** type needed to build list with discarded tracks or tracks to compare */
   struct AliHLTTPCTrackList
   {
+    AliHLTTPCTrackList() : 
+      track(),
+      pythiatrack(),
+      wronglydiscarded(kFALSE),
+      matchingindicator(0),
+      next(NULL),
+      matchingtrack(NULL)
+    {}
+
+    AliHLTTPCTrackList (const AliHLTTPCTrackList&);
+    AliHLTTPCTrackList& operator= (const AliHLTTPCTrackList&);
+
     AliHLTTPCTrack track;       // store information of found discarded track   
     AliHLTTPCTrack pythiatrack; // store pythia information about this found discarded track
     Bool_t wronglydiscarded;    // flag to mark if track and pythia track information match together
@@ -105,6 +117,11 @@ public:
   Int_t MarkTrashCluster(AliHLTTPCClusterData *discardedcluster, UInt_t slice, UInt_t patch);
  
 private:
+  /** copy constructor prohibited */
+  AliHLTTPCCompModelAnalysis (const AliHLTTPCCompModelAnalysis&); 
+
+  /** assignment operator prohibited */
+  AliHLTTPCCompModelAnalysis& operator= (const AliHLTTPCCompModelAnalysis&);
 
   /** private function to display results from model loss analysis
    * @return 0 upon success
index ba4f50e..88d0677 100644 (file)
@@ -236,7 +236,9 @@ int AliHLTTPCCompModelConverterComponent::DoEvent( const AliHLTComponent_EventDa
       AliHLTUInt8_t minSlice=0xFF, maxSlice=0xFF, minPatch=0xFF, maxPatch=0xFF;
       for ( unsigned long n = 0; n < evtData.fBlockCnt; n++ )
        {
-         AliHLTUInt8_t slice, patch;
+         AliHLTUInt8_t slice = 0;
+         AliHLTUInt8_t patch = 0;
+
          if ( blocks[n].fDataType == AliHLTTPCDefinitions::fgkClustersDataType ||
               blocks[n].fDataType == AliHLTTPCDefinitions::fgkTracksDataType )
            {
index 9e85622..edbde98 100644 (file)
@@ -178,7 +178,8 @@ int AliHLTTPCCompModelDeflaterComponent::DoEvent( const AliHLTComponent_EventDat
              }
            continue;
            }
-         AliHLTUInt8_t slice, patch;
+         AliHLTUInt8_t slice = 0;
+         AliHLTUInt8_t patch = 0;
          if ( blocks[n].fDataType == AliHLTTPCDefinitions::fgkClustersDataType ||
               blocks[n].fDataType == AliHLTTPCDefinitions::fgkTracksDataType )
            {
index 7662d0f..56aabcd 100644 (file)
@@ -34,8 +34,8 @@ ClassImp(AliHLTCOMPHuffmanAltroCalibComponent)
 AliHLTCOMPHuffmanAltroCalibComponent::AliHLTCOMPHuffmanAltroCalibComponent()
   :
   fHuffmanCompressor(NULL),
-  fOrigin(kAliHLTVoidDataOrigin),
   fHuffmanData(NULL),
+  fOrigin(kAliHLTVoidDataOrigin),
   fRunNumber(0),
   fSpecification(0),
   fTablePath(),
@@ -264,7 +264,7 @@ Int_t AliHLTCOMPHuffmanAltroCalibComponent::DeinitCalibration() {
 }
 
 /** function to do the calibration */
-Int_t AliHLTCOMPHuffmanAltroCalibComponent::ProcessCalibration( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData ) {
+Int_t AliHLTCOMPHuffmanAltroCalibComponent::ProcessCalibration( const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/ ) {
   // see header file for class documentation
  
   const AliHLTComponentBlockData* iter = NULL;
@@ -330,7 +330,7 @@ Int_t AliHLTCOMPHuffmanAltroCalibComponent::ProcessCalibration( const AliHLTComp
 } // Int_t AliHLTCOMPHuffmanAltroCalibComponent::ProcessCalibration( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData ) {
 
 
-Int_t AliHLTCOMPHuffmanAltroCalibComponent::ShipDataToFXS( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData ) {
+Int_t AliHLTCOMPHuffmanAltroCalibComponent::ShipDataToFXS( const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/ ) {
   // see header file for class documentation
 
   // create code from training table
index 9daa327..a41ee03 100644 (file)
@@ -183,7 +183,7 @@ void AliHLTRunSummaryProducerComponent::ProcessTriggerData( AliHLTComponentTrigg
     if ( triggerClasses & 0x1 )
       fRunSummary->AddTriggerClass( ndx );
     
-    triggerClasses >> 1;
+    triggerClasses = triggerClasses >> 1;
   }
 
 }