//////////////////////////////////////////////////////////
// This class has been automatically generated on
// Tue Jan 22 08:33:33 2019 by ROOT version 6.04/16
// from TTree WeightAnalysis_Res__ntuple/Simple Analysis ntuple
// found on file: outSignal_Weight_Test_1.root
//////////////////////////////////////////////////////////

#ifndef WeightAnalysis_Res__ntuple_h
#define WeightAnalysis_Res__ntuple_h
#include <TROOT.h>
#include <TChain.h>
#include <TFile.h>
#include <TH1F.h>

// Header file for the classes stored in the TTree if any.
#include "vector"

class WeightAnalysis_Res__ntuple {
public :
   TTree          *fChain;   //!pointer to the analyzed TTree or TChain
   Int_t           fCurrent; //!current Tree number in a TChain

// Fixed size dimensions of array or collections stored in the TTree if any.

   // Declaration of leaf types
   Float_t         eventWeight;
   Int_t           Event;
   Float_t         event_Weight;
   Float_t         event_Weight_squared;
   Float_t         Trigger_weight;
   vector<float>   *muonsE;
   vector<float>   *muonsPt;
   vector<float>   *muonsEta;
   vector<float>   *muonsPhi;
   vector<float>   *muonsCharge;
   vector<float>   *jetsE;
   vector<float>   *jetsPt;
   vector<float>   *jetsEta;
   vector<float>   *jetsPhi;
   vector<float>   *jetsid;
   vector<float>   *jetsindex;
   vector<float>   *jetsTruthE;
   vector<float>   *jetsTruthPt;
   vector<float>   *jetsTruthEta;
   vector<float>   *jetsTruthPhi;
   vector<float>   *jetsTruthid;
   vector<float>   *jetsTruthindex;

   // List of branches
   TBranch        *b_eventWeight;   //!
   TBranch        *b_Event;   //!
   TBranch        *b_event_Weight;   //!
   TBranch        *b_event_Weight_squared;   //!
   TBranch        *b_Trigger_weight;   //!
   TBranch        *b_muonsE;   //!
   TBranch        *b_muonsPt;   //!
   TBranch        *b_muonsEta;   //!
   TBranch        *b_muonsPhi;   //!
   TBranch        *b_muonsCharge;   //!
   TBranch        *b_jetsE;   //!
   TBranch        *b_jetsPt;   //!
   TBranch        *b_jetsEta;   //!
   TBranch        *b_jetsPhi;   //!
   TBranch        *b_jetsid;   //!
   TBranch        *b_jetsindex;   //!
   TBranch        *b_jetsTruthE;   //!
   TBranch        *b_jetsTruthPt;   //!
   TBranch        *b_jetsTruthEta;   //!
   TBranch        *b_jetsTruthPhi;   //!
   TBranch        *b_jetsTruthid;   //!
   TBranch        *b_jetsTruthindex;   //!

   TH1F *WeightAnalysis_Res__eventWeight_0;
   TH1F *WeightAnalysis_Res__n_muons_0;
   TH1F *WeightAnalysis_Res__n_muons_1;
   TH1F *WeightAnalysis_Res__n_muons_2;
   TH1F *WeightAnalysis_Res__n_muons_3;
   TH1F *WeightAnalysis_Res__n_muons_4;
   TH1F *WeightAnalysis_Res__n_muons_5;
   TH1F *WeightAnalysis_Res__n_muons_6;
   TH1F *WeightAnalysis_Res__n_muons_7;
   TH1F *WeightAnalysis_Res__n_muons_8;
   TH1F *WeightAnalysis_Res__n_muons_9;
   TH1F *WeightAnalysis_Res__n_muons_10;
   TH1F *WeightAnalysis_Res__n_muons_11;
   TH1F *WeightAnalysis_Res__n_muons_12;
   TH1F *WeightAnalysis_Res__n_muons_13;
   TH1F *WeightAnalysis_Res__n_muons_14;

   WeightAnalysis_Res__ntuple(TTree *tree=0);
   virtual ~WeightAnalysis_Res__ntuple();
   virtual Int_t    Cut(Long64_t entry);
   virtual Int_t    GetEntry(Long64_t entry);
   virtual Long64_t LoadTree(Long64_t entry);
   virtual void     Init(TTree *tree);
   virtual void     Loop();
   virtual Bool_t   Notify();
   virtual void     Show(Long64_t entry = -1);
};

#endif

#ifdef WeightAnalysis_Res__ntuple_cxx
WeightAnalysis_Res__ntuple::WeightAnalysis_Res__ntuple(TTree *tree) : fChain(0) 
{
// if parameter tree is not specified (or zero), connect the file
// used to generate this class and read the Tree.
   if (tree == 0) {
      TFile *f = (TFile*)gROOT->GetListOfFiles()->FindObject("outSignal_Weight_Test_1.root");
      if (!f || !f->IsOpen()) {
         f = new TFile("outSignal_Weight_Test_1.root");
      }
      f->GetObject("WeightAnalysis_Res__ntuple",tree);
   }

   Init(tree);
}

