Refactoring: All code related to the processing of
authorphille <phille@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 12 May 2010 21:30:10 +0000 (21:30 +0000)
committerphille <phille@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 12 May 2010 21:30:10 +0000 (21:30 +0000)
an event is now factored out to the AliHLTCaloRawAnalyzerComponentv3
base class.

HLT/CALO/AliHLTCaloRawAnalyzerComponentv3.cxx
HLT/CALO/AliHLTCaloRawAnalyzerComponentv3.h
HLT/EMCAL/AliHLTEMCALRawAnalyzerComponent.cxx
HLT/EMCAL/AliHLTEMCALRawAnalyzerComponent.h
HLT/PHOS/AliHLTPHOSRawAnalyzerComponentv3.cxx
HLT/PHOS/AliHLTPHOSRawAnalyzerComponentv3.h

index 33c8bb0..c487004 100644 (file)
 #include "AliAltroRawStreamV3.h"
 #include "AliCaloRawStreamV3.h"
 #include "AliHLTCaloConstantsHandler.h"
-
-
-//#include "AliHLTCaloConstants.h"
-
-//#include "AliHLTCaloRcuProcessor.h"
-
 #include "AliHLTCaloCrazynessDefinitions.h"
 #include "AliHLTCaloChannelRawDataStruct.h"
 #include "AliHLTCaloCoordinate.h"
 #include "AliLog.h"
 
-//#include "AliCALOBunchInfo.h"
-//AliCALORawAnalyzer
-
 #include <vector>
 using namespace std;
 
-ClassImp(AliHLTCaloRawAnalyzerComponentv3);
+//ClassImp(AliHLTCaloRawAnalyzerComponentv3);
+
+
+#include  "TStopwatch.h"
+TStopwatch  fgWatch; //CRAP PTH
+
 
 AliHLTCaloRawAnalyzerComponentv3::AliHLTCaloRawAnalyzerComponentv3(TString det):AliHLTCaloProcessor(),
-  AliHLTCaloConstantsHandler(det),
-  //  AliHLTCaloRcuProcessor(),
-  //  fCaloEventCount(0),
-  fAnalyzerPtr(0),
-  fMapperPtr(0),     
-  fSanityInspectorPtr(0),
-  fRawReaderMemoryPtr(0),
-  fAltroRawStreamPtr(0),
-  fAlgorithm(0),  
-  fOffset(0),
-  fBunchSizeCut(0),
-  fMinPeakPosition(0),
-  fMaxPeakPosition(100),
-  fDoPushBadRawData(false),
-  fDoPushRawData(false),
-  fRawDataWriter(0)
+                                                                               AliHLTCaloConstantsHandler(det),
+                                                                               fAnalyzerPtr(0),
+                                                                               fMapperPtr(0),     
+                                                                               fCurrentSpec(-1),
+                                                                               fDebug(false),
+                                                                               fSanityInspectorPtr(0),
+                                                                               fRawReaderMemoryPtr(0),
+                                                                               fAltroRawStreamPtr(0),
+                                                                               fAlgorithm(0),  
+                                                                               fOffset(0),
+                                                                               fBunchSizeCut(0),
+                                                                               fMinPeakPosition(0),
+                                                                               fMaxPeakPosition(100),
+                                                                               fDoPushBadRawData(false),
+                                                                               fDoPushRawData(false),
+                                                                               fRawDataWriter(0)
+                                                                       
 {
   //comment
-
-  //  fMapperPtr = new AliHLTCaloMapper();
-
   fRawReaderMemoryPtr = new AliRawReaderMemory();
-
   fAltroRawStreamPtr = new AliAltroRawStreamV3(fRawReaderMemoryPtr);
-
   fSanityInspectorPtr = new AliHLTCaloSanityInspector();
   
   if( fDoPushRawData == true  )
@@ -82,53 +74,15 @@ AliHLTCaloRawAnalyzerComponentv3::AliHLTCaloRawAnalyzerComponentv3(TString det):
   }
   
   fAltroRawStreamPtr = new AliCaloRawStreamV3(fRawReaderMemoryPtr, det);  
