MyDetectorManager Class Reference

#include <MyDetectorManager.hh>

List of all members.

Public Member Functions

 MyDetectorManager ()
 ~MyDetectorManager ()
void ReadCard (G4String)
void AddGeo (G4String, G4String, G4String)
void ClearGeo ()
G4VPhysicalVolume * SetGeometry ()
void ReadOutputCard (G4String)
void SetBranch ()
G4VSensitiveDetector * GetSD (G4String, G4String, MyVGeometrySvc *)
G4VSensitiveDetector * GetSD (G4String, G4String)
MyVGeometrySvc * GetSvc (G4String name)
SimpleGeometryParameter * GetParaFromVolume (G4String name)
void RegistorDM (G4String)
void Digitize ()
void SetVerbose (int val)

Static Public Member Functions

static MyDetectorManager * GetMyDetectorManager ()

Private Member Functions

void DEBUG (G4String)

Private Attributes

MyDetectorManagerMessenger * m_MyDetectorManagerMessenger
G4SDManager * fSDman
std::vector< MySD * > fSDList
std::vector< G4String > fSDName
std::vector< G4String > fVolName
std::vector< G4String > fDMName
int fVerboseLevel
std::vector< MyVGeometrySvc * > fMyVGeometrySvc
std::vector< G4String > fSvcName

Static Private Attributes

static MyDetectorManager * fMyDetectorManager = 0

Detailed Description

Definition at line 31 of file MyDetectorManager.hh.

Constructor & Destructor Documentation

MyDetectorManager::MyDetectorManager (  ) 

Definition at line 34 of file MyDetectorManager.cc.

References DEBUG(), fMyDetectorManager, fSDman, and m_MyDetectorManagerMessenger.

00035         :fVerboseLevel(0)
00036 {
00037   if (fMyDetectorManager){
00038     G4Exception("MyDetectorManager::MyDetectorManager()","Run0031",
00039         FatalException, "MyDetectorManager constructed twice.");
00040   }
00041   fMyDetectorManager = this;
00042         fSDman = G4SDManager::GetSDMpointer();
00043         if (!fSDman) DEBUG("Can not find G4SDManager.");
00044   m_MyDetectorManagerMessenger = new MyDetectorManagerMessenger(this);
00045 }

MyDetectorManager::~MyDetectorManager (  ) 

Definition at line 47 of file MyDetectorManager.cc.

References m_MyDetectorManagerMessenger.

00048 {
00049         delete m_MyDetectorManagerMessenger;
00050 }

Member Function Documentation

void MyDetectorManager::AddGeo ( G4String  name,
G4String  file,
G4String  type 
)

Definition at line 135 of file MyDetectorManager.cc.

References fMyVGeometrySvc, fSvcName, fVerboseLevel, MyVGeometrySvc::ReadCard(), and MyVGeometrySvc::set_VerboseLevel().

Referenced by SetGeometry(), and MyDetectorManagerMessenger::SetNewValue().

00135                                                                          {
00136         MyVGeometrySvc* aGSvc = 0;
00137         if( type == "Simple" ){
00138                 aGSvc = new SimpleGeometrySvc( name );
00139         }
00140         else{
00141                 std::cout<<"In MyDetectorManager::ReadCard, unsupported GeometrySvc type: "<<type<<"! Will ignore this line!"<<std::endl;
00142         }
00143         if (aGSvc){
00144                 aGSvc->set_VerboseLevel(fVerboseLevel);
00145                 //push and call ReadCard
00146                 fMyVGeometrySvc.push_back(aGSvc);
00147                 fSvcName.push_back(name);
00148                 aGSvc->ReadCard(file);
00149         }
00150 }

void MyDetectorManager::ClearGeo (  ) 

Definition at line 151 of file MyDetectorManager.cc.

References fMyVGeometrySvc, and fSvcName.

Referenced by DetectorConstruction::ReloadGeo(), and MyDetectorManagerMessenger::SetNewValue().

00151                                 {
00152         fSvcName.clear();
00153         fMyVGeometrySvc.clear();
00154         printf("MyDetectorManager::ClearGeo()\n");
00155 }

void MyDetectorManager::DEBUG ( G4String  content  )  [private]

Definition at line 357 of file MyDetectorManager.cc.

