TMBTau.cpp

Go to the documentation of this file.

// File:  TMBTau.cpp
//
//                                                                      //
// TMBTree Taus class                                                   //
//                                                                      //

#include "tmb_tree/TMBTau.hpp"
#include "tmb_tree/TMBTrack.hpp"

ClassImp(TMBTau);


//_____________________________________________________________________________
TMBTau::TMBTau(Float_t px, Float_t py, Float_t pz, Float_t E,
                   TRefArray* cpsptr, TRefArray* fpsptr, 
                  TRefArray* tracks, TRef& vtxref,
                  Float_t rms, Float_t profile, Float_t emf,
                  Float_t icdf, Float_t chf, Float_t hot,
                  Int_t flag, 
                  Int_t* iq, Float_t* fq,
                  Float_t et_7, Float_t et_3, 
                  Float_t EM12_Et, Float_t EM12_Et_core,
                  Float_t EM3_Et, Float_t EM3_Et_core,
                  Float_t EM4_Et, Float_t EM4_Et_core, 
               Int_t typ): _nnout(-1.0), _nnelec(-1.0)
{
  Set(px, py, pz, E, 
      cpsptr, fpsptr, tracks, vtxref,
      rms, profile, emf, icdf, chf, hot,
      flag,
      iq, fq, et_7, et_3, 
      EM12_Et, EM12_Et_core,
      EM3_Et, EM3_Et_core, EM4_Et,
      EM4_Et_core, typ);
}
void TMBTau::Set(Float_t px, Float_t py, Float_t pz, Float_t E, 
                  TRefArray* cpsptr, TRefArray* fpsptr,
                  TRefArray* tracks, TRef& vtxref,
                  Float_t rms, Float_t profile, Float_t emf,
                  Float_t icdf, Float_t chf, Float_t hot,
                   Int_t flag,
                  Int_t* iq, Float_t *fq,
                  Float_t et_7, Float_t et_3, 
                  Float_t EM12_Et, Float_t EM12_Et_core,
                  Float_t EM3_Et, Float_t EM3_Et_core, Float_t EM4_Et, 
                  Float_t EM4_Et_core, Int_t typ)

{
  SetPxPyPzE(px, py, pz,E);

  _vtxref    = vtxref;
  _rms       = rms;
  _profile   = profile;
  _emf       = emf;
  _icdf      = icdf;
  _chf       = chf;
  _hot       = hot;
  _flag      = flag;
 
  _nnout=0.;
   _nclus=iq[2];
   // fill fq explicitly
   _ett1=fq[0];
   _ett2=fq[1];
   _ett3=fq[2];
   _mtrk=fq[3];
   _ettr=fq[4];
   _empt=fq[5];
   _emm=fq[6];
   _emeta=fq[7];
   _emphi=fq[8];
   _tzDCA=fq[9];
   _teta=fq[10];
   _tphi=fq[11];
   _tphiPS=fq[12]+fq[11];
   _tphiEM3=fq[13]+fq[11];
   _emcl_eta1=fq[14];
   _emcl_eta2=fq[15];
   _emcl_phi1=fq[16];
   _emcl_phi2=fq[17];
   _emcl_et1=fq[18];
   _emcl_et2=fq[19];

   _pseta=fq[24];
   _psphi=fq[25];
   _e1e2=fq[26];
   _dalpha=fq[27];

   _emcl_f12=fq[31];
   _emcl_f3=fq[32];
   _emcl_f4=fq[33];

  _et_7           = et_7;
  _et_3           = et_3;
  _EM12_Et        = EM12_Et;
  _EM12_Et_core   = EM12_Et_core;
  _EM3_Et         = EM3_Et;
  _EM3_Et_core    = EM3_Et_core;
  _EM4_Et         = EM4_Et;
  _EM4_Et_core    = EM4_Et_core;
  _typ            = typ;


  _tracks.Clear();
    if (tracks) {
      for (int i=0; i<tracks->GetLast()+1; i++) {
        _tracks.Add( tracks->At(i) );
      }
    }

  _cpsptr.Clear();
    if (cpsptr) {
      for (int i=0; i<cpsptr->GetLast()+1; i++) {
        _cpsptr.Add( cpsptr->At(i) );
      }
    }

    _fpsptr.Clear();
    if (fpsptr) {
      for (int i=0; i<fpsptr->GetLast()+1; i++) {
        _fpsptr.Add( fpsptr->At(i) );
      }
    }

}

Float_t TMBTau::charge()const{
  int ntrks=ntrk();
  float q=0;
  for(int i=0; i<ntrks; ++i){
    q+=GetChargedTrack(i)->charge();
  }
  return q;
}
    

// calculate tau detector eta
Float_t TMBTau::etad() const {
  float z=vz();
  if(fabs(z)<100.) return det_eta(z,Pz(),ET());
  return 10.0;
}

// get tau vz
Float_t TMBTau::vz() const {
  float z=1000.;
  const TMBTrack* trk=GetChargedTrack(0);
  if(trk) z=trk->z();
  //std::cout<<"ttau vz="<<vz<<std::endl;
  return z;
}

Float_t TMBTau::det_eta(float z, float pz, float pT) const {
  float dz=120.*pz/pT+z;
  if(fabs(dz)<150.0){
    float l=sqrt(14400.0+dz*dz);
    return 0.5*log((l+dz) / (l-dz)); 
  }else{
    int sign=give_sign(pz);
    dz=sign*150.0;
    float r=(dz-z)*pT/pz;
    float l=sqrt(r*r+22500);
    return 0.5*log((l+dz)/(l-dz));
  }
}


//______________________________________________________________________________

---