-
 }
 
 
 AliHLTCaloRawAnalyzerComponentv3::~AliHLTCaloRawAnalyzerComponentv3()
 {
-  //comment
-  //this is not created here but in the derived classes
-  //   if(fAnalyzerPtr)
-  //     {
-  //       delete fAnalyzerPtr;
-  //        fAnalyzerPtr = 0;
-  //     }
-
-  if(fMapperPtr)
-    {
-      delete  fMapperPtr;
-      fMapperPtr = 0;
-    }
-
-  if(fRawReaderMemoryPtr)
-    {
-      delete fRawReaderMemoryPtr;
-      fRawReaderMemoryPtr = 0;
-    }
-
-  if(fAltroRawStreamPtr)
-    {
-      delete fAltroRawStreamPtr;
-      fAltroRawStreamPtr = 0;
-    }
-
-  if (fRawDataWriter)
-    {
-      delete fRawDataWriter;
-      fRawDataWriter = 0;
-    }
-
-  if (fSanityInspectorPtr)
-    {
-      delete fSanityInspectorPtr;
-      fSanityInspectorPtr = 0;
-    }
-
-  // NOT A GOOD IDEA TO CALL VIRTUAL FUNCTION
-  // ESPECIALLY IN VIRTUAL DESTRUCTOR - just stick to it
-  // DoDeinit();
+  delete fRawReaderMemoryPtr;
+  delete fAltroRawStreamPtr;
+  delete fRawDataWriter;
+  delete fSanityInspectorPtr;
 }
 
 
@@ -136,16 +90,11 @@ AliHLTCaloRawAnalyzerComponentv3::~AliHLTCaloRawAnalyzerComponentv3()
 int
 AliHLTCaloRawAnalyzerComponentv3::DoInit( int argc, const char** argv )
 { 
-  
   //See base class for documentation
   //  fPrintInfo = kFALSE;
-
   int iResult=0;
-  
   //  fMapperPtr = new AliHLTCaloMapper();
   
-  //InitMapping(); 
-
   for(int i = 0; i < argc; i++)
     {
       if(!strcmp("-offset", argv[i]))
@@ -183,51 +132,157 @@ AliHLTCaloRawAnalyzerComponentv3::DoInit( int argc, const char** argv )
        }
     }
  
-  /*
-  if( fMapperPtr->GetIsInitializedMapping() == false)
-    {
-      Logging(kHLTLogFatal, __FILE__ , IntToChar(  __LINE__ ) , "AliHLTCaloMapper::Could not initialise mapping from file %s, aborting", fMapperPtr->GetFilePath());
-      return -4;
-    }
-  */
   return iResult;
 }
 
+
+
 int 
 AliHLTCaloRawAnalyzerComponentv3::DoDeinit()
 {
   //comment
-  
-  //this is not created here but in the derived classes
-  //   if(fAnalyzerPtr)
-  //     {
-  //       delete fAnalyzerPtr;
-  //        fAnalyzerPtr = 0;
-  //     }
+  // if(fMapperPtr)
+  //   {
+  //     delete  fMapperPtr;
+  //     fMapperPtr = 0;
+  //   }
+
+  // if(fRawReaderMemoryPtr)
+  //   {
+  //     delete fRawReaderMemoryPtr;
+  //     fRawReaderMemoryPtr = 0;
+  //   }
+
+  if(fAltroRawStreamPtr)
+    {
+      delete fAltroRawStreamPtr;
+      fAltroRawStreamPtr = 0;
+    }
+
+  return 0;
+}
 
-  // what about the rest of the created objects?
-  // in the contructor?
 
-  if(fMapperPtr)
+
+void 
+AliHLTCaloRawAnalyzerComponentv3::PrintDebugInfo()
+{
+  //  static int evntcnt = 0;
+  static double wlast = -1;
+  static double wcurrent = 0;
+  // evntcnt  ++;
+  
+  if( true == fDebug )
     {
-      delete  fMapperPtr;
-      fMapperPtr = 0;
+      if( fCaloEventCount %1000 == 0  )
+       {
+         cout << __FILE__ << __LINE__ << " : Processing event "  << fCaloEventCount << endl; 
+         wlast =  wcurrent;
+         wcurrent = fgWatch.RealTime();
+         ////cout << wlast << ":" << wcurrent << endl;
+         cout << __FILE__ << __LINE__ << "The event rate is " <<  
+           1000/( wcurrent  -  wlast ) << "  Hz" << endl;        fgWatch.Start(kFALSE); 
+         //     wlast =  fgWatch.RealTime(); 
+       }
     }
+}
+
+
+
+bool 
+AliHLTCaloRawAnalyzerComponentv3::CheckInputDataType(const AliHLTComponentDataType &datatype)
+{
+  vector <AliHLTComponentDataType> validTypes;
+  GetInputDataTypes(validTypes);
+  
+  // if( true == fDebug)
+  //   {
+  //     cout << __FILE__ << __LINE__ << "  :  fID  = " << datatype.fID <<  " : fOrigin = " 
+  //          <<  datatype.fOrigin << endl;
+  //   }
 
-  if(fRawReaderMemoryPtr)
+  for(int i=0; i < validTypes.size(); i++ )
     {
-      delete fRawReaderMemoryPtr;
-      fRawReaderMemoryPtr = 0;
+      if ( datatype  ==  validTypes.at(i) )
+       {
+         return true;
+       }
     }
+  HLTDebug("Invalid Datatype");
+  return false;
+}
 
