G4VUserDetectorConstruction Class Reference

#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.

{;}

G4VUserDetectorConstruction::~G4VUserDetectorConstruction ( )

virtual

Definition at line 45 of file G4VUserDetectorConstruction.cc.

{;}

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.

{ 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:

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:

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:

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:

• geant4.10.03.p01/source/run/include/G4VUserDetectorConstruction.hh
• geant4.10.03.p01/source/run/src/G4VUserDetectorConstruction.cc