LISTSERV 16.5 - LCD-CVS Archives

+#ifndef G4ScorerSD_hh +#define G4ScorerSD_hh 1 + +#include "G4TrackerSD.hh" + +class G4ScorerSD : public G4TrackerSD +{ +public: + G4ScorerSD(G4String sdName, + G4String hcName + //, + // bool killTracks + ); + +protected: + virtual G4bool ProcessHits(G4Step*, G4TouchableHistory*); + +protected: + bool m_killTracks; + int m_currentTrackID; +}; + +#endif

+#ifndef ScorerType_hh +#define ScorerType_hh 1 + +#include "SensitiveDetectorType.hh" + +/** + * @class ScorerType + * @brief ScorerType from schema. + */ +class ScorerType : public SensitiveDetectorType +{ + +public: + ScorerType() + {} + + virtual ~ScorerType() + {} + + /* + void set_kill_tracks(const std::string& k) + { + m_kill_tracks = k; + } + + const std::string& get_kill_tracks() + { + return m_kill_tracks; + } + + private: + std::string m_kill_tracks; + */ + +}; + +#endif

+#ifndef scorer_hh +#define scorer_hh + +#include "ScorerType.hh" + +#include "Saxana/SAXObject.h" +#include "SensitiveDetectorType.hh" + +/** + * @class scorer + * @brief scorer element from schema. + */ +class scorer : public SAXObject, public ScorerType +{ +public: + scorer() + {} + + virtual ~scorer() + {} + + virtual SAXObject::Type type() + { + return SAXObject::element; + } +}; + +#endif

- if ( name == "calorimeter" || name == "tracker" ) { - sdt->set_type( name ); - } - else { - std::cerr << "Invalid tag for SD type - " << name << std::endl; - G4Exception( "Unknown SD tag." ); - }

<xs:attribute name="name" type="xs:ID" use="required" /> <xs:attribute name="hits_collection" type="xs:string" use="required" /> <xs:attribute name="endcap_flag" type="xs:boolean" default="false" />

+#include "G4ScorerSD.hh" + +#include "TrackInformation.hh" + +G4ScorerSD::G4ScorerSD(G4String sdName, + G4String hcName + //, + // bool killTracks + ) + : G4TrackerSD(sdName, hcName), + m_currentTrackID(-1) +{ + // m_killTracks = killTracks; +} + +G4bool G4ScorerSD::ProcessHits(G4Step* aStep, G4TouchableHistory*) +{ +#ifdef G4VERBOSE + if ( m_verbose > 1 ) { + std::cout << "G4ScorerSD::ProcessHits() - " << this->GetName() << std::endl; + } +#endif + + G4SensitiveDetector::ProcessHits( aStep, 0 ); + + bool sameTrack = false; + +#ifdef G4VERBOSE + if ( m_verbose > 3 ) { + std::cout << "current trackID <" << m_currentTrackID << ">" << std::endl; + } +#endif + + if ( (m_currentTrackID == -1) || (m_currentTrackID != trackID() ) ) { + +#ifdef G4VERBOSE + if ( m_verbose > 2 ) { + std::cout << "new track <" << trackID() << ">" << std::endl; + } +#endif + + m_currentTrackID = trackID(); + } + else { +#ifdef G4VERBOSE + if ( m_verbose > 2 ) { + std::cout << "old track <" << trackID() << ">" << std::endl; + } +#endif + + sameTrack = true; + } + + if ( !sameTrack ) { + +#ifdef G4VERBOSE + if ( m_verbose > 2 ) { + std::cout << "writing hit" << std::endl; + } +#endif + + // edep + G4double e = edep(); + + // get track information + TrackInformation* trkInfo = trackInformation(); + + // set hit flag in trk info + trkInfo->setHasTrackerHit( true ); + + // hit data + G4int trkID = trackID(); + G4double tdep = globalTime(); + G4ThreeVector prepos = prePosition(); + G4ThreeVector meanmom = meanMomentum(); + + // create hit + G4TrackerHit* trkHit = new G4TrackerHit(); + + // create id vector + Id64bit id64 = makeId(); + + // set track hit info + trkHit->setTrackID(trkID); + trkHit->setEdep(e); + trkHit->setPos(prepos); + trkHit->setMomentum(meanmom); + trkHit->setTdep(tdep); + trkHit->setId( id64.getId0() ); + + // add to HC + m_HC->insert(trkHit); + + // if ( m_killTracks ) { + // + // } + } + else { +#ifdef G4VERBOSE + if ( m_verbose > 0 ) { + std::cout << "Skipping hit from track <" << m_currentTrackID << ">." << std::endl; + } +#endif + } + return true; +}

