///////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////
#include <cmath>

#include "TH1F.h"
#include "Stntuple/alg/TStnMuonID.hh"
#include "Stntuple/obj/TStnMuon.hh"
#include "Stntuple/obj/TStnTrack.hh"
#include "Stntuple/alg/TStntuple.hh"

ClassImp(TStnMuonID)

//______________________________________________________________________________
void TStnMuonID::ReadV1 (TBuffer &R__b) {
   // read in V1 of class TStnMuonID.

 struct TStnMuonID_V1_t {
   TObject    fObject;
   Int_t      fDetectorMask;
   Float_t    fMinTrackPt;
   Float_t    fMaxEta;
   Float_t    fMaxEEm;
   Float_t    fMaxEHad;
   Float_t    fMaxCmuDelX;
   Float_t    fMaxCmpDelX;
   Float_t    fMaxCmxDelX;
   Float_t    fMaxBmuDelX;
   Float_t    fMaxCmuDelZ;
   Float_t    fMaxTrackD0;
   Float_t    fMaxTrackZ0;
   Float_t    fMaxCotChi2;
   Float_t    fMaxEIso;
   Float_t    fMaxIso1;
   Float_t    fMaxTIso;
   Float_t    fMinNCotAxSeg;
   Float_t    fMinNCotStSeg;
  } id ;

   id.fObject.Streamer(R__b);
   R__b >> id.fDetectorMask;
   R__b >> id.fMinTrackPt;
   R__b >> id.fMaxEta;
   R__b >> id.fMaxEEm;
   R__b >> id.fMaxEHad;
   R__b >> id.fMaxCmuDelX;
   R__b >> id.fMaxCmpDelX;
   R__b >> id.fMaxCmxDelX;
   R__b >> id.fMaxBmuDelX;
   R__b >> id.fMaxCmuDelZ;
   R__b >> id.fMaxTrackD0;
   R__b >> id.fMaxTrackZ0;
   R__b >> id.fMaxCotChi2;
   R__b >> id.fMaxEIso;
   R__b >> id.fMaxIso1;
   R__b >> id.fMaxTIso;
   R__b >> id.fMinNCotAxSeg;
   R__b >> id.fMinNCotStSeg;
   fUseMask = 0xFFFFFFFF;
//-----------------------------------------------------------------------------
// do copy back it later! however set bc momentum to 0
//-----------------------------------------------------------------------------
   fMinTrackBcPt = 0;
}

//______________________________________________________________________________
void TStnMuonID::ReadV2 (TBuffer &R__b) {
   // read in V2 of class TStnMuonID.

 struct TStnMuonID_V2_t {
   TNamed     fNamed;
   Int_t      fDetectorMask;
   Float_t    fMinTrackPt;
   Float_t    fMaxEta;
   Float_t    fMaxEEm;
   Float_t    fMaxEHad;

   Float_t    fMaxCmuDelX;
   Float_t    fMaxCmpDelX;
   Float_t    fMaxCmxDelX;
   Float_t    fMaxBmuDelX;
   
   Float_t    fMaxCmuDelZ;
   
   Float_t    fMaxTrackD0;
   Float_t    fMaxTrackZ0;
   Float_t    fMaxCotChi2;
   
   Float_t    fMaxEIso;
   Float_t    fMaxIso1;
   Float_t    fMaxTIso;
  
   Float_t    fMinNCotAxSeg;
   Float_t    fMinNCotStSeg;
   
   Float_t    fMinTrackBcPt;
   
   Float_t    fMinLooseTrackPt;
   Float_t    fMaxLooseEEm;
   Float_t    fMaxLooseEHad;
   void*      fEOR;
 } id ;

  int nwi = ((Int_t*  )&id.fMinTrackPt)-&id.fDetectorMask;
  int nwf = ((Float_t*)&id.fEOR       )-&id.fMinTrackPt  ;

  TNamed::Streamer(R__b);
  R__b.ReadFastArray(&fDetectorMask,nwi);
  R__b.ReadFastArray(&fMinTrackPt  ,nwf);
//-----------------------------------------------------------------------------
// do copy back it later! however set bc momentum to 0
//-----------------------------------------------------------------------------
  fMinTrackBcPt  = 0;
  fMinNCotAxHits = 5;
  fMinNCotStHits = 5;
  fUseMask = 0xFFFFFFFF;
}


