Morgue.cxx

Go to the documentation of this file.

// Morgue
//
// This is a long-awaited attempt to build a fully-featured CandMorgue
// class.  It's function is to remain in Candidate files and inform other
// reconstructed data about things that might comprimise data quality in this
// event.
//
// In particular it records:
//  - A history of when individual strips go dead (and when they come alive again)
//    due to readout deadtime
//  - A list of strips that may have associated hardware problems (and the severity of the problems)
//  - A record of when the nearest LI injection event occoured
//
//  This object is just for storage and retrieval of this data. The actual compilation
// is done in the Coroner (which declares things dead).
//
// n.tagg1@physics.ox.ac.uk
//
// Some docs:
// Phil A's notes on the topic:
// http://www.slac.stanford.edu/~gmieg/proposals/CandMorgue.txt
//


#include "Morgue.h"
#include "MinosObjectMap/MomNavigator.h"
#include "CandData/CandRecord.h"

ClassImp(Morgue)


// Functions used to construct and build Morgue data.

Morgue::Morgue()
{
  Reset();
}

Morgue::~Morgue()
{
  Reset();
}

void Morgue::Reset()
{
  fTriggerTime = 0;
  fNearestLiTime = -1e9;
  fGraveyard.clear();
  fPrison.clear();
}


void Morgue::AddDeadStrip(const PlexStripEndId& seid, 
                          Double_t fired, 
                          Double_t probableRecover, 
                          Double_t definateRecover)
{
  StripGrave grave;
  //grave.fSeid = seid;
  grave.fFired = fired;
  grave.fProbableRecover = probableRecover;
  grave.fDefinateRecover = definateRecover;
  
  fGraveyard.insert(std::pair<PlexStripEndId,StripGrave>(seid,grave));
}


void Morgue::AddBadStrip(const PlexStripEndId& seid, 
                         HardwareComponent component,
                         Badness_t badness,
                         const char* reason )
{
  StripPrisonCell cell;
  cell.fComponent = component,
  cell.fBadness = badness;
  cell.fReason  = reason;
  Prison_t::iterator it = fPrison.find(seid);
  if(it!=fPrison.end()) {
    // This strip already has an entry. Take the worst entry.
    if(badness > it->second.fBadness) {
      it->second = cell;
    }
    return;
  }

  // insert a new entry.
  fPrison[seid] = cell;
}


// Retrieval: Get ahold of an existing Morgue

const Morgue& Morgue::GetMorgue(const MomNavigator* mom)
{

   // Find PrimaryCandidateRecord fragment in MOM.
  CandRecord *candrec = dynamic_cast<CandRecord *>
    (mom->GetFragment("CandRecord", "PrimaryCandidateRecord"));
 
  return GetMorgue(candrec);
}

const Morgue& Morgue::GetMorgue(const CandRecord* candrec)
{
  static Morgue nullMorgue;
  const Morgue* m;

  if (candrec == 0) return nullMorgue;
  
  m = dynamic_cast<const Morgue*>(candrec->FindComponent("Morgue","Morgue"));
  if(m) return *m;

  m = dynamic_cast<const Morgue*>(candrec->FindTemporary("Morgue","Morgue"));
  if(m) return *m;

  return nullMorgue;
}

// Retrieval: Print
void Morgue::Print(Option_t* option) const
{
  using namespace std;
  cout << "----Morgue-----" << endl;
  cout << " Total dead stripends " << GetNumDeadStripEnds() << endl;
  cout << "  at trigger time " << fTriggerTime*1e9 << endl;

  if(option[0]=='a') {
    Graveyard_t::const_iterator it = fGraveyard.begin();
    for(; it!=fGraveyard.end(); it++) {    
      Deadness_t deadness = it->second.Deadness(fTriggerTime);
      cout << it->first.AsString() 
           << "\t" << deadness 
           << "\t" << 1e9*(it->second.fFired-fTriggerTime)
           << "\t" << 1e9*(it->second.fProbableRecover-fTriggerTime)
           << "\t" << 1e9*(it->second.fDefinateRecover-fTriggerTime)
           << endl;
    }
  }
}


// Retrieval: Dead chip functions

Morgue::Deadness_t Morgue::StripGrave::Deadness(Double_t time) const
{
  // If the channel fired before now, it could be dead:
  if(time <= fFired) return kNotDead;

  // If we're under 5us, the chip hasn't recovered yet for sure:
  if(time <= fProbableRecover) return kDead;

  // If we're under 30us the chip may have recovered:
  if(time <= fDefinateRecover) return kMaybeDead;

  // Oh, it's recovered.
  return kNotDead;
}


