ECAL TB 2006 calibration with matrix inversion technique. More...

#include <EcalEleCalibLooper.h>

Inheritance diagram for EcalEleCalibLooper:

Public Member Functions
void	beginOfJob ()
	BeginOfJob. More...

Status	duringLoop (const edm::Event &, const edm::EventSetup &)

	EcalEleCalibLooper (const edm::ParameterSet &)
	ctor More...

void	endOfJob ()

Status	endOfLoop (const edm::EventSetup &, unsigned int iCounter)

void	startingNewLoop (unsigned int)

	~EcalEleCalibLooper ()
	dtor More...

Public Member Functions inherited from edm::EDLooper
	EDLooper ()

	EDLooper (EDLooper const &)=delete

EDLooper &	operator= (EDLooper const &)=delete

virtual	~EDLooper ()

Public Member Functions inherited from edm::EDLooperBase
virtual void	attachTo (ActivityRegistry &)
	Override this method if you need to monitor the state of the processing. More...

virtual void	beginOfJob (EventSetup const &)

void	copyInfo (ScheduleInfo const &)

void	doBeginLuminosityBlock (LuminosityBlockPrincipal &, EventSetup const &, ProcessContext *)

void	doBeginRun (RunPrincipal &, EventSetup const &, ProcessContext *)

Status	doDuringLoop (EventPrincipal &eventPrincipal, EventSetup const &es, ProcessingController &, StreamContext *)

void	doEndLuminosityBlock (LuminosityBlockPrincipal &, EventSetup const &, ProcessContext *)

Status	doEndOfLoop (EventSetup const &es)

void	doEndRun (RunPrincipal &, EventSetup const &, ProcessContext *)

void	doStartingNewLoop ()

	EDLooperBase ()

	EDLooperBase (EDLooperBase const &)=delete

virtual std::set < eventsetup::EventSetupRecordKey >	modifyingRecords () const

EDLooperBase &	operator= (EDLooperBase const &)=delete

void	prepareForNextLoop (eventsetup::EventSetupProvider *esp)

void	setActionTable (ExceptionToActionTable const *actionTable)

void	setModuleChanger (ModuleChanger const *)

virtual	~EDLooperBase ()

Private Member Functions
int	EBregionCheck (const int eta, const int phi) const
	Tells if you are in the region to be calibrated. More...

void	EBRegionDefinition ()
	DS EB Region Definition. More...

int	EBRegionId (const int, const int) const
	Reg Id generator EB --— for the barrel. More...

int	EBregionsNum () const
	DS number of regions in EB. More...

int	EEregionCheck (const int, const int) const
	returns zero if the coordinates are in the right place. More...

void	EERegionDefinition ()

int	EERegionId (const int, const int) const
	Gives the id of the region. More...

int	EEregionsNum () const
	DS Number of regions in EE. More...

int	etaShifter (const int) const
	LP Change the coordinate system. More...

double	giveLimit (int)
	copes with the infinitives of the tangent More...

Private Attributes
bool	isfirstcall_

edm::InputTag	m_barrelAlCa
	EcalBarrel Input Collection name. More...

std::vector< DetId >	m_barrelCells

EcalIntercalibConstantMap	m_barrelMap
	the maps of recalib coeffs More...

std::vector< VEcalCalibBlock * >	m_EcalCalibBlocks
	single blocks calibrators More...

edm::InputTag	m_ElectronLabel
	To take the electrons. More...

edm::InputTag	m_endcapAlCa
	EcalEndcap Input Collection name. More...

std::vector< DetId >	m_endcapCells

EcalIntercalibConstantMap	m_endcapMap

int	m_etaEnd
	eta end of the region of interest More...

int	m_etaStart
	phi size of the additive border to the sub-matrix More...

int	m_etaWidth
	eta size of the sub-matrix More...

unsigned int	m_loops
	DS sets the number of loops to do. More...

VFillMap *	m_MapFiller

double	m_maxCoeff
	maximum coefficient accepted (RAW) More...

double	m_maxEnergyPerCrystal
	maximum energy per crystal cut More...

int	m_maxSelectedNumPerXtal
	maximum number of events per crystal More...

double	m_minCoeff
	minimum coefficient accepted (RAW) More...

double	m_minEnergyPerCrystal
	minimum energy per crystal cut More...

int	m_phiEndEB
	phi end of the region of interest More...

int	m_phiEndEE

