Adding processing component to translate dHLT internal raw data blocks into ROOT...
authorszostak <szostak@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 29 Sep 2007 12:56:26 +0000 (12:56 +0000)
committerszostak <szostak@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 29 Sep 2007 12:56:26 +0000 (12:56 +0000)
HLT/MUON/HLTMUONLinkDef.h
HLT/MUON/OfflineInterface/AliHLTMUONRootifierComponent.cxx [new file with mode: 0644]
HLT/MUON/OfflineInterface/AliHLTMUONRootifierComponent.h [new file with mode: 0644]
HLT/libAliHLTMUON.pkg

index 19d2ad5..28f4728 100644 (file)
 #pragma link C++ class AliHLTMUONTriggerReconstructorComponent+;
 #pragma link C++ class AliHLTMUONHitReconstructorComponent+;
 #pragma link C++ class AliHLTMUONMansoTrackerFSMComponent+;
+#pragma link C++ class AliHLTMUONRecHit+;
+#pragma link C++ class AliHLTMUONRecHit::Channel+;
+#pragma link C++ class AliHLTMUONTriggerRecord+;
+#pragma link C++ class AliHLTMUONMansoTrack+;
+#pragma link C++ class AliHLTMUONRootifierComponent+;
+
+// The following is temporary:
+#pragma link C++ class AliHLTMUONEvent+;
 
 #endif // __CINT__