//_____________________________________________________________________________
void TStnMuonID::ReadV3(TBuffer &R__b) {
   // read in V3 of class TStnMuonID.

 struct TStnMuonID_V2_t {
   TNamed     fNamed;
   Int_t      fDetectorMask;
   Float_t    fMinTrackPt;
   Float_t    fMaxEta;
   Float_t    fMaxEEm;
   Float_t    fMaxEHad;

   Float_t    fMaxCmuDelX;
   Float_t    fMaxCmpDelX;
   Float_t    fMaxCmxDelX;
   Float_t    fMaxBmuDelX;
   
   Float_t    fMaxCmuDelZ;
   
   Float_t    fMaxTrackD0;
   Float_t    fMaxTrackZ0;
   Float_t    fMaxCotChi2;
   
   Float_t    fMaxEIso;
   Float_t    fMaxIso1;
   Float_t    fMaxTIso;
   
   Float_t    fMinNCotAxSeg;
   Float_t    fMinNCotStSeg;
   
   Float_t    fMinTrackBcPt;
   
   Float_t    fMinLooseTrackPt;
   Float_t    fMaxLooseEEm;
   Float_t    fMaxLooseEHad;
   
   Float_t    fMinNCotAxHits;	// min n hits on the segment, added V3
   Float_t    fMinNCotStHits;

   void*      fEOR;		// ! end of record
 } id ;

  int nwi = ((Int_t*  )&id.fMinTrackPt)-&id.fDetectorMask;
  int nwf = ((Float_t*)&id.fEOR       )-&id.fMinTrackPt  ;

  TNamed::Streamer(R__b);
  R__b.ReadFastArray(&fDetectorMask,nwi);
  R__b.ReadFastArray(&fMinTrackPt  ,nwf);
//-----------------------------------------------------------------------------
// do copy back it later! however set bc momentum to 0
//-----------------------------------------------------------------------------
  fMinTrackBcPt  = 0;
  fMinNCotAxHits = 5;
  fMinNCotStHits = 5;
  fUseMask = 0xFFFFFFFF;

}

//______________________________________________________________________________
void TStnMuonID::Streamer(TBuffer &R__b) {
  // Stream an object of class TStnMuonID.

  UInt_t R__s, R__c;

  int nwi = ((Int_t*  )&fMinTrackPt)-&fDetectorMask;
  int nwf = ((Float_t*)&fEOR       )-&fMinTrackPt  ;

  if (R__b.IsReading()) {
    Version_t R__v = R__b.ReadVersion(&R__s, &R__c); 
    if      (R__v == 1) ReadV1(R__b);
    else if (R__v == 2) ReadV2(R__b);
    else if (R__v == 3) ReadV3(R__b);
    else if (R__v == 4) {
      TNamed::Streamer(R__b);
      R__b.ReadFastArray(&fDetectorMask,nwi);
      R__b.ReadFastArray(&fMinTrackPt  ,nwf);
    }
    R__b.CheckByteCount(R__s, R__c, TStnMuonID::IsA());
  } 
  else {
//-----------------------------------------------------------------------------
//  write section
//-----------------------------------------------------------------------------
    R__c = R__b.WriteVersion(TStnMuonID::IsA(), kTRUE);
    TNamed::Streamer(R__b);
    R__b.WriteFastArray(&fDetectorMask,nwi);
    R__b.WriteFastArray(&fMinTrackPt  ,nwf);
    R__b.SetByteCount(R__c, kTRUE);
  }
}

