ZIterativeAlgorithmWithFit Class Reference

#include <ZIterativeAlgorithmWithFit.h>

List of all members.

Classes
struct	ZIterativeAlgorithmWithFitPlots
Public Member Functions
bool	addEvent (calib::CalibElectron *, calib::CalibElectron *, float)
const std::vector< float > &	getEpsilonSum () const
const ZIterativeAlgorithmWithFitPlots *	getHistos () const
int	getNumberOfChannels () const
int	getNumberOfIterations () const
const std::vector< float > &	getOptimizedChiSquare () const
const std::vector< float > &	getOptimizedCoefficients () const
const std::vector< float > &	getOptimizedCoefficientsError () const
const std::vector< int > &	getOptimizedIterations () const
const std::vector< float > &	getWeightSum () const
bool	iterate ()
ZIterativeAlgorithmWithFit &	operator= (const ZIterativeAlgorithmWithFit &r)
	Assignment operator.
bool	resetIteration ()
	ZIterativeAlgorithmWithFit (const edm::ParameterSet &ps)
	Constructor with explicit iterations & exponent.
	ZIterativeAlgorithmWithFit ()
	Default constructor.
virtual	~ZIterativeAlgorithmWithFit ()
	Destructor.
Static Public Member Functions
static float	cosTheta12 (float Eta1, float Phi1, float Eta2, float Phi2)
static void	gausfit (TH1F *histoou, double *par, double *errpar, float nsigmalow, float nsigmaup, double *mychi2, int *iterations)
static float	invMassCalc (float Energy1, float Eta1, float Phi1, float Energy2, float Eta2, float Phi2)
Private Member Functions
void	addWeightsCorrections (unsigned int event_id)
void	bookHistograms ()
float	getEventWeight (unsigned int event_id)
void	getStatWeights (const std::string &file)
void	getWeight (unsigned int evid, calib::CalibElectron *ele, float)
void	getWeight (unsigned int evid, std::pair< calib::CalibElectron *, calib::CalibElectron * >, float)
void	recalculateMasses ()
void	recalculateWeightsEnergies (calib::CalibElectron *electron)
void	recalculateWeightsEnergies ()
Private Attributes
std::vector< float >	calib_fac_
TString	calibType_
unsigned int	channels_
unsigned int	currentEvent_
unsigned int	currentIteration_
std::vector< std::pair < calib::CalibElectron *, calib::CalibElectron * > >	electrons_
std::vector< float >	Event_Weight_
std::string	massMethod
std::vector< float >	massReco_
int	nCrystalCut_
unsigned int	numberOfIterations_
std::vector< float >	optimizedChiSquare_
std::vector< float >	optimizedCoefficients_
std::vector< float >	optimizedCoefficientsError_
std::vector< int >	optimizedIterations_
std::vector< float >	StatWeights_
ZIterativeAlgorithmWithFitPlots *	thePlots_
unsigned int	totalEvents_
bool	UseStatWeights_
std::vector< float >	weight_sum_
std::string	WeightFileName_
Static Private Attributes
static const double	M_Z_ = 91.187

---

Detailed Description

Class that implements an iterative in situ calibration algorithm using Z events Author: paolo.meridiani@roma1.infn.it

Definition at line 30 of file ZIterativeAlgorithmWithFit.h.

---

Constructor & Destructor Documentation

ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFit

(

)

Default constructor.

Definition at line 47 of file ZIterativeAlgorithmWithFit.cc.

References calib_fac_, channels_, currentEvent_, currentIteration_, electrons_, massReco_, numberOfIterations_, optimizedChiSquare_, optimizedCoefficients_, optimizedCoefficientsError_, optimizedIterations_, totalEvents_, and weight_sum_.

{
  // std::cout<< "ZIterativeAlgorithmWithFit::Called Construnctor" << std::endl;
  numberOfIterations_=10;
  channels_=1;
  totalEvents_=0;
  currentEvent_=0;
  currentIteration_=0;
  optimizedCoefficients_.resize(channels_);
  optimizedCoefficientsError_.resize(channels_);
  optimizedChiSquare_.resize(channels_);
  optimizedIterations_.resize(channels_);
  calib_fac_.resize(channels_);
  weight_sum_.resize(channels_);
  electrons_.resize(1);
  massReco_.resize(1);
}

ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFit

(

const edm::ParameterSet &

ps

)

Constructor with explicit iterations & exponent.

Definition at line 65 of file ZIterativeAlgorithmWithFit.cc.

