PulserTimingPoint.cxx

Go to the documentation of this file.

#include "PulserTimingPoint.h"
#include "RawData/RawLITimingSummaryBlock.h"
#include "RawData/RawLITimingSummary.h"
#include "Plex/PlexHandle.h"
#include "MessageService/MsgService.h"
#include "DatabaseInterface/DbiWriter.h"
#include <cassert>
#include <fstream>
#include <set>
#include "PulserTimeDrift.h"

CVSID("$Id: PulserTimingPoint.cxx,v 1.9 2007/03/01 17:06:40 rhatcher Exp $");

using namespace std;

PulserTimingPoint::PulserTimingPoint()
{
  // Null constructor. For ROOT only.
}

PulserTimingPoint::PulserTimingPoint(const RawLITimingSummaryBlock* startblock)
{
  assert(startblock);
  
  fCalibType = startblock->GetCalibType();
  fCalibPoint = startblock->GetCalibPoint();
  fPulserBox = startblock->GetPulserBox();
  fLed       = startblock->GetLed();
  fPulseHeight = startblock->GetPulseHeight();
  fPulses      = startblock->GetPulses();
  fPeriod      = startblock->GetPeriod();
  fTotalCount  = startblock->GetCount();
  fStartContext = fEndContext = startblock->GetVldContext();

  fValidChannels.clear();
  ValidChannelList_t::iterator vcit = fValidChannels.end();

  PlexHandle plex(fStartContext);
  PlexLedId led(fStartContext.GetDetector(),fPulserBox,fLed);
  
  // Make a list of channels that this LED connects to.
  const std::vector<PlexStripEndId>& ends = plex.GetAllStripEnds();
  for(UInt_t i=0;i<ends.size();i++) {
    if(plex.GetLedId(ends[i])==led) {
      RawChannelId rcid = plex.GetRawChannelId(ends[i]);
      UInt_t chindex = PulserTimeDrift::GetIndex(rcid);
      vcit = fValidChannels.insert(vcit,chindex); // Insert with time-saving device.
    }
  }


  fMaxEntries = fMinEntries = 0;
  AddSummaryBlock(startblock);
}


PulserTimingPoint::~PulserTimingPoint()
{
  ChannelMap_t::iterator it;
  for(it = fChannelMap.begin(); it!=fChannelMap.end(); it++) {
    if(it->second) delete it->second;
  }
  fChannelMap.clear();
}

Bool_t PulserTimingPoint::AddSummaryBlock(const RawLITimingSummaryBlock* sumblock)
{
  assert(sumblock);
  if(fCalibType !=sumblock->GetCalibType())  return false;
  if(fCalibPoint!=sumblock->GetCalibPoint()) return false;
  if(fPulserBox !=sumblock->GetPulserBox())  return false;
  if(fLed       !=sumblock->GetLed())        return false;

  // Ok, looks good. Add the sucker.
  fEndContext = sumblock->GetVldContext();
  fTotalCount += sumblock->GetCount();

  // Go through the entries. Use only one per VA chip.
  // We only want the summary with the MOST entries for
  // each VA chip (to ensure we get max statistics, not a
  // crosstalk channel that only occasionaly fires.)

  // Which to use maps my chindex to best At() index.
  std::map<UInt_t,Int_t>           whichToUse;
  std::map<UInt_t,Int_t>::iterator useItr;

  for(Int_t i=0;i<sumblock->GetNumberOfSummaries(); i++) {
    const RawLITimingSummary* summary = sumblock->At(i);
    if(!summary) continue; // protection against null entries.
    
    UInt_t chindex = PulserTimeDrift::GetIndex(summary->GetChannel());
    if(!ChannelBelongsToPoint(chindex)) continue; // Ignore illegal channels.
    
    useItr = whichToUse.find(chindex);
    if(useItr==whichToUse.end()) {
      // First instance of this channel. Add it.
      whichToUse[chindex] = i;
    } else {
      int index2 = useItr->second;
      if(sumblock->At(i)->GetEntries() > sumblock->At(index2)->GetEntries())
        useItr->second = i;
    }
  }

  fMaxEntries = -1;
  fMinEntries  = 1e10;

  for(Int_t i=0;i<sumblock->GetNumberOfSummaries();i++) {
    const RawLITimingSummary* summary = sumblock->At(i);
    if(!summary) continue; // protection against null entries.
    
    UInt_t chindex = PulserTimeDrift::GetIndex(summary->GetChannel());
    if(!ChannelBelongsToPoint(chindex)) continue; // Ignore illegal channels.

    // Is this the right entry to use?
    if(whichToUse[chindex]==i) {

      ChannelMap_t::iterator it = fChannelMap.find(chindex);
      if(it==fChannelMap.end()) {
        // Gotta make a new one.
        // Note: aggregate number is pulser box number.
        it = 
          fChannelMap.insert(ChannelMap_t::value_type
                             (chindex,new PulserTimeDrift(fPulserBox,chindex))
                             ).first;   
      }
      it->second->Add(summary->GetEntries(),
                      summary->GetMean(),
                      summary->GetRms() );

      // Update summary stats:
      if(it->second->GetEntries() > fMaxEntries) 
        fMaxEntries = it->second->GetEntries();
      if(it->second->GetEntries() < fMinEntries) 
        fMinEntries = it->second->GetEntries();
    }
  }
  // We added it successfully.
  return true;
}

Bool_t PulserTimingPoint::PointTimedOut(const VldTimeStamp& currentTime,
                                        double timeout)
{

  // See if we've timed out.
  int currentSec = currentTime.GetSec();
  int currentNsec= currentTime.GetNanoSec();
  int endSec = fEndContext.GetTimeStamp().GetSec();
  int endNsec= fEndContext.GetTimeStamp().GetNanoSec();
  
  double dt = (double)(currentSec-endSec) + 1e-9*(double)(currentNsec-endNsec);
  if(dt>timeout)  return true; 
  return false;
}


Bool_t PulserTimingPoint::PointIsFinished()
{

  // If we've collected all the stats we're supposed to...
  if(fMinEntries >= fPulses) return true;

  // Otherwise, point has has to time out
  // or the system has to go onto a new point, or the job has to end.
  return false; 
}


Bool_t PulserTimingPoint::PointIsGood()
{

  // Only use drift point:
  if(fCalibType!=1) return false;

  int badChips = 0;
  int goodChips = 0;

  // Enough stats: 
  // Look at each channel.
  ChannelMap_t::iterator it;
  for(it = fChannelMap.begin(); it!=fChannelMap.end(); it++) {
    //if(ChannelBelongsToPoint(it->first))  // they all do
    if(it->second->GetEntries() < (float)(fPulses)*0.9) {
      MSG("PulserTiming",Msg::kInfo) << "Channel " 
                                        << it->second->GetRawChannelId().AsString() 
                                        << " has only " << it->second->GetEntries()
                                        << " and point expected " << fPulses << " entries."
                                        << std::endl;
      badChips++;
    } else 
      goodChips++;    
  }  

  bool retval = true;
  
  if(badChips>0)
    MSG("PulserTiming",Msg::kWarning) << "--->" << badChips 
                                      << "Bad chips, "
                                      << goodChips << " good chips on " << AsString() << endl;
  
  // Fail if there are no good chips, or more than 4 bad chips.
  if((goodChips<1)||(badChips>10)) {
    MSG("PulserTiming",Msg::kWarning) << "--->Point is judged bad. Storing anyway. " << AsString() << endl;
  //MSG("PulserTiming",Msg::kWarning) << "--->Point is judged bad and won't be stored " << AsString() << endl;
  // retval = false;
  }

  
  return retval;
}

Bool_t PulserTimingPoint::WriteToTextfile(const char* name)
{
  const char* filename = Form("%s_%d_%d",
                              name,
                              fPulserBox,
                              fLed);
  ofstream outfile(filename);
  outfile << "CalibType:  \t" << fCalibType << endl;
  outfile << "CalibPoint: \t" << fCalibPoint << endl;
  outfile << "PulserBox:  \t" << fPulserBox << endl;
  outfile << "Led:        \t" << fLed << endl;
  outfile << "PulseHeight:\t" << fPulseHeight << endl;
  outfile << "PulseWidth: \t" << fPulseWidth << endl;
  outfile << "Pulses:     \t" << fPulses << endl;
  outfile << "Period:     \t" << fPeriod << endl;
  outfile << "TotalCounts:\t" << fTotalCount << endl;
  outfile << "Start:      \t" << fStartContext.AsString() << endl;  
  outfile << "End:        \t" << fEndContext.AsString() << endl;
  outfile << endl << endl << endl << endl;

  outfile << "Entries:    \t" << fChannelMap.size() << endl;

  for(ChannelMap_t::iterator it=fChannelMap.begin();
      it!=fChannelMap.end();
      it++) {
    outfile << Form("%10d ",it->first)
            << Form("%8d " ,(int)(it->second->GetEntries()))
            << Form("%6.2f ",it->second->GetMean())
            << Form("%6.2f ",it->second->GetRms())
            << it->second->GetRawChannelId().AsString()
            << endl;
  }

  outfile.close();
  return true;
}

Bool_t PulserTimingPoint::WriteToDatabase()
{
  VldTimeStamp endtime = fStartContext.GetTimeStamp();
  VldTimeStamp offset(60*60*24*30*2,0); // Two months from now.
  endtime.Add(offset);

  VldRange range(fStartContext.GetDetector(),
                 fStartContext.GetSimFlag(),
                 fStartContext.GetTimeStamp(),
                 endtime,
                 "Automatic generation of time drift. $Id ");

  Int_t aggNo = fPulserBox;
  Int_t task  = fLed;
  std::string comment("Automatic generation of time drift. $Id ");

  MSG("PulserTiming",Msg::kInfo) << "Writing pulser table.  Aggregate(Crate) = " << aggNo 
                                 << " Task(Led) = " << task << endl;
  MSG("PulserTiming",Msg::kDebug) << "  VldRange = " << range.AsString() << endl;
  MSG("PulserTiming",Msg::kDebug) << "  Comment = " << comment << endl;

  DbiWriter<PulserTimeDrift> writer(range,      // vld range
                                    aggNo,
                                    task,
                                    fStartContext.GetTimeStamp(), // creation date, of the data generated.
                                    0,          // db no
                                    "" // comment
                                    );

  for(ChannelMap_t::iterator it=fChannelMap.begin();
      it!=fChannelMap.end();
      it++) {
    if(it->second) writer <<  *(it->second);
  }

  writer.Close();

  return true;
}


Bool_t PulserTimingPoint::ChannelBelongsToPoint(UInt_t chindex)
{
  if(fValidChannels.find(chindex)==fValidChannels.end()) return false;
  return true;
}


const char* PulserTimingPoint::AsString()
{
  return Form("Point: PulserBox %2d  LED %2d  %s",
              fPulserBox,
              fLed,
              fEndContext.AsString()
              );
}

---