WeightAnalysis_Res__ntuple::~WeightAnalysis_Res__ntuple()
{
   if (!fChain) return;
   delete fChain->GetCurrentFile();
}

Int_t WeightAnalysis_Res__ntuple::GetEntry(Long64_t entry)
{
// Read contents of entry.
   if (!fChain) return 0;
   return fChain->GetEntry(entry);
}
Long64_t WeightAnalysis_Res__ntuple::LoadTree(Long64_t entry)
{
// Set the environment to read one entry
   if (!fChain) return -5;
   Long64_t centry = fChain->LoadTree(entry);
   if (centry < 0) return centry;
   if (fChain->GetTreeNumber() != fCurrent) {
      fCurrent = fChain->GetTreeNumber();
      Notify();
   }
   return centry;
}

void WeightAnalysis_Res__ntuple::Init(TTree *tree)
{
   // The Init() function is called when the selector needs to initialize
   // a new tree or chain. Typically here the branch addresses and branch
   // pointers of the tree will be set.
   // It is normally not necessary to make changes to the generated
   // code, but the routine can be extended by the user if needed.
   // Init() will be called many times when running on PROOF
   // (once per file to be processed).

   // Set object pointer
   muonsE = 0;
   muonsPt = 0;
   muonsEta = 0;
   muonsPhi = 0;
   muonsCharge = 0;
   jetsE = 0;
   jetsPt = 0;
   jetsEta = 0;
   jetsPhi = 0;
   jetsid = 0;
   jetsindex = 0;
   jetsTruthE = 0;
   jetsTruthPt = 0;
   jetsTruthEta = 0;
   jetsTruthPhi = 0;
   jetsTruthid = 0;
   jetsTruthindex = 0;

   //Declare histograms
   WeightAnalysis_Res__eventWeight_0 = new TH1F("WeightAnalysis_Res__eventWeight_0","WeightAnalysis_Res__eventWeight_0",45,-0.9,4.4);
   WeightAnalysis_Res__n_muons_0 = new TH1F("WeightAnalysis_Res__n_muons_0","WeightAnalysis_Res__n_muons_0",10,-1,9);
   WeightAnalysis_Res__n_muons_1 = new TH1F("WeightAnalysis_Res__n_muons_1","WeightAnalysis_Res__n_muons_1",10,-1,9);
   WeightAnalysis_Res__n_muons_2 = new TH1F("WeightAnalysis_Res__n_muons_2","WeightAnalysis_Res__n_muons_2",10,-1,9);
   WeightAnalysis_Res__n_muons_3 = new TH1F("WeightAnalysis_Res__n_muons_3","WeightAnalysis_Res__n_muons_3",10,-1,9);
   WeightAnalysis_Res__n_muons_4 = new TH1F("WeightAnalysis_Res__n_muons_4","WeightAnalysis_Res__n_muons_4",10,-1,9);
   WeightAnalysis_Res__n_muons_5 = new TH1F("WeightAnalysis_Res__n_muons_5","WeightAnalysis_Res__n_muons_5",10,-1,9);
   WeightAnalysis_Res__n_muons_6 = new TH1F("WeightAnalysis_Res__n_muons_6","WeightAnalysis_Res__n_muons_6",10,-1,9);
   WeightAnalysis_Res__n_muons_7 = new TH1F("WeightAnalysis_Res__n_muons_7","WeightAnalysis_Res__n_muons_7",10,-1,9);
   WeightAnalysis_Res__n_muons_8 = new TH1F("WeightAnalysis_Res__n_muons_8","WeightAnalysis_Res__n_muons_8",10,-1,9);
   WeightAnalysis_Res__n_muons_9 = new TH1F("WeightAnalysis_Res__n_muons_9","WeightAnalysis_Res__n_muons_9",10,-1,9);
   WeightAnalysis_Res__n_muons_10 = new TH1F("WeightAnalysis_Res__n_muons_10","WeightAnalysis_Res__n_muons_10",10,-1,9);
   WeightAnalysis_Res__n_muons_11 = new TH1F("WeightAnalysis_Res__n_muons_11","WeightAnalysis_Res__n_muons_11",10,-1,9);
   WeightAnalysis_Res__n_muons_12 = new TH1F("WeightAnalysis_Res__n_muons_12","WeightAnalysis_Res__n_muons_12",10,-1,9);
   WeightAnalysis_Res__n_muons_13 = new TH1F("WeightAnalysis_Res__n_muons_13","WeightAnalysis_Res__n_muons_13",10,-1,9);
   WeightAnalysis_Res__n_muons_14 = new TH1F("WeightAnalysis_Res__n_muons_14","WeightAnalysis_Res__n_muons_14",10,-1,9);

   // Set branch addresses and branch pointers
   if (!tree) return;
   fChain = tree;
   fCurrent = -1;
   fChain->SetMakeClass(1);

   fChain->SetBranchAddress("eventWeight", &eventWeight, &b_eventWeight);
   fChain->SetBranchAddress("Event", &Event, &b_Event);
   fChain->SetBranchAddress("event_Weight", &event_Weight, &b_event_Weight);
   fChain->SetBranchAddress("event_Weight_squared", &event_Weight_squared, &b_event_Weight_squared);
   fChain->SetBranchAddress("Trigger_weight", &Trigger_weight, &b_Trigger_weight);
   fChain->SetBranchAddress("muonsE", &muonsE, &b_muonsE);
   fChain->SetBranchAddress("muonsPt", &muonsPt, &b_muonsPt);
   fChain->SetBranchAddress("muonsEta", &muonsEta, &b_muonsEta);
   fChain->SetBranchAddress("muonsPhi", &muonsPhi, &b_muonsPhi);
   fChain->SetBranchAddress("muonsCharge", &muonsCharge, &b_muonsCharge);
   fChain->SetBranchAddress("jetsE", &jetsE, &b_jetsE);
   fChain->SetBranchAddress("jetsPt", &jetsPt, &b_jetsPt);
   fChain->SetBranchAddress("jetsEta", &jetsEta, &b_jetsEta);
   fChain->SetBranchAddress("jetsPhi", &jetsPhi, &b_jetsPhi);
   fChain->SetBranchAddress("jetsid", &jetsid, &b_jetsid);
   fChain->SetBranchAddress("jetsindex", &jetsindex, &b_jetsindex);
   fChain->SetBranchAddress("jetsTruthE", &jetsTruthE, &b_jetsTruthE);
   fChain->SetBranchAddress("jetsTruthPt", &jetsTruthPt, &b_jetsTruthPt);
   fChain->SetBranchAddress("jetsTruthEta", &jetsTruthEta, &b_jetsTruthEta);
   fChain->SetBranchAddress("jetsTruthPhi", &jetsTruthPhi, &b_jetsTruthPhi);
   fChain->SetBranchAddress("jetsTruthid", &jetsTruthid, &b_jetsTruthid);
   fChain->SetBranchAddress("jetsTruthindex", &jetsTruthindex, &b_jetsTruthindex);
   Notify();
}

Bool_t WeightAnalysis_Res__ntuple::Notify()
{
   // The Notify() function is called when a new file is opened. This
   // can be either for a new TTree in a TChain or when when a new TTree
   // is started when using PROOF. It is normally not necessary to make changes
   // to the generated code, but the routine can be extended by the
   // user if needed. The return value is currently not used.

   return kTRUE;
}

void WeightAnalysis_Res__ntuple::Show(Long64_t entry)
{
// Print contents of entry.
// If entry is not specified, print current entry
   if (!fChain) return;
   fChain->Show(entry);
}
Int_t WeightAnalysis_Res__ntuple::Cut(Long64_t entry)
{
// This function may be called from Loop.
// returns  1 if entry is accepted.
// returns -1 otherwise.
   return 1;
}

bool MassCollinearCore(const TLorentzVector &k1, const TLorentzVector &k2, //particles
                                       const double metetx, const double metety,           //met
                                       double &mass, double &xp1, double &xp2)
{ //result

    std::cout << "Check" << std::endl;
/*
    double a = k1.Px();
    double b = k2.Px();
    double d = k1.Py();
    double e = k2.Py();
    double c = metetx;
    double f = metety;


    std::cout << " Inside MassCollinear 1" << std::endl;
    TMatrixD K(2, 2);
    K(0, 0) = k1.Px();
    K(0, 1) = k2.Px();
    K(1, 0) = k1.Py();
    K(1, 1) = k2.Py();

    std::cout << " Inside MassCollinear 2" << std::endl;
    if (K.Determinant() == 0)
        return false;

    TMatrixD M(2, 1);
    M(0, 0) = metetx;
    M(1, 0) = metety;

    std::cout << " Inside MassCollinear 3" << std::endl;
    TMatrixD Kinv = K.Invert();

    std::cout << " Inside MassCollinear 4" << std::endl;
    TMatrixD X(2, 1);
    X = Kinv * M;

    std::cout << " Inside MassCollinear 5" << std::endl;
    double X1 = X(0, 0);
    double X2 = X(1, 0);

    double X1 = (c*e-b*f)/(a*e-b*d);
    double X2 = (a*f-c*d)/(a*e-b*d);
    double x1 = 1. / (1. + X1);
    double x2 = 1. / (1. + X2);

    std::cout << " Inside MassCollinear 6" << std::endl;
    TLorentzVector p1 = k1 * (1. / x1);
    TLorentzVector p2 = k2 * (1. / x2);

    std::cout << " Inside MassCollinear 7" << std::endl;
    double m = (p1 + p2).M();

    //return to caller
    mass = m;

    std::cout << " Inside MassCollinear 8" << std::endl;
    if (k1.Pt() > k2.Pt())
    {
        xp1 = x1;
        xp2 = x2;
    }
    else
    {
        xp1 = x2;
        xp2 = x1;
    }

    std::cout << " Inside MassCollinear 9" << std::endl;
*/
    return true;
}

#endif // #ifdef WeightAnalysis_Res__ntuple_cxx