SdInspector.cc

Go to the documentation of this file.

#include <iostream>

#include <fwk/CentralConfig.h>

#include <utl/Reader.h>
#include <utl/ErrorLogger.h>

#include <evt/Event.h>
#include <evt/Header.h>

#include <sevt/SEvent.h>
#include <sevt/Header.h>
#include <sevt/Station.h>
#include <sevt/StationSimData.h>
#include <sevt/PMT.h>
#include <sevt/PMTCalibData.h>
#include <sevt/PMTRecData.h>
#include <sevt/StationGPSData.h>
#include <sevt/StationTriggerData.h>
#include <sevt/StationCalibData.h>
#include <sevt/StationRecData.h>
#include <sevt/EventTrigger.h>

#include "SdInspector.h"

using namespace std;
using namespace fwk;
using namespace utl;
using namespace evt;
using namespace sevt;
using namespace SdInspectorOG;


// IndentOut tab size and newline
const int tab = 4;
const char nl = '\n';


// indented-output helper class
class IndentOut {
private:
  ostream& fOs;
  int fIndent;
public:
  IndentOut(ostream& os = cout, const int ind = 0)
    : fOs(os), fIndent(ind) { }

  ostream& GetOs() { return fOs; }

  void OutputBinary(const int value, const int bits = 8) const
  { for (int i = bits - 1; i >= 0; --i) fOs << (value & (1<<i) ? '1':'0'); }

  void SetIndent(const int ind) { fIndent = ind; }

  template<typename T>
  ostream& operator<<(const T& t)
  { for (int i = 0; i < fIndent; ++i) fOs << ' '; return fOs << t; }

  int operator++(const int) { return ++fIndent; }

  int operator--(const int) { return --fIndent; }

  int operator+=(const int i) { return fIndent+=i; }

  int operator-=(const int i) { return fIndent-=i; }
};


VModule::ResultFlag
SdInspector::Init()
{
  auto topBranch = CentralConfig::GetInstance()->GetTopBranch("SdInspector");

  const auto str = topBranch.GetChild("infoLevel").Get<string>();

  fInfoLevel = eInfoNone;
  if (str.find_first_of("aA") != string::npos)
    fInfoLevel = eInfoAll;
  else if (str.find_first_of("pP") != string::npos)
    fInfoLevel = eInfoPMT;
  else if (str.find_first_of("sS") != string::npos)
    fInfoLevel = eInfoStation;
  else if (str.find_first_of("eE") != string::npos)
    fInfoLevel = eInfoEvent;

  topBranch.GetChild("showSimData").GetData(fShowSimData);

  // Event second is unbounded if no bound is specified in the file.
  fEventSecondUnbounded = !bool(topBranch.GetChild("eventSecondRange"));

  if (!fEventSecondUnbounded)
    topBranch.GetChild("eventSecondRange").GetData(fEventSecondRange);

  ostringstream info;
  info << "Parameters:\n"
          "       infoLevel: " << fInfoLevel << "\n"
          "     showSimData: " << fShowSimData << "\n"
          "eventSecondRange: ";
  if (fEventSecondUnbounded)
    info << "unbounded\n";
  else
    info << '[' << fEventSecondRange.first << ", " << fEventSecondRange.second << "]\n";
  INFO(info);

  return eSuccess;
}


