updates for new CLHEP and G4 version (LArG4HitManagement-00-01-01)

LArCalorimeter/LArG4/LArG4HitManagement/LArG4HitManagement/LArCalibHitMerger.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// LArCalibHitMerger class used by LArG4CalibSD to merge CaloCalibrationHit-s
+
+#ifndef __LArCalibHitMerger_H__
+#define __LArCalibHitMerger_H__
+
+#include "CaloSimEvent/CaloCalibrationHit.h"
+#include "LArG4Code/LArVCalibHitMerger.h"
+#include "LArG4HitManagement/LArHitsEventAction.h"
+
+#include "G4Types.hh"
+
+#include <set>
+#include <vector>
+
+class LArCalibHitMerger : public LArVCalibHitMerger
+{
+public:
+
+  // Constructors and destructors.
+  LArCalibHitMerger(StoreGateSvc* detStore,
+		    LArHitsEventAction* action);
+
+  virtual ~LArCalibHitMerger();
+
+  // Clean up at the beginning of event
+  void BeginOfEvent();
+
+  // Do the actual job here
+  bool process(LArG4Identifier ident,
+               const std::vector<G4double>& energies);
+
+  // Do the actual job here
+  bool process(LArG4Identifier ident,
+               const std::vector<G4double>& energies, 
+	       unsigned int particleID);
+
+  // Distribute hits created during the event between global containers
+  void EndOfEvent(std::string detectorName);
+
+  // Clear the map
+  void clear();
+
+  // We need a container for the hits.  "calibrationHits" is used to
+  // tell us if we've already had a hit in a cell.  We store these
+  // hits in a set, so we can quickly search it.  Note the use of a
+  // custom definition of a "less" function for the set, so we're
+  // not just comparing hit pointers.
+ 
+  class LessHit {
+  public:
+    bool operator() ( CaloCalibrationHit* const& p, CaloCalibrationHit* const& q ) const
+      {
+	return p->Less(q);
+      }
+  };
+
+  typedef std::set< CaloCalibrationHit*, LessHit >  m_calibrationHits_t;
+  typedef m_calibrationHits_t::iterator             m_calibrationHits_ptr_t;
+  
+
+private:
+  // Pointer to the action object which holds global collections
+  LArHitsEventAction* m_action;
+
+  m_calibrationHits_t                               m_calibrationHits;
+
+};
+
+#endif // _LArCalibHitMerger_H_

LArCalorimeter/LArG4/LArG4HitManagement/LArG4HitManagement/LArCalibHitMergerFactory.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef __LArCalibHitMergerFactory_H__
+#define __LArCalibHitMergerFactory_H__
+
+#include "LArG4Code/LArVCalibHitMergerFactory.h"
+#include "LArG4HitManagement/LArCalibHitMerger.h"
+#include <vector>
+
+class StoreGateSvc;
+class LArHitsEventAction;
+
+
+class LArCalibHitMergerFactory : public LArVCalibHitMergerFactory
+{
+ public:
+
+  // Constructors and destructors.
+  LArCalibHitMergerFactory(StoreGateSvc* detStore,
+			   LArHitsEventAction* action);
+
+  virtual ~LArCalibHitMergerFactory();
+
+  LArVCalibHitMerger* getHitMerger() const;
+
+ private:
+  StoreGateSvc*       m_detStore;
+  LArHitsEventAction* m_action;
+
+  // Keep pointers to all created hit mergers in order to avoid memory leaks
+  typedef std::vector<LArCalibHitMerger* > CalibHitMergerVec;
+  mutable CalibHitMergerVec m_hitMergers;
+};
+
+#endif // _LArCalibHitMergerFactory_H_

