[u/mrichter/AliRoot.git] / HLT / TRD / AliHLTTRDMonitorComponent.cxx

// $Id$
//**************************************************************************
//* This file is property of and copyright by the ALICE HLT Project        * 
//* ALICE Experiment at CERN, All rights reserved.                         *
//*                                                                        *
//*                                                                        *
//* 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.                  *
//**************************************************************************

/// @file   AliHLTTRDMonitorComponent.cxx
/// @author Felix Rettig, Stefan Kirsch
/// @date   2011-08-02
/// @brief  A processing component for TRD tracking/trigger data on FEP-level
/// @ingroup alihlt_trd_components

#include "AliHLTTRDMonitorComponent.h"
#include "AliLog.h"
#include "AliHLTDataTypes.h"
#include "AliRawReaderMemory.h"
#include "AliHLTTRDDefinitions.h"

#include "AliTRDdigitsManager.h"
#include "AliTRDrawStream.h"
#include "AliTRDtrackletWord.h"
#include "AliESDTrdTracklet.h"
#include "AliESDTrdTrack.h"

#include "TH1I.h"
#include "TH2I.h"
#include "TH1F.h"


/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTTRDMonitorComponent)

AliHLTTRDMonitorComponent::AliHLTTRDMonitorComponent()
  : AliHLTProcessor()
  , fTrackletArray(NULL)
  , fGtuTrackArray(NULL)
  , fRawReaderMem(NULL)
  , fDigitsManagerTrd(NULL)
  , fRawReaderTrd(NULL)
  , fHistArray(NULL)
  , fHistTrackletY(NULL)
  , fHistTrackletDy(NULL)
  , fHistTrackletZ(NULL)
  , fHistTrackletPID(NULL)
  , fHistTrackletYDy(NULL)
  , fHistTrackletHC(NULL)
  , fHistTrackletBadY(NULL)
  , fHistTrackletBadPID(NULL)
  , fHistFirstTrackletTime(NULL)
  , fHistLastTrackletTime(NULL)
  , fHistTmuTime(NULL)
  , fHistSmuTime(NULL)
  , fHistTrackPt(NULL)
  , fHistTrackStack(NULL)
  , fHistTrackletsTrack(NULL)
  , fHistTrackletsTrackHpt(NULL)
  , fHistTrackPID(NULL)
  , fHistTriggerContribs(NULL)
{
  // constructor
}

AliHLTTRDMonitorComponent::~AliHLTTRDMonitorComponent()
{
  // destructor
}

const char* AliHLTTRDMonitorComponent::GetComponentID()
{ 
  // component property: id
  return "TRDMonitorComponent";
}

void AliHLTTRDMonitorComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
{
  // component property: list of input data types
  list.push_back(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTRD);
}

AliHLTComponentDataType AliHLTTRDMonitorComponent::GetOutputDataType()
{
  // component property: output data type
  return kAliHLTMultipleDataType;
}

int AliHLTTRDMonitorComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)

{
  // see header file for class documentation
  tgtList.clear();
  //  tgtList.push_back(AliHLTTRDDefinitions::fgkSimpleIntegerDataType);
  tgtList.push_back(kAliHLTDataTypeTObject | kAliHLTDataOriginTRD);
  return tgtList.size();
}

void AliHLTTRDMonitorComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
{
  // component property: output size estimator
  constBase = 5000000;
  inputMultiplier = 0;
}

void AliHLTTRDMonitorComponent::GetOCDBObjectDescription( TMap* const /*targetMap*/)
{
  // Get a list of OCDB object description.
  // The list of objects is provided in a TMap
  // - key: complete OCDB path, e.g. GRP/GRP/Data
  // - value: short description why the object is needed
  // Key and value objects created inside this class go into ownership of
  // target TMap.
  //if (!targetMap) return;
  //targetMap->Add(new TObjString("HLT/ConfigSample/SampleRawAnalysis"),
  //               new TObjString("configuration object"));
}

AliHLTComponent* AliHLTTRDMonitorComponent::Spawn()
{
  // Spawn function, return new class instance
  return new AliHLTTRDMonitorComponent;
}

