Geant4SensitiveDetector.cpp

// $Id$
//====================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------
//
//  Author     : M.Frank
//
//====================================================================

// Framework include files
#include "DDG4/Geant4SensitiveDetector.h"
#include "DDG4/Geant4Converter.h"
#include "DDG4/Geant4Hits.h"
#include "DD4hep/Printout.h"
#include "DD4hep/LCDD.h"

#include "G4Step.hh"
#include "G4PVPlacement.hh"

#include "TGeoNode.h"

#define DEBUG 0


// C/C++ include files
#include <iostream>
#include <stdexcept>

using namespace std;
using namespace DD4hep;
using namespace DD4hep::Simulation;

/// Constructor. The detector element is identified by the name
Geant4SensitiveDetector::Geant4SensitiveDetector(const string& name, LCDD& lcdd)
  : G4VSensitiveDetector(name), m_lcdd(lcdd), m_detector(), m_sensitive(), m_readout(), m_hce(0)
{
  m_sensitive = lcdd.sensitiveDetector(name);
  m_detector  = lcdd.detector(name);
  m_readout   = m_sensitive.readout();
}

/// Standard destructor
Geant4SensitiveDetector::~Geant4SensitiveDetector() {
}

/// Initialize the sensitive detector for the usage of a single hit collection
bool Geant4SensitiveDetector::defineCollection(const string& coll_name)   {
  if ( coll_name.empty() ) {
    throw runtime_error("Geant4SensitiveDetector: No collection defined for "+name()+
			" of type "+string(m_sensitive.type()));
  }
  collectionName.insert(coll_name);
  return true;
}

/// Access HitCollection container names
const string& Geant4SensitiveDetector::hitCollectionName(int which) const      { 
  size_t w = which;
  if ( w >= collectionName.size() ) {
    throw runtime_error("The collection name index for subdetector "+name()+" is out of range!");
  }
  return collectionName[which];
}

/// Create single hits collection
Geant4SensitiveDetector::HitCollection* Geant4SensitiveDetector::createCollection(const string& coll_name)  const  {
  return new G4THitsCollection<Geant4Hit>(GetName(), coll_name);
}
namespace DD4hep { namespace Simulation {
template <> Geant4CalorimeterHit* 
Geant4SensitiveDetector::find<Geant4CalorimeterHit>(const HitCollection* c,const HitCompare<Geant4CalorimeterHit>& cmp)   {
  typedef vector<Geant4CalorimeterHit*> _V;
  const _V* v = (const _V*)c->GetVector();
  for(_V::const_iterator i=v->begin(); i !=v->end(); ++i) 
    if ( cmp(*i) ) return *i;
  return 0;
}
}}

/// Method invoked at the begining of each event. 
void Geant4SensitiveDetector::Initialize(G4HCofThisEvent* HCE) {
  int count = 0;
  m_hce = HCE;
  for(G4CollectionNameVector::const_iterator i=collectionName.begin(); i!=collectionName.end();++i,++count) {
    G4VHitsCollection* c = createCollection(*i);
    m_hce->AddHitsCollection(GetCollectionID(count),c);
  }
}

/// Method invoked at the end of each event. 
void Geant4SensitiveDetector::EndOfEvent(G4HCofThisEvent* /* HCE */) {
  m_hce = 0;
  // Eventuall print event summary
}

/// Method for generating hit(s) using the information of G4Step object.
G4bool Geant4SensitiveDetector::ProcessHits(G4Step* step,G4TouchableHistory* hist) {
  return process(step,hist);
}

/// Method for generating hit(s) using the information of G4Step object.
G4bool Geant4SensitiveDetector::process(G4Step* step,G4TouchableHistory* hist) {
  double ene_cut = m_sensitive.energyCutoff();
  if ( step->GetTotalEnergyDeposit() > ene_cut ) {
    if ( !Geant4Hit::isGeantino(step->GetTrack()) )   {
#if DEBUG
      dumpStep(step, hist);
#endif
      return buildHits(step,hist);
    }
  }
#if DEBUG
  std::cout << " *** too small energy deposit : " <<  step->GetTotalEnergyDeposit()  << " < " <<  ene_cut  << "    at " <<  step->GetPreStepPoint()->GetPosition() << std::endl ;
#endif
  return false;
}

/// Retrieve the hits collection associated with this detector by its collection identifier
Geant4SensitiveDetector::HitCollection* Geant4SensitiveDetector::collectionByID(int id)    {
  HitCollection* hc = (HitCollection*)m_hce->GetHC(id);
  if ( hc ) return hc;
  throw runtime_error("The collection index for subdetector "+name()+" is wrong!");
}

/// Retrieve the hits collection associated with this detector by its serial number
Geant4SensitiveDetector::HitCollection* Geant4SensitiveDetector::collection(int which)    {
  size_t w = which;
  if ( w < collectionName.size() ) {
    HitCollection* hc = (HitCollection*)m_hce->GetHC(GetCollectionID(which));
    if ( hc ) return hc;
    throw runtime_error("The collection index for subdetector "+name()+" is wrong!");
  }
  throw runtime_error("The collection name index for subdetector "+name()+" is out of range!");
}

/// Method is invoked if the event abortion is occured.
void Geant4SensitiveDetector::clear() {
}

