CscPeakThresholdClusterBuilderTool Class Reference

#include <CscPeakThresholdClusterBuilderTool.h>

Inheritance diagram for CscPeakThresholdClusterBuilderTool:

Collaboration diagram for CscPeakThresholdClusterBuilderTool:

Public Member Functions
	CscPeakThresholdClusterBuilderTool (const std::string &type, const std::string &aname, const IInterface *)
	~CscPeakThresholdClusterBuilderTool ()
StatusCode	initialize ()
	AlgTool InterfaceID.
StatusCode	getClusters (std::vector< IdentifierHash > &idVect, std::vector< IdentifierHash > &selectedIdVect, Muon::CscPrepDataContainer *object)
StatusCode	finalize ()
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 const InterfaceID &	interfaceID ()

Protected Member Functions
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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
int	make_clusters (bool measphi, const std::vector< const Muon::CscStripPrepData * > &strips, Muon::CscPrepDataCollection *&collection)
StatusCode	getClusters (IdentifierHash idVect, std::vector< IdentifierHash > &selectedIdVect, Muon::CscPrepDataContainer *pclusters)
StatusCode	getClusters (std::vector< IdentifierHash > &selectedIdVect, Muon::CscPrepDataContainer *pclusters)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
double	m_qpeak_threshold_eta
double	m_qpeak_threshold_phi
double	m_q3sum_threshold_eta
double	m_q3sum_threshold_phi
SG::ReadHandleKey< Muon::CscStripPrepDataContainer >	m_digit_key
SG::WriteHandle< Muon::CscPrepDataContainer >	m_cluster_handle
ToolHandle< ICscStripFitter >	m_pstrip_fitter
ToolHandle< ICscClusterFitter >	m_pfitter_def
ToolHandle< ICscClusterFitter >	m_pfitter_prec
ToolHandle< ICscClusterFitter >	m_pfitter_split
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_DetectorManagerKey
	retrieve MuonDetectorManager from the conditions store
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 73 of file CscPeakThresholdClusterBuilderTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

CscPeakThresholdClusterBuilderTool()

CscPeakThresholdClusterBuilderTool::CscPeakThresholdClusterBuilderTool	(	const std::string &	type,
		const std::string &	aname,
		const IInterface *	parent )

Definition at line 66 of file CscPeakThresholdClusterBuilderTool.cxx.

                                                                                                 :
    AthAlgTool(type, aname, parent), m_digit_key("CSC_Measurements") {
    declareInterface<ICscClusterBuilder>(this);
 
    declareProperty("qpeak_threshold_eta", m_qpeak_threshold_eta = 21000.0);
    declareProperty("qpeak_threshold_phi", m_qpeak_threshold_phi = 33000.0);
    declareProperty("q3sum_threshold_eta", m_q3sum_threshold_eta = 38000.0);
    declareProperty("q3sum_threshold_phi", m_q3sum_threshold_phi = 33000.0);
    declareProperty("digit_key", m_digit_key);
}

~CscPeakThresholdClusterBuilderTool()

CscPeakThresholdClusterBuilderTool::~CscPeakThresholdClusterBuilderTool ( )

default

Member Function Documentation

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());
  }

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; }

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

finalize()

StatusCode CscPeakThresholdClusterBuilderTool::finalize

(

)

Definition at line 324 of file CscPeakThresholdClusterBuilderTool.cxx.

                                                        {
    ATH_MSG_VERBOSE("Finalizing " << name());
    return StatusCode::SUCCESS;
}

getClusters() [1/3]

StatusCode CscPeakThresholdClusterBuilderTool::getClusters ( IdentifierHash idVect, std::vector< IdentifierHash > & selectedIdVect, Muon::CscPrepDataContainer * pclusters )

private