int AliHLTTRDMonitorComponent::DoInit( int /*argc*/, const char** /*argv*/ )
{

  int iResult=0;

  // init stage 1: default values for all data members

  // init stage 2: read configuration object
  // ScanConfigurationArgument() needs to be implemented
  // HLT component configuration objects are located in the HLT/ConfigDET
  // of the OCDB. TObjString configuration objects can be generated with
  // the macro HLT/exa/makeComponentConfigurationObject.C, e.g.
  // aliroot -b -q -l $ALICE_ROOT/HLT/exa/makeComponentConfigurationObject.C'("HLT/ConfigSample/SampleRawAnalysis", "")'
  //TString cdbPath="HLT/ConfigSample/";
  //cdbPath+=GetComponentID();
  //iResult=ConfigureFromCDBTObjString(cdbPath);

  // init stage 3: read the component arguments
  //if (iResult>=0) {
  //  iResult=ConfigureFromArgumentString(argc, argv);
  //}

  // implement the component initialization
  // Matthias 2011-08-24: this has to go into ScanConfigurationArgument
  do {

    fRawReaderMem = new AliRawReaderMemory; 
    if (!fRawReaderMem) {
      iResult=-ENOMEM;
      break;
    }

    fTrackletArray = new TClonesArray("AliTRDtrackletWord", 500);
    if (!fTrackletArray) {
      iResult=-ENOMEM;
      break;
    }

    fGtuTrackArray = new TClonesArray("AliESDTrdTrack", 50);
    if (!fGtuTrackArray){
      iResult=-ENOMEM;
      break;
    }

    fDigitsManagerTrd = new AliTRDdigitsManager();
    if (!fDigitsManagerTrd) {
      iResult=-ENOMEM;
      break;
    }
    fDigitsManagerTrd->CreateArrays();

    fRawReaderTrd = new AliTRDrawStream(fRawReaderMem);
    if (!fRawReaderTrd) {
      iResult=-ENOMEM;
      break;
    }

    fRawReaderTrd->SetDigitsManager(fDigitsManagerTrd);
    // fRawReaderTrd->SetDigitsManager(NULL);  // FIXME may be used to improve performance, needs a fix to be committed by TRD
    fRawReaderTrd->SetTrackletArray(fTrackletArray);
    fRawReaderTrd->SetTrackArray(fGtuTrackArray);
  
    // Disable raw reader error messages that could flood HLT logbook
    fRawReaderTrd->SetErrorDebugLevel( AliTRDrawStream::kLinkMonitor, 1 );

    fHistArray = new TObjArray(25);
    if(!fHistArray){
      return -ENOMEM;
      break;
    }
    fHistArray->SetOwner(kTRUE);

    fHistTrackletY = new TH1I("hist_tracklets_y", "Y-Position of online tracklets", 256, -4096, 4096);
    if (!fHistTrackletY){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistTrackletY);

    fHistTrackletDy = new TH1I("hist_tracklets_dy", "Deflection of online tracklets", 128, -64, 64);
    if (!fHistTrackletDy){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistTrackletDy);

    fHistTrackletZ = new TH1I("hist_tracklets_z", "Z-Position of online tracklets", 12, 0, 12);
    if (!fHistTrackletZ){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistTrackletZ);

    fHistTrackletPID = new TH1I("hist_tracklets_pid", "PID of online tracklets", 256, 0, 256);
    if (!fHistTrackletPID){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistTrackletPID);

    fHistTrackletYDy = new TH2I("hist_tracklets_y_dy", "Tracklet deflection vs. tracklet position", 256, -4096, 4096, 64, -64, 64);
    if (!fHistTrackletYDy){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistTrackletYDy);

    fHistTrackletHC = new TH2I("hist_tracklets_hc", "Number of online tracklets by HC", 18, 0, 18, 60, 0, 60);
    if (!fHistTrackletHC){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistTrackletHC);

    fHistTrackletBadY = new TH2I("hist_tracklets_bad_y", "Number of online tracklets with bad y-position by HC", 18, 0, 18, 5, 0, 5);
    if (!fHistTrackletBadY){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistTrackletBadY);

    fHistTrackletBadPID = new TH2I("hist_tracklets_bad_pid", "Number of online tracklets with bad y-position by HC", 18, 0, 18, 5, 0, 5);
    if (!fHistTrackletBadPID){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistTrackletBadPID);

    fHistFirstTrackletTime = new TH1F("hist_first_tracklet_time", "Arrival time of first tracklet", 160, 0., 8.);
    if (!fHistFirstTrackletTime){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistFirstTrackletTime);

    fHistLastTrackletTime = new TH1F("hist_last_tracklet_time", "Arrival time of last tracklet", 160, 0., 8.);
    if (!fHistLastTrackletTime){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistLastTrackletTime);

    fHistTmuTime = new TH1F("hist_tmu_time", "Tracking done time at TMU-level", 160, 0., 8.);
    if (!fHistTmuTime){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistTmuTime);

    fHistSmuTime = new TH1F("hist_smu_time", "Tracking done time at SMU-level", 160, 0., 8.);
    if (!fHistSmuTime){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistSmuTime);

    fHistTrackPt = new TH1F("hist_tracks_pt", "Transverse momentum of GTU tracks", 100, 0., 20.);
    if (!fHistTrackPt){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistTrackPt);

    fHistTrackPID = new TH1I("hist_tracks_pid", "PID of online tracks", 256, 0, 256);
    if (!fHistTrackPID){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistTrackPID);

    fHistTrackStack = new TH2I("hist_tracks_stack", "Number of GTU tracks by stack", 18, 0, 18, 5, 0, 5);
    if (!fHistTrackStack){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistTrackStack);

    fHistTrackletsTrack = new TH1I("hist_tracklets_track", "Tracklets per GTU track", 7, 0, 7);
    if (!fHistTrackletsTrack){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistTrackletsTrack);

    fHistTrackletsTrackHpt = new TH1I("hist_tracklets_track_hpt", "Tracklets per high-pt GTU track", 7, 0, 7);
    if (!fHistTrackletsTrackHpt){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistTrackletsTrackHpt);

    fHistTriggerContribs = new TH2I("hist_trigger_contribs", "Trigger contributions by segment", 18, 0, 18, 12, 0, 12);
    if (!fHistTriggerContribs){
      return -ENOMEM;
      break;
    }
    fHistArray->AddLast(fHistTriggerContribs);

  } while (0);

  if (iResult<0) {
    // implement cleanup
    if (fRawReaderMem) delete fRawReaderMem;
    fRawReaderMem=NULL;

    if (fRawReaderTrd) delete fRawReaderTrd;
    fRawReaderTrd=NULL;

    if (fTrackletArray) delete fTrackletArray;
    fTrackletArray = NULL;

    if (fGtuTrackArray) delete fGtuTrackArray;
    fGtuTrackArray = NULL;

    if (fHistArray) delete fHistArray;
    fHistArray = NULL;

    fHistTrackletY = NULL;
    fHistTrackletDy = NULL;
    fHistTrackletZ = NULL;
    fHistTrackletPID = NULL;
    fHistTrackletYDy = NULL;
    fHistTrackletHC = NULL;
    fHistTrackletBadY = NULL;
    fHistTrackletBadPID = NULL;
    fHistTrackPt = NULL;
    fHistTrackStack = NULL;
    fHistFirstTrackletTime = NULL;
    fHistLastTrackletTime = NULL;
    fHistTmuTime = NULL;
    fHistSmuTime = NULL;
    fHistTrackPt = NULL;
    fHistTrackStack = NULL;
    fHistTrackletsTrack = NULL;
    fHistTrackletsTrackHpt = NULL;
    fHistTrackPID = NULL;
    fHistTriggerContribs = NULL;
  }

  return iResult;
}

int AliHLTTRDMonitorComponent::ScanConfigurationArgument(int /*argc*/, const char** /*argv*/)
{
  // Scan configuration arguments
  // Return the number of processed arguments
  //        -EPROTO if argument format error (e.g. number expected but not found)
  //
  // The AliHLTComponent base class implements a parsing loop for argument strings and
  // arrays of strings which is invoked by ConfigureFromArgumentString/ConfigureFromCDBTObjString
  // The component needs to implement ScanConfigurationArgument in order to decode the arguments.

  /*
  int i=0;
  TString argument=argv[i];

  if (argument.IsNull()) return 0;

  // -mandatory1 arg
  if (argument.CompareTo("-mandatory1")==0) {
    if (++i>=argc) return -EINVAL;
    HLTInfo("got \'-mandatory1\' argument: %s", argv[i]);
    return 2; // keyword + 1 argument
  }

  // -optional1 arg
  if (argument.CompareTo("-optional1")==0) {
    if (++i>=argc) return -EINVAL;
    HLTInfo("got \'-optional1\' argument: %s", argv[i]);
    return 2; // keyword + 1 argument
  }

  // -verbose
  if (argument.CompareTo("-verbose")==0) {
    fVerbosity=1;
    return 1; // only keyword
  }
  */
  return 0;
}

