MdtVsTgcRawDataValAlg Class Reference

#include <MdtVsTgcRawDataValAlg.h>

Inheritance diagram for MdtVsTgcRawDataValAlg:

Collaboration diagram for MdtVsTgcRawDataValAlg:

Public Types
enum	Interval_t {   file = 0 , eventsBlock , lumiBlock , lowStat ,   medStat , higStat , run , fill ,   all }
	An enumeration describing how detailed a particular monitoring object is. More...
enum	MgmtAttr_t { ATTRIB_MANAGED = 0 , ATTRIB_UNMANAGED = 1 , ATTRIB_X_VS_LB = 2 }
	An enumeration describing how the class handles the histogram. More...

Public Member Functions
	MdtVsTgcRawDataValAlg (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~MdtVsTgcRawDataValAlg ()
StatusCode	initialize ()
virtual StatusCode	bookHistogramsRecurrent ()
	An inheriting class should either override this function, bookHists() or bookHistograms().
virtual StatusCode	fillHistograms (const EventContext &ctx)
	An inheriting class should either override this function or fillHists().
virtual StatusCode	procHistograms ()
	An inheriting class should either override this function or finalHists().
virtual StreamNameFcn *	streamNameFunction ()
	Returns the function object that converts logical paramters into a physical stream name.
virtual StatusCode	bookHists ()
	Calls bookHists( true, true, true ) and initializes lumiBlock and run numbers.
virtual StatusCode	fillHists (const EventContext &ctx)
	Calls fillHists( bool, bool, bool ); if an eventBlock,lumiBlock, or run has turned over, calls procHists( bool, bool, bool ) and bookHists( bool, bool, bool ).
virtual StatusCode	finalHists ()
	Calls procHists( true, true, true ).
virtual StatusCode	bookHistograms ()
	An inheriting class should either override this function or bookHists().
virtual void	setMonManager (AthenaMonManager *manager)
	Takes a pointer to a managing object to get information from it when needed.
virtual StatusCode	regHist (TH1 *h, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
	Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram.
virtual StatusCode	regHist (TH1 *h, const MonGroup &group)
	Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram.
virtual StatusCode	getHist (TH1 *&h, const std::string &hName, const std::string &system, Interval_t interval)
	Returns a TH1 via the pointer passed as the first argument.
virtual StatusCode	getHist (TH1 *&h, const std::string &hName, const MonGroup &group)
	Returns a TH1 via the pointer passed as the first argument.
virtual StatusCode	getHist (TH2 *&h, const std::string &hName, const std::string &system, Interval_t interval)
	Returns a TH2 via the pointer passed as the first argument.
virtual StatusCode	getHist (TH2 *&h, const std::string &hName, const MonGroup &group)
	Returns a TH2 via the pointer passed as the first argument.
virtual StatusCode	regEfficiency (TEfficiency *e, const MonGroup &group)
	Registers a TEfficiency to be included in the output stream using logical parameters that describe the plot.
virtual StatusCode	regGraph (TGraph *g, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
	Registers a TGraph to be included in the output stream using logical parameters that describe the graph.
virtual StatusCode	regGraph (TGraph *g, const MonGroup &group)
	Registers a TGraph to be included in the output stream using logical parameters that describe the graph.
virtual StatusCode	regTree (TTree *t, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
	Registers a TTree to be included in the output stream using logical parameters that describe it.
virtual StatusCode	regTree (TTree *t, const MonGroup &group)
	Registers a TTree to be included in the output stream using logical parameters that describe it.
virtual StatusCode	writeAndDelete (TH1 *h, const MonGroup &group)
	Write out histogram and delete it.
virtual StatusCode	deregHist (TH1 *h)
	De-registers a TH1 from the THistSvc, but does NOT delete the object.
virtual StatusCode	deregGraph (TGraph *g)
	De-registers a TGraph from the THistSvc, but does NOT delete the object.
virtual StatusCode	deregObject (const std::string &objName, const std::string &system, Interval_t interval)
	De-registers a TObject from the THistSvc, but does NOT delete the object.
virtual StatusCode	deregObject (const std::string &objName, const MonGroup &group)
	De-registers a TObject from the THistSvc, but does NOT delete the object.
virtual StatusCode	setupOutputStreams (std::vector< std::string > Mapping=std::vector< std::string >())
	This implementation does nothing—streams in this class should be managed by the AthenaMonManager.
virtual StatusCode	runStat ()
	This implementation does nothing; equivalent functionality may be provided by procHists( true, true, true ).
virtual StatusCode	checkHists (bool calledFromFinalize)
	This implementation does nothing; equivalent functionality may be provided by procHists(...) with appropriate arguments.
virtual bool	preSelector ()
virtual float	lbAverageInteractionsPerCrossing (const EventContext &ctx) const
	Average mu, i.e.
virtual float	lbInteractionsPerCrossing (const EventContext &ctx) const
	Instantaneous number of interactions, i.e.
virtual float	lbAverageLuminosity (const EventContext &ctx) const
	Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1).
virtual float	lbLuminosityPerBCID (const EventContext &ctx) const
	Instantaneous luminosity.
virtual double	lbDuration (const EventContext &ctx) const
	Luminosity block time (in seconds).
virtual float	lbAverageLivefraction (const EventContext &ctx) const
	Average luminosity livefraction.
virtual float	livefractionPerBCID (const EventContext &ctx) const
	Livefraction per bunch crossing ID.
virtual double	lbLumiWeight (const EventContext &ctx) const
	Average Integrated Luminosity Live Fraction.
	MMTB_DEPRECATED (newLowStatInterval)
	MMTB_DEPRECATED (newMedStatInterval)
	MMTB_DEPRECATED (newHigStatInterval)
	MMTB_DEPRECATED (newLowStat)
	MMTB_DEPRECATED (newLumiBlock)
	MMTB_DEPRECATED (newRun)
	MMTB_DEPRECATED (newEventsBlock)
	MMTB_DEPRECATED (endOfEventsBlock)
	MMTB_DEPRECATED (endOfLowStat)
	MMTB_DEPRECATED (endOfLumiBlock)
	MMTB_DEPRECATED (endOfRun)
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static std::string	intervalEnumToString (Interval_t interval)
	Converts a LevelOfDetail_t to a string of the same name.
static Interval_t	intervalStringToEnum (const std::string &str)
	Converts a string to the corresponding Interval_t.
static const InterfaceID &	interfaceID ()

Protected Types
typedef std::map< std::string, OutputMetadata * >	MDMap_t

Protected Member Functions
StatusCode	regManagedHistograms (std::vector< MgmtParams< TH1 > > &templateHistograms)
StatusCode	regManagedGraphs (std::vector< MgmtParams< TGraph > > &templateGraphs)
StatusCode	regManagedTrees (std::vector< MgmtParams< TTree > > &templateTrees)
StatusCode	regManagedEfficiencies (std::vector< MgmtParams< TEfficiency > > &templateEfficiencies)
StatusCode	parseList (const std::string &, std::vector< std::string > &)
void	updateTriggersForGroups (std::vector< std::string > &)
StatusCode	registerMetadata (const std::string &streamName, const std::string &hName, const MonGroup &group)
StatusCode	THistSvc_deReg_fixTGraph (TFile *file, TGraph *theGraph, std::string &directoryName)
	Fixes THistSvc->deReg(obj) when obj is TGraph instance.
unsigned int	get_nEvents () const
long	get_procNEventsProp () const
virtual bool	trigChainsArePassed (std::vector< std::string > &)
virtual StreamNameFcn *	getNewStreamNameFcn () const
bool	newLowStatIntervalFlag () const
	Flag functions allowing clients to determine when to book new and process old histograms; values are updated by fillHists() based on counting lumiBlocks, and are correctly set when fillHistograms(), bookHistograms() and procHistograms() are called.
bool	newMedStatIntervalFlag () const
bool	newHigStatIntervalFlag () const
bool	newLowStatFlag () const
bool	newLumiBlockFlag () const
bool	newRunFlag () const
bool	newEventsBlockFlag () const
bool	endOfEventsBlockFlag () const
bool	endOfLowStatFlag () const
bool	endOfLumiBlockFlag () const
bool	endOfRunFlag () const
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Protected Attributes
std::map< Interval_t, std::vector< MgmtParams< TH1 > > >	m_templateHistograms
std::map< Interval_t, std::vector< MgmtParams< TGraph > > >	m_templateGraphs
std::map< Interval_t, std::vector< MgmtParams< TTree > > >	m_templateTrees
std::map< Interval_t, std::vector< MgmtParams< TEfficiency > > >	m_templateEfficiencies
std::vector< std::string >	m_vTrigChainNames
std::vector< std::string >	m_vTrigGroupNames
MDMap_t	m_metadataMap
AthenaMonManager *	m_manager
std::string	m_managerNameProp
std::string	m_fileKey
std::string	m_dataTypeStr
std::string	m_environmentStr
unsigned int	m_detailLevel
AthenaMonManager::DataType_t	m_dataType
AthenaMonManager::Environment_t	m_environment
StreamNameFcn *	m_streamNameFcn
ServiceHandle< ITHistSvc >	m_THistSvc
PublicToolHandle< Trig::ITrigDecisionTool >	m_trigDecTool {this, "TrigDecisionTool",""}
PublicToolHandle< ITriggerTranslatorTool >	m_trigTranslator {this,"TriggerTranslatorTool",""}
ToolHandleArray< IDQFilterTool >	m_DQFilterTools {this,"FilterTools",{}}
long	m_procNEventsProp
std::string	m_path
long	m_preScaleProp
std::string	m_triggerChainProp
std::string	m_triggerGroupProp
bool	m_useTrigger
unsigned int	m_lastLumiBlock
unsigned int	m_lastRun
int	m_lastLowStatInterval
int	m_lastMedStatInterval
int	m_lastHigStatInterval
unsigned int	m_nEvents
unsigned int	m_nEventsIgnoreTrigger
unsigned int	m_nLumiBlocks
bool	m_haveClearedLastEventBlock

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	correlation (const Muon::MdtPrepDataContainer *mdt_hit_container, const Muon::TgcCoinDataContainer *tgc_trigger_container)
int	numberOfSL (const Muon::TgcCoinDataContainer *tgctrgcontainer)
void	roi2etaphi (const Muon::TgcCoinData &cd, int &eta, int &phi)
int	phi2sector (int phi, int ef)
int	roiphi2mdtSector (int roiphi, int ef)
int	roitotalphi2sectorphi (int phi)
int	stationGasGap2layer (int station, int GasGap)
void	prepareTREarray (const MuonGM::MuonDetectorManager *MuonDetMgrDS)
int	TGCgetlayer (int stationName, int g)
int	TGClayer2stationindex (int l)
int	TGCstationname2stationindex (int stationName)
StatusCode	bookmaphists (MonGroup &mdtvstgclv1_expert_a, MonGroup &mdtvstgclv1_expert_c)
void	maphists (const xAOD::MuonSegmentContainer *m_newsegment, const Muon::TgcPrepDataContainer *tgc_prepcontainer)
void	maphistsfinalize ()
StatusCode	bookeffhists (MonGroup &mdtvstgclv1_expert_a, MonGroup &mdtvstgclv1_expert_c)
void	tgceffcalc (const xAOD::MuonSegmentContainer *m_newsegment, const Muon::TgcPrepDataContainer *tgc_prepcontainer)
void	SortMDTSegments (const xAOD::MuonSegmentContainer *m_newsegment, std::vector< const Muon::MuonSegment * >(&sortedSegments)[2][4])
void	DQCheckMDTSegments (std::vector< const Muon::MuonSegment * >(&sortedSegments)[2][4], std::vector< const Muon::MuonSegment * >(&disqualifiedSegments)[2][4])
void	MatchMDTSegments (std::vector< const Muon::MuonSegment * >(&sortedSegments)[2][4], std::vector< const Muon::MuonSegment * >(&disqualifiedSegments)[2][4], std::vector< SegmTrack >(&matchedSegments)[2])
void	CheckTGConTrack (std::vector< SegmTrack >(&matchedSegments)[2], const Muon::TgcPrepDataContainer *tgc_prepcontainer)
void	MidstationOnlyCheck (std::vector< const Muon::MuonSegment * >(&sortedSegments)[2][4], std::vector< const Muon::MuonSegment * >(&disqualifiedSegments)[2][4], const Muon::TgcPrepDataContainer *tgc_prepcontainer)
void	tgceffcalcfinalize ()
int	getStationMapIndex (int x, int l, int stationFE, int stationEta, int stationPhi)
void	labelStationMap (TH2 *h2, int i=-1, int k=-1)
void	putBox (TH2 *h2, float x1, float y1, float x2, float y2)
void	BlankPhi24 (TH2 *h2, int binx)
void	BlankStationMap (TH2 *h2, int ws)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
MuonDQAHistMap	m_stationHists
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_DetectorManagerKey
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
bool	m_checkCabling
bool	m_tgclv1file
std::string	m_chamberName
std::string	m_StationSize
int	m_sector
int	m_side
int	m_lastEvent
int	m_cosmicStation
SG::ReadHandleKey< Muon::TgcPrepDataContainer >	m_tgc_PrepDataContainerName {this,"TgcPrepDataContainer","TGC_Measurements","TGC PRDs"}
SG::ReadHandleKey< Muon::TgcCoinDataContainer >	m_tgc_CoinContainerName {this,"OutputCoinCollection","TrigT1CoinDataCollection","TGC coincidences"}
SG::ReadHandleKey< Muon::MdtPrepDataContainer >	m_mdt_PrepDataContainerName {this,"MdtPrepDataContainer","MDT_DriftCircles","MDT PRDs"}
SG::ReadHandleKey< xAOD::MuonSegmentContainer >	m_mdt_SegmentCollectionName {this,"MdtSegmentCollection","MuonSegments","muon segments"}
int	m_MdtAdcCut
int	m_MdtTdcCut
const MuonGM::TgcReadoutElement *	m_TREarray [8][2][9][49] {}
TH1 *	m_mvt_cutspassed [2] {}
TH2 *	m_mdt_segmmap [2][4] {}
TH2 *	m_eff_stationmapbase [2][2][4] {}
TH2 *	m_eff_stationmapmid [2][2][4] {}
TH2 *	m_eff_stationmap [2][2][4] {}
TH1 *	m_mvt_extrprdsag [2][4][2][2][4] {}
TH1 *	m_mvt_extrprdsag2 [2][4][2][2][4] {}
TH1 *	m_tgc_prdcompsag [2][2][4] {}
TH1 *	m_mdt_segmmatchsag [2][4][4][4] {}
TH1 *	m_mdt_segmposdirsag [2][4][4] {}
TH1 *	m_mdt_trackdirdirsag [2][4][4][4] {}
TH1 *	m_mdt_trackchecksag [2][4][4][4][2] {}
bool	m_newLowStatInterval
bool	m_newMedStatInterval
bool	m_newHigStatInterval
bool	m_newLowStat
bool	m_newLumiBlock
bool	m_newRun
bool	m_newEventsBlock
bool	m_endOfEventsBlock
bool	m_endOfLowStat
bool	m_endOfLumiBlock
bool	m_endOfRun
SG::ReadCondHandleKey< LuminosityCondData >	m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
SG::ReadCondHandleKey< LBDurationCondData >	m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
SG::ReadCondHandleKey< TrigLiveFractionCondData >	m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData","SG Key of TrigLiveFractionCondData object"}
bool	m_bookHistogramsInitial
bool	m_useLumi
float	m_defaultLBDuration
std::set< Interval_t >	m_supportedIntervalsForRebooking
Imp *	m_d
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 38 of file MdtVsTgcRawDataValAlg.h.

Member Typedef Documentation

MDMap_t

typedef std::map<std::string,OutputMetadata*> ManagedMonitorToolBase::MDMap_t

protectedinherited

Definition at line 827 of file ManagedMonitorToolBase.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

Interval_t

enum ManagedMonitorToolBase::Interval_t

inherited

An enumeration describing how detailed a particular monitoring object is.

summary: used to summarize the state of the system

runstat: same as summary

shift: used to flag potential problems

expert: essential for diagnosing problems identified by shift-level objects

debug: useful for standalone debugging, but not for routine monitoring; not essential for diagnosing problems during normal running

transient: too detailed to ever be written; always summarized by the user by means of another object An enumeration describing the interval over which a particular monitoring object is filled (i.e., interval over which the method Fill(...) is called). This information may be stored with the monitoring object if an application is only able to partially fill the object (i.e., a job sees only part of a run or fill). This information may be ignored in some running Environments. The 'fill' interval corresponds to a fill of the LHC. The 'all' interval corresponds to all available data. The 'lumiBlock' and 'fill' intervals are only valid for the 'collisions' DataType_t.

Enumerator
file
eventsBlock
lumiBlock
lowStat
medStat
higStat
run
fill
all

Definition at line 114 of file ManagedMonitorToolBase.h.

                      { file = 0, eventsBlock, lumiBlock,
         lowStat, medStat, higStat,
         run, fill, all };

MgmtAttr_t

enum ManagedMonitorToolBase::MgmtAttr_t

inherited

An enumeration describing how the class handles the histogram.

attrib_unmanaged: histograms with this attribute will not be rebooked automatically and must be managed by the user code.

attrib_x_is_lb: indicates that the x-axis of the histogram is the luminosity block number and that the histogram should be rebooked as necessary if the current LB exceeds the range.

Enumerator
ATTRIB_MANAGED
ATTRIB_UNMANAGED
ATTRIB_X_VS_LB

Definition at line 131 of file ManagedMonitorToolBase.h.

{ ATTRIB_MANAGED = 0, ATTRIB_UNMANAGED = 1, ATTRIB_X_VS_LB = 2};

Constructor & Destructor Documentation

MdtVsTgcRawDataValAlg()

MdtVsTgcRawDataValAlg::MdtVsTgcRawDataValAlg	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 33 of file MdtVsTgcRawDataValAlg.cxx.

  :ManagedMonitorToolBase( type, name, parent )
{
  // Declare the properties 
  declareProperty("CheckCabling",     m_checkCabling=false);
  declareProperty("TgcLv1File",       m_tgclv1file=true);    
  declareProperty("ChamberName",      m_chamberName="XXX");
  declareProperty("StationSize",      m_StationSize="XXX");
  declareProperty("Sector",           m_sector=0); 
  declareProperty("Side",             m_side=0); 
  declareProperty("LastEvent",        m_lastEvent=0);
  declareProperty("CosmicStation",    m_cosmicStation=0);
  declareProperty("MdtAdcCut",        m_MdtAdcCut=50);
  declareProperty("MdtTdcCut",        m_MdtTdcCut=1600);
  
  // initialize class members
   
  for(int ac=0; ac<2; ac++){
    m_mvt_cutspassed[ac] = nullptr;
    for(int jMDT=0; jMDT<4; jMDT++){
        m_mdt_segmmap[ac][jMDT] = nullptr;
        for(int sMDT=0; sMDT<4; sMDT++){
            m_mdt_segmposdirsag[ac][jMDT][sMDT] = nullptr;
            for(int iREPT=0; iREPT<4; iREPT++){
                m_mdt_segmmatchsag[ac][jMDT][sMDT][iREPT] = nullptr;
                m_mdt_trackdirdirsag[ac][jMDT][sMDT][iREPT] = nullptr;
                m_mdt_trackchecksag[ac][jMDT][sMDT][iREPT][0] = nullptr;
                m_mdt_trackchecksag[ac][jMDT][sMDT][iREPT][1] = nullptr;
            }
        }
    }
    for(int WS=0; WS<2; WS++){
        for(int EffNDE=0; EffNDE<4; EffNDE++){
            m_eff_stationmapbase[ac][WS][EffNDE] = nullptr;
            m_eff_stationmapmid[ac][WS][EffNDE] = nullptr;
            m_eff_stationmap[ac][WS][EffNDE] = nullptr;
        }
    }
  }
 
  // Initialize to zero
  for(int i=0;i<2;i++)// AC
    for(int jTGC=0;jTGC<4;jTGC++)// TGC Station
      for(int f=0;f<2;f++)// FE
        for(int k=0;k<2;k++)// WireStrip
          for(int x=0;x<4;x++){
            m_mvt_extrprdsag[i][jTGC][f][k][x]=nullptr;
            m_mvt_extrprdsag2[i][jTGC][f][k][x]=nullptr;
          }
  for(int k=0;k<2;k++)
    for(int i=0;i<2;i++)
      for(int x=0;x<4;x++){
        m_tgc_prdcompsag[i][k][x]=nullptr;
      }
 
}

~MdtVsTgcRawDataValAlg()

MdtVsTgcRawDataValAlg::~MdtVsTgcRawDataValAlg ( )

virtual

Definition at line 90 of file MdtVsTgcRawDataValAlg.cxx.

                                             {
  ATH_MSG_INFO( " deleting MdtVsTgcRawDataValAlg "  );
}

Member Function Documentation

BlankPhi24()

void MdtVsTgcRawDataValAlg::BlankPhi24 ( TH2 * h2, int binx )

private

Definition at line 144 of file MdtVsTgcRawData_functions.cxx.

                                                 {
  float x1=h->GetXaxis()->GetBinLowEdge(binx);
  float x2=h->GetXaxis()->GetBinUpEdge(binx);
  for(int i=0;i<24;i++){
    int biny = (i+1)*2;
    float y1=h->GetYaxis()->GetBinLowEdge(biny);
    float y2=h->GetYaxis()->GetBinUpEdge(biny);
    putBox(h, x1, y1, x2, y2);
  }
}

BlankStationMap()

void MdtVsTgcRawDataValAlg::BlankStationMap ( TH2 * h2, int ws )

private

Definition at line 155 of file MdtVsTgcRawData_functions.cxx.

                                                    {
  bool rebin=true;
  if(rebin){//use new bin
      for(int i=33; i<44;i++)BlankPhi24(h,i);
      int x1=h->GetXaxis()->GetBinLowEdge(40);
      int x2=h->GetXaxis()->GetBinUpEdge(40);
      int x3=h->GetXaxis()->GetBinLowEdge(41);
      int x4=h->GetXaxis()->GetBinUpEdge(41);
      int y1=h->GetYaxis()->GetBinLowEdge(19);
      int y2=h->GetYaxis()->GetBinUpEdge(19);
      putBox(h, x1, y1, x2, y2);
      putBox(h, x3, y1, x4, y2);
      y1=h->GetYaxis()->GetBinLowEdge(35);
      y2=h->GetYaxis()->GetBinUpEdge(35);
      putBox(h, x1, y1, x2, y2);
      putBox(h, x3, y1, x4, y2);
      y1=h->GetYaxis()->GetBinLowEdge(43);
      y2=h->GetYaxis()->GetBinUpEdge(43);
      putBox(h, x1, y1, x2, y2);
      putBox(h, x3, y1, x4, y2);
      
      if(ws==1){//Strip
        x1=h->GetXaxis()->GetBinLowEdge(2);
        y1=h->GetYaxis()->GetBinLowEdge(1);             
        x2=h->GetXaxis()->GetBinUpEdge(2);              
        y2=h->GetYaxis()->GetBinUpEdge(48);                 
        putBox(h, x1, y1, x2, y2);                          
        x1=h->GetXaxis()->GetBinLowEdge(9);         
        x2=h->GetXaxis()->GetBinUpEdge(9);          
        putBox(h, x1, y1, x2, y2);                      
        x1=h->GetXaxis()->GetBinLowEdge(16);
        x2=h->GetXaxis()->GetBinUpEdge(16);
        putBox(h, x1, y1, x2, y2);
        x1=h->GetXaxis()->GetBinLowEdge(23);
        x2=h->GetXaxis()->GetBinUpEdge(23);             
        putBox(h, x1, y1, x2, y2);                      
        x1=h->GetXaxis()->GetBinLowEdge(34);
        x2=h->GetXaxis()->GetBinUpEdge(34);
        putBox(h, x1, y1, x2, y2);
      }
  }else{//use old bin, logically dead code, comment out
//    BlankPhi24(h, 5);
//    BlankPhi24(h, 10);
//    BlankPhi24(h, 15);
//    BlankPhi24(h, 21);
//    BlankPhi24(h, 27);
//    BlankPhi24(h, 33);
//    BlankPhi24(h, 39);
//    BlankPhi24(h, 40);
//    BlankPhi24(h, 41);
//    BlankPhi24(h, 42);
//    BlankPhi24(h, 43);
//    int x1=h->GetXaxis()->GetBinLowEdge(40);
//    int x2=h->GetXaxis()->GetBinUpEdge(40);
//    int x3=h->GetXaxis()->GetBinLowEdge(42);
//    int x4=h->GetXaxis()->GetBinUpEdge(42);
//    int y1=h->GetYaxis()->GetBinLowEdge(19);
//    int y2=h->GetYaxis()->GetBinUpEdge(19);
//    putBox(h, x1, y1, x2, y2);
//    putBox(h, x3, y1, x4, y2);
//    y1=h->GetYaxis()->GetBinLowEdge(35);
//    y2=h->GetYaxis()->GetBinUpEdge(35);
//    putBox(h, x1, y1, x2, y2);
//    putBox(h, x3, y1, x4, y2);
//    y1=h->GetYaxis()->GetBinLowEdge(43);
//    y2=h->GetYaxis()->GetBinUpEdge(43);
//    putBox(h, x1, y1, x2, y2);
//    putBox(h, x3, y1, x4, y2);
  }
}

bookeffhists()

StatusCode MdtVsTgcRawDataValAlg::bookeffhists ( MonGroup & mdtvstgclv1_expert_a, MonGroup & mdtvstgclv1_expert_c )

private

Definition at line 100 of file MdtVsTgcRawData_bookhistograms.cxx.

                                                                   {
  
  std::stringstream sst;
  std::string AC[2]=          {"A","C"};
  std::string RhoEtaPhiThe[4]={"Rho","Eta","Phi","Theta"};
  std::string RhoEtaPhiZ[4]=  {"Rho","Eta","Phi","Z"};
  std::string FE[2]=          {"F","E"};// Forward, Endcap
  std::string EffNumDenom[4]= {"","num","denom","error"};
  std::string WireStrip[2]=   {"Wire","Strip"};
  int   nbins3D_1[4]=         { 0, 0, 0, 0};
  float fGlobalCoords3Dlo[4]= { 0, 0, 0, 0};
  float fGlobalCoords3Dup[4]= { 0, 0, 0, 0};
  // **************************************************************
  // ** EffCheck
  // **************************************************************
  // Efficiencies
  nbins3D_1[0]=              100; nbins3D_1[1]=                8; nbins3D_1[2]=               48; nbins3D_1[3]=              100;
  fGlobalCoords3Dlo[0]=    -1000; fGlobalCoords3Dlo[1]=       -1; fGlobalCoords3Dlo[2]=    -M_PI; fGlobalCoords3Dlo[3]=        0;
  fGlobalCoords3Dup[0]=     1000; fGlobalCoords3Dup[1]=        1; fGlobalCoords3Dup[2]=     M_PI; fGlobalCoords3Dup[3]= 0.5*M_PI;
  for(int i=0;i<2;i++){// AC
    for(int k=0;k<2;k++){// WireStrip
      for(int e=0;e<4;e++){// EffNumDenom
        // Station Efficiency Map Segm Track
        sst<<WireStrip[k];
        sst<<"_EfficiencyAgainstMDT";
        sst<<"_MapSegmTrack"<<EffNumDenom[e];
        sst<<"_"<<AC[i];
        ATH_MSG_DEBUG("Eff_StationMapBase "<<i<<" "<<k<<" "<<e<<sst.str().c_str() );
        m_eff_stationmapbase[i][k][e]=new TH2F( sst.str().c_str(), sst.str().c_str(),43, 0, 43, 48, 0, 48 );
        if(i==0){
          ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_eff_stationmapbase[i][k][e]) );
        }else{
          ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_eff_stationmapbase[i][k][e]) );
        }
 
        labelStationMap(m_eff_stationmapbase[i][k][e], i,k);
        sst.str("");
        
        // Station Efficiency Map Midstation Segments
        sst<<WireStrip[k];
        sst<<"_EfficiencyAgainstMDT";
        sst<<"_MapMidOnly"<<EffNumDenom[e];
        sst<<"_"<<AC[i];
        ATH_MSG_DEBUG("Eff_StationMapMid "<<i<<" "<<k<<" "<<e<<sst.str().c_str() );
        m_eff_stationmapmid[i][k][e]=new TH2F( sst.str().c_str(), sst.str().c_str(),43, 0, 43, 48, 0, 48 );
        if(i==0){
          ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_eff_stationmapmid[i][k][e]) );
        }else{
          ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_eff_stationmapmid[i][k][e]) );
        }
 
        labelStationMap(m_eff_stationmapmid[i][k][e], i,k);
        sst.str("");
        
        // Station Efficiency Map Total
        sst<<WireStrip[k];
        sst<<"_EfficiencyAgainstMDT";
        sst<<"_Map"<<EffNumDenom[e];
        sst<<"_"<<AC[i];
        ATH_MSG_DEBUG("Eff_StationMap "<<i<<" "<<k<<" "<<e<<sst.str().c_str() );
        m_eff_stationmap[i][k][e]=new TH2F( sst.str().c_str(), sst.str().c_str(),43, 0, 43, 48, 0, 48 );
        if(i==0){
          ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_eff_stationmap[i][k][e]) );
        }else{
          ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_eff_stationmap[i][k][e]) );
        }
 
        labelStationMap(m_eff_stationmap[i][k][e], i,k);
        sst.str("");
      }// EffNumDenom
    }// WireStrip
  }// AC
  
  // Sagittas
  
  
  nbins3D_1[0]=             8000; nbins3D_1[1]=              200; nbins3D_1[2]=             4096; nbins3D_1[3]=            40000;
  fGlobalCoords3Dlo[0]=    -8000; fGlobalCoords3Dlo[1]=       -1; fGlobalCoords3Dlo[2]=    -M_PI; fGlobalCoords3Dlo[3]=  -200000;
  fGlobalCoords3Dup[0]=     8000; fGlobalCoords3Dup[1]=        1; fGlobalCoords3Dup[2]=     M_PI; fGlobalCoords3Dup[3]=   200000;
  for(int i=0;i<2;i++){// AC
    for(int jTGC=0;jTGC<4;jTGC++){// TGC Station
      for(int f=0;f<2;f++){// FE
        for(int k=0;k<2;k++){// WireStrip
          for(int x=0;x<4;x++){// RhoEtaPhi
            if(x==0||x==2){ // Only interested in Rho and Phi
              // TGC EIFI vs MDT extrapolated position, Sagitta
              sst<<"TGC_SegmTrack_"<<RhoEtaPhiZ[x];
              sst<<"Sagitta_T"<<jTGC+1;
              sst<<FE[f];
              sst<<WireStrip[k];
              sst<<"_"<<AC[i];
              ATH_MSG_DEBUG("TGC_Sagitta "<<i<<" "<<jTGC<<" "<<f<<" "<<k<<" "<<x<<" "<<sst.str().c_str() );
              m_mvt_extrprdsag[i][jTGC][f][k][x] =new TH1F(sst.str().c_str(), sst.str().c_str(), nbins3D_1[x],fGlobalCoords3Dlo[x],fGlobalCoords3Dup[x]);
              if(i==0){
                ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_mvt_extrprdsag[i][jTGC][f][k][x]) );
              }else{
                ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_mvt_extrprdsag[i][jTGC][f][k][x]) );
              }
 
              m_mvt_extrprdsag[i][jTGC][f][k][x]->GetXaxis()->SetTitle(RhoEtaPhiZ[x].c_str());
              sst.str("");
            
              // TGC EIFI vs MDT extrapolated position, Sagitta
              sst<<"TGC_MidSegm_"<<RhoEtaPhiZ[x];
              sst<<"Sagitta_T"<<jTGC+1;
              sst<<FE[f];
              sst<<WireStrip[k];
              sst<<"_"<<AC[i];
              ATH_MSG_DEBUG("TGC_Sagitta "<<i<<" "<<jTGC<<" "<<f<<" "<<k<<" "<<x<<" "<<sst.str().c_str() );
              m_mvt_extrprdsag2[i][jTGC][f][k][x] =new TH1F(sst.str().c_str(), sst.str().c_str(), nbins3D_1[x],fGlobalCoords3Dlo[x],fGlobalCoords3Dup[x]);
              if(i==0){
                ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_mvt_extrprdsag2[i][jTGC][f][k][x]) );
              }else{
                ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_mvt_extrprdsag2[i][jTGC][f][k][x]) );
              }
 
              m_mvt_extrprdsag2[i][jTGC][f][k][x]->GetXaxis()->SetTitle(RhoEtaPhiZ[x].c_str());
              sst.str("");
            }
          }// RhoEtaPhi
        }// WireStrip
      }// FE
    }// TGC Station
  }// AC
  
  
  for(int k=0;k<2;k++){// WireStrip
    if(k==0){
      nbins3D_1[0]=            10000; nbins3D_1[1]=             1200; nbins3D_1[2]=             8192; nbins3D_1[3]=            40000;
      fGlobalCoords3Dlo[0]=    -1000; fGlobalCoords3Dlo[1]=       -3; fGlobalCoords3Dlo[2]=-1*M_PI/8; fGlobalCoords3Dlo[3]=  -200000;
      fGlobalCoords3Dup[0]=     1000; fGlobalCoords3Dup[1]=        3; fGlobalCoords3Dup[2]=   M_PI/8; fGlobalCoords3Dup[3]=   200000;
    }
    else{
      nbins3D_1[0]=            10000; nbins3D_1[1]=             1200; nbins3D_1[2]=             8192; nbins3D_1[3]=            40000;
      fGlobalCoords3Dlo[0]=    -5000; fGlobalCoords3Dlo[1]=       -3; fGlobalCoords3Dlo[2]=-1*M_PI/8; fGlobalCoords3Dlo[3]=  -200000;
      fGlobalCoords3Dup[0]=     5000; fGlobalCoords3Dup[1]=        3; fGlobalCoords3Dup[2]=   M_PI/8; fGlobalCoords3Dup[3]=   200000;
    }
    for(int i=0;i<2;i++){// AC
      for(int x=0;x<4;x++){// RhoEtaPhiZ
        if(x==0||x==2){ // Only interested in Rho and Phi
          // TGC PRD comparison for Mid Only Check
          sst<<"TGC_MidStationPRD_"<<RhoEtaPhiZ[x];
          sst<<"Sagitta_"<<WireStrip[k];
          sst<<"_"<<AC[i];
          ATH_MSG_DEBUG("TGC_PRDonly_Sagitta "<<i<<" "<<" "<<k<<" "<<x<<" "<<sst.str().c_str() );
          m_tgc_prdcompsag[i][k][x] =new TH1F(sst.str().c_str(), sst.str().c_str(), nbins3D_1[x],fGlobalCoords3Dlo[x],fGlobalCoords3Dup[x]);
          if(i==0){
            ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_tgc_prdcompsag[i][k][x]) );
          }else{
            ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_tgc_prdcompsag[i][k][x]) );
          }
 
          m_tgc_prdcompsag[i][k][x]->GetXaxis()->SetTitle(RhoEtaPhiZ[x].c_str());
          sst.str("");
        }
      }// WireStrip
    }// RhoEtaPhiThe
  }// AC
  
  
  // Segment Positions
  
  // Initialize to zero
  for(int i=0;i<2;i++)// AC
    for(int jMDT1=0;jMDT1<4;jMDT1++)// MDT Station1
      for(int jMDT2=0;jMDT2<4;jMDT2++)// MDT Station2
        for(int x=0;x<4;x++){
          m_mdt_segmmatchsag[i][jMDT1][jMDT2][x]=nullptr;
        }
  
  nbins3D_1[0]=             2000; nbins3D_1[1]=              200; nbins3D_1[2]=             4096; nbins3D_1[3]=             1024;
  fGlobalCoords3Dlo[0]=    -1000; fGlobalCoords3Dlo[1]=       -1; fGlobalCoords3Dlo[2]=  -M_PI/8; fGlobalCoords3Dlo[3]=        0;
  fGlobalCoords3Dup[0]=     1000; fGlobalCoords3Dup[1]=        1; fGlobalCoords3Dup[2]=   M_PI/8; fGlobalCoords3Dup[3]= 0.5*M_PI;
  for(int i=0;i<2;i++){// AC
    for(int jMDT1=0;jMDT1<4;jMDT1++){// MDT Station1
      for(int jMDT2=0;jMDT2<4;jMDT2++){// MDT Station2
        //if(jMDT1==jMDT2)continue;
        for(int x=0;x<4;x++){// RhoEtaPhiThe
          if(x==0||x==2||x==3){// Not interested in Eta
            // Segm Matching Sag
            sst<<"MDT_Matching_"<<RhoEtaPhiThe[x];
            sst<<"Sagitta_MDT"<<jMDT1+1;
            sst<<"vsMDT"<<jMDT2+1;
            sst<<"_"<<AC[i];
            ATH_MSG_DEBUG("MDT_MatchingSagitta "<<i<<" "<<jMDT1<<" "<<jMDT2<<" "<<x<<" "<<sst.str().c_str() );
            m_mdt_segmmatchsag[i][jMDT1][jMDT2][x] =new TH1F(sst.str().c_str(),sst.str().c_str(),  nbins3D_1[x], fGlobalCoords3Dlo[x], fGlobalCoords3Dup[x]);
            if(i==0){
              ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_mdt_segmmatchsag[i][jMDT1][jMDT2][x]) );
            }else{
              ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_mdt_segmmatchsag[i][jMDT1][jMDT2][x]) );
            }
 
            m_mdt_segmmatchsag[i][jMDT1][jMDT2][x]->GetXaxis()->SetTitle(RhoEtaPhiThe[x].c_str());
            sst.str("");
          }
        }
      }
    }
  }
  
  
  // Segment Directions
  
  for(int i=0;i<2;i++)// AC
    for(int jMDT1=0;jMDT1<4;jMDT1++){// MDT Station2
      for(int x=0;x<4;x++){// RhoEtaPhiThe
        m_mdt_segmposdirsag[i][jMDT1][x]=nullptr;
      }
      for(int jMDT2=0;jMDT2<4;jMDT2++){
        for(int x=0;x<4;x++){
          m_mdt_trackdirdirsag[i][jMDT1][jMDT2][x]=nullptr;
          for(int v=0;v<2;v++){
            m_mdt_trackchecksag[i][jMDT1][jMDT2][x][v]=nullptr;
          }
        }
      }
    }
  
  nbins3D_1[0]=             2000; nbins3D_1[1]=              200; nbins3D_1[2]=             8192; nbins3D_1[3]=             2048;
  fGlobalCoords3Dlo[0]=    -1000; fGlobalCoords3Dlo[1]=       -1; fGlobalCoords3Dlo[2]=  -2*M_PI; fGlobalCoords3Dlo[3]=-0.5*M_PI;
  fGlobalCoords3Dup[0]=     1000; fGlobalCoords3Dup[1]=        1; fGlobalCoords3Dup[2]=   2*M_PI; fGlobalCoords3Dup[3]= 0.5*M_PI;
  for(int i=0;i<2;i++){// AC
    for(int jMDT1=0;jMDT1<4;jMDT1++){// MDT Station2
      for(int x=0;x<4;x++){// RhoEtaPhiThe
        if(x==2||x==3){ // Only interested in Phi & Theta
          // Segm Pos-Dir Sag
          sst<<"MDT_PosDir_"<<RhoEtaPhiThe[x];
          sst<<"Sagitta_MDT"<<jMDT1+1;
          sst<<"_"<<AC[i];
          ATH_MSG_DEBUG("MDT_PosDirSagitta "<<i<<" "<<jMDT1<<" "<<x<<" "<<sst.str().c_str() );
          m_mdt_segmposdirsag[i][jMDT1][x] =new TH1F(sst.str().c_str(),sst.str().c_str(), nbins3D_1[x], fGlobalCoords3Dlo[x], fGlobalCoords3Dup[x]);
          if(i==0){
            ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_mdt_segmposdirsag[i][jMDT1][x]) );
          }else{
            ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_mdt_segmposdirsag[i][jMDT1][x]) );
          }
          m_mdt_segmposdirsag[i][jMDT1][x]->GetXaxis()->SetTitle(RhoEtaPhiThe[x].c_str());
          sst.str("");
        }
      }// RhoEtaPhiThe
 
      for(int jMDT2=0;jMDT2<4;jMDT2++){// MDT Station2
        //if(jMDT1==jMDT2)continue;// Cut same station comparison
        for(int x=0;x<4;x++){// RhoEtaPhiThe
          if(x==2||x==3){ // Only interested in Phi & Theta
            // Track Dir-Dir Sag
            sst<<"MDT_DirDir_"<<RhoEtaPhiThe[x];
            sst<<"Sagitta_MDT"<<jMDT1+1;
            sst<<"vsMDT"<<jMDT2+1;
            sst<<"_"<<AC[i];
            ATH_MSG_DEBUG("MDT_DirDirSagitta "<<i<<" "<<jMDT1<<" "<<jMDT2<<" "<<x<<" "<<sst.str().c_str() );
            m_mdt_trackdirdirsag[i][jMDT1][jMDT2][x] =new TH1F(sst.str().c_str(),sst.str().c_str(),  nbins3D_1[x], fGlobalCoords3Dlo[x], fGlobalCoords3Dup[x]);
            if(i==0){
              ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_mdt_trackdirdirsag[i][jMDT1][jMDT2][x]) );
            }else{
              ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_mdt_trackdirdirsag[i][jMDT1][jMDT2][x]) );
            }
 
            m_mdt_trackdirdirsag[i][jMDT1][jMDT2][x]->GetXaxis()->SetTitle(RhoEtaPhiThe[x].c_str());
            sst.str("");
              
            for(int v=0;v<2;v++){
              if(jMDT1>=jMDT2)continue;// Regard vector comparison between two stations as 
              // Track Direction Check
              sst<<"MDT_TrackCheck_"<<RhoEtaPhiThe[x];
              sst<<"Sagitta_MDT"<<jMDT1+1;
              sst<<"vs"<<jMDT2+1;
              sst<<"_MDT";
              if(v==0)sst<<jMDT1+1;
              else    sst<<jMDT2+1;
              sst<<"_"<<AC[i];
              ATH_MSG_DEBUG("MDT_TrackCheckSagitta "<<i<<" "<<jMDT1<<" "<<jMDT2<<" "<<x<<" "<<sst.str().c_str() );
              m_mdt_trackchecksag[i][jMDT1][jMDT2][x][v] =new TH1F(sst.str().c_str(),sst.str().c_str(),  nbins3D_1[x], fGlobalCoords3Dlo[x], fGlobalCoords3Dup[x]);
              if(i==0){
                ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_mdt_trackchecksag[i][jMDT1][jMDT2][x][v]) );
              }else{
                ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_mdt_trackchecksag[i][jMDT1][jMDT2][x][v]) );
              }
              m_mdt_trackchecksag[i][jMDT1][jMDT2][x][v]->GetXaxis()->SetTitle(RhoEtaPhiThe[x].c_str());
              sst.str("");
            }
          }
        }// RhoEtaPhiThe
      }// MDT Station2
    }// MDT Station1
  }// AC
  
  return StatusCode::SUCCESS;
}