-  if(fAltroRawStreamPtr)
+
+int 
+AliHLTCaloRawAnalyzerComponentv3::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                                         AliHLTComponentTriggerData& /*trigData*/, 
+                                         AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
+{
+  if(!IsDataEvent())
+   {
+     size = 0;
+     return 0;
+   }
+
+  if( true == fDebug ) { PrintDebugInfo(); };
+   
+  
+   Int_t blockSize          = -1;
+   UInt_t totSize           = 0;
+   const AliHLTComponentBlockData* iter = NULL; 
+   unsigned long ndx;
+
+   
+  
+   for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
     {
-      delete fAltroRawStreamPtr;
-      fAltroRawStreamPtr = 0;
+      iter = blocks+ndx;
+      if(  ! CheckInputDataType(iter->fDataType) )
+       //          CheckInputDataType  
+       {
+         continue;
+       }
+
+      //    else
+      //  {
+      //     InitMapping( iter->fSpecification); 
+   
+      // blockSize = DoIt(iter, outputPtr, size, totSize); // Processing the block
+      
+      // if(blockSize == -1) // If the processing returns -1 we are out of buffer and return an error msg.
+      //       {
+      //         return -ENOBUFS;
+      //       }
+
+      if(iter->fSpecification != fCurrentSpec)
+      {
+       fCurrentSpec = iter->fSpecification;
+       InitMapping(iter->fSpecification);
+      }
+  
+      blockSize = DoIt(iter, outputPtr, size, totSize); // Processing the block
+      
+   
+      totSize += blockSize; //Keeping track of the used size
+      AliHLTComponentBlockData bdChannelData;
+      FillBlockData( bdChannelData );
+      bdChannelData.fOffset = 0; //FIXME
+      bdChannelData.fSize = blockSize;
+      bdChannelData.fDataType = GetOutputDataType();
+      bdChannelData.fSpecification = iter->fSpecification;
+      outputBlocks.push_back(bdChannelData);
+      outputPtr += blockSize; //Updating position of the output buffer
+      //      fCaloEventCount++; 
+      //     size = totSize; //telling the framework how much buffer space we have used.
     }
 
-  return 0;
-}
+   fCaloEventCount++; 
+   size = totSize; //telling the framework how much buffer space we have used.
+   
+   return 0;
+   
+}//end DoEvent
 
 
 
