[u/mrichter/AliRoot.git] / MUON / AliMUONDigitMaker.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * 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$

//-----------------------------------------------------------------------------
/// \class AliMUONDigitMaker
/// MUON Digit maker from rawdata.
///
/// Raw2Digits:
/// Using real mapping  for tracker
/// Indranil Das (Adapted for runloader: Ch. Finck) july 05
///
/// Implemented non-constant buspatch numbers for tracking
/// with correct DDL id.
/// (Ch. Finck, dec 05)
///
/// Add reader for scaler trigger events
/// Use memcpy instead of assignment elt by elt
/// (Ch. Finck, Jan 06)
///
/// Using new interface with AliMUONRawStreamTracker(Trigger)
/// (New interface of AliMUONRawReader class)
/// (further details could be found in Alice-note)
/// (Ch. Finck, March 06)
///
/// Add (S)Digit maker tracker (for free)
/// and for trigger. Create trigger inverse mapping.
///
/// \author Ch. Finck, oct 06 
//-----------------------------------------------------------------------------

#include "AliMUONDigitMaker.h"

#include "AliMUONDDLTrigger.h"
#include "AliMUONDarcHeader.h"
#include "AliMUONVDigit.h"
#include "AliMUONVDigitStore.h"
#include "AliMUONGlobalTrigger.h"
#include "AliMUONLocalStruct.h"
#include "AliMUONLocalTrigger.h"
#include "AliMUONLogger.h"
#include "AliMUONRawStreamTracker.h"
#include "AliMUONRawStreamTrackerHP.h"
#include "AliMUONRawStreamTrigger.h"
#include "AliMUONRawStreamTriggerHP.h"
#include "AliMUONRegHeader.h"
#include "AliMUONTriggerCircuit.h"
#include "AliMUONVTriggerStore.h"
#include "AliMpDetElement.h"
#include "AliMpTriggerCrate.h"
#include "AliMpLocalBoard.h"
#include "AliMpCathodType.h"
#include "AliMpDDLStore.h"
#include "AliMpDEManager.h"
#include "AliMpPad.h"
#include "AliMpSegmentation.h"
#include "AliMpVSegmentation.h"
#include "AliCodeTimer.h"
#include "AliLog.h"
#include "AliRawReader.h"
#include <TArrayS.h>

/// \cond CLASSIMP
ClassImp(AliMUONDigitMaker) // Class implementation in ROOT context
/// \endcond

//__________________________________________________________________________
AliMUONDigitMaker::AliMUONDigitMaker(
      Bool_t enableErrorLogger,
      Bool_t useFastTrackerDecoder, Bool_t useFastTriggerDecoder
  ) :
    TObject(),
    fScalerEvent(kFALSE),
    fMakeTriggerDigits(kFALSE),
    fRawStreamTracker(NULL),
    fRawStreamTrigger(NULL),
    fDigitStore(0x0),
    fTriggerStore(0x0),
  fLogger(new AliMUONLogger(10000))
{
  /// ctor 

  AliDebug(1,"");
  
  CreateRawStreamTracker(useFastTrackerDecoder);
  CreateRawStreamTrigger(useFastTriggerDecoder);

  // Standard Constructor
  if (enableErrorLogger) {
    fRawStreamTracker->EnabbleErrorLogger();
    fRawStreamTrigger->EnabbleErrorLogger();
  }

  SetMakeTriggerDigits();

}

//__________________________________________________________________________
AliMUONDigitMaker::~AliMUONDigitMaker()
{
  /// clean up
  /// and time processing measure

  delete fRawStreamTracker;
  delete fRawStreamTrigger;
  delete fLogger;
}

//__________________________________________________________________________
void AliMUONDigitMaker::CreateRawStreamTracker(Bool_t useFastDecoder)
{
/// Create raw stream tracker according to the passed option

  if (useFastDecoder)
  {
    fRawStreamTracker = new AliMUONRawStreamTrackerHP();
  }
  else {
    AliInfo("Using non-high performance tracker decoder.");
    fRawStreamTracker = new AliMUONRawStreamTracker();
  }  
}

//__________________________________________________________________________
void AliMUONDigitMaker::CreateRawStreamTrigger(Bool_t useFastDecoder)
{
/// Create raw stream trigger according to the passed option

  if (useFastDecoder)
  {
    fRawStreamTrigger = new AliMUONRawStreamTriggerHP();
  }
  else {
    AliInfo("Using non-high performance tracker decoder.");
    fRawStreamTrigger = new AliMUONRawStreamTrigger();
  }  
}

//____________________________________________________________________
void
AliMUONDigitMaker::Print(Option_t*) const
{
  /// Printout

  cout << "RawStreamerTracker class=" << fRawStreamTracker->ClassName()
       << " MakeTriggerDigits=" << fMakeTriggerDigits
       << " ScalerEvent=" << fScalerEvent
       << " DigitStore=" << fDigitStore
       << " TriggerStore=" << fTriggerStore << endl;

  if ( fLogger ) fLogger->Print();
}

//____________________________________________________________________
Int_t
AliMUONDigitMaker::Raw2Digits(AliRawReader* rawReader, 
                                        AliMUONVDigitStore* digitStore,
                                        AliMUONVTriggerStore* triggerStore)
{
  /// Main method to creates digit
  /// for tracker 
  /// and trigger

  AliDebug(1,Form("rawReader=%p digitStore=%p triggerStore=%p",
                  rawReader,digitStore,triggerStore));
  
  fDigitStore = digitStore;
  fTriggerStore = triggerStore;
  
  if (!fDigitStore && !fTriggerStore)
  {
    fLogger->Log("No digit or trigger store given. Nothing to do...");
    return kTriggerBAD & kTrackerBAD;
  }
  
  Int_t tracker(kOK);
  Int_t trigger(kOK);
  
  if ( fDigitStore ) 
  {
    fDigitStore->Clear(); // insure we start with an empty container
    tracker = ReadTrackerDDL(rawReader);
  }
  
  if ( fTriggerStore || fMakeTriggerDigits ) 
  {
    if ( fTriggerStore ) fTriggerStore->Clear();
    if ( fMakeTriggerDigits && !fDigitStore ) 
    {
      fLogger->Log("Asking for trigger digits but digitStore is null");
    }
    else
    {
      trigger = ReadTriggerDDL(rawReader);
    }
  }
  
  return tracker | trigger;
}

