AlgDigitList.cxx

Go to the documentation of this file.

// $Id: AlgDigitList.cxx,v 1.15 2003/03/29 01:26:13 gmieg Exp $
//
// AlgDigitList.cxx
//
// AlgDigitList is a concrete DigitList Algorithm class.
//
// Author:  G. Irwin 4/2000

#include <cassert>

#include "Algorithm/AlgConfig.h"
#include "Algorithm/AlgFactory.h"
#include "Algorithm/AlgHandle.h"
#include "CandData/CandRecord.h"
#include "CandDigit/AlgDigitList.h"
#include "CandDigit/CandDigit.h"
#include "CandDigit/CandDigitHandle.h"
#include "CandDigit/CandDigitList.h"
#include "CandDigit/CandDigitListHandle.h"
#include "Candidate/CandContext.h"
#include "Conventions/Munits.h"
#include "MessageService/MsgService.h"
#include "Plex/PlexSEIdAltL.h"
#include "Plex/PlexSEIdAltLItem.h"
#include "RawData/RawDigit.h"
#include "RawData/RawRecord.h"
#include "RawData/RawDigitDataBlock.h"
#include "Validity/VldContext.h"
#include "Validity/VldTimeStamp.h"

#define ONLYSCINT
#ifdef ONLYSCINT
#include "Plex/PlexHandle.h"
#include "RawData/RawHeader.h"
#endif

ClassImp(AlgDigitList)

//______________________________________________________________________
CVSID("$Id: AlgDigitList.cxx,v 1.15 2003/03/29 01:26:13 gmieg Exp $");

//______________________________________________________________________
AlgDigitList::AlgDigitList()
{
}

//______________________________________________________________________
AlgDigitList::~AlgDigitList()
{
}

//______________________________________________________________________
void AlgDigitList::RunAlg(AlgConfig &ac, CandHandle &ch,
                                                        CandContext &cx)
{
#ifdef ENABLE_DEBUG_MSG
   MSG("AlgDigitList", Msg::kDebug)
                           << "Starting AlgDigitList::RunAlg()" << endl;
#endif

   assert(cx.GetDataIn());

// Get VldContext
   const VldContext &vldc = *(cx.GetCandRecord()->GetVldContext());

// Iterate over RawDigitDataBlock or CandDigitList daughters.
   if (cx.GetDataIn()->InheritsFrom("RawRecord")) {

#ifdef ONLYSCINT
     PlexHandle ph(vldc);
#endif

// Set up to iterate over input RawDigit's to fill output CandDigitList.

// Get Singleton instance of AlgFactory.
#ifdef ENABLE_DEBUG_MSG
     MSG("AlgDigitList", Msg::kDebug)
               << "AlgFactory &af = AlgFactory::GetInstance();" << endl;
#endif
     AlgFactory &af = AlgFactory::GetInstance();

// Get correct Algorithm by name from AlgFactory
     const char *tmpcs = 0;
     const char *digitalgorithm = 0;
     const char *digitalgconfig = 0;

     if (ac.Get("DigitAlgorithm", tmpcs)) digitalgorithm = tmpcs;
     if (ac.Get("DigitAlgConfig", tmpcs)) digitalgconfig = tmpcs;

// Get an AlgHandle to an Algorithm with requested AlgConfig.
#ifdef ENABLE_DEBUG_MSG
     MSG("AlgDigitList", Msg::kDebug)
         << "AlgHandle ah = af.GetAlgHandle("
         << digitalgorithm << ", "
         << digitalgconfig << ");" << endl;
#endif
     AlgHandle ah = af.GetAlgHandle(digitalgorithm, digitalgconfig);

#ifdef ENABLE_DEBUG_MSG
     MSG("AlgDigitList", Msg::kDebug)
                               << "Create CandContext instance." << endl
                                    << "CandContext cxx(this);" << endl;
#endif
     CandContext cxx(this, cx.GetMom());

// Set CandRecord pointer in CandContext.
#ifdef ENABLE_DEBUG_MSG
     MSG("AlgDigitList", Msg::kDebug)
                    << "Set CandRecord pointer in CandContext." << endl;
#endif
     cxx.SetCandRecord(cx.GetCandRecord());

     Bool_t isSparse = true;              // sparsified unless otherwise

// Iterate over RawRecord's RawDataBlockList to find RawDigitDataBlock.
     RawRecord *rr = (RawRecord *) (cx.GetDataIn());
     TIter rdbit = rr->GetRawBlockIter();
     TObject *tob;
     while ((tob = rdbit())) {
       if (tob->InheritsFrom("RawDigitDataBlock")) {
         RawDigitDataBlock *rdb = (RawDigitDataBlock *) tob;
         TIter rdit = rdb->GetDatumIter();
         RawDigit *rd;
         Int_t rawdigitindex = -1;

         Int_t ndigits = rdb->GetNumberOfDigits();
         Bool_t blkIsSparse = 
            ( rdb->GetNumberOfCrates() == rdb->GetNSparsModeCrates());
         isSparse &= blkIsSparse;
         if (!blkIsSparse) 
           MSG("AlgDigitList", Msg::kInfo) 
         << "AlgDigitList finds RawDigitDataBlock is Unsparsified with " 
                               << ndigits << " digits " << endl << endl;

         while ((rd = (RawDigit *) rdit())) { 
           ++rawdigitindex;

#ifdef ENABLE_DEBUG_MSG
           MSG("AlgDigitList", Msg::kDebug)
             << "Set RawDigit object as CandContext input data." << endl
                                        << "cxx.SetDataIn(rd);" << endl;
#endif

#ifdef ONLYSCINT
// skip all non-scint readouts
           if (ph.GetReadoutType(rd->GetChannel()) != 
               ReadoutType::kScintStrip) continue;
#endif

           cxx.SetDataIn(rd);

#ifdef ENABLE_DEBUG_MSG
           MSG("AlgDigitList", Msg::kDebug)
                  << "Get handle to CandDigit." << endl
                  << "cdh = CandDigit::MakeCandidate(ah, cxx);" << endl;
#endif

           CandDigitHandle cdh = CandDigit::MakeCandidate(ah, cxx);
           cdh.SetRawDigitIndex(rawdigitindex);

           ch.AddDaughterLink(cdh, kFALSE);      // Don't check for dups
         }
       }
     }

// Set absolute time offset in CandDigitList.
// It's no longer subtracted from CandDigits in AlgDigit.
     CandDigitListHandle &cdlh =
                                dynamic_cast<CandDigitListHandle &>(ch);
     cdlh.SetAbsTime(((Double_t) vldc.GetTimeStamp().GetNanoSec()) *
                                                    Munits::nanosecond);

// Set CandDigitList sparsification flag.
     cdlh.SetIsSparse(isSparse);
   }

   else if (cx.GetDataIn()->InheritsFrom("TCollection")) {
     TCollection *cdl = (TCollection *) cx.GetDataIn();
     TIter cdit(cdl);
     CandDigitHandle *cdh;
     while ((cdh = (CandDigitHandle *) cdit())) {
       ch.AddDaughterLink(*cdh, kFALSE);         // Don't check for dups
     }
   }
}

//______________________________________________________________________
void AlgDigitList::Trace(const char * /* c */) const
{
}

---