// -*- C++ -*-
//
// Package:    TestAnlz/TestAnalyzer
// Class:      TestAnalyzer
//
/**\class TestAnalyzer TestAnalyzer.cc TestAnlz/TestAnalyzer/plugins/TestAnalyzer.cc

 Description: [one line class summary]

 Implementation:
     [Notes on implementation]
*/
//
// Original Author:  Anup Kumar Sikdar
//         Created:  Sun, 02 Sep 2018 06:06:51 GMT
//
//


// system include files
#include <memory>
#include <iostream>
#include <vector>
#include <iomanip>
#include <TVector3.h>
#include <TLorentzVector.h>
#include <TProfile.h>
#include <TTree.h>
#include <TMath.h>
#include <algorithm>
#include <bitset>


// user include files
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/one/EDAnalyzer.h"

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

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"


//// newly added ////
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Utilities/interface/StreamID.h"

//PAT candidates
#include <DataFormats/PatCandidates/interface/Photon.h>
#include "DataFormats/PatCandidates/interface/Electron.h"
#include "DataFormats/PatCandidates/interface/Muon.h"
#include "DataFormats/PatCandidates/interface/MET.h"
#include "DataFormats/PatCandidates/interface/Tau.h"
#include "DataFormats/PatCandidates/interface/Jet.h"
#include "DataFormats/PatCandidates/interface/PackedCandidate.h"
#include "DataFormats/PatCandidates/interface/GenericParticle.h"
#include "DataFormats/PatCandidates/interface/PackedGenParticle.h"
#include "DataFormats/PatCandidates/interface/IsolatedTrack.h"
#include "DataFormats/PatCandidates/interface/PackedCandidate.h"

#include "DataFormats/BeamSpot/interface/BeamSpot.h"
#include "DataFormats/Candidate/interface/Candidate.h"
#include "DataFormats/METReco/interface/MET.h"
#include "DataFormats/Math/interface/deltaR.h"
#include "DataFormats/Math/interface/deltaPhi.h"
#include "DataFormats/JetReco/interface/Jet.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/HepMCCandidate/interface/GenParticle.h"
#include "DataFormats/Common/interface/ValueMap.h"
#include "DataFormats/MuonReco/interface/MuonSelectors.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/TrackReco/interface/Track.h"

#include "CommonTools/UtilAlgos/interface/TFileService.h"
#include "PhysicsTools/PatAlgos/plugins/PATJetProducer.h"

#include "TrackingTools/TransientTrack/interface/TransientTrack.h"
#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
#include "TrackingTools/Records/interface/TransientTrackRecord.h"

#include "MagneticField/Engine/interface/MagneticField.h"
#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"

#include "RecoVertex/VertexPrimitives/interface/TransientVertex.h"
#include "RecoVertex/KalmanVertexFit/interface/KalmanVertexFitter.h"
#include "SimTracker/Records/interface/TrackAssociatorRecord.h"

#include "SimDataFormats/GeneratorProducts/interface/GenEventInfoProduct.h"
#include "SimDataFormats/PileupSummaryInfo/interface/PileupSummaryInfo.h"
#include "SimDataFormats/PileupSummaryInfo/interface/PileupMixingContent.h"
#include "SimDataFormats/PileupSummaryInfo/interface/PileupVertexContent.h"

//#include "MuonProducer.h"
// class declaration
//

// If the analyzer does not use TFileService, please remove
// the template argument to the base class so the class inherits
// from  edm::one::EDAnalyzer<>
// This will improve performance in multithreaded jobs.


    using namespace edm;
    using namespace std;
    using namespace reco;
    using namespace pat;


using reco::TrackCollection;

class TestAnalyzer : public edm::one::EDAnalyzer<edm::one::SharedResources>  {
   public:
      explicit TestAnalyzer(const edm::ParameterSet&);
      ~TestAnalyzer();

