IdenticalSlicerAna_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// \file    IdenticalSlicerAna.cxx
// \brief   Module to make sure physics slices of two slicers are identical 
// \author  rocco 
// \date    5/17/2013
////////////////////////////////////////////////////////////////////////

// C/C++ includes
#include <cmath>
#include <iostream>
#include <map>
#include <vector>

// ROOT includes
#include "TTree.h"
#include "TH1F.h"
#include "TH2F.h"

// Framework includes
#include "art/Framework/Core/EDAnalyzer.h"
#include "canvas/Persistency/Common/FindManyP.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.h"
#include "art/Framework/Services/Optional/TFileDirectory.h"
#include "art/Framework/Services/Optional/TFileService.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Persistency/Common/PtrVector.h"
#include "fhiclcpp/ParameterSet.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

// NOvASoft includes
#include "RecoBase/CellHit.h"
#include "RecoBase/Cluster.h"
#include "Utilities/AssociationUtil.h"






// IdenticalSlicerAna header
namespace slicer {
  class IdenticalSlicerAna : public art::EDAnalyzer {
  public:
    explicit IdenticalSlicerAna(fhicl::ParameterSet const& pset);    
    ~IdenticalSlicerAna();                        
    
    void analyze(const art::Event& evt); 
    void reconfigure(const fhicl::ParameterSet& pset);
    
  private:
    std::string   fCellHitInput;
    std::string   fOldSlicerLabel;
    std::string   fNewSlicerLabel;
    
    
  };
}



namespace slicer
{
  //.......................................................................
  IdenticalSlicerAna::IdenticalSlicerAna(fhicl::ParameterSet const& pset) 
    : EDAnalyzer(pset)
  {
    this->reconfigure(pset);
  }

  //......................................................................
  IdenticalSlicerAna::~IdenticalSlicerAna()
  {
    //======================================================================
    // Clean up any memory allocated by your module
    //======================================================================
  }

  //......................................................................
  void IdenticalSlicerAna::reconfigure(const fhicl::ParameterSet& pset)
  {
    fCellHitInput   = pset.get< std::string> ("CellHitInput");
    fOldSlicerLabel = pset.get<std::string>  ("OldSlicerLabel");
    fNewSlicerLabel = pset.get<std::string>  ("NewSlicerLabel");
  }
      


  //......................................................................
  void IdenticalSlicerAna::analyze(const art::Event& evt)
  {

    // Get the hits from calhit
    art::Handle< std::vector<rb::CellHit> > hitcol;
    evt.getByLabel(fCellHitInput, hitcol);
    
    // make a vector
    std::vector<art::Ptr<rb::CellHit > > hitlist;
    for(unsigned int i = 0; i < hitcol->size(); ++i){
      art::Ptr<rb::CellHit> hit(hitcol, i);
      hitlist.push_back(hit);
    }
    
    // get the old slices
    art::Handle< std::vector< rb::Cluster > > oldSlicesHandle;
    evt.getByLabel(fOldSlicerLabel, oldSlicesHandle);
    std::vector< rb::Cluster > oldSlices = *oldSlicesHandle;
    
    art::Handle< std::vector< rb::Cluster > > newSlicesHandle;
    evt.getByLabel(fNewSlicerLabel, newSlicesHandle);
    std::vector< rb::Cluster > newSlices = *newSlicesHandle;
    
    // make sure both have 
    assert(newSlices.size() == oldSlices.size());
    
    for(size_t iSlc = 0; iSlc < oldSlices.size(); ++iSlc){
      if(!newSlices[iSlc].IsNoise())
      {
        assert(newSlices[iSlc].NCell() == oldSlices[iSlc].NCell());
        
        for(size_t iHit = 0; iHit < oldSlices[iSlc].NCell(); ++iHit){
          assert(*oldSlices[iSlc].Cell(iHit) == *newSlices[iSlc].Cell(iHit));
        }
        
        
      }
    }
    
    
    
    // make sure that all cell hits in the new slices are unique 
    // first check output from calhit
    for(size_t i = 0; i< hitlist.size(); ++i)
    {
      for(size_t j = 0; j< hitlist.size(); ++j)
      {
        if(i != j){
          assert(!(*(hitlist[i]) == *(hitlist[j])) && " CalHits are not unique!");
        }    
      }  
    }
  
    
    for (auto it = newSlices.begin(); it != newSlices.end(); ++it) 
    {
      
      art::PtrVector< rb::CellHit > cells = it->AllCells();
      for(size_t i = 0; i < cells.size(); ++i)
      {
        for(size_t j = 0; j < cells.size(); ++j)
        {
          if(i != j){
            if(*(cells[i]) == *(cells[j]))
            {
              std::cout << i << "   " << cells[i]->Cell() << "  " <<  cells[i]->Plane() << "  " << 
                cells[i]->PE() << "  " <<  cells[i]->TDC() << std::endl;

              std::cout << j << "   " << cells[j]->Cell() << "  " <<  cells[j]->Plane() << "  " << 
                cells[j]->PE() << "  " <<  cells[j]->TDC() << std::endl;
              
            }
            assert(!(*(cells[i]) == *(cells[j])) && " Cells are not unique");
          }
        }
        
      }
      
      
    }
    
    std::cout << " slices are idential " << std::endl;
    
    return;
  }

  
  
 

} // end namespace slicer
////////////////////////////////////////////////////////////////////////



#include "art/Framework/Core/ModuleMacros.h"

namespace slicer
{
  DEFINE_ART_MODULE(IdenticalSlicerAna)
}