Definition at line 148 of file CscPeakThresholdClusterBuilderTool.cxx.

                                                                                                {
    // identifiers of collections already decoded and stored in the container will be skipped
    if (pclusters->indexFindPtr(givenHashId) != nullptr) {
        decodedIds.push_back(givenHashId);
        ATH_MSG_DEBUG("A collection already exists in the container for offline id hash. " << (int)givenHashId);
        return StatusCode::SUCCESS;
    }
 
    // Retrieve the CSC digits for this event.
    SG::ReadHandle<CscStripPrepDataContainer> pdigcon(m_digit_key);
    if (pdigcon.isValid()) {
        ATH_MSG_DEBUG("Retrieved strip container " << m_digit_key.key() << " with " << pdigcon->size() << " entries.");
    } else {
        ATH_MSG_WARNING("Failure to retrieve strip container " << m_digit_key.key());
        return StatusCode::SUCCESS;
    }
 
    //**********************************************
    // retrieve specific collection for the givenID
    const CscStripPrepDataCollection* col = pdigcon->indexFindPtr(givenHashId);
    if (nullptr == col) {
        unsigned int coll_hash = givenHashId;
        ATH_MSG_WARNING("Specific CSC Strip PrepData collection retrieving failed for collection hash = " << coll_hash);
        return StatusCode::SUCCESS;
    }
 
    ATH_MSG_DEBUG("Retrieved " << col->size() << " CSC Strip PrepDatas.");
 
    Identifier colid = col->identify();
    int istation = m_idHelperSvc->cscIdHelper().stationName(colid) - 49;
    int zsec = m_idHelperSvc->cscIdHelper().stationEta(colid);
    int phisec = m_idHelperSvc->cscIdHelper().stationPhi(colid);
 
    ATH_MSG_DEBUG("  Strip collection " << chamber(istation, zsec, phisec) << " has " << col->size() << " strips");
 
    // Create arrays to hold digits and cathode plane parameters.
    vector<const CscStripPrepData*> strips[8];
    int maxstrip[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 
    // retrieve 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 MuonDetectorManager conditions object");
        return StatusCode::FAILURE;
    }
 
    IdentifierHash hash;
    // Loop over digits and fill these arrays.
    for (CscStripPrepDataCollection::const_iterator idig = col->begin(); idig != col->end(); ++idig) {
        const CscStripPrepData& dig = **idig;
        Identifier did = dig.identify();
        hash = dig.collectionHash();
        const CscReadoutElement* pro = MuonDetMgr->getCscReadoutElement(did);
        int wlay = m_idHelperSvc->cscIdHelper().wireLayer(did);
        int measphi = m_idHelperSvc->cscIdHelper().measuresPhi(did);
        int idx = 2 * (wlay - 1) + measphi;
        // First entry for a cathode plane, initialize.
        if (maxstrip[idx] == 0) {
            maxstrip[idx] = pro->maxNumberOfStrips(measphi);
            for (int istrip = 0; istrip < maxstrip[idx]; ++istrip) strips[idx].push_back(nullptr);
        }
        int istrip = m_idHelperSvc->cscIdHelper().strip(did) - 1;
        if (istrip < 0 || istrip >= maxstrip[idx]) {
            ATH_MSG_WARNING("Invalid strip number");
            continue;
        }
        strips[idx][istrip] = &dig;
    }
 
    // Cluster.
    CscPrepDataCollection* newCollection = nullptr;
    for (int measphi = 0; measphi < 2; ++measphi) {
        for (int wlay = 1; wlay < 5; ++wlay) {
            int idx = 2 * (wlay - 1) + measphi;
            if (maxstrip[idx]) {
                make_clusters(measphi, strips[idx], newCollection);
                ATH_MSG_DEBUG("    " << wlay << "th layer ");
            }
        }
    }
    if (newCollection) {
        if (pclusters->addCollection(newCollection, hash).isFailure()) {
            ATH_MSG_ERROR("Couldn't add CscPrepdataCollection to container!");
            return StatusCode::FAILURE;
        }
        decodedIds.push_back(hash);  // Record that this collection contains data
    }
 
    return StatusCode::SUCCESS;
}

getClusters() [2/3]

StatusCode CscPeakThresholdClusterBuilderTool::getClusters ( std::vector< IdentifierHash > & idVect, std::vector< IdentifierHash > & selectedIdVect, Muon::CscPrepDataContainer * object )

virtual

Implements ICscClusterBuilder.

