#include <G4VUserDetectorConstruction.hh>

Public Member Functions
	G4VUserDetectorConstruction ()

virtual	~G4VUserDetectorConstruction ()

virtual G4VPhysicalVolume *	Construct ()=0

virtual void	ConstructSDandField ()

virtual void	CloneSD ()

virtual void	CloneF ()

void	RegisterParallelWorld (G4VUserParallelWorld *)

G4int	ConstructParallelGeometries ()

void	ConstructParallelSD ()

G4int	GetNumberOfParallelWorld () const

G4VUserParallelWorld *	GetParallelWorld (G4int i) const

Protected Member Functions
void	SetSensitiveDetector (const G4String &logVolName, G4VSensitiveDetector *aSD, G4bool multi=false)

void	SetSensitiveDetector (G4LogicalVolume logVol, G4VSensitiveDetector aSD)

Detailed Description

Definition at line 50 of file G4VUserDetectorConstruction.hh.

Constructor & Destructor Documentation

G4VUserDetectorConstruction::G4VUserDetectorConstruction ( )

Definition at line 42 of file G4VUserDetectorConstruction.cc.

43 {;}

G4VUserDetectorConstruction::~G4VUserDetectorConstruction ( )

virtual

Definition at line 45 of file G4VUserDetectorConstruction.cc.

46 {;}

Member Function Documentation

void G4VUserDetectorConstruction::CloneF ( )

virtual

Definition at line 109 of file G4VUserDetectorConstruction.cc.

 {
     typedef std::map<G4FieldManager*,G4FieldManager*> FMtoFMmap;
     typedef std::pair<G4FieldManager*,G4FieldManager*> FMpair;
     FMtoFMmap masterToWorker;
     G4LogicalVolumeStore* const logVolStore = G4LogicalVolumeStore::GetInstance();
     assert( logVolStore != NULL );
     for ( G4LogicalVolumeStore::const_iterator it = logVolStore->begin() ; it != logVolStore->end() ; ++it )
     {
         G4LogicalVolume *g4LogicalVolume = *it;
         //Use shadow of master to get instance of FM
         G4FieldManager* masterFM = 0;//g4LogicalVolume->fFieldManager;
         G4FieldManager* clonedFM = 0;
         if ( masterFM )
         {
             FMtoFMmap::iterator fmFound = masterToWorker.find(masterFM);
             if ( fmFound == masterToWorker.end() )
             {
                 //First time we see this SD, let's clone and remember...
                 try {
                     std::pair<FMtoFMmap::iterator,bool> insertedEl = masterToWorker.insert( FMpair(masterFM, masterFM->Clone()) );
                     clonedFM = (insertedEl.first)->second;
                 }
                 catch (...)
                 {
                     G4ExceptionDescription msg;
                     msg << "Cloning of G4FieldManager failed."
                     << " But derived class does not implement cloning. Cannot continue.";
                     G4Exception("G4VUserDetectorConstruction::CloneSD", "Run0053", FatalException,msg);
 
                 }
             }
             else
             {
                 // We have already seen this SD attached to a fifferent LogicalVolume, let's re-use previous clone
                 clonedFM = (*fmFound).second;
             }
         }// masterFM != 0
         //Note that we do not push FM to doughters (false argument), however, since we area looping on all
         //logical volumes and we implemented the "trick" of the map master<->cloned the final
         //effect is the same as using here the correct boolean flag: log-volumes that originally were sharing
         //the same FM they will have cloned ones
         g4LogicalVolume->SetFieldManager(clonedFM, false);
     }
 }

Here is the call graph for this function:

void G4VUserDetectorConstruction::CloneSD ( )

virtual

