//////////////////////////////////////////////////////////////////////////
//                                                                      //
// ATLFast TriggerMaker class.                                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "ATLFPhotonMaker.h"
#include "ATLFMuonMaker.h"
#include "ATLFElectronMaker.h"
#include "ATLFJetMaker.h"
#include "ATLFMCMaker.h"
#include "ATLFElectron.h"
#include "ATLFJet.h"
#include "ATLFPhoton.h"
#include "ATLFMuon.h"
#include "ATLFast.h"

#include "ATLFTriggerMaker.h"
#include "ATLFTrigger.h"

ClassImp(ATLFTriggerMaker)

//_____________________________________________________________________________
 ATLFTriggerMaker::ATLFTriggerMaker()
{

}

//_____________________________________________________________________________
 ATLFTriggerMaker::ATLFTriggerMaker(const char *name, const char *title)
                 :ATLFMaker(name,title)
{
//    Setters for isolated electron/photon trigger
   SetEPhoEtaCoverage();
   SetEPhoMinPTlowEle();
   SetEPhoMinPThighEle();
   SetEPhoMinPTlowPho();
   SetEPhoMinPThighPho();
   SetEPhoMinPTlow2();
   SetEPhoMinPThigh2();
//    Setters for muon trigger
   SetMuoEtaCoverage();
   SetMuoMinPTlowIso();
   SetMuoMinPThighIso();
   SetMuoMinPTlow();
   SetMuoMinPThigh();
   SetMuoMinPTlow2();
   SetMuoMinPThigh2();
   SetMuoMinPThigh2Iso();
//    Setters for electron/muon trigger
   SetEMuoEtaCoverageE();
   SetEMuoEtaCoverageM();
   SetEMuoMinPTlowEle();
   SetEMuoMinPThighEle();
   SetEMuoMinPTlowMuo();
   SetEMuoMinPThighMuo();
//    Setters for jet trigger
   SetJetEtaCoverage();
   SetJetMinPTlow1jet();
   SetJetMinPThigh1jet();
   SetJetMinPTlow3jet();
   SetJetMinPThigh3jet();
   SetJetMinPTlow4jet();
   SetJetMinPThigh4jet();

   m_Fruits     = new ATLFTrigger();
   m_BranchName = "Trigger";
   Save();
}

//_____________________________________________________________________________
 ATLFTriggerMaker::~ATLFTriggerMaker()
{
   //dummy
}

//_____________________________________________________________________________
 void ATLFTriggerMaker::Clear(Option_t *option)
{
//    Reset Cluster Maker

   ATLFMaker::Clear(option);
}


//_____________________________________________________________________________
 void ATLFTriggerMaker::Init()
{
//  Create histograms
   m_Content        = new TH1F("TriContent","trigger content",12,0,12);
   m_MuonEffHighLow = new TH1F("TriMuonEffHighLow","muon trig eff. for high + low  pT threshold",50,0,100); 
   m_MuonEffHigh    = new TH1F("TriMuonEffHigh","muon trig eff. for high pT threshold",50,0,100);
   m_Counter        = new TH1F("TriCounter","muon trig counter",50,0,100);

// Initialize trigger parameters in function of the selected luminosity
   if (gATLFast->Luminosity() == 1) {
      m_PTELE  = m_EPhoMinPTlowEle;
      m_PTPHO  = m_EPhoMinPTlowPho;
      m_PTEM2  = m_EPhoMinPTlow2;
      m_PTMU1I = m_MuoMinPTlowIso;
      m_PTMU1  = m_MuoMinPTlow;
      m_PTMU2  = m_MuoMinPTlow2;
      m_ETAEL1 = m_EMuoEtaCoverageE;
      m_ETAMU1 = m_EMuoEtaCoverageM;
      m_PTEMUE = m_EMuoMinPTlowEle;
      m_PTEMUM = m_EMuoMinPTlowMuo;
      m_PTJET1 = m_JetMinPTlow1jet;
      m_PTJET3 = m_JetMinPTlow3jet;
      m_PTJET4 = m_JetMinPTlow4jet;
   } else {
      m_PTELE  = m_EPhoMinPThighEle;
      m_PTPHO  = m_EPhoMinPThighPho;
      m_PTEM2  = m_EPhoMinPThigh2;
      m_PTMU1I = m_MuoMinPThighIso;
      m_PTMU1  = m_MuoMinPThigh;
      m_PTMU2  = m_MuoMinPThigh2;
      m_PTMU2I = m_MuoMinPThigh2Iso;
      m_ETAEL1 = m_EMuoEtaCoverageE;
      m_ETAMU1 = m_EMuoEtaCoverageM;
      m_PTEMUE = m_EMuoMinPThighEle;
      m_PTEMUM = m_EMuoMinPThighMuo;
      m_PTJET1 = m_JetMinPThigh1jet;
      m_PTJET3 = m_JetMinPThigh3jet;
      m_PTJET4 = m_JetMinPThigh4jet;
   }
}