bookHistograms()

StatusCode ManagedMonitorToolBase::bookHistograms ( )

virtualinherited

An inheriting class should either override this function or bookHists().

Reimplemented in ActsTrk::PhysValTool, CscCalibMonToolBase, CscCalibMonToolPed, CscCalibMonToolSlope, DiMuMon, egammaMonToolBase, EgammaPhysValMonitoring::EgammaPhysValMonitoringTool, electronMonTool, forwardElectronMonTool, GeneratorPhysVal::GeneratorPhysValMonitoringTool, IDPerfMonKshort, IDPerfMonWenu, IDPerfMonZee, IDTPM::InDetTrackPerfMonTool, InDetPhysValMonitoringTool, JetMonitoringTool, JetTagDQA::PhysValBTag, ManagedMonitorToolTest, MissingEtDQA::PhysValMET, MuonPhysValMonitoring::MuonPhysValMonitoringTool, photonMonTool, PhysVal::PhysValExample, PhysValCluster, PhysValDiTau, PhysValFE, PhysValSecVtx, PhysValTau, TrackCaloClusterRecValidationTool, ZeeTaPMonTool, and ZeeValidation::ZeeValidationMonitoringTool.

Definition at line 1297 of file ManagedMonitorToolBase.cxx.

{
 
   return StatusCode::SUCCESS;
}

bookHistogramsRecurrent()

StatusCode MdtVsTgcRawDataValAlg::bookHistogramsRecurrent ( )

virtual

An inheriting class should either override this function, bookHists() or bookHistograms().

Reimplemented from ManagedMonitorToolBase.

Definition at line 133 of file MdtVsTgcRawDataValAlg.cxx.

                                                         {
/*----------------------------------------------------------------------------------*/
  ATH_MSG_DEBUG( "TGC RawData Monitoring Histograms being booked"  );
  
  //declare a group of histograms
  std::string generic_path_mdtvstgclv1 = "Muon/MuonRawDataMonitoring/MDTvsTGC";
  //MonGroup mdtvstgclv1_expert( this, generic_path_mdtvstgclv1+"/Global", expert, run );
  MonGroup mdtvstgclv1_expert_a( this, generic_path_mdtvstgclv1+"/TGCEA", run, ATTRIB_UNMANAGED );
  MonGroup mdtvstgclv1_expert_c( this, generic_path_mdtvstgclv1+"/TGCEC", run, ATTRIB_UNMANAGED );
  
  if(newRunFlag()){
    ATH_MSG_INFO( "MdtVsTgc RawData Monitoring : begin of run"  );
    
    ATH_CHECK( bookmaphists(mdtvstgclv1_expert_a, mdtvstgclv1_expert_c) );
    ATH_CHECK( bookeffhists(mdtvstgclv1_expert_a, mdtvstgclv1_expert_c) );
  }//isNewRun
  return StatusCode::SUCCESS;
}

bookHists()

StatusCode ManagedMonitorToolBase::bookHists ( )

virtualinherited

Calls bookHists( true, true, true ) and initializes lumiBlock and run numbers.

Implements IMonitorToolBase.

Definition at line 730 of file ManagedMonitorToolBase.cxx.

{
   // The Run/LumiBlock numbers are not set when beginRun() is called.  Therefore,
   // book histograms on the first call to fillHists(), which is called from execute().
   return StatusCode::SUCCESS;
}

bookmaphists()

StatusCode MdtVsTgcRawDataValAlg::bookmaphists ( MonGroup & mdtvstgclv1_expert_a, MonGroup & mdtvstgclv1_expert_c )

private

Definition at line 27 of file MdtVsTgcRawData_bookhistograms.cxx.

                                                                   {
  
  std::stringstream sst;
  std::string AC[2]=          {"A","C"};
  int   nbins3D_1[4]=         { 0, 0, 0, 0};
  float fGlobalCoords3Dlo[4]= { 0, 0, 0, 0};
  float fGlobalCoords3Dup[4]= { 0, 0, 0, 0};
  // **************************************************************
  // ** maphists
  // **************************************************************
  // Number of~ hists
  nbins3D_1[0]=              480; nbins3D_1[1]=              120; nbins3D_1[2]=              128; nbins3D_1[3]=              100;
  fGlobalCoords3Dlo[0]=        0; fGlobalCoords3Dlo[1]=        0; fGlobalCoords3Dlo[2]=        0; fGlobalCoords3Dlo[3]=        0;
  fGlobalCoords3Dup[0]=    12000; fGlobalCoords3Dup[1]=        3; fGlobalCoords3Dup[2]=   2*M_PI; fGlobalCoords3Dup[3]= 0.5*M_PI;
  for(int i=0;i<2;i++){// AC
    // nEvents passing cut criteria
    sst<<"EffCheck_CutsPassed_"<<AC[i];
    ATH_MSG_DEBUG("EffCheck_CutsPassed "<<i<<" "<<sst.str().c_str() );
    m_mvt_cutspassed[i] =new TH1I(sst.str().c_str(), sst.str().c_str(), 14, 1, 15);
    if(i==0){
      ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_mvt_cutspassed[i]) );
    }else{
      ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_mvt_cutspassed[i]) );
    }
 
    m_mvt_cutspassed[i]->GetYaxis()->SetTitle("nEvents");
    m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(1, "Events");
    m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(2, "matchedSegm=0");
    m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(3, "matchedSegm>1");
    m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(4, "matchedSegm=1");
    m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(5, "+HasEIFI");
    m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(6, "EIFIMatch");
    m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(7, "+HasT1");
    m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(8, "T1Match");
    m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(9,"+HasT2");
    m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(10,"T2Match");
    m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(11,"+HasT3");
    m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(12,"T3Match");
    m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(13,"AllStationsMatch");
    m_mvt_cutspassed[i]->GetXaxis()->SetBinLabel(14,"AllLayersMatch");
    sst.str("");
  }// AC
  
  
  // Distributions
  nbins3D_1[0]=              600; nbins3D_1[1]=              120; nbins3D_1[2]=              128; nbins3D_1[3]=              128;
  fGlobalCoords3Dlo[0]=        0; fGlobalCoords3Dlo[1]=        0; fGlobalCoords3Dlo[2]=        0; fGlobalCoords3Dlo[3]=        0;
  fGlobalCoords3Dup[0]=    12000; fGlobalCoords3Dup[1]=        3; fGlobalCoords3Dup[2]=   2*M_PI; fGlobalCoords3Dup[3]= 0.5*M_PI;
  for(int i=0;i<2;i++){// AC
    for(int jMDT=0;jMDT<4;jMDT++){// MDT Station
      // MDT Segm Eta vs Phi
      sst<<"MDT_SegmMap_MDT"<<jMDT+1;
      sst<<"_"<<AC[i];
      ATH_MSG_DEBUG("MDT_SegmMap "<<i<<" "<<jMDT<<" "<<sst.str().c_str() );
      m_mdt_segmmap[i][jMDT] =new TH2F(sst.str().c_str(),sst.str().c_str(), nbins3D_1[2], fGlobalCoords3Dlo[2], fGlobalCoords3Dup[2], nbins3D_1[1], fGlobalCoords3Dlo[1], fGlobalCoords3Dup[1]);
      if(i==0){
        ATH_CHECK( mdtvstgclv1_expert_a.regHist(m_mdt_segmmap[i][jMDT]) );
      }else{
        ATH_CHECK( mdtvstgclv1_expert_c.regHist(m_mdt_segmmap[i][jMDT]) );
      }
 
      m_mdt_segmmap[i][jMDT]->GetXaxis()->SetTitle("MDT Phi");
      m_mdt_segmmap[i][jMDT]->GetYaxis()->SetTitle("MDT Eta");
      sst.str("");
    }// MDT Station
  }// AC
  return StatusCode::SUCCESS;
}

checkHists()

StatusCode ManagedMonitorToolBase::checkHists ( bool calledFromFinalize )

virtualinherited

This implementation does nothing; equivalent functionality may be provided by procHists(...) with appropriate arguments.

Implements IMonitorToolBase.

Reimplemented in CscCalibMonToolBase.

Definition at line 1670 of file ManagedMonitorToolBase.cxx.

{
   // Histograms will be checked using the data-quality monitoring framework (DQMF)
 
   return StatusCode::SUCCESS;
}

CheckTGConTrack()

void MdtVsTgcRawDataValAlg::CheckTGConTrack ( std::vector< SegmTrack >(&) matchedSegments[2], const Muon::TgcPrepDataContainer * tgc_prepcontainer )

private

