LISTSERV 16.5 - LCD-CVS Archives

lcdd/include

G4SensitiveDetector.hh 1.12 -> 1.13

diff -u -r1.12 -r1.13
--- G4SensitiveDetector.hh	5 Sep 2006 23:25:20 -0000	1.12
+++ G4SensitiveDetector.hh	18 Dec 2006 21:21:20 -0000	1.13
@@ -1,24 +1,31 @@

 #ifndef G4SENSITIVEDETECTOR_HH
 #define G4SENSITIVEDETECTOR_HH 1

-// G4

+// geant4

 #include "G4VSensitiveDetector.hh"

-#include "globals.hh"

+#include "G4UnitsTable.hh"

-// LCDD
-#include "G4StepReadout.hh"

+// lcdd
+#include "StepReadout.hh"

 #include "IdSpec.hh"
 #include "Id64bit.hh"

+class G4UImessenger;
+class G4VHitsCollection;
+

 /**
  * @class G4SensitiveDetector
  * @brief Basic implementation of G4VSensitiveDetector.
  * @note  Primary settings include verbosity, energy cut,
  *        IdSpec, and HC ID.

-*/
-class G4SensitiveDetector : public G4VSensitiveDetector, protected G4StepReadout

+ */
+class G4SensitiveDetector : public G4VSensitiveDetector, protected StepReadout

 {
 public:

+
+  /**
+   * EType indicates the basic type of detector, e.g. tracker or calorimeter.
+   */

   enum EType { eNone=0, eTracker=1, eCalorimeter=2 };
 
   static const std::string& trackerStr;

@@ -33,76 +40,198 @@

   virtual ~G4SensitiveDetector();
 
 public:

+
+  /**
+   * Geant4 initialization function called at beginning of event.
+   */

   virtual void Initialize(G4HCofThisEvent *);

+
+  /**
+   * Geant4 EndOfEvent hook.
+   */

   virtual void EndOfEvent(G4HCofThisEvent *);
 
 protected:

+
+  /**
+   * Geant4 function to make hits from the step.
+   */

   virtual G4bool ProcessHits(G4Step*, G4TouchableHistory*);
 
 public:

+  
+  /**
+   * Return the type of this detector encoded as an int.
+   */
+  inline G4SensitiveDetector::EType getType() const
+  {
+    return m_type;
+  }

-  EType getType() const;
-  const std::string& getTypeString() const;
-
-  G4int getHCID() const;
-
-  virtual bool isValidVolume(G4LogicalVolume* lv);

+  /**
+   * Return the type of this detector encoded as a string.
+   */
+  inline const std::string& getTypeString() const;
+
+  /**
+   * Return the hits collection ID associated with this detector.
+   */
+  inline G4int getHCID() const
+  {
+    return m_HCID;
+  }

-  const std::string& getHCName()

+  /**
+   * Check whether the G4LogicalVolume can be readout by this detector. 
+   */
+  inline virtual bool isValidVolume(G4LogicalVolume* lv);
+
+  /**
+   * Return the hits collection name associated with this detector.
+   */
+  inline const std::string& getHCName() const

   {
     return collectionName[0];
   }

-  void setVerbose(unsigned int v)

+  /**
+   * Set the verbosity level of this detector.
+   */
+  inline void setVerbose(unsigned int v)

+    std::cout << "setVerbose " << v << std::endl;

     m_verbose = v;
   }

-  unsigned int getVerbose()

+  /**
+   * Get the verbosity level of this detector.
+   */
+  inline const unsigned int getVerbose() const

   {
     return m_verbose;
   }

-  G4double getEcut()

+  /**
+   * Return the hit energy cut of this detector.
+   */
+  inline G4double getEcut()

   {
     return m_ecut;
   }

-  void setEcut(G4double ec)

+  /**
+   * Set the hit energy cut of this detector.
+   */
+  inline void setEcut(G4double ec)

