implemented AliPHOSClusterSelectionLogbackTask
authorhqvigsta <henrik.qvigstad@cern.ch>
Tue, 11 Feb 2014 12:18:03 +0000 (13:18 +0100)
committerhqvigsta <henrik.qvigstad@cern.ch>
Tue, 11 Feb 2014 13:22:17 +0000 (14:22 +0100)
PWGGA/PHOSTasks/ClusterSelection/AliPHOSClusterSelectionLogbackTask.cxx
PWGGA/PHOSTasks/ClusterSelection/AliPHOSClusterSelectionLogbackTask.h

index ff6e978..7105bd5 100644 (file)
@@ -29,101 +29,149 @@ ClassImp(AliPHOSClusterSelectionLogbackTask);
 
 AliPHOSClusterSelectionLogbackTask::AliPHOSClusterSelectionLogbackTask(const char* name = "AliPHOSClusterSelectionLogbackTask")
   : AliPHOSClusterSelectionTask(name),
-    fClusterArrayList(0x0),
-    fSelectionArrayMapLists(0x0)
+    fMapOfEventLists(0x0)
 {
-  
+  fMapOfEventLists = new TMap;
+  fMapOfEventLists->SetOwnerValue();
 }
 
 AliPHOSClusterSelectionLogbackTask::~AliPHOSClusterSelectionLogbackTask()
 {
-  delete fClusterArrayList;
-  delete fSelectionArrayMap;
+  delete fMapOfEventLists
 }
   
 void AliPHOSClusterSelectionLogbackTask::UserCreateOutputObjects()
 {
   return;
 }
