PndCACounters.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

#ifndef PNDCACOUNTERS_H
#define PNDCACOUNTERS_H

#include "PndCACountersBase.h"
#include "PndCAParameters.h"

#include <iostream>
using std::cout;
using std::endl;
using std::ios;

#include <string>
using std::string;

#include <vector>
using std::vector;

#include <map>
using std::map;

struct PndCAEfficiencies : public TEfficiencies {
  PndCAEfficiencies() : TEfficiencies()
  {

    AddCounter("ref_prim_long", "LRefPrim  efficiency");
    AddCounter("ref_prim", "RefPrim   efficiency");
    AddCounter("ref_sec", "RefSec    efficiency");
    AddCounter("ref", "Refset    efficiency");
    AddCounter("extra_prim", "ExtraPrim efficiency");
    AddCounter("extra_sec", "ExtraSec  efficiency");
    AddCounter("extra", "Extra     efficiency");
    AddCounter("total", "Allset    efficiency");
    AddCounter("rest", "Rest      efficiency");
  }
  virtual ~PndCAEfficiencies(){};

  virtual void AddCounter(string shortname, string name)
  {
    TEfficiencies::AddCounter(shortname, name);
    ratio_killed.AddCounter();
    ratio_clone.AddCounter();
    ratio_length.AddCounter();
    ratio_fakes.AddCounter();
    killed.AddCounter();
    clone.AddCounter();
    reco_length.AddCounter();
    reco_fakes.AddCounter();
  }

  PndCAEfficiencies &operator+=(PndCAEfficiencies &a)
  {
    TEfficiencies::operator+=(a);
    killed += a.killed;
    clone += a.clone;
    reco_length += a.reco_length;
    reco_fakes += a.reco_fakes;
    return *this;
  }

  void CalcEff()
  {
    TEfficiencies::CalcEff();
    ratio_killed = killed / mc;
    ratio_clone = clone / mc;
    TTracksCatCounters<int> allReco = reco + clone;
    ratio_length = reco_length / allReco;
    ratio_fakes = reco_fakes / allReco;
  }

  void Inc(bool isReco, bool isKilled, double _ratio_length, double _ratio_fakes, int _nclones, string name)
  {
    TEfficiencies::Inc(isReco, name);

    const int index = indices[name];

    if (isKilled)
      killed.counters[index]++;
    reco_length.counters[index] += _ratio_length;
    reco_fakes.counters[index] += _ratio_fakes;
    clone.counters[index] += _nclones;
  }

  void Print()
  {
    std::cout.setf(ios::fixed);
    std::cout.setf(ios::showpoint);
    std::cout.precision(3);
    std::cout << "Track category         : "
              << " Eff  "
              //<<" / "<< "Killed"
              << " / "
              << "Length"
              << " / "
              << "Fakes "
              << " / "
              << "Clones"
              << " / "
              << "All Reco"
              << " | "
              << "All MC" << std::endl;

    int NCounters = mc.NCounters;
    for (int iC = 0; iC < NCounters; iC++) {
      if ((names[iC] != "D0        efficiency") || (mc.counters[iC] != 0))
        std::cout << names[iC] << "   : "
                  << ratio_reco.counters[iC]
                  //<< "  / " << ratio_killed.counters[iC]  // tracks with aren't reco because other tracks takes their hit(-s)
                  << "  / " << ratio_length.counters[iC] // nRecoMCHits/nMCHits
                  << "  / " << ratio_fakes.counters[iC]  // nFakeHits/nRecoAllHits
                  << "  / " << ratio_clone.counters[iC]  // nCloneTracks/nMCTracks
                  << "  / " << double(reco.counters[iC]) / double(nEvents) << "    | " << double(mc.counters[iC]) / double(nEvents) << std::endl;
    }
    std::cout << "Ghost     probability  : " << ratio_ghosts << " | " << double(ghosts) / double(nEvents) << std::endl;
    std::cout << "All reco tracks/ev : " << int(double(reco.counters[indices["total"]]) / double(nEvents) + .5) << endl;
  }

  TTracksCatCounters<double> ratio_killed;
  TTracksCatCounters<double> ratio_clone;
  TTracksCatCounters<double> ratio_length;
  TTracksCatCounters<double> ratio_fakes;

  TTracksCatCounters<int> killed;
  TTracksCatCounters<int> clone;
  TTracksCatCounters<double> reco_length;
  TTracksCatCounters<double> reco_fakes;
};

class PndCAPerformanceMCTrackData {
 public:
  PndCAPerformanceMCTrackData()
  {
    set = 0;
    isReconstructable = 0;
  };

  void SetSet(int set_) { set = set_; }
  void SetAsReconstructable() { isReconstructable = true; }
  void AddReconstructed(int itr = 0) { recoTrackIds.push_back(itr); }

  int GetSet() { return set; }
  bool IsReconstructable() { return isReconstructable; }
  bool IsReconstructed() { return recoTrackIds.size() >= 1; }
  bool GetNClones() { return (recoTrackIds.size() > 1) ? recoTrackIds.size() - 1 : 0; }

  const std::vector<int> &RecoTrackIds() const { return recoTrackIds; }
  void Print() { cout << "Set: " << set << " RecoAble: " << isReconstructable << " NReco: " << recoTrackIds.size() << endl; }

 private:
  int set; // set of tracks 0-OutSet, 1-ExtraSet, 2-RefSet, 3-ExtraSecSet, 4-ExtraPrimSet, 5-RefSecSet, 6-RefPrimSet, 7-LongRefPrimSet
  bool isReconstructable;

  std::vector<int> recoTrackIds;
};

class PndCAPerformanceRecoTrackData {
 public:
  PndCAPerformanceRecoTrackData() { mcTrackId = -1; };

  void SetMCTrack(int mcTrackId_, float purity_, int nHits_)
  {
    mcTrackId = mcTrackId_;
    purity = purity_;
    nHits = nHits_;
  }

  int GetMCTrackId() { return mcTrackId; }
  float GetPurity() { return purity; }
  bool IsGhost(float minPurity = 0) { return (mcTrackId == -1) || (purity < minPurity); }
  bool IsReco(float minPurity = 0, int minNHits = 0) { return (mcTrackId != -1) && (purity >= minPurity) && (nHits >= minNHits); }
  int NHits() { return nHits; }

  void Print() { cout << "Track: " << mcTrackId << " Purity: " << purity << endl; }

 private:
  int mcTrackId;
  float purity;
  int nHits;
};

#endif