DumpChannelMap_module.cc

Go to the documentation of this file.

// LArSoft libraries
#include "larcoreobj/SimpleTypesAndConstants/RawTypes.h" // raw::ChannelID_t

// framework libraries
#include "fhiclcpp/ParameterSet.h"
#include "art/Framework/Core/EDAnalyzer.h"
#include "art/Framework/Core/ModuleMacros.h"

// C/C++ standard libraries
#include <string>

// ... more follow

namespace geo {
  class DumpChannelMap;
}

class geo::DumpChannelMap: public art::EDAnalyzer {
public:
  explicit DumpChannelMap(fhicl::ParameterSet const & p);

  // Plugins should not be copied or assigned.
  DumpChannelMap(DumpChannelMap const &) = delete;
  DumpChannelMap(DumpChannelMap &&) = delete;
  DumpChannelMap & operator = (DumpChannelMap const &) = delete;
  DumpChannelMap & operator = (DumpChannelMap &&) = delete;

  // Required functions
  virtual void analyze(art::Event const&) override {}
  
  virtual void beginRun(art::Run const&) override;
  
    private:
  
  std::string OutputCategory; 
  bool DoChannelToWires; 
  bool DoWireToChannel; 
  
  raw::ChannelID_t FirstChannel; 
  raw::ChannelID_t LastChannel; 
  
}; // geo::DumpChannelMap


//==============================================================================
//=== Algorithms declaration
//===

// LArSoft libraries
#include "larcoreobj/SimpleTypesAndConstants/RawTypes.h" // raw::ChannelID_t

// C/C++ standard libraries
#include <string>

// ... and more below...

namespace geo {
  class GeometryCore;
} // namespace geo

namespace {
  
  class DumpChannelToWires {
      public:
    
    DumpChannelToWires()
      : FirstChannel(raw::InvalidChannelID)
      , LastChannel(raw::InvalidChannelID)
      {}
    
    void Setup(geo::GeometryCore const& geometry)
      { pGeom = &geometry; }
    
    void SetLimits
      (raw::ChannelID_t first_channel, raw::ChannelID_t last_channel)
      { FirstChannel = first_channel; LastChannel = last_channel; }
    
    void Dump(std::string OutputCategory) const;
    
    
      protected:
    geo::GeometryCore const* pGeom = nullptr; 
    
    raw::ChannelID_t FirstChannel; 
    raw::ChannelID_t LastChannel; 
    
    void CheckConfig() const;
    
  }; // class DumpChannelToWires
  
  
  class DumpWireToChannel {
      public:
    
    DumpWireToChannel() {}
    
    void Setup(geo::GeometryCore const& geometry)
      { pGeom = &geometry; }
    
    void Dump(std::string OutputCategory) const;
    
    
      protected:
    geo::GeometryCore const* pGeom = nullptr; 
    
    void CheckConfig() const;
    
  }; // class DumpWireToChannel
  
  
} // local namespace


//==============================================================================
//=== Module implementation
//===

// LArSoft libraries
#include "larcoreobj/SimpleTypesAndConstants/RawTypes.h" // raw::ChannelID_t
#include "larcore/Geometry/Geometry.h"
#include "larcorealg/Geometry/GeometryCore.h"

// framework libraries
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"

// C/C++ standard libraries
#include <string>

// ... and more below ...

//------------------------------------------------------------------------------
geo::DumpChannelMap::DumpChannelMap(fhicl::ParameterSet const& p)
  : EDAnalyzer(p)
  , OutputCategory(p.get<std::string>   ("OutputCategory", "DumpChannelMap"))
  , DoChannelToWires(p.get<bool>        ("ChannelToWires", true))
  , DoWireToChannel(p.get<bool>         ("WireToChannel",  false))
  , FirstChannel(p.get<raw::ChannelID_t>("FirstChannel",   raw::InvalidChannelID))
  , LastChannel(p.get<raw::ChannelID_t> ("LastChannel",    raw::InvalidChannelID))
{
  
} // geo::DumpChannelMap::DumpChannelMap()

