CscOverlay Class Reference

#include <CscOverlay.h>

Inheritance diagram for CscOverlay:

Collaboration diagram for CscOverlay:

Public Member Functions
	CscOverlay (const std::string &name, ISvcLocator *pSvcLocator)
virtual StatusCode	initialize () override final
virtual StatusCode	execute (const EventContext &ctx) const override final
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
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	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

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
StatusCode	overlayContainer (const CscRawDataContainer *bkgContainer, const CscRawDataContainer *signalContainer, CscRawDataContainer *outputContainer) const
	Overlay signal on the background container and record to the output one.
std::unique_ptr< CscRawDataCollection >	copyCollection (const CscRawDataCollection *collection, bool propertiesOnly=false) const
	Copy CscRawDataCollection, optionally only copy properties.
void	mergeCollections (const CscRawDataCollection *bkgCollection, const CscRawDataCollection *signalCollection, CscRawDataCollection *outputCollection, CLHEP::HepRandomEngine *rndmEngine) const
	In case of overlap merge signal and background collections.
void	spuData (const CscRawDataCollection *coll, const uint16_t spuID, std::vector< const CscRawData * > &data) const
	get the data in one SPU of a chamber
uint32_t	stripData (const std::vector< const CscRawData * > &data, const unsigned int numSamples, std::map< int, std::vector< uint16_t > > &samples, uint32_t &hash, const uint16_t spuID, const int gasLayer, bool isdata) const
	data in one gas lauer
std::vector< CscRawData * >	overlay (const std::map< int, std::vector< uint16_t > > &sigSamples, const std::map< int, std::vector< uint16_t > > &ovlSamples, const uint32_t address, const uint16_t spuID, const uint16_t collId, const uint32_t hash, CLHEP::HepRandomEngine *rndmEngine) const
	do the overlay - summing the ADC samples on one plane if there is overlap between zero bias data and simulation.
bool	needtoflip (const int address) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKey< CscRawDataContainer >	m_bkgInputKey {this,"BkgInputKey","Bkg_CSCRDO",""}
SG::ReadHandleKey< CscRawDataContainer >	m_signalInputKey {this,"SignalInputKey","Sig_CSCRDO",""}
SG::WriteHandleKey< CscRawDataContainer >	m_outputKey {this,"OutputKey","CSCRDO",""}
Gaudi::Property< bool >	m_isDataOverlay {this, "isDataOverlay", false, ""}
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
ToolHandle< ICscCalibTool >	m_cscCalibTool {this, "CalibTool", "CscCalibTool", ""}
ToolHandle< Muon::ICSC_RDO_Decoder >	m_cscRdoDecoderTool {this, "CscRdoDecoderTool", "Muon::CscRDO_Decoder", ""}
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc", "Random Number Service"}
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
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 41 of file CscOverlay.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

CscOverlay()

CscOverlay::CscOverlay	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 28 of file CscOverlay.cxx.

                                                                      :
  AthReentrantAlgorithm(name, pSvcLocator) {
}

Member Function Documentation

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

copyCollection()

std::unique_ptr< CscRawDataCollection > CscOverlay::copyCollection ( const CscRawDataCollection * collection, bool propertiesOnly = false ) const

private

Copy CscRawDataCollection, optionally only copy properties.

Definition at line 228 of file CscOverlay.cxx.

{
  auto outputCollection = std::make_unique<CscRawDataCollection>(collection->identify());
 
  // Copy property values to the new collection
  outputCollection->setIdentifyHash(collection->identifyHash());
  outputCollection->set_eventType(collection->eventType());
  outputCollection->setRodId(collection->rodId());
  outputCollection->setSubDetectorId(collection->subDetectorId());
  outputCollection->set_samplingPhase(collection->samplingPhase());
  outputCollection->set_triggerType(collection->triggerType());
  outputCollection->set_firstBitSummary(collection->firstBitSummary());
  outputCollection->set_scaAddress(collection->scaAddress());
  for (uint8_t dataType : collection->dataType()) {
    outputCollection->addDataType(dataType);
  }
 
  // Return if only properties requested
  if (propertiesOnly) {
    return outputCollection;
  }
 
  for (const CscRawData *existingDatum : *collection) {
    // Owned by the collection
    auto *datumCopy = new CscRawData(*existingDatum);
    outputCollection->push_back(datumCopy);
  }
 
  return outputCollection;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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; }

execute()

