df/dd7/recoBSVTagInfoValidationAnalyzer_8cc_source.html

 #include <map>

 #include <string>

 #include <cmath>

 #include <Math/Functions.h>

 #include <Math/SVector.h>

 #include <Math/SMatrix.h>

 #include "TH1F.h"

 #include "TH1D.h"

 #include "TH2D.h"

 #include "TMath.h"

 #include "DataFormats/BTauReco/interface/SecondaryVertexTagInfo.h"


 #include "FWCore/Framework/interface/Frameworkfwd.h"

 #include "FWCore/Framework/interface/EDAnalyzer.h"

 #include "FWCore/Framework/interface/MakerMacros.h"

 #include "FWCore/ParameterSet/interface/ParameterSet.h"

 #include "FWCore/ServiceRegistry/interface/Service.h"

 #include "DQMServices/Core/interface/DQMStore.h"

 #include "DQMServices/Core/interface/MonitorElement.h"


 #include "SimTracker/TrackHistory/interface/VertexClassifierByProxy.h"

 #include "CommonTools/Statistics/interface/ChiSquaredProbability.h"

 #include "DataFormats/Math/interface/Vector.h"

 #include "TROOT.h"

 #include "Math/VectorUtil.h"

 #include <TVector3.h>

 #include <Math/GenVector/PxPyPzE4D.h>

 #include <Math/GenVector/PxPyPzM4D.h>

 #include "DataFormats/Math/interface/LorentzVector.h"

 //

 // class decleration

 //

 using namespace reco;

 using namespace std;

 using namespace edm;


 class recoBSVTagInfoValidationAnalyzer : public edm::EDAnalyzer

 {


 public:


     explicit recoBSVTagInfoValidationAnalyzer(const edm::ParameterSet&);


 private:


     virtual void analyze(const edm::Event&, const edm::EventSetup&);

     virtual void endJob() ;

     // Member data


     VertexClassifierByProxy<reco::SecondaryVertexTagInfoCollection> classifier_;


     Int_t numberVertexClassifier_;

     edm::InputTag trackingTruth_;

     edm::InputTag svTagInfoProducer_;


     DQMStore * dqmStore_;

     std::string dqmLabel;


     Int_t n_event;

     Int_t rs_total_nall ;

     Int_t rs_total_nsv ;

     Int_t rs_total_nbv ;

     Int_t rs_total_nbsv ;

     Int_t rs_total_ncv ;

     Int_t rs_total_nlv ;

     Int_t total_nfake ;


     Int_t sr_total_nall ;

     Int_t sr_total_nsv ;

     Int_t sr_total_nbv ;

     Int_t sr_total_nbsv ;

     Int_t sr_total_ncv ;

     Int_t sr_total_nlv ;

     Int_t total_nmiss ;


   // Bookeeping of all the histograms per category

   void bookRecoToSim(std::string const &);

     void bookSimToReco(std::string const &);


     // Fill all histogram per category

     void fillRecoToSim(std::string const &, reco::Vertex const &, TrackingVertexRef const &);

     void fillSimToReco(std::string const &, reco::VertexBaseRef const &, TrackingVertexRef const &);


     // Histogram handlers

     std::map<std::string, MonitorElement *> HistIndex_;


 };


 recoBSVTagInfoValidationAnalyzer::recoBSVTagInfoValidationAnalyzer(const edm::ParameterSet& config) : classifier_(config)

 {

   //Initialize counters

     n_event = 0;

     rs_total_nall = 0;

     rs_total_nsv = 0;

     rs_total_nbv = 0;

     rs_total_nbsv = 0;

     rs_total_ncv = 0;

     rs_total_nlv = 0;

     total_nfake = 0;


     sr_total_nall = 0;

     sr_total_nsv = 0;

     sr_total_nbv = 0;

     sr_total_nbsv = 0;

     sr_total_ncv = 0;

     sr_total_nlv = 0;

     total_nmiss = 0;


       //  get the store

     dqmStore_ = edm::Service<DQMStore>().operator->();

     dqmLabel = "SVValidation/";

     dqmStore_->setCurrentFolder(dqmLabel);


     // Get the track collection

     svTagInfoProducer_ = config.getUntrackedParameter<edm::InputTag> ( "svTagInfoProducer" );


     // Name of the traking pariticle collection

     trackingTruth_ = config.getUntrackedParameter<edm::InputTag> ( "trackingTruth" );


     // Number of track categories

     numberVertexClassifier_ = VertexCategories::Unknown+1;


     // Define histogram for counting categories

     HistIndex_["VertexClassifier"] = dqmStore_->book1D(

                                         "VertexClassifier",

                                         "Frequency for the different track categories",

                                         numberVertexClassifier_,

                                         -0.5,

                                         numberVertexClassifier_ - 0.5

                                     );


     //--- RecoToSim

     HistIndex_["rs_All_MatchQuality"]= dqmStore_->book1D( "rs_All_MatchQuality", "Quality of Match", 51, -0.01, 1.01 );

     HistIndex_["rs_All_FlightDistance2d"]= dqmStore_->book1D( "rs_All_FlightDistance2d", "Transverse flight distance [cm]", 100, 0, 5 );

     HistIndex_["rs_SecondaryVertex_FlightDistance2d"]= dqmStore_->book1D( "rs_SecondaryVertex_FlightDistance2d", "Transverse flight distance [cm]", 100, 0, 5 );

     HistIndex_["rs_BSV_FlightDistance2d"]= dqmStore_->book1D( "rs_BSV_FlightDistance2d", "Transverse flight distance [cm]", 100, 0, 5 );

     HistIndex_["rs_BWeakDecay_FlightDistance2d"]= dqmStore_->book1D( "rs_BWeakDecay_FlightDistance2d", "Transverse flight distance [cm]", 100, 0, 5 );

     HistIndex_["rs_CWeakDecay_FlightDistance2d"]= dqmStore_->book1D( "rs_CWeakDecay_FlightDistance2d", "Transverse flight distance [cm]", 100, 0, 5 );

     HistIndex_["rs_Light_FlightDistance2d"]= dqmStore_->book1D( "rs_Light_FlightDistance2d", "Transverse flight distance [cm]", 100, 0, 5 );


     HistIndex_["rs_All_nRecVtx"]= dqmStore_->book1D( "rs_All_nRecVtx", "Number of Vertices per event", 11, -0.5, 10.5 );

     HistIndex_["rs_SecondaryVertex_nRecVtx"]= dqmStore_->book1D( "rs_SecondaryVertex_nRecVtx", "Number of Vertices per event", 11, -0.5, 10.5 );

     HistIndex_["rs_BSV_nRecVtx"]= dqmStore_->book1D( "rs_BSV_nRecVtx", "Number of Vertices per event", 11, -0.5, 10.5 );

     HistIndex_["rs_BWeakDecay_nRecVtx"]= dqmStore_->book1D( "rs_BWeakDecay_nRecVtx", "Number of Vertices per event", 11, -0.5, 10.5 );

     HistIndex_["rs_CWeakDecay_nRecVtx"]= dqmStore_->book1D( "rs_CWeakDecay_nRecVtx", "Number of Vertices per event", 11, -0.5, 10.5 );

     HistIndex_["rs_Light_nRecVtx"]= dqmStore_->book1D( "rs_Light_nRecVtx", "Number of Vertices per event", 11, -0.5, 10.5 );


     //--- SimToReco

     HistIndex_["sr_All_MatchQuality"]= dqmStore_->book1D( "sr_All_MatchQuality", "Quality of Match", 51, -0.01, 1.01 );

     HistIndex_["sr_All_nRecVtx"]= dqmStore_->book1D( "sr_All_nRecVtx", "Number of Vertices per event", 11, -0.5, 10.5 );

     HistIndex_["sr_SecondaryVertex_nRecVtx"]= dqmStore_->book1D( "sr_SecondaryVertex_nRecVtx", "Number of Vertices per event", 11, -0.5, 10.5 );

     HistIndex_["sr_BSV_nRecVtx"]= dqmStore_->book1D( "sr_BSV_nRecVtx", "Number of Vertices per event", 11, -0.5, 10.5 );

     HistIndex_["sr_BWeakDecay_nRecVtx"]= dqmStore_->book1D( "sr_BWeakDecay_nRecVtx", "Number of Vertices per event", 11, -0.5, 10.5 );

     HistIndex_["sr_CWeakDecay_nRecVtx"]= dqmStore_->book1D( "sr_CWeakDecay_nRecVtx", "Number of Vertices per event", 11, -0.5, 10.5 );

     HistIndex_["sr_Light_nRecVtx"]= dqmStore_->book1D( "sr_Light_nRecVtx", "Number of Vertices per event", 11, -0.5, 10.5 );


     // Set the proper categories names

     for (Int_t i = 0; i < numberVertexClassifier_; ++i)

       HistIndex_["VertexClassifier"]->getTH1F()->GetXaxis()->SetBinLabel(i+1, VertexCategories::Names[i]);


     // book histograms

     bookRecoToSim("rs_All");

     bookRecoToSim("rs_SecondaryVertex");

     bookRecoToSim("rs_BSV");

     bookRecoToSim("rs_BWeakDecay");

     bookRecoToSim("rs_CWeakDecay");

     bookRecoToSim("rs_Light");


     bookSimToReco("sr_All");

     bookSimToReco("sr_SecondaryVertex");

     bookSimToReco("sr_BSV");

     bookSimToReco("sr_BWeakDecay");

     bookSimToReco("sr_CWeakDecay");

     bookSimToReco("sr_Light");

 }


 void recoBSVTagInfoValidationAnalyzer::analyze(const edm::Event& event, const edm::EventSetup& setup)

 {

   ++n_event;


   std::cout << "*** Analyzing " << event.id() << " n_event = " << n_event << std::endl << std::endl;


   // Set the classifier for a new event

   classifier_.newEvent(event, setup);


   // Vertex collection

   edm::Handle<reco::SecondaryVertexTagInfoCollection> svTagInfoCollection;

   event.getByLabel(svTagInfoProducer_, svTagInfoCollection);


   // Get a constant reference to the track history associated to the classifier

   VertexHistory const & tracer = classifier_.history();


   cout << "* Event " << n_event << " ; svTagInfoCollection->size() = " << svTagInfoCollection->size() << endl;


   int rs_nall = 0;

   int rs_nsv = 0;

   int rs_nbv = 0;

   int rs_nbsv = 0;

   int rs_ncv = 0;

   int rs_nlv = 0;

   int nfake = 0;


   int sr_nall = 0;

   int sr_nsv = 0;

   int sr_nbv = 0;

   int sr_nbsv = 0;

   int sr_ncv = 0;

   int sr_nlv = 0;

   int nmiss = 0;


   // Loop over the svTagInfo collection.

   for (std::size_t index = 0; index < svTagInfoCollection->size(); ++index){


     reco::SecondaryVertexTagInfoRef svTagInfo(svTagInfoCollection, index);


     // Loop over the vertexes in svTagInfo

     for ( std::size_t vindex = 0; vindex < svTagInfo->nVertices(); ++vindex ){


       // Classify the vertices

       classifier_.evaluate(svTagInfo, vindex);


       //quality of the match

       double rs_quality = tracer.quality();


       // Fill the histogram with the categories

       for (Int_t i = 0; i != numberVertexClassifier_; ++i) {


     if ( classifier_.is( (VertexCategories::Category) i ) ) {


       HistIndex_["VertexClassifier"]->Fill(i);

     }

       }

       if ( !classifier_.is(VertexCategories::Fake) ) {


         HistIndex_["rs_All_MatchQuality"]->Fill( rs_quality );

     fillRecoToSim("rs_All", svTagInfo->secondaryVertex(vindex), tracer.simVertex());

     HistIndex_["rs_All_FlightDistance2d"]->Fill( svTagInfo->flightDistance( vindex, true ).value() );

         rs_nall++;


     if ( classifier_.is(VertexCategories::SecondaryVertex) ) {


       fillRecoToSim("rs_SecondaryVertex", svTagInfo->secondaryVertex(vindex), tracer.simVertex());

       HistIndex_["rs_SecondaryVertex_FlightDistance2d"]->Fill( svTagInfo->flightDistance( vindex, true ).value() );

           rs_nsv++;

     }


     if ( classifier_.is(VertexCategories::BWeakDecay) ) {


       fillRecoToSim("rs_BWeakDecay", svTagInfo->secondaryVertex(vindex), tracer.simVertex());

       HistIndex_["rs_BWeakDecay_FlightDistance2d"]->Fill( svTagInfo->flightDistance( vindex, true ).value() );

           rs_nbv++;


           if ( classifier_.is(VertexCategories::SecondaryVertex) ) {


         fillRecoToSim("rs_BSV", svTagInfo->secondaryVertex(vindex), tracer.simVertex());

             HistIndex_["rs_BSV_FlightDistance2d"]->Fill( svTagInfo->flightDistance( vindex, true ).value() );

         rs_nbsv++;


           }

     }//BWeakDecay


     else if ( classifier_.is(VertexCategories::CWeakDecay) ) {


       fillRecoToSim("rs_CWeakDecay", svTagInfo->secondaryVertex(vindex), tracer.simVertex());

       HistIndex_["rs_CWeakDecay_FlightDistance2d"]->Fill( svTagInfo->flightDistance( vindex, true ).value() );

           rs_ncv++;


     }

     else {


       fillRecoToSim("rs_Light", svTagInfo->secondaryVertex(vindex), tracer.simVertex());

       HistIndex_["rs_Light_FlightDistance2d"]->Fill( svTagInfo->flightDistance( vindex, true ).value() );

           rs_nlv++;

     }

       }//end if classifier


       else {

         cout << "    VertexCategories::Fake!!" << endl;

         nfake++;

       }


     }//end loop over vertices in svTagInfo


   }//loop over svTagInfo


   HistIndex_["rs_All_nRecVtx"]->Fill( rs_nall );

   HistIndex_["rs_SecondaryVertex_nRecVtx"]->Fill( rs_nsv );

   HistIndex_["rs_BWeakDecay_nRecVtx"]->Fill( rs_nbv );

   HistIndex_["rs_BSV_nRecVtx"]->Fill( rs_nbsv );

   HistIndex_["rs_CWeakDecay_nRecVtx"]->Fill( rs_ncv );

   HistIndex_["rs_Light_nRecVtx"]->Fill( rs_nlv );

   cout << endl;


   //----------------------------------------------------------------

   // SIM TO RECO!


   // Vertex collection

   edm::Handle<TrackingVertexCollection>  TVCollection;

   event.getByLabel(trackingTruth_, TVCollection);


   // Loop over the TV collection.

   for (std::size_t index = 0; index < TVCollection->size(); ++index){


     TrackingVertexRef trackingVertex(TVCollection, index);


     classifier_.evaluate(trackingVertex);


     double sr_quality = tracer.quality();


     if ( classifier_.is(VertexCategories::Reconstructed) ) {


       HistIndex_["sr_All_MatchQuality"]->Fill( sr_quality );

       fillSimToReco("sr_All", tracer.recoVertex(), trackingVertex);

       sr_nall++;


       if ( classifier_.is(VertexCategories::SecondaryVertex) ) {


         fillSimToReco("sr_SecondaryVertex", tracer.recoVertex(), trackingVertex);

         sr_nsv++;

       }


       if ( classifier_.is(VertexCategories::BWeakDecay) ) {


         fillSimToReco("sr_BWeakDecay", tracer.recoVertex(), trackingVertex);

         sr_nbv++;


         if ( classifier_.is(VertexCategories::SecondaryVertex) ) {


          fillSimToReco("sr_BSV", tracer.recoVertex(), trackingVertex);

          sr_nbsv++;

     }


       }//BWeakDecay


       else if ( classifier_.is(VertexCategories::CWeakDecay) ) {


     fillSimToReco("sr_CWeakDecay", tracer.recoVertex(), trackingVertex);

         sr_ncv++;

       }


       else {


     fillSimToReco("sr_Light", tracer.recoVertex(), trackingVertex);

         sr_nlv++;

       }


     }//Reconstructed

     else {

       //cout << "##### Not reconstructed!" << endl;

       nmiss++;

     }


   }//TVCollection.size()


   HistIndex_["sr_All_nRecVtx"]->Fill( sr_nall );

   HistIndex_["sr_SecondaryVertex_nRecVtx"]->Fill( sr_nsv );

   HistIndex_["sr_BWeakDecay_nRecVtx"]->Fill( sr_nbv );

   HistIndex_["sr_BSV_nRecVtx"]->Fill( sr_nbsv );

   HistIndex_["sr_CWeakDecay_nRecVtx"]->Fill( sr_ncv );

   HistIndex_["sr_Light_nRecVtx"]->Fill( rs_nlv );


   rs_total_nall += rs_nall;

   rs_total_nsv += rs_nsv;

   rs_total_nbv += rs_nbv;

   rs_total_nbsv += rs_nbsv;

   rs_total_ncv += rs_ncv ;

   rs_total_nlv += rs_nlv;

   total_nfake += nfake;


   sr_total_nall += sr_nall;

   sr_total_nsv += sr_nsv;

   sr_total_nbv += sr_nbv;

   sr_total_nbsv += sr_nbsv;

   sr_total_ncv += sr_ncv;

   sr_total_nlv += sr_nlv;

   total_nmiss += nmiss;


 }


 void recoBSVTagInfoValidationAnalyzer::bookRecoToSim(std::string const & prefix){

   // Book pull histograms


   std::string name = prefix + "_Pullx";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, -10., 10.);

   name = prefix + "_Pully";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, -10., 10.);

   name = prefix + "_Pullz";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, -10., 10.);


    name = prefix + "_Resx";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, -0.05, 0.05);

   name = prefix + "_Resy";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, -0.05, 0.05);

   name = prefix + "_Resz";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, -0.05, 0.05);


   name = prefix + "_Chi2Norm";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, 0, 10.);

   name = prefix + "_Chi2Prob";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, 0., 1.);


   name = prefix + "_nRecTrks";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 501, -0.5, 500.5);


   name = prefix + "_AverageTrackWeight";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, -0.1, 1.1);


   name = prefix + "_Mass";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 65, 0., 6.5);


   name = prefix + "_RecPt";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 2000, 0., 1000.);


   name = prefix + "_RecEta";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 200, -3., 3.);


   name = prefix + "_RecCharge";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 21, -0.5, 20.5);


   name = prefix + "_RecTrackPt";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 2000, 0., 1000.);


   name = prefix + "_RecTrackEta";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 200, -3., 3.);


   name = prefix + "_nSimTrks";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 501, -0.5, 500.5);


   name = prefix + "_SimPt";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 2000, 0., 1000.);


   name = prefix + "_SimEta";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 200, -3., 3.);


   name = prefix + "_SimCharge";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 21, -0.5, 20.5);


   name = prefix + "_SimTrackPt";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 500, 0., 500.);


   name = prefix + "_SimTrackEta";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 200, -3., 3.);


 }


 void recoBSVTagInfoValidationAnalyzer::bookSimToReco(std::string const & prefix){

   // Book pull histograms


   std::string name = prefix + "_Pullx";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, -10., 10.);

   name = prefix + "_Pully";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, -10., 10.);

   name = prefix + "_Pullz";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, -10., 10.);


    name = prefix + "_Resx";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, -0.05, 0.05);

   name = prefix + "_Resy";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, -0.05, 0.05);

   name = prefix + "_Resz";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, -0.05, 0.05);


   name = prefix + "_Chi2Norm";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, 0, 10.);

   name = prefix + "_Chi2Prob";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, 0., 1.);


   name = prefix + "_nRecTrks";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 501, -0.5, 500.5);


   name = prefix + "_AverageTrackWeight";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 100, -0.1, 1.1);


   name = prefix + "_Mass";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 65, 0., 6.5);


   name = prefix + "_RecPt";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 2000, 0., 1000.);


   name = prefix + "_RecEta";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 200, -3., 3.);


   name = prefix + "_RecCharge";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 21, -0.5, 20.5);


   name = prefix + "_RecTrackPt";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 2000, 0., 1000.);


   name = prefix + "_RecTrackEta";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 200, -3., 3.);


   name = prefix + "_nSimTrks";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 501, -0.5, 500.5);


   name = prefix + "_SimPt";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 2000, 0., 1000.);


   name = prefix + "_SimEta";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 200, -3., 3.);


   name = prefix + "_SimCharge";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 21, -0.5, 20.5);


   name = prefix + "_SimTrackPt";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 500, 0., 500.);


   name = prefix + "_SimTrackEta";

   HistIndex_[name] = dqmStore_->book1D(name.c_str(), name.c_str(), 200, -3., 3.);


 }


 void recoBSVTagInfoValidationAnalyzer::fillRecoToSim(std::string const & prefix, reco::Vertex const & vertex, TrackingVertexRef const & simVertex)

 {


   double pullx = (vertex.x() - simVertex->position().x())/vertex.xError();

   double pully = (vertex.y() - simVertex->position().y())/vertex.yError();

   double pullz = (vertex.z() - simVertex->position().z())/vertex.zError();


   double resx = vertex.x() - simVertex->position().x();

   double resy = vertex.y() - simVertex->position().y();

   double resz = vertex.z() - simVertex->position().z();


   double chi2norm = vertex.normalizedChi2();

   double chi2prob = ChiSquaredProbability( vertex.chi2(), vertex.ndof() );


  double sum_weight = 0.;

  double weight = 0.;

  double tracksize =  vertex.tracksSize();

  math::XYZVector momentum;

  math::XYZTLorentzVector sum;

  int charge = 0;

   double thePiMass = 0.13957;

   for ( reco::Vertex::trackRef_iterator recDaughter = vertex.tracks_begin() ; recDaughter != vertex.tracks_end(); ++recDaughter) {


     ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> > vec;


     vec.SetPx( (**recDaughter).px() );

     vec.SetPy( (**recDaughter).py() );

     vec.SetPz( (**recDaughter).pz() );

     vec.SetM(thePiMass);


     sum += vec;


     weight = vertex.trackWeight(*recDaughter);

     sum_weight += weight;


     math::XYZVector p;

     p = (**recDaughter).momentum();

     momentum += p;


     charge += (*recDaughter)->charge();


     HistIndex_[prefix + "_RecTrackPt"]->Fill( (*recDaughter)->pt() );

     HistIndex_[prefix + "_RecTrackEta"]->Fill( (*recDaughter)->eta() );

   }//end loop to recDaughters

   //cout << "                   average sum of weights = " << sum_weight/tracksize << endl;


   double mass = sum.M();

   double pt = sqrt( momentum.Perp2() );

   double eta = momentum.Eta();


   math::XYZVector simmomentum;

   int simcharge = 0;

   for ( TrackingVertex::tp_iterator simDaughter = simVertex->daughterTracks_begin(); simDaughter != simVertex->daughterTracks_end(); ++simDaughter ){


     math::XYZVector p;

     p = (**simDaughter).momentum();

     simmomentum += p;


     simcharge += (*simDaughter)->charge();


     HistIndex_[prefix + "_SimTrackPt"]->Fill( (*simDaughter)->pt() );

     HistIndex_[prefix + "_SimTrackEta"]->Fill( (*simDaughter)->eta() );

   }


   double simpt = sqrt( simmomentum.Perp2() );

   double simeta = simmomentum.Eta();


   //cout << "[fillRecoToSim]  vertex.tracksSize() = " << vertex.tracksSize() << " ; simVertex->nDaughterTracks() = " << simVertex->nDaughterTracks() << endl;


   HistIndex_[prefix + "_nRecTrks"]->Fill( vertex.tracksSize() );

   HistIndex_[prefix + "_nSimTrks"]->Fill( simVertex->nDaughterTracks() );

   HistIndex_[prefix + "_Pullx"]->Fill(pullx);

   HistIndex_[prefix + "_Pully"]->Fill(pully);

   HistIndex_[prefix + "_Pullz"]->Fill(pullz);

   HistIndex_[prefix + "_Resx"]->Fill(resx);

   HistIndex_[prefix + "_Resy"]->Fill(resy);

   HistIndex_[prefix + "_Resz"]->Fill(resz);

   HistIndex_[prefix + "_AverageTrackWeight"]->Fill( sum_weight/tracksize );

   HistIndex_[prefix + "_Chi2Norm"]->Fill(chi2norm);

   HistIndex_[prefix + "_Chi2Prob"]->Fill(chi2prob);

   HistIndex_[prefix + "_RecPt"]->Fill(pt);

   HistIndex_[prefix + "_RecEta"]->Fill(eta);

   HistIndex_[prefix + "_RecCharge"]->Fill(charge);

   HistIndex_[prefix + "_Mass"]->Fill(mass);

   HistIndex_[prefix + "_SimPt"]->Fill(simpt);

   HistIndex_[prefix + "_SimEta"]->Fill(simeta);

   HistIndex_[prefix + "_SimCharge"]->Fill(simcharge);

 }


 void recoBSVTagInfoValidationAnalyzer::fillSimToReco(std::string const & prefix, reco::VertexBaseRef const & vertex, TrackingVertexRef const & simVertex)

 {


   double pullx = (vertex->x() - simVertex->position().x())/vertex->xError();

   double pully = (vertex->y() - simVertex->position().y())/vertex->yError();

   double pullz = (vertex->z() - simVertex->position().z())/vertex->zError();


   double resx = vertex->x() - simVertex->position().x();

   double resy = vertex->y() - simVertex->position().y();

   double resz = vertex->z() - simVertex->position().z();


   double chi2norm = vertex->normalizedChi2();

   double chi2prob = ChiSquaredProbability(vertex->chi2(), vertex->ndof());


   double sum_weight = 0.;

   double weight = 0.;

   double tracksize =  vertex->tracksSize();

   math::XYZVector momentum;

   math::XYZTLorentzVector sum;

   int charge = 0;

   double thePiMass = 0.13957;

   for ( reco::Vertex::trackRef_iterator recDaughter = vertex->tracks_begin() ; recDaughter != vertex->tracks_end(); ++recDaughter ) {


     ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> > vec;


     vec.SetPx( (**recDaughter).px() );

     vec.SetPy( (**recDaughter).py() );

     vec.SetPz( (**recDaughter).pz() );

     vec.SetM(thePiMass);


     sum += vec;


     weight = vertex->trackWeight(*recDaughter);

     sum_weight += weight;


     math::XYZVector p;

     p = (**recDaughter).momentum();

     momentum += p;


     charge += (*recDaughter)->charge();


     HistIndex_[prefix + "_RecTrackPt"]->Fill( (*recDaughter)->pt() );

     HistIndex_[prefix + "_RecTrackEta"]->Fill( (*recDaughter)->eta() );


   }

   //cout << "                   average sum of weights = " << sum_weight/tracksize << endl;


   double mass = sum.M();

   double pt = sqrt( momentum.Perp2() );

   double eta = momentum.Eta();


    math::XYZVector simmomentum;

   int simcharge = 0;

   for ( TrackingVertex::tp_iterator simDaughter = simVertex->daughterTracks_begin(); simDaughter != simVertex->daughterTracks_end(); ++simDaughter ){


     math::XYZVector p;

     p = (**simDaughter).momentum();

     simmomentum += p;


     simcharge += (*simDaughter)->charge();


     HistIndex_[prefix + "_SimTrackPt"]->Fill( (*simDaughter)->pt() );

     HistIndex_[prefix + "_SimTrackEta"]->Fill( (*simDaughter)->eta() );

   }


   double simpt = sqrt( simmomentum.Perp2() );

   double simeta = simmomentum.Eta();


   //cout << "[fillSimToReco]  vertex->tracksSize() = " << vertex->tracksSize() << " ; simVertex->nDaughterTracks() = " << simVertex->nDaughterTracks() << endl;


   HistIndex_[prefix + "_nRecTrks"]->Fill( vertex->tracksSize() );

   HistIndex_[prefix + "_nSimTrks"]->Fill( simVertex->nDaughterTracks() );

   HistIndex_[prefix + "_Pullx"]->Fill(pullx);

   HistIndex_[prefix + "_Pully"]->Fill(pully);

   HistIndex_[prefix + "_Pullz"]->Fill(pullz);

   HistIndex_[prefix + "_Resx"]->Fill(resx);

   HistIndex_[prefix + "_Resy"]->Fill(resy);

   HistIndex_[prefix + "_Resz"]->Fill(resz);

   HistIndex_[prefix + "_AverageTrackWeight"]->Fill( sum_weight/tracksize );

   HistIndex_[prefix + "_Chi2Norm"]->Fill(chi2norm);

   HistIndex_[prefix + "_Chi2Prob"]->Fill(chi2prob);

   HistIndex_[prefix + "_RecPt"]->Fill(pt);

   HistIndex_[prefix + "_RecEta"]->Fill(eta);

   HistIndex_[prefix + "_RecCharge"]->Fill(charge);

   HistIndex_[prefix + "_Mass"]->Fill(mass);

   HistIndex_[prefix + "_SimPt"]->Fill(simpt);

   HistIndex_[prefix + "_SimEta"]->Fill(simeta);

   HistIndex_[prefix + "_SimCharge"]->Fill(simcharge);


 }


 void

 recoBSVTagInfoValidationAnalyzer::endJob() {


   std::cout << std::endl;

   std::cout << " ====== Total Number of analyzed events: " << n_event << " ====== " << std::endl;

   std::cout << " ====== Total Number of R2S All:                         " << rs_total_nall << " ====== " << std::endl;

   std::cout << " ====== Total Number of R2S SecondaryVertex:             " << rs_total_nsv  << " ====== " << std::endl;

   std::cout << " ====== Total Number of R2S BWeakDecay:                  " << rs_total_nbv  << " ====== " << std::endl;

   std::cout << " ====== Total Number of R2S BWeakDecay::SecondaryVertex: " << rs_total_nbsv << " ====== " << std::endl;

   std::cout << " ====== Total Number of R2S CWeakDecay:                  " << rs_total_ncv  << " ====== " << std::endl;

   std::cout << " ====== Total Number of R2S Light:                       " << rs_total_nlv  << " ====== " << std::endl;

   std::cout << std::endl;

   std::cout << " ====== Total Number of S2R All:                         " << sr_total_nall << " ====== " << std::endl;

   std::cout << " ====== Total Number of S2R SecondaryVertex:             " << sr_total_nsv  << " ====== " << std::endl;

   std::cout << " ====== Total Number of S2R BWeakDecay:                  " << sr_total_nbv  << " ====== " << std::endl;

   std::cout << " ====== Total Number of S2R BWeakDecay::SecondaryVertex: " << sr_total_nbsv << " ====== " << std::endl;

   std::cout << " ====== Total Number of S2R CWeakDecay:                  " << sr_total_ncv  << " ====== " << std::endl;

   std::cout << " ====== Total Number of S2R Light:                       " << sr_total_nlv  << " ====== " << std::endl;

   std::cout << std::endl;

   std::cout << " ====== Total Number of Fake Vertices:              " << total_nfake   << " ====== " << std::endl;


 }


 DEFINE_FWK_MODULE(recoBSVTagInfoValidationAnalyzer);