int	m_phiStartEB
	phi start of the region of interest More...

int	m_phiStartEE

int	m_phiWidthEB
	eta size of the additive border to the sub-matrix More...

int	m_phiWidthEE

int	m_radEnd

int	m_radStart
	DS For the EE. More...

int	m_radWidth

int	m_recoWindowSidex
	reconstruction window size More...

int	m_recoWindowSidey

std::vector< int >	m_regions

int	m_usingBlockSolver
	to exclude the blocksolver More...

std::map< int, int >	m_xtalNumOfHits

std::map< int, int >	m_xtalPositionInRegion

std::map< int, int >	m_xtalRegionId

Additional Inherited Members
Public Types inherited from edm::EDLooperBase
enum	Status { kContinue, kStop }

Protected Member Functions inherited from edm::EDLooperBase
ModuleChanger const *	moduleChanger () const
	This only returns a non-zero value during the call to endOfLoop. More...

ScheduleInfo const *	scheduleInfo () const
	This returns a non-zero value after the constructor has been called. More...

Detailed Description

ECAL TB 2006 calibration with matrix inversion technique.

Author

Definition at line 32 of file EcalEleCalibLooper.h.

Constructor & Destructor Documentation

EcalEleCalibLooper::EcalEleCalibLooper ( const edm::ParameterSet & iConfig )

explicit

ctor

LP ctor.

Graphs to ckeck the region definition

End of Graphs

Definition at line 36 of file EcalEleCalibLooper.cc.

