SToGS_DetectorFactory.hh

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//

#ifndef SToGS_DetectorFactory_h
#define SToGS_DetectorFactory_h 1

#include "globals.hh"
#include "G4VUserDetectorConstruction.hh"
#include "G4RotationMatrix.hh"
#include "G4Transform3D.hh"

// std includes 
#include <iostream>
#include <sstream>
#include <fstream>

class G4Box;
class G4Sphere;
class G4LogicalVolume;
class G4VPhysicalVolume;
class G4Material;
class G4AssemblyVolume;
class G4VSensitiveDetector;

namespace SToGS {
    
    class DFMessenger;


    class DetectorFactory
    {
    private:
        static DetectorFactory *pMainFactory;
    private:
        static DFMessenger *pMainMessanger;
    private:

        static std::vector < DetectorFactory * > fSubFactory;
    private:
        static G4int gCopyNb;
        
    protected:
        G4String fPath;
    protected:
        std::vector < std::pair < G4String, G4AssemblyVolume *> > fLoadedAssembly;
        std::vector < std::pair < G4String, G4VPhysicalVolume *> > fLoadedPhysical;
        
    private:

        void Register(DetectorFactory *df)
        {
            fSubFactory.push_back(df);
        }
        
    protected:
        DetectorFactory():
            fPath("DetectorFactory/"),
            fLoadedAssembly(0),
            fLoadedPhysical(0)
            {;}
        DetectorFactory(G4String path):
            fPath(path),
            fLoadedAssembly(1000),
            fLoadedPhysical(1000)
        {
            fPath.prepend(theMainFactory()->GetFactoryName().data());
            theMainFactory()->Register(this) ;
        }
        
    public:
// Main factory facilities
        static G4int AddGCopyNb()
        {
            G4int val = gCopyNb++;
            return val;
        }
        static G4int SetGCopyNb(G4int val)
        {
            G4int current = gCopyNb;
            gCopyNb = val;
            return current;
        }
        static G4int GetGCopyNb()
        {
            return gCopyNb;
        }
        static void ChangeCopyNb(G4VPhysicalVolume *top, G4String which_det, G4int which_nb);

        static DetectorFactory *theMainFactory();
        
        static DetectorFactory *GetFactory(G4String fullname);
        
        static G4VPhysicalVolume *MakeVCR(
                            G4String name,
                            G4double HalfX = 5.0*CLHEP::m, G4double HalfY = 5.0*CLHEP::m, G4double HalfZ = 5.0*CLHEP::m,
                            G4int copy = -1);
        

        static void SetActive(G4LogicalVolume *pv, const G4String &option = "*|*|*|0.5;0.5;0.5;0.5");
        

        static void ChangeSD(G4String opt, G4VPhysicalVolume *top = 0x0);
        static G4VSensitiveDetector * GetSD(G4String opt, const char sd_type = 'S');
        

        static void CollectVolumes(G4VPhysicalVolume *theDetector,
                                   std::vector<G4LogicalVolume *> &logical_stored,
                                   std::vector<G4VPhysicalVolume *> &physical_stored, std::vector<G4VPhysicalVolume *> &physical_active);
        
        protected:
// Methods to be overwritten in particular factory
        virtual G4VPhysicalVolume * Make(G4String /* name */, G4String /* version_string */)
        {
            return 0x0;
        }
        void StoreMap(std::ofstream &amap, std::ofstream &dmap,
                      std::vector<G4LogicalVolume *> &logical_stored,
                      std::vector<G4VPhysicalVolume *> &physical_stored,
                      std::vector<G4VPhysicalVolume *> &physical_active,
                      G4VPhysicalVolume *theDetector);
        
        void StreamTouchable(std::ofstream &dmap, G4String);
        

        G4VPhysicalVolume *Import(G4String gdmlfile, G4String detname, const G4String &opt_amap, const G4String &opt_dmap);
        
        
    public:
        virtual ~DetectorFactory()
        { /* what to delete ? ... the main factory .. */ ;}
        
        G4String GetFactoryName() const
        {
            return fPath;
        }
        
    public:

        G4String GetDetName(const G4String &path) const;
        G4String GetDetName(G4String name, G4String version) const;
        
        G4String GetFileName(G4String detname, G4String extention);
        

        virtual G4VPhysicalVolume *Get(G4String basename);
        G4AssemblyVolume  *GetAssembly(G4String basename);
        virtual void GetAttributes(G4String basename, G4bool do_amap = true, G4bool do_dmap = false);
        
        G4int Set(G4String basename, G4VPhysicalVolume *world, G4int copy_number_offset,
                   const G4ThreeVector *T = 0x0, const G4RotationMatrix *R = 0x0,  G4int main_copy_number = 0);
        G4int Set(G4String basename, G4VPhysicalVolume *world, G4int copy_number_offset,
                   const G4Transform3D *Tr, G4int main_copy_number = 0);
        void Clean();

    protected:

        void MakeInStore(G4String name, G4String version_string);
        
    public:
        virtual void MakeStore();
        
        virtual void Store(G4VPhysicalVolume *);
        
        void AssemblyRename(G4AssemblyVolume *assembly, const G4String &volume_to_find) const;
        
        /*
         */
        G4int DoMap(G4AssemblyVolume *assembly, G4VPhysicalVolume *volume_used_to_built_assembly, G4int copy_number_offset = 0
                    /*, G4String opt = "->" */) const;

        virtual G4int ReMap(G4VPhysicalVolume *adetector, G4int offset);
        
        /*
            The volume are reas as they are and only the top physical volume has its copy number affected
         */
        virtual G4VPhysicalVolume * MakeAnArrayFromFactory(G4String input_file);

    };
} // SToGS Namespace

    
#include "G4UImessenger.hh"
    
class G4UIdirectory;
class G4UIcmdWithAString;
    
namespace SToGS {

    class DFMessenger: public G4UImessenger
    {
    public:
        DFMessenger();
        virtual ~DFMessenger();
        
        void SetNewValue(G4UIcommand*, G4String);
        
    private:
        G4UIdirectory *theDirectory;
        
        G4UIcmdWithAString *cmdToChangeSD;
        G4UIcmdWithAString *cmdToSaveInFactory;
    };
    
} // SToGS Namespace

#endif