Definition at line 155 of file G4VUserDetectorConstruction.cc.

 {
     //Loop on ALL logial volumes to search for attached SD
     G4LogicalVolumeStore* const logVolStore = G4LogicalVolumeStore::GetInstance();
     assert( logVolStore != NULL );
     
     typedef std::map<G4VSensitiveDetector*,G4VSensitiveDetector*> SDtoSDmap;
     typedef std::pair<G4VSensitiveDetector*,G4VSensitiveDetector*> SDpair;
     SDtoSDmap masterToWorker;
 
     for ( G4LogicalVolumeStore::const_iterator it = logVolStore->begin() ; it != logVolStore->end() ; ++it )
     {
         G4LogicalVolume *g4LogicalVolume = *it;
         //Use shadow of master to get the instance of SD
         G4VSensitiveDetector* masterSD = 0;//g4LogicalVolume->fSensitiveDetector;
         G4VSensitiveDetector* clonedSD = 0;
         if ( masterSD )
         {
             SDtoSDmap::iterator sdFound = masterToWorker.find(masterSD);
             if ( sdFound == masterToWorker.end() )
             {
                 //First time we see this SD, let's clone and remember...
                 try {
                     std::pair<SDtoSDmap::iterator,bool> insertedEl = masterToWorker.insert( SDpair(masterSD,masterSD->Clone()) );
                     clonedSD = (insertedEl.first)->second;
                     }
                     catch (...)
                     {
                         G4ExceptionDescription msg;
                         msg << "Cloning of G4VSensitiveDetector requested for:" << masterSD->GetName() << "\n"
 #ifndef WIN32
                             << " (full path name: " << masterSD->GetFullPathName() << ").\n"
 #endif
                             << " But derived class does not implement cloning. Cannot continue.";
                         G4Exception("G4VUserDetectorConstruction::CloneSD", "Run0053", FatalException,msg);
                     }
 
             }
             else
             {
                 // We have already seen this SD attached to a fifferent LogicalVolume, let's re-use previous clone
                 clonedSD = (*sdFound).second;
                 
             }
         }// masterSD!=0
         g4LogicalVolume->SetSensitiveDetector(clonedSD);
 
     }
 }

Here is the call graph for this function:

virtual G4VPhysicalVolume* G4VUserDetectorConstruction::Construct ( )

pure virtual

Here is the caller graph for this function:

G4int G4VUserDetectorConstruction::ConstructParallelGeometries ( )

Definition at line 65 of file G4VUserDetectorConstruction.cc.

 {
   G4int nP = 0;
   std::vector<G4VUserParallelWorld*>::iterator pwItr;
   for(pwItr=parallelWorld.begin();pwItr!=parallelWorld.end();pwItr++)
   {
     (*pwItr)->Construct();
     nP++;
   }
   return nP;
 }

Here is the caller graph for this function:

void G4VUserDetectorConstruction::ConstructParallelSD ( )

Definition at line 77 of file G4VUserDetectorConstruction.cc.

 {
   std::vector<G4VUserParallelWorld*>::iterator pwItr;
   for(pwItr=parallelWorld.begin();pwItr!=parallelWorld.end();pwItr++)
   { (*pwItr)->ConstructSD(); }
 }

Here is the caller graph for this function:

void G4VUserDetectorConstruction::ConstructSDandField ( )

virtual

Definition at line 95 of file G4VUserDetectorConstruction.cc.

 {
 //   G4RunManager::RMType rmtype = G4RunManager::GetRunManager()->GetRunManagerType();
 //   if(rmtype != G4RunManager::sequentialRM)
 //   {
 //    G4cout 
 //    << "User-derived detector construction class does not implement \n"
 //    << "ConstructSDandFiled method: i.e. workers will not have SD and fields!\n"
 //    << "The user can safely ignore this message if (s)he has no sensitive\n"
 //    << "detector or field in her/his application." << G4endl;
 //   }
 }

Here is the caller graph for this function:

G4int G4VUserDetectorConstruction::GetNumberOfParallelWorld ( ) const

Definition at line 84 of file G4VUserDetectorConstruction.cc.

85 { return parallelWorld.size(); }

Here is the caller graph for this function:

G4VUserParallelWorld * G4VUserDetectorConstruction::GetParallelWorld ( G4int i ) const