VertexClassifierByProxy< reco::SecondaryVertexTagInfoCollection >

VertexHistory
This class traces the simulated and generated history of a given track.
Definition: VertexHistory.h:17

recoBSVTagInfoValidationAnalyzer::total_nmiss
Int_t total_nmiss
Definition: recoBSVTagInfoValidationAnalyzer.cc:74

edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const

i
int i
Definition: DBlmapReader.cc:9

SecondaryVertexTagInfo.h

recoBSVTagInfoValidationAnalyzer::sr_total_nbv
Int_t sr_total_nbv
Definition: recoBSVTagInfoValidationAnalyzer.cc:70

recoBSVTagInfoValidationAnalyzer::analyze
virtual void analyze(const edm::Event &, const edm::EventSetup &)
Definition: recoBSVTagInfoValidationAnalyzer.cc:183

edm::Service< DQMStore >

VertexClassifier::history
VertexHistory const & history() const
Returns a reference to the vertex history used in the classification.
Definition: VertexClassifier.h:45

recoBSVTagInfoValidationAnalyzer::rs_total_nlv
Int_t rs_total_nlv
Definition: recoBSVTagInfoValidationAnalyzer.cc:65

DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:717

reco::Vertex::tracks_end
trackRef_iterator tracks_end() const
last iterator over tracks
Definition: Vertex.cc:45