+#include "Saxana/ProcessingConfigurator.h" +#include "Saxana/ProcessingContext.h" +#include "Saxana/SAXProcessor.h" +#include "Saxana/StateStack.h" +#include "Saxana/SAXProcessingState.h" +#include "Saxana/SAXStateProcess.h" +#include "Saxana/SAXComponentFactory.h" + +#include "scorer.hh" +#include "SensitiveDetectorTypeProcess.hh" + +#include <iostream> + +/** + @class scorerProcess + @brief SAX process for scorer element. +*/ +class scorerProcess : public SensitiveDetectorTypeProcess +{ + +public: + scorerProcess( const ProcessingContext* context = 0) + : SensitiveDetectorTypeProcess(context) + {} + + virtual ~scorerProcess() + {} + + virtual void StartElement( const std::string& name, const ASCIIAttributeList& attrs) + { + //std::cout << "PROCESS::START OF TAG : " << name << std::endl; + + SAXObject** obj = Context()->GetTopObject(); + + + scorer* scr = new scorer; + /* + scr->set_kill_tracks(attrs.getValue("kill_tracks") ); + */ + + m_obj = scr; + *obj = scr; + + SensitiveDetectorTypeProcess::StartElement(name, attrs); + } + + virtual void EndElement(const std::string&) + { + //std::cout << "PROCESS::END OF TAG : " << name << " " << std::endl; + + //SensitiveDetectorTypeProcess::EndElement( name ); + } + + virtual void StackPopNotify(const std::string& name) + { + SensitiveDetectorTypeProcess::StackPopNotify( name ); + } + + virtual const std::string& State() const + { + static std::string tag = "scorer"; + return tag; + } +}; + +DECLARE_PROCESS_FACTORY(scorerProcess)

+#include "Saxana/SAXSubscriber.h" +#include "Saxana/SAXComponentFactory.h" + +#include "LCDDProcessor.hh" +#include "scorer.hh" +#include "G4SensitiveDetector.hh" +#include "G4ScorerSD.hh" +#include "SensitiveDetectorFactory.hh" + +#include <iostream> + +/** + @class scorerSubscriber + @brief SAX subscriber for scorer element. + @note Delegates to SensitiveDetectorFactory to create G4ScorerSD. +*/ +class scorerSubscriber : virtual public SAXSubscriber +{ +public: + virtual const SAXComponentObject* Build() const + { + return this; + } + +public: + scorerSubscriber() + { + Subscribe("scorer"); + } + + virtual ~scorerSubscriber() + {} + + virtual void Activate(const SAXObject* object) + { + SensitiveDetectorFactory::createSensitiveDetector( object ); + } +}; + +DECLARE_SUBSCRIBER_FACTORY(scorerSubscriber)

lcdd/src

SensitiveDetectorFactory.cc 1.10 -> 1.11

diff -u -r1.10 -r1.11
--- SensitiveDetectorFactory.cc	6 May 2005 18:24:43 -0000	1.10
+++ SensitiveDetectorFactory.cc	5 Jul 2005 20:35:54 -0000	1.11
@@ -1,7 +1,11 @@

-// $Header: /cvs/lcd/lcdd/src/SensitiveDetectorFactory.cc,v 1.10 2005/05/06 18:24:43 jeremy Exp $

+// $Header: /cvs/lcd/lcdd/src/SensitiveDetectorFactory.cc,v 1.11 2005/07/05 20:35:54 jeremy Exp $

 #include "SensitiveDetectorFactory.hh"

+/* LCDD */

 #include "G4TrackerCombineSD.hh"

+#include "G4ScorerSD.hh"
+#include "G4TrackerSD.hh"
+#include "G4CalorimeterSD.hh"

 
 #include "StringUtil.hh"

@@ -14,16 +18,22 @@

   if ( sdt ) {
     std::string sd_type = sdt->get_type();

-    // create specific type of SD

+    /* create calorimeter */

     if ( sd_type == "calorimeter" ) {
       sd = createCalorimeterSD( object );
     }

+    /* create tracker */

     else if ( sd_type == "tracker" ) {
       sd = createTrackerSD( object );
     }

+    /* create scorer */
+    else if ( sd_type == "scorer" ) {
+      sd = createScorerSD( object );
+    }
+    /* invalid type */

     else {

-      G4cerr << "sd_type is not known <" << sd_type << ">." << G4endl;
-      G4Exception( "Unknown SD tag." );

+      G4cerr << "Invalid sd_type <" << sd_type << ">." << G4endl;
+      G4Exception( "Unknown SD type.  Check the LCDD file." );

     }
 
     // set ecut and verbose

@@ -32,12 +42,12 @@

     // find idspec
     IdSpec* idspec = findIdSpec( sdt );

-    // set idspec, if exists (null is ok here)

+    // set idspec, if exists (null is ok)

     if ( idspec != 0 ) {
       sd->setIdSpec( idspec );
     }

-    // register

+    // register the SD

     std::string sdName = sd->GetName();
     LCDDProcessor::instance()->addSensitiveDetector(sdName,
 						    sd);

@@ -50,7 +60,7 @@

 }
 
 G4CalorimeterSD* SensitiveDetectorFactory::createCalorimeterSD(const SAXObject* object)