Definition at line 35 of file MdtVsTgcRawData_PRDonTrack.cxx.

                                                                                         {
  // Define Cuts:
  // Loose cut for PRD and Extrapolated
  const float dPhiCut_Loose    = M_PI/8;
  // Cut for Global Position  Efficiencies
  const float dPhiCutGlobal[2] = {static_cast<float>(M_PI/24),static_cast<float>(M_PI/12)};       //[WireStrip]
  const float dRhoCutGlobal[2] = {   0.08,    0.5};         //[WireStrip]
  // Cut for Sector Efficiencies
  const float dPhiCutSector[2] = {    0.2,    0.1};         //[WireStrip]
  const float dRhoCutSector[2] = {    200,   2000};         //[WireStrip]
  
  // Loop over sides
  for(int i=0;i<2;i++){// AC
    // Get number of tracks
    unsigned int nTrack=matchedSegments[i].size();
    
    // Fill nEvents histograms
    m_mvt_cutspassed[i]->Fill(1);
    if(nTrack==0)m_mvt_cutspassed[i]->Fill(2);
    if(nTrack>1)m_mvt_cutspassed[i]->Fill(3);
    if(nTrack==1)m_mvt_cutspassed[i]->Fill(4);
    
    // Cut events without exactly one set of matched Segments
    if(nTrack!=1)continue;
    
    // Declare Position variables for inner
    //Trk::GlobalPosition innerSegmPos;
    Amg::Vector3D innerSegmPos = {0, 0, 0};
 
    // float innerSegmEta=0; 
    float innerSegmRho=0; float innerSegmPhi=0; float innerSegmZ=0;
    //Trk::GlobalDirection innerSegmDirzunit;
    Amg::Vector3D innerSegmDirzunit = {0, 0, 0};
    
    // Declare Position variables for midstation
    //Trk::GlobalPosition midSegmPos;
    Amg::Vector3D midSegmPos = {0, 0, 0};
 
    // float midSegmRho  =0; float midSegmEta  =0; 
    float midSegmPhi  =0; float midSegmZ  =0;
    //Trk::GlobalDirection midSegmDirzunit;
    Amg::Vector3D midSegmDirzunit = {0, 0, 0};
    
    // Check which layers have sufficienct segments to operate on for global coordinates
    bool canCheckGlobal[4] = {0, 0, 0, 0};// [TGCStation]
    if(matchedSegments[i].at(0).at(2)!=nullptr){
      // Check Midstation
      canCheckGlobal[0]=true; canCheckGlobal[1]=true; canCheckGlobal[2]=true;
      // Read Midstation Segment Values into variables
      midSegmPos   = Amg::Vector3D(matchedSegments[i].at(0).at(2)->globalPosition());
      midSegmPhi   = midSegmPos.phi();
      midSegmZ     = midSegmPos.z();
      if(midSegmPhi<0)midSegmPhi+=2*M_PI;
      midSegmDirzunit = Amg::Vector3D(midSegmPos/std::abs(midSegmZ));
    }
    if((matchedSegments[i].at(0).at(0)!=nullptr)&&(matchedSegments[i].at(0).at(2)!=nullptr)){
      // Check EIFI
      canCheckGlobal[3]=true;
      // Read Inner Segment Values
      innerSegmPos = Amg::Vector3D(matchedSegments[i].at(0).at(0)->globalPosition());
      innerSegmRho = std::abs(innerSegmPos.perp());
      innerSegmZ   = std::abs(innerSegmPos.z());
      // Modify position
      innerSegmPhi = midSegmPhi;
 
      innerSegmPos      = Amg::Vector3D(innerSegmRho*std::cos(innerSegmPhi), innerSegmRho*std::sin(innerSegmPhi), innerSegmZ);
      innerSegmDirzunit = Amg::Vector3D(innerSegmPos/std::abs(innerSegmZ));
    } 
    
    // If no layers can be checked (i.e. no midstation segment matched) skip side
    bool skipSide = true;
    for(int jTGC=0;jTGC<4;jTGC++)if(canCheckGlobal[jTGC]==true)skipSide=false;
    if(skipSide==true)continue;
    
    // Initialize variables for TRE array search
    int TGCStationNames[8]      ={41, 42, 43, 44, 45, 46, 47, 48};
    int TGCstation_StationFE[4] ={-1,-1,-1,-1};// [TGCStation]
    int TGCstation_StationEta[4]={ 0, 0, 0, 0};// [TGCStation]
    int TGCstation_StationPhi[4]={ 0, 0, 0, 0};// [TGCStation]
    int nStationMatch[4]        ={ 0, 0, 0, 0};// [TGCStation]
    bool canCheckSector[4]      ={ true, true, true, true};// [TGCStation]
    
    // Loop through TRE array, finding sectors which match the track in each layer
    for(int stationnameindex=0; stationnameindex<8; stationnameindex++){// Station {T1F,T1E,T2F,T2E,T3F,T3E,T4F,T4E}
      // Skip stations which don't have sufficient Segments to run efficiency check
      int stationName = TGCStationNames[stationnameindex];
      int stationIndex= TGCstationname2stationindex(stationName);
      if(stationIndex<0) continue;
      if(!canCheckGlobal[stationIndex])continue;
      
      // Loop over StationEta&StationPhi
      for(int stationeta=1; stationeta<=8; stationeta++){// AbsStationEta
        for(int stationphi=1; stationphi<=48; stationphi++){// StationPhi
          // Cut Station EtaPhi combinations with no TGC element
          if(m_TREarray[stationnameindex][i][stationeta][stationphi]==nullptr)continue;
          const MuonGM::TgcReadoutElement *tre=m_TREarray[stationnameindex][i][stationeta][stationphi];
          
          // Extrapolate position from nearest Station's Segment to Sector's Z
          float sectorZ=tre->globalPosition().z();
          //Trk::GlobalPosition sectorExtrapolatedPos;
          Amg::Vector3D sectorExtrapolatedPos;
      
          if(stationIndex==3){// Inner
            float dZ_sector=std::abs(sectorZ)-std::abs(innerSegmZ);
            //sectorExtrapolatedPos = Trk::GlobalPosition(innerSegmPos+(innerSegmDirzunit*dZ_sector));
            sectorExtrapolatedPos = Amg::Vector3D(innerSegmPos+(innerSegmDirzunit*dZ_sector)); 
      }
          else{// Midstation
            float dZ_sector=std::abs(sectorZ)-std::abs(midSegmZ);
            sectorExtrapolatedPos = Amg::Vector3D(midSegmPos+(midSegmDirzunit*dZ_sector));
          }
          
          // Convert extrapolated position to local position on the Sector
          Identifier sector_id=tre->identify();
          const Amg::Vector3D sectorLocalPos3D=tre->globalToLocalTransf(sector_id)*sectorExtrapolatedPos;
          Amg::Vector2D sectorLocalPos2D(sectorLocalPos3D.y(),sectorLocalPos3D.z());
          
          double avWidth = (tre->getLongSsize()+tre->getSsize())/2;
          //double dWidth  = (tre->longWidth()-tre->shortWidth());
          double length  = tre->length();
          
          // Cut sectors which the track does not go through the central 80% of (avoids double counts)
          double tol1=-0.1*(avWidth/2);
          double tol2=-0.1*(length/2);
          
          bool insideSectorBounds=tre->bounds().inside(sectorLocalPos2D,tol1,tol2);
          if(!insideSectorBounds)continue;
          
          // Assign values to matching station variables
          TGCstation_StationFE[stationIndex]= (tre->isForward()==false);
          TGCstation_StationEta[stationIndex]=stationeta;
          TGCstation_StationPhi[stationIndex]=stationphi;
          nStationMatch[stationIndex]++;
        }// StationPhi
      }// StationEta
    }// StationName
    
    // Don't check stations that don't have exactly 1 match for this track
    for(int jTGC=0;jTGC<4;jTGC++){// TGC Station
      if(nStationMatch[jTGC]==0){
        canCheckSector[jTGC]=false;
      }
      else if(nStationMatch[jTGC]>1){
        canCheckSector[jTGC]=false;
        // Should be impossible, but happens due a problem with the bounds().inside function
        // commenting out until this bug is resolved
        //m_log << MSG::WARNING << "SegmTrack: Number of matches for TGC" << jTGC+1 << " is " << nStationMatch[jTGC] << endl;
      }
    }// TGC Station
    
    // Loop through segments to check number of TGC Strips in each
    int nTGCStrips[4] = {0, 0, 0, 0};//[TGCStation]
    for(int jMDT=0;jMDT<4;jMDT++){// MDT Station
      if(matchedSegments[i].at(0).at(jMDT)==nullptr)continue;
      const Muon::MuonSegment *segm=matchedSegments[i].at(0).at(jMDT);
      // Loop through contained ROTs and identify used stations
      const std::vector<const Trk::MeasurementBase*> mMeasTrk = segm->containedMeasurements();
      ATH_MSG_DEBUG( "number of MeasurementBase: "<<mMeasTrk.size() );
      for (unsigned int i=0; i<mMeasTrk.size(); i++) {
    const Trk::MeasurementBase* m  = mMeasTrk[i];
    //const Trk::RIO_OnTrack* rio = dynamic_cast<const Trk::RIO_OnTrack*>(m);
    const Muon::CompetingMuonClustersOnTrack* crot = dynamic_cast<const Muon::CompetingMuonClustersOnTrack*>(m);
    if(crot) { 
      for(const auto& rio : crot->containedROTs()){
       //const Trk::RIO_OnTrack* rio = crot->rioOnTrack(iROT);
       Identifier id = rio->identify();
       int stationName = int(m_idHelperSvc->mdtIdHelper().stationName(id));
           // 41=T1F 42=T1E 43=T2F 44=T2E 45=T3F 46=T3E 47=T4F 48=T4E
           if(m_idHelperSvc->tgcIdHelper().isStrip(id)){
             if((jMDT==2)&&((stationName==41)||(stationName==42)))nTGCStrips[0]++;// TGC
             if((jMDT==2)&&((stationName==43)||(stationName==44)))nTGCStrips[1]++;// TGC
             if((jMDT==2)&&((stationName==45)||(stationName==46)))nTGCStrips[2]++;// TGC
             if((jMDT==0)&&((stationName==47)||(stationName==48)))nTGCStrips[3]++;// TGC
           }
 
       ATH_MSG_DEBUG( " check if TGC strip: "<<m_idHelperSvc->tgcIdHelper().isStrip(id)<<" StationName: "<<stationName );
      }
    }
      }
    }// MDT Station
 
    
    // Don't check mid-stations when there are no strips in other mid-stations  
    if((nTGCStrips[1]==0)&&(nTGCStrips[2]==0)){canCheckSector[0]=false;canCheckGlobal[0]=false;}
    if((nTGCStrips[0]==0)&&(nTGCStrips[2]==0)){canCheckSector[1]=false;canCheckGlobal[1]=false;}
    if((nTGCStrips[0]==0)&&(nTGCStrips[1]==0)){canCheckSector[2]=false;canCheckGlobal[2]=false;}
    
    // Initialise hit registered arrays
    // bool hitregistered[9][2];
    bool sectorhitregistered[9][2];
    for(int l=0;l<9;l++){// Layer
      for(int k=0;k<2;k++){// WireStrip
        // hitregistered[l][k]=false;
        sectorhitregistered[l][k]=false;
      }// WireStrip
    }// Layer
    
    // Initialise flags for whether a layer in this event has PRD and PRD which matched the current track
    bool HasPRD[9]  ={false,false,false,false,false,false,false,false,false};
    bool PRDMatch[9]={false,false,false,false,false,false,false,false,false};
    
    // Loop over TGC Prep Data container
    Muon::TgcPrepDataContainer::const_iterator prepit_end=tgc_prepcontainer->end();
    for( Muon::TgcPrepDataContainer::const_iterator prepit=tgc_prepcontainer->begin();
         prepit!=prepit_end;
         ++prepit){
      
      //loop over TGC Prep Data collection
      Muon::TgcPrepDataCollection::const_iterator prepitc_end=(*prepit)->end();
      for( Muon::TgcPrepDataCollection::const_iterator prepitc=(*prepit)->begin();
           prepitc!= prepitc_end;
           ++prepitc){
        // Get PRD and variables
        const Muon::TgcPrepData* tpd=*prepitc;
        const MuonGM::TgcReadoutElement *tre = tpd->detectorElement();
        const std::string stationType = tre->getStationType();
        
        // Get id values
        Identifier tgcid=(*prepitc)->identify();
        int tgcAC=(tre->sideA()==false);//isNotAside a:0, c:1
        int tgcFE=(tre->isForward()==false);//isNotForward f:0, e:1
        int tgcWS=(m_idHelperSvc->tgcIdHelper().isStrip(tgcid));//isStrip w=0, s=1
        int stationName = m_idHelperSvc->tgcIdHelper().stationName(tgcid);
        int stationEta  = std::abs(tre->getStationEta());
        int stationPhi  = tre->getStationPhi();
        int gasGap      = m_idHelperSvc->tgcIdHelper().gasGap(tgcid);
        
        // Cut hits except those from same side EIFI & Midstation
        if(tgcAC!=i) continue;
        if(stationName>48 || stationName<41) continue;
 
        // Get layer number and stationIndex
        int layer        = TGCgetlayer(stationName,gasGap);
        int stationIndex = TGCstationname2stationindex(stationName);
 
        // Skip PRD in stations which can't be checked
        if(stationIndex<0) continue;
        if(!(canCheckGlobal[stationIndex]||canCheckSector[stationIndex]))continue;
    if(layer<0) continue;
        HasPRD[layer]=true;
        
        // Get position variables
        // const Trk::GlobalPosition prdPos = tpd->globalPosition();
        const Amg::Vector3D prdPos = tpd->globalPosition();
    float tgcRho = std::abs(prdPos.perp());
        float tgcPhi = prdPos.phi();
        float tgcZ   = prdPos.z();
        if(tgcPhi<0)tgcPhi+=2*M_PI;
        
        // Run Extrapolation
       // Trk::GlobalPosition tgcExtrapolatedPos;
    Amg::Vector3D tgcExtrapolatedPos;
        if(stationIndex==3){// Extrapolate position from Inner Position to PRD Z position
          //if(innerSegmPos=0)m_log << MSG::WARNING << "MidstationOnly: innerSegmPos=0 but passed canCheckGlobal"  );
          float dZ = std::abs(tgcZ) - std::abs(innerSegmZ);
          //tgcExtrapolatedPos = Trk::GlobalPosition(innerSegmPos+(innerSegmDirzunit*dZ));
          tgcExtrapolatedPos = Amg::Vector3D(innerSegmPos+(innerSegmDirzunit*dZ)); 
    }
        else{// Extrapolate position from Midstation Position to PRD Z position
          float dZ = std::abs(tgcZ) - std::abs(midSegmZ);
          //tgcExtrapolatedPos = Trk::GlobalPosition(midSegmPos+(midSegmDirzunit*dZ));
          tgcExtrapolatedPos = Amg::Vector3D(midSegmPos+(midSegmDirzunit*dZ)); 
    }
        float tgcExtrRho = std::abs(tgcExtrapolatedPos.perp());
        float tgcExtrPhi = tgcExtrapolatedPos.phi();
        if(tgcExtrPhi<0)tgcExtrPhi+=2*M_PI;
        
        // Get differences between extrapolated and segm2 positions
        float dRho = tgcRho-tgcExtrRho;
        float dPhi = tgcPhi-tgcExtrPhi;
        if(dPhi<-M_PI)dPhi+=2*M_PI;
        if(dPhi> M_PI)dPhi-=2*M_PI;
        
        // Pass through loose phi cut to eliminate some noise
        if(std::abs(dPhi)<dPhiCut_Loose){
          // Fill PRD sagitta histograms 
          if(m_mvt_extrprdsag[i][stationIndex][tgcFE][tgcWS][0]) m_mvt_extrprdsag[i][stationIndex][tgcFE][tgcWS][0]->Fill(dRho);
          if(m_mvt_extrprdsag[i][stationIndex][tgcFE][tgcWS][2]) m_mvt_extrprdsag[i][stationIndex][tgcFE][tgcWS][2]->Fill(dPhi);
          
          // Global efficiency check
          if(canCheckGlobal[stationIndex]){
            // Do check
            float dRhoCut = dRhoCutGlobal[tgcWS]*tgcExtrRho;
            if(std::abs(dPhi)<dPhiCutGlobal[tgcWS] && std::abs(dRho)<dRhoCut){
            }
          }
          
          // Sector Efficiency Check
          if(canCheckSector[stationIndex]){// If this station can be checked
            if((stationEta==TGCstation_StationEta[stationIndex])&&
               (stationPhi==TGCstation_StationPhi[stationIndex])&&
               (tgcFE==TGCstation_StationFE[stationIndex])){// If Station FE&Eta&Phi match
              if(std::abs(dPhi)<dPhiCutSector[tgcWS] && std::abs(dRho)<dRhoCutSector[tgcWS]){
                sectorhitregistered[layer][tgcWS]=true;
              }
            }// Station EtaPhi
          }
 
        }// dPhi Loose Cut
      }// TGC PRD Collection
    }// TGC PRD Container
    
    // Fill Efficiency Histograms
    for(int l=0;l<9;l++){// Layer
      // Get Station Number
      int stationIndex=TGClayer2stationindex(l);
      if(stationIndex<0) continue;
      for(int k=0;k<2;k++){// WireStrip
        // If Segment Track matches a Sector
        if(canCheckSector[stationIndex]){
          if((TGCstation_StationFE[stationIndex]<0)||(TGCstation_StationEta[stationIndex]==0)||(TGCstation_StationPhi[stationIndex]==0)){
            ATH_MSG_WARNING( "SegmTrack: canCheckSector passed for jTGC=" << stationIndex
                             << " but, FE=" << TGCstation_StationFE[stationIndex]
                             << " Eta=" << TGCstation_StationEta[stationIndex]
                             << " Phi=" << TGCstation_StationPhi[stationIndex]  );
            continue;
          }
          // Get Sector histogram indexes
          int stationMap_EtaIndex=getStationMapIndex(1, l, TGCstation_StationFE[stationIndex], TGCstation_StationEta[stationIndex], TGCstation_StationPhi[stationIndex]);
          int stationMap_PhiIndex=getStationMapIndex(2, l, TGCstation_StationFE[stationIndex], TGCstation_StationEta[stationIndex], TGCstation_StationPhi[stationIndex]);
          // Fill Sector efficiency histograms
          if(sectorhitregistered[l][k]){// Hit in Sector matches extrapolated track
            m_eff_stationmapbase[i][k][1]->Fill(stationMap_EtaIndex, stationMap_PhiIndex);
          }
          m_eff_stationmapbase[i][k][2]->Fill(stationMap_EtaIndex, stationMap_PhiIndex);
        }
      }// WireStrip
    }// Layer
    
    // Fill +Has Station bins of histogram
    if(HasPRD[0]||HasPRD[1]||HasPRD[2])m_mvt_cutspassed[i]->Fill(7);
    if(HasPRD[3]||HasPRD[4])m_mvt_cutspassed[i]->Fill(9);
    if(HasPRD[5]||HasPRD[6])m_mvt_cutspassed[i]->Fill(11);
    if(HasPRD[7]||HasPRD[8])m_mvt_cutspassed[i]->Fill(5);
    
    // Fill Match Station bins of histogram
    if(PRDMatch[0]||PRDMatch[1]||PRDMatch[2])m_mvt_cutspassed[i]->Fill(8);
    if(PRDMatch[3]||PRDMatch[4])m_mvt_cutspassed[i]->Fill(10);
    if(PRDMatch[5]||PRDMatch[6])m_mvt_cutspassed[i]->Fill(12);
    if(PRDMatch[7]||PRDMatch[8])m_mvt_cutspassed[i]->Fill(6);
    if((PRDMatch[0]||PRDMatch[1]||PRDMatch[2])&&
       (PRDMatch[3]||PRDMatch[4])&&
       (PRDMatch[5]||PRDMatch[6])&&
       (PRDMatch[7]||PRDMatch[8]))m_mvt_cutspassed[i]->Fill(13);
    if((PRDMatch[0]&&PRDMatch[1]&&PRDMatch[2])&&
       (PRDMatch[3]&&PRDMatch[4])&&
       (PRDMatch[5]&&PRDMatch[6])&&
       (PRDMatch[7]&&PRDMatch[8]))m_mvt_cutspassed[i]->Fill(14);
    
    
  }// AC
}// End of function

correlation()

void MdtVsTgcRawDataValAlg::correlation ( const Muon::MdtPrepDataContainer * mdt_hit_container, const Muon::TgcCoinDataContainer * tgc_trigger_container )

private

<<"mmdtStationName "<<mdtStationName

Definition at line 24 of file MdtVsTgcRawData_correlation.cxx.

                                                                                {
 
  ATH_MSG_DEBUG("inside correlation" );
  //StatusCode sc=StatusCode::SUCCESS;
 
  // MuonDetectorManager from the conditions store
  SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey};
  const MuonGM::MuonDetectorManager* MuonDetMgr = DetectorManagerHandle.cptr(); 
  if(MuonDetMgr==nullptr){
    ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object");
    return;
  } 
 
  //loop over TGC RoI container
  Muon::TgcCoinDataContainer::const_iterator it_end=tgccontainer->end();
  for( Muon::TgcCoinDataContainer::const_iterator it=tgccontainer->begin();
       it!=it_end;
       ++it){
  
 
    ATH_MSG_DEBUG( "size of tgc collection is " << (*it) -> size()  );
 
    //loop over TGC RoI collection
    Muon::TgcCoinDataCollection::const_iterator itc_end=(*it)->end();
    for( Muon::TgcCoinDataCollection::const_iterator itc=(*it)->begin();
         itc!= itc_end;
         ++itc){
 
      const Muon::TgcCoinData* tcd=*itc;
      Identifier tgcid=(*itc)->identify();
 
      if( tcd->type() != Muon::TgcCoinData::TYPE_SL )continue;
 
      int ac=(tcd->isAside()==false);//isNotAside a:0, c:1
      int ef=(tcd->isForward()==false);//isNotForward f:0, e:1
      int phi48=tcd->phi();//48(24)
      int roi=tcd->roi();
      int roieta;//1-53
      int roiphi;//1-192
 
      roi2etaphi(*tcd, roieta, roiphi);
 
      //int tgcMdtSector=roiphi2mdtSector(roiphi,ef);
 
      const MuonGM::TgcReadoutElement*  pReadoutElementTGC = MuonDetMgr->getTgcReadoutElement(tgcid);
      const Amg::Vector3D pos = pReadoutElementTGC->channelPos(tgcid);
 
      float tgcEta = std::abs(pos.eta());
      float tgcPhi = pos.phi();
      if(tgcPhi<0)tgcPhi+=2*M_PI;
 
 
      ATH_MSG_DEBUG("ac "<<ac
                    <<" ef "<<ef
                    <<" phi48 "<<phi48
                    <<" roi "<<roi
                    <<" roieta "<<roieta
                    <<" roiphi "<<roiphi
                    <<" tgcEta "<<tgcEta
                    <<" tgcPhi "<<tgcPhi );
 
 
      //loop over MDT container
      Muon::MdtPrepDataContainer::const_iterator containerIt;
      Muon::MdtPrepDataContainer::const_iterator container_end=mdt_hit_container->end();
      for (containerIt = mdt_hit_container->begin() ; 
           containerIt != container_end ; 
           ++containerIt){ 
    
        Identifier mdt_id = (*containerIt)->identify();
        // Field           Range               Notes
        // ==============================================================================
        // StationName     unsigned integer    maps to "BIL", "EMS" ,etc.
        // StationEta      [-6,-1]             backward endcap (-1 at lowest R)
        //                 [-8,8]              barrel (increases with Z)
        //                 [-6,-1]+[1,6]       forward endcap (1 at lowest R)
        // StationPhi      [1,8]               increases with phi
        // Technology      [0]                 maps to "MDT"
        // Multilayer      [1,2]               barrel: increases with R
        //                                     endcap: increases with |Z|
        // TubeLayer       [1,4]               barrel: increases with R
        //                                     endcap: increases with |Z|
        // Tube            [1,n]               barrel: increases with |Z|
        //                                     endcap: increases with R
        // ==============================================================================
 
        int mdtStationName      =   int(m_idHelperSvc->mdtIdHelper().stationName(mdt_id)) ;
 
        //SN     Layer Tube Radial
        //13:EIL 2x4   x54  x4
        //49:EIS 2x4   x36  x2
        //17:EML 2x3   x64  x5
        //18:EMS 2x3   x64  x5
        //20:EOL 2x3   x48  x6
        //21:EOS 2x3   x48  x6
 
        //only Endcap MDT
        //if(mdtStationName!=13 && mdtStationName!=49 && mdtStationName!=17 && mdtStationName!=18 && mdtStationName!=20 && mdtStationName!=21 )continue;
 
        //if (m_debuglevel){
        //m_log<<MSG::DEBUG
        //    <<endmsg;
        //}
 
        //only Endcap middle MDT
        if(mdtStationName!=17 && mdtStationName!=18 )continue;
 
        int mdtStationEta       =   int(m_idHelperSvc->mdtIdHelper().stationEta(mdt_id))  ;//backward:[-6,-1], forward:[1,6], (1 or -1 at lowest R)
        int mdtStationPhi       =   int(m_idHelperSvc->mdtIdHelper().stationPhi(mdt_id))  ;//[1:8]
        int mdtAC = (mdtStationEta<0);//a:0, c:1
 
        float mdtSector=mdtStationPhi*2.-1.;
        if(mdtStationName==18)mdtSector+=1;
        double mdtSectorPhi = (mdtSector-1.)*M_PI/8.;
 
        //same Side
        if(ac!=mdtAC)continue;
        ATH_MSG_DEBUG( "size of mdt collection is " << (*containerIt) -> size()  );
 
        ATH_MSG_DEBUG("mdtStationName "<<mdtStationName
                      <<" mdtStationEta "<<mdtStationEta
                      <<" mdtStationPhi "<<mdtStationPhi
                      <<" mdtSectorPhi "<<mdtSectorPhi );
 
        //loop over MDT PRD Collection
        Muon::MdtPrepDataCollection::const_iterator collection_it_end=(*containerIt)->end();
 
 
        int tmp[2][4][64];
        for(int i=0;i<2;i++)
          for(int j=0;j<4;j++)
            for(int k=0;k<64;k++)
              tmp[i][j][k]=0;
 
        for(Muon::MdtPrepDataCollection::const_iterator mdtCollection=(*containerIt)->begin();
            mdtCollection!= collection_it_end;
            ++mdtCollection){
 
          Identifier mdt_id2 = (*mdtCollection)->identify();
 
          int mdtMultiLayer       =   int(m_idHelperSvc->mdtIdHelper().multilayer(mdt_id2));
          int mdtTubeLayer        =   int(m_idHelperSvc->mdtIdHelper().tubeLayer(mdt_id2));
          int mdtTube             =   int(m_idHelperSvc->mdtIdHelper().tube(mdt_id2));
          int mdtTubeIdForEM = (std::abs(mdtStationEta)-1)*64 + mdtTube -1;
 
          ATH_MSG_DEBUG("mdtMultiLayer "<<mdtMultiLayer
                        <<" mdtTubeLayer "<<mdtTubeLayer
                        <<" mdtTube "<<mdtTube
                        <<" mdtTubeIdForEM "<<mdtTubeIdForEM );
 
          if(tmp[mdtMultiLayer-1][mdtTubeLayer-1][mdtTube-1]==1)continue;
          tmp[mdtMultiLayer-1][mdtTubeLayer-1][mdtTube-1]=1;
 
          int adc = (*mdtCollection)->adc();
          int tdc = (*mdtCollection)->tdc();
 
          if(adc < m_MdtAdcCut )continue;
 
          const MuonGM::MdtReadoutElement*  pReadoutElementMDT = MuonDetMgr->getMdtReadoutElement(mdt_id2);
          const Amg::Vector3D mdtgPos = pReadoutElementMDT->tubePos(mdt_id2); //global position of the wire
          float mdtEta = std::abs(mdtgPos.eta());
          float mdtPhi = mdtgPos.phi();
          float mdtr = mdtgPos.perp();
          float mdtz = mdtgPos.z();
          if(mdtPhi<0)mdtPhi+=2*M_PI;
 
          ATH_MSG_DEBUG(" Name "<<mdtStationName
                        <<" Eta "<<mdtStationEta
                        <<" Phi "<<mdtStationPhi
                        <<" MultiLayer "<<mdtMultiLayer
                        <<" TubeLayer "<<mdtTubeLayer
                        <<" Tube "<<mdtTube
                        <<" TubeIdForEM "<<mdtTubeIdForEM
                        <<" Eta "<<mdtEta
                        <<" Phi "<<mdtPhi
                        <<" r "<<mdtr
                        <<" z "<<mdtz
                        <<" Sec "<<mdtSector
                        <<" SecPhi "<<mdtSectorPhi
                        <<" ADC "<<adc
                        <<" TDC "<<tdc );
          
        }//MDT collection
      }//MDT container
    }//TGC collection
  }//TGC container
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

deregGraph()

StatusCode ManagedMonitorToolBase::deregGraph ( TGraph * g )

virtualinherited

De-registers a TGraph from the THistSvc, but does NOT delete the object.

Definition at line 1624 of file ManagedMonitorToolBase.cxx.

{
   return m_THistSvc->deReg( g );
}

deregHist()

StatusCode ManagedMonitorToolBase::deregHist ( TH1 * h )

virtualinherited

De-registers a TH1 from the THistSvc, but does NOT delete the object.

Definition at line 1616 of file ManagedMonitorToolBase.cxx.

{
   return m_THistSvc->deReg( h );
}

deregObject() [1/2]

StatusCode ManagedMonitorToolBase::deregObject ( const std::string & objName, const MonGroup & group )

virtualinherited

De-registers a TObject from the THistSvc, but does NOT delete the object.

(NB: LightWeight histograms are not even registered until readout).

Definition at line 1642 of file ManagedMonitorToolBase.cxx.

{
   std::string streamName = streamNameFunction()->getStreamName( this, group, objName );
   return m_THistSvc->deReg( streamName );
}

deregObject() [2/2]

StatusCode ManagedMonitorToolBase::deregObject ( const std::string & objName, const std::string & system, Interval_t interval )

virtualinherited

De-registers a TObject from the THistSvc, but does NOT delete the object.

(NB: LightWeight histograms are not even registered until readout).

Definition at line 1632 of file ManagedMonitorToolBase.cxx.

{
   MonGroup group( this, system, interval );
   return deregObject( objName, group );
}

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

DQCheckMDTSegments()

void MdtVsTgcRawDataValAlg::DQCheckMDTSegments ( std::vector< const Muon::MuonSegment * >(&) sortedSegments[2][4], std::vector< const Muon::MuonSegment * >(&) disqualifiedSegments[2][4] )

private

Definition at line 33 of file MdtVsTgcRawData_SegmDQ.cxx.

                                                                                                          {
  // Define Cuts:
  // Cut for miniumum number of measurements necessary to use Segments
  const int   nMeasCutMdt[4]      = { 4, 2, 4, 5};             //[MDTStation]
  const int   nMeasCutTgcStrip[4] = { 0, 0, 1, 0};             //[MDTStation]
  // Cut for differences between direction and position vectors
  const float dPhiCutPosDir[4]    = {0.05,0.05,0.08,0.1 };
  const float dTheCutPosDir[4]    = { 0.2, 0.4, 0.6,0.5 };
  
  // Loop over sides
  for(int i=0;i<2;i++){// AC
    bool skipSegm;int nDisqualifiedSegm; // used when checking the disqualified list for a segment
    bool segmDisqual;                    // used to flag a segment which has been found DQ insufficient
    //bool HasStationDQSegm[4] = {false, false, false, false};// flags for whether the there are segments in each MDT station with sufficienct DQ
    
    for(int jMDT=0;jMDT<4;jMDT++){// MDT Stations
      // Get number of segments
      int nSegm=sortedSegments[i][jMDT].size();
      
      // Loop over segments in this MDT Station
      for(int n=0; n<nSegm;n++){
        segmDisqual = false;// set disqualified flag to false
        // Get segment
        const Muon::MuonSegment *segm=sortedSegments[i][jMDT].at(n);
        if(segm==nullptr)continue;// Cut empty entries
        
        // Check disqualifiedSegments for current segment
        skipSegm=false;
        nDisqualifiedSegm=disqualifiedSegments[i][jMDT].size();
        for(int ndis=0;ndis<nDisqualifiedSegm;ndis++)if(segm==disqualifiedSegments[i][jMDT].at(ndis))skipSegm=true;
        if(skipSegm)continue;
        
        // Apply nHits cuts to segments
        int stationName=0;
        int nMdtMeas = 0;       //             nMDTHits in this Segment
        int nTgcMeas[2] = {0,0};// [WireStrip] nTGCHits in this Segment
        
        // Loop through contained ROTs and identify used stations
        for(unsigned int iROT=0; iROT<segm->numberOfContainedROTs(); ++iROT) {
          const Trk::RIO_OnTrack* rio = segm->rioOnTrack(iROT);
      if(!rio){
        ATH_MSG_DEBUG("no RIO");
        continue;
      }
          Identifier id = rio->identify();
          stationName = int(m_idHelperSvc->mdtIdHelper().stationName(id));
          int isStrip = m_idHelperSvc->tgcIdHelper().isStrip(id);
          
          if((stationName==41)||(stationName==42))nTgcMeas[isStrip]++;// TGC
          if((stationName==43)||(stationName==44))nTgcMeas[isStrip]++;// TGC
          if((stationName==45)||(stationName==46))nTgcMeas[isStrip]++;// TGC
          if((stationName==47)||(stationName==48))nTgcMeas[isStrip]++;// TGC
          
          if((stationName==13)||(stationName==49))nMdtMeas++;// MDT
          if((stationName==14)||(stationName==15))nMdtMeas++;// MDT
          if((stationName==17)||(stationName==18))nMdtMeas++;// MDT
          if((stationName==20)||(stationName==21))nMdtMeas++;// MDT
        }
        
        // Cut Segments with insufficient numbers of hits in the stations
        if(nMdtMeas<nMeasCutMdt[jMDT]||nTgcMeas[1]<nMeasCutTgcStrip[jMDT]){
          segmDisqual = true;
        }
        
        // Apply Direction-Position cuts to segments
        // Get Position and Direction Variables
       // const Trk::GlobalPosition segmGlobalPos  = segm->globalPosition();
        const Amg::Vector3D segmGlobalPos  = segm->globalPosition();
       
        float  segmPosPhi  = segmGlobalPos.phi();
        float  segmPosThe  = segmGlobalPos.theta();
        if(segmPosPhi<0) segmPosPhi+=2*M_PI;
        if(segmPosThe>M_PI/2) segmPosThe=M_PI-segmPosThe;
        //const Trk::GlobalDirection segmGlobalDir = segm->globalDirection();
        const Amg::Vector3D segmGlobalDir = segm->globalDirection();
        
    float  segmDirPhi     = segmGlobalDir.phi();
        float  segmDirThe     = segmGlobalDir.theta();
        if(segmDirPhi<0) segmDirPhi+=2*M_PI;
        if(segmDirThe>M_PI/2) segmDirThe=M_PI-segmDirThe;
        
        // Get Differences between Position and Direction vectors
        float dPhi_Pos_Dir = segmPosPhi-segmDirPhi;
        float dThe_Pos_Dir = segmPosThe-segmDirThe;
        if(dPhi_Pos_Dir<-M_PI)dPhi_Pos_Dir+=2*M_PI;
        if(dPhi_Pos_Dir> M_PI)dPhi_Pos_Dir-=2*M_PI;
        
        if(!segmDisqual){
          if(m_mdt_segmposdirsag[i][jMDT][2]) m_mdt_segmposdirsag[i][jMDT][2]->Fill(dPhi_Pos_Dir);
          if(m_mdt_segmposdirsag[i][jMDT][3]) m_mdt_segmposdirsag[i][jMDT][3]->Fill(dThe_Pos_Dir);
        }
 
        // Cut Segments with too great a difference between position and direction vectors
        if(std::abs(dPhi_Pos_Dir)>dPhiCutPosDir[jMDT]||std::abs(dThe_Pos_Dir)>dTheCutPosDir[jMDT]){
          segmDisqual = true;
        }
          
        // Add disqualified segments to the disqualified list
        if(segmDisqual){
          disqualifiedSegments[i][jMDT].push_back(segm);
        }
        else{
          //HasStationDQSegm[jMDT]=true;// Flag event as having a DQ sufficient segment in the current station
        }
      }// Segments in station
    }// MDT Stations
  }// AC
  
  return;
}// End of function

