FPGATrackSimFitConstantBank Class Reference

#include <FPGATrackSimFitConstantBank.h>

Inheritance diagram for FPGATrackSimFitConstantBank:

Collaboration diagram for FPGATrackSimFitConstantBank:

Public Member Functions
	FPGATrackSimFitConstantBank (FPGATrackSimPlaneMap const *pmap, int ncoords, std::string const &fname, bool isFirstStage, float phishift, int missingPlane=-1)
int	getBankID () const
int	getNConstr () const
int	getNCoords () const
int	getNPars () const
int	getNSectors () const
int	getMissingPlane () const
bool	getIsGood (sector_t sector) const
float	getFitConst (int isec, int ipar) const
float	getFitPar (int isec, int ipar, int icoord) const
float	getKaverage (int isec, int iconstr) const
float	getKernel (int isec, int iconstr, int icoord) const
bool	linfit (sector_t sector, FPGATrackSimTrack &track, bool isSecondStage) const
void	linfit_chisq (sector_t sector, FPGATrackSimTrack &trk) const
void	linfit_pars_eval (sector_t sector, FPGATrackSimTrack &trk) const
int	missing_point_guess (sector_t sector, FPGATrackSimTrack &track, bool isFirstStage, bool doExtrapolation) const
void	invlinfit (sector_t sector, FPGATrackSimTrack &track, double const *constr) const
	This method uses the track parameters and additional constraints to use the constants to calculate the corresponding hits.
void	setIdealCoordFit (bool v)
void	setPhiShift (float v)
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Member Functions
void	readHeader (std::ifstream &geocfile)
void	readSectorInfo (std::ifstream &geocfile)
void	calculateMajority ()
void	prepareInvFitConstants ()
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
FPGATrackSimPlaneMap const *	m_pmap = nullptr
int	m_bankID
int	m_nsectors
int	m_npars = 0
int	m_ncoords
int	m_nconstr
int	m_npixcy
float	m_phiShift
int	m_missingPlane
bool	m_isIdealCoordFit
std::vector< int >	m_missid
std::vector< bool >	m_sector_good
vector3D< float >	m_fit_pars
vector2D< float >	m_fit_const
vector3D< float >	m_kernel
vector2D< float >	m_kaverage
vector2D< float >	m_maj_a
vector3D< float >	m_maj_kk
vector3D< float >	m_maj_invkk
std::vector< Eigen::MatrixXf, Eigen::aligned_allocator< Eigen::MatrixXf > >	m_invfit_consts
vector2D< int >	m_WCs
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

Definition at line 23 of file FPGATrackSimFitConstantBank.h.

Constructor & Destructor Documentation

FPGATrackSimFitConstantBank()

FPGATrackSimFitConstantBank::FPGATrackSimFitConstantBank	(	FPGATrackSimPlaneMap const *	pmap,
		int	ncoords,
		std::string const &	fname,
		bool	isFirstStage,
		float	phishift,
		int	missingPlane = -1 )

Definition at line 22 of file FPGATrackSimFitConstantBank.cxx.

                                                                                                                                                                          :
    AthMessaging ("FPGATrackSimFitConstantBank"),
    m_pmap(pmap),
    m_bankID(0),
    m_nsectors(0),
    m_ncoords(ncoords),
    m_nconstr(0),
    m_npixcy(0),
    m_phiShift(phishift),    
    m_missingPlane(missingPlane),
//    m_isFirstStage(isFirstStage),
    m_isIdealCoordFit(true)
{
  std::ifstream geocfile(fname);
  if (not geocfile.is_open()) {
    ATH_MSG_WARNING("FitConstants file: " << fname << " cannot be opened");
  }
  else {
    ATH_MSG_INFO("Reading " << fname);
    // Read the file header
    readHeader(geocfile);
    ATH_MSG_INFO("Settings: m_ncoords="<<m_ncoords<<" m_npars="<<m_npars);
    // Read the sector constants
    //coverity[TAINTED_SCALAR]
    readSectorInfo(geocfile);
    // Pre-calculate the majority logic elements
    if (m_missingPlane == -1)
      //coverity[TAINTED_SCALAR]
      calculateMajority();
    
    if (sizeof(float) * CHAR_BIT != 32)
      ATH_MSG_WARNING("Floating points on this computer are not 32 bit. This may cause a problem for the hardware agreement. Be careful!");
    
    setIdealCoordFit(true);
    //coverity[TAINTED_SCALAR]
    prepareInvFitConstants();
  }
}

