dune::DUNEGeometryHelper Class Reference

#include <DUNEGeometryHelper.h>

Inheritance diagram for dune::DUNEGeometryHelper:

Public Member Functions
	DUNEGeometryHelper (fhicl::ParameterSet const &pset)
Public Member Functions inherited from geo::ExptGeoHelperInterface
virtual	~ExptGeoHelperInterface ()=default
	Virtual destructor; does nothing. More...
ChannelMapAlgPtr_t	ConfigureChannelMapAlg (fhicl::ParameterSet const &sortingParameters, std::string const &detectorName) const
	Configure and initialize the channel map. More...

Private Member Functions
std::unique_ptr< geo::ChannelMapAlg >	doConfigureChannelMapAlg (fhicl::ParameterSet const &sortingParameters, std::string const &detectorName) const override

Private Attributes
std::string	fChannelMapClass
std::string	fGeoSorterClass

Additional Inherited Members
Public Types inherited from geo::ExptGeoHelperInterface
using	ChannelMapAlgPtr_t = std::unique_ptr< ChannelMapAlg >

Detailed Description

Definition at line 30 of file DUNEGeometryHelper.h.

Constructor & Destructor Documentation

DUNEGeometryHelper::DUNEGeometryHelper ( fhicl::ParameterSet const &  pset )

explicit

Definition at line 41 of file DUNEGeometryHelper_service.cc.

  : fChannelMapClass{pset.get<string>("ChannelMapClass", {})}
  , fGeoSorterClass{pset.get<string>("GeoSorterClass", {})}
{}

Member Function Documentation

std::unique_ptr< geo::ChannelMapAlg > DUNEGeometryHelper::doConfigureChannelMapAlg ( fhicl::ParameterSet const &  sortingParameters, std::string const &  detectorName  ) const

overrideprivatevirtual

Implements geo::ExptGeoHelperInterface.

Definition at line 49 of file DUNEGeometryHelper_service.cc.

