Coroner.cxx

Go to the documentation of this file.

// $Id: Coroner.cxx,v 1.7 2007/11/11 06:00:01 rhatcher Exp $
//
// FILL_IN: [Document your code!!]
//
// n.tagg1@physics.ox.ac.uk
#include "Morgue/Coroner.h"
#include "Morgue/Morgue.h"
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "JobControl/JobCModuleRegistry.h" // For JOBMODULE macro
#include "Plex/PlexHandle.h"
#include "CandData/CandRecord.h"
#include "CandDigit/CandDigitListHandle.h"
#include "CandDigit/CandDigitHandle.h"
#include "Conventions/Munits.h"
#include "DataUtil/GetRawBlock.h"
#include "DataUtil/GetRawHeader.h"
#include "RawData/RawLiTpmtDigitsBlock.h"
#include "RawData/RawHeader.h"
#include "RawData/RawDigit.h"
#include "Calibrator/Calibrator.h"
#include <algorithm>
#include <cmath>

JOBMODULE(Coroner, "Coroner",
          "Coroner");
CVSID("$Id: Coroner.cxx,v 1.7 2007/11/11 06:00:01 rhatcher Exp $");
//......................................................................

Coroner::Coroner()
{
}

//......................................................................

Coroner::~Coroner()
{
  ClearTables();
}

//......................................................................

JobCResult Coroner::Ana(const MomNavigator* mom)
{
  // 
  // Quick module to look at Morgue
  //

  const Morgue& morgue = Morgue::GetMorgue(mom);
  morgue.Print("a");

  return JobCResult::kPassed; // kNoDecision, kFailed, etc.
}

//......................................................................

JobCResult Coroner::Reco(MomNavigator* mom)
{
  //
  // Creates and fills a Morgue object with all the relevant info about an event.
  //
  
  // Look for TPMT hits and record them.
  UpdateLiHitList(mom);

  JobCResult result;
  VldContext context;

  // Find PrimaryCandidateRecord fragment in MOM.
  CandRecord *candrec = dynamic_cast<CandRecord *>
    (mom->GetFragment("CandRecord", "PrimaryCandidateRecord"));
  if (candrec == 0) {
    MSG("Morgue", Msg::kWarning) << "No PrimaryCandidateRecord in  MOM."
                                 << endl;
    result.SetWarning().SetFailed();
    return result;
  }

  // Find vld.
  context = *(candrec->GetVldContext());

  // Make new Morgue.
  Morgue* morgue = new Morgue;
  
  // Give it dead strips.
  result |= RecordDeadStrips(morgue,candrec);
  
  // Give it bad strips.
  result |= RecordBadStrips(morgue,context);

  // Find relevant LI hit.
  result |= RecordLiHits(morgue,context);
  
  // Add the morgue to the cand record.
  if(candrec)
    candrec->AdoptTemporary(morgue);

  return result; // kNoDecision, kFailed, etc.
}


