BasicEventDataGPUExporter Class Reference

Standard tool to export cell energy and gain to the GPU. More...

#include <BasicEventDataGPUExporter.h>

Inheritance diagram for BasicEventDataGPUExporter:

Collaboration diagram for BasicEventDataGPUExporter:

Public Member Functions
	BasicEventDataGPUExporter (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual StatusCode	convert (const EventContext &ctx, const CaloRecGPU::ConstantDataHolder &constant_data, const xAOD::CaloClusterContainer *cluster_collection, CaloRecGPU::EventDataHolder &event_data) const override
	Fill the CaloRecGPU::EventDataHolder with the relevant information. More...
virtual StatusCode	finalize () override
virtual	~BasicEventDataGPUExporter ()=default
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const
	DeclareInterfaceID (ICaloClusterGPUInputTransformer, 1, 0)

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
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. More...
void	record_times (const size_t event_num, const std::vector< size_t > &times) const
template<class ... Args>
void	record_times (const size_t event_num, const size_t &value) const
template<class ... Args>
void	record_times (const size_t event_num, const size_t &value, Args &&... args) const
void	print_times (const std::string &header, const size_t time_size) const

Protected Attributes
std::mutex	m_timeMutex
	Mutex that is locked when recording times. More...
std::vector< size_t > m_times	ATLAS_THREAD_SAFE
	Vector to hold execution times to be recorded if necessary. More...
std::vector< size_t > m_eventNumbers	ATLAS_THREAD_SAFE
	Vector to hold the event numbers to be recorded if necessary. More...
Gaudi::Property< bool >	m_measureTimes
	If true, times are recorded to the file given by m_timeFileName. More...
Gaudi::Property< std::string >	m_timeFileName
	File to which times should be saved. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
void	record_times_helper (size_t) const
void	record_times_helper (size_t index, size_t t) const
template<class ... Args>
void	record_times_helper (size_t index, size_t t, Args &&... args) const

Private Attributes
Gaudi::Property< bool >	m_keepCPUData {this, "KeepCPUData", true, "Keep CPU version of GPU data format"}
	If true, do not delete the CPU version of the GPU-friendly data representation. More...
SG::ReadHandleKey< CaloCellContainer >	m_cellsKey {this, "CellsName", "", "Name(s) of Cell Containers"}
	vector of names of the cell containers to use as input. More...
Gaudi::Property< bool >	m_considerSharedCells {this, "ConsiderSharedCells", false, "Take into account the possibility of a cell being shared between clusters."}
	If true, into account the possibility of a cell being shared between clusters. More...
Gaudi::Property< std::vector< int > >	m_missingCellsToFill {this, "MissingCellsToFill", {}, "Force fill these cells as disabled on empty containers."}
	Cell indices to fill as disabled cells (useful if the cell vector is always missing the same cells). More...
const CaloCell_ID *	m_calo_id {nullptr}
	Pointer to Calo ID Helper. More...
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Standard tool to export cell energy and gain to the GPU.

Author

Nuno Fernandes nuno..nosp@m.dos..nosp@m.santo.nosp@m.s.fe.nosp@m.rnand.nosp@m.es@c.nosp@m.ern.c.nosp@m.h

Date

29 May 2022

Definition at line 30 of file BasicEventDataGPUExporter.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

BasicEventDataGPUExporter()

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

Definition at line 22 of file BasicEventDataGPUExporter.cxx.

                                                                                                                             :
  AthAlgTool(type, name, parent),
  CaloGPUTimed(this)
{
  declareInterface<ICaloClusterGPUInputTransformer> (this);
}

~BasicEventDataGPUExporter()

virtual BasicEventDataGPUExporter::~BasicEventDataGPUExporter ( )

virtualdefault

Member Function Documentation

convert()

StatusCode BasicEventDataGPUExporter::convert ( const EventContext &  ctx, const CaloRecGPU::ConstantDataHolder &  constant_data, const xAOD::CaloClusterContainer *  cluster_collection, CaloRecGPU::EventDataHolder &  event_data  ) const

overridevirtual

Fill the CaloRecGPU::EventDataHolder with the relevant information.

Parameters

ctx	The event context.
constant_data	Data held in GPU memory that is common to all events (cell noise and geometry).
cluster_collection	The cluster collection, in the standard Athena structures.
event_data	Data held in GPU memory that is specific to this event (including the description of the clusters themselves).

Implements ICaloClusterGPUInputTransformer.

Definition at line 42 of file BasicEventDataGPUExporter.cxx.

{
  using clock_type = boost::chrono::thread_clock;
  auto time_cast = [](const auto & before, const auto & after)
  {
    return boost::chrono::duration_cast<boost::chrono::microseconds>(after - before).count();
  };
 
  const auto start = clock_type::now();
 
  ed.m_cell_info.allocate();
 
  SG::ReadHandle<CaloCellContainer> cell_collection(m_cellsKey, ctx);
  if ( !cell_collection.isValid() )
    {
      ATH_MSG_ERROR( " Cannot retrieve CaloCellContainer: " << cell_collection.name()  );
      return StatusCode::FAILURE;
    }
  
  /*
  SG::ReadCondHandle<CaloNoise> noise_handle(m_noiseCDOKey, ctx);
  const CaloNoise * noise_tool = *noise_handle;
  //For Two Gaussian Noise comparisons.
  */
  
  auto export_cell = [&](const CaloCell * cell, const int cell_index)
  {
    const float energy = cell->energy();
    const unsigned int gain = GainConversion::from_standard_gain(cell->gain());
    ed.m_cell_info->energy[cell_index] = energy;
    ed.m_cell_info->gain[cell_index] = gain;
    ed.m_cell_info->time[cell_index] = cell->time();
    
    
    if (CaloRecGPU::GeometryArr::is_tile(cell_index))
      {
        const TileCell * tile_cell = (TileCell *) cell;
 
        ed.m_cell_info->qualityProvenance[cell_index] = QualityProvenance{tile_cell->qual1(),
                                                                          tile_cell->qual2(),
                                                                          tile_cell->qbit1(),
                                                                          tile_cell->qbit2()};
        
        /*
        //For Two Gaussian Noise comparisons.
        
        const float original_snr = noise_tool->getEffectiveSigma(cell->ID(),cell->gain(),cell->energy());
        const float our_snr = cd.m_cell_noise->get_double_gaussian_noise(cell_index, gain, energy);
        if (our_snr != original_snr)
        {
          std::cout << "---------------------------------------- ERR: " << cell_index << " " << our_snr << " " << original_snr << " " << our_snr - original_snr << std::endl;
        }
        */
      }
    else
      {
        ed.m_cell_info->qualityProvenance[cell_index] = QualityProvenance{cell->quality(), cell->provenance()};
      }
    
  };
  
  //For Two Gaussian Noise comparisons.
  //std::cout << "-------------------------------------------------------------------------- START" << std::endl;
 
  if (cell_collection->isOrderedAndComplete())
    //Fast path: cell indices within the collection and identifierHashes match!
    {
      ATH_MSG_DEBUG("Taking quick path on event " << ctx.evt());
      int cell_index = 0;
      for (CaloCellContainer::const_iterator iCells = cell_collection->begin(); iCells != cell_collection->end(); ++iCells, ++cell_index)
        {
          const CaloCell * cell = (*iCells);
          export_cell(cell, cell_index);
        }
    }
  else if (cell_collection->isOrdered() && m_missingCellsToFill.size() > 0)
    //Remediated: we know the missing cells, force them to be invalid.
    //(Tests so far, on samples both oldish and newish, had 186986 and 187352 missing...)
    {
      ATH_MSG_DEBUG("Taking remediated fast path on event " << ctx.evt());
      int cell_index = 0;
      size_t missing_cell_count = 0;
      for (CaloCellContainer::const_iterator iCells = cell_collection->begin(); iCells != cell_collection->end(); ++iCells, ++cell_index)
        {
          const CaloCell * cell = (*iCells);
 
          if (missing_cell_count < m_missingCellsToFill.size() && cell_index == m_missingCellsToFill[missing_cell_count])
            {
              --iCells;
              ed.m_cell_info->gain[cell_index] = GainConversion::invalid_gain();
              ++missing_cell_count;
              continue;
            }
          else
            {
              export_cell(cell, cell_index);
            }
        }
    }
  else
    //Slow path: be careful.
    {
      /*
      std::vector<bool> has_cell(NCaloCells, false);
      // */
      ATH_MSG_DEBUG("Taking slow path on event " << ctx.evt());
      for (int cell_index = 0; cell_index < NCaloCells; ++cell_index)
        {
          ed.m_cell_info->gain[cell_index] = GainConversion::invalid_gain();
        }
 
      for (CaloCellContainer::const_iterator iCells = cell_collection->begin(); iCells != cell_collection->end(); ++iCells)
        {
          const CaloCell * cell = (*iCells);
 
          //const int cell_index = m_calo_id->calo_cell_hash(cell->ID());
          const int cell_index = cell->caloDDE()->calo_hash();
          //See calodde
          
          export_cell(cell, cell_index);
 
          /*
          has_cell[cell_index] = true;
          // */
 
        }
 
      /*
      //Useful output for detecting missing cells in the calorimeter collection...
      
      for (size_t i = 0; i < has_cell.size(); ++i)
        {
          if (!has_cell[i])
            {
              const auto identifier = m_calo_id->cell_id(i);
              const auto sampling = m_calo_id->calo_sample(m_calo_id->cell_id((IdentifierHash) i));
              std::cout << i << " " << sampling << std::endl;
            }
        }
      // */
    }
 
  //For Two Gaussian Noise comparisons.
  //std::cout << "-------------------------------------------------------------------------- END" << std::endl;
 
  const auto post_cells = clock_type::now();
  
  ed.m_clusters.allocate();
  ed.m_cell_state.allocate();
 
  if (cluster_collection->size() > 0)
    {
 
      for (int i = 0; i < NCaloCells; ++i)
        {
          ed.m_cell_state->clusterTag[i] = ClusterTag::make_invalid_tag();
        }
 
      const auto cluster_end = cluster_collection->end();
      auto cluster_iter = cluster_collection->begin();
 
      for (int cluster_number = 0; cluster_iter != cluster_end; ++cluster_iter, ++cluster_number )
        {
          const xAOD::CaloCluster * cluster = (*cluster_iter);
          const CaloClusterCellLink * cell_links = cluster->getCellLinks();
 
          ed.m_clusters->clusterEnergy[cluster_number] = cluster->e();
          ed.m_clusters->clusterEt[cluster_number] = cluster->et();
          ed.m_clusters->clusterEta[cluster_number] = cluster->eta();
          ed.m_clusters->clusterPhi[cluster_number] = cluster->phi();
 
          const int seed_cell_index = m_calo_id->calo_cell_hash(cluster->cell_begin()->ID());
 
          ed.m_clusters->seedCellID[cluster_number] = seed_cell_index;
 
          for (auto it = cell_links->begin(); it != cell_links->end(); ++it)
            {
              if (m_considerSharedCells)
                {
                  const int cell_ID = m_calo_id->calo_cell_hash(it->ID());
                  const float weight = it.weight();
 
                  uint32_t weight_as_int = 0;
                  std::memcpy(&weight_as_int, &weight, sizeof(float));
                  //On the platforms we expect to be running this, it should be fine.
                  //Still UB.
                  //With C++20, we could do that bit-cast thing.
 
                  if (weight_as_int == 0)
                    {
                      weight_as_int = 1;
                      //Subnormal,
                      //but just to distinguish from
                      //a non-shared cluster.
                    }
 
                  const ClusterTag other_tag = ed.m_cell_state->clusterTag[cell_ID];
 
                  const int other_index = other_tag.is_part_of_cluster() ? other_tag.cluster_index() : -1;
 
                  if (other_index < 0)
                    {
                      if (weight < 0.5f)
                        {
                          ed.m_cell_state->clusterTag[cell_ID] = ClusterTag::make_tag(cluster_number, weight_as_int, 0);
                        }
                      else
                        {
                          ed.m_cell_state->clusterTag[cell_ID] = ClusterTag::make_tag(cluster_number);
                        }
                    }
                  else if (weight > 0.5f)
                    {
                      ed.m_cell_state->clusterTag[cell_ID] = ClusterTag::make_tag(cluster_number, other_tag.secondary_cluster_weight(), other_index);
                    }
                  else if (weight == 0.5f)
                    //Unlikely, but...
                    {
                      const int max_cluster = cluster_number > other_index ? cluster_number : other_index;
                      const int min_cluster = cluster_number > other_index ? other_index : cluster_number;
                      ed.m_cell_state->clusterTag[cell_ID] = ClusterTag::make_tag(max_cluster, weight_as_int, min_cluster);
                    }
                  else /*if (weight < 0.5f)*/
                    {
                      ed.m_cell_state->clusterTag[cell_ID] = ClusterTag::make_tag(other_index, weight_as_int, cluster_number);
                    }
                }
              else
                {
                  ed.m_cell_state->clusterTag[m_calo_id->calo_cell_hash(it->ID())] = ClusterTag::make_tag(cluster_number);
                }
            }
        }
 
      ed.m_clusters->number = cluster_collection->size();
    }
 
  const auto post_clusters = clock_type::now();
 
  const bool has_cluster_info = cluster_collection->size() > 0;
 
  ed.sendToGPU(!m_keepCPUData, has_cluster_info, has_cluster_info, false);
 
  const auto post_send = clock_type::now();
 
  if (m_measureTimes)
    {
      record_times(ctx.evt(),
                   time_cast(start, post_cells),
                   time_cast(post_cells, post_clusters),
                   time_cast(post_clusters, post_send)
                  );
    }
 
  return StatusCode::SUCCESS;
 
}

declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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());
 
  }

declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

DeclareInterfaceID()

ICaloClusterGPUInputTransformer::DeclareInterfaceID ( ICaloClusterGPUInputTransformer  , 1  , 0    )

inherited

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  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() [1/2]

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

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 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 BasicEventDataGPUExporter::finalize ( )

overridevirtual

Definition at line 304 of file BasicEventDataGPUExporter.cxx.

{
 
  if (m_measureTimes)
    {
      print_times("Cells Clusters Transfer_to_GPU", 3);
    }
  return StatusCode::SUCCESS;
}

initialize()

StatusCode BasicEventDataGPUExporter::initialize ( )

overridevirtual

Definition at line 29 of file BasicEventDataGPUExporter.cxx.

{
 
  //ATH_CHECK(m_noiseCDOKey.initialize());
  //For Two Gaussian Noise comparisons.
  
  ATH_CHECK( m_cellsKey.initialize() );
 
  ATH_CHECK( detStore()->retrieve(m_calo_id, "CaloCell_ID") );
 
  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.

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

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.

print_times()

void CaloGPUTimed::print_times ( const std::string &  header, const size_t  time_size  ) const

inlineprotectedinherited

Definition at line 138 of file CaloGPUTimed.h.

  {
    if (m_timeFileName.size() == 0)
    {
      return;
    }
 
    std::vector<size_t> indices(m_eventNumbers.size());
    std::iota(indices.begin(), indices.end(), 0);
    std::sort(indices.begin(), indices.end(), [&](size_t a, size_t b)
    {
      return m_eventNumbers[a] < m_eventNumbers[b];
    }
             );
    std::ofstream out(m_timeFileName);
 
    out << "Event_Number Total " << header << "\n";
 
    for (const size_t idx : indices)
      {
        out << m_eventNumbers[idx] << " ";
        
        size_t total = 0;
        
        for (size_t i = 0; i < time_size; ++i)
          {
            total += m_times[idx * time_size + i];
          }
        
        out << total << " ";
        
        for (size_t i = 0; i < time_size; ++i)
          {
            out << m_times[idx * time_size + i] << " ";
          }
        out << "\n";
      }
 
    out << std::endl;
 
    out.close();
  }

record_times() [1/3]

template<class ... Args>

void CaloGPUTimed::record_times ( const size_t  event_num, const size_t &  value  ) const

inlineprotectedinherited

Definition at line 102 of file CaloGPUTimed.h.

  {
    const size_t time_size = 1;
 
    size_t old_size;
 
    //Scope just for the lock_guard.
    {
      std::lock_guard<std::mutex> lock_guard(m_timeMutex);
      old_size = m_times.size();
      m_times.resize(old_size + time_size);
      m_eventNumbers.push_back(event_num);
    }
 
    record_times_helper(old_size, value);
  }

record_times() [2/3]

template<class ... Args>

void CaloGPUTimed::record_times ( const size_t  event_num, const size_t &  value, Args &&...  args  ) const

inlineprotectedinherited

Definition at line 120 of file CaloGPUTimed.h.

  {
    const size_t time_size = sizeof...(args) + 1;
 
    size_t old_size;
 
    //Scope just for the lock_guard.
    {
      std::lock_guard<std::mutex> lock_guard(m_timeMutex);
      old_size = m_times.size();
      m_times.resize(old_size + time_size);
      m_eventNumbers.push_back(event_num);
    }
 
    record_times_helper(old_size, value, std::forward<Args>(args)...);
 
  }

record_times() [3/3]

void CaloGPUTimed::record_times ( const size_t  event_num, const std::vector< size_t > &  times  ) const

inlineprotectedinherited

Definition at line 84 of file CaloGPUTimed.h.

  {
    size_t old_size;
    //Scope just for the lock_guard.
    {
      std::lock_guard<std::mutex> lock_guard(m_timeMutex);
      old_size = m_times.size();
      m_times.resize(old_size + times.size());
      m_eventNumbers.push_back(event_num);
    }
 
    for (size_t i = 0; i < times.size(); ++i)
      {
        m_times[old_size + i] = times[i];
      }
  }

record_times_helper() [1/3]

void CaloGPUTimed::record_times_helper ( size_t  index, size_t  t  ) const

inlineprivateinherited

Definition at line 70 of file CaloGPUTimed.h.

  {
    m_times[index] = t;
  }

record_times_helper() [2/3]

template<class ... Args>

void CaloGPUTimed::record_times_helper ( size_t  index, size_t  t, Args &&...  args  ) const

inlineprivateinherited

Definition at line 76 of file CaloGPUTimed.h.

  {
    record_times_helper(index, t);
    record_times_helper(index + 1, std::forward<Args>(args)...);
  }

record_times_helper() [3/3]

void CaloGPUTimed::record_times_helper ( size_t  ) const

inlineprivateinherited

Definition at line 64 of file CaloGPUTimed.h.

  {
    //Do nothing
  }

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

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

ATLAS_THREAD_SAFE [1/2]

std::vector<size_t> m_times CaloGPUTimed::ATLAS_THREAD_SAFE

mutableprotectedinherited

Vector to hold execution times to be recorded if necessary.

Definition at line 35 of file CaloGPUTimed.h.

ATLAS_THREAD_SAFE [2/2]

std::vector<size_t> m_eventNumbers CaloGPUTimed::ATLAS_THREAD_SAFE

mutableprotectedinherited

Vector to hold the event numbers to be recorded if necessary.

Definition at line 40 of file CaloGPUTimed.h.

m_calo_id

const CaloCell_ID* BasicEventDataGPUExporter::m_calo_id {nullptr}

private

Pointer to Calo ID Helper.

Definition at line 73 of file BasicEventDataGPUExporter.h.

m_cellsKey

SG::ReadHandleKey<CaloCellContainer> BasicEventDataGPUExporter::m_cellsKey {this, "CellsName", "", "Name(s) of Cell Containers"}

private

vector of names of the cell containers to use as input.

Definition at line 57 of file BasicEventDataGPUExporter.h.

m_considerSharedCells

Gaudi::Property<bool> BasicEventDataGPUExporter::m_considerSharedCells {this, "ConsiderSharedCells", false, "Take into account the possibility of a cell being shared between clusters."}

private

If true, into account the possibility of a cell being shared between clusters.

Hurts performance when not needed. Defaults to false.

Definition at line 64 of file BasicEventDataGPUExporter.h.

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_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_keepCPUData

Gaudi::Property<bool> BasicEventDataGPUExporter::m_keepCPUData {this, "KeepCPUData", true, "Keep CPU version of GPU data format"}

private

If true, do not delete the CPU version of the GPU-friendly data representation.

Defaults to true.

Definition at line 52 of file BasicEventDataGPUExporter.h.

m_measureTimes

Gaudi::Property<bool> CaloGPUTimed::m_measureTimes

protectedinherited

If true, times are recorded to the file given by m_timeFileName.

Defaults to false.

Definition at line 46 of file CaloGPUTimed.h.

m_missingCellsToFill

Gaudi::Property<std::vector<int> > BasicEventDataGPUExporter::m_missingCellsToFill {this, "MissingCellsToFill", {}, "Force fill these cells as disabled on empty containers."}

private

Cell indices to fill as disabled cells (useful if the cell vector is always missing the same cells).

Definition at line 68 of file BasicEventDataGPUExporter.h.

m_timeFileName

Gaudi::Property<std::string> CaloGPUTimed::m_timeFileName

protectedinherited

File to which times should be saved.

Definition at line 50 of file CaloGPUTimed.h.

m_timeMutex

std::mutex CaloGPUTimed::m_timeMutex

mutableprotectedinherited

Mutex that is locked when recording times.

Definition at line 32 of file CaloGPUTimed.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:

• BasicEventDataGPUExporter.h
• BasicEventDataGPUExporter.cxx