Merge branch 'displayDevel'
authorslindal <slindal@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 30 Oct 2010 09:51:14 +0000 (09:51 +0000)
committerslindal <slindal@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 30 Oct 2010 09:51:14 +0000 (09:51 +0000)
* displayDevel:
  Made all EVE processors TEveElementList descendants
  Updated AliHLTEveCalo HLT to deal with offline eve
  Updated homer manager to automatically pre-fetch events
  updated processing functions to use AlieveHLTEventManager

18 files changed:
HLT/BASE/AliHLTHOMERManager.cxx
HLT/BASE/AliHLTHOMERManager.h
HLT/BASE/AliHLTHOMERProxyHandler.cxx
HLT/EVE/AliHLTEveAny.cxx
HLT/EVE/AliHLTEveBase.cxx
HLT/EVE/AliHLTEveBase.h
HLT/EVE/AliHLTEveCalo.cxx
HLT/EVE/AliHLTEveCalo.h
HLT/EVE/AliHLTEveEmcal.cxx
HLT/EVE/AliHLTEveEmcal.h
HLT/EVE/AliHLTEveHLT.cxx
HLT/EVE/AliHLTEveHLT.h
HLT/EVE/AliHLTEveITS.cxx
HLT/EVE/AliHLTEveMuon.cxx
HLT/EVE/AliHLTEvePhos.cxx
HLT/EVE/AliHLTEvePhos.h
HLT/EVE/AliHLTEveTPC.cxx
HLT/EVE/AliHLTEveTRD.cxx

index 7896911..d28b760 100644 (file)
@@ -64,15 +64,19 @@ ClassImp(AliHLTHOMERManager)
   fEventID(),
   fCurrentBlk(0),
   fAsyncBlockList(NULL),
-  fEventBuffer(NULL),
+  fBlockList(NULL),
+   fEventBuffer(NULL),
   fBufferTopIdx(-1),
   fBufferLowIdx(-1),
   fCurrentBufferIdx(-1),
   fNavigateBufferIdx(-1),
+  fNEventsAvailable(0),
   fConnected(kFALSE), 
   fTriggerString("ALL"), 
   fNEventsNotTriggered(0),