//____________________________________________________________________
Int_t
AliMUONDigitMaker::ReadTrackerDDL(AliRawReader* rawReader)
{
  /// Reading tracker DDL
  /// filling the fDigitStore container, which must not be null

  AliDebug(1,"");
  
  AliCodeTimerAuto("");

  // elex info
  Int_t    buspatchId;
  UChar_t  channelId;
  UShort_t manuId;
  UShort_t charge; 

  fRawStreamTracker->SetReader(rawReader);
  fRawStreamTracker->First();
  
  while ( fRawStreamTracker->Next(buspatchId,manuId,channelId,charge) )
  {    
    // getting DE from buspatch
    Int_t detElemId = AliMpDDLStore::Instance()->GetDEfromBus(buspatchId);

    AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);

    if (!de)
      {
	fLogger->Log(Form("DE %04d does not exist !"));
	continue;
      }

    if (!de->IsConnectedChannel(manuId,channelId))
      {
	// non connected pad, do nothing (this is not an error !)
	continue;
      }

    const AliMpVSegmentation* seg 
      = AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId, 
                                                                      manuId);  

    if (!seg)
    {
      fLogger->Log(Form("(DE,MANUID)=(%04d,%04d) is not valid",detElemId,manuId));
      continue;
    }
    
    AliMp::CathodType cathodeType = de->GetCathodType(seg->PlaneType());

    AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,channelId),kFALSE);

    if (!pad.IsValid())
    {
      fLogger->Log(Form("No pad for detElemId: %d, manuId: %d, channelId: %d",
                    detElemId, manuId, channelId));
      continue;
    } 

    AliMUONVDigit* digit = fDigitStore->Add(detElemId,manuId,channelId,cathodeType,
                                            AliMUONVDigitStore::kDeny);

    if (!digit)
    {
      fLogger->Log(Form("Digit DE %04d Manu %04d Channel %02d could not be added",
                    detElemId, manuId, channelId));
      continue;
    }
    
    digit->SetPadXY(pad.GetIndices().GetFirst(),
                   pad.GetIndices().GetSecond());
    
	  digit->SetADC(charge);

  }
  
  if ( fRawStreamTracker->IsErrorMessage() ) 
  {
    return kTrackerBAD;
  }
  
  return kOK;
}

//____________________________________________________________________
Int_t
AliMUONDigitMaker::ReadTriggerDDL(AliRawReader* rawReader)
{
  /// reading tracker DDL
  /// filling the fTriggerStore container, which must not be null

  AliDebug(1,"");
  
  AliMUONDDLTrigger*       ddlTrigger      = 0x0;
  AliMUONDarcHeader*       darcHeader      = 0x0;
  AliMUONRegHeader*        regHeader       = 0x0;
  AliMUONLocalStruct*      localStruct     = 0x0;

  Int_t loCircuit;

  AliCodeTimerAuto("");
  
  if (UsingFastTriggerDecoder()) return ReadTriggerDDLFast(rawReader);

  fRawStreamTrigger->SetReader(rawReader);

  while (fRawStreamTrigger->NextDDL()) 
  {
    ddlTrigger = fRawStreamTrigger->GetDDLTrigger();
    darcHeader = ddlTrigger->GetDarcHeader();
    
    // fill global trigger information
    if (fTriggerStore) 
    {
      if (darcHeader->GetGlobalFlag()) 
      {
          AliMUONGlobalTrigger globalTrigger;
          globalTrigger.SetFromGlobalResponse(darcHeader->GetGlobalOutput());
          fTriggerStore->SetGlobal(globalTrigger);
      }
    }
    
    Int_t nReg = darcHeader->GetRegHeaderEntries();
    
    for(Int_t iReg = 0; iReg < nReg ;iReg++)
    {   //reg loop
      

      // crate info  
      AliMpTriggerCrate* crate = AliMpDDLStore::Instance()->
                                GetTriggerCrate(fRawStreamTrigger->GetDDL(), iReg);
      
      if (!crate) 
        fLogger->Log(Form("Missing crate number %d in DDL %d\n", iReg, fRawStreamTrigger->GetDDL()));
     
      
      regHeader =  darcHeader->GetRegHeaderEntry(iReg);
      
      Int_t nLocal = regHeader->GetLocalEntries();
      for(Int_t iLocal = 0; iLocal < nLocal; iLocal++) 
      {  
        
        localStruct = regHeader->GetLocalEntry(iLocal);
        
        // if card exist
        if (localStruct) {
          
   	  loCircuit = crate->GetLocalBoardId(localStruct->GetId());

	  if ( !loCircuit ) continue; // empty slot

	  AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(loCircuit, false);

	  // skip copy cards
	  if( !localBoard->IsNotified()) 
	     continue;
          
          if (fTriggerStore) 
          {
            // fill local trigger
            AliMUONLocalTrigger localTrigger;
            localTrigger.SetLocalStruct(loCircuit, *localStruct);
            fTriggerStore->Add(localTrigger);
          } 
          
          if ( fMakeTriggerDigits )
          {
            //FIXEME should find something better than a TArray
            TArrayS xyPattern[2];
            
	    localStruct->GetXPattern(xyPattern[0]);
	    localStruct->GetYPattern(xyPattern[1]);
            
            TriggerDigits(loCircuit, xyPattern, *fDigitStore);
          }          
        } // if triggerY
      } // iLocal
    } // iReg
  } // NextDDL
  
  return kOK;
}

