HotMapMaker_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// Class:       HotMapMaker
// Module Type: analyzer
// File:        HotMapMaker_module.cc
//
// Generated at Fri Feb 24 17:38:07 2017 by Andrey Sheshukov using artmod
// from cetpkgsupport v1_10_02.
////////////////////////////////////////////////////////////////////////

#include "art/Framework/Core/EDAnalyzer.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.h"
#include "art/Framework/Principal/Run.h"
#include "art/Framework/Principal/SubRun.h"
#include "canvas/Utilities/InputTag.h"
#include "fhiclcpp/ParameterSet.h"
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "DDTBaseDataProducts/HitList.h"
#include "OnlineCalibration/HitMap.h"
#include "OnlineCalibration/FileWatcher.h"
#include <NovaTimingUtilities/TimingUtilities.h>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <sstream>


namespace novaddt {
  class HotMapMaker;
}

class novaddt::HotMapMaker : public art::EDAnalyzer{
public:
  explicit HotMapMaker(fhicl::ParameterSet const & p);
  // The destructor generated by the compiler is fine for classes
  // without bare pointers or other resource use.

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

  // Required functions.
  void analyze(art::Event const & e) override;
  void endJob(){ SaveMaps(); }

  void saveMapTo(const novaddt::calib::FDHitMap& map, std::string filename);
  void saveMetaData(std::string filename);
  calib::FDHitMap MakeMask();
  void AppendHot();
  void AppendCold();
  void AppendRate();
  void SaveMaps();
  void ResetMaps();

private:

  // Declare member data here.
    novaddt::calib::FDHitMap fShortMap;// hit rate per 5ms, collected over fEventsToCollect
    novaddt::calib::FDHitMap fRateMap; // cumulative hit rate/5ms
    novaddt::calib::FDHitMap fHotMap;  // maximum of short rate maps
    novaddt::calib::FDHitMap fColdMap; // count number of windows when channel was cold
 //   novaddt::calib::FDHitMap fMaskMap; // final product

    //configuration parameters
    art::InputTag fHitsTag; //where to read the hits for noise activity
    uint32_t fWindowSize;
    double fColdLevel;
    //thresholds to define channels
    double fColdThreshold;
    double fHotThreshold;
    std::string fHotOutput; //where to write map
    std::string fColdOutput; //where to write map
    std::string fRateOutput; //where to write map
    std::string fMetaOutput; //where to write metadata
    std::string fMaskOutput; //where to write mask

    std::string fWatchFile; //a file to signalize that the map should be updated
    //state
    FileWatcher fFileWatcher;
    uint32_t fEventsCount=0;
    uint32_t fMapsCount=0;
    //metadata
    novaddt::TDC fTimeStart;
    novaddt::TDC fTimeEnd;
    uint32_t fEventsTotal=0;
    
};


novaddt::HotMapMaker::HotMapMaker(fhicl::ParameterSet const & p):
  EDAnalyzer(p),
  fHitsTag(p.get<std::string>("hits_tag")),
  fWindowSize   (p.get<uint32_t>("window_size")),
  fColdLevel    (p.get<double>("cold_level")),
  fColdThreshold(p.get<double>("thresholds.cold")),
  fHotThreshold (p.get<double>("thresholds.hot")),
  fHotOutput (p.get<std::string>("output.hot", "")),
  fColdOutput(p.get<std::string>("output.cold","")),
  fRateOutput(p.get<std::string>("output.rate","")),
  fMetaOutput(p.get<std::string>("output.metadata","")),
  fMaskOutput(p.get<std::string>("output.mask","")),
  fWatchFile (p.get<std::string>("watch")),
  fFileWatcher(fWatchFile)
{
    mf::SetModuleName("HotMapMaker");
    mf::LogInfo("Configuration")<<"input_hits:\""<<fHitsTag
        <<"\n* Mask Output: "<<fMaskOutput
        <<"\n* Cold Output: "<<fColdOutput
        <<"\n* Hot Output: "<<fHotOutput
        <<"\n* Rate Output: "<<fRateOutput
        <<"\n* Metadata Output: "<<fMetaOutput
        <<"\nWatch file: "<<fWatchFile
        <<"\nEvents to collect: "<<fWindowSize
        <<std::endl;

        fShortMap.reset();
        ResetMaps();
}
void novaddt::HotMapMaker::AppendHot(){
    std::transform(fHotMap.data.begin(),fHotMap.data.end(),
                   fShortMap.data.begin(),fHotMap.data.begin(),
                   [](double a, double b){return std::max(a,b);}
                   );
}