+
 void AliPHOSClusterSelectionLogbackTask::UserExec(Option_t *option)
 {
   AliPHOSClusterSelectionTask::UserExec(option);
   AliVEvent* event = InputEvent();
 
-  // initialize fClusterArrayLists
-  if( !fClusterArrayLists ) {
-    fClusterArrayLists = new TMap;
-    fClusterArrayLists->SetOwnerValue();
-  }
-  // initialize fSelectionArrayMapLists
-  if( !fSelectionArrayMapLists ) {
-    fSelectionArrayMapLists = new TMap;
-    fSelectionArrayMapLists->SetOwnerValue();
+  // initialize fMapOfEventLists
+  if( !fMapOfEventLists ) {
+    fMapOfEventLists = new TMap;
+    fMapOfEventLists->SetOwnerValue();
   }
 }
 
-TObjArray* AliPHOSClusterSelectionLogbackTask::GetPHOSClustersLogback(const AliPHOSEventSelection* eventSelection, UInt_t eventBacklogIndex, const AliPHOSClusterSelection* clusterSelection) const
+TObjArray* AliPHOSClusterSelectionLogbackTask::GetPHOSClustersLogback(const AliPHOSEventSelection* eventSelection, UInt_t eventLogbackIndex, const AliPHOSClusterSelection* clusterSelection) const
 {
   // Gives an array of clusters for an given event and cluster selection, 
   // provided that such an selection has been logged.
-  // eventBacklogIndex - How many logged events to go back in time, must be an positive integer 0,1,2... 
+  // eventLogbackIndex - How many logged events to go back in time, must be an positive integer 0,1,2...
+  // , an clusterSelection is optional.
+
+  TObject* objEventList = fMapOfEventLists->GetValue(eventSelection);
+  TList* eventList = dynamic_cast<TList*> ( objEventList );
+  if(!eventList)
+    return 0x0;
   
-  if( clusterSelection ) {
-    TObject* objEventList = fSelectionArrayMapLists->GetValue(eventSelection);
-    TList* eventList = dynamic_cast<TList*> ( objEventList );
-    if(!eventList)
-      return 0x0;
-
-    TObject* objSelMap = eventList->At(eventBacklogIndex);
-    TMap* selMap = dynamic_cast<TMap*> ( objSelMap );
-    if(!semMap)
-      return 0x0;
-    
-    TObject* objCluArray = selMap->GetValue(clusterSelection);
-    TObjArray* cluArray = dynamic_cast<TObjArray*> ( objCluArray );
-    return cluArray;
-  }
-  else { // i.e. !clusterSelection
-    TObject* objEventList = fClusterArrayLists->GetValue(eventSelection);
-    TList* eventList = dynamic_cast<TList*> ( objEventList );
-    if(!eventList)
-      return 0x0;
-    
-    TObject* objCluArray = eventList->At(eventBacklogIndex);
-    TObjArray* cluArray = dynamic_cast<TObjArray*> ( objCluArray );
-    return cluArray;
-  }
+  // eventList is a list of eventArray
+  TObject* objEventArray = eventList->At(eventLogbackIndex);
+  TObjArray* eventArray = dynamic_cast<TObjArray*> ( objEventArray );
+  if( !eventArray )
+    return 0x0;
+  
+  // fMapOfEventLists[eventSelection][eventLogbackIndex][0]
+  TObject* objEventClusters = eventArray->At(kCluArray);
+  TObjArray* eventClusters = dynamic_cast<TObjArray*> ( objEventClusters );
+  if( !eventClusters )
+    AliFatal(Form("eventArray should always contain and TObjArray in index %i", kCluArray));
+  
+  // fMapOfEventLists[eventSelection][eventLogbackIndex][1]
+  TObject* objSelectionMap = eventArray->At(kSelMap);
+  TMap* selectionMap = dynamic_cast<TMap*> ( objSelectionMap );
+  if( !selectionMap )
+    AliFatal(Form("eventArray should always contain and TMap in index 0", kSelMap));
+
+  
+  // For the given eventSelection and eventBacklog, we should now have 
+  // eventClusters and selectionMap !!!
+  // which TObjArray we return to the user depends on if an clusterSelection is specified
+  if(clusterSelection) {
+    TObject* objSelectionArray = selectionMap->GetValue(clusterSelection);
+    TObjArray* selectionArray = dynamic_cast<TObjArray*> ( objSelectionArray );
+    return selectionArray;
+  } 
+  else
+    return eventClusters;
 }
 
 
 void AliPHOSClusterSelectionLogbackTask::LogEvent(const AliPHOSEventSelection* eventSelection, int nEventsToLog)
 {
-  // Lists:
-  TObject* objCluEventList = fClusterArrayLists->GetValue(eventSelection);
-  TList* cluEventList = dynamic_cast<TList*> ( objCluEventList );
-  TObject* objSelEventList = fSelectionArrayMapLists->GetValue(eventSelection);
-  Tlist* selEventList = dynamic_cast<TList*> ( objSelEventList );
-
-  if( !cluEventList || !selEventList) { // if either don't exist
-    if( ! (!cluEventList && !selEventList) )
-      AliFatal("neither or both should exist!");
-    // else, initilize
-    cluEventList = new TList;
-    cluEventList->SetOwner();
-    fClusterArrayLists->Add(eventSelection, cluEventList); // key, value
-    
-    selEventList = new TList;
-    selEventList->SetOwner();
-    fSelectionArrayMapLists->Add(eventSelection, selEventList); // key, value
+  if( nEventsToLog < 1) {
+    AliError("nEventsToLog needs to be >0, or logging does not make sense");
+    return;
   }
 
-  // Log Clusters
-  for(int index = 0; index < fClusters->GetEntriesFast; ++index) {
-    //TODO
+  // Make a copy of the cluster array
+  TObjArray* newCluArray = new TObjArray(fClusters->GetEntriesFast());
+  newCluArray->SetOwner();
+  for(int iclu=0; iclu < fClusters.GetSize(); ++iclu) {
+    AliPHOSLogbackCluster* clu = new AliPHOSLogbackCluster(fClusters->At(iclu));
+    newCluArray->Add(clu);
   }
-
-  // Log Selection Maps
-  // TODO
+  
+  // Make a copy of the selection map
+  // and referance to the new array of clusters
+  TMap* newMap = new TMap;
+  newMap->SetOwnerValue();
+  TMapIter* iter = (TMapIter*) fSelectionMap->MakeIterator();
+  while((TObject* key = iter->Next())){ // Loop over Cluster Selections 
+    TRefArray* oldSelArray = dynamic_cast<TRefArray*> (fSelectionMap->GetValue(key));
+    TObjArray* newSelArray = new TObjArray(oldSelArray->GetEntriesFast());
+    newSelArray->SetOwner(false);
+    // Referance the new selection array to the new clusters
+    for(int selInd=0; selInd<oldSelArray->GetEntriesFast(); ++selInd){
+      bool matched = false; // false untill mached
+      for(int cluInd=0; cluInd<fClusters->GetEntriesFast(); ++cluInd){
+       TObject* oldSelCluster = oldSelArray->At(selInd);
+       TObject* oldCluster = fClusters->At(cluInd);
+       if(oldSelCluster == oldCluster) { // if old selection matches old cluster,
+         // then new selection should match cluster in the same index as old cluster
+         // at the same old selection index
+         if( newSelArray->At(cluInd) )
+           AliError("should be empty!");
+         newSelArray->Add(newCluArray->At(cluInd), selInd);
+
+         matched = true;
+         break;
+       }
+      }
+      if( ! matched )
+       AliError("Should have found a match!");
+    }
+    
+    if( newSelArray->GetEntriesFast() != newSelArray->GetEntries()
+       || newSelArray->GetEntriesFast() != oldSelArray->GetEntriesFast() )
+      AliError("Entries should match!");
+    
+    newMap->Add(key, newSelArray);
+  }// endo of creation of new selMap.
+
+  //make an eventArray to hold clusters and maps
+  TObjArray* eventArray = new TObjArray(kSize);
+  eventArray->SetOwner();
+  eventArray->AddAt(newCluArray, kCluArray);
+  eventArray->AddAt(newMap, kSelMap);
+  // at to list of events
+  TObject* objEventList = fMapOfEventLists->GetValue(eventSelection);
+  TList* eventList = dynamic_cast<TList*> ( objEventList );
+  if(!eventList) {
+    eventList = new TList;
+    eventList->SetOwner();
+  }
+  eventList->AddFist(eventArray);
+  
+  
+  // remove old events
+  while( cluEventList->At(nEventsToLog) && nEventsToLog )
+    eventList->RemoveLast();
 }
 
 
index 1ad6cb4..a3138f2 100644 (file)
@@ -21,7 +21,7 @@ class TObjArray;
 
 #include "AliPHOSClusterSelectionTask.h"
 
-class AliPHOSClusterSelectionLogbackTask : AliPHOSClusterSelectionTask {
+class AliPHOSClusterSelectionLogbackTask : public AliPHOSClusterSelectionTask {
  public:
   AliPHOSClusterSelectionLogbackTask(const char* name = "AliPHOSClusterSelectionLogbackTask");
   virtual ~AliPHOSClusterSelectionLogbackTask();
@@ -30,7 +30,7 @@ class AliPHOSClusterSelectionLogbackTask : AliPHOSClusterSelectionTask {
   virtual void   UserExec(Option_t *option);
   /* virtual void   Terminate(Option_t *); */
 
-  TObjArray* GetPHOSClustersLogback(const AliPHOSEventSelection* eventSelection, UInt_t eventBacklogIndex, const AliPHOSClusterSelection* clusterSelection=0) const;
+  TObjArray* GetPHOSClustersLogback(const AliPHOSEventSelection* eventSelection, UInt_t eventLogbackIndex, const AliPHOSClusterSelection* clusterSelection=0) const;
 
   void LogEvent(const AliPHOSEventSelection* selection, UInt_t nEventsToLog);
 
@@ -40,10 +40,8 @@ class AliPHOSClusterSelectionLogbackTask : AliPHOSClusterSelectionTask {
   AliPHOSClusterSelectionLogbackTask(const AliPHOSClusterSelectionLogbackTask&); // not implemented
   AliPHOSClusterSelectionLogbackTask& operator=(const AliPHOSClusterSelectionLogbackTask&); // not implemented
 
-  TMap* fClusterArrayLists; // Maps: EventSelection -> List, of ObjArray of Clusters
-  TMap* fSelectionArrayMapLists; // Maps: EventSelection -> List, of Cluster Selection Maps
-
-  TMap* fCurrentClusterSelectionMap; // Maps: ClusterSelection -> Selection Bits
+  TMap* fMapOfEventLists; // fMapOfEventLists: EventSelection -> EventList, EventList of EventArray in (CluArray, SelMap), SelMap: CluSelection -> CluArray.
+  enum EventArrayIndex { kCluArray, kSelMap, kSize };
 
   ClassDef(AliPHOSClusterSelectionLogbackTask, 1);
 };