Member Function Documentation

calculateMajority()

void FPGATrackSimFitConstantBank::calculateMajority ( )

private

Definition at line 174 of file FPGATrackSimFitConstantBank.cxx.

{
 
    for (int isec=0;isec!=m_nsectors;++isec)
    {
        // Fill m_maj_a and m_maj_kk
        for (int ix=0;ix!=m_ncoords;++ix)
      {
            for (int row=0;row!=m_nconstr;++row)
          m_maj_a(isec, ix) += m_kaverage(isec, row) * m_kernel(isec, row, ix);
            for (int jx=0;jx!=m_ncoords;++jx)
          {
                for (int row=0;row!=m_nconstr;++row)
          m_maj_kk(isec, ix, jx) += m_kernel(isec, row, ix) * m_kernel(isec, row, jx);
          }
      }
 
        // Fill m_maj_invkk
 
        // Pixel layers (2 coordinates each), assume these come first!
        for (int ix=0;ix!=m_npixcy;ix+=2)
        {
            float det = m_maj_kk(isec, ix, ix) * m_maj_kk(isec, ix+1, ix+1)
                      - m_maj_kk(isec, ix+1, ix) * m_maj_kk(isec, ix, ix+1);
            if (det == 0) continue;
 
            m_maj_invkk(isec, ix, ix)       = m_maj_kk(isec, ix+1, ix+1)/det;
            m_maj_invkk(isec, ix, ix+1)     = -m_maj_kk(isec, ix+1, ix)/det;
            m_maj_invkk(isec, ix+1, ix)     = -m_maj_kk(isec, ix, ix+1)/det;
            m_maj_invkk(isec, ix+1, ix+1)   = m_maj_kk(isec, ix, ix)/det;
        }
 
        // Strip layers (1 coordinate)
        for (int ix=m_npixcy;ix!=m_ncoords;++ix) {
      if (m_maj_kk(isec, ix, ix) == 0) continue;
      m_maj_invkk(isec, ix, ix) = 1./m_maj_kk(isec, ix, ix);
    }
    }
}

getBankID()

int FPGATrackSimFitConstantBank::getBankID ( ) const

inline

Definition at line 33 of file FPGATrackSimFitConstantBank.h.

{ return m_bankID; }

getFitConst()

float FPGATrackSimFitConstantBank::getFitConst ( int isec, int ipar ) const

inline

Definition at line 42 of file FPGATrackSimFitConstantBank.h.

{ return m_fit_const(isec, ipar); }

getFitPar()

float FPGATrackSimFitConstantBank::getFitPar ( int isec, int ipar, int icoord ) const

inline

Definition at line 43 of file FPGATrackSimFitConstantBank.h.

{ return m_fit_pars(isec, ipar, icoord); }

getIsGood()

bool FPGATrackSimFitConstantBank::getIsGood ( sector_t sector ) const

inline

Definition at line 41 of file FPGATrackSimFitConstantBank.h.

{ return m_sector_good[sector]; }

getKaverage()

float FPGATrackSimFitConstantBank::getKaverage ( int isec, int iconstr ) const

inline

Definition at line 44 of file FPGATrackSimFitConstantBank.h.

{ return m_kaverage(isec, iconstr); }

getKernel()

float FPGATrackSimFitConstantBank::getKernel ( int isec, int iconstr, int icoord ) const

inline

Definition at line 45 of file FPGATrackSimFitConstantBank.h.

{ return m_kernel(isec, iconstr, icoord); }

getMissingPlane()

int FPGATrackSimFitConstantBank::getMissingPlane ( ) const

inline

Definition at line 38 of file FPGATrackSimFitConstantBank.h.

{ return m_missingPlane; }

getNConstr()

int FPGATrackSimFitConstantBank::getNConstr ( ) const

inline

Definition at line 34 of file FPGATrackSimFitConstantBank.h.