@@ -260,7 +315,6 @@ AliHLTCaloRawAnalyzerComponentv3::DoIt(const AliHLTComponentBlockData* iter, Ali
     fOffset = 0;
     while( fAltroRawStreamPtr->NextChannel()  )
       { 
-       //       cout << __FILE__  << ":" << __LINE__ << ":" <<__FUNCTION__ << "T3"  << endl; 
        if(  fAltroRawStreamPtr->GetHWAddress() < 128 || ( fAltroRawStreamPtr->GetHWAddress() ^ 0x800) < 128 ) 
          {
            continue; 
@@ -270,15 +324,12 @@ AliHLTCaloRawAnalyzerComponentv3::DoIt(const AliHLTComponentBlockData* iter, Ali
            ++ cnt;
            UShort_t* firstBunchPtr = 0;
            int chId = fMapperPtr->GetChannelID(iter->fSpecification, fAltroRawStreamPtr->GetHWAddress()); 
-           //      HLTError("Channel HW address: %d", fAltroRawStreamPtr->GetHWAddress());
-           
            
            if( fDoPushRawData == true)
              {
                fRawDataWriter->SetChannelId( chId );
              }
            
-           //      return 1;
            vector <AliCaloBunchInfo> bvctr;
            while( fAltroRawStreamPtr->NextBunch() == true )
              {
@@ -307,13 +358,13 @@ AliHLTCaloRawAnalyzerComponentv3::DoIt(const AliHLTComponentBlockData* iter, Ali
            //    fAnalyzerPtr->SetData( firstBunchPtr, nSamples);
            AliCaloFitResults res = fAnalyzerPtr->Evaluate( bvctr,  fAltroRawStreamPtr->GetAltroCFG1(), fAltroRawStreamPtr->GetAltroCFG2() );  
  
-           HLTDebug("Channel energy: %f, max sig: %d, gain = %d, x = %d, z = %d", res.GetAmp(), res.GetMaxSig(), (chId >> 12)&0x1, chId&0x3f, (chId >> 6)&0x3f);
+           HLTDebug("Channel energy: %f, max sig: %d, gain = %d, x = %d, z = %d", res.GetAmp(), res.GetMaxSig(), 
+                    (chId >> 12)&0x1, chId&0x3f, (chId >> 6)&0x3f);
            
            //        if(fAnalyzerPtr->GetTiming() > fMinPeakPosition && fAnalyzerPtr->GetTiming() < fMaxPeakPosition)
            {
              channelDataPtr->fChannelID =  chId;
              channelDataPtr->fEnergy = static_cast<Float_t>( res.GetAmp()  ) - fOffset;
-
              channelDataPtr->fTime = static_cast<Float_t>(  res.GetTof() );
              channelDataPtr->fCrazyness = static_cast<Short_t>(crazyness);
              channelCount++;
@@ -359,32 +410,23 @@ AliHLTCaloRawAnalyzerComponentv3::DoIt(const AliHLTComponentBlockData* iter, Ali
               }
 
        */
-         }
-    
+      }
     if( fDoPushRawData == true)
       { 
        fRawDataWriter->NewChannel();
       }
-
   }
 
-
-// return 1;
-
 //Writing the header
   channelDataHeaderPtr->fNChannels   =  channelCount;
   channelDataHeaderPtr->fAlgorithm   = fAlgorithm;
   channelDataHeaderPtr->fInfo        = 0;
-
-  // return 1;
-
-
+  
   if( fDoPushRawData == true)
     {
       tmpsize += fRawDataWriter->CopyBufferToSharedMemory( (UShort_t *)channelDataPtr, size, totSize);
     }
 
-  // channelDataHeaderPtr->fHasRawData  = false;
   channelDataHeaderPtr->fHasRawData = fDoPushRawData;
   HLTDebug("Number of channels: %d", channelCount);
   tmpsize += sizeof(AliHLTCaloChannelDataStruct)*channelCount + sizeof(AliHLTCaloChannelDataHeaderStruct); 
@@ -394,14 +436,10 @@ AliHLTCaloRawAnalyzerComponentv3::DoIt(const AliHLTComponentBlockData* iter, Ali
 
 
 
-
-
-AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::RawDataWriter(AliHLTCaloConstants* cConst) :  //fIsFirstChannel(true),
+AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::RawDataWriter(AliHLTCaloConstants* cConst) : 
                                                                    fRawDataBuffer(0),
                                                                    fCurrentChannelSize(0),
-                                                                   //    fIsFirstChannel(true),
                                                                    fBufferIndex(0),
-                                                                   //      fBufferSize( NZROWSRCU*NXCOLUMNSRCU*ALTROMAXSAMPLES*NGAINS +1000 ),
                                                                    fBufferSize( 64*56*cConst->GetNGAINS()*cConst->GetALTROMAXSAMPLES() +1000 ),
                                                                    fCurrentChannelIdPtr(0),
                                                                    fCurrentChannelSizePtr(0),
@@ -412,15 +450,12 @@ AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::RawDataWriter(AliHLTCaloConstan
   Init();
 }
 
+
 AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::~RawDataWriter()
 {
-  //destructor - added by MP
-  if (0 != fRawDataBuffer)
-    {
-      delete [] fRawDataBuffer;
-      fRawDataBuffer = 0;
-    }
+  delete [] fRawDataBuffer;
 }
+
    
 void  
 AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::Init()
@@ -501,7 +536,7 @@ AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::CopyBufferToSharedMemory(UShort
   if(  sizerequested   > sizetotal  )
     {
       return 0;
-  }
+    }
   else
     {
       for(int i=0; i < fTotalSize; i++)
@@ -509,6 +544,6 @@ AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::CopyBufferToSharedMemory(UShort
          memPtr[i] = fRawDataBuffer[i]; 
        }
       return fTotalSize;
-   }
+    }
 }
   
index ad244fb..7d503b6 100644 (file)
@@ -100,18 +100,11 @@ class AliAltroRawStreamV3;
 #include "AliHLTProcessor.h"
 #include "AliHLTCaloDefinitions.h"
 #include "AliHLTCaloConstantsHandler.h"
-
-//#include "AliHLTCaloRcuProcessor.h"
-
-//#include "TObject.h"
-//#include "AliHLTProcessor.h"
 #include "AliHLTCaloProcessor.h"
 
 class AliHLTCaloMapper;
 
 
-//class AliHLTCaloRawAnalyzerComponentv3 : public AliHLTCaloConstantsHandler, public AliHLTCaloRcuProcessor
-//class AliHLTCaloRawAnalyzerComponentv3 : public AliHLTCaloConstantsHandler
 class AliHLTCaloRawAnalyzerComponentv3 :  public AliHLTCaloProcessor, protected AliHLTCaloConstantsHandler
 {
  public:
@@ -146,6 +139,9 @@ class AliHLTCaloRawAnalyzerComponentv3 :  public AliHLTCaloProcessor, protected
   virtual AliHLTComponent* Spawn() = 0; 
 
  protected:
+  bool CheckInputDataType(const AliHLTComponentDataType &datatype);
+  
+
   //virtual bool CheckInputDataType(const AliHLTComponentDataType &datatype) = 0;
   /** interface function, see @ref AliHLTComponent for description */
 
@@ -154,7 +150,8 @@ class AliHLTCaloRawAnalyzerComponentv3 :  public AliHLTCaloProcessor, protected
   /** interface function, see @ref AliHLTComponent for description */
   virtual int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
                     AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                      AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks ) = 0;  
+                      AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );  
+
 
   /** 
    * Do the real processing in the component 
@@ -164,17 +161,21 @@ class AliHLTCaloRawAnalyzerComponentv3 :  public AliHLTCaloProcessor, protected
    * @param totSize is the total size used for output
    * @return the size output size used
    */
-  virtual Int_t DoIt(const AliHLTComponentBlockData* iter, AliHLTUInt8_t* outputPtr, const AliHLTUInt32_t size, UInt_t& totSize); 
+  virtual Int_t DoIt(const AliHLTComponentBlockData* iter, AliHLTUInt8_t* outputPtr, 
+                    const AliHLTUInt32_t size, UInt_t& totSize); 
 
+  
+ protected:
+  virtual void InitMapping(const int specification ) = 0;
+  void PrintDebugInfo();
   // unsigned long fCaloEventCount;
-
   /** Pointer to an analyzer object used for raw data anlysis */ 
   AliCaloRawAnalyzer *fAnalyzerPtr;   //COMMENT
-
   //** Pointer to a mapper opbject */
   AliHLTCaloMapper *fMapperPtr;          //COMMENT
-
-  virtual void InitMapping(const int specification ) = 0;
+  AliHLTUInt32_t fCurrentSpec;
+  
+  bool fDebug;
 
  private:
 
@@ -223,13 +224,20 @@ class AliHLTCaloRawAnalyzerComponentv3 :  public AliHLTCaloProcessor, protected
       
   /** Should we push all raw data (using the raw data writer) */
   Bool_t fDoPushRawData;                              //COMMENT
+  
+  //  AliHLTUInt32_t fCurrentSpec;
+
+
 
   class RawDataWriter 
   {
   public:
     RawDataWriter(AliHLTCaloConstants* cConst);
-    ~RawDataWriter();
+    virtual ~RawDataWriter();
     //   void WriteChannelId(const UShort_t channeldid );
+
+    //   virtual bool CheckDataType() = 0;
+    
     void NewChannel( );
     void WriteBunchData(const UShort_t *bunchdata,  const int length,   const UInt_t starttimebin );
     void ResetBuffer();
@@ -237,7 +245,7 @@ class AliHLTCaloRawAnalyzerComponentv3 :  public AliHLTCaloProcessor, protected
     //void CopyBufferToSharedMemory(UShort_t *memPtr, const int sizetotal, const int sizeused );
     int CopyBufferToSharedMemory(UShort_t *memPtr, const int sizetotal, const int sizeused );
     void NewEvent();
-    
   private:
     //Default constructor, should not be used. 
     RawDataWriter();    
@@ -253,10 +261,11 @@ class AliHLTCaloRawAnalyzerComponentv3 :  public AliHLTCaloProcessor, protected
     UShort_t *fCurrentChannelSizePtr; 
     UShort_t *fCurrentChannelDataPtr; 
     int fTotalSize;
+    //  bool fDebug;
   };
 
   RawDataWriter *fRawDataWriter; 
-
+  // bool fDebug;
   ClassDef(AliHLTCaloRawAnalyzerComponentv3, 1)
 
 };
index 50448e4..bd90a5c 100644 (file)
 TStopwatch  fgWatch; //CRAP PTH
 
 
+
 AliHLTEMCALRawAnalyzerComponent::AliHLTEMCALRawAnalyzerComponent() : AliHLTCaloRawAnalyzerComponentv3("EMCAL")
 {
-  
-  //  cout << __FILE__ << __FUNCTION__ << __LINE__ <<  endl;
+  fDebug = true;
+   //  cout << __FILE__ << __FUNCTION__ << __LINE__ <<  endl;
 }
 
 
+
 AliHLTEMCALRawAnalyzerComponent::~AliHLTEMCALRawAnalyzerComponent()
 {
 
 }
 
 
-
 void 
 AliHLTEMCALRawAnalyzerComponent::GetInputDataTypes( vector <AliHLTComponentDataType>& list)
 {
@@ -58,7 +59,6 @@ AliHLTEMCALRawAnalyzerComponent::GetInputDataTypes( vector <AliHLTComponentDataT
 }
 
 
-
 AliHLTComponentDataType
 AliHLTEMCALRawAnalyzerComponent::GetOutputDataType()
 {
@@ -85,40 +85,11 @@ AliHLTEMCALRawAnalyzerComponent::DoInit()
  
 }
 
-/*
-struct AliHLTComponentDataType
-  {
-    AliHLTUInt32_t fStructSize;                            /// Size of this structure in bytes.
-    char fID[kAliHLTComponentDataTypefIDsize];             /// Data type identifier.
-    char fOrigin[kAliHLTComponentDataTypefOriginSize];     /// Subsystem or detector origin of the data.
-  };
-*/
-
-bool 
-AliHLTEMCALRawAnalyzerComponent::CheckInputDataType(const AliHLTComponentDataType &datatype)
-{
-  // Cheking if datatype is the correct one before processing 
-  //    ////cout << __FILE__ << __LINE__ << "  :  fID  = " << datatype.fID <<  " : fOrigin = " <<  datatype.fOrigin << endl;
-  //  ////cout << __FILE__ << __LINE__ << "fgkDDLRawDataType->fID = " << AliHLTEMCALDefinitions::fgkDDLRawDataType.fID <<
-  //  "fgkDDLRawDataType->fOrigin = " << AliHLTEMCALDefinitions::fgkDDLRawDataType.fOrigin << endl;
-
-
-  if ( datatype  == AliHLTEMCALDefinitions::fgkDDLRawDataType  )
-     {
-       return true;
-     }
-   else
-     {
-       //    return true;
-       return false;
-     }
-}
-
 
 void 
 AliHLTEMCALRawAnalyzerComponent::InitMapping( const int specification )
 {
-  //-------------
+  // Comment
   if ( fMapperPtr == 0 )
     {
       fMapperPtr =  new   AliHLTEMCALMapper( specification );
@@ -126,104 +97,9 @@ AliHLTEMCALRawAnalyzerComponent::InitMapping( const int specification )
 
   if(fMapperPtr->GetIsInitializedMapping() == false )
     {
-      //      HLTError("%d:%d, ERROR, mapping not initialized ", __FILE__, __LINE__ );
+      HLTError("%d:%d, ERROR, mapping not initialized ", __FILE__, __LINE__ );
       exit(-2);
     }
 }
 
 
-int 
-AliHLTEMCALRawAnalyzerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, AliHLTComponentTriggerData& /*trigData*/, 
-                                        AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
-{
-  
-  //  cout << __FILE__ << __FUNCTION__ << __LINE__ <<  endl;
-  
-   if(!IsDataEvent())
-   {
-      size = 0;
-      return 0;
-   }
-
-  static int evntcnt = 0;
-  static double wlast = -1;
-  static double wcurrent = 0;
-  evntcnt  ++;
-  
-  if( evntcnt %1000 == 0  )
-    {
-      ////cout << __FILE__ << __LINE__ << " : Processing event "  << evntcnt   << endl; 
-      wlast =  wcurrent;
-      wcurrent = fgWatch.RealTime();
-      ////cout << wlast << ":" << wcurrent << endl;
-      //     cout << __FILE__ << __LINE__ << "The event rate is " <<  1000/( wcurrent  -  wlast ) << "  Hz" << endl; 
-      fgWatch.Start(kFALSE); 
-      //     wlast =  fgWatch.RealTime(); 
-    }
-
-  
-  /*
-  if( evntcnt %100 == 0  )
-    {
-      
-      ////cout << __FILE__ << __LINE__ << " : Processing event "  << evntcnt   << endl; 
-      wlast =  wcurrent;
-      wcurrent = fgWatch.RealTime();
-      ////cout << wlast << ":" << wcurrent << endl;
-      ////cout << __FILE__ << __LINE__ << "The event rate is " <<  100/( wcurrent  -  wlast ) << "  Hz" << endl; 
-      fgWatch.Start(kFALSE); 
-      //     wlast =  fgWatch.RealTime(); 
-    }
-  */
-  
-
-  Int_t blockSize          = -1;
-  UInt_t totSize           = 0;
-  const AliHLTComponentBlockData* iter = NULL; 
-  unsigned long ndx;
-
-  for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
-    {
-      //   //cout << __FILE__ << __LINE__ <<  "ndx =" << ndx  << endl;
-      iter = blocks+ndx;
-      if(  ! CheckInputDataType(iter->fDataType) )
-       {
-         //      //cout << __FILE__ << __LINE__ <<  "  continue" << endl; 
-         continue;
-       }
-      else
-       {
-         //      //cout << __FILE__ << __LINE__ <<  "  else" << endl;  
-
-         InitMapping( iter->fSpecification); 
-         blockSize = DoIt(iter, outputPtr, size, totSize); // Processing the block
-         
-         if(blockSize == -1) // If the processing returns -1 we are out of buffer and return an error msg.
-           {
-             //             //cout << __FILE__ << __LINE__ <<  "  return -ENOBUFS " << endl;   
-             return -ENOBUFS;
-           }
-         
-         totSize += blockSize; //Keeping track of the used size
-         AliHLTComponentBlockData bdChannelData;
-         FillBlockData( bdChannelData );
-         bdChannelData.fOffset = 0; //FIXME
-         bdChannelData.fSize = blockSize;
-         
-         //      bdChannelData.fDataType = AliHLTPHOSDefinitions::fgkChannelDataType;
-         bdChannelData.fDataType = AliHLTEMCALDefinitions::fgkChannelDataType;
-
-         bdChannelData.fSpecification = iter->fSpecification;
-         outputBlocks.push_back(bdChannelData);
-         outputPtr += blockSize; //Updating position of the output buffer
-       }
-
-      fCaloEventCount++; 
-      size = totSize; //telling the framework how much buffer space we have used.
-    }
-
-  
-return 0;
-  
-}//end DoEvent
-
index c6940b3..c54ce89 100644 (file)
 
 #include "AliHLTCaloRawAnalyzerComponentv3.h"
  
-//class AliHLTCaloMapper;
 
 class  AliHLTEMCALRawAnalyzerComponent : public AliHLTCaloRawAnalyzerComponentv3
 {
  public:
   AliHLTEMCALRawAnalyzerComponent();
   virtual ~AliHLTEMCALRawAnalyzerComponent();
-  virtual void GetInputDataTypes( vector <AliHLTComponentDataType>& list);
-  virtual AliHLTComponentDataType GetOutputDataType();
-  virtual void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier);
-  virtual void DoInit();
+  void GetInputDataTypes( vector <AliHLTComponentDataType>& list);
+  AliHLTComponentDataType GetOutputDataType();
+  void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier);
+  void DoInit();
 
   virtual const char* GetComponentID() = 0;
   virtual AliHLTComponent* Spawn() = 0; 
-
- protected:
-  virtual int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
-                    AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                      AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );  
-
-  virtual bool CheckInputDataType(const AliHLTComponentDataType &datatype);
+  
+  
  private:
   AliHLTEMCALRawAnalyzerComponent(const AliHLTEMCALRawAnalyzerComponent & );
   AliHLTEMCALRawAnalyzerComponent & operator = (const AliHLTEMCALRawAnalyzerComponent  &);
+  //  virtual bool CheckInputDataType(const AliHLTComponentDataType &datatype);
   virtual void InitMapping( const int specification );
 };
 