References bookHistograms(), calib_fac_, calibType_, channels_, gather_cfg::cout, currentEvent_, currentIteration_, EcalIndexingTools::getInstance(), EcalIndexingTools::getNumberOfChannels(), getStatWeights(), edm::ParameterSet::getUntrackedParameter(), massMethod, EcalRingCalibrationTools::N_MODULES_BARREL, EcalRingCalibrationTools::N_RING_TOTAL, nCrystalCut_, numberOfIterations_, optimizedChiSquare_, optimizedCoefficients_, optimizedCoefficientsError_, optimizedIterations_, StatWeights_, AlCaHLTBitMon_QueryRunRegistry::string, thePlots_, totalEvents_, UseStatWeights_, weight_sum_, and WeightFileName_.

{
  //std::cout<< "ZIterativeAlgorithmWithFit::Called Constructor" << std::endl;
  numberOfIterations_=ps.getUntrackedParameter<unsigned int>("maxLoops",0);
  massMethod = ps.getUntrackedParameter<std::string>("ZCalib_InvMass","SCMass");
  calibType_= ps.getUntrackedParameter<std::string>("ZCalib_CalibType","RING"); 

  if (calibType_ == "RING")
    channels_ = EcalRingCalibrationTools::N_RING_TOTAL;
  else if (calibType_ == "MODULE")


    channels_ = EcalRingCalibrationTools::N_MODULES_BARREL;  
  else if (calibType_ == "ABS_SCALE")
    channels_ = 1;  
  else if(calibType_ == "ETA_ET_MODE")
    channels_ = EcalIndexingTools::getInstance()->getNumberOfChannels();

  std::cout << "[ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFit] channels_ = " << channels_ << std::endl;

  nCrystalCut_=ps.getUntrackedParameter<int>("ZCalib_nCrystalCut",-1);

  //Resetting currentEvent & iteration
  currentEvent_=0;
  currentIteration_=0;
  totalEvents_=0;

  optimizedCoefficients_.resize(channels_);
  optimizedCoefficientsError_.resize(channels_);
  optimizedChiSquare_.resize(channels_);
  optimizedIterations_.resize(channels_);
  calib_fac_.resize(channels_);
  weight_sum_.resize(channels_);

  //Creating and booking histograms
  thePlots_ = new ZIterativeAlgorithmWithFitPlots;
  bookHistograms();

  //Setting up rescaling if needed
  UseStatWeights_=ps.getUntrackedParameter<bool>("ZCalib_UseStatWeights",false);
  if (UseStatWeights_) {
    WeightFileName_="weights.txt";
    StatWeights_.resize(channels_);
    getStatWeights(WeightFileName_);
    //    Event_Weight_.resize(events);
  }
}

ZIterativeAlgorithmWithFit::~ZIterativeAlgorithmWithFit

(

)

[virtual]

Destructor.

Definition at line 362 of file ZIterativeAlgorithmWithFit.cc.

{

}

---

Member Function Documentation

bool ZIterativeAlgorithmWithFit::addEvent	(	calib::CalibElectron *	ele1,
		calib::CalibElectron *	ele2,
		float	invMassRescFactor
	)

Definition at line 253 of file ZIterativeAlgorithmWithFit.cc.

References gather_cfg::cout, currentEvent_, SLHCCaloTriggerAnalysisOnData_cfi::Electrons, reco::LeafCandidate::eta(), calib::CalibElectron::getRecoElectron(), getWeight(), invMassCalc(), massMethod, massReco_, reco::LeafCandidate::phi(), reco::GsfElectron::superCluster(), and totalEvents_.

Referenced by ZeeCalibration::duringLoop().