Vispa.Share.Profiling.analyze
def analyze
Definition: Profiling.py:11

recoBSVTagInfoValidationAnalyzer::rs_total_nall
Int_t rs_total_nall
Definition: recoBSVTagInfoValidationAnalyzer.cc:60

cppFunctionSkipper.operator
string operator
Definition: cppFunctionSkipper.py:10

reco::Vertex::zError
double zError() const
error on z
Definition: Vertex.h:105

DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:17

reco::Vertex::y
double y() const
y coordinate
Definition: Vertex.h:97

getHLTprescales.index
tuple index
Definition: getHLTprescales.py:79

MakerMacros.h

recoBSVTagInfoValidationAnalyzer::bookSimToReco
void bookSimToReco(std::string const &)
Definition: recoBSVTagInfoValidationAnalyzer.cc:459

VertexCategories::CWeakDecay
Definition: VertexCategories.h:19

edm::RefToBase< reco::Vertex >

CommonMethods.weight
def weight
Definition: CommonMethods.py:268

VertexHistory::recoVertex
const reco::VertexBaseRef & recoVertex() const
Return a reference to the reconstructed track.
Definition: VertexHistory.h:62

eta
T eta() const
Definition: Basic3DVectorLD.h:172

edm::Handle
Definition: AssociativeIterator.h:48