LArCalorimeter/LArG4/LArG4HitManagement/LArG4HitManagement/LArHitMerger.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// LArHitMerger class used by LArG4SD and FastSimulation to merge
+// LArHits in the same time bins
+
+#ifndef __LArHitMerger_H__
+#define __LArHitMerger_H__
+
+#include "LArSimEvent/LArHit.h"
+#include "LArG4Code/LArVHitMerger.h"
+#include "LArG4HitManagement/LArHitsEventAction.h"
+
+#include "G4Types.hh"
+
+#include <set>
+#include <map>
+#include <string>
+
+class LArHitMerger : public LArVHitMerger
+{
+public:
+
+  enum LArHitTimeBins
+  {
+    HitTimeBinDefault = 0,
+    HitTimeBinUniform = 1
+  };
+
+  // Constructors and destructors.
+  LArHitMerger(StoreGateSvc* detStore,
+	       LArHitsEventAction* action,
+	       std::string timeBinType,
+	       G4float timeBinWidth);    // This has some effect for the uniform binning only
+
+  virtual ~LArHitMerger();
+
+  // Clean up at the beginning of event
+  void BeginOfEvent();
+
+  // Do the actual job here
+  bool process(G4Step* step,
+	       LArG4Identifier ident,
+	       G4double time,
+	       G4double energy);
+
+  // Distribute hits created during the event between global containers
+  void EndOfEvent();
+
+  // Clear the map
+  void clear();
+
+  // We need two types containers for hits:
+
+  // The set defined below is used to tell us if we've already had a
+  // hit in a cell.  We store these hits in a set, so we can quickly
+  // search it.  Note the use of a custom definition of a "less"
+  // function for the set, so we're not just comparing hit pointers.
+
+  class LessHit {
+  public:
+    bool operator() ( LArHit* const& p, LArHit* const& q ) const
+    {
+      return p->Less(q);
+    }
+  };
+  
+  typedef std::set< LArHit*, LessHit >  hits_t;
+  typedef hits_t::iterator              hits_pointer;
+  
+  // The hits are grouped into time bins, with the width of a bin
+  // determined by a user parameter.  This map is used to associate a
+  // time bin with its corresponding set of hits.
+  
+  typedef std::map < G4int, hits_t* >   timeBins_t;
+  typedef timeBins_t::iterator          timeBins_pointer;
+  typedef timeBins_t::const_iterator    timeBins_const_pointer;
+
+private:
+  // Pointer to the action object which holds global collections
+  LArHitsEventAction* m_action;
+
+  // Time binning type
+  LArHitMerger::LArHitTimeBins m_timeBinType;
+
+  // Get the time bin
+  G4int getTimeBin(G4double time);
+
+  // Width of the time bins for summing hits - for the uniform binning
+  G4float m_timeBinWidth;
+
+  timeBins_t                          m_timeBins;
+};
+
+#endif // _LArHitMerger_H_

LArCalorimeter/LArG4/LArG4HitManagement/LArG4HitManagement/LArHitMergerFactory.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef __LArHitMergerFactory_H__
+#define __LArHitMergerFactory_H__
+
+#include "LArG4HitManagement/LArHitMerger.h"
+#include "LArG4Code/LArVHitMergerFactory.h"
+#include <string>
+#include <vector>
+
+class StoreGateSvc;
+class LArHitsEventAction;
+
+class LArHitMergerFactory : public LArVHitMergerFactory
+{
+ public:
+
+  // Constructors and destructors.
+  LArHitMergerFactory(StoreGateSvc* detStore,
+		      LArHitsEventAction* action,
+		      std::string timeBinType,
+		      G4float timeBinWidth);
+
+  virtual ~LArHitMergerFactory();
+
+  LArVHitMerger* getHitMerger() const;
+
+ private:
+  StoreGateSvc*       m_detStore;
+  LArHitsEventAction* m_action;
+  std::string         m_timeBinType;
+  G4float             m_timeBinWidth;
+
+  // Keep pointers to all created hit mergers in order to avoid memory leaks
+  typedef std::vector<LArHitMerger* > HitMergerVec;
+  mutable HitMergerVec m_hitMergers;
+};
+
+#endif // _LArHitMergerFactory_H_

LArCalorimeter/LArG4/LArG4HitManagement/LArG4HitManagement/LArHitsEventAction.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef LArHitEventAction_H
+#define LArHitEventAction_H
+
+#include "FadsActions/ApplicationAction.h"
+#include "SimHelpers/AthenaHitsCollectionHelper.h"
+
+#include "globals.hh"
+#include <string>
+
+class G4Event;
+class G4Run;
+class IMessageSvc;
+class StoreGateSvc;
+class StoredLArHitContainers;
+class StoredLArCalibHitContainers;
+
+class LArHitsEventAction: public FADS::ApplicationAction 
+{
+  friend class LArHitMerger;
+  friend class LArCalibHitMerger;
+
+ public:
+  LArHitsEventAction();
+  ~LArHitsEventAction();
+  void BeginOfRunAction(const G4Run*);
+  void EndOfRunAction(const G4Run*);
+  void BeginOfEventAction(const G4Event*);
+  void EndOfEventAction(const G4Event*);
+
+ protected:
+  StoredLArHitContainers* m_storedContainers;
+  StoredLArCalibHitContainers* m_storedCalibContainers;
+
+  StoredLArHitContainers* getStoredContainers() { return m_storedContainers;}
+  StoredLArCalibHitContainers* getStoredCalibContainers() { return m_storedCalibContainers;}
+
+ private:
+  AthenaHitsCollectionHelper helper;
+
+  StoreGateSvc* m_detStore;
+  IMessageSvc*  m_msgSvc;
+
+  // Lar hit time binning type
+  std::string m_timeBinType;
+
+  // Width of the time bins for summing hits - for the uniform binning
+  G4float m_timeBinWidth;
+
+  bool m_doMiniFcal;
+  bool m_allowMods;
+};
+
+#endif

LArCalorimeter/LArG4/LArG4HitManagement/cmt/requirements