//____________________________________________________________________
Int_t
AliMUONDigitMaker::ReadTriggerDDLFast(AliRawReader* rawReader)
{
  /// reading tracker DDL like ReadTriggerDDL but with fast decoder interface.
  /// filling the fTriggerStore container, which must not be null

  const AliMUONRawStreamTriggerHP::AliHeader*          darcHeader  = 0x0;
  const AliMUONRawStreamTriggerHP::AliRegionalHeader*  regHeader   = 0x0;
  const AliMUONRawStreamTriggerHP::AliLocalStruct*     localStruct = 0x0;

  Int_t loCircuit;

  fRawStreamTrigger->SetReader(rawReader);
  AliMUONRawStreamTriggerHP* rawStreamTrigger =
    dynamic_cast<AliMUONRawStreamTriggerHP*>(fRawStreamTrigger);

  while (fRawStreamTrigger->NextDDL())
  {
    darcHeader = rawStreamTrigger->GetHeaders();
    
    // fill global trigger information
    if (fTriggerStore) 
    {
      if (darcHeader->GetGlobalFlag()) 
      {
          AliMUONGlobalTrigger globalTrigger;
          globalTrigger.SetFromGlobalResponse(darcHeader->GetGlobalOutput());
          fTriggerStore->SetGlobal(globalTrigger);
      }
    }
    
    Int_t nReg = rawStreamTrigger->GetRegionalHeaderCount();
    
    for(Int_t iReg = 0; iReg < nReg ;iReg++)
    {   //reg loop
      

      // crate info  
      AliMpTriggerCrate* crate = AliMpDDLStore::Instance()->
                                GetTriggerCrate(fRawStreamTrigger->GetDDL(), iReg);
      
      if (!crate) 
        fLogger->Log(Form("Missing crate number %d in DDL %d\n", iReg, fRawStreamTrigger->GetDDL()));
     
      
      regHeader =  rawStreamTrigger->GetRegionalHeader(iReg);
      
      Int_t nLocal = regHeader->GetLocalStructCount();
      for(Int_t iLocal = 0; iLocal < nLocal; iLocal++) 
      {
        
        localStruct = regHeader->GetLocalStruct(iLocal);
        
        // if card exist
        if (localStruct) {
          
   	  loCircuit = crate->GetLocalBoardId(localStruct->GetId());

	  if ( !loCircuit ) continue; // empty slot

	  AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(loCircuit, kTRUE);

	  // skip copy cards
	  if( !localBoard->IsNotified()) 
	     continue;
          
          if (fTriggerStore)
          {
            // fill local trigger
            AliMUONLocalTrigger localTrigger;
            localTrigger.SetLoCircuit(loCircuit);
            localTrigger.SetLoStripX((Int_t)localStruct->GetXPos());
            localTrigger.SetLoStripY((Int_t)localStruct->GetYPos());
            localTrigger.SetLoDev((Int_t)localStruct->GetXDev());
            localTrigger.SetLoSdev((Int_t)localStruct->GetSXDev());
            localTrigger.SetLoTrigY((Int_t)localStruct->GetTrigY());
            localTrigger.SetLoLpt(localStruct->GetLpt());
            localTrigger.SetLoHpt(localStruct->GetHpt());
            localTrigger.SetX1Pattern(localStruct->GetX1());
            localTrigger.SetX2Pattern(localStruct->GetX2());
            localTrigger.SetX3Pattern(localStruct->GetX3());
            localTrigger.SetX4Pattern(localStruct->GetX4());
            localTrigger.SetY1Pattern(localStruct->GetY1());
            localTrigger.SetY2Pattern(localStruct->GetY2());
            localTrigger.SetY3Pattern(localStruct->GetY3());
            localTrigger.SetY4Pattern(localStruct->GetY4());
            fTriggerStore->Add(localTrigger);
          }
          
          if ( fMakeTriggerDigits )
          {
            //FIXEME should find something better than a TArray
            TArrayS xyPattern[2];
            
	    localStruct->GetXPattern(xyPattern[0]);
	    localStruct->GetYPattern(xyPattern[1]);
            
            TriggerDigits(loCircuit, xyPattern, *fDigitStore);
          }
        } // if triggerY
      } // iLocal
    } // iReg
  } // NextDDL
  
  return kOK;
}