Definition at line 124 of file CscPeakThresholdClusterBuilderTool.cxx.

                                                                                             {
    // clear output vector of selected data collections containing data
    decodedIds.clear();
 
    if (!givenIDs.empty()) {
        for (unsigned int i = 0; i < givenIDs.size(); ++i) {
            if (getClusters(givenIDs[i], decodedIds, object).isFailure()) {
                ATH_MSG_ERROR("Unable to decode CSC RDO " << i << "th into CSC PrepRawData");
                return StatusCode::RECOVERABLE;
            }
        }
    } else {
        // Clusterization is done for every area
        if (getClusters(decodedIds, object).isFailure()) {
            ATH_MSG_ERROR("Unable to decode CSC RDO into CSC PrepRawData");
            return StatusCode::RECOVERABLE;
        }
    }
    return StatusCode::SUCCESS;
}

getClusters() [3/3]

StatusCode CscPeakThresholdClusterBuilderTool::getClusters ( std::vector< IdentifierHash > & selectedIdVect, Muon::CscPrepDataContainer * pclusters )

private

Definition at line 243 of file CscPeakThresholdClusterBuilderTool.cxx.

                                                                                                                                     {
    // Retrieve the CSC digits for this event.
 
    SG::ReadHandle<CscStripPrepDataContainer> pdigcon(m_digit_key);
    if (pdigcon.isValid()) {
        ATH_MSG_DEBUG("Retrieved strip container " << m_digit_key.key() << " with " << pdigcon->size() << " entries.");
    } else {
        ATH_MSG_WARNING("Failure to retrieve strip container " << m_digit_key.key());
        return StatusCode::SUCCESS;
    }
 
    // Loop over digit collections.
    // This a loop over chambers (each with 4 wire planes).
    const CscStripPrepDataContainer& con = *pdigcon;
    for (CscStripPrepDataContainer::const_iterator icol = con.begin(); icol != con.end(); ++icol) {
        const CscStripPrepDataCollection& col = **icol;
        Identifier colid = col.identify();
        int istation = m_idHelperSvc->cscIdHelper().stationName(colid) - 49;
        int zsec = m_idHelperSvc->cscIdHelper().stationEta(colid);
        int phisec = m_idHelperSvc->cscIdHelper().stationPhi(colid);
        ATH_MSG_DEBUG("  Strip collection " << chamber(istation, zsec, phisec) << " has " << col.size() << " strips");
 
        // Create arrays to hold digits and cathode plane parameters.
        vector<const CscStripPrepData*> strips[8];
        int maxstrip[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 
        // retrieve 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 MuonDetectorManager conditions object");
            return StatusCode::FAILURE;
        }
 
        IdentifierHash hash;
        // Loop over digits and fill these arrays.
        for (CscStripPrepDataCollection::const_iterator idig = col.begin(); idig != col.end(); ++idig) {
            const CscStripPrepData& dig = **idig;
            Identifier did = dig.identify();
            hash = dig.collectionHash();
            const CscReadoutElement* pro = MuonDetMgr->getCscReadoutElement(did);
            int wlay = m_idHelperSvc->cscIdHelper().wireLayer(did);
            int measphi = m_idHelperSvc->cscIdHelper().measuresPhi(did);
            int idx = 2 * (wlay - 1) + measphi;
            // First entry for a cathode plane, initialize.
            if (maxstrip[idx] == 0) {
                maxstrip[idx] = pro->maxNumberOfStrips(measphi);
                for (int istrip = 0; istrip < maxstrip[idx]; ++istrip) strips[idx].push_back(nullptr);
            }
            int istrip = m_idHelperSvc->cscIdHelper().strip(did) - 1;
            if (istrip < 0 || istrip >= maxstrip[idx]) {
                ATH_MSG_WARNING("Invalid strip number");
                continue;
            }
            strips[idx][istrip] = &dig;
        }
 
        // Cluster.
        CscPrepDataCollection* newCollection = nullptr;
        for (int measphi = 0; measphi < 2; ++measphi) {
            for (int wlay = 1; wlay < 5; ++wlay) {
                int idx = 2 * (wlay - 1) + measphi;
                if (maxstrip[idx]) {
                    make_clusters(measphi, strips[idx], newCollection);
                    ATH_MSG_DEBUG("    " << wlay << "th layer ");
                }
            }
        }
        if (newCollection) {
            if (pclusters->addCollection(newCollection, hash).isFailure()) {
                ATH_MSG_ERROR("Couldn't add CscPrepdataCollection to container!");
                return StatusCode::FAILURE;
            }
            decodedIds.push_back(hash);  // Record that this collection contains data
        }
    }  // end loop over chambers
 
    return StatusCode::SUCCESS;
}