dt_dqm_sourceclient_common_cff.reco
tuple reco
Definition: dt_dqm_sourceclient_common_cff.py:105

mergeVDriftHistosByStation.name
string name
Definition: mergeVDriftHistosByStation.py:77

DeDxDiscriminatorTools::charge
double charge(const std::vector< uint8_t > &Ampls)
Definition: DeDxDiscriminatorTools.cc:43

Frameworkfwd.h

recoBSVTagInfoValidationAnalyzer::n_event
Int_t n_event
Definition: recoBSVTagInfoValidationAnalyzer.cc:59

VertexClassifierByProxy.h

recoBSVTagInfoValidationAnalyzer::sr_total_ncv
Int_t sr_total_ncv
Definition: recoBSVTagInfoValidationAnalyzer.cc:72

recoBSVTagInfoValidationAnalyzer::fillSimToReco
void fillSimToReco(std::string const &, reco::VertexBaseRef const &, TrackingVertexRef const &)
Definition: recoBSVTagInfoValidationAnalyzer.cc:617

ParameterSet.h

recoBSVTagInfoValidationAnalyzer::rs_total_nbv
Int_t rs_total_nbv
Definition: recoBSVTagInfoValidationAnalyzer.cc:62

math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:30

recoBSVTagInfoValidationAnalyzer
Definition: recoBSVTagInfoValidationAnalyzer.cc:37

recoBSVTagInfoValidationAnalyzer::dqmStore_
DQMStore * dqmStore_
Definition: recoBSVTagInfoValidationAnalyzer.cc:56

VertexCategories::Fake
Definition: VertexCategories.h:15

DQMStore
Definition: DQMStore.h:67

VertexCategories::Reconstructed
Definition: VertexCategories.h:16

reco::Vertex
Definition: Vertex.h:35

reco::Vertex::trackWeight
float trackWeight(const TrackBaseRef &r) const
returns the weight with which a Track has contributed to the vertex-fit.

DQMStore.h

VertexCategories::Category
Category
Categories available to vertexes.
Definition: VertexCategories.h:13

mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:46

recoBSVTagInfoValidationAnalyzer::recoBSVTagInfoValidationAnalyzer
recoBSVTagInfoValidationAnalyzer(const edm::ParameterSet &)
Definition: recoBSVTagInfoValidationAnalyzer.cc:91

recoBSVTagInfoValidationAnalyzer::classifier_
VertexClassifierByProxy< reco::SecondaryVertexTagInfoCollection > classifier_
Definition: recoBSVTagInfoValidationAnalyzer.cc:50

recoBSVTagInfoValidationAnalyzer::dqmLabel
std::string dqmLabel
Definition: recoBSVTagInfoValidationAnalyzer.cc:57

recoBSVTagInfoValidationAnalyzer::svTagInfoProducer_
edm::InputTag svTagInfoProducer_
Definition: recoBSVTagInfoValidationAnalyzer.cc:54

recoBSVTagInfoValidationAnalyzer::sr_total_nbsv
Int_t sr_total_nbsv
Definition: recoBSVTagInfoValidationAnalyzer.cc:71

reco::Vertex::chi2
double chi2() const
chi-squares
Definition: Vertex.h:82

reco::Vertex::z
double z() const
y coordinate
Definition: Vertex.h:99

recoBSVTagInfoValidationAnalyzer::endJob
virtual void endJob()
Definition: recoBSVTagInfoValidationAnalyzer.cc:710

recoBSVTagInfoValidationAnalyzer::HistIndex_
std::map< std::string, MonitorElement * > HistIndex_
Definition: recoBSVTagInfoValidationAnalyzer.cc:86

Service.h

ChiSquaredProbability
float ChiSquaredProbability(double chiSquared, double nrDOF)
Definition: ChiSquaredProbability.cc:13

edm::EventSetup
Definition: EventSetup.h:44

recoBSVTagInfoValidationAnalyzer::sr_total_nlv
Int_t sr_total_nlv
Definition: recoBSVTagInfoValidationAnalyzer.cc:73

getTH1F
TH1F * getTH1F(std::string name, std::string process, std::string rootfolder, DQMStore *dbe_, bool verb, bool clone)
Definition: HcalHistoUtils.h:57

VertexCategories::is
bool is(Category category) const
Returns track flag for a given category.
Definition: VertexCategories.h:67

LorentzVector.h

event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past

ChiSquaredProbability.h

recoBSVTagInfoValidationAnalyzer::trackingTruth_
edm::InputTag trackingTruth_
Definition: recoBSVTagInfoValidationAnalyzer.cc:53

recoBSVTagInfoValidationAnalyzer::bookRecoToSim
void bookRecoToSim(std::string const &)
Definition: recoBSVTagInfoValidationAnalyzer.cc:391

edm::EDAnalyzer
Definition: EDAnalyzer.h:14

EDAnalyzer.h

reco::Vertex::ndof
double ndof() const
Definition: Vertex.h:89

HistoryBase::simVertex
const TrackingVertexRef & simVertex() const
Return the initial tracking vertex from the history.
Definition: HistoryBase.h:83

VertexCategories::SecondaryVertex
Definition: VertexCategories.h:48

reco::Vertex::x
double x() const
x coordinate
Definition: Vertex.h:95

Vector.h

recoBSVTagInfoValidationAnalyzer::total_nfake
Int_t total_nfake
Definition: recoBSVTagInfoValidationAnalyzer.cc:66