//_____________________________________________________________________________
TStnMuonID::TStnMuonID(const char* Name): TNamed(Name,Name) {
  
  fDetectorMask    = 0xf;
  fMinTrackPt      = 20.;
  fMinTrackBcPt    = 20.;
  fMaxEEm          = 2.;
  fMaxEHad         = 6.;

  fMaxEIso         = 1.e6;
  fMaxIso1         = 0.1;
  fMaxTIso         = 1.e6;

  fMaxCmuDelX      = 3.;
  fMaxCmuDelZ      = 1.e6;
  fMaxCmpDelX      = 5.;
  fMaxCmxDelX      = 6.;
  fMaxBmuDelX      = 1.e6;

  fMinNCotAxSeg    = 3;
  fMinNCotStSeg    = 3;

  fMinNCotAxHits   = 5;
  fMinNCotStHits   = 5;

  fMaxTrackD0      = 0.3;
  fMaxTrackZ0      = 1.e6;
  fMaxCotChi2      = 4.0;

  fMinLooseTrackPt = 10.;
  fMaxLooseEEm     = 2.;
  fMaxLooseEHad    = 6.;
  fUseMask = 0xFFFFFFFF;

  fCalcNCotSeg     = 0;

}


//_____________________________________________________________________________
TStnMuonID::~TStnMuonID() {
}

//_____________________________________________________________________________
int TStnMuonID::IDWord(TStnMuon* Muo) {
  Int_t      id_word = 0;
  Int_t      n_ax_seg, n_st_seg;

  TStnTrack* trk;
  double     pt, bcpt, d0, z0, max_ehad, max_eem, bcp, iso1, cot_chi2;

  TStntuple* stn = TStntuple::Instance();

  trk = Muo->Track();
  if (trk == 0) {
    Error("IDWord","no track defined");
    return -1;
  }
				// pt should be unsiged
  pt   = Muo->Momentum()->Pt();

  if (Muo->TrackBcPt() > 0) {
    bcpt = TMath::Abs(stn->LarrysPt(trk,1));
  }
  else {
//-----------------------------------------------------------------------------
// handle case of the old ntuples with no beam-constrained momentum
//-----------------------------------------------------------------------------
    bcpt = pt;
  }

  bcp = bcpt*Muo->Momentum()->P()/Muo->Momentum()->Pt();

  if (bcp < 100) {
    max_eem  = fMaxEEm;
    max_ehad = fMaxEHad;
  }
  else {
    max_eem  = fMaxEEm+0.0115*(bcp-100);
    max_ehad = fMaxEHad+0.028*(bcp-100 );
  }

  iso1     = Muo->Iso()/bcp;
  cot_chi2 = trk->Chi2Cot()/(trk->NCotHitsTot()-4.9999);

  if ((Muo->Detector() & fDetectorMask) == 0) id_word |= kDetectorBit;
  if (Muo->EmEnergy () > max_eem            ) id_word |= kEEmBit ;
  if (Muo->HadEnergy() > max_ehad           ) id_word |= kEHadBit ;
  if (Muo->Iso      () > fMaxEIso           ) id_word |= kIsoBit;
  if (iso1             > fMaxIso1           ) id_word |= kIso1Bit;
  if (cot_chi2         > fMaxCotChi2        ) id_word |= kCotChi2Bit;
  if (Muo->TIso     () > fMaxTIso           ) id_word |= kTIsoBit;
//-----------------------------------------------------------------------------
//  check residuals
//-----------------------------------------------------------------------------
  if (Muo->HasCmuStub()) {
    if (fabs(Muo->CmuDelX()) > fMaxCmuDelX)   id_word |= kCmuDelXBit;
    if (fabs(Muo->CmuDelZ()) > fMaxCmuDelZ)   id_word |= kCmuDelZBit;
  }

  if (Muo->HasCmpStub()) {
    if (fabs(Muo->CmpDelX()) > fMaxCmpDelX)   id_word |= kCmpDelXBit;
  }

  if (Muo->HasCmxStub()) {
    if (fabs(Muo->CmxDelX()) > fMaxCmxDelX)   id_word |= kCmxDelXBit;
  }
//-----------------------------------------------------------------------------
//  note that track pointer should be set by you!
//-----------------------------------------------------------------------------
  if (trk == NULL) {
					// this should not be happening! 
    id_word |= kTrackPtBit ;
    id_word |= kTrackBcPtBit ;
    id_word |= kTIsoBit; 
    id_word |= kTrackZ0Bit;
    id_word |= kTrackD0Bit;
    id_word |= kCotNAxBit;
    id_word |= kCotNStBit;
    id_word |= kCotChi2Bit;
  }
  else {
    d0       = TStntuple::CorrectedD0(trk);
    z0       = trk->BcZ0();
					// ideally nsegs/nhits should be 
					// precalculated, but ...
    if (fCalcNCotSeg == 0) {
      n_ax_seg = trk->NAxSeg();
      n_st_seg = trk->NStSeg();
    }
    else {
      n_ax_seg = trk->NCotAxSeg(int(fMinNCotAxHits));
      n_st_seg = trk->NCotStSeg(int(fMinNCotStHits));
    }

    if (pt               < fMinTrackPt      ) id_word |= kTrackPtBit ;
    if (bcpt             < fMinTrackBcPt    ) id_word |= kTrackBcPtBit ;
    if (TMath::Abs(d0)   > fMaxTrackD0      ) id_word |= kTrackD0Bit;
    if (TMath::Abs(z0)   > fMaxTrackZ0      ) id_word |= kTrackZ0Bit;
    if (trk->Iso4()      > fMaxTIso         ) id_word |= kTIsoBit;
    if (n_ax_seg         < fMinNCotAxSeg    ) id_word |= kCotNAxBit;
    if (n_st_seg         < fMinNCotStSeg    ) id_word |= kCotNStBit;
  }

  return  (id_word & fUseMask);
}