JobCResult Coroner::RecordDeadStrips(Morgue* morgue, 
                                     const CandRecord* candrec)
{
  //
  // Loop over digits in the snarl
  // and use them to figure out when strips are dead.
  //

   // Get CandDigits.
  CandDigitListHandle* cdlh = dynamic_cast<CandDigitListHandle *>
    (candrec->FindCandHandle("CandDigitListHandle", "canddigitlist"));

  if(!cdlh) {
    MSG("Morgue", Msg::kWarning) << "No CandDigitList in  MOM."
                                 << endl;
    return JobCResult::kFailed;
  }

  VldContext context = *(cdlh->GetVldContext());
  morgue->SetTriggerTime((context.GetTimeStamp().GetNanoSec())*Munits::ns);

  // FIXME: Are we in ND spill mode? If so, skip the dead chip step.
  
  // Look for fired PMTs, build up a deadness map.
  // This contorted logic is to get a list of PMTs that fired, with only 
  // one entry per PMT fire, but allowing a PMT to fire more than once.
  std::map<PlexPixelSpotId, std::vector<Double_t> > firedPmts;
  std::map<PlexPixelSpotId, std::vector<Double_t> >::iterator pmtItr;

  CandDigitHandleItr cdhItr(cdlh->GetDaughterIterator());
  while(CandDigitHandle *cdh = cdhItr()) {
    const PlexSEIdAltL& altl = cdh->GetPlexSEIdAltL();
    if(altl.size()>0) {
      PlexPixelSpotId tube = altl.GetBestItem().GetPixelSpotId();
      tube.SetSpot(1);
      tube.SetPixel(1);
      Double_t t = cdh->GetTime(); // Uncalibrated time.
      std::vector<Double_t>& v = firedPmts[tube];
    
      // See if this fire has already been recorded.
      bool isnew = true;
      for(UInt_t i=0;i<v.size();i++) { if (t==v[i])  isnew=false; };
      
      if(isnew) v.push_back(t); // Record the mother.
    }
  }

  // Dead time definitions.
  const double kVA_1chip_FD = ( 300. * Munits::ns  // Shaping delay
                                +22. * (1.0/5.e6)  // Readout 22 channels @ 5MHz/channel
                                +100.* Munits::ns ); // Veto region around chip recovery

  const double kVA_6chip_FD = ( 300. * Munits::ns  // Shaping delay
                                +6.0 * 22. * (1.0/5.e6)  // Readout 6 chips on a VMM at 22 channels @ 5MHz/channel
                                +100.* Munits::ns ); // Veto region around chip recovery
 
  // For most caldet runs, the readout speed was less (the wait delay was 4 instead of 2)
  const double kVA_1chip_CalDet = ( 300. * Munits::ns  // Shaping delay
                                    +22. * (1.0/2.5e6)  // Readout 22 channels @ 5MHz/channel
                                    +100.* Munits::ns ); // Veto region around chip recovery
  
  const double kVA_6chip_CalDet = ( 300. * Munits::ns  // Shaping delay
                                    +6.0 * 22. * (1.0/2.5e6)  // Readout 6 chips on a VMM at 22 channels @ 5MHz/channel
                                    +100.* Munits::ns ); // Veto region around chip recovery
  
  // ND:
  // Dave R. sez: It takes 2 clock ticks per channel per bucket to read out, so..
  // Dead time is 32 x livetime. Livetime is 8 x 53MHz buckets
  const double kQIE_1pmt = 32. * 8. * (1.0/53.1e6); 
  

  PlexHandle plex(context);
  
  // Finally, we can fill the Morgue.
  for(pmtItr = firedPmts.begin(); pmtItr!=firedPmts.end(); pmtItr++) {
    PlexPixelSpotId tube = pmtItr->first;
    std::vector<Double_t>& v = pmtItr->second; 
    for(UInt_t i=0;i<v.size();i++) {
      double t_fired = v[i];
      double t_maybe = t_fired;
      double t_recover= t_fired;

      switch(tube.GetElecType()) {
        case ElecType::kVA:
          t_maybe   = t_fired + kVA_1chip_FD;
          t_recover = t_fired + kVA_6chip_FD;
          if(tube.GetDetector()==Detector::kCalDet) {
            t_maybe   = t_fired + kVA_1chip_CalDet;
            t_recover = t_fired + kVA_6chip_CalDet;
          }
        break;
      case ElecType::kQIE:
        t_maybe   = t_fired + kQIE_1pmt; 
        t_recover = t_fired + kQIE_1pmt; 
        break;
      default:
        MSG("Morgue",Msg::kWarning) << "Unknown ElecType on PMT: " << tube.AsString() << endl;
      }
      
      int npix = 16;
      int nspot = 8;
      if(tube.GetElecType()==ElecType::kQIE) {
        npix = 64;
        nspot= 1;
      }
      PlexPixelSpotId pixel = tube;

      for(int ipix = 0; ipix<npix; ipix++) {
        for(int ispot=1; ispot<=nspot; ispot++) {
          pixel.SetPixel(ipix);
          pixel.SetSpot(ispot);
          PlexStripEndId seid = plex.GetStripEndId(pixel);
          if(seid.IsValid()) {
            morgue->AddDeadStrip(seid,t_fired,t_maybe,t_recover);
          }
        }
      }

    }    
  }

  return JobCResult::kPassed;
}

//......................................................................

JobCResult Coroner::RecordBadStrips(Morgue* morgue, 
                                    const VldContext& context)
{
  // Consult all available databases.
  PlexHandle plex(context);

  for(UInt_t itask=0;itask<fBadHardwareTasks.size();itask++) {
    fBadHardwareTables[itask]->NewQuery(context,fBadHardwareTasks[itask]);
  
    // Check all entries in all tables.
    for(UInt_t irow=0;irow <  fBadHardwareTables[itask]->GetNumRows(); irow++) {
      const BadHardware* row = fBadHardwareTables[itask]->GetRow(irow);
      if(row) {
        if(row->IsInEffect(context.GetTimeStamp())) {
          vector<PlexStripEndId> strips = row->GetComponent().GetStripEnds(plex);
          for(UInt_t istrip = 0; istrip < strips.size(); istrip++) {
            morgue->AddBadStrip(strips[istrip], row->GetComponent(), (Morgue::Badness_t)(row->GetBadness()), row->GetReason().c_str() );
          }
        }
      }
    }
  }


  return JobCResult::kPassed;
}


JobCResult Coroner::RecordLiHits(Morgue* morgue, 
                                 const VldContext& context)
{
  VldTimeStamp eventtime = context.GetTimeStamp();
  // find the closest.
  double smallest_dt = 1e0;
  VldTimeStamp closest;
  LiHitList_t::iterator it = fRecentLiHits.begin();
  for(; it!= fRecentLiHits.end(); it++) {
    double dt = fabs((*it) - eventtime);
    if(dt <= smallest_dt) {
      smallest_dt = dt;
      closest = *it;
    }
  }
  // Don't bother if the nearest one is more than 100ms away.. that's good enough.
  if(smallest_dt > 0.1*Munits::second) return JobCResult::kPassed;

  double time = Munits::ns*closest.GetNanoSec();
  int del_secs = closest.GetSec() - eventtime.GetSec();
  time += (del_secs)*Munits::second;
  morgue->SetNearestLiTime(time);
  MSG("Morgue",Msg::kInfo) << "Set nearest LI time. Dt from trigger is "  
                           << morgue->GetNearestLiTime() - morgue->GetTriggerTime()
                           << endl;
  return JobCResult::kPassed;
}
               




void Coroner::UpdateLiHitList( const MomNavigator* mom )
{
  const RawHeader* header = DataUtil::GetRawHeader<RawHeader>(mom);
  if(header) {
    VldTimeStamp curtime = header->GetVldContext().GetTimeStamp();

    // This little snippet clips out the 
    LiHitList_t::iterator it = fRecentLiHits.begin();
    for( ; it!= fRecentLiHits.end(); it++) {
      if( fabs((*it)-curtime) < 3.0 ) break;
    }
    if(it!=fRecentLiHits.begin()) {
      fRecentLiHits.erase(fRecentLiHits.begin(),(it));
    }
    
  }

  const RawLiTpmtDigitsBlock* tpmt_block =
    DataUtil::GetRawBlock<RawLiTpmtDigitsBlock>(mom);


  if(tpmt_block) {
    MSG("Morgue",Msg::kInfo) << "Found TPMT block time "
                             << tpmt_block->GetTimeStamp().AsString()
                             <<"  with " 
                             << tpmt_block->GetNumberOfDigits()
                             << " digits. " << endl;
    for(int i=0;i< tpmt_block->GetNumberOfDigits(); i++) {
      const RawDigit* digit = tpmt_block->At(i);
      double digtime = Calibrator::Instance().GetTimeFromTDC(digit->GetTDC(),
                                                             digit->GetChannel());

      VldTimeStamp ts = tpmt_block->GetTimeStamp();
      ts.Add(digtime);
      fRecentLiHits.push_back(ts);
    }
    std::sort(fRecentLiHits.begin(),fRecentLiHits.end());
  }

}



//......................................................................

const Registry& Coroner::DefaultConfig() const
{
//======================================================================
// Supply the default configuration for the module
//======================================================================
  static Registry r; // Default configuration for module

  // Set name of config
  std::string name = this->GetName();
  name += ".config.default";
  r.SetName(name.c_str());

  // Set values in configuration
  r.UnLockValues();
  r.Set("BadHardwareTasks","1,2");
  r.LockValues();

  return r;
}

//......................................................................

void Coroner::Config(const Registry& r)
{
//======================================================================
// Configure the module given the Registry r
//======================================================================
  
  int task;
  if(r.Get("BadHardwareTasks",task) ) {
    ClearTables();
    fBadHardwareTasks.push_back(task);
    fBadHardwareTables.push_back( new DbiResultPtr<BadHardware> ); 
    MSG("Morgue",Msg::kInfo) << "Configured to use BadHardware task " << task << endl;
  }

  const char* taskstr;
  if(r.Get("BadHardwareTasks",taskstr) ) {
    ClearTables();
    const char* s = taskstr;
    int task;
    int n;
    while( sscanf(s,"%d%n",&task,&n) > 0) {
      s += n+1;
      fBadHardwareTasks.push_back(task);
      fBadHardwareTables.push_back( new DbiResultPtr<BadHardware> );

      MSG("Morgue",Msg::kInfo) << "Configured to use BadHardware task " << task << endl;
    }
  }

 
}


void Coroner::ClearTables()
{
  for(UInt_t itask=0;itask<fBadHardwareTasks.size();itask++) {
    delete fBadHardwareTables[itask];
  }
  fBadHardwareTasks.clear();
  fBadHardwareTables.clear();

}

---