int AliHLTTRDMonitorComponent::DoDeinit()
{
  // component cleanup, delete all instances of helper classes here
  if (fRawReaderMem) delete fRawReaderMem;
  fRawReaderMem=NULL;

  if (fRawReaderTrd) delete fRawReaderTrd;
  fRawReaderTrd=NULL;

  if (fTrackletArray) delete fTrackletArray;
  fTrackletArray = NULL;

  if (fGtuTrackArray) delete fGtuTrackArray;
  fGtuTrackArray = NULL;
  
  if (fHistArray) delete fHistArray;
  fHistArray = NULL;

  fHistTrackletY = NULL;
  fHistTrackletDy = NULL;
  fHistTrackletY = NULL;
  fHistTrackletDy = NULL;
  fHistTrackletZ = NULL;
  fHistTrackletPID = NULL;
  fHistTrackletHC = NULL;
  fHistTrackletBadY = NULL;
  fHistTrackletBadPID = NULL;
  fHistFirstTrackletTime = NULL;
  fHistLastTrackletTime = NULL;
  fHistTmuTime = NULL;
  fHistSmuTime = NULL;
  fHistTrackPt = NULL;
  fHistTrackStack = NULL;
  fHistTrackletsTrack = NULL;
  fHistTrackletsTrackHpt = NULL;
  fHistTrackPID = NULL;
  fHistTriggerContribs = NULL;

  return 0;
}

int AliHLTTRDMonitorComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/,
					      AliHLTComponentTriggerData& /*trigData*/)
{
  // event processing function
  int iResult=0;

  // check if this is a data event, there are a couple of special events
  // which should be ignored for normal processing
  if (!IsDataEvent()) return 0;

  // #FIXME: Also take care of SOR, EOR, etc...

  // loop over the raw input data blocks and set up the rawreader
  for (const AliHLTComponentBlockData* pBlock = GetFirstInputBlock(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTRD);
       pBlock!=NULL && iResult>=0;
       pBlock=GetNextInputBlock()) {
    // extract DDL id from specification
    int ddlnum=-1;
    for (unsigned pos=0; pos<8*sizeof(AliHLTUInt32_t); pos++) {
      if (pBlock->fSpecification & (0x1<<pos)) {
	      if (ddlnum>=0) {
	        // this is just an example, please avoid warnings in every event since those will
	        // saturate the logging system. Consider AliHLTErrorGuard for such cases, e.g.
	        // ALIHLTERRORGUARD(5, "nasty error, first occurence in event %d", event);
	        // this will show the error 5 times and then a summary at the end
	        HLTWarning("Can not uniquely identify DDL number from specification, skipping data block %s 0x%08x",
	      	     DataType2Text(pBlock->fDataType).c_str(),
	      	     pBlock->fSpecification);
	        ddlnum=-1;
	        break;
	      }
	      ddlnum=pos;
      }
    }
    if (ddlnum<0) continue;
    ddlnum += 1024;

    // add data block to rawreader
    if(!fRawReaderMem->AddBuffer((UChar_t*) pBlock->fPtr, pBlock->fSize, ddlnum)){
      HLTError("Could not add buffer of data block  %s, 0x%08x to rawreader",
	       DataType2Text(pBlock->fDataType).c_str(),
	       pBlock->fSpecification);
      continue;
    }

    // read and process TRD tracklet and GTU tracks from event
    fTrackletArray->Clear();
    fGtuTrackArray->Clear();
    fRawReaderTrd->ReadEvent();

    // read and process tracking/trigger flags
    UInt_t iSector = ddlnum-1024;
    UInt_t trgflags = fRawReaderTrd->GetTriggerFlags(iSector);
    //UInt_t done_tmu = (trgflags >> 27) & 0x1f;
    //UInt_t done_smu = (trgflags >> 22) & 0x1f;
    Float_t smu_timing = ((trgflags >> 12) & 0x3ff) * 0.0083333; // tracking finished after L0, in us
    UInt_t ctb_fired =  trgflags & 0xfff;

    /*
      printf("Trigger flags sector %02d: 0x%08x - ctb=0x%03x  tmu-done=0x%x smu-done=0x%x  smu-time: %.2fus\n", 
	   iSector, trgflags,
	   ctb_fired,
	   done_tmu,
	   done_smu,
	   smu_timing
	   );
    */
    fHistSmuTime->Fill(smu_timing);

    for (int iCtb=0; iCtb<12; iCtb++){
      if ((ctb_fired >> iCtb) & 1)
        fHistTriggerContribs->Fill(iSector, iCtb, 1);
    }

    Float_t first_tracklet_timing[5]={0};
    Float_t last_tracklet_timing[5]={0};
    Float_t tmu_timing[5]={0};
    ULong64_t trkflags;

    for (int iStack=0; iStack<5; iStack++){
      trkflags = fRawReaderTrd->GetTrkFlags(iSector, iStack);
      tmu_timing[iStack]=(trkflags & 0x3ff) * 0.02;
      first_tracklet_timing[iStack]=((trkflags >> 20) & 0x3ff) * 0.008;
      last_tracklet_timing[iStack]=((trkflags >> 10) & 0x3ff) * 0.008;
      /*
      printf("  Stack %02d_%d: 0x%016llx - first tracklet: %.2fus  last tracklet: %.2fus  tmu timing: %.2fus\n",
	     iSector, iStack, trkflags, 
	     first_tracklet_timing[iStack], last_tracklet_timing[iStack], tmu_timing[iStack]
	     );
      */
      fHistFirstTrackletTime->Fill(first_tracklet_timing[iStack]);
      fHistLastTrackletTime->Fill(last_tracklet_timing[iStack]);
      fHistTmuTime->Fill(tmu_timing[iStack]);
    }

    for (int iTracklet = 0; iTracklet < fTrackletArray->GetEntriesFast(); iTracklet++) {
      AliTRDtrackletWord *trackletWord = (AliTRDtrackletWord*) ((*fTrackletArray)[iTracklet]);
      AliESDTrdTracklet tracklet(trackletWord->GetTrackletWord(), trackletWord->GetHCId());
      /*
      printf("TRDMSG: TRD tracklet found: 0x%08x  - y=%+5d  dy=%+3d  pid=%3d\n",
	     tracklet.GetTrackletWord(),
	     tracklet.GetBinY(),
	     tracklet.GetBinDy(),
	     tracklet.GetPID());
      */
      // fill some basic histograms right here
      fHistTrackletY->Fill(tracklet.GetBinY());
      fHistTrackletDy->Fill(tracklet.GetBinDy());
      fHistTrackletZ->Fill(tracklet.GetBinZ());
      fHistTrackletPID->Fill(tracklet.GetPID());
      fHistTrackletYDy->Fill(tracklet.GetBinY(), tracklet.GetBinDy());
      fHistTrackletHC->Fill(tracklet.GetHCId()/60, tracklet.GetHCId()%60);

      if (TMath::Abs(tracklet.GetBinY()) >= 3682) 
        fHistTrackletBadY->Fill(tracklet.GetHCId()/60, (tracklet.GetHCId()%60)/12);

      if (tracklet.GetPID() < 40)
        fHistTrackletBadPID->Fill(tracklet.GetHCId()/60, (tracklet.GetHCId()%60)/12);

    }

    for (int iTrack = 0; iTrack < fGtuTrackArray->GetEntriesFast(); iTrack++) {
      AliESDTrdTrack *trdTrack = (AliESDTrdTrack*) ((*fGtuTrackArray)[iTrack]);
      /*
      printf("TRDMSG: GTU track found: 0x%016llx - Stack %02d_%d  pt=%.3fGeV/c\n",
	     trdTrack->GetTrackWord(0),
	     trdTrack->GetSector(), trdTrack->GetStack(),
	     trdTrack->Pt());
      */
      fHistTrackPt->Fill(trdTrack->Pt());
      fHistTrackStack->Fill(trdTrack->GetSector(), trdTrack->GetStack());
      fHistTrackPID->Fill(trdTrack->GetPID());

      Int_t layers=0;
      Int_t layer_mask = trdTrack->GetLayerMask();
      for (Int_t iLayer=0; iLayer<6; iLayer++)
       if ((layer_mask >> iLayer) & 1)
         layers++;
      fHistTrackletsTrack->Fill(layers);
      if (TMath::Abs(trdTrack->Pt()) >= 3.)
        fHistTrackletsTrackHpt->Fill(layers);
    }

    // do more complex processing here, preferably in a dedicated class

    // push  TObject-based data to output
    iResult = PushBack(fHistArray, 
		       (kAliHLTDataTypeTObject | kAliHLTDataOriginTRD), 
    		       pBlock->fSpecification);

    if (iResult < 0)                                  
      break;
		       
    // clear the rawreader
    fRawReaderMem->ClearBuffers();    
  }

  return iResult;
}

int AliHLTTRDMonitorComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/)
{
  // reconfigure the component from the specified CDB entry, or default CDB entry
  // function is invoked by the framework if a reconfigure command was received.
  // 
  int iResult=0;
  /*
  TString cdbPath;
  if (cdbEntry) {
    cdbPath=cdbEntry;
  } else {
    cdbPath="HLT/ConfigSample/";
    cdbPath+=GetComponentID();
  }
  AliInfoClass(Form("reconfigure '%s' from entry %s%s", chainId, cdbPath.Data(), cdbEntry?"":" (default)"));
  iResult=ConfigureFromCDBTObjString(cdbPath);
  */
  return iResult;
}

int AliHLTTRDMonitorComponent::ReadPreprocessorValues(const char* /*modules*/)
{
  // read the preprocessor values for the detectors in the modules list
  // function is invoked by the framework if the pendolino indivates an update
  // of online calibration objects, e.g temperature and pressure measurements.
  int iResult=0;
  /*
  TString detectors(modules!=NULL?modules:"");
  AliInfoClass(Form("read preprocessor values for detector(s): %s", detectors.IsNull()?"none":detectors.Data()));
  */
  return iResult;
}
Commit	Line	Data
ce6fd1b1	1	// $Id$
	2	//**************************************************************************
	3	//* This file is property of and copyright by the ALICE HLT Project *
	4	//* ALICE Experiment at CERN, All rights reserved. *
	5	//* *
	6	//* *
	7	//* Permission to use, copy, modify and distribute this software and its *
	8	//* documentation strictly for non-commercial purposes is hereby granted *
	9	//* without fee, provided that the above copyright notice appears in all *
	10	//* copies and that both the copyright notice and this permission notice *
	11	//* appear in the supporting documentation. The authors make no claims *
	12	//* about the suitability of this software for any purpose. It is *
	13	//* provided "as is" without express or implied warranty. *
	14	//**************************************************************************
	15
	16	/// @file AliHLTTRDMonitorComponent.cxx
	17	/// @author Felix Rettig, Stefan Kirsch
	18	/// @date 2011-08-02
	19	/// @brief A processing component for TRD tracking/trigger data on FEP-level
	20	/// @ingroup alihlt_trd_components
	21
	22	#include "AliHLTTRDMonitorComponent.h"
	23	#include "AliLog.h"
	24	#include "AliHLTDataTypes.h"
	25	#include "AliRawReaderMemory.h"
	26	#include "AliHLTTRDDefinitions.h"
	27
	28	#include "AliTRDdigitsManager.h"
	29	#include "AliTRDrawStream.h"
	30	#include "AliTRDtrackletWord.h"
	31	#include "AliESDTrdTracklet.h"
	32	#include "AliESDTrdTrack.h"
	33
	34	#include "TH1I.h"
	35	#include "TH2I.h"
	36	#include "TH1F.h"
	37
	38
	39	/** ROOT macro for the implementation of ROOT specific class methods */
	40	ClassImp(AliHLTTRDMonitorComponent)
	41
	42	AliHLTTRDMonitorComponent::AliHLTTRDMonitorComponent()
	43	: AliHLTProcessor()
	44	, fTrackletArray(NULL)
	45	, fGtuTrackArray(NULL)
	46	, fRawReaderMem(NULL)
	47	, fDigitsManagerTrd(NULL)
	48	, fRawReaderTrd(NULL)
	49	, fHistArray(NULL)
	50	, fHistTrackletY(NULL)
	51	, fHistTrackletDy(NULL)
	52	, fHistTrackletZ(NULL)
	53	, fHistTrackletPID(NULL)
	54	, fHistTrackletYDy(NULL)
	55	, fHistTrackletHC(NULL)
	56	, fHistTrackletBadY(NULL)
	57	, fHistTrackletBadPID(NULL)
	58	, fHistFirstTrackletTime(NULL)
	59	, fHistLastTrackletTime(NULL)
	60	, fHistTmuTime(NULL)
	61	, fHistSmuTime(NULL)
	62	, fHistTrackPt(NULL)
	63	, fHistTrackStack(NULL)
	64	, fHistTrackletsTrack(NULL)