StatusCode CscOverlay::execute ( const EventContext & ctx ) const

finaloverridevirtual

Definition at line 54 of file CscOverlay.cxx.

                                                            {
  ATH_MSG_DEBUG("execute() begin");
 
 
  SG::ReadHandle<CscRawDataContainer> bkgContainer(m_bkgInputKey, ctx);
  if(!bkgContainer.isValid()) {
    ATH_MSG_ERROR("Could not get background CscRawDataContainer called " << bkgContainer.name() << " from store " << bkgContainer.store());
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Found background CscRawDataContainer called " << bkgContainer.name() << " in store " << bkgContainer.store());
 
  SG::ReadHandle<CscRawDataContainer> signalContainer(m_signalInputKey, ctx);
  if(!signalContainer.isValid()) {
    ATH_MSG_ERROR("Could not get signal CscRawOverlayContainer called " << signalContainer.name() << " from store " << signalContainer.store());
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Found signal CscRawOverlayContainer called " << signalContainer.name() << " in store " << signalContainer.store());
 
  SG::WriteHandle<CscRawDataContainer> outputContainer(m_outputKey, ctx);
  ATH_CHECK(outputContainer.record(std::make_unique<CscRawDataContainer>(bkgContainer->size())));
  if (!outputContainer.isValid()) {
    ATH_MSG_ERROR("Could not record output CscRawOverlayContainer called " << outputContainer.name() << " to store " << outputContainer.store());
    return StatusCode::FAILURE;
  }
  ATH_MSG_DEBUG("Recorded output CscRawOverlayContainer called " << outputContainer.name() << " in store " << outputContainer.store());
 
  // now do the overlay
  ATH_CHECK(overlayContainer(bkgContainer.cptr(), signalContainer.cptr(), outputContainer.ptr()));
 
 
  ATH_MSG_DEBUG("execute() end");
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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

extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

initialize()

StatusCode CscOverlay::initialize ( )

finaloverridevirtual

CSC calibratin tool for the Condtiions Data base access

Definition at line 33 of file CscOverlay.cxx.

                                  {
  ATH_MSG_DEBUG("CscOverlay initialized");
  ATH_CHECK(m_idHelperSvc.retrieve());

  ATH_CHECK(m_cscCalibTool.retrieve());
 
  // get cscRdoDecoderTool
  ATH_CHECK(m_cscRdoDecoderTool.retrieve());
 
  //random number initialization
  ATH_CHECK(m_rndmSvc.retrieve());
 
  ATH_CHECK( m_bkgInputKey.initialize() );
  ATH_CHECK( m_signalInputKey.initialize() );
  ATH_CHECK( m_outputKey.initialize() );
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

mergeCollections()

void CscOverlay::mergeCollections ( const CscRawDataCollection * bkgCollection, const CscRawDataCollection * signalCollection, CscRawDataCollection * outputCollection, CLHEP::HepRandomEngine * rndmEngine ) const

private

In case of overlap merge signal and background collections.

loop over the SPU - collecting thr data by layer do the overlay by igas layer in a chamber

for the non-precision strips, all the 4 layers in a chamber are in the same SPU, we need to recover the data by chamber layer

Definition at line 283 of file CscOverlay.cxx.

{
  ATH_MSG_DEBUG("mergeCollection() begin");
 
  // number of ADC samples in  the both data stream
  unsigned int nSigSamples  = bkgCollection->numSamples();
  unsigned int nOvlSamples  = signalCollection->numSamples();
 
  // sampling times in both data streams
  unsigned int dataSamplingTime = bkgCollection->rate();
  unsigned int ovlSamplingTime  = signalCollection->rate();
 
  if ( dataSamplingTime != ovlSamplingTime ) {
    ATH_MSG_ERROR("Overlay of inconsistent data - sampling times not the same "
                  << dataSamplingTime << " ns " << ovlSamplingTime << " ns");
    throw std::runtime_error("mergeCollections(): sampling time mismatch");
  }
 
  if ( nSigSamples != nOvlSamples ) {
    ATH_MSG_ERROR("Overlay of inconsistent data - number of samples not the same "
                  << nSigSamples << " " << nOvlSamples);
    throw std::runtime_error("mergeCollections(): number of samples mismatch");
  }

  uint16_t clusterCounts[] = {0,0,0,0,0,0,0,0,0,0};
  uint16_t rpuCount[] = {0,0};
  for ( uint16_t spuID=0; spuID<10; ++spuID) {
 
    std::vector<const CscRawData*> sigData; // real data
    this->spuData(bkgCollection, spuID, sigData);
 
    std::vector<const CscRawData*> ovlData; // simulation
    this->spuData(signalCollection, spuID, ovlData);

    int layer = 0;
    if ( spuID == 4 || spuID == 9 ) layer=4;
    for ( int j=0; j<=layer; ++j ) {
       std::map< int,std::vector<uint16_t> > sigSamples;
       std::map< int,std::vector<uint16_t> > ovlSamples;
       uint32_t sigHash;
       uint32_t ovlHash;
       uint32_t sigAddress = this->stripData( sigData, nSigSamples, sigSamples, sigHash, spuID, j , m_isDataOverlay); // need to patch in the case of real data
       uint32_t ovlAddress = this->stripData( ovlData, nOvlSamples, ovlSamples, ovlHash, spuID, j , false); // simulation
       if (sigSamples.size()==0 && ovlSamples.size()==0) continue;
 
       uint32_t hash      = std::min( sigHash, ovlHash );
       uint32_t address   = std::min( sigAddress, ovlAddress );
       if (sigSamples.size()!=0 && ovlSamples.size()!=0 && needtoflip(address)){
         ATH_MSG_DEBUG("Looking for overlap of hashes and addresses within widths because needtoflip");
         msg() << MSG::VERBOSE ;
         std::set<int> sig;  int lastindex=-1;
         for (std::map< int,std::vector<uint16_t> >::const_iterator si=sigSamples.begin(); si!=sigSamples.end(); ++si) {
           if (si!=sigSamples.begin() && si->first-lastindex!=1) break;
           lastindex=si->first;
           sig.insert(si->first); msg() << si->first << " ";
         }
         msg()<<endmsg;
         bool overlap=false;
         msg() <<MSG::VERBOSE ;
         for (std::map< int,std::vector<uint16_t> >::const_iterator so=ovlSamples.begin(); so!=ovlSamples.end(); ++so) {
           //add 1 to beginning and end of list because adjacent counts as overlap
           msg() << (so->first)-1 << " ";
           if (sig.find((so->first)-1)!=sig.end()) {overlap=true; msg() << "!!";}
           msg() << (so->first) << " ";
           if (sig.find((so->first))!=sig.end()) {overlap=true; msg() << "!!";}
           msg() << (so->first)+1 << " ";
           if (sig.find((so->first)+1)!=sig.end()) {overlap=true; msg() << "!!";}
         }
         msg()<<endmsg;
         if (!overlap){
           ATH_MSG_DEBUG("Taking max of hashes and addresses because needtoflip and no overlap");
           hash      = std::max( sigHash, ovlHash );
           address   = std::max( sigAddress, ovlAddress );
         }
       }
 
       //for checks
       std::set<int> insertedstrips, readstrips;
       for (std::map< int,std::vector<uint16_t> >::const_iterator s=sigSamples.begin(); s!=sigSamples.end(); ++s){readstrips.insert(s->first);}
       for (std::map< int,std::vector<uint16_t> >::const_iterator si=ovlSamples.begin(); si!=ovlSamples.end(); ++si){readstrips.insert(si->first);}
 
       std::vector<CscRawData*> datums = this->overlay(sigSamples, ovlSamples,address, spuID, outputCollection->identify(), hash, rndmEngine);
       if ( datums.size()==0 ) {         ATH_MSG_WARNING("datums is size 0!");       }
       for (unsigned int di=0; di<datums.size(); ++di){
         CscRawData* datum=datums[di];
         hash = datum->hashId();
         address = datum->address();
         int stripstart        = (  address & 0x000000FF) + 1 + 0;
         ATH_MSG_DEBUG("Datum in layer="<<j<<" has hash="<<hash<<" address="<<address<<" stripstart="<<stripstart<<", "<< *datum );
         if (datum->width()==0) {
           ATH_MSG_WARNING("Datum has 0 width!");
           continue;
         }
 
          //perform some checks
          int stationName =  ( ( address & 0x00010000) >> 16 ) + 50;
          int stationEta  =  ( ((address & 0x00001000) >> 12 ) == 0x0) ? -1 : 1;
          int stationPhi  =  ( ( address & 0x0000E000) >> 13 ) + 1;
          Identifier me= m_idHelperSvc->cscIdHelper().elementID(stationName,stationEta,stationPhi);
          ATH_MSG_VERBOSE("stationName,Eta,Phi="<<stationName<<","<<stationEta<<","<<stationPhi<<" - me="<<me);
          bool good=true;
          for (unsigned int j=0; j<datum->width(); ++j) {
            int chamberLayer = ( (address & 0x00000800) >> 11) + 1;
            int wireLayer    = ( (address & 0x00000600) >>  9) + 1;
            int measuresPhi  = ( (address & 0x00000100) >>  8);
            int strip        = (  address & 0x000000FF) + 1 + j;
            ATH_MSG_VERBOSE("chamberlayer,wirelayer,measuresphi,strip="<<chamberLayer<<","<<wireLayer<<","<<measuresPhi<<","<<strip);
            // Added to Online -> Offline id  in A side number is opposite bug#56002
            if (measuresPhi) {
              int stationEta  =  ( ((address & 0x00001000) >> 12 ) == 0x0) ? -1 : 1;
              if (stationEta>0) {
                ATH_MSG_VERBOSE("FLIP strip. Formerly strip="<<strip<<", now strip="<<49-strip);
                strip = 49-strip;
              }
            }
            insertedstrips.insert(strip);//for checks
            Identifier mechan= m_idHelperSvc->cscIdHelper().channelID(me,chamberLayer,wireLayer,measuresPhi,strip);
            ATH_MSG_VERBOSE("mechan="<<mechan);
            const Identifier channelId = m_cscRdoDecoderTool->channelIdentifier(datum, &m_idHelperSvc->cscIdHelper(), j);
            if(!(m_idHelperSvc->cscIdHelper().valid(channelId))) {
              ATH_MSG_WARNING("Invalid CSC Identifier in merge! - skipping " << channelId );
              good=false;
            }
          else{ATH_MSG_DEBUG("Valid CSC Identifier in merge " << channelId);}
          }
          if (good){        outputCollection->push_back(datum);   }
          else{     continue;     }
 
          //keep count
          if (spuID <10) clusterCounts[spuID] += 1;
          if ( spuID <= 4 ) rpuCount[0] = 5;
          else if ( spuID > 4 && spuID <= 9 ) rpuCount[1] = 11;
       }//loop over datum
 
       //check
       if (readstrips!=insertedstrips){
         ATH_MSG_WARNING("Readstrips != Insertedstrips: ");
         std::ostringstream readstream;
         for (std::set<int>::const_iterator i = readstrips.begin(); i!=readstrips.end(); ++i){readstream<<*i<<" ";}
         ATH_MSG_WARNING(readstream.str());
         std::ostringstream insertstream;
         for (std::set<int>::const_iterator i = insertedstrips.begin(); i!=insertedstrips.end(); ++i){insertstream<<*i<<" ";}
         ATH_MSG_WARNING(insertstream.str());
       }
 
    }
  }
  for (unsigned int i=0; i<10; ++i) outputCollection->set_spuCount(i,clusterCounts[i]);
  for (unsigned int i=0; i<2; ++i)  { if (rpuCount[i] != 0) outputCollection->addRPU(rpuCount[i]); }
  // FIXME --- need to be able to reset the dataType - should add a new method to CscRawDataCollection for this
  ATH_MSG_DEBUG("mergeCollection<>() end ");
}

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

needtoflip()

bool CscOverlay::needtoflip ( const int address ) const

private

Definition at line 271 of file CscOverlay.cxx.

{
         int measuresPhi  = ( (address & 0x00000100) >>  8);
         if (address<2147483640 && measuresPhi) {
           int stationEta  =  ( ((address & 0x00001000) >> 12 ) == 0x0) ? -1 : 1;
           if (stationEta>0) {       return true;          }
         }
         return false;
}

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

overlay()

std::vector< CscRawData * > CscOverlay::overlay ( const std::map< int, std::vector< uint16_t > > & sigSamples, const std::map< int, std::vector< uint16_t > > & ovlSamples, const uint32_t address, const uint16_t spuID, const uint16_t collId, const uint32_t hash, CLHEP::HepRandomEngine * rndmEngine ) const

private

do the overlay - summing the ADC samples on one plane if there is overlap between zero bias data and simulation.

If there is no overlap, simply copy the data

Definition at line 540 of file CscOverlay.cxx.

{
  ATH_MSG_DEBUG("overlay<>() begin: hash="<<hash<<" address="<<address);
  std::vector<CscRawData*> datas;
  CscRawData * rawData = nullptr;
  int max = 192;
  if ( spuID == 4 || spuID == 9 ) max = 48;
  std::vector<uint16_t> samples;
  std::map< int,std::vector<uint16_t> >::const_iterator sig;
  std::map< int,std::vector<uint16_t> >::const_iterator ovl;
  uint16_t width = 0;
  int myhash=hash; int myaddress=address;
 
  max+=1;//go one past the end, to get the clusters ending right
  for ( int i=1; i<=max; ++i) {
    sig = sigSamples.find(i);
    ovl = ovlSamples.find(i);
    bool used=false;
 
    if ( sig != sigSamples.end() && ovl == ovlSamples.end() ) { // real data only
      ATH_MSG_VERBOSE("data only for i="<<i);
      for ( unsigned int j=0; j<(*sig).second.size(); ++j ) {
        samples.push_back( (*sig).second.at(j) );
        assert((*sig).second.at(j)<=MAX_AMPL);
      }
      width++; used=true;
    }
    else if ( sig == sigSamples.end() && ovl != ovlSamples.end() ) { // simulation only
      ATH_MSG_VERBOSE("simulation only for i="<<i);
      int myhashw=myhash+width; if (needtoflip(myaddress)) {myhashw=myhash-width;}
      double noise = m_cscCalibTool->stripNoise( (myhashw), false );//in ADC counts
       for ( unsigned int j=0; j<(*ovl).second.size(); ++j ) {
          double theNoise = CLHEP::RandGaussZiggurat::shoot(rndmEngine, 0.0, noise);
          float adcCount = (*ovl).second.at(j) + theNoise ;//add noise
          if ( adcCount > MAX_AMPL ) {
            ATH_MSG_DEBUG("value out of range (adding noise): " << adcCount << " "
                << " Setting it to max value = " << MAX_AMPL
                          << " IdentifierHash is " << (myhashw));
            adcCount = MAX_AMPL;
          }
          samples.push_back( (uint16_t) rint(adcCount) );
       }
       width++; used=true;
    }
    else if ( sig != sigSamples.end() && ovl != ovlSamples.end() ) { // real data + MC
      ATH_MSG_VERBOSE("data and simulation for i="<<i);
      int myhashw=myhash+width; if (needtoflip(myaddress)) {myhashw=myhash-width;}
      double pedestal = m_cscCalibTool->stripPedestal( (myhashw), false );//in ADC counts
       for ( unsigned int j=0; j<(*sig).second.size(); ++j ) {
          float adcCount = (*sig).second.at(j) + (*ovl).second.at(j) - pedestal ;//subtract pedestal only (data already has noise)
          if ( adcCount > MAX_AMPL ) {
            ATH_MSG_DEBUG("value out of range (adding data+MC samples - pedestal): " << adcCount << " "
                << " Setting it to max value = " << MAX_AMPL
                          << " IdentifierHash is " << (myhashw));
            adcCount = MAX_AMPL;
          }
          samples.push_back( (uint16_t) rint(adcCount) );
       }
       width++; used=true;
    }
 
    if ( used==false && datas.size()>0 ){
      if (needtoflip(myaddress)) {myhash-=1; myaddress-=1;}
      else {myhash+=1; myaddress+=1;}
    }
 
    //If a break is detected in the strip cluster, start a new CscRawData object...
    //and adjust the hash and address, etc.
    if ( (used==false||i==max) && samples.size()>0){
      if (datas.size()>0 && needtoflip(myaddress)) {myhash-=width; myaddress-=width;}
      rawData = new CscRawData( samples, myaddress, collId, spuID, width );
      rawData->setHashID(myhash);
      rawData->setTime(0);//ACH - TODO: should be made significantly more clever!
      datas.push_back(rawData);
      ATH_MSG_DEBUG("overlay<>() add datum: hash="<<myhash<<" address="<<myaddress<<" width="<<width);
      samples.clear();
      if (!needtoflip(myaddress)) {myhash+=width; myaddress+=width;}
      width=0;
    }
 
  }
  ATH_MSG_DEBUG("overlay<>() end: CscRawDatas size="<<datas.size());
  return datas;
}

overlayContainer()

StatusCode CscOverlay::overlayContainer ( const CscRawDataContainer * bkgContainer, const CscRawDataContainer * signalContainer, CscRawDataContainer * outputContainer ) const

private

Overlay signal on the background container and record to the output one.

Definition at line 89 of file CscOverlay.cxx.

{
  ATH_MSG_DEBUG("overlayContainer() begin");
 
  // The MC signal container should typically be smaller than bkgContainer,
  // because the latter contains all the noise, minimum bias and pile up.
  // Thus we firstly iterate over signal hashes and store them in a map.
  std::vector < std::pair<IdentifierHash, bool> > overlapMap;
  overlapMap.reserve(signalContainer->numberOfCollections());
  for (const auto &[hashId, ptr] : signalContainer->GetAllHashPtrPair()) {
    overlapMap.emplace_back(hashId, false);
  }
 
  // Now loop through the background hashes and copy unique ones over
  for (const auto &[hashId, ptr] : bkgContainer->GetAllHashPtrPair()) {
    auto search = std::lower_bound( overlapMap.begin(), overlapMap.end(), hashId,
     [](const std::pair<IdentifierHash, bool> &lhs,  IdentifierHash rhs) -> bool { return lhs.first < rhs; } );
    if (search == overlapMap.end() || search->first != hashId) {
      // Copy the background collection
      std::unique_ptr<CscRawDataCollection> bkgCollection  = copyCollection(ptr);
 
      if (outputContainer->addCollection(bkgCollection.get(), hashId).isFailure()) {
        ATH_MSG_ERROR("Adding background Collection with hashId " << hashId << " failed");
        return StatusCode::FAILURE;
      } else {
        (void)bkgCollection.release();
      }
    } else {
      // Flip the overlap flag
      search->second = true;
    }
  }
 
  // Setup random engine
  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this);
  rngWrapper->setSeed( name(), Gaudi::Hive::currentContext() );
  CLHEP::HepRandomEngine *rndmEngine(*rngWrapper);
 
  // Finally loop through the map and process the signal and overlay if
  // necessary
  for (const auto &[hashId, overlap] : overlapMap) {
    // Retrieve the signal collection
    const CscRawDataCollection *signalCollection = signalContainer->indexFindPtr(hashId);
 
    // Output collection
    std::unique_ptr<CscRawDataCollection> outputCollection{};
 
    if (overlap) { // Do overlay
      // Retrieve the background collection
      const CscRawDataCollection *bkgCollection = bkgContainer->indexFindPtr(hashId);
 
      // Create the output collection with background collection as a base
      // TODO: should it be signal collection?
      outputCollection = copyCollection(bkgCollection, true);
 
      // Merge the collections
      mergeCollections(bkgCollection, signalCollection, outputCollection.get(), rndmEngine);
    } else {
      // Create the output collection with signal collection as a base
      outputCollection = copyCollection(signalCollection, true);
 
      uint16_t numSamples = signalCollection->numSamples();
 
      for (const CscRawData *data : *signalCollection) {
        if (!data) {
          ATH_MSG_WARNING("NULL pointer to Digit!");
          continue;
        }
 
        // Copy the digit and add noise
        std::vector<uint16_t> samples;
 
        uint16_t width = data->width();
        uint32_t hashOffset = data->hashId();
 
        // Loop over width
        for (uint16_t j = 0; j < width; ++j) {
          uint32_t stripHash = hashOffset + j;
          double stripNoise = m_cscCalibTool->stripNoise(stripHash, false);
          // Get the samples
          std::vector<uint16_t> stripSamples;
          bool extractSamplesStatus = data->samples(j, numSamples, stripSamples);
          if (!extractSamplesStatus) {
            ATH_MSG_WARNING("Unable to extract samples for strip " << j
                            << " Online Cluster width = " << width
                            << " for number of Samples = " << numSamples
                            << " continuing ...");
          } else {
            for (uint16_t sample : stripSamples) {
              double sampleNoise = CLHEP::RandGaussZiggurat::shoot(rndmEngine, 0.0, stripNoise);
              float adcCount = sample + sampleNoise;
              if (adcCount > MAX_AMPL) {
                ATH_MSG_DEBUG("value out of range (copying over signal): " << adcCount << " "
                              << " Setting it to max value = " << MAX_AMPL
                              << " IdentifierHash is " << stripHash);
                adcCount = MAX_AMPL;
              }
              samples.push_back( (uint16_t) std::rint(adcCount) );
            }
          }
        }
 
        // Copy over the digit with the updated samples
        auto rdo = std::make_unique<CscRawData>(samples, data->address(), data->identify(), data->time(), data->rpuID(), data->width(), data->hashId());
 
        // Perform some checks
        bool good = true;
        for (uint16_t j = 0; j < width; ++j) {
          const Identifier channelId = m_cscRdoDecoderTool->channelIdentifier(rdo.get(), &m_idHelperSvc->cscIdHelper(), j);
          if (!m_idHelperSvc->cscIdHelper().valid(channelId)) {
            ATH_MSG_WARNING("Invalid CSC Identifier! - skipping " << channelId);
            good = false;
            break;
          }
        }
        if (good) {
          outputCollection->push_back(rdo.release());
        }
      }
    }
 
    if (outputContainer->addCollection(outputCollection.get(), hashId).isFailure()) {
      ATH_MSG_ERROR("Adding overlaid Collection with hashId " << hashId << " failed");
      return StatusCode::FAILURE;
    } else {
      //intentional release, the outputContainer owns it now.
      //coverity[RESOURCE_LEAK]
      (void)outputCollection.release();
    }
  }
 
  ATH_MSG_DEBUG("overlayContainer>() end");
  return StatusCode::SUCCESS;
}

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< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

spuData()

void CscOverlay::spuData ( const CscRawDataCollection * coll, const uint16_t spuID, std::vector< const CscRawData * > & data ) const

private

get the data in one SPU of a chamber

Definition at line 260 of file CscOverlay.cxx.

{
  data.clear();  if ( !coll ) return;
  CscRawDataCollection::const_iterator idata = coll->begin();
  CscRawDataCollection::const_iterator edata = coll->end();
  for ( ; idata != edata; ++idata ) {
      if ( (*idata)->rpuID() == spuID ) data.push_back( *idata );
  }
  ATH_MSG_DEBUG("spuData(): made data vector of size "<<data.size()<<" for SPU "<<spuID);
}

stripData()

uint32_t CscOverlay::stripData ( const std::vector< const CscRawData * > & data, const unsigned int numSamples, std::map< int, std::vector< uint16_t > > & samples, uint32_t & hash, const uint16_t spuID, const int gasLayer, bool isdata ) const

private

data in one gas lauer

loop over the data in the SPU

find the strip Identifier given the strip hash ID

create the map only layer by layer for the precision strip, we set gasLayer=0 because the spuID tells you the gas layer for the non-precision strips, we need to explicitly get the gas layer number form the Identifier

Definition at line 443 of file CscOverlay.cxx.

{
  ATH_MSG_DEBUG("stripData<>() begin: gasLayer="<<gasLayer<<" spuID="<<spuID<<" isdata="<<isdata);
 
  samples.clear();
  IdContext context = m_idHelperSvc->cscIdHelper().channel_context();
 
  uint32_t maxInt  = 2147483640;
  uint32_t address = maxInt;
  hash             = maxInt;

  std::vector<const CscRawData*>::const_iterator idata = data.begin();
  std::vector<const CscRawData*>::const_iterator edata = data.end();
  for ( ; idata != edata; ++idata ) {
    const CscRawData * datum = *idata;
    uint32_t hashOffset = datum->hashId();

    Identifier stripId;
    m_idHelperSvc->cscIdHelper().get_id(hashOffset, stripId, &context);
    unsigned int strip = static_cast<unsigned int> ( m_idHelperSvc->cscIdHelper().strip( stripId ) );
    int layer          = m_idHelperSvc->cscIdHelper().wireLayer( stripId );
    uint16_t width = datum->width();

    bool non_precision = (gasLayer==layer) && (spuID==4 || spuID==9);
    bool precision     = (gasLayer==0) && (!(spuID==4 || spuID==9));
    bool check = precision || non_precision;
    if ( !check ) {
      //ATH_MSG_DEBUG("Not precision or non_precision, skipping layer="<<layer<<", gasLayer="<<gasLayer<<", spuID="<<spuID);
      continue;
    }
 
    //ACH - move down here after layer continue...
    unsigned int newaddress = datum->address();
    //if we're going to later flip the data strip for bug#56002
    if (isdata && needtoflip(newaddress)) {
      ATH_MSG_VERBOSE("needtoflip in stripdata, newaddress was = "<<newaddress<<", strip was = "<<strip);
 
      //old way
      //newaddress= newaddress- (width-1);//apparently need to shift the address to the highest strip
 
      //new way
      uint32_t oldFirstStrip  = uint32_t (newaddress & 0x000000FF);
      uint32_t newFirstStrip  = uint32_t (47-oldFirstStrip) - width +1;//starts at 0
      newaddress=newaddress - oldFirstStrip + newFirstStrip;
 
      uint32_t oldStrip  = uint32_t (strip & 0x000000FF);
      uint32_t newStrip  = uint32_t (49-oldStrip);//starts at 1
      strip=strip - oldStrip + newStrip;
 
      ATH_MSG_VERBOSE("needtoflip in stripdata, newaddress now = "<<newaddress<<", strip now = "<<strip);
    }
 
    if ( needtoflip(newaddress) ){
      if (hash == maxInt) hash=0;
      if (address == maxInt) address=0;
      if ( hashOffset > hash ) hash = hashOffset;
      if ( newaddress > address ) address = newaddress;
    }
    else{
      if ( hashOffset < hash ) hash = hashOffset;
      if ( newaddress < address ) address = newaddress;
    }
 
    ATH_MSG_DEBUG("stripData(): width="<<width<<" hashOffset="<<hashOffset<<" datumaddress="<<datum->address()<<" layer="<<layer<<" strip="<<strip<<", hash="<<hash<<" address="<<address);
 
    for (unsigned int j=0; j<width; ++j) {
       std::vector<uint16_t> adcs;
       bool extractSamples = datum->samples(j, numSamples, adcs);
       if ( !extractSamples ) {
         ATH_MSG_WARNING("Unable to extract samples for strip " << j
                         << " Online Cluster width = " << width << " for number of Samples = " << numSamples);
       }
       else {
         int newstrip = (strip+j);
         if (false && isdata && needtoflip(address)){
           newstrip = strip-j;
           ATH_MSG_VERBOSE("needtoflip in stripdata, newstrip is "<<newstrip);
         }
         samples.insert ( std::make_pair( newstrip, adcs) );
       }
    }
  }
 
  ATH_MSG_DEBUG("stripData<>() end: hash=" << hash << " address=" << address);
  return address;
}

sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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_bkgInputKey

SG::ReadHandleKey<CscRawDataContainer> CscOverlay::m_bkgInputKey {this,"BkgInputKey","Bkg_CSCRDO",""}

private

Definition at line 96 of file CscOverlay.h.

{this,"BkgInputKey","Bkg_CSCRDO",""};

m_cscCalibTool

ToolHandle<ICscCalibTool> CscOverlay::m_cscCalibTool {this, "CalibTool", "CscCalibTool", ""}

private

Definition at line 102 of file CscOverlay.h.

{this, "CalibTool", "CscCalibTool", ""};

m_cscRdoDecoderTool

ToolHandle<Muon::ICSC_RDO_Decoder> CscOverlay::m_cscRdoDecoderTool {this, "CscRdoDecoderTool", "Muon::CscRDO_Decoder", ""}

private

Definition at line 103 of file CscOverlay.h.

{this, "CscRdoDecoderTool", "Muon::CscRDO_Decoder", ""};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_idHelperSvc

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

private

Definition at line 101 of file CscOverlay.h.

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

m_isDataOverlay

Gaudi::Property<bool> CscOverlay::m_isDataOverlay {this, "isDataOverlay", false, ""}

private

Definition at line 100 of file CscOverlay.h.

{this, "isDataOverlay", false, ""};

m_outputKey

SG::WriteHandleKey<CscRawDataContainer> CscOverlay::m_outputKey {this,"OutputKey","CSCRDO",""}

private

Definition at line 98 of file CscOverlay.h.

{this,"OutputKey","CSCRDO",""};

m_rndmSvc

ServiceHandle<IAthRNGSvc> CscOverlay::m_rndmSvc {this, "RndmSvc", "AthRNGSvc", "Random Number Service"}

private

Definition at line 105 of file CscOverlay.h.

{this, "RndmSvc", "AthRNGSvc", "Random Number Service"};      // Random number service

m_signalInputKey

SG::ReadHandleKey<CscRawDataContainer> CscOverlay::m_signalInputKey {this,"SignalInputKey","Sig_CSCRDO",""}

private

Definition at line 97 of file CscOverlay.h.

{this,"SignalInputKey","Sig_CSCRDO",""};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• CscOverlay.h
• CscOverlay.cxx