{
  totalEvents_++;
  std::pair<calib::CalibElectron*, calib::CalibElectron*> Electrons(ele1, ele2);
#ifdef DEBUG
  std::cout  << "In addEvent " ;
  std::cout << ele1->getRecoElectron()->superCluster()->rawEnergy() << " " ;
  std::cout << ele1->getRecoElectron()->superCluster()->position().eta() << " " ;
  std::cout << ele2->getRecoElectron()->superCluster()->rawEnergy() << " " ;
  std::cout << ele2->getRecoElectron()->superCluster()->position().eta() << " " ;
  std::cout << std::endl;
#endif

  if (massMethod == "SCTRMass" )
    {
      massReco_.push_back(invMassCalc(ele1->getRecoElectron()->superCluster()->energy(), ele1->getRecoElectron()->eta(), ele1->getRecoElectron()->phi(), ele2->getRecoElectron()->superCluster()->energy(), ele2->getRecoElectron()->eta(), ele2->getRecoElectron()->phi()));
    }

  else if (massMethod == "SCMass" )
    {
      massReco_.push_back(invMassCalc(ele1->getRecoElectron()->superCluster()->energy(), ele1->getRecoElectron()->superCluster()->position().eta(), ele1->getRecoElectron()->superCluster()->position().phi(), ele2->getRecoElectron()->superCluster()->energy(), ele2->getRecoElectron()->superCluster()->position().eta(), ele2->getRecoElectron()->superCluster()->position().phi()));
    }  
  
#ifdef DEBUG
  std::cout << "Mass calculated " << massReco_[currentEvent_] << std::endl;
#endif

  if((ele2->getRecoElectron()->superCluster()->position().eta() > -10.) && (ele2->getRecoElectron()->superCluster()->position().eta() < 10.) && 
     (ele2->getRecoElectron()->superCluster()->position().phi() > -10.) && (ele2->getRecoElectron()->superCluster()->position().phi() < 10.)) {
    getWeight(currentEvent_, Electrons, invMassRescFactor);
  }

  currentEvent_++;
  return kTRUE;
}

void ZIterativeAlgorithmWithFit::addWeightsCorrections

(

unsigned int

event_id

)

[private]

void ZIterativeAlgorithmWithFit::bookHistograms

(

)

[private]

Definition at line 115 of file ZIterativeAlgorithmWithFit.cc.

References channels_, MAX_RESCALE, MIN_RESCALE, NBINS_HIGHETA, NBINS_LOWETA, numberOfIterations_, thePlots_, ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFitPlots::unweightedRescaleFactor, ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFitPlots::weight, and ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFitPlots::weightedRescaleFactor.

Referenced by ZIterativeAlgorithmWithFit().

{
  if (!thePlots_)
    return;

  for (unsigned int i2 = 0; i2 < numberOfIterations_; i2++) {
    for (unsigned int i1 = 0; i1 < channels_; i1++) {
      char histoName[200];
      char histoTitle[200];

      //WeightedRescaling factor
      sprintf(histoName, "WeightedRescaleFactor_channel_%d_Iteration_%d",i1, i2);
      sprintf(histoTitle, "WeightedRescaleFactor Channel_%d Iteration %d",i1, i2);
      if (i1>15 && i1<155)
        thePlots_->weightedRescaleFactor[i2][i1] = new TH1F(histoName, histoTitle, NBINS_LOWETA, MIN_RESCALE, MAX_RESCALE);
      else
        thePlots_->weightedRescaleFactor[i2][i1] = new TH1F(histoName, histoTitle, NBINS_HIGHETA, MIN_RESCALE, MAX_RESCALE);
      thePlots_->weightedRescaleFactor[i2][i1]->GetXaxis()->SetTitle("Rescale factor");
      thePlots_->weightedRescaleFactor[i2][i1]->GetYaxis()->SetTitle("a.u.");

      //UnweightedRescaling factor
      sprintf(histoName, "UnweightedRescaleFactor_channel_%d_Iteration_%d",i1, i2);
      sprintf(histoTitle, "UnweightedRescaleFactor Channel_%d Iteration %d",i1, i2);
      if (i1>15 && i1<155)
        thePlots_->unweightedRescaleFactor[i2][i1] = new TH1F(histoName, histoTitle, NBINS_LOWETA, MIN_RESCALE, MAX_RESCALE);
      else
        thePlots_->unweightedRescaleFactor[i2][i1] = new TH1F(histoName, histoTitle, NBINS_HIGHETA, MIN_RESCALE, MAX_RESCALE);
      thePlots_->unweightedRescaleFactor[i2][i1]->GetXaxis()->SetTitle("Rescale factor");
      thePlots_->unweightedRescaleFactor[i2][i1]->GetYaxis()->SetTitle("a.u.");

      //Weights
      sprintf(histoName, "Weight_channel_%d_Iteration_%d",i1, i2);
      sprintf(histoTitle, "Weight Channel_%d Iteration %d",i1, i2);
      thePlots_->weight[i2][i1] = new TH1F(histoName, histoTitle, 100, 0., 1.);
      thePlots_->weight[i2][i1]->GetXaxis()->SetTitle("Weight");
      thePlots_->weight[i2][i1]->GetYaxis()->SetTitle("a.u.");
    }
  }
}

static float ZIterativeAlgorithmWithFit::cosTheta12	(	float	Eta1,
		float	Phi1,
		float	Eta2,
		float	Phi2
	)		[inline, static]

Definition at line 84 of file ZIterativeAlgorithmWithFit.h.

References funct::cos().

