GeoBKLMCreator.h

/**************************************************************************
 * 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/bklm/geometry/GeometryPar.h>
#include <klm/dbobjects/bklm/BKLMGeometryPar.h>
 
/* Basf2 headers. */
#include <framework/database/DBImportObjPtr.h>
#include <framework/database/DBObjPtr.h>
#include <framework/database/IntervalOfValidity.h>
#include <framework/logging/Logger.h>
#include <geometry/CreatorBase.h>
 
class G4VSolid;
class G4Box;
class G4Tubs;
class G4Polyhedra;
class G4LogicalVolume;
class G4VSensitiveDetector;
class G4String;
class G4VisAttributes;
 
namespace Belle2 {
  class GearDir;
 
  namespace bklm {
 
 
    class GeoBKLMCreator : public geometry::CreatorBase {
 
    public:
 
      GeoBKLMCreator();
 
      GeoBKLMCreator(GeoBKLMCreator&) = delete;
 
      GeoBKLMCreator& operator=(GeoBKLMCreator&) = delete;
 
      ~GeoBKLMCreator();
 
      void create(const GearDir& content, G4LogicalVolume& topVolume, geometry::GeometryTypes type) override
      {
        BKLMGeometryPar config = createConfiguration(content);
        createGeometry(config, topVolume, type);
      }
 
      void createPayloads(const GearDir& content, const IntervalOfValidity& iov) override
      {
        DBImportObjPtr<BKLMGeometryPar> importObj;
        importObj.construct(createConfiguration(content));
        importObj.import(iov);
      }
 
      void createFromDB(const std::string& name, G4LogicalVolume& topVolume, geometry::GeometryTypes type) override
      {
        DBObjPtr<BKLMGeometryPar> dbObj;
        if (!dbObj) {
          B2FATAL("No configuration for " << name << " found.");
        }
        createGeometry(*dbObj, topVolume, type);
      }
 
    protected:
 
    private:
 
      BKLMGeometryPar createConfiguration(const GearDir& param)
      {
        BKLMGeometryPar bklmGeometryPar;
        //bklmGeometryPar.setVersion(0);
        bklmGeometryPar.read(param);
        return bklmGeometryPar;
      };
 
      void createGeometry(const BKLMGeometryPar& parameters, G4LogicalVolume& topVolume, geometry::GeometryTypes type);
 
      void putEndsInEnvelope(G4LogicalVolume*);
 
      void putSectorsInEnd(G4LogicalVolume*, int);
 
      void putCapInSector(G4LogicalVolume*, bool);
 
      void putInnerRegionInSector(G4LogicalVolume*, bool, bool);
 
      void putVoidInInnerRegion(G4LogicalVolume*, bool, bool);
 
      void putLayer1SupportInInnerVoid(G4LogicalVolume*, bool);
 
      void putLayer1BracketsInInnerVoid(G4LogicalVolume*, bool);
 
      void putLayersInSector(G4LogicalVolume*, int, int, bool);
 
      void putChimneyInLayer(G4LogicalVolume*, int);
 
      void putModuleInLayer(G4LogicalVolume*, int, int, int, bool, bool, int);
 
      void putRPCsInInterior(G4LogicalVolume*, int, bool);
 
      void putScintsInInterior(G4LogicalVolume*, int, int, int, bool);
 
      G4LogicalVolume* getScintLogical(double, double, double, double);
 
      G4LogicalVolume* getMPPCHousingLogical(void);
 
      G4LogicalVolume* getReadoutContainerLogical(void);
 
      G4Tubs* getSolenoidTube(void);
 
      G4String logicalName(G4VSolid*);
 
      G4String physicalName(G4LogicalVolume*);
 
      GeometryPar* m_GeoPar;
 
      G4VSensitiveDetector* m_Sensitive;
 
      double m_SectorDphi;
 
      double m_SectorDz;
 
      double m_RibShift;
 
      G4Polyhedra* m_CapSolid;
 
      G4LogicalVolume* m_CapLogical[2];
 
      G4VSolid* m_InnerIronSolid;
 
      G4LogicalVolume* m_InnerIronLogical[4];
 
      G4VSolid* m_InnerAirSolid;
 
      G4LogicalVolume* m_InnerAirLogical[4];
 
      G4LogicalVolume* m_SupportLogical[2];
 
      G4LogicalVolume* m_BracketLogical;
 
      G4Polyhedra* m_LayerIronSolid[BKLMElementNumbers::getMaximalLayerNumber()];
 
      G4LogicalVolume* m_LayerIronLogical[12 * BKLMElementNumbers::getMaximalLayerNumber()];
 
      G4Box* m_LayerGapSolid[2 * BKLMElementNumbers::getMaximalLayerNumber()];
 
      G4LogicalVolume* m_LayerGapLogical[12 * BKLMElementNumbers::getMaximalLayerNumber()];
 
      G4LogicalVolume* m_LayerModuleLogical[2 * BKLMElementNumbers::getMaximalLayerNumber()];
 
      G4Tubs* m_SectorTube;
 
      G4LogicalVolume* m_SectorLogical[2][BKLMElementNumbers::getMaximalSectorNumber()];
 
      G4LogicalVolume* m_MPPCHousingLogical;
 
      G4LogicalVolume* m_ReadoutContainerLogical;
 
      G4Tubs* m_SolenoidTube;
 
      std::vector<G4LogicalVolume*> m_ScintLogicals;
 
      std::vector<G4VisAttributes*> m_VisAttributes;
 
      std::vector<G4String*> m_Names;
 
    };
 
  } // end of namespace bklm
 
}  // end of namespace Belle2