+package LArG4HitManagement
+
+author ADA
+
+
+use AtlasPolicy    AtlasPolicy-*
+
+use Geant4         Geant4-*            External
+
+# Needed for basic LArG4 classes (e.g., internal hit description)
+use LArG4Code       LArG4Code-*        LArCalorimeter/LArG4
+
+# Needed to create hit collections.
+use LArSimEvent    LArSimEvent-*       LArCalorimeter
+use CaloSimEvent   CaloSimEvent-*      Calorimeter
+
+
+# Application Action
+
+use FadsActions	   FadsActions-*       Simulation/G4Sim/FADS
+
+# helpers
+
+use SimHelpers	   SimHelpers-*        Simulation/G4Sim
+
+library LArG4HitManagement *.cxx
+
+apply_pattern linked_library
+
+#=======================================================
+private
+use GaudiInterface  GaudiInterface-*    External
+use LArG4RunControl LArG4RunControl-*   LArCalorimeter/LArG4
+use StoreGate       StoreGate-*         Control
+use CaloIdentifier  CaloIdentifier-*    Calorimeter
+

LArCalorimeter/LArG4/LArG4HitManagement/doc/MainPage.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+
+
+@mainpage
+
+This package contains the implementation of HitMerger interface which is used by standard LAr G4 Simulation. It also contains a Fads Application Action class which manages Hit Merger objects and LAr Hit Collections.
+
+--------------------------------
+  REQUIREMENTS 
+--------------------------------
+
+@include requirements
+@htmlinclude used_packages.html 
+
+*/