Referenced by invMassCalc().

                                                                                 {
    return ((cos(Phi1 - Phi2) + sinh(Eta1) * sinh(Eta2)) / (cosh(Eta1) * cosh(Eta2)));
  }

void ZIterativeAlgorithmWithFit::gausfit	(	TH1F *	histoou,
		double *	par,
		double *	errpar,
		float	nsigmalow,
		float	nsigmaup,
		double *	mychi2,
		int *	iterations
	)		[static]

Definition at line 367 of file ZIterativeAlgorithmWithFit.cc.

References gather_cfg::cout, p1, and createPayload::suffix.

Referenced by ZeeCalibration::endOfLoop(), and iterate().

                                                                                                                                                   {
  TF1 *gausa = new TF1("gausa","gaus",histoou->GetMean()-3*histoou->GetRMS(),histoou->GetMean()+3*histoou->GetRMS());
  
  gausa->SetParameters(histoou->GetMaximum(),histoou->GetMean(),histoou->GetRMS());
  
  histoou->Fit("gausa","qR0N");
  
  double p1    = gausa->GetParameter(1);
  double sigma = gausa->GetParameter(2);
  double nor   = gausa->GetParameter(0);
    
  double xmi=p1-5*sigma;
  double xma=p1+5*sigma;
  double chi2=100;
  
  double xmin_fit=p1-nsigmalow*sigma;
  double xmax_fit=p1+nsigmaup*sigma;
  
  int iter=0;
  TF1* fitFunc;

  while ((chi2>1. && iter<5) || iter<2 )
    {
      xmin_fit=p1-nsigmalow*sigma;
      xmax_fit=p1+nsigmaup*sigma;
      xmi=p1-5*sigma;
      xma=p1+5*sigma;
      
      char suffix[20];
      sprintf (suffix,"_iter_%d",iter); 
      fitFunc = new TF1("FitFunc"+TString(suffix),"gaus",xmin_fit,xmax_fit);
      fitFunc->SetParameters(nor,p1,sigma);
      fitFunc->SetLineColor((int)(iter+1));
      fitFunc->SetLineWidth(1);
      //histoou->Fit("FitFunc","lR+","");
      histoou->Fit("FitFunc"+TString(suffix),"qR0+","");
      
      histoou->GetXaxis()->SetRangeUser(xmi,xma);
      histoou->GetXaxis()->SetLabelSize(0.055);
      
      //      std::cout << fitFunc->GetParameters() << "," << par << std::endl;
      par[0]=(fitFunc->GetParameters())[0];
      par[1]=(fitFunc->GetParameters())[1];
      par[2]=(fitFunc->GetParameters())[2];
      errpar[0]=(fitFunc->GetParErrors())[0];
      errpar[1]=(fitFunc->GetParErrors())[1];
      errpar[2]=(fitFunc->GetParErrors())[2];
      if (fitFunc->GetNDF()!=0)
        {
          chi2=fitFunc->GetChisquare()/(fitFunc->GetNDF());
          *myChi2 = chi2;
 
        }
      else
        {
          chi2=100.;
//           par[0]=-99;
//           par[1]=-99;
//           par[2]=-99;
          std::cout << "WARNING: Not enough NDF" << std::endl;
//           return 0;
        }

      // Non visualizzare
      //      histoou->Draw();
      //      c1->Update();

      //      std::cout << "iter " << iter << " chi2 " << chi2 << std::endl;
      nor=par[0];
      p1=par[1];
      sigma=par[2];
      iter++;
      *iterations = iter;

    }
  return;
}

const std::vector<float>& ZIterativeAlgorithmWithFit::getEpsilonSum

(

)

const [inline]

Definition at line 76 of file ZIterativeAlgorithmWithFit.h.

References calib_fac_.

{ return calib_fac_; }

float ZIterativeAlgorithmWithFit::getEventWeight

(

unsigned int

event_id

)

[private]

Definition at line 296 of file ZIterativeAlgorithmWithFit.cc.

                                                                      {

  return 1.;
}

const ZIterativeAlgorithmWithFitPlots* ZIterativeAlgorithmWithFit::getHistos

(

)

const [inline]

Definition at line 60 of file ZIterativeAlgorithmWithFit.h.

References thePlots_.

Referenced by ZeeCalibration::endOfJob(), and ZeeRescaleFactorPlots::writeHistograms().

{ return thePlots_; }

int ZIterativeAlgorithmWithFit::getNumberOfChannels

(

)

const [inline]

Definition at line 64 of file ZIterativeAlgorithmWithFit.h.

References channels_.