//_____________________________________________________________________________
int TStnMuonID::TightIDWord(TStnMuon* Muo) {
  int  id_word;
  id_word = IDWord(Muo);
  return id_word;
}


//_____________________________________________________________________________
int TStnMuonID::LooseIDWord(TStnMuon* Muo) {

  double     pt, max_ehad, max_eem, p, d0, z0;
  int        id_word;
  TStnTrack* trk;

  TStntuple* stn = TStntuple::Instance();

  trk = Muo->Track();
					// pt should be unsiged
  id_word  = 0;
  pt       = Muo->Momentum()->Pt();
  p        = Muo->Momentum()->P();
  d0       = TStntuple::CorrectedD0(trk);
  z0       = trk->Z0();

					// same cuts on Eem, Ehad
  max_eem  = fMaxEEm;
  max_ehad = fMaxEHad;
  if (p > 100) {
    max_eem  += 0.0115*(p-100);
    max_ehad += 0.0280*(p-100);
  }

  if (pt               < fMinLooseTrackPt   ) id_word |= kLooseTrackPtBit;
  if (TMath::Abs(d0)   > fMaxTrackD0        ) id_word |= kTrackD0Bit;
  if (TMath::Abs(z0)   > fMaxTrackZ0        ) id_word |= kTrackZ0Bit;
  if (Muo->EmEnergy () > max_eem            ) id_word |= kLooseEEmBit    ;
  if (Muo->HadEnergy() > max_ehad           ) id_word |= kLooseEHadBit   ;

  return (id_word & fUseMask);
}


