MinL3AlgoUniv< IDdet > Class Template Reference

#include <MinL3AlgoUniv.h>

Public Types
typedef IDmap::const_iterator	citer_IDmap
typedef std::map< IDdet, float >	IDmap
typedef IDmap::value_type	IDmapvalue
typedef IDmap::iterator	iter_IDmap

Public Member Functions
void	addEvent (const std::vector< float > &myCluster, const std::vector< IDdet > &idCluster, const float &energy)
	add event to the calculation of the calibration vector More...
IDmap	getSolution (const bool resetsolution=true)
IDmap	iterate (const std::vector< std::vector< float > > &eventMatrix, const std::vector< std::vector< IDdet > > &idMatrix, const std::vector< float > &energyVector, const int &nIter, const bool &normalizeFlag=false)
	MinL3AlgoUniv (float kweight_=0.)
std::vector< float >	recalibrateEvent (const std::vector< float > &myCluster, const std::vector< IDdet > &idCluster, const IDmap &newCalibration)
	recalibrate before next iteration: give previous solution vector as argument More...
void	resetSolution ()
	reset for new iteration More...
	~MinL3AlgoUniv ()
	Destructor. More...

Private Attributes
int	countEvents
IDmap	Ewsum
float	kweight
IDmap	wsum

Detailed Description

template<class IDdet>
class MinL3AlgoUniv< IDdet >

Implementation of the L3 Collaboration algorithm to solve a system Ax = B by minimization of |Ax-B| using an iterative linear approach This class should be universal, i.e. working with DetIds or whatever else will be invented to identify Subdetector parts The bookkeeping of the cluster size and its elements has to be done by the user.

Author

R.Ofierzynski, CERN

Definition at line 20 of file MinL3AlgoUniv.h.

Member Typedef Documentation

citer_IDmap

template<class IDdet>

typedef IDmap::const_iterator MinL3AlgoUniv< IDdet >::citer_IDmap

Definition at line 25 of file MinL3AlgoUniv.h.

IDmap

template<class IDdet>

typedef std::map<IDdet, float> MinL3AlgoUniv< IDdet >::IDmap

Definition at line 22 of file MinL3AlgoUniv.h.

IDmapvalue

template<class IDdet>

typedef IDmap::value_type MinL3AlgoUniv< IDdet >::IDmapvalue

Definition at line 23 of file MinL3AlgoUniv.h.

iter_IDmap

template<class IDdet>

typedef IDmap::iterator MinL3AlgoUniv< IDdet >::iter_IDmap

Definition at line 24 of file MinL3AlgoUniv.h.

Constructor & Destructor Documentation

MinL3AlgoUniv()

template<class IDdet >

MinL3AlgoUniv< IDdet >::MinL3AlgoUniv

(

float

kweight_ = 0.

)

Default constructor kweight_ = event weight

Definition at line 68 of file MinL3AlgoUniv.h.

                                                  : kweight(kweight_), countEvents(0) {
  resetSolution();
}

~MinL3AlgoUniv()

template<class IDdet >

MinL3AlgoUniv< IDdet >::~MinL3AlgoUniv

(

)

Destructor.

Definition at line 73 of file MinL3AlgoUniv.h.

{}

Member Function Documentation

addEvent()

template<class IDdet>

void MinL3AlgoUniv< IDdet >::addEvent	(	const std::vector< float > &	myCluster,
		const std::vector< IDdet > &	idCluster,
		const float &	energy
	)

add event to the calculation of the calibration vector

Definition at line 142 of file MinL3AlgoUniv.h.

                                                         {
  countEvents++;
 
  float w, invsumXmatrix;
  float eventw;
  // Loop over the crystal matrix to find the sum
  float sumXmatrix = 0.;
 
  for (unsigned i = 0; i < myCluster.size(); i++) {
    sumXmatrix += myCluster[i];
  }
 
  // event weighting
  eventw = 1 - fabs(1 - sumXmatrix / energy);
  eventw = pow(eventw, kweight);
 
  if (sumXmatrix != 0.) {
    invsumXmatrix = 1 / sumXmatrix;
    // Loop over the crystal matrix (3x3,5x5,7x7) again and calculate the weights for each xtal
    for (unsigned i = 0; i < myCluster.size(); i++) {
      w = myCluster[i] * invsumXmatrix;
 
      // include the weights into wsum, Ewsum
      iter_IDmap iwsum = wsum.find(idCluster[i]);
      if (iwsum == wsum.end())
        wsum.insert(IDmapvalue(idCluster[i], w * eventw));
      else
        iwsum->second += w * eventw;
 
      iter_IDmap iEwsum = Ewsum.find(idCluster[i]);
      if (iEwsum == Ewsum.end())
        Ewsum.insert(IDmapvalue(idCluster[i], (w * eventw * energy * invsumXmatrix)));
      else
        iEwsum->second += (w * eventw * energy * invsumXmatrix);
    }
  }
  //  else {std::cout << " Debug: dropping null event: " << countEvents << std::endl;}
}

Referenced by L3CalibBlock::Fill().

getSolution()

template<class IDdet >

MinL3AlgoUniv< IDdet >::IDmap MinL3AlgoUniv< IDdet >::getSolution

(

const bool

resetsolution = true

)