LArCalorimeter/LArG4/LArG4HitManagement/src/LArCalibHitMerger.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "LArG4HitManagement/LArCalibHitMerger.h"
+#include "CaloSimEvent/CaloCalibrationHitContainer.h"
+
+#include "StoreGate/StoreGateSvc.h"
+
+#include "CaloIdentifier/CaloDM_ID.h"
+
+#include <string>
+
+LArCalibHitMerger::LArCalibHitMerger(StoreGateSvc* detStore,
+				     LArHitsEventAction* action):
+  LArVCalibHitMerger(detStore),
+  m_action(action)
+{
+}
+
+LArCalibHitMerger::~LArCalibHitMerger()
+{
+}
+
+void LArCalibHitMerger::BeginOfEvent()
+{
+}
+
+bool LArCalibHitMerger::process(LArG4Identifier ident,
+				const std::vector<G4double>& energies)
+{
+  Identifier id = ConvertID(ident);
+  if(!id.is_valid())
+    return false;
+
+  // Reject cases where invisible energy calculation produced values
+  // of order 10e-12 instead of 0 due to rounding errors in that
+  // calculation, or general cases where the energy deposits are
+  // trivially small.
+  
+  if(energies[0]+energies[1]+energies[3] < 0.001*CLHEP::eV && fabs(energies[2]) < 0.001*CLHEP::eV ) {
+    return true;
+  }
+
+  // Build the hit.
+  CaloCalibrationHit* hit = new CaloCalibrationHit(id,
+						   energies[0],
+						   energies[1],
+						   energies[2],
+						   energies[3]);
+
+
+  // If we haven't had a hit in this cell before, add the current hit
+  // to the hit collection.
+
+  // If we've had a hit in this cell before, then add this to the
+  // previously-existing hit.
+
+  // Look for the hit in the m_calibrationHits (this is a binary search).
+  m_calibrationHits_ptr_t bookmark = m_calibrationHits.lower_bound(hit);
+  
+  // The lower_bound method of a set finds the first element not less
+  // the hit.  If this element == our hit, we've found a match.
+  
+  // Reminders:
+  // bookmark = iterator (pointer) into the m_calibrationHits set.
+  // (*bookmark) = a member of the set, which is a CalibrationHit*.
+  
+  // Equals() is a function defined in CalibrationHit.h; it has the value of
+  // "true" when a CalibrationHit* points to the same identifier.
+  
+  if(bookmark == m_calibrationHits.end() || !(*bookmark)->Equals(hit))
+  {
+    // We haven't had a hit in this readout cell before.  Add it
+    // to our set.
+
+    if(m_calibrationHits.empty() || bookmark == m_calibrationHits.begin())
+    {
+      // Insert the hit before the first entry in the map.
+      m_calibrationHits.insert(hit);
+    }
+    else
+    {
+      // We've just done a binary search of m_calibrationHits,
+      // so we should use the results of that search to speed up
+      // the insertion of a new hit into the map.  The "insert"
+      // method is faster if the new entry is right _after_ the
+      // bookmark.  If we left bookmark unchanged, the new entry
+      // would go right _before_ the bookmark.  We therefore
+      // want to decrement the bookmark from the lower_bound
+      // search.
+      
+      m_calibrationHits.insert(--bookmark, hit);
+    }
+  }
+  else
+  {
+    // Update the existing hit. 
+    (*bookmark)->Add(hit);
+    
+    // We don't need the hit anymore.  Remember that we've adopted
+    // the hit, so we're responsible for deleting it if needed.
+    delete hit;
+  }
+
+  return true;
+}
+
+
+bool LArCalibHitMerger::process(LArG4Identifier ident,
+                                const std::vector<G4double>& energies, 
+				unsigned int particleID)
+{
+  Identifier id = ConvertID(ident);
+  if(!id.is_valid())
+    return false;
+
+  // Reject cases where invisible energy calculation produced values
+  // of order 10e-12 instead of 0 due to rounding errors in that
+  // calculation, or general cases where the energy deposits are
+  // trivially small.
+  
+  if(energies[0]+energies[1]+energies[3] < 0.001*CLHEP::eV && fabs(energies[2]) < 0.001*CLHEP::eV ) {
+    return true;
+  }
+
+  // Build the hit.
+  CaloCalibrationHit* hit = new CaloCalibrationHit(id,
+      energies[0],
+      energies[1],
+      energies[2],
+      energies[3],
+      particleID);
+
+  // If we haven't had a hit in this cell before, add the current hit
+  // to the hit collection.
+
+  // If we've had a hit in this cell before, then add this to the
+  // previously-existing hit.
+
+  // Look for the hit in the m_calibrationHits (this is a binary search).
+  m_calibrationHits_ptr_t bookmark = m_calibrationHits.lower_bound(hit);
+  
+  // The lower_bound method of a set finds the first element not less
+  // the hit.  If this element == our hit, we've found a match.
+  
+  // Reminders:
+  // bookmark = iterator (pointer) into the m_calibrationHits set.
+  // (*bookmark) = a member of the set, which is a CalibrationHit*.
+  
+  // Equals() is a function defined in CalibrationHit.h; it has the value of
+  // "true" when a CalibrationHit* points to the same identifier.
+  
+  if(bookmark == m_calibrationHits.end() || !(*bookmark)->Equals(hit))
+  {
+    // We haven't had a hit in this readout cell before.  Add it
+    // to our set.
+
+    if(m_calibrationHits.empty() || bookmark == m_calibrationHits.begin())
+    {
+      // Insert the hit before the first entry in the map.
+      m_calibrationHits.insert(hit);
+    }
+    else
+    {
+      // We've just done a binary search of m_calibrationHits,
+      // so we should use the results of that search to speed up
+      // the insertion of a new hit into the map.  The "insert"
+      // method is faster if the new entry is right _after_ the
+      // bookmark.  If we left bookmark unchanged, the new entry
+      // would go right _before_ the bookmark.  We therefore
+      // want to decrement the bookmark from the lower_bound
+      // search.
+      
+      m_calibrationHits.insert(--bookmark, hit);
+    }
+  }
+  else
+  {
+    // Update the existing hit. 
+    (*bookmark)->Add(hit);
+    
+    // We don't need the hit anymore.  Remember that we've adopted
+    // the hit, so we're responsible for deleting it if needed.
+    delete hit;
+  }
+
+  return true;
+}
+
+
+void LArCalibHitMerger::EndOfEvent(std::string detectorName)
+{
+  StoredLArCalibHitContainers* storedContainers = m_action->getStoredCalibContainers();
+
+  CaloCalibrationHitContainer* deadHitCollection = storedContainers->deadHitCollection;
+  CaloCalibrationHitContainer* inactiveHitCollection = storedContainers->inactiveHitCollection;
+  CaloCalibrationHitContainer* activeHitCollection = storedContainers->activeHitCollection;
+
+  m_calibrationHits_ptr_t i;
+  for(i = m_calibrationHits.begin(); i != m_calibrationHits.end(); i++)
+  {
+    CaloCalibrationHit* hit = *i;
+    Identifier id = hit->cellID();
+
+    if(m_caloDmID->is_lar_dm(id) || m_caloDmID->is_tile_dm(id))
+    {
+      deadHitCollection->push_back(hit);
+    }
+    else if(detectorName.find("::Inactive")!=std::string::npos)
+    {
+      inactiveHitCollection->push_back(hit);
+    }
+    else if(detectorName.find("::Dead")!=std::string::npos)
+    {
+      inactiveHitCollection->push_back(hit);
+    }
+    else
+    {
+      // If it's not dead or inactive, then it's active.
+      activeHitCollection->push_back(hit);
+    }
+  }
+
+  clear();
+}
+
+void LArCalibHitMerger::clear()
+{
+  m_calibrationHits.clear();
+}
+

LArCalorimeter/LArG4/LArG4HitManagement/src/LArCalibHitMergerFactory.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "LArG4HitManagement/LArCalibHitMergerFactory.h"
+#include "LArG4HitManagement/LArHitsEventAction.h"
+
+#include "StoreGate/StoreGateSvc.h"
+
+
+LArCalibHitMergerFactory::LArCalibHitMergerFactory(StoreGateSvc* detStore,
+						   LArHitsEventAction* action):
+  m_detStore(detStore),
+  m_action(action)
+{
+}
+
+LArCalibHitMergerFactory::~LArCalibHitMergerFactory()
+{
+  // Clean up the vector of hit mergers
+  CalibHitMergerVec::iterator first = m_hitMergers.begin();
+  CalibHitMergerVec::iterator last = m_hitMergers.end();
+  for(; first!=last; first++)
+    delete (*first);
+}
+
+LArVCalibHitMerger* LArCalibHitMergerFactory::getHitMerger() const
+{
+  LArCalibHitMerger* hitMerger = new LArCalibHitMerger(m_detStore,m_action);
+  m_hitMergers.push_back(hitMerger);
+  return hitMerger;
+}
+