Referenced by GetSD(), and MyDetectorManager().

00357                                              {
00358         G4Exception("MyDetectorManager","Run0031",
00359                         FatalException, content);
00360 }

void MyDetectorManager::Digitize (  ) 

Definition at line 348 of file MyDetectorManager.cc.

References fDMName.

Referenced by MyAnalysisSvc::EndOfEventAction().

00348                                 {
00349         for ( int i = 0; i < fDMName.size(); i++ ){
00350                 G4String DMName = fDMName[i];
00351                 G4DigiManager::GetDMpointer()->Digitize(DMName);
00352         }
00353 }

MyDetectorManager * MyDetectorManager::GetMyDetectorManager (  )  [static]

Definition at line 52 of file MyDetectorManager.cc.

References fMyDetectorManager.

Referenced by SimpleGeometrySvc::ConstructVolumes(), DetectorConstruction::DetectorConstruction(), MyAnalysisSvc::MyAnalysisSvc(), SimpleGeometrySvc::PlaceVolumes(), MyTriggerSvc::SetMyTrigger(), and PrimaryGeneratorAction::SetUniformPosition().

00052                                                           {
00053   if ( !fMyDetectorManager ){
00054     fMyDetectorManager = new MyDetectorManager;
00055   }
00056   return fMyDetectorManager;
00057 }

SimpleGeometryParameter* MyDetectorManager::GetParaFromVolume ( G4String  name  )  [inline]

Definition at line 99 of file MyDetectorManager.hh.

References fMyVGeometrySvc, and SimpleGeometryParameter::get_VolIndex().

Referenced by SimpleGeometrySvc::PlaceVolumes(), and PrimaryGeneratorAction::SetUniformPosition().

00099                                                                            {
00100                         SimpleGeometryParameter* pointer = 0;
00101                         for ( int i = 0; i < fMyVGeometrySvc.size(); i++ ){
00102                                 SimpleGeometryParameter* ipointer = (SimpleGeometryParameter*) fMyVGeometrySvc[i]->get_GeometryParameter();
00103                                 if ( ipointer->get_VolIndex(name) >= 0 ){
00104                                         pointer = ipointer;
00105                                         break;
00106                                 }
00107                         }
00108                         return pointer;
00109                 }

G4VSensitiveDetector * MyDetectorManager::GetSD ( G4String  VolName,
G4String  SDName 
)

Definition at line 292 of file MyDetectorManager.cc.

References DEBUG(), fSDList, fSDName, and fVolName.

00292                                                                                {
00293 
00294         //check SDName
00295         G4String newVolName;
00296         G4String newSDName;
00297         size_t sLast = SDName.last('/');
00298         if(sLast==std::string::npos){ // Sensitive Detector name only
00299                 newVolName = VolName;
00300                 newSDName = SDName;
00301         }
00302         else{
00303                 newVolName = SDName.substr(0,sLast);
00304                 newSDName = SDName.substr(sLast+1,SDName.length()-sLast-1);
00305         }
00306 
00307         //Search for (VolName, SDName).
00308         MySD* aMySD = 0;
00309         //std::cout<<"Searching for ["<<newVolName<<","<<newSDName<<"]"<<std::endl;
00310         for ( int i = 0; i < fSDList.size(); i++ ){
00311                 //std::cout<<"["<<fVolName[i]<<","<<fSDName[i]<<"]"<<std::endl;
00312                 if ( fSDName[i] == newSDName ){
00313                         //std::cout<<"VolName Matched!"<<std::endl;
00314                         if ( fVolName[i] == newVolName ){
00315                                 //std::cout<<"SDName Matched!"<<std::endl;
00316                                 aMySD = fSDList[i];
00317                                 if ( !aMySD ) DEBUG("An element of fSDList is zero!"); //G4Exception would be called
00318                                 break;
00319                         }
00320                 }
00321         }
00322 
00323         //if not found ...
00324         G4VSensitiveDetector* aG4SD = 0;
00325         if ( !aMySD ){
00326         }
00327         else {
00328                 aG4SD = dynamic_cast<G4VSensitiveDetector*> (aMySD);
00329                 if ( aG4SD == NULL ){
00330                         G4String content = "Cannot convert "+newSDName+" from G4VSensitiveDetector* to MySD* at construction";
00331                         DEBUG(content);
00332                 }
00333         }
00334 
00335         return aG4SD;
00336 }