// These functions return how many strip ends are dead (or possibly dead)

Int_t 
Morgue::GetNumDeadStripEndsInVeto( Double_t time,
                                   Deadness_t deadness) const
{
  
    if (time == -1.0) time = GetTriggerTime();

  int num = 0;
  Graveyard_t::const_iterator it = fGraveyard.begin();
  for(; it!=fGraveyard.end(); it++) {

    // Is this strip up for consideration?
    if(it->first.IsVetoShield()) {
      if(it->second.Deadness(time) >= deadness) {
        num++; // It's at least as dead as the requested deadness.
      }
    }
  }
  
  return num;

}


Int_t 
Morgue::GetNumDeadStripEnds(Int_t plane_start, 
                            Int_t plane_end, 
                            Double_t time,                          
                            Deadness_t deadness) const
{
  
  if (time == -1.0) time = GetTriggerTime();

  int num = 0;
  Graveyard_t::const_iterator it = fGraveyard.begin();
  for(; it!=fGraveyard.end(); it++) {

    // Is this strip up for consideration?
    if(it->first.GetPlane() <= plane_start) continue;
    if(it->first.GetPlane() >= plane_end) continue;    

    
    if(it->second.Deadness(time) >= deadness) {
      num++; // It's at least as dead as the requested deadness.
    }
  }
  
  return num;
}

Int_t 
Morgue::GetNumDeadStripEnds(Int_t plane, 
                            Double_t time, 
                            Deadness_t deadness) const

{

  if(time==-1.0) time = GetTriggerTime();

  int num = 0;
  Graveyard_t::const_iterator it = fGraveyard.begin();
  for(; it!=fGraveyard.end(); it++) {

    // Is this strip up for consideration?
    if(it->first.GetPlane() != plane) continue;
    
    if(it->second.Deadness(time) >= deadness) {
      num++; // It's at least as dead as the requested deadness.
    }
  }
  return num;
}

// These return the state of a specific strip
Morgue::Deadness_t 
Morgue::StripEndIsDead(PlexStripEndId seid,
                       Double_t time) const
                       
{

  if(time==-1.0) time = GetTriggerTime();

  // Default: alive.
  Deadness_t result = kNotDead;

  // Find all graves for this strip.
  std::pair<Graveyard_t::const_iterator,Graveyard_t::const_iterator> range = 
    fGraveyard.equal_range(seid);

  // Go through all these possible dead times and return the worst one.
  Graveyard_t::const_iterator it;
  for(it = range.first; it!= range.second; it++) {
    Deadness_t thisres = it->second.Deadness(time);
    if(thisres>result) result = thisres;
  }
  
  return result;
}

const std::vector<PlexStripEndId>& 
Morgue::GetDeadStripEnds(Double_t time, 
                         Deadness_t deadness) const
{
  if(time == -1.0) time = GetTriggerTime();

  static std::vector<PlexStripEndId> retval;
  retval.clear();
  retval.reserve(1024);

  Graveyard_t::const_iterator it = fGraveyard.begin();
  for(; it!=fGraveyard.end(); it++) {
    if(it->second.Deadness(time) >= deadness) retval.push_back(it->first);
  }
  
  return retval;
}


// Retrieval: Bad strip functions

Int_t Morgue::GetNumBadStripEnds(Int_t plane_start, 
                                 Int_t plane_end,
                                 Badness_t badness ) const
{
  int bad_strips = 0;
  for(Prison_t::const_iterator it = fPrison.begin(); 
      it!= fPrison.end(); ++it) {
    int plane = it->first.GetPlane();
    if((plane >= plane_start) && (plane <= plane_end)) {
      if(it->second.fBadness >= badness) bad_strips++;
    }
  }
  return bad_strips;
}

Int_t Morgue::GetNumBadStripEnds(Int_t plane,
                                 Badness_t badness) const
{
  int bad_strips = 0;
  for(Prison_t::const_iterator it = fPrison.begin(); 
      it!= fPrison.end(); it++) {
    if( plane == it->first.GetPlane() ) {
      if(it->second.fBadness >= badness) bad_strips++;
    }
  }
  return bad_strips;
}

Morgue::Badness_t Morgue::StripEndIsBad(const PlexStripEndId& seid) const
{
  Prison_t::const_iterator it = fPrison.find(seid);
  if(it==fPrison.end()) return kGood;
  
  return it->second.fBadness;
}

const char* Morgue::HowIsStripEndBad(const PlexStripEndId& seid) const
{
  Prison_t::const_iterator it = fPrison.find(seid);
  if(it==fPrison.end()) return "Good";
  
  if(it->second.fReason) return it->second.fReason;
  return "Unknown";
}

---