//____________________________________________________________________
Int_t AliMUONDigitMaker::TriggerDigits(Int_t nBoard, 
                                       TArrayS* xyPattern,
                                       AliMUONVDigitStore& digitStore) const
{
  /// make digits for trigger from pattern, and add them to digitStore

  AliCodeTimerAuto("");
  
  Int_t detElemId;

  AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(nBoard);

  Int_t n,b;

  // loop over x1-4 and y1-4
  for (Int_t iChamber = 0; iChamber < 4; ++iChamber)
  {
    for (Int_t iCath = 0; iCath < 2; ++iCath)
    {
      Int_t pattern = (Int_t)xyPattern[iCath].At(iChamber); 
      if (!pattern) continue;
      
      // get detElemId
      detElemId = AliMpDDLStore::Instance()->GetDEfromLocalBoard(nBoard, iChamber);
        
        const AliMpVSegmentation* seg 
          = AliMpSegmentation::Instance()
          ->GetMpSegmentation(detElemId, AliMp::GetCathodType(iCath));  
        
        // loop over the 16 bits of pattern
        for (Int_t ibitxy = 0; ibitxy < 16; ++ibitxy) 
        {
          if ((pattern >> ibitxy) & 0x1) 
          {            
            // not quite sure about this
            Int_t offset = 0;
            if (iCath && localBoard->GetSwitch(6)) offset = -8;
            
            AliMpPad pad = seg->PadByLocation(AliMpIntPair(nBoard,ibitxy+offset),kTRUE);
                        
            if (!pad.IsValid()) 
            {
              fLogger->Log(Form("No pad for detElemId: %d, nboard %d, ibitxy: %d\n",
                              detElemId, nBoard, ibitxy));
              continue;
            }

            n = pad.GetLocation(0).GetFirst(); // always take first location so that digits are not inserted several times
	    b = pad.GetLocation(0).GetSecond();

	    AliDebug(1,Form("Using localBoard %d ixy %d instead of %d,%d",
			    n,b,nBoard,ibitxy));

	    AliMUONVDigit* digit = digitStore.Add(detElemId,n,b,iCath,AliMUONVDigitStore::kDeny);
            
            if (!digit)
            {
		AliDebug(1, Form("Digit DE %04d LocalBoard %03d ibitxy %02d cath %d already in store",
				 detElemId,nBoard,ibitxy,iCath));
		continue;
            }
            
            Int_t padX = pad.GetIndices().GetFirst();
            Int_t padY = pad.GetIndices().GetSecond();
            
            // fill digit
            digit->SetPadXY(padX,padY);
            digit->SetCharge(1.);
          }// xyPattern
        }// ibitxy
    }// cath
  } // ichamber
  
  return kTRUE;
}

//____________________________________________________________________
Bool_t AliMUONDigitMaker::UsingFastTrackerDecoder() const
{
/// Returns kTRUE if the digit maker is using the high performance decoder for
/// tracker DDL stream decoding.

  return (fRawStreamTracker->IsA() == AliMUONRawStreamTrackerHP::Class());
}

//____________________________________________________________________
Bool_t AliMUONDigitMaker::UsingFastTriggerDecoder() const
{
/// Returns kTRUE if the digit maker is using the high performance decoder for
/// trigger DDL stream decoding.

  return (fRawStreamTrigger->IsA() == AliMUONRawStreamTriggerHP::Class());
}

//____________________________________________________________________
void  AliMUONDigitMaker::SetFastTrackerDecoder(Bool_t useFastDecoder)
{
/// Set fast raw data decoder

  delete fRawStreamTracker;
  CreateRawStreamTracker(useFastDecoder);
}

//____________________________________________________________________
void  AliMUONDigitMaker::SetFastTriggerDecoder(Bool_t useFastDecoder)
{
/// Set fast raw data decoder

  delete fRawStreamTrigger;
  CreateRawStreamTrigger(useFastDecoder);
}
Commit	Line	Data
a3283a4c	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	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
3d1463c8	16	// $Id$
	17
	18	//-----------------------------------------------------------------------------
9265505b	19	/// \class AliMUONDigitMaker
8c51a32f	20	/// MUON Digit maker from rawdata.
a3283a4c	21	///
	22	/// Raw2Digits:
	23	/// Using real mapping for tracker
	24	/// Indranil Das (Adapted for runloader: Ch. Finck) july 05
8c51a32f	25	///
	26	/// Implemented non-constant buspatch numbers for tracking
	27	/// with correct DDL id.
	28	/// (Ch. Finck, dec 05)
	29	///
a3283a4c	30	/// Add reader for scaler trigger events
	31	/// Use memcpy instead of assignment elt by elt
	32	/// (Ch. Finck, Jan 06)
8c51a32f	33	///
	34	/// Using new interface with AliMUONRawStreamTracker(Trigger)
	35	/// (New interface of AliMUONRawReader class)
	36	/// (further details could be found in Alice-note)
	37	/// (Ch. Finck, March 06)
	38	///
	39	/// Add (S)Digit maker tracker (for free)
	40	/// and for trigger. Create trigger inverse mapping.
78649106	41	///
78649106	42	/// \author Ch. Finck, oct 06
3d1463c8	43	//-----------------------------------------------------------------------------
a3283a4c	44
a3283a4c	45	#include "AliMUONDigitMaker.h"
a3283a4c	46
a3283a4c	47	#include "AliMUONDDLTrigger.h"
a3283a4c	48	#include "AliMUONDarcHeader.h"
40e382ae	49	#include "AliMUONVDigit.h"
	50	#include "AliMUONVDigitStore.h"
	51	#include "AliMUONGlobalTrigger.h"
a3283a4c	52	#include "AliMUONLocalStruct.h"
a3283a4c	53	#include "AliMUONLocalTrigger.h"
0145e89a	54	#include "AliMUONLogger.h"
40e382ae	55	#include "AliMUONRawStreamTracker.h"
e3a2b9c9	56	#include "AliMUONRawStreamTrackerHP.h"
40e382ae	57	#include "AliMUONRawStreamTrigger.h"
481d8064	58	#include "AliMUONRawStreamTriggerHP.h"
40e382ae	59	#include "AliMUONRegHeader.h"
e1a10d41	60	#include "AliMUONTriggerCircuit.h"
be63c782	61	#include "AliMUONVTriggerStore.h"
be63c782	62	#include "AliMpDetElement.h"
d9b1ecb0	63	#include "AliMpTriggerCrate.h"
d9b1ecb0	64	#include "AliMpLocalBoard.h"
40e382ae	65	#include "AliMpCathodType.h"
	66	#include "AliMpDDLStore.h"
	67	#include "AliMpDEManager.h"
	68	#include "AliMpPad.h"
