Line data    Source code

       1             : #ifndef ALIHLTMUONROOTIFIERCOMPONENT_H
       2             : #define ALIHLTMUONROOTIFIERCOMPONENT_H
       3             : /* This file is property of and copyright by the ALICE HLT Project        *
       4             :  * ALICE Experiment at CERN, All rights reserved.                         *
       5             :  * See cxx source for full Copyright notice                               */
       6             : 
       7             : // $Id$
       8             : 
       9             : ///
      10             : /// @file   AliHLTMUONRootifierComponent.h
      11             : /// @author Artur Szostak <artursz@iafrica.com>
      12             : /// @date   29 Sep 2007
      13             : /// @brief  Component for converting dHLT raw data into ROOT objects.
      14             : ///
      15             : 
      16             : #include "AliHLTMUONProcessor.h"
      17             : 
      18             : class AliHLTMUONEvent;
      19             : class AliHLTMUONMansoTrack;
      20             : class AliHLTMUONTrack;
      21             : extern "C" struct AliHLTMUONMansoTrackStruct;
      22             : 
      23             : /**
      24             :  * \class AliHLTMUONRootifierComponent
      25             :  * \brief Converts dHLT raw data blocks into ROOT objects.
      26             :  *
      27             :  * This component class is used to convert all internal raw dHLT data blocks into
      28             :  * ROOT object that can be stored in '.root' files in a platform independant manner.
      29             :  * This can also make some of the analysis easier because the dHLT internal data
      30             :  * will be available in TObjects.
      31             :  *
      32             :  * <h2>General properties:</h2>
      33             :  *
      34             :  * Component ID: \b MUONRootifier <br>
      35             :  * Library: \b libAliHLTMUON.so <br>
      36             :  * Input Data Types:  kAliHLTAnyDataType = "*******:***" <br>
      37             :  * Output Data Types: AliHLTMUONConstants::RootifiedEventDataType() = "ROOTEVNT:MUON" <br>
      38             :  *
      39             :  * <h2>Mandatory arguments:</h2>
      40             :  * None.
      41             :  *
      42             :  * <h2>Optional arguments:</h2>
      43             :  * \li -warn_on_unexpected_block <br>
      44             :  *      This will cause the component to generate warnings when it receives data block
      45             :  *      types it does not know how to handle. Without this option the component only
      46             :  *      generates debug messages when they are compiled in. <br>
      47             :  * \li -dumponerror <br>
      48             :  *      This flag will cause the component to dump the data blocks it received if
      49             :  *      an error occurs during the processing of an event. <br>
      50             :  * \li -dumppath <i>path</i> <br>
      51             :  *      Allows one to specify the path in which to dump the received data blocks
      52             :  *      if an error occurs. <br>
      53             :  *
      54             :  * <h2>Standard configuration:</h2>
      55             :  * There is no special configuration for this component.
      56             :  *
      57             :  * <h2>Default CDB entries:</h2>
      58             :  * None.
      59             :  *
      60             :  * <h2>Performance:</h2>
      61             :  * A few milliseconds per event.
      62             :  *
      63             :  * <h2>Memory consumption:</h2>
      64             :  * A few MBytes.
      65             :  *
      66             :  * <h2>Output size:</h2>
      67             :  * A few kBytes.
      68             :  *
      69             :  * @ingroup alihlt_muon_components
      70             :  */
      71             : class AliHLTMUONRootifierComponent : public AliHLTMUONProcessor
      72             : {
      73             : public:
      74             : 
      75             :         AliHLTMUONRootifierComponent();
      76             :         virtual ~AliHLTMUONRootifierComponent();
      77             :         
      78             :         virtual const char* GetComponentID();
      79             : 
      80             :         virtual void GetInputDataTypes(AliHLTComponentDataTypeList& list);
      81             :         virtual AliHLTComponentDataType GetOutputDataType();
      82             :         virtual int GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);
      83             :         virtual void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier);
      84             : 
      85             :         virtual AliHLTComponent* Spawn();
      86             : 
      87             : protected:
      88             : 
      89             :         virtual int DoInit(int argc, const char** argv);
      90             :         virtual int DoDeinit();
      91             :         virtual int DoEvent(const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData);
      92             :         virtual bool IgnoreArgument(const char* arg) const;
      93             :         using AliHLTProcessor::DoEvent;
      94             :         
      95             : private:
      96             : 
      97             :         // Prevent copying of these objects.
      98             :         AliHLTMUONRootifierComponent(const AliHLTMUONRootifierComponent& /*object*/);
      99             :         AliHLTMUONRootifierComponent& operator = (const AliHLTMUONRootifierComponent& /*object*/);
     100             :         
     101             :         /**
     102             :          * This method creates a AliHLTMUONMansoTrack object from the track structure
     103             :          * and adds it to the dHLT event object.
     104             :          * \param event  The dHLT event object.
     105             :          * \param track  The track structure to convert and add to the event.
     106             :          */
     107             :         AliHLTMUONMansoTrack* AddTrack(AliHLTMUONEvent& event, const AliHLTMUONMansoTrackStruct& track);
     108             :         
     109             :         /**
     110             :          * This method creates a AliHLTMUONTrack object from the given track structure
     111             :          * and adds it to the dHLT event object.
     112             :          * \param event  The dHLT event object.
     113             :          * \param track  The track structure to convert and add to the event.
     114             :          */
     115             :         AliHLTMUONTrack* AddTrack(AliHLTMUONEvent& event, const AliHLTMUONTrackStruct& track);
     116             :         
     117             :         bool fWarnForUnexpecedBlock;  /// Flag indicating if we should log a warning if we got a block of an unexpected type.
     118             : 
     119           6 :         ClassDef(AliHLTMUONRootifierComponent, 0); // Converter component of dHLT raw data.
     120             : };
     121             : 
     122             : #endif // ALIHLTMUONROOTIFIERCOMPONENT_H