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/geometry/GeometryData.h>
#include <klm/eklm/geometry/TransformData.h>
#include <klm/simulation/SensitiveDetector.h>
 
/* Basf2 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* 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() override;

      GeoEKLMCreator(const GeoEKLMCreator&) = delete;

      GeoEKLMCreator& operator=(const GeoEKLMCreator&) = delete;

      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();

      static G4SubtractionSolid* cutSolidCorner(
        const char* name, G4VSolid* solid, G4Box* subtractionBox,
        const HepGeom::Transform3D& transf, bool largerAngles,
        double x1, double y1, double x2, double y2);

      static 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);

      static 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) const;

      G4LogicalVolume* createSector(G4LogicalVolume* layer) 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;

      KLM::SensitiveDetector* m_Sensitive;
 
    };
 
  }

}