9265505b	69	#include "AliMpSegmentation.h"
a3283a4c	70	#include "AliMpVSegmentation.h"
be63c782	71	#include "AliCodeTimer.h"
be63c782	72	#include "AliLog.h"
9265505b	73	#include "AliRawReader.h"
7771752e	74	#include <TArrayS.h>
9265505b	75
9265505b	76	/// \cond CLASSIMP
a3283a4c	77	ClassImp(AliMUONDigitMaker) // Class implementation in ROOT context
9265505b	78	/// \endcond
9265505b	79
a3283a4c	80	//__________________________________________________________________________
481d8064	81	AliMUONDigitMaker::AliMUONDigitMaker(
	82	Bool_t enableErrorLogger,
	83	Bool_t useFastTrackerDecoder, Bool_t useFastTriggerDecoder
	84	) :
	85	TObject(),
9f5dcca3	86	fScalerEvent(kFALSE),
40e382ae	87	fMakeTriggerDigits(kFALSE),
e3a2b9c9	88	fRawStreamTracker(NULL),
481d8064	89	fRawStreamTrigger(NULL),
40e382ae	90	fDigitStore(0x0),
0145e89a	91	fTriggerStore(0x0),
0145e89a	92	fLogger(new AliMUONLogger(10000))
a3283a4c	93	{
40e382ae	94	/// ctor
a3283a4c	95
a3283a4c	96	AliDebug(1,"");
e3a2b9c9	97
481d8064	98	CreateRawStreamTracker(useFastTrackerDecoder);
481d8064	99	CreateRawStreamTrigger(useFastTriggerDecoder);
a3283a4c	100
a3283a4c	101	// Standard Constructor
3c7f5307	102	if (enableErrorLogger) {
	103	fRawStreamTracker->EnabbleErrorLogger();
	104	fRawStreamTrigger->EnabbleErrorLogger();
	105	}
a3283a4c	106
40e382ae	107	SetMakeTriggerDigits();
a3283a4c	108
	109	}
	110
a3283a4c	111	//__________________________________________________________________________
9f5dcca3	112	AliMUONDigitMaker::~AliMUONDigitMaker()
a3283a4c	113	{
9265505b	114	/// clean up
	115	/// and time processing measure
	116
a3283a4c	117	delete fRawStreamTracker;
a3283a4c	118	delete fRawStreamTrigger;
0145e89a	119	delete fLogger;
a3283a4c	120	}
a3283a4c	121
d61f56df	122	//__________________________________________________________________________
	123	void AliMUONDigitMaker::CreateRawStreamTracker(Bool_t useFastDecoder)
	124	{
	125	/// Create raw stream tracker according to the passed option
	126
	127	if (useFastDecoder)
	128	{
d61f56df	129	fRawStreamTracker = new AliMUONRawStreamTrackerHP();
d61f56df	130	}
5f3519d9	131	else {
5f3519d9	132	AliInfo("Using non-high performance tracker decoder.");
d61f56df	133	fRawStreamTracker = new AliMUONRawStreamTracker();
5f3519d9	134	}
481d8064	135	}
	136
	137	//__________________________________________________________________________
	138	void AliMUONDigitMaker::CreateRawStreamTrigger(Bool_t useFastDecoder)
	139	{
	140	/// Create raw stream trigger according to the passed option
	141
	142	if (useFastDecoder)
	143	{
481d8064	144	fRawStreamTrigger = new AliMUONRawStreamTriggerHP();
481d8064	145	}
5f3519d9	146	else {
5f3519d9	147	AliInfo("Using non-high performance tracker decoder.");
481d8064	148	fRawStreamTrigger = new AliMUONRawStreamTrigger();
5f3519d9	149	}
481d8064	150	}
d61f56df	151
a3283a4c	152	//____________________________________________________________________
be63c782	153	void
	154	AliMUONDigitMaker::Print(Option_t*) const
	155	{
	156	/// Printout
	157
	158	cout << "RawStreamerTracker class=" << fRawStreamTracker->ClassName()
	159	<< " MakeTriggerDigits=" << fMakeTriggerDigits
	160	<< " ScalerEvent=" << fScalerEvent
	161	<< " DigitStore=" << fDigitStore
	162	<< " TriggerStore=" << fTriggerStore << endl;
	163
	164	if ( fLogger ) fLogger->Print();
	165	}
	166
	167	//____________________________________________________________________
	168	Int_t
	169	AliMUONDigitMaker::Raw2Digits(AliRawReader* rawReader,
	170	AliMUONVDigitStore* digitStore,
	171	AliMUONVTriggerStore* triggerStore)
a3283a4c	172	{
9265505b	173	/// Main method to creates digit
	174	/// for tracker
	175	/// and trigger
a3283a4c	176
40e382ae	177	AliDebug(1,Form("rawReader=%p digitStore=%p triggerStore=%p",
	178	rawReader,digitStore,triggerStore));
	179
	180	fDigitStore = digitStore;
	181	fTriggerStore = triggerStore;
	182
	183	if (!fDigitStore && !fTriggerStore)
	184	{
0145e89a	185	fLogger->Log("No digit or trigger store given. Nothing to do...");
be63c782	186	return kTriggerBAD & kTrackerBAD;
40e382ae	187	}
40e382ae	188
be63c782	189	Int_t tracker(kOK);
	190	Int_t trigger(kOK);
	191
40e382ae	192	if ( fDigitStore )
	193	{
	194	fDigitStore->Clear(); // insure we start with an empty container
be63c782	195	tracker = ReadTrackerDDL(rawReader);
40e382ae	196	}
	197
	198	if ( fTriggerStore \|\| fMakeTriggerDigits )
	199	{
	200	if ( fTriggerStore ) fTriggerStore->Clear();
	201	if ( fMakeTriggerDigits && !fDigitStore )
	202	{
0145e89a	203	fLogger->Log("Asking for trigger digits but digitStore is null");
40e382ae	204	}
	205	else
	206	{
be63c782	207	trigger = ReadTriggerDDL(rawReader);
40e382ae	208	}
	209	}
	210
be63c782	211	return tracker \| trigger;
a3283a4c	212	}
	213
	214	//____________________________________________________________________