+    G4cout << this->GetName() << " - hit energy cut set to " << ec << G4endl;

     m_ecut = ec;
   }

-  void setIdSpec(IdSpec* idspec)

+  /**
+   * Set the identifier specification for this detector.
+   */
+  inline void setIdSpec(IdSpec* idspec)

   {
     m_idspec = idspec;
   }

-  IdSpec* getIdSpec() const

+  /**
+   * Return the identifier specification for this detector.
+   */
+  inline IdSpec* getIdSpec() const

   {
     return m_idspec;
   }

-  bool hasIdSpec() const

+  /**
+   * Returns whether or not this detector has an associated identifier specification.
+   */
+  inline bool hasIdSpec() const

   {
     return ( m_idspec != 0 );
   }

+  /**
+   * Create a 64-bit identifier based on the current step information.
+   */

   Id64bit makeId() const;

-  void setEndcapFlag( bool ec = true )

+  /**
+   * Set the endcap flag.
+   */
+  inline void setEndcapFlag( bool ec = true )

   {
     m_endcap = ec;
   }

-  bool getEndcapFlag()

+  /**
+   * Return the endcap flag.
+   */
+  inline bool getEndcapFlag()

   {
     return m_endcap;
   }

+  /**
+   * Print basic information about this detector to the output stream.
+   */
+  virtual std::ostream& printBasicInfo(std::ostream& os) const;
+
+  /**
+   * Print the number of hits to the output stream.
+   */
+  virtual std::ostream& printNumberOfHits(std::ostream& os) const;
+
+  /**
+   * Print the number of hits to the output stream.
+   */
+  virtual std::ostream& printEdep(std::ostream& os) const;
+
+  /**
+   * Print the names of volumes associated to this detector.
+   */
+  virtual std::ostream& printVolumes(std::ostream& os) const;
+
+  /**
+   * Print the list of hits.  Subclasses must implement this.
+   */
+  virtual std::ostream& printHits(std::ostream& os) const { return os; }
+
+  /**
+   * Retrieve the hits collection associated with this detector,
+   * using the hits collection ID (HCID).
+   */
+  G4VHitsCollection* getHitsCollection() const;
+
+  /**
+   * Return the number of hits.  The m_nhits variable should
+   * be set by a subclass for this value to have any meaning.
+   */
+  inline int getNumberOfHits() const { return m_nhits;}
+
+  /**
+   * Return the total energy deposition from the hits of this detector.
+   * Requires access to concrete hit types, so this function must be
+   * implemented by subclasses.
+   */
+  virtual double getEdep() const { return 0.0;}
+
+  /**
+   * Return a list of G4LogicalVolume objects that have been assigned
+   * this sensitive detector.
+   */
+  std::vector<G4LogicalVolume*> getLogicalVolumes() const;
+

 protected:

-  void setHCID(G4int hcid);

+  /**
+   * Set the hits collection ID corresponding to this detector.
+   */
+  inline void setHCID(G4int hcid)
+  {
+    m_HCID = hcid;
+  }

 
 protected:

@@ -125,6 +254,13 @@

 
   // type = calorimeter or tracker
   EType m_type;

+
+  // The Geant4 command messenger associated with this detector.
+  G4UImessenger* m_messenger;
+
+protected:
+  // Hit counter.
+  int m_nhits;

 };
 
 #endif

+} + +std::ostream& G4CalorimeterSD::printBasicInfo(std::ostream& os) const +{ + G4SensitiveDetector::printBasicInfo( os ); + + os << "segmentation type: " << m_segmentation->getTypeString() << std::endl; + + os << "segmentation bins:"; + + for ( std::vector<std::string>::const_iterator it = m_segmentation->getBinNames().begin(); + it != m_segmentation->getBinNames().end(); + it++ ) { + os << " " << *it; + } + + os << std::endl; + + return os; +}