Referenced by ZeeCalibration::duringLoop(), ZeeCalibration::endOfJob(), ZeeCalibration::endOfLoop(), and ZeeRescaleFactorPlots::writeHistograms().

{ return channels_; }

int ZIterativeAlgorithmWithFit::getNumberOfIterations

(

)

const [inline]

Definition at line 62 of file ZIterativeAlgorithmWithFit.h.

References numberOfIterations_.

Referenced by ZeeCalibration::endOfJob(), and ZeeRescaleFactorPlots::writeHistograms().

{ return numberOfIterations_; }

const std::vector<float>& ZIterativeAlgorithmWithFit::getOptimizedChiSquare

(

)

const [inline]

Definition at line 70 of file ZIterativeAlgorithmWithFit.h.

References optimizedChiSquare_.

Referenced by ZeeCalibration::endOfLoop().

{ return optimizedChiSquare_; }

const std::vector<float>& ZIterativeAlgorithmWithFit::getOptimizedCoefficients

(

)

const [inline]

Definition at line 66 of file ZIterativeAlgorithmWithFit.h.

References optimizedCoefficients_.

Referenced by ZeeCalibration::endOfLoop().

{ return optimizedCoefficients_; }

const std::vector<float>& ZIterativeAlgorithmWithFit::getOptimizedCoefficientsError

(

)

const [inline]

Definition at line 68 of file ZIterativeAlgorithmWithFit.h.

References optimizedCoefficientsError_.

Referenced by ZeeCalibration::endOfLoop().

{ return optimizedCoefficientsError_; }

const std::vector<int>& ZIterativeAlgorithmWithFit::getOptimizedIterations

(

)

const [inline]

Definition at line 72 of file ZIterativeAlgorithmWithFit.h.

References optimizedIterations_.

Referenced by ZeeCalibration::endOfLoop().

{ return optimizedIterations_; }

void ZIterativeAlgorithmWithFit::getStatWeights

(

const std::string &

file

)

[private]

Definition at line 155 of file ZIterativeAlgorithmWithFit.cc.

References channels_, gather_cfg::cout, cmsRelvalreport::exit, i, and StatWeights_.

Referenced by ZIterativeAlgorithmWithFit().

                                                                     {
  ifstream statfile;
  statfile.open(file.c_str());
  if (!statfile) {
    std::cout << "ZIterativeAlgorithmWithFit::FATAL: stat weight  file " << file << " not found" << std::endl;
    exit(-1);
  }
  for(unsigned int i=0;i<channels_;i++) {
    int imod;
    statfile >> imod >> StatWeights_[i];
    //std::cout << "Read Stat Weight for module " << imod << ": " <<  StatWeights_[i] << std::endl;
  }
}

void ZIterativeAlgorithmWithFit::getWeight	(	unsigned int	evid,
		calib::CalibElectron *	ele,
		float	evweight
	)		[private]

Definition at line 301 of file ZIterativeAlgorithmWithFit.cc.

References calib_fac_, calibType_, channels_, gather_cfg::cout, currentIteration_, first, calib::CalibElectron::getRecoElectron(), massReco_, MAX_RESCALE, MIN_RESCALE, mod(), nCrystalCut_, edm::second(), reco::GsfElectron::superCluster(), thePlots_, ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFitPlots::unweightedRescaleFactor, ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFitPlots::weight, weight_sum_, and ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFitPlots::weightedRescaleFactor.

                                                                                                         {
  //  std::cout<< "getting weight for module " << module << " in electron " << ele << std::endl;

  std::vector< std::pair<int,float> > modules=(*ele).getCalibModulesWeights(calibType_); 

  for (int imod=0; imod< (int) modules.size(); imod++) {

    int mod = (int) modules[imod].first;
    
    if (mod< (int) channels_ && mod>=0) {

      if (modules[imod].second >= 0.12 && modules[imod].second < 10000.) 
        {
          if( (nCrystalCut_ == -1) || ((!(mod <= nCrystalCut_ - 1 )) &&
                                     !((mod > (19-nCrystalCut_)) && (mod <= (19+nCrystalCut_))) &&
                                     !((mod > (39-nCrystalCut_)) && (mod <= (39+nCrystalCut_))) &&
                                     !((mod > (59-nCrystalCut_)) && (mod <= (59+nCrystalCut_))) &&
                                     !((mod > (84-nCrystalCut_)) && (mod <= (84+nCrystalCut_))) &&
                                     !((mod > (109-nCrystalCut_)) && (mod <= (109+nCrystalCut_))) &&
                                     !((mod > (129-nCrystalCut_)) && (mod <= (129+nCrystalCut_))) &&
                                     !((mod > (149-nCrystalCut_)) && (mod <= (149+nCrystalCut_))) &&
                                     !(mod > (169-nCrystalCut_))))
            {

              float weight2 = modules[imod].second / ele->getRecoElectron()->superCluster()->rawEnergy();
#ifdef DEBUG
              std::cout << "w2 " << weight2 << std::endl;
#endif
              if (weight2>=0. && weight2<=1.)
                {

                  float rescale = (TMath::Power((massReco_[event_id] / evweight), 2.) - 1) / 2.;
#ifdef DEBUG
                  std::cout << "rescale " << rescale << std::endl;                
#endif
                  if (rescale>= MIN_RESCALE && rescale<=MAX_RESCALE)
                    {
                      calib_fac_[mod] += weight2 * rescale;
                      weight_sum_[mod]+= weight2;

                      thePlots_->weightedRescaleFactor[currentIteration_][mod]->Fill(rescale,weight2);
                      thePlots_->unweightedRescaleFactor[currentIteration_][mod]->Fill(rescale,1.);
                      thePlots_->weight[currentIteration_][mod]->Fill(weight2,1.);
                    }
                  else
                    {
                      std::cout     << "[ZIterativeAlgorithmWithFit]::[getWeight]::rescale out " << rescale << std::endl;
                    }
                }

            }
        }
    } 
    else 
      {
        std::cout << "ZIterativeAlgorithmWithFit::FATAL:found a wrong module_id " << mod << " channels " << channels_ << std::endl;
      }
  }
}