be63c782	215	Int_t
be63c782	216	AliMUONDigitMaker::ReadTrackerDDL(AliRawReader* rawReader)
a3283a4c	217	{
40e382ae	218	/// Reading tracker DDL
40e382ae	219	/// filling the fDigitStore container, which must not be null
a3283a4c	220
40e382ae	221	AliDebug(1,"");
40e382ae	222
0145e89a	223	AliCodeTimerAuto("");
a3283a4c	224
	225	// elex info
	226	Int_t buspatchId;
	227	UChar_t channelId;
	228	UShort_t manuId;
a3283a4c	229	UShort_t charge;
a3283a4c	230
a3283a4c	231	fRawStreamTracker->SetReader(rawReader);
1bc885f3	232	fRawStreamTracker->First();
	233
	234	while ( fRawStreamTracker->Next(buspatchId,manuId,channelId,charge) )
	235	{
40e382ae	236	// getting DE from buspatch
40e382ae	237	Int_t detElemId = AliMpDDLStore::Instance()->GetDEfromBus(buspatchId);
a3283a4c	238
be63c782	239	AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
	240
	241	if (!de)
	242	{
	243	fLogger->Log(Form("DE %04d does not exist !"));
	244	continue;
	245	}
	246
	247	if (!de->IsConnectedChannel(manuId,channelId))
	248	{
	249	// non connected pad, do nothing (this is not an error !)
	250	continue;
	251	}
	252
40e382ae	253	const AliMpVSegmentation* seg
	254	= AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,
	255	manuId);
a3283a4c	256
0145e89a	257	if (!seg)
	258	{
	259	fLogger->Log(Form("(DE,MANUID)=(%04d,%04d) is not valid",detElemId,manuId));
	260	continue;
	261	}
	262
be63c782	263	AliMp::CathodType cathodeType = de->GetCathodType(seg->PlaneType());
1bc885f3	264
40e382ae	265	AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,channelId),kFALSE);
be63c782	266
40e382ae	267	if (!pad.IsValid())
40e382ae	268	{
0145e89a	269	fLogger->Log(Form("No pad for detElemId: %d, manuId: %d, channelId: %d",
40e382ae	270	detElemId, manuId, channelId));
	271	continue;
	272	}
be63c782	273
40e382ae	274	AliMUONVDigit* digit = fDigitStore->Add(detElemId,manuId,channelId,cathodeType,
40e382ae	275	AliMUONVDigitStore::kDeny);
be63c782	276
40e382ae	277	if (!digit)
40e382ae	278	{
0145e89a	279	fLogger->Log(Form("Digit DE %04d Manu %04d Channel %02d could not be added",
40e382ae	280	detElemId, manuId, channelId));
	281	continue;
	282	}
	283
	284	digit->SetPadXY(pad.GetIndices().GetFirst(),
	285	pad.GetIndices().GetSecond());
	286
	287	digit->SetADC(charge);
9265505b	288
40e382ae	289	}
a3283a4c	290
be63c782	291	if ( fRawStreamTracker->IsErrorMessage() )
	292	{
	293	return kTrackerBAD;
	294	}
	295
	296	return kOK;
a3283a4c	297	}
	298
	299	//____________________________________________________________________