void novaddt::HotMapMaker::AppendCold(){
    auto clevel=fColdLevel;
    std::transform(fColdMap.data.begin(),fColdMap.data.end(),
                   fShortMap.data.begin(),fColdMap.data.begin(),
                   [clevel](double a, double b){return a+(b<=clevel);}
                   );
}

void novaddt::HotMapMaker::AppendRate(){
    std::cout<<"ShortMap max="<<*std::max_element(fShortMap.data.begin(),fShortMap.data.end())<<std::endl;
    std::transform(fRateMap.data.begin(),fRateMap.data.end(),
                   fShortMap.data.begin(),fRateMap.data.begin(),
                   [](double a, double b){return a+b;}
                   );
    std::cout<<"HotMap max="<<*std::max_element(fHotMap.data.begin(),fHotMap.data.end())<<std::endl;
}

void novaddt::HotMapMaker::analyze(art::Event const & e)
{
    //get the hits which we'll use to fill the map
    auto hits=e.getValidHandle<novaddt::HitList>(fHitsTag);
    //fill the metadata
    if(fEventsCount==0)
        fTimeStart=hits->front().TDC();

    //fill the map
    for(const auto &hit: *hits) fShortMap[hit]+=1;
    //Increment events counter
    if(++fEventsCount>=fWindowSize){
        //normalize the map to 1 event
        mf::LogInfo("Progress")<<"Appending hit map with "
                               <<fEventsCount<<" events"<<std::endl;
        fShortMap.Scale(1./fEventsCount);
        AppendHot();
        AppendCold();
        AppendRate();
        fShortMap.reset();
        fEventsTotal+=fEventsCount;
        ++fMapsCount;
        fEventsCount=0;
    }

    //check if we should do the rollover
    if(fFileWatcher.isModified()){
        //fill the metadata
        fTimeEnd=hits->back().TDC();
        SaveMaps();
        ResetMaps();
        fFileWatcher.update();
        fMapsCount=0;
        fEventsTotal=0;
    }
}


novaddt::calib::FDHitMap novaddt::HotMapMaker::MakeMask()
{
    mf::LogInfo("MapRollover")<<" preparing the mask"<<std::endl;
    novaddt::calib::FDHitMap mask;
    //combine the mask from Hot and Cold maps:
    double c_thresh=fColdThreshold;
    double h_thresh=fHotThreshold;

    std::transform(fColdMap.data.begin(),fColdMap.data.end(),
                   fHotMap.data.begin(),mask.data.begin(),
                   [c_thresh,h_thresh](double a, double b){return 1*(a>=c_thresh)+2*(b>=h_thresh);}
                   );

    return mask;
}

void novaddt::HotMapMaker::ResetMaps()
{
    fHotMap.reset();
    fColdMap.reset();
    fRateMap.reset();
}
void novaddt::HotMapMaker::SaveMaps()
{
    //normalize the maps
    fRateMap.Scale(1./fMapsCount);
    fColdMap.Scale(1./fMapsCount);
    saveMapTo(MakeMask(),fMaskOutput);
    if(!fMaskOutput.empty()) saveMapTo(MakeMask(),fMaskOutput);
    if(!fHotOutput.empty())  saveMapTo(fHotMap,fHotOutput);
    if(!fColdOutput.empty()) saveMapTo(fColdMap,fColdOutput);
    if(!fRateOutput.empty()) saveMapTo(fRateMap,fRateOutput);
    if(!fMetaOutput.empty()) saveMetaData(fMetaOutput);

}
void novaddt::HotMapMaker::saveMapTo(const novaddt::calib::FDHitMap& map,std::string fname){
    mf::LogInfo("Progress")<<"Saving map to file:"<<fname <<std::endl;
    //save map to the file
    std::ofstream s(fname.data(),std::ofstream::binary);
    s<<map;
}

void novaddt::HotMapMaker::saveMetaData(std::string fname){
    mf::LogInfo("Progress")<<"Saving metadata to file:"<<fname <<std::endl;
    namespace pt = boost::property_tree;
    pt::ptree tree;
    tree.put("window_size", fWindowSize);
    tree.put("count.maps", fMapsCount);
    tree.put("count.events", fEventsTotal);
    tree.put("time.start",fTimeStart.val);
    tree.put("time.end",  fTimeEnd.val);
    tree.put("thresholds.cold", fColdThreshold);
    tree.put("thresholds.hot", fHotThreshold);
    tree.put("cold_level", fColdLevel);
    pt::write_json(fname,tree);
}
DEFINE_ART_MODULE(novaddt::HotMapMaker)