void ZIterativeAlgorithmWithFit::getWeight	(	unsigned int	evid,
		std::pair< calib::CalibElectron *, calib::CalibElectron * >	elepair,
		float	invMassRescFactor
	)		[private]

Definition at line 290 of file ZIterativeAlgorithmWithFit.cc.

Referenced by addEvent().

{
  getWeight(event_id, elepair.first, invMassRescFactor);
  getWeight(event_id, elepair.second, invMassRescFactor);
}

const std::vector<float>& ZIterativeAlgorithmWithFit::getWeightSum

(

)

const [inline]

Definition at line 74 of file ZIterativeAlgorithmWithFit.h.

References weight_sum_.

{ return weight_sum_; }

static float ZIterativeAlgorithmWithFit::invMassCalc	(	float	Energy1,
		float	Eta1,
		float	Phi1,
		float	Energy2,
		float	Eta2,
		float	Phi2
	)		[inline, static]

Definition at line 80 of file ZIterativeAlgorithmWithFit.h.

References cosTheta12(), and mathSSE::sqrt().

Referenced by addEvent(), ZeeKinematicTools::calculateZMass_noTK(), ZeeKinematicTools::calculateZMass_withTK(), ZeeKinematicTools::calculateZMassWithCorrectedElectrons_noTK(), and ZeeKinematicTools::calculateZMassWithCorrectedElectrons_withTK().

                                                                                                                {
    return (sqrt(2 * Energy1 * Energy2 * (1 - cosTheta12(Eta1, Phi1, Eta2, Phi2))));
  }

bool ZIterativeAlgorithmWithFit::iterate

(

)

Definition at line 184 of file ZIterativeAlgorithmWithFit.cc.

References calib_fac_, channels_, gather_cfg::cout, currentIteration_, gausfit(), i, MAX_RESCALE, MIN_RESCALE, nCrystalCut_, optimizedChiSquare_, optimizedCoefficients_, optimizedCoefficientsError_, optimizedIterations_, thePlots_, weight_sum_, and ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFitPlots::weightedRescaleFactor.

Referenced by ZeeCalibration::endOfLoop().

{

  //Found optimized coefficients
  for (int i=0;i<(int)channels_;i++) 
    { 

      //RP      if (weight_sum_[i]!=0. && calib_fac_[i]!=0.) {
      if( (nCrystalCut_ == -1) || ((!(i <=  nCrystalCut_ -1 )) &&
                                  !((i > (19-nCrystalCut_)) && (i <= (19+nCrystalCut_))) &&
                                  !((i > (39-nCrystalCut_)) && (i <= (39+nCrystalCut_))) &&
                                  !((i > (59-nCrystalCut_)) && (i <= (59+nCrystalCut_))) &&
                                  !((i > (84-nCrystalCut_)) && (i <= (84+nCrystalCut_))) &&
                                  !((i > (109-nCrystalCut_)) && (i <= (109+nCrystalCut_))) &&
                                  !((i > (129-nCrystalCut_)) && (i <= (129+nCrystalCut_))) &&
                                  !((i > (149-nCrystalCut_)) && (i <= (149+nCrystalCut_))) &&
                                  !(i > (169-nCrystalCut_))))
        {
          if (weight_sum_[i]!=0.) {
            //optimizedCoefficients_[i] = calib_fac_[i]/weight_sum_[i];
            
            double gausFitParameters[3], gausFitParameterErrors[3], gausFitChi2;
            int gausFitIterations;
            
            gausfit( (TH1F*)thePlots_->weightedRescaleFactor[currentIteration_][i], gausFitParameters, gausFitParameterErrors, 2.5, 2.5, &gausFitChi2, &gausFitIterations );
            
            float peak=gausFitParameters[1];
            float peakError=gausFitParameterErrors[1];
            float chi2 = gausFitChi2;
            
            int iters = gausFitIterations;
                  
            optimizedCoefficientsError_[i] = peakError;
            optimizedChiSquare_[i] = chi2;
            optimizedIterations_[i] = iters;
            
            if (peak >=MIN_RESCALE && peak <= MAX_RESCALE)
              optimizedCoefficients_[i] = 1 / (1 + peak);
            else
              optimizedCoefficients_[i] = 1 / (1 + calib_fac_[i]/weight_sum_[i]);
          
          } else {
            optimizedCoefficients_[i]=1.;
            optimizedCoefficientsError_[i] = 0.;
            optimizedChiSquare_[i] = -1.;
            optimizedIterations_[i] = 0;
          }

        }

      else
        {
          optimizedCoefficientsError_[i] = 0.;
          optimizedCoefficients_[i]=1.;
          optimizedChiSquare_[i] = -1.;
          optimizedIterations_[i] = 0;
//        EcalCalibMap::getMap()->setRingCalib(i, optimizedCoefficients_[i]);
//        //      initialCoefficients_[i] *= optimizedCoefficients_[i];
        }
      
      std::cout << "ZIterativeAlgorithmWithFit::run():Energy Rescaling Coefficient for region " 
                << i << " is "  << optimizedCoefficients_[i] << ", with error "<<optimizedCoefficientsError_[i]<<" - number of events: " << weight_sum_[i] << std::endl;
    }
  
  currentIteration_++;
  return kTRUE;
}    

ZIterativeAlgorithmWithFit& ZIterativeAlgorithmWithFit::operator=

(

const ZIterativeAlgorithmWithFit &

r

)

[inline]

Assignment operator.

Definition at line 47 of file ZIterativeAlgorithmWithFit.h.

                                                                             {
    return *this;
  }

void ZIterativeAlgorithmWithFit::recalculateMasses

(

)

[private]

void ZIterativeAlgorithmWithFit::recalculateWeightsEnergies

(

calib::CalibElectron *

electron

)

[private]

void ZIterativeAlgorithmWithFit::recalculateWeightsEnergies

(

)

[private]

bool ZIterativeAlgorithmWithFit::resetIteration

(

)

Definition at line 170 of file ZIterativeAlgorithmWithFit.cc.

References calib_fac_, channels_, currentEvent_, i, massReco_, totalEvents_, and weight_sum_.

Referenced by ZeeCalibration::startingNewLoop().

{
  totalEvents_=0;
  currentEvent_=0;
  
  //Reset correction
  massReco_.clear();
  for (unsigned int i=0;i<channels_;i++) calib_fac_[i]=0.;
  for (unsigned int i=0;i<channels_;i++) weight_sum_[i]=0.;

  return kTRUE;
}    

---

Member Data Documentation

std::vector<float> ZIterativeAlgorithmWithFit::calib_fac_ [private]

Definition at line 131 of file ZIterativeAlgorithmWithFit.h.

Referenced by getEpsilonSum(), getWeight(), iterate(), resetIteration(), and ZIterativeAlgorithmWithFit().

TString ZIterativeAlgorithmWithFit::calibType_ [private]

Definition at line 145 of file ZIterativeAlgorithmWithFit.h.

Referenced by getWeight(), and ZIterativeAlgorithmWithFit().

unsigned int ZIterativeAlgorithmWithFit::channels_ [private]

Definition at line 120 of file ZIterativeAlgorithmWithFit.h.

Referenced by bookHistograms(), getNumberOfChannels(), getStatWeights(), getWeight(), iterate(), resetIteration(), and ZIterativeAlgorithmWithFit().

unsigned int ZIterativeAlgorithmWithFit::currentEvent_ [private]

Definition at line 124 of file ZIterativeAlgorithmWithFit.h.