-{

+{

   G4CalorimeterSD* sd = 0;
   G4Segmentation* seg = 0;

@@ -64,10 +74,10 @@

   // child tag loop for segmentation
   bool fnd_seg = false;
   for( size_t i = 0; i < count; i++) {

     std::string child_tag = seq->content(i).tag;

-    const ContentGroup::ContentItem& segitem = seq->content(i);	  
-

+    const ContentGroup::ContentItem& segitem = seq->content(i);
+

     // create segmentation using factory
     if ( isSegmentationTag( child_tag ) ) {

@@ -76,7 +86,7 @@

       seg = G4SegmentationFactory::createSegmentation( segitem.object, segitem.tag );
       fnd_seg = true;
       break;

-    }

+    }

   }
 
   if ( !fnd_seg ) {

@@ -97,7 +107,6 @@

   return sd;
 }

-/** @todo different type if combining hits */

 G4TrackerSD* SensitiveDetectorFactory::createTrackerSD(const SAXObject* object)
 {
   const tracker* trk = dynamic_cast<const tracker*>( object );

@@ -113,12 +122,12 @@

     G4Exception("SensitiveDetectorFactory - There was a problem with the name of the hits collection.");
   }

-  // create tracker that aggregates hits

+  /* tracker that aggregates hits */

   if ( combineHits ) {
     sd = new G4TrackerCombineSD(nm,
 				hc);
   }

-  // create regular tracker

+  /* regular tracker */

   else {
     sd = new G4TrackerSD(nm,
 			 hc);

@@ -127,30 +136,48 @@

   return sd;
 }

+G4ScorerSD* SensitiveDetectorFactory::createScorerSD(const SAXObject* object)
+{
+  const scorer * scr = dynamic_cast<const scorer*>( object );
+
+  G4ScorerSD* sd = 0;
+
+  std::string nm = scr->get_name();
+  std::string hc = scr->get_hitsCollectionName();
+
+  if ( checkHCName(hc) ) {
+    G4Exception("SensitiveDetectorFactory - There was a problem with the name of the hits collection.");
+  }
+
+  sd = new G4ScorerSD(nm,
+		      hc);
+  return sd;
+}
+

 IdSpec* SensitiveDetectorFactory::findIdSpec(const SensitiveDetectorType* sdt)
 {
   IdSpec* idspec = 0;
   ContentSequence* seq = const_cast<ContentSequence*> ( sdt->get_content() );

-  size_t count = seq->size();

+  size_t count = seq->size();

   for( size_t i = 0; i < count; i++) {
 
     std::string child_tag = seq->content(i).tag;
 
     // find idspec

-    if ( child_tag == "idspecref" ) {

+    if ( child_tag == "idspecref" ) {

-      IdSpecType::idspecref* id_ref =

+      IdSpecType::idspecref* id_ref =

 	dynamic_cast<IdSpecType::idspecref*> ( seq->content(i).object );
 
       idspec = IdManager::instance()->getIdSpec( id_ref->get_ref() );

       break;
     }
   }
   return idspec;
 }

-void SensitiveDetectorFactory::setBaseSensitiveDetectorAttributes(G4SensitiveDetector* sd, const SensitiveDetectorType* sdt)

+void SensitiveDetectorFactory::setBaseSensitiveDetectorAttributes(G4SensitiveDetector* sd, const SensitiveDetectorType* sdt)

 {
   sd->setEcut( SensitiveDetectorFactory::computeEcut( sdt ) );
   sd->setVerbose( SensitiveDetectorFactory::convertVerbose( sdt ) );

@@ -174,13 +201,13 @@

   return verbose;
 }

-bool SensitiveDetectorFactory::isSegmentationTag(const std::string& s)

+bool SensitiveDetectorFactory::isSegmentationTag(const std::string& s)

 {
   // new segmentations must appear here!
   // @todo Fix this to know all segmentation types somehow.

-  return ( s == "projective_cylinder" || 
-	   s == "grid_xyz" || 
-	   s == "nonprojective_cylinder" ||

+  return ( s == "projective_cylinder" ||
+	   s == "grid_xyz" ||
+	   s == "nonprojective_cylinder" ||

 	   s == "projective_zplane" );
 }

Commit in `lcdd` on MAIN
`include/G4ScorerSD.hh`	+23		added 1.1
`/ScorerType.hh`	+37		added 1.1
`/scorer.hh`	+28		added 1.1
`/G4TrackerSD.hh`	+2	-2	1.9 -> 1.10
`/SensitiveDetectorFactory.hh`	+8	-4	1.5 -> 1.6
`/SensitiveDetectorTypeProcess.hh`	+5	-11	1.8 -> 1.9
`/TrackerType.hh`		-2	1.3 -> 1.4
`schemas/lcdd/1.0/sensitive_detectors.xsd`	+6	-2	1.4 -> 1.5
`src/G4ScorerSD.cc`	+106		added 1.1
`/scorerProcess.cc`	+66		added 1.1
`/scorerSubscriber.cc`	+40		added 1.1
`/G4TrackerSD.cc`	+15	-15	1.25 -> 1.26
`/LCDDLibLoad.cc`	+6	-4	1.17 -> 1.18
`/SensitiveDetectorFactory.cc`	+50	-23	1.10 -> 1.11
	+392	-63