      static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);


   private:
      virtual void beginJob() override;
      virtual void analyze(const edm::Event&, const edm::EventSetup&) override;
      virtual void endJob() override;

      // ----------member data ---------------------------
   //   edm::EDGetTokenT<TrackCollection> tracksToken_;  //used to select what tracks to read from configuration file
      
        edm::InputTag slimmedElectrons;
        edm::EDGetTokenT<edm::View<pat::Electron>>  slimmedElectronsToken_;
	
	edm::InputTag jettag;
        edm::EDGetTokenT<edm::View<pat::Jet>> JetToken_;
	
	edm::InputTag MetTag;
        edm::EDGetTokenT<edm::View<pat::MET>> MetTagToken_;
	
        edm::InputTag slimmedMuons;
        edm::EDGetTokenT<edm::View<pat::Muon>> slimmedMuonsToken_;
	
	edm::InputTag slimmedTaus;
	edm::EDGetTokenT<edm::View<pat::Taus>> slimmedTausToken_;
    
        TTree *MyTree;
        std::vector<float> PtElec;
        std::vector<float> EtaElec;
        std::vector<float> PhiElec;
	
	std::vector<float> PtJet;
        std::vector<float> EtaJet;
	std::vector<float> PhiJet;
        std::vector<float> EnJet;
	
	double metpt;
	double metphi;
	double meteta;
        double metEn;
	
	std::vector<float> PtMuon;
        std::vector<float> EtaMuon;
        std::vector<float> PhiMuon;
        std::vector<float> ChargeMu;
	
	std::vector<float> PtTau;
	std::vector<float> EtaTau;
	std::vector<float> PhiTau;
	std::vector<float> ChargeTau;
 
 
};

//
// constants, enums and typedefs
//

//
// static data member definitions
//

//
// constructors and destructor
//
TestAnalyzer::TestAnalyzer(const edm::ParameterSet& iConfig)
 :
  //tracksToken_(consumes<TrackCollection>(iConfig.getUntrackedParameter<edm::InputTag>("tracks")))

slimmedElectrons(iConfig.getUntrackedParameter<edm::InputTag>("slimmedElectrons")),
slimmedElectronsToken_(consumes<edm::View<pat::Electron>>(slimmedElectrons)),

jettag(iConfig.getUntrackedParameter<edm::InputTag>("jettag")),
JetToken_(consumes<edm::View<pat::Jet>>(jettag)),
	
MetTag(iConfig.getUntrackedParameter<edm::InputTag>("MetTag")),
MetTagToken_(consumes<edm::View<pat::MET>>(MetTag)),
	
slimmedMuons(iConfig.getUntrackedParameter<edm::InputTag>("slimmedMuons")),
slimmedMuonsToken_(consumes<edm::View<pat::Muon>>(slimmedMuons)),

slimmedTaus(iConfig.getUntrackedParameter<edm::InputTag>("slimmedTaus")),
slimmedTausToken_(consumes<edm::View<pat::Tau>>(slimmedTaus))
	
{	
   //now do what ever initialization is needed
 
                         //    ofstream ifile;
                         //    ifile.open("text.txt");
                             usesResource("TFileService");
                             edm::Service<TFileService> fs;
                             MyTree = fs->make<TTree>("MyTree","TestTree");
 
                             MyTree->Branch("PtElec", &PtElec);
                             MyTree->Branch("EtaElec", &EtaElec);
                             MyTree->Branch("PhiElec", &PhiElec);

                             MyTree->Branch("PtJet", &PtJet);
                             MyTree->Branch("EtaJet", &EtaJet);
                             MyTree->Branch("PhiJet", &PhiJet);
                             MyTree->Branch("EnJet", &EnJet);
	
	                     MyTree->Branch("metpt", &metpt);
                             MyTree->Branch("meteta", &meteta);
                             MyTree->Branch("metphi", &metphi);
                             MyTree->Branch("metEn", &metEn);
	
	                     MyTree->Branch("PtMuon", &PtMuon);
                             MyTree->Branch("EtaMuon", &EtaMuon);
                             MyTree->Branch("PhiMuon", &PhiMuon);
                             MyTree->Branch("Charge_of_muon", &ChargeMu);
	
	                     MyTree->Branch("PtTau", &PtTau);
	                     MyTree->Branch("EtaTau", &EtaTau);
	                     MyTree->Branch("PhiTau", &PhiTau);
	                     MyTree->Branch("ChargeTau", &ChargeTau);


}


TestAnalyzer::~TestAnalyzer()
{

   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)

}


//
// member functions
//