Definition at line 87 of file G4VUserDetectorConstruction.cc.

 {
   if(i<0||i>=GetNumberOfParallelWorld()) return 0;
   return parallelWorld[i];
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VUserDetectorConstruction::RegisterParallelWorld ( G4VUserParallelWorld * aPW )

Definition at line 48 of file G4VUserDetectorConstruction.cc.

 {
   std::vector<G4VUserParallelWorld*>::iterator pwItr;
   for(pwItr=parallelWorld.begin();pwItr!=parallelWorld.end();pwItr++)
   {
     if((*pwItr)->GetName()==aPW->GetName())
     {
       G4String eM = "A parallel world <";
       eM += aPW->GetName();
       eM += "> is already registered to the user detector construction.";
       G4Exception("G4VUserDetectorConstruction::RegisterParallelWorld",
                   "Run0051",FatalErrorInArgument,eM);
     }
   }
   parallelWorld.push_back(aPW);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VUserDetectorConstruction::SetSensitiveDetector	(	const G4String &	logVolName,
		G4VSensitiveDetector *	aSD,
		G4bool	multi = `false`
	)

protected

Definition at line 206 of file G4VUserDetectorConstruction.cc.

 { 
   G4bool found = false;
   G4LogicalVolumeStore* store = G4LogicalVolumeStore::GetInstance();
   for(G4LogicalVolumeStore::iterator pos=store->begin(); pos!=store->end(); pos++)
   {
     if((*pos)->GetName()==logVolName)
     {
       if(found && !multi)
       {
         G4String eM = "More than one logical volumes of the name <";
         eM += (*pos)->GetName();
         eM += "> are found and thus the sensitive detector <";
         eM += aSD->GetName();
         eM += "> cannot be uniquely assigned.";
         G4Exception("G4VUserDetectorConstruction::SetSensitiveDetector",
                     "Run0052",FatalErrorInArgument,eM);
       }
       found = true;
       SetSensitiveDetector(*pos,aSD);
     }
   } 
   if(!found)
   {
     G4String eM2 = "No logical volume of the name <";
     eM2 += logVolName;
     eM2 += "> is found. The specified sensitive detector <";
     eM2 += aSD->GetName();
     eM2 += "> couldn't be assigned to any volume.";
     G4Exception("G4VUserDetectorConstruction::SetSensitiveDetector",
                     "Run0053",FatalErrorInArgument,eM2);
   }
 } 

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VUserDetectorConstruction::SetSensitiveDetector	(	G4LogicalVolume *	logVol,
		G4VSensitiveDetector *	aSD
	)

protected

Definition at line 241 of file G4VUserDetectorConstruction.cc.

 { 
   assert(logVol!=nullptr&&aSD!=nullptr);
 
   //The aSD has already been added by user to the manager if needed
   //G4SDManager::GetSDMpointer()->AddNewDetector(aSD);
 
   //New Logic: allow for "multiple" SDs being attached to a single LV.
   //To do that we use a special proxy SD called G4MultiSensitiveDetector
 
   //Get existing SD if already set and check if it is of the special type
   G4VSensitiveDetector* originalSD = logVol->GetSensitiveDetector();
   if ( originalSD == nullptr ) {
       logVol->SetSensitiveDetector(aSD);
   } else {
       G4MultiSensitiveDetector* msd = dynamic_cast<G4MultiSensitiveDetector*>(originalSD);
       if ( msd != nullptr ) {
           msd->AddSD(aSD);
       } else {
           std::ostringstream mn;
           mn<<"/MultiSD_"<<logVol->GetName()<<"_"<<logVol;
           const G4String msdname = mn.str();
           msd = new G4MultiSensitiveDetector(msdname);
           //We need to register the proxy to have correct handling of IDs
           G4SDManager::GetSDMpointer()->AddNewDetector(msd);
       msd->AddSD(originalSD);
           msd->AddSD(aSD);
           logVol->SetSensitiveDetector(msd);
       }
   }
 }

Here is the call graph for this function:

The documentation for this class was generated from the following files:

source/geant4.10.03.p02/source/run/include/G4VUserDetectorConstruction.hh
source/geant4.10.03.p02/source/run/src/G4VUserDetectorConstruction.cc

Public Member Functions

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation