Changeset 68 for MEMPHYS


Ignore:
Timestamp:
Jan 10, 2006, 4:28:08 PM (18 years ago)
Author:
campagne
Message:

Introduction of the MEMPHYS namespace

Location:
MEMPHYS/HEAD
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSAnalysis.hh

    r10 r68  
    1010}
    1111
    12 #define CAST(aObject,aClass) (aClass*)(aObject)->cast(#aClass)
    13 
     12//JEC 10/1/06 introduction
     13namespace MEMPHYS {
    1414
    1515class MEMPHYSAnalysis  : public virtual MEMPHYSIAnalysis {
    … …  
    2929};
    3030
    31 
     31}
    3232#endif

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSDetectorConstruction.hh

    r10 r68  
    1515#include <hash_map.h>
    1616
    17 enum cyl_location {endcap1,wall,endcap2}; //JEC FIXME Not in Global
    1817
    1918class G4Box;
    … …  
    2423class G4VPhysicalVolume;
    2524
    26 class MEMPHYSAnalysis;
    27 class MEMPHYSDetectorMessenger;
    28 class MEMPHYSWCSD;
     25
    2926
    3027//JEC FIXME does it runs on over plateform?
     28// look in /usr/include/c++/3.2.3/ext/
    3129namespace __gnu_cxx {
    3230  template<> struct hash< std::string >
    … …  
    3836}
    3937
    40 //JEC 18/11/05 introduce AIDA
    4138namespace AIDA {
    4239  class ITuple;
    4340}
     41
     42
     43//JEC 10/1/06 introduce MEMPHYS
     44namespace MEMPHYS {
     45
    4446class MEMPHYSAnalysis;
     47class MEMPHYSDetectorMessenger;
     48class MEMPHYSWCSD;
     49class MEMPHYSAnalysis;
     50
     51enum cyl_location {endcap1,wall,endcap2};
     52
    4553
    4654class MEMPHYSDetectorConstruction : public G4VUserDetectorConstruction {
    … …  
    243251};
    244252
     253}
     254
     255
    245256#endif
    246257

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSDetectorMessenger.hh

    r10 r68  
    22#define MEMPHYSDetectorMessenger_h 1
    33
    4 class MEMPHYSDetectorConstruction;
    5 class G4UIdirectory;
    6 class G4UIcmdWithAString;
    74
    85#include "G4UImessenger.hh"
    … …  
    129#include "G4UIdirectory.hh"
    1310#include "G4UIcmdWithADouble.hh"
     11
     12
     13class G4UIdirectory;
     14class G4UIcmdWithAString;
     15
     16//JEC 10/1/06 introduce MEMPHYS
     17namespace MEMPHYS {
     18
     19class MEMPHYSDetectorConstruction;
     20
    1421
    1522class MEMPHYSDetectorMessenger: public G4UImessenger {
    … …  
    3037};
    3138
     39}
    3240#endif
    3341

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSEventAction.hh

    r10 r68  
    2020  class ITuple;
    2121}
    22 
     22//JEC 10/1/06 introduce MEMPHYS
     23namespace MEMPHYS {
    2324
    2425class MEMPHYSAnalysis;
    … …  
    5657};
    5758
     59}
    5860
    5961#endif

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSIAnalysis.hh

    r10 r68  
    22#define MEMPHYS_IAnalysis_h
    33
     4//JEC 10/1/06 introduce MEMPHYS
     5namespace MEMPHYS {
    46
    57class MEMPHYSIAnalysis  {
    … …  
    1012};
    1113
     14}
    1215
    1316#endif

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSPhysicsList.hh

    r10 r68  
    88//MEMPHYS
    99#include "MEMPHYS/MEMPHYSPhysicsMessenger.hh"
     10
     11//JEC 10/1/06 introduce MEMPHYS
     12namespace MEMPHYS {
     13
    1014
    1115class MEMPHYSPhysicsList: public G4VUserPhysicsList {
    … …  
    5155};
    5256
     57}
    5358#endif
    5459

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSPhysicsMessenger.hh

    r10 r68  
    55#include "G4UImessenger.hh"
    66
    7 class MEMPHYSPhysicsList;
    87class G4UIdirectory;
    98class G4UIcommand;
    109class G4UIcmdWithAString;
     10//JEC 10/1/06 introduce MEMPHYS
     11namespace MEMPHYS {
     12
     13class MEMPHYSPhysicsList;
    1114
    1215class MEMPHYSPhysicsMessenger: public G4UImessenger
    … …  
    2629};
    2730
     31}
    2832#endif

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSPrimaryGeneratorAction.hh

    r10 r68  
    22#define MEMPHYSPrimaryGeneratorAction_h
    33
     4//Geant4
    45#include "G4VUserPrimaryGeneratorAction.hh"
    56#include "G4ThreeVector.hh"
    67#include "globals.hh"
    78
     9//std
    810#include <fstream>
    911
    1012class G4ParticleGun;
    1113class G4Event;
     14
     15//JEC 10/1/06 introduce MEMPHYS
     16namespace MEMPHYS {
    1217
    1318class MEMPHYSDetectorConstruction;
    … …  
    9499  }
    95100  G4bool IsGeneratingVertexInRock() { return GenerateVertexInRock; }
    96   void SetGenerateVertexInRock(G4bool choice) { GenerateVertexInRock = choice; }
     101  void SetGenerateVertexInRock(G4bool choice) { GenerateVertexInRock = choice;}
    97102};
     103
     104
     105}
    98106
    99107#endif

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSPrimaryGeneratorMessenger.hh

    r10 r68  
    22#define MEMPHYSPrimaryGeneratorMessenger_h 1
    33
     4//Geant4
     5#include "G4UImessenger.hh"
     6#include "globals.hh"
     7
    48class G4UIdirectory;
    59class G4UIcmdWithAString;
     10
     11
     12//JEC 10/1/06 introduce MEMPHYS
     13namespace MEMPHYS {
     14
    615class MEMPHYSPrimaryGeneratorAction;
    716
    8 
    9 #include "G4UImessenger.hh"
    10 #include "globals.hh"
    1117
    1218class MEMPHYSPrimaryGeneratorMessenger: public G4UImessenger {
    … …  
    2834 
    2935};
    30 
     36}
    3137#endif
    3238

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSRunAction.hh

    r10 r68  
    88
    99class G4Run;
     10
     11//JEC 10/1/06 introduce MEMPHYS
     12namespace MEMPHYS {
    1013class MEMPHYSRunActionMessenger;
    1114
    … …  
    3437  MEMPHYSRunActionMessenger* messenger;
    3538};
    36 
     39}
    3740#endif

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSRunActionMessenger.hh

    r10 r68  
    22#define MEMPHYSRunActionMessenger_h 1
    33
    4 class MEMPHYSRunAction;
     4//Geant4
     5#include "G4UImessenger.hh"
     6#include "globals.hh"
     7
    58class G4UIdirectory;
    69class G4UIcmdWithAString;
    710
    8 #include "G4UImessenger.hh"
    9 #include "globals.hh"
     11
     12//JEC 10/1/06 introduce MEMPHYS
     13namespace MEMPHYS {
     14class MEMPHYSRunAction;
    1015
    1116class MEMPHYSRunActionMessenger: public G4UImessenger {
    … …  
    2328  G4UIdirectory*      MEMPHYSIODir;
    2429};
    25 
     30}
    2631#endif
    2732

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSStackingAction.hh

    r10 r68  
    22#define MEMPHYSStackingAction_H 1
    33
     4//Geant4
    45#include "globals.hh"
    56#include "G4UserStackingAction.hh"
    … …  
    78class G4Track;
    89
     10//JEC 10/1/06 introduce MEMPHYS
     11namespace MEMPHYS {
    912class MEMPHYSStackingAction : public G4UserStackingAction {
    1013
    … …  
    1821    virtual void PrepareNewEvent();
    1922};
    20 
     23}
    2124#endif
    2225

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSSteppingAction.hh

    r65 r68  
    66#include "G4UserSteppingAction.hh"
    77
    8 //JEC 14/12/05 code adapted from G4 extanded optical LXe ex.
     8//JEC 10/1/06 introduce MEMPHYS
     9namespace MEMPHYS {
    910
    1011class MEMPHYSSteppingAction : public G4UserSteppingAction
    … …  
    2223  // G4bool oneStepPrimaries;
    2324};
    24 
     25}
    2526#endif

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSTrackInformation.hh

    r65 r68  
    1111//for Track Status
    1212
     13
     14//JEC 10/1/06 introduce MEMPHYS
     15namespace MEMPHYS {
     16
    1317enum TrackStatus { active=1, hitPMT=2, absorbed=4, boundaryAbsorbed=8,
    14                       inactive=14};
     18                    inactive=14};
    1519
    1620/*TrackStatus:
    … …  
    6367
    6468};
     69}
    6570
    66 extern G4Allocator<MEMPHYSTrackInformation> aMEMPHYSTrackInfoAllocator;
     71//JEC 10/1/06 introduce MEMPHYS
     72namespace MEMPHYS {
     73  extern G4Allocator<MEMPHYSTrackInformation> aMEMPHYSTrackInfoAllocator;
     74}
    6775
    68 inline void* MEMPHYSTrackInformation::operator new(size_t) {
     76inline void* MEMPHYS::MEMPHYSTrackInformation::operator new(size_t) {
    6977  void* aTrackInfo;
    70   aTrackInfo = (void*)aMEMPHYSTrackInfoAllocator.MallocSingle();
     78  aTrackInfo = (void*)MEMPHYS::aMEMPHYSTrackInfoAllocator.MallocSingle();
    7179  return aTrackInfo;
    7280}
    7381
    74 inline void MEMPHYSTrackInformation::operator delete(void *aTrackInfo){
    75   aMEMPHYSTrackInfoAllocator.FreeSingle((MEMPHYSTrackInformation*)aTrackInfo);
     82inline void MEMPHYS::MEMPHYSTrackInformation::operator delete(void *aTrackInfo){
     83  MEMPHYS::aMEMPHYSTrackInfoAllocator.FreeSingle((MEMPHYS::MEMPHYSTrackInformation*)aTrackInfo);
    7684}
    7785

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSTrackingAction.hh

    r10 r68  
    66#include "globals.hh"
    77
     8//std
    89#include <set>
    910
    1011
    1112class G4Track;
     13
     14//JEC 10/1/06 introduce MEMPHYS
     15namespace MEMPHYS {
    1216
    1317class MEMPHYSTrackingAction : public G4UserTrackingAction {
    … …  
    2731  G4float thresholdTobeSaved;
    2832};
    29 
     33}
    3034
    3135#endif

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSTrajectory.hh

    r10 r68  
    2121
    2222typedef std::vector<G4VTrajectoryPoint*>  TrajectoryPointContainer;
     23
     24//JEC 10/1/06 introduce MEMPHYS
     25namespace MEMPHYS {
     26
    2327
    2428class MEMPHYSTrajectory : public G4VTrajectory {
    … …  
    98102  G4double                  globalTime;
    99103};
     104}
    100105
    101 /***            TEMP  : M FECHNER ***********
    102 ** modification by Chris Walter that works for geant4 >= 4.6.2p01
    103 ** does not compile with 4.6.1
    104 #if defined G4TRACKING_ALLOC_EXPORT
    105   extern G4DLLEXPORT G4Allocator<MEMPHYSTrajectory> myTrajectoryAllocator;
    106 #else
    107   extern G4DLLIMPORT G4Allocator<MEMPHYSTrajectory> myTrajectoryAllocator;
    108 #endif
    109 */
     106//JEC 10/1/06 introduce MEMPHYS
     107namespace MEMPHYS {
     108  extern G4Allocator<MEMPHYSTrajectory> myTrajectoryAllocator;
     109}
    110110
    111 extern G4Allocator<MEMPHYSTrajectory> myTrajectoryAllocator;
    112 
    113 inline void* MEMPHYSTrajectory::operator new(size_t)
     111inline void* MEMPHYS::MEMPHYSTrajectory::operator new(size_t)
    114112{
    115113  void* aTrajectory;
    116   aTrajectory = (void*)myTrajectoryAllocator.MallocSingle();
     114  aTrajectory = (void*)MEMPHYS::myTrajectoryAllocator.MallocSingle();
    117115  return aTrajectory;
    118116}
    119117
    120 inline void MEMPHYSTrajectory::operator delete(void* aTrajectory)
     118inline void MEMPHYS::MEMPHYSTrajectory::operator delete(void* aTrajectory)
    121119{
    122   myTrajectoryAllocator.FreeSingle((MEMPHYSTrajectory*)aTrajectory);
     120  MEMPHYS::myTrajectoryAllocator.FreeSingle((MEMPHYS::MEMPHYSTrajectory*)aTrajectory);
    123121}
    124122

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSWCDigi.hh

    r45 r68  
    1414
    1515
     16//JEC 10/1/06 introduce MEMPHYS
     17namespace MEMPHYS {
    1618
    1719class MEMPHYSWCDigi : public G4VDigi {
    … …  
    6567 
    6668};
    67 
     69}
    6870//-----------------------------------------------------------------------
    6971
    70 typedef G4TDigiCollection<MEMPHYSWCDigi> MEMPHYSWCDigitsCollection;
    71 extern G4Allocator<MEMPHYSWCDigi> MEMPHYSWCDigiAllocator;
     72//JEC 10/1/06 introduce MEMPHYS
     73namespace MEMPHYS {
    7274
    73 inline void* MEMPHYSWCDigi::operator new(size_t) {
     75  typedef G4TDigiCollection<MEMPHYSWCDigi> MEMPHYSWCDigitsCollection;
     76  extern G4Allocator<MEMPHYSWCDigi> MEMPHYSWCDigiAllocator;
     77}
     78
     79inline void* MEMPHYS::MEMPHYSWCDigi::operator new(size_t) {
    7480  void* aDigi;
    75   aDigi = (void*) MEMPHYSWCDigiAllocator.MallocSingle();
     81  aDigi = (void*) MEMPHYS::MEMPHYSWCDigiAllocator.MallocSingle();
    7682  return aDigi;
    7783}
    7884
    79 inline void MEMPHYSWCDigi::operator delete(void* aDigi) {
    80   MEMPHYSWCDigiAllocator.FreeSingle((MEMPHYSWCDigi*) aDigi);
     85inline void MEMPHYS::MEMPHYSWCDigi::operator delete(void* aDigi) {
     86  MEMPHYS::MEMPHYSWCDigiAllocator.FreeSingle((MEMPHYS::MEMPHYSWCDigi*) aDigi);
    8187}
    8288

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSWCDigitizer.hh

    r10 r68  
    1010#include "MEMPHYS/MEMPHYSWCDigi.hh"
    1111
     12//JEC 10/1/06 introduce MEMPHYS
     13namespace MEMPHYS {
    1214
    1315class MEMPHYSWCDigitizer : public G4VDigitizerModule {
    … …  
    6567};
    6668
     69}
    6770#endif
    6871

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSWCHit.hh

    r45 r68  
    1616#include <algorithm> // for sort, find, count_if
    1717#include <functional> //for less_equal, bind2nd,...
     18
     19//JEC 10/1/06 introduce MEMPHYS
     20namespace MEMPHYS {
    1821
    1922class MEMPHYSWCHit : public G4VHit {
    … …  
    6770
    6871 private:
    69 
    70   //JEC 17/11/05 put the Copy Ctor and the Assignation Operator private
    7172  MEMPHYSWCHit(const MEMPHYSWCHit&);
    7273  const MEMPHYSWCHit& operator=(const MEMPHYSWCHit&);
    … …  
    9192  G4int                 totalPeInGate;
    9293};
     94}
    9395
    9496//----------------------------------------------------------------
    9597
    96 typedef G4THitsCollection<MEMPHYSWCHit> MEMPHYSWCHitsCollection;
     98//JEC 10/1/06 introduce MEMPHYS
     99namespace MEMPHYS {
     100  typedef G4THitsCollection<MEMPHYSWCHit> MEMPHYSWCHitsCollection;
     101  extern G4Allocator<MEMPHYSWCHit> MEMPHYSWCHitAllocator;
     102}
    97103
    98 extern G4Allocator<MEMPHYSWCHit> MEMPHYSWCHitAllocator;
    99 
    100 inline void* MEMPHYSWCHit::operator new(size_t) {
     104inline void* MEMPHYS::MEMPHYSWCHit::operator new(size_t) {
    101105  void *aHit;
    102   aHit = (void *) MEMPHYSWCHitAllocator.MallocSingle();
     106  aHit = (void *) MEMPHYS::MEMPHYSWCHitAllocator.MallocSingle();
    103107  return aHit;
    104108}
    105109
    106 inline void MEMPHYSWCHit::operator delete(void *aHit) {
    107   MEMPHYSWCHitAllocator.FreeSingle((MEMPHYSWCHit*) aHit);
     110inline void MEMPHYS::MEMPHYSWCHit::operator delete(void *aHit) {
     111  MEMPHYS::MEMPHYSWCHitAllocator.FreeSingle((MEMPHYS::MEMPHYSWCHit*) aHit);
    108112}
    109113

  • MEMPHYS/HEAD/MEMPHYS/MEMPHYSWCSD.hh

    r65 r68  
    1010class G4Step;
    1111class G4HCofThisEvent;
     12
     13//JEC 10/1/06 introduce MEMPHYS
     14namespace MEMPHYS {
    1215
    1316class MEMPHYSWCSD : public G4VSensitiveDetector {
    … …  
    2528  MEMPHYSWCHitsCollection* hitsCollection;
    2629  std::map<int,int> PMTHitMap;   // Whether a PMT was hit already
    27   G4int HCID; //JEC 16/11/05
     30  G4int HCID;
    2831
    2932};
    3033
     34}
    3135#endif
    3236

  • MEMPHYS/HEAD/applications/MEMPHYS_batch.cxx

    r65 r68  
    4040  }
    4141  //Book all the histo, tuple
    42   MEMPHYSAnalysis* analysis = new MEMPHYSAnalysis(*aida);
     42  MEMPHYS::MEMPHYSAnalysis* analysis = new MEMPHYS::MEMPHYSAnalysis(*aida);
    4343
    4444
    … …  
    5151
    5252  //JEC 18/11/05 give the "analysis" to fill geometry ITuple
    53   MEMPHYSDetectorConstruction* MEMPHYSdetector =
    54     new MEMPHYSDetectorConstruction(*analysis);
     53  MEMPHYS::MEMPHYSDetectorConstruction* MEMPHYSdetector =
     54    new MEMPHYS::MEMPHYSDetectorConstruction(*analysis);
    5555
    5656  runManager->SetUserInitialization(MEMPHYSdetector);
    5757
    58   runManager->SetUserInitialization(new MEMPHYSPhysicsList);
     58  runManager->SetUserInitialization(new MEMPHYS::MEMPHYSPhysicsList);
    5959
    6060  G4UImanager* UI = G4UImanager::GetUIpointer();
    … …  
    6868
    6969  // Set user action classes
    70   MEMPHYSPrimaryGeneratorAction* myGeneratorAction = new MEMPHYSPrimaryGeneratorAction(MEMPHYSdetector);
     70  MEMPHYS::MEMPHYSPrimaryGeneratorAction* myGeneratorAction = new MEMPHYS::MEMPHYSPrimaryGeneratorAction(MEMPHYSdetector);
    7171  runManager->SetUserAction(myGeneratorAction);
    7272
    73   MEMPHYSRunAction* myRunAction = new MEMPHYSRunAction();
     73  MEMPHYS::MEMPHYSRunAction* myRunAction = new MEMPHYS::MEMPHYSRunAction();
    7474
    7575  runManager->SetUserAction(myRunAction);
    7676
    7777
    78   runManager->SetUserAction(new MEMPHYSEventAction(*analysis,
     78  runManager->SetUserAction(new MEMPHYS::MEMPHYSEventAction(*analysis,
    7979                                                   myRunAction,
    8080                                                   MEMPHYSdetector,
    8181                                                   myGeneratorAction));
    82   runManager->SetUserAction(new MEMPHYSTrackingAction);
     82  runManager->SetUserAction(new MEMPHYS::MEMPHYSTrackingAction);
    8383
    84   runManager->SetUserAction(new MEMPHYSStackingAction);
    85   runManager->SetUserAction(new MEMPHYSSteppingAction); //JEC 15/12/05 Add user SteppingAction
     84  runManager->SetUserAction(new MEMPHYS::MEMPHYSStackingAction);
     85  runManager->SetUserAction(new MEMPHYS::MEMPHYSSteppingAction); //JEC 15/12/05 Add user SteppingAction
    8686
    8787  // Initialize G4 kernel

  • MEMPHYS/HEAD/applications/MEMPHYS_session.cxx

    r65 r68  
    3737// Create a manager to access the MEMPHYSAnalysis from the callbacks :
    3838
     39//JEC 10/1/06 introduce MEMPHYS namespace
     40namespace MEMPHYS {
    3941class MEMPHYSAnalysisManager
    4042  :public virtual IManager
    … …  
    4345  virtual const std::string& name() const { return fName;}
    4446  virtual void* cast(const std::string& aTo) const {
    45     if(aTo=="MEMPHYSAnalysisManager") {
    46       return Lib_SCast(MEMPHYSAnalysisManager);
    47     } else if(aTo=="MEMPHYSIAnalysis") {
    48       return Lib_SCast(MEMPHYSIAnalysis);
    49     } else if(aTo=="MEMPHYSAnalysis") {
    50       return Lib_SCast(MEMPHYSAnalysis);
     47    if(aTo=="MEMPHYS::MEMPHYSAnalysisManager") {
     48      return Lib_SCast(MEMPHYS::MEMPHYSAnalysisManager);
     49    } else if(aTo=="MEMPHYS::MEMPHYSIAnalysis") {
     50      return Lib_SCast(MEMPHYS::MEMPHYSIAnalysis);
     51    } else if(aTo=="MEMPHYS::MEMPHYSAnalysis") {
     52      return Lib_SCast(MEMPHYS::MEMPHYSAnalysis);
    5153    } else if(aTo=="IManager") {
    5254      return Lib_SCast(IManager);
    … …  
    5759 public:
    5860  MEMPHYSAnalysisManager(AIDA::IAnalysisFactory& aAIDA,bool aBatch)
    59     :MEMPHYSAnalysis(aAIDA,aBatch),fName("MEMPHYSAnalysisManager") {}
     61    :MEMPHYSAnalysis(aAIDA,aBatch),fName("MEMPHYS::MEMPHYSAnalysisManager") {}
    6062  virtual ~MEMPHYSAnalysisManager(){}
    6163 private:
    6264  std::string fName;
    6365};
    64 
     66}
    6567
    6668//////////////////////////////////////////////////////////////////////////////
    … …  
    8082  G4Lab::UIOnX* session = new G4Lab::UIOnX(*runManager,gui,aArgc,aArgv);
    8183
    82   MEMPHYSAnalysisManager* analysisManager = 0;
     84  MEMPHYS::MEMPHYSAnalysisManager* analysisManager = 0;
    8385
    8486  AIDA::IAnalysisFactory* aida = G4Lab::UIOnX_aida(*session);
    … …  
    8688    std::cout << "MEMPHYS_session : AIDA not found." << std::endl;
    8789  } else {
    88     analysisManager = new MEMPHYSAnalysisManager(*aida,false);
     90    analysisManager = new MEMPHYS::MEMPHYSAnalysisManager(*aida,false);
    8991    session->addManager(analysisManager);
    9092  }
    … …  
    9496    //FIXME : From G4VDigiCollection, we can't loop on G4VDigi !
    9597    session->addType
    96       (new G4Lab::DigitsCollectionType<MEMPHYSWCDigi>
     98      (new G4Lab::DigitsCollectionType<MEMPHYS::MEMPHYSWCDigi>
    9799        (*(session->session()),"WCDigitizedCollection"));
    98100  }
    … …  
    107109 
    108110  //JEC 18/11/05 give the "analysis" to fill geometry ITuple
    109   MEMPHYSDetectorConstruction* MEMPHYSdetector =
    110     new MEMPHYSDetectorConstruction(*analysisManager);
     111  MEMPHYS::MEMPHYSDetectorConstruction* MEMPHYSdetector =
     112    new MEMPHYS::MEMPHYSDetectorConstruction(*analysisManager);
    111113
    112114  runManager->SetUserInitialization(MEMPHYSdetector);
    113115
    114   runManager->SetUserInitialization(new MEMPHYSPhysicsList);
     116  runManager->SetUserInitialization(new MEMPHYS::MEMPHYSPhysicsList);
    115117
    116118  // Set user action classes
    117   MEMPHYSPrimaryGeneratorAction* myGeneratorAction =
    118     new MEMPHYSPrimaryGeneratorAction(MEMPHYSdetector);
     119  MEMPHYS::MEMPHYSPrimaryGeneratorAction* myGeneratorAction =
     120    new MEMPHYS::MEMPHYSPrimaryGeneratorAction(MEMPHYSdetector);
    119121  runManager->SetUserAction(myGeneratorAction);
    120122
    121   MEMPHYSRunAction* myRunAction = new MEMPHYSRunAction();
     123  MEMPHYS::MEMPHYSRunAction* myRunAction = new MEMPHYS::MEMPHYSRunAction();
    122124
    123125  runManager->SetUserAction(myRunAction);
    124126
    125127
    126   runManager->SetUserAction(new MEMPHYSEventAction(*analysisManager,
     128  runManager->SetUserAction(new MEMPHYS::MEMPHYSEventAction(*analysisManager,
    127129                                                   myRunAction,
    128130                                                   MEMPHYSdetector,
    129131                                                   myGeneratorAction));
    130   runManager->SetUserAction(new MEMPHYSTrackingAction);
     132  runManager->SetUserAction(new MEMPHYS::MEMPHYSTrackingAction);
    131133
    132   runManager->SetUserAction(new MEMPHYSStackingAction);
     134  runManager->SetUserAction(new MEMPHYS::MEMPHYSStackingAction);
    133135
    134   runManager->SetUserAction(new MEMPHYSSteppingAction); //JEC 15/12/05 Add user SteppingAction
     136  runManager->SetUserAction(new MEMPHYS::MEMPHYSSteppingAction); //JEC 15/12/05 Add user SteppingAction
    135137
    136138  // Initialize G4 kernel
Note: See TracChangeset for help on using the changeset viewer.