initialize()

StatusCode CscPeakThresholdClusterBuilderTool::initialize

(

)

AlgTool InterfaceID.

Definition at line 86 of file CscPeakThresholdClusterBuilderTool.cxx.

                                                          {
    ATH_MSG_DEBUG("Initializing " << name());
    ATH_CHECK(m_digit_key.initialize());
    // Display algorithm properties.
    ATH_MSG_DEBUG("Properties for " << name() << ":");
    ATH_MSG_DEBUG("  Cluster qpeak threshold is eta/phi " << m_qpeak_threshold_eta << "/" << m_qpeak_threshold_phi);
    ATH_MSG_DEBUG("  Cluster q3sum threshold is eta/phi " << m_q3sum_threshold_eta << "/" << m_q3sum_threshold_phi);
    ATH_MSG_DEBUG("  Strip fitter is " << m_pstrip_fitter.typeAndName());
    ATH_MSG_DEBUG("  Default cluster fitter is " << m_pfitter_def.typeAndName());
    ATH_MSG_DEBUG("  Precision cluster fitter is " << m_pfitter_prec.typeAndName());
    ATH_MSG_DEBUG("  Split cluster fitter is " << m_pfitter_split.typeAndName());
    ATH_MSG_DEBUG("  Input digit key is " << m_digit_key.key());
 
    // Retrieve the strip fitting tool.
    ATH_CHECK(m_pstrip_fitter.retrieve());
    ATH_MSG_DEBUG("Retrieved strip fitting tool " << m_pstrip_fitter);
 
    // Retrieve the default cluster fitting tool.
    ATH_CHECK(m_pfitter_def.retrieve());
    ATH_MSG_DEBUG("Retrieved CSC default cluster fitting tool");
 
    // Retrieve the precision cluster fitting tool.
    ATH_CHECK(m_pfitter_prec.retrieve());
    ATH_MSG_DEBUG("Retrieved CSC precision cluster fitting tool");
 
    // Retrieve the split cluster fitting tool.
    ATH_CHECK(m_pfitter_split.retrieve());
    ATH_MSG_DEBUG("Retrieved CSC split cluster fitting tool");
 
    // retrieve MuonDetectorManager from the conditions store
    ATH_CHECK(m_DetectorManagerKey.initialize());
    ATH_CHECK(m_idHelperSvc.retrieve());
 
    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 & ICscClusterBuilder::interfaceID ( )

inlinestaticinherited

Must declare this, with name of interface

Definition at line 30 of file ICscClusterBuilder.h.

                                            {
        static const InterfaceID IID_ICscClusterBuilder("ICscClusterBuilder", 1, 0);
        return IID_ICscClusterBuilder;
    }

make_clusters()

int CscPeakThresholdClusterBuilderTool::make_clusters ( bool measphi, const std::vector< const Muon::CscStripPrepData * > & strips, Muon::CscPrepDataCollection *& collection )

private

Definition at line 338 of file CscPeakThresholdClusterBuilderTool.cxx.

                                                                                             {
    // CscPrepDataCollection* newCollection = 0;
 
    // Loop over channels.
    unsigned int maxstrip = strips.size();
 
    ATH_MSG_DEBUG("    Clustering for " << setaphi(measphi) << " plane with " << maxstrip << " strips");
 
    // Loop over strips and fetch the charge and time for each.
    // Also set flag indicating if this strip is active, i.e. should be included
    // in a cluster.
    ICscClusterFitter::StripFitList stripfits;
    std::vector<bool> astrip;
    IdentifierHash cscHashId;
 
    for (unsigned int istrip = 0; istrip < strips.size(); ++istrip) {
        const CscStripPrepData* pstrip = strips[istrip];
        ICscClusterFitter::StripFit res;
        res.charge = 0.0;
        res.time = -666.;
        bool active = false;
 
        if (pstrip) {
            if (!newCollection) {
                Identifier elementId = m_idHelperSvc->cscIdHelper().elementID(pstrip->identify());
                cscHashId = pstrip->collectionHash();
                newCollection = new CscPrepDataCollection(cscHashId);
                newCollection->setIdentifier(elementId);
            }
            if (!m_pstrip_fitter) {
                ATH_MSG_WARNING("Unable to locate strip fitter");
                return 1;
            }
            res = m_pstrip_fitter->fit(*pstrip);
            active = res.charge > 0.0;  // Allow all the positive charged strips...
            // Log message.
            ATH_MSG_DEBUG("      Strip " << setw(3) << istrip + 1 << ": charge= " << setw(7) << int(res.charge) << " time=" << setw(3)
                                         << int(res.time + 0.5));
            //        if ( active ) *m_log << " *";
            //        else *m_log << " .";
            //        if ( res.status ) *m_log << " x";
            //        else *m_log << " o";
            //        *m_log );
        }
 
        //    if (res.charge == 0.0) res.charge =40.;
        stripfits.push_back(res);
        astrip.push_back(active);
    }
 
    // Loop over strips and create clusters.
    bool incluster = false;
    int first_strip = 0;  // First strip in the cluster.
    double qpeak = 0;
    ICscClusterFitter::StripFitList sfits;
    std::vector<const CscStripPrepData*> clusterStrips;
    std::vector<Identifier> prd_digit_ids;
    for (unsigned int istrip = 0; istrip < strips.size(); ++istrip) {
        const CscStripPrepData* pstrip = strips[istrip];
        ICscClusterFitter::StripFit sfit = stripfits[istrip];
        double q = sfit.charge;
 
        // If the current strip is not active, skip it.
        if (!astrip[istrip]) continue;
        assert(pstrip != 0);
 
        // First strip in cluster: initialize a new cluster.
        if (!incluster) {
            incluster = true;
            qpeak = q;
            first_strip = istrip;
            sfits.clear();
            clusterStrips.clear();
            prd_digit_ids.clear();
            incluster = true;
        }
 
        // Add strip to the current cluster.
        sfits.push_back(sfit);
        clusterStrips.push_back(pstrip);
        prd_digit_ids.push_back(pstrip->identify());
        if (q > qpeak) qpeak = q;
 
        // If this is not the last strip in the plane, and the next
        // strip is active, add the next strip to the cluster.
        if (istrip != maxstrip - 1 && astrip[istrip + 1]) continue;

        // Create a cluster
        ATH_MSG_VERBOSE("      Creating cluster");
 
        // QPeak Threshold Requirement.................
 
        if (qpeak < (measphi ? m_qpeak_threshold_phi : m_qpeak_threshold_eta)) {  // discard cluster and find new one....
            incluster = false;
            continue;
        }
 
        int fitresult = 99;
        std::vector<ICscClusterFitter::Result> results;
        // Precision fit.
        if (!measphi && m_pfitter_prec) {
            ATH_MSG_VERBOSE("      Performing precision fit with " << m_pfitter_prec);
 
            results = m_pfitter_prec->fit(sfits);
            fitresult = results[0].fitStatus;
 
            ATH_MSG_VERBOSE("        Precision fit result return=" << fitresult);
        }
 
        if (fitresult == 6) {  // in case of multipeak cluster
            ATH_MSG_VERBOSE("      Performing split fit with " << m_pfitter_split);
 
            results = m_pfitter_split->fit(sfits);
            fitresult = results[0].fitStatus;
 
            for (unsigned int i = 0; i < results.size(); ++i) ATH_MSG_VERBOSE("        Split fit result return=" << results[i].fitStatus);
        }
        // if splitcluster is succeeded, fitresult should be either 20 or 21
        // if not, it's 19.
 
        // Default fit.
        if (measphi || (fitresult > 0 && fitresult < 20)) {  // including measphi case
            ATH_MSG_VERBOSE("      Performing default fit with " << m_pfitter_def);
            ICscClusterFitter::Result res;
            if (!measphi) res = results[0];
            CscClusterStatus oldclustatus = res.clusterStatus;
            results = m_pfitter_def->fit(sfits);
            res = results[0];
            fitresult = results[0].fitStatus;
            if (fitresult) {
                ATH_MSG_VERBOSE("        Default fit failed: return=" << fitresult);
                return 1;
            } else {
                ATH_MSG_VERBOSE("        Default fit succeeded");
            }
            // Keep the status from the first fit if it is defined.
            if (oldclustatus != Muon::CscStatusUndefined) {
                res.clusterStatus = oldclustatus;
                // we want to keep oldcluster status
                results[0] = res;
            }
        }
 
        // retrieve 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 MuonDetectorManager conditions object");
            return 0;
        }
 
        // Check results.
        unsigned int nresults = results.size();
        for (unsigned int ire = 0; ire < nresults; ++ire) {
            if (results[ire].qpeak < (measphi ? m_qpeak_threshold_phi : m_qpeak_threshold_eta)) continue;
            double q3sum = results[ire].qleft + results[ire].qpeak + results[ire].qright;
            if (q3sum < (measphi ? m_q3sum_threshold_phi : m_q3sum_threshold_eta)) continue;
 
            CscClusterStatus clustatus = results[ire].clusterStatus;
            Muon::CscTimeStatus timeStatus = results[ire].timeStatus;
            double pos = results[ire].position;
            double err = results[ire].dposition;
            unsigned int id_strip = results[ire].strip;
            double cluster_charge = results[ire].charge;
            double cluster_time = results[ire].time;
            if (clustatus == Muon::CscStatusUndefined) ATH_MSG_DEBUG("      Csc Cluster Status is not defined.");
 
            if (id_strip >= sfits.size()) {
                ATH_MSG_WARNING("        Fit size check failed: ");
                return 1;
            }
            // Fetch the strip used to identify this cluster.
            const CscStripPrepData* pstrip_id = nullptr;
            if (id_strip < clusterStrips.size()) pstrip_id = clusterStrips[id_strip];
            if (!pstrip_id) {
                ATH_MSG_WARNING("        Fit ID check failed: ");
                return 1;
            }
 
            // Create ATLAS CSC cluster.
            Identifier cluster_id = pstrip_id->identify();
            IdentifierHash cluster_hash = pstrip_id->collectionHash();
            int zsec = m_idHelperSvc->cscIdHelper().stationEta(cluster_id);
            int wlay = m_idHelperSvc->cscIdHelper().wireLayer(cluster_id);
            // This local position is in the muon (not tracking) coordinate system.
            //      const CscReadoutElement* pro = pstrip_id->detectorElement();
            const CscReadoutElement* pro = MuonDetMgr->getCscReadoutElement(cluster_id);
            Amg::Vector3D local_pos = pro->nominalLocalClusterPos(zsec, wlay, measphi, pos);
            auto cov = Amg::MatrixX(1, 1);
            (cov)(0, 0) = err * err;
            Amg::Vector2D plpos(measphi ? local_pos.y() : local_pos.z(), measphi ? local_pos.z() : local_pos.y());
 
            if (msgLvl(MSG::DEBUG)) {
                ATH_MSG_DEBUG("        Cluster parameters: " << nresults);
                ATH_MSG_DEBUG("                ID strip: " << first_strip + id_strip << "(" << first_strip << ":" << id_strip << ")");
                ATH_MSG_DEBUG("          local position: " << plpos.x() << " " << plpos.y());
                ATH_MSG_DEBUG("                  error: " << Amg::toString(cov));
                ATH_MSG_DEBUG("                  charge: " << cluster_charge);
                ATH_MSG_DEBUG("                    time: " << cluster_time);
                ATH_MSG_DEBUG("                  status: " << Muon::toString(clustatus));
            }
            std::vector<Identifier> prd_digit_ids_submit;
            unsigned int fstrip = results[ire].fstrip;
            unsigned int lstrip = results[ire].lstrip;
            prd_digit_ids_submit.reserve(lstrip + 1);
            for (unsigned int ids_index = fstrip; ids_index < lstrip + 1; ++ids_index) {
                if (ids_index >= prd_digit_ids.size())
                    ATH_MSG_WARNING(" bad index " << ids_index << " maximum " << prd_digit_ids.size());
                else
                    prd_digit_ids_submit.push_back(prd_digit_ids[ids_index]);
            }
 
            CscPrepData* pclus = new CscPrepData(cluster_id,
                                                 cluster_hash,
                                                 plpos,
                                                 prd_digit_ids_submit,
                                                 cov,
                                                 pro,
                                                 int(cluster_charge + 0.5),
                                                 cluster_time,
                                                 clustatus,
                                                 timeStatus);
            pclus->setHashAndIndex(newCollection->identifyHash(),
                                   newCollection->size());
 
            newCollection->push_back(pclus);
        }
        // Reset incluster.
        incluster = false;
    }  // end loop over strips
    return 0;
}

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);
  }

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.

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();
  }

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 >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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.

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);
      }
    }
  }