65	, fHistTrackletsTrackHpt(NULL)
66	, fHistTrackPID(NULL)
67	, fHistTriggerContribs(NULL)
68	{
69	// constructor
70	}
71
72	AliHLTTRDMonitorComponent::~AliHLTTRDMonitorComponent()
73	{
74	// destructor
75	}
76
77	const char* AliHLTTRDMonitorComponent::GetComponentID()
78	{
79	// component property: id
80	return "TRDMonitorComponent";
81	}
82
83	void AliHLTTRDMonitorComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
84	{
85	// component property: list of input data types
86	list.push_back(kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginTRD);
87	}
88
89	AliHLTComponentDataType AliHLTTRDMonitorComponent::GetOutputDataType()
90	{
91	// component property: output data type
92	return kAliHLTMultipleDataType;
93	}
94
95	int AliHLTTRDMonitorComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
96
97	{
98	// see header file for class documentation
99	tgtList.clear();
100	// tgtList.push_back(AliHLTTRDDefinitions::fgkSimpleIntegerDataType);
101	tgtList.push_back(kAliHLTDataTypeTObject \| kAliHLTDataOriginTRD);
102	return tgtList.size();
103	}
104
105	void AliHLTTRDMonitorComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
106	{
107	// component property: output size estimator
108	constBase = 5000000;
109	inputMultiplier = 0;
110	}
111
112	void AliHLTTRDMonitorComponent::GetOCDBObjectDescription( TMap* const /targetMap/)
113	{
114	// Get a list of OCDB object description.
115	// The list of objects is provided in a TMap
116	// - key: complete OCDB path, e.g. GRP/GRP/Data
117	// - value: short description why the object is needed
118	// Key and value objects created inside this class go into ownership of
119	// target TMap.
120	//if (!targetMap) return;
121	//targetMap->Add(new TObjString("HLT/ConfigSample/SampleRawAnalysis"),
122	// new TObjString("configuration object"));
123	}
124
125	AliHLTComponent* AliHLTTRDMonitorComponent::Spawn()
126	{
127	// Spawn function, return new class instance
128	return new AliHLTTRDMonitorComponent;
129	}
130
131	int AliHLTTRDMonitorComponent::DoInit( int /argc/, const char** /argv/ )
132	{
133
134	int iResult=0;
135
136	// init stage 1: default values for all data members
137
138	// init stage 2: read configuration object
139	// ScanConfigurationArgument() needs to be implemented
140	// HLT component configuration objects are located in the HLT/ConfigDET
141	// of the OCDB. TObjString configuration objects can be generated with
142	// the macro HLT/exa/makeComponentConfigurationObject.C, e.g.
143	// aliroot -b -q -l $ALICE_ROOT/HLT/exa/makeComponentConfigurationObject.C'("HLT/ConfigSample/SampleRawAnalysis", "")'
144	//TString cdbPath="HLT/ConfigSample/";
145	//cdbPath+=GetComponentID();
146	//iResult=ConfigureFromCDBTObjString(cdbPath);
147
148	// init stage 3: read the component arguments
149	//if (iResult>=0) {
150	// iResult=ConfigureFromArgumentString(argc, argv);
151	//}
152
153	// implement the component initialization
79f07cf4	154	// Matthias 2011-08-24: this has to go into ScanConfigurationArgument
ce6fd1b1	155	do {
ce6fd1b1	156
	157	fRawReaderMem = new AliRawReaderMemory;
	158	if (!fRawReaderMem) {
	159	iResult=-ENOMEM;
	160	break;
	161	}
	162
	163	fTrackletArray = new TClonesArray("AliTRDtrackletWord", 500);
	164	if (!fTrackletArray) {
	165	iResult=-ENOMEM;
	166	break;
	167	}
	168
	169	fGtuTrackArray = new TClonesArray("AliESDTrdTrack", 50);
	170	if (!fGtuTrackArray){
	171	iResult=-ENOMEM;
	172	break;
	173	}
	174
	175	fDigitsManagerTrd = new AliTRDdigitsManager();
	176	if (!fDigitsManagerTrd) {
	177	iResult=-ENOMEM;
	178	break;
	179	}
	180	fDigitsManagerTrd->CreateArrays();
	181
	182	fRawReaderTrd = new AliTRDrawStream(fRawReaderMem);
	183	if (!fRawReaderTrd) {
	184	iResult=-ENOMEM;
	185	break;
	186	}
	187
	188	fRawReaderTrd->SetDigitsManager(fDigitsManagerTrd);
	189	// fRawReaderTrd->SetDigitsManager(NULL); // FIXME may be used to improve performance, needs a fix to be committed by TRD
	190	fRawReaderTrd->SetTrackletArray(fTrackletArray);
	191	fRawReaderTrd->SetTrackArray(fGtuTrackArray);
	192
	193	// Disable raw reader error messages that could flood HLT logbook
	194	fRawReaderTrd->SetErrorDebugLevel( AliTRDrawStream::kLinkMonitor, 1 );
	195
	196	fHistArray = new TObjArray(25);
	197	if(!fHistArray){
	198	return -ENOMEM;
	199	break;
	200	}
	201	fHistArray->SetOwner(kTRUE);
	202
	203	fHistTrackletY = new TH1I("hist_tracklets_y", "Y-Position of online tracklets", 256, -4096, 4096);
	204	if (!fHistTrackletY){
	205	return -ENOMEM;
	206	break;
	207	}
	208	fHistArray->AddLast(fHistTrackletY);
	209
	210	fHistTrackletDy = new TH1I("hist_tracklets_dy", "Deflection of online tracklets", 128, -64, 64);
	211	if (!fHistTrackletDy){
	212	return -ENOMEM;
	213	break;
	214	}
	215	fHistArray->AddLast(fHistTrackletDy);
	216
	217	fHistTrackletZ = new TH1I("hist_tracklets_z", "Z-Position of online tracklets", 12, 0, 12);
	218	if (!fHistTrackletZ){
	219	return -ENOMEM;
220	break;
221	}
222	fHistArray->AddLast(fHistTrackletZ);
223
224	fHistTrackletPID = new TH1I("hist_tracklets_pid", "PID of online tracklets", 256, 0, 256);
225	if (!fHistTrackletPID){
226	return -ENOMEM;
227	break;
228	}
229	fHistArray->AddLast(fHistTrackletPID);
230
231	fHistTrackletYDy = new TH2I("hist_tracklets_y_dy", "Tracklet deflection vs. tracklet position", 256, -4096, 4096, 64, -64, 64);
232	if (!fHistTrackletYDy){
233	return -ENOMEM;
234	break;
235	}
236	fHistArray->AddLast(fHistTrackletYDy);
237
238	fHistTrackletHC = new TH2I("hist_tracklets_hc", "Number of online tracklets by HC", 18, 0, 18, 60, 0, 60);
239	if (!fHistTrackletHC){
240	return -ENOMEM;
241	break;
242	}
243	fHistArray->AddLast(fHistTrackletHC);
244
245	fHistTrackletBadY = new TH2I("hist_tracklets_bad_y", "Number of online tracklets with bad y-position by HC", 18, 0, 18, 5, 0, 5);
246	if (!fHistTrackletBadY){
247	return -ENOMEM;
248	break;
249	}
250	fHistArray->AddLast(fHistTrackletBadY);
251
252	fHistTrackletBadPID = new TH2I("hist_tracklets_bad_pid", "Number of online tracklets with bad y-position by HC", 18, 0, 18, 5, 0, 5);
253	if (!fHistTrackletBadPID){
254	return -ENOMEM;
255	break;
256	}
257	fHistArray->AddLast(fHistTrackletBadPID);
258
259	fHistFirstTrackletTime = new TH1F("hist_first_tracklet_time", "Arrival time of first tracklet", 160, 0., 8.);
260	if (!fHistFirstTrackletTime){
261	return -ENOMEM;
262	break;
263	}
264	fHistArray->AddLast(fHistFirstTrackletTime);
265
266	fHistLastTrackletTime = new TH1F("hist_last_tracklet_time", "Arrival time of last tracklet", 160, 0., 8.);
267	if (!fHistLastTrackletTime){
268	return -ENOMEM;
269	break;
270	}
271	fHistArray->AddLast(fHistLastTrackletTime);
272
273	fHistTmuTime = new TH1F("hist_tmu_time", "Tracking done time at TMU-level", 160, 0., 8.);
274	if (!fHistTmuTime){
275	return -ENOMEM;
276	break;
277	}
278	fHistArray->AddLast(fHistTmuTime);
279
280	fHistSmuTime = new TH1F("hist_smu_time", "Tracking done time at SMU-level", 160, 0., 8.);
281	if (!fHistSmuTime){
282	return -ENOMEM;
283	break;
284	}
285	fHistArray->AddLast(fHistSmuTime);
286
287	fHistTrackPt = new TH1F("hist_tracks_pt", "Transverse momentum of GTU tracks", 100, 0., 20.);
288	if (!fHistTrackPt){
289	return -ENOMEM;
290	break;
291	}
292	fHistArray->AddLast(fHistTrackPt);
293
294	fHistTrackPID = new TH1I("hist_tracks_pid", "PID of online tracks", 256, 0, 256);
295	if (!fHistTrackPID){
296	return -ENOMEM;
297	break;
298	}
299	fHistArray->AddLast(fHistTrackPID);
300
301	fHistTrackStack = new TH2I("hist_tracks_stack", "Number of GTU tracks by stack", 18, 0, 18, 5, 0, 5);
302	if (!fHistTrackStack){
303	return -ENOMEM;
304	break;
305	}
306	fHistArray->AddLast(fHistTrackStack);
307
308	fHistTrackletsTrack = new TH1I("hist_tracklets_track", "Tracklets per GTU track", 7, 0, 7);
309	if (!fHistTrackletsTrack){
310	return -ENOMEM;
311	break;
312	}
313	fHistArray->AddLast(fHistTrackletsTrack);
314
315	fHistTrackletsTrackHpt = new TH1I("hist_tracklets_track_hpt", "Tracklets per high-pt GTU track", 7, 0, 7);
316	if (!fHistTrackletsTrackHpt){
317	return -ENOMEM;
318	break;
319	}
320	fHistArray->AddLast(fHistTrackletsTrackHpt);
321
322	fHistTriggerContribs = new TH2I("hist_trigger_contribs", "Trigger contributions by segment", 18, 0, 18, 12, 0, 12);
323	if (!fHistTriggerContribs){
324	return -ENOMEM;
325	break;
326	}
327	fHistArray->AddLast(fHistTriggerContribs);
328
329	} while (0);
330
331	if (iResult<0) {
332	// implement cleanup
333	if (fRawReaderMem) delete fRawReaderMem;
334	fRawReaderMem=NULL;
335
336	if (fRawReaderTrd) delete fRawReaderTrd;
337	fRawReaderTrd=NULL;
338
339	if (fTrackletArray) delete fTrackletArray;
340	fTrackletArray = NULL;
341
342	if (fGtuTrackArray) delete fGtuTrackArray;
343	fGtuTrackArray = NULL;
344
345	if (fHistArray) delete fHistArray;
346	fHistArray = NULL;
347
348	fHistTrackletY = NULL;
349	fHistTrackletDy = NULL;
350	fHistTrackletZ = NULL;
351	fHistTrackletPID = NULL;
352	fHistTrackletYDy = NULL;
353	fHistTrackletHC = NULL;
354	fHistTrackletBadY = NULL;
355	fHistTrackletBadPID = NULL;
356	fHistTrackPt = NULL;
357	fHistTrackStack = NULL;
358	fHistFirstTrackletTime = NULL;
359	fHistLastTrackletTime = NULL;
360	fHistTmuTime = NULL;
361	fHistSmuTime = NULL;
362	fHistTrackPt = NULL;
363	fHistTrackStack = NULL;
364	fHistTrackletsTrack = NULL;
365	fHistTrackletsTrackHpt = NULL;
366	fHistTrackPID = NULL;
367	fHistTriggerContribs = NULL;
368	}
369
370	return iResult;
371	}
372
373	int AliHLTTRDMonitorComponent::ScanConfigurationArgument(int /argc/, const char** /argv/)
374	{
375	// Scan configuration arguments
376	// Return the number of processed arguments
377	// -EPROTO if argument format error (e.g. number expected but not found)
378	//
379	// The AliHLTComponent base class implements a parsing loop for argument strings and
380	// arrays of strings which is invoked by ConfigureFromArgumentString/ConfigureFromCDBTObjString
381	// The component needs to implement ScanConfigurationArgument in order to decode the arguments.
382
383	/*
384	int i=0;
385	TString argument=argv[i];
386
387	if (argument.IsNull()) return 0;
388
389	// -mandatory1 arg
390	if (argument.CompareTo("-mandatory1")==0) {
391	if (++i>=argc) return -EINVAL;
392	HLTInfo("got \'-mandatory1\' argument: %s", argv[i]);
393	return 2; // keyword + 1 argument
394	}
395
396	// -optional1 arg
397	if (argument.CompareTo("-optional1")==0) {
398	if (++i>=argc) return -EINVAL;
399	HLTInfo("got \'-optional1\' argument: %s", argv[i]);
400	return 2; // keyword + 1 argument
401	}
402
403	// -verbose
404	if (argument.CompareTo("-verbose")==0) {
405	fVerbosity=1;
406	return 1; // only keyword
407	}
408	*/
409	return 0;
410	}
411
412	int AliHLTTRDMonitorComponent::DoDeinit()
413	{
414	// component cleanup, delete all instances of helper classes here
415	if (fRawReaderMem) delete fRawReaderMem;
416	fRawReaderMem=NULL;
417
418	if (fRawReaderTrd) delete fRawReaderTrd;
419	fRawReaderTrd=NULL;
420
421	if (fTrackletArray) delete fTrackletArray;
422	fTrackletArray = NULL;
423
424	if (fGtuTrackArray) delete fGtuTrackArray;
425	fGtuTrackArray = NULL;
426
427	if (fHistArray) delete fHistArray;
428	fHistArray = NULL;
429
430	fHistTrackletY = NULL;
431	fHistTrackletDy = NULL;
432	fHistTrackletY = NULL;
433	fHistTrackletDy = NULL;
434	fHistTrackletZ = NULL;
435	fHistTrackletPID = NULL;
436	fHistTrackletHC = NULL;
437	fHistTrackletBadY = NULL;
438	fHistTrackletBadPID = NULL;
439	fHistFirstTrackletTime = NULL;
440	fHistLastTrackletTime = NULL;
441	fHistTmuTime = NULL;
442	fHistSmuTime = NULL;
443	fHistTrackPt = NULL;
444	fHistTrackStack = NULL;
445	fHistTrackletsTrack = NULL;
446	fHistTrackletsTrackHpt = NULL;
447	fHistTrackPID = NULL;
448	fHistTriggerContribs = NULL;
449
450	return 0;
451	}
452
453	int AliHLTTRDMonitorComponent::DoEvent(const AliHLTComponentEventData& /evtData/,
454	AliHLTComponentTriggerData& /trigData/)
455	{
456	// event processing function
457	int iResult=0;
458
459	// check if this is a data event, there are a couple of special events
460	// which should be ignored for normal processing
461	if (!IsDataEvent()) return 0;
462
463	// #FIXME: Also take care of SOR, EOR, etc...
464
465	// loop over the raw input data blocks and set up the rawreader
466	for (const AliHLTComponentBlockData* pBlock = GetFirstInputBlock(kAliHLTDataTypeDDLRaw\|kAliHLTDataOriginTRD);
467	pBlock!=NULL && iResult>=0;
468	pBlock=GetNextInputBlock()) {
469	// extract DDL id from specification
470	int ddlnum=-1;
471	for (unsigned pos=0; pos<8*sizeof(AliHLTUInt32_t); pos++) {
472	if (pBlock->fSpecification & (0x1<<pos)) {
473	if (ddlnum>=0) {
474	// this is just an example, please avoid warnings in every event since those will
475	// saturate the logging system. Consider AliHLTErrorGuard for such cases, e.g.
476	// ALIHLTERRORGUARD(5, "nasty error, first occurence in event %d", event);
477	// this will show the error 5 times and then a summary at the end
478	HLTWarning("Can not uniquely identify DDL number from specification, skipping data block %s 0x%08x",
479	DataType2Text(pBlock->fDataType).c_str(),
480	pBlock->fSpecification);
481	ddlnum=-1;
482	break;
483	}
484	ddlnum=pos;
485	}
486	}
487	if (ddlnum<0) continue;
488	ddlnum += 1024;
489
490	// add data block to rawreader
491	if(!fRawReaderMem->AddBuffer((UChar_t*) pBlock->fPtr, pBlock->fSize, ddlnum)){
492	HLTError("Could not add buffer of data block %s, 0x%08x to rawreader",
493	DataType2Text(pBlock->fDataType).c_str(),
494	pBlock->fSpecification);
495	continue;
496	}
497
498	// read and process TRD tracklet and GTU tracks from event
499	fTrackletArray->Clear();
500	fGtuTrackArray->Clear();
501	fRawReaderTrd->ReadEvent();
502
503	// read and process tracking/trigger flags
504	UInt_t iSector = ddlnum-1024;
505	UInt_t trgflags = fRawReaderTrd->GetTriggerFlags(iSector);
506	//UInt_t done_tmu = (trgflags >> 27) & 0x1f;
507	//UInt_t done_smu = (trgflags >> 22) & 0x1f;
508	Float_t smu_timing = ((trgflags >> 12) & 0x3ff) * 0.0083333; // tracking finished after L0, in us
509	UInt_t ctb_fired = trgflags & 0xfff;
510
511	/*
512	printf("Trigger flags sector %02d: 0x%08x - ctb=0x%03x tmu-done=0x%x smu-done=0x%x smu-time: %.2fus\n",
513	iSector, trgflags,
514	ctb_fired,
515	done_tmu,
516	done_smu,
517	smu_timing
518	);
519	*/
520	fHistSmuTime->Fill(smu_timing);
521
522	for (int iCtb=0; iCtb<12; iCtb++){
523	if ((ctb_fired >> iCtb) & 1)
524	fHistTriggerContribs->Fill(iSector, iCtb, 1);
525	}
526
527	Float_t first_tracklet_timing[5]={0};
528	Float_t last_tracklet_timing[5]={0};
529	Float_t tmu_timing[5]={0};
530	ULong64_t trkflags;
531
532	for (int iStack=0; iStack<5; iStack++){
533	trkflags = fRawReaderTrd->GetTrkFlags(iSector, iStack);
534	tmu_timing[iStack]=(trkflags & 0x3ff) * 0.02;
535	first_tracklet_timing[iStack]=((trkflags >> 20) & 0x3ff) * 0.008;
536	last_tracklet_timing[iStack]=((trkflags >> 10) & 0x3ff) * 0.008;
537	/*
538	printf(" Stack %02d_%d: 0x%016llx - first tracklet: %.2fus last tracklet: %.2fus tmu timing: %.2fus\n",
539	iSector, iStack, trkflags,
540	first_tracklet_timing[iStack], last_tracklet_timing[iStack], tmu_timing[iStack]
541	);
542	*/
543	fHistFirstTrackletTime->Fill(first_tracklet_timing[iStack]);
544	fHistLastTrackletTime->Fill(last_tracklet_timing[iStack]);
545	fHistTmuTime->Fill(tmu_timing[iStack]);
546	}
547
548	for (int iTracklet = 0; iTracklet < fTrackletArray->GetEntriesFast(); iTracklet++) {
549	AliTRDtrackletWord trackletWord = (AliTRDtrackletWord) ((*fTrackletArray)[iTracklet]);
e85c4f29	550	AliESDTrdTracklet tracklet(trackletWord->GetTrackletWord(), trackletWord->GetHCId());
ce6fd1b1	551	/*
ce6fd1b1	552	printf("TRDMSG: TRD tracklet found: 0x%08x - y=%+5d dy=%+3d pid=%3d\n",
e85c4f29	553	tracklet.GetTrackletWord(),
	554	tracklet.GetBinY(),
	555	tracklet.GetBinDy(),
	556	tracklet.GetPID());
ce6fd1b1	557	*/
ce6fd1b1	558	// fill some basic histograms right here
e85c4f29	559	fHistTrackletY->Fill(tracklet.GetBinY());
	560	fHistTrackletDy->Fill(tracklet.GetBinDy());
	561	fHistTrackletZ->Fill(tracklet.GetBinZ());
	562	fHistTrackletPID->Fill(tracklet.GetPID());
	563	fHistTrackletYDy->Fill(tracklet.GetBinY(), tracklet.GetBinDy());
	564	fHistTrackletHC->Fill(tracklet.GetHCId()/60, tracklet.GetHCId()%60);
	565
	566	if (TMath::Abs(tracklet.GetBinY()) >= 3682)
	567	fHistTrackletBadY->Fill(tracklet.GetHCId()/60, (tracklet.GetHCId()%60)/12);
	568
	569	if (tracklet.GetPID() < 40)
	570	fHistTrackletBadPID->Fill(tracklet.GetHCId()/60, (tracklet.GetHCId()%60)/12);
ce6fd1b1	571
	572	}
	573
	574	for (int iTrack = 0; iTrack < fGtuTrackArray->GetEntriesFast(); iTrack++) {
	575	AliESDTrdTrack trdTrack = (AliESDTrdTrack) ((*fGtuTrackArray)[iTrack]);
	576	/*
	577	printf("TRDMSG: GTU track found: 0x%016llx - Stack %02d_%d pt=%.3fGeV/c\n",
	578	trdTrack->GetTrackWord(0),
	579	trdTrack->GetSector(), trdTrack->GetStack(),
	580	trdTrack->Pt());
	581	*/
	582	fHistTrackPt->Fill(trdTrack->Pt());
	583	fHistTrackStack->Fill(trdTrack->GetSector(), trdTrack->GetStack());
	584	fHistTrackPID->Fill(trdTrack->GetPID());
	585
	586	Int_t layers=0;
	587	Int_t layer_mask = trdTrack->GetLayerMask();
	588	for (Int_t iLayer=0; iLayer<6; iLayer++)
	589	if ((layer_mask >> iLayer) & 1)
	590	layers++;
	591	fHistTrackletsTrack->Fill(layers);
	592	if (TMath::Abs(trdTrack->Pt()) >= 3.)
	593	fHistTrackletsTrackHpt->Fill(layers);
	594	}
	595
	596	// do more complex processing here, preferably in a dedicated class
	597
	598	// push TObject-based data to output
	599	iResult = PushBack(fHistArray,
	600	(kAliHLTDataTypeTObject \| kAliHLTDataOriginTRD),
	601	pBlock->fSpecification);
	602
79f07cf4	603	if (iResult < 0)
79f07cf4	604	break;
ce6fd1b1	605
	606	// clear the rawreader
	607	fRawReaderMem->ClearBuffers();
ce6fd1b1	608	}
	609
	610	return iResult;
	611	}
	612
	613	int AliHLTTRDMonitorComponent::Reconfigure(const char* /cdbEntry/, const char* /chainId/)
	614	{
	615	// reconfigure the component from the specified CDB entry, or default CDB entry
	616	// function is invoked by the framework if a reconfigure command was received.
	617	//
	618	int iResult=0;
	619	/*
	620	TString cdbPath;
	621	if (cdbEntry) {
	622	cdbPath=cdbEntry;
	623	} else {
	624	cdbPath="HLT/ConfigSample/";
	625	cdbPath+=GetComponentID();
	626	}
	627	AliInfoClass(Form("reconfigure '%s' from entry %s%s", chainId, cdbPath.Data(), cdbEntry?"":" (default)"));
	628	iResult=ConfigureFromCDBTObjString(cdbPath);
	629	*/
	630	return iResult;
	631	}
	632
	633	int AliHLTTRDMonitorComponent::ReadPreprocessorValues(const char* /modules/)
	634	{
	635	// read the preprocessor values for the detectors in the modules list
	636	// function is invoked by the framework if the pendolino indivates an update
	637	// of online calibration objects, e.g temperature and pressure measurements.
	638	int iResult=0;
	639	/*
	640	TString detectors(modules!=NULL?modules:"");
	641	AliInfoClass(Form("read preprocessor values for detector(s): %s", detectors.IsNull()?"none":detectors.Data()));
	642	*/
	643	return iResult;
	644	}