---

GenericMinL3Algorithm Class Reference

Implementation of the L3 Collaboration algorithm to solve a system Ax = B by minimization of |Ax-B| using an iterative linear approach. More...

#include <Calibration/Tools/interface/GenericMinL3Algorithm.h>

List of all members.

Public Member Functions
	GenericMinL3Algorithm (bool normalise=false)
	Default constructor CAVEAT: use normalise = true only if you know what you're doing!
vector< float >	iterate (const vector< vector< float > > &eventMatrix, const vector< float > &energyVector)
	perform one iteration using the Minimization L3 Algorithm returns the vector of calibration coefficients
vector< float >	iterate (const vector< vector< float > > &eventMatrix, const vector< float > &energyVector, int nIter)
	run the Minimization L3 Algorithm "nIter" number of times, recalibrating the event matrix after each iteration with the new solution returns the vector of calibration coefficients built from all iteration solutions
	~GenericMinL3Algorithm ()
	Destructor.
Private Attributes
bool	normaliseFlag

---

Detailed Description

Implementation of the L3 Collaboration algorithm to solve a system Ax = B by minimization of |Ax-B| using an iterative linear approach.

Date

2006/10/13 14:33:26

Revision

1.1

Author:

R.Ofierzynski, CERN

Definition at line 19 of file GenericMinL3Algorithm.h.

---

Constructor & Destructor Documentation

GenericMinL3Algorithm::GenericMinL3Algorithm

(

bool

normalise = false

)

Default constructor CAVEAT: use normalise = true only if you know what you're doing!

Definition at line 13 of file GenericMinL3Algorithm.cc.

  :normaliseFlag(normalise)
// if normalize=true: for all events sum the e25ovTRP. then take the mean value and rescale all TrP
{
}

GenericMinL3Algorithm::~GenericMinL3Algorithm

(

)

Destructor.

Definition at line 20 of file GenericMinL3Algorithm.cc.

{
}

---

Member Function Documentation

vector< float > GenericMinL3Algorithm::iterate	(	const vector< vector< float > > &	eventMatrix,
		const vector< float > &	energyVector
	)

perform one iteration using the Minimization L3 Algorithm returns the vector of calibration coefficients

Definition at line 59 of file GenericMinL3Algorithm.cc.

References GenMuonPlsPt100GeV_cfg::cout, lat::endl(), i, j, normaliseFlag, scale, and w.

{
  vector<float> solution;
  vector<float> myEnergyVector(energyVector);

  int Nevents = eventMatrix.size(); // Number of events to calibrate with
  int Nchannels = eventMatrix[0].size(); // Number of channel coefficients

  // Sanity check
  if (Nevents != myEnergyVector.size()) 
    {
      cout << "GenericMinL3Algorithm::iterate(): Error: bad matrix dimensions. Dropping out." << endl;
      return solution; // empty vector !
    }

  // initialize the solution vector with 1.
  solution.assign(Nchannels,1.);

  int ievent, i, j;

  // if normalization flag is set, normalize energies
  float sumOverEnergy;
  if (normaliseFlag)
    {
      float scale = 0.;
      
      cout << "GenericMinL3Algorithm::iterate(): Normalising event data" << endl;

      for (i=0; i<Nevents; i++)
        {
          sumOverEnergy = 0.;
          for (j=0; j<Nchannels; j++) {sumOverEnergy += eventMatrix[i][j];}
          sumOverEnergy /= myEnergyVector[i];
          scale += sumOverEnergy;
        }
      scale /= Nevents;
      cout << "  Normalisation = " << scale << endl;
      
      for (i=0; i<Nevents; i++) {myEnergyVector[i] *= scale;}     
    } // end normalize energies


  // This is where the real work goes on...
  float sum25, invsum25;
  float w; // weight for event
  vector<float> wsum(Nchannels,0.); // sum of weights for a crystal
  vector<float> Ewsum(Nchannels,0.); // sum of products of weight*Etrue/E25

  // Loop over events
  for (ievent = 0; ievent<Nevents; ievent++)
    {
      // Loop over the 5x5 to find the sum
      sum25=0.;
      
      for (i=0; i<Nchannels; i++) { sum25+=eventMatrix[ievent][i]; } //*calibs[i];
      
      if (sum25 != 0.)
        {
          invsum25 = 1/sum25;
          // Loop over the 5x5 again and calculate the weights for each xtal
          for (i=0; i<Nchannels; i++) 
            {           
              w = eventMatrix[ievent][i] * invsum25; // * calibs[i]
              wsum[i] += w;
              Ewsum[i] += (w * myEnergyVector[ievent] * invsum25);      
            }
        }
      else {cout << " Debug: dropping null event: " << ievent << endl;}
      
    } // end Loop over events
  
  // Apply correction factors to all channels not in the margin
  for (i=0; i<Nchannels; i++) 
    {
      if (wsum[i] != 0.) 
        { solution[i]*=Ewsum[i]/wsum[i]; }
      else 
        { cout << "warning - no event data for crystal index " << i << endl; }
    }

  return solution;
}

vector< float > GenericMinL3Algorithm::iterate	(	const vector< vector< float > > &	eventMatrix,
		const vector< float > &	energyVector,
		int	nIter
	)

run the Minimization L3 Algorithm "nIter" number of times, recalibrating the event matrix after each iteration with the new solution returns the vector of calibration coefficients built from all iteration solutions

Definition at line 25 of file GenericMinL3Algorithm.cc.

References i, and iter.

{
  vector<float> solution;
  vector<vector<float> > myEventMatrix(eventMatrix);
  int Nevents = eventMatrix.size(); // Number of events to calibrate with
  int Nchannels = eventMatrix[0].size(); // Number of channel coefficients
  vector<float> theCalibVector(Nchannels,1.);

  // Iterate the correction
  for (int iter=1;iter<=nIter;iter++) 
    {
      // make one iteration
      solution = iterate(myEventMatrix, energyVector);

      if (solution.empty()) return solution;
      // R.O.: or throw an exception, what's the standard CMS way ?

      // re-calibrate eventMatrix with solution
      for (int i=0; i<Nchannels; i++) 
        {
          for (int ievent = 0; ievent<Nevents; ievent++)
            {
              myEventMatrix[ievent][i] *= solution[i];
            }
          // save solution into theCalibVector
          theCalibVector[i] *= solution[i];
        }

    } // end iterate the correction

  return theCalibVector;
}

---

Member Data Documentation

bool GenericMinL3Algorithm::normaliseFlag [private]

Definition at line 41 of file GenericMinL3Algorithm.h.

Referenced by iterate().

---

The documentation for this class was generated from the following files:

• Calibration/Tools/interface/GenericMinL3Algorithm.h
• Calibration/Tools/src/GenericMinL3Algorithm.cc

---