-  fRetryNextEvent(kFALSE) {
+  fRetryNextEvent(kFALSE),
+  fIsBlockOwner(kTRUE)
+{
   // see header file for class documentation
   // or
   // refer to README to build package
@@ -116,6 +120,12 @@ AliHLTHOMERManager::~AliHLTHOMERManager() {
   }
   fEventBuffer = NULL;
 
+  if(fBlockList) {
+    fBlockList->Clear();
+    delete fBlockList;
+  }
+  fBlockList = NULL;
+
   if ( fAsyncBlockList ) {
     fAsyncBlockList->Clear();
     delete fAsyncBlockList;
@@ -127,6 +137,8 @@ AliHLTHOMERManager::~AliHLTHOMERManager() {
 Int_t AliHLTHOMERManager::Initialize() {
   // see header file for class documentation
 
+  HLTInfo("Initializing");
+
   Int_t iResult = 0;
 
   // -- Initialize ProxyHandler
@@ -137,8 +149,8 @@ Int_t AliHLTHOMERManager::Initialize() {
     iResult = fProxyHandler->Initialize();
     if (iResult)
       HLTError(Form("Initialize of ProxyHandler failed."));
-  }
-  else {
+  
+  } else {
     iResult = -1;
     HLTError(Form("Creating of ProxyHandler failed."));
   }
@@ -154,6 +166,12 @@ Int_t AliHLTHOMERManager::Initialize() {
     fAsyncBlockList->SetOwner(kTRUE);
   }
 
+  //initialize normal block list
+  if( !fBlockList ) {
+    fBlockList = new TList();
+    fBlockList->SetOwner(kFALSE);
+  }
+
   // -- Initialize Event Buffer and EventID array
   if ( !fEventBuffer ) {
     fEventBuffer = new TClonesArray( "TList", BUFFERSIZE );
@@ -180,7 +198,7 @@ Int_t AliHLTHOMERManager::CreateSourcesList() {
   // see header file for class documentation
 
   Int_t iResult = 0;
-  
+
   if ( fSourceList != NULL )
     delete fSourceList;
   fSourceList = NULL;
@@ -273,6 +291,9 @@ Int_t AliHLTHOMERManager::ConnectHOMER( TString detector ){
   
   for (UInt_t idx = 0; idx < sourceCount; idx++) {
     
+    if (sourcePorts[idx] > 60000)
+      continue;
+
     HLTInfo(Form("Adding source %d as %s : %d", idx, sourceHostnames[idx], sourcePorts[idx]));
     
     fReaderList->Add(dynamic_cast<TObject*>(fLibManager->OpenReader(sourceHostnames[idx], sourcePorts[idx])));
@@ -463,17 +484,7 @@ Int_t AliHLTHOMERManager::NextEvent(){
 
   } // while( (object = next()) ) {
 
-  // -- Check if NextEvent should be recalled, 
-  //    to catch the next event with a trigger
-  if ( fRetryNextEvent ) {
-    usleep(1000000);
-    fRetryNextEvent = kFALSE;
-    
-    HLTInfo(Form("Checked trigger of %d events, without triggering", fNEventsNotTriggered));
-    return NextEvent();
-  }
-  else
-    return 0;  
+  return 0;  
 }
 
 /* ---------------------------------------------------------------------------------
@@ -502,6 +513,8 @@ Int_t AliHLTHOMERManager::NavigateEventBufferBack() {
 Int_t AliHLTHOMERManager::NavigateEventBufferFwd() {
   // see header file for class documentation
 
+  HLTInfo(Form("fNavigateBufferIdx: %d, fCurrentBufferIdx %d, fBufferTopIdx %d", fNavigateBufferIdx, fCurrentBufferIdx, fBufferTopIdx));
+
   // -- reached the top of the buffer
   if ( fNavigateBufferIdx == fBufferTopIdx )
     return -1;
@@ -511,8 +524,12 @@ Int_t AliHLTHOMERManager::NavigateEventBufferFwd() {
     newIdx = 0;
   
   fCurrentBufferIdx = fNavigateBufferIdx = newIdx;
+  fNEventsAvailable -= 1;
 
-  return newIdx;
+  HLTInfo(Form("fNavigateBufferIdx: %d, fCurrentBufferIdx %d, fBufferTopIdx %d", fNavigateBufferIdx, fCurrentBufferIdx, fBufferTopIdx));
+
+
+  return 0;
 }
 
  ///////////////////////////////////////////////////////////////////////////////////
@@ -534,6 +551,9 @@ void AliHLTHOMERManager::CreateReadoutList( const char** sourceHostnames, UShort
   TIter next( fSourceList );
   while ( ( source = dynamic_cast<AliHLTHOMERSourceDesc*>(next()) ) ) {
 
+    ///Don't use sources from dev cluster
+    if(source->GetPort() > 60000) continue;
+
     // -- If detector NO detector name given
     if ( ! detector.CompareTo("ALL") ) {
       // -- Continue if source is not selected
@@ -619,14 +639,17 @@ void AliHLTHOMERManager::AddBlockListToBuffer() {
       fBufferLowIdx = 0;
   }
 
-  fNavigateBufferIdx = fCurrentBufferIdx = fBufferTopIdx;    
 
   // -- Fill EventID
   fEventID[fBufferTopIdx] = eventID;
 
   // -- Clear Buffer slot
   (reinterpret_cast<TList*>((*fEventBuffer)[fBufferTopIdx]))->Clear();
-
+  if(fBlockList->IsOwner()) HLTWarning("block list is owner!!");
+  HLTInfo(Form("fBlockList size %d", fBlockList->GetSize()));
+  //fBlockList->Clear();
+  fBlockList = new TList();
+  HLTInfo(Form("fBlockList size %d", fBlockList->GetSize()));
 
   GetFirstBlk();
 
@@ -641,16 +664,21 @@ void AliHLTHOMERManager::AddBlockListToBuffer() {
     // -- Check sources list if block is requested
     if ( CheckIfRequested( block ) ) {
       (reinterpret_cast<TList*>((*fEventBuffer)[fBufferTopIdx]))->Add( block );
+      fBlockList->Add(block);
     }
     else {
       // XXX HACK Jochen
       (reinterpret_cast<TList*>((*fEventBuffer)[fBufferTopIdx]))->Add( block );
+      fBlockList->Add(block);
       // delete block;
       // block = NULL;
     }
  
   } while( GetNextBlk() );
 
+  //We have one more event available
+  fNEventsAvailable++;
+  HLTInfo(Form("fNEventsAvailable %d", fNEventsAvailable));
   return;
 }
 
@@ -662,46 +690,61 @@ void AliHLTHOMERManager::AddToAsyncBlockList() {
 
   GetFirstBlk();
 
-  // -- Fill block list
   do {
     
-    // -- Create new block
     AliHLTHOMERBlockDesc * block = new AliHLTHOMERBlockDesc();
     block->SetBlock( GetBlk(), GetBlkSize(), GetBlkOrigin(),
                     GetBlkType(), GetBlkSpecification() );
     
+
+    fAsyncBlockList->Add( block );
+
     // -- Check sources list if block is requested
-    if ( CheckIfRequested( block ) ) 
-      fAsyncBlockList->Add( block );
-    else {
-      // XXX HACK Jochen
-      fAsyncBlockList->Add( block );
-      // delete block;
-      // block = NULL;
-    }
+    // if ( CheckIfRequested( block ) ) 
+    //   fAsyncBlockList->Add( block );
+    // else {
+    //   // XXX HACK Jochen
+    // }
  
   } while( GetNextBlk() );
 
   return;
 }
-//##################################################################################
+//__________________________________________________________________________________
+void AliHLTHOMERManager::AddToBlockList() {
+  // see header file for class documentation
+  HLTInfo("Adding blocks to the synchroneous block list");
+
+  
+  GetFirstBlk();
+  do {
+
+    AliHLTHOMERBlockDesc * block = new AliHLTHOMERBlockDesc();
+    block->SetBlock( GetBlk(), GetBlkSize(), GetBlkOrigin(),
+                    GetBlkType(), GetBlkSpecification() );
+    fBlockList->Add( block );
+  
+  } while( GetNextBlk() );  
+}
+
+//__________________________________________________________________________________
 TList* AliHLTHOMERManager::GetBlockListEventBuffer( Int_t idx ) {
   // see header file for class documentation
 
-  if ( idx == -1 )
+  if(fBlockList)
+    return fBlockList;
+  else 
     return NULL;
 
+  if ( idx == -1 )
+    return NULL;
   return reinterpret_cast<TList*>((*fEventBuffer)[idx]);
 
 }
 
-/*
- * ---------------------------------------------------------------------------------
- *                          Block Handling - private
- * ---------------------------------------------------------------------------------
- */
 
-//##################################################################################
+//__________________________________________________________________________________
 Int_t AliHLTHOMERManager::HandleBlocks() {
   // see header file for class documentation
   
@@ -719,35 +762,18 @@ Int_t AliHLTHOMERManager::HandleBlocks() {
   }
 
   HLTInfo(Form("Event 0x%016lX (%lu) with %lu blocks", eventID, eventID, fNBlks));
-
-#if EVE_DEBUG
-  // Loop for Debug only
-  for ( ULong_t ii = 0; ii < fNBlks; ii++ ) {
-    Char_t tmp1[9], tmp2[5];
-    memset( tmp1, 0, 9 );
-    memset( tmp2, 0, 5 );
-    void *tmp11 = tmp1;
-    ULong64_t* tmp12 = static_cast<ULong64_t*>(tmp11);
-    *tmp12 = fCurrentReader->GetBlockDataType(ii);
-    void *tmp21 = tmp2;
-    ULong_t* tmp22 = static_cast<ULong_t*>(tmp21);
-    *tmp22 = fCurrentReader->GetBlockDataOrigin(ii);
-    HLTInfo(Form( "Block %lu length: %lu - type: %s - origin: %s - spec 0x%08X",
-                 ii, fCurrentReader->GetBlockDataLength(ii), tmp1, tmp2, fCurrentReader->GetBlockDataSpec(ii) ));
-  } // end for ( ULong_t ii = 0; ii < fNBlks; ii++ ) {
-#endif
     
-  // -- Check if blocks are from syncronous source
+  if ( IsSyncBlocks() ) {
+    //AddBlockListToBuffer();
+    AddToBlockList();
+  } else {
+    AddToAsyncBlockList();
+  }
 
-   if ( IsSyncBlocks() )
-     AddBlockListToBuffer();
-   else
-     AddToAsyncBlockList();
-    
   return iResult;
 }
 
-//##################################################################################
+//__________________________________________________________________________________
 Bool_t AliHLTHOMERManager::IsSyncBlocks() {
   // see header file for class documentation
   
index 8a0464a..72c6fe9 100644 (file)
@@ -12,7 +12,8 @@
 
 /** @file   AliHLTHOMERManager.h
     @author Jochen Thaeder
-    @date
+    @author Svein Lindal <slindal@fys.uio.no>
+    @date   October 2010
     @brief  Manager for HOMER in aliroot
 */
 
@@ -28,7 +29,7 @@
 
 #include "AliHLTLoggingVariadicFree.h"
 
-#define BUFFERSIZE 10
+#define BUFFERSIZE 15
 
 class AliHLTHOMERLibManager;
 
@@ -51,134 +52,73 @@ class AliHLTHOMERManager : public AliHLTLogging
 {
 public:
   
-  /*
-   * ---------------------------------------------------------------------------------
-   *                            Constructor / Destructor
-   * ---------------------------------------------------------------------------------
-   */
-
   /** default constructor */
   AliHLTHOMERManager();
 
   /** destructor */
   virtual ~AliHLTHOMERManager();
 
-  /** Initialize 
-   *  @return 0 on success, <0 for failure
-   */
+  /** Initialize */
   Int_t Initialize();
 
-  /*
-   * ---------------------------------------------------------------------------------
-   *                            Source Handling - public
-   * ---------------------------------------------------------------------------------
-   */
-
-  /** Create Sources List from HOMER-Proxy 
-   *  @return 0 on success, <0 for failure, 1 for no active service
-   */
+  /** Create Sources List from HOMER-Proxy */
   virtual Int_t CreateSourcesList();
 
-  /** Set state of a source 
-   *  @param source      Pointer to AliHLTHOMERSourceDesc object.
-   *  @param state       New (selected/not selected) state.
-   */
+  /** Set state of a source */
   void   SetSourceState( AliHLTHOMERSourceDesc* source, Bool_t state);
 
   /** Get pointer to source List */
   TList* GetSourceList() { return fSourceList; }
 
-  /*
-   * ---------------------------------------------------------------------------------
-   *                            Connection Handling - public
-   * ---------------------------------------------------------------------------------
-   */
-
-  /** Connect to HOMER sources, of a certain detector.
-   *  which gets created when state has changed 
-   *  @param detector    Detector to be connected to
-   *  @return            0 on success, <0 for failure
-   */
+  /** Connect to HOMER sources, of a certain detector. */
   Int_t ConnectHOMER( TString detector="ALL" );
 
   /** Disconnect from HOMER sources */
   void  DisconnectHOMER();
 
-  /** Reconnect from HOMER sources 
-   *  @param detector    Detector to be connected to
-   *  @return            0 on success, <0 for failure
-   */
+  /** Reconnect from HOMER sources */
   Int_t ReconnectHOMER( TString detector);
 
-  /*
-   * ---------------------------------------------------------------------------------
-   *                            Event Handling - public
-   * ---------------------------------------------------------------------------------
-   */
 
-  /** Loads the next Event, after being connected 
-   *  @return 0 on success, <0 for failure
-   */
+  /** Loads the next Event, after being connected */
   virtual Int_t NextEvent();
 
-  /** Loads the next Cycle, after being connected 
-   *  @return 0 on success, <0 for failure
-   */
+  /** Loads the next Cycle, after being connected */
   virtual Int_t NextCycle() { return NextEvent(); }
 
   /** Get event ID */
   ULong_t GetEventID() { return fEventID[fCurrentBufferIdx]; }
 
-  /* ---------------------------------------------------------------------------------
-   *                           Buffer Handling - public
-   * ---------------------------------------------------------------------------------
-   */
-
-  /** Get pointer to last requested BlockList 
-   *  @return     ptr to buffer, NULL if buffer boundary reached                
-   */
-  TList* GetBlockList() { return GetBlockListEventBuffer(fCurrentBufferIdx); }
-
-  /** Get pointer to last asynchrounous BlockList 
-   *  @return     ptr to buffer, NULL if none present
-   */
+  Int_t GetNAvailableEvents() { return fNEventsAvailable;}
+  
+  /** Get pointer to last requested BlockList */
+  TList* GetBlockList() { return fBlockList; }
   TList* GetAsyncBlockList() { return fAsyncBlockList; }
 
-  /** Navigate backwards in event buffer 
-   *  @return      index in buffer, -1 if boundary reached                
-   */
+  /** Navigate backwards in event buffer */
   Int_t  NavigateEventBufferBack();
 
-  /** Navigate forwards in event buffer 
-   *  @return      index in buffer, -1 if boundary reached                
-   */
+  /** Navigate forwards in event buffer */
   Int_t  NavigateEventBufferFwd();
 
-  /* ---------------------------------------------------------------------------------
-   *                          Trigger Handling - public
-   * ---------------------------------------------------------------------------------
-   */
-
-  /** Set and get the string used to select triggers 
-   *  @param triggerString    Trigger selection string
-   */
+  /** Set and get the string used to select triggers */
   void SetTriggerString ( TString triggerString ) { fTriggerString = triggerString; }
 
   /** Get TriggerString */
   TString GetTriggerString () { return fTriggerString; }
 
-  ///////////////////////////////////////////////////////////////////////////////////
+  void SetBlockOwner(Bool_t owner) { fBlockList->SetOwner(owner); }
+  Bool_t GetBlockOwner() const { return fBlockList->IsOwner(); }
 
 protected:
 
   /** Dynamic loader manager for the HOMER library */
   AliHLTHOMERLibManager* fLibManager;             //! transient
 
-  /** Indicates, if a sources have changes, 
-   *  so that one has to reconnect. */
+  /** Indicates, if a sources have changes,  so that one has to reconnect. */
   Bool_t    fStateHasChanged;                     //  see above
 
-  ///////////////////////////////////////////////////////////////////////////////////
+  Bool_t Connected() const { return fConnected; }
 
 private:
 
@@ -188,67 +128,38 @@ private:
   /** assignment operator prohibited */
   AliHLTHOMERManager& operator=(const AliHLTHOMERManager&);
 
-  /*
-   * ---------------------------------------------------------------------------------
-   *                            Connection Handling - private
-   * ---------------------------------------------------------------------------------
-   */
-
-  /** Create a readout list for Hostname and ports 
-   *  @param socurceHostnames   Array of selected hostnames
-   *  @param socurcePorts       Array of selected ports
-   *  @param socurceCount       Number of selected hostname:port
-   *  @param detector           detector to be selected
-   */
+  //==============Connection to homer ==========================
+
+  /** Create a readout list for Hostname and ports */
   void CreateReadoutList( const char** sourceHostnames, UShort_t* sourcePorts, 
                          UInt_t &sourceCount, TString detector );
 
   /** Checks if already connected to HOMER sources */
   Bool_t IsConnected() { return fConnected; }  
-  
-  /* ---------------------------------------------------------------------------------
-   *                           Buffer Handling - private
-   * ---------------------------------------------------------------------------------
-   */
 
   /** Create and add Block List to Buffer */
   void AddBlockListToBuffer();
 
   /** Add bocks to asynchronous BlockList */
   void AddToAsyncBlockList();
+  void AddToBlockList();
+
 
-  /** Get pointer to block list in event buffer 
-   *  @return     ptr to buffer, NULL if not present
-   */
+  //============ Block Handling ====================
+
+  /** Get pointer to block list in event buffer */
   TList* GetBlockListEventBuffer( Int_t idx );
     
-  /*
-   * ---------------------------------------------------------------------------------
-   *                            Block Handling - private
-   * ---------------------------------------------------------------------------------
-   */
-
   /** Get Number of blocks in current event */
   ULong_t GetNBlks() { return fNBlks; }
 
-  // ----------------------------------------------------
-
-  /** Handle Blocks and fill them in event buffer or asyncronous BlockList
-   *  @return 0 on success, <0 for failure
-   */
+  /** Handle Blocks and fill them in event buffer or asyncronous BlockList */
   Int_t HandleBlocks();
 
-  /** Check is block are from syncronous source
-   *  @return kTRUE, if asyncronous kFALSE
-   */
+  /** Check is block are from syncronous source */
   Bool_t IsSyncBlocks();
 
-  // ----------------------------------------------------
-
-  /** Get pointer to block ndx in current event 
-   *  @param ndx        Block index
-   *  @return           returns pointer to blk, NULL if no block present
-   */
+  /** Get pointer to block ndx in current event */
   void* GetBlk( Int_t ndx );
 
   /** Get pointer to current block in current event */
@@ -260,139 +171,63 @@ private:
   /** Get next block in current event */
   void* GetNextBlk() { return GetBlk(++fCurrentBlk); }
 
-  // ----------------------------------------------------
-
-  /** Get size of block ndx 
-   *  @param ndx        Block index
-   *  @return           returns size blk, 0 otherwise
-   */
+  /** Get size of block ndx */
   ULong_t GetBlkSize( Int_t ndx );
 
   /** Get size of current block */ 
   ULong_t GetBlkSize() { return GetBlkSize( fCurrentBlk ); }
 
-  // ---------------------------------------------------- 
-
-  /** Get origin of block ndx 
-   *  @param ndx        Block index
-   *  @return           origin of block
-   */
+  /** Get origin of block ndx  */
   TString GetBlkOrigin( Int_t ndx );
 
   /** Get origin of current block */
   TString GetBlkOrigin(){ return GetBlkOrigin( fCurrentBlk ); }
 
-  // ----------------------------------------------------
-
-  /** Get type of block ndx 
-   *  @param ndx        Block index
-   *  @return           type of block
-   */
+  /** Get type of block ndx */
   TString GetBlkType( Int_t ndx ); 
 
   /** Get type of current block */
   TString GetBlkType() { return GetBlkType( fCurrentBlk ); } 
   
-  // ----------------------------------------------------
-  
-  /** Get specification of block ndx 
-   *  @param ndx        Block index
-   *  @return           specification of block
-   */
+  //Get specification of block at ndx in bufferindex
   ULong_t GetBlkSpecification( Int_t ndx );
 
   /** Get specification of current block */
   ULong_t GetBlkSpecification() { return GetBlkSpecification( fCurrentBlk ); } 
 
-  // ----------------------------------------------------
-
-  /** Checks if current Block should was requested 
-   *  @return           returns kTRUE, if block should was requested
-   */
+  //Check if requested in eve
   Bool_t CheckIfRequested( AliHLTHOMERBlockDesc* block );
-
-  /* ---------------------------------------------------------------------------------
-   *                          Trigger Handling - private
-   * ---------------------------------------------------------------------------------
-   */
-  
-  /** Loops over the data block from all the readers in the readerlist until
-   *    a triggerdecsision has been found
-   *    Locates the triggerdecision required by fTriggerString and checks if it triggered 
-   *  @return           returns kTRUE, if event was triggered, kFALSE otherwise
-   */
+    
+  //Check trigger decision
   Bool_t CheckTriggerDecision();
-
-  /*
-   * ---------------------------------------------------------------------------------
-   *                            Members - private
-   * ---------------------------------------------------------------------------------
-   */
-
-  /** Proxy Handler to get the list of sources */
-  AliHLTHOMERProxyHandler *fProxyHandler;               //! transient 
-
-  // == connection ==
-
-  /** Pointer to current HOMER reader */
-  AliHLTHOMERReader       *fCurrentReader;              //! transient 
-
-  /** List to pointer of HOMER readers */
-  TList                   *fReaderList;                 //! transient
+  
+  AliHLTHOMERProxyHandler * fProxyHandler;  /** Proxy Handler to get the list of sources */  //! transient 
+  AliHLTHOMERReader* fCurrentReader;   /** Pointer to current HOMER reader */ //! transient 
+  TList* fReaderList;                 /** List to pointer of HOMER readers */
 
   // == sources ==
-
-  /** List to HOMER sources */
-  TList                   *fSourceList;                 //! transient
-
-  // == events ==
-
-  /** Number of blockes in current event */
-  ULong_t                  fNBlks;                      //  see above
-
-  /** EventID of current event */
-  ULong64_t                fEventID[BUFFERSIZE];        //  see above
-
-  /** Current block in current event */
-  ULong_t                  fCurrentBlk;                 //  see above
-
-  // == Asynchronous BlockList ==
-
-  /** List containing asychronous blocks */
-  TList                   *fAsyncBlockList;             //  see above
+  TList* fSourceList;                /** List to HOMER sources */
+  ULong_t fNBlks;                    /** Number of blockes in current event */
+  ULong64_t fEventID[BUFFERSIZE];    /** EventID of current event */
+  ULong_t fCurrentBlk;               /** Current block in current event */
+  TList* fAsyncBlockList;            /** List containing asychronous blocks */
+  TList* fBlockList;            /** List containing asychronous blocks */
 
   // == event buffer ==
-
-  /** Event Buffer */
-  TClonesArray            *fEventBuffer;                //  see above
-
-  /** Buffer index to last received event */
-  Int_t                    fBufferTopIdx;               //  see above
-
-  /** Buffer index to last received event */
-  Int_t                    fBufferLowIdx;               //  see above
-
-  /** Buffer index to current event */
-  Int_t                    fCurrentBufferIdx;           //  see above
-
-  /** Navigate index through event buffer */
-  Int_t                    fNavigateBufferIdx;          //  see above
+  TClonesArray     * fEventBuffer;  /** Event Buffer */
+  Int_t  fBufferTopIdx;             /** Buffer index to last received event */
+  Int_t  fBufferLowIdx;             /** Buffer index to last received event */
+  Int_t  fCurrentBufferIdx;         /** Buffer index to current event */
+  Int_t  fNavigateBufferIdx;        //  Navigate index through event buffer */
+  Int_t  fNEventsAvailable;         //Number of available events
   
-  // == states ==
+  Bool_t fConnected;                /** Shows connection status */
+  TString fTriggerString;           /** String indicating which trigger should be used to select events */
+  Int_t  fNEventsNotTriggered;      /** Number Events not triggered, before next triggered event is found */
   
-  /** Shows connection status */
-  Bool_t                   fConnected;                  //  see above
-
-  // == trigger selection ==
-
-  /** String indicating which trigger should be used to select events */
-  TString                  fTriggerString;              //  see above
-
-  /** Number Events not triggered, before next triggered event is found */
-  Int_t                    fNEventsNotTriggered;        //  see above
+  Bool_t fRetryNextEvent;           /** Retry reading next event */
 
-  /** Retry reading next event */
-  Bool_t                   fRetryNextEvent;             //  see above
+  Bool_t fIsBlockOwner;
 
   ClassDef(AliHLTHOMERManager, 1); // Manage connections to HLT data-sources.
 };
index 62dbb9f..e241174 100644 (file)
@@ -68,12 +68,8 @@ AliHLTHOMERProxyHandler::~AliHLTHOMERProxyHandler() {
 //##################################################################################
 Int_t AliHLTHOMERProxyHandler::Initialize() {
   // see header file for class documentation
-
-  Int_t iResult = 0 ;
-
   IdentifyRealm();
-
-  return iResult;
+  return 0;
 }
 
 /*
@@ -146,6 +142,8 @@ void AliHLTHOMERProxyHandler::IdentifyRealm() {
     fRealm = kLoc;
   }
 
+  //fRealm = kLoc;
+
   return;
 }
 
index 351812f..50af0a2 100644 (file)
@@ -13,7 +13,7 @@
 ClassImp(AliHLTEveAny);
 
 AliHLTEveAny::AliHLTEveAny() : 
-  AliHLTEveBase()
+  AliHLTEveBase("Other")
 {
   // Constructor.
   SetDetector("Any detector");
index 2ecd300..4570fa9 100644 (file)
@@ -21,8 +21,9 @@
 
 #include "AliHLTEveBase.h"
 #include "AliHLTHOMERBlockDesc.h"
-//#include "TCollection.h"
-#include "AliEveHOMERManager.h"
+#include "TCollection.h"
+#include "TObjArray.h"
+#include "AliEveHLTEventManager.h"
 #include "TCanvas.h"
 #include "TEveWindow.h"
 #include "TEveManager.h"
@@ -32,7 +33,8 @@
 
 ClassImp(AliHLTEveBase);
 
-AliHLTEveBase::AliHLTEveBase() : 
+AliHLTEveBase::AliHLTEveBase(const char * name) : 
+  TEveElementList(name),
   fEventManager(NULL), 
   fCanvas(NULL),
   fHistoCount(0),
@@ -72,8 +74,13 @@ TCanvas * AliHLTEveBase::CreateCanvas(TString  tabTitle, TString  canvasTitle )
 void AliHLTEveBase::AddHistogramsToCanvas(AliHLTHOMERBlockDesc * block, TCanvas * canvas, Int_t &cdCount ) {
   //See header file for documentation
 
-   
+
+
   if ( ! block->GetClassName().CompareTo("TObjArray")) {
+
+    // // TObjArray * blocks = dynamic_cast<TObjArray*>(block->GetTObject());
+    // // TIterator* next = block::MakeIterator();
+
     TIter next((TObjArray*)(block->GetTObject()));
     TObject *object;
     
index df2b6e4..07dfd9e 100644 (file)
 
 #include "Rtypes.h"
 #include "TString.h"
-
+#include "TEveElement.h"
 class AliHLTHOMERBlockDesc;
-class AliEveHOMERManager;
+class AliEveHLTEventManager;
 class TCanvas;
 
 
-class AliHLTEveBase{
+class AliHLTEveBase : public TEveElementList {
 
 public:
   
   /** Default constructor prohibited **/
-  AliHLTEveBase();
+  AliHLTEveBase(const char * name);
 
   /** Destructor **/
   virtual ~AliHLTEveBase();
@@ -36,8 +36,8 @@ public:
   /** Reset the elements before reading in new event, to be implemented by children */
   virtual void ResetElements() = 0;
 
-  /** Set the parent AliEveHOMERManager instance */
-  void SetEventManager(AliEveHOMERManager * em) { fEventManager = em; };
+  /** Set the parent AliEveHLTEventManager instance */
+  void SetEventManager(AliEveHLTEventManager * em) { fEventManager = em; };
 
   
 
@@ -59,13 +59,15 @@ protected:
   TString GetDetector() const {return fDetector;}
 
   
-  AliEveHOMERManager * fEventManager; //Pointer to AliEveHOMERManager instance
+  AliEveHLTEventManager * fEventManager; //Pointer to AliEveHLTEventManager instance
   TCanvas * fCanvas;                  //Canvas for histograms
   Int_t fHistoCount;                  //Counter for histograms, to track where to draw the next one
 
 
 private:
 
+  /** Default constructor prohibited **/
+  AliHLTEveBase();
   /** copy constructor prohibited */
   AliHLTEveBase(const AliHLTEveBase&);
   /** assignment operator prohibited */
index cec2602..4d85cfa 100644 (file)
@@ -18,6 +18,8 @@
 /// @author Svein Lindal <slindal@fys.uio.no>
 /// @brief  Calorimeter base class for the HLT EVE display
 
+#include "TCollection.h"
+#include "TObjArray.h"
 #include "AliHLTEveCalo.h"
 #include "AliHLTHOMERBlockDesc.h"
 #include "TCanvas.h"
@@ -25,7 +27,7 @@
 #include "TEveBoxSet.h"
 #include "AliPHOSGeometry.h"
 #include "TVector3.h"
-#include "AliEveHOMERManager.h"
+#include "AliEveHLTEventManager.h"
 #include "TEveManager.h"
 #include "AliHLTCaloDigitDataStruct.h"
 #include "AliHLTCaloClusterDataStruct.h"
 #include "TString.h"
 #include "TH2F.h"
 #include "TH1F.h"
-
-
+#include "TRefArray.h"
+#include "AliESDEvent.h"
+#include "AliESDCaloCluster.h"
 
 ClassImp(AliHLTEveCalo);
 
 AliHLTEveCalo::AliHLTEveCalo(Int_t nm, TString name) : 
-  AliHLTEveBase(), 
+  AliHLTEveBase(name), 
   fBoxSetDigits(NULL),
   fBoxSetClusters(NULL),
-  fElementList(NULL),
   fNModules(nm),
+  fClustersArray(NULL),
   fName(name), 
   fPadTitles(NULL),
   fInvMassCanvas(NULL)
@@ -59,6 +62,7 @@ AliHLTEveCalo::AliHLTEveCalo(Int_t nm, TString name) :
     fPadTitles[i] = "";
   }
 
+  fClustersArray = new TRefArray();
 
 }
 
@@ -73,11 +77,6 @@ AliHLTEveCalo::~AliHLTEveCalo()
     delete fBoxSetClusters;
   fBoxSetClusters = NULL;
 
-  if(fElementList) {
-    
-    delete fElementList;
-  }
-  fElementList = NULL;
 
   if(fPadTitles)
     delete [] fPadTitles;
@@ -94,10 +93,6 @@ void AliHLTEveCalo::ProcessBlock(AliHLTHOMERBlockDesc * block) {
    
   } else {
 
-    if( !fElementList ) {
-      fElementList = CreateElementList();
-      fEventManager->GetEveManager()->AddElement(fElementList);
-    }
     
     if ( block->GetDataType().CompareTo("CALOCLUS") == 0 ){
       //cout <<"Skipping calo clusters"<<endl;
@@ -151,11 +146,23 @@ void AliHLTEveCalo::ProcessHistogram(AliHLTHOMERBlockDesc * block ) {
 
 // }
 
+void AliHLTEveCalo::ProcessEvent(AliESDEvent * event) {
+  //see header file for documentation
+
+
+
+  Int_t nClusters = GetClusters(event, fClustersArray);
+  for(int ic = 0; ic < nClusters; ic++) {
+    AliESDCaloCluster * cluster = dynamic_cast<AliESDCaloCluster*>(fClustersArray->At(ic));
+    ProcessESDCluster(cluster);
+  }
+  
+}
+
 
 void AliHLTEveCalo::ProcessClusters(AliHLTHOMERBlockDesc* block) {
   //See header file for documentation
 
-
   AliHLTCaloClusterHeaderStruct *dh = reinterpret_cast<AliHLTCaloClusterHeaderStruct*> (block->GetData());
   AliHLTCaloClusterReader * clusterReader = new AliHLTCaloClusterReader();
   clusterReader->SetMemory(dh);  
index 2cb5b85..9bfbaa1 100644 (file)
@@ -13,6 +13,9 @@
 #include "AliHLTEveBase.h"
 #include "TString.h"
 
+class AliESDEvent;
+class AliESDCaloCluster;
+class TRefArray;
 class TEveElementList;
 class TEveBoxSet;
 class AliHLTHOMERBlockDesc;
@@ -37,12 +40,14 @@ public:
   /** inherited from AliHLTEveBase */
   void ResetElements();
 
+  /// Process esd event
+  void ProcessEvent(AliESDEvent * event);
 
 
 protected :
 
   /** Create the elementlist */
-  virtual TEveElementList * CreateElementList() = 0;
+  virtual void CreateElementList() = 0;
   
   /** Add clusters boxset to eve display */
   virtual void AddClusters(Float_t * pos, Int_t module, Float_t energy) = 0;
@@ -50,6 +55,10 @@ protected :
   /** Add digits boxset to eve display */
   virtual void AddDigits(UShort_t fX, UShort_t fZ, Int_t module, Float_t energy) = 0;
 
+  
+  virtual void ProcessESDCluster(AliESDCaloCluster * cluster)  = 0;
+
+
   /** Process clusters block */
   void ProcessClusters(AliHLTHOMERBlockDesc * block);
   
@@ -58,19 +67,25 @@ protected :
 
   /** Process histogram block */
   void ProcessHistogram(AliHLTHOMERBlockDesc * block );
+
   
   /** Process and draw histograms */
   void AddHistogramsToCanvas(AliHLTHOMERBlockDesc * block, TCanvas * canvas, Int_t &cdCount );  
+  
 
   Int_t GetPadNumber(TString name);  
 
+  virtual Int_t GetClusters (AliESDEvent * event, TRefArray * clusters) = 0;
+
   TEveBoxSet * fBoxSetDigits;            //Boxset for clusters and digist
   TEveBoxSet * fBoxSetClusters;            //Boxset for clusters and digist
-  
-  TEveElementList * fElementList; //Element list to contain the clusters
 
   const Int_t fNModules;          //Number of modules in calorimeter
 
+
+  TRefArray * fClustersArray;
+
+
 private:
   
   /** default constructor prohibited */
index 141d03b..3837868 100644 (file)
@@ -26,7 +26,7 @@
 #include "TEveBoxSet.h"
 #include "AliPHOSGeometry.h"
 #include "TVector3.h"
-#include "AliEveHOMERManager.h"
+#include "AliEveHLTEventManager.h"
 #include "TEveManager.h"
 #include "AliHLTCaloDigitDataStruct.h"
 #include "AliHLTCaloClusterDataStruct.h"
 #include "TEveTrans.h"
 #include "TGeoNode.h"
 #include "AliEMCALGeoUtils.h"
+#include "TGeoManager.h"
+
+#include "TEveGeoShapeExtract.h"
+#include "TEveGeoNode.h"
 
 ClassImp(AliHLTEveEmcal)
 
@@ -43,6 +47,7 @@ fGeoUtils(NULL)
 {
   //Constructor
   fGeoUtils = new AliEMCALGeoUtils("EMCAL_COMPLETE","EMCAL");
+  CreateElementList();
 
 }
 
@@ -52,12 +57,16 @@ AliHLTEveEmcal::~AliHLTEveEmcal()
   //Destructor, not implemented
 }
 
-TEveElementList * AliHLTEveEmcal::CreateElementList() {
+void AliHLTEveEmcal::CreateElementList() {
   
-  TGeoNode * gEMCALNode = fEventManager->GetGeoManager()->GetTopVolume()->FindNode("XEN1_1");
 
-  fElementList = new TEveElementList("EMCAL Digits / Clusters");
-  fElementList->SetTitle("Tooltip");
+  //TEveGeoShapeExtract * shape = new TEveGeoShapeExtract();
+  TGeoNode * gEMCALNode = gGeoManager->GetTopVolume()->FindNode("XEN1_1");
+  //TEveGeoNode * eveNode = new TEveGeoNode(gEMCALNode);
+  //TEveGeoShapeExtract* juice = eveNode->DumpShapeTree(this, shape, kFALSE);
+  //juice->Dump();
+  //eveNode->WriteExtract("out.root", kFALSE);
+
   
   //gStyle->SetPalette(1, 0);
   TEveRGBAPalette* pal = new TEveRGBAPalette(0, 512);
@@ -77,7 +86,7 @@ TEveElementList * AliHLTEveEmcal::CreateElementList() {
     fBoxSetDigits[sm].RefMainTrans().SetFrom(*gEMCALNode->GetDaughter(sm)->GetMatrix());
     fBoxSetDigits[sm].SetPalette(pal);
     
-    fElementList->AddElement(&fBoxSetDigits[sm]);
+    AddElement(&fBoxSetDigits[sm]);
  
     //Clusters
     fBoxSetClusters[sm].SetTitle(Form("Clusters Module %d", sm));
@@ -88,12 +97,10 @@ TEveElementList * AliHLTEveEmcal::CreateElementList() {
     //    fBoxSetClusters[sm].RefMainTrans().SetFrom(*gEMCALNode->GetDaughter(sm)->GetMatrix());
     fBoxSetClusters[sm].SetPalette(pal);
     
-    fElementList->AddElement(&fBoxSetClusters[sm]);
+    AddElement(&fBoxSetClusters[sm]);
 
 
   }
-  
-  return fElementList;
 }
 
 void AliHLTEveEmcal::AddClusters(Float_t * pos, Int_t module, Float_t energy) {
index 58b437a..1e4faca 100644 (file)
@@ -9,6 +9,7 @@
 #ifndef ALIHLTEVEEMCAL_H
 #define ALIHLTEVEEMCAL_H
 
+#include "AliESDEvent.h"
 #include "AliHLTEveCalo.h"
 class TEveElementList;
 class AliEMCALGeoUtils;
@@ -33,8 +34,12 @@ private:
   void AddClusters(Float_t * pos, Int_t module, Float_t energy);
 
   void AddDigits(UShort_t fX, UShort_t fZ, Int_t module, Float_t energy);
+
+  Int_t GetClusters(AliESDEvent * event, TRefArray * clusters) { return event->GetEMCALClusters(clusters); }
   
-  TEveElementList * CreateElementList();
+  void ProcessESDCluster(AliESDCaloCluster * cluster) { if(cluster) return;}
+
+  void CreateElementList();
 
   AliEMCALGeoUtils * fGeoUtils;
 
index 677056c..aa4025e 100644 (file)
@@ -21,7 +21,7 @@
 #include "AliHLTEveHLT.h"
 #include "AliHLTHOMERBlockDesc.h"
 #include "AliHLTEveBase.h"
-#include "AliEveHOMERManager.h"
+#include "AliEveHLTEventManager.h"
 #include "TEveManager.h"
 #include "TEvePointSet.h"
 #include "TEveTrack.h"
 #include "AliEveMagField.h"
 #include "TH1F.h"
 #include "TH2F.h"
+#include "TThread.h"
 
 ClassImp(AliHLTEveHLT)
 
 AliHLTEveHLT::AliHLTEveHLT() : 
-  AliHLTEveBase(), 
+  AliHLTEveBase("TPC tracks"), 
   fTrueField(kFALSE),
   fUseIpOnFailedITS(kFALSE),
   fUseRkStepper(kFALSE),
   fTrackList(NULL),
+  fOldTrackList(NULL),
   fPointSetVertex(NULL),
   fTrCanvas(NULL),
   fHistPt(NULL), 
@@ -56,8 +58,7 @@ AliHLTEveHLT::AliHLTEveHLT() :
   fHistMult(NULL)
 {
   // Constructor.
-  CreateHistograms();
-
+  //CreateHistograms();
 }
 
 AliHLTEveHLT::~AliHLTEveHLT()
@@ -68,24 +69,14 @@ AliHLTEveHLT::~AliHLTEveHLT()
   fTrackList = NULL;
 }
 
-void AliHLTEveHLT::CreateHistograms(){
+void AliHLTEveHLT::ProcessEsdEvent( AliESDEvent * esd ) {
   //See header file for documentation
-  fHistPt        = new TH1F("fHistPt",       "transverse momentum",    100, 0, 10); // KK   
-  fHistP         = new TH1F("fHistP",        "signed momentum",        100,-7,  7);       
-  fHistEta       = new TH1F("fHistEta",      "pseudorapidity",         100,-2,  2);       
-  fHistTheta     = new TH1F("fHistTheta",    "polar angle",            180, 0,180);   
-  fHistPhi      = new TH1F("fHistPhi",      "azimuthal angle",        180, 0,360);   
-  fHistnClusters = new TH1F("fHistnClusters","TPC clusters per track", 160, 0,160);
-  fHistMult      = new TH1F("fHistMult",     "event track multiplicity",50, 0, 50);    
-  
-  fHistPt   ->SetXTitle("p_{t} (GeV/c)");   // KK
-  fHistP    ->SetXTitle("P*charge (GeV/c)");
-  fHistEta  ->SetXTitle("#eta");
-  fHistTheta->SetXTitle("#theta (degrees)");
-  fHistPhi  ->SetXTitle("#phi (degrees)");
-
+  if(!fTrackList) CreateTrackList();
+  if(!fPointSetVertex) CreateVertexPointSet();
+  ProcessEsdEvent(esd, fTrackList);
+    
 }
-
+///_____________________________________________________________________
 void AliHLTEveHLT::ProcessBlock(AliHLTHOMERBlockDesc * block) {
   //See header file for documentation
   if ( ! block->GetDataType().CompareTo("ALIESDV0") ) {
@@ -108,28 +99,49 @@ void AliHLTEveHLT::ProcessBlock(AliHLTHOMERBlockDesc * block) {
       fCanvas->Divide(3, 2);
     }
     ProcessHistograms( block , fCanvas);
-  }
-  
+  }  
 }
 
-
+///____________________________________________________________________________
 void AliHLTEveHLT::UpdateElements() {
   //See header file for documentation
-  if(fCanvas) fCanvas->Update();
-  DrawHistograms();
+  //if(fCanvas) fCanvas->Update();
+  //DrawHistograms();
   if(fTrackList) fTrackList->ElementChanged();
   if(fPointSetVertex) fPointSetVertex->ResetBBox();
 
 }
-
+///_________________________________________________________________________________
 void AliHLTEveHLT::ResetElements(){
-    //See header file for documentation
-  if(fTrackList) fTrackList->DestroyElements();
+  //See header file for documentation
+  
+  cout << "destroy"<<endl;
+  if(fTrackList) {
+    RemoveElement(fTrackList);
+    fTrackList = NULL;
+  }
+  
   if(fPointSetVertex) fPointSetVertex->Reset();
+  cout<< "reset done"<<endl;
   fHistoCount = 0;
 
 }
 
+///_____________________________________________________________________________________
+void * AliHLTEveHLT::DestroyGarbage(void * arg) {
+  AliHLTEveHLT * hlt = reinterpret_cast<AliHLTEveHLT*>(arg);
+  if(hlt) hlt->DestroyOldTrackList();
+  return (void*)0;
+}
+///_____________________________________________________________________________________
+void AliHLTEveHLT::DestroyOldTrackList() {
+  cout << "Destroying the old tracklist's elements"<<endl;
+  fOldTrackList->DestroyElements();
+  cout << "Destroying the old tracklist itself"<<endl;
+  fOldTrackList->Destroy();
+}
+
+///_____________________________________________________________________________________
 void AliHLTEveHLT::ProcessHistograms(AliHLTHOMERBlockDesc * block, TCanvas * canvas) {
   //See header file for documentation
   if ( ! block->GetClassName().CompareTo("TH1F")) {
@@ -158,26 +170,24 @@ void AliHLTEveHLT::ProcessHistograms(AliHLTHOMERBlockDesc * block, TCanvas * can
     }
   }
   canvas->cd();
-
-
-
-
 }
 
+
 void AliHLTEveHLT::CreateTrackList() {
   //See header file for documentation
   fTrackList = new TEveTrackList("ESD Tracks");
   fTrackList->SetMainColor(6);
-  gEve->AddElement(fTrackList);
+  AddElement(fTrackList);
 }
 
+
 void AliHLTEveHLT::CreateVertexPointSet() {
   //See header file for documentation
   fPointSetVertex = new TEvePointSet("Primary Vertex");
   fPointSetVertex->SetMainColor(6);
   fPointSetVertex->SetMarkerStyle((Style_t)kFullStar);
 
-  gEve->AddElement(fPointSetVertex);
+  AddElement(fPointSetVertex);
 }
 
 
@@ -185,8 +195,19 @@ void AliHLTEveHLT::ProcessEsdBlock( AliHLTHOMERBlockDesc * block, TEveTrackList
   //See header file for documentation
 
   AliESDEvent* esd = (AliESDEvent *) (block->GetTObject());
+  if (!esd) return;
+  
+  ProcessEsdEvent(esd, cont);
+}
+
+void AliHLTEveHLT::ProcessEsdEvent(AliESDEvent * esd, TEveTrackList * cont) {
+
   esd->GetStdContent();
 
+  cout << esd->GetEventNumberInFile() << "  " << esd->GetNumberOfCaloClusters() << endl;
+
+  //fEventManager->SetRunNumber(esd->GetRunNumber());
+
   Double_t vertex[3];
   const AliESDVertex * esdVertex = esd->GetPrimaryVertex();
   
@@ -201,25 +222,26 @@ void AliHLTEveHLT::ProcessEsdBlock( AliHLTHOMERBlockDesc * block, TEveTrackList
     AliEveTrack* track = dynamic_cast<AliEveTrack*>(MakeEsdTrack(esd->GetTrack(iter), cont));
     cont->AddElement(track);
    
-    fHistPt->Fill(esd->GetTrack(iter)->Pt());   // KK
-    fHistP->Fill(esd->GetTrack(iter)->P()*esd->GetTrack(iter)->Charge());
-    fHistEta->Fill(esd->GetTrack(iter)->Eta());
-    fHistTheta->Fill(esd->GetTrack(iter)->Theta()*TMath::RadToDeg());
-    fHistPhi->Fill(esd->GetTrack(iter)->Phi()*TMath::RadToDeg());
-    if(esd->GetTrack(iter)->GetStatus()&AliESDtrack::kTPCin || (esd->GetTrack(iter)->GetStatus()&AliESDtrack::kTPCin && esd->GetTrack(iter)->GetStatus()&AliESDtrack::kITSin)){
-       fHistnClusters->Fill(esd->GetTrack(iter)->GetTPCNcls());  
-    }
+    // fHistPt->Fill(esd->GetTrack(iter)->Pt());   // KK
+    // fHistP->Fill(esd->GetTrack(iter)->P()*esd->GetTrack(iter)->Charge());
+    // fHistEta->Fill(esd->GetTrack(iter)->Eta());
+    // fHistTheta->Fill(esd->GetTrack(iter)->Theta()*TMath::RadToDeg());
+    // fHistPhi->Fill(esd->GetTrack(iter)->Phi()*TMath::RadToDeg());
+    // if(esd->GetTrack(iter)->GetStatus()&AliESDtrack::kTPCin || (esd->GetTrack(iter)->GetStatus()&AliESDtrack::kTPCin && esd->GetTrack(iter)->GetStatus()&AliESDtrack::kITSin)){
+    //    fHistnClusters->Fill(esd->GetTrack(iter)->GetTPCNcls());  
+    //}
   }
   
-  fHistMult->Fill(esd->GetNumberOfTracks()); // KK
+//fHistMult->Fill(esd->GetNumberOfTracks()); // KK
   
   
   cont->SetTitle(Form("N=%d", esd->GetNumberOfTracks()) );
   cont->MakeTracks();
-
+  
 }
 
 
+
 void AliHLTEveHLT::DrawHistograms(){
   //See header file for documentation
 
@@ -341,7 +363,7 @@ AliEveTrack* AliHLTEveHLT::MakeEsdTrack (AliESDtrack *at, TEveTrackList* cont) {
     //
     
     for( double dxx=dx/2; TMath::Abs(dxx)>=1.; dxx*=.9 ){
-      if( !t.TransportToX(x0+dxx, bz, .99 ) ) continue;
+      if( !t.TransportToX(x0+dxx, bz, .999 ) ) continue;
       AliHLTTPCCATrackConvertor::GetExtParam( t, trackParam, trackParam.GetAlpha() ); 
       trackParam.GetXYZ(vbuf);
       trackParam.GetPxPyPz(pbuf);
@@ -358,7 +380,7 @@ AliEveTrack* AliHLTEveHLT::MakeEsdTrack (AliESDtrack *at, TEveTrackList* cont) {
     //
     
     for( ; TMath::Abs(dx)>=1.; dx*=.9 ){
-      if( !t.TransportToX(x0+dx, bz, .99 ) ) continue;
+      if( !t.TransportToX(x0+dx, bz, .999 ) ) continue;
       AliHLTTPCCATrackConvertor::GetExtParam( t, trackParam, trackParam.GetAlpha() ); 
       trackParam.GetXYZ(vbuf);
       trackParam.GetPxPyPz(pbuf);
@@ -472,3 +494,4 @@ TString AliHLTEveHLT::CreateTrackTitle(AliESDtrack* t) {
   return s;
 }
 
+
index a143bc4..d31fb7f 100644 (file)
@@ -19,6 +19,7 @@ class TEveTrackPropagator;
 class TString;
 class AliExternalTrackParam;
 class TH1F;
+class AliESDEvent;
 
 class AliHLTEveHLT : public AliHLTEveBase {
 
@@ -39,6 +40,11 @@ public:
   /** inherited from AliHLTEveBase */
   void ResetElements();
 
+  void ProcessEsdEvent( AliESDEvent * esd);
+
+  void DestroyOldTrackList();
+  static void * DestroyGarbage(void * arg);
+
 private:
 
   /** copy constructor prohibited */
@@ -58,6 +64,9 @@ private:
   // Process the ESD block and call the functions necessary to fill the tracklist
   void ProcessEsdBlock( AliHLTHOMERBlockDesc * block, TEveTrackList * cont );
 
+  // Process ESD event
+  void ProcessEsdEvent( AliESDEvent * esd, TEveTrackList * cont);
+
   //Set up the track propagator
   void SetUpTrackPropagator(TEveTrackPropagator* trkProp, Float_t magF, Float_t maxR);
 
@@ -80,11 +89,13 @@ private:
   void DrawHistograms();
 
 
+
   Bool_t fTrueField;        //Use true field?
   Bool_t fUseIpOnFailedITS; // Use IP as origin if ITS refit fails?
   Bool_t fUseRkStepper;    // Use Runge Kutta for something something?
 
   TEveTrackList * fTrackList;  //Eve tracklist 
+  TEveTrackList * fOldTrackList;  //Eve tracklist 
   TEvePointSet * fPointSetVertex;      //Display primary vertex
 
   TCanvas * fTrCanvas;  //Canvas for track qa histos
index 00b1203..b82782f 100644 (file)
@@ -21,7 +21,7 @@
 #include "AliHLTEveITS.h"
 #include "AliHLTHOMERBlockDesc.h"
 #include "TCanvas.h"
-#include "AliEveHOMERManager.h"
+#include "AliEveHLTEventManager.h"
 #include "TEveManager.h"
 #include "TH1F.h"
 #include "TH2F.h"
@@ -33,7 +33,7 @@
 ClassImp(AliHLTEveITS)
 
 AliHLTEveITS::AliHLTEveITS(TString name) : 
-AliHLTEveBase(),
+AliHLTEveBase(name.Data()),
   fName(name), 
   fPointSet(NULL)
 {
@@ -65,7 +65,7 @@ void AliHLTEveITS::ProcessBlock(AliHLTHOMERBlockDesc * block) {
   else if ( block->GetDataType().CompareTo("CLUSTERS") == 0 ) {
     if(!fPointSet) {
       fPointSet = CreatePointSet(fName);
-      fEventManager->GetEveManager()->AddElement(fPointSet);
+      AddElement(fPointSet);
     }
     ProcessClusters(block, fPointSet);
   }
index cc81f39..05625e2 100644 (file)
@@ -24,7 +24,7 @@
 #include "TCanvas.h"\r
 #include "TEveStraightLineSet.h"\r
 #include "TEvePointSet.h"\r
-#include "AliEveHOMERManager.h"\r
+#include "AliEveHLTEventManager.h"\r
 #include "TEveManager.h"\r
 \r
 \r
@@ -47,7 +47,7 @@ class AliEveMuonTrack;
 ClassImp(AliHLTEveMuon);\r
 \r
 AliHLTEveMuon::AliHLTEveMuon() : \r
-  AliHLTEveBase(),\r
+  AliHLTEveBase("Muon"),\r
   fFullTrackList(NULL),\r
   fTracks(NULL),\r
   fClusters(NULL)\r
@@ -78,7 +78,7 @@ void AliHLTEveMuon::ProcessBlock(AliHLTHOMERBlockDesc * block) {
   if ( (block->GetDataType().CompareTo("RECHITS") == 0) || (block->GetDataType().CompareTo("TRIGRECS") == 0) ) {\r
     if(!fClusters) {\r
       fClusters = CreateClusters();\r
-      fEventManager->GetEveManager()->AddElement(fClusters);\r
+      AddElement(fClusters);\r
     }\r
     ProcessClusters( block, fClusters );\r
     \r
@@ -86,8 +86,7 @@ void AliHLTEveMuon::ProcessBlock(AliHLTHOMERBlockDesc * block) {
     \r
     if ( !fTracks ) {\r
       fTracks = CreateTrackSet(); \r
-      fEventManager->GetEveManager()->AddElement(fTracks);\r
-      gEve->AddElement(fTracks);\r
+      AddElement(fTracks);\r
     }\r
     \r
     ProcessTracks( block, fTracks );\r
@@ -96,8 +95,7 @@ void AliHLTEveMuon::ProcessBlock(AliHLTHOMERBlockDesc * block) {
     \r
     if ( !fFullTrackList ) {\r
       fFullTrackList = CreateFullTrackList(); \r
-      fEventManager->GetEveManager()->AddElement(fFullTrackList);      \r
-      gEve->AddElement(fFullTrackList);\r
+      AddElement(fFullTrackList);\r
     }\r
     \r
     ProcessFullTracks( block,  fFullTrackList );\r
@@ -118,17 +116,17 @@ TEvePointSet * AliHLTEveMuon::CreateClusters() {
 \r
 TEveStraightLineSet * AliHLTEveMuon::CreateTrackSet() {\r
   // See header file\r
-  TEveStraightLineSet * ls = new TEveStraightLineSet("MUON Tracks");\r
-  ls->SetMainColor(kRed);\r
-  ls->SetLineWidth(3);\r
-  return ls;\r
+  TEveStraightLineSet * lineset = new TEveStraightLineSet("MUON Tracks");\r
+  lineset->SetMainColor(kRed);\r
+  lineset->SetLineWidth(3);\r
+  return lineset;\r
 }\r
 \r
 TEveTrackList * AliHLTEveMuon::CreateFullTrackList(){\r
   // See header file\r
-  TEveTrackList * ls = new TEveTrackList("MUON Full Tracks");\r
-  ls->SetMainColor(kBlue);\r
-  return ls;\r
+  TEveTrackList * lineset = new TEveTrackList("MUON Full Tracks");\r
+  lineset->SetMainColor(kBlue);\r
+  return lineset;\r
 }\r
 \r
 void AliHLTEveMuon::ProcessHistogram(AliHLTHOMERBlockDesc * block ) {\r
@@ -347,7 +345,7 @@ Int_t AliHLTEveMuon::ProcessFullTracks(AliHLTHOMERBlockDesc * block, TEveTrackLi
     track->MakeESDTrack(muonESDTrack);\r
     //track->SetTitle(Form("HLT Track : %d, pt : %lf",ientry,TMath::Sqrt(((mtrack->fPx * mtrack->fPx) + (mtrack->fPy * mtrack->fPy)))));\r
     track->SetName(Form("HLT Track : %d, pt : %lf",ientry,TMath::Sqrt(((mtrack->fPx * mtrack->fPx) + (mtrack->fPy * mtrack->fPy)))));\r
-    gEve->AddElement(track, fullTracks);\r
+    fullTracks->AddElement(track);\r
     \r
     mtrack++;\r
   }//track loop\r
index 940d102..5b9e54b 100644 (file)
@@ -25,7 +25,7 @@
 #include "AliPHOSGeoUtils.h"
 #include "AliPHOSGeometry.h"
 #include "TVector3.h"
-#include "AliEveHOMERManager.h"
+#include "AliEveHLTEventManager.h"
 #include "TEveManager.h"
 #include "AliHLTCaloDigitDataStruct.h"
 #include "AliHLTCaloClusterDataStruct.h"
@@ -40,6 +40,8 @@ fGeoUtils(NULL)
 {
   // Constructor.
   fGeoUtils = new AliPHOSGeoUtils("PHOS", "noCPV");
+  CreateElementList();
+
 }
 
 AliHLTEvePhos::~AliHLTEvePhos()
@@ -50,11 +52,9 @@ AliHLTEvePhos::~AliHLTEvePhos()
   fGeoUtils = NULL;
 }
 
-
-TEveElementList * AliHLTEvePhos::CreateElementList() {
+void AliHLTEvePhos::CreateElementList() {
   //See header file for documentation
 
-  TEveElementList * elementList  = new TEveElementList("PHOS ");
   fBoxSetClusters = new TEveBoxSet[fNModules];
   fBoxSetDigits = new TEveBoxSet[fNModules];
 
@@ -67,7 +67,7 @@ TEveElementList * AliHLTEvePhos::CreateElementList() {
   for(int im = 0; im < fNModules; im++) {
     
     TEveRGBAPalette* pal = new TEveRGBAPalette(0,512);
-    pal->SetLimits(-1, 6);
+    pal->SetLimits(-1, 45);
 
     //Create clusters box set
     fBoxSetClusters[im].SetTitle(Form("Clusters Module %d", im));
@@ -85,7 +85,7 @@ TEveElementList * AliHLTEvePhos::CreateElementList() {
     t.SetupRotation(1, 2, angle );
     t.SetPos(center.X(), center.Y(), center.Z());
     
-    elementList->AddElement(&fBoxSetClusters[im]);
+    AddElement(&fBoxSetClusters[im]);
 
 
     //Create digits box set
@@ -104,12 +104,11 @@ TEveElementList * AliHLTEvePhos::CreateElementList() {
     t2.SetupRotation(1, 2, angle );
     t2.SetPos(center.X(), center.Y(), center.Z());
     
-    elementList->AddElement(&fBoxSetDigits[im]);
+    AddElement(&fBoxSetDigits[im]);
 
 
   }
 
-  return elementList;
 }
 
 void AliHLTEvePhos::AddDigits(UShort_t fX, UShort_t fZ, Int_t module, Float_t energy) {
@@ -120,6 +119,25 @@ void AliHLTEvePhos::AddDigits(UShort_t fX, UShort_t fZ, Int_t module, Float_t en
   fBoxSetDigits[4-module].DigitValue(static_cast<Int_t>(energy));
 }
 
+void AliHLTEvePhos::ProcessESDCluster(AliESDCaloCluster * cluster) {
+  
+  Float_t pos[3];
+  cluster->GetPosition(pos);
+  TVector3 vec = TVector3(pos);
+  Float_t phi = vec.Phi() *180 / TMath::Pi();
+  if(phi < 0) phi += 360;
+
+  Int_t mid = 0;
+  if(phi > 320) return;
+  else if(phi > 300) mid = 4;
+  else if(phi > 280) mid = 3;
+  else if(phi > 260) mid = 2;
+  else return;
+  
+  Int_t nCells = cluster->GetNCells();
+  AddClusters(pos, mid, cluster->E(), nCells);
+
+}
 
 void AliHLTEvePhos::AddClusters(Float_t * pos, Int_t module, Float_t energy) {
 
@@ -129,7 +147,19 @@ void AliHLTEvePhos::AddClusters(Float_t * pos, Int_t module, Float_t energy) {
   fGeoUtils->Global2Local(localVector, globalVector, 5-module);
 
  //See header file for documentation
-  fBoxSetClusters[4-module].AddBox(localVector.X(), -70, localVector.Z(), 2.2, -energy*20, 2.2);
-  fBoxSetClusters[4-module].DigitValue(static_cast<Int_t>(energy));
+  fBoxSetClusters[4-module].AddBox(localVector.X(), 0, localVector.Z(), 2.2, energy*40, 2.2 );
+  fBoxSetClusters[4-module].DigitValue(static_cast<Int_t>(energy*10));
+}
+void AliHLTEvePhos::AddClusters(Float_t * pos, Int_t module, Float_t energy, Int_t nCells) {
+
+  TVector3 localVector;
+  TVector3 globalVector(pos);
+
+  fGeoUtils->Global2Local(localVector, globalVector, 5-module);
+
+  Float_t cf = 2.2*TMath::Sqrt(nCells);
+ //See header file for documentation
+  fBoxSetClusters[4-module].AddBox(localVector.X(), 0, localVector.Z(), cf, energy*40, cf );
+  fBoxSetClusters[4-module].DigitValue(static_cast<Int_t>(energy*10));
 }
 
index 25d3a3c..31f4a1b 100644 (file)
@@ -9,7 +9,9 @@
 #ifndef ALIHLTEVEPHOS_H
 #define ALIHLTEVEPHOS_H
 
+#include "AliESDEvent.h"
 #include "AliHLTEveCalo.h"
+
 class TEveElementList;
 class AliPHOSGeoUtils;
 
@@ -31,14 +33,19 @@ private:
   AliHLTEvePhos& operator = (const AliHLTEvePhos );
 
   /** inherited from AliHLTEveCalo */
-  TEveElementList * CreateElementList();
+  void CreateElementList();
   
   /** inherited from AliHLTEveCalo */
   void AddClusters(Float_t * pos, Int_t module, Float_t energy);
+  void AddClusters(Float_t * pos, Int_t module, Float_t energy, Int_t nCells);
 
   /** inherited from AliHLTEveCalo */
   void AddDigits(UShort_t fX, UShort_t fZ, Int_t module, Float_t energy);
 
+  Int_t GetClusters(AliESDEvent * event, TRefArray * clusters) { return event->GetPHOSClusters(clusters); }
+
+  void ProcessESDCluster(AliESDCaloCluster * cluster);
+
   AliPHOSGeoUtils * fGeoUtils;  //PHOS geometry
 
   ClassDef(AliHLTEvePhos, 0);
index a9606ba..7b9543e 100644 (file)
@@ -22,7 +22,7 @@
 #include "AliHLTHOMERBlockDesc.h"
 #include "TCanvas.h"
 #include "AliHLTEveBase.h"
-#include "AliEveHOMERManager.h"
+#include "AliEveHLTEventManager.h"
 #include "TEveManager.h"
 #include "TEvePointSet.h"
 #include "TColor.h"
@@ -33,7 +33,7 @@
 ClassImp(AliHLTEveTPC)
 
 AliHLTEveTPC::AliHLTEveTPC() : 
-  AliHLTEveBase(), 
+  AliHLTEveBase("TPC Clusters"), 
   fEveClusters(NULL),
   fEveColClusters(NULL),
   fNColorBins(15), 
@@ -82,7 +82,7 @@ void AliHLTEveTPC::ProcessBlock(AliHLTHOMERBlockDesc * block) {
     
     if(!fEveColClusters){
       fEveColClusters = CreatePointSetArray();
-      fEventManager->GetEveManager()->AddElement(fEveColClusters);
+      AddElement(fEveColClusters);
     } 
     
     ProcessClusters(block, fEveClusters, fEveColClusters);
@@ -143,7 +143,7 @@ void AliHLTEveTPC::UpdateElements() {
   if(fEveClusters) fEveClusters->ResetBBox();
 
   if (fHistQMax || fHistQMaxOverCharge || fHistCharge )
-    DrawHistograms();
+    // DrawHistograms();
  
   if(fCanvas) fCanvas->Update();
  
@@ -171,9 +171,9 @@ Int_t AliHLTEveTPC::ProcessClusters( AliHLTHOMERBlockDesc * block, TEvePointSet
   //See header file for documentation
 
 
-  if(!fHistCharge) fHistCharge = new TH1F("ClusterCharge","ClusterCharge",100,0,500);
-  if(!fHistQMax) fHistQMax = new TH1F("QMax","QMax",50,0,250);
-  if(!fHistQMaxOverCharge) fHistQMaxOverCharge = new TH1F("QMaxOverCharge","QMaxOverCharge",50,0,1);
+  // if(!fHistCharge) fHistCharge = new TH1F("ClusterCharge","ClusterCharge",100,0,500);
+  // if(!fHistQMax) fHistQMax = new TH1F("QMax","QMax",50,0,250);
+  // if(!fHistQMaxOverCharge) fHistQMaxOverCharge = new TH1F("QMaxOverCharge","QMaxOverCharge",50,0,1);
 
 
   Int_t   slice = block->GetSubDetector();
@@ -192,9 +192,9 @@ Int_t AliHLTEveTPC::ProcessClusters( AliHLTHOMERBlockDesc * block, TEvePointSet
        contCol->Fill(cos*sp->fX - sin*sp->fY, sin*sp->fX + cos*sp->fY, sp->fZ, sp->fCharge);
 
 
-      fHistCharge->Fill(sp->fCharge);
-      fHistQMax->Fill(sp->fQMax);
-      fHistQMaxOverCharge->Fill(((Float_t)sp->fQMax)/((Float_t)sp->fCharge));
+      // fHistCharge->Fill(sp->fCharge);
+      // fHistQMax->Fill(sp->fQMax);
+      // fHistQMaxOverCharge->Fill(((Float_t)sp->fQMax)/((Float_t)sp->fCharge));
     }
   }
 
index 7a21da4..eb60c73 100644 (file)
 /// @author Svein Lindal <slindal@fys.uio.no>
 /// @brief  TPC processor for the HLT EVE display
 
+#include "TClonesArray.h"
 #include "AliHLTEveTRD.h"
 #include "AliHLTHOMERBlockDesc.h"
 #include "TCanvas.h"
 #include "AliHLTEveBase.h"
-#include "AliEveHOMERManager.h"
+#include "AliEveHLTEventManager.h"
 #include "TEveManager.h"
 #include "TEvePointSet.h"
 #include "TColor.h"
@@ -34,7 +35,7 @@
 ClassImp(AliHLTEveTRD)
 
 AliHLTEveTRD::AliHLTEveTRD() : 
-  AliHLTEveBase(), 
+  AliHLTEveBase("TRD"), 
   fEveClusters(NULL),
   fEveColClusters(NULL),
   fNColorBins(15),
@@ -68,7 +69,7 @@ void AliHLTEveTRD::ProcessBlock(AliHLTHOMERBlockDesc * block) {
     
     if(!fEveColClusters){
       fEveColClusters = CreatePointSetArray();
-      fEventManager->GetEveManager()->AddElement(fEveColClusters);
+      AddElement(fEveColClusters);
     } 
     
     ProcessClusters(block, fEveColClusters);