+double G4CalorimeterSD::getEdep() const +{ + double edep=0.0; + for ( G4CalorimeterHitList::const_iterator it = m_hits.begin(); + it != m_hits.end(); + it++ ) { + edep += (*it)->getEdep(); + } + return edep; +} + +void G4CalorimeterSD::clearHits() { +// for ( G4CalorimeterHitList::iterator it = m_hits.begin(); +// it != m_hits.end(); +// it++ ) { +// delete *it; +// } + m_hits.clear(); + m_nhits=0;

+ os << "name: " << this->GetName() << std::endl; + os << "type: " << m_type << std::endl; + os << "hits collection: " << this->getHCName() << std::endl; + os << "hits collection ID: " << m_HCID << std::endl; + os << "energy cut: " << G4BestUnit( m_ecut, "Energy" ) << std::endl; + os << "endcap flag: " << m_endcap << std::endl; + os << "verbose level: " << m_verbose << std::endl; + + if ( m_idspec != 0 ) { + os << "id spec: " << m_idspec->getName() << std::endl; + os << "id fields:"; + for ( IdSpec::IdFields::const_iterator it = m_idspec->IdFieldsBegin(); + it != m_idspec->IdFieldsEnd(); + it++ ) { + os << " " << (*it)->getLabel(); + } + os << std::endl; + } + else { + os << "no id spec" << std::endl; + } + + return os;

+ +G4VHitsCollection* G4SensitiveDetector::getHitsCollection() const +{ + G4VHitsCollection* hc = 0; + if ( this->getHCID() != -1 ) { + hc = G4EventManager::GetEventManager()->GetConstCurrentEvent()->GetHCofThisEvent()->GetHC( this->getHCID() ); + } + return hc; +} + +std::ostream& G4SensitiveDetector::printNumberOfHits(std::ostream& os) const +{ + os << "number of hits: " << this->getNumberOfHits() << std::endl; + return os; +} + +std::ostream& G4SensitiveDetector::printEdep(std::ostream& os) const +{ + os << "total edep: " << G4BestUnit( this->getEdep(), "Energy" ) << std::endl; + return os; +} + +std::vector<G4LogicalVolume*> G4SensitiveDetector::getLogicalVolumes() const +{ + std::vector<G4LogicalVolume*> volumes; + for ( G4LogicalVolumeStore::const_iterator it = G4LogicalVolumeStore::GetInstance()->begin(); + it != G4LogicalVolumeStore::GetInstance()->end(); + it++ ) { + if ( (*it)->GetSensitiveDetector() == this ) { + volumes.push_back( *it ); + } + } + return volumes; +} + +std::ostream& G4SensitiveDetector::printVolumes(std::ostream& os) const +{ + std::vector<G4LogicalVolume*> volumes = this->getLogicalVolumes(); + + for ( std::vector<G4LogicalVolume*>::const_iterator it = volumes.begin(); + it != volumes.end(); + it++ ) { + std::cout << (*it)->GetName() << std::endl; + } + return os; +}

+ +double G4TrackerSD::getEdep() const +{ + double edep=0.0; + for ( G4TrackerHitList::const_iterator it = m_hits.begin(); + it != m_hits.end(); + it++ ) { + edep += (*it)->getEdep(); + } + return edep; +} + +void G4TrackerSD::clearHits() +{ + //for ( G4TrackerHitList::iterator it = m_hits.begin(); + // it != m_hits.end(); + // it++ ) { + // delete *it; + // } + m_hits.clear(); + m_nhits=0; +}

Commit in `lcdd` on MAIN
`include/G4CalorimeterSD.hh`	+11	-8	1.8 -> 1.9
`/G4SensitiveDetector.hh`	+159	-23	1.12 -> 1.13
`/G4TrackerSD.hh`	+6	-1	1.13 -> 1.14
`src/G4CalorimeterSD.cc`	+58	-11	1.27 -> 1.28
`/G4SensitiveDetector.cc`	+91	-23	1.10 -> 1.11
`/G4TrackerSD.cc`	+38	-5	1.28 -> 1.29
	+363	-71