{ return m_nconstr; }

getNCoords()

int FPGATrackSimFitConstantBank::getNCoords ( ) const

inline

Definition at line 35 of file FPGATrackSimFitConstantBank.h.

{ return m_ncoords; }

getNPars()

int FPGATrackSimFitConstantBank::getNPars ( ) const

inline

Definition at line 36 of file FPGATrackSimFitConstantBank.h.

{ return m_npars; }

getNSectors()

int FPGATrackSimFitConstantBank::getNSectors ( ) const

inline

Definition at line 37 of file FPGATrackSimFitConstantBank.h.

{ return m_nsectors; }

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

invlinfit()

void FPGATrackSimFitConstantBank::invlinfit	(	sector_t	sector,
		FPGATrackSimTrack &	track,
		double const *	constr ) const

This method uses the track parameters and additional constraints to use the constants to calculate the corresponding hits.

This method is the base of the patt-from-constant generation.

Definition at line 557 of file FPGATrackSimFitConstantBank.cxx.

{
    // vector of the acutal parameters, it is zeroed
    Eigen::VectorXf pars(m_ncoords);
 
    for (int ip = 0; ip < m_npars; ++ip)
    {
        // The first elements are the track parameters. The track are shifted using the sector constants
        pars(ip) = track.getParameter(ip) - m_fit_const(sector, ip);
        if (ip == 2) pars(ip) = remainder(pars(ip), 2.*M_PI);
    }
    for (int ic = 0; ic < m_nconstr; ++ic)
    {
        // The rest of the paramaters are the external constraints.
        // The external constraint is also shifted by the kAverage value
        if (!constr)
            pars(m_npars+ic) = -m_kaverage(sector, ic);
        else
            pars(m_npars+ic) = constr[ic] - m_kaverage(sector, ic);
    }
 
    // The raw hits are obtained multiplying the parameters to the inverted constants
    Eigen::VectorXf rawhits = (m_invfit_consts[sector]) * pars;
 
    // The hits are assigned to the original track
    for (int j = 0; j < m_ncoords ; ++j) {
      int plane = m_pmap->getCoordLayer(j);
      SiliconTech Tech = m_pmap->getDetType(plane);
      FPGATrackSimHit hit;
      hit.setHitType(HitType::mapped);
      hit.setDetType(Tech);
      hit.setLayer(plane);
      if (m_WCs(sector,j))
    hit.setPhiIndex(-1); // to keep track later on, set hit position negative
      else
    hit.setPhiIndex(rawhits(j));
 
      if (Tech == SiliconTech::pixel) {
    if (m_WCs(sector,j))
      hit.setEtaIndex(-1); // to keep track later on, set hit position negative
    else
      hit.setEtaIndex(rawhits(j+1));
 
    ++j; // skip a coordinate if doing two at once
      }
      track.setFPGATrackSimHit(plane, std::make_shared<FPGATrackSimHit>(std::move(hit)));
    }
}

linfit()

bool FPGATrackSimFitConstantBank::linfit	(	sector_t	sector,
		FPGATrackSimTrack &	track,
		bool	isSecondStage ) const

Definition at line 309 of file FPGATrackSimFitConstantBank.cxx.

{
    // Do majority guess if it's needed
    if (m_missingPlane == -1 && !m_isIdealCoordFit)
    {
        int nmissing = track.getNMissing();
        if (nmissing > 0)
        {
        int guess_res = missing_point_guess(sector, track, !isSecondStage, false);
            if (nmissing != guess_res) return false; // majority failed
        }
    }
 
    // evaluate the chi2
    linfit_chisq(sector, track);
 
    // Do the fit
    linfit_pars_eval(sector, track);
 
    return true;
}

linfit_chisq()

void FPGATrackSimFitConstantBank::linfit_chisq	(	sector_t	sector,
		FPGATrackSimTrack &	trk ) const

we don't want to shift phi for the outer hits in a SP, so check that!

Definition at line 476 of file FPGATrackSimFitConstantBank.cxx.