reco::Vertex::xError
double xError() const
error on x
Definition: Vertex.h:101

math::XYZVector
XYZVectorD XYZVector
spatial vector with cartesian internal representation
Definition: Vector3D.h:31

VertexClassifierByProxy::evaluate
VertexClassifierByProxy< Collection > const & evaluate(TrackingVertexRef const &vertex)
Classify the TrackingVertex in categories.
Definition: VertexClassifierByProxy.h:33

HDQMDatabaseProducer.config
tuple config
Definition: HDQMDatabaseProducer.py:18

MonitorElement.h

VertexCategories::Unknown
Definition: VertexCategories.h:51

AlCaHLTBitMon_ParallelJobs.p
tuple p
Definition: AlCaHLTBitMon_ParallelJobs.py:152

recoBSVTagInfoValidationAnalyzer::numberVertexClassifier_
Int_t numberVertexClassifier_
Definition: recoBSVTagInfoValidationAnalyzer.cc:52

edm::InputTag
Definition: InputTag.h:12

VertexClassifierByProxy::newEvent
virtual void newEvent(edm::Event const &event, edm::EventSetup const &config)
Pre-process event information (for accessing reconstraction information).
Definition: VertexClassifierByProxy.h:24

scaleCards.mass
tuple mass
Definition: scaleCards.py:27

edm::RefVectorIterator
Definition: EDProductfwd.h:28

VertexCategories::BWeakDecay
Definition: VertexCategories.h:18

reco::Vertex::trackRef_iterator
std::vector< TrackBaseRef >::const_iterator trackRef_iterator
The iteratator for the vector&lt;TrackRef&gt;
Definition: Vertex.h:38

recoBSVTagInfoValidationAnalyzer::rs_total_nsv
Int_t rs_total_nsv
Definition: recoBSVTagInfoValidationAnalyzer.cc:61

edm::ParameterSet
Definition: ParameterSet.h:35

gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121

recoBSVTagInfoValidationAnalyzer::sr_total_nsv
Int_t sr_total_nsv
Definition: recoBSVTagInfoValidationAnalyzer.cc:69

reco::Vertex::normalizedChi2
double normalizedChi2() const
chi-squared divided by n.d.o.f.
Definition: Vertex.h:91

VertexCategories::Names
static const char * Names[]
Name of the different categories.
Definition: VertexCategories.h:55

recoBSVTagInfoValidationAnalyzer::rs_total_ncv
Int_t rs_total_ncv
Definition: recoBSVTagInfoValidationAnalyzer.cc:64

prof2calltree.prefix
list prefix
Definition: prof2calltree.py:21

VertexHistory::quality
double quality() const
Return the quality of the match.
Definition: VertexHistory.h:68

reco::Vertex::tracks_begin
trackRef_iterator tracks_begin() const
first iterator over tracks
Definition: Vertex.cc:40

recoBSVTagInfoValidationAnalyzer::sr_total_nall
Int_t sr_total_nall
Definition: recoBSVTagInfoValidationAnalyzer.cc:68

recoBSVTagInfoValidationAnalyzer::rs_total_nbsv
Int_t rs_total_nbsv
Definition: recoBSVTagInfoValidationAnalyzer.cc:63

edm::Event
Definition: Event.h:50

recoBSVTagInfoValidationAnalyzer::fillRecoToSim
void fillRecoToSim(std::string const &, reco::Vertex const &, TrackingVertexRef const &)
Definition: recoBSVTagInfoValidationAnalyzer.cc:527

HcalObjRepresent::setup
void setup(std::vector< TH2F > &depth, std::string name, std::string units="")
Definition: HcalObjRepresent.h:628

edm::Ref< TrackingVertexCollection >

reco::Vertex::yError
double yError() const
error on y
Definition: Vertex.h:103

DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:429

reco::Vertex::tracksSize
size_t tracksSize() const
number of tracks
Definition: Vertex.cc:35