TMarBody.C

Go to the documentation of this file.

// Class TMarBody
//
// Author     : Matti Peez
// Created    : 02/2002
// Last update: $Date: 2005/06/08 11:39:56 $
//          by: $Author: blist $
// Comment: Definition of a reconstructed body with Pt(body) > Pt(min,body)
//          - Pointing to the particle candidate
//          - Type

#ifndef __TMARBODY
#include "Marana/TMarBody.h"
#endif

// Important for ROOT use
ClassImp(TMarBody)

TMarBody::TMarBody(void)
{
// Base constructor
   fE=0;        
   fPt=0;       
   fEta=0;     
   fPhi=0;      
   fIndex = -1;
   fIndexID = -1;
   fSelected = kFALSE;
}
TMarBody::TMarBody(Int_t ID,Int_t indexID,Int_t index)
{
// Constructor with index
   fE=0;        
   fPt=0;       
   fEta=0;     
   fPhi=0;         
   fIndex = index;
   fIndexID = indexID;
   fID = ID;
   fSelected = kFALSE;
}
TMarBody::TMarBody(TMarBody *body){
// Copy information from body

  body->GetEPtEtaPhi(fE,fPt,fEta,fPhi);
  fIndex = body->GetIndex();
  fIndexID = body->GetIndexID();
  fID = body->GetType();
  if (body->IsSel() == kTRUE)
    fSelected = kTRUE;
  else
    fSelected = kFALSE;
}

TMarBody::TMarBody(const Int_t& ID,const Int_t& indexID,const Float_t& E,const
Float_t& Pt,const Float_t &Eta,const Float_t& Phi,const Int_t& index)
{
   fE=E;        
   fPt=Pt;       
   fEta=Eta;     
   fPhi=Phi;         
   fIndex = index;
   fIndexID = indexID;
   fID = ID;
   fSelected = kFALSE;



}
TMarBody::~TMarBody()
{

}


Int_t TMarBody::GetType(void) const
{
// Get type of object

 return(fID);
}

Int_t TMarBody::GetIndex(void) const
{
// Get index of object

 return(fIndex);
}
Int_t TMarBody::GetIndexID(void) const
{
// Get index of object

 return(fIndexID);
} 

Bool_t TMarBody::GetEPtEtaPhi(Float_t &E,Float_t &Pt,Float_t &Eta,Float_t &Phi) const
{
// Set kinematics

  Bool_t selection = kTRUE;

  E = fE;
  Pt = fPt;
  Eta = fEta;
  Phi = fPhi;

  // Check coherence
  if (Pt<=0)
   return(kFALSE);

 return(selection);
}

void TMarBody::SetEPtEtaPhi(Float_t E,Float_t Pt,Float_t Eta,Float_t Phi)
{
// Set kinematics

  fE = E;
  fPt = Pt;
  fEta = Eta;
  fPhi = Phi;
}
Float_t TMarBody::GetE() const
{
// Return E of particle
  
  return(fE);
}
Float_t TMarBody::GetP() const
{
// Return P of particle, up to npw consider m=0 for particle
  
  return(fE);
}

Float_t TMarBody::GetPt()  const
{
// Return pt of particle
  
  return(fPt);
}
Float_t TMarBody::GetEta() const
{
// Return eta of particle
  
  return(fEta);
}

Float_t TMarBody::GetTheta() const
{
// Return eta of particle
  
  return(2.*TMath::ATan(exp(-fEta)));
}


Float_t TMarBody::GetPhi() const
{
// Return phi of particle
  
  return(fPhi);
}

Float_t TMarBody::GetPx() const
{
// Return px of particle
  Float_t Px=this->GetP()*TMath::Sin(this->GetTheta())*TMath::Cos(this->GetPhi());
  return(Px);
}
Float_t TMarBody::GetPy() const
{
// Return px of particle
  Float_t Py=this->GetP()*TMath::Sin(this->GetTheta())*TMath::Sin(this->GetPhi());
  return(Py);
}

Float_t TMarBody::GetPz() const
{
// Return px of particle
  Float_t Pz=this->GetP()*TMath::Cos(this->GetTheta());
  return(Pz);
}


void TMarBody::SetSel(Bool_t selection)
{
// Set selection bit to "selection"

 fSelected = selection;
}


Bool_t TMarBody::IsSel(void)
{
// Is selected ?
 
 return(fSelected);
} 


Int_t TMarBody::Compare(const TObject* body) 
{
// Defines sorting criterion for bodies

    if(!body->InheritsFrom("TMarBody")) {
        Warning("IsEqual","input object must inherit from TMarBody!");
        return kFALSE;
    }
    TMarBody *Body = (TMarBody*) body;
    Float_t Pt = GetPt();
    if (Pt < Body->GetPt()) return 1;
    else if (Pt == Body->GetPt()) return 0;
    else if (Pt > Body->GetPt())  return -1;
    return -99;
}


Bool_t TMarBody::IsEqual(const TMarBody* body) 
{
// Defines sorting criterion for bodies, clusters are 
// considered equal if they have equal pt.

    if(!body->InheritsFrom("TMarBody")) {
        Warning("IsEqual","input object must inherit from TMarBody!");
        return kFALSE;
    }
    TMarBody *Body = (TMarBody*) body;
    if (fPt == Body->GetPt()&&fEta==Body->GetEta()&&fPhi==Body->GetPhi()) 
        return kTRUE;
    return kFALSE;

}


TLorentzVector TMarBody::GetFourVector()
{
   TLorentzVector vect(0,0,0,0);
   vect.SetPtEtaPhiE(fPt,fEta,fPhi,fE);
   return vect;
}

Bool_t TMarBody::IsSortable() const
{
  return kTRUE;
}



Float_t TMarBody::EtaPhiDist(TMarBody *body)
{
// Calculate eta-phi distance between bodies

 Float_t Dist=99999;

 Float_t DiffEta = body->GetEta()-this->GetEta();
 Float_t DiffPhi = TMath::ACos(TMath::Cos(body->GetPhi()-this->GetPhi()));

 Float_t Dist2 = DiffEta*DiffEta + DiffPhi*DiffPhi;
 if (Dist2 > 0.0001) Dist = TMath::Sqrt(Dist2);         
 else Dist = 0;
 

 return Dist;
}



bool TMarBody::operator<(const TMarBody& other){
  return (fPt<other.fPt);

}

---