DetectorActivityRatePlots.cpp File Reference

Draws some plots of detector activity with time. For simulation. More...

#include "Binner.h"
#include "icarusalg/Utilities/ROOTutils.h"
#include "icarusalg/gallery/helpers/C++/expandInputFiles.h"
#include "lardataobj/Simulation/SimChannel.h"
#include "lardataobj/Simulation/SimPhotons.h"
#include "lardataobj/Simulation/SimEnergyDeposit.h"
#include "lardataalg/DetectorInfo/DetectorPropertiesStandardTestHelpers.h"
#include "lardataalg/DetectorInfo/DetectorPropertiesStandard.h"
#include "lardataalg/DetectorInfo/DetectorPropertiesData.h"
#include "lardataalg/DetectorInfo/DetectorClocksStandardTestHelpers.h"
#include "lardataalg/DetectorInfo/DetectorClocksStandard.h"
#include "lardataalg/DetectorInfo/DetectorClocksStandardDataFor.h"
#include "lardataalg/DetectorInfo/DetectorClocksData.h"
#include "lardataalg/DetectorInfo/LArPropertiesStandardTestHelpers.h"
#include "lardataalg/DetectorInfo/LArPropertiesStandard.h"
#include "icarusalg/Geometry/ICARUSChannelMapAlg.h"
#include "larcorealg/Geometry/StandaloneGeometrySetup.h"
#include "larcorealg/Geometry/GeometryCore.h"
#include "larcorealg/Geometry/StandaloneBasicSetup.h"
#include "lardataalg/DetectorInfo/DetectorTimings.h"
#include "lardataalg/DetectorInfo/DetectorTimingTypes.h"
#include "lardataalg/Utilities/StatCollector.h"
#include "lardataalg/Utilities/intervals_fhicl.h"
#include "lardataalg/Utilities/quantities/energy.h"
#include "lardataalg/Utilities/quantities/electronics.h"
#include "lardataalg/Utilities/quantities/spacetime.h"
#include "larcorealg/CoreUtils/enumerate.h"
#include "gallery/Event.h"
#include "canvas/Utilities/InputTag.h"
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "fhiclcpp/types/Table.h"
#include "fhiclcpp/types/Atom.h"
#include "fhiclcpp/ParameterSet.h"
#include "TFile.h"
#include "TDirectory.h"
#include "TProfile.h"
#include <algorithm>
#include <vector>
#include <array>
#include <memory>
#include <iostream>
#include <limits>
#include <cmath>
#include <iterator>

Go to the source code of this file.

Classes
class	PlotDetectorActivityRates
	Produces plots. Aaah! More...
struct	PlotDetectorActivityRates::AlgorithmConfiguration
	Data structure with all the configuration. More...
struct	PlotDetectorActivityRates::AlgorithmConfiguration::BinConfig< Point >
struct	PlotDetectorActivityRates::FHiCLconfig
struct	PlotDetectorActivityRates::FHiCLconfig::BinningConfig< Point, Interval >

Functions
int	makePlots (std::string const &configFile, std::vector< std::string > const &inputFiles)
	Runs the analysis macro. More...
int	makePlots (std::string const &configFile, std::string filename)
	Version with a single input file. More...
int	main (int argc, char **argv)

Detailed Description

Draws some plots of detector activity with time. For simulation.

Author

Gianluca Petrillo (petri.nosp@m.llo@.nosp@m.fnal..nosp@m.gov)

Date

October 13, 2020

The configuration requires:

• services table with Geometry, LArPropertiesService, DetectorClocksService and DetectorPropertiesService
• analysis table configuring the job

Definition in file DetectorActivityRatePlots.cpp.

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 996 of file DetectorActivityRatePlots.cpp.

                                {
  
  char **pParam = argv + 1, **pend = argv + argc;
  if (pParam == pend) {
    std::cerr << "Usage: " << argv[0] << "  configFile [inputFile ...]"
      << std::endl;
    PlotDetectorActivityRates::printConfigurationHelp(std::cerr);
    return 1;
  }
  std::string const configFile = *(pParam++);
  std::vector<std::string> fileNames;
  std::copy(pParam, pend, std::back_inserter(fileNames));
  
  return makePlots(configFile, fileNames);
} // main()

int makePlots	(	std::string const &	configFile,
		std::vector< std::string > const &	inputFiles
	)

Runs the analysis macro.

Parameters

configFile	path to the FHiCL configuration to be used for the services
inputFiles	vector of path of file names

Returns

an integer as exit code (0 means success)

Definition at line 846 of file DetectorActivityRatePlots.cpp.