/// Dump Step information (careful: very verbose)
void Geant4SensitiveDetector::dumpStep(G4Step* st, G4TouchableHistory* /* history */) {
  Geant4StepHandler step(st);
  Geant4Mapping& cnv = Geant4Mapping::instance();
  //Geant4Converter::G4GeometryInfo& data = cnv.data();

  Position pos1 = step.prePos();
  Position pos2 = step.postPos();
  Momentum mom = step.postMom();

  printout(INFO,"G4Step","  Track:%08ld Pos:(%8f %8f %8f) -> (%f %f %f)  Mom:%7.0f %7.0f %7.0f",
   	   long(step.track), pos1.X(), pos1.Y(), pos1.Z(), pos2.X(), pos2.Y(), pos2.Z(), mom.X(), mom.Y(), mom.Z());
  printout(INFO,"G4Step","                pre-Vol: %s  Status:%s",
   	   step.preVolume()->GetName().c_str(), step.preStepStatus());
  printout(INFO,"G4Step","                post-Vol:%s  Status:%s",
   	   step.postVolume()->GetName().c_str(), step.postStepStatus());
  
  const G4VPhysicalVolume* pv = step.volume(step.post);
  
  typedef Geant4Converter::PlacementMap Places;
  const Places& places = cnv.data().g4Placements;

  for(Places::const_iterator i=places.begin(); i!=places.end();++i) {
    const G4VPhysicalVolume* pl = (*i).second;
    const G4VPhysicalVolume* qv = pl;
    
    if ( qv == pv ) {
      const TGeoNode* tpv = (*i).first;
      printf("           Found TGeoNode:%s!\n",tpv->GetName());
    }
  }

}


long long Geant4SensitiveDetector::getVolumeID(G4Step* aStep ){
  
  Geant4Mapping&  mapping = Geant4Mapping::instance();
  
  Geant4StepHandler step(aStep);

  Geant4VolumeManager volMgr = Geant4Mapping::instance().volumeManager();
  
  VolumeID id = volMgr.volumeID( step.preTouchable() );


#if 0 //  additional checks ...
   
  const G4VPhysicalVolume* g4v = step.volume( step.pre );

  if ( id == Geant4VolumeManager::InvalidPath )  {
    ::printf("                 -->  Severe ERROR: Invalid placement path: touchable corrupted?\n");
  }
  else if ( id == Geant4VolumeManager::Insensitive )  {
    ::printf("                 -->  WARNING: Only sensitive volumes may be decoded. %s\n" , g4v->GetName().c_str() );
  }
  else if ( id == Geant4VolumeManager::NonExisting )  {
    ::printf("                 -->  WARNING: non existing placement path.\n");
  }
  else  {

    std::stringstream str;
    Geant4VolumeManager::VolIDDescriptor dsc;
    Geant4VolumeManager::VolIDFields& fields = dsc.second;
    volMgr.volumeDescriptor( step.preTouchable(), dsc );
    for(Geant4VolumeManager::VolIDFields::iterator i=fields.begin(); i!=fields.end();++i){
      str << (*i).first->name() << "=" << (*i).second << " ";
    }
    ::printf("                 -->  CellID: %X [%X] -> %s\n",id,dsc.first,str.str().c_str());
    
  }

#endif
  
  return id ;
  

 //   // old way of lookup ----------- does not work for assemblies ....

 // //------------ get the cellID description string -----------------------------------
 
 //  Geometry::PlacedVolume place  = mapping.placement( g4v ) ;
      
 //  if( ! place.isValid() || ! place.volume().isSensitive() )  {
 //    G4cout << " **** Error in Geant4SensitiveDetector::getVolumeID:  invalid first sensitive volume in buildHits is not sensitive !!! " << std::endl ;
 //  }
 //  Geometry::Volume            vol    = place.volume();
 //  Geometry::SensitiveDetector sd     = vol.sensitiveDetector();
 //  Geometry::Readout           ro     = sd.readout();
      
 //  std::string  idDescStr =  ro.idSpec().fieldDescription() ;
 //  BitField64 bf( idDescStr ) ; 

 //  //------------ now fill the cellID from the volIDs of the complete path -----------------------------------

 //  const G4NavigationHistory* hist = aStep->GetPreStepPoint()->GetTouchableHandle()->GetHistory() ;
 //  int depth =  hist->GetDepth() ;
 //  //const G4VPhysicalVolume*  g4v = hist->GetVolume( depth ) ;
      
 //  for(int i=depth ; i>0 ; --i ) {
	
 //    g4v = hist->GetVolume(i) ;
 //    Geometry::PlacedVolume place  = mapping.placement( g4v ) ;

 //    if( ! place.isValid() ) {
 //      G4cout << " **** WARNING in Geant4SensitiveDetector::getVolumeID: ingnoring invalid PlacedVolume for : " <<  g4v->GetName() << std::endl ;
 //      continue ;
 //    }
	
 //    // G4cout << "---  VolIDs : " << std::endl ;
 //    Geometry::PlacedVolume::VolIDs ids = place.volIDs() ;

 //    for( Geometry::PlacedVolume::VolIDs::const_iterator it = ids.begin() ; it != ids.end() ; ++it ){
	  
 //      //  G4cout << "--- " << it->first << " -- " << it->second << std::
 //      bf[  it->first ] = it->second  ;
 //    }
 //  }

 //  return bf.getValue()  ;

}