H1ElecCalibration.C

Go to the documentation of this file.

/***************************************************************************
                          H1ElecCalibration.C  -  description
    begin                : Fri Jul 15 2003
    last update          : $Date: 2005/01/14 16:29:37 $ (UTC)
    by                   : $Author: sauvan $
 ***************************************************************************/

/***************************************************************************
                                   based on

                          H1JetCalibration.C  -  description
                             -------------------
    begin                : Fri Jun 14 2002
    copyright            : (C) 2002 by Nicole Werner
    email                : nwerner@mail.desy.de

 ***************************************************************************/

/***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
***************************************************************************/

#ifndef __H1ELECCALIBRATION_H
#include "H1ElecCalibration.h"
#endif

#include <iostream>

ClassImp(H1ElecCalibration)
  //------------------------------------------------------
  // This class is for application of electron energy calibration coefficients
  //
  // More details to come
  //


H1ElecCalibration::H1ElecCalibration(Bool_t DoStackWiseCalibration,
                                     Bool_t DoZimpactWiseCalibration,
                                     Bool_t DoResolutionSmearing,
                                     Bool_t UseTrackTheta, Bool_t UseTrackPhi)
{
  // Constructor
  // Takes decisions on whether to use cluster/track theta & phi in constructor

  bUseTrackTheta = UseTrackTheta;
  bUseTrackPhi = UseTrackPhi;

  bDoStackWiseCalibration = DoStackWiseCalibration;
  bDoZimpactWiseCalibration = DoZimpactWiseCalibration;
  bDoForwardWheelWiseCalibration = DoZimpactWiseCalibration;  // FIXME
  //  bDoForwardWheelWiseCalibration = false;  // FIXME
  bDoResolutionSmearing = DoResolutionSmearing;

  fExtrapol = new H1CalcTrackExtrapol();

  fCalibration = 0;

  // data members to store electron information passed into this class
  fElectronTrack = TLorentzVector(0,0,0,0);
  fElectronCluster = TLorentzVector(0,0,0,0);
  fCalibratedElectron = TLorentzVector(0,0,0,0);

  fCharge = 0;
  fLinkedTrackType = 0;

  // data members to store electron information determined by this class
  fElectronTheta = 0.0;
  fElectronPhi = 0.0;

}

H1ElecCalibration::~H1ElecCalibration()
{
  // Destructor

  if ( fExtrapol != 0 ) delete fExtrapol;  
}

const TLorentzVector& H1ElecCalibration::GetElecCalibration(const TLorentzVector& UncalibratedElectron,
                                                            const TLorentzVector& ElectronTrack,
                                                            Int_t Charge, Float_t ZVertex,
                                                            Bool_t IsMC, Int_t RunPeriod,
                                                            Int_t LinkedTrackType)
{
  // Get calibrated electron object with user steered calibration constants

  // set data members
  fElectronTrack = (TLorentzVector)ElectronTrack;
  fElectronCluster = (TLorentzVector)UncalibratedElectron;
  fCharge = Charge;
  fLinkedTrackType = LinkedTrackType;
  
  // static local variables, i.e. wannabe data members
  static TVector3 impactPositon(0.0,0.0,0.0);

  // Get calibration parameters for different run periods...

  // ... for data
  if (!IsMC) {

    if (RunPeriod == 5){
      // Do 9900
      static H1LarCalParameters* Calibration = new H1LarCalParameters("9900", RunPeriod);
      fCalibration = Calibration;
    } else if (RunPeriod == 7 || RunPeriod == 6){ // good for 0203 or 0304?
      // Do 0304
      static H1LarCalParameters* Calibration = new H1LarCalParameters("0304", RunPeriod);
      fCalibration = Calibration;
    } else if (RunPeriod < 5){
      // 94-99 not supported
      Warning("GetElecCalibration", "Run Period not supported. Taking no calibration.");
      static H1LarCalParameters* Calibration = new H1LarCalParameters("Default");
      fCalibration = Calibration;
    } else {
      // Unknown Run Period
      Warning("GetElecCalibration", "No valid Run Period. Taking default CalibrationParameters 9900.");
      static H1LarCalParameters* Calibration = new H1LarCalParameters("9900");
      fCalibration = Calibration;
    }
    
  }
  // ...for monte carlo
  else {
    
    if (RunPeriod == 5){
      // Do 99MC
      static H1LarCalParameters* Calibration = new H1LarCalParameters("99MC", RunPeriod);
      fCalibration = Calibration;
    } else if (RunPeriod == 6 || RunPeriod == 7){  // compare 03MC with 0304 only?
      // use 03MC monte carlo
      static H1LarCalParameters* Calibration = new H1LarCalParameters("03MC", RunPeriod);
      fCalibration = Calibration;
   } else if (RunPeriod < 5){
      // 94-99 not supported
      Warning("GetElecCalibration", "Run Period not supported. Taking no calibration.");
      static H1LarCalParameters* Calibration = new H1LarCalParameters("Default");
      fCalibration = Calibration;
    } else {
      // Unknown Run Period
      Warning("GetElecCalibration", "No valid Run Period. Taking default CalibrationParameters 99MC.");
      static H1LarCalParameters* Calibration = new H1LarCalParameters("99MC");
      fCalibration = Calibration;
    }
  }


  //
  // **********************************************************************
  // **********************************************************************
  //


  if (bDoStackWiseCalibration) {
    
    // Wheel-Octant based calibration
    

    //
    //    Calculate Zimpact, PhiImpact
    //

    impactPositon = fExtrapol->MakeImpactPosition(GetElectronVector(), fCharge);

    Float_t zImpact = impactPositon.Z();
    Float_t extrapolPhi = impactPositon.Phi();
    

    // Apply correction

    Float_t Correction = 1.0 / fCalibration->GetOctantCalibrationFactor(extrapolPhi, zImpact);
    fElectronCluster *= Correction;
    
  }
  
  
  //
  // **********************************************************************
  // **********************************************************************
  //
  

  if (bDoZimpactWiseCalibration) {
    
    // Zimpact based calibration


    //
    //    Calculate Zimpact
    //

    impactPositon = fExtrapol->MakeImpactPosition(GetElectronVector(), fCharge);

    Float_t zImpact = impactPositon.Z();


    // Apply correction

    Float_t Correction = 1.0 / fCalibration->GetZimpactCalibrationFactor(zImpact);
    fElectronCluster *= Correction;

  }


  //
  // **********************************************************************
  // **********************************************************************
  //
  

  
  if (bDoForwardWheelWiseCalibration) {
    
    // calibration of forward wheels
    

    //
    //    Calculate Zimpact
    //
    
    impactPositon = fExtrapol->MakeImpactPosition(GetElectronVector(), fCharge);

    Float_t zImpact = impactPositon.Z();


    // Apply correction
    
    Float_t Correction = fCalibration->GetForwardWheelCalibrationFactor(zImpact);
    fElectronCluster *= Correction;

  }


  //
  // **********************************************************************
  // **********************************************************************
  //
  

  //
  // Smear by difference in resolutions
  //
  
  if (bDoResolutionSmearing  && IsMC) {


    //
    //    Calculate Zimpact
    //

    impactPositon = fExtrapol->MakeImpactPosition(GetElectronVector(), fCharge);

    Float_t zImpact = impactPositon.Z();

  
    // Apply smearing    
    Float_t Correction = fCalibration->GetResolutionSmearingFactor(zImpact);
    fElectronCluster *= Correction;

  }

  //
  // **********************************************************************
  // **********************************************************************
  //
  
  fCalibratedElectron = fElectronCluster;
  return fCalibratedElectron;
  
}

