CDCTriggerNeuroDQMModule.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/core/HistoModule.h>
 
#include <framework/datastore/StoreArray.h>
#include <framework/datastore/StoreObjPtr.h>
#include <trg/cdc/dataobjects/CDCTriggerTrack.h>
#include <trg/cdc/dataobjects/CDCTriggerSegmentHit.h>
#include <trg/cdc/dataobjects/CDCTriggerMLPInput.h>
#include <tracking/dataobjects/RecoTrack.h>
#include <framework/dataobjects/BinnedEventT0.h>
 
#include "TH1F.h"
#include "TH2F.h"
 
namespace Belle2 {
  class CDCTriggerNeuroDQMModule : public HistoModule {  // <- derived from HistoModule class
 
  public:
    CDCTriggerNeuroDQMModule();
    virtual ~CDCTriggerNeuroDQMModule();
 
    virtual void initialize() override;
    virtual void beginRun() override;
    virtual void event() override;
    virtual void endRun() override;
    virtual void terminate() override;
 
    virtual void defineHisto() override;
    struct TSLine {
      const CDCTriggerSegmentHit* hit;
      std::string strline;
      //vector<const CDCTriggerTrack*> relin2dtracks;
      //vector<const CDCTriggerTrack*> relin2dtracks;
      explicit TSLine(const CDCTriggerSegmentHit& h)
      {
        hit = &h;
      }
    };
    typedef std::vector<TSLine> TSLines;
 
  private:
    void condFill(TH1F* histo, float value)
    {
      if (value != 0) {
        histo->Fill(value);
      }
    }
    unsigned getPattern(CDCTriggerTrack* track, std::string hitCollectionName)
    {
      unsigned pattern = 0;
      for (const CDCTriggerSegmentHit& hit : track->getRelationsTo<CDCTriggerSegmentHit>(hitCollectionName)) {
        unsigned sl = hit.getISuperLayer();
        if (sl % 2 == 1) pattern |= (1 << ((sl - 1) / 2));
      }
      return pattern;
    }
    bool isValidPattern(unsigned pattern)
    {
      bool valid = false;
      switch (pattern) {
        case 7:
        case 11:
        case 13:
        case 14:
        case 15:
          valid = true;
      }
      return valid;
    }
    std::string padto(std::string s, unsigned l)
    {
      if (s.size() < l) {
        s.insert(s.begin(), l - s.size(), ' ');
      }
      return s;
    }
    std::string padright(std::string s, unsigned l)
    {
      if (s.size() < l) {
        s.insert(s.end(), l - s.size(), ' ');
      }
      return s;
    }
    bool have_relation(const CDCTriggerTrack& track, const CDCTriggerSegmentHit& hit, std::string& arrayname)
    {
      bool related = false;
      for (const CDCTriggerSegmentHit& ts : track.getRelationsTo<CDCTriggerSegmentHit>(arrayname)) {
        if (&ts == &hit) {related = true;}
      }
      return related;
    }
    void sorted_insert(TSLines& lines, TSLine& line, std::string& arrayname, std::string& firstsortarray, std::string& secondsortarray)
    {
      bool inserted = false;
      bool related = false;
      TSLines::iterator it = lines.begin();
      for (const CDCTriggerTrack& track : line.hit->getRelationsFrom<CDCTriggerTrack>(firstsortarray)) {
        if (!inserted) {
          for (TSLines::iterator i = lines.begin(); i < lines.end(); ++i) {
            if (i->hit->getISuperLayer() % 2 != line.hit->getISuperLayer() % 2) {
              continue;
            }
            if (have_relation(track, *(i->hit), arrayname)) {
              it = i;
              related = true;
              if (i->hit->getSegmentID() > line.hit->getSegmentID()) {
                inserted = true;
                break;
              }
            }
          }
        } else { break; }
      }
      if (related) {
        if (!inserted) {++it; }
        lines.insert(it, line);
      } else {
        for (const CDCTriggerTrack& track : line.hit->getRelationsFrom<CDCTriggerTrack>(secondsortarray)) {
          if (!inserted) {
            for (TSLines::iterator i = it; i < lines.end(); ++i) {
              if (i->hit->getISuperLayer() % 2 != line.hit->getISuperLayer() % 2) {
                continue;
              }
              if (have_relation(track, *(i->hit), arrayname)) {
                it = i;
                related = true;
                if (i->hit->getSegmentID() > line.hit->getSegmentID()) {
                  inserted = true;
                  break;
                }
              }
            }
          } else { break; }
        }
        if (related) {
          if (!inserted) {++it; }
          lines.insert(it, line);
        } else {
          lines.push_back(line);
        }
      }
    }
    std::string m_histogramDirectoryName;
    bool m_limitedoutput;
    int m_nsamets;
    // names for unpacked objects
    std::string m_unpackedSegmentHitsName;
    std::string m_unpacked2DTracksName;
    std::string m_unpackedNeuroTracksName;
    std::string m_unpackedNeuroInputVectorName;
    std::string m_unpackedNeuroInput2DTracksName;
    std::string m_unpackedNeuroInputSegmentsName;
 