//_____________________________________________________________________________
 void ATLFTriggerMaker::Finish()
{
// Function called by ATLFast::Finish at the end of the job

   m_MuonEffHighLow->Divide(m_Counter);
   m_MuonEffHigh->Divide(m_Counter);
}

//_____________________________________________________________________________
 Int_t ATLFTriggerMaker::Make()
{
//.............................................
//  This primitive trigger routine provides nine types of trigger selection: 
//  
//  trigger types
//     Bool_t         m_ALL;            //All triggers
//     Bool_t         m_EM1;            //One isolated electron
//     Bool_t         m_PH1;            //One isolated photon
//     Bool_t         m_EM2;            //Two isolated electrons/photons
//     Bool_t         m_MU1;            //One muon
//     Bool_t         m_MU2;            //Two muons
//     Bool_t         m_EMU;            //Electron-muon pairs
//     Bool_t         m_JT1;            //One jet
//     Bool_t         m_JT3;            //Three jets
//     Bool_t         m_JT4;            //Four jets
//  where the logical values  can be true/false depending on whether the 
//  event passed trigger selection criteria.
//  If any of above listed logical variables is true than m_ALL is true.
//.............................................

   Bool_t Trig_EM1 = kFALSE;
   Bool_t Trig_PH1 = kFALSE;
   Bool_t Trig_EM2 = kFALSE;
   Bool_t Trig_MU1 = kFALSE;
   Bool_t Trig_MU2 = kFALSE;
   Bool_t Trig_EMU = kFALSE;
   Bool_t Trig_JT1 = kFALSE;
   Bool_t Trig_JT3 = kFALSE;
   Bool_t Trig_JT4 = kFALSE;
   Bool_t Trig_ALL = kFALSE;

//........................................................
//... Get pointers to electronmaker ClonesArray
//........................................................
   ATLFElectronMaker *electronmaker = gATLFast->ElectronMaker();
   TClonesArray *electrons = electronmaker->Fruits();
   ATLFElectron *electron;
   Int_t nelectrons    = electronmaker->Nelectrons();

//........................................................
//... Get pointers to photonmaker ClonesArray
//........................................................
   ATLFPhotonMaker *photonmaker = gATLFast->PhotonMaker();
   TClonesArray *photons = photonmaker->Fruits();
   ATLFPhoton *photon;
   Int_t nphotons    = photonmaker->Nphotons();

//........................................................
//... Get pointers to muonmaker ClonesArray
//........................................................
   ATLFMuonMaker *muonmaker = gATLFast->MuonMaker();
   TClonesArray *muons = muonmaker->Fruits();
   ATLFMuon *muon;
   Int_t nmuons    = muonmaker->Nmuons();

//........................................................
//... Get pointers to jets ClonesArray
//........................................................
   ATLFJetMaker *jetmaker = gATLFast->JetMaker();
   TClonesArray *jets = jetmaker->Fruits();
   ATLFJet *jet;
   Int_t njets       = jetmaker->Njets();

//........................................................
//..... apply efficiency for triggering
//.....**  APPLY MUON TRIGGER EFFICIENCY
//.....**  KMUOTRG(I)=2 muon passing high pt trigger
//.....**  KMUOTRG(I)=1 muon passing low pt trigger
//.....**  KMUOTRG(I)=0 muon failing both triggers
//........................................................
//      ISTART=1 
   Int_t i;
   Int_t trigger = 0;
   for (i=0;i<nmuons;i++) {
      muon = (ATLFMuon*)muons->UncheckedAt(i);
      //       CALL TRIGMUO(ISTART,muon->PT(),muon-Px(),trigger)
      //=========>
         static Bool_t printerror = kTRUE;
         if (printerror) {
            Warning("ATLFTriggerMaker","Function TRIGMUO for Muon Trigger Efficiency missing");
            Warning("ATLFTriggerMaker","instead used 100 percent  efficiency");
            printerror = kFALSE;
         }
      trigger=1;
      muon->SetTrigger(trigger);
      if (trigger >= 1) m_MuonEffHighLow->Fill(muon->PT());
      if (trigger == 2) m_MuonEffHigh->Fill(muon->PT());
      m_Counter->Fill(muon->PT());
   }

//........................................................
//.... trigger for isolated electron/photons
//........................................................
   Int_t nTrigA,nTrigB,nTrigC,nTrigD;
   nTrigA = 0;
   nTrigB = 0;
   nTrigC = 0;
   for (i=0;i<nelectrons;i++) {
      electron = (ATLFElectron*)electrons->UncheckedAt(i);
      if (TMath::Abs(electron->Eta()) < m_EPhoEtaCoverage ) {
         if (electron->PT() > m_PTELE) nTrigA++;
         if (electron->PT() > m_PTEM2) nTrigC++;
      }
   }
   for (i=0;i<nphotons;i++) {
      photon = (ATLFPhoton*)photons->UncheckedAt(i);
      if (TMath::Abs(photon->Eta()) < m_EPhoEtaCoverage) {
         if (photon->PT() > m_PTPHO) nTrigB++;
         if (photon->PT() > m_PTEM2) nTrigC++;
      }
   }
   if (nTrigA >= 1) Trig_EM1= kTRUE;
   if (nTrigB >= 1) Trig_PH1= kTRUE;
   if (nTrigC >= 2) Trig_EM2= kTRUE;
   if (Trig_EM1) m_Content->Fill(1.1);
   if (Trig_PH1) m_Content->Fill(2.1);
   if (Trig_EM2) m_Content->Fill(3.1);

//........................................................
//.... trigger for muons
//........................................................
   nTrigA = 0;
   nTrigB = 0;
   nTrigC = 0;
   nTrigD = 0;
   for (i=0;i<nmuons;i++) {
      muon = (ATLFMuon*)muons->UncheckedAt(i);
      if (muon->Trigger() > 0) {
         if (TMath::Abs(muon->Eta()) < m_MuoEtaCoverage) {
            if (muon->PT() > m_PTMU1I && muon->Isolated() == 1) nTrigA++;
            if (muon->PT() > m_PTMU2I && muon->Isolated() == 1 && gATLFast->Luminosity() == 2) nTrigB++;
            if (muon->PT() > m_PTMU1)  nTrigC++;
            if (muon->PT() > m_PTMU2)  nTrigD++;
         }
      }
   }
   if (nTrigA >= 1 || nTrigC >= 1) Trig_MU1 = kTRUE;
   if (nTrigB >= 1 || nTrigD >= 2) Trig_MU2 = kTRUE;
   if (Trig_MU1) m_Content->Fill(4.1);
   if (Trig_MU2) m_Content->Fill(5.1);

//........................................................
//.... trigger for electron-muons pairs
//........................................................
   nTrigA = 0;
   nTrigB = 0;
   for (i=0;i<nelectrons;i++) {
      electron = (ATLFElectron*)electrons->UncheckedAt(i);
      if (TMath::Abs(electron->Eta()) < m_ETAEL1) {
         if (electron->PT() > m_PTEMUE) nTrigA++;
      }
   }
   for (i=0;i<nmuons;i++) {
      muon = (ATLFMuon*)muons->UncheckedAt(i);
      if (TMath::Abs(muon->Eta()) < m_EMuoEtaCoverageM && muon->Trigger() > 0) {
         if (muon->PT() > m_PTEMUM) nTrigB++;
      }
   }
   if (nTrigA >= 1 && nTrigB >= 1) Trig_EMU = kTRUE;
   if (Trig_EMU) m_Counter->Fill(6.1);

//........................................................
//.... trigger for jets
//........................................................
   nTrigA = 0;
   nTrigB = 0;
   nTrigC = 0;
   for (i=0;i<njets;i++) {
      jet = (ATLFJet*)jets->UncheckedAt(i);
      if (TMath::Abs(jet->Eta()) < m_JetEtaCoverage) {
         if (jet->PT() >= m_PTJET1) nTrigA++;
         if (jet->PT() >= m_PTJET3) nTrigB++;
         if (jet->PT() >= m_PTJET4) nTrigC++;
      }
   }
   if (nTrigA >= 1) Trig_JT1 = kTRUE;
   if (nTrigB >= 3) Trig_JT3 = kTRUE;
   if (nTrigC >= 4) Trig_JT4 = kTRUE;
   if (Trig_JT1) m_Content->Fill(7.1);
   if (Trig_JT3) m_Content->Fill(8.1);
   if (Trig_JT4) m_Content->Fill(9.1);

//........................................................
//...any trigger
//........................................................
   if (Trig_EM1 || Trig_PH1 || Trig_EM2 || Trig_MU1 || Trig_MU2 || Trig_EMU
                || Trig_JT1 || Trig_JT3 || Trig_JT4) Trig_ALL= kTRUE;
   if (Trig_ALL) m_Content->Fill(10.1);

//........................................................
//...Save trigger info into Root trigger object
//........................................................
   ATLFTrigger *trig = (ATLFTrigger*)m_Fruits;
   trig->SetEM1(Trig_EM1);
   trig->SetPH1(Trig_PH1);
   trig->SetEM2(Trig_EM2);
   trig->SetMU1(Trig_MU1);
   trig->SetMU2(Trig_MU2);
   trig->SetEMU(Trig_EMU);
   trig->SetJT1(Trig_JT1);
   trig->SetJT3(Trig_JT3);
   trig->SetJT4(Trig_JT4);
   trig->SetALL(Trig_ALL);

   return 0;
}

//_____________________________________________________________________________
 void ATLFTriggerMaker::PrintInfo()
{
   ATLFMaker::PrintInfo();
}