H1LarCalParameters.C

Go to the documentation of this file.

/***************************************************************************
                          H1LarCalParameters.C

                                based on

                          H1CalibParameters.C  -  description
                             -------------------
    begin                : Fri Jun 13 2002
    copyright            : (C) 2002 by Nicole Werner
    email                : nwerner@mail.desy.de
    last update          : $Date: 2005/01/14 16:29:37 $ (UTC)
    by                   : $Author: sauvan $

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

/***************************************************************************
*                                                                         *
*   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 __H1LARCALPARAMETERS_H
#include "H1LarCalParameters.h"
#endif

#include "TMath.h"
#include "H1Steering/H1SteerManager.h"
#include <iostream>

ClassImp(H1LarCalParameters)

//------------------------------------------------------

H1LarCalParameters::H1LarCalParameters(TString DataSet, Int_t RunPeriod)
{
  // Constructor

  fDataSet = DataSet;
  fRunPeriod = RunPeriod;
  fRunPeriodName = "";

  fOctantConstants = new H1ArrayF(32);
  fZimpactConstants = new H1ArrayF(208);
  fForwardWheelConstants = new H1ArrayF(6);
  fEnergyResolutionConstantsData = new H1ArrayF(57); // size???
  fEnergyResolutionConstantsMC = new H1ArrayF(57); // size???

  fOctantCalibrationFactor = 1.0;
  fZimpactCalibrationFactor = 1.0;
  fForwardWheelCalibrationFactor = 1.0;
  fResolutionSmearingFactor = 1.0;

  fRandom = new TRandom(1);

  Reset();
}

H1LarCalParameters::~H1LarCalParameters()
{
  // Destructor

  if (fOctantConstants) {
    delete fOctantConstants;
  }
  if (fZimpactConstants) {
    delete fZimpactConstants;
  }
  if (fForwardWheelConstants) {
    delete fForwardWheelConstants;
  }
  if (fEnergyResolutionConstantsData) {
    delete fEnergyResolutionConstantsData;
  }
  if (fEnergyResolutionConstantsMC) {
    delete fEnergyResolutionConstantsMC;
  }

  if (fRandom) {
    delete fRandom;
  }

}

void H1LarCalParameters::Reset()
{
  // Reset the boolean flags - Use to Read in new parameters

  bReadOctantConstants = false;
  bReadZimpactConstants = false;
  bReadForwardWheelConstants = false;
  bReadEnergyResolutionConstants = false;
}


void H1LarCalParameters::SetCalibrationParametersFile(TString filename)
{
  // Sets up the gH1SteerManager with the given steering file

  if (fRunPeriod == 5) {
    fRunPeriodName = "9900";
  } else if (fRunPeriod == 6 || fRunPeriod == 7) {
    fRunPeriodName = "0304";
  } else {
    Warning("SetCalibrationParametersFile", "RunPeriod %i not supported.  Set to 9900.", fRunPeriod);
    fRunPeriodName = "9900";
  }

//   TString filePath = "H1ElecCalibration/";
  TString filePath = "./";
  filename.Append(fRunPeriodName);
  filename.Append(".steer");
  filePath.Append(filename);  
  gH1SteerManager->SetFilename(filePath);
  
  gH1SteerManager->SetClassname("H1LarCalParameters");
}

Double_t H1LarCalParameters::GetOctantCalibrationFactor(Float_t &phi, Float_t &zimpact)
{
  // Get the phi dependent calibration factor for LAr electrons
  // The factor depends on the Wheel and the Octant within that wheel
  SetOctantConstants();
  SetOctantCalibrationFactors(phi, zimpact);
  return fOctantCalibrationFactor;
}

Double_t H1LarCalParameters::GetZimpactCalibrationFactor(Float_t &zimpact)
{
  // Get the zimpact dependent calibration factor for LAr electrons
  SetZimpactConstants();
  SetZimpactCalibrationFactors(zimpact);
  return fZimpactCalibrationFactor;
}

Double_t H1LarCalParameters::GetForwardWheelCalibrationFactor(Float_t &zimpact)
{
  // Get the calibration factor for LAr electrons in forward wheels
  SetForwardWheelConstants();
  SetForwardWheelCalibrationFactors(zimpact);
  return fForwardWheelCalibrationFactor;
}

Double_t H1LarCalParameters::GetResolutionSmearingFactor(Float_t &zimpact)
{
  // Get the zimpact dependent smearing factor for MC
  SetEnergyResolutionConstants();
  SetResolutionSmearingFactors(zimpact);
  return fResolutionSmearingFactor;
}

void H1LarCalParameters::SetOctantConstants()
{
  // Read in the Wheel + Octant dependent constants from the H1SteerManager
  
  if (!bReadOctantConstants) {
    bReadOctantConstants = true;


    if ( (fDataSet.CompareTo("Default"))==0 ) {
      // Set default array for 94-98 data, no calibration applied
      fOctantConstants->Reset(1.0);
      return;
    }

    SetCalibrationParametersFile("LarCalStackFactors");
    TString steerName = "NStack";
    steerName.Append(fDataSet);

    Float_t phiConstants[32];
    gH1SteerManager->ReadArray(steerName,phiConstants);

    fOctantConstants->Set(32, phiConstants);
  }
}

void H1LarCalParameters::SetZimpactConstants()
{
  // Read in the Zimpact dependent constants from the H1SteerManager
  
  if (!bReadZimpactConstants) {
    bReadZimpactConstants = true;


    if ( (fDataSet.CompareTo("Default"))==0 ) {
      // Set default array for 94-98 data, no calibration applied
      fZimpactConstants->Reset(1.0);
      return;
    }

    SetCalibrationParametersFile("LarCalZimpactFactors");
    TString steerName = "Zimpact";
    steerName.Append(fDataSet);

    Float_t zimpactConstants[286];
    gH1SteerManager->ReadArray(steerName,zimpactConstants);

    fZimpactConstants->Set(286, zimpactConstants);
  }
}

void H1LarCalParameters::SetForwardWheelConstants()
{
  // Read in the zimpact dependent constants for the forward wheels from the H1SteerManager
  
  if (!bReadForwardWheelConstants) {
    bReadForwardWheelConstants = true;


    if ( (fDataSet.CompareTo("Default"))==0 ) {
      // Set default array for 94-98 data, no calibration applied
      fForwardWheelConstants->Reset(1.0);
      return;
    }

    SetCalibrationParametersFile("LarCalForwardWheelFactors");
    TString steerName = "ForwardWheel";
    steerName.Append(fDataSet);

    Float_t forwardwheelConstants[6];
    gH1SteerManager->ReadArray(steerName,forwardwheelConstants);

    fForwardWheelConstants->Set(6, forwardwheelConstants);
  }

}

void H1LarCalParameters::SetEnergyResolutionConstants()
{
  // Read in the data/mc energy resolutions from the H1SteerManager

  if (!bReadEnergyResolutionConstants) {
    bReadEnergyResolutionConstants=true;
    
    SetCalibrationParametersFile("LarCalResFactors");
    TString steerName = "Res";
    TString steerNameData(steerName + fRunPeriodName);  // run period e.g. 9900 (Data)
    TString steerNameMC(steerName + fDataSet);  // dataset here is e.g. 99NC (Django)

    Float_t energyResolutionConstantsData[57];
    gH1SteerManager->ReadArray(steerNameData,energyResolutionConstantsData);
    Float_t energyResolutionConstantsMC[57];
    gH1SteerManager->ReadArray(steerNameMC,energyResolutionConstantsMC);

    fEnergyResolutionConstantsData->Set(57, energyResolutionConstantsData);
    fEnergyResolutionConstantsMC->Set(57, energyResolutionConstantsMC);

  }
}

void H1LarCalParameters::SetOctantCalibrationFactors(Float_t &phi, Float_t &zimpact)
{
  // returns the octant dependent calibration factor
  
  Int_t nOctant = SetLarOctant(phi);
  Int_t nWheel = SetLarWheel(zimpact);
  Int_t nStack = (nWheel * 8) + nOctant;

  if (nStack < 0) {
    cout << "NWheel = " << nWheel << "\t"
         << "NOctant = " << nOctant << endl;
    cout << "Phi = " << phi << "\t"
         << "zImpact = " << zimpact << endl;
  }

  if (nWheel < 4)
    fOctantCalibrationFactor = fOctantConstants->At(nStack);
  else
    fOctantCalibrationFactor = 1.0;
}

void H1LarCalParameters::SetZimpactCalibrationFactors(Float_t &zimpact)
{
  // returns the zimpact dependent calibration factor

  Int_t zStep = SetLarZBin(zimpact, 1);

  if ( (zStep-190) >= -190 && (zStep-190) < 95)
    fZimpactCalibrationFactor = fZimpactConstants->At(zStep);
  else
    fZimpactCalibrationFactor = 1.0;

}

void H1LarCalParameters::SetForwardWheelCalibrationFactors(Float_t &zimpact)
{
  // returns the zimpact dependent calibration factor for forward wheels

  Int_t zStep = SetForwardWheelZBin(zimpact);

  fForwardWheelCalibrationFactor = 1.0;
  
  if (zStep>=0)
    fForwardWheelCalibrationFactor += fForwardWheelConstants->At(zStep);
}

void H1LarCalParameters::SetResolutionSmearingFactors(Float_t &zimpact)
{
  // Smear MC according according difference in resolution with data
  // Shamelessly stolen from H1CalibElec

  Float_t Sigma = -1.0;

  if(zimpact >= -190.0 && zimpact < 0) {
    Int_t zBin = SetLarZBin(zimpact, 5);
    
    //  Smear MC if resolution better than in data
    if(fEnergyResolutionConstantsData->At(zBin) > fEnergyResolutionConstantsMC->At(zBin))

      Sigma=TMath::Sqrt(TMath::Power(fEnergyResolutionConstantsData->At(zBin),2)-
                        TMath::Power(fEnergyResolutionConstantsMC->At(zBin),2));

  } else if(zimpact>=0&&zimpact<20) 
    Sigma=0.028;
  else if(zimpact>=20&&zimpact<95) 
    Sigma=0.028;
  else
    Sigma=0.036;
  
  if(Sigma>0.001)
    fResolutionSmearingFactor = fRandom->Gaus(1,Sigma);       // apply smearing
  else
    fResolutionSmearingFactor = 1.0;
}

Int_t H1LarCalParameters::SetLarOctant(Float_t &phi)
{
  // returns the Octant in the LAr corresponding to the phi position
  
  // Transform -180 < phi < 180 to 0 < phi < 360
  phi += TMath::Pi();
  
  // Label each 45.0 octant of phi as 0...7
  Int_t nOctant = Int_t(TMath::Floor( phi / (TMath::Pi()/4.0) )); // Round down and convert to Int_t
  
  return nOctant;
}

Int_t H1LarCalParameters::SetLarWheel(Float_t &zimpact)
{
  // Returns the wheel in the LAr corresponding to zimpact
  // wheel boundaries copied from H1Calculator/H1Constants

  Int_t nWheel = 100;

  if ( zimpact < -152.5 ) {
    nWheel = 0;
  } else if ( zimpact < -60 ){
    nWheel = 1;
  } else if ( zimpact < 20 ){
    nWheel = 2;
  } else if ( zimpact < 95 ){
    nWheel = 3;
  } else if ( zimpact < 300 ){
    nWheel = 4;
  } else if ( zimpact < FLT_MAX ){
    nWheel = 5;
  } else  {
    Warning("GetLarWheel", ("zImpact %d not inside LAr!"), zimpact);
  }
  
  return nWheel;
}

Int_t H1LarCalParameters::SetLarZBin(Float_t &zimpact, Int_t binsize)
{
  // returns the Zimpact position of the electron in the Lar, in binsize cm bins
  Int_t zStep = (Int_t)TMath::Floor(zimpact/binsize);
  zStep += 190 / binsize;

  return zStep;
}

Int_t H1LarCalParameters::SetForwardWheelZBin(Float_t &zimpact)
{
  // returns the forward wheel corresponding to the Zimpact position of the electron

  Int_t zStep=-1;

  // hardwired numbers for forward Lar geometry taken from H1CalibElec,
  // presumably taken from lotus++/electronphan/qcalelar.F
  if(zimpact>=95.0&&zimpact<120.0)
    zStep=0;
  else if(zimpact>=120.0 && zimpact<180.0)
    zStep=1;
  else if(zimpact>=180 && zimpact<215)
    zStep=2;
  else if(zimpact>=215 && zimpact<290)
    zStep=3;
  else if(zimpact>=290 && zimpact<320)
    zStep=4;
  else if(zimpact>=320)
    zStep=5;

  return zStep;
}

---