{
    float chi2 = 0;
 
    for (int i = 0; i < m_nconstr; i++)
    {
        float chi_component = m_kaverage(sector, i);
 
        for (int coord = 0; coord < m_ncoords; coord++) {
      unsigned layer = m_pmap->getCoordLayer(coord);
 
    if (m_pmap->getDim(m_pmap->getCoordLayer(coord)) == 2) { // do two at a time if 2d, then skip ahead
      chi_component += m_kernel(sector, i, coord) * (m_phiShift+trk.getPhiCoord(layer));
      chi_component += m_kernel(sector, i, coord+1) * trk.getEtaCoord(layer);
      ++coord;
    }
    else { // strip coords      
      float phishift = m_phiShift;
      auto hitPtr = trk.getFPGATrackSimHitPtrs()[layer];
      if (!hitPtr) throw std::runtime_error("Null hit pointer in getAccumulatorTerm: tracks should not have unassigned layers");
      if (((hitPtr->getPhysLayer() %2) == 1) && hitPtr->getHitType() == HitType::spacepoint) phishift = 0.0;
      chi_component += m_kernel(sector, i, coord) * (phishift+trk.getPhiCoord(layer));
    }
  } 
  chi2 += chi_component * chi_component;
 
    }
    trk.setChi2(chi2);
}

linfit_pars_eval()

void FPGATrackSimFitConstantBank::linfit_pars_eval	(	sector_t	sector,
		FPGATrackSimTrack &	trk ) const

we don't want to shift phi for the outer hits in a SP, so check that!

Definition at line 515 of file FPGATrackSimFitConstantBank.cxx.

{
  std::vector<float> pars(m_npars);
 
    for (int ip = 0; ip < m_npars; ip++)
    {
        pars[ip] = m_fit_const(sector, ip);
    
        for (int coord = 0; coord < m_ncoords; coord++) {

    float phishift = m_phiShift;
    int layer = m_pmap->getCoordLayer(coord);
    auto hitPtr = trk.getFPGATrackSimHitPtrs()[layer];
    if (!hitPtr) throw std::runtime_error("Null hit pointer in getTrackPars: tracks should not have unassigned layers");
    if (((hitPtr->getPhysLayer() %2) == 1) && hitPtr->getHitType() == HitType::spacepoint) phishift = 0.0;
    
    pars[ip] += m_fit_pars(sector, ip, coord) * (phishift+trk.getPhiCoord(layer));
    if (m_pmap->getDim(m_pmap->getCoordLayer(coord)) == 2) { // do two at a time if 2d, then skip ahead
      pars[ip] += m_fit_pars(sector, ip, coord+1) * trk.getEtaCoord(layer);
      ++coord;
    }
  }
    }
    
    trk.setQOverPt(pars[0]);
    trk.setD0(pars[1]);
    trk.setPhi(pars[2]-m_phiShift); // angle is moved within -pi to +pi, and shift phi back to the range we want
    trk.setZ0(pars[3]);
    trk.setEta(pars[4]);
    if (trk.getDoDeltaGPhis()) {
      trk.setQOverPt(trk.getHoughY()/1000.0 - trk.getQOverPt()); // final  q/pT =  q/pT from HT + delta q/pT
      trk.setPhi(trk.getHoughX() - trk.getPhi());                // final phi_0 = phi_0 from HT + delta phi_0
    }
    
}

missing_point_guess()

int FPGATrackSimFitConstantBank::missing_point_guess	(	sector_t	sector,
		FPGATrackSimTrack &	track,
		bool	isFirstStage,
		bool	doExtrapolation ) const

we don't want to shift phi for the outer hits in a SP, so check that!

Definition at line 332 of file FPGATrackSimFitConstantBank.cxx.

