MakeActsGeometry.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file MakeActsGeometry.h

#ifndef MAKE_ACTS_GEOMETRY_H
#define MAKE_ACTS_GEOMETRY_H

#include <fun4all/SubsysReco.h>
#include <trackbase/TrkrDefs.h>

#include <trackbase/ActsTrackingGeometry.h>
#include <trackbase/ActsSurfaceMaps.h>

#include <Acts/Utilities/Definitions.hpp>
#include <Acts/Utilities/BinnedArray.hpp>                      
#include <Acts/Utilities/Logger.hpp>                           
#include <Acts/EventData/MeasurementHelpers.hpp> 
#include <Acts/Geometry/TrackingGeometry.hpp>
#include <Acts/MagneticField/MagneticFieldContext.hpp>
#include <Acts/Utilities/CalibrationContext.hpp>

#include <ActsExamples/TGeoDetector/TGeoDetector.hpp>
#include <ActsExamples/Fitting/TrkrClusterFittingAlgorithm.hpp>
#include <ActsExamples/Plugins/BField/BFieldOptions.hpp>

#include <map>
#include <memory>            
#include <string>
#include <vector>

class PHCompositeNode;
class PHG4CylinderGeomContainer;
class PHG4CylinderCellGeomContainer;
class TGeoManager;
class TGeoNode;
class TGeoVolume;

namespace ActsExamples 
{
  class IBaseDetector;
  class IContextDecorator;
}

namespace Acts 
{
  class Surface;
}

using Surface = std::shared_ptr<const Acts::Surface>;
using TrackingGeometry = std::shared_ptr<const Acts::TrackingGeometry>;
using TrackingVolumePtr = std::shared_ptr<const Acts::TrackingVolume>;

class MakeActsGeometry : public SubsysReco
{
 public:

  MakeActsGeometry(const std::string& name = "MakeActsGeometry");

  ~MakeActsGeometry() override = default;

  int Init(PHCompositeNode *topNode) override;
  int InitRun(PHCompositeNode *topNode) override;
  int process_event(PHCompositeNode *topNode) override;
  int End(PHCompositeNode *topNode) override;

  std::vector<std::shared_ptr<ActsExamples::IContextDecorator>> getContextDecorators()
    { return m_contextDecorators; }

  void setMagField(const std::string &magField)
    {m_magField = magField;}
  void setMagFieldRescale(double magFieldRescale)
    {m_magFieldRescale = magFieldRescale;}

  double getSurfStepPhi() {return m_surfStepPhi;}
  double getSurfStepZ() {return m_surfStepZ;}

  void add_fake_surfaces(bool add){fake_surfaces = add;}

 private:
  int buildAllGeometry(PHCompositeNode *topNode);
 
  int getNodes(PHCompositeNode*);
  
  int createNodes(PHCompositeNode*);
  
  void setPlanarSurfaceDivisions();
  void editTPCGeometry(PHCompositeNode *topNode);
  void addActsTpcSurfaces(TGeoVolume *tpc_gas_vol, 
        TGeoManager *geoManager);


  void addActsMicromegasSurfaces(int mm_layer, TGeoVolume *micromegas_vol, TGeoManager *geoManager);

  void buildActsSurfaces();

  void makeGeometry(int argc, char* argv[], 
        ActsExamples::IBaseDetector& detector);
 
  void setMaterialResponseFile(std::string& responseFile,
             std::string& materialFile);

  void getInttKeyFromNode(TGeoNode *gnode);
  void getMvtxKeyFromNode(TGeoNode *gnode);
  void getTpcKeyFromNode(TGeoNode *gnode);
  
  void makeMvtxMapPairs(TrackingVolumePtr &mvtxVolume);
  void makeInttMapPairs(TrackingVolumePtr &inttVolume);
  void makeTpcMapPairs(TrackingVolumePtr &tpcVolume);

  void makeMmMapPairs(TrackingVolumePtr &tpcVolume);
  
  TrkrDefs::hitsetkey getMvtxHitSetKeyFromCoords(unsigned int layer, 
             std::vector<double> &world);
  TrkrDefs::hitsetkey getInttHitSetKeyFromCoords(unsigned int layer,
             std::vector<double> &world);
  TrkrDefs::hitsetkey getTpcHitSetKeyFromCoords(std::vector<double> &world);

  void isActive(TGeoNode *gnode, int nmax_print);

  void makeTGeoNodeMap(PHCompositeNode *topNode);
  
  void unpackVolumes();

  PHG4CylinderGeomContainer* m_geomContainerMvtx = nullptr;
  PHG4CylinderGeomContainer* m_geomContainerIntt = nullptr;
  PHG4CylinderGeomContainer* m_geomContainerMicromegas = nullptr;
  PHG4CylinderCellGeomContainer* m_geomContainerTpc = nullptr;

  TGeoManager* m_geoManager = nullptr;

  std::vector<std::shared_ptr<ActsExamples::IContextDecorator> > 
    m_contextDecorators;

  std::map<TrkrDefs::hitsetkey, TGeoNode*> m_clusterNodeMap;
  std::map<TrkrDefs::hitsetkey, Surface> m_clusterSurfaceMapSilicon;
  std::map<unsigned int, std::vector<Surface>> m_clusterSurfaceMapTpcEdit;  // uses layer as key
  std::map<TrkrDefs::hitsetkey, Surface> m_clusterSurfaceMapMmEdit;
  
  const static unsigned int m_nTpcLayers = 48;
  const unsigned int m_nTpcModulesPerLayer = 12;
  const unsigned int m_nTpcSides = 2;

  double m_minSurfZ = 0.;
  double m_maxSurfZ = 105.78;
  unsigned int m_nSurfZ = 1;
  unsigned int m_nSurfPhi = 12;
  double m_surfStepPhi = 0;
  double m_surfStepZ = 0;
  double m_moduleStepPhi = 0;
  double m_modulePhiStart = 0;

  int nprint_tpc = 0;

  const static int m_nTpcSectors = 3;
  const double m_minRadius[m_nTpcSectors] = {30.0, 40.0, 60.0};
  const double m_maxRadius[m_nTpcSectors] = {40.0, 60.0, 77.0};
  double layer_thickness_sector[m_nTpcSectors] = {0};
  double m_layerRadius[m_nTpcLayers] = {0};
  double m_layerThickness[m_nTpcLayers] = {0};

  // Spaces to prevent boxes from touching when placed
  const double half_width_clearance_thick = 0.4999;
  const double half_width_clearance_phi = 0.4999;
  const double half_width_clearance_z = 0.4999;

  TGeoDetector m_detector;

  TrackingGeometry m_tGeometry;
  ActsExamples::Options::BFieldVariant m_magneticField;
  Acts::GeometryContext  m_geoCtxt;  
  Acts::CalibrationContext m_calibContext;
  Acts::MagneticFieldContext m_magFieldContext;

  ActsTrackingGeometry *m_actsGeometry = nullptr;
  ActsSurfaceMaps *m_surfMaps = nullptr;

  int m_verbosity = 0;

  std::string m_magField ="1.4" ;
  double m_magFieldRescale = -1.;

  bool m_buildMMs = false;
  bool fake_surfaces = true;
};

#endif