be63c782	300	Int_t
be63c782	301	AliMUONDigitMaker::ReadTriggerDDL(AliRawReader* rawReader)
a3283a4c	302	{
9265505b	303	/// reading tracker DDL
40e382ae	304	/// filling the fTriggerStore container, which must not be null
a3283a4c	305
40e382ae	306	AliDebug(1,"");
40e382ae	307
a3283a4c	308	AliMUONDDLTrigger* ddlTrigger = 0x0;
	309	AliMUONDarcHeader* darcHeader = 0x0;
	310	AliMUONRegHeader* regHeader = 0x0;
	311	AliMUONLocalStruct* localStruct = 0x0;
	312
	313	Int_t loCircuit;
d2d759cf	314
0145e89a	315	AliCodeTimerAuto("");
481d8064	316
481d8064	317	if (UsingFastTriggerDecoder()) return ReadTriggerDDLFast(rawReader);
a3283a4c	318
	319	fRawStreamTrigger->SetReader(rawReader);
	320
40e382ae	321	while (fRawStreamTrigger->NextDDL())
40e382ae	322	{
a3283a4c	323	ddlTrigger = fRawStreamTrigger->GetDDLTrigger();
a3283a4c	324	darcHeader = ddlTrigger->GetDarcHeader();
40e382ae	325
	326	// fill global trigger information
	327	if (fTriggerStore)
	328	{
	329	if (darcHeader->GetGlobalFlag())
	330	{
	331	AliMUONGlobalTrigger globalTrigger;
	332	globalTrigger.SetFromGlobalResponse(darcHeader->GetGlobalOutput());
	333	fTriggerStore->SetGlobal(globalTrigger);
d2d759cf	334	}
a3283a4c	335	}
40e382ae	336
a3283a4c	337	Int_t nReg = darcHeader->GetRegHeaderEntries();
40e382ae	338
	339	for(Int_t iReg = 0; iReg < nReg ;iReg++)
	340	{ //reg loop
	341
d9b1ecb0	342
	343	// crate info
	344	AliMpTriggerCrate* crate = AliMpDDLStore::Instance()->
	345	GetTriggerCrate(fRawStreamTrigger->GetDDL(), iReg);
40e382ae	346
d53fb0de	347	if (!crate)
0145e89a	348	fLogger->Log(Form("Missing crate number %d in DDL %d\n", iReg, fRawStreamTrigger->GetDDL()));
d9b1ecb0	349
40e382ae	350
a3283a4c	351	regHeader = darcHeader->GetRegHeaderEntry(iReg);
40e382ae	352
a3283a4c	353	Int_t nLocal = regHeader->GetLocalEntries();
40e382ae	354	for(Int_t iLocal = 0; iLocal < nLocal; iLocal++)
	355	{
	356
	357	localStruct = regHeader->GetLocalEntry(iLocal);
	358
	359	// if card exist
	360	if (localStruct) {
	361
d9b1ecb0	362	loCircuit = crate->GetLocalBoardId(localStruct->GetId());
	363
	364	if ( !loCircuit ) continue; // empty slot
	365
	366	AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(loCircuit, false);
	367
	368	// skip copy cards
	369	if( !localBoard->IsNotified())
	370	continue;
40e382ae	371
	372	if (fTriggerStore)
	373	{
	374	// fill local trigger
	375	AliMUONLocalTrigger localTrigger;
	376	localTrigger.SetLocalStruct(loCircuit, *localStruct);
	377	fTriggerStore->Add(localTrigger);
	378	}
	379
	380	if ( fMakeTriggerDigits )
	381	{
	382	//FIXEME should find something better than a TArray
	383	TArrayS xyPattern[2];
40e382ae	384
d9b1ecb0	385	localStruct->GetXPattern(xyPattern[0]);
d9b1ecb0	386	localStruct->GetYPattern(xyPattern[1]);
40e382ae	387
	388	TriggerDigits(loCircuit, xyPattern, *fDigitStore);
	389	}
	390	} // if triggerY
a3283a4c	391	} // iLocal
	392	} // iReg
	393	} // NextDDL
40e382ae	394
be63c782	395	return kOK;
a3283a4c	396	}
7771752e	397
481d8064	398	//____________________________________________________________________
	399	Int_t
	400	AliMUONDigitMaker::ReadTriggerDDLFast(AliRawReader* rawReader)
	401	{
	402	/// reading tracker DDL like ReadTriggerDDL but with fast decoder interface.
	403	/// filling the fTriggerStore container, which must not be null
	404
	405	const AliMUONRawStreamTriggerHP::AliHeader* darcHeader = 0x0;
	406	const AliMUONRawStreamTriggerHP::AliRegionalHeader* regHeader = 0x0;
	407	const AliMUONRawStreamTriggerHP::AliLocalStruct* localStruct = 0x0;
	408
	409	Int_t loCircuit;
	410
	411	fRawStreamTrigger->SetReader(rawReader);
	412	AliMUONRawStreamTriggerHP* rawStreamTrigger =
	413	dynamic_cast<AliMUONRawStreamTriggerHP*>(fRawStreamTrigger);
	414
	415	while (fRawStreamTrigger->NextDDL())
	416	{
	417	darcHeader = rawStreamTrigger->GetHeaders();
	418
	419	// fill global trigger information
	420	if (fTriggerStore)
	421	{
	422	if (darcHeader->GetGlobalFlag())
	423	{
	424	AliMUONGlobalTrigger globalTrigger;
	425	globalTrigger.SetFromGlobalResponse(darcHeader->GetGlobalOutput());
	426	fTriggerStore->SetGlobal(globalTrigger);
	427	}
	428	}
	429
	430	Int_t nReg = rawStreamTrigger->GetRegionalHeaderCount();
	431
	432	for(Int_t iReg = 0; iReg < nReg ;iReg++)
	433	{ //reg loop
	434
	435
	436	// crate info
	437	AliMpTriggerCrate* crate = AliMpDDLStore::Instance()->
	438	GetTriggerCrate(fRawStreamTrigger->GetDDL(), iReg);
	439
	440	if (!crate)
	441	fLogger->Log(Form("Missing crate number %d in DDL %d\n", iReg, fRawStreamTrigger->GetDDL()));
	442
	443
	444	regHeader = rawStreamTrigger->GetRegionalHeader(iReg);
	445
	446	Int_t nLocal = regHeader->GetLocalStructCount();
	447	for(Int_t iLocal = 0; iLocal < nLocal; iLocal++)
	448	{
	449
	450	localStruct = regHeader->GetLocalStruct(iLocal);
	451
	452	// if card exist
	453	if (localStruct) {
	454
	455	loCircuit = crate->GetLocalBoardId(localStruct->GetId());
	456
	457	if ( !loCircuit ) continue; // empty slot
	458
1ffbeb9d	459	AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(loCircuit, kTRUE);
481d8064	460
	461	// skip copy cards
	462	if( !localBoard->IsNotified())
	463	continue;
	464
	465	if (fTriggerStore)
	466	{
	467	// fill local trigger
	468	AliMUONLocalTrigger localTrigger;
	469	localTrigger.SetLoCircuit(loCircuit);
	470	localTrigger.SetLoStripX((Int_t)localStruct->GetXPos());
	471	localTrigger.SetLoStripY((Int_t)localStruct->GetYPos());
	472	localTrigger.SetLoDev((Int_t)localStruct->GetXDev());
	473	localTrigger.SetLoSdev((Int_t)localStruct->GetSXDev());
	474	localTrigger.SetLoTrigY((Int_t)localStruct->GetTrigY());
	475	localTrigger.SetLoLpt(localStruct->GetLpt());
	476	localTrigger.SetLoHpt(localStruct->GetHpt());
	477	localTrigger.SetX1Pattern(localStruct->GetX1());
	478	localTrigger.SetX2Pattern(localStruct->GetX2());
	479	localTrigger.SetX3Pattern(localStruct->GetX3());
	480	localTrigger.SetX4Pattern(localStruct->GetX4());
	481	localTrigger.SetY1Pattern(localStruct->GetY1());
	482	localTrigger.SetY2Pattern(localStruct->GetY2());
	483	localTrigger.SetY3Pattern(localStruct->GetY3());
	484	localTrigger.SetY4Pattern(localStruct->GetY4());
	485	fTriggerStore->Add(localTrigger);
	486	}
	487
	488	if ( fMakeTriggerDigits )
	489	{
	490	//FIXEME should find something better than a TArray
	491	TArrayS xyPattern[2];
	492
	493	localStruct->GetXPattern(xyPattern[0]);
	494	localStruct->GetYPattern(xyPattern[1]);
	495
	496	TriggerDigits(loCircuit, xyPattern, *fDigitStore);
	497	}
	498	} // if triggerY
	499	} // iLocal
	500	} // iReg
	501	} // NextDDL
	502
	503	return kOK;
	504	}
	505
