GeoVXDCreator.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.                  *
 **************************************************************************/
 
#ifndef GEOVXDCREATOR_H
#define GEOVXDCREATOR_H
 
#include <vxd/geometry/GeoVXDComponents.h>
#include <vxd/geometry/GeoVXDAssembly.h>
#include <vxd/geometry/SensorInfoBase.h>
#include <vxd/geometry/GeoVXDRadiationSensors.h>
#include <vxd/simulation/SensitiveDetectorBase.h>
#include <geometry/CreatorBase.h>
#include <framework/gearbox/GearDir.h>
#include <framework/logging/Logger.h>
#include <string>
#include <vector>
#include <map>
 
 
#include <framework/database/DBObjPtr.h>
#include <framework/database/DBImportObjPtr.h>
#include <framework/database/IntervalOfValidity.h>
#include <vxd/dbobjects/VXDGeometryPar.h>
 
 
#include <G4Transform3D.hh>
#include <G4Polycone.hh>
class G4LogicalVolume;
class G4AssemblyVolume;
class G4VSolid;
class G4Material;
class G4UserLimits;
 
namespace Belle2 {
  namespace VXD {

    class GeoVXDCreator : public geometry::CreatorBase {
 
    public:
      explicit GeoVXDCreator(const std::string& prefix);

      virtual ~GeoVXDCreator();

      virtual SensorInfoBase* createSensorInfo(const VXDGeoSensorPar& sensor) = 0;

      virtual SensitiveDetectorBase* createSensitiveDetector(VxdID sensorID, const VXDGeoSensor& sensor,
                                                             const VXDGeoSensorPlacement& placement) = 0;

      virtual void setCurrentLayer(int layer, const VXDGeometryPar& parameters);

      G4Transform3D placeLadder(int ladderID, double phi, G4LogicalVolume* volume, const G4Transform3D& placement,
                                const VXDGeometryPar& parameters);

      G4Transform3D getPosition(const VXDGeoComponent& mother, const VXDGeoComponent& daughter, const VXDGeoPlacement& placement,
                                bool originCenter);

      G4Transform3D getAlignment(const VXDAlignmentPar& params);

      GeoVXDAssembly createSubComponents(const std::string& name, VXDGeoComponent& component,
                                         std::vector<VXDGeoPlacement> placements,
                                         bool originCenter = true, bool allowOutside = false);

      G4VSolid* createTrapezoidal(const std::string& name, double width, double
                                  width2, double length, double& height, double angle = 0);

      void createDiamonds(const VXDGeoRadiationSensorsPar& params, G4LogicalVolume& topVolume, G4LogicalVolume& envelopeVolume);

      std::vector<VXDGeoPlacementPar> getSubComponents(const GearDir& path);

      virtual void readLadder(int layer, GearDir components, VXDGeometryPar& geoparameters);

      virtual void readLadderComponents(int layerID, int ladderID, GearDir content, VXDGeometryPar& vxdGeometryPar);

      void readComponent(const std::string& name, GearDir components, VXDGeometryPar& vxdGeometryPar);

      void readSubComponents(const std::vector<VXDGeoPlacementPar>& placements, const GearDir& componentsDir,
                             VXDGeometryPar& vxdGeometryPar);
 
    protected:
      std::string m_prefix;
      GearDir m_alignment;
      GearDir m_components;

      std::map<std::string, VXDGeoComponent> m_componentCache;
      std::map<std::string, VXDGeoSensor> m_sensorMap;
      VXDGeoLadder m_ladder;
      std::vector<Simulation::SensitiveDetectorBase*> m_sensitive;
      GeoVXDRadiationSensors m_radiationsensors;

      std::string m_defaultMaterial;
      float m_distanceTolerance {(float)(5 * Unit::um)};
      float m_electronTolerance {100};
      float m_minimumElectrons {10};
      double m_activeStepSize {5 * Unit::um};
      bool m_activeChips {false};
      bool m_seeNeutrons {false};
      bool m_onlyPrimaryTrueHits {false};
      bool m_onlyActiveMaterial {false};
      std::vector<G4UserLimits*> m_UserLimits;
      std::string m_currentHalfShell {""};
      std::map<std::string, Belle2::VxdID> m_halfShellVxdIDs {
        {{"PXD.Ying"}, {Belle2::VxdID(1, 0, 0, 1)}},
        {{"PXD.Yang"}, {Belle2::VxdID(1, 0, 0, 2)}},
        {{"SVD.Pat"}, {Belle2::VxdID(3, 0, 0, 1)}},
        {{"SVD.Mat"}, {Belle2::VxdID(3, 0, 0, 2)}}
      };
      std::map<std::string, Belle2::VxdID> m_halfShellVxdIDs {…};
 
    }; // class GeoVXDCreator
    class GeoVXDCreator : public geometry::CreatorBase {…};
 
  } // namespace VXD
} //namespace Belle2
 
#endif /* GEOVXDCREATOR_H */