LArCalorimeter/LArG4/LArG4HitManagement/src/LArHitMerger.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "LArG4HitManagement/LArHitMerger.h"
+#include "LArSimEvent/LArHitContainer.h"
+
+#include "GaudiKernel/MsgStream.h"
+#include "StoreGate/StoreGateSvc.h"
+
+#include "CaloIdentifier/LArEM_ID.h"
+#include "CaloIdentifier/LArFCAL_ID.h"
+#include "CaloIdentifier/LArMiniFCAL_ID.h"
+#include "CaloIdentifier/LArHEC_ID.h"
+
+LArHitMerger::LArHitMerger(StoreGateSvc* detStore,
+			   LArHitsEventAction* action,
+			   std::string timeBinType,
+			   G4float timeBinWidth):
+  LArVHitMerger(detStore),
+  m_action(action),
+  m_timeBinWidth(timeBinWidth)
+{
+  // Set time bin type
+  if(timeBinType == "Default")
+    m_timeBinType = LArHitMerger::HitTimeBinDefault;
+  else if(timeBinType == "Uniform")
+    m_timeBinType = LArHitMerger::HitTimeBinUniform;
+  else // Unexpected value - fail over default
+    m_timeBinType = LArHitMerger::HitTimeBinDefault;
+}
+
+LArHitMerger::~LArHitMerger()
+{
+}
+
+void LArHitMerger::BeginOfEvent()
+{
+}
+
+bool LArHitMerger::process(G4Step* /*step*/,
+			   LArG4Identifier ident,
+			   G4double time,
+			   G4double energy)
+{
+  // Build the hit from the calculator results.
+  Identifier id = ConvertID( ident );
+  if (!id.is_valid()) 
+    return false;
+
+  G4int timeBin = getTimeBin(time);  
+  
+  // Find the set of hits for this time bin.  If this is the
+  // first hit in this bin, create a new set.
+  
+  hits_t* hitCollection = 0;
+  timeBins_pointer setForThisBin = m_timeBins.find( timeBin );
+
+  if (setForThisBin == m_timeBins.end())
+  {
+    // New time bin
+    hitCollection = new hits_t;
+    m_timeBins[ timeBin ] = hitCollection;
+  }
+  else
+  {
+    // Get the existing set of hits for this time bin.
+    // Reminders:
+    // setForThisBin = iterator (pointer) into the m_timeBins map
+    // (*setForThisBin) = pair< G4int, m_hits_t* >
+    // (*setForThisBin).second = m_hits_t*, the pointer to the set of hits
+      
+    hitCollection = (*setForThisBin).second;
+  }
+  
+  LArHit* hit = new LArHit(id,energy,time);
+
+  // If we haven't had a hit in this cell before, create one and add
+  // it to the hit collection.
+  
+  // If we've had a hit in this cell before, then add the energy to
+  // the existing hit.
+  
+  // Look for the key in the hitCollection (this is a binary search).
+  hits_pointer bookmark = hitCollection->lower_bound(hit);
+  
+  // The lower_bound method of a map finds the first element
+  // whose key is not less than the identifier.  If this element
+  // == our hit, we've found a match.
+  
+  // Reminders:
+  // bookmark = iterator (pointer) into the hitCollection set.
+  // (*bookmark) = a member of the set, which is a LArG4Hit*.
+  
+  // Equals() is a function defined in LArG4Hit.h; it has the value of
+  // "true" when a LArG4Hit* points to the same identifier.
+  
+  if (bookmark == hitCollection->end() ||
+      !(*bookmark)->Equals(hit))
+  {
+    // We haven't had a hit in this readout cell before.  Add it
+    // to our set.
+    if (hitCollection->empty() || 
+	bookmark == hitCollection->begin())
+    {
+      // Insert the hit before the first entry in the map.
+      hitCollection->insert(hit);
+    }
+    else
+    {
+      // We'just done a binary search of hitCollection, so we should use
+      // the results of that search to speed up the insertion of a new
+      // hit into the map.  The "insert" method is faster if the new
+      // entry is right _after_ the bookmark.  If we left bookmark
+      // unchanged, the new entry would go right _before_ the
+      // bookmark.  We therefore want to decrement the bookmark from
+      // the lower_bound search.
+      
+      hitCollection->insert(--bookmark, hit);
+    }
+  }
+  else
+  {
+    // Update the existing hit.
+    (*bookmark)->Add(hit);
+    
+    // We don't need our previously-created hit anymore.  
+    delete hit;	
+  }
+
+  return true;
+}
+
+void LArHitMerger::EndOfEvent()
+{
+  StoredLArHitContainers* storedContainers = m_action->getStoredContainers();
+
+  LArHitContainer* embHitCollection = storedContainers->embHitCollection; 
+  LArHitContainer* emecHitCollection = storedContainers->emecHitCollection;
+  LArHitContainer* fcalHitCollection = storedContainers->fcalHitCollection;
+  LArHitContainer* hecHitCollection = storedContainers->hecHitCollection;
+  LArHitContainer* miniFcalHitCollection = storedContainers->miniFcalHitCollection;
+
+  // For each time bin...
+  for(timeBins_const_pointer i = m_timeBins.begin(); i != m_timeBins.end(); i++)
+  {
+    if(m_log->level()==MSG::DEBUG)
+      (*m_log) << MSG::DEBUG << "EndOfEvent: time bin " << (*i).first
+	       << " - #hits = " << (*i).second->size() << endreq;
+
+    const hits_t* hitSet = (*i).second;
+
+    // For each hit in the set...
+    for(hits_pointer j = hitSet->begin(); j != hitSet->end(); j++)
+    {
+      // Reminders:
+      // j = iterator (pointer) into the hitSet.
+      // (*j) = a member of the set, which is a LArG4Hit*.
+      LArHit* hit = *j;
+      hit->finalize();
+      Identifier id  = hit->cellID();
+
+      if(m_larEmID->is_lar_em(id))
+      {
+	if(m_larEmID->is_em_barrel(id))
+	{
+	  embHitCollection->push_back(hit);
+	}
+	else if(m_larEmID->is_em_endcap(id))
+	{
+	  emecHitCollection->push_back(hit);
+	}
+      }
+      else if(m_larMiniFcalID->is_initialized() && m_larMiniFcalID->is_lar_minifcal(id))
+      {
+	miniFcalHitCollection->push_back(hit);
+      }
+      else if(m_larFcalID->is_lar_fcal(id))
+      {
+	fcalHitCollection->push_back(hit);
+      }
+      else if(m_larHecID->is_lar_hec(id))
+      {
+	hecHitCollection->push_back(hit);
+      }
+    }
+  }
+
+  clear();
+}
+
+void LArHitMerger::clear()
+{
+  for(timeBins_pointer i = m_timeBins.begin(); i!= m_timeBins.end(); i++)
+    delete (*i).second;
+  m_timeBins.clear();
+}
+
+G4int LArHitMerger::getTimeBin(G4double time) 
+{
+  G4int timeBin = INT_MAX;
+
+  if(m_timeBinType==LArHitMerger::HitTimeBinDefault)
+  {
+    if(time<0.) 
+      time=0.;
+    if(time<10.) 
+      timeBin = int(time/2.5);
+    else if(time<50.)
+      timeBin = 4 + int((time-10.)/5.);
+    else if(time<100.)
+      timeBin = 12 + int((time-50.)/25.);
+    else
+      timeBin = 14;
+  }
+  else
+  {
+    // Uniform binning by 2.5 ns
+    G4double timeBinf = time/m_timeBinWidth;
+    
+    if (timeBinf < G4double(INT_MAX))
+      timeBin = G4int(timeBinf);
+  }
+
+  return timeBin;
+} 