d2d759cf	506	//____________________________________________________________________
7771752e	507	Int_t AliMUONDigitMaker::TriggerDigits(Int_t nBoard,
40e382ae	508	TArrayS* xyPattern,
40e382ae	509	AliMUONVDigitStore& digitStore) const
d2d759cf	510	{
40e382ae	511	/// make digits for trigger from pattern, and add them to digitStore
d2d759cf	512
0145e89a	513	AliCodeTimerAuto("");
0145e89a	514
d9b1ecb0	515	Int_t detElemId;
	516
	517	AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(nBoard);
	518
8c0b5e70	519	Int_t n,b;
8c0b5e70	520
d2d759cf	521	// loop over x1-4 and y1-4
40e382ae	522	for (Int_t iChamber = 0; iChamber < 4; ++iChamber)
	523	{
	524	for (Int_t iCath = 0; iCath < 2; ++iCath)
	525	{
7771752e	526	Int_t pattern = (Int_t)xyPattern[iCath].At(iChamber);
7771752e	527	if (!pattern) continue;
40e382ae	528
7771752e	529	// get detElemId
d9b1ecb0	530	detElemId = AliMpDDLStore::Instance()->GetDEfromLocalBoard(nBoard, iChamber);
40e382ae	531
	532	const AliMpVSegmentation* seg
	533	= AliMpSegmentation::Instance()
	534	->GetMpSegmentation(detElemId, AliMp::GetCathodType(iCath));
	535
	536	// loop over the 16 bits of pattern
	537	for (Int_t ibitxy = 0; ibitxy < 16; ++ibitxy)
	538	{
	539	if ((pattern >> ibitxy) & 0x1)
	540	{
	541	// not quite sure about this
	542	Int_t offset = 0;
	543	if (iCath && localBoard->GetSwitch(6)) offset = -8;
	544
	545	AliMpPad pad = seg->PadByLocation(AliMpIntPair(nBoard,ibitxy+offset),kTRUE);
	546
	547	if (!pad.IsValid())
	548	{
0145e89a	549	fLogger->Log(Form("No pad for detElemId: %d, nboard %d, ibitxy: %d\n",
40e382ae	550	detElemId, nBoard, ibitxy));
	551	continue;
	552	}
8c0b5e70	553
	554	n = pad.GetLocation(0).GetFirst(); // always take first location so that digits are not inserted several times
	555	b = pad.GetLocation(0).GetSecond();
	556
	557	AliDebug(1,Form("Using localBoard %d ixy %d instead of %d,%d",
	558	n,b,nBoard,ibitxy));
	559
	560	AliMUONVDigit* digit = digitStore.Add(detElemId,n,b,iCath,AliMUONVDigitStore::kDeny);
40e382ae	561
	562	if (!digit)
	563	{
8c0b5e70	564	AliDebug(1, Form("Digit DE %04d LocalBoard %03d ibitxy %02d cath %d already in store",
	565	detElemId,nBoard,ibitxy,iCath));
	566	continue;
40e382ae	567	}
	568
	569	Int_t padX = pad.GetIndices().GetFirst();
	570	Int_t padY = pad.GetIndices().GetSecond();
	571
	572	// fill digit
	573	digit->SetPadXY(padX,padY);
	574	digit->SetCharge(1.);
	575	}// xyPattern
	576	}// ibitxy
7771752e	577	}// cath
7771752e	578	} // ichamber
40e382ae	579
d2d759cf	580	return kTRUE;
481d8064	581	}
d61f56df	582
d61f56df	583	//____________________________________________________________________
481d8064	584	Bool_t AliMUONDigitMaker::UsingFastTrackerDecoder() const
	585	{
	586	/// Returns kTRUE if the digit maker is using the high performance decoder for
	587	/// tracker DDL stream decoding.
	588
	589	return (fRawStreamTracker->IsA() == AliMUONRawStreamTrackerHP::Class());
	590	}
	591
	592	//____________________________________________________________________
	593	Bool_t AliMUONDigitMaker::UsingFastTriggerDecoder() const
	594	{
	595	/// Returns kTRUE if the digit maker is using the high performance decoder for
	596	/// trigger DDL stream decoding.
	597
	598	return (fRawStreamTrigger->IsA() == AliMUONRawStreamTriggerHP::Class());
	599	}
	600
	601	//____________________________________________________________________
	602	void AliMUONDigitMaker::SetFastTrackerDecoder(Bool_t useFastDecoder)
d61f56df	603	{
	604	/// Set fast raw data decoder
	605
	606	delete fRawStreamTracker;
	607	CreateRawStreamTracker(useFastDecoder);
481d8064	608	}
	609
	610	//____________________________________________________________________
	611	void AliMUONDigitMaker::SetFastTriggerDecoder(Bool_t useFastDecoder)
	612	{
	613	/// Set fast raw data decoder
	614
	615	delete fRawStreamTrigger;
	616	CreateRawStreamTrigger(useFastDecoder);
	617	}
d61f56df	618