References algorithm(), EBRegionDefinition(), EBregionsNum(), EERegionDefinition(), EEregionsNum(), eta(), cmsRelvalreport::exit, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), m_barrelMap, m_EcalCalibBlocks, m_endcapMap, m_etaEnd, m_etaStart, m_etaWidth, m_MapFiller, m_maxEnergyPerCrystal, m_minEnergyPerCrystal, m_radEnd, m_radStart, m_radWidth, m_recoWindowSidex, m_recoWindowSidey, m_regions, m_xtalPositionInRegion, m_xtalRegionId, dbtoconf::out, phi, AlCaHLTBitMon_QueryRunRegistry::string, EBDetId::unhashIndex(), EEDetId::validDetId(), x, and detailsBasic3DVector::y.

                                                                       :
       m_barrelAlCa (iConfig.getParameter<edm::InputTag> ("alcaBarrelHitCollection")) ,
       m_endcapAlCa (iConfig.getParameter<edm::InputTag> ("alcaEndcapHitCollection")) ,
       m_recoWindowSidex (iConfig.getParameter<int> ("recoWindowSidex")) ,
       m_recoWindowSidey (iConfig.getParameter<int> ("recoWindowSidey")) ,
       m_etaWidth (iConfig.getParameter<int> ("etaWidth")) ,
       m_phiWidthEB (iConfig.getParameter<int> ("phiWidthEB")) ,
       m_etaStart (etaShifter (iConfig.getParameter<int> ("etaStart"))) , 
       m_etaEnd (etaShifter (iConfig.getParameter<int> ("etaEnd"))) ,
       m_phiStartEB (iConfig.getParameter<int> ("phiStartEB")) , 
       m_phiEndEB (iConfig.getParameter<int> ("phiEndEB")),
       m_radStart (iConfig.getParameter<int> ("radStart")) , 
       m_radEnd (iConfig.getParameter<int> ("radEnd")) ,
       m_radWidth (iConfig.getParameter<int> ("radWidth")) ,
       m_phiStartEE (iConfig.getParameter<int> ("phiStartEE")) ,
       m_phiEndEE (iConfig.getParameter<int> ("phiEndEE")) ,
       m_phiWidthEE (iConfig.getParameter<int> ("phiWidthEE")) ,
       m_maxSelectedNumPerXtal (iConfig.getParameter<int> ("maxSelectedNumPerCrystal")) ,  
       m_minEnergyPerCrystal (iConfig.getParameter<double> ("minEnergyPerCrystal")),
       m_maxEnergyPerCrystal (iConfig.getParameter<double> ("maxEnergyPerCrystal")) ,
       m_minCoeff (iConfig.getParameter<double> ("minCoeff")) ,
       m_maxCoeff (iConfig.getParameter<double> ("maxCoeff")) ,
       m_usingBlockSolver (iConfig.getParameter<int> ("usingBlockSolver")) ,
       m_loops (iConfig.getParameter<int> ("loops")),
       m_ElectronLabel (iConfig.getParameter<edm::InputTag> ("electronLabel"))
 {
   edm::LogInfo ("IML") << "[EcalEleCalibLooper][ctor] asserts" ;
   assert (!((m_etaEnd - m_etaStart )%m_etaWidth)); 
 
   assert (m_etaStart >=0 && m_etaStart <= 171);
   assert (m_etaEnd >= m_etaStart && m_etaEnd <= 171);
   assert ( (m_radEnd - m_radStart)%m_radWidth == 0) ; 
   assert (m_radStart >=0 && m_radStart <= 50);
   assert (m_radEnd >= m_radStart && m_radEnd <= 50);
   edm::LogInfo ("IML") << "[EcalEleCalibLooper][ctor] entering " ;
   edm::LogInfo ("IML") << "[EcalEleCalibLooper][ctor] region definition" ;
   EBRegionDefinition () ;
   EERegionDefinition () ;
   TH2F * EBRegion = new TH2F ("EBRegion","EBRegion",170,0,170,360,0,360) ;
   for (int eta = 0; eta<170; ++eta)
      for (int phi = 0; phi <360; ++phi){
     EBRegion->Fill (eta, phi,m_xtalRegionId[EBDetId::unhashIndex(eta*360+phi).rawId()] );
       }
   TH2F * EERegion = new TH2F ("EERegion", "EERegion",100,0,100,100,0,100);
   for (int x = 0; x<100; ++x)
      for (int y = 0; y<100;++y){
    if(EEDetId::validDetId(x+1,y+1,1))
              EERegion->Fill(x,y,m_xtalRegionId[EEDetId(x+1,y+1,-1).rawId()]);
      }
          
   TFile out ("EBZone.root", "recreate");
     EBRegion->Write ();
     EERegion->Write ();
   out.Close ();
   delete EERegion;
   delete EBRegion;
 
   //PG build the calibration algorithms for the regions
   //PG ------------------------------------------------
 
   edm::LogInfo ("IML") << "[EcalEleCalibLooper][ctor] Calib Block" ;
   std::string algorithm = iConfig.getParameter<std::string> ("algorithm") ;
   int eventWeight = iConfig.getUntrackedParameter<int> ("L3EventWeight",1) ;
 
   //PG loop over the regions set
   for (int region = 0 ; 
        region < EBregionsNum () + 2 * EEregionsNum () ; 
        ++region)
     {   
       if (algorithm == "IMA")
         m_EcalCalibBlocks.push_back (
             new IMACalibBlock (m_regions.at (region))
           ) ; 
       else if (algorithm == "L3")
         m_EcalCalibBlocks.push_back (
             new L3CalibBlock (m_regions.at (region), eventWeight)
           ) ; 
       else
         {
           edm::LogError ("building") << algorithm 
                           << " is not a valid calibration algorithm" ;
           exit (1) ;    
         }    
     } //PG loop over the regions set
   std::string mapFiller = iConfig.getParameter<std::string> ("FillType");
   if (mapFiller == "Cluster") m_MapFiller= new ClusterFillMap (
     m_recoWindowSidex ,m_recoWindowSidey ,
         m_xtalRegionId ,m_minEnergyPerCrystal ,
         m_maxEnergyPerCrystal , m_xtalPositionInRegion ,
         & m_barrelMap ,
         & m_endcapMap ); 
   if (mapFiller == "Matrix") m_MapFiller = new MatrixFillMap (
     m_recoWindowSidex ,m_recoWindowSidey ,
         m_xtalRegionId , m_minEnergyPerCrystal ,
         m_maxEnergyPerCrystal , m_xtalPositionInRegion ,
         & m_barrelMap ,
         & m_endcapMap); 
  } //end ctor

EcalEleCalibLooper::~EcalEleCalibLooper ( )

dtor

LP destructor.

Definition at line 142 of file EcalEleCalibLooper.cc.

References m_EcalCalibBlocks.

 {
   edm::LogInfo ("IML") << "[EcalEleCalibLooper][dtor]" ;
   for (std::vector<VEcalCalibBlock *>::iterator calibBlock = m_EcalCalibBlocks.begin () ;
        calibBlock != m_EcalCalibBlocks.end () ;
        ++calibBlock) 
     delete (*calibBlock) ;
 
 }

Member Function Documentation

void EcalEleCalibLooper::beginOfJob ( )

virtual