{
  /*
   * the "test" environment configuration
   */
  // read FHiCL configuration from a configuration file:
  fhicl::ParameterSet config = lar::standalone::ParseConfiguration(configFile);

  // set up message facility (always picked from "services.message")
  lar::standalone::SetupMessageFacility(config, "");

  // ***************************************************************************
  // ***  SERVICE PROVIDER SETUP BEGIN  ****************************************
  // ***************************************************************************
  //
  // Uncomment the things you need
  // (and make sure the corresponding headers are also uncommented)
  //
  // geometry setup (it's special)
  auto geom = lar::standalone::SetupGeometry<icarus::ICARUSChannelMapAlg>
    (config.get<fhicl::ParameterSet>("services.Geometry"));

  // LArProperties setup
  auto larProp = testing::setupProvider<detinfo::LArPropertiesStandard>
    (config.get<fhicl::ParameterSet>("services.LArPropertiesService"));

  // DetectorClocks setup
  auto detClocks = testing::setupProvider<detinfo::DetectorClocksStandard>
    (config.get<fhicl::ParameterSet>("services.DetectorClocksService"));

  // DetectorProperties setup
  auto detProps = testing::setupProvider<detinfo::DetectorPropertiesStandard>(
    config.get<fhicl::ParameterSet>("services.DetectorPropertiesService"),
    detinfo::DetectorPropertiesStandard::providers_type{geom.get(),larProp.get()}
//     { geom.get(), larProp.get() } // FIXME try this simpler version
    );

  // ***************************************************************************
  // ***  SERVICE PROVIDER SETUP END    ****************************************
  // ***************************************************************************

  auto const& analysisConfig = config.get<fhicl::ParameterSet>("analysis");
  
  // event loop options
  constexpr auto NoLimits = std::numeric_limits<unsigned int>::max();
  unsigned int nSkip = analysisConfig.get("skipEvents", 0U);
  unsigned int const maxEvents = analysisConfig.get("maxEvents", NoLimits);

  /*
   * the preparation of input file list
   */
  if (inputFiles.size() != 1) {
    throw std::runtime_error("Support for multiple input files not implemented yet!");
  }
  std::vector<std::string> const allInputFiles = expandInputFiles(inputFiles);

  /*
   * other parameters
   */

  /*
   * preparation of histogram output file
   */
  std::unique_ptr<TFile> pHistFile;
  if (analysisConfig.has_key("histogramFile")) {
    std::string fileName = analysisConfig.get<std::string>("histogramFile");
    mf::LogVerbatim("makePlots")
      << "Creating output file: '" << fileName << "'" << std::endl;
    pHistFile = std::make_unique<TFile>(fileName.c_str(), "RECREATE");
  }

  /*
   * preparation of the algorithm class
   */
  
  // configuration from `ConfigurationKey` table of configuration file:
  PlotDetectorActivityRates plotAlg {
    analysisConfig.get<fhicl::ParameterSet>
      (PlotDetectorActivityRates::ConfigurationKey)
    };
  
  plotAlg.printConfig(mf::LogVerbatim{"makePlots"});
  
  {
    auto clocksData = detClocks->DataForJob();
    plotAlg.setup
      (pHistFile.get(), std::move(clocksData), detProps->DataFor(clocksData));
  }
  plotAlg.printTimingSummary(mf::LogVerbatim{"makePlots"});
  
  plotAlg.prepare();
  
  /*
  auto const clock_data = detclk->DataForJob();
  auto const det_prop_data = detp->DataFor(clock_data);
  */
  
  unsigned int numEvents { 0U };

  /*
   * the event loop
   */
  for (gallery::Event event(allInputFiles); !event.atEnd(); event.next()) {
    
    if (nSkip > 0) { --nSkip; continue; }
    if (numEvents >= maxEvents) {
      mf::LogVerbatim("makePlots") << "Maximum number of events reached.";
      break;
    }
    
    // *************************************************************************
    // ***  SINGLE EVENT PROCESSING BEGIN  *************************************
    // *************************************************************************

    ++numEvents;
    {
      mf::LogVerbatim log("makePlots");
      log << "This is event " << event.fileEntry() << "-" << event.eventEntry()
        << " (" << numEvents;
      if (maxEvents < NoLimits) log << "/" << maxEvents;
      log << ")";
    }
    
    {
      auto clocksData
        = detinfo::detectorClocksStandardDataFor(*detClocks, event);
      plotAlg.setupEvent(std::move(clocksData), detProps->DataFor(clocksData));
    }
    
    plotAlg.plotEvent(event);
    

    // *************************************************************************
    // ***  SINGLE EVENT PROCESSING END    *************************************
    // *************************************************************************

  } // for

  plotAlg.finish();
  plotAlg.printTimingSummary(mf::LogVerbatim{"makePlots"} << "Once again:\n");
  
  return 0;
} // makePlots()

int makePlots	(	std::string const &	configFile,
		std::string	filename
	)

Version with a single input file.

Definition at line 992 of file DetectorActivityRatePlots.cpp.

  { return makePlots(configFile, std::vector<std::string>{ filename }); }