index 5d5ec28..f3164c1 100644 (file)
@@ -25,7 +25,7 @@
 
 AliHLTPHOSRawAnalyzerComponentv3::AliHLTPHOSRawAnalyzerComponentv3() :
    AliHLTCaloRawAnalyzerComponentv3("PHOS")
-   ,fCurrentSpec(-1)
+   // ,fCurrentSpec(-1)
 {
    // See header file for class documentation
    InitMapping(0x1); //using 0x1 to avoid error message
@@ -60,67 +60,6 @@ AliHLTPHOSRawAnalyzerComponentv3::GetOutputDataSize(unsigned long& constBase, do
   inputMultiplier = 1.5;
 }
 
-int 
-AliHLTPHOSRawAnalyzerComponentv3::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, AliHLTComponentTriggerData& /*trigData*/, 
-                                        AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
-{
-  //comment
-
-
-   if(!IsDataEvent())
-   {
-      size = 0;
-      return 0;
-   }
-
-
-  Int_t blockSize          = 0;
-  UInt_t totSize           = 0;
-
-  const AliHLTComponentBlockData* iter = NULL; 
-  unsigned long ndx;
-
-  for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
-    {
-      iter = blocks+ndx;
-      if ( iter->fDataType != AliHLTPHOSDefinitions::fgkDDLPackedRawDataType  )
-       {
-         HLTDebug("Data block is not of type fgkDDLPackedRawDataType");
-         continue; 
-       }
-      if(iter->fSpecification != fCurrentSpec)
-      {
-        fCurrentSpec = iter->fSpecification;
-        InitMapping(iter->fSpecification);
-      }
-      blockSize = DoIt(iter, outputPtr, size, totSize); // Processing the block
-
-      if(blockSize == -1) // If the processing returns -1 we are out of buffer and return an error msg.
-       {
-         return -ENOBUFS;
-       }
-
-      totSize += blockSize; //Keeping track of the used size
-      // HLTDebug("Output data size: %d - Input data size: %d", totSize, iter->fSize);
-
-      //Filling the block data
-      AliHLTComponentBlockData bdChannelData;
-      FillBlockData( bdChannelData );
-      bdChannelData.fOffset = 0; //FIXME
-      bdChannelData.fSize = blockSize;
-      bdChannelData.fDataType = AliHLTPHOSDefinitions::fgkChannelDataType;
-      bdChannelData.fSpecification = iter->fSpecification;
-      outputBlocks.push_back(bdChannelData);
-
-      outputPtr += blockSize; //Updating position of the output buffer
-    }
-
-  fCaloEventCount++; 
-  size = totSize; //telling the framework how much buffer space we have used.
-  
-  return 0;
-}//end DoEvent
-
 
 void AliHLTPHOSRawAnalyzerComponentv3::InitMapping ( const int specification )
 {
@@ -128,6 +67,5 @@ void AliHLTPHOSRawAnalyzerComponentv3::InitMapping ( const int specification )
    fMapperPtr = new AliHLTPHOSMapper;
    fMapperPtr->InitDDLSpecificationMapping();
    fMapperPtr->InitAltroMapping(specification);
-
 }
 
index 7c296c5..9571400 100644 (file)
@@ -90,50 +90,21 @@ class AliHLTPHOSRawAnalyzer;
 class AliHLTPHOSRawAnalyzerComponentv3 : public AliHLTCaloRawAnalyzerComponentv3
 {
  public:
-
-  /** Standard constructor */
-  AliHLTPHOSRawAnalyzerComponentv3();
-
-  /** Destructor */
+  AliHLTPHOSRawAnalyzerComponentv3(); /** Standard constructor */
   virtual ~AliHLTPHOSRawAnalyzerComponentv3();
-
-  /** interface function, see @ref AliHLTComponent for description */
-  virtual const char* GetComponentID() = 0;
-
-  /** interface function, see @ref AliHLTComponent for description */
-  virtual void GetInputDataTypes( vector <AliHLTComponentDataType>& list);
-
-  /** interface function, see @ref AliHLTComponent for description */
-  virtual AliHLTComponentDataType GetOutputDataType();
-
-  /** interface function, see @ref AliHLTComponent for description */
-  virtual void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier);
-
-  /** interface function, see @ref AliHLTComponent for description */
-  virtual AliHLTComponent* Spawn() = 0; 
-
-  //virtual void InitMapping(const AliHLTUInt32_t specification);
-  
+  virtual const char* GetComponentID() = 0; 
+  virtual void GetInputDataTypes( vector <AliHLTComponentDataType>& list);/** interface function, see @ref AliHLTComponent for description */
+  virtual AliHLTComponentDataType GetOutputDataType();/** interface function, see @ref AliHLTComponent for description */
+  virtual void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier);/** interface function, see @ref AliHLTComponent for description */
+  virtual AliHLTComponent* Spawn() = 0; /** interface function, see @ref AliHLTComponent for description */
  protected:
-
-  /** interface function, see @ref AliHLTComponent for description */
-  virtual int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
-                    AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                      AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );  
+  virtual void InitMapping(const int specification);
   
-   virtual void InitMapping(const int specification);
-
  private:
-
-  /** Keep the copy constructor private since it should not be used */
   AliHLTPHOSRawAnalyzerComponentv3(const AliHLTPHOSRawAnalyzerComponentv3 & );
-
-  /** Keep the assignement operator private since it should not be used */
   AliHLTPHOSRawAnalyzerComponentv3 & operator = (const AliHLTPHOSRawAnalyzerComponentv3 &);
-
-  /** The current specification for which the mapping is loaded */
-  AliHLTUInt32_t fCurrentSpec;
-
+  
 };
 
 #endif