GeoEKLMCreator.h

Go to the documentation of this file.

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
/* KLM headers. */
#include <klm/eklm/simulation/EKLMSensitiveDetector.h>
#include <klm/eklm/geometry/GeometryData.h>
#include <klm/eklm/geometry/TransformData.h>
 
/* Belle 2 headers. */
#include <framework/gearbox/GearDir.h>
#include <geometry/CreatorBase.h>
 
/* C++ headers. */
#include <string>
 
/* Geant4 headers. */
#include <G4Box.hh>
#include <G4LogicalVolume.hh>
#include <G4Material.hh>
#include <G4SubtractionSolid.hh>
#include <G4Transform3D.hh>
#include <G4Tubs.hh>
 
namespace Belle2 {
  namespace EKLM {
 
    struct SectorSupportSolids {
      G4VSolid* itube; 
      G4VSolid* otube; 
    };
 
    struct SectorSupportLogicalVolumes {
      G4LogicalVolume* corn1; 
      G4LogicalVolume* corn2; 
      G4LogicalVolume* corn3; 
      G4LogicalVolume* corn4; 
      G4LogicalVolume* supp;  
    };
 
    struct ShieldLogicalVolumes {
      G4LogicalVolume* detailA; 
      G4LogicalVolume* detailB; 
      G4LogicalVolume* detailC; 
      G4LogicalVolume* detailD; 
    };
 
    struct Solids {
      G4VSolid* section;
      G4VSolid* layer;
      G4VSolid* sector;
      G4VSolid* secsupp;
      G4VSolid** plane;
      G4VSolid** stripSegment;
      G4VSolid** plasticSheetElement;
      G4VSolid** psheet;
      G4VSolid** strip;
      G4VSolid** groove;
      G4Box* subtractionBox;
      struct SectorSupportSolids sectorsup;
    };
 
    struct LogicalVolumes {
      G4LogicalVolume* shieldLayer;
      G4LogicalVolume* shieldLayerSector;
      G4LogicalVolume* cover;
      G4LogicalVolume** segment;
      G4LogicalVolume** stripSegment;
      G4LogicalVolume** strip;
      G4LogicalVolume** groove;
      G4LogicalVolume** scint;
      G4LogicalVolume** psheet;
      G4LogicalVolume*** segmentsup;
      struct SectorSupportLogicalVolumes sectorsup;
      struct ShieldLogicalVolumes shield;
    };
 
    struct Materials {
      G4Material* air;          
      G4Material* polyethylene; 
      G4Material* polystyrene;  
      G4Material* polystyrol;   
      G4Material* iron;         
      G4Material* duralumin;    
      G4Material* silicon;      
      G4Material* gel;          
    };
 
    struct VolumeNumbers {
      int section;  
      int layer;   
      int sector;  
      int plane;   
      int segment; 
      int strip;   
    };
 
    class GeoEKLMCreator : public geometry::CreatorBase {
 
    public:
 
      GeoEKLMCreator();
 
      ~GeoEKLMCreator();
 
      void create(const GearDir& content, G4LogicalVolume& topVolume,
                  geometry::GeometryTypes type) override;
 
      void createFromDB(const std::string& name, G4LogicalVolume& topVolume,
                        geometry::GeometryTypes type) override;
 
      void createPayloads(const GearDir& content,
                          const IntervalOfValidity& iov) override;
 
    private:
 
      void createMaterials();
 
      void readXMLDataStrips();
 
      void createSectionSolid();
 
      G4LogicalVolume* createLayerLogicalVolume(const char* name) const;
 
      void createLayerSolid();
 
      G4LogicalVolume* createSectorLogicalVolume(const char* name) const;
 
      void createSectorSolid();
 
      void createSectorCoverLogicalVolume();
 
      G4Tubs* createSectorSupportInnerTube();
 
      G4Tubs* createSectorSupportOuterTube();
 
      G4Box* createSectorSupportBoxX(G4Transform3D& t);
 