LArCalorimeter/LArG4/LArG4HitManagement/src/LArHitMergerFactory.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "LArG4HitManagement/LArHitMergerFactory.h"
+#include "LArG4HitManagement/LArHitsEventAction.h"
+
+#include "StoreGate/StoreGateSvc.h"
+
+
+
+LArHitMergerFactory::LArHitMergerFactory(StoreGateSvc* detStore,
+					 LArHitsEventAction* action,
+					 std::string timeBinType,
+					 G4float timeBinWidth):
+  m_detStore(detStore),
+  m_action(action),
+  m_timeBinType(timeBinType),
+  m_timeBinWidth(timeBinWidth)
+{
+}
+
+LArHitMergerFactory::~LArHitMergerFactory()
+{
+  // Clean up the vector of hit mergers
+  HitMergerVec::iterator first = m_hitMergers.begin();
+  HitMergerVec::iterator last = m_hitMergers.end();
+  for(; first!=last; first++)
+    delete (*first);
+}
+
+LArVHitMerger* LArHitMergerFactory::getHitMerger() const
+{
+  LArHitMerger* hitMerger = new LArHitMerger(m_detStore,m_action,m_timeBinType,m_timeBinWidth);
+  m_hitMergers.push_back(hitMerger);
+  return hitMerger;
+}
+