get the solution at the end of the calibration as a map between DetIds and calibration constant

Definition at line 184 of file MinL3AlgoUniv.h.

                                                                                             {
  IDmap solution;
 
  for (iter_IDmap i = wsum.begin(); i != wsum.end(); i++) {
    iter_IDmap iEwsum = Ewsum.find(i->first);
    float myValue = 1;
    if (i->second != 0)
      myValue = iEwsum->second / i->second;
 
    solution.insert(IDmapvalue(i->first, myValue));
  }
 
  if (resetsolution)
    resetSolution();
 
  return solution;
}

Referenced by L3CalibBlock::solve().

iterate()

template<class IDdet>

MinL3AlgoUniv< IDdet >::IDmap MinL3AlgoUniv< IDdet >::iterate	(	const std::vector< std::vector< float > > &	eventMatrix,
		const std::vector< std::vector< IDdet > > &	idMatrix,
		const std::vector< float > &	energyVector,
		const int &	nIter,
		const bool &	normalizeFlag = false
	)

method doing the full calibration running 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

also to be used also as recipe on how to use the calibration methods << one-by-one with a re-selection of the events in between the iterations<<

Definition at line 76 of file MinL3AlgoUniv.h.

                                                                                              {
  int Nevents = eventMatrix.size();  // Number of events to calibrate with
 
  IDmap totalSolution;
  IDmap iterSolution;
  std::vector<std::vector<float> > myEventMatrix(eventMatrix);
  std::vector<float> myEnergyVector(energyVector);
 
  int i;
 
  // Iterate the correction
  for (int iter = 1; iter <= nIter; iter++) {
    // if normalization flag is set, normalize energies
    float sumOverEnergy;
    if (normalizeFlag) {
      float scale = 0.;
 
      for (i = 0; i < Nevents; i++) {
        sumOverEnergy = 0.;
        for (unsigned j = 0; j < myEventMatrix[i].size(); j++) {
          sumOverEnergy += myEventMatrix[i][j];
        }
        sumOverEnergy /= myEnergyVector[i];
        scale += sumOverEnergy;
      }
      scale /= Nevents;
 
      for (i = 0; i < Nevents; i++) {
        myEnergyVector[i] *= scale;
      }
    }  // end normalize energies
 
    // now the real work starts:
    for (int iEvt = 0; iEvt < Nevents; iEvt++) {
      addEvent(myEventMatrix[iEvt], idMatrix[iEvt], myEnergyVector[iEvt]);
    }
    iterSolution = getSolution();
    if (iterSolution.empty())
      return iterSolution;
 
    // re-calibrate eventMatrix with solution
    for (int ievent = 0; ievent < Nevents; ievent++) {
      myEventMatrix[ievent] = recalibrateEvent(myEventMatrix[ievent], idMatrix[ievent], iterSolution);
    }
 
    // save solution into theCalibVector
    for (iter_IDmap i = iterSolution.begin(); i != iterSolution.end(); i++) {
      iter_IDmap itotal = totalSolution.find(i->first);
      if (itotal == totalSolution.end()) {
        totalSolution.insert(IDmapvalue(i->first, i->second));
      } else {
        itotal->second *= i->second;
      }
    }
 
    //      resetSolution(); // reset for new iteration, now: getSolution does it automatically if not vetoed
  }  // end iterate correction
 
  return totalSolution;
}

Referenced by ElectronCalibrationUniv::endJob(), and hcalCalib::Terminate().

recalibrateEvent()

template<class IDdet>

std::vector< float > MinL3AlgoUniv< IDdet >::recalibrateEvent	(	const std::vector< float > &	myCluster,
		const std::vector< IDdet > &	idCluster,
		const IDmap &	newCalibration
	)

recalibrate before next iteration: give previous solution vector as argument

Definition at line 209 of file MinL3AlgoUniv.h.

                                                                                       {
  std::vector<float> newCluster(myCluster);
 
  for (unsigned i = 0; i < myCluster.size(); i++) {
    citer_IDmap icalib = newCalibration.find(idCluster[i]);
    if (icalib != newCalibration.end()) {
      newCluster[i] *= icalib->second;
    } else {
      std::cout << "No calibration available for this element." << std::endl;
    }
  }
 
  return newCluster;
}

resetSolution()

template<class IDdet >

void MinL3AlgoUniv< IDdet >::resetSolution

(

)

reset for new iteration

Definition at line 203 of file MinL3AlgoUniv.h.

                                         {
  wsum.clear();
  Ewsum.clear();
}

Referenced by MinL3AlgoUniv< DetId >::MinL3AlgoUniv(), and L3CalibBlock::reset().

Member Data Documentation

countEvents

template<class IDdet>

int MinL3AlgoUniv< IDdet >::countEvents

private

Definition at line 62 of file MinL3AlgoUniv.h.

Ewsum

template<class IDdet>

IDmap MinL3AlgoUniv< IDdet >::Ewsum

private

Definition at line 64 of file MinL3AlgoUniv.h.

kweight

template<class IDdet>

float MinL3AlgoUniv< IDdet >::kweight

private

Definition at line 61 of file MinL3AlgoUniv.h.

wsum

template<class IDdet>

IDmap MinL3AlgoUniv< IDdet >::wsum

private

Definition at line 63 of file MinL3AlgoUniv.h.