Atlfast::ElectronMatrixManager

Atlfast::ElectronMatrixManager Class Reference

Provides smear matrices corresponding to given track trajectories. More...

#include <ElectronMatrixManager.h>

Inheritance diagram for Atlfast::ElectronMatrixManager:

Inheritance graph
[legend]
Collaboration diagram for Atlfast::ElectronMatrixManager:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 ElectronMatrixManager (string, string, int, MsgStream)
virtual ~ElectronMatrixManager ()
vector< double > getVariables (const TrackTrajectory &track, HepSymMatrix &usedSigma) const

Private Member Functions

void initialise ()
void fillVector (ifstream &, vector< vector< double > > &, int)
void makeHeader ()
IBinData * getBinData (const TrackTrajectory &track) const

Private Attributes

MsgStream * m_log
string m_bremParamFile
string m_smearParamFile
BremMatrixManager * m_bremMgr
map< BinID, IBinData * > m_binData
CorrelatedData * m_correlatedData
int m_randSeed
vector< double > m_etaBoundaries
vector< double > m_rTBoundaries
int m_nRTBins
int m_nEtaBins

Detailed Description

Provides smear matrices corresponding to given track trajectories.

Used by Atlfast::TrackSmearer. It reads a flat file containing smear matrix data and creates a BinData object for every eta/rT bin.

Definition at line 40 of file ElectronMatrixManager.h.

Constructor & Destructor Documentation

Atlfast::ElectronMatrixManager::ElectronMatrixManager ( string  ,
string  ,
int  ,
MsgStream   
)

Default Constructor

Definition at line 13 of file ElectronMatrixManager.cxx.

00016                                                                 : 
00017                          m_bremParamFile( bremParamFile ), 
00018                          m_smearParamFile( smearParamFile ), 
00019                          m_randSeed( randSeed )
00020   {
00021     m_log = &log;
00022     *m_log << MSG::INFO 
00023            << "Constructing ElectronMatrixManager with parameter files "
00024            << m_bremParamFile 
00025            << "  "
00026            << m_smearParamFile 
00027            << endreq;
00028     
00029     m_smearParamFile = PathResolver::find_file( m_smearParamFile, "DATAPATH" );
00030     m_bremMgr = new BremMatrixManager( m_bremParamFile, m_randSeed, *m_log );
00031     m_correlatedData = new CorrelatedData( m_randSeed );
00032     this->initialise();
00033     *m_log << MSG::INFO << "Constructed ElectronMatrixManager" << endreq;
00034   }

Atlfast::ElectronMatrixManager::~ElectronMatrixManager (  )  [virtual]

Default Destructor

Definition at line 40 of file ElectronMatrixManager.cxx.

00041   {
00042     delete m_bremMgr;
00043     delete m_correlatedData;
00044     map<BinID, IBinData*>::iterator iter = m_binData.begin();
00045     map<BinID, IBinData*>::iterator end = m_binData.end();
00046     for ( ; iter != end; ++iter )
00047     {
00048       delete ( iter->second ); 
00049     }
00050   }

Member Function Documentation

vector< double > Atlfast::ElectronMatrixManager::getVariables ( const TrackTrajectory &  track,
HepSymMatrix &  usedSigma 
) const [virtual]

returns correlation matrix corresponding to given track trajectory

Implements Atlfast::IMatrixManager.

Definition at line 287 of file ElectronMatrixManager.cxx.

00289   {
00290     HepSymMatrix sigma;
00291     vector<double> variables;
00292 
00293     // get bremsstrahlung corrections
00294     TrackTrajectory bremTrack = m_bremMgr->getBremTrack(track);
00295     TrackParameters bremTrkParam = bremTrack.parameters();
00296 
00297     // get data for gaussian smearing
00298     IBinData* binData = getBinData(track);
00299     sigma = binData->getMatrix(track);
00300     
00301     // do Dcorset and Dcorgen to get smeared parameters
00302     variables = m_correlatedData->generate( m_correlatedData->root(sigma) );
00303     
00304     // add bremsstahlung and gaussian smearing effects
00305     variables[0] += bremTrkParam.impactParameter();
00306     variables[2] += bremTrkParam.phi();
00307     variables[4] += bremTrkParam.invPtCharge();
00308     
00309     // adjust covariance matrix
00310     // (1,3) ... cov(d0,phi0)
00311     sigma(1,3) = sigma(1,3) / std::sqrt( sigma(1,1) * sigma(3,3) )
00312                             * std::abs( variables[0] * variables[2] );
00313     // (1,5) ... cov(d0,q/pT)
00314     sigma(1,5) = sigma(1,5) / std::sqrt( sigma(1,1) * sigma(5,5) )
00315                             * std::abs( variables[0] * variables[4] )  ;
00316     // (3,5) ... cov(phi0,q/pT)
00317     sigma(3,5) = sigma(3,5) / std::sqrt( sigma(3,3) * sigma(5,5) )
00318                             * std::abs( variables[2] * variables[4] )  ;
00319     sigma(3,1) = sigma(1,3);                        
00320     sigma(5,1) = sigma(1,5);                        
00321     sigma(5,3) = sigma(3,5);                        
00322     sigma(1,1) = std::pow( variables[0], 2 );  // (1,1) ... cov(d0,d0)
00323     sigma(3,3) = std::pow( variables[2], 2 );  // (3,3) ... cov(phi0,phi0)
00324     sigma(5,5) = std::pow( variables[4], 2 );  // (5,5) ... cov(q/pT,q/pT)
00325     
00326     returnSigma = sigma;
00327     return variables;
00328   }

void Atlfast::ElectronMatrixManager::initialise (  )  [private]

reads file, creates BinData objects and asks them to calculate their matrices

Definition at line 55 of file ElectronMatrixManager.cxx.

00056   {
00057     // open file
00058     ifstream input;
00059     input.open( m_smearParamFile.c_str() );
00060     
00061     if (input) 
00062     {
00063       *m_log << MSG::INFO << "ElectronMatrixManager: File " << m_smearParamFile << " open." << endreq;
00064       
00065       double pTMin, etaMin, etaMax, rtBoundary;
00066       
00067       // read some parameters
00068       input >> pTMin;
00069       input >> etaMin;
00070       input >> etaMax;
00071       input >> m_nEtaBins;
00072       input >> m_nRTBins;
00073       
00074       // construct vector<binboundaries>
00075       double etaStep = (etaMax - etaMin) / double(m_nEtaBins);
00076       for ( int i = 0; i < m_nEtaBins; i++ )
00077       { 
00078         m_etaBoundaries.push_back( etaMin + etaStep/2. + double(i)*etaStep );
00079       }
00080       
00081       for ( int i = 0; i < m_nRTBins + 1; i++ )
00082       { 
00083         input >> rtBoundary;
00084         m_rTBoundaries.push_back(rtBoundary);
00085       }
00086       
00087       // parameters are stored in rT bin blocks----
00088       // with parameters in format:
00089       // core  resolutions: 
00090       //               C0(d0, z0, phi0, cot(theta0), q/pT), 
00091       //               C1(d0, z0, phi0, cot(theta0), q/pT), etc.
00092       // tails resolutions: 
00093       //               C0(d0, z0, phi0, cot(theta0), q/pT), 
00094       //               C1(d0, z0, phi0, cot(theta0), q/pT), etc.
00095       // core fractions: 
00096       //               C0(d0, z0, phi0, cot(theta0), q/pT), 
00097       //               C1(d0, z0, phi0, cot(theta0), q/pT), etc.
00098       // correlation coefficients rho: 
00099       //               C0(rho(d0,phi0), rho(d0,q/pT), rho(phi0,q/pT), rho(z0,cot(theta0))), 
00100       //               C1(rho(d0,phi0), rho(d0,q/pT), rho(phi0,q/pT), rho(z0,cot(theta0))), etc.
00101       //
00102       // coefficients C0,C1,C2,C3,C4 define pT-dependence of the respective quantities
00103       // according to f(pT) = C0 + C1/sqrt(pT) + C2/pT + C3/pT/sqrt(pT) + C4/pT^2
00104         
00105       //start bin id ints at zero
00106       int iBin = 0; 
00107       
00108       for ( int rt = 0; rt < m_nRTBins; rt++ )
00109       {
00110         // make vectors to hold all resolution parameters for this rT bin
00111         vector<double> empty;
00112         
00113         vector< vector<double> >  coreC0( m_nEtaBins, empty ); 
00114         vector< vector<double> >  coreC1( m_nEtaBins, empty );
00115         vector< vector<double> >  coreC2( m_nEtaBins, empty );
00116         vector< vector<double> >  coreC3( m_nEtaBins, empty );
00117         vector< vector<double> >  coreC4( m_nEtaBins, empty );
00118         
00119         vector< vector<double> >  tailsC0( m_nEtaBins, empty );
00120         vector< vector<double> >  tailsC1( m_nEtaBins, empty );
00121         vector< vector<double> >  tailsC2( m_nEtaBins, empty );
00122         vector< vector<double> >  tailsC3( m_nEtaBins, empty );
00123         vector< vector<double> >  tailsC4( m_nEtaBins, empty );
00124         
00125         vector< vector<double> >  fractionsC0( m_nEtaBins, empty );
00126         vector< vector<double> >  fractionsC1( m_nEtaBins, empty );
00127         vector< vector<double> >  fractionsC2( m_nEtaBins, empty );
00128         vector< vector<double> >  fractionsC3( m_nEtaBins, empty );
00129         vector< vector<double> >  fractionsC4( m_nEtaBins, empty );
00130 
00131         vector< vector<double> >  correlationsC0( m_nEtaBins, empty );
00132         vector< vector<double> >  correlationsC1( m_nEtaBins, empty );
00133         vector< vector<double> >  correlationsC2( m_nEtaBins, empty );
00134         vector< vector<double> >  correlationsC3( m_nEtaBins, empty );
00135         vector< vector<double> >  correlationsC4( m_nEtaBins, empty );
00136         
00137         //read eta bin number of values for each Ci, i=0,1,2,3,4, and parameter
00138         // read core data
00139         fillVector( input, coreC0, 5 );
00140         fillVector( input, coreC1, 5 );
00141         fillVector( input, coreC2, 5 );
00142         fillVector( input, coreC3, 5 );
00143         fillVector( input, coreC4, 5 );
00144 
00145         // read tail data
00146         fillVector( input, tailsC0, 5 );
00147         fillVector( input, tailsC1, 5 );
00148         fillVector( input, tailsC2, 5 );
00149         fillVector( input, tailsC3, 5 );
00150         fillVector( input, tailsC4, 5 );
00151 
00152         // read fractions data
00153         fillVector( input, fractionsC0, 5 );
00154         fillVector( input, fractionsC1, 5 );
00155         fillVector( input, fractionsC2, 5 );
00156         fillVector( input, fractionsC3, 5 );
00157         fillVector( input, fractionsC4, 5 );
00158 
00159         // read correlations data
00160         fillVector( input, correlationsC0, 4 );
00161         fillVector( input, correlationsC1, 4 );
00162         fillVector( input, correlationsC2, 4 );
00163         fillVector( input, correlationsC3, 4 );
00164         fillVector( input, correlationsC4, 4 );
00165         
00166         // DATA READING FINISHED FOR THIS RT BIN
00167         
00168         // got all values, now make rT/eta bins and resolution objects
00169         for ( int i = 0; i < m_nEtaBins - 1; ++i ) 
00170         {         
00171           double etaLow = m_etaBoundaries[i];
00172           double etaHigh = m_etaBoundaries[i+1];
00173           
00174           // make bin id with rT and eta boundaries
00175           BinID rTEtaBin( iBin, m_rTBoundaries[rt], m_rTBoundaries[rt+1], etaLow, etaHigh );
00176           
00177           // make parameter resolutions for each parameter
00178           vector<ParameterResolutions*> core;
00179           vector<ParameterResolutions*> tails;
00180           vector<ParameterResolutions*> fractions;
00181           vector<ParameterResolutions*> correlations;
00182           for ( int param = 0; param < 5; param++ ) 
00183           {
00184             vector<BinID> coreCoeffBins;
00185             coreCoeffBins.push_back( BinID( 0, coreC0[i][param], coreC0[i+1][param] ) );
00186             coreCoeffBins.push_back( BinID( 0, coreC1[i][param], coreC1[i+1][param] ) );
00187             coreCoeffBins.push_back( BinID( 0, coreC2[i][param], coreC2[i+1][param] ) );
00188             coreCoeffBins.push_back( BinID( 0, coreC3[i][param], coreC3[i+1][param] ) );
00189             coreCoeffBins.push_back( BinID( 0, coreC4[i][param], coreC4[i+1][param] ) );
00190             core.push_back( new ParameterResolutions( coreCoeffBins, etaLow, etaHigh ) );
00191 
00192             vector<BinID> tailsCoeffBins;
00193             tailsCoeffBins.push_back( BinID( 0, tailsC0[i][param], tailsC0[i+1][param] ) );
00194             tailsCoeffBins.push_back( BinID( 0, tailsC1[i][param], tailsC1[i+1][param] ) );
00195             tailsCoeffBins.push_back( BinID( 0, tailsC2[i][param], tailsC2[i+1][param] ) );
00196             tailsCoeffBins.push_back( BinID( 0, tailsC3[i][param], tailsC3[i+1][param] ) );
00197             tailsCoeffBins.push_back( BinID( 0, tailsC4[i][param], tailsC4[i+1][param] ) );
00198             tails.push_back( new ParameterResolutions( tailsCoeffBins, etaLow, etaHigh ) );
00199 
00200             vector<BinID> fractionsCoeffBins;
00201             fractionsCoeffBins.push_back( BinID( 0, fractionsC0[i][param], fractionsC0[i+1][param] ) );
00202             fractionsCoeffBins.push_back( BinID( 0, fractionsC1[i][param], fractionsC1[i+1][param] ) );
00203             fractionsCoeffBins.push_back( BinID( 0, fractionsC2[i][param], fractionsC2[i+1][param] ) );
00204             fractionsCoeffBins.push_back( BinID( 0, fractionsC3[i][param], fractionsC3[i+1][param] ) );
00205             fractionsCoeffBins.push_back( BinID( 0, fractionsC4[i][param], fractionsC4[i+1][param] ) );
00206             fractions.push_back( new ParameterResolutions( fractionsCoeffBins, etaLow, etaHigh ) );
00207           }
00208           
00209           for ( int param = 0; param < 4; param++ ) 
00210           {
00211             vector<BinID> correlationsCoeffBins;
00212             correlationsCoeffBins.push_back( BinID( 0, correlationsC0[i][param], correlationsC0[i+1][param] ) );
00213             correlationsCoeffBins.push_back( BinID( 0, correlationsC1[i][param], correlationsC1[i+1][param] ) );
00214             correlationsCoeffBins.push_back( BinID( 0, correlationsC2[i][param], correlationsC2[i+1][param] ) );
00215             correlationsCoeffBins.push_back( BinID( 0, correlationsC3[i][param], correlationsC3[i+1][param] ) );
00216             correlationsCoeffBins.push_back( BinID( 0, correlationsC4[i][param], correlationsC4[i+1][param] ) );
00217             correlations.push_back( new ParameterResolutions( correlationsCoeffBins, etaLow, etaHigh ) );
00218           }
00219           
00220           // Now make a bin data with edges rT and eta, containing the 
00221           // correlation data
00222           ElectronBinData* binData = new ElectronBinData( rTEtaBin, core, tails, fractions, correlations, m_randSeed );
00223           
00224           // enter bin data into map
00225           m_binData[rTEtaBin] = binData;
00226           
00227           // increment bin ID
00228           iBin++;
00229           
00230         } // end of eta bin loop
00231       } // end of rT bin loop
00232 
00233       // close file
00234       input.close();
00235       
00236     }
00237     else  // no input file 
00238     { 
00239       *m_log << MSG::INFO 
00240              << "ElectronMatrixManager: no data file ( " << m_smearParamFile << " )!!!!" 
00241              << endreq;
00242     }
00243     
00244     makeHeader();
00245     
00246   }

void Atlfast::ElectronMatrixManager::fillVector ( ifstream &  ,
vector< vector< double > > &  ,
int   
) [private]

Definition at line 265 of file ElectronMatrixManager.cxx.

00268   {
00269     double res;
00270     for ( int param = 0; param < M; param++ ) 
00271     { 
00272       vector< vector<double> >::iterator binIter = myVector.begin();
00273       for ( ; binIter != myVector.end(); binIter++ )
00274       {
00275         input >> res;
00276         binIter->push_back(res);
00277       } 
00278       
00279     }
00280   }

void Atlfast::ElectronMatrixManager::makeHeader (  )  [private]

Definition at line 248 of file ElectronMatrixManager.cxx.

00249   {
00250     HeaderPrinter hp( "Atlfast ElectronTrack Smearer:", *m_log );
00251     hp.add( "Total number of Bins     ", m_nRTBins * m_nEtaBins );
00252     hp.add( "rT Bin Min               ", m_rTBoundaries.front() );        
00253     hp.add( "rT Bin Max               ", m_rTBoundaries.back() );
00254     hp.add( "Number of rT Bins        ", m_nRTBins );
00255     hp.add( "Eta Bin Min              ", m_etaBoundaries.front() );        
00256     hp.add( "Eta Bin Max              ", m_etaBoundaries.back() );
00257     hp.add( "Number of Eta Bins       ", m_nEtaBins );
00258     hp.print();
00259   }

IBinData * Atlfast::ElectronMatrixManager::getBinData ( const TrackTrajectory &  track  )  const [private]

returns BinData object corresponding to track trajectory

Definition at line 335 of file ElectronMatrixManager.cxx.

00336   {
00337     TrackParameters track = traj.parameters();
00338 
00339     vector<double> rTEta;
00340     double rT = abs( traj.radius() );
00341     double eta = abs( track.eta() );
00342 
00343     // validity check
00344     double rTLow = ( (m_binData.begin())->first ).low(0);
00345     double rTHigh = ( (m_binData.rbegin())->first ).high(0);
00346     double etaLow = ( (m_binData.begin())->first ).low(1);
00347     double etaHigh = ( (m_binData.rbegin())->first ).high(1);
00348 
00349     if ( rT < rTLow )  rT = rTLow;
00350     if ( rT > rTHigh ) rT = rTHigh;  
00351     if ( eta < etaLow )  eta = etaLow;
00352     if ( eta > etaHigh ) eta = etaHigh;  
00353 
00354     // find BinID
00355     rTEta.push_back(rT);
00356     rTEta.push_back(eta);
00357 
00358     map<BinID, IBinData*>::const_iterator binIter = m_binData.begin();
00359     map<BinID, IBinData*>::const_iterator binEnd  = m_binData.end();
00360 
00361     for ( ; binIter != binEnd; ++binIter )
00362     {
00363       if ( binIter->first.isInBin(rTEta) ) 
00364       {
00365         return binIter->second;
00366       }
00367     }
00368     // OOPS! couldn't fin bin
00369     *m_log << MSG::WARNING 
00370            << "WARNING: ElectronMatrixManager - No bin; rT " << rT << ", eta " << eta 
00371            << endreq;
00372     
00373     return ( m_binData.begin() )->second;
00374   }

Member Data Documentation

MsgStream* Atlfast::ElectronMatrixManager::m_log [private]

Definition at line 58 of file ElectronMatrixManager.h.

string Atlfast::ElectronMatrixManager::m_bremParamFile [private]

name of flat files containing bremsstrahlung corrections and smear matrix data.

Definition at line 69 of file ElectronMatrixManager.h.

string Atlfast::ElectronMatrixManager::m_smearParamFile [private]

Definition at line 69 of file ElectronMatrixManager.h.

BremMatrixManager* Atlfast::ElectronMatrixManager::m_bremMgr [private]

matrix manager for bremsstrahlung corrections

Definition at line 72 of file ElectronMatrixManager.h.

map<BinID, IBinData*> Atlfast::ElectronMatrixManager::m_binData [private]

BinData objects, paired to a BinID

Definition at line 75 of file ElectronMatrixManager.h.

CorrelatedData* Atlfast::ElectronMatrixManager::m_correlatedData [private]

object which performs dcorset/dcorgen

Definition at line 78 of file ElectronMatrixManager.h.

int Atlfast::ElectronMatrixManager::m_randSeed [private]

Definition at line 80 of file ElectronMatrixManager.h.

vector<double> Atlfast::ElectronMatrixManager::m_etaBoundaries [private]

Definition at line 81 of file ElectronMatrixManager.h.

vector<double> Atlfast::ElectronMatrixManager::m_rTBoundaries [private]

Definition at line 82 of file ElectronMatrixManager.h.

int Atlfast::ElectronMatrixManager::m_nRTBins [private]

Definition at line 83 of file ElectronMatrixManager.h.

int Atlfast::ElectronMatrixManager::m_nEtaBins [private]

Definition at line 84 of file ElectronMatrixManager.h.

The documentation for this class was generated from the following files:
Generated on Mon Sep 24 14:19:37 2007 for AtlfastAlgs by  doxygen 1.5.1