{
  std::unique_ptr<geo::ChannelMapAlg> channelMap{nullptr};

  // The APA sorting algorithm requires special handling.
  // This flag is set if that map is used.
  bool useApaMap = false;
  bool is35t = false;

  // If class name is given use it.
  if ( fChannelMapClass.size() ) {
    if ( fChannelMapClass == "DuneApaChannelMapAlg" ) {
      useApaMap = true;
    } else if ( fChannelMapClass == "ChannelMap35Alg" ) {
      channelMap = std::make_unique<geo::ChannelMap35Alg>(pset);
    } else if ( fChannelMapClass == "ChannelMap35OptAlg" ) {
      channelMap = std::make_unique<geo::ChannelMap35OptAlg>(pset);
    } else if ( fChannelMapClass == "ChannelMapAPAAlg" ) {
      channelMap = std::make_unique<geo::ChannelMapAPAAlg>(pset);
    } else if ( fChannelMapClass == "ProtoDUNEChannelMapAlg" ) {
      channelMap = std::make_unique<geo::ProtoDUNEChannelMapAlg>(pset);
    } else if ( fChannelMapClass == "ProtoDUNEChannelMapAlgv7" ) {
      channelMap = std::make_unique<geo::ProtoDUNEChannelMapAlgv7>(pset);
    } else if ( fChannelMapClass == "ProtoDUNEChannelMapAlgv8" ) {
      channelMap = std::make_unique<geo::ProtoDUNEChannelMapAlgv8>(pset);
    } else {
      throw cet::exception("DUNEGeometryHelper") << "Invalid channel map class name:" << fChannelMapClass << "\n";
    }

  // Otherwise derive class name from detector name.
  } else {
    // DUNE 35t prototype
    if ( ( detectorName.find("dune35t") != std::string::npos ) ||
         ( detectorName.find("lbne35t") != std::string::npos ) ) {
      std::string const detectorVersion = pset.get< std::string >("DetectorVersion");
      if (( detectorVersion.find("v3") != std::string::npos )
       || ( detectorVersion.find("v4") != std::string::npos )
       || ( detectorVersion.find("v5") != std::string::npos )
       || ( detectorVersion.find("v6") != std::string::npos )) {
        useApaMap = true;
        is35t = true;
      } else {
        channelMap = std::make_unique<geo::ChannelMap35Alg>(pset);
      }

    // DUNE 10kt
    } else if (( detectorName.find("dune10kt") != std::string::npos )
          || ( detectorName.find("lbne10kt") != std::string::npos )) {
      useApaMap = true;

    // DUNE 10kt dual phase
    } else if ( detectorName.find("dunedphase10kt") != std::string::npos ) {
      channelMap = std::make_unique<geo::ChannelMapCRMAlg>(pset);

    // DUNE 10kt vd
    } else if ( ( detectorName.find("dunevd10kt") != std::string::npos ) ) {
      channelMap = std::make_unique<geo::ChannelMapCRUAlg>(pset);

    // VD CRP cold box channel map 
    } else if ( ( detectorName.find("dunevdcb") != std::string::npos ) ) {
      channelMap = std::make_unique<geo::ColdBoxChannelMapAlg>(pset);
      //channelMap = std::make_unique<geo::ChannelMapCRUAlg>(pset);

    // protoDUNE 6x6x6 dual phase
    } else if ( detectorName.find("protodunedphase") != std::string::npos ) {
      channelMap = std::make_unique<geo::ChannelMapCRMAlg>(pset);

    // 3x1x1 dual phase
    } else if ( detectorName.find("3x1x1dphase") != std::string::npos ) {
      channelMap = std::make_unique<geo::ChannelMapCRMAlg>(pset);

    // DUNE 34kt
    } else if ( ( detectorName.find("dune34kt") != std::string::npos )
             || ( detectorName.find("lbne34kt") != std::string::npos ) ) {
      channelMap = std::make_unique<geo::ChannelMapAPAAlg>(pset);

    // protoDUNE with arapucas
    } else if ( detectorName.find("protodunev7") != std::string::npos ) {
      channelMap = std::make_unique<geo::ProtoDUNEChannelMapAlgv7>(pset);

    // protoDUNE with arapucas and updated paddles
    } else if ( detectorName.find("protodunev8") != std::string::npos ) {
      channelMap = std::make_unique<geo::ProtoDUNEChannelMapAlgv8>(pset);

    // protoDUNE
    } else if ( ( detectorName.find("protodune") != std::string::npos )
             || ( detectorName.find("protolbne") != std::string::npos ) ) {
      channelMap = std::make_unique<geo::ProtoDUNEChannelMapAlg>(pset);

    // iceberg
    } else if ( detectorName.find("iceberg") != std::string::npos ) {
      channelMap = std::make_unique<geo::ProtoDUNEChannelMapAlg>(pset);

    // LArND
    } else if ( detectorName.find("larnd") != std::string::npos ) {
      channelMap = std::make_unique<geo::ChannelMapAPAAlg>(pset);
    }
    else {
      throw cet::exception("DUNEGeometryHelper") << "Unsupported detector: '" << detectorName << "'\n";
    }
  }

  if ( useApaMap ) {
    // Find the sorter.
    bool useApaSort = false;
    bool use35tSort = false;
    GeoObjectSorter* psort = nullptr;
    if ( fGeoSorterClass.size() ) {
      if ( fGeoSorterClass == "GeoObjectSorterAPA" ) {
        useApaSort = true;
      } else if ( fGeoSorterClass == "GeoObjectSorter35" ) {
        use35tSort = true;
      }
    } else {
      if ( is35t ) use35tSort = true;
      else useApaSort = true;
    }
    // Construct the sorter.
    if ( useApaSort ) {
      psort = new GeoObjectSorterAPA(pset);
    } else if ( use35tSort ) {
      psort = new GeoObjectSorter35(pset);
    }
    // Create channel map and set sorter.
    auto alg = new geo::DuneApaChannelMapAlg(pset);
    alg->setSorter(*psort);
    channelMap = std::unique_ptr<geo::DuneApaChannelMapAlg>(alg);
  }

  return channelMap;
}

Member Data Documentation

std::string dune::DUNEGeometryHelper::fChannelMapClass

private

Definition at line 42 of file DUNEGeometryHelper.h.

std::string dune::DUNEGeometryHelper::fGeoSorterClass

private

Definition at line 43 of file DUNEGeometryHelper.h.

---

The documentation for this class was generated from the following files:

• dunecore/dunecore/Geometry/DUNEGeometryHelper.h
• dunecore/dunecore/Geometry/DUNEGeometryHelper_service.cc