Member Data Documentation

m_cluster_handle

SG::WriteHandle<Muon::CscPrepDataContainer> CscPeakThresholdClusterBuilderTool::m_cluster_handle

private

Definition at line 111 of file CscPeakThresholdClusterBuilderTool.h.

m_DetectorManagerKey

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

private

Initial value:

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

retrieve MuonDetectorManager from the conditions store

Definition at line 144 of file CscPeakThresholdClusterBuilderTool.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_digit_key

SG::ReadHandleKey<Muon::CscStripPrepDataContainer> CscPeakThresholdClusterBuilderTool::m_digit_key

private

Definition at line 110 of file CscPeakThresholdClusterBuilderTool.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_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> CscPeakThresholdClusterBuilderTool::m_idHelperSvc

private

Initial value:

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

Definition at line 137 of file CscPeakThresholdClusterBuilderTool.h.

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

m_pfitter_def

ToolHandle<ICscClusterFitter> CscPeakThresholdClusterBuilderTool::m_pfitter_def

private

Initial value:

{
        this,
        "default_fitter",
        "SimpleCscClusterFitter/SimpleCscClusterFitter",
    }

Definition at line 121 of file CscPeakThresholdClusterBuilderTool.h.

                                               {
        this,
        "default_fitter",
        "SimpleCscClusterFitter/SimpleCscClusterFitter",
    };