LArCalorimeter/LArG4/LArG4HitManagement/src/LArHitsEventAction.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "LArG4HitManagement/LArHitsEventAction.h"
+#include "LArG4HitManagement/LArHitMergerFactory.h"
+#include "LArG4HitManagement/LArCalibHitMergerFactory.h"
+#include "LArG4RunControl/LArG4GlobalOptions.h"
+
+#include "LArSimEvent/LArHitContainer.h"
+#include "CaloSimEvent/CaloCalibrationHitContainer.h"
+
+#include "FadsActions/FadsEventAction.h"
+#include "FadsActions/FadsRunAction.h"
+
+#include "GaudiKernel/ISvcLocator.h"
+#include "GaudiKernel/IMessageSvc.h"
+#include "StoreGate/StoreGateSvc.h"
+
+#include "CaloIdentifier/CaloIdManager.h"
+#include "CaloIdentifier/LArMiniFCAL_ID.h"
+
+#include "G4Run.hh"
+#include "G4Event.hh"
+
+#include <iostream>
+#include <vector>
+
+using namespace FADS;
+
+static LArHitsEventAction applEventAction;
+
+LArHitsEventAction::LArHitsEventAction():
+  ApplicationAction(),
+  m_storedContainers(0),
+  m_storedCalibContainers(0),
+  m_timeBinType("Default"),
+  m_timeBinWidth(2.5*CLHEP::ns),
+  m_doMiniFcal(false),
+  m_allowMods(false)
+{
+  FadsEventAction::GetEventAction()->SetApplicationAction(this);
+  FadsRunAction::GetRunAction()->SetApplicationAction(this);
+}
+
+LArHitsEventAction::~LArHitsEventAction()
+{
+}
+
+void LArHitsEventAction::EndOfRunAction(const G4Run*)
+{
+  delete m_storedContainers;
+  delete m_storedCalibContainers;
+}
+
+void LArHitsEventAction::BeginOfRunAction(const G4Run*)
+{
+  // We have to defer the creation of collectionBuilder until
+  // well into the application initialization process.  The reason is
+  // the "static" declaration above; if we put the following statement
+  // in the constructor, then the object will try to create
+  // collectionBuilder immediately when the library is loaded.  The
+  // problem is that collectionBuilder depends on the detector
+  // description, which isn't loaded into memory until later.  The
+  // following code attempts to get around that issue.
+
+  // Global containers
+  m_storedContainers = new StoredLArHitContainers();
+  m_storedCalibContainers = new StoredLArCalibHitContainers();
+
+  // Get the Message Service and the Detector Store
+  ISvcLocator* svcLocator = Gaudi::svcLocator();
+  StatusCode status = svcLocator->service("MessageSvc", m_msgSvc);
+  MsgStream log(m_msgSvc, "LArHitsEventAction::BeginOfRunAction");
+  if (status.isFailure())
+  {
+    log << MSG::FATAL << "MessageSvc not found!" << endreq;
+    return;
+  }
+  else
+    log << MSG::DEBUG << "MessageSvc initialized." << endreq;
+
+  status = svcLocator->service("DetectorStore", m_detStore);
+  if (status.isFailure())
+  {
+    log << MSG::FATAL << "Unable to get pointer to DetectorStore Service" << endreq;
+    return;
+  }
+  else
+    log << MSG::DEBUG << "DetectorStore Svc initialized." << endreq;
+
+  // Get Global Options from Run Control - for Time Bin Width
+  const LArG4GlobalOptions* glOpt=0;
+
+  if(m_detStore->contains<LArG4GlobalOptions>("LArG4GlobalOptions"))
+  {
+    status = m_detStore->retrieve(glOpt,"LArG4GlobalOptions");
+
+    if(status.isSuccess())
+      log << MSG::DEBUG << "LArG4GlobalOptions retrieved!" << endreq;
+    else
+      log << MSG::DEBUG << "Unable to retrieve LArG4GlobalOptions! Using default value for TimeBinType = '" << m_timeBinType 
+	  << "' and TimeBinWidth = " << m_timeBinWidth << " and AllowHitModification = " << m_allowMods << endreq;
+
+    if(glOpt)
+    {
+      m_timeBinType = glOpt->TimeBinType();
+      m_timeBinWidth = glOpt->TimeBinWidth();
+      m_allowMods = glOpt->AllowHitModification();
+    }
+  }
+  else
+    log << MSG::DEBUG << "No LArG4GlobalOptions in Detector Store! Using default value for TimeBinType = '" << m_timeBinType 
+	<< "' and TimeBinWidth = " << m_timeBinWidth <<  endreq;
+
+  // Create Hit Merger Factories for regular and calibration hits and put them to TDS
+  LArHitMergerFactory* _factory = new LArHitMergerFactory(m_detStore,this,m_timeBinType,m_timeBinWidth);
+
+  status = m_detStore->record(dynamic_cast<LArVHitMergerFactory*>(_factory),"LArHitMergerFactory");
+  if (status.isFailure()) 
+    log << MSG::ERROR << "Unable to record HitMergerFactory" << endreq;
+  else
+    log << MSG::DEBUG << "HitMergerFactory recorded" << endreq;
+
+  LArCalibHitMergerFactory* _calib_factory = new LArCalibHitMergerFactory(m_detStore,this);
+
+  status = m_detStore->record(dynamic_cast<LArVCalibHitMergerFactory*>(_calib_factory),"LArCalibHitMergerFactory");
+  if (status.isFailure()) {
+    log << MSG::ERROR << "Unable to record CalibHitMergerFactory" << endreq;
+    return;
+  }
+  else {
+    log << MSG::DEBUG << "CalibHitMergerFactory recorded" << endreq;
+  }
+
+  // Check whether or not we need to write out Mini FCAL hits
+  const CaloIdManager* caloIdManager;
+  status = m_detStore->retrieve(caloIdManager);
+  if(!status.isSuccess()) {
+    log << MSG::ERROR << "Unable to retrieve CaloIdManager. Mini FCAL hits will not be persistified" << endreq;
+    return;
+  }
+
+  const LArMiniFCAL_ID* larMiniFcalID = caloIdManager->getMiniFCAL_ID();
+  m_doMiniFcal = (larMiniFcalID && larMiniFcalID->is_initialized());
+  
+}
+
+void LArHitsEventAction::BeginOfEventAction(const G4Event*)
+{
+
+  m_storedContainers->embHitCollection = helper.RetrieveNonconstCollection<LArHitContainer>("LArHitEMB");
+  m_storedContainers->emecHitCollection = helper.RetrieveNonconstCollection<LArHitContainer>("LArHitEMEC");
+  m_storedContainers->fcalHitCollection = helper.RetrieveNonconstCollection<LArHitContainer>("LArHitFCAL");
+  m_storedContainers->hecHitCollection = helper.RetrieveNonconstCollection<LArHitContainer>("LArHitHEC");
+  if(m_doMiniFcal)
+    m_storedContainers->miniFcalHitCollection = helper.RetrieveNonconstCollection<LArHitContainer>("LArHitMiniFCAL");
+  
+  m_storedCalibContainers->activeHitCollection = helper.RetrieveNonconstCollection<CaloCalibrationHitContainer>("LArCalibrationHitActive");
+  m_storedCalibContainers->inactiveHitCollection = helper.RetrieveNonconstCollection<CaloCalibrationHitContainer>("LArCalibrationHitInactive");
+  m_storedCalibContainers->deadHitCollection = helper.RetrieveNonconstCollection<CaloCalibrationHitContainer>("LArCalibrationHitDeadMaterial");
+
+  /*
+  m_storedContainers->embHitCollection = new LArHitContainer("LArHitEMB");
+  m_storedContainers->emecHitCollection = new LArHitContainer("LArHitEMEC");
+  m_storedContainers->fcalHitCollection = new LArHitContainer("LArHitFCAL");
+  m_storedContainers->hecHitCollection = new LArHitContainer("LArHitHEC");
+  if(m_doMiniFcal)
+    m_storedContainers->miniFcalHitCollection = new LArHitContainer("LArHitMiniFCAL");
+
+  m_storedCalibContainers->activeHitCollection = new CaloCalibrationHitContainer("LArCalibrationHitActive");
+  m_storedCalibContainers->inactiveHitCollection = new CaloCalibrationHitContainer("LArCalibrationHitInactive");
+  m_storedCalibContainers->deadHitCollection = new CaloCalibrationHitContainer("LArCalibrationHitDeadMaterial");
+  */
+
+}
+
+void LArHitsEventAction::EndOfEventAction(const G4Event*)
+{
+  if (!m_allowMods) {
+    helper.SetConstCollection< LArHitContainer >(m_storedContainers->embHitCollection);
+    helper.SetConstCollection< LArHitContainer >(m_storedContainers->emecHitCollection);
+    helper.SetConstCollection< LArHitContainer >(m_storedContainers->fcalHitCollection);
+    helper.SetConstCollection< LArHitContainer >(m_storedContainers->hecHitCollection);
+    if(m_doMiniFcal)
+      helper.SetConstCollection< LArHitContainer >(m_storedContainers->miniFcalHitCollection);
+    
+    helper.SetConstCollection< CaloCalibrationHitContainer >(m_storedCalibContainers->activeHitCollection);
+    helper.SetConstCollection< CaloCalibrationHitContainer >(m_storedCalibContainers->inactiveHitCollection);
+    helper.SetConstCollection< CaloCalibrationHitContainer >(m_storedCalibContainers->deadHitCollection);    
+  }
+  
+  /*
+  helper.ExportCollection< LArHitContainer >(m_storedContainers->embHitCollection);
+  helper.ExportCollection< LArHitContainer >(m_storedContainers->emecHitCollection);
+  helper.ExportCollection< LArHitContainer >(m_storedContainers->fcalHitCollection);
+  helper.ExportCollection< LArHitContainer >(m_storedContainers->hecHitCollection);
+  if(m_doMiniFcal)
+    helper.ExportCollection< LArHitContainer >(m_storedContainers->miniFcalHitCollection);
+
+  helper.ExportCollection< CaloCalibrationHitContainer >(m_storedCalibContainers->activeHitCollection);
+  helper.ExportCollection< CaloCalibrationHitContainer >(m_storedCalibContainers->inactiveHitCollection);
+  helper.ExportCollection< CaloCalibrationHitContainer >(m_storedCalibContainers->deadHitCollection);
+  */
+}