Referenced by addEvent(), resetIteration(), and ZIterativeAlgorithmWithFit().

unsigned int ZIterativeAlgorithmWithFit::currentIteration_ [private]

Definition at line 125 of file ZIterativeAlgorithmWithFit.h.

Referenced by getWeight(), iterate(), and ZIterativeAlgorithmWithFit().

std::vector< std::pair<calib::CalibElectron*,calib::CalibElectron*> > ZIterativeAlgorithmWithFit::electrons_ [private]

Definition at line 127 of file ZIterativeAlgorithmWithFit.h.

Referenced by ZIterativeAlgorithmWithFit().

std::vector<float> ZIterativeAlgorithmWithFit::Event_Weight_ [private]

Definition at line 143 of file ZIterativeAlgorithmWithFit.h.

const double ZIterativeAlgorithmWithFit::M_Z_ = 91.187 [static, private]

Definition at line 147 of file ZIterativeAlgorithmWithFit.h.

std::string ZIterativeAlgorithmWithFit::massMethod [private]

Definition at line 137 of file ZIterativeAlgorithmWithFit.h.

Referenced by addEvent(), and ZIterativeAlgorithmWithFit().

std::vector<float> ZIterativeAlgorithmWithFit::massReco_ [private]

Definition at line 133 of file ZIterativeAlgorithmWithFit.h.

Referenced by addEvent(), getWeight(), resetIteration(), and ZIterativeAlgorithmWithFit().

int ZIterativeAlgorithmWithFit::nCrystalCut_ [private]

Definition at line 118 of file ZIterativeAlgorithmWithFit.h.

Referenced by getWeight(), iterate(), and ZIterativeAlgorithmWithFit().

unsigned int ZIterativeAlgorithmWithFit::numberOfIterations_ [private]

Definition at line 122 of file ZIterativeAlgorithmWithFit.h.

Referenced by bookHistograms(), getNumberOfIterations(), and ZIterativeAlgorithmWithFit().

std::vector<float> ZIterativeAlgorithmWithFit::optimizedChiSquare_ [private]

Definition at line 134 of file ZIterativeAlgorithmWithFit.h.

Referenced by getOptimizedChiSquare(), iterate(), and ZIterativeAlgorithmWithFit().

std::vector<float> ZIterativeAlgorithmWithFit::optimizedCoefficients_ [private]

Definition at line 129 of file ZIterativeAlgorithmWithFit.h.

Referenced by getOptimizedCoefficients(), iterate(), and ZIterativeAlgorithmWithFit().

std::vector<float> ZIterativeAlgorithmWithFit::optimizedCoefficientsError_ [private]

Definition at line 130 of file ZIterativeAlgorithmWithFit.h.

Referenced by getOptimizedCoefficientsError(), iterate(), and ZIterativeAlgorithmWithFit().

std::vector<int> ZIterativeAlgorithmWithFit::optimizedIterations_ [private]

Definition at line 135 of file ZIterativeAlgorithmWithFit.h.

Referenced by getOptimizedIterations(), iterate(), and ZIterativeAlgorithmWithFit().

std::vector<float> ZIterativeAlgorithmWithFit::StatWeights_ [private]

Definition at line 142 of file ZIterativeAlgorithmWithFit.h.

Referenced by getStatWeights(), and ZIterativeAlgorithmWithFit().

ZIterativeAlgorithmWithFitPlots* ZIterativeAlgorithmWithFit::thePlots_ [private]

Definition at line 116 of file ZIterativeAlgorithmWithFit.h.

Referenced by bookHistograms(), getHistos(), getWeight(), iterate(), and ZIterativeAlgorithmWithFit().

unsigned int ZIterativeAlgorithmWithFit::totalEvents_ [private]

Definition at line 121 of file ZIterativeAlgorithmWithFit.h.

Referenced by addEvent(), resetIteration(), and ZIterativeAlgorithmWithFit().

bool ZIterativeAlgorithmWithFit::UseStatWeights_ [private]

Definition at line 139 of file ZIterativeAlgorithmWithFit.h.

Referenced by ZIterativeAlgorithmWithFit().

std::vector<float> ZIterativeAlgorithmWithFit::weight_sum_ [private]

Definition at line 132 of file ZIterativeAlgorithmWithFit.h.

Referenced by getWeight(), getWeightSum(), iterate(), resetIteration(), and ZIterativeAlgorithmWithFit().

std::string ZIterativeAlgorithmWithFit::WeightFileName_ [private]

Definition at line 140 of file ZIterativeAlgorithmWithFit.h.

Referenced by ZIterativeAlgorithmWithFit().