m_pfitter_prec

ToolHandle<ICscClusterFitter> CscPeakThresholdClusterBuilderTool::m_pfitter_prec

private

Initial value:

{
        this,
        "precision_fitter",
        "QratCscClusterFitter/QratCscClusterFitter",
    }

Definition at line 126 of file CscPeakThresholdClusterBuilderTool.h.

                                                {
        this,
        "precision_fitter",
        "QratCscClusterFitter/QratCscClusterFitter",
    };

m_pfitter_split

ToolHandle<ICscClusterFitter> CscPeakThresholdClusterBuilderTool::m_pfitter_split

private

Initial value:

{
        this,
        "split_fitter",
        "CscSplitClusterFitter/CscSplitClusterFitter",
    }

Definition at line 131 of file CscPeakThresholdClusterBuilderTool.h.

                                                 {
        this,
        "split_fitter",
        "CscSplitClusterFitter/CscSplitClusterFitter",
    };

m_pstrip_fitter

ToolHandle<ICscStripFitter> CscPeakThresholdClusterBuilderTool::m_pstrip_fitter

private

Initial value:

{
        this,
        "strip_fitter",
        "CalibCscStripFitter/CalibCscStripFitter",
    }

Definition at line 114 of file CscPeakThresholdClusterBuilderTool.h.

                                               {
        this,
        "strip_fitter",
        "CalibCscStripFitter/CalibCscStripFitter",
    };

m_q3sum_threshold_eta

double CscPeakThresholdClusterBuilderTool::m_q3sum_threshold_eta

private

Definition at line 108 of file CscPeakThresholdClusterBuilderTool.h.

m_q3sum_threshold_phi

double CscPeakThresholdClusterBuilderTool::m_q3sum_threshold_phi

private

Definition at line 109 of file CscPeakThresholdClusterBuilderTool.h.

m_qpeak_threshold_eta

double CscPeakThresholdClusterBuilderTool::m_qpeak_threshold_eta

private

Definition at line 106 of file CscPeakThresholdClusterBuilderTool.h.

m_qpeak_threshold_phi

double CscPeakThresholdClusterBuilderTool::m_qpeak_threshold_phi

private

Definition at line 107 of file CscPeakThresholdClusterBuilderTool.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.

---

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

• CscPeakThresholdClusterBuilderTool.h
• CscPeakThresholdClusterBuilderTool.cxx