#include <CscSegmentMaker.h>

Inheritance diagram for TrigL2MuonSA::CscSegmentMaker:

Collaboration diagram for TrigL2MuonSA::CscSegmentMaker:

Classes
struct	local2dSegment
struct	localCscHit

Public Member Functions
	CscSegmentMaker (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
ReturnCode	FindSuperPointCsc (const TrigL2MuonSA::CscHits &cscHits, std::vector< TrigL2MuonSA::TrackPattern > &v_trackPatterns, const TrigL2MuonSA::TgcFitResult &tgcFitResult, const TrigL2MuonSA::MuonRoad &muroad) const
ReturnCode	make_segment (int mod_hash, TrigL2MuonSA::CscHits clusters[8], CscSegment &cscsegment, CscSegment &cscsegment_noip, const MuonGM::MuonDetectorManager *muDetMgr) const
ReturnCode	make_2dsegment (int measphi, const localCscHit &ip_loc, const std::vector< localCscHit > hits_loc[4], local2dSegment &seg2d_eta, local2dSegment &local2d_noip, int &nhite) const
ReturnCode	make_2dseg4hit (int measphi, const localCscHit &ip_loc, std::vector< localCscHit > hits_loc[4], std::vector< local2dSegment > &seg2d_4hitCollection, int &nhite) const
ReturnCode	make_2dseg3hit (int measphi, const localCscHit &ip_loc, const std::vector< localCscHit > hits_loc[4], std::vector< local2dSegment > &seg2d_4hitCollection, int &nhit) const
ReturnCode	fit_clusters (int measphi, const std::vector< localCscHit > &hits_fit, local2dSegment &seg2d) const
ReturnCode	make_4dsegment (const local2dSegment &seg2d_eta, const local2dSegment &seg2d_phi, Amg::Vector3D &seg_pos, Amg::Vector3D &seg_dir) const
ReturnCode	getModuleSP (int mod_hash[2], const TrigL2MuonSA::TgcFitResult &tgcFitResult, int phibin, const TrigL2MuonSA::MuonRoad &muroad, const int exist_clusters[32]) const
ReturnCode	display_hits (const std::vector< localCscHit > localHits[4]) const
CscSegment	segmentAtFirstLayer (int mod_hash, TrigL2MuonSA::CscSegment *mu_seg) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
UtilTools	m_util
ToolHandle< CscRegDict >	m_cscregdict
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_muDetMgrKey {this, "DetectorManagerKey", "MuonDetectorManager", "Key of input MuonDetectorManager condition data"}
Gaudi::Property< bool >	m_use_geometry
Gaudi::Property< double >	m_max_chisquare
Gaudi::Property< double >	m_max_residual_eta
Gaudi::Property< double >	m_max_residual_phi
Gaudi::Property< double >	m_err_eta
Gaudi::Property< double >	m_err_phi
Gaudi::Property< double >	m_err_ip
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 30 of file CscSegmentMaker.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ CscSegmentMaker()

TrigL2MuonSA::CscSegmentMaker::CscSegmentMaker	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 20 of file CscSegmentMaker.cxx.

  : AthAlgTool(type, name, parent),
    m_util()
{
}

Member Function Documentation

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	hndl,
		const SG::VarHandleKeyType &	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ display_hits()

ReturnCode TrigL2MuonSA::CscSegmentMaker::display_hits ( const std::vector< localCscHit > localHits[4] ) const

Definition at line 654 of file CscSegmentMaker.cxx.

{  
  for(unsigned int ilyr=0; ilyr<4; ++ilyr){
    for (unsigned int ihit=0; ihit<localHits[ilyr].size(); ++ihit) {
      const localCscHit &locHit = localHits[ilyr][ihit];
      ATH_MSG_DEBUG("measphi=" << locHit.measphi << " wirelyr=" << ilyr+1
                    << " x=" << locHit.loc_x << " y=" << locHit.loc_y << " z=" << locHit.loc_z
                    << " err=" << locHit.error << " res=" << locHit.residual);
    }
  }
   
  return ReturnCode::SUCCESS;
}

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ FindSuperPointCsc()

ReturnCode TrigL2MuonSA::CscSegmentMaker::FindSuperPointCsc	(	const TrigL2MuonSA::CscHits &	cscHits,
		std::vector< TrigL2MuonSA::TrackPattern > &	v_trackPatterns,
		const TrigL2MuonSA::TgcFitResult &	tgcFitResult,
		const TrigL2MuonSA::MuonRoad &	muroad ) const

Definition at line 35 of file CscSegmentMaker.cxx.

{
  ATH_MSG_DEBUG( "FindSuperPointCsc" );
  SG::ReadCondHandle<MuonGM::MuonDetectorManager> muDetMgrHandle{m_muDetMgrKey};
  const MuonGM::MuonDetectorManager* muDetMgr = muDetMgrHandle.cptr();
  
  if( !cscHits.empty() ){
    
    for (TrigL2MuonSA::TrackPattern& track : v_trackPatterns) { // loop for track candidates
      
      //get module hash  to read
      int hash_clusters[32]={0};      
      
      TrigL2MuonSA::CscHits clusters[32][8];
      for(unsigned int iclu=0; iclu<cscHits.size(); ++iclu){
        const TrigL2MuonSA::CscHitData &cscHit = cscHits[iclu];
        
    //outlier or not
        double width = (cscHit.MeasuresPhi == 0 ) ? m_max_residual_eta : m_max_residual_phi;
        if ( width < std::abs(cscHit.Residual) )  continue;
        
        
        int cathodelayer = 2*(cscHit.WireLayer-1)+  cscHit.MeasuresPhi;//cathodelayer is in [0,7]
        int module_hash = m_cscregdict->get_hash(cscHit.StationName, cscHit.StationEta,  cscHit.StationPhi);
        
    if(0<=module_hash && 32>module_hash){
      clusters[module_hash][cathodelayer].push_back( cscHit );        
      hash_clusters[module_hash]=1;//set modules to read
        }else{
      continue;
    }
      }//for clusters
      
      
      //decide which module to read
      int hashSPs[2]={999,999};
      if( getModuleSP( hashSPs, tgcFitResult, track.phiBin, muroad, hash_clusters)!=ReturnCode::FAILURE ){
        
    bool found_segment=false;
    for(int ihash=0; ihash<2; ++ihash){
      if(found_segment) break;//once a segment is found, then finish searching more
      
      int hashSP=hashSPs[ihash];
      if(hashSP>32) continue;
          
      //making segment
      CscSegment cscsegment, cscsegment_noip;
      if (this->make_segment(hashSP, clusters[hashSP] , cscsegment, cscsegment_noip, muDetMgr) != ReturnCode::FAILURE  ){
        found_segment=true;
        track.hashID_CSC = hashSP;
 
        xAOD::L2MuonParameters::Chamber csc = xAOD::L2MuonParameters::Chamber::CSC;
        xAOD::L2MuonParameters::Chamber outer = xAOD::L2MuonParameters::Chamber::EndcapOuter;
        TrigL2MuonSA::SuperPoint* superPoint = &(track.superPoints[csc]);
        const TrigL2MuonSA::SuperPoint* outerSP = &(track.superPoints[outer]);
        bool &large_dphidz = track.large_dPhidZ;
        double &outerCorFactor =  track.outerCorFactor;
        
            //tgcfitresult
        double tgcmid1z = tgcFitResult.tgcMid1[3];
        double tgcmid2z = tgcFitResult.tgcMid2[3];
        double phimiddle = tgcFitResult.phi;
        double dPhidz = tgcFitResult.dPhidZ;
        if( 0.75e-6<std::abs(dPhidz) ) large_dphidz=true;
        double tgcmidZ = (tgcmid1z+tgcmid2z)/2.;
        double outerz = outerSP->Z;
        
            //calculate SP
        CscSegment cscsegment_ext = segmentAtFirstLayer(hashSP, &cscsegment);
        double phiMod = m_cscregdict->phiMod(hashSP);
        double CSCR=cscsegment_ext.x()*std::cos(phiMod)+cscsegment_ext.y()*std::sin(phiMod);
        double CSCZ=cscsegment_ext.z();
        double PhiAtCsc = phimiddle/* - std::abs(CSCZ-tgcmidZ)*dPhidz*/;
        double CSCSPR = CSCR/std::cos( m_util.calc_dphi(PhiAtCsc,phiMod) );
        
        
        superPoint->Z = CSCZ;
        superPoint->R = CSCSPR;
        superPoint->Alin = cscsegment_ext.slopeRZ();
        superPoint->Blin = cscsegment_ext.interceptRZ();
        superPoint->Npoint = cscsegment_ext.nHitEta();
        superPoint->Chi2 = cscsegment_ext.chiSquare();
        ATH_MSG_DEBUG("CSC super point:hashID=" << hashSP
              << ",CSCR=" << CSCSPR << ",CSCZ=" << CSCZ 
              << ",Slope=" << cscsegment_ext.slopeRZ() << ",Intercept=" << cscsegment_ext.interceptRZ()
              << ",nHitsEta=" << cscsegment_ext.nHitEta() << ",Chi2="<< cscsegment_ext.chiSquare());
        
        //calculate outerSP's correction (dphidz of tgcFitResult)
        double phiouter = phimiddle+std::abs(outerz-tgcmidZ)*dPhidz;
        outerCorFactor = std::cos( m_util.calc_dphi(phiouter,phiMod) )/std::cos( m_util.calc_dphi(phimiddle,phiMod) );
        ATH_MSG_DEBUG("outerCorFactor=" << outerCorFactor);
        
      }//if there is a segment.
    }//ihash loop over modules in which segment will be made
      }//if there is the module in which segment will be made.
    }//loop over track pattern candidate
  }//if there are clusters, then make a segment
  
  
  return  ReturnCode::SUCCESS;
}

◆ fit_clusters()

ReturnCode TrigL2MuonSA::CscSegmentMaker::fit_clusters	(	int	measphi,
		const std::vector< localCscHit > &	hits_fit,
		local2dSegment &	seg2d ) const

Definition at line 456 of file CscSegmentMaker.cxx.

                                                                                                                        {
  
  
  double S=0.;
  double Sx=0.;
  double Sy=0.;
  double aStt=0.;
  int nhit=0;
  int nhit_with_ip=0;
  double Stt=0.;
  double Syy=0.;
  double Sxx=0.;
  double Sxy=0.;
  double a = 0.;
  double b = 0.;
  double rp=0.;
  double rq=0.;
  double aver_res=0.;
  
  
  for (unsigned int ihit=0; ihit< hits_fit.size(); ++ihit) {
    
 
    double x= hits_fit[ihit].loc_z;
    double y= (measphi==0) ? hits_fit[ihit].loc_y : hits_fit[ihit].loc_x;
    double err= hits_fit[ihit].error;
    double w = 1./(err*err);
    //    ATH_MSG_DEBUG("local pos, z=" << hits_fit[ihit].loc_z << ", x,y=" << y << ", err=" << err << ", w=" << w << ", res=" << hits_fit[ihit].residual << ", measphi="<< hits_fit[ihit].measphi);
    S += w;
    Sx += w*x;
    Sy += w*y;
    if( !hits_fit[ihit].isIP ){
        seg2d.stationname=hits_fit[ihit].stationname;
    aver_res += w*hits_fit[ihit].residual;
    rq += w;
    rp += w*x;
    ++nhit;
    }
    ++nhit_with_ip;
  }//ihit
  seg2d.zshift=rp/rq;
  
  seg2d.residual=aver_res/rq;
  
  
  for (unsigned int ihit=0; ihit< hits_fit.size(); ++ihit) {
    
    double x= hits_fit[ihit].loc_z;
    double y= (measphi==0) ? hits_fit[ihit].loc_y : hits_fit[ihit].loc_x;
    double err = hits_fit[ihit].error;
    double w = 1./(err*err);// (ihit==0)?0.25:100.;//
    Stt += w*(x-Sx/S)*(x-Sx/S);
    aStt += w*y*(x-Sx/S);
    Sxx += w*x*x;
    Syy += w*y*y;
    Sxy += w*x*y;
    
  }//ihit
    
    
  
  if(nhit_with_ip>1){
    a = seg2d.a = aStt/Stt;
    b = seg2d.b = (Sy-Sx*a)/S;
    seg2d.nhit = nhit;
    
  }else{
    return ReturnCode::FAILURE;
  }
  seg2d.chi2  = Syy + a*a*Sxx + 2*b*a*Sx + b*b*S - 2*b*Sy - 2*a*Sxy;
  
  ATH_MSG_DEBUG( "fit: a=" << a << " b=" << b << " chi2=" << seg2d.chi2 );
  
  return ReturnCode::SUCCESS;
}

◆ getModuleSP()

ReturnCode TrigL2MuonSA::CscSegmentMaker::getModuleSP	(	int	mod_hash[2],
		const TrigL2MuonSA::TgcFitResult &	tgcFitResult,
		int	phibin,
		const TrigL2MuonSA::MuonRoad &	muroad,
		const int	exist_clusters[32] ) const

Definition at line 581 of file CscSegmentMaker.cxx.

{
  ATH_MSG_DEBUG("getModuleSP()");
  
  
  for(unsigned int imod=0; imod<32;++imod){
    
    if( 0==hash_clusters[imod] ) continue;
    int stationeta = m_cscregdict->stationEta(imod);
    int side = (muroad.side) ? 1 : -1;
    double phiMod = m_cscregdict->phiMod(imod);
    double dphi = m_util.calc_dphi(phiMod, tgcFitResult.phi);
    ATH_MSG_DEBUG("getModuleSP()::(phi,side) modlue:(" << phiMod << "," << stationeta << ") tgcroad:(" << tgcFitResult.phi << "," << side << ")");
    if( std::abs(dphi)>M_PI/8. || side != stationeta) continue;
 
    
    if(7!=phibin){
 
      if(imod<16 && phibin>7){//small normal
        mod_hashes[0]=imod;
      } else if( imod >=16  && phibin<7){//large normal
        mod_hashes[0]=imod;
      } else {//overlap
        mod_hashes[1]=imod;
      }
 
    } else if (7==phibin) {
 
      if(imod<16 && 1==muroad.LargeSmall ){//small normal
        mod_hashes[0]=imod;
      } else if( imod >=16  && 0== muroad.LargeSmall){//large normal
        mod_hashes[0]=imod;
      } else {//overlap
        mod_hashes[1]=imod;
      }
 
    }
  }//for imod
  ATH_MSG_DEBUG("getModuleSP::Normal sector=" << mod_hashes[0] << " overlap sector=" << mod_hashes[1]);
  
  return ReturnCode::SUCCESS;
  
  
}

◆ initialize()

StatusCode TrigL2MuonSA::CscSegmentMaker::initialize ( )

overridevirtual

Definition at line 27 of file CscSegmentMaker.cxx.

                                      {
  ATH_CHECK(m_cscregdict.retrieve());
  ATH_CHECK(m_muDetMgrKey.initialize());
  ATH_CHECK(m_idHelperSvc.retrieve());
  return StatusCode::SUCCESS;
}

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ make_2dseg3hit()

ReturnCode TrigL2MuonSA::CscSegmentMaker::make_2dseg3hit	(	int	measphi,
		const localCscHit &	ip_loc,
		const std::vector< localCscHit >	hits_loc[4],
		std::vector< local2dSegment > &	seg2d_4hitCollection,
		int &	nhit ) const

Definition at line 394 of file CscSegmentMaker.cxx.

{
  
  int empty_lyr=-1;
  int nohit=0;
  for (int ilyr=0; ilyr<4; ++ilyr ){
    if( 0==hits_loc[ilyr].size() ){
      ++nohit;
      empty_lyr=ilyr;
    }
  }
  
  if ( 1<nohit ) return ReturnCode::SUCCESS;
  
  std::vector<localCscHit> hit_fit;
  
  
  int hit_lyrA[4] = {1, 2, 3, 0};
  int hit_lyrB[4] = {2, 3, 0, 1};
  int hit_lyrC[4] = {3, 0, 1, 2};
  
  for(int lyrcomb=0; lyrcomb<4; ++lyrcomb){
    
    if(0<=empty_lyr && empty_lyr!=lyrcomb) continue;
    
    for (unsigned int ihitA=0; ihitA<hits_loc[hit_lyrA[lyrcomb]].size(); ++ihitA) {
      for (unsigned int ihitB=0; ihitB<hits_loc[hit_lyrB[lyrcomb]].size(); ++ihitB) {
        for (unsigned int ihitC=0; ihitC<hits_loc[hit_lyrC[lyrcomb]].size(); ++ihitC) {
          
          hit_fit.clear();
          hit_fit.push_back(ip_loc);
          hit_fit.push_back(hits_loc[hit_lyrA[lyrcomb]][ihitA]);
          hit_fit.push_back(hits_loc[hit_lyrB[lyrcomb]][ihitB]);
          hit_fit.push_back(hits_loc[hit_lyrC[lyrcomb]][ihitC]);
          
            //fit clusters
          local2dSegment seg2d_tmp;
          
          if( this->fit_clusters(measphi,hit_fit,seg2d_tmp)!=ReturnCode::SUCCESS ) continue;//for eta
          
          if(seg2d_tmp.chi2<2.0*m_max_chisquare/3.0){
            seg2d_tmp.localHits.push_back(hits_loc[hit_lyrA[lyrcomb]][ihitA]);
            seg2d_tmp.localHits.push_back(hits_loc[hit_lyrB[lyrcomb]][ihitB]);
            seg2d_tmp.localHits.push_back(hits_loc[hit_lyrC[lyrcomb]][ihitC]);
            seg2d_3hitCollection.push_back(seg2d_tmp);
            ATH_MSG_DEBUG("3hitsegment was made");
          }
        }
      }
    }
  }//loop over layer combination
  nhit=3;
  
  
  return ReturnCode::SUCCESS;
}

◆ make_2dseg4hit()

ReturnCode TrigL2MuonSA::CscSegmentMaker::make_2dseg4hit	(	int	measphi,
		const localCscHit &	ip_loc,
		std::vector< localCscHit >	hits_loc[4],
		std::vector< local2dSegment > &	seg2d_4hitCollection,
		int &	nhite ) const

Definition at line 327 of file CscSegmentMaker.cxx.

{
  
  std::vector<localCscHit> hit_fit;
  
  for (unsigned int ihit0=0; ihit0<hits_loc[0].size(); ++ihit0) {
    for (unsigned int ihit1=0; ihit1<hits_loc[1].size(); ++ihit1) {
      for (unsigned int ihit2=0; ihit2<hits_loc[2].size(); ++ihit2) {
        for (unsigned int ihit3=0; ihit3<hits_loc[3].size(); ++ihit3) {
          
            // set clusters
          hit_fit.clear();
          hit_fit.push_back(ip_loc);
          hit_fit.push_back(hits_loc[0][ihit0]);
          hit_fit.push_back(hits_loc[1][ihit1]);
          hit_fit.push_back(hits_loc[2][ihit2]);
          hit_fit.push_back(hits_loc[3][ihit3]);
          
            //segment fit
          local2dSegment seg2d_tmp;
          if( this->fit_clusters(measphi,hit_fit,seg2d_tmp)!=ReturnCode::SUCCESS ) continue;
          
          
          if(seg2d_tmp.chi2<m_max_chisquare){
            seg2d_tmp.localHits.push_back(hits_loc[0][ihit0]);
            seg2d_tmp.localHits.push_back(hits_loc[1][ihit1]);
            seg2d_tmp.localHits.push_back(hits_loc[2][ihit2]);
            seg2d_tmp.localHits.push_back(hits_loc[3][ihit3]);
              //disable hits
            hits_loc[0][ihit0].enabled=false;
            hits_loc[1][ihit1].enabled=false;
            hits_loc[2][ihit2].enabled=false;
            hits_loc[3][ihit3].enabled=false;
            
            seg2d_4hitCollection.push_back(seg2d_tmp);
            ATH_MSG_DEBUG("4hitsegment was made");
          }
          
        }
      }
    }
  }//loop over all combination of 4hits
  
  
    //make vector of hits left unused
  std::vector<localCscHit> hit_loc_left[4];
  for (unsigned int ilyr=0;ilyr<4; ++ilyr){
    for(unsigned int ihit=0; ihit < hits_loc[ilyr].size(); ++ihit){
      
      if ( true==hits_loc[ilyr][ihit].enabled ){
        hit_loc_left[ilyr].push_back(hits_loc[ilyr][ihit]);
      }
    }//loop over hits in layer
  }//loop over wire layer
  
  for(int ilyr=0; ilyr<4; ++ilyr) hits_loc[ilyr]=hit_loc_left[ilyr];//copying "objects" of vector
  
  nhit=4;
  
  return ReturnCode::SUCCESS;
  
}

◆ make_2dsegment()

ReturnCode TrigL2MuonSA::CscSegmentMaker::make_2dsegment	(	int	measphi,
		const localCscHit &	ip_loc,
		const std::vector< localCscHit >	hits_loc[4],
		local2dSegment &	seg2d_eta,
		local2dSegment &	local2d_noip,
		int &	nhite ) const

Definition at line 262 of file CscSegmentMaker.cxx.

{
  
  int nohit=0;
  std::vector<int> hit_lyr;
  hit_lyr.clear();
  
    //counting layers without clusters
  for (int i=0; i<4; ++i ){
    if( 0==hits_loc[i].size() ) ++nohit;
  }
  
  std::vector<local2dSegment> seg2d_4hitCollection,seg2d_3hitCollection;
  seg2d_4hitCollection.clear(); seg2d_3hitCollection.clear();
  std::vector<localCscHit> hits_loc_copy[4];
  for (int i=0;i<4;++i) hits_loc_copy[i] = hits_loc[i];
  
  
  if(0==nohit){
    
    if( this->make_2dseg4hit(measphi, ip_loc, hits_loc_copy, seg2d_4hitCollection, nhit)!=ReturnCode::SUCCESS ) return ReturnCode::FAILURE;
    //hits already used are removed in hits_loc_copy
    ATH_MSG_DEBUG("display hits left");
    display_hits(hits_loc_copy);
    if( this->make_2dseg3hit(measphi, ip_loc, hits_loc_copy, seg2d_3hitCollection, nhit)!=ReturnCode::SUCCESS ) return ReturnCode::FAILURE;
    
  } else if(1==nohit) {
    
    if( this->make_2dseg3hit(measphi, ip_loc, hits_loc_copy, seg2d_3hitCollection, nhit)!=ReturnCode::SUCCESS ) return ReturnCode::FAILURE;
    
  } else {
    return ReturnCode::FAILURE;
  }
  
    //select the segment nearest to tgcroad.
  bool exist=false;
  seg2d.residual=99999.;
  for(unsigned int iseg4=0; iseg4< seg2d_4hitCollection.size(); ++iseg4){
    
    if( std::abs( seg2d_4hitCollection[iseg4].residual ) < std::abs(seg2d.residual) ){
      seg2d=seg2d_4hitCollection[iseg4];
      exist=true;
      ATH_MSG_DEBUG("seg2d.residual=" << seg2d.residual);
    }
  }
  for(unsigned int iseg3=0; iseg3< seg2d_3hitCollection.size(); ++iseg3){
    
    if( std::abs( seg2d_3hitCollection[iseg3].residual ) < std::abs(seg2d.residual) ){
      seg2d=seg2d_3hitCollection[iseg3];
      exist=true;
      ATH_MSG_DEBUG("seg2d.residual=" << seg2d.residual);
    }
  }
  
  if(false==exist) return ReturnCode::FAILURE;
  
  if( this->fit_clusters(measphi,seg2d.localHits,seg2d_ipremoved)!=ReturnCode::SUCCESS ) return ReturnCode::FAILURE;
  
  return ReturnCode::SUCCESS;
  
}

◆ make_4dsegment()

ReturnCode TrigL2MuonSA::CscSegmentMaker::make_4dsegment	(	const local2dSegment &	seg2d_eta,
		const local2dSegment &	seg2d_phi,
		Amg::Vector3D &	seg_pos,
		Amg::Vector3D &	seg_dir ) const

Definition at line 534 of file CscSegmentMaker.cxx.

{
  
  int nhit_e=seg2d_eta.nhit;
  int nhit_p=seg2d_phi.nhit;
  double a_eta=seg2d_eta.a;
  double b_eta=seg2d_eta.b;
  double a_phi=seg2d_phi.a;
  double b_phi=seg2d_phi.b;
  double rzshift=seg2d_eta.zshift;
  double phizshift=seg2d_phi.zshift;
  
  if (nhit_e<2   || nhit_p<2 ) return ReturnCode::FAILURE;
  
  ATH_MSG_DEBUG("rzshift=" << rzshift << " phizshift=" << phizshift << " diff=" << (rzshift-phizshift)
                << " angle=" << ( 0.5*M_PI - std::atan(a_phi) ) << " b_phi=" << b_phi /*<< " Newb_phi=" << Newb_phi*/ );
  
  double norm = std::sqrt( a_phi*a_phi + a_eta*a_eta + 1 );
  
  seg_dir = Amg::Vector3D(a_phi/norm, a_eta/norm, 1./norm);
  ATH_MSG_DEBUG("segdir_loc (px,py,pz)=" << "(" << seg_dir(Amg::px) << "," << seg_dir(Amg::py) << "," << seg_dir(Amg::pz) << ") a_eta="
                << a_eta << " a_phi=" << a_phi << " chi2_eta=" << seg2d_eta.chi2 << " chi2_phi=" << seg2d_phi.chi2 );
  
  double aver_z=0.5*(rzshift+phizshift);
  
  ATH_MSG_DEBUG(" new aver_z=" << aver_z );
  seg_pos = Amg::Vector3D(seg_dir(Amg::px)*aver_z/seg_dir(Amg::pz) + b_phi,  seg_dir(Amg::py)*aver_z/seg_dir(Amg::z) + b_eta,  aver_z);
  
  ATH_MSG_DEBUG( "myseg_loc  (x,y,z,px,py,pz)=(" << seg_pos(Amg::x) << "," << seg_pos(Amg::y) << "," << seg_pos(Amg::z)
         << "," << seg_dir(Amg::px) << "," << seg_dir(Amg::py) << "," << seg_dir(Amg::pz) << ")");
  
  return ReturnCode::SUCCESS;
  
}

◆ make_segment()

ReturnCode TrigL2MuonSA::CscSegmentMaker::make_segment	(	int	mod_hash,
		TrigL2MuonSA::CscHits	clusters[8],
		CscSegment &	cscsegment,
		CscSegment &	cscsegment_noip,
		const MuonGM::MuonDetectorManager *	muDetMgr ) const

Definition at line 144 of file CscSegmentMaker.cxx.

{
  ATH_MSG_DEBUG("################################## make_segment #####################################");
  
  std::vector<localCscHit> hits_loc_eta[4], hits_loc_phi[4],emp;
  emp.clear();
  for(int i =0;i<4;++i){
    hits_loc_eta[i]=emp;
    hits_loc_phi[i]=emp;
  }
  
 
 
  Amg::Transform3D gToLocal;
  if(m_use_geometry){
    Identifier Id = m_idHelperSvc->cscIdHelper().channelID(m_cscregdict->stationName(mod_hash), m_cscregdict->stationEta(mod_hash),m_cscregdict->stationPhi(mod_hash),2/*chamberLayer*/, 1, 0, 1);
    const MuonGM::CscReadoutElement *csc = muDetMgr->getCscReadoutElement(Id);
    if (csc == NULL){
      ATH_MSG_DEBUG( "Csc Readout Element not found ---- skip");
      return ReturnCode::FAILURE;
    }
    ATH_MSG_DEBUG("CscReadoutElement");
    gToLocal = csc->GlobalToAmdbLRSTransform();
  }else{
  double rotpi = (m_cscregdict->stationEta(mod_hash)>0) ? -M_PI/2. : M_PI/2.;
  Amg::AngleAxis3D rotZamg( (-1)*(m_cscregdict->phiMod(mod_hash)), Amg::Vector3D(0,0,1));
  Amg::AngleAxis3D rotYamg( (-1)*(m_cscregdict->actualAtanNormal(mod_hash)), Amg::Vector3D(0,1,0) );
  Amg::AngleAxis3D rotPIamg( rotpi, Amg::Vector3D(0,0,1));
  Amg::Translation3D translation( 0.0, 0.0, (-1)*(m_cscregdict->displacement(mod_hash)) );
  gToLocal=translation*rotPIamg*rotYamg*rotZamg;
  }
 
 
  localCscHit ip_loc;  
  Amg::Vector3D ip_vec = gToLocal*Amg::Vector3D(0.0, 0.0, 0.0);
  ip_loc.loc_x = ip_vec(Amg::x);  
  ip_loc.loc_y = ip_vec(Amg::y);  
  ip_loc.loc_z = ip_vec(Amg::z);  
  ip_loc.measphi = -1;
  ip_loc.error = m_err_ip;
  ip_loc.residual = 0.;
  ip_loc.isIP = true;
  ip_loc.enabled = false;
  ip_loc.stationname = 0;
 
  for (unsigned int clyr=0; clyr<8; ++clyr) {
    for (unsigned int ihit=0; ihit<clusters[clyr].size(); ++ihit) {
      
      TrigL2MuonSA::CscHitData &cschit = clusters[clyr][ihit];
      double r = cschit.r;
      double phi = cschit.phi;
      double z = cschit.z;
      
        //move to local coordinate system
      Amg::Vector3D vect(r*std::cos(phi),r*std::sin(phi),z);
      Amg::Vector3D loc_vect = gToLocal*vect;      
 
        //building localCscHit object
      localCscHit loc_hit;
      loc_hit.loc_x = loc_vect(Amg::x);
      loc_hit.loc_y = loc_vect(Amg::y);
      loc_hit.loc_z = loc_vect(Amg::z);
      loc_hit.measphi=cschit.MeasuresPhi;
      loc_hit.error = (loc_hit.measphi==0) ? m_err_eta : m_err_phi;
      loc_hit.residual = cschit.Residual;
      loc_hit.enabled=true;
      loc_hit.isIP=false;
      loc_hit.stationname=cschit.StationName;
      ATH_MSG_DEBUG( "measphi=" << cschit.MeasuresPhi << " wirelyr=" << cschit.WireLayer << " x=" << loc_hit.loc_x << " y=" << loc_hit.loc_y << " z=" << loc_hit.loc_z <<  " err=" << loc_hit.error << " res=" << loc_hit.residual);
      
      
      if(0==loc_hit.measphi) {
        if(m_max_residual_eta>std::abs(loc_hit.residual)) hits_loc_eta[cschit.WireLayer-1].push_back( loc_hit );
      }
      if(1==loc_hit.measphi) {
        if(m_max_residual_phi>std::abs(loc_hit.residual))  hits_loc_phi[cschit.WireLayer-1].push_back( loc_hit );
      }
    }//ihit
  }//clyr
  
  Amg::Vector3D seg_pos_loc, seg_dir_loc,seg_pos_loc_noip, seg_dir_loc_noip;
  int nhite=0,nhitp=0;
  local2dSegment seg2d_eta ,seg2d_phi, seg2d_eta_noip, seg2d_phi_noip;
  
  
  if( this->make_2dsegment( 0/*=measphi*/, ip_loc, hits_loc_eta, seg2d_eta, seg2d_eta_noip, nhite)!=ReturnCode::SUCCESS ) return ReturnCode::FAILURE;
  if( this->make_2dsegment( 1/*=measphi*/, ip_loc, hits_loc_phi, seg2d_phi,seg2d_phi_noip, nhitp)!=ReturnCode::SUCCESS ) return ReturnCode::FAILURE;
  
  
  ATH_MSG_DEBUG("==include IP==");
  if( this->make_4dsegment(seg2d_eta,seg2d_phi,seg_pos_loc,seg_dir_loc)!=ReturnCode::SUCCESS ) return ReturnCode::FAILURE;
  ATH_MSG_DEBUG("==exclude IP==");
  if( this->make_4dsegment(seg2d_eta_noip,seg2d_phi_noip,seg_pos_loc_noip,seg_dir_loc_noip)!=ReturnCode::SUCCESS ) return ReturnCode::FAILURE;
  
  
  Amg::Transform3D lToGlobal = gToLocal.inverse();
  Amg::Vector3D seg_pos = lToGlobal*seg_pos_loc;
  Amg::Vector3D seg_dir = lToGlobal.rotation()*seg_dir_loc;
  Amg::Vector3D seg_pos_noip = lToGlobal*seg_pos_loc_noip;
  Amg::Vector3D seg_dir_noip = lToGlobal.rotation()*seg_dir_loc_noip;
 
  
    //building CscSegment objects
  cscsegment.set(seg_pos,seg_dir, seg2d_eta.chi2, seg2d_phi.chi2);
  cscsegment.setNHitEta(seg2d_eta.nhit);
  cscsegment.setNHitPhi(seg2d_phi.nhit);
  cscsegment_noip.set(seg_pos_noip,seg_dir_noip, seg2d_eta_noip.chi2, seg2d_phi_noip.chi2);
  cscsegment_noip.setNHitEta(seg2d_eta_noip.nhit);
  cscsegment_noip.setNHitPhi(seg2d_phi_noip.nhit);
  
  
  return ReturnCode::SUCCESS;
}

◆ msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ segmentAtFirstLayer()

CscSegment TrigL2MuonSA::CscSegmentMaker::segmentAtFirstLayer	(	int	mod_hash,
		TrigL2MuonSA::CscSegment *	mu_seg ) const

Definition at line 631 of file CscSegmentMaker.cxx.

                                                                                                 {
  
  
  double alpha = m_cscregdict->displacement(mod_hash);
  Amg::Vector3D n = m_cscregdict->nomalVector(mod_hash);
  double a0=mu_seg->px(), a1=mu_seg->py(), a2=mu_seg->pz();
  double b0=mu_seg->x(), b1=mu_seg->y(),b2=mu_seg->z();
  double t = ( alpha-(n(0)*b0+n(1)*b1+n(2)*b2) )/( n(0)*a0+n(1)*a1+n(2)*a2 );
  double x0=a0*t+b0,x1=a1*t+b1,x2=a2*t+b2;
  double chisquare=mu_seg->chiSquare();  
  double chisquare_phi=mu_seg->chiSquarePhi();  
 
  CscSegment cscsegment;
  cscsegment.set(x0,x1,x2,a0,a1,a2,chisquare, chisquare_phi);
  cscsegment.setNHitEta(mu_seg->nHitEta());  
  cscsegment.setNHitPhi(mu_seg->nHitPhi());  
 
  return cscsegment;
}

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

◆ m_cscregdict

ToolHandle<CscRegDict> TrigL2MuonSA::CscSegmentMaker::m_cscregdict

private

Initial value:

{

this, "CscRegDict", "TrigL2MuonSA::CscRegDict", ""}

Definition at line 92 of file CscSegmentMaker.h.

92 {

93 this, "CscRegDict", "TrigL2MuonSA::CscRegDict", ""};

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_err_eta

Gaudi::Property< double > TrigL2MuonSA::CscSegmentMaker::m_err_eta

private

Initial value:

{

this, "err_eta", 3., ""}

Definition at line 106 of file CscSegmentMaker.h.

106 {

107 this, "err_eta", 3., ""};

◆ m_err_ip

Gaudi::Property< double > TrigL2MuonSA::CscSegmentMaker::m_err_ip

private

Initial value:

{

this, "err_ip", 250., ""}

Definition at line 110 of file CscSegmentMaker.h.

110 {

111 this, "err_ip", 250., ""};

◆ m_err_phi

Gaudi::Property< double > TrigL2MuonSA::CscSegmentMaker::m_err_phi

private

Initial value:

{

this, "err_phi", 6., ""}

Definition at line 108 of file CscSegmentMaker.h.

108 {

109 this, "err_phi", 6., ""};

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> TrigL2MuonSA::CscSegmentMaker::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 94 of file CscSegmentMaker.h.

94{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

◆ m_max_chisquare

Gaudi::Property< double > TrigL2MuonSA::CscSegmentMaker::m_max_chisquare

private

Initial value:

{

this, "max_chisquare", 25., ""}

Definition at line 100 of file CscSegmentMaker.h.

100 {

101 this, "max_chisquare", 25., ""};

◆ m_max_residual_eta

Gaudi::Property< double > TrigL2MuonSA::CscSegmentMaker::m_max_residual_eta

private

Initial value:

{

this, "max_residual_eta", 100., ""}

Definition at line 102 of file CscSegmentMaker.h.

102 {

103 this, "max_residual_eta", 100., ""};

◆ m_max_residual_phi

Gaudi::Property< double > TrigL2MuonSA::CscSegmentMaker::m_max_residual_phi

private

Initial value:

{

this, "max_residual_phi", 250., ""}

Definition at line 104 of file CscSegmentMaker.h.

104 {

105 this, "max_residual_phi", 250., ""};

◆ m_muDetMgrKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> TrigL2MuonSA::CscSegmentMaker::m_muDetMgrKey {this, "DetectorManagerKey", "MuonDetectorManager", "Key of input MuonDetectorManager condition data"}

private

Definition at line 95 of file CscSegmentMaker.h.

95{this, "DetectorManagerKey", "MuonDetectorManager", "Key of input MuonDetectorManager condition data"};

◆ m_use_geometry

Gaudi::Property< bool > TrigL2MuonSA::CscSegmentMaker::m_use_geometry

private

Initial value:

{

this, "UseGeometry", false, ""}

Definition at line 98 of file CscSegmentMaker.h.

98 {

99 this, "UseGeometry", false, ""};

◆ m_util

UtilTools TrigL2MuonSA::CscSegmentMaker::m_util

private

Definition at line 91 of file CscSegmentMaker.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

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

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ CscSegmentMaker()

Member Function Documentation

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ display_hits()

◆ evtStore()

◆ extraDeps_update_handler()

◆ FindSuperPointCsc()

◆ fit_clusters()

◆ getModuleSP()

◆ initialize()

◆ inputHandles()

◆ make_2dseg3hit()

◆ make_2dseg4hit()

◆ make_2dsegment()

◆ make_4dsegment()

◆ make_segment()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ segmentAtFirstLayer()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_cscregdict

◆ m_detStore

◆ m_err_eta

◆ m_err_ip

◆ m_err_phi

◆ m_evtStore

◆ m_idHelperSvc

◆ m_max_chisquare

◆ m_max_residual_eta

◆ m_max_residual_phi

◆ m_muDetMgrKey

◆ m_use_geometry

◆ m_util

◆ m_varHandleArraysDeclared

◆ m_vhka