G4VSensitiveDetector * MyDetectorManager::GetSD ( G4String  VolName,
G4String  SDName,
MyVGeometrySvc *  pointer 
)

Definition at line 206 of file MyDetectorManager.cc.

References DEBUG(), fMyVGeometrySvc, fSDList, fSDman, fSDName, fVerboseLevel, fVolName, MyVGeometrySvc::get_GeometryParameter(), MYDETM_LINEINFO, MySD::set_GeometryParameter(), and MySD::SetVerbose().

Referenced by SimpleGeometrySvc::ConstructVolumes(), and MyTriggerSvc::SetMyTrigger().

00206                                                                                                         {
00207         MYDETM_LINEINFO()
00208         MyVGeometryParameter* pPara = pointer->get_GeometryParameter();
00209 
00210         //Safety check
00211         int index = -1;
00212         for ( int i = 0; i < fMyVGeometrySvc.size(); i++ ){
00213                 if ( (void*) pointer == (void*) fMyVGeometrySvc[i]) index = i;
00214         }
00215         if (index == -1){
00216                 std::cout<<"WRONG!!! unrecorded MyVGeometrySvc pointer!!!"<<std::endl;
00217     G4Exception("MyDetectorManager::GetSD()","Run0031",
00218         FatalException, "unrecorded MyVGeometrySvc pointer.");
00219         }
00220 
00221         //check SDName
00222         G4String newVolName;
00223         G4String newSDName;
00224         size_t sLast = SDName.last('/');
00225         if(sLast==std::string::npos){ // Sensitive Detector name only
00226                 newVolName = VolName;
00227                 newSDName = SDName;
00228         }
00229         else{
00230                 newVolName = SDName.substr(0,sLast);
00231                 newSDName = SDName.substr(sLast+1,SDName.length()-sLast-1);
00232         }
00233 
00234         //Search for (VolName, SDName).
00235         MYDETM_LINEINFO()
00236         MySD* aMySD = 0;
00237         for ( int i = 0; i < fSDList.size(); i++ ){
00238                 if ( fSDName[i] == newSDName ){
00239                         if ( fVolName[i] == newVolName ){
00240                                 aMySD = fSDList[i];
00241                                 if ( !aMySD ) DEBUG("An element of fSDList is zero!"); //G4Exception would be called
00242                                 //Found it. Modify
00243                                 aMySD->set_GeometryParameter(pPara);
00244                                 break;
00245                         }
00246                 }
00247         }
00248         MYDETM_LINEINFO()
00249 
00250         //if not found, then create a new one w.r.t SDName
00251         G4VSensitiveDetector* aG4SD = 0;
00252         if ( !aMySD ){
00253                 G4String FullSDName = newVolName + "/" + newSDName;
00254                 if ( newSDName == "KillerSD" ){
00255                         aG4SD = new KillerSD( FullSDName, pPara );
00256                         fSDman->AddNewDetector( aG4SD );
00257                 }
00258                 else if ( newSDName == "MonitorSD" ){
00259                         aG4SD = new MonitorSD( FullSDName, pPara );
00260                         fSDman->AddNewDetector( aG4SD );
00261                 }
00262                 else if ( newSDName != "none" ) {//"none" means the user does not want to use a SD. aSD set to 0 and will not be pushed to vecto
00263                         DEBUG("Sensitive detector type " + newSDName + " is not supported yet!!!");
00264                 }
00265 
00266                 if ( aG4SD ){
00267                         MySD* aSD = dynamic_cast<MySD*> (aG4SD);
00268                         aSD->SetVerbose(fVerboseLevel);
00269                         if ( aSD == NULL ){
00270                                 G4String content = "Cannot convert "+newSDName+" from G4VSensitiveDetector* to MySD* at construction";
00271                                 DEBUG(content);
00272                         }
00273                         fSDList.push_back(aSD);
00274                         fVolName.push_back(newVolName);
00275                         fSDName.push_back(newSDName);
00276                 }
00277         }
00278         MYDETM_LINEINFO()
00279         else {
00280                 aMySD->SetVerbose(fVerboseLevel);
00281                 aG4SD = dynamic_cast<G4VSensitiveDetector*> (aMySD);
00282                 if ( aG4SD == NULL ){
00283                         G4String content = "Cannot convert "+newSDName+" from G4VSensitiveDetector* to MySD* at construction";
00284                         DEBUG(content);
00285                 }
00286         }
00287         MYDETM_LINEINFO()
00288 
00289         return aG4SD;
00290 }

MyVGeometrySvc* MyDetectorManager::GetSvc ( G4String  name  )  [inline]

Definition at line 87 of file MyDetectorManager.hh.

References fMyVGeometrySvc, and fSvcName.

Referenced by PrimaryGeneratorAction::SetUniformPosition().

00087                                                        {
00088                         MyVGeometrySvc* pointer = 0;
00089                         for ( int i = 0; i < fSvcName.size(); i++ ){
00090                                 if ( fSvcName[i] == name ){
00091                                         pointer = fMyVGeometrySvc[i];
00092                                         break;
00093                                 }
00094                         }
00095                         return pointer;
00096                 }

void MyDetectorManager::ReadCard ( G4String  file_name  ) 

Definition at line 67 of file MyDetectorManager.cc.

References fMyVGeometrySvc, fSvcName, fVerboseLevel, MyVGeometrySvc::ReadCard(), and MyVGeometrySvc::set_VerboseLevel().

Referenced by DetectorConstruction::Construct(), DetectorConstruction::ReloadGeo(), and MyDetectorManagerMessenger::SetNewValue().

00067                                                   {
00068         //delete and clear
00069         for ( int i = 0; i < fMyVGeometrySvc.size(); i++ ){
00070                 if (fMyVGeometrySvc[i]) delete (fMyVGeometrySvc[i]);
00071         }
00072         fMyVGeometrySvc.clear();
00073         fSvcName.clear();
00074 
00075         //get the file
00076         if(file_name[0] != '/'){ // Relative Dir
00077                 G4String dir_name = getenv("CONFIGUREROOT");
00078                 if (dir_name[dir_name.size()-1] != '/') dir_name.append("/");
00079                 file_name = dir_name + file_name;
00080         }
00081         //std::cout<<"MyDetectorManager: Reading \""<<file_name<<"\""<<std::endl;
00082   std::ifstream fin_card(file_name);
00083   if ( !fin_card ){
00084     std::cout<<"Geometry file: "<<file_name<<" is not available!!!"<<std::endl;
00085     G4Exception("MyDetectorManager::ReadCard()","Run0031",
00086         FatalException, "Geometry file is not available.");
00087   }
00088 
00089         //read line by line
00090   std::stringstream buf_card;
00091   std::string s_card;
00092   while(getline(fin_card,s_card)){
00093     buf_card.str("");
00094     buf_card.clear();
00095     buf_card<<s_card;
00096     const char* c = s_card.c_str();
00097     int length = strlen(c);
00098     int offset = 0;
00099     for ( ; offset < length; offset++ ){
00100       if ( c[offset] != ' ' ) break;
00101     }
00102     if ( c[offset] == '#' ) continue;
00103     else if ( c[offset] == '/' && c[offset+1] == '/' ) continue;
00104     else if ( length - offset == 0 ) continue;
00105 
00106                 G4String name, type, file;
00107                 MyVGeometrySvc* aGSvc = 0;
00108                 buf_card>>name;
00109                 //std::cout<<"MyDetectorManager: "<<buf_card.str()<<std::endl;
00110                 if ( name == "VerboseLevel:" ){
00111                         buf_card>>fVerboseLevel;
00112                 }
00113                 else{
00114                         buf_card>>type>>file;
00115                         if( type == "Simple" ){
00116                                 aGSvc = new SimpleGeometrySvc( name );
00117                         }
00118                         else{
00119                                 std::cout<<"In MyDetectorManager::ReadCard, unsupported GeometrySvc type: "<<type<<"! Will ignore this line!"<<std::endl;
00120                         }
00121                 }
00122                 if (aGSvc){
00123                         aGSvc->set_VerboseLevel(fVerboseLevel);
00124                         //push and call ReadCard
00125                         fMyVGeometrySvc.push_back(aGSvc);
00126                         fSvcName.push_back(name);
00127                         aGSvc->ReadCard(file);
00128                 }
00129         }
00130 }

void MyDetectorManager::ReadOutputCard ( G4String  file_name  ) 

Definition at line 176 of file MyDetectorManager.cc.

References fSDList.

Referenced by MyAnalysisSvc::set_out_card().

00176                                                           {
00177         for ( int i = 0; i < fSDList.size(); i++ ){
00178                 fSDList[i]->ReadOutputCard(file_name);
00179         }
00180 }

void MyDetectorManager::RegistorDM ( G4String  DMName  ) 

Definition at line 341 of file MyDetectorManager.cc.

References fDMName.

00341                                                    {
00342         if ( DMName != "none" ) fDMName.push_back(DMName);
00343 }

void MyDetectorManager::SetBranch ( void   ) 

Definition at line 184 of file MyDetectorManager.cc.

References fSDList.

Referenced by MyAnalysisSvc::BeginOfRunAction().

00184                                  {
00185         for ( int i = 0; i < fSDList.size(); i++ ){
00186                 fSDList[i]->SetBranch();
00187         }
00188 }

G4VPhysicalVolume * MyDetectorManager::SetGeometry (  ) 

Definition at line 161 of file MyDetectorManager.cc.

References AddGeo(), and fMyVGeometrySvc.

Referenced by DetectorConstruction::ConstructDetector().

00161                                                  {
00162         if (fMyVGeometrySvc.size()==0){
00163                 AddGeo("default","world_default","Simple");
00164         }
00165         G4VPhysicalVolume* vol_world = (fMyVGeometrySvc[0])->SetGeometry();
00166         for ( int i = 1; i < fMyVGeometrySvc.size(); i++ ){
00167                 (fMyVGeometrySvc[i])->SetGeometry();
00168         }
00169         return vol_world;
00170 }

void MyDetectorManager::SetVerbose ( int  val  )  [inline]

Definition at line 119 of file MyDetectorManager.hh.

References fVerboseLevel.

00119 {fVerboseLevel = val;};

Member Data Documentation

std::vector<G4String> MyDetectorManager::fDMName [private]

Definition at line 138 of file MyDetectorManager.hh.

Referenced by Digitize(), and RegistorDM().

MyDetectorManager * MyDetectorManager::fMyDetectorManager = 0 [static, private]

Definition at line 127 of file MyDetectorManager.hh.

Referenced by GetMyDetectorManager(), and MyDetectorManager().

std::vector<MyVGeometrySvc*> MyDetectorManager::fMyVGeometrySvc [private]

Definition at line 143 of file MyDetectorManager.hh.

Referenced by AddGeo(), ClearGeo(), GetParaFromVolume(), GetSD(), GetSvc(), ReadCard(), and SetGeometry().

std::vector<MySD*> MyDetectorManager::fSDList [private]

Definition at line 135 of file MyDetectorManager.hh.

Referenced by GetSD(), ReadOutputCard(), and SetBranch().

G4SDManager* MyDetectorManager::fSDman [private]

Definition at line 133 of file MyDetectorManager.hh.

Referenced by GetSD(), and MyDetectorManager().

std::vector<G4String> MyDetectorManager::fSDName [private]

Definition at line 136 of file MyDetectorManager.hh.

Referenced by GetSD().

std::vector<G4String> MyDetectorManager::fSvcName [private]

Definition at line 144 of file MyDetectorManager.hh.

Referenced by AddGeo(), ClearGeo(), GetSvc(), and ReadCard().

int MyDetectorManager::fVerboseLevel [private]

Definition at line 142 of file MyDetectorManager.hh.

Referenced by AddGeo(), GetSD(), ReadCard(), and SetVerbose().

std::vector<G4String> MyDetectorManager::fVolName [private]

Definition at line 137 of file MyDetectorManager.hh.

Referenced by GetSD().

MyDetectorManagerMessenger* MyDetectorManager::m_MyDetectorManagerMessenger [private]

Definition at line 129 of file MyDetectorManager.hh.

Referenced by MyDetectorManager(), and ~MyDetectorManager().

The documentation for this class was generated from the following files:
Generated on 15 Jun 2016 for g4sim by  doxygen 1.6.1