detector.h

Go to the documentation of this file.

#ifndef detector_H
#define detector_H 1

// G4 headers
#include "G4PVPlacement.hh"
#include "G4VSensitiveDetector.hh"
#include "G4VSolid.hh"
#include "G4VisManager.hh"

// gemc headers
#include "identifier.h"
#include "run_conditions.h"
#include "string_utilities.h"


class detector
{
    
    public:
        detector();
        ~detector(){;}
        
        string                 name;   
        string               mother;   
        string          description;   
        
        G4ThreeVector           pos;   
        G4RotationMatrix        rot;   
        
        G4VisAttributes       VAtts;   
        
        string                 type;   
        vector<double>   dimensions;   
        
        string             material;   
        string             magfield;   
        
        int                   ncopy;   
        bool                  pMany;   
        
        int                   exist;   
        int                 visible;   
        int                   style;   
        
        string          sensitivity;   
        string              hitType;   
        vector<identifier> identity;   
        
        int                 scanned;   
        
        string               system;   
        string              factory;   
        string            variation;   
        int                     run;   
    
    private:
        G4VSolid*                     SolidV;   
        G4LogicalVolume*              LogicV;   
        G4VPhysicalVolume*         PhysicalV;   
        
    public:
        int create_solid(goptions, map<string, detector>*);                             
        int create_logical_volume(map<string, G4Material*>*, goptions);                 
        int create_physical_volumes(goptions, G4LogicalVolume*);                        
        void setSensitivity(G4VSensitiveDetector *SD){LogicV->SetSensitiveDetector(SD);} 
        
        G4VSolid          *GetSolid()   { return SolidV;}                                
        G4LogicalVolume   *GetLogical() { return LogicV;}                                
        G4VPhysicalVolume *GetPhysical(){ return PhysicalV;}                             
        void SetLogical(G4LogicalVolume *LV){LogicV = LV;}                               
        void SetTranslation(G4ThreeVector TR){PhysicalV->SetTranslation(TR);}            
        void RemoveDaughter(G4VPhysicalVolume* PV){LogicV->RemoveDaughter(PV);}          
        void AssignMFM(G4FieldManager* MFM){LogicV->SetFieldManager(MFM, true);}         
        
        void SetUserLimits(G4UserLimits* L) { LogicV->SetUserLimits(L);}
        
        friend ostream &operator<<(ostream &stream, detector);                           
        bool operator== (const detector& D) const;                                       
};


#endif