{
 
    std::vector<int> coordsmask(m_ncoords);
    std::vector<int> missid;
 
    // Keep track of which hits are missing
    int nmissing = 0;
    std::vector<int> missing_planes;
    for (int j = 0; j < m_ncoords ; ++j)
    {
        coordsmask[j] = (track.getHitMap()>>j) & 1;
        if (!coordsmask[j]) {
            int plane = m_pmap->getCoordLayer(j);
            if(missing_planes.size() == 0) {
                missing_planes.push_back(plane);
            }
            else {
                for (unsigned k = 0; k < missing_planes.size(); k++) {
                    if(plane == missing_planes[k]) break;
                    if(k == missing_planes.size() - 1) missing_planes.push_back(plane);
                }
            }
            missid.push_back(j);
            nmissing++;
        }
    }
 
    if(!doExtrapolation){
      if(isFirstStage){
    if(missing_planes.size() > 1){
      ATH_MSG_WARNING("missing_point_guess() Can only guess 1 layer in the first stage");
      return 0;
    }
    if (nmissing > 2){
      ATH_MSG_WARNING("missing_point_guess() Cannot guess more than two coordinates in the first stage");
      return 0;
    }
      }
      else{
    if(missing_planes.size() > 2){
      ATH_MSG_WARNING("missing_point_guess() Can only guess 2 layers in the second stage");
      return 0;
    }
    if (nmissing > 4){
      ATH_MSG_WARNING("missing_point_guess() Cannot guess more than four coordinates in the second stage");
      return 0;
    } 
      }
    }
 
    Eigen::MatrixXd coef(nmissing,nmissing);
    Eigen::VectorXd a(nmissing);
 
    for (int i=0; i<nmissing; ++i)
    {
      a[i] = -m_maj_a(sector, missid[i]);
        // complete the calculation with the terms that depend on the known hits
        for (int col=0; col<m_ncoords; ++col)
        {
            if (!coordsmask[col]) continue;

        float phishift = m_phiShift;
        int layer = m_pmap->getCoordLayer(col);
        auto hit_ptr = track.getFPGATrackSimHitPtrs()[layer];
        if (!hit_ptr) throw std::runtime_error("Null hit pointer in FPGATrackSimFitConstantBank: tracks should not have unassigned layers");
        FPGATrackSimHit hit = *hit_ptr;
        if (((hit.getPhysLayer() %2) == 1) && hit.getHitType() == HitType::spacepoint) phishift = 0.0;
 
            a[i] -= m_maj_kk(sector, col, missid[i])*(phishift+track.getPhiCoord(m_pmap->getCoordLayer(col)));
 
            if (m_pmap->getDim(m_pmap->getCoordLayer(col)) == 2) { // do two at a time if 2d, then skip ahead
               a[i] -= m_maj_kk(sector, col+1, missid[i])*track.getEtaCoord(m_pmap->getCoordLayer(col));
               ++col;
            }
        }
 
        for (int j=0; j<nmissing; ++j)
        {
        // here for missing pieces need to know the coordinate and sector number only
            coef(i,j) = m_maj_kk(sector, missid[i], missid[j]);
        }
    }
 
    if (coef.determinant()==0) return -1;
    Eigen::VectorXd missing_hits = coef.inverse()*a; // our missing hits!
 
    for(int m=0; m<nmissing; m++){
 
      int missedplane = m_pmap->getCoordLayer(missid[m]);
 
      if(m_pmap->getDim(m_pmap->getCoordLayer(missid[m])) == 1){
      
    FPGATrackSimHit newhit;
    if(!doExtrapolation)
      newhit.setHitType(HitType::guessed);
    else
      newhit.setHitType(HitType::extrapolated);
    newhit.setDetType(SiliconTech::strip);
    newhit.setLayer(missedplane);
    newhit.setSection(0);
    if (m_isIdealCoordFit) {
          // TODO: all the missing hit logic will eventually need spacepoint updates.
      double target_r = track.getIdealRadius(missedplane);
      newhit.setX(target_r*TMath::Cos(missing_hits[m]));
      newhit.setY(target_r*TMath::Sin(missing_hits[m]));
    }
    else{
      newhit.setPhiIndex(missing_hits[m]);
    }
 
    track.setFPGATrackSimHit(missedplane, std::make_shared<FPGATrackSimHit>(newhit));
      }
      else if (m_pmap->getDim(m_pmap->getCoordLayer(missid[m])) == 2){
 
    FPGATrackSimHit newhit;
    if(!doExtrapolation)
          newhit.setHitType(HitType::guessed);
    else
          newhit.setHitType(HitType::extrapolated);
    newhit.setDetType(SiliconTech::pixel);
    newhit.setLayer(missedplane);
    newhit.setSection(0);
    if (m_isIdealCoordFit) {
          // TODO This will also eventually ned spacepoint updates.
      double target_r = track.getIdealRadius(missedplane);
      newhit.setX(target_r*TMath::Cos(missing_hits[m]));
      newhit.setY(target_r*TMath::Sin(missing_hits[m]));
      newhit.setZ(missing_hits[m+1]);
    }
    else {
      newhit.setPhiIndex(missing_hits[m]);
      newhit.setEtaIndex(missing_hits[m+1]);
    }
    m++; //skip ahead
 
    track.setFPGATrackSimHit(missedplane, std::make_shared<FPGATrackSimHit>(newhit));
      }
    }
 
    return nmissing;
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 167 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 182 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  // If user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

prepareInvFitConstants()

void FPGATrackSimFitConstantBank::prepareInvFitConstants ( )

private

Definition at line 216 of file FPGATrackSimFitConstantBank.cxx.

{
    m_invfit_consts.resize(m_nsectors);
 
    for (int isec=0;isec!=m_nsectors;++isec)
    {
      Eigen::MatrixXf thisMatrix(m_ncoords, m_ncoords);
 
        // Parameters, by row
        for (int ip=0;ip!=m_npars;++ip)
            for (int ix=0;ix!=m_ncoords;++ix)
                thisMatrix(ip,ix)= (m_fit_pars(isec, ip, ix));
 
        // Constraints, by row
        for (int ic=0;ic!=m_nconstr;++ic)
            for (int ix=0;ix!=m_ncoords;++ix)
                thisMatrix(ic+m_npars,ix) = m_kernel(isec, ic, ix);
 
    // reset usable coordinate
    for (int ix = 0; ix != m_ncoords; ++ix)
      m_WCs(isec,ix) = 1; // start with all WCs
 
    // now let's check if we have any "null" row or column, and if so, we will get rid of them temporarily
    // we don't have access to module/WC information at this stage should just look for non-zero values
    for (int ix=0;ix!=m_ncoords;++ix) {
      bool foundrow = false;
      bool foundcolumn = false;
      for (int iy=0;iy!=m_ncoords;++iy) {
        if (abs(thisMatrix(ix,iy)) > MTX_TOLERANCE) foundrow = true;
        if (abs(thisMatrix(iy,ix)) > MTX_TOLERANCE) foundcolumn = true;
      }
      if (foundrow && foundcolumn) m_WCs(isec,ix) = 0;
    }
 
    // now count the number of usable entries
    size_t nDimToUse = 0; for (int ix=0;ix!=m_ncoords;++ix) if(!m_WCs(isec,ix)) ++nDimToUse;
 
    Eigen::MatrixXf tempMatrix(nDimToUse, nDimToUse); // this is the matrix we will invert
 
    size_t counteri = 0, counterj = 0;
    for (int i = 0; i < m_ncoords; i++) {
      counterj = 0;
      if (!m_WCs(isec,i)) {
        for (int j = 0; j < m_ncoords; j++)  {
          if (!m_WCs(isec,j)) {
        tempMatrix(counteri,counterj) = thisMatrix(i,j); // if we use this coordinate, copy it over
        counterj++; // iterate counter
          }
        }
        counteri++;
      }
    }
        /* commenting this out for now because it screws up the new 'non-safeguarded' maps
        // Invert the matrix
    Eigen::MatrixXf inverted = tempMatrix.inverse();
 
    // this is the full matrix that includes inverted coordinates plus the padded zeros
    Eigen::MatrixXf fullInverted(m_ncoords, m_ncoords);
 
    // now we put things back into the full matrix, adding back the padded zeros
    counteri = 0; counterj = 0;
    for (int i = 0; i < m_ncoords; i++) {
      counterj = 0;
      if (!m_WCs(isec,i)) {
        for (int j = 0; j < m_ncoords; j++)  {
          if (!m_WCs(isec,j)) {
        fullInverted(i,j) = inverted(counteri,counterj); // if we use this coordinate, copy it over
        counterj++; // iterate counter
          }
          else {
        fullInverted(i,j) = 0;
          }
        }
        counteri++;
      }
      else {
        for (int j = 0; j < m_ncoords; j++)  {
          fullInverted(i,j) = 0;
        }
      }
    }
        m_invfit_consts[isec]= fullInverted;
        */
    }
}

readHeader()

void FPGATrackSimFitConstantBank::readHeader ( std::ifstream & geocfile )

private

Definition at line 63 of file FPGATrackSimFitConstantBank.cxx.

{
  std::string key;
  int ival;
  int nplanes;
  
  for (int i = 0; i < 5; ++i) getline(geocfile, key); // skip 5 lines
  
  geocfile >> key;
  if (key != "NPLANES") ATH_MSG_ERROR("Invalid file format");
  geocfile >> nplanes;
  
  geocfile >> key;
  if (key!="NSECTORS") ATH_MSG_ERROR("Invalid file format");
  geocfile >> m_nsectors;
  
  geocfile >> key;
  if (key!="NDIM") ATH_MSG_ERROR("Invalid file format");
  geocfile >> ival;
  
  // Set derived configuration variables
  if (ival==1) m_npars = 3;
  else if (ival==2) m_npars = 5;
  else ATH_MSG_ERROR("Number of dimensions invalid");
  
  m_npixcy = 2*(m_ncoords - nplanes); // difference between number of coordinates and planes is number of 2d measurements
  m_nconstr = m_ncoords - m_npars;
  
  // Allocate the block of pointer per sector
  //m_nsectors should be checked to be sane
  //coverity[TAINTED_SCALAR]
  m_sector_good.resize(m_nsectors);
  m_fit_pars.resize(m_nsectors, 5, m_ncoords);
  m_fit_const.resize(m_nsectors, 5);
  m_kernel.resize(m_nsectors, m_nconstr, m_ncoords);
  m_kaverage.resize(m_nsectors, m_nconstr);
  
  m_WCs.resize(m_nsectors, m_ncoords);
  
  m_maj_a.resize(m_nsectors, m_ncoords, 0);
  m_maj_kk.resize(m_nsectors, m_ncoords, m_ncoords, 0);
  m_maj_invkk.resize(m_nsectors, m_ncoords, m_ncoords, 0);
}

readSectorInfo()

void FPGATrackSimFitConstantBank::readSectorInfo ( std::ifstream & geocfile )

private

Definition at line 109 of file FPGATrackSimFitConstantBank.cxx.

{
    std::string key;
    int ival;
    double dval; // temp value used to conver from double to float
 
    for (int isec = 0; isec < m_nsectors; ++isec)
    {
        // Read sector number
        geocfile >> key >> ival;
        if (ival != isec) ATH_MSG_WARNING("Reached sector " << ival << " but expected sector " << isec);
 
        // Read fit parameters
    for (int ipar = 0; ipar < m_npars; ++ipar)
        {
            geocfile >> key;
            // no check on key?
            for (int icoord = 0; icoord < m_ncoords; ++icoord)
            {
                geocfile >> dval;
                if (geocfile.fail())
          ATH_MSG_WARNING("par loop (1) key=\"" << key << "\" ipar,icoord=" << ipar << "," << icoord);
 
                if (dval != 0) m_sector_good[isec] = true;
                m_fit_pars(isec, ipar, icoord) = dval;
            }
        }
 
        // Read k averages
        geocfile >> key;
        assert(key=="kaverages");
        for (int ik=0;ik<m_nconstr;++ik)
        {
            geocfile >> dval;
            if (dval != 0) m_sector_good[isec] = true;
            m_kaverage(isec,ik) = dval;
        }
 
        // Read kernel
        geocfile >> key;
        assert(key=="kernel");
        for (int ik=0;ik<m_nconstr;++ik)
        {
            for (int ik2=0;ik2<m_ncoords;++ik2)
            {
                geocfile >> dval;
                if (dval != 0) m_sector_good[isec] = true;
                m_kernel(isec, ik, ik2) = dval;
            }
        }
 
        // Read fit const
    for (int ipar=0;ipar<m_npars;++ipar)
        {
            geocfile >> key;
            geocfile >> dval;
            if (dval != 0) m_sector_good[isec] = true;
            m_fit_const(isec, ipar) = dval;
        }
 
    }
}

setIdealCoordFit()

void FPGATrackSimFitConstantBank::setIdealCoordFit ( bool v )

inline

Definition at line 56 of file FPGATrackSimFitConstantBank.h.

{ m_isIdealCoordFit = v;}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setPhiShift()

void FPGATrackSimFitConstantBank::setPhiShift ( float v )

inline

Definition at line 57 of file FPGATrackSimFitConstantBank.h.

{m_phiShift = v;}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

m_bankID

int FPGATrackSimFitConstantBank::m_bankID

private

Definition at line 66 of file FPGATrackSimFitConstantBank.h.

m_fit_const

vector2D<float> FPGATrackSimFitConstantBank::m_fit_const

private

Definition at line 86 of file FPGATrackSimFitConstantBank.h.

m_fit_pars

vector3D<float> FPGATrackSimFitConstantBank::m_fit_pars

private

Definition at line 85 of file FPGATrackSimFitConstantBank.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_invfit_consts

std::vector<Eigen::MatrixXf, Eigen::aligned_allocator<Eigen::MatrixXf> > FPGATrackSimFitConstantBank::m_invfit_consts

private

Definition at line 94 of file FPGATrackSimFitConstantBank.h.

m_isIdealCoordFit

bool FPGATrackSimFitConstantBank::m_isIdealCoordFit

private

Definition at line 75 of file FPGATrackSimFitConstantBank.h.

m_kaverage

vector2D<float> FPGATrackSimFitConstantBank::m_kaverage

private

Definition at line 88 of file FPGATrackSimFitConstantBank.h.

m_kernel

vector3D<float> FPGATrackSimFitConstantBank::m_kernel

private

Definition at line 87 of file FPGATrackSimFitConstantBank.h.

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_maj_a

vector2D<float> FPGATrackSimFitConstantBank::m_maj_a

private

Definition at line 90 of file FPGATrackSimFitConstantBank.h.

m_maj_invkk

vector3D<float> FPGATrackSimFitConstantBank::m_maj_invkk

private

Definition at line 92 of file FPGATrackSimFitConstantBank.h.

m_maj_kk

vector3D<float> FPGATrackSimFitConstantBank::m_maj_kk

private

Definition at line 91 of file FPGATrackSimFitConstantBank.h.

m_missid

std::vector<int> FPGATrackSimFitConstantBank::m_missid

private

Definition at line 80 of file FPGATrackSimFitConstantBank.h.

m_missingPlane

int FPGATrackSimFitConstantBank::m_missingPlane

private

Definition at line 73 of file FPGATrackSimFitConstantBank.h.

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

m_nconstr

int FPGATrackSimFitConstantBank::m_nconstr

private

Definition at line 70 of file FPGATrackSimFitConstantBank.h.

m_ncoords

int FPGATrackSimFitConstantBank::m_ncoords

private

Definition at line 69 of file FPGATrackSimFitConstantBank.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_npars

int FPGATrackSimFitConstantBank::m_npars = 0

private

Definition at line 68 of file FPGATrackSimFitConstantBank.h.

m_npixcy

int FPGATrackSimFitConstantBank::m_npixcy

private

Definition at line 71 of file FPGATrackSimFitConstantBank.h.

m_nsectors

int FPGATrackSimFitConstantBank::m_nsectors

private

Definition at line 67 of file FPGATrackSimFitConstantBank.h.

m_phiShift

float FPGATrackSimFitConstantBank::m_phiShift

private

Definition at line 72 of file FPGATrackSimFitConstantBank.h.

m_pmap

FPGATrackSimPlaneMap const* FPGATrackSimFitConstantBank::m_pmap = nullptr

private

Definition at line 61 of file FPGATrackSimFitConstantBank.h.

m_sector_good

std::vector<bool> FPGATrackSimFitConstantBank::m_sector_good

private

Definition at line 84 of file FPGATrackSimFitConstantBank.h.

m_WCs

vector2D<int> FPGATrackSimFitConstantBank::m_WCs

private

Definition at line 96 of file FPGATrackSimFitConstantBank.h.

---

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

• FPGATrackSimFitConstantBank.h
• FPGATrackSimFitConstantBank.cxx