void H1ElecCalibration::MakeVertexElectron()
{
  // Determines the electron theta and phi at the vertex, 
  // according to user steering and track quality.

  // What about charge?  Unconditionally accepting (verified) track charge.

  // Theta
  fElectronTheta = 0.;
  if ( bUseTrackTheta && IsGoodTrack() ){  // do not use theta from bad tracks
    fElectronTheta = fElectronTrack.Theta();
  } else {
    fElectronTheta = fElectronCluster.Theta();
  }
  
  // 
  // Electron Phi at the event vertex
  //

  fElectronPhi = 0.;
  if ( bUseTrackPhi && IsGoodTrack() ){  // do not use phi from bad tracks
    fElectronPhi = fElectronTrack.Phi();
  } else {
    // back-extrapolate phi from cluster center back to vertex
    // WARNING this may lead to inconsistency as forward-extrapolate with H1HelixExtrapolation

    Float_t phiLAr = fElectronCluster.Phi();
    Float_t dPhi   = fExtrapol->MakeExtrapolatedPhi(fElectronCluster.P(),
                                                    fElectronTheta, phiLAr, fCharge) - phiLAr;
    fElectronPhi   = phiLAr - dPhi; // minus sign because of back-extrapolation
    
  }
  
}

const TLorentzVector& H1ElecCalibration::GetElectronVector()
{
  // accessor for the electron TLorentzVector at the vertex
  
  static TLorentzVector electron;
  
  //
  // Determine theta and phi of electron four-vector (at vertex)
  //

  MakeVertexElectron();


  // Now construct the four-vector

  Double_t elecP = fElectronCluster.P();
  
  Double_t elecPx = elecP * TMath::Sin(fElectronTheta)*TMath::Cos(fElectronPhi);
  Double_t elecPy = elecP * TMath::Sin(fElectronTheta)*TMath::Sin(fElectronPhi);
  Double_t elecPz = elecP * TMath::Cos(fElectronTheta);
  
  electron.SetPxPyPzE(elecPx, elecPy, elecPz, elecP);  // tiny mass inconsistency
  
  return electron;
}

Bool_t H1ElecCalibration::IsGoodTrack()
{
  // evaluates quality of linked track
  return (fLinkedTrackType < 1 || fLinkedTrackType > 2  || 
          fElectronCluster.Theta() < (30.0*TMath::Pi()/180.0) 
          ) ? kFALSE : kTRUE;
}

---