      G4Box* createSectorSupportBoxY(G4Transform3D& t);
 
      G4Box* createSectorSupportBoxTop(G4Transform3D& t);
 
      void createSectorSupportLogicalVolume();
 
      void createSectorSupportCorner1LogicalVolume();
 
      void createSectorSupportCorner2LogicalVolume();
 
      void createSectorSupportCorner3LogicalVolume();
 
      void createSectorSupportCorner4LogicalVolume();
 
      void createSubtractionBoxSolid();
 
      G4SubtractionSolid* cutSolidCorner(
        const char* name, G4VSolid* solid, G4Box* subtractionBox,
        const HepGeom::Transform3D& transf, bool largerAngles,
        double x1, double y1, double x2, double y2);
 
      G4SubtractionSolid* cutSolidCorner(
        const char* name, G4VSolid* solid, G4Box* subtractionBox,
        const HepGeom::Transform3D& transf, bool largerAngles,
        double x, double y, double ang);
 
      void createPlaneSolid(int n);
 
      void createSegmentSupportLogicalVolume(int iPlane, int iSegmentSupport);
 
      G4VSolid* unifySolids(G4VSolid** solids, HepGeom::Transform3D* transf,
                            int nSolids, const std::string& name);
 
      void createPlasticSheetLogicalVolume(int iSegment);
 
      void createStripSegmentLogicalVolume(int iSegment);
 
      void createSegmentLogicalVolume(int iSegment);
 
      void createStripLogicalVolume(int iStrip);
 
      void createStripGrooveLogicalVolume(int iStrip);
 
      void createScintillatorLogicalVolume(int iStrip);
 
      void createShieldDetailALogicalVolume();
 
      void createShieldDetailBLogicalVolume();
 
      void createShieldDetailCLogicalVolume();
 
      void createShieldDetailDLogicalVolume();
 
      void createSolids();
 
      bool detectorLayer(int section, int layer) const;
 
      G4LogicalVolume* createSection(G4LogicalVolume* topVolume) const;
 
      G4LogicalVolume* createLayer(G4LogicalVolume* section,
                                   G4LogicalVolume* layer) const;
 
      G4LogicalVolume* createSector(G4LogicalVolume* layer,
                                    G4LogicalVolume* sector) const;
 
      void createSectorCover(int iCover, G4LogicalVolume* sector) const;
 
      void createSectorSupport(G4LogicalVolume* sector) const;
 
      void createSectorSupportCorner1(G4LogicalVolume* sector) const;
 
      void createSectorSupportCorner2(G4LogicalVolume* sector) const;
 
      void createSectorSupportCorner3(G4LogicalVolume* sector) const;
 
      void createSectorSupportCorner4(G4LogicalVolume* sector) const;
 
      G4LogicalVolume* createPlane(G4LogicalVolume* sector) const;
 
      void createSegmentSupport(int iSegmentSupport,
                                G4LogicalVolume* plane) const;
 
      void createPlasticSheet(int iSheetPlane, int iSheet) const;
 
      void createStripSegment(int iSegment) const;
 
      void createSegment(G4LogicalVolume* plane) const;
 
      void createStrip(G4LogicalVolume* segment) const;
 
      void createStripGroove(int iStrip) const;
 
      void createScintillator(int iStrip) const;
 
      void createShield(G4LogicalVolume* sector) const;
 
      void newVolumes();
 
      void newSensitive();
 
      void deleteVolumes();
 
      void deleteSensitive();
 
      double getSectorSupportCornerAngle();
 
      void create(G4LogicalVolume& topVolume);
 
      struct Solids m_Solids;
 
      struct LogicalVolumes m_LogVol;
 
      struct Materials m_Materials;
 
      struct VolumeNumbers m_CurVol;
 
      const EKLMElementNumbers* m_ElementNumbers;
 
      TransformData* m_TransformData;
 
      const GeometryData* m_GeoDat;
 
      EKLMSensitiveDetector* m_Sensitive;
 
    };
 
  }
 
}