GeoARICHCreator.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 GEOARICHCREATOR_H
#define GEOARICHCREATOR_H
 
#include <geometry/CreatorBase.h>
#include <framework/logging/Logger.h>
#include <arich/dbobjects/ARICHGeometryConfig.h>
#include <framework/database/DBObjPtr.h>
#include <framework/database/DBImportObjPtr.h>
#include <framework/database/IntervalOfValidity.h>
#include <arich/dbobjects/ARICHModulesInfo.h>
#include <arich/dbobjects/ARICHGeoMergerCooling.h>
 
#include <G4AssemblyVolume.hh>
 
class G4LogicalVolume;
class G4Material;
 
namespace Belle2 {
  class GearDir;
 
  namespace arich {
 
    class SensitiveDetector;
    class SensitiveAero;
 
    class GeoARICHCreator : public geometry::CreatorBase {
 
    private:
 
      ARICHGeometryConfig createConfiguration(const GearDir& param)
      {
        ARICHGeometryConfig arichGeometryConfig(param);
        return arichGeometryConfig;
      }
 
      void createGeometry(G4LogicalVolume& topVolume, geometry::GeometryTypes type);
 
    public:
 
      GeoARICHCreator();
 
      virtual ~GeoARICHCreator();
 
      virtual void create(const GearDir& content, G4LogicalVolume& topVolume, geometry::GeometryTypes type) override
      {
        m_config = createConfiguration(content);
 
        // override geometry configuration from the DB
        DBStore::Instance().addConstantOverride("ARICHGeometryConfig", new ARICHGeometryConfig(m_config));
 
        createGeometry(topVolume, type);
      }
 
      virtual void createPayloads(const GearDir& content, const IntervalOfValidity& iov) override
      {
        DBImportObjPtr<ARICHGeometryConfig> importObj;
        importObj.construct(createConfiguration(content));
        importObj.import(iov);
      }
 
      virtual void createFromDB(const std::string& name, G4LogicalVolume& topVolume, geometry::GeometryTypes type) override
      {
        DBObjPtr<ARICHGeometryConfig> dbObj;
        if (!dbObj) {
          // Check that we found the object and if not report the problem
          B2FATAL("No configuration for " << name << " found.");
        }
        m_config = *dbObj;
        createGeometry(topVolume, type);
      }
 
    private:
 
      G4LogicalVolume* buildHAPD(const ARICHGeoHAPD& hapdPar);
 
      G4LogicalVolume* buildMerger(const ARICHGeoMerger& mergerGeo);
 
      G4LogicalVolume* buildMergerEnvelope(const ARICHGeoMerger& mergerGeo, int type);
 
      G4LogicalVolume* buildCables(const ARICHGeoCablesEnvelope& cablesGeo);
 
      G4LogicalVolume* buildMirror(const ARICHGeometryConfig& detectorGeo);
 
      G4LogicalVolume* buildDetectorPlane(const ARICHGeometryConfig& detectorGeo);
 
      G4LogicalVolume* buildMergerPCBEnvelopePlane(const ARICHGeometryConfig& detectorGeo);
 
      G4LogicalVolume* buildCoolingEnvelopePlane(const ARICHGeoCooling& coolingGeo);
 
      G4LogicalVolume* buildCoolingTube(const unsigned i_volumeID, const ARICHGeoCooling& coolingGeo);
 
      G4LogicalVolume* buildCoolingTorus(const unsigned i_volumeID, const ARICHGeoCooling& coolingGeo);
 
      G4LogicalVolume* buildCoolingTestPlate(const ARICHGeoCooling& coolingGeo);
 
      G4LogicalVolume* buildFEBCoolingBody(const ARICHGeoFEBCooling& coolingv2Geo);
 
      G4LogicalVolume* buildMergerCooling(unsigned iType);
 
      G4LogicalVolume* buildAerogelPlane(const ARICHGeometryConfig& detectorGeo);
 
      G4LogicalVolume* buildAerogelPlaneAveragedOverLayers(const ARICHGeometryConfig& detectorGeo);
 
      G4LogicalVolume* buildAerogelPlaneWithIndividualTilesProp(const ARICHGeometryConfig& detectorGeo);
 
      G4LogicalVolume* buildSimpleAerogelPlane(const ARICHGeometryConfig& detectorGeo);
 
      G4LogicalVolume* buildDetectorSupportPlate(const ARICHGeometryConfig& detectorGeo);
 
      void makeJoint(G4Material* supportMaterial, const std::vector<double>& pars, G4AssemblyVolume* assemblyWedge);
 
      double getAvgRINDEX(G4Material* material);
 
      ARICHGeometryConfig m_config;
 
      SensitiveDetector* m_sensitive;
 
      SensitiveAero* m_sensitiveAero;
 
      int m_isBeamBkgStudy;
 
      DBObjPtr<ARICHModulesInfo> m_modInfo; 
      OptionalDBObjPtr<ARICHGeoMergerCooling> m_mergerCooling; 
    };
 
  }
}
 
#endif /* GEOARICHCREATOR_H */