diff --git a/HLT/MUON/OfflineInterface/AliHLTMUONRootifierComponent.cxx b/HLT/MUON/OfflineInterface/AliHLTMUONRootifierComponent.cxx
new file mode 100644 (file)
index 0000000..c108eef
--- /dev/null
@@ -0,0 +1,423 @@
+/**************************************************************************
+ * This file is property of and copyright by the ALICE HLT Project        * 
+ * All rights reserved.                                                   *
+ *                                                                        *
+ * Primary Authors:                                                       *
+ *   Artur Szostak <artursz@iafrica.com>                                  *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          * 
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+/**
+ * @file   AliHLTMUONRootifierComponent.cxx
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Implementation of the AliHLTMUONRootifierComponent component.
+ */
+
+#include "AliHLTMUONRootifierComponent.h"
+#include "AliHLTMUONConstants.h"
+#include "AliHLTMUONUtils.h"
+#include "AliHLTMUONDataBlockReader.h"
+#include "AliHLTMUONRecHit.h"
+#include "AliHLTMUONTriggerRecord.h"
+#include "AliHLTMUONMansoTrack.h"
+#include "TObjArray.h"
+#include <cassert>
+
+namespace
+{
+       // The global object used for automatic component registration.
+       // Note DO NOT use this component for calculation!
+       AliHLTMUONRootifierComponent gAliHLTMUONRootifierComponent;
+}
+
+ClassImp(AliHLTMUONEvent);
+ClassImp(AliHLTMUONRootifierComponent);
+
+
+AliHLTMUONRootifierComponent::AliHLTMUONRootifierComponent() :
+       AliHLTProcessor()
+{
+}
+
+
+AliHLTMUONRootifierComponent::~AliHLTMUONRootifierComponent()
+{
+}
+
+
+int AliHLTMUONRootifierComponent::DoInit(int argc, const char** argv)
+{
+       return 0;
+}
+
+
+int AliHLTMUONRootifierComponent::DoDeinit()
+{
+       return 0;
+}
+
+
+const char* AliHLTMUONRootifierComponent::GetComponentID()
+{
+       return "MUONRootifier";
+}
+
+
+AliHLTComponentDataType AliHLTMUONRootifierComponent::GetOutputDataType()
+{
+       return kAliHLTAnyDataType;
+}
+
+
+void AliHLTMUONRootifierComponent::GetInputDataTypes(
+               vector<AliHLTComponentDataType>& list
+       )
+{
+       list.push_back(kAliHLTAnyDataType);
+}
+
+
+void AliHLTMUONRootifierComponent::GetOutputDataSize(
+               unsigned long& constBase, double& inputMultiplier
+       )
+{
+       constBase = 10000;
+       inputMultiplier = 5;
+}
+
+
+AliHLTComponent* AliHLTMUONRootifierComponent::Spawn()
+{
+       return new AliHLTMUONRootifierComponent();
+}
+
+
+int AliHLTMUONRootifierComponent::DoEvent(
+               const AliHLTComponentEventData& evtData,
+               AliHLTComponentTriggerData& trigData
+       )
+{
+       AliHLTMUONEvent event(evtData.fEventID);
+
+       // First process the blocks of reconstructed hits and trigger records.
+       for (int i = 0; i < GetNumberOfInputBlocks(); i++)
+       {
+               const AliHLTComponentBlockData* block = GetInputBlock(i);
+               assert( block != NULL );
+               if (block->fDataType == AliHLTMUONConstants::RecHitsBlockDataType())
+               {
+                       AliHLTUInt8_t* ptr = reinterpret_cast<AliHLTUInt8_t*>(block->fPtr);
+                       ptr += block->fOffset;
+                       AliHLTMUONRecHitsBlockReader inblock(ptr, block->fSize);
+                       if (not inblock.BufferSizeOk())
+                       {
+                               size_t headerSize = sizeof(AliHLTMUONRecHitsBlockReader::HeaderType);
+                               if (block->fSize < headerSize)
+                               {
+                                       HLTError("Received a reconstructed hits data block with a size of %d bytes,"
+                                               " which is smaller than the minimum valid header size of %d bytes."
+                                               " The block must be corrupt.",
+                                               block->fSize, headerSize
+                                       );
+                                       continue;
+                               }
+                               
+                               size_t expectedWidth = sizeof(AliHLTMUONRecHitsBlockReader::ElementType);
+                               if (inblock.CommonBlockHeader().fRecordWidth != expectedWidth)
+                               {
+                                       HLTError("Received a reconstructed hits data block with a record"
+                                               " width of %d bytes, but the expected value is %d bytes."
+                                               " The block might be corrupt.",
+                                               block->fSize, headerSize
+                                       );
+                                       continue;
+                               }
+                               
+                               HLTError("Received a reconstructed hits data block with a size of %d bytes,"
+                                       " but the block header claims the block should be %d bytes."
+                                       " The block might be corrupt.",
+                                       block->fSize, inblock.BytesUsed()
+                               );
+                               continue;
+                       }
+                       
+                       // Decode the source DDL from the specification bits.
+                       Int_t sourceDDL = -1;
+                       bool ddl[22];
+                       AliHLTMUONUtils::UnpackSpecBits(block->fSpecification, ddl);
+                       for (int k = 0; k < 22; k++)
+                       {
+                               if (ddl[k])
+                               {
+                                       if (sourceDDL == -1)
+                                       {
+                                               sourceDDL = k+1;
+                                       }
+                                       else
+                                       {
+                                               HLTWarning("The input data block %d contains"
+                                                       " data from multiple DDL sources.", i
+                                               );
+                                       }
+                               }
+                       }
+                       if (sourceDDL > 20)
+                       {
+                               HLTWarning("The source DDL for input data block %d is %d."
+                                       " The expected range for the DDL is [1..20].",
+                                       i, sourceDDL
+                               );
+                       }
+                       
+                       for (AliHLTUInt32_t n = 0; n < inblock.Nentries(); n++)
+                       {
+                               const AliHLTMUONRecHitStruct& h = inblock[n];
+                               //AliHLTMUONRecHit rh(h.fX, h.fY, h.fZ, sourceDDL);
+                               //PushBack(&rh, "ROOTHITS", "MUON");
+                               event.Add(new AliHLTMUONRecHit(h.fX, h.fY, h.fZ, sourceDDL));
+                       }
+               }
+               else if (block->fDataType == AliHLTMUONConstants::TriggerRecordsBlockDataType())
+               {
+                       AliHLTUInt8_t* ptr = reinterpret_cast<AliHLTUInt8_t*>(block->fPtr);
+                       ptr += block->fOffset;
+                       AliHLTMUONTriggerRecordsBlockReader inblock(ptr, block->fSize);
+                       if (not inblock.BufferSizeOk())
+                       {
+                               size_t headerSize = sizeof(AliHLTMUONTriggerRecordsBlockReader::HeaderType);
+                               if (block->fSize < headerSize)
+                               {
+                                       HLTError("Received a trigger records data block with a size of %d bytes,"
+                                               " which is smaller than the minimum valid header size of %d bytes."
+                                               " The block must be corrupt.",
+                                               block->fSize, headerSize
+                                       );
+                                       continue;
+                               }
+                               
+                               size_t expectedWidth = sizeof(AliHLTMUONTriggerRecordsBlockReader::ElementType);
+                               if (inblock.CommonBlockHeader().fRecordWidth != expectedWidth)
+                               {
+                                       HLTError("Received a trigger records data block with a record"
+                                               " width of %d bytes, but the expected value is %d bytes."
+                                               " The block might be corrupt.",
+                                               block->fSize, headerSize
+                                       );
+                                       continue;
+                               }
+                               
+                               HLTError("Received a trigger records data block with a size of %d bytes,"
+                                       " but the block header claims the block should be %d bytes."
+                                       " The block might be corrupt.",
+                                       block->fSize, inblock.BytesUsed()
+                               );
+                               continue;
+                       }
+                       
+                       // Decode the source DDL from the specification bits.
+                       Int_t sourceDDL = -1;
+                       bool ddl[22];
+                       AliHLTMUONUtils::UnpackSpecBits(block->fSpecification, ddl);
+                       for (int k = 0; k < 22; k++)
+                       {
+                               if (ddl[k])
+                               {
+                                       if (sourceDDL == -1)
+                                       {
+                                               sourceDDL = k+1;
+                                       }
+                                       else
+                                       {
+                                               HLTWarning("The input data block %d contains"
+                                                       " data from multiple DDL sources.", i
+                                               );
+                                       }
+                               }
+                       }
+                       if (sourceDDL < 21 or sourceDDL > 22)
+                       {
+                               HLTWarning("The source DDL for input data block %d is %d."
+                                       " The expected range for the DDL is [21..22].",
+                                       i, sourceDDL
+                               );
+                       }
+                       
+                       for (AliHLTUInt32_t n = 0; n < inblock.Nentries(); n++)
+                       {
+                               const AliHLTMUONTriggerRecordStruct& t = inblock[n];
+                               
+                               AliHLTMUONParticleSign sign;
+                               bool hitset[4];
+                               AliHLTMUONUtils::UnpackTriggerRecordFlags(
+                                               t.fFlags, sign, hitset
+                                       );
+                       
+                               AliHLTMUONTriggerRecord* tr = new AliHLTMUONTriggerRecord(
+                                               t.fId, sign, t.fPx, t.fPy, t.fPz, sourceDDL
+                                       );
+                               for (int k = 0; k < 4; k++)
+                                       tr->SetHit(k+11, t.fHit[k].fX, t.fHit[k].fY, t.fHit[k].fZ);
+                               event.Add(tr);
+                       }
+               }
+               else
+               {
+                       // TODO: ignore for now, but should log an optional message.
+               }
+       }
+       
+       // Now we can look for tracks to add. We needed the ROOT trigger records
+       // and reco hits created before we can create track objects.
+       for (int i = 0; i < GetNumberOfInputBlocks(); i++)
+       {
+               const AliHLTComponentBlockData* block = GetInputBlock(i);
+               assert( block != NULL );
+               if (block->fDataType == AliHLTMUONConstants::MansoTracksBlockDataType())
+               {
+                       AliHLTUInt8_t* ptr = reinterpret_cast<AliHLTUInt8_t*>(block->fPtr);
+                       ptr += block->fOffset;
+                       AliHLTMUONMansoTracksBlockReader inblock(ptr, block->fSize);
+                       if (not inblock.BufferSizeOk())
+                       {
+                               size_t headerSize = sizeof(AliHLTMUONMansoTracksBlockReader::HeaderType);
+                               if (block->fSize < headerSize)
+                               {
+                                       HLTError("Received a Manso tracks data block with a size of %d bytes,"
+                                               " which is smaller than the minimum valid header size of %d bytes."
+                                               " The block must be corrupt.",
+                                               block->fSize, headerSize
+                                       );
+                                       continue;
+                               }
+                               
+                               size_t expectedWidth = sizeof(AliHLTMUONMansoTracksBlockReader::ElementType);
+                               if (inblock.CommonBlockHeader().fRecordWidth != expectedWidth)
+                               {
+                                       HLTError("Received a Manso tracks data block with a record"
+                                               " width of %d bytes, but the expected value is %d bytes."
+                                               " The block might be corrupt.",
+                                               block->fSize, headerSize
+                                       );
+                                       continue;
+                               }
+                               
+                               HLTError("Received a Manso tracks data block with a size of %d bytes,"
+                                       " but the block header claims the block should be %d bytes."
+                                       " The block might be corrupt.",
+                                       block->fSize, inblock.BytesUsed()
+                               );
+                               continue;
+                       }
+                       
+                       for (AliHLTUInt32_t n = 0; n < inblock.Nentries(); n++)
+                       {
+                               const AliHLTMUONMansoTrackStruct& t = inblock[n];
+                               
+                               AliHLTMUONParticleSign sign;
+                               bool hitset[4];
+                               AliHLTMUONUtils::UnpackMansoTrackFlags(
+                                               t.fFlags, sign, hitset
+                                       );
+                               
+                               // Try find the trigger record in 'event'.
+                               const AliHLTMUONTriggerRecord* trigrec = NULL;
+                               for (Int_t k = 0; k < event.Array().GetEntriesFast(); k++)
+                               {
+                                       if (event.Array()[k]->IsA() != AliHLTMUONTriggerRecord::Class())
+                                               continue;
+                                       const AliHLTMUONTriggerRecord* tk =
+                                               static_cast<const AliHLTMUONTriggerRecord*>(event.Array()[k]);
+                                       if (tk->Id() == t.fTrigRec)
+                                       {
+                                               trigrec = tk;
+                                               break;
+                                       }
+                               }
+                               
+                               // Now try find the hits in 'event'.
+                               // If they cannot be found then create new ones.
+                               const AliHLTMUONRecHit* hit7 = NULL;
+                               const AliHLTMUONRecHit* hit8 = NULL;
+                               const AliHLTMUONRecHit* hit9 = NULL;
+                               const AliHLTMUONRecHit* hit10 = NULL;
+                               for (Int_t k = 0; k < event.Array().GetEntriesFast(); k++)
+                               {
+                                       if (event.Array()[k]->IsA() != AliHLTMUONRecHit::Class())
+                                               continue;
+                                       const AliHLTMUONRecHit* h =
+                                               static_cast<const AliHLTMUONRecHit*>(event.Array()[k]);
+                                       
+                                       if (hitset[0] and h->X() == t.fHit[0].fX and h->Y() == t.fHit[0].fY
+                                           and h->Z() == t.fHit[0].fZ)
+                                       {
+                                               hit7 = h;
+                                       }
+                                       if (hitset[1] and h->X() == t.fHit[1].fX and h->Y() == t.fHit[1].fY
+                                           and h->Z() == t.fHit[1].fZ)
+                                       {
+                                               hit8 = h;
+                                       }
+                                       if (hitset[2] and h->X() == t.fHit[2].fX and h->Y() == t.fHit[2].fY
+                                           and h->Z() == t.fHit[2].fZ)
+                                       {
+                                               hit9 = h;
+                                       }
+                                       if (hitset[3] and h->X() == t.fHit[3].fX and h->Y() == t.fHit[3].fY
+                                           and h->Z() == t.fHit[3].fZ)
+                                       {
+                                               hit10 = h;
+                                       }
+                               }
+                               AliHLTMUONRecHit* newhit;
+                               if (hitset[0] and hit7 == NULL)
+                               {
+                                       newhit = new AliHLTMUONRecHit(t.fHit[0].fX, t.fHit[0].fY, t.fHit[0].fZ);
+                                       event.Add(newhit);
+                                       hit7 = newhit;
+                               }
+                               if (hitset[1] and hit8 == NULL)
+                               {
+                                       newhit = new AliHLTMUONRecHit(t.fHit[1].fX, t.fHit[1].fY, t.fHit[1].fZ);
+                                       event.Add(newhit);
+                                       hit8 = newhit;
+                               }
+                               if (hitset[2] and hit9 == NULL)
+                               {
+                                       newhit = new AliHLTMUONRecHit(t.fHit[2].fX, t.fHit[2].fY, t.fHit[2].fZ);
+                                       event.Add(newhit);
+                                       hit9 = newhit;
+                               }
+                               if (hitset[3] and hit10 == NULL)
+                               {
+                                       newhit = new AliHLTMUONRecHit(t.fHit[3].fX, t.fHit[3].fY, t.fHit[3].fZ);
+                                       event.Add(newhit);
+                                       hit10 = newhit;
+                               }
+                       
+                               AliHLTMUONMansoTrack* tr = new AliHLTMUONMansoTrack(
+                                               t.fId, sign, t.fPx, t.fPy, t.fPz, t.fChi2,
+                                               trigrec, hit7, hit8, hit9, hit10
+                                       );
+                               event.Add(tr);
+                       }
+               }
+               else
+               {
+                       // TODO: ignore for now, but should log an optional message.
+               }
+       }
+       
+       PushBack(&event, "ROOTEVNT", "MUON");
+       
+       return 0;
+}
diff --git a/HLT/MUON/OfflineInterface/AliHLTMUONRootifierComponent.h b/HLT/MUON/OfflineInterface/AliHLTMUONRootifierComponent.h
new file mode 100644 (file)
index 0000000..790a903
--- /dev/null
@@ -0,0 +1,89 @@
+#ifndef ALIHLTMUONROOTIFIERCOMPONENT_H
+#define ALIHLTMUONROOTIFIERCOMPONENT_H
+/* This file is property of and copyright by the ALICE HLT Project        *
+ * ALICE Experiment at CERN, All rights reserved.                         *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+/**
+ * @file   AliHLTMUONRootifierComponent.h
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Component for converting dHLT raw data into ROOT objects.
+ */
+
+#include "AliHLTProcessor.h"
+
+// Temporary solution for grouping together objects for the same event.
+#include "TObjArray.h"
+class AliHLTMUONEvent : public TObject
+{
+public:
+
+       AliHLTMUONEvent(AliHLTEventID_t eventId = AliHLTEventID_t(-1))
+               : fEventId(eventId)
+       {
+               fArray.SetOwner(kTRUE);
+       }
+       
+       virtual ~AliHLTMUONEvent() {}
+       
+       AliHLTEventID_t EventID() const { return fEventId; }
+       const TObjArray& Array() const { return fArray; }
+       
+       // Takes ownership of the object.
+       void Add(TObject* obj) { fArray.Add(obj); }
+       
+       virtual void Print(Option_t* option = NULL) const
+       {
+               cout << "################## EVENT: " << fEventId << " ##################" << endl;
+               for (Int_t i = 0; i < fArray.GetEntriesFast(); i++)
+                       if (fArray[i] != NULL) fArray[i]->Print(option);
+       }
+
+private:
+
+       AliHLTEventID_t fEventId;
+       TObjArray fArray;
+       
+       ClassDef(AliHLTMUONEvent, 1); // Container class for dHLT event results.
+};
+
+
+/**
+ * Converts dHLT raw data blocks into ROOT objects.
+ */
+class AliHLTMUONRootifierComponent : public AliHLTProcessor
+{
+public:
+
+       AliHLTMUONRootifierComponent();
+       virtual ~AliHLTMUONRootifierComponent();
+       
+       int DoEvent(const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData);
+       
+       virtual const char* GetComponentID();
+
+       virtual void GetInputDataTypes(vector<AliHLTComponentDataType>& list);
+       virtual AliHLTComponentDataType GetOutputDataType();
+
+       virtual void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier);
+
+       virtual AliHLTComponent* Spawn();
+
+protected:
+
+       virtual int DoInit(int argc, const char** argv);
+       virtual int DoDeinit();
+       
+private:
+
+       // Prevent copying of these objects.
+       AliHLTMUONRootifierComponent(const AliHLTMUONRootifierComponent& /*object*/);
+       AliHLTMUONRootifierComponent& operator = (const AliHLTMUONRootifierComponent& /*object*/);
+
+       ClassDef(AliHLTMUONRootifierComponent, 0); // Converter component of dHLT raw data.
+};
+
+#endif // ALIHLTMUONROOTIFIERCOMPONENT_H
index 5b312c2..466e8b9 100644 (file)
@@ -8,9 +8,13 @@ include $(MODDIR)/hlt.conf
 CLASS_HDRS :=  OfflineInterface/AliHLTMUONAgent.h \
                OfflineInterface/AliHLTMUONTriggerRecordsSource.h \
                OfflineInterface/AliHLTMUONRecHitsSource.h \
+               OfflineInterface/AliHLTMUONRootifierComponent.h \
                OnlineAnalysis/AliHLTMUONTriggerReconstructorComponent.h \
                OnlineAnalysis/AliHLTMUONHitReconstructorComponent.h \
-               OnlineAnalysis/AliHLTMUONMansoTrackerFSMComponent.h
+               OnlineAnalysis/AliHLTMUONMansoTrackerFSMComponent.h \
+               AliHLTMUONRecHit.h \
+               AliHLTMUONTriggerRecord.h \
+               AliHLTMUONMansoTrack.h
 
 # Sources that are not ROOT classes:
 MODULE_SRCS := $(CLASS_HDRS:.h=.cxx) \