BeginOfJob.

Reimplemented from edm::EDLooperBase.

Definition at line 158 of file EcalEleCalibLooper.cc.

References isfirstcall_.

 {
   isfirstcall_=true;
  
 }

edm::EDLooper::Status EcalEleCalibLooper::duringLoop	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

virtual

duringLoop return the status Kcontinue, fills the calibBlock with the recHits

Implements edm::EDLooper.

Definition at line 194 of file EcalEleCalibLooper.cc.

References DetId::det(), DetId::Ecal, EcalBarrel, EcalEndcap, HcalObjRepresent::Fill(), VFillMap::fillMap(), first, geometry, edm::EventSetup::get(), edm::Event::getByLabel(), CaloGeometry::getValidDetIds(), isfirstcall_, edm::HandleBase::isValid(), edm::EDLooperBase::kContinue, m_barrelAlCa, m_barrelCells, m_barrelMap, m_EcalCalibBlocks, m_ElectronLabel, m_endcapAlCa, m_endcapCells, m_endcapMap, m_MapFiller, m_maxSelectedNumPerXtal, m_xtalNumOfHits, m_xtalRegionId, Max(), edm::Handle< T >::product(), and DetId::rawId().

 {
 
   // this chunk used to belong to beginJob(isetup). Moved here
   // with the beginJob without arguments migration
   
   if (isfirstcall_){
   edm::ESHandle<CaloGeometry> geoHandle;
   iSetup.get<CaloGeometryRecord> ().get (geoHandle);
   const CaloGeometry& geometry = *geoHandle;
   m_barrelCells = geometry.getValidDetIds (DetId::Ecal, EcalBarrel);
   m_endcapCells = geometry.getValidDetIds (DetId::Ecal, EcalEndcap);
     for (std::vector<DetId>::const_iterator barrelIt=m_barrelCells.begin();
      barrelIt!=m_barrelCells.end();++barrelIt){
       m_barrelMap[*barrelIt]=1;
       m_xtalNumOfHits[barrelIt->rawId()]=0;
     }
     for (std::vector<DetId>::const_iterator endcapIt=m_endcapCells.begin();
      endcapIt!=m_endcapCells.end();++endcapIt){
       m_endcapMap[*endcapIt]=1;
       m_xtalNumOfHits[endcapIt->rawId()]=0;
     }
     
     isfirstcall_=false; 
   }
   
 
 
  //take the collection of recHits in the barrel
  const EBRecHitCollection* barrelHitsCollection = 0;
  edm::Handle<EBRecHitCollection> barrelRecHitsHandle ;
  iEvent.getByLabel (m_barrelAlCa, barrelRecHitsHandle) ;
  barrelHitsCollection = barrelRecHitsHandle.product () ;
  if (!barrelRecHitsHandle.isValid ()) {
      edm::LogError ("reading") << "[EcalEleCalibLooper] barrel rec hits not found" ;
      return  kContinue ;
     }
 
  //take the collection of rechis in the endcap
  const EERecHitCollection * endcapHitsCollection = 0 ;
  edm::Handle<EERecHitCollection> endcapRecHitsHandle ;
  iEvent.getByLabel (m_endcapAlCa, endcapRecHitsHandle) ;
  endcapHitsCollection = endcapRecHitsHandle.product () ;
  if (!endcapRecHitsHandle.isValid ()) {  
      edm::LogError ("reading") << "[EcalEleCalibLooper] endcap rec hits not found" ; 
      return kContinue;
    }
 
  //Takes the electron collection of the pixel detector
  edm::Handle<reco::GsfElectronCollection> pElectrons;
  iEvent.getByLabel (m_ElectronLabel,pElectrons);
  if (!pElectrons.isValid ()) {
      edm::LogError ("reading")<< "[EcalEleCalibLooper] electrons not found" ;
      return kContinue;
    }
 
  //Start the loop over the electrons 
  for (reco::GsfElectronCollection::const_iterator eleIt = pElectrons->begin ();
       eleIt != pElectrons->end ();
       ++eleIt )
    {
      double pSubtract = 0 ;
      double pTk = 0 ;
      std::map<int , double> xtlMap;
      DetId Max =0;
      if (fabs(eleIt->eta()<1.49))
          Max = EcalClusterTools::getMaximum(eleIt->superCluster()->hitsAndFractions(),barrelHitsCollection).first;
      else 
          Max = EcalClusterTools::getMaximum(eleIt->superCluster()->hitsAndFractions(),endcapHitsCollection).first;
      if (Max.det()==0) continue;
      m_MapFiller->fillMap(eleIt->superCluster ()->hitsAndFractions (),Max, 
                            barrelHitsCollection,endcapHitsCollection, xtlMap,pSubtract);
      if (m_maxSelectedNumPerXtal > 0 && 
         m_xtalNumOfHits[Max.rawId ()] > m_maxSelectedNumPerXtal ) continue;
      ++m_xtalNumOfHits[Max.rawId()];
      if (m_xtalRegionId[Max.rawId()]==-1) continue;
      pTk = eleIt->trackMomentumAtVtx ().R ();
      m_EcalCalibBlocks.at (m_xtalRegionId[Max.rawId()])->Fill (xtlMap.begin (), 
                                            xtlMap.end (),pTk,pSubtract) ;
    } //End of the loop over the electron collection
 
   return  kContinue;
 } //end of duringLoop

int EcalEleCalibLooper::EBregionCheck	(	const int	eta,
		const int	phi
	)		const

private

Tells if you are in the region to be calibrated.

Definition at line 397 of file EcalEleCalibLooper.cc.

References m_etaEnd, m_etaStart, m_phiEndEB, and m_phiStartEB.

Referenced by EBRegionId().

  {
    if (eta < m_etaStart) return 1 ;
    if (eta >= m_etaEnd)   return 2 ;
    if (phi < m_phiStartEB) return 3 ;
    if (phi >= m_phiEndEB)   return 4 ;
    return 0 ;
  }

void EcalEleCalibLooper::EBRegionDefinition ( )

private

DS EB Region Definition.

Definition at line 519 of file EcalEleCalibLooper.cc.

References EBRegionId(), EBregionsNum(), eta(), m_regions, m_xtalPositionInRegion, m_xtalRegionId, phi, DetId::rawId(), and EBDetId::unhashIndex().

Referenced by EcalEleCalibLooper().

 {
  int reg=-1;
  for (int it = 0 ; it < EBregionsNum () ; ++it) m_regions.push_back (0) ;   
  for (int eta = 0 ; eta < 170  ; ++eta)
    for (int phi = 0 ; phi < 360 ; ++phi)
       {
         reg = EBRegionId (eta,phi) ;
         m_xtalRegionId[EBDetId::unhashIndex (eta*360+phi).rawId ()] = reg ; 
     if (reg==-1) continue;
         m_xtalPositionInRegion[EBDetId::unhashIndex (eta*360+phi).rawId ()] = m_regions.at (reg) ;
         ++m_regions.at (reg);
       }
 }

int EcalEleCalibLooper::EBRegionId	(	const int	etaXtl,
		const int	phiXtl
	)		const

private

Reg Id generator EB --— for the barrel.

Definition at line 455 of file EcalEleCalibLooper.cc.

References EBregionCheck(), m_etaStart, m_etaWidth, m_phiEndEB, m_phiStartEB, and m_phiWidthEB.

Referenced by EBRegionDefinition().

 {
  if (EBregionCheck(etaXtl,phiXtl)) return -1;
  int phifake = m_phiStartEB;
  if (m_phiStartEB>m_phiEndEB) phifake = m_phiStartEB - 360;
  int Nphi = (m_phiEndEB-phifake)/m_phiWidthEB ;
  int etaI = (etaXtl-m_etaStart) / m_etaWidth ;  
  int phiI = (phiXtl-m_phiStartEB) / m_phiWidthEB ; 
  int regionNumEB = phiI + Nphi*etaI ;
  return (int) regionNumEB;
 }

int EcalEleCalibLooper::EBregionsNum ( ) const

inlineprivate

DS number of regions in EB.

Definition at line 507 of file EcalEleCalibLooper.cc.

References m_etaEnd, m_etaStart, m_etaWidth, m_phiEndEB, m_phiStartEB, m_phiWidthEB, and phi.

Referenced by EBRegionDefinition(), EcalEleCalibLooper(), and EERegionDefinition().

 {
   int phi = m_phiStartEB;
   if (m_phiStartEB>m_phiEndEB) phi = m_phiStartEB - 360;
   return ( (m_etaEnd - m_etaStart)/m_etaWidth) * ( (m_phiEndEB - phi)/m_phiWidthEB) ; 
 }

int EcalEleCalibLooper::EEregionCheck	(	const int	ics,
		const int	ips
	)		const

private

returns zero if the coordinates are in the right place.

Definition at line 576 of file EcalEleCalibLooper.cc.

References degrees(), m_phiEndEE, m_phiStartEE, m_radEnd, m_radStart, phi, x, and detailsBasic3DVector::y.

Referenced by EERegionId().

 {
   int x = ics-50;
   int y = ips-50;
   double radius2 = x*x + y*y ;
   if (radius2 < 10*10) return 1;  //center of the donut
   if (radius2 > 50*50) return 1;  //outer part of the donut
   if (radius2 < m_radStart * m_radStart) return 2 ;
   if (radius2 >= m_radEnd * m_radEnd) return 2 ;
   double phi = atan2 (static_cast<double> (y),static_cast<double> (x));
   phi = degrees (phi);
   if (phi < 0) phi += 360; 
   if (m_phiStartEE < m_phiEndEE 
      && phi > m_phiStartEE && phi < m_phiEndEE ) return 0; 
   if (m_phiStartEE > m_phiEndEE 
       && (phi > m_phiStartEE || phi < m_phiEndEE )) return 0; 
    return 3;
 }

void EcalEleCalibLooper::EERegionDefinition ( )

private

Definition at line 539 of file EcalEleCalibLooper.cc.

References bsc_activity_cfg::EBnum, EBregionsNum(), bsc_activity_cfg::EEnum, EERegionId(), EEregionsNum(), h2_mapping_cfi::ics, m_regions, m_xtalPositionInRegion, m_xtalRegionId, DetId::rawId(), and EEDetId::validDetId().

Referenced by EcalEleCalibLooper().

 {
  // reset
  int EBnum=EBregionsNum();
  int EEnum=EEregionsNum();
  for (int it = 0 ; it < 2* EEnum ; ++it) m_regions.push_back (0) ;   
  // loop sui xtl 
  int reg=-1;
  for (int ics = 0 ; ics < 100 ; ++ics)
   for (int ips = 0 ; ips < 100 ; ++ips)
     {
      int ireg = EERegionId(ics, ips);
      if (ireg==-1) reg =-1;
      else reg = EBnum + ireg;
      if (EEDetId::validDetId (ics+1, ips+1, 1))
       {
         m_xtalRegionId[EEDetId (ics+1, ips+1, 1).rawId ()] = reg ; 
         if (reg==-1) continue;
         m_xtalPositionInRegion[EEDetId (ics+1, ips+1, 1).rawId ()] = m_regions.at (reg) ;
         ++m_regions.at(reg);
       }
      if (reg!=-1) reg += EEnum; 
      if (EEDetId::validDetId (ics+1, ips+1, -1))
       {
         m_xtalRegionId[EEDetId (ics+1, ips+1, -1).rawId ()] = reg ; 
         if (reg==-1) continue;
         m_xtalPositionInRegion[EEDetId (ics+1, ips+1, -1).rawId ()] = m_regions.at (reg) ;
         ++m_regions.at (reg) ;
        }
     }
 }

int EcalEleCalibLooper::EERegionId	(	const int	ics,
		const int	ips
	)		const

private

Gives the id of the region.

Definition at line 472 of file EcalEleCalibLooper.cc.

References degrees(), EEregionCheck(), m_phiEndEE, m_phiStartEE, m_phiWidthEE, m_radStart, m_radWidth, phi, CosmicsPD_Skims::radius, and mathSSE::sqrt().

Referenced by EERegionDefinition().

 {
  if (EEregionCheck(ics,ips)) return -1;
  int phifake = m_phiStartEE;
  if (m_phiStartEE>m_phiEndEE) phifake = m_phiStartEE - 360;
  double radius = (ics-50) * (ics-50) + (ips-50) * (ips-50) ;
  radius = sqrt (radius) ;
  int Nphi = (m_phiEndEE - phifake)/m_phiWidthEE ;
  double phi = atan2 (static_cast<double> (ips-50), 
                      static_cast<double> (ics-50)) ;
  phi = degrees (phi);
  if (phi < 0) phi += 360; 
  int radI = static_cast<int> ((radius-m_radStart) / m_radWidth) ;
  int phiI = static_cast<int> ((m_phiEndEE-phi) / m_phiWidthEE) ;
  int regionNumEE = phiI + Nphi*radI ;
  return  regionNumEE ;
 }

int EcalEleCalibLooper::EEregionsNum ( ) const

inlineprivate

DS Number of regions in EE.

Definition at line 495 of file EcalEleCalibLooper.cc.

References m_phiEndEE, m_phiStartEE, m_phiWidthEE, m_radEnd, m_radStart, and m_radWidth.

Referenced by EcalEleCalibLooper(), and EERegionDefinition().

 {
   int phifake = m_phiStartEE;
   if (m_phiStartEE>m_phiEndEE) phifake = m_phiStartEE - 360;
   return ( (m_radEnd - m_radStart)/m_radWidth) * ( (m_phiEndEE - phifake)/m_phiWidthEE) ;
 }

void EcalEleCalibLooper::endOfJob ( )

virtual

LP endOfJob writes the coefficients in the xml format and exits

Reimplemented from edm::EDLooperBase.

Definition at line 365 of file EcalEleCalibLooper.cc.

References EcalBarrel, EcalEndcap, m_barrelCells, m_barrelMap, m_endcapCells, m_endcapMap, and calibXMLwriter::writeLine().

 {
  edm::LogInfo ("IML") << "[InvMatrixCalibLooper][endOfJob] saving calib coeffs" ;
 
 //Writes the coeffs 
  calibXMLwriter barrelWriter (EcalBarrel);
  calibXMLwriter endcapWriter (EcalEndcap);
  for (std::vector<DetId>::const_iterator barrelIt = m_barrelCells.begin (); 
        barrelIt!=m_barrelCells.end (); 
        ++barrelIt) 
    {
      EBDetId eb (*barrelIt);
      barrelWriter.writeLine (eb,m_barrelMap[*barrelIt]);
    }
  for (std::vector<DetId>::const_iterator endcapIt = m_endcapCells.begin ();
       endcapIt!=m_endcapCells.end ();
       ++endcapIt) 
    {
      EEDetId ee (*endcapIt);
      endcapWriter.writeLine (ee,m_endcapMap[*endcapIt]);
    }
  edm::LogInfo ("IML") << "[InvMatrixCalibLooper][endOfJob] Exiting" ;    
 }

edm::EDLooper::Status EcalEleCalibLooper::endOfLoop	(	const edm::EventSetup &	dumb,
		unsigned int	iCounter
	)

virtual

EndOfLoop Return kContinue if there's still another loop to be done; otherwise stops returnig kStop; Takes the coefficients solving the calibBlock;

Implements edm::EDLooperBase.

Definition at line 286 of file EcalEleCalibLooper.cc.

References lut2db_cfg::filename, EBDetId::ieta(), cmsHarvester::index, EBDetId::iphi(), EEDetId::ix(), EEDetId::iy(), edm::EDLooperBase::kContinue, edm::EDLooperBase::kStop, m_barrelCells, m_barrelMap, m_EcalCalibBlocks, m_endcapCells, m_endcapMap, m_loops, m_maxCoeff, m_minCoeff, m_usingBlockSolver, m_xtalPositionInRegion, m_xtalRegionId, and EEDetId::zside().

 {
  edm::LogInfo ("IML") << "[InvMatrixCalibLooper][endOfLoop] entering..." ;
  for (std::vector<VEcalCalibBlock *>::iterator calibBlock = m_EcalCalibBlocks.begin ();
        calibBlock!=m_EcalCalibBlocks.end ();
        ++calibBlock) 
    (*calibBlock)->solve (m_usingBlockSolver, m_minCoeff,m_maxCoeff);
 
   TH1F * EBcoeffEnd = new TH1F ("EBRegion","EBRegion",100,0.5,2.1) ;
   TH2F * EBcoeffMap = new TH2F ("EBcoeff","EBcoeff",171,-85,85,360,1,361);
   TH1F * EEPcoeffEnd = new TH1F ("EEPRegion", "EEPRegion",100,0.5,2.1);
   TH1F * EEMcoeffEnd = new TH1F ("EEMRegion", "EEMRegion",100,0.5,2.1);
   TH2F * EEPcoeffMap = new TH2F ("EEPcoeffMap","EEPcoeffMap",101,1,101,101,0,101);
   TH2F * EEMcoeffMap = new TH2F ("EEMcoeffMap","EEMcoeffMap",101,1,101,101,0,101);
  //loop over the barrel xtals to get the coeffs
  for (std::vector<DetId>::const_iterator barrelIt=m_barrelCells.begin();
        barrelIt!=m_barrelCells.end();++barrelIt)
         {
           EBDetId ee (*barrelIt);
           int index= barrelIt->rawId();
           if(m_xtalRegionId[index]==-1)continue;
           m_barrelMap[*barrelIt] *= 
               m_EcalCalibBlocks.at(m_xtalRegionId[index])->at(m_xtalPositionInRegion[index]);
           EBcoeffEnd->Fill(m_barrelMap[*barrelIt]);
           EBcoeffMap->Fill(ee.ieta(),ee.iphi(),m_barrelMap[*barrelIt]);
         } //PG loop over phi
 
   // loop over the EndCap to get the recalib coefficients
     for(std::vector<DetId>::const_iterator endcapIt=m_endcapCells.begin();
          endcapIt!=m_endcapCells.end();++endcapIt)
     {
      EEDetId ee (*endcapIt);
      int index =endcapIt->rawId(); 
      if (ee.zside()>0) 
         { 
           if (m_xtalRegionId[index]==-1) continue ;
           m_endcapMap[*endcapIt] *= 
              m_EcalCalibBlocks.at (m_xtalRegionId[index])->at (m_xtalPositionInRegion[index]);
           EEPcoeffEnd->Fill (m_endcapMap[*endcapIt]) ;
           EEPcoeffMap->Fill (ee.ix(),ee.iy(),m_endcapMap[*endcapIt]) ;
         }
       else
         {
           m_endcapMap[*endcapIt] *= 
             m_EcalCalibBlocks.at (m_xtalRegionId[index])->at (m_xtalPositionInRegion[index]);
           EEMcoeffEnd->Fill (m_endcapMap[*endcapIt]) ;
           EEMcoeffMap->Fill (ee.ix(),ee.iy(),m_endcapMap[*endcapIt]) ;
         }
     } // loop over the EndCap to get the recalib coefficients
 
   edm::LogInfo ("IML") << "[InvMatrixCalibLooper][endOfLoop] End of endOfLoop" ;
 
   char filename[80];
   sprintf(filename,"coeffs%d.root",iCounter);
   TFile zout (filename, "recreate");
   EBcoeffEnd->Write () ;
   EBcoeffMap->Write () ;
   EEPcoeffEnd->Write () ;
   EEPcoeffMap->Write () ;
   EEMcoeffEnd->Write () ;
   EEMcoeffMap->Write () ;
   zout.Close () ;
   delete EBcoeffEnd;
   delete EBcoeffMap;
   delete EEPcoeffEnd;
   delete EEMcoeffEnd;
   delete EEPcoeffMap;
   delete EEMcoeffMap;
   if (iCounter < m_loops-1 ) return kContinue ;
   else return kStop; 
 }

int EcalEleCalibLooper::etaShifter ( const int etaOld ) const

private

LP Change the coordinate system.

Definition at line 600 of file EcalEleCalibLooper.cc.

    {
      if (etaOld < 0) return etaOld + 85;
      else if (etaOld > 0) return etaOld + 84;
      assert(0!=etaOld); // etaOld = 0, apparently not a foreseen value, so fail
      return 999; // dummy statement to silence compiler warning
    }

double EcalEleCalibLooper::giveLimit ( int degrees )

private

copes with the infinitives of the tangent

Definition at line 431 of file EcalEleCalibLooper.cc.

References radiants(), and funct::tan().

   {
     //PG 200 > atan (50/0.5)
     if (degrees == 90) return 90 ; 
     return tan (radiants (degrees)) ;      
   } 

void EcalEleCalibLooper::startingNewLoop ( unsigned int ciclo )

virtual

startingNewLoop empties the map of the calibBlock so that it can be filled

Implements edm::EDLooperBase.

Definition at line 170 of file EcalEleCalibLooper.cc.

References m_EcalCalibBlocks, and m_xtalNumOfHits.

 {
   edm::LogInfo ("IML") << "[InvMatrixCalibLooper][Start] entering loop " << ciclo;
 
  
 
   for (std::vector<VEcalCalibBlock *>::iterator calibBlock = m_EcalCalibBlocks.begin () ;
        calibBlock != m_EcalCalibBlocks.end () ;
        ++calibBlock) 
           (*calibBlock)->reset ();
   for (std::map<int,int>::iterator it= m_xtalNumOfHits.begin();
        it!=m_xtalNumOfHits.end();
        ++it)
     it->second = 0 ;
  return ;
 }