//------------------------------------------------------------------------------
void geo::DumpChannelMap::beginRun(art::Run const&) {
  
  geo::GeometryCore const& geom = *(art::ServiceHandle<geo::Geometry>());
  
  if (DoChannelToWires) {
    DumpChannelToWires dumper;
    dumper.Setup(geom);
    dumper.SetLimits(FirstChannel, LastChannel);
    dumper.Dump(OutputCategory);
  }
  
  if (DoWireToChannel) {
    DumpWireToChannel dumper;
    dumper.Setup(geom);
  //  dumper.SetLimits(FirstChannel, LastChannel);
    dumper.Dump(OutputCategory);
  }
  
} // geo::DumpChannelMap::beginRun()

//------------------------------------------------------------------------------
DEFINE_ART_MODULE(geo::DumpChannelMap)

//==============================================================================
//===  Algorithm implementation
//===

// LArSoft libraries
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h" // geo::WireID
#include "larcorealg/Geometry/GeometryCore.h"

// framework libraries
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "canvas/Utilities/Exception.h"

// C/C++ standard libraries
#include <vector>

//------------------------------------------------------------------------------
//--- DumpChannelToWires
//------------------------------------------------------------------------------
void DumpChannelToWires::CheckConfig() const {
  
  if (!pGeom) {
    throw art::Exception(art::errors::LogicError)
      << "DumpChannelToWires: no valid geometry available!";
  }
} // DumpChannelToWires::CheckConfig()

//------------------------------------------------------------------------------
void DumpChannelToWires::Dump(std::string OutputCategory) const {
  
  CheckConfig();
  
  unsigned int const NChannels = pGeom->Nchannels();
  
  if (NChannels == 0) {
    mf::LogError(OutputCategory)
      << "Nice detector we have here, with no channels.";
    return;
  }
  
  raw::ChannelID_t const PrintFirst
    = raw::isValidChannelID(FirstChannel)? FirstChannel: raw::ChannelID_t(0);
  raw::ChannelID_t const PrintLast
    = raw::isValidChannelID(LastChannel)? LastChannel: raw::ChannelID_t(NChannels-1);
  
  // print intro
  unsigned int const NPrintedChannels = (PrintLast - PrintFirst) + 1;
  if (NPrintedChannels == NChannels) {
    mf::LogInfo(OutputCategory) << "Printing all " << NChannels << " channels";
  }
  else {
    mf::LogInfo(OutputCategory) << "Printing channels from " << PrintFirst
      << " to " << LastChannel << " (" << NPrintedChannels
      << " channels out of " << NChannels << ")";
  }
  
  // print map
  mf::LogVerbatim log(OutputCategory);
  for (raw::ChannelID_t channel = PrintFirst; channel <= PrintLast; ++channel) {
    std::vector<geo::WireID> const Wires = pGeom->ChannelToWire(channel);
    
    log << "\n " << ((int) channel) << " ->";
    switch (Wires.size()) {
      case 0:  log << " no wires";                       break;
      case 1:                                            break;
      default: log << " [" << Wires.size() << " wires]"; break;
    } // switch
    
    for (geo::WireID const& wireID: Wires)
      log << " { " << std::string(wireID) << " };";
    
  } // for (channels)
  
} // DumpChannelToWires::Dump()

//------------------------------------------------------------------------------
//--- DumpWireToChannel
//------------------------------------------------------------------------------
void DumpWireToChannel::CheckConfig() const {
  
  if (!pGeom) {
    throw art::Exception(art::errors::LogicError)
      << "DumpWireToChannel: no valid geometry available!";
  }
} // DumpWireToChannel::CheckConfig()

//------------------------------------------------------------------------------
void DumpWireToChannel::Dump(std::string OutputCategory) const {
  
  CheckConfig();
  
  unsigned int const NChannels = pGeom->Nchannels();
  
  if (NChannels == 0) {
    mf::LogError(OutputCategory)
      << "Nice detector we have here, with no channels.";
    return;
  }
  
  // print intro
  mf::LogInfo(OutputCategory)
    << "Printing wire channels for up to " << NChannels << " channels";
  
  // print map
  mf::LogVerbatim log(OutputCategory);
  for (geo::WireID const& wireID: pGeom->IterateWireIDs()) {
    raw::ChannelID_t channel = pGeom->PlaneWireToChannel(wireID);
    log << "\n { " << std::string(wireID) << " } => ";
    if (raw::isValidChannelID(channel)) log << channel;
    else                                log << "invalid!";
  } // for
  
} // DumpWireToChannel::Dump()


//==============================================================================