//_____________________________________________________________________________
void TStnMuonID::FillHistograms(Hist_t& Hist, TStnMuon* Muo) {
//-----------------------------------------------------------------------------
// distributions for ID variables (with n-1 ID cuts applied). 
// Plot 3 sets of histograms:
// --------------------------
// set 1: for all the muons
// set 2: for the parameter given all the rest cuts were successfull
// set 3&4: for the cuts in sequence they are applied
//-----------------------------------------------------------------------------
  double  iso1, pt, bcpt, ch;
  int     id_word;
 
  TStnTrack* trk;
  TStntuple* stn = TStntuple::Instance();

  const TLorentzVector* mom = Muo->Momentum();

  trk = Muo->Track();

  pt   = mom->Pt();
  ch   = Muo->Charge();
  bcpt = TMath::Abs(stn->LarrysPt(trk,1));

  id_word = IDWord(Muo);
//-----------------------------------------------------------------------------
//  1. muon detector
//-----------------------------------------------------------------------------
  Hist.fDetector[0]->Fill(Muo->Detector());
  if ((id_word & ~kDetectorBit) == 0) Hist.fDetector[1]->Fill(Muo->Detector());
  if (id_word == 0) Hist.fDetector[4]->Fill(Muo->Detector());

  Hist.fTrackPt[0]->Fill(pt);
  if ((id_word & ~kTrackPtBit) == 0) Hist.fTrackPt[1]->Fill(pt);
  if (id_word == 0) Hist.fTrackPt[4]->Fill(pt);

  Hist.fTrackBcPt[0]->Fill(bcpt);
  if ((id_word & ~kTrackBcPtBit) == 0) Hist.fTrackBcPt[1]->Fill(bcpt);
  if (id_word == 0) Hist.fTrackBcPt[4]->Fill(bcpt);
//-----------------------------------------------------------------------------
//  1. calorimetry isolation
//-----------------------------------------------------------------------------
  Hist.fEIso[0]->Fill(Muo->Iso());
  if ((id_word & ~kIsoBit) == 0) Hist.fEIso[1]->Fill(Muo->Iso());
  if (id_word == 0) Hist.fEIso[4]->Fill(Muo->Iso());

  iso1 = Muo->Iso()/pt;

  Hist.fIso1[0]->Fill(iso1);
  if ((id_word & ~kIso1Bit) == 0) Hist.fIso1[1]->Fill(iso1);
  if (id_word == 0) Hist.fIso1[4]->Fill(iso1);
//-----------------------------------------------------------------------------
//  2. calorimetry
//-----------------------------------------------------------------------------
  Hist.fHadEnergy[0]->Fill(Muo->HadEnergy());
  if ((id_word & ~kEHadBit) == 0) Hist.fHadEnergy[1]->Fill(Muo->HadEnergy());
  if (id_word == 0) Hist.fHadEnergy[4]->Fill(Muo->HadEnergy());

  Hist.fEmEnergy[0]->Fill(Muo->EmEnergy());
  if ((id_word & ~kEEmBit) == 0) Hist.fEmEnergy[1]->Fill(Muo->EmEnergy());
  if (id_word == 0) Hist.fEmEnergy[4]->Fill(Muo->EmEnergy());
//-----------------------------------------------------------------------------
//  7. CMU residuals
//-----------------------------------------------------------------------------
  if (Muo->HasCmuStub()) {
    Hist.fCmuDelX[0]->Fill(Muo->CmuDelX());
    if ((id_word & ~kCmuDelXBit) == 0) Hist.fCmuDelX[1]->Fill(Muo->CmuDelX());
    if (id_word == 0) Hist.fCmuDelX[4]->Fill(Muo->CmuDelX());

    Hist.fCmuDelZ[0]->Fill(Muo->CmuDelZ());
    if ((id_word & ~kCmuDelZBit) == 0) Hist.fCmuDelZ[1]->Fill(Muo->CmuDelZ());
    if (id_word == 0) Hist.fCmuDelZ[4]->Fill(Muo->CmuDelZ());
  }
//-----------------------------------------------------------------------------
//  8. CMP residuals
//-----------------------------------------------------------------------------
  if (Muo->HasCmpStub()) {
    Hist.fCmpDelX[0]->Fill(Muo->CmpDelX());
    if ((id_word & ~kCmpDelXBit) == 0) Hist.fCmpDelX[1]->Fill(Muo->CmpDelX());
    if (id_word == 0) Hist.fCmpDelX[4]->Fill(Muo->CmpDelX());
  }
//-----------------------------------------------------------------------------
//  9. CMX residuals
//-----------------------------------------------------------------------------
  if (Muo->HasCmxStub()) {
    Hist.fCmxDelX[0]->Fill(Muo->CmxDelX());
    if ((id_word & ~kCmxDelXBit) == 0) Hist.fCmxDelX[1]->Fill(Muo->CmxDelX());
    if (id_word == 0) Hist.fCmxDelX[4]->Fill(Muo->CmxDelX());
  }
//-----------------------------------------------------------------------------
// 10. fill track histograms - cut on corrected D0
//-----------------------------------------------------------------------------
  Hist.fTIso[0]->Fill(Muo->TIso());
  if ((id_word & ~kTIsoBit) == 0) Hist.fTIso[1]->Fill(Muo->TIso());
  if (id_word == 0) Hist.fTIso[4]->Fill(Muo->TIso());

  double d0_corr;
  int    n_ax_hits, n_st_hits;

  int it = Muo->TrackNumber(); 
  if (it < 0) {
//-----------------------------------------------------------------------------
// muon track is not defined
//-----------------------------------------------------------------------------
    d0_corr   = 1.e6;
    n_ax_hits = -1;
    n_st_hits = -1;
  }
  else {
//-----------------------------------------------------------------------------
// muon has a track
//-----------------------------------------------------------------------------
    trk       = Muo->Track();
    d0_corr   = TStntuple::CorrectedD0(trk);
    n_ax_hits = trk->NCotHitsAx();
    n_st_hits = trk->NCotHitsSt();
  }

  Hist.fTrackD0[0]->Fill(d0_corr);
  if ((id_word & ~kTrackD0Bit) == 0) Hist.fTrackD0[1]->Fill(d0_corr);
  if (id_word == 0) Hist.fTrackD0[4]->Fill(d0_corr);

  Hist.fTrackZ0[0]->Fill(Muo->Z0());
  if ((id_word & ~kTrackZ0Bit) == 0) Hist.fTrackZ0[1]->Fill(Muo->Z0());
  if (id_word == 0) Hist.fTrackZ0[4]->Fill(Muo->Z0());

  Hist.fCotNAxHits[0]->Fill(n_ax_hits);
  if ((id_word & ~kCotNAxBit) == 0) Hist.fCotNAxHits[1]->Fill(n_ax_hits);
  if (id_word == 0) Hist.fCotNAxHits[4]->Fill(n_ax_hits);

  Hist.fCotNStHits[0]->Fill(n_st_hits);
  if ((id_word & ~kCotNStBit) == 0) Hist.fCotNStHits[1]->Fill(n_st_hits);
  if (id_word == 0) Hist.fCotNStHits[4]->Fill(n_st_hits);
//-----------------------------------------------------------------------------
//  single histogram showing how often every particular cut failed
//-----------------------------------------------------------------------------
  for (int bit=0; bit<32; bit++) {
    if (((id_word >> bit) & 0x1) == 1) {
      Hist.fFailedBits->Fill(bit);
    }
  }
  Hist.fPassed->Fill(id_word == 0);
//-----------------------------------------------------------------------------
//  ***** now histogram effect of cuts in the order they are applied
//-----------------------------------------------------------------------------
  Hist.fDetector[2]->Fill(Muo->Detector());
  if ((id_word & kDetectorBit) != 0)                        goto END;
  Hist.fDetector[3]->Fill(Muo->Detector());

  Hist.fTrackPt[2]->Fill(pt);
  if ((id_word & kTrackPtBit) != 0)                         goto END;
  Hist.fTrackPt[3]->Fill(pt);

  Hist.fEIso[2]->Fill(Muo->Iso());
  if ((id_word & kIsoBit) != 0)                             goto END;
  Hist.fEIso[3]->Fill(Muo->Iso());

  Hist.fIso1[2]->Fill(Muo->TIso());
  if ((id_word & kIso1Bit) != 0)                            goto END;
  Hist.fIso1[3]->Fill(Muo->TIso());

  Hist.fHadEnergy[2]->Fill(Muo->HadEnergy());
  if ((id_word & kEHadBit) != 0)                            goto END;
  Hist.fHadEnergy[3]->Fill(Muo->HadEnergy());

  Hist.fEmEnergy[2]->Fill(Muo->EmEnergy());
  if ((id_word & kEEmBit) != 0)                             goto END;
  Hist.fEmEnergy[3]->Fill(Muo->EmEnergy());

  if (Muo->HasCmuStub()) {
    Hist.fCmuDelX[2]->Fill(Muo->CmuDelX());
    if ((id_word & kCmuDelXBit) != 0)                       goto END;
    Hist.fCmuDelX[3]->Fill(Muo->CmuDelX());

    Hist.fCmuDelZ[2]->Fill(Muo->CmuDelZ());
    if ((id_word & kCmuDelZBit) != 0)                       goto END;
    Hist.fCmuDelZ[3]->Fill(Muo->CmuDelZ());
  }

  Hist.fTrackD0[2]->Fill(d0_corr);
  if ((id_word & kTrackD0Bit) != 0)                         goto END;
  Hist.fTrackD0[3]->Fill(d0_corr);

  Hist.fTrackZ0[2]->Fill(Muo->Z0());
  if ((id_word & kTrackZ0Bit) != 0)                         goto END;
  Hist.fTrackZ0[3]->Fill(Muo->Z0());

  Hist.fCotNAxHits[2]->Fill(n_ax_hits);
  if ((id_word & kCotNAxBit) != 0)                          goto END;
  Hist.fCotNAxHits[3]->Fill(n_ax_hits);

  Hist.fCotNStHits[2]->Fill(n_st_hits);
  if ((id_word & kCotNStBit) != 0)                          goto END;
  Hist.fCotNStHits[3]->Fill(n_st_hits);

  Hist.fTrackBcPt[2]->Fill(bcpt);
  if ((id_word & kTrackBcPtBit) != 0)                       goto END;
  Hist.fTrackBcPt[3]->Fill(bcpt);

 END:;
}