// ------------ method called for each event  ------------
void
TestAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
{
   using namespace edm;
//electrons
   PtElec.clear(); EtaElec.clear(); PhiElec.clear();
 
             edm::Handle< View<pat::Electron>> eCand;
             iEvent.getByToken(slimmedElectronsToken_,eCand);
	
	for(View<pat::Electron>::const_iterator j = eCand->begin(); j!=eCand->end(); ++j)
	{
		
	        PtElec.push_back(j->pt());
                EtaElec.push_back(j->eta());
                PhiElec.push_back(j->phi());
		
	}
	
	//Jets
	
	  PtJet.clear(); EtaJet.clear(); PhiJet.clear(); EnJet.clear();

             edm::Handle< View<pat::Jet>> jetCands;
             iEvent.getByToken(JetToken_,jetCands);
	
             for(View<pat::Jet>::const_iterator iJet = jetCands->begin(); iJet != jetCands->end(); ++iJet)
	     {
                PtJet.push_back(iJet->pt());
                EtaJet.push_back(iJet->eta());
                PhiJet.push_back(iJet->phi());
		EnJet.push_back(iJet->energy());
             }
	
	///METs
	   metpt=0; metphi=0; meteta=0; metEn=0;
	
             edm::Handle< View<pat::MET>> MetCand;
	     iEvent.getByToken(MetTagToken_,MetCand);
	
             for(View<pat::MET>::const_iterator iMet = MetCand->begin(); iMet != MetCand->end(); ++iMet)
	     {
                metpt=	iMet->pt();
                meteta=iMet->eta();
                metphi=iMet->phi();
		metEn=iMet->energy();
             }
	
	  PtMuon.clear(); EtaMuon.clear(); PhiMuon.clear(); ChargeMu.clear(); 
	
             edm::Handle< View<pat::Muon>> mCand;
             iEvent.getByToken(slimmedMuonsToken_,mCand);
	
             for(View<pat::Muon>::const_iterator i = mCand->begin(); i!=mCand->end(); ++i)
	     {
                PtMuon.push_back(i->pt());
                EtaMuon.push_back(i->eta());
                PhiMuon.push_back(i->phi());
		ChargeMu.push_back(i->charge());
		
             }
	
	 PtTau.clear(); EtaTau.clear(); PhiTau.clear(); ChargeTau.clear();
	
             edm::Handle< View<pat::Tau>> tauCand;
             iEvent.getByToken(slimmedTausToken_,tauCand);
	
             for(View<pat::Tau>::const_iterator i = tauCand->begin(); i!=tauCand->end(); ++i)
	     {
                PtTau.push_back(i->pt());
                EtaTau.push_back(i->eta());
	        PhiTau.push_back(i->phi());
		ChargeTau.push_back(i->charge());
             
		
             }
	
	//	ofstream ifile;	
	//	ifile.open("text.txt", ios::app);
	//	ifile << "Event completed \n"<<endl;

 MyTree->Fill();
 
 
/*    Handle<TrackCollection> tracks;
    iEvent.getByToken(tracksToken_, tracks);
    for(TrackCollection::const_iterator itTrack = tracks->begin();
        itTrack != tracks->end();
        ++itTrack) {
      // do something with track parameters, e.g, plot the charge.
      // int charge = itTrack->charge();
 */
    

#ifdef THIS_IS_AN_EVENT_EXAMPLE
   Handle<ExampleData> pIn;
   iEvent.getByLabel("example",pIn);
#endif

#ifdef THIS_IS_AN_EVENTSETUP_EXAMPLE
   ESHandle<SetupData> pSetup;
   iSetup.get<SetupRecord>().get(pSetup);
#endif
}


// ------------ method called once each job just before starting event loop  ------------
void
TestAnalyzer::beginJob()
{
}

// ------------ method called once each job just after ending the event loop  ------------
void
TestAnalyzer::endJob()
{
}

// ------------ method fills 'descriptions' with the allowed parameters for the module  ------------
void
TestAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  //The following says we do not know what parameters are allowed so do no validation
  // Please change this to state exactly what you do use, even if it is no parameters
  edm::ParameterSetDescription desc;
  desc.setUnknown();
  descriptions.addDefault(desc);

  //Specify that only 'tracks' is allowed
  //To use, remove the default given above and uncomment below
  //ParameterSetDescription desc;
  //desc.addUntracked<edm::InputTag>("tracks","ctfWithMaterialTracks");
  //descriptions.addDefault(desc);
}

//define this as a plug-in
DEFINE_FWK_MODULE(TestAnalyzer);