LCIOSDTestActions.cpp

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : F.Gaede, DESY
//
//==========================================================================
 
// Framework include files
#include <Exceptions.h>
#include <IMPL/LCCollectionVec.h>
#include <IMPL/SimTrackerHitImpl.h>
#include <IMPL/SimCalorimeterHitImpl.h>
#include <IMPL/MCParticleImpl.h>
#include <UTIL/Operators.h>
#include <UTIL/ILDConf.h>
 
#include <DDG4/Geant4SensDetAction.h>
#include <DDG4/Geant4Data.h>
#include <DDG4/Geant4StepHandler.h>
 
#include <DD4hep/Printout.h>
#include <DD4hep/InstanceCount.h>
 
using namespace dd4hep::sim;
using namespace dd4hep;
 
namespace  Tests {
 
  // copied from Geant4SDActions.cpp (why is this not a public class ??????)
 
 
  template <typename T> class Geant4SensitiveAction : public Geant4Sensitive  {
  protected:
    typedef Geant4Sensitive Base;
    size_t m_collectionID;
 
    // properties:
    bool _detailedHitsStoring ;
 
  public:
    //    typedef SimpleHit::Contribution HitContribution;
    // Standard , initializing constructor
    Geant4SensitiveAction(Geant4Context* ctxt, const std::string& nam, DetElement det, Detector& description_ref)
      : Geant4Sensitive(ctxt,nam,det,description_ref), m_collectionID(0) {
      declareProperty("detailedHitsStoring", _detailedHitsStoring ) ;
      defineCollections();
      InstanceCount::increment(this);
    }
    virtual ~Geant4SensitiveAction(){
      InstanceCount::decrement(this);
    }
    virtual void defineCollections()   override   {}
    virtual void begin(G4HCofThisEvent* hce)   override   {
      Base::begin(hce);
    }
    virtual void end(G4HCofThisEvent* hce)   override   {
      Base::end(hce);
    }
    virtual bool process(const G4Step* step, G4TouchableHistory* history)  override   {
      return Base::process(step,history);
    }
    virtual bool processFastSim(const Geant4FastSimSpot* spot, G4TouchableHistory* history)  override {
      return Base::processFastSim(spot,history);
    }
    virtual void clear(G4HCofThisEvent* hce)  override   {
      Base::clear(hce);
    }
  };
 
 
  // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  //               Geant4SensitiveAction<SimpleTracker>
  // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 
  class LcioTestTracker {};
 
  template <> void Geant4SensitiveAction<LcioTestTracker>::defineCollections() {
    m_collectionID = Base::defineCollection<lcio::SimTrackerHitImpl>(m_sensitive.readout().name());
  }
 
  template <> bool Geant4SensitiveAction<LcioTestTracker>::process(const G4Step* step,G4TouchableHistory* /*hist*/ ) {
    Geant4StepHandler h(step);
 
    Position prePos    = h.prePos();
    Position postPos   = h.postPos();
    Position direction = postPos - prePos;
    Position position  = mean_direction(prePos,postPos);
    double   hit_len   = direction.R();
 
    if (hit_len > 0) {
      double new_len = mean_length(h.preMom(),h.postMom())/hit_len;
      direction *= new_len/hit_len;
    }
 
    lcio::SimTrackerHitImpl* hit = new lcio::SimTrackerHitImpl;
    //    (h.track->GetTrackID(),
    // h.track->GetDefinition()->GetPDGEncoding(),
    // step->GetTotalEnergyDeposit(),
    // h.track->GetGlobalTime());
 
    // HitContribution contrib = Hit::extractContribution(step);
 
    VolumeID cell = volumeID( step ) ;
    hit->setCellID0( cell & 0xffffffff   ) ;
    hit->setCellID1( ( cell >> 32 ) & 0xffffffff   ) ;
 
    printout(INFO,"LcioTestTracker","%s> Add hit with deposit:%f  Pos:%f %f %f - cellID0: 0x%x cellID1: 0x%x",
             c_name(),step->GetTotalEnergyDeposit(),position.X(),position.Y(),position.Z() , hit->getCellID0() ,hit->getCellID1() );
 
    double pos[3] = {position.x(), position.y(), position.z()};
    hit->setPosition( pos  ) ;
 
    // hit->energyDeposit = contrib.deposit ;
    // hit->position      = position;
    // hit->momentum      = direction;
    // hit->length        = hit_len;
    collection(m_collectionID)->add(hit);
    return true;
  }
 
  template <> bool 
  Geant4SensitiveAction<LcioTestTracker>::processFastSim(const Geant4FastSimSpot*  /* spot */,
                             G4TouchableHistory* /*hist*/ )
  {
    except("Not implemented");
    return true;
  }
 
  
  typedef Geant4SensitiveAction<LcioTestTracker> LcioTestTrackerAction;
} // namespace
 
#include <DDG4/Factories.h>
DECLARE_GEANT4SENSITIVE_NS(Tests,LcioTestTrackerAction)