LCOV - code coverage report
Current view: top level - HLT/TPCLib - AliHLTTPCDigitReaderUnpacked.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1 2 50.0 %
Date: 2016-06-14 17:26:59 Functions: 1 6 16.7 %

          Line data    Source code
       1             : // XEmacs -*-C++-*-
       2             : // @(#) $Id$
       3             : 
       4             : #ifndef ALIHLTTPCDIGITREADERUNPACKED_H
       5             : #define ALIHLTTPCDIGITREADERUNPACKED_H
       6             : 
       7             : //* This file is property of and copyright by the ALICE HLT Project        * 
       8             : //* ALICE Experiment at CERN, All rights reserved.                         *
       9             : //* See cxx source for full Copyright notice                               *
      10             : 
      11             : /** @file   AliHLTTPCDigitReaderUnpacked.h
      12             :     @author Timm Steinbeck, Jochen Thaeder, Matthias Richter
      13             :     @date   
      14             :     @brief  A digit reader implementation for unpacked TPC data.
      15             : */
      16             : 
      17             : #include "AliHLTTPCDigitReader.h"
      18             : #include "AliHLTTPCDigitData.h"
      19             : class AliHLTTPCMapping;
      20             : class AliHLTTPCDigitRowData;
      21             : 
      22             : /**
      23             :  * @class AliHLTTPCDigitReaderUnpacked
      24             :  * A digit reader implementation for unpacked TPC data.
      25             :  * @ingroup alihlt_tpc
      26             :  */
      27             : class AliHLTTPCDigitReaderUnpacked : public AliHLTTPCDigitReader{
      28             : public:
      29             :   /** standard constructor */
      30             :   AliHLTTPCDigitReaderUnpacked();
      31             :   /** destructor */
      32             :   virtual ~AliHLTTPCDigitReaderUnpacked();
      33             : 
      34             :   /**
      35             :    * Init the reader
      36             :    * @param ptr    pointer to input buffer
      37             :    * @param size   size of the input buffer
      38             :    * @param patch  readout partition
      39             :    * @param slice  sector no
      40             :    */  
      41             :   int InitBlock(void* ptr,unsigned long size, Int_t patch, Int_t slice);
      42             :   using AliHLTTPCDigitReader::InitBlock;
      43             : 
      44             :   /**
      45             :    * place the reader at the next signal
      46             :    * @return 1 if there was a nest signal, 0 if not
      47             :    */
      48             :   bool NextSignal();
      49             : 
      50             :   /**
      51             :    * Get row number of the current signal
      52             :    * @return row number of the current signal
      53             :    */
      54             :   int GetRow();
      55             : 
      56             :   /**
      57             :    * Get pad number of the current signal
      58             :    * @return pad number of the current signal
      59             :    */
      60             :   int GetPad();
      61             : 
      62             :   /**
      63             :    * Get signal
      64             :    * @return ADC signal
      65             :    */
      66             :   int GetSignal();
      67             : 
      68             :   /**
      69             :    * Get time of the current signal
      70             :    * @return time of the current signal
      71             :    */
      72             :   int GetTime();
      73             :   
      74             :   bool NextChannel();
      75             :   int NextBunch();
      76             :   AliHLTUInt32_t GetAltroBlockHWaddr() const;
      77             :   int GetBunchSize();
      78             :   const UInt_t* GetSignals();
      79             :   AliHLTTPCDigitData GetSortedDigit();
      80             :   Int_t GetSortedTime();    
      81             :   Int_t GetSortedSignal();
      82             :   Int_t GetSortedPad() const;
      83             :   Int_t GetSortedRow() const;
      84             :   int GetRowOffset() const;
      85             : 
      86           0 :   void SetUnsorted(bool unsorted){fUnsorted=unsorted;}
      87             : 
      88             :   void SortBunchBinVector(); // fills the vector fBinRowPositionSorted so that digits are read in the correct order
      89             : 
      90             :   const AliHLTTPCDigitData* GetBunchDigits();
      91             : 
      92             : protected:
      93             : 
      94             : 
      95             : private:
      96             :   /** copy constructor prohibited */
      97             :   AliHLTTPCDigitReaderUnpacked(const AliHLTTPCDigitReaderUnpacked&);
      98             :   /** assignment operator prohibited */
      99             :   AliHLTTPCDigitReaderUnpacked& operator=(const AliHLTTPCDigitReaderUnpacked&);
     100             : 
     101             :   /**
     102             :    * Increment to the next raw data pointer.
     103             :    * @param pRow        [IN] the current row data pointer
     104             :    *                    [OUT] the new pointer
     105             :    * @return -EBADF in case of format error 
     106             :    */
     107             :   int GetNextRowData(AliHLTTPCDigitRowData*& pRow) const;
     108             : 
     109             :   /** intermediate row data structure (pointer in fPtr buffer) */
     110             :   AliHLTTPCDigitRowData *fDigitRowData; //!
     111             :   /** current row data structure (pointer in fPtr buffer) */
     112             :   AliHLTTPCDigitRowData *fActRowData; //!
     113             :   /** the current digit data */
     114             :   AliHLTTPCDigitData *fData; //!
     115             : 
     116             :   /** input buffer */
     117             :   void* fPtr; //!
     118             :   /** size of the input buffer */
     119             :   unsigned long fSize;                                             // see above
     120             : 
     121             :   /** current bin */
     122             :   Int_t fBin;                                                      // see above
     123             :   /** current row */
     124             :   Int_t fRow;                                                      // see above
     125             :   /** first row */
     126             :   Int_t fFirstRow;                                                 // see above
     127             :   /** last row */
     128             :   Int_t fLastRow;                                                  // see above
     129             : 
     130             :   Bool_t fUnsorted; //!transient
     131             : 
     132             :   /** array to hold bunch data */
     133             :   vector<UInt_t> fDataBunch;                            //! transient
     134             : 
     135             :   vector<Int_t> fTrackIDs;                              //! transient
     136             :   vector<UInt_t> fTrackIDCounts;                        //! transient
     137             :   
     138             :   Bool_t fEndOfDataReached;                             //! transient
     139             : 
     140             :   Bool_t fEndOfChannelReached;                          //! transient
     141             : 
     142             :   Int_t fPrevTime;                                      //! transient
     143             : 
     144             :   Int_t fEndTimeBinOfBunch;                             //! transient
     145             : 
     146             :   Int_t fPrevSignal;                                    //! transient
     147             : 
     148             :   Int_t fPrevPad;                                       //! transient
     149             : 
     150             :   Int_t fPrevRow;                                       //! transient
     151             :   
     152             :   Bool_t fNextChannelIsAlreadyConfirmed;                //! transient 
     153             : 
     154             :   AliHLTTPCMapping *fMapping;                           //! transient
     155             : 
     156             :   vector<AliHLTTPCDigitData> fDigitsVector;             //! transient
     157             : 
     158             :   vector<Int_t>fBinRowPositionSorted;                      //! transient
     159             : 
     160             :   Int_t fPatch;
     161             : 
     162           6 :   ClassDef(AliHLTTPCDigitReaderUnpacked, 0)
     163             : };
     164             : #endif
     165             : 
     166             :  
     167             : 

Generated by: LCOV version 1.11