KVFilterGroupReconstructor.h

#ifndef __KVFILTERGROUPRECONSTRUCTOR_H
#define __KVFILTERGROUPRECONSTRUCTOR_H
 
#include "KVGroupReconstructor.h"
#include "KVDataQualityAudit.h"
#include <unordered_map>
class KVFilterGroupReconstructor : public KVGroupReconstructor {
 
   const KVDataQualityAudit* fDataQAudit = nullptr; 
 
protected:
    std::unique_ptr<KVEvent> fSimEvent;
    std::unordered_map<std::string, int> hits;
    std::unordered_map<KVReconstructedNucleus*, TList> part_correspond;
    KVReconstructedNucleus* current_nuc_recon;
 
    std::unordered_map<std::string, double> energy_loss;
    std::unordered_map<std::string, int> number_uncalibrated;
    std::unordered_map<std::string, int> number_unidentified;
   KVReconNucTrajectory* get_recon_traj_for_particle(const KVGeoDNTrajectory*, const KVGeoDetectorNode* node) override;
   void identify_particle(KVIDTelescope* idt, KVIdentificationResult* IDR, KVReconstructedNucleus& nuc) override;
   void check_identification_threshold(KVNucleus*, KVIDTelescope* idt, KVIdentificationResult* IDR);
   void PerformSecondaryAnalysis();
 
   virtual TString get_id_telescope_name_for_audit(KVIDTelescope* idt) const
   {
      return idt->GetName();
   }
   bool audit_has_telescope_with_name(const TString& n) const
   {
      return fDataQAudit->HasTelescope(n);
   }
   bool has_audit() const
   {
      return fDataQAudit!=nullptr;
   }
   static std::unordered_map<std::string,bool> audit_id_extensions;
   bool can_extend_identification_beyond_audit(const std::string& id_label)
   {
      return audit_id_extensions[id_label];
   }
 
public:
   static void EnableIDExtensionBeyondAudit(const TString& idlab)
   {
 
      ::Info("KVFilterGroupReconstructor::EnableIDExtensionBeyondAudit()", "%s", idlab.Data());
      audit_id_extensions[idlab.Data()]=true;
      audit_id_extensions["initialised"]=true;
   }
 
   KVFilterGroupReconstructor(const KVGroup* g = nullptr) : KVGroupReconstructor(g)
   {
   }
 
   void SetSimEvent(KVEvent* e)
   {
 
      fSimEvent.reset(static_cast<KVEvent*>(e->IsA()->New()));
   }
   void AddSimParticle(const KVNucleus* n)
   {
 
      KVNucleus* nuc;
 
      n->Copy(*(nuc = fSimEvent->AddNucleus()));
      auto traj = GetGroup()->FindReconTraj(n->GetParameters()->GetStringValue("TRAJECTORY"));
      if(!traj)
      {
         KVString s_traj(n->GetParameters()->GetStringValue("TRAJECTORY"));
 
         s_traj.Begin("/");
         auto stop_det = GetGroup()->GetDetector(s_traj.Next());
         int most_dets_on_traj = 0;
         KVGeoDNTrajectory* best_traj = nullptr;
         for(auto _traj : *stop_det->GetNode()->GetTrajectories())
         {
            traj = dynamic_cast<KVGeoDNTrajectory*>(_traj);
            s_traj.Begin("/");
            int ndets=0;
            while(!s_traj.End())
            {
               ndets+=traj->Contains(s_traj.Next());
            }
            if(ndets>most_dets_on_traj)
            {
               most_dets_on_traj=ndets;
               best_traj=const_cast<KVGeoDNTrajectory*>(traj);
            }
         }
 
         if(!best_traj)
         {
            Error("AddSimParticle", "Could not find trajectory to suit this particle:");
            n->Print();
            GetGroup()->Print();
         }
         else
         {
            traj = GetGroup()->GetTrajectoryForReconstruction(best_traj,stop_det->GetNode());
         }
 
         nuc->SetParameter("TRAJECTORY", traj->GetPathString());
      }
      traj->IterateFrom();
      double de_tot=0;
      while (auto node = traj->GetNextNode()) {
         ++hits[node->GetName()];
         ++number_unidentified[node->GetName()];
         KVNamedParameter* np;
         if((np = nuc->GetParameters()->FindParameter(node->GetName())) && np->IsDouble())
            de_tot += np->GetDouble();
      }
      nuc->SetParameter("TOTAL_DE", de_tot);
      nuc->SetE(de_tot);
   }
   void Clear(Option_t* = "") override
   {
      fSimEvent->Clear();
      hits.clear();
      part_correspond.clear();
      energy_loss.clear();
      number_uncalibrated.clear();
      number_unidentified.clear();
   }
   void ReconstructParticle(KVReconstructedNucleus* part, const KVGeoDNTrajectory* traj, const KVGeoDetectorNode* node) override;
   void IdentifyParticle(KVReconstructedNucleus& PART) override;
   void CalibrateParticle(KVReconstructedNucleus* PART) override;
 
   void SetDataQualityAudit(const KVDataQualityAudit* DQA)
   {
      fDataQAudit = DQA;
   }
 
   ClassDefOverride(KVFilterGroupReconstructor, 1) //Reconstruct simulated events after filtering
};
 
#endif