VModule::ResultFlag
SdInspector::Run(evt::Event& ev)
{
  if (fInfoLevel == eInfoNone)
    return eSuccess;

  const Event& event = ev;

  if (!ev.HasSEvent())
    return eSuccess;

  //  if (!ev.HasRawEvent() || !ev.GetRawEvent().HasSd() || !ev.HasSEvent())
  //return eSuccess;

  const SEvent& sev = ev.GetSEvent();
  //const IoSdEvent& rawSEvent = ev.GetRawEvent().Sd();
  const sevt::Header& head = sev.GetHeader();
  const TimeStamp headTime = head.GetTime();
  const unsigned int headSec = headTime.GetGPSSecond();

  // limit info
  if (!fEventSecondUnbounded)
    if(headSec < fEventSecondRange.first ||
       headSec > fEventSecondRange.second)
      return eSuccess;

  IndentOut iout;

  iout << "Event.Header.Id: " << event.GetHeader().GetId() << nl;
  iout << "SEvent:" << nl;
  iout += tab;
  iout << "NumberOfStations: " << sev.GetNumberOfStations() << nl;
  iout << "NErrorZeroStations: " << sev.GetNErrorZeroStations()
       << nl;

  iout << "+ Header:" << nl;
  iout += tab;
  iout << "Id: " << head.GetId() << nl;
  iout << "Time: " << headTime << nl;
  iout -= tab;

  /*const IoSdT3Trigger& rawT3 = rawSEvent.Trigger;

  iout << "+ EventTrigger:" << nl;
  iout+=tab;
  iout << "Id: " << rawT3.Id << nl;
  iout << "PreviousId: " << rawT3.PreviousId << nl;
  iout << "NumberOfStations: " << rawT3.NumberOfStation << nl;
  iout << "Sender: " << rawT3.Sender << nl;
  iout << "Algorithm: " << rawT3.Algo << nl;
  iout << "SDPAngle: " << rawT3.SDPAngle << nl;
  iout << "Time: " << TimeStamp(int(rawT3.Second), int(rawT3.MicroSecond*microsecond/nanosecond)) << nl;
  iout-=tab;
  */

  if (sev.HasTrigger()) {
    const EventTrigger& trig = sev.GetTrigger();
    iout << "+ EventTrigger:" << nl;
    iout+=tab;
    iout << "Id: " << trig.GetId() << nl;
    iout << "PreviousId: " << trig.GetPreviousId() << nl;
    iout << "NStations: " << trig.GetNStations() << nl;
    iout << "Sender: " << trig.GetSender() << nl;
    iout << "Algorithm: " << trig.GetAlgorithm() << nl;
    iout << "SDPAngle: " << trig.GetSDPAngle() << nl;
    iout << "Time: " << trig.GetTime() << nl;
    iout -= tab;
  } else
    iout << "- EventTrigger" << nl;

  if (fInfoLevel >= eInfoStation) {

    int nStations = 0;
    int nCandidates = 0;
    int nSilent = 0;

    iout << "* Station Collection:" << nl << nl;
    iout+=tab;
    for (SEvent::ConstStationIterator sIt = sev.StationsBegin();
         sIt != sev.StationsEnd();
         ++sIt) {

      ++nStations;
      iout << "StationId: " << sIt->GetId() << nl;

      iout << "Saturation: ";
      {
        string sep;
        if (sIt->IsHighGainSaturation()) {
          iout.GetOs() << "HighGain";
          sep = ", ";
        }
        if (sIt->IsLowGainSaturation()) {
          iout.GetOs() << sep << "LowGain";
          sep = "*";
        }
        iout.GetOs() << (sep.length() ? "\n" : "None\n");
      }

      iout << "Is: ";
      {
        string sep;
        if (sIt->IsCandidate()) {
          ++nCandidates;
          iout.GetOs() << "Candidate";
          sep = ", ";
        }
        if (sIt->IsSilent()) {
          ++nSilent;
          iout.GetOs() << sep << "Silent";
          sep = ", ";
        }
        if (sIt->IsRejected())
          iout.GetOs() << sep << "Rejected:" << sIt->GetRejectionStatus();
      }
      iout.GetOs() << nl;

      // Find the raw station
      /*const vector<IoSdStation>& rawStations = rawSEvent.Stations;
      const IoSdStation* rStation = NULL;

      for (vector<IoSdStation>::const_iterator rsIt = rawStations.begin();
           rsIt != rawStations.end(); ++rsIt)
        if (rsIt->Id == (unsigned int)sIt->GetId()) {
          rStation = &(*rsIt);
          break;
        }

      if (!rStation) {
        ostringstream buf;
        buf << "Unmatched raw and in-memory station " << sIt->GetId();
        ERROR(buf.str());
        continue;
      }

      if (rStation->Gps) {
        const IoSdGps& rawGPS = *(rStation->Gps);
        iout << "+ GPSData:" << nl;
        iout+=tab;
        iout << "Second: " << rawGPS.Second << nl;
        iout << "CorrectedNanoSecond: " << rawGPS.NanoSecond << nl;
        iout << "Offset: " << rawGPS.Offset << nl;
        iout << "Tick: " << rawGPS.Tick << nl;
        iout << "TickFall: " << rawGPS.TickFall << nl;
        iout << "Current100: " << rawGPS.Current100 << nl;
        iout << "Next100: " << rawGPS.Next100 << nl;
        iout << "Current40: " << rawGPS.Current40 << nl;
        iout << "Next40: " << rawGPS.Next40 << nl;
        iout << "PreviousST: " << rawGPS.PreviousST << nl;
        iout << "CurrentST: " << rawGPS.CurrentST << nl;
        iout << "NextST: " << rawGPS.NextST << nl;
        iout-=tab;
      } else
        iout << "- GPSData" << nl;
      */

      if (sIt->HasGPSData()) {
        const StationGPSData& gps = sIt->GetGPSData();
        iout << "+ GPSData:" << nl;
        iout += tab;
        iout << "Second: " << gps.GetSecond() << nl;
        iout << "CorrectedNanoSecond: " << gps.GetCorrectedNanosecond() << nl;
        iout << "Offset: " << gps.GetOffset() << nl;
        iout << "Tick: " << gps.GetTick() << nl;
        iout << "TickFall: " << gps.GetTickFall() << nl;
        iout << "Current100: " << gps.GetCurrent100() << nl;
        iout << "Next100: " << gps.GetNext100() << nl;
        iout << "Current40: " << gps.GetCurrent40() << nl;
        iout << "Next40: " << gps.GetNext40() << nl;
        iout << "PreviousST: " << gps.GetPreviousST() << nl;
        iout << "CurrentST: " << gps.GetCurrentST() << nl;
        iout << "NextST: " << gps.GetNextST() << nl;
        iout -= tab;
      } else
        iout << "- GPSData" << nl;

      iout << "TraceStartTime: " << sIt->GetTraceStartTime() << nl;
      if (sIt->HasVEMTrace())
        iout << "+ VEMTrace: " << sIt->GetVEMTrace().GetSize() << " (size)" << nl;
      else
        iout << "- VEMTrace" << nl;

      if (sIt->HasTriggerData()) {
        const StationTriggerData& trig = sIt->GetTriggerData();
        //const IoSdT2Trigger& rawTrigger = rStation->Trigger;
        iout << "+ TriggerData:" << nl;
        iout+=tab;
        iout << "OffsetMicroSecond: " << trig.GetOffsetMicroSecond() << nl;
        iout << "ErrorCode: " << trig.GetErrorCode() << nl;
        iout << "WindowMicroSecond: " << trig.GetWindowMicroSecond() << nl;
        iout << "PLDTrigger: "; iout.OutputBinary(trig.GetPLDTrigger(), 16);
                            iout.GetOs() << " (mask)" << nl;
        iout << "Algorithm: " << trig.GetAlgorithmName() << nl;
        iout-=tab;
      } else
        iout << "- TriggerData" << nl;

      if (sIt->HasCalibData()) {
        //const IoSdCalib& rawCalib = *(rStation->Calib);
        const StationCalibData& calib = sIt->GetCalibData();
        iout << "+ StationCalibData:" << nl;
        iout+=tab;
        iout << "Version: " << calib.GetVersion() << nl;
        iout << "StartSecond: " << calib.GetStartSecond() << nl;
        iout << "EndSecond: " << calib.GetEndSecond() << nl;
        iout << "NT1: " << calib.GetNT1() << nl;
        iout << "NT2: " << calib.GetNT2() << nl;
        iout << "NTot: " << calib.GetNTot() << nl;
        // iout << "TubeMask: "; iout.OutputBinary(rawCalib.TubeMask, 3);
        //                  iout.GetOs() << " (mask)" << nl;
        /*if (rStation->Histo && rawCalib.Version > 8) {
          iout << "+ MuonChargeHisto" << nl;
          iout << "+ OffsetHisto:" << nl;
          iout+=tab;
          iout << "";
          for (int i = 0; i < NB_HISTO_CALIB; ++i)
            iout.GetOs() << rStation->Histo->Offset[i] << ((i+1)%3 ? " ":" | ");
          iout.GetOs() << nl;
          iout-=tab;
        } else {
          iout << "- MuonChargeHisto" << nl;
          iout << "- OffsetHisto" << nl;
        }
        iout-=tab;
      } else
        iout << "- StationCalibData" << nl;
        */
        iout << "NTubesOk: " << calib.GetNTubesOk() << nl;
        const int mSize = calib.GetMuonChargeHisto().size();
        iout << (mSize ? '+':'-') << " MuonChargeHisto: " << mSize << " (size)" << nl;
        /*const vector<int>& oHisto = calib.GetOffsetHisto();
        const int oSize = oHisto.size();
        if (oSize) {
          iout << "+ OffsetHisto: " << oSize << " (size)" << nl;
          iout+=tab;
          iout << "";
          for (int i = 0; i < oSize; ++i)
            iout.GetOs() << oHisto[i] << ((i+1)%3 ? " ":" | ");
          iout.GetOs() << nl;
          iout-=tab;
        } else
          iout << "- OffsetHisto" << nl;*/
        iout-=tab;
      } else
        iout << "- StationCalibData" << nl;

      if (sIt->HasRecData()) {
        const StationRecData& rec = sIt->GetRecData();
        iout << "+ StationRecData:" << nl;
        iout+=tab;
        iout << "TotalSignal: " << rec.GetTotalSignal() << nl;
        iout << "SPDistance: " << rec.GetSPDistance() << nl;
        iout << "PeakAmplitude: " << rec.GetPeakAmplitude() << nl;
        iout << "ShapeParameter: " << rec.GetShapeParameter() << " +/- "
                               << rec.GetShapeParameterRMS() << nl;
        iout << "RiseTime: " << rec.GetRiseTime() << " +/- "
                         << rec.GetRiseTimeRMS() << nl;
        iout << "FallTime: " << rec.GetFallTime() << " +/- "
                         << rec.GetFallTimeRMS() << nl;
        iout << "Residual: " << rec.GetResidual() << nl;
        iout << "LDFResidual: " << rec.GetLDFResidual() << nl;
        iout << "SignalStartTime: " << rec.GetSignalStartTime() << nl;
        iout << "SignalStartSlot: " << rec.GetSignalStartSlot() << nl;
        iout << "SignalEndSlot: " << rec.GetSignalEndSlot() << nl;
        iout << "MuonComponent: " << rec.GetMuonComponent() << nl;
        iout-=tab;
      } else
        iout << "- StationRecData" << nl;

      if (fShowSimData) {
        if (sIt->HasSimData()) {
          const StationSimData& sim = sIt->GetSimData();
          iout << "+ StationSimData:" << nl;
          iout+=tab;

          unsigned int nParticles = 0;
          for (StationSimData::ConstParticleIterator pIt = sim.ParticlesBegin();
               pIt != sim.ParticlesEnd(); ++pIt)
            ++nParticles;

          iout << "NParticles: " << nParticles << nl;
          iout << "PlaneFrontTime: " << sim.GetPlaneFrontTime() << nl;
          iout-=tab;
        } else
          iout << "- StationSimData" << nl;
      }

      if (fInfoLevel >= eInfoPMT) {
        iout << "* PMT Collection:" << nl << nl;
        iout+=tab;
        for (Station::ConstPMTIterator pmtIt = sIt->PMTsBegin();
             pmtIt != sIt->PMTsEnd();
             ++pmtIt) {

          iout << "Id: " << pmtIt->GetId() << nl;
          if (pmtIt->HasFADCTrace()) {
            const int fadcSize = pmtIt->GetFADCTrace().GetSize();
            iout << "+ FADCTrace: " << fadcSize << " (size)" << nl;
          } else
            iout << "- FADCTrace" << nl;

          if (pmtIt->HasCalibData()) {
            const PMTCalibData& cal = pmtIt->GetCalibData();
            iout << "+ PMTCalibData:" << nl;
            iout+=tab;
            iout << "IsTubeOk: " << cal.IsTubeOk() << nl;
            iout << "Rate: " << cal.GetRate() << nl;
            iout << "OnlinePeak: " << cal.GetOnlinePeak() << nl;
            iout << "OnlineCharge: " << cal.GetOnlineCharge() << nl;
            iout << "Baseline.HighGain: " << cal.GetBaseline() << " +/- " << cal.GetBaselineRMS() << nl;
            iout << "Baseline.LowGain: " << cal.GetBaseline(sdet::PMTConstants::eLowGain) << " +/- "
                 << cal.GetBaselineRMS(sdet::PMTConstants::eLowGain) << nl;
            iout << "GainRatio: " << cal.GetGainRatio() << " +/- " << cal.GetGainRatioRMS() << nl;
            iout << "DynodeAnodeDelay: " << cal.GetHighGainDelay() << " +/- "
                 << cal.GetHighGainDelayRMS() << ", "
                 << cal.GetHighGainDelayChi2() << " (Chi2)" << nl;
            const int mBaseSize = cal.GetMuonBaseHisto().size();
            iout << (mBaseSize ? '+':'-') << " MuonBaseHisto: " << mBaseSize << " (size)" << nl;
            const int mPeakSize = cal.GetMuonPeakHisto().size();
            iout << (mPeakSize ? '+':'-') << " MuonPeakHisto: " << mPeakSize << " (size)" << nl;
            const int mChargeSize = cal.GetMuonChargeHisto().size();
            iout << (mChargeSize ? '+':'-') << " MuonChargeHisto: " << mChargeSize << " (size)" << nl;
            const int mShapeSize = cal.GetMuonShapeHisto().size();
            iout << (mShapeSize ? '+':'-') << " MuonShapeHisto: " << mShapeSize << " (size)" << nl;
            const int evolution = cal.GetEvolution();
            iout << "Evolution: " << evolution << " \"";
            for (int i = 0; i < 16; i+=2)
              switch ((evolution>>i) & 3) {
              case 0:  iout.GetOs() << '='; break;
              case 1:  iout.GetOs() << '-'; break;
              case 2:  iout.GetOs() << '+'; break;
              default: iout.GetOs() << '?'; break;
              }
            iout.GetOs() << '\"' << nl;
            iout << "NumberTDA: " << cal.GetNumberTDA() << nl;
            iout-=tab;
          } else
            iout << "- PMTCalibData" << nl;


          if (pmtIt->HasRecData()) {
            const PMTRecData& rec = pmtIt->GetRecData();
            iout << "+ PMTRecData:" << nl;
            iout+=tab;
            if (rec.HasVEMTrace()) {
              const int vemSize = rec.GetVEMTrace().GetSize();
              iout << "+ VEMTrace: " << vemSize << " (size)" << nl;
            } else
              iout << "- VEMTrace" << nl;
            iout << "RiseTime: " << rec.GetRiseTime() << " +/- " << rec.GetRiseTimeRMS() << nl;
            iout << "FallTime: " << rec.GetFallTime() << " +/- " << rec.GetFallTimeRMS() << nl;
            iout << "VEMPeak: " << rec.GetVEMPeak() << nl;
            iout << "VEMCharge: " << rec.GetVEMCharge() << nl;
            iout << "AreaOverPeak: " << rec.GetAreaOverPeak() << nl;
            iout << "TotalCharge: " << rec.GetTotalCharge() << nl;
            iout << "PeakAmplitude: " << rec.GetPeakAmplitude() << nl;
            iout << "GainRatio: " << rec.GetGainRatio() << nl;
            iout-=tab;
          } else
            iout << "- PMTRecData" << nl;

          iout.GetOs() << nl;
        } // pmtIt

        iout-=tab;

      } // eInfoPMT

      iout.GetOs() << nl;
    } // sIt

    iout-=tab;
    iout << "^ Station statistics:" << nl;
    iout << "|     NStations: " << nStations << nl;
    iout << "|     NCandidates: " << nCandidates << nl;
    iout << "|     NSilent: " << nSilent << nl << endl;

  } // eInfoStation

  iout-=tab;

  return eSuccess;
}


VModule::ResultFlag
SdInspector::Finish()
{
  return eSuccess;
}

// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// End: