Atlfast::BremMatrixManager

Atlfast::BremMatrixManager Class Reference

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

#include <BremMatrixManager.h>

List of all members.

Public Member Functions

 BremMatrixManager (string, int, MsgStream)
 ~BremMatrixManager ()
TrackTrajectory getBremTrack (const TrackTrajectory &track) const

Private Member Functions

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

Private Attributes

MsgStream * m_log
string m_file
map< BinID, BremBinData * > m_binData
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 tracksmearer to provide smear matrices corresponding to given track trajectories. It reads a flat file containing smear matrix data and creates a BinData object for every eta/rT bin.

Definition at line 39 of file BremMatrixManager.h.

Constructor & Destructor Documentation

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

Default Constructor

Definition at line 13 of file BremMatrixManager.cxx.

00013                                                                                       : 
00014        m_file( paramFile ), 
00015        m_randSeed( randSeed )
00016   {
00017     m_log = &log;
00018     *m_log << MSG::INFO 
00019            << "Constructing BremMatrixManager with parameter file "
00020            << m_file 
00021            << endreq;
00022     m_file = PathResolver::find_file( m_file, "DATAPATH" );
00023     this->initialise();
00024     *m_log << MSG::INFO << "Constructed BremMatrixManager" << endreq;
00025   }

Atlfast::BremMatrixManager::~BremMatrixManager (  ) 

Default Destructor

Definition at line 31 of file BremMatrixManager.cxx.

00032   {
00033     map<BinID, BremBinData*>::iterator iter = m_binData.begin();
00034     map<BinID, BremBinData*>::iterator end = m_binData.end();
00035     for ( ; iter != end; ++iter )
00036     {
00037       delete ( iter->second ); 
00038     }
00039   }

Member Function Documentation

TrackTrajectory Atlfast::BremMatrixManager::getBremTrack ( const TrackTrajectory &  track  )  const

returns modified track parameters according to input track

Definition at line 245 of file BremMatrixManager.cxx.

00246   {
00247 
00248     BremBinData* binData = getBinData(track);
00249     
00250     TrackTrajectory newTrack = binData->getBremTrack(track);
00251 
00252     return newTrack;
00253   }

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

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

Definition at line 44 of file BremMatrixManager.cxx.

00045   {
00046     // open file
00047     ifstream input;
00048     input.open( m_file.c_str() );
00049     
00050     if (input) 
00051     {
00052       *m_log << MSG::INFO << "BremMatrixManager: File " << m_file << " open." << endreq;
00053       
00054       double pTMin, etaMin, etaMax, rtBoundary;
00055       
00056       // read some parameters
00057       input >> pTMin;
00058       input >> etaMin;
00059       input >> etaMax;
00060       input >> m_nEtaBins;
00061       input >> m_nRTBins;
00062       
00063       // construct vector<binboundaries>
00064       double etaStep = (etaMax - etaMin) / double(m_nEtaBins);
00065       for ( int i = 0; i < m_nEtaBins; i++ )
00066       { 
00067         m_etaBoundaries.push_back( etaMin + etaStep/2. + double(i)*etaStep );
00068       }
00069       
00070       for ( int i = 0; i < m_nRTBins + 1; i++ )
00071       { 
00072         input >> rtBoundary;
00073         m_rTBoundaries.push_back(rtBoundary);
00074       }
00075       
00076       // parameters are stored in rT bin blocks----
00077       // with parameters in format:
00078       // power function start points: C0(d0, phi0, q/pT), 
00079       //                              C1(d0, phi0, q/pT), etc.
00080       // power function slopes: C0(d0, phi0, q/pT), 
00081       //                        C1(d0, phi0, q/pT), etc.
00082       // Gaussian sigmas: C0(d0, phi0, q/pT), 
00083       //                  C1(d0, phi0, q/pT), etc.
00084       //
00085       // coefficients C0,C1,C2,C3,C4 define pT-dependence of the respective quantities
00086       // according to f(pT) = C0 + C1/sqrt(pT) + C2/pT + C3/pT/sqrt(pT) + C4/pT^2
00087         
00088       //start bin id ints at zero
00089       int iBin = 0; 
00090       
00091       for ( int rt = 0; rt < m_nRTBins; rt++ )
00092       {
00093         // make vectors to hold all resolution parameters for this rT bin
00094         vector<double> empty;
00095         
00096         vector< vector<double> >  startPointsC0( m_nEtaBins, empty ); 
00097         vector< vector<double> >  startPointsC1( m_nEtaBins, empty );
00098         vector< vector<double> >  startPointsC2( m_nEtaBins, empty );
00099         vector< vector<double> >  startPointsC3( m_nEtaBins, empty );
00100         vector< vector<double> >  startPointsC4( m_nEtaBins, empty );
00101         
00102         vector< vector<double> >  slopesC0( m_nEtaBins, empty );
00103         vector< vector<double> >  slopesC1( m_nEtaBins, empty );
00104         vector< vector<double> >  slopesC2( m_nEtaBins, empty );
00105         vector< vector<double> >  slopesC3( m_nEtaBins, empty );
00106         vector< vector<double> >  slopesC4( m_nEtaBins, empty );
00107         
00108         vector< vector<double> >  sigmasC0( m_nEtaBins, empty );
00109         vector< vector<double> >  sigmasC1( m_nEtaBins, empty );
00110         vector< vector<double> >  sigmasC2( m_nEtaBins, empty );
00111         vector< vector<double> >  sigmasC3( m_nEtaBins, empty );
00112         vector< vector<double> >  sigmasC4( m_nEtaBins, empty );
00113         
00114         //read eta bin number of values for each Ci, i=0,1,2,3, and parameter
00115         // read start point data
00116         fillVector( input, startPointsC0, 3 );
00117         fillVector( input, startPointsC1, 3 );
00118         fillVector( input, startPointsC2, 3 );
00119         fillVector( input, startPointsC3, 3 );
00120         fillVector( input, startPointsC4, 3 );
00121 
00122         // read slope data
00123         fillVector( input, slopesC0, 3 );
00124         fillVector( input, slopesC1, 3 );
00125         fillVector( input, slopesC2, 3 );
00126         fillVector( input, slopesC3, 3 );
00127         fillVector( input, slopesC4, 3 );
00128 
00129         // read Gaussian sigma data
00130         fillVector( input, sigmasC0, 3 );
00131         fillVector( input, sigmasC1, 3 );
00132         fillVector( input, sigmasC2, 3 );
00133         fillVector( input, sigmasC3, 3 );
00134         fillVector( input, sigmasC4, 3 );
00135         
00136         // DATA READING FINISHED FOR THIS RT BIN
00137         
00138         // got all values, now make rT/eta bins and resolution objects
00139         for ( int i = 0; i < m_nEtaBins - 1; ++i ) 
00140         {         
00141           double etaLow = m_etaBoundaries[i];
00142           double etaHigh = m_etaBoundaries[i+1];
00143           
00144           // make bin id with rT and eta boundaries
00145           BinID rTEtaBin( iBin, m_rTBoundaries[rt], m_rTBoundaries[rt+1], etaLow, etaHigh );
00146           
00147           // make parameter resolutions for each parameter
00148           vector<ParameterResolutions*> startPoints;
00149           vector<ParameterResolutions*> slopes;
00150           vector<ParameterResolutions*> sigmas;
00151           for ( int param = 0; param < 3; param++ ) 
00152           {
00153             vector<BinID> startPointCoeffBins;
00154             startPointCoeffBins.push_back( BinID( 0, startPointsC0[i][param], startPointsC0[i+1][param] ) );
00155             startPointCoeffBins.push_back( BinID( 0, startPointsC1[i][param], startPointsC1[i+1][param] ) );
00156             startPointCoeffBins.push_back( BinID( 0, startPointsC2[i][param], startPointsC2[i+1][param] ) );
00157             startPointCoeffBins.push_back( BinID( 0, startPointsC3[i][param], startPointsC3[i+1][param] ) );
00158             startPointCoeffBins.push_back( BinID( 0, startPointsC4[i][param], startPointsC4[i+1][param] ) );
00159             startPoints.push_back( new ParameterResolutions( startPointCoeffBins, etaLow, etaHigh ) );
00160 
00161             vector<BinID> slopeCoeffBins;
00162             slopeCoeffBins.push_back( BinID( 0, slopesC0[i][param], slopesC0[i+1][param] ) );
00163             slopeCoeffBins.push_back( BinID( 0, slopesC1[i][param], slopesC1[i+1][param] ) );
00164             slopeCoeffBins.push_back( BinID( 0, slopesC2[i][param], slopesC2[i+1][param] ) );
00165             slopeCoeffBins.push_back( BinID( 0, slopesC3[i][param], slopesC3[i+1][param] ) );
00166             slopeCoeffBins.push_back( BinID( 0, slopesC4[i][param], slopesC4[i+1][param] ) );
00167             slopes.push_back( new ParameterResolutions( slopeCoeffBins, etaLow, etaHigh ) );
00168 
00169             vector<BinID> sigmaCoeffBins;
00170             sigmaCoeffBins.push_back( BinID( 0, sigmasC0[i][param], sigmasC0[i+1][param] ) );
00171             sigmaCoeffBins.push_back( BinID( 0, sigmasC1[i][param], sigmasC1[i+1][param] ) );
00172             sigmaCoeffBins.push_back( BinID( 0, sigmasC2[i][param], sigmasC2[i+1][param] ) );
00173             sigmaCoeffBins.push_back( BinID( 0, sigmasC3[i][param], sigmasC3[i+1][param] ) );
00174             sigmaCoeffBins.push_back( BinID( 0, sigmasC4[i][param], sigmasC4[i+1][param] ) );
00175             sigmas.push_back( new ParameterResolutions( sigmaCoeffBins, etaLow, etaHigh ) );
00176           }
00177           
00178           // Now make a bin data with edges rT and eta, containing the 
00179           // data for bremsstrahlung corrections
00180           BremBinData* binData = new BremBinData( rTEtaBin, startPoints, slopes, sigmas, m_randSeed );
00181           
00182           // enter bin data into map
00183           m_binData[rTEtaBin] = binData;
00184           
00185           // increment bin ID
00186           iBin++;
00187           
00188         } // end of eta bin loop
00189       } // end of rT bin loop
00190 
00191       // close file
00192       input.close();
00193       
00194     }
00195     else  // no input file 
00196     { 
00197       *m_log << MSG::INFO 
00198              << "BremMatrixManager: no data file ( " << m_file << " )!!!!" 
00199              << endreq;
00200     }
00201     
00202     makeHeader();
00203     
00204   }

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

Definition at line 223 of file BremMatrixManager.cxx.

00226   {
00227     double res;
00228     for ( int param = 0; param < M; param++ ) 
00229     { 
00230       vector< vector<double> >::iterator binIter = myVector.begin();
00231       for ( ; binIter != myVector.end(); binIter++ )
00232       {
00233         input >> res;
00234         binIter->push_back(res);
00235       } 
00236       
00237     }
00238   }

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

Definition at line 206 of file BremMatrixManager.cxx.

00207   {
00208     HeaderPrinter hp( "Atlfast BremMatrixManager:", *m_log );
00209     hp.add( "Total number of Bins     ", m_nRTBins * m_nEtaBins );
00210     hp.add( "rT Bin Min               ", m_rTBoundaries.front() );        
00211     hp.add( "rT Bin Max               ", m_rTBoundaries.back() );
00212     hp.add( "Number of rT Bins        ", m_nRTBins );
00213     hp.add( "Eta Bin Min              ", m_etaBoundaries.front() );        
00214     hp.add( "Eta Bin Max              ", m_etaBoundaries.back() );
00215     hp.add( "Number of Eta Bins       ", m_nEtaBins );
00216     hp.print();
00217   }

BremBinData * Atlfast::BremMatrixManager::getBinData ( const TrackTrajectory &  track  )  const [private]

returns BremBinData object corresponding to track trajectory

Definition at line 260 of file BremMatrixManager.cxx.

00261   {
00262     TrackParameters track = traj.parameters();
00263 
00264     vector<double> rTEta;
00265     double rT = abs( traj.radius() );
00266     double eta = abs( track.eta() );
00267 
00268     // validity check
00269     double rTLow = ( (m_binData.begin())->first ).low(0);
00270     double rTHigh = ( (m_binData.rbegin())->first ).high(0);
00271     double etaLow = ( (m_binData.begin())->first ).low(1);
00272     double etaHigh = ( (m_binData.rbegin())->first ).high(1);
00273 
00274     if ( rT < rTLow )  rT = rTLow;
00275     if ( rT > rTHigh ) rT = rTHigh;  
00276     if ( eta < etaLow )  eta = etaLow;
00277     if ( eta > etaHigh ) eta = etaHigh;  
00278 
00279     // find BinID
00280     rTEta.push_back(rT);
00281     rTEta.push_back(eta);
00282 
00283     map<BinID, BremBinData*>::const_iterator binIter = m_binData.begin();
00284     map<BinID, BremBinData*>::const_iterator binEnd  = m_binData.end();
00285 
00286     for ( ; binIter != binEnd; ++binIter )
00287     {
00288       if ( binIter->first.isInBin(rTEta) ) 
00289       {
00290         return binIter->second;
00291       }
00292     }
00293     // OOPS! couldn't fin bin
00294     *m_log << MSG::WARNING 
00295            << "WARNING: BremMatrixManager - No bin; rT " << rT << ", eta " << eta 
00296            << endreq;
00297     
00298     return ( m_binData.begin() )->second;
00299   }

Member Data Documentation

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

Definition at line 56 of file BremMatrixManager.h.

string Atlfast::BremMatrixManager::m_file [private]

name of flat file containing smear matrix data.

Definition at line 67 of file BremMatrixManager.h.

map<BinID, BremBinData*> Atlfast::BremMatrixManager::m_binData [private]

BinData objects, paired to a BinID

Definition at line 70 of file BremMatrixManager.h.

int Atlfast::BremMatrixManager::m_randSeed [private]

Definition at line 72 of file BremMatrixManager.h.

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

Definition at line 73 of file BremMatrixManager.h.

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

Definition at line 74 of file BremMatrixManager.h.

int Atlfast::BremMatrixManager::m_nRTBins [private]

Definition at line 75 of file BremMatrixManager.h.

int Atlfast::BremMatrixManager::m_nEtaBins [private]

Definition at line 76 of file BremMatrixManager.h.

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