- cleaning up debug output
authorodjuvsla <odjuvsla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 12 Feb 2010 01:13:44 +0000 (01:13 +0000)
committerodjuvsla <odjuvsla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 12 Feb 2010 01:13:44 +0000 (01:13 +0000)
- fixing compilation warnings

12 files changed:
HLT/BASE/util/AliHLTCaloClusterReader.cxx
HLT/BASE/util/AliHLTESDCaloClusterMaker.cxx
HLT/CALO/AliHLTCaloClusterAnalyser.cxx
HLT/CALO/AliHLTCaloClusterAnalyser.h
HLT/CALO/AliHLTCaloClusterizer.cxx
HLT/CALO/AliHLTCaloClusterizer.h
HLT/CALO/AliHLTCaloClusterizerComponent.cxx
HLT/CALO/AliHLTCaloGeometry.cxx
HLT/CALO/AliHLTCaloGeometry.h
HLT/PHOS/AliHLTPHOSClusterizerComponent.cxx
HLT/PHOS/AliHLTPHOSGeometry.cxx
HLT/PHOS/AliHLTPHOSGeometry.h

index 13e57f12da7eaeeb3d95330b8fb93e55f465bc3a..d048137ca5fc2cfa92771f9f9d5305a43bb0fbae 100644 (file)
@@ -97,10 +97,8 @@ AliHLTCaloClusterReader::SetMemory(const AliHLTCaloClusterHeaderStruct* clusterH
 {
   //See header file for documentation
   
-  printf("Header with %d clusters and %d digits\n", clusterHeaderPtr->fNClusters, clusterHeaderPtr->fNDigits);
   fMaxCnt = clusterHeaderPtr->fNClusters;
   fCurrentClusterPtr = reinterpret_cast<AliHLTCaloClusterDataStruct*>((UChar_t*)(clusterHeaderPtr) + sizeof(AliHLTCaloClusterHeaderStruct) + sizeof(AliHLTCaloDigitDataStruct)*clusterHeaderPtr->fNDigits);
-  printf("First cluster energy: %f\n", fCurrentClusterPtr->fEnergy);
   fIsSetMemory = true;
 }
 
index a8dcfe3286733587ded9b1546b571fdd0fb1fbbe..0b55c391f27125afba1ab5445be2eb0fbe5b0a7b 100644 (file)
@@ -90,8 +90,6 @@ AliHLTESDCaloClusterMaker::FillESD(AliESDEvent *esdPtr, const AliHLTCaloClusterH
       //      esdCluster.SetCellsAbsId(idArrayPtr);
       //      esdCluster.SetCellsAmplitudeFraction(ampFracArrayPtr);
 
-      printf("Cluster energy: %f\n", esdCluster.E());
-      
       esdPtr->AddCaloCluster(&esdCluster);
       nClusters++;
     }
index 7467f23e3639c47c1bd890c73f2e574e6ea170a7..135964b997285d4a7ce4bfa9a4ea10b59a2d8683 100644 (file)
@@ -60,15 +60,11 @@ AliHLTCaloClusterAnalyser::AliHLTCaloClusterAnalyser() :
   fClusterType(AliESDCaloCluster::kPHOSCluster)
 {
   //See header file for documentation
-  fHist = new TH1F("cluster_energies", "cluster_energies", 200, 0, 20);
-  
 }
 
 AliHLTCaloClusterAnalyser::~AliHLTCaloClusterAnalyser() 
 {
-   TFile *file = TFile::Open("debug.root", "RECREATE");
-   fHist->Write();
-   file->Close();
+  // See header file for class documentation
 }
 
 void 
@@ -105,11 +101,6 @@ AliHLTCaloClusterAnalyser::CalculateCenterOfGravity()
   Float_t zi = 0.;
 
   AliHLTCaloDigitDataStruct *digit = 0;
-  //AliPHOSGeometry * phosgeom =  AliPHOSGeometry::GetInstance() ;
-   
-  
-  //AliHLTCaloClusterizer      cl("PHOS");
-  //cl.CheckDigits(fRecPointArray, fDigitDataArray, fNRecPoints);
 
   UInt_t iDigit = 0;
 
@@ -117,19 +108,17 @@ AliHLTCaloClusterAnalyser::CalculateCenterOfGravity()
     {
       AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[iRecPoint];
       //      digit = &(recPoint->fDigits);
-      cout << "COG: Rec point multiplicity: " << recPoint->fMultiplicity << ", rec point energy: " << recPoint->fAmp << endl;
+
       Int_t *digitIndexPtr = &(recPoint->fDigits);
 
       for(iDigit = 0; iDigit < recPoint->fMultiplicity; iDigit++)
        {
-         //cout << "1. Digit array: " << fDigitDataArray << ", Digit: " << digit << ", Index: " << *digitIndexPtr << ", ID: " << digit->fID << endl;
 
          digit = &(fDigitDataArray[*digitIndexPtr]);
-         cout << "COG: 2. Digit array: " << fDigitDataArray << ", Digit: " << digit << ", Index: " << *digitIndexPtr << ", index pointer: " << digitIndexPtr<<  endl;
-         cout << ", dig Energy: " << digit->fEnergy << ", Index: " << *digitIndexPtr << ", ID: " << digit->fID << endl;        
+
          xi = digit->fX;
          zi = digit->fZ;
-         //  cout << "COG digits (x:z:E:time): " << xi << " : " << zi << " : " << digit->fEnergy << " : " << digit->fTime << endl;
+
          if (recPoint->fAmp > 0 && digit->fEnergy > 0) 
            {
              Float_t w = TMath::Max( 0., fLogWeight + TMath::Log( digit->fEnergy / recPoint->fAmp ) ) ;
@@ -139,7 +128,7 @@ AliHLTCaloClusterAnalyser::CalculateCenterOfGravity()
            }
          digitIndexPtr++;
        }
-      //cout << endl;
+
       if (wtot>0) 
        {
          recPoint->fX = x/wtot ;
@@ -199,7 +188,7 @@ AliHLTCaloClusterAnalyser::CreateClusters(Int_t nRecPoints, UInt_t availableSize
   UShort_t* cellIDPtr = 0;
   Float_t* cellAmpFracPtr = 0;;
   
-  Int_t id = -1;
+//  Int_t id = -1;
   TVector3 globalPos;
 
   for(Int_t i = 0; i < fNRecPoints; i++) //TODO needs fix when we start unfolding (number of clusters not necessarily same as number of recpoints gotten from the clusterizer
@@ -216,12 +205,9 @@ AliHLTCaloClusterAnalyser::CreateClusters(Int_t nRecPoints, UInt_t availableSize
       cellAmpFracPtr = &(caloClusterPtr->fCellsAmpFraction);
      
       AliHLTCaloRecPointDataStruct *recPointPtr = fRecPointArray[i];
-      cout << "CA: rec point energy: " << recPointPtr->fAmp << ", rec point multiplicity: " << recPointPtr->fMultiplicity << endl;
-      //      cout << "Local Position (x:z:module): " << recPointPtr->fX << " : "<< recPointPtr->fZ << " : " << recPointPtr->fModule << endl;
       
       AliHLTCaloGlobalCoordinate globalCoord;
       fGeometry->GetGlobalCoordinates(*recPointPtr, globalCoord);
-      // cout << "Global Position (x:y:z): " << globalPos[0] << " : "<< globalPos[1] << " : " << globalPos[2] << endl << endl;
 
       caloClusterPtr->fGlobalPos[0] = globalCoord.fX;
       caloClusterPtr->fGlobalPos[1] = globalCoord.fY;
@@ -251,12 +237,6 @@ AliHLTCaloClusterAnalyser::CreateClusters(Int_t nRecPoints, UInt_t availableSize
 
       caloClusterPtr->fEnergy = recPointPtr->fAmp;
 
-      fHist->Fill(caloClusterPtr->fEnergy);
-
-      cout << "CA: cluster energy: " << caloClusterPtr->fEnergy << endl;
-      cout << "CA: recpoint energy: " << recPointPtr->fAmp << endl;
-      
-      
       if(fDoClusterFit)
        {
          FitCluster(recPointPtr);
@@ -307,9 +287,8 @@ AliHLTCaloClusterAnalyser::CreateClusters(Int_t nRecPoints, UInt_t availableSize
       recPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(digitPtr);
       //digitPtr = &(recPointPtr->fDigits);  
     }
-  //  cout << "CA: Energy End: " << fCaloClusterDataPtr->fEnergy << endl;
-  //cout << "CA totSize: " << totSize << endl;
-  return fNRecPoints;
+
+return fNRecPoints;
 
 }
 
index 4f78b5958af00fc3bb3da0a164aac4712d66c838..48f70706d125154718d60d1ad97af901872188b0 100644 (file)
@@ -210,9 +210,13 @@ private:
 
   /** The cluster type */
   Char_t fClusterType;                   //COMMENT
-
-   TH1F *fHist;
-
+ /** Copy constructor  not implemented */
+ AliHLTCaloClusterAnalyser ( const AliHLTCaloClusterAnalyser &); // not implemented
+    
+ /** Assignment */
+AliHLTCaloClusterAnalyser & operator = ( const AliHLTCaloClusterAnalyser &); // not implemented
+    
 };
 
 #endif
index 2cb92d1e457c51f35e9b3a748ef965557777fce6..e21c56114890f7b1c1e65cef023ecaed74cd936d 100644 (file)
@@ -71,7 +71,6 @@ AliHLTCaloClusterizer::AliHLTCaloClusterizer(TString det):
   fAvailableSize = sizeof(AliHLTCaloRecPointDataStruct) * 20;\r
   fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(new UChar_t[fAvailableSize]);\r
   fFirstRecPointPtr = fRecPointDataPtr;  \r
-  printf("Start of rec point data: %x, end of rec point data: %x\n", fRecPointDataPtr, reinterpret_cast<UChar_t*>(fRecPointDataPtr) + fAvailableSize);\r
 \r
 }//end\r
 \r
@@ -100,14 +99,14 @@ AliHLTCaloClusterizer::ClusterizeEvent(Int_t nDigits)
   for(Int_t i = 0; i < nDigits; i++)\r
     { \r
       fDigitsInCluster = 0;\r
-      //      printf("ENERGY: %f\n", fDigitsPointerArray[i]->fEnergy);\r
+\r
       if(fDigitsPointerArray[i]->fEnergy < fEmcClusteringThreshold)\r
        {\r
          continue;\r
        }\r
       CheckArray();\r
       CheckBuffer();\r
-      //            printf("` candidate!\n");\r
+\r
       // First digit is placed at the fDigits member variable in the recpoint\r
       fDigitIndexPtr = &(fRecPointDataPtr->fDigits);\r
       fUsedSize += sizeof(AliHLTCaloRecPointDataStruct);\r
@@ -117,7 +116,6 @@ AliHLTCaloClusterizer::ClusterizeEvent(Int_t nDigits)
 \r
       // Assigning the digit to this rec point\r
       fRecPointDataPtr->fDigits = i;\r
-      printf("Clusterizier: adding digit:  index pointer: %x, index: %d\n", fDigitIndexPtr, *fDigitIndexPtr);\r
       fUsedSize += sizeof(AliHLTCaloRecPointDataStruct);\r
       \r
       // Incrementing the pointer to be ready for new entry\r
@@ -137,8 +135,6 @@ AliHLTCaloClusterizer::ClusterizeEvent(Int_t nDigits)
       //fUsedSize += sizeof(AliHLTCaloRecPointDataStruct) + (fDigitsInCluster-1)*sizeof(AliHLTCaloDigitDataStruct);   \r
       \r
       fRecPointDataPtr->fMultiplicity = fDigitsInCluster;     \r
-      printf("Rec point energy: %f\n", fRecPointDataPtr->fAmp);\r
-      printf("Multiplicity: %d\n", fDigitsInCluster);\r
       fRecPointArray[fNRecPoints] = fRecPointDataPtr; \r
       \r
       fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(fDigitIndexPtr);\r
@@ -182,11 +178,9 @@ AliHLTCaloClusterizer::ScanForNeighbourDigits(Int_t index, AliHLTCaloRecPointDat
 //                  }  \r
                  CheckBuffer();\r
                  // Assigning index to digit\r
-                 printf("Digit index pointer: %x\n", fDigitIndexPtr);\r
                  *fDigitIndexPtr = j;\r
                  fUsedSize += sizeof(Int_t);\r
                  \r
-                 printf("Clusterizier: adding digit:  index pointer: %x, index: %d\n", fDigitIndexPtr, *fDigitIndexPtr); \r
                  // Incrementing digit pointer to be ready for new entry\r
                  fDigitIndexPtr++;\r
 \r
@@ -247,10 +241,8 @@ AliHLTCaloClusterizer::AreNeighbours(AliHLTCaloDigitDataStruct* digit1,
 \r
 Int_t AliHLTCaloClusterizer::CheckArray()\r
 {\r
-      printf("CheckArray: fArraySize: %d, fNRecPoints: %d\n", fArraySize, fNRecPoints);\r
       if(fArraySize == fNRecPoints)\r
        {\r
-          printf("Expanding array...");\r
           fArraySize *= 2;\r
           AliHLTCaloRecPointDataStruct **tmp = new AliHLTCaloRecPointDataStruct*[fArraySize];\r
           memcpy(tmp, fRecPointArray, fArraySize/2 * sizeof(AliHLTCaloRecPointDataStruct*));\r
@@ -263,10 +255,8 @@ Int_t AliHLTCaloClusterizer::CheckArray()
 Int_t AliHLTCaloClusterizer::CheckBuffer()\r
 {\r
    // See header file for class documentation \r
-        printf("CheckBuffer: Used size %d, fAvailableSize: %d\n", fUsedSize, fAvailableSize);\r
-       if((fAvailableSize - fUsedSize) < sizeof(AliHLTCaloRecPointDataStruct) )\r
+       if((fAvailableSize - fUsedSize) < sizeof(AliHLTCaloRecPointDataStruct))\r
        {\r
-          printf("Expanding buffer...\n");\r
            Int_t recPointOffset = reinterpret_cast<UChar_t*>(fRecPointDataPtr) - reinterpret_cast<UChar_t*>(fFirstRecPointPtr);\r
            fAvailableSize *= 2;\r
            UChar_t *tmp = new UChar_t[fAvailableSize];\r
@@ -301,7 +291,6 @@ Int_t AliHLTCaloClusterizer::CheckDigits(AliHLTCaloRecPointDataStruct** recArray
   {\r
      nRecPoints = fNRecPoints;\r
   }\r
-  printf("CL: CheckDigits: Number of rec points: %d\n", nRecPoints);\r
   for(Int_t i = 0; i < nRecPoints; i++)\r
   {\r
           \r
@@ -310,23 +299,16 @@ Int_t AliHLTCaloClusterizer::CheckDigits(AliHLTCaloRecPointDataStruct** recArray
      //AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[0];\r
      Int_t multiplicity = recPoint->fMultiplicity;\r
      Int_t *digitIndexPtr = &(recPoint->fDigits);\r
-     printf("CL: Rec point with energy: %f, multiplicity: %d\n", recPoint->fAmp, recPoint->fMultiplicity);\r
      for(Int_t j = 0; j < multiplicity; j++)\r
      {\r
        //AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[j];\r
-       AliHLTCaloDigitDataStruct *digit = digits[*digitIndexPtr];\r
-       printf("CL: Digit ID: %d, energy: %f, index: %d, indexpointer: %x\n", digit->fID, digit->fEnergy, *digitIndexPtr, digitIndexPtr);\r
+//     AliHLTCaloDigitDataStruct *digit = digits[*digitIndexPtr];\r
        digitIndexPtr++;\r
        //recPoint = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(digitIndexPtr);\r
      }\r
   }\r
      \r
-     \r
-     \r
-     \r
-     \r
-     \r
-     \r
+     return 0;\r
 }\r
 \r
 Int_t AliHLTCaloClusterizer::CheckDigits(AliHLTCaloRecPointDataStruct** recArray, AliHLTCaloDigitDataStruct* digitArray, Int_t nRP)\r
@@ -343,7 +325,6 @@ Int_t AliHLTCaloClusterizer::CheckDigits(AliHLTCaloRecPointDataStruct** recArray
   {\r
      nRecPoints = fNRecPoints;\r
   }\r
-  printf("CL: CheckDigits: Number of rec points: %d\n", nRecPoints);\r
   for(Int_t i = 0; i < nRecPoints; i++)\r
   {\r
           \r
@@ -352,22 +333,14 @@ Int_t AliHLTCaloClusterizer::CheckDigits(AliHLTCaloRecPointDataStruct** recArray
      //AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[0];\r
      Int_t multiplicity = recPoint->fMultiplicity;\r
      Int_t *digitIndexPtr = &(recPoint->fDigits);\r
-     printf("CL: Rec point with energy: %f, multiplicity: %d\n", recPoint->fAmp, recPoint->fMultiplicity);\r
      for(Int_t j = 0; j < multiplicity; j++)\r
      {\r
        //AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[j];\r
        AliHLTCaloDigitDataStruct digit = digits[*digitIndexPtr];\r
-       printf("CL: digits: %x, recpoints: %x, digitIndexPtr: %x\n", digits, recpoints, digitIndexPtr);\r
-       printf("CL: Digit ID: %d, energy: %f, index: %d, indexpointer: %x\n", digit.fID, digit.fEnergy, *digitIndexPtr, digitIndexPtr);\r
        digitIndexPtr++;\r
        //recPoint = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(digitIndexPtr);\r
      }\r
   }\r
-     \r
-     \r
-     \r
-     \r
-     \r
-     \r
+   return 0;\r
      \r
 }
\ No newline at end of file
index ebfb0c5e66a156c3a49ef0f617e5eab49376d2a3..11c5983f59b4d6e096cfdf75ea4168cc14eb64d7 100644 (file)
@@ -189,13 +189,13 @@ protected:
 private:\r
 \r
   /** Default constructor, prohibited */\r
-  //AliHLTCaloClusterizer();                          // COMMENT\r
+  AliHLTCaloClusterizer();                          // COMMENT\r
   \r
   /** Copy constructor, prohibited */\r
-  //AliHLTCaloClusterizer (const AliHLTCaloClusterizer &); //COMMENT\r
+  AliHLTCaloClusterizer (const AliHLTCaloClusterizer &); //COMMENT\r
   \r
   /** Assignment operator, prohibited */\r
-  //AliHLTCaloClusterizer & operator = (const AliHLTCaloClusterizer &); //COMMENT\r
+  AliHLTCaloClusterizer & operator = (const AliHLTCaloClusterizer &); //COMMENT\r
 \r
   ClassDef(AliHLTCaloClusterizer, 0);\r
 \r
index 2dfbca29ca14265ef416150a466a142bd1ff448a..2359c82568a54c47d28c7a8dc4eeff263aac8e6b 100644 (file)
 AliHLTCaloClusterizerComponent::AliHLTCaloClusterizerComponent(TString det): 
   AliHLTCaloProcessor(),
   AliHLTCaloConstantsHandler(det),
+  fDataOrigin('\0'),
+  fAnalyserPtr(0),
   fDigitsPointerArray(0), 
+  fOutputDigitsArray(0),
   fClusterizerPtr(0),
-  fAnalyserPtr(0),
   fDigitCount(0)
 {
   //See headerfile for documentation
@@ -83,30 +85,6 @@ if (fClusterizerPtr)
   return 0;
 }
 
-// void
-// AliHLTCaloClusterizerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
-// {
-//   //See headerfile for documentation
-//   list.clear();
-//   list.push_back(AliHLTCaloDefinitions::fgkDigitDataType|kAliHLTDataOriginPHOS);
-// }
-
-// AliHLTComponentDataType
-// AliHLTCaloClusterizerComponent::GetOutputDataType()
-// {
-//   //See headerfile for documentation
-//   return AliHLTCaloDefinitions::fgkRecPointDataType|kAliHLTDataOriginPHOS;
-// }
-
-// void
-// AliHLTCaloClusterizerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
-
-// {
-//   //See headerfile for documentation
-//   constBase = sizeof(AliHLTCaloRecPointHeaderStruct) + sizeof(AliHLTCaloRecPointDataStruct) + (sizeof(AliHLTCaloDigitDataStruct) << 7); //Reasonable estimate... ;
-//   inputMultiplier = 1.5;
-// }
-
 int
 AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
                                         AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size,
@@ -132,9 +110,6 @@ AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData,
   
   AliHLTCaloDigitDataStruct *digitDataPtr = 0;
   
-//   delete fAnalyserPtr;
-//   fAnalyserPtr  = new AliHLTCaloClusterAnalyser();
-//   
   // Adding together all the digits, should be put in standalone method  
   for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
     {
@@ -143,13 +118,8 @@ AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData,
       if (iter->fDataType == (AliHLTCaloDefinitions::fgkDigitDataType|fDataOrigin))
        {
 
-//       fDigitsPointerArray[digCount] = reinterpret_cast<AliHLTCaloDigitDataStruct*>(iter->fPtr);
-         
-         //cout << "Digits pointer array [" << digCount << "]: " << fDigitsPointerArray[digCount] << endl;
          // Update the number of digits
          nDigits = iter->fSize/sizeof(AliHLTCaloDigitDataStruct);;
-//       digCount += nDigits;
-         //      HLTError("Got %d digits", nDigits);
          
          availableSize -= iter->fSize;
          
@@ -184,44 +154,27 @@ AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData,
          memcpy(outBPtr, fDigitsPointerArray[n], sizeof(AliHLTCaloDigitDataStruct));
          //fOutputDigitsArray[n] = reinterpret_cast<AliHLTCaloDigitDataStruct*>(outBPtr);
          outBPtr = outBPtr + sizeof(AliHLTCaloDigitDataStruct);
-         printf("CL: digit energy: %f, ID: %d\n", fOutputDigitsArray[n].fEnergy, fOutputDigitsArray[n].fID);
        }
   
        mysize += digCount*sizeof(AliHLTCaloDigitDataStruct);
 
-//       AliHLTComponentBlockData bdDigits;
-//       FillBlockData( bdDigits );
-//       bdDigits.fOffset = offset;
-//       bdDigits.fSize = mysize;
-//       bdDigits.fDataType = iter->fDataType;
-//       bdDigits.fSpecification = specification;
-//       outputBlocks.push_back( bdDigits );
-
       //HLTDebug("Total number of digits: %d", digCount );
 
       nRecPoints = fClusterizerPtr->ClusterizeEvent(digCount);
-      //fClusterizerPtr->CheckDigits();
+
       //HLTDebug("Number of rec points found: %d", nRecPoints);
 
       fAnalyserPtr->SetCaloClusterData(reinterpret_cast<AliHLTCaloClusterDataStruct*>(outBPtr));
       
-      //fClusterizerPtr->CheckDigits(fClusterizerPtr->GetRecPoints(), fOutputDigitsArray, nRecPoints);
-
       fAnalyserPtr->SetRecPointArray(fClusterizerPtr->GetRecPoints(), nRecPoints);
 
-      //fClusterizerPtr->CheckDigits(fClusterizerPtr->GetRecPoints(), fOutputDigitsArray, nRecPoints);
-
       fAnalyserPtr->SetDigitDataArray(fOutputDigitsArray);
 
-//      fClusterizerPtr->CheckDigits(fClusterizerPtr->GetRecPoints(), fOutputDigitsArray, nRecPoints);
-
       Int_t nClusters = fAnalyserPtr->CreateClusters(nRecPoints, size, mysize);
   
       caloClusterHeaderPtr->fNClusters = nClusters;
       
-      //  HLTError("Number of clusters: %d", nRecPoints);
-
-      
+      //HLTDebug("Number of clusters: %d", nRecPoints);
       
       AliHLTComponentBlockData bd;
       FillBlockData( bd );
index e76d612910cbc3b6b451172a9b21906e57492831..191a22d87edd24c8746fb1d51816f6f987a16604 100644 (file)
@@ -35,14 +35,9 @@ AliHLTCaloGeometry::AliHLTCaloGeometry(TString det) :
 
 AliHLTCaloGeometry::~AliHLTCaloGeometry()
 {
-
+   //see header file for class documentation
 }
 
-//void AliHLTCaloGeometry:: GetGlobalCoordinates(AliHLTCaloCoordinate &channelCoord, AliHLTCaloGlobalCoordinate &globalCoord )
-//{
-  //Virtual base class
-//}
-
 
 
 
index ec10df697e8e3f4ab9800a6eebc822bab6ccc4df..f0e33ab0487051e51e541623b45faea6cd85dd18 100644 (file)
@@ -20,11 +20,20 @@ class AliHLTCaloGeometry : public AliHLTCaloConstantsHandler
 {
 
  public:
-  AliHLTCaloGeometry (TString det);
+   
+   /** Constructor */
+  AliHLTCaloGeometry (TString det);  //COMMENT
   
-  virtual ~AliHLTCaloGeometry();
+  /** Destructor */
+  virtual ~AliHLTCaloGeometry(); //COMMENT
   
-  virtual void GetGlobalCoordinates(AliHLTCaloRecPointDataStruct &recPoint, AliHLTCaloGlobalCoordinate &globalCoord ) = 0;
+  /**
+  * Get the global coordinates for a rec point. 
+  * Pure virtual - must be implemented by child classes
+  * @param recPoint is the rec point containing the local coordinates
+  * @param globalCoord is a AliHLTCaloGlobalCoordinate to write to
+  */
+  virtual void GetGlobalCoordinates(AliHLTCaloRecPointDataStruct &recPoint, AliHLTCaloGlobalCoordinate &globalCoord ) = 0;  //COMMENT
   
   /**
   * Get the absolute ID from the relative position in the module
@@ -34,12 +43,12 @@ class AliHLTCaloGeometry : public AliHLTCaloConstantsHandler
   * @param z is the z position in the module
   * @param AbsId is a the absolute id variable
   */
-  virtual void GetCellAbsId(UInt_t module, UInt_t x, UInt_t z, Int_t& AbsId) const = 0;
+  virtual void GetCellAbsId(UInt_t module, UInt_t x, UInt_t z, Int_t& AbsId) const = 0; //COMMENT
   
   private:
      
-    
-   AliHLTCaloGeometry();
+    /** Default constructor, not implemented */
+   AliHLTCaloGeometry();   //COMMENT
 
 
 };
index 2b05b63240e30b1a934d795f1b119a3cd1694347..47ccdf4995e3156353a6358b30fe91eca22ad77a 100644 (file)
@@ -48,7 +48,7 @@ AliHLTPHOSClusterizerComponent::AliHLTPHOSClusterizerComponent():
 
   fDataOrigin = const_cast<char*>(kAliHLTDataOriginPHOS);
 
-  AliHLTPHOSGeometry *geom = new AliHLTPHOSGeometry;
+  //AliHLTPHOSGeometry *geom = new AliHLTPHOSGeometry;
   
   fAnalyserPtr->SetGeometry(new AliHLTPHOSGeometry);
   
index c73fd8c1282cb97deb3b81307353027f20a49d4d..e5990f60ff31f17f365ab07e062407e05c7911cc 100644 (file)
@@ -1,4 +1,3 @@
-/*
 /**************************************************************************
  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  *                                                                        *
 AliHLTPHOSGeometry::AliHLTPHOSGeometry() :
 AliHLTCaloGeometry("PHOS")
 {
-
+ // See header file for class documentation
 }
 
 AliHLTPHOSGeometry::~AliHLTPHOSGeometry()
 {
-
+// See header file for class documentation
 }
 
-void AliHLTPHOSGeometry::GetGlobalCoordinates ( AliHLTCaloRecPointDataStruct& recPoint, AliHLTCaloGlobalCoordinate& globalCoord )
+void AliHLTPHOSGeometry::GetGlobalCoordinates ( AliHLTCaloRecPointDataStruct& /*recPoint*/, AliHLTCaloGlobalCoordinate& globalCoord )
 {
+   // See header file for class documentation
    globalCoord.fX = 0;
    globalCoord.fZ = 0;
    globalCoord.fY = 0;
 }
-
index a8d81c434f72b58c18511f7f2b3ac2f0e8d2d0e8..95e8ed1847d4513f272ebfd16df01823ce2ecb02 100644 (file)
@@ -1,4 +1,3 @@
-/*
 /**************************************************************************
  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  *                                                                        *
@@ -33,11 +32,8 @@ class AliHLTPHOSGeometry : public AliHLTCaloGeometry
       virtual void GetGlobalCoordinates ( AliHLTCaloRecPointDataStruct& recPoint,  AliHLTCaloGlobalCoordinate& globalCoord ); //COMMENT
 
       /** See base class for class documentation */
-      virtual void GetCellAbsId(UInt_t module, UInt_t x, UInt_t z, Int_t& AbsId) const { AbsId = 0; }
-      
-      
-
-      
+      virtual void GetCellAbsId(UInt_t /*module*/, UInt_t /*x*/, UInt_t /*z*/, Int_t& AbsId) const { AbsId = 0; }
+    
   };
 
 #endif // ALIHLTPHOSGEOMETRY_H