    // names for simulated objects
    std::string m_simNeuroTracksName;
    std::string m_simNeuroInputVectorName;
    bool m_showRecoTracks;
    int m_recoTrackMultiplicity;
    bool m_skipWithoutHWTS;
    double m_maxRecoZDist;
    double m_maxRecoD0Dist;
 
    std::string m_simSegmentHitsName;
    std::string m_sim2DTracksSWTSName;
    std::string m_simNeuroTracksSWTSSW2DName;
    std::string m_simNeuroInputVectorSWTSSW2DName;
 
    std::string m_recoTracksName;
 
 
    // store arrays for direct access
    StoreArray<CDCTriggerSegmentHit> m_unpackedSegmentHits;
    StoreArray<CDCTriggerTrack> m_unpacked2DTracks;
    StoreArray<CDCTriggerTrack> m_unpackedNeuroTracks;
    StoreArray<CDCTriggerMLPInput> m_unpackedNeuroInputVector;
    StoreArray<CDCTriggerTrack> m_unpackedNeuroInput2DTracks;
    StoreArray<CDCTriggerSegmentHit> m_unpackedNeuroInputSegments;
    StoreArray<CDCTriggerTrack> m_simNeuroTracks;
    StoreArray<CDCTriggerMLPInput> m_simNeuroInputVector;
    StoreArray<RecoTrack> m_RecoTracks;
 