endOfEventsBlockFlag()

bool ManagedMonitorToolBase::endOfEventsBlockFlag ( ) const

inlineprotectedinherited

Definition at line 795 of file ManagedMonitorToolBase.h.

{ return m_endOfEventsBlock; }

endOfLowStatFlag()

bool ManagedMonitorToolBase::endOfLowStatFlag ( ) const

inlineprotectedinherited

Definition at line 796 of file ManagedMonitorToolBase.h.

{ return m_endOfLowStat; }

endOfLumiBlockFlag()

bool ManagedMonitorToolBase::endOfLumiBlockFlag ( ) const

inlineprotectedinherited

Definition at line 797 of file ManagedMonitorToolBase.h.

{ return m_endOfLumiBlock; }

endOfRunFlag()

bool ManagedMonitorToolBase::endOfRunFlag ( ) const

inlineprotectedinherited

Definition at line 798 of file ManagedMonitorToolBase.h.

{ return m_endOfRun; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

fillHistograms()

StatusCode MdtVsTgcRawDataValAlg::fillHistograms ( const EventContext & ctx )

virtual

An inheriting class should either override this function or fillHists().

Reimplemented from ManagedMonitorToolBase.

Definition at line 154 of file MdtVsTgcRawDataValAlg.cxx.

                                                                       {
/*----------------------------------------------------------------------------------*/
  ATH_MSG_DEBUG( "MdtVsTgcRawDataValAlg::TGC RawData Monitoring Histograms being filled"  );
 
  //TGC PRD
  SG::ReadHandle<Muon::TgcPrepDataContainer> tgc_prd_container(m_tgc_PrepDataContainerName, ctx);
  
  //TGC Coincidence
  SG::ReadHandle<Muon::TgcCoinDataContainer> tgc_coin_container(m_tgc_CoinContainerName, ctx);
 
  ATH_MSG_DEBUG( "size of tgc container is " << tgc_coin_container -> size()  );
  
  //MDT PRD
  SG::ReadHandle<Muon::MdtPrepDataContainer> mdt_prd_container(m_mdt_PrepDataContainerName, ctx);
 
  SG::ReadHandle<xAOD::MuonSegmentContainer> mdt_segment_collection(m_mdt_SegmentCollectionName, ctx) ;
  tgceffcalc(mdt_segment_collection.cptr(), tgc_prd_container.cptr());
  maphists(mdt_segment_collection.cptr(), tgc_prd_container.cptr());
 
  //only analyze nSL==1
  int nSL = numberOfSL(tgc_coin_container.cptr());
 
  if(nSL==1){
    //fill MDT hit vs TGC RoI
    correlation(mdt_prd_container.cptr(), tgc_coin_container.cptr());
  }
 
 
  return StatusCode::SUCCESS;  // statuscode check
} 

fillHists()

StatusCode ManagedMonitorToolBase::fillHists ( const EventContext & ctx )

virtualinherited

Calls fillHists( bool, bool, bool ); if an eventBlock,lumiBlock, or run has turned over, calls procHists( bool, bool, bool ) and bookHists( bool, bool, bool ).

Implements IMonitorToolBase.

Definition at line 740 of file ManagedMonitorToolBase.cxx.

{
 
   if (m_d->m_warnAboutMissingInitialize) {
       m_d->m_warnAboutMissingInitialize = false;
       msg(MSG::WARNING) << "ManagedMonitorToolBase::initialize() never called from reimplementation!" << endmsg;
   }
 
 
   bool isNewEventsBlock = ( m_procNEventsProp > 0  && ((m_nEvents % m_procNEventsProp) == 1) && m_haveClearedLastEventBlock );
   if (isNewEventsBlock) m_haveClearedLastEventBlock = false;
 
   m_newLowStat = false;
   m_newLumiBlock = false;
   m_newRun = false;
   newLowStat = false;
   newLumiBlock = false;
   newRun = false;
 
   m_newLowStatInterval = false;
   m_newMedStatInterval = false;
   m_newHigStatInterval = false;
   newLowStatInterval = false;
   newMedStatInterval = false;
   newHigStatInterval = false;
   
   m_useTrigger = ( (m_triggerChainProp != "" || m_triggerGroupProp != "")  && (!m_trigDecTool.empty()) );
 
   if( m_manager != 0 ) {
     m_newLumiBlock = ( (m_lastLumiBlock != m_manager->lumiBlockNumber()) || m_manager->forkedProcess());
      m_newRun = ( m_lastRun != m_manager->runNumber() );
      newLumiBlock = m_newLumiBlock;
      newRun = m_newRun;
 
      if(m_newRun) {
         m_newLumiBlock = true;
         newLumiBlock = m_newLumiBlock;
         isNewEventsBlock = true;
      }
 
      m_newEventsBlock = isNewEventsBlock;
      newEventsBlock = m_newEventsBlock;
 
      if( m_newLumiBlock ) {
         // check if a new LB interval has started
         // lowest lumiBlockNumber() is 1
         // m_lastLowStatInterval is -1 initially
         int currentLB = m_manager->lumiBlockNumber();
         int LBsLowStat = m_manager->getLBsLowStat();
         int LBsMedStat = m_manager->getLBsMedStat();
         int LBsHigStat = m_manager->getLBsHigStat();
 
         if( LBsLowStat*LBsMedStat*LBsHigStat == 0) {
            msg(MSG::WARNING) << "zero LBs requested for interval" << endmsg;
         }
         else {
            if( ((currentLB-1)/LBsLowStat) != m_lastLowStatInterval ) m_newLowStatInterval = true;
            if( ((currentLB-1)/LBsMedStat) != m_lastMedStatInterval ) m_newMedStatInterval = true;
            if( ((currentLB-1)/LBsHigStat) != m_lastHigStatInterval ) m_newHigStatInterval = true;
            newLowStatInterval = m_newLowStatInterval;
            newMedStatInterval = m_newHigStatInterval;
            newHigStatInterval = m_newHigStatInterval;
         }
      }
 
      // Allow inheriting classes the option of using the lastLumiBloc/lastRun values
      // before updating them
   }
 
 
   StatusCode sc0( StatusCode::SUCCESS );
   StatusCode sc1( StatusCode::SUCCESS );
   StatusCode sc2( StatusCode::SUCCESS );
   StatusCode sc3( StatusCode::SUCCESS );
 
   // Set end of LowStat, LumiBlock and Run variables
   // These are needed to be used in procHistograms().
   m_endOfEventsBlock = m_newEventsBlock;
   m_endOfLowStat = m_newLowStatInterval;
   m_endOfLumiBlock = m_newLumiBlock;
   m_endOfRun = m_newRun;
   endOfEventsBlock = m_newEventsBlock;
   endOfLowStat = m_newLowStatInterval;
   endOfLumiBlock = m_newLumiBlock;
   endOfRun = m_newRun;
 
   // just duplicates m_newLowStatInterval
   m_newLowStat = m_newLowStatInterval; 
   newLowStat = m_newLowStatInterval; 
 
   if( m_newEventsBlock || m_newLumiBlock || m_newRun ) {
     ATH_MSG_DEBUG("Interval transition processing");
      // Process histograms from the previous lumiBlock/run
      if( m_nEvents != 1 ) {
         m_d->benchPreProcHistograms();
         sc0 = procHistograms();
         m_d->benchPostProcHistograms();
      }
      // Re-book new histograms
      m_d->benchPreBookHistograms();
 
      if (!m_bookHistogramsInitial) {
          sc1 = bookHistograms();
          m_bookHistogramsInitial = true;
      } else {
          std::vector<Interval_t> intervals_to_process;
          if (m_newEventsBlock) intervals_to_process.push_back(eventsBlock);
          if (m_newLumiBlock) intervals_to_process.push_back(lumiBlock);
          if (m_newLowStatInterval) intervals_to_process.push_back(lowStat);
          if (m_newRun) intervals_to_process.push_back(run);
          for (const auto interval: intervals_to_process) {
            sc1 = regManagedHistograms(m_templateHistograms[interval]);     
            sc1 = regManagedGraphs(m_templateGraphs[interval]);
            sc1 = regManagedTrees(m_templateTrees[interval]);
          }
      }
      for (const auto& interval: std::vector<Interval_t>{ eventsBlock, lumiBlock, lowStat, run }) {
    for (const auto& it: m_templateHistograms[interval]) {
      // is histogram too small in x axis for LB range?
      if (it.m_group.histo_mgmt() == ATTRIB_X_VS_LB) {
        //ATH_MSG_WARNING("We are rebinning for " << it.m_templateHist->GetName());
        while ( it.m_templateHist->GetXaxis()->GetXmax() <= AthenaMonManager::lumiBlockNumber() ) {
          it.m_templateHist->LabelsInflate("X");
        }
      }
    }
        for (auto& it: m_templateEfficiencies[interval]) {
      if (it.m_group.histo_mgmt() == ATTRIB_X_VS_LB) {
        // get the underlying passed and total TH1's from the TEfficiency
        TH1* passedHist = it.m_templateHist->GetCopyPassedHisto();
        TH1* totalHist = it.m_templateHist->GetCopyTotalHisto();
        // inflate them until they exceed the lumi-block number
        while (passedHist->GetXaxis()->GetXmax() <= AthenaMonManager::lumiBlockNumber() ) {
          passedHist->LabelsInflate("X");
          totalHist->LabelsInflate("X");
              }
        // Replace them in the TEfficiency. First one has force ("f") option, since the 
        // histograms will not be consistent. This is corrected in the next line, so we
        // do check for consistency then.
        it.m_templateHist->SetPassedHistogram(*passedHist, "f");
        it.m_templateHist->SetTotalHistogram(*totalHist, " ");
        delete passedHist; // not owned by THistSvc, so need to be deleted.
        delete totalHist;
      }
        }
      }
 
      if (auto streamname = dynamic_cast<OfflineStream*>(streamNameFunction())) {
    streamname->updateRunLB();
      }
      
      sc3 = bookHistogramsRecurrent( );
      
      m_d->benchPostBookHistograms();
 
   }//end if new RUN/LB/Block
 
   // check filters
   bool filterresult(true);
   if (! m_DQFilterTools.empty()) {
     ToolHandleArray<IDQFilterTool>::const_iterator ifilter(m_DQFilterTools.begin()), filterend(m_DQFilterTools.end());
     for (; filterresult && (ifilter != filterend);
      ++ifilter) {
       filterresult = (filterresult && (*ifilter)->accept(ctx));
     }
   }
   
 
   // ...and fill as normal
   if(filterresult &&
      (!m_useTrigger
       || (m_vTrigChainNames.size()>0 && trigChainsArePassed(m_vTrigChainNames))
       || (m_vTrigGroupNames.size()>0 && trigChainsArePassed(m_vTrigGroupNames))) ) {
     ATH_MSG_DEBUG("Passed trigger, presumably");
      m_d->benchPreFillHistograms();
      fillHistograms(ctx).ignore();
      m_haveClearedLastEventBlock = true;
      m_d->benchPostFillHistograms();
      ++m_nEvents;
   } else { ATH_MSG_DEBUG("Failed trigger, presumably"); }
 
   ++m_nEventsIgnoreTrigger;
   if( m_newLumiBlock && (m_nEventsIgnoreTrigger != 1) ) {
      ++m_nLumiBlocks;
   }
   if( m_manager != 0 ) {
      m_lastRun = m_manager->runNumber();
      if( m_newLumiBlock ) {
         m_lastLumiBlock = m_manager->lumiBlockNumber();
 
         int LBsLowStat = m_manager->getLBsLowStat();
         int LBsMedStat = m_manager->getLBsMedStat();
         int LBsHigStat = m_manager->getLBsHigStat();
         if( LBsLowStat*LBsMedStat*LBsHigStat > 0) {
            if( m_newLowStatInterval ) m_lastLowStatInterval = (m_lastLumiBlock-1)/LBsLowStat;
            if( m_newMedStatInterval ) m_lastMedStatInterval = (m_lastLumiBlock-1)/LBsMedStat;
            if( m_newHigStatInterval ) m_lastHigStatInterval = (m_lastLumiBlock-1)/LBsHigStat;
         }
      }
   }
 
   return StatusCode::SUCCESS;
}

finalHists()

StatusCode ManagedMonitorToolBase::finalHists ( )

virtualinherited

Calls procHists( true, true, true ).

Implements IMonitorToolBase.

Definition at line 1255 of file ManagedMonitorToolBase.cxx.

{
 
   // This assumes that the end of a file will naturally end a run, which is not always true.
   // A merging application run afterwards should be able to put parts of a run together.
   if( m_nEvents != 1 ) {
     m_d->benchPreProcHistograms();
 
     // Set end flags for the LowStat, LumiBlock and Run variables.
     // This is needed to be used in the procHistograms method below.
     m_endOfEventsBlock = true;
     m_endOfLowStat = true;
     m_endOfLumiBlock = true;
     m_endOfRun = true;
     endOfEventsBlock = true;
     endOfLowStat = true;
     endOfLumiBlock = true;
     endOfRun = true;
 
     StatusCode sc = procHistograms();
 
     m_d->benchPostProcHistograms();
     return sc;
   }
   return StatusCode::SUCCESS;
}

get_nEvents()

unsigned int ManagedMonitorToolBase::get_nEvents ( ) const

inlineprotectedinherited

Definition at line 693 of file ManagedMonitorToolBase.h.

                                              {
          return m_nEvents; 
      }

get_procNEventsProp()

long ManagedMonitorToolBase::get_procNEventsProp ( ) const

inlineprotectedinherited

Definition at line 697 of file ManagedMonitorToolBase.h.

                                              {
          return m_procNEventsProp;
      }

getHist() [1/4]

StatusCode ManagedMonitorToolBase::getHist ( TH1 *& h, const std::string & hName, const MonGroup & group )

virtualinherited

Returns a TH1 via the pointer passed as the first argument.

The histogram name, without the leading path or stream name, must be given as the second argument.

Definition at line 1418 of file ManagedMonitorToolBase.cxx.

{
   std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
   return m_THistSvc->getHist( streamName, h );
}

getHist() [2/4]

StatusCode ManagedMonitorToolBase::getHist ( TH1 *& h, const std::string & hName, const std::string & system, Interval_t interval )

virtualinherited

Returns a TH1 via the pointer passed as the first argument.

The histogram name, without the leading path or stream name, must be given as the second argument.

Definition at line 1408 of file ManagedMonitorToolBase.cxx.

{
   MonGroup group( this, system, interval );
   return getHist( h, hName, group );
}

getHist() [3/4]

StatusCode ManagedMonitorToolBase::getHist ( TH2 *& h, const std::string & hName, const MonGroup & group )

virtualinherited

Returns a TH2 via the pointer passed as the first argument.

The histogram name, without the leading path or stream name, must be given as the second argument.

Definition at line 1437 of file ManagedMonitorToolBase.cxx.

{
   std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
   return m_THistSvc->getHist( streamName, h );
}

getHist() [4/4]

StatusCode ManagedMonitorToolBase::getHist ( TH2 *& h, const std::string & hName, const std::string & system, Interval_t interval )

virtualinherited

Returns a TH2 via the pointer passed as the first argument.

The histogram name, without the leading path or stream name, must be given as the second argument.

Definition at line 1427 of file ManagedMonitorToolBase.cxx.

{
   MonGroup group( this, system, interval );
   return getHist( h, hName, group );
}

getNewStreamNameFcn()

ManagedMonitorToolBase::StreamNameFcn * ManagedMonitorToolBase::getNewStreamNameFcn ( ) const

protectedvirtualinherited

Definition at line 2156 of file ManagedMonitorToolBase.cxx.

{
   StreamNameFcn* fcn(0);
 
   switch( m_environment ) {
      case AthenaMonManager::noOutput:
         fcn = new NoOutputStream();
         break;
      case AthenaMonManager::online:
         fcn = new OnlineStream();
         break;
      case AthenaMonManager::user:
         fcn = new DefaultStream( m_fileKey );
         break;
      case AthenaMonManager::tier0:
      case AthenaMonManager::tier0Raw:
      case AthenaMonManager::tier0ESD:
      case AthenaMonManager::AOD:
      case AthenaMonManager::altprod:
      default:
         fcn = new OfflineStream( m_fileKey, m_dataType, m_environment );
   }
 
   return fcn;
}

getStationMapIndex()

int MdtVsTgcRawDataValAlg::getStationMapIndex ( int x, int l, int stationFE, int stationEta, int stationPhi )

private

Definition at line 258 of file MdtVsTgcRawData_TGCEffCheck.cxx.

                                                                                                    {
  // Display error messages if invalid TRE variables are passed in
  if((stationFE!=0)&&(stationFE!=1)) ATH_MSG_WARNING( "getStationMapIndex passed invalid stationFE=" << stationFE  );
  if((l<0)||(l>8)) ATH_MSG_WARNING( "getStationMapIndex passed invalid layer index l=" << l  );
  if(stationEta<1) ATH_MSG_WARNING( "getStationMapIndex passed invalid stationEta=" << stationEta  );
  if(stationPhi<1) ATH_MSG_WARNING( "getStationMapIndex passed invalid stationPhi=" << stationPhi  );
  int index=0;
  switch(x){
   case 1:// Getting Eta Index //use old eta bin
    if(l==0||l==1||l==2){// T1
      if(stationEta>4) ATH_MSG_WARNING( "getStationMapIndex(" << x << ") passed invalid l=" << l << " stationEta=" << stationEta  );
      if(stationFE==0)index=32+l;
      else{ 
        index=4-stationEta;
        index=index*7+l;
            }
    }
    else if(l==3||l==4){// T2
      if(stationEta>5) ATH_MSG_WARNING( "getStationMapIndex(" << x << ") passed invalid l=" << l << " stationEta=" << stationEta  );
      if(stationFE==0)index=32+l;
      else {
        index=5-stationEta;
        index=index*7+l;
        if(stationEta==1)index=25+l;
      }
    }
    else if(l==5||l==6){// T3
      if(stationEta>5) ATH_MSG_WARNING( "getStationMapIndex(" << x << ") passed invalid l=" << l << " stationEta=" << stationEta  );
      if(stationFE==0)index=32+l;
      else{
        index=5-stationEta;
        index=index*7+l;
        if(stationEta==1)index=25+l;
      }
    }
    else if(l==7||l==8){// T4
      if(stationEta>1) ATH_MSG_WARNING( "getStationMapIndex(" << x << ") passed invalid l=" << l << " stationEta=" << stationEta  );
      if(stationFE==0){
        if(l==7){index=41;}
        else if(l==8){index=42;}
      }else{
        if(l==7){index=39;}
        else if(l==8){index=40;}
      }
    }
    break;
  case 2:// Getting Phi Index
    if(stationFE==0){// Forward
      if((l==7)||(l==8)){// FI
        if(stationPhi>24) ATH_MSG_WARNING( "getStationMapIndex(" << x << ") passed invalid l=" << l << " FE=" << stationFE << " stationPhi=" << stationPhi  );
        index=(stationPhi-1)*2;
      }
      else{// Forward Midstation
        if(stationPhi>24) ATH_MSG_WARNING( "getStationMapIndex(" << x << ") passed invalid l=" << l << " FE=" << stationFE << " stationPhi=" << stationPhi  );
        index=(stationPhi-1)*2;
      }
    }
    else{// Endcap
      if((l==7)||(l==8)){// EI
        if(stationPhi>21) ATH_MSG_WARNING( "getStationMapIndex(" << x << ") passed invalid l=" << l << " FE=" << stationFE << " stationPhi=" << stationPhi  );
        index=(stationPhi-1);
        if(index>7)index++;
        if(index>15)index++;
        if(index>19)index++;
        index*=2;
      }
      else{// Endcap Midstation
        if(stationPhi>48) ATH_MSG_WARNING( "getStationMapIndex(" << x << ") passed invalid l=" << l << " FE=" << stationFE << " stationPhi=" << stationPhi  );
        index=stationPhi-1;
      }
    }
    // Adjust to set A01phi0(stationPhi=47 for Midstation)at 0
    index+=2;
    if(index>47)index-=48;
    break;
  default:
    ATH_MSG_WARNING( "getStationMapIndex(" << x << ") is invalid"  );
    break;
  }
  return index;
}// End of function

initialize()

StatusCode MdtVsTgcRawDataValAlg::initialize ( )

virtual

Reimplemented from ManagedMonitorToolBase.

Definition at line 97 of file MdtVsTgcRawDataValAlg.cxx.

                                 {
  ATH_CHECK(ManagedMonitorToolBase::initialize());
  ATH_MSG_INFO( "in initializing MdtVsTgcRawDataValAlg"  );
  // MuonDetectorManager from the conditions store
  ATH_CHECK(m_DetectorManagerKey.initialize());
  ATH_CHECK(m_idHelperSvc.retrieve());
 
  //MDT z position
  //Name MultiLayer TubeLayer z
  //17 1 1 14142.5
  //17 1 2 14168.5
  //17 1 3 14194.5
  //17 2 1 14394.6
  //17 2 2 14420.6
  //17 2 3 14446.6
  //18 1 1 13726.5
  //18 1 2 13752.5
  //18 1 3 13778.5
  //18 2 1 13978.6
  //18 2 2 14004.6
  //18 2 3 14030.6
 
  // Retrieve the MuonDetectorManager
  const MuonGM::MuonDetectorManager* MuonDetMgrDS=nullptr;
  ATH_CHECK( detStore()->retrieve(MuonDetMgrDS) );
  ATH_MSG_DEBUG( " Found the MuonDetectorManager from detector store. "  );
  prepareTREarray(MuonDetMgrDS);
  ATH_CHECK(m_tgc_PrepDataContainerName.initialize());
  ATH_CHECK(m_tgc_CoinContainerName.initialize());
  ATH_CHECK(m_mdt_PrepDataContainerName.initialize());
  ATH_CHECK(m_mdt_SegmentCollectionName.initialize());
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & IMonitorToolBase::interfaceID ( )

inlinestaticinherited

Definition at line 30 of file IMonitorToolBase.h.

{ return IID_IMonitorToolBase; }

intervalEnumToString()

std::string ManagedMonitorToolBase::intervalEnumToString ( Interval_t interval )

staticinherited

Converts a LevelOfDetail_t to a string of the same name.

Converts a string to the corresponding LevelOfDetail_t. Converts a Interval_t to a string of the same name.

Definition at line 536 of file ManagedMonitorToolBase.cxx.

{
   std::string str("file");
 
   switch( interval ) {
      case all:
         str = "all";
         break;
      case fill:
         str = "fill";
         break;
      case run:
         str = "run";
         break;
      case lowStat:
         str = "lowStat";
         break;
      case medStat:
         str = "medStat";
         break;
      case higStat:
         str = "higStat";
         break;
      case lumiBlock:
         str = "lumiBlock";
         break;
      case eventsBlock:
         str = "eventsBlock";
         break;
      case file:
     str = "file";
     break;
      default:
         str = "unknown";
   }
 
   return str;
}

intervalStringToEnum()

ManagedMonitorToolBase::Interval_t ManagedMonitorToolBase::intervalStringToEnum ( const std::string & str )

staticinherited

Converts a string to the corresponding Interval_t.

Definition at line 578 of file ManagedMonitorToolBase.cxx.

{
   std::string lcstr( strToLower(str) );
 
   if( lcstr == "all" )
      return all;
   else if( lcstr == "fill" )
      return fill;
   else if( lcstr == "run" )
      return run;
   else if( lcstr == "lowStat" )
      return lowStat;
   else if( lcstr == "medStat" )
      return medStat;
   else if( lcstr == "higStat" )
      return higStat;
   else if( lcstr == "lumiBlock" )
      return lumiBlock;
   else if( lcstr == "eventsBlock" )
      return eventsBlock;
   else if( lcstr == "file" )
      return file;
 
   if( Imp::s_svcLocator ) {
      SmartIF<IMessageSvc> ms{Imp::s_svcLocator.load()->service( "MessageSvc" )};
      if( ms.isValid() ) {
         MsgStream log( ms, "ManagedMonitorToolBase::intervalStringToEnum()" );
         log << MSG::WARNING << "Unknown ManagedMonitorToolBase::Interval_t \""
            << str << "\", returning \"file\"" << endmsg;
      }
   }
 
   return file;
}

labelStationMap()

void MdtVsTgcRawDataValAlg::labelStationMap ( TH2 * h2, int i = -1, int k = -1 )

private

Definition at line 397 of file MdtVsTgcRawData_bookhistograms.cxx.

                                                             {
  // Blank non-existent chambers
  BlankStationMap(h2,ws);
  
  std::stringstream sst;
  std::string AC[2]={"A","C"};
  int nChambers[9]={5,5,5,6,6,6,6,2,2};
  std::string chamber1[6]={"E1", "E2", "E3", "E4", "F"};
  std::string chamber3[6]={"E1", "E2", "E3", "E4", "E5", "F"};
  std::string chamberE[2]={"EI", "FI"};
  
  bool rebin=true;
  // Name StationEtas/Layers
  int ibin=1;
  if(rebin){//use new bin
    for(int l=0 ; l<9 ; l++ ){// Layer
      //cppcheck-suppress negativeIndex
      for( int c=0 ; c<nChambers[l] ; c++ ){// Chamber
        sst << "L" << l+1 << "_";
        if(nChambers[l]==5)sst<<chamber1[c];
        else if(nChambers[l]==6)sst<<chamber3[c];
        else if(nChambers[l]==2)sst<<chamberE[c];
          if(l+1>0 && l+1<=3 && c+1<5)ibin=7*c+(l+1);
          else if(l+1>3 && l+1<=7 && c+1<5)ibin=7*c+(l+1);
          else if(l+1>3 && l+1<=7 && c+1==5)ibin=25+(l+1);
          else if(l+1==1 && c+1==5)ibin=33;
          else if(l+1==2 && c+1==5)ibin=34;
          else if(l+1==3 && c+1==5)ibin=35;
          else if(l+1==4 && c+1==6)ibin=36;
          else if(l+1==5 && c+1==6)ibin=37;
          else if(l+1==6 && c+1==6)ibin=38;
          else if(l+1==7 && c+1==6)ibin=39;
          else if(l+1==8 && c+1==1)ibin=40;
          else if(l+1==8 && c+1==2)ibin=42;
          else if(l+1==9 && c+1==1)ibin=41;
          else if(l+1==9 && c+1==2)ibin=43;
        h2->GetXaxis()->SetBinLabel(ibin, sst.str().c_str()); 
        h2->GetXaxis()->SetBit(TAxis::kLabelsVert);
        sst.str(""); 
      }// Chamber 
    }// Layer
  }else{//use old bin   logically dead code, comment out
//    for(int l=0 ; l<9 ; l++ ){// Layer
//      for( int c=0 ; c<nChambers[l] ; c++ ){// Chamber
//        sst << "L" << l+1 << "_";
//        if(nChambers[l]==5)sst<<chamber1[c];
//        else if(nChambers[l]==6)sst<<chamber3[c];
//        else if(nChambers[l]==2)sst<<chamberE[c];
//        h2->GetXaxis()->SetBinLabel(ibin, sst.str().c_str()); 
//        sst.str(""); ibin++;
//      }// Chamber
//    }// Layer
//    h2->GetXaxis()->LabelsOption("v");
  }
  // Name Phi Sectors
  for(int isec=1;isec<=12;isec++){// Sector
    for(int iphi=0;iphi<=3;iphi+=4){// Phi number
      if(ac==0||ac==1)sst << AC[ac];
      if(isec<10)sst << "0";
      sst << isec << "phi" << iphi;
      ibin=(isec-1)*4+iphi+1;
      h2->GetYaxis()->SetBinLabel(ibin, sst.str().c_str()); 
      sst.str("");
    }// Phi number
  }// Sector
}// End of function

lbAverageInteractionsPerCrossing()

float ManagedMonitorToolBase::lbAverageInteractionsPerCrossing ( const EventContext & ctx ) const

virtualinherited

Average mu, i.e.

<mu>

Definition at line 1692 of file ManagedMonitorToolBase.cxx.

{
    if (!m_lumiDataKey.empty()) {
        SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
        return lumi->lbAverageInteractionsPerCrossing();
    } else {
        //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageInteractionsPerCrossing() can't work properly! ");
        ATH_MSG_DEBUG("Warning: lbAverageInteractionsPerCrossing() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
        return -1.0;
    }
    // not reached
}

lbAverageLivefraction()

float ManagedMonitorToolBase::lbAverageLivefraction ( const EventContext & ctx ) const

virtualinherited

Average luminosity livefraction.

Definition at line 1761 of file ManagedMonitorToolBase.cxx.

{
    if (m_environment == AthenaMonManager::online)
        return 1.0;
 
    if (!m_trigLiveFractionDataKey.empty()) {
        SG::ReadCondHandle<TrigLiveFractionCondData> live (m_trigLiveFractionDataKey, ctx);
        return live->lbAverageLiveFraction();
    } else {
        //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageLivefraction() can't work properly! ");
        ATH_MSG_DEBUG("Warning: lbAverageLivefraction() - luminosity not availble (i.e. EnableLumi = False)");
        return -1.0;
    }
    // not reached
}

lbAverageLuminosity()

float ManagedMonitorToolBase::lbAverageLuminosity ( const EventContext & ctx ) const

virtualinherited

Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1).

Definition at line 1728 of file ManagedMonitorToolBase.cxx.

{
    if (!m_lumiDataKey.empty()) {
        SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
        return lumi->lbAverageLuminosity();
    } else {
        //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageLuminosity() can't work properly! ");
        ATH_MSG_DEBUG("Warning: lbAverageLuminosity() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
        return -1.0;
    }
    // not reached
}

lbDuration()

double ManagedMonitorToolBase::lbDuration ( const EventContext & ctx ) const

virtualinherited

Luminosity block time (in seconds).

Definition at line 1815 of file ManagedMonitorToolBase.cxx.

{
    if ( m_environment == AthenaMonManager::online ) {
        return m_defaultLBDuration;
    }
    if (!m_lbDurationDataKey.empty()) {
        SG::ReadCondHandle<LBDurationCondData> dur (m_lbDurationDataKey, ctx);
        return dur->lbDuration();
    } else {
        //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbDuration() can't work properly! ");
        ATH_MSG_DEBUG("Warning: lbDuration() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
        return m_defaultLBDuration;
    }
    // not reached
}

lbInteractionsPerCrossing()

float ManagedMonitorToolBase::lbInteractionsPerCrossing ( const EventContext & ctx ) const

virtualinherited

Instantaneous number of interactions, i.e.

mu

Definition at line 1708 of file ManagedMonitorToolBase.cxx.

{
    if (!m_lumiDataKey.empty()) {
        SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
        float muToLumi = lumi->muToLumi();
        if (muToLumi > 0) {
          return lumi->lbLuminosityPerBCIDVector().at (ctx.eventID().bunch_crossing_id()) / muToLumi;
        }
        return 0;
    } else {
        //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbInteractionsPerCrossing() can't work properly! ");
        ATH_MSG_DEBUG("Warning: lbInteractionsPerCrossing() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
        return -1.0;
    }
    // not reached
}

lbLuminosityPerBCID()

float ManagedMonitorToolBase::lbLuminosityPerBCID ( const EventContext & ctx ) const

virtualinherited

Instantaneous luminosity.

Definition at line 1744 of file ManagedMonitorToolBase.cxx.

{
    if (!m_lumiDataKey.empty()) {
        SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
        return lumi->lbLuminosityPerBCIDVector().at (ctx.eventID().bunch_crossing_id());
    } else {
        //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbLuminosityPerBCID() can't work properly! ");
        ATH_MSG_DEBUG("Warning: lbLuminosityPerBCID() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
        return -1.0;
    }
    // not reached
}

lbLumiWeight()

double ManagedMonitorToolBase::lbLumiWeight ( const EventContext & ctx ) const

virtualinherited

Average Integrated Luminosity Live Fraction.

Definition at line 1799 of file ManagedMonitorToolBase.cxx.

{
    if (!m_lumiDataKey.empty()) {
        return (lbAverageLuminosity(ctx)*lbDuration(ctx))*lbAverageLivefraction(ctx);
    } else{
        //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbLumiWeight() can't work properly! ");
        ATH_MSG_DEBUG("Warning: lbLumiWeight() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
        return -1.0;
    }
    // not reached
}

livefractionPerBCID()

float ManagedMonitorToolBase::livefractionPerBCID ( const EventContext & ctx ) const

virtualinherited

Livefraction per bunch crossing ID.

Definition at line 1780 of file ManagedMonitorToolBase.cxx.

{
    if (m_environment == AthenaMonManager::online)
        return 1.0;
 
    if (!m_trigLiveFractionDataKey.empty()) {
        SG::ReadCondHandle<TrigLiveFractionCondData> live (m_trigLiveFractionDataKey, ctx);
        return live->l1LiveFractionVector().at (ctx.eventID().bunch_crossing_id());
    } else {
        //ATH_MSG_FATAL("! Luminosity tool has been disabled ! livefractionPerBCID() can't work properly! ");
        ATH_MSG_DEBUG("Warning: livefractionPerBCID() - luminosity retrieved available (i.e. EnableLumi = False)");
        return -1.0;
    }
    // not reached
}

maphists()

void MdtVsTgcRawDataValAlg::maphists ( const xAOD::MuonSegmentContainer * m_newsegment, const Muon::TgcPrepDataContainer * tgc_prepcontainer )

private

Definition at line 36 of file MdtVsTgcRawData_maptgchits.cxx.

                                                                                  {//use new mdt segment
  ATH_MSG_DEBUG("inside maptgchits" );
  
  // loop over MDT Segment Collection
  xAOD::MuonSegmentContainer::const_iterator mdtseg_itr = newsegment->begin();
  xAOD::MuonSegmentContainer::const_iterator mdtseg_end = newsegment->end();
  for(; mdtseg_itr!=mdtseg_end; ++mdtseg_itr){
    if(!(*mdtseg_itr)->muonSegment().isValid())continue;
    // Get segm
    const Muon::MuonSegment* segm = dynamic_cast<const Muon::MuonSegment*>(*(*mdtseg_itr)->muonSegment());
    if (segm == nullptr) {
      ATH_MSG_ERROR( "no pointer to segm!!!" );
      break;
    }
    // Initialize variables
    int stationName=0;
    int nMdtMeas[4] = {0,0,0,0};
    bool isMdt=false, isEndcap=false;
    
    // Loop through contained ROTs and count used MDT and TGC stations
    for(unsigned int i=0;i<segm->numberOfContainedROTs();++i){
      // Get station information
      const Trk::RIO_OnTrack* rio = segm->rioOnTrack(i);
      if(!rio) continue;
      Identifier id = rio->identify();
      stationName = int(m_idHelperSvc->mdtIdHelper().stationName(id));
      // Flag Segments with ROTs in the MDT & Endcap
      if(m_idHelperSvc->isMdt(id))isMdt=true;
      if(m_idHelperSvc->isEndcap(id))isEndcap=true;
      // If ROT is MDT
      if((stationName==13)||(stationName==49)){nMdtMeas[0]++;}
      if((stationName==14)||(stationName==15)){nMdtMeas[1]++;}
      if((stationName==17)||(stationName==18)){nMdtMeas[2]++;}
      if((stationName==20)||(stationName==21)){nMdtMeas[3]++;}
    }
    if(!isMdt)continue;
    if(!isEndcap)continue;
 
    // Establish which MDT stations the Segment is in
    int nStations = 0;
    for(int jMDT=0;jMDT<4;jMDT++){
      if(nMdtMeas[jMDT]){
        nStations++;
      }
    }
    // Check that the Segment only occupies one Station
    if(nStations!=1)continue;
 
    // Get Position pointer and segmAC index
    const Amg::Vector3D segmGlobalPos = segm->globalPosition();
    int segmAC = (segmGlobalPos.z()<0);// a:0, c:1
 
    // Fill MDT data
    for(int jMDT=0;jMDT<4;jMDT++){// jMDT
      if(nMdtMeas[jMDT]){// If hits in this Station
        // Get position variables
        float  segmGlobalEta  = std::abs(segmGlobalPos.eta());
        float  segmGlobalPhi  = segmGlobalPos.phi();
        if(segmGlobalPhi<0) segmGlobalPhi+=2*M_PI;
        // Fill position histogram
        m_mdt_segmmap[segmAC][jMDT]->Fill(segmGlobalPhi, segmGlobalEta);
      }// If hits in Station
    }// jMDT
  }// MDT Segment Collection
  
  //loop over TGC Prep Data container
  Muon::TgcPrepDataContainer::const_iterator tgc_it_end=tgc_prepcontainer->end();
  for( Muon::TgcPrepDataContainer::const_iterator tgc_it=tgc_prepcontainer->begin();
       tgc_it!=tgc_it_end;
       ++tgc_it){
    
    //loop over TGC Prep Data collection
    Muon::TgcPrepDataCollection::const_iterator tgc_itc_end=(*tgc_it)->end();
    for( Muon::TgcPrepDataCollection::const_iterator tgc_itc=(*tgc_it)->begin();
         tgc_itc!= tgc_itc_end;
         ++tgc_itc){
      const Muon::TgcPrepData* tpd=*tgc_itc;
      
      // Get detector information
      const MuonGM::TgcReadoutElement *tre = tpd->detectorElement();
      const std::string tgcStationType = tre->getStationType();
      
      // Get detector variables
      Identifier tgcid=(*tgc_itc)->identify();
      int tgcStationName = m_idHelperSvc->tgcIdHelper().stationName(tgcid);
      
      // Get position variables
      const Amg::Vector3D tgcGlobalPos  = tpd->globalPosition();
      float tgcGlobalPhi = tgcGlobalPos.phi();
      if(tgcGlobalPhi<0)tgcGlobalPhi+=2*M_PI;
      
      // Cut non-TGC-Endcap
      if(tgcStationName<41 || tgcStationName>48)continue;
    }// TGC PRD Collection
  }// TGC PRD Container
  
  return;
}// End of function

maphistsfinalize()

void MdtVsTgcRawDataValAlg::maphistsfinalize ( )

private

Definition at line 139 of file MdtVsTgcRawData_maptgchits.cxx.

                                            {
  
}// End of function

MatchMDTSegments()

void MdtVsTgcRawDataValAlg::MatchMDTSegments ( std::vector< const Muon::MuonSegment * >(&) sortedSegments[2][4], std::vector< const Muon::MuonSegment * >(&) disqualifiedSegments[2][4], std::vector< SegmTrack >(&) matchedSegments[2] )

private

Definition at line 32 of file MdtVsTgcRawData_SegmMatching.cxx.

                                                                                   {// Define Cuts:
  // Cut for matching Segments
  const float dRhoCutSegmentMatching = 1000;
  const float dPhiCutSegmentMatching = M_PI/8;
  const float dPhiCutSegmentDirectionChecking[4][4]={{     0,M_PI/8,   0.1,  0.01},
                                                     {M_PI/8,     0,M_PI/8,M_PI/8},
                                                     {  0.06,M_PI/8,     0,  0.01},
                                                     {  0.05,M_PI/8,  0.05,     0}};
  const float dTheCutSegmentDirectionChecking[4][4]={{     0,M_PI/8,  0.05,  0.06},
                                                     {M_PI/8,     0,M_PI/8,M_PI/8},
                                                     {  0.04,M_PI/8,     0, 0.005},
                                                     {  0.02,M_PI/8, 0.005,     0}};
  // Loop over sides
  for(int i=0;i<2;i++){// AC
    bool skipSegm;int nDisqualifiedSegm; // used when checking the disqualified list for a segment
    //bool HasStationMatchSegm[4] = {false, false, false, false};// flags for whether the there are segments in each MDT station which were included in tracks
    //bool HasMatchedTrack = false;// flag for whether a track was found on current side
    
    for(int jMDT1=3;jMDT1>=0;jMDT1--){// MDT Stations in reverse]
      // Get number of segments
      int nSegm1=sortedSegments[i][jMDT1].size();
      
      // Loop over Segments in Station
      for(int n1=0; n1<nSegm1;n1++){
        // Get segment
        const Muon::MuonSegment *segm1 = sortedSegments[i][jMDT1].at(n1);
        
        // Check disqualifiedSegments for current segment
        skipSegm=false;
        nDisqualifiedSegm=disqualifiedSegments[i][jMDT1].size();
        for(int ndis=0;ndis<nDisqualifiedSegm;ndis++)if(segm1==disqualifiedSegments[i][jMDT1].at(ndis))skipSegm=true;
        if(skipSegm)continue;
        
        // Get position variables
        const Amg::Vector3D segm1Pos = segm1->globalPosition();
        
        float segm1PosPhi = segm1Pos.phi();
        float segm1PosZ   = segm1Pos.z();
        if(segm1PosPhi<0)segm1PosPhi+=2*M_PI;
        Amg::Vector3D segm1PosZunit(segm1Pos/std::abs(segm1PosZ));
        Amg::Vector3D segm1Dir = segm1->globalDirection();
        
    float segm1DirThe = segm1Dir.theta();
        float segm1DirPhi = segm1Dir.phi();
        if(segm1DirThe>M_PI/2) segm1DirThe=M_PI-segm1DirThe;
        if(segm1DirPhi<0) segm1DirPhi+=2*M_PI;
        
        // Initialise segment matching variables
        bool stationMatchFound[4] = {false,false,false,false};
        std::vector<const Muon::MuonSegment*> matchingSegments[4];
        for(int jMDT2=0;jMDT2<4;jMDT2++)matchingSegments[jMDT2] = std::vector<const Muon::MuonSegment*>();
        matchingSegments[jMDT1].push_back(segm1);
        int nStationMatch=0;
        
        for(int jMDT2=3;jMDT2>=0;jMDT2--){// MDT Station in reverse
          // Get number of segments
          int nSegm2=sortedSegments[i][jMDT2].size();
 
          // Loop over Segments in Station
          for(int n2=0; n2<nSegm2;n2++){
            // Get segment
            const Muon::MuonSegment *segm2 = sortedSegments[i][jMDT2].at(n2);
            if(segm1==segm2)continue; //do not compare same segments
            
            // Check disqualifiedSegments for current segment
            skipSegm = false;
            nDisqualifiedSegm=disqualifiedSegments[i][jMDT2].size();
            for(int ndis=0;ndis<nDisqualifiedSegm;ndis++)if(segm1==disqualifiedSegments[i][jMDT2].at(ndis))skipSegm=true;
            if(skipSegm)continue;
            
            // Position Cut
            // Fill position variables
            const Amg::Vector3D segm2Pos = segm2->globalPosition();
           
        float segm2PosRho = std::abs(segm2Pos.perp());
            float segm2PosPhi = segm2Pos.phi();
            float segm2PosThe = segm2Pos.theta();
            float segm2PosZ   = segm2Pos.z();
            if(segm2PosThe>M_PI/2) segm2PosThe=M_PI-segm2PosThe;
            if(segm2PosPhi<0)segm2PosPhi+=2*M_PI;
            Amg::Vector3D segm2PosZunit(segm2Pos/std::abs(segm2PosZ));
            
            // Apply preliminary phi cut between segm1 and segm2 positions
            float dPhi_Segm1_Segm2 = segm1PosPhi-segm2PosPhi;
            if(dPhi_Segm1_Segm2<-M_PI)dPhi_Segm1_Segm2+=2*M_PI;
            if(dPhi_Segm1_Segm2> M_PI)dPhi_Segm1_Segm2-=2*M_PI;
            if(std::abs(dPhi_Segm1_Segm2)>dPhiCutSegmentMatching)continue;
            
            // Extrapolate segm1 position to segm2's Z position
            float dZ = std::abs(segm2PosZ)-std::abs(segm1PosZ);
            Amg::Vector3D extrPos(segm1Pos+(segm1PosZunit*dZ));
            
        float extrPosRho = std::abs(extrPos.perp());
            float extrPosThe = extrPos.theta();
            float extrPosPhi = extrPos.phi();
            if(extrPosThe>M_PI/2) extrPosThe=M_PI-extrPosThe;
            if(extrPosPhi<0)extrPosPhi+=2*M_PI;
            
            // Get differences between extrapolated and segm2 positions
            float dRho_Extr_Segm2 = extrPosRho-segm2PosRho;
            float dPhi_Extr_Segm2 = extrPosPhi-segm2PosPhi;
            float dThe_Extr_Segm2 = extrPosThe-segm2PosThe;
            if(dPhi_Extr_Segm2<-M_PI)dPhi_Extr_Segm2+=2*M_PI;
            if(dPhi_Extr_Segm2> M_PI)dPhi_Extr_Segm2-=2*M_PI;
            
            // Fill difference histograms
            if(m_mdt_segmmatchsag[i][jMDT1][jMDT2][0]) m_mdt_segmmatchsag[i][jMDT1][jMDT2][0]->Fill(dRho_Extr_Segm2);
            if(m_mdt_segmmatchsag[i][jMDT1][jMDT2][2]) m_mdt_segmmatchsag[i][jMDT1][jMDT2][2]->Fill(dPhi_Extr_Segm2);
            if(m_mdt_segmmatchsag[i][jMDT1][jMDT2][3]) m_mdt_segmmatchsag[i][jMDT1][jMDT2][3]->Fill(dThe_Extr_Segm2);
            
            // Cut segments (segm2) which are outside difference cuts
            if(std::abs(dPhi_Extr_Segm2)>dPhiCutSegmentMatching)continue;
            if(std::abs(dRho_Extr_Segm2)>dRhoCutSegmentMatching)continue;
            
            // Direction Cut
            // Fill direction variables
            //const Trk::GlobalDirection segm2Dir = segm2->globalDirection();
            const Amg::Vector3D segm2Dir = segm2->globalDirection();
            
        float segm2DirThe = segm2Dir.theta();
            float segm2DirPhi = segm2Dir.phi();
            if(segm2DirThe>M_PI/2) segm2DirThe=M_PI-segm2DirThe;
            if(segm2DirPhi<0) segm2DirPhi+=2*M_PI;
            
            // Vector Method
            // Make vector between segment positions
            //Trk::GlobalDirection segmVector;
            Amg::Vector3D segmVector;
            
        if(jMDT2>jMDT1)segmVector = segm2Pos-segm1Pos;
            else           segmVector = segm1Pos-segm2Pos;
            float segmVecThe = segmVector.theta();
            float segmVecPhi = segmVector.phi();
            if(segmVecThe>M_PI/2) segmVecThe=M_PI-segmVecThe;
            if(segmVecPhi<0) segmVecPhi+=2*M_PI;
            
            // Get difference between vector direction and segment directions
            float dThe_Vec_Segm1 = segmVecThe-segm1DirThe;
            float dPhi_Vec_Segm1 = segmVecPhi-segm1DirPhi;
            if(dPhi_Vec_Segm1<-M_PI)dPhi_Vec_Segm1+=2*M_PI;
            if(dPhi_Vec_Segm1> M_PI)dPhi_Vec_Segm1-=2*M_PI;
            float dThe_Vec_Segm2 = segmVecThe-segm2DirThe;
            float dPhi_Vec_Segm2 = segmVecPhi-segm2DirPhi;
            if(dPhi_Vec_Segm2<-M_PI)dPhi_Vec_Segm2+=2*M_PI;
            if(dPhi_Vec_Segm2> M_PI)dPhi_Vec_Segm2-=2*M_PI;
            
            // Fill histograms
            if(jMDT1>jMDT2){
              if(m_mdt_trackchecksag[i][jMDT2][jMDT1][2][0]) m_mdt_trackchecksag[i][jMDT2][jMDT1][2][0]->Fill(dPhi_Vec_Segm2);
              if(m_mdt_trackchecksag[i][jMDT2][jMDT1][3][0]) m_mdt_trackchecksag[i][jMDT2][jMDT1][3][0]->Fill(dThe_Vec_Segm2);
              if(m_mdt_trackchecksag[i][jMDT2][jMDT1][2][1]) m_mdt_trackchecksag[i][jMDT2][jMDT1][2][1]->Fill(dPhi_Vec_Segm1);
              if(m_mdt_trackchecksag[i][jMDT2][jMDT1][3][1]) m_mdt_trackchecksag[i][jMDT2][jMDT1][3][1]->Fill(dThe_Vec_Segm1);
            }
            else if(jMDT1<jMDT2){
              if(m_mdt_trackchecksag[i][jMDT1][jMDT2][2][0]) m_mdt_trackchecksag[i][jMDT1][jMDT2][2][0]->Fill(dPhi_Vec_Segm1);
              if(m_mdt_trackchecksag[i][jMDT1][jMDT2][3][0]) m_mdt_trackchecksag[i][jMDT1][jMDT2][3][0]->Fill(dThe_Vec_Segm1);
              if(m_mdt_trackchecksag[i][jMDT1][jMDT2][2][1]) m_mdt_trackchecksag[i][jMDT1][jMDT2][2][1]->Fill(dPhi_Vec_Segm2);
              if(m_mdt_trackchecksag[i][jMDT1][jMDT2][3][1]) m_mdt_trackchecksag[i][jMDT1][jMDT2][3][1]->Fill(dThe_Vec_Segm2);
            }
            
            // Direction Comparison Method
            float dTheDir_Segm1_Segm2 = segm1DirThe-segm2DirThe;
            float dPhiDir_Segm1_Segm2 = segm1PosPhi-segm2PosPhi;
            if(dPhiDir_Segm1_Segm2<-M_PI)dPhiDir_Segm1_Segm2+=2*M_PI;
            if(dPhiDir_Segm1_Segm2> M_PI)dPhiDir_Segm1_Segm2-=2*M_PI;
            if(m_mdt_trackdirdirsag[i][jMDT1][jMDT2][2]) m_mdt_trackdirdirsag[i][jMDT1][jMDT2][2]->Fill(dTheDir_Segm1_Segm2);
            if(m_mdt_trackdirdirsag[i][jMDT1][jMDT2][3]) m_mdt_trackdirdirsag[i][jMDT1][jMDT2][3]->Fill(dPhiDir_Segm1_Segm2);
            // Cut using Vector Method
            if(dPhi_Vec_Segm1>dPhiCutSegmentDirectionChecking[jMDT1][jMDT2] ||
               dThe_Vec_Segm1>dTheCutSegmentDirectionChecking[jMDT1][jMDT2] ||
               dPhi_Vec_Segm2>dPhiCutSegmentDirectionChecking[jMDT2][jMDT1] ||
               dThe_Vec_Segm2>dTheCutSegmentDirectionChecking[jMDT2][jMDT1]) continue;
            
            // Match is found, increment counter and assign segm2 to match found array
            matchingSegments[jMDT2].push_back(segm2);
          }// nSegms2
          
          if(matchingSegments[jMDT2].size()==1){
            stationMatchFound[jMDT2]=true;
            nStationMatch++;
          }
        }// Reverse MDT Stations2
        
        // If matches found add to matchedSegments and disqualify all segments in array
        if(nStationMatch>1){
          //HasMatchedTrack=true;
          const Muon::MuonSegment *segmArray[4] = {nullptr,nullptr,nullptr,nullptr};
          for(int jMDT2=0;jMDT2<4;jMDT2++){
            if(stationMatchFound[jMDT2]){
              segmArray[jMDT2]=matchingSegments[jMDT2].at(0);
              //HasStationMatchSegm[jMDT2]=true;
              disqualifiedSegments[i][jMDT2].push_back(matchingSegments[jMDT2].at(0));
            }
          }
          SegmTrack newTrack(segmArray);
          matchedSegments[i].push_back(newTrack);
        }// If Matched Track Found
        
      }// nSegms1
    }// Reverse MDT Stations1
    
  }// AC
  
  return;
}// End of function

MidstationOnlyCheck()

void MdtVsTgcRawDataValAlg::MidstationOnlyCheck ( std::vector< const Muon::MuonSegment * >(&) sortedSegments[2][4], std::vector< const Muon::MuonSegment * >(&) disqualifiedSegments[2][4], const Muon::TgcPrepDataContainer * tgc_prepcontainer )

private

Definition at line 33 of file MdtVsTgcRawData_MidstationMatching.cxx.

                                                                                             {
  // Define Cuts:
  // Cut for matching Segments
  const float dRhoCutSegmentMatching = 1000;
  const float dPhiCutSegmentMatching = M_PI/8;
  
  // Cuts for number of Mdt Measurements required for Midstation only track
  const int nMeasCutMdtMidstation = 5;
  const int nMeasCutTGCMidPRD[2]  = {2,2};
  
  // Loose cut for PRD and Extrapolated
  const float dPhiCut_Loose    = M_PI/8;
  // Cut for Global Position  Efficiencies
  const float dPhiCutGlobal[2] = {static_cast<float>(M_PI/24),static_cast<float>(M_PI/12)};//[WireStrip]
  const float dRhoCutGlobal[2] = {   0.08,    0.5};//[WireStrip]
  // Cut for Sector Efficiencies
  const float dPhiCutSector[2] = {    0.2,    0.1};//[WireStrip]
  const float dRhoCutSector[2] = {    300,   3000};//[WireStrip]
  // Cut for TgcPrepData comparison
  const float dPhiCutTPD[2]  = {   0.15,   0.02};//[WireStrip]
  const float dRhoCutTPD[2]  = {    150,   3000};//[WireStrip]
  
  // Loop over sides
  for(int i=0;i<2;i++){// AC
    // Number of Segments found which passed all cuts
    int  nValidatedSegm              = 0;
    
    // Following "Fill" variables are only used if one segment passed all cuts
    // Flags for whether different stations can be checked by the segment
    //bool canCheckGlobalFill[4]       = {0, 0, 0, 0};
    bool canCheckSectorFill[4]       = {0, 0, 0, 0};
    // Segment Global Position variables
    // float posThetaFill               = 0;
    // float posPhiFill                 = 0;
    // Segment Sector Position
    int TGCstation_StationFEFill[4]  = {-1,-1,-1,-1};// [TGCStation]
    int TGCstation_StationEtaFill[4] = { 0, 0, 0, 0};// [TGCStation]
    int TGCstation_StationPhiFill[4] = { 0, 0, 0, 0};// [TGCStation]
    // Hit registered arrays
    // bool hitregisteredFill[9][2]       = {{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}};
    bool sectorhitregisteredFill[9][2] = {{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}};
    
    bool skipSegm;int nDisqualifiedSegm; // used when checking the disqualified list for a segment
    
    // Make copy of disqualifiedSegment vector array
    std::vector<const Muon::MuonSegment*> copyDisqualifiedSegments;
    nDisqualifiedSegm=disqualifiedSegments[i][2].size();
    copyDisqualifiedSegments.reserve(nDisqualifiedSegm);
for(int ndis=0;ndis<nDisqualifiedSegm;ndis++)copyDisqualifiedSegments.push_back(disqualifiedSegments[i][2].at(ndis));
    
    // Apply preliminary nMdtMeas Cut
    int nSegm = sortedSegments[i][2].size();
    for(int n0=0; n0<nSegm;n0++){
      // Get segment
      const Muon::MuonSegment *segm0 = sortedSegments[i][2].at(n0);
      
      // Check copyDisqualifiedSegments for current segment
      skipSegm=false;
      nDisqualifiedSegm=copyDisqualifiedSegments.size();
      for(int ndis=0;ndis<nDisqualifiedSegm;ndis++)if(segm0==copyDisqualifiedSegments.at(ndis))skipSegm=true;
      if(skipSegm)continue;
      
      // Apply nMDTMeasurements Cut to Segment Collection
      int stationName = 0;
      int nMdtMeas    = 0;
      // Loop through contained ROTs and identify used stations
      for(unsigned int iROT=0; iROT<segm0->numberOfContainedROTs(); ++iROT) {
        const Trk::RIO_OnTrack* rio = segm0->rioOnTrack(iROT);
    if(!rio) continue;
        Identifier id = rio->identify();
        stationName = int(m_idHelperSvc->mdtIdHelper().stationName(id));
        
        if((stationName==17)||(stationName==18))nMdtMeas++;// MDT
      }
      // Cut Segments with insufficient numbers of hits in the stations
      if(nMdtMeas<nMeasCutMdtMidstation){
        copyDisqualifiedSegments.push_back(segm0);
      }
    }
    
    // Loop over Segments in MidStation
    for(int n1=0; n1<nSegm;n1++){
      // Start operation on Segment
      // Get segment
      const Muon::MuonSegment *segm1 = sortedSegments[i][2].at(n1);
      
      // Check copyDisqualifiedSegments for current segment
      skipSegm=false;
      nDisqualifiedSegm=copyDisqualifiedSegments.size();
      for(int ndis=0;ndis<nDisqualifiedSegm;ndis++)if(segm1==copyDisqualifiedSegments.at(ndis))skipSegm=true;
      if(skipSegm)continue;
      
      // Flag for Grouping cut
      bool failedGroupingCut = false;
      // Flags for whether different stations can be checked by the segment
      bool canCheckGlobal[4] = {true, true, true, false};
      bool canCheckSector[4] = {true, true, true, false};
      
      // Get position variables
      //const Trk::GlobalPosition segm1Pos = segm1->globalPosition();
      const Amg::Vector3D segm1Pos = segm1->globalPosition();
 
      float segm1PosPhi = segm1Pos.phi();
      float segm1PosThe = segm1Pos.theta();
      float segm1PosZ   = segm1Pos.z();
      if(segm1PosPhi<0)segm1PosPhi+=2*M_PI;
      if(segm1PosThe>M_PI/2) segm1PosThe=M_PI-segm1PosThe;
      Amg::Vector3D segm1PosZunit(segm1Pos/std::abs(segm1PosZ));
      
      
      // Apply nTGCStripMeasurements Cut to canCheck arrays
      int stationName   = 0;
      int nTGCStrips[4] = { 0, 0, 0, 0};
      // Loop through contained ROTs and identify used stations
      for(unsigned int iROT=0; iROT<segm1->numberOfContainedROTs(); ++iROT){
        const Trk::RIO_OnTrack* rio = segm1->rioOnTrack(iROT);
    if(!rio) continue;
        Identifier id = rio->identify();
        stationName = int(m_idHelperSvc->mdtIdHelper().stationName(id));
        bool isStrip = m_idHelperSvc->tgcIdHelper().isStrip(id);
        
        if(((stationName==41)||(stationName==42))&&isStrip)nTGCStrips[0]++;// TGC
        if(((stationName==43)||(stationName==44))&&isStrip)nTGCStrips[1]++;// TGC
        if(((stationName==45)||(stationName==46))&&isStrip)nTGCStrips[2]++;// TGC
        if(((stationName==47)||(stationName==48))&&isStrip)nTGCStrips[3]++;// TGC
      }
    
      // Don't check mid-stations when there are no strips in other mid-stations
      if((nTGCStrips[1]==0)&&(nTGCStrips[2]==0)){canCheckSector[0]=false;canCheckGlobal[0]=false;}
      if((nTGCStrips[0]==0)&&(nTGCStrips[2]==0)){canCheckSector[1]=false;canCheckGlobal[1]=false;}
      if((nTGCStrips[0]==0)&&(nTGCStrips[1]==0)){canCheckSector[2]=false;canCheckGlobal[2]=false;}
            
      
      // Do Grouping Cut
      // Ignore any segments which are too close to any other segments not in the original disqualified list
      for(int n2=0; n2<nSegm;n2++){
        if(n1==n2)continue; // don't compare segment to itself
        // Get segment
        const Muon::MuonSegment *segm2 = sortedSegments[i][2].at(n2);
        
        // Check disqualifiedSegments for current segment
        skipSegm=false;
        nDisqualifiedSegm=disqualifiedSegments[i][2].size();
        for(int ndis=0;ndis<nDisqualifiedSegm;ndis++)if(segm1==disqualifiedSegments[i][2].at(ndis))skipSegm=true;
        if(skipSegm)continue;
        
        // Get position variables
        const Amg::Vector3D segm2Pos = segm2->globalPosition(); 
    float segm2PosRho = std::abs(segm2Pos.perp());
        float segm2PosPhi = segm2Pos.phi();
        float segm2PosZ   = segm2Pos.z();
        if(segm2PosPhi<0)segm2PosPhi+=2*M_PI;
        Amg::Vector3D segm2PosZunit(segm2Pos/std::abs(segm2PosZ));
        
        // Apply preliminary phi cut between segm1 and segm2 positions
        float dPhi_Segm1_Segm2 = segm1PosPhi-segm2PosPhi;
        if(dPhi_Segm1_Segm2<-M_PI)dPhi_Segm1_Segm2+=2*M_PI;
        if(dPhi_Segm1_Segm2> M_PI)dPhi_Segm1_Segm2-=2*M_PI;
        if(std::abs(dPhi_Segm1_Segm2)<dPhiCutSegmentMatching){
          failedGroupingCut=true;
          break;
        }
        
        // Extrapolate segm1 position to segm2's Z position
        float dZ = std::abs(segm2PosZ)-std::abs(segm1PosZ);
        Amg::Vector3D extrPos(segm1Pos+(segm1PosZunit*dZ));
        float extrPosRho = std::abs(extrPos.perp());
        float extrPosThe = extrPos.theta();
        float extrPosPhi = extrPos.phi();
        if(extrPosThe>M_PI/2) extrPosThe=M_PI-extrPosThe;
        if(extrPosPhi<0)extrPosPhi+=2*M_PI;
        
        // Get differences between extrapolated and segm2 positions
        float dRho_Extr_Segm2 = extrPosRho-segm2PosRho;
        float dPhi_Extr_Segm2 = extrPosPhi-segm2PosPhi;
        if(dPhi_Extr_Segm2<-M_PI)dPhi_Extr_Segm2+=2*M_PI;
        if(dPhi_Extr_Segm2> M_PI)dPhi_Extr_Segm2-=2*M_PI;
        
        // Cut segments (segm1) which are inside difference cuts
        if((std::abs(dPhi_Extr_Segm2)<dPhiCutSegmentMatching)||
           (std::abs(dRho_Extr_Segm2)<dRhoCutSegmentMatching)){
          failedGroupingCut=true;
          break;
        }
      }// nSegm2
      if(failedGroupingCut)continue;
      
      // Check track against TGC Sectors to find which it passes
      // Initialize variables for TRE array search
      int TGCStationNames[8]      ={41, 42, 43, 44, 45, 46, 47, 48};
      int TGCstation_StationFE[4] ={-1,-1,-1,-1};// [TGCStation]
      int TGCstation_StationEta[4]={ 0, 0, 0, 0};// [TGCStation]
      int TGCstation_StationPhi[4]={ 0, 0, 0, 0};// [TGCStation]
      int nStationMatch[4]        ={ 0, 0, 0, 0};// [TGCStation]
      
      // Loop through TRE array, finding sectors which match the track in each layer
      for(int stationnameindex=0; stationnameindex<6; stationnameindex++){// Station {T1F,T1E,T2F,T2E,T3F,T3E}
        // Skip stations which don't have sufficient Segments to run efficiency check
        int stationName = TGCStationNames[stationnameindex];
        int stationIndex= TGCstationname2stationindex(stationName);
        
        // Loop over StationEta&StationPhi
        for(int stationeta=1; stationeta<=8; stationeta++){// AbsStationEta
          for(int stationphi=1; stationphi<=48; stationphi++){// StationPhi
            // Cut Station EtaPhi combinations with no TGC element
            if(m_TREarray[stationnameindex][i][stationeta][stationphi]==nullptr)continue;
            const MuonGM::TgcReadoutElement *tre=m_TREarray[stationnameindex][i][stationeta][stationphi];
            
            // Extrapolate position from nearest Station's Segment to Sector's Z
            float sectorZ=tre->globalPosition().z();
            float dZ_sector=std::abs(sectorZ)-std::abs(segm1PosZ);
            //Trk::GlobalPosition sectorExtrapolatedPos = segm1Pos+(segm1PosZunit*dZ_sector);
            Amg::Vector3D sectorExtrapolatedPos = segm1Pos+(segm1PosZunit*dZ_sector);
            
            // Convert extrapolated position to local position on the Sector
            Identifier sector_id=tre->identify();
            //const HepGeom::Point3D<double> sectorLocalPos3D=tre->globalToLocalCoords(sectorExtrapolatedPos, sector_id);
            const Amg::Vector3D sectorLocalPos3D=tre->globalToLocalTransf(sector_id) * sectorExtrapolatedPos; 
        //Trk::LocalPosition sectorLocalPos2D(sectorLocalPos3D.y(),sectorLocalPos3D.z());
        Amg::Vector2D sectorLocalPos2D(sectorLocalPos3D.y(),sectorLocalPos3D.z());
            
            double avWidth = (tre->getLongSsize()+tre->getSsize())/2;
            //double dWidth  = (tre->longWidth()-tre->shortWidth());
            double length  = tre->length();
            
            // Cut sectors which the track does not go through the central 80% of (avoids double counts)
            double tol1=-0.1*(avWidth/2);
            double tol2=-0.1*(length/2);
            
            bool insideSectorBounds=tre->bounds().inside(sectorLocalPos2D,tol1,tol2);
            if(!insideSectorBounds)continue;
            // Assign values to matching station variables
            if(stationIndex<0) continue;
            TGCstation_StationFE[stationIndex]= (tre->isForward()==false);
            TGCstation_StationEta[stationIndex]=stationeta;
            TGCstation_StationPhi[stationIndex]=stationphi;
            nStationMatch[stationIndex]++;
          }// StationPhi
        }// StationEta
      }// StationName
      
      // Don't check stations that don't have exactly 1 match for this track
      for(int jTGC=0;jTGC<4;jTGC++){// TGC Station
        if(nStationMatch[jTGC]==0){
          canCheckSector[jTGC]=false;
        }
        else if(nStationMatch[jTGC]>1){
          canCheckSector[jTGC]=false;
                // Should be impossible, but happens due a problem with the bounds().inside function
                // commenting out until this bug is resolved
          //m_log << MSG::WARNING << "MidstationOnly: Number of matches for TGC" << jTGC+1 << " is " << nStationMatch[jTGC] << endl;
        }
      }// TGC Station
      
      // Cut Segment if no stations can be checked
      if((!canCheckGlobal[0])&&(!canCheckGlobal[1])&&(!canCheckGlobal[2])&&(!canCheckGlobal[3]))continue;
      // Check which PRD matches Segm1
      // Initialise hit registered arrays
      bool sectorhitregistered[9][2] = {{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}};
      std::vector<const Muon::TgcPrepData*> tpdVector[2];
      
      // Loop over TGC Prep Data container
      Muon::TgcPrepDataContainer::const_iterator prepit_end=tgc_prepcontainer->end();
      for( Muon::TgcPrepDataContainer::const_iterator prepit=tgc_prepcontainer->begin();
           prepit!=prepit_end;
           ++prepit){
        
        //loop over TGC Prep Data collection
        Muon::TgcPrepDataCollection::const_iterator prepitc_end=(*prepit)->end();
        for( Muon::TgcPrepDataCollection::const_iterator prepitc=(*prepit)->begin();
             prepitc!= prepitc_end;
             ++prepitc){
          // Get PRD and variables
          const Muon::TgcPrepData* tpd=*prepitc;
          const MuonGM::TgcReadoutElement *tre = tpd->detectorElement();
          const std::string stationType = tre->getStationType();
          
          // Get id values
          Identifier tgcid=(*prepitc)->identify();
          int tgcAC=(tre->sideA()==false);//isNotAside a:0, c:1
          int tgcFE=(tre->isForward()==false);//isNotForward f:0, e:1
          int tgcWS=(m_idHelperSvc->tgcIdHelper().isStrip(tgcid));//isStrip w=0, s=1
          int stationName = m_idHelperSvc->tgcIdHelper().stationName(tgcid);
          int stationEta  = std::abs(tre->getStationEta());
          int stationPhi  = tre->getStationPhi();
          int gasGap      = m_idHelperSvc->tgcIdHelper().gasGap(tgcid);
          
          // Cut hits except those from same side Midstation
          if(tgcAC!=i) continue;
          if(stationName>46 || stationName<41) continue;
          
          // Get layer number and stationIndex
          int layer        = TGCgetlayer(stationName,gasGap);
          int stationIndex = TGCstationname2stationindex(stationName);
          if(stationIndex==3)continue;
          
          // Get position variables
          const Amg::Vector3D prdPos = tpd->globalPosition(); 
      float tgcRho = std::abs(prdPos.perp());
          float tgcPhi = prdPos.phi();
          float tgcZ   = prdPos.z();
          if(tgcPhi<0)tgcPhi+=2*M_PI;
          
          // Extrapolate Segm1 to PRD Z position
          float dZ = std::abs(tgcZ) - std::abs(segm1PosZ);
          Amg::Vector3D tgcExtrapolatedPos = ((segm1Pos)+((segm1PosZunit)*dZ));
          
          // Get extrapolated variables
          float tgcExtrRho = std::abs(tgcExtrapolatedPos.perp());
          float tgcExtrPhi = tgcExtrapolatedPos.phi();
          if(tgcExtrPhi<0)tgcExtrPhi+=2*M_PI;
          
          // Get differences between extrapolated and segm2 positions
          float dRho = tgcRho-tgcExtrRho;
          float dPhi = tgcPhi-tgcExtrPhi;
          if(dPhi<-M_PI)dPhi+=2*M_PI;
          if(dPhi> M_PI)dPhi-=2*M_PI;
          
          // Pass through loose phi cut to eliminate some noise
          if(std::abs(dPhi)<dPhiCut_Loose){
            // Fill PRD sagitta histograms
            if(m_mvt_extrprdsag2[i][stationIndex][tgcFE][tgcWS][0]) m_mvt_extrprdsag2[i][stationIndex][tgcFE][tgcWS][0]->Fill(dRho);
            if(m_mvt_extrprdsag2[i][stationIndex][tgcFE][tgcWS][2]) m_mvt_extrprdsag2[i][stationIndex][tgcFE][tgcWS][2]->Fill(dPhi);
            
            // Do Global check
            if(canCheckGlobal[stationIndex]){
              float dRhoCut = dRhoCutGlobal[tgcWS]*tgcExtrRho;
              if(std::abs(dPhi)<dPhiCutGlobal[tgcWS] && std::abs(dRho)<dRhoCut){
              }
            }// global
 
            // Add PRD which matches Segm1 position to vector for further analysis
            if(std::abs(dPhi)<dPhiCutSector[tgcWS] && std::abs(dRho)<dRhoCutSector[tgcWS]){
              tpdVector[tgcWS].push_back(tpd);
            }
            // Do Sector Efficiency Check
            if(canCheckSector[stationIndex]){
              // Do check against PRD from matching Sectors
              if((stationEta==TGCstation_StationEta[stationIndex])&&
                 (stationPhi==TGCstation_StationPhi[stationIndex])&&
                 (tgcFE==TGCstation_StationFE[stationIndex])){
                // Do check
                if(std::abs(dPhi)<dPhiCutSector[tgcWS] && std::abs(dRho)<dRhoCutSector[tgcWS]){
                  if(layer>=0)sectorhitregistered[layer][tgcWS]=true;// Sector hit
                }
              }
            }// sector
            
          }// dPhi Loose Cut
        }// TGC PRD Collection
      }// TGC PRD Container
 
      // Cut Segment if no stations can be checked
      if((!canCheckGlobal[0])&&(!canCheckGlobal[1])&&(!canCheckGlobal[2])&&(!canCheckGlobal[3]))continue;
      // Do PRD checks
      // Find vector of PRD which forms a coherent line in the vicinity of Segm1
 
      // Variables to hold best PRD matching results
      std::vector<const Muon::TgcPrepData*> *bestTPDmatches[2];
      bestTPDmatches[0] = nullptr;
      bestTPDmatches[1] = nullptr;
      if(bestTPDmatches[0]->size()>0) bestTPDmatches[0]->clear();
      if(bestTPDmatches[1]->size()>0) bestTPDmatches[1]->clear();
      int bestTPDlayerMatches[2][9] = {{0,0,0,0,0,0,0,0,0},
               {0,0,0,0,0,0,0,0,0}};
 
      for(int k=0;k<2;k++){// WireStrip
        // Variables to record quality of best match found
        int nPRDMax   = 0;
        int nlayerMax = 0;
 
        // Loop over PRD vector
        int nTPD = tpdVector[k].size();
        for(int iTPD1=0;iTPD1<nTPD;iTPD1++){
          // Variables to hold matches found for this PRD
          std::vector<const Muon::TgcPrepData*> thisTPDmatches;
          int thisTPDlayerMatches[9] = {0,0,0,0,0,0,0,0,0}; 
          
          // Get position variables
          const Amg::Vector3D prdPos1 = tpdVector[k].at(iTPD1)->globalPosition();
          
          float prd1Phi = prdPos1.phi();
          float prd1Z   = prdPos1.z();
          if(prd1Phi<0)prd1Phi+=2*M_PI;
          Amg::Vector3D prd1PosZunit(prdPos1/std::abs(prd1Z));
          
          // Get id values
          Identifier tgcid1=(tpdVector[k].at(iTPD1))->identify();
          int stationName1 = m_idHelperSvc->tgcIdHelper().stationName(tgcid1);
          int gasGap1      = m_idHelperSvc->tgcIdHelper().gasGap(tgcid1);
          int layer1       = TGCgetlayer(stationName1,gasGap1);
          if(layer1>=0)thisTPDlayerMatches[layer1]++;
          
          // Loop over PRD
          for(int iTPD2=0;iTPD2<nTPD;iTPD2++){
            if(iTPD2==iTPD1)continue;// do not check PRD against itself
            
            // Get position variables
            const Amg::Vector3D prdPos2 = tpdVector[k].at(iTPD2)->globalPosition(); 
        float prd2Rho = std::abs(prdPos2.perp());
            float prd2Phi = prdPos2.phi();
            float prd2Z   = prdPos2.z();
            if(prd2Phi<0)prd2Phi+=2*M_PI;
            
            // Extrapolate PRD1 to PRD2 Z position
            float dZ = std::abs(prd2Z)- std::abs(prd1Z);
            Amg::Vector3D prdExtrPos = ((prdPos1)+((prd1PosZunit)*dZ));
            
            // Get extrapolated variables
            float prdExtrRho = std::abs(prdExtrPos.perp());
            float prdExtrPhi = prdExtrPos.phi();
            if(prdExtrPhi<0)prdExtrPhi+=2*M_PI;
            
            // Get differences between extrapolated and PRD2 positions
            float dRho = prd2Rho-prdExtrRho;
            float dPhi = prd2Phi-prdExtrPhi;
            if(dPhi<-M_PI)dPhi+=2*M_PI;
            if(dPhi> M_PI)dPhi-=2*M_PI;
            
            // Fill PRD comparison sagitta histograms
            if(m_tgc_prdcompsag[i][k][0]) m_tgc_prdcompsag[i][k][0]->Fill(dRho);
            if(m_tgc_prdcompsag[i][k][2]) m_tgc_prdcompsag[i][k][2]->Fill(dPhi);
            
            // Do check
            if(std::abs(dPhi)<dPhiCutTPD[k] && std::abs(dRho)<dRhoCutTPD[k]){
              // Get id values
              Identifier tgcid2=(tpdVector[k].at(iTPD2))->identify();
              int stationName2 = m_idHelperSvc->tgcIdHelper().stationName(tgcid2);
              int gasGap2      = m_idHelperSvc->tgcIdHelper().gasGap(tgcid2);
              int layer2       = TGCgetlayer(stationName2,gasGap2);
              
              // Add PRD2 to matches for PRD1
              if(layer2>=0)thisTPDlayerMatches[layer2]++;
              thisTPDmatches.push_back(tpdVector[k].at(iTPD2));
            }
          }// nTPD2
          
          // Get quality of matching array produced
          int nPRDCurrent   = 0;
          int nlayerCurrent = 0;
          for(int l=0;l<9;l++){
            if(thisTPDlayerMatches[l]>0)nlayerCurrent++;
            nPRDCurrent+=thisTPDlayerMatches[l];
          }
          
          // Check quality variables against maximum found
          if(nlayerMax <= nlayerCurrent){
            if(nPRDMax < nPRDCurrent){
              // Set maximum values to current segment's values
              nlayerMax = nlayerCurrent;
              nPRDMax   = nPRDCurrent;
              bestTPDmatches[k]    = &thisTPDmatches;
              for(int l=0;l<9;l++){
                bestTPDlayerMatches[k][l] = thisTPDlayerMatches[l];
              }
            }
          }
        }// nTPD1
        
        // If matching array was somehow empty (should be impossible)
        if(nlayerMax==0)continue;
        if(bestTPDmatches[k]->size()==0){
          ATH_MSG_WARNING( "MidstationOnly: empty bestTPDmatches["<<k<<"] passed"  );
          continue;
        }
        
        // Set canCheck variables based on contents of matched PRD array
        for(int jTGC1=0;jTGC1<3;jTGC1++){// TGC Stations
          // Number of matched PRD found in other Stations
          int nMatchOther = 0;
          for(int l=0;l<9;l++){
            int jTGC2 = TGClayer2stationindex(l);
            if(jTGC1==jTGC2)continue;
            nMatchOther+=bestTPDlayerMatches[k][l];
          }
          
          // Check against cut
          if(nMatchOther<nMeasCutTGCMidPRD[k]){
            canCheckGlobal[jTGC1]=false;
            canCheckSector[jTGC1]=false;
          }
        }// TGC Stations
      }// WireStrip
      
      // Cut Segment if no stations can be checked
      if((!canCheckGlobal[0])&&(!canCheckGlobal[1])&&(!canCheckGlobal[2])&&(!canCheckGlobal[3]))continue;
      // Segment has passed all global cuts, fill histogram variables
      // If no segments have already passed all cuts
      if(nValidatedSegm==0){
        for(int jTGC=0;jTGC<4;jTGC++){// TGC Stations
          // Assign values of variables to fill histograms
          // posThetaFill = segm1PosThe;
          // posPhiFill   = segm1PosPhi;
          
          //canCheckGlobalFill[jTGC] = canCheckGlobal[jTGC];
          canCheckSectorFill[jTGC] = canCheckSector[jTGC];
          
          TGCstation_StationFEFill[jTGC]  = TGCstation_StationFE[jTGC];
          TGCstation_StationEtaFill[jTGC] = TGCstation_StationEta[jTGC];
          TGCstation_StationPhiFill[jTGC] = TGCstation_StationPhi[jTGC];
        }
        for(int l=0;l<9;l++){
          for(int k=0;k<2;k++){
            sectorhitregisteredFill[l][k] = sectorhitregistered[l][k];
            // hitregisteredFill[l][k]       = hitregistered[l][k];
          }
        }
      }// TGC Stations
      nValidatedSegm++;
    }// nSegm1
    
    // If only one Segment was validated on this side
    if(nValidatedSegm==1){
      for(int l=0;l<9;l++){//Layer
        int stationIndex = TGClayer2stationindex(l);
        for(int k=0;k<2;k++){// WireStrip
          // If this station can be checked
          if(canCheckSectorFill[stationIndex]){
            if((TGCstation_StationFEFill[stationIndex]<0)||(TGCstation_StationEtaFill[stationIndex]==0)||(TGCstation_StationPhiFill[stationIndex]==0)){
              ATH_MSG_WARNING( "MidstationOnly: canCheckSector passed for jTGC=" << stationIndex
                               << " but, FE="<<TGCstation_StationFEFill[stationIndex]
                               << " Eta="<<TGCstation_StationEtaFill[stationIndex]
                               << " Phi=" << TGCstation_StationPhiFill[stationIndex]  );
              continue;
            }
            // Get Sector histogram indexes
            int stationMap_EtaIndex=getStationMapIndex(1, l, TGCstation_StationFEFill[stationIndex], TGCstation_StationEtaFill[stationIndex], TGCstation_StationPhiFill[stationIndex]);
            int stationMap_PhiIndex=getStationMapIndex(2, l, TGCstation_StationFEFill[stationIndex], TGCstation_StationEtaFill[stationIndex], TGCstation_StationPhiFill[stationIndex]);
            
            // Fill Sector efficiency histograms
            if(sectorhitregisteredFill[l][k]){// Hit in Sector matches extrapolated track
              m_eff_stationmapmid[i][k][1]->Fill(stationMap_EtaIndex, stationMap_PhiIndex);
            }
            m_eff_stationmapmid[i][k][2]->Fill(stationMap_EtaIndex, stationMap_PhiIndex);
          }
        }// WireStrip
      }// layer
    }
    
  }// AC
  
}// End of Function

MMTB_DEPRECATED() [1/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfEventsBlock )

inherited

MMTB_DEPRECATED() [2/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfLowStat )

inherited

MMTB_DEPRECATED() [3/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfLumiBlock )

inherited

MMTB_DEPRECATED() [4/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfRun )

inherited

MMTB_DEPRECATED() [5/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newEventsBlock )

inherited

MMTB_DEPRECATED() [6/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newHigStatInterval )

inherited

MMTB_DEPRECATED() [7/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLowStat )

inherited

MMTB_DEPRECATED() [8/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLowStatInterval )

inherited

MMTB_DEPRECATED() [9/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLumiBlock )

inherited

MMTB_DEPRECATED() [10/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newMedStatInterval )

inherited

MMTB_DEPRECATED() [11/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newRun )

inherited

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

newEventsBlockFlag()

bool ManagedMonitorToolBase::newEventsBlockFlag ( ) const

inlineprotectedinherited

Definition at line 794 of file ManagedMonitorToolBase.h.

{ return m_newEventsBlock; }

newHigStatIntervalFlag()

bool ManagedMonitorToolBase::newHigStatIntervalFlag ( ) const

inlineprotectedinherited

Definition at line 790 of file ManagedMonitorToolBase.h.

{ return m_newHigStatInterval; }

newLowStatFlag()

bool ManagedMonitorToolBase::newLowStatFlag ( ) const

inlineprotectedinherited

Definition at line 791 of file ManagedMonitorToolBase.h.

{ return m_newLowStat; }

newLowStatIntervalFlag()

bool ManagedMonitorToolBase::newLowStatIntervalFlag ( ) const

inlineprotectedinherited

Flag functions allowing clients to determine when to book new and process old histograms; values are updated by fillHists() based on counting lumiBlocks, and are correctly set when fillHistograms(), bookHistograms() and procHistograms() are called.

Definition at line 788 of file ManagedMonitorToolBase.h.

{ return m_newLowStatInterval; }

newLumiBlockFlag()

bool ManagedMonitorToolBase::newLumiBlockFlag ( ) const

inlineprotectedinherited

Definition at line 792 of file ManagedMonitorToolBase.h.

{ return m_newLumiBlock; }

newMedStatIntervalFlag()

bool ManagedMonitorToolBase::newMedStatIntervalFlag ( ) const

inlineprotectedinherited

Definition at line 789 of file ManagedMonitorToolBase.h.

{ return m_newMedStatInterval; }

newRunFlag()

bool ManagedMonitorToolBase::newRunFlag ( ) const

inlineprotectedinherited

Definition at line 793 of file ManagedMonitorToolBase.h.

{ return m_newRun; }

numberOfSL()

int MdtVsTgcRawDataValAlg::numberOfSL ( const Muon::TgcCoinDataContainer * tgctrgcontainer )

private

Definition at line 83 of file MdtVsTgcRawData_functions.cxx.

                                                                                {
 
  int nSL=0;
 
  //loop over TGC RoI container
  Muon::TgcCoinDataContainer::const_iterator it_end=tgctrgcontainer->end();
  for( Muon::TgcCoinDataContainer::const_iterator it=tgctrgcontainer->begin();
       it!=it_end;
       ++it){
  
 
    ATH_MSG_DEBUG( "size of tgc collection is " << (*it) -> size()  );
 
    //loop over TGC RoI collection
    Muon::TgcCoinDataCollection::const_iterator itc_end=(*it)->end();
    for( Muon::TgcCoinDataCollection::const_iterator itc=(*it)->begin();
         itc!= itc_end;
         ++itc){
 
      const Muon::TgcCoinData* tcd=*itc;
 
      if( tcd->type() != Muon::TgcCoinData::TYPE_SL )continue;
      ATH_MSG_DEBUG("pt"<<tcd->pt() );
      nSL++;
    }
  }
 
  return nSL;
}

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

parseList()

StatusCode ManagedMonitorToolBase::parseList ( const std::string & line, std::vector< std::string > & result )

protectedinherited

Definition at line 2112 of file ManagedMonitorToolBase.cxx.

                                                               {
   std::string item;
   std::stringstream ss(line);
 
   if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "ManagedMonitorToolBase::parseList:";
 
   while ( std::getline(ss, item, ',') ) {
      std::stringstream iss(item); // remove 
      iss >> item;                 // whitespace 
      if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " " << item;
      result.push_back(item);
   }
 
   msg(MSG::DEBUG) << endmsg;
   return StatusCode::SUCCESS;
}

phi2sector()

int MdtVsTgcRawDataValAlg::phi2sector ( int phi, int ef )

private

Definition at line 57 of file MdtVsTgcRawData_functions.cxx.

                                                {
  int sector=-1;
  if(ef==0){//forward
    sector=phi/2+1;//(phi,sector)= (1,1), (2,2), (3,2), (4,3)
  }else{//endcap
    sector=(phi+1)/4+1;//(phi,sector)= (1,1), (2,1), (3,2), (4,2)
  }
  if(sector>12)sector=1;
 
  return sector;
}

prepareTREarray()

void MdtVsTgcRawDataValAlg::prepareTREarray ( const MuonGM::MuonDetectorManager * MuonDetMgrDS )

private

Definition at line 85 of file MdtVsTgcRawData_TGCEffCheck.cxx.

                                                                                   {
  int TGCStationNames[8]={41, 42, 43, 44, 45, 46, 47, 48};
  
  // Make array of TGC Readout Element pointers
  for(int stationNameIndex=0; stationNameIndex<8; stationNameIndex++){// Station Name
    int stationName = TGCStationNames[stationNameIndex];
    for(int stationEta=-8; stationEta<=8; stationEta++){// Station Eta
      int tgcAC(stationEta<0);
      int absStationEta = std::abs(stationEta);
      for(int stationPhi=0; stationPhi<=48; stationPhi++){// Station Phi
        // Exclude non-existent "zero" sectors included in the array for ease of use
        if(stationEta==0){
          m_TREarray[stationNameIndex][0][absStationEta][stationPhi]=nullptr;
          m_TREarray[stationNameIndex][1][absStationEta][stationPhi]=nullptr;
          continue;
        }
        m_TREarray[stationNameIndex][tgcAC][absStationEta][stationPhi]=nullptr;
        if(stationPhi==0)continue;
        
        // Exclude sectors known not to exist
        if(stationNameIndex==6){         // Inner Forward
          if(std::abs(stationEta)>1)continue;
          if(stationPhi>24)continue;
        }
        else if(stationNameIndex==7){    // Inner Endcap
          if(std::abs(stationEta)>1)continue;
          if(stationPhi>21)continue;
        }
        else if((stationNameIndex==0)||  // Midstation Forward
                (stationNameIndex==2)||
                (stationNameIndex==4)){
          if(std::abs(stationEta)>1)continue;
          if(stationPhi>24)continue;
        }
        else{                            // Midstation Endcap
          if(std::abs(stationEta)>5)continue;
          if((stationNameIndex==1)&&
             (std::abs(stationEta)>4))continue;
        } 
        
        // Get identifier of TRE at this set of indexes
        bool isValid{false};
        Identifier tgc_testId = m_idHelperSvc->tgcIdHelper().elementID(stationName, stationEta, stationPhi, isValid);
        if(!isValid){continue;}
        
        // Get TRE and put into to array
        m_TREarray[stationNameIndex][tgcAC][absStationEta][stationPhi] = MuonDetMgrDS->getTgcReadoutElement(tgc_testId);
        if(m_TREarray[stationNameIndex][tgcAC][absStationEta][stationPhi]==nullptr){
          ATH_MSG_WARNING( "prepareTREarray: TgcReadoutElement==0 passed checks"  );
          continue;
        }
      }// Station Phi
    }// Station Eta
  }// Station Name
  return;
}// End of function

preSelector()

bool ManagedMonitorToolBase::preSelector ( )

virtualinherited

Implements IMonitorToolBase.

Definition at line 1680 of file ManagedMonitorToolBase.cxx.

{
   if( m_preScaleProp > 1 ) {
      return ( (m_nEvents % m_preScaleProp) == 1 );
   }
   return true;
}

procHistograms()

StatusCode MdtVsTgcRawDataValAlg::procHistograms ( )

virtual

An inheriting class should either override this function or finalHists().

Reimplemented from ManagedMonitorToolBase.

Definition at line 185 of file MdtVsTgcRawDataValAlg.cxx.

                                                {
/*----------------------------------------------------------------------------------*/
 
  ATH_MSG_DEBUG( "MdtVsTgcRawDataValAlg finalize()"  );
  if(endOfRunFlag()){
    tgceffcalcfinalize();
    maphistsfinalize();
  }
  return StatusCode::SUCCESS;
}

putBox()

void MdtVsTgcRawDataValAlg::putBox ( TH2 * h2, float x1, float y1, float x2, float y2 )

private

Definition at line 129 of file MdtVsTgcRawData_functions.cxx.

                                                                           {
  TBox* box = new TBox(x1, y1, x2, y2);
//  box->SetFillColor(kGray+1);
//  box->SetLineColor(kGray+1);
//  box->SetFillStyle(3013);
//  box->SetFillStyle(3004);
 
  box->SetFillColor(kGray);
  box->SetLineColor(kGray);
 
//  box->SetLineStyle(3);
 
  (h->GetListOfFunctions())->Add(box);    
}

regEfficiency()

StatusCode ManagedMonitorToolBase::regEfficiency ( TEfficiency * e, const MonGroup & group )

virtualinherited

Registers a TEfficiency to be included in the output stream using logical parameters that describe the plot.

Definition at line 1445 of file ManagedMonitorToolBase.cxx.

                                                                                        {
    if (!e)
        return StatusCode::FAILURE;
 
    TGraph* g = reinterpret_cast<TGraph*>(e);
    std::string name = e->GetName();
 
    // MANAGED
    if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
        // warn about not using merge algorithms
        if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
            ATH_MSG_WARNING("HEY! Attempting to register "<<name<<" as a per-LB histogram, but not setting the merge algorithm! Use \"merge\", at least.");
        }
        // add the efficiency to rebooking vector
        if (m_supportedIntervalsForRebooking.count(group.interval())) {
            m_templateEfficiencies[group.interval()].push_back( MgmtParams<TEfficiency>(e, group) );
        } else {
            ATH_MSG_ERROR("Attempt to book managed graph " << name << " with invalid interval type " << intervalEnumToString(group.interval()));
            return StatusCode::FAILURE;
        }
 
        MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
        std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
        registerMetadata(streamName, name, group).ignore();
        return m_THistSvc->regGraph( streamName, g );
    } else {
    // UNMANAGED
        if( m_manager != 0 ) {
            std::string genericName = NoOutputStream().getStreamName( this, group, name );
            m_manager->writeAndDelete( genericName );
            m_manager->passOwnership( e, genericName );
        }
 
        std::string streamName = streamNameFunction()->getStreamName( this, group, name, false );
        StatusCode smd = registerMetadata(streamName, name, group);
        if (smd != StatusCode::SUCCESS) 
            return StatusCode::FAILURE;
 
        return m_THistSvc->regGraph( streamName, g );
    }
}

regGraph() [1/2]

StatusCode ManagedMonitorToolBase::regGraph ( TGraph * g, const MonGroup & group )

virtualinherited

Registers a TGraph to be included in the output stream using logical parameters that describe the graph.

Definition at line 1499 of file ManagedMonitorToolBase.cxx.

{
   if (!g)
      return StatusCode::FAILURE;
 
   // This part of the code deals with MANAGED type
   if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
       // Create an unmanaged group based on the original MonGroup instance passed
       // This is needed because managed graph is presented as a number of unmanaged
       // graphs (one per each interval)
       MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
 
       if (m_supportedIntervalsForRebooking.count(group.interval())) {
           m_templateGraphs[group.interval()].push_back( MgmtParams<TGraph>(g, group_unmanaged) );
       } else {
           ATH_MSG_ERROR("Attempt to book managed graph " << g->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
           return StatusCode::FAILURE;
       }
 
       std::string name = g->GetName();
       std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
       registerMetadata(streamName, name, group).ignore();
       return m_THistSvc->regGraph( streamName, g );
       //return m_THistSvc->regGraph( streamName );
   } 
 
   // This part of the code deals with UNMANAGED type
   std::string gName = g->GetName();
 
   if( m_manager != 0 ) {
      std::string genericName = NoOutputStream().getStreamName( this, group, gName );
      m_manager->writeAndDelete( genericName );
      m_manager->passOwnership( g, genericName );
   }
 
   std::string streamName = streamNameFunction()->getStreamName( this, group, gName, false );
 
   StatusCode smd = registerMetadata(streamName, gName, group);
   if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
 
   return m_THistSvc->regGraph( streamName, g );
}

regGraph() [2/2]

StatusCode ManagedMonitorToolBase::regGraph ( TGraph * g, const std::string & system, Interval_t interval, MgmtAttr_t histo_mgmt = ATTRIB_MANAGED, const std::string & chain = "", const std::string & merge = "" )

virtualinherited

Registers a TGraph to be included in the output stream using logical parameters that describe the graph.

Definition at line 1489 of file ManagedMonitorToolBase.cxx.

{
   MonGroup group( this, system, interval, histo_mgmt, chain, merge );
   return regGraph( g, group );
}

regHist() [1/2]

StatusCode ManagedMonitorToolBase::regHist ( TH1 * h, const MonGroup & group )

virtualinherited

Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram.

A histogram is passed via reference to a pointer.

Definition at line 1353 of file ManagedMonitorToolBase.cxx.

{
//   ManagedMonitorToolBase_addHistStatistics(this,h);
 
  if (!h)
    return StatusCode::FAILURE;
  
  // This part of the code deals with MANAGED type
  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
    /* 
       Create an unmanaged group based on the original MonGroup instance passed
       It is needed because managed histogram is presented as a number of unmanaged
       histograms (one per each interval)
       Update (PUEO) - I don't think it actually matters, and need to keep 
       track of "proper" attribute for X_VS_LB
    */
    
    if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
      ATH_MSG_WARNING("HEY! You're attempting to register " << h->GetName() << " as a per-LB histogram, but you're not setting the merge algorithm! This is a SUPER-BAD idea! Use \"merge\", at least.");
    }
    
    if (m_supportedIntervalsForRebooking.count(group.interval())) {
      m_templateHistograms[group.interval()].push_back( MgmtParams<TH1>(h, group) );
    } else {
      ATH_MSG_ERROR("Attempt to book managed histogram " << h->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
           return StatusCode::FAILURE;
    }
    
    std::string hName = h->GetName();
    MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
    std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, hName, false );
    registerMetadata(streamName, hName, group).ignore();
    return m_THistSvc->regHist( streamName, h );
  }
  
  // This part of the code deals with UNMANAGED type
  std::string hName = h->GetName();
  
  if( m_manager != 0 ) {
    std::string genericName = NoOutputStream().getStreamName( this, group, hName );
    m_manager->writeAndDelete( genericName );
    m_manager->passOwnership( h, genericName );
  }
  
  std::string streamName = streamNameFunction()->getStreamName( this, group, hName, false );
  
  StatusCode smd = registerMetadata(streamName, hName, group);
  if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
  
  return m_THistSvc->regHist( streamName, h );
}

regHist() [2/2]

StatusCode ManagedMonitorToolBase::regHist ( TH1 * h, const std::string & system, Interval_t interval, MgmtAttr_t histo_mgmt = ATTRIB_MANAGED, const std::string & chain = "", const std::string & merge = "" )

virtualinherited

Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram.

Definition at line 1344 of file ManagedMonitorToolBase.cxx.

{
   MonGroup group( this, system, interval, histo_mgmt, chain, merge );
   return regHist( h, group );
}

registerMetadata()

StatusCode ManagedMonitorToolBase::registerMetadata ( const std::string & streamName, const std::string & hName, const MonGroup & group )

protectedinherited

Definition at line 946 of file ManagedMonitorToolBase.cxx.

                                {
  if( m_environment != AthenaMonManager::online ) {
    TTree* metadata(0);
    std::string mdStreamName( streamName );
    size_t found=mdStreamName.rfind('/');
    
    if ( found != std::string::npos )
      mdStreamName.replace( found, mdStreamName.length(), "/metadata" );
    
    MDMap_t::iterator i = m_metadataMap.find( mdStreamName );
    if( i == m_metadataMap.end() ) {
      metadata = new TTree( "metadata", "Monitoring Metadata" );
      if (! metadata) return StatusCode::FAILURE;
      StatusCode scmd = m_THistSvc->regTree( mdStreamName, metadata );
      if (scmd == StatusCode::FAILURE) return StatusCode::FAILURE;
      i = m_metadataMap.emplace( mdStreamName, new OutputMetadata(metadata) ).first;
    }
    
    i->second->fill( hName,  group.interval(), group.chain(), group.merge() );
  }
  return StatusCode::SUCCESS;
}

regManagedEfficiencies()

StatusCode ManagedMonitorToolBase::regManagedEfficiencies ( std::vector< MgmtParams< TEfficiency > > & templateEfficiencies )

protectedinherited

Definition at line 1140 of file ManagedMonitorToolBase.cxx.

                                                                                                                    {
    bool allIsOk = true;
    for( auto& it : templateEfficiencies ) {
        // get components of MgmtParams and copy efficiency
        MonGroup group = it.m_group;
        TEfficiency* theEfficiency = it.m_templateHist;
        TEfficiency* e = static_cast<TEfficiency*>(theEfficiency->Clone());
        int nbins = theEfficiency->GetTotalHistogram()->GetNbinsX();
        int xlow = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmin();
        int xhigh = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmax();
        e->SetBins(nbins,xlow,xhigh); // reset histogram
        std::string name = e->GetName();
 
        // make TGraph casts of TEfficiencies
        TGraph* theGraph = reinterpret_cast<TGraph*>(theEfficiency);
        TGraph* g = reinterpret_cast<TGraph*>(e);
 
        // Get the streamName for the previous interval
        std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
 
        // RE-REGISTER 
        // 1) De-register the original graph with the THistSvc
        StatusCode sc1 = m_THistSvc->deReg( theGraph );
        if (sc1 == StatusCode::FAILURE) allIsOk = false;
        // 2) Fix THistSvc->deReg for TGraphs
        bool doneCleaning = false;
        std::string directoryName = streamNameFunction()->getDirectoryName( this, group, name, true );
        TSeqCollection *filelist=gROOT->GetListOfFiles();
        for (int i=0; i<filelist->GetEntries(); i++) {
            ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
            TFile* file = static_cast<TFile*>(filelist->At(i));
            StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
            if (sc2 == StatusCode::SUCCESS) doneCleaning = true;
        }
        // 3) Check if TGraph fix has been applied successfully
        if (!doneCleaning) { 
            ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
            allIsOk = false;
        }
        // 4) Register cloned histogram under previous interval streamName
        StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
        if (sc3 == StatusCode::FAILURE) 
            allIsOk = false;
 
        // get streamname for interval
        streamName = streamNameFunction()->getStreamName( this, group, name, false );
        // store metadata
        StatusCode smd = registerMetadata(streamName, name, group);
        if (smd != StatusCode::SUCCESS) allIsOk = false;
        // Re-register the original graph
        StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
        if (sc4 == StatusCode::FAILURE) allIsOk = false;
    }
 
    if (!allIsOk) return StatusCode::FAILURE;
    return StatusCode::SUCCESS;
}

regManagedGraphs()

StatusCode ManagedMonitorToolBase::regManagedGraphs ( std::vector< MgmtParams< TGraph > > & templateGraphs )

protectedinherited

Definition at line 1069 of file ManagedMonitorToolBase.cxx.

{
      // See the description for the regManagedHistograms method
      bool allIsOk = true;  
   
      for( std::vector< MgmtParams<TGraph> >::iterator it = templateGraphs.begin(); it != templateGraphs.end(); ++it ) {
          MonGroup group = (*it).m_group;
 
          // Get a handle to the graph
          TGraph* theGraph = (*it).m_templateHist;
 
          // Clone the graph
          TGraph* g = static_cast<TGraph*>(theGraph->Clone());
          theGraph->Set(0); // equivalent to Reset() for TH1
 
          // Get name
          std::string gName = g->GetName();
 
          // Get the streamName for the previous interval
          std::string streamName = streamNameFunction()->getStreamName( this, group, gName, true );
 
          // De-register the original graph with the THistSvc
          StatusCode sc1 = m_THistSvc->deReg( theGraph );
          if (sc1 == StatusCode::FAILURE)
              allIsOk = false;
 
          // *** begin ***
          // Fix THistSvc->deReg for TGraphs
          bool doneCleaning = false;
          std::string directoryName = streamNameFunction()->getDirectoryName( this, group, gName, true );
          TSeqCollection *filelist=gROOT->GetListOfFiles();
          for (int i=0; i<filelist->GetEntries(); i++) {
              ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
              TFile* file = static_cast<TFile*>(filelist->At(i));
              StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
              if (sc2 == StatusCode::SUCCESS)
                  doneCleaning = true;
          }
         
          // Check if TGraph fix has been applied successfully 
          if (!doneCleaning) { 
              ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
              allIsOk = false;
          }
          // *** end ***
 
          // Register clonned histogram under previous interval streamName
          StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
          if (sc3 == StatusCode::FAILURE) 
              allIsOk = false;
 
          // Get streamName for the current interval
          streamName = streamNameFunction()->getStreamName( this, group, gName, false );
          // Register metadata information with the current interval streamname
          StatusCode smd = registerMetadata(streamName, gName, group);
          if (smd != StatusCode::SUCCESS) 
              allIsOk = false;
 
          // Re-register the original graph with the current interval streamName
          StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
          if (sc4 == StatusCode::FAILURE) 
              allIsOk = false;
 
      }
 
      if (!allIsOk) return StatusCode::FAILURE;
      
      return StatusCode::SUCCESS;
}

regManagedHistograms()

StatusCode ManagedMonitorToolBase::regManagedHistograms ( std::vector< MgmtParams< TH1 > > & templateHistograms )

protectedinherited

Definition at line 972 of file ManagedMonitorToolBase.cxx.

{
      // The method registers histograms with the THistSvc and saves them to file.
 
      // The funky business with registering and deregistering the histogram is needed
      // to get the correct directory when saving histograms. THistSvc deals with ROOT 
      // to set up proper TDirectory, so we rely on it.
      // E.g. 
      //     m_THistSvc->regHist( streamName, h ): sets the correct TDirectory with streamName
      //     m_THistSvc->deReg( h ) - deregister from THistSvc otherwise THistSvc will try to save it
      //                          at the end of execution
      //  use passownership of the histogram and save it to file 
      //     m_manager->passOwnership( h, genericName );
      //     m_manager->writeAndDelete( genericName );
      bool allIsOk = true;  
   
      for( std::vector< MgmtParams<TH1> >::iterator it = templateHistograms.begin(); it != templateHistograms.end(); ++it ) {
          MonGroup& group = (*it).m_group;
 
          // Get a handle to the histogram
          TH1* theHist = (*it).m_templateHist;
 
          // Clone the histogram
          TH1* h = static_cast<TH1*>(theHist->Clone());
          theHist->Reset();
 
          // Get name
          std::string hName = h->GetName();
 
          // Get the streamName for the previous interval
          std::string streamName = streamNameFunction()->getStreamName( this, group, hName, true );
 
          // Register the histogram with the THistSvc
          StatusCode sc1 = m_THistSvc->deReg( theHist );
          if (sc1 == StatusCode::FAILURE) allIsOk = false;
 
          // Register clonned histogram under previous interval streamName
          StatusCode sc2 = m_THistSvc->regHist( streamName, h );
          if (sc2 == StatusCode::FAILURE) allIsOk = false;
 
          if( m_manager != 0 ) {
             std::string genericName = NoOutputStream().getStreamName( this, group, hName );
             m_manager->passOwnership( h, genericName );
             m_manager->writeAndDelete( genericName );
          }
        
          // Get streamName for the current interval 
          streamName = streamNameFunction()->getStreamName( this, group, hName, false );
          // Register metadata information with the current interval streamname
          StatusCode smd = registerMetadata(streamName, hName, group);
          if (smd != StatusCode::SUCCESS) allIsOk = false;
 
          // Re-register the original histogram with the current interval streamName
          StatusCode sc3 = m_THistSvc->regHist( streamName, theHist );
          if (sc3 == StatusCode::FAILURE) allIsOk = false;
 
      }
 
      if (!allIsOk) return StatusCode::FAILURE;
      
      return StatusCode::SUCCESS;
}

regManagedTrees()

StatusCode ManagedMonitorToolBase::regManagedTrees ( std::vector< MgmtParams< TTree > > & templateTrees )

protectedinherited

Definition at line 1200 of file ManagedMonitorToolBase.cxx.

{
      // See the description for the regManagedHistograms method
      bool allIsOk = true;  
   
      for( std::vector< MgmtParams<TTree> >::iterator it = templateTrees.begin(); it != templateTrees.end(); ++it ) {
          MonGroup group = (*it).m_group;
 
          // Get a handle to the original tree
          TTree* theTree = (*it).m_templateHist;
 
          // Clone the tree
          TTree* t = static_cast<TTree*>(theTree->Clone());
          theTree->Reset();
 
          // Dumping the tree
          std::string name = t->GetName();
 
          // Get the streamName for the previous interval
          std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
 
          // De-register original tree with the THistSvc
          StatusCode sc1 = m_THistSvc->deReg( theTree );
          if (sc1 == StatusCode::FAILURE) allIsOk = false;
 
          // Register clonned tree under previous interval streamName
          StatusCode sc2 = m_THistSvc->regTree( streamName, t );
          if (sc2 == StatusCode::FAILURE) allIsOk = false;
 
          if( m_manager != 0 ) {
             std::string genericName = NoOutputStream().getStreamName( this, group, name );
             m_manager->passOwnership( t, genericName );
             m_manager->writeAndDelete( genericName );
          }
 
          // Get streamName for the current interval
          streamName = streamNameFunction()->getStreamName( this, group, name, false );
          // Register metadata information with the current interval streamname
          StatusCode smd = registerMetadata(streamName, name, group);
          if (smd != StatusCode::SUCCESS) allIsOk = false;
 
          // Re-register the original graph with the current interval streamName
          StatusCode sc3 = m_THistSvc->regTree( streamName, theTree );
          if (sc3 == StatusCode::FAILURE) allIsOk = false;
 
      }
 
      if (!allIsOk) return StatusCode::FAILURE;
      
      return StatusCode::SUCCESS;
}

regTree() [1/2]

StatusCode ManagedMonitorToolBase::regTree ( TTree * t, const MonGroup & group )

virtualinherited

Registers a TTree to be included in the output stream using logical parameters that describe it.

Definition at line 1555 of file ManagedMonitorToolBase.cxx.

{
 
   // This part of the code deals with MANAGED type
   if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
       // Create an unmanaged group based on the original MonGroup instance passed
       // This is needed because managed tree is presented as a number of unmanaged
       // trees (one per each interval)
       MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
 
       if (m_supportedIntervalsForRebooking.count(group.interval())) {
           m_templateTrees[group.interval()].push_back( MgmtParams<TTree>(t, group_unmanaged) );
       } else {
           ATH_MSG_ERROR("Attempt to book managed tree " << t->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
           return StatusCode::FAILURE;
       }
 
       std::string name = t->GetName();
       std::string genericName = NoOutputStream().getStreamName( this, group_unmanaged, name );
       std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
       registerMetadata(streamName, name, group).ignore();
       return m_THistSvc->regTree( streamName, t );
   }
 
 
   // This part of the code deals with UNMANAGED type
   std::string tName = t->GetName();
 
   if( m_manager != 0 ) {
      std::string genericName = NoOutputStream().getStreamName( this, group, tName );
      m_manager->writeAndDelete( genericName );
      m_manager->passOwnership( t, genericName );
   }
 
   std::string streamName = streamNameFunction()->getStreamName( this, group, tName, false );
 
   StatusCode smd = registerMetadata(streamName, tName, group);
   if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
 
   return m_THistSvc->regTree( streamName, t );
}

regTree() [2/2]

StatusCode ManagedMonitorToolBase::regTree ( TTree * t, const std::string & system, Interval_t interval, MgmtAttr_t histo_mgmt = ATTRIB_MANAGED, const std::string & chain = "", const std::string & merge = "" )

virtualinherited

Registers a TTree to be included in the output stream using logical parameters that describe it.

Definition at line 1545 of file ManagedMonitorToolBase.cxx.

{
   MonGroup group( this, system, interval, histo_mgmt, chain, merge );
   return regTree( t, group );
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

roi2etaphi()

void MdtVsTgcRawDataValAlg::roi2etaphi ( const Muon::TgcCoinData & cd, int & eta, int & phi )

private

Definition at line 28 of file MdtVsTgcRawData_functions.cxx.

                                                                              {
  
  int roiphi=cd.phi();//phi in 1/48(24) sector for endcap(forward)
  int roi=cd.roi();//0-147(0-63)
 
  //int localeta=roi/4;
 
  if(cd.isForward()){//forward
 
    int localphi=roi%4;
 
    //eta=roi/4;
    eta=roi/4+36;
    phi=(localphi+roiphi*4)*2;
 
  }else{//endcap
 
    int sector=phi2sector(roiphi,1);
 
    phi=roiphi*4 + ( sector%2==0 ? roi%4 : 3-(roi%4)   );
    eta=roi/4;
  }
 
  //eta=52-eta;
  return;
 
}

roiphi2mdtSector()

int MdtVsTgcRawDataValAlg::roiphi2mdtSector ( int roiphi, int ef )

private

Definition at line 70 of file MdtVsTgcRawData_functions.cxx.

                                                         {
  int mdtSector=-1;
  if(ef==0){//forward phi1-24
    mdtSector=roiphi/2+1;//(phi,sector)= (1,1), (2,2), (3,2), (4,3)
  }else{//endcap
    mdtSector=(roiphi+1)/4+1;//(phi,sector)= (1,1), (2,1), (3,2), (4,2)
  }
  if(mdtSector>8)mdtSector=1;
 
  return mdtSector;
}

roitotalphi2sectorphi()

int MdtVsTgcRawDataValAlg::roitotalphi2sectorphi ( int phi )

private

runStat()

StatusCode ManagedMonitorToolBase::runStat ( )

virtualinherited

This implementation does nothing; equivalent functionality may be provided by procHists( true, true, true ).

Implements IMonitorToolBase.

Definition at line 1662 of file ManagedMonitorToolBase.cxx.

{
   return StatusCode::SUCCESS;
}

setMonManager()

void ManagedMonitorToolBase::setMonManager ( AthenaMonManager * manager )

virtualinherited

Takes a pointer to a managing object to get information from it when needed.

Definition at line 1326 of file ManagedMonitorToolBase.cxx.

{
  ATH_MSG_DEBUG( "ManagedMonitorToolBase::setMonManager():");
  m_manager = manager;
  if( m_manager != 0 ) {
      ATH_MSG_DEBUG( "  --> Setting manager");
      m_managerNameProp = m_manager->name();
      m_fileKey = m_manager->fileKey();
      m_dataType = m_manager->dataType();
      m_environment = m_manager->environment();
      delete m_streamNameFcn;
      m_streamNameFcn = getNewStreamNameFcn();
   }
    ATH_MSG_DEBUG( "  --> Exiting successfully");
}

setupOutputStreams()

StatusCode ManagedMonitorToolBase::setupOutputStreams ( std::vector< std::string > Mapping = std::vector<std::string>() )

virtualinherited

This implementation does nothing—streams in this class should be managed by the AthenaMonManager.

Consider using MonitorToolBase for user-managed streams.

Implements IMonitorToolBase.

Definition at line 1651 of file ManagedMonitorToolBase.cxx.

{
   // All instances should write to the stream(s) defined by the
   // AthenaMonManager.
 
   return StatusCode::SUCCESS;
}

SortMDTSegments()

void MdtVsTgcRawDataValAlg::SortMDTSegments ( const xAOD::MuonSegmentContainer * m_newsegment, std::vector< const Muon::MuonSegment * >(&) sortedSegments[2][4] )

private

Definition at line 28 of file MdtVsTgcRawData_SegmSorting.cxx.

                                                                                                 {
    
  // Loop over all segments in event
  xAOD::MuonSegmentContainer::const_iterator mdtseg_itr = newsegment->begin();
  xAOD::MuonSegmentContainer::const_iterator mdtseg_end = newsegment->end();
  for(; mdtseg_itr!=mdtseg_end; ++mdtseg_itr){
    if(!(*mdtseg_itr)->muonSegment().isValid())continue;
    // Get segm
    const Muon::MuonSegment* segm = dynamic_cast<const Muon::MuonSegment*>(*(*mdtseg_itr)->muonSegment());
    if (segm == nullptr) {
      ATH_MSG_ERROR( "no pointer to segm!!!" );
      break;
    }
    
    bool isMdt=false, isEndcap=false; // Flags for whether the Segment has hits from the MDT/Endcap
    int nMdtMeas[4]={0,0,0,0};        // int array to count number of MDT hits in different stations
    
    // Loop through contained ROTs and identify used stations
    for(unsigned int iROT=0; iROT<segm->numberOfContainedROTs(); ++iROT){
      const Trk::RIO_OnTrack* rio = segm->rioOnTrack(iROT);
      if(!rio){
    ATH_MSG_DEBUG("No RIO");
    continue;
      }
      Identifier id = rio->identify();
      
      // Identify MDT Endcap Segments
      if(m_idHelperSvc->isMdt(id))isMdt=true;
      if(m_idHelperSvc->isEndcap(id))isEndcap=true;
      
      int stationName = int(m_idHelperSvc->mdtIdHelper().stationName(id));
      // Large (L) = odd, greater r, Small (S) = even, lower r
      // 13=EIL 49=EIS 14=EEL 15=EES 17=EML 18=EMS 20=EOL 21=EOS
      if((stationName==13)||(stationName==49))nMdtMeas[0]++;// MDT
      if((stationName==14)||(stationName==15))nMdtMeas[1]++;// MDT
      if((stationName==17)||(stationName==18))nMdtMeas[2]++;// MDT
      if((stationName==20)||(stationName==21))nMdtMeas[3]++;// MDT
    }
    
    // If not Endcap and does not contain MDT hits
    if(!isMdt||!isEndcap)continue;
    
    // Get Side
    int segmAC = (segm->globalPosition().eta()<0);// a:0, c:1
    
    // Check MDT Stations included in this Segment
    int nMDTStations=0; int MDTStationj=-1;
    for(int jMDT=0;jMDT<4;jMDT++){
      if(nMdtMeas[jMDT]!=0){
        nMDTStations++;
        MDTStationj=jMDT;
      }
    }
    
    // MC data has an odd channel set always triggering segments, this cuts them
    if((segmAC==0)&&(MDTStationj==0)&&
       (segm->globalPosition().eta()>1.815)&&(segm->globalPosition().eta()<1.82)&&
       (segm->globalPosition().phi()>2.857)&&(segm->globalPosition().phi()<2.862))continue;
    
    // If there is only one station pass the segment data on to the variables
    if(nMDTStations==1){
      //HasStationSegm[segmAC][MDTStationj]=true;
      sortedSegments[segmAC][MDTStationj].push_back(segm);
    }
  }// Loop over segments
}// End of function

stationGasGap2layer()

int MdtVsTgcRawDataValAlg::stationGasGap2layer ( int station, int GasGap )

private

Definition at line 114 of file MdtVsTgcRawData_functions.cxx.

                                                                 {
  int layer=0;
  if(station==41||station==42){
    layer += GasGap;
  }else if(station==43||station==44){
    layer = 3+GasGap;
  }else if(station==45||station==46){
    layer = 5+GasGap;
  }
  return layer;
}

streamNameFunction()

ManagedMonitorToolBase::StreamNameFcn * ManagedMonitorToolBase::streamNameFunction ( )

virtualinherited

Returns the function object that converts logical paramters into a physical stream name.

Definition at line 451 of file ManagedMonitorToolBase.cxx.

{
   if( m_streamNameFcn == 0 ) {
      msg(MSG::ERROR) << "!! streamNameFunction() has not been initialized !!" << endmsg;
      msg(MSG::ERROR) << "  --> neither ManagedMonitorToolBase::initialize() nor" << endmsg;
      msg(MSG::ERROR) << "  --> ManagedMonitorToolBase::setMonManager() has been called." << endmsg;
      msg(MSG::ERROR) << "  --> Correct configuration cannot be guaranteed from this point." << endmsg;
      m_streamNameFcn = getNewStreamNameFcn();
   }
   return m_streamNameFcn;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

tgceffcalc()

void MdtVsTgcRawDataValAlg::tgceffcalc ( const xAOD::MuonSegmentContainer * m_newsegment, const Muon::TgcPrepDataContainer * tgc_prepcontainer )

private

Definition at line 35 of file MdtVsTgcRawData_TGCEffCheck.cxx.

                                                                                    {
  ATH_MSG_DEBUG("inside tgcEIFIeffcalc" );
  // Declare vector arrays to hold segment pointers
 
  // Holds Segments sorted into MDT Stations on each side
  std::vector<const Muon::MuonSegment*> sortedSegments[2][4];           //[AC][MDTStation]
  
  // Holds Segments which have been disqualified, any segments in this array are ignored when looping through sortedSegments
  std::vector<const Muon::MuonSegment*> DQdisqualifiedSegments[2][4];   //[AC][MDTStation] // Segments which have been disqualified by DQ
  std::vector<const Muon::MuonSegment*> MATCHdisqualifiedSegments[2][4];//[AC][MDTStation] // Segments which have been disqualified by DQ or already been included in a track
  
  // Holds Segments which have been matched into a track
  std::vector<SegmTrack> matchedSegments[2];             //[AC]
  
  
  // Sort and filter Segments
  
  // Sort Segments from segmcollection into correct bin in sortedSegments array
  SortMDTSegments(newmdtsegment, sortedSegments);
  // Disqualify Segments with bad DQ
  DQCheckMDTSegments(sortedSegments, DQdisqualifiedSegments);
  for(int i=0;i<2;i++){
    for(int jMDT=0;jMDT<4;jMDT++){
      MATCHdisqualifiedSegments[i][jMDT] = DQdisqualifiedSegments[i][jMDT];
    }
  }
  
  
  // Segment Track Method
  // Match up Segments into tracks
  MatchMDTSegments(sortedSegments, MATCHdisqualifiedSegments, matchedSegments);
  // Use tracks to look for TGC hits
  CheckTGConTrack(matchedSegments, tgc_prepcontainer);
 
  
  // Midstation-only Method
  
  // Use segments to check Midstation again
  MidstationOnlyCheck(sortedSegments, DQdisqualifiedSegments, tgc_prepcontainer);
  
  return;
}// End of function

tgceffcalcfinalize()

void MdtVsTgcRawDataValAlg::tgceffcalcfinalize ( )

private

Definition at line 144 of file MdtVsTgcRawData_TGCEffCheck.cxx.

                                         {
  int   beff, bdenom, berror;
  float feff, fdenom;
  for(int i=0;i<2;i++){// AC
    // Station Coordinate Efficiency Histograms
    for(int k=0;k<2;k++){// WireStrip
      // Loop Numerator and Denominator, total up histograms
      for(int e=1;e<3;e++){
        TList histlist;
        histlist.Add(m_eff_stationmapbase[i][k][e]);
        histlist.Add(m_eff_stationmapmid[i][k][e]);
        m_eff_stationmap[i][k][e]->Merge(&histlist);
      }
      
      const int nhtypes = 3;
      // Make array of pointers to different efficiency histogram types
      TH2 *histarray[nhtypes][4] = {{  m_eff_stationmapbase[i][k][0],  m_eff_stationmapbase[i][k][1],  m_eff_stationmapbase[i][k][2],  m_eff_stationmapbase[i][k][3]},
                                    {   m_eff_stationmapmid[i][k][0],   m_eff_stationmapmid[i][k][1],   m_eff_stationmapmid[i][k][2],   m_eff_stationmapmid[i][k][3]},
                                    {      m_eff_stationmap[i][k][0],      m_eff_stationmap[i][k][1],      m_eff_stationmap[i][k][2],      m_eff_stationmap[i][k][3]}};
      for(int h=0;h<nhtypes;h++){
        // Calculate Efficiency
        histarray[h][0]->Divide(histarray[h][1], histarray[h][2]);
        
        // Calculate Error
        int nX=histarray[h][3]->GetNbinsX();
        int nY=histarray[h][3]->GetNbinsY();
        for(int x=1;x<=nX;x++){
          for(int y=1;y<=nY;y++){
            beff  =histarray[h][0]->GetBin(x,y);
            bdenom=histarray[h][2]->GetBin(x,y);
            berror=histarray[h][3]->GetBin(x,y);
            
            feff  =histarray[h][0]->GetBinContent(beff);
            fdenom=histarray[h][2]->GetBinContent(bdenom);
            
            float result = 0;
            if(fdenom>0){
              result=sqrt(feff*(1-feff)/fdenom);
            }
            histarray[h][3]->SetBinContent(berror,result);
          }// nY Bins
        }// nX Bins
      }
    }// WireStrip
  }// AC
  
  return;
}// End of function

TGCgetlayer()

int MdtVsTgcRawDataValAlg::TGCgetlayer ( int stationName, int g )

private

Definition at line 195 of file MdtVsTgcRawData_TGCEffCheck.cxx.

                                                        {
  if(g<1){
    ATH_MSG_WARNING( "TGCgetlayer passed invalid gasgap g=" << g  );
    return -1;
  }
  int l = g-1;
  if(stationName==41||stationName==42){
    if(g>3){
      ATH_MSG_WARNING( "TGCgetlayer passed invalid gasgap and stationName combination n=" << stationName << " g=" << g  );
      return -1;
    }
  }else if(stationName==43||stationName==44){
    if(g>2){
      ATH_MSG_WARNING( "TGCgetlayer passed invalid gasgap and stationName combination n=" << stationName << " g=" << g  );
      return -1;
    }
    l+=3;
  }else if(stationName==45||stationName==46){
    if(g>2){
      ATH_MSG_WARNING( "TGCgetlayer passed invalid gasgap and stationName combination n=" << stationName << " g=" << g  );
      return -1;
    }
    l+=5;
  }else if(stationName==47||stationName==48){
    if(g>2){
      ATH_MSG_WARNING( "TGCgetlayer passed invalid gasgap and stationName combination n=" << stationName << " g=" << g  );
      return -1;
    }
    l+=7;
  }else{
    ATH_MSG_WARNING( "TGCgetlayer passed invalid stationName n=" << stationName  );
    return -1;
  }
  return l;
}// End of function

TGClayer2stationindex()

int MdtVsTgcRawDataValAlg::TGClayer2stationindex ( int l )

private

Definition at line 233 of file MdtVsTgcRawData_TGCEffCheck.cxx.

                                                 {
  if(l==0||l==1||l==2)return 0;
  else if(l==3||l==4)return 1;
  else if(l==5||l==6)return 2;
  else if(l==7||l==8)return 3;
  else{
    ATH_MSG_WARNING( "TGClayer2Station passed invalid layer number:" << l  );
    return -1;
  }
}// End of function

TGCstationname2stationindex()

int MdtVsTgcRawDataValAlg::TGCstationname2stationindex ( int stationName )

private

Definition at line 245 of file MdtVsTgcRawData_TGCEffCheck.cxx.

                                                                 {
  if(stationName==41||stationName==42)return 0;
  else if(stationName==43||stationName==44)return 1;
  else if(stationName==45||stationName==46)return 2;
  else if(stationName==47||stationName==48)return 3;
  else{
    ATH_MSG_WARNING( "TGCstationname2stationindex passed invalid stationName n=" << stationName  );
    return -1;
  }
}// End of function

THistSvc_deReg_fixTGraph()

StatusCode ManagedMonitorToolBase::THistSvc_deReg_fixTGraph ( TFile * file, TGraph * theGraph, std::string & directoryName )

protectedinherited

Fixes THistSvc->deReg(obj) when obj is TGraph instance.

Read more in source file about this bug.

Definition at line 1037 of file ManagedMonitorToolBase.cxx.

{
    // THistSvc employs TDirectory Append method when registering TGraph.
    // When deReg is used to de-register TGraph object, THistSvc only removes the object
    // from its internal management but forgets to delete from TDirectory.
    // The current method fixes this problem by removing the TGraph object manually
    // after THistSvc->deReg(TGraph* obj) is called.
 
    // Saves and restores gFile and gDirectory
    GlobalDirectoryRestore restore;
 
    // This check is true when TGraph object is removed successfully
    bool graphRemoved = false;
 
    file->cd("/");
    TDirectory* dir = file->GetDirectory(directoryName.c_str());
    if (dir != 0) {
        dir->cd();
        TObject* obj = dir->Remove(theGraph);
        if (obj != 0) 
            graphRemoved = true;
    } 
 
    if (!graphRemoved) {
        return StatusCode::FAILURE;
    }
 
    return StatusCode::SUCCESS;
}

trigChainsArePassed()

bool ManagedMonitorToolBase::trigChainsArePassed ( std::vector< std::string > & vTrigNames )

protectedvirtualinherited

Definition at line 2093 of file ManagedMonitorToolBase.cxx.

{
  ATH_MSG_DEBUG( "ManagedMonitorToolBase::trigChainsArePassed:");
 
   for(unsigned int i=0; i<vTrigNames.size(); i++) {
      if( m_trigDecTool->isPassed(vTrigNames[i]) ) {
    ATH_MSG_DEBUG( "  + \"" << vTrigNames[i] << "\" passed, returning \'true\'");
    return true;
      }
      else {
    ATH_MSG_DEBUG( "  - \"" << vTrigNames[i] << "\" did not pass");
      }
   }
 
   return false;
}

updateTriggersForGroups()

void ManagedMonitorToolBase::updateTriggersForGroups ( std::vector< std::string > & vTrigChainNames )

protectedinherited

Definition at line 2131 of file ManagedMonitorToolBase.cxx.

                                                               {
  for (size_t i = 0; i < vTrigChainNames.size(); ++i) {
    std::string& thisName = vTrigChainNames[i];
    if (thisName.compare(0, 9, "CATEGORY_") ==0) {
      ATH_MSG_DEBUG("Found a trigger category: " << thisName << ". We will unpack it.");
      std::vector<std::string> triggers = m_trigTranslator->translate(thisName.substr(9,std::string::npos));
      std::ostringstream oss;
      oss << "(";
      for (size_t itrig = 0; itrig < triggers.size(); ++itrig) {
    if (itrig != 0) { 
      oss << "|";
    }
    oss << triggers[itrig];
      }
      oss << ")";
      // replace with new value
      std::string newval = oss.str();
      ATH_MSG_DEBUG("Replaced with " << newval);
      vTrigChainNames[i] = std::move(newval);
    }
  }
}

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

writeAndDelete()

StatusCode ManagedMonitorToolBase::writeAndDelete ( TH1 * h, const MonGroup & group )

virtualinherited

Write out histogram and delete it.

Definition at line 1600 of file ManagedMonitorToolBase.cxx.

                                                {
  if (!h)
    return StatusCode::FAILURE;
  
  std::string hName = h->GetName();
  
  if( m_manager != 0 ) {
    std::string genericName = NoOutputStream().getStreamName( this, group, hName );
    m_manager->writeAndDelete( genericName );
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_bookHistogramsInitial

bool ManagedMonitorToolBase::m_bookHistogramsInitial

privateinherited

Definition at line 894 of file ManagedMonitorToolBase.h.

m_chamberName

std::string MdtVsTgcRawDataValAlg::m_chamberName

private

Definition at line 75 of file MdtVsTgcRawDataValAlg.h.

m_checkCabling

bool MdtVsTgcRawDataValAlg::m_checkCabling

private

Definition at line 72 of file MdtVsTgcRawDataValAlg.h.

m_cosmicStation

int MdtVsTgcRawDataValAlg::m_cosmicStation

private

Definition at line 80 of file MdtVsTgcRawDataValAlg.h.

m_d

Imp* ManagedMonitorToolBase::m_d

privateinherited

Definition at line 901 of file ManagedMonitorToolBase.h.

m_dataType

AthenaMonManager::DataType_t ManagedMonitorToolBase::m_dataType

protectedinherited

Definition at line 839 of file ManagedMonitorToolBase.h.

m_dataTypeStr

std::string ManagedMonitorToolBase::m_dataTypeStr

protectedinherited

Definition at line 835 of file ManagedMonitorToolBase.h.

m_defaultLBDuration

float ManagedMonitorToolBase::m_defaultLBDuration

privateinherited

Definition at line 896 of file ManagedMonitorToolBase.h.

m_detailLevel

unsigned int ManagedMonitorToolBase::m_detailLevel

protectedinherited

Definition at line 837 of file ManagedMonitorToolBase.h.

m_DetectorManagerKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> MdtVsTgcRawDataValAlg::m_DetectorManagerKey

private

Initial value:

{this, "DetectorManagerKey", 
      "MuonDetectorManager", 
      "Key of input MuonDetectorManager condition data"}

Definition at line 66 of file MdtVsTgcRawDataValAlg.h.

                                                                      {this, "DetectorManagerKey", 
      "MuonDetectorManager", 
      "Key of input MuonDetectorManager condition data"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_DQFilterTools

ToolHandleArray<IDQFilterTool> ManagedMonitorToolBase::m_DQFilterTools {this,"FilterTools",{}}

protectedinherited

Definition at line 850 of file ManagedMonitorToolBase.h.

{this,"FilterTools",{}};

m_eff_stationmap

TH2* MdtVsTgcRawDataValAlg::m_eff_stationmap[2][2][4] {}

private

Definition at line 145 of file MdtVsTgcRawDataValAlg.h.

{};         // [AC][WireStrip][EffNumDenomError] //Filled in postprocessor

m_eff_stationmapbase

TH2* MdtVsTgcRawDataValAlg::m_eff_stationmapbase[2][2][4] {}

private

Definition at line 143 of file MdtVsTgcRawDataValAlg.h.

{};     // [AC][WireStrip][EffNumDenomError]

m_eff_stationmapmid

TH2* MdtVsTgcRawDataValAlg::m_eff_stationmapmid[2][2][4] {}

private

Definition at line 144 of file MdtVsTgcRawDataValAlg.h.

{};      // [AC][WireStrip][EffNumDenomError]

m_endOfEventsBlock

bool ManagedMonitorToolBase::m_endOfEventsBlock

privateinherited

Definition at line 824 of file ManagedMonitorToolBase.h.

m_endOfLowStat

bool ManagedMonitorToolBase::m_endOfLowStat

privateinherited

Definition at line 824 of file ManagedMonitorToolBase.h.

m_endOfLumiBlock

bool ManagedMonitorToolBase::m_endOfLumiBlock

privateinherited

Definition at line 824 of file ManagedMonitorToolBase.h.

m_endOfRun

bool ManagedMonitorToolBase::m_endOfRun

privateinherited

Definition at line 824 of file ManagedMonitorToolBase.h.

m_environment

AthenaMonManager::Environment_t ManagedMonitorToolBase::m_environment

protectedinherited

Definition at line 840 of file ManagedMonitorToolBase.h.

m_environmentStr

std::string ManagedMonitorToolBase::m_environmentStr

protectedinherited

Definition at line 836 of file ManagedMonitorToolBase.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_fileKey

std::string ManagedMonitorToolBase::m_fileKey

protectedinherited

Definition at line 834 of file ManagedMonitorToolBase.h.

m_haveClearedLastEventBlock

bool ManagedMonitorToolBase::m_haveClearedLastEventBlock

protectedinherited

Definition at line 867 of file ManagedMonitorToolBase.h.

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MdtVsTgcRawDataValAlg::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 69 of file MdtVsTgcRawDataValAlg.h.

{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_lastEvent

int MdtVsTgcRawDataValAlg::m_lastEvent

private

Definition at line 79 of file MdtVsTgcRawDataValAlg.h.

m_lastHigStatInterval

int ManagedMonitorToolBase::m_lastHigStatInterval

protectedinherited

Definition at line 862 of file ManagedMonitorToolBase.h.

m_lastLowStatInterval

int ManagedMonitorToolBase::m_lastLowStatInterval

protectedinherited

Definition at line 862 of file ManagedMonitorToolBase.h.

m_lastLumiBlock

unsigned int ManagedMonitorToolBase::m_lastLumiBlock

protectedinherited

Definition at line 860 of file ManagedMonitorToolBase.h.

m_lastMedStatInterval

int ManagedMonitorToolBase::m_lastMedStatInterval

protectedinherited

Definition at line 862 of file ManagedMonitorToolBase.h.

m_lastRun

unsigned int ManagedMonitorToolBase::m_lastRun

protectedinherited

Definition at line 861 of file ManagedMonitorToolBase.h.

m_lbDurationDataKey

SG::ReadCondHandleKey<LBDurationCondData> ManagedMonitorToolBase::m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}

privateinherited

Definition at line 889 of file ManagedMonitorToolBase.h.

{this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"};

m_lumiDataKey

SG::ReadCondHandleKey<LuminosityCondData> ManagedMonitorToolBase::m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}

privateinherited

Definition at line 887 of file ManagedMonitorToolBase.h.

{this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"};

m_manager

AthenaMonManager* ManagedMonitorToolBase::m_manager

protectedinherited

Definition at line 830 of file ManagedMonitorToolBase.h.

m_managerNameProp

std::string ManagedMonitorToolBase::m_managerNameProp

protectedinherited

Definition at line 832 of file ManagedMonitorToolBase.h.

m_mdt_PrepDataContainerName

SG::ReadHandleKey<Muon::MdtPrepDataContainer> MdtVsTgcRawDataValAlg::m_mdt_PrepDataContainerName {this,"MdtPrepDataContainer","MDT_DriftCircles","MDT PRDs"}

private

Definition at line 83 of file MdtVsTgcRawDataValAlg.h.

{this,"MdtPrepDataContainer","MDT_DriftCircles","MDT PRDs"};

m_mdt_SegmentCollectionName

SG::ReadHandleKey<xAOD::MuonSegmentContainer> MdtVsTgcRawDataValAlg::m_mdt_SegmentCollectionName {this,"MdtSegmentCollection","MuonSegments","muon segments"}

private

Definition at line 84 of file MdtVsTgcRawDataValAlg.h.

{this,"MdtSegmentCollection","MuonSegments","muon segments"};

m_mdt_segmmap

TH2* MdtVsTgcRawDataValAlg::m_mdt_segmmap[2][4] {}

private

Definition at line 111 of file MdtVsTgcRawDataValAlg.h.

{};        // [AC][StationIndex]

m_mdt_segmmatchsag

TH1* MdtVsTgcRawDataValAlg::m_mdt_segmmatchsag[2][4][4][4] {}

private

Definition at line 150 of file MdtVsTgcRawDataValAlg.h.

{};    // [AC][MDTStation][MDTStation][RhoEtaPhiThe]

m_mdt_segmposdirsag

TH1* MdtVsTgcRawDataValAlg::m_mdt_segmposdirsag[2][4][4] {}

private

Definition at line 151 of file MdtVsTgcRawDataValAlg.h.

{};      // [AC][MDTStation][RhoEtaPhiThe]

m_mdt_trackchecksag

TH1* MdtVsTgcRawDataValAlg::m_mdt_trackchecksag[2][4][4][4][2] {}

private

Definition at line 153 of file MdtVsTgcRawDataValAlg.h.

{};// [AC][MDTStation][MDTStation][RhoEtaPhiThe]

m_mdt_trackdirdirsag

TH1* MdtVsTgcRawDataValAlg::m_mdt_trackdirdirsag[2][4][4][4] {}

private

Definition at line 152 of file MdtVsTgcRawDataValAlg.h.

{};  // [AC][MDTStation][MDTStation][RhoEtaPhiThe]

m_MdtAdcCut

int MdtVsTgcRawDataValAlg::m_MdtAdcCut

private

Definition at line 86 of file MdtVsTgcRawDataValAlg.h.

m_MdtTdcCut

int MdtVsTgcRawDataValAlg::m_MdtTdcCut

private

Definition at line 87 of file MdtVsTgcRawDataValAlg.h.

m_metadataMap

MDMap_t ManagedMonitorToolBase::m_metadataMap

protectedinherited

Definition at line 828 of file ManagedMonitorToolBase.h.

m_mvt_cutspassed

TH1* MdtVsTgcRawDataValAlg::m_mvt_cutspassed[2] {}

private

Definition at line 109 of file MdtVsTgcRawDataValAlg.h.

{};        // [AC]

m_mvt_extrprdsag

TH1* MdtVsTgcRawDataValAlg::m_mvt_extrprdsag[2][4][2][2][4] {}

private

Definition at line 147 of file MdtVsTgcRawDataValAlg.h.

{};   // [AC][TGCStation][FE][WireStrip][RhoEtaPhi]

m_mvt_extrprdsag2

TH1* MdtVsTgcRawDataValAlg::m_mvt_extrprdsag2[2][4][2][2][4] {}

private

Definition at line 148 of file MdtVsTgcRawDataValAlg.h.

{};  // [AC][TGCStation][FE][WireStrip][RhoEtaPhi]

m_nEvents

unsigned int ManagedMonitorToolBase::m_nEvents

protectedinherited

Definition at line 864 of file ManagedMonitorToolBase.h.

m_nEventsIgnoreTrigger

unsigned int ManagedMonitorToolBase::m_nEventsIgnoreTrigger

protectedinherited

Definition at line 865 of file ManagedMonitorToolBase.h.

m_newEventsBlock

bool ManagedMonitorToolBase::m_newEventsBlock

privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

m_newHigStatInterval

bool ManagedMonitorToolBase::m_newHigStatInterval

privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

m_newLowStat

bool ManagedMonitorToolBase::m_newLowStat

privateinherited

Definition at line 822 of file ManagedMonitorToolBase.h.

m_newLowStatInterval

bool ManagedMonitorToolBase::m_newLowStatInterval

privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

m_newLumiBlock

bool ManagedMonitorToolBase::m_newLumiBlock

privateinherited

Definition at line 822 of file ManagedMonitorToolBase.h.

m_newMedStatInterval

bool ManagedMonitorToolBase::m_newMedStatInterval

privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

m_newRun

bool ManagedMonitorToolBase::m_newRun

privateinherited

Definition at line 822 of file ManagedMonitorToolBase.h.

m_nLumiBlocks

unsigned int ManagedMonitorToolBase::m_nLumiBlocks

protectedinherited

Definition at line 866 of file ManagedMonitorToolBase.h.

m_path

std::string ManagedMonitorToolBase::m_path

protectedinherited

Definition at line 853 of file ManagedMonitorToolBase.h.

m_preScaleProp

long ManagedMonitorToolBase::m_preScaleProp

protectedinherited

Definition at line 854 of file ManagedMonitorToolBase.h.

m_procNEventsProp

long ManagedMonitorToolBase::m_procNEventsProp

protectedinherited

Definition at line 852 of file ManagedMonitorToolBase.h.

m_sector

int MdtVsTgcRawDataValAlg::m_sector

private

Definition at line 77 of file MdtVsTgcRawDataValAlg.h.

m_side

int MdtVsTgcRawDataValAlg::m_side

private

Definition at line 78 of file MdtVsTgcRawDataValAlg.h.

m_stationHists

MuonDQAHistMap MdtVsTgcRawDataValAlg::m_stationHists

private

Definition at line 63 of file MdtVsTgcRawDataValAlg.h.

m_StationSize

std::string MdtVsTgcRawDataValAlg::m_StationSize

private

Definition at line 76 of file MdtVsTgcRawDataValAlg.h.

m_streamNameFcn

StreamNameFcn* ManagedMonitorToolBase::m_streamNameFcn

protectedinherited

Definition at line 842 of file ManagedMonitorToolBase.h.

m_supportedIntervalsForRebooking

std::set<Interval_t> ManagedMonitorToolBase::m_supportedIntervalsForRebooking

privateinherited

Definition at line 897 of file ManagedMonitorToolBase.h.

m_templateEfficiencies

std::map< Interval_t, std::vector< MgmtParams<TEfficiency> > > ManagedMonitorToolBase::m_templateEfficiencies

protectedinherited

Definition at line 677 of file ManagedMonitorToolBase.h.

m_templateGraphs

std::map< Interval_t, std::vector< MgmtParams<TGraph> > > ManagedMonitorToolBase::m_templateGraphs

protectedinherited

Definition at line 669 of file ManagedMonitorToolBase.h.

m_templateHistograms

std::map< Interval_t, std::vector< MgmtParams<TH1> > > ManagedMonitorToolBase::m_templateHistograms

protectedinherited

Definition at line 665 of file ManagedMonitorToolBase.h.

m_templateTrees

std::map< Interval_t, std::vector< MgmtParams<TTree> > > ManagedMonitorToolBase::m_templateTrees

protectedinherited

Definition at line 673 of file ManagedMonitorToolBase.h.

m_tgc_CoinContainerName

SG::ReadHandleKey<Muon::TgcCoinDataContainer> MdtVsTgcRawDataValAlg::m_tgc_CoinContainerName {this,"OutputCoinCollection","TrigT1CoinDataCollection","TGC coincidences"}

private

Definition at line 82 of file MdtVsTgcRawDataValAlg.h.

{this,"OutputCoinCollection","TrigT1CoinDataCollection","TGC coincidences"};

m_tgc_prdcompsag

TH1* MdtVsTgcRawDataValAlg::m_tgc_prdcompsag[2][2][4] {}

private

Definition at line 149 of file MdtVsTgcRawDataValAlg.h.

{};         // [AC][TGCStation][RhoEtaPhiZ]

m_tgc_PrepDataContainerName

SG::ReadHandleKey<Muon::TgcPrepDataContainer> MdtVsTgcRawDataValAlg::m_tgc_PrepDataContainerName {this,"TgcPrepDataContainer","TGC_Measurements","TGC PRDs"}

private

Definition at line 81 of file MdtVsTgcRawDataValAlg.h.

{this,"TgcPrepDataContainer","TGC_Measurements","TGC PRDs"};

m_tgclv1file

bool MdtVsTgcRawDataValAlg::m_tgclv1file

private

Definition at line 73 of file MdtVsTgcRawDataValAlg.h.

m_THistSvc

ServiceHandle<ITHistSvc> ManagedMonitorToolBase::m_THistSvc

protectedinherited

Definition at line 844 of file ManagedMonitorToolBase.h.

m_TREarray

const MuonGM::TgcReadoutElement* MdtVsTgcRawDataValAlg::m_TREarray[8][2][9][49] {}

private

Definition at line 94 of file MdtVsTgcRawDataValAlg.h.

{}; // [StationName][AC][StationEta][StationPhi]

m_trigDecTool

PublicToolHandle<Trig::ITrigDecisionTool> ManagedMonitorToolBase::m_trigDecTool {this, "TrigDecisionTool",""}

protectedinherited

Definition at line 846 of file ManagedMonitorToolBase.h.

{this, "TrigDecisionTool",""};

m_triggerChainProp

std::string ManagedMonitorToolBase::m_triggerChainProp

protectedinherited

Definition at line 855 of file ManagedMonitorToolBase.h.

m_triggerGroupProp

std::string ManagedMonitorToolBase::m_triggerGroupProp

protectedinherited

Definition at line 856 of file ManagedMonitorToolBase.h.

m_trigLiveFractionDataKey

SG::ReadCondHandleKey<TrigLiveFractionCondData> ManagedMonitorToolBase::m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData","SG Key of TrigLiveFractionCondData object"}

privateinherited

Definition at line 891 of file ManagedMonitorToolBase.h.

{this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData","SG Key of TrigLiveFractionCondData object"};

m_trigTranslator

PublicToolHandle<ITriggerTranslatorTool> ManagedMonitorToolBase::m_trigTranslator {this,"TriggerTranslatorTool",""}

protectedinherited

Definition at line 848 of file ManagedMonitorToolBase.h.

{this,"TriggerTranslatorTool",""};

m_useLumi

bool ManagedMonitorToolBase::m_useLumi

privateinherited

Definition at line 895 of file ManagedMonitorToolBase.h.

m_useTrigger

bool ManagedMonitorToolBase::m_useTrigger

protectedinherited

Definition at line 858 of file ManagedMonitorToolBase.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_vTrigChainNames

std::vector<std::string> ManagedMonitorToolBase::m_vTrigChainNames

protectedinherited

Definition at line 681 of file ManagedMonitorToolBase.h.

m_vTrigGroupNames

std::vector<std::string> ManagedMonitorToolBase::m_vTrigGroupNames

protectedinherited

Definition at line 681 of file ManagedMonitorToolBase.h.

---

The documentation for this class was generated from the following files:

• MdtVsTgcRawDataValAlg.h
• MdtVsTgcRawData_MidstationMatching.cxx
• MdtVsTgcRawData_PRDonTrack.cxx
• MdtVsTgcRawData_SegmDQ.cxx
• MdtVsTgcRawData_SegmMatching.cxx
• MdtVsTgcRawData_SegmSorting.cxx
• MdtVsTgcRawData_bookhistograms.cxx
• MdtVsTgcRawData_correlation.cxx
• MdtVsTgcRawData_functions.cxx
• MdtVsTgcRawData_maptgchits.cxx
• MdtVsTgcRawData_TGCEffCheck.cxx
• MdtVsTgcRawDataValAlg.cxx