//_____________________________________________________________________________
void TStnMuonID::Print(const char* Opt) const {
  printf("-----------------------------------------------------\n");
  printf("      muon ID cuts                                   \n");
  printf("-----------------------------------------------------\n");
  printf(" bit  0: fDetectorMask   = %d\n",    fDetectorMask );
  printf(" bit  1: fMaxEEm         = %12.4f\n",fMaxEEm       );
  printf(" bit  2: fMaxEHad        = %12.4f\n",fMaxEHad      );
  printf(" bit  3: fMaxCmuDelX     = %12.4f\n",fMaxCmuDelX   );
  printf(" bit  4: fMaxCmpDelX     = %12.4f\n",fMaxCmpDelX   );
  printf(" bit  5: fMaxCmxDelX     = %12.4f\n",fMaxCmxDelX   );
  printf(" bit  6: fMaxBmuDelX     = %12.4f\n",fMaxBmuDelX   );
  printf(" bit  7: fMaxEIso        = %12.4f\n",fMaxEIso      );
  printf(" bit  8: fMaxIso1        = %12.4f\n",fMaxIso1      );
  printf(" bit  9: fMaxTIso        = %12.4f\n",fMaxTIso      );
  printf(" bit 10: fMinTrackPt     = %12.4f\n",fMinTrackPt   );
  printf(" bit 11: fMinNCotAxSeg   = %12.4f\n",fMinNCotAxSeg );
  printf(" bit 12: fMinNCotStSeg   = %12.4f\n",fMinNCotStSeg );
  printf(" bit 13: fMaxTrackZ0     = %12.4f\n",fMaxTrackZ0   );
  printf(" bit 14: fMaxTrackD0     = %12.4f\n",fMaxTrackD0   );
  printf(" bit 15: fMaxCmuDelZ     = %12.4f\n",fMaxCmuDelZ   );
  printf(" bit 16: fMaxCotChi2     = %12.4f\n",fMaxCotChi2   );
  printf(" bit 17: fMinTrackBcPt   = %12.4f\n",fMinTrackBcPt );

  printf(" bit 18: fMinLooseTrackPt= %12.4f\n",fMinLooseTrackPt);
  printf(" bit 19: fMaxLooseEEm    = %12.4f\n",fMaxLooseEEm    );
  printf(" bit 20: fMaxLooseEHad   = %12.4f\n",fMaxLooseEHad   );
}