    StoreArray<CDCTriggerSegmentHit> m_simSegmentHits;
    StoreArray<CDCTriggerTrack> m_sim2DTracksSWTS;
    StoreArray<CDCTriggerMLPInput> m_simNeuroInputVectorSWTSSW2D;
    StoreArray<CDCTriggerTrack> m_simNeuroTracksSWTSSW2D;
    StoreObjPtr<BinnedEventT0> m_eventTime;
    // histograms for neurotrigger
    TH1F* m_neuroHWOutZ = nullptr;                     
    TH1F* m_neuroHWOutCosTheta = nullptr;              
    TH1F* m_neuroHWOutInvPt = nullptr;                 
    TH1F* m_neuroHWOutPt = nullptr;                    
    TH1F* m_neuroHWOutPhi0 = nullptr;                  
    TH1F* m_neuroHWOutHitPattern = nullptr;            
    TH1F* m_neuroHWOutm_time = nullptr;                
    TH1F* m_neuroHWOutTrackCount = nullptr;            
    TH1F* m_neuroHWSector = nullptr;                   
    TH1F* m_neuroHWInInvPt = nullptr;                  
    TH1F* m_neuroHWInPhi0 = nullptr;                   
    TH1F* m_neuroHWInm_time = nullptr;                 
    TH1F* m_neuroHWInTrackCount = nullptr;             
    TH1F* m_neuroHWOutVsInTrackCount = nullptr;        
    TH1F* m_2DHWOutInvPt = nullptr;                    
    TH1F* m_2DHWOutPhi0 = nullptr;                     
    TH1F* m_2DHWOutm_time = nullptr;                   
    TH1F* m_2DHWOutTrackCount = nullptr;               
    TH1F* m_neuroHWInVs2DOutTrackCount = nullptr;      
    // hw TS hw 2D sw NN
    TH1F* m_neuroSWOutZ = nullptr;                     
    TH1F* m_neuroSWOutCosTheta = nullptr;              
    TH1F* m_neuroSWOutInvPt = nullptr;                 
    TH1F* m_neuroSWOutPhi0 = nullptr;                  
    TH1F* m_neuroSWOutHitPattern = nullptr;            
    TH1F* m_neuroSWOutTrackCount = nullptr;            
    TH1F* m_neuroSWSector = nullptr;                   
    TH1F* m_2DSWOutInvPt = nullptr;                    
    TH1F* m_2DSWOutPhi0 = nullptr;                     
    TH1F* m_2DSWOutm_time = nullptr;                   
    TH1F* m_2DSWOutTrackCount = nullptr;               
    // sw TS sw 2D sw NN
    TH1F* m_neuroSWTSSW2DOutZ = nullptr;               
    TH1F* m_neuroSWTSSW2DOutCosTheta = nullptr;        
    TH1F* m_neuroSWTSSW2DOutInvPt = nullptr;           
    TH1F* m_neuroSWTSSW2DOutPhi0 = nullptr;            
    TH1F* m_neuroSWTSSW2DOutHitPattern = nullptr;      
    TH1F* m_neuroSWTSSW2DOutTrackCount = nullptr;      
    TH1F* m_neuroSWTSSW2DSector = nullptr;             
    // hw TS hw 2D sw NN vs hw NN
    TH1F* m_neuroDeltaZ = nullptr;                     
    TH1F* m_neuroDeltaTheta = nullptr;                 
    TH2F* m_neuroScatterZ = nullptr;                   
    TH2F* m_neuroScatterTheta = nullptr;               
    TH1F* m_neuroDeltaInputID = nullptr;               
    TH1F* m_neuroDeltaInputT = nullptr;                
    TH1F* m_neuroDeltaInputAlpha = nullptr;            
    TH1F* m_neuroDeltaTSID = nullptr;                  
    TH1F* m_neuroDeltaSector = nullptr;                
    TH1F* m_simSameTS = nullptr;                       
    TH1F* m_simDiffTS = nullptr;                       
    // hw NN output for each quadrant
    TH1F* m_neuroHWOutQuad5Z = nullptr;                
    TH1F* m_neuroHWOutQuad5CosTheta = nullptr;         
    TH1F* m_neuroHWOutQuad5Phi0 = nullptr;             
    TH1F* m_neuroHWOutQuad5InvPt = nullptr;            
    TH1F* m_neuroHWOutQuad0Z = nullptr;                
    TH1F* m_neuroHWOutQuad0CosTheta = nullptr;         
    TH1F* m_neuroHWOutQuad0Phi0 = nullptr;             
    TH1F* m_neuroHWOutQuad0InvPt = nullptr;            
    TH1F* m_neuroHWOutQuad1Z = nullptr;                
    TH1F* m_neuroHWOutQuad1CosTheta = nullptr;         
    TH1F* m_neuroHWOutQuad1Phi0 = nullptr;             
    TH1F* m_neuroHWOutQuad1InvPt = nullptr;            
    TH1F* m_neuroHWOutQuad2Z = nullptr;                
    TH1F* m_neuroHWOutQuad2CosTheta = nullptr;         
    TH1F* m_neuroHWOutQuad2Phi0 = nullptr;             
    TH1F* m_neuroHWOutQuad2InvPt = nullptr;            
    TH1F* m_neuroHWOutQuad3Z = nullptr;                
    TH1F* m_neuroHWOutQuad3CosTheta = nullptr;         
    TH1F* m_neuroHWOutQuad3Phi0 = nullptr;             
    TH1F* m_neuroHWOutQuad3InvPt = nullptr;            
    // hw NN received TS
    TH1F* m_neuroHWInTSID = nullptr;                   
    TH1F* m_neuroHWInTSCount = nullptr;                
    TH1F* m_neuroHWInTSPrioT_Layer0 = nullptr;         
    TH1F* m_neuroHWInTSPrioT_Layer1 = nullptr;         
    TH1F* m_neuroHWInTSPrioT_Layer2 = nullptr;         
    TH1F* m_neuroHWInTSPrioT_Layer3 = nullptr;         
    TH1F* m_neuroHWInTSPrioT_Layer4 = nullptr;         
    TH1F* m_neuroHWInTSPrioT_Layer5 = nullptr;         
    TH1F* m_neuroHWInTSPrioT_Layer6 = nullptr;         
    TH1F* m_neuroHWInTSPrioT_Layer7 = nullptr;         
    TH1F* m_neuroHWInTSPrioT_Layer8 = nullptr;         
    TH1F* m_neuroHWInTSFoundT_Layer0 = nullptr;        
    TH1F* m_neuroHWInTSFoundT_Layer1 = nullptr;        
    TH1F* m_neuroHWInTSFoundT_Layer2 = nullptr;        
    TH1F* m_neuroHWInTSFoundT_Layer3 = nullptr;        
    TH1F* m_neuroHWInTSFoundT_Layer4 = nullptr;        
    TH1F* m_neuroHWInTSFoundT_Layer5 = nullptr;        
    TH1F* m_neuroHWInTSFoundT_Layer6 = nullptr;        
    TH1F* m_neuroHWInTSFoundT_Layer7 = nullptr;        
    TH1F* m_neuroHWInTSFoundT_Layer8 = nullptr;        
    TH1F* m_neuroHWInTSPrioB_Layer0 = nullptr;         
    TH1F* m_neuroHWInTSPrioB_Layer1 = nullptr;         
    TH1F* m_neuroHWInTSPrioB_Layer2 = nullptr;         
    TH1F* m_neuroHWInTSPrioB_Layer3 = nullptr;         
    TH1F* m_neuroHWInTSPrioB_Layer4 = nullptr;         
    TH1F* m_neuroHWInTSPrioB_Layer5 = nullptr;         
    TH1F* m_neuroHWInTSPrioB_Layer6 = nullptr;         
    TH1F* m_neuroHWInTSPrioB_Layer7 = nullptr;         
    TH1F* m_neuroHWInTSPrioB_Layer8 = nullptr;         
    TH1F* m_neuroHWInTSLR_Layer0 = nullptr;            
    TH1F* m_neuroHWInTSLR_Layer1 = nullptr;            
    TH1F* m_neuroHWInTSLR_Layer2 = nullptr;            
    TH1F* m_neuroHWInTSLR_Layer3 = nullptr;            
    TH1F* m_neuroHWInTSLR_Layer4 = nullptr;            
    TH1F* m_neuroHWInTSLR_Layer5 = nullptr;            
    TH1F* m_neuroHWInTSLR_Layer6 = nullptr;            
    TH1F* m_neuroHWInTSLR_Layer7 = nullptr;            
    TH1F* m_neuroHWInTSLR_Layer8 = nullptr;            
    // hw NN selected TS
    TH1F* m_neuroHWSelTSID = nullptr;                  
    TH1F* m_neuroHWSelTSCount = nullptr;               
    TH1F* m_neuroHWSelTSPrioT_Layer0 = nullptr;        
    TH1F* m_neuroHWSelTSPrioT_Layer1 = nullptr;        
    TH1F* m_neuroHWSelTSPrioT_Layer2 = nullptr;        
    TH1F* m_neuroHWSelTSPrioT_Layer3 = nullptr;        
    TH1F* m_neuroHWSelTSPrioT_Layer4 = nullptr;        
    TH1F* m_neuroHWSelTSPrioT_Layer5 = nullptr;        
    TH1F* m_neuroHWSelTSPrioT_Layer6 = nullptr;        
    TH1F* m_neuroHWSelTSPrioT_Layer7 = nullptr;        
    TH1F* m_neuroHWSelTSPrioT_Layer8 = nullptr;        
    TH1F* m_neuroHWSelTSFoundT_Layer0 = nullptr;       
    TH1F* m_neuroHWSelTSFoundT_Layer1 = nullptr;       
    TH1F* m_neuroHWSelTSFoundT_Layer2 = nullptr;       
    TH1F* m_neuroHWSelTSFoundT_Layer3 = nullptr;       
    TH1F* m_neuroHWSelTSFoundT_Layer4 = nullptr;       
    TH1F* m_neuroHWSelTSFoundT_Layer5 = nullptr;       
    TH1F* m_neuroHWSelTSFoundT_Layer6 = nullptr;       
    TH1F* m_neuroHWSelTSFoundT_Layer7 = nullptr;       
    TH1F* m_neuroHWSelTSFoundT_Layer8 = nullptr;       
    TH1F* m_neuroHWSelTSPrioB_Layer0 = nullptr;        
    TH1F* m_neuroHWSelTSPrioB_Layer1 = nullptr;        
    TH1F* m_neuroHWSelTSPrioB_Layer2 = nullptr;        
    TH1F* m_neuroHWSelTSPrioB_Layer3 = nullptr;        
    TH1F* m_neuroHWSelTSPrioB_Layer4 = nullptr;        
    TH1F* m_neuroHWSelTSPrioB_Layer5 = nullptr;        
    TH1F* m_neuroHWSelTSPrioB_Layer6 = nullptr;        
    TH1F* m_neuroHWSelTSPrioB_Layer7 = nullptr;        
    TH1F* m_neuroHWSelTSPrioB_Layer8 = nullptr;        
    TH1F* m_neuroHWSelTSLR_Layer0 = nullptr;           
    TH1F* m_neuroHWSelTSLR_Layer1 = nullptr;           
    TH1F* m_neuroHWSelTSLR_Layer2 = nullptr;           
    TH1F* m_neuroHWSelTSLR_Layer3 = nullptr;           
    TH1F* m_neuroHWSelTSLR_Layer4 = nullptr;           
    TH1F* m_neuroHWSelTSLR_Layer5 = nullptr;           
    TH1F* m_neuroHWSelTSLR_Layer6 = nullptr;           
    TH1F* m_neuroHWSelTSLR_Layer7 = nullptr;           
    TH1F* m_neuroHWSelTSLR_Layer8 = nullptr;           
    // hw 2D received TS
    //TH1F* m_2DHWInTSID = nullptr;                      /**< ID of 2D incoming axial track segments */
    //TH1F* m_2DHWInTSCount = nullptr;                   /**< number of 2D incoming TS per event */
    TH1F* m_2DHWInTSPrioT_Layer0 = nullptr;            
    TH1F* m_2DHWInTSPrioT_Layer2 = nullptr;            
    TH1F* m_2DHWInTSPrioT_Layer4 = nullptr;            
    TH1F* m_2DHWInTSPrioT_Layer6 = nullptr;            
    TH1F* m_2DHWInTSPrioT_Layer8 = nullptr;            
    TH1F* m_2DHWInTSFoundT_Layer0 = nullptr;           
    TH1F* m_2DHWInTSFoundT_Layer2 = nullptr;           
    TH1F* m_2DHWInTSFoundT_Layer4 = nullptr;           
    TH1F* m_2DHWInTSFoundT_Layer6 = nullptr;           
    TH1F* m_2DHWInTSFoundT_Layer8 = nullptr;           
    TH1F* m_2DHWInTSPrioB_Layer0 = nullptr;            
    TH1F* m_2DHWInTSPrioB_Layer2 = nullptr;            
    TH1F* m_2DHWInTSPrioB_Layer4 = nullptr;            
    TH1F* m_2DHWInTSPrioB_Layer6 = nullptr;            
    TH1F* m_2DHWInTSPrioB_Layer8 = nullptr;            
    TH1F* m_2DHWInTSLR_Layer0 = nullptr;               
    TH1F* m_2DHWInTSLR_Layer2 = nullptr;               
    TH1F* m_2DHWInTSLR_Layer4 = nullptr;               
    TH1F* m_2DHWInTSLR_Layer6 = nullptr;               
    TH1F* m_2DHWInTSLR_Layer8 = nullptr;               
    // hw TS selected by sw NN
    TH1F* m_neuroSWSelTSID = nullptr;                  
    TH1F* m_neuroSWSelTSCount = nullptr;               
    TH1F* m_neuroSWSelTSPrioT_Layer0 = nullptr;        
    TH1F* m_neuroSWSelTSPrioT_Layer1 = nullptr;        
    TH1F* m_neuroSWSelTSPrioT_Layer2 = nullptr;        
    TH1F* m_neuroSWSelTSPrioT_Layer3 = nullptr;        
    TH1F* m_neuroSWSelTSPrioT_Layer4 = nullptr;        
    TH1F* m_neuroSWSelTSPrioT_Layer5 = nullptr;        
    TH1F* m_neuroSWSelTSPrioT_Layer6 = nullptr;        
    TH1F* m_neuroSWSelTSPrioT_Layer7 = nullptr;        
    TH1F* m_neuroSWSelTSPrioT_Layer8 = nullptr;        
    TH1F* m_neuroSWSelTSFoundT_Layer0 = nullptr;       
    TH1F* m_neuroSWSelTSFoundT_Layer1 = nullptr;       
    TH1F* m_neuroSWSelTSFoundT_Layer2 = nullptr;       
    TH1F* m_neuroSWSelTSFoundT_Layer3 = nullptr;       
    TH1F* m_neuroSWSelTSFoundT_Layer4 = nullptr;       
    TH1F* m_neuroSWSelTSFoundT_Layer5 = nullptr;       
    TH1F* m_neuroSWSelTSFoundT_Layer6 = nullptr;       
    TH1F* m_neuroSWSelTSFoundT_Layer7 = nullptr;       
    TH1F* m_neuroSWSelTSFoundT_Layer8 = nullptr;       
    TH1F* m_neuroSWSelTSPrioB_Layer0 = nullptr;        
    TH1F* m_neuroSWSelTSPrioB_Layer1 = nullptr;        
    TH1F* m_neuroSWSelTSPrioB_Layer2 = nullptr;        
    TH1F* m_neuroSWSelTSPrioB_Layer3 = nullptr;        
    TH1F* m_neuroSWSelTSPrioB_Layer4 = nullptr;        
    TH1F* m_neuroSWSelTSPrioB_Layer5 = nullptr;        
    TH1F* m_neuroSWSelTSPrioB_Layer6 = nullptr;        
    TH1F* m_neuroSWSelTSPrioB_Layer7 = nullptr;        
    TH1F* m_neuroSWSelTSPrioB_Layer8 = nullptr;        
    TH1F* m_neuroSWSelTSLR_Layer0 = nullptr;           
    TH1F* m_neuroSWSelTSLR_Layer1 = nullptr;           
    TH1F* m_neuroSWSelTSLR_Layer2 = nullptr;           
    TH1F* m_neuroSWSelTSLR_Layer3 = nullptr;           
    TH1F* m_neuroSWSelTSLR_Layer4 = nullptr;           
    TH1F* m_neuroSWSelTSLR_Layer5 = nullptr;           
    TH1F* m_neuroSWSelTSLR_Layer6 = nullptr;           
    TH1F* m_neuroSWSelTSLR_Layer7 = nullptr;           
    TH1F* m_neuroSWSelTSLR_Layer8 = nullptr;           
    // sw TS incoming
    TH1F* m_neuroSWTSSW2DInTSID = nullptr;             
    TH1F* m_neuroSWTSSW2DInTSCount = nullptr;          
    TH1F* m_neuroSWTSSW2DInTSPrioT_Layer0 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSPrioT_Layer1 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSPrioT_Layer2 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSPrioT_Layer3 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSPrioT_Layer4 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSPrioT_Layer5 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSPrioT_Layer6 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSPrioT_Layer7 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSPrioT_Layer8 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSFoundT_Layer0 = nullptr;  
    TH1F* m_neuroSWTSSW2DInTSFoundT_Layer1 = nullptr;  
    TH1F* m_neuroSWTSSW2DInTSFoundT_Layer2 = nullptr;  
    TH1F* m_neuroSWTSSW2DInTSFoundT_Layer3 = nullptr;  
    TH1F* m_neuroSWTSSW2DInTSFoundT_Layer4 = nullptr;  
    TH1F* m_neuroSWTSSW2DInTSFoundT_Layer5 = nullptr;  
    TH1F* m_neuroSWTSSW2DInTSFoundT_Layer6 = nullptr;  
    TH1F* m_neuroSWTSSW2DInTSFoundT_Layer7 = nullptr;  
    TH1F* m_neuroSWTSSW2DInTSFoundT_Layer8 = nullptr;  
    TH1F* m_neuroSWTSSW2DInTSPrioB_Layer0 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSPrioB_Layer1 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSPrioB_Layer2 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSPrioB_Layer3 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSPrioB_Layer4 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSPrioB_Layer5 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSPrioB_Layer6 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSPrioB_Layer7 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSPrioB_Layer8 = nullptr;   
    TH1F* m_neuroSWTSSW2DInTSLR_Layer0 = nullptr;      
    TH1F* m_neuroSWTSSW2DInTSLR_Layer1 = nullptr;      
    TH1F* m_neuroSWTSSW2DInTSLR_Layer2 = nullptr;      
    TH1F* m_neuroSWTSSW2DInTSLR_Layer3 = nullptr;      
    TH1F* m_neuroSWTSSW2DInTSLR_Layer4 = nullptr;      
    TH1F* m_neuroSWTSSW2DInTSLR_Layer5 = nullptr;      
    TH1F* m_neuroSWTSSW2DInTSLR_Layer6 = nullptr;      
    TH1F* m_neuroSWTSSW2DInTSLR_Layer7 = nullptr;      
    TH1F* m_neuroSWTSSW2DInTSLR_Layer8 = nullptr;      
    // sw TS selected
    TH1F* m_neuroSWTSSW2DSelTSID = nullptr;            
    TH1F* m_neuroSWTSSW2DSelTSCount = nullptr;         
    TH1F* m_neuroSWTSSW2DSelTSPrioT_Layer0 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSPrioT_Layer1 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSPrioT_Layer2 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSPrioT_Layer3 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSPrioT_Layer4 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSPrioT_Layer5 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSPrioT_Layer6 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSPrioT_Layer7 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSPrioT_Layer8 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSFoundT_Layer0 = nullptr; 
    TH1F* m_neuroSWTSSW2DSelTSFoundT_Layer1 = nullptr; 
    TH1F* m_neuroSWTSSW2DSelTSFoundT_Layer2 = nullptr; 
    TH1F* m_neuroSWTSSW2DSelTSFoundT_Layer3 = nullptr; 
    TH1F* m_neuroSWTSSW2DSelTSFoundT_Layer4 = nullptr; 
    TH1F* m_neuroSWTSSW2DSelTSFoundT_Layer5 = nullptr; 
    TH1F* m_neuroSWTSSW2DSelTSFoundT_Layer6 = nullptr; 
    TH1F* m_neuroSWTSSW2DSelTSFoundT_Layer7 = nullptr; 
    TH1F* m_neuroSWTSSW2DSelTSFoundT_Layer8 = nullptr; 
    TH1F* m_neuroSWTSSW2DSelTSPrioB_Layer0 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSPrioB_Layer1 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSPrioB_Layer2 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSPrioB_Layer3 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSPrioB_Layer4 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSPrioB_Layer5 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSPrioB_Layer6 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSPrioB_Layer7 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSPrioB_Layer8 = nullptr;  
    TH1F* m_neuroSWTSSW2DSelTSLR_Layer0 = nullptr;     
    TH1F* m_neuroSWTSSW2DSelTSLR_Layer1 = nullptr;     
    TH1F* m_neuroSWTSSW2DSelTSLR_Layer2 = nullptr;     
    TH1F* m_neuroSWTSSW2DSelTSLR_Layer3 = nullptr;     
    TH1F* m_neuroSWTSSW2DSelTSLR_Layer4 = nullptr;     
    TH1F* m_neuroSWTSSW2DSelTSLR_Layer5 = nullptr;     
    TH1F* m_neuroSWTSSW2DSelTSLR_Layer6 = nullptr;     
    TH1F* m_neuroSWTSSW2DSelTSLR_Layer7 = nullptr;     
    TH1F* m_neuroSWTSSW2DSelTSLR_Layer8 = nullptr;     
    // hw input vector
    TH1F* m_neuroHWInputID_Layer0 = nullptr;           
    TH1F* m_neuroHWInputT_Layer0 = nullptr;            
    TH1F* m_neuroHWInputAlpha_Layer0 = nullptr;        
    TH1F* m_neuroHWInputID_Layer1 = nullptr;           
    TH1F* m_neuroHWInputT_Layer1 = nullptr;            
    TH1F* m_neuroHWInputAlpha_Layer1 = nullptr;        
    TH1F* m_neuroHWInputID_Layer2 = nullptr;           
    TH1F* m_neuroHWInputT_Layer2 = nullptr;            
    TH1F* m_neuroHWInputAlpha_Layer2 = nullptr;        
    TH1F* m_neuroHWInputID_Layer3 = nullptr;           
    TH1F* m_neuroHWInputT_Layer3 = nullptr;            
    TH1F* m_neuroHWInputAlpha_Layer3 = nullptr;        
    TH1F* m_neuroHWInputID_Layer4 = nullptr;           
    TH1F* m_neuroHWInputT_Layer4 = nullptr;            
    TH1F* m_neuroHWInputAlpha_Layer4 = nullptr;        
    TH1F* m_neuroHWInputID_Layer5 = nullptr;           
    TH1F* m_neuroHWInputT_Layer5 = nullptr;            
    TH1F* m_neuroHWInputAlpha_Layer5 = nullptr;        
    TH1F* m_neuroHWInputID_Layer6 = nullptr;           
    TH1F* m_neuroHWInputT_Layer6 = nullptr;            
    TH1F* m_neuroHWInputAlpha_Layer6 = nullptr;        
    TH1F* m_neuroHWInputID_Layer7 = nullptr;           
    TH1F* m_neuroHWInputT_Layer7 = nullptr;            
    TH1F* m_neuroHWInputAlpha_Layer7 = nullptr;        
    TH1F* m_neuroHWInputID_Layer8 = nullptr;           
    TH1F* m_neuroHWInputT_Layer8 = nullptr;            
    TH1F* m_neuroHWInputAlpha_Layer8 = nullptr;        
    // sw input vector (hw TS hw 2D)
    TH1F* m_neuroSWInputID_Layer0 = nullptr;           
    TH1F* m_neuroSWInputT_Layer0 = nullptr;            
    TH1F* m_neuroSWInputAlpha_Layer0 = nullptr;        
    TH1F* m_neuroSWInputID_Layer1 = nullptr;           
    TH1F* m_neuroSWInputT_Layer1 = nullptr;            
    TH1F* m_neuroSWInputAlpha_Layer1 = nullptr;        
    TH1F* m_neuroSWInputID_Layer2 = nullptr;           
    TH1F* m_neuroSWInputT_Layer2 = nullptr;            
    TH1F* m_neuroSWInputAlpha_Layer2 = nullptr;        
    TH1F* m_neuroSWInputID_Layer3 = nullptr;           
    TH1F* m_neuroSWInputT_Layer3 = nullptr;            
    TH1F* m_neuroSWInputAlpha_Layer3 = nullptr;        
    TH1F* m_neuroSWInputID_Layer4 = nullptr;           
    TH1F* m_neuroSWInputT_Layer4 = nullptr;            
    TH1F* m_neuroSWInputAlpha_Layer4 = nullptr;        
    TH1F* m_neuroSWInputID_Layer5 = nullptr;           
    TH1F* m_neuroSWInputT_Layer5 = nullptr;            
    TH1F* m_neuroSWInputAlpha_Layer5 = nullptr;        
    TH1F* m_neuroSWInputID_Layer6 = nullptr;           
    TH1F* m_neuroSWInputT_Layer6 = nullptr;            
    TH1F* m_neuroSWInputAlpha_Layer6 = nullptr;        
    TH1F* m_neuroSWInputID_Layer7 = nullptr;           
    TH1F* m_neuroSWInputT_Layer7 = nullptr;            
    TH1F* m_neuroSWInputAlpha_Layer7 = nullptr;        
    TH1F* m_neuroSWInputID_Layer8 = nullptr;           
    TH1F* m_neuroSWInputT_Layer8 = nullptr;            
    TH1F* m_neuroSWInputAlpha_Layer8 = nullptr;        
    // sw input vector (sw TS sw 2D)
    TH1F* m_neuroSWTSSW2DInputID_Layer0 = nullptr;     
    TH1F* m_neuroSWTSSW2DInputT_Layer0 = nullptr;      
    TH1F* m_neuroSWTSSW2DInputAlpha_Layer0 = nullptr;  
    TH1F* m_neuroSWTSSW2DInputID_Layer1 = nullptr;     
    TH1F* m_neuroSWTSSW2DInputT_Layer1 = nullptr;      
    TH1F* m_neuroSWTSSW2DInputAlpha_Layer1 = nullptr;  
    TH1F* m_neuroSWTSSW2DInputID_Layer2 = nullptr;     
    TH1F* m_neuroSWTSSW2DInputT_Layer2 = nullptr;      
    TH1F* m_neuroSWTSSW2DInputAlpha_Layer2 = nullptr;  
    TH1F* m_neuroSWTSSW2DInputID_Layer3 = nullptr;     
    TH1F* m_neuroSWTSSW2DInputT_Layer3 = nullptr;      
    TH1F* m_neuroSWTSSW2DInputAlpha_Layer3 = nullptr;  
    TH1F* m_neuroSWTSSW2DInputID_Layer4 = nullptr;     
    TH1F* m_neuroSWTSSW2DInputT_Layer4 = nullptr;      
    TH1F* m_neuroSWTSSW2DInputAlpha_Layer4 = nullptr;  
    TH1F* m_neuroSWTSSW2DInputID_Layer5 = nullptr;     
    TH1F* m_neuroSWTSSW2DInputT_Layer5 = nullptr;      
    TH1F* m_neuroSWTSSW2DInputAlpha_Layer5 = nullptr;  
    TH1F* m_neuroSWTSSW2DInputID_Layer6 = nullptr;     
    TH1F* m_neuroSWTSSW2DInputT_Layer6 = nullptr;      
    TH1F* m_neuroSWTSSW2DInputAlpha_Layer6 = nullptr;  
    TH1F* m_neuroSWTSSW2DInputID_Layer7 = nullptr;     
    TH1F* m_neuroSWTSSW2DInputT_Layer7 = nullptr;      
    TH1F* m_neuroSWTSSW2DInputAlpha_Layer7 = nullptr;  
    TH1F* m_neuroSWTSSW2DInputID_Layer8 = nullptr;     
    TH1F* m_neuroSWTSSW2DInputT_Layer8 = nullptr;      
    TH1F* m_neuroSWTSSW2DInputAlpha_Layer8 = nullptr;  
    // reco
    TH1F* m_RecoZ = nullptr;                     
    TH1F* m_RecoCosTheta = nullptr;              
    TH1F* m_RecoInvPt = nullptr;                 
    TH1F* m_RecoPhi = nullptr;                   
    TH1F* m_RecoD0 = nullptr;                    
    TH1F* m_RecoTrackCount = nullptr;            
    // reco values for tracks matched to hw NN tracks
    TH1F* m_RecoHWZ = nullptr;                   
    TH1F* m_RecoHWCosTheta = nullptr;            
    TH1F* m_RecoHWInvPt = nullptr;               
    TH1F* m_RecoHWPhi = nullptr;                 
    TH1F* m_RecoHWD0 = nullptr;                  
    TH2F* m_RecoHWZScatter = nullptr;            
    // hw neuro values for tracks matched to reco tracks
    TH1F* m_neuroRecoHWOutZ = nullptr;           
    TH1F* m_neuroRecoHWOutCosTheta = nullptr;    
    TH1F* m_neuroRecoHWOutInvPt = nullptr;       
    TH1F* m_neuroRecoHWOutPhi0 = nullptr;        
    TH1F* m_neuroRecoHWOutHitPattern = nullptr;  
    TH1F* m_neuroRecoHWOutTrackCount = nullptr;  
    TH1F* m_neuroRecoHWSector = nullptr;         
    // hw accuracy
    TH1F* m_DeltaRecoHWZ = nullptr;              
    TH1F* m_DeltaRecoHWCosTheta = nullptr;       
    TH1F* m_DeltaRecoHWInvPt = nullptr;          
    TH1F* m_DeltaRecoHWPhi = nullptr;            
    // reco values for tracks matched to sw NN tracks (hw TS, hw 2D)
    TH1F* m_RecoSWZ = nullptr;                   
    TH1F* m_RecoSWCosTheta = nullptr;            
    TH1F* m_RecoSWInvPt = nullptr;               
    TH1F* m_RecoSWPhi = nullptr;                 
    TH1F* m_RecoSWD0 = nullptr;                  
    TH2F* m_RecoSWZScatter = nullptr;            
    // sw neuro values for tracks matched to reco tracks
    TH1F* m_neuroRecoSWOutZ = nullptr;           
    TH1F* m_neuroRecoSWOutCosTheta = nullptr;    
    TH1F* m_neuroRecoSWOutInvPt = nullptr;       
    TH1F* m_neuroRecoSWOutPhi0 = nullptr;        
    TH1F* m_neuroRecoSWOutHitPattern = nullptr;  
    TH1F* m_neuroRecoSWOutTrackCount = nullptr;  
    TH1F* m_neuroRecoSWSector = nullptr;         
    // sw accuracy (hw TS, hw 2D)
    TH1F* m_DeltaRecoSWZ = nullptr;              
    TH1F* m_DeltaRecoSWCosTheta = nullptr;       
    TH1F* m_DeltaRecoSWInvPt = nullptr;          
    TH1F* m_DeltaRecoSWPhi = nullptr;            
    // reco values for tracks matched to sw NN tracks (sw TS, sw 2D)
    TH1F* m_RecoSWTSSW2DZ = nullptr;             
    TH1F* m_RecoSWTSSW2DCosTheta = nullptr;      
    TH1F* m_RecoSWTSSW2DInvPt = nullptr;         
    TH1F* m_RecoSWTSSW2DPhi = nullptr;           
    TH1F* m_RecoSWTSSW2DD0 = nullptr;            
    TH2F* m_RecoSWTSSW2DZScatter = nullptr;      
    // sw neuro values for tracks matched to reco tracks (sw TS, sw 2D)
    TH1F* m_neuroRecoSWTSSW2DOutZ = nullptr;           
    TH1F* m_neuroRecoSWTSSW2DOutCosTheta = nullptr;    
    TH1F* m_neuroRecoSWTSSW2DOutInvPt = nullptr;       
    TH1F* m_neuroRecoSWTSSW2DOutPhi0 = nullptr;        
    TH1F* m_neuroRecoSWTSSW2DOutHitPattern =
      nullptr;  
    TH1F* m_neuroRecoSWTSSW2DOutTrackCount = nullptr;  
    TH1F* m_neuroRecoSWTSSW2DSector = nullptr;         
    // sw accuracy (sw TS, sw 2D)
    TH1F* m_DeltaRecoSWTSSW2DZ = nullptr;        
    TH1F* m_DeltaRecoSWTSSW2DCosTheta = nullptr; 
    TH1F* m_DeltaRecoSWTSSW2DInvPt = nullptr;    
    TH1F* m_DeltaRecoSWTSSW2DPhi = nullptr;      
  };
 
}