AlgChopListFar.cxx

Go to the documentation of this file.

// $Id: AlgChopListFar.cxx,v 1.4 2009/02/28 21:46:11 gmieg Exp $
//
// AlgChopListFar.cxx
//

#include <algorithm>
#include <cassert>

#include "CandChop/AlgChopListFar.h"
#include "CandChop/CandChopListHandle.h"
#include "CandChop/DigitVector.h"


#include "Algorithm/AlgConfig.h"
#include "Algorithm/AlgFactory.h"
#include "Algorithm/AlgHandle.h"
#include "CandData/CandHeader.h"
#include "CandData/CandRecord.h"
#include "CandDigit/CandDigitHandle.h"
#include "CandDigit/CandDigitListHandle.h"
#include "CandDigit/CandDigitList.h"
#include "Candidate/CandContext.h"
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "RawData/RawHeader.h"
#include "RawData/RawRecord.h"
#include "RawData/RawDigitDataBlock.h"
#include "UgliGeometry/UgliGeomHandle.h"
#include "UgliGeometry/UgliStripHandle.h"
#include "Validity/VldContext.h"

ClassImp(AlgChopListFar)
CVSID( " $Id: AlgChopListFar.cxx,v 1.4 2009/02/28 21:46:11 gmieg Exp $ ");

struct compareDigitTimes : public binary_function<const CandDigitHandle&, const CandDigitHandle&, bool> {
  bool operator()(const CandDigitHandle& d1, const CandDigitHandle& d2) {
    return (d1.GetTime() < d2.GetTime());
  }
};


//______________________________________________________________________
AlgChopListFar::AlgChopListFar()
{
}

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

//______________________________________________________________________

void AlgChopListFar::RunAlg(AlgConfig &algConfig, 
                           CandHandle &candHandle,  // thing to make
                           CandContext &candContext)
{
  assert(candHandle.InheritsFrom("CandChopListHandle"));
  CandChopListHandle &sliceList = dynamic_cast<CandChopListHandle &>(candHandle);

   assert(candContext.GetDataIn());
   // Check for CandDigitListHandle input
   if (!(candContext.GetDataIn()->InheritsFrom("CandDigitListHandle"))) {
     MSG("Chop",Msg::kWarning ) << "Data into AlgChopListFar is not a digit list." << std::endl;
   }
   
   const CandDigitListHandle *cdlh_ptr = 
     dynamic_cast<const CandDigitListHandle*>(candContext.GetDataIn());
   
   const MomNavigator *mom = candContext.GetMom();
   RawRecord *rr = dynamic_cast<RawRecord *>(mom->GetFragment("RawRecord"));
   if (!rr) {
     MSG("Chop", Msg::kWarning) << "No RawRecord in MOM." << endl;
     return;
   }
   const RawDigitDataBlock *rddb = dynamic_cast<const RawDigitDataBlock *>
     (rr->FindRawBlock("RawDigitDataBlock"));
   if (!rddb) {
     MSG("Chop", Msg::kWarning) << "No RawDigitDataBlock in RawRecord." << endl;
     return;
   }
   
   // Get setup for the DigitList maker algorithm
   AlgFactory &af = AlgFactory::GetInstance();
   AlgHandle ah = af.GetAlgHandle("AlgChop","default");
   CandContext cxx(this,candContext.GetMom());

   // Configuration:
   double cTimeGap           = algConfig.GetDouble("TimeGap");
   double cExtraShieldWindow = algConfig.GetDouble("ExtraShieldWindow");
   bool   cIgnorePreTrigger  = algConfig.GetInt("IgnorePreTrigger");
 

   // First, make a nice stl vector of the digits.
   DigitVector digits(cdlh_ptr);

   UInt_t ndigits = digits.size();
   if(ndigits==0) return; // No data.

   // Sort the list by time.
   std::sort(digits.begin(), digits.end(), compareDigitTimes());

   // Trigger time.
   double trigTime = cdlh_ptr->GetAbsTime();
   if(!cIgnorePreTrigger) trigTime = -100.0; // Set trigger time infinately early.

   // Find the first digit after the pre-trigger window.
   int first_digit = 0;
   for(UInt_t i=0;i<ndigits;i++) {
     if( (digits[i].GetTime()-trigTime) >0) {
       first_digit = i;
       break;
     }
   }

    
   // Go through, look for gaps. When you find a gap, make a new slice.

   int nslice = 0;
   double slice_start = digits[first_digit].GetTime();    // start time (inclusive)
   double slice_end   = slice_start;                      // stop  time (inclusive)
   double t_last = 99e9;
   bool have_slice = false;

   for(UInt_t i=first_digit; i<ndigits; i++) {     
     double t = digits[i].GetTime();
     bool create_slice = false;

     // Only look at non-veto digits.
     if(!(digits[i].GetPlexSEIdAltL().IsVetoShield()) ) {
       // This digit isn't in veto.. use it.
       double delta_t = t-t_last;
       t_last = t;
       if(!have_slice) {
         slice_start = t;
         have_slice = true;
       } else {
         if( (delta_t >= cTimeGap) ) create_slice = true;
       }
     }

     // Hack for last digit: close off the slice:
     if(i == ndigits-1) {
       if(have_slice) {
         create_slice = true;
         slice_end = 99e9;
       }
     }
     
     if(create_slice) {

       // Set start and end times. Note that the extra window
       // will only catch shield hits, assuming the extra window 
       // is smaller than the gap window.
       double tstart = slice_start - cExtraShieldWindow;
       double tend   = slice_end   + cExtraShieldWindow;
       
       // Make a new slice.
       MSG("Chop",Msg::kDebug) << "Forming new slice, digit " << slice_start
                               << " to " << slice_end << endl;
       DigitVector slice_data;
       for(UInt_t j=0; j<ndigits; j++) {
         double tt = digits[j].GetTime();            
         if((tt>=tstart)&&(tt<=tend))  slice_data.push_back(digits[j]);
       }
         
       cxx.SetDataIn(&(slice_data));
       CandDigitListHandle sliceHandle = CandDigitList::MakeCandidate(ah,cxx);
       sliceHandle.SetName(Form("Chop %d",nslice++));
       sliceList.AddDaughterLink(sliceHandle);
       
       // Prep next slice.
       slice_start = t;
     }

     slice_end = t;


   }      
   
}
  

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

---