ALFA_LocRecCorr Class Reference

#include <ALFA_LocRecCorr.h>

Inheritance diagram for ALFA_LocRecCorr:

Collaboration diagram for ALFA_LocRecCorr:

Public Member Functions
	ALFA_LocRecCorr (const std::string &name, ISvcLocator *pSvcLocator)
	~ALFA_LocRecCorr ()
StatusCode	initialize ()
StatusCode	execute ()
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
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	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
bool	UpdateGeometryAtlas ()
void	SetNominalGeometry ()
StatusCode	RecordCollection ()
StatusCode	RecordODCollection ()
HepGeom::Transform3D	UserTransform3DInDetector (eRPotName eRPName)
HepGeom::Transform3D	UserTransform3DInStation (eRPotName eRPName)
HepGeom::Point3D< double >	Point3DInDetector (eRPotName eRPName)
StatusCode	COOLUpdate ()
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
GEOMETRYCONFIGURATION	m_Config
ALFA_GeometryReader *	m_pGeometryReader
ALFA_LocRecCorrEvCollection *	m_pLocRecCorrEvCollection
ALFA_LocRecCorrODEvCollection *	m_pLocRecCorrODEvCollection
bool	m_bCoolData
std::list< eRPotName >	m_ListExistingRPots
std::string	m_strLocRecCollectionName
std::string	m_strLocRecODCollectionName
Int_t	m_iDataType
Int_t	m_iEvt
std::vector< bool >	m_bIsTransformInStation
std::vector< bool >	m_bIsTransformInDetector
std::vector< double >	m_pointTransformInDetectorB7L1U
std::vector< double >	m_pointTransformInDetectorB7L1L
std::vector< double >	m_pointTransformInDetectorA7L1U
std::vector< double >	m_pointTransformInDetectorA7L1L
std::vector< double >	m_pointTransformInDetectorB7R1U
std::vector< double >	m_pointTransformInDetectorB7R1L
std::vector< double >	m_pointTransformInDetectorA7R1U
std::vector< double >	m_pointTransformInDetectorA7R1L
std::vector< double >	m_vecTransformInDetectorB7L1U
std::vector< double >	m_vecTransformInDetectorB7L1L
std::vector< double >	m_vecTransformInDetectorA7L1U
std::vector< double >	m_vecTransformInDetectorA7L1L
std::vector< double >	m_vecTransformInDetectorB7R1U
std::vector< double >	m_vecTransformInDetectorB7R1L
std::vector< double >	m_vecTransformInDetectorA7R1U
std::vector< double >	m_vecTransformInDetectorA7R1L
std::vector< double >	m_vecTransformInStationB7L1U
std::vector< double >	m_vecTransformInStationB7L1L
std::vector< double >	m_vecTransformInStationA7L1U
std::vector< double >	m_vecTransformInStationA7L1L
std::vector< double >	m_vecTransformInStationB7R1U
std::vector< double >	m_vecTransformInStationB7R1L
std::vector< double >	m_vecTransformInStationA7R1U
std::vector< double >	m_vecTransformInStationA7R1L
std::string	m_strKeyGeometryForReco
std::string	m_strKeyLocRecEvCollection
std::string	m_strKeyLocRecODEvCollection
std::string	m_strKeyLocRecCorrEvCollection
std::string	m_strKeyLocRecCorrODEvCollection
std::string	m_strCollectionName
std::string	m_strODCollectionName
std::string	m_strTruthCollectionName
std::string	m_strKeyRawDataCollection
std::string	m_rootInputFileName
HepGeom::Transform3D	m_TransMatrixSt [RPOTSCNT]
HepGeom::Transform3D	m_TransMatrixLHC [RPOTSCNT]
DataObjIDColl	m_extendedExtraObjects
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 52 of file ALFA_LocRecCorr.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

ALFA_LocRecCorr()

ALFA_LocRecCorr::ALFA_LocRecCorr	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 14 of file ALFA_LocRecCorr.cxx.

                                                                             :
AthAlgorithm(name, pSvcLocator)
{
    //MsgStream LogStream(Athena::getMessageSvc(), "ALFA_LocRecCorr::ALFA_LocRecCorr");
    ATH_MSG_DEBUG("begin ALFA_LocRecCorr::ALFA_LocRecCorr");
 
    m_pGeometryReader = nullptr;
 
//  m_Config.eOwner=EOT_RECO;
    m_Config.clear();
 
    //begin of Geometry properties
    declareProperty("MetrologyType",m_Config.eRPMetrologyGeoType=EMT_NOMINAL);//EGST_FILE
    declareProperty("MetrologySource",m_Config.strRPMetrologyConnString=string(""));//"rpmetrology.dat"
    declareProperty("ShiftToX97Pos",m_Config.bShiftToX97Pos=false);
 
    declareProperty("B7L1U_PosType",m_Config.CfgRPosParams[0].eRPPosType=ERPPT_ACTIVE);
    declareProperty("B7L1U_MDGeometryType",m_Config.CfgRPosParams[0].eMDGeoType=EGST_IDEALGEOMETRY);
    declareProperty("B7L1U_ODGeometryType",m_Config.CfgRPosParams[0].eODGeoType=EGST_IDEALGEOMETRY);
    declareProperty("B7L1U_MDSource",m_Config.CfgRPosParams[0].strMDConnString=string(""));
    declareProperty("B7L1U_ODSource",m_Config.CfgRPosParams[0].strODConnString=string(""));
    declareProperty("B7L1U_CurrentLVDT",m_Config.CfgRPosParams[0].fCurrentLVDTmm=7.0*CLHEP::mm);
 
    declareProperty("B7L1L_PosType",m_Config.CfgRPosParams[1].eRPPosType=ERPPT_ACTIVE);
    declareProperty("B7L1L_MDGeometryType",m_Config.CfgRPosParams[1].eMDGeoType=EGST_IDEALGEOMETRY);
    declareProperty("B7L1L_ODGeometryType",m_Config.CfgRPosParams[1].eODGeoType=EGST_IDEALGEOMETRY);
    declareProperty("B7L1L_MDSource",m_Config.CfgRPosParams[1].strMDConnString=string(""));
    declareProperty("B7L1L_ODSource",m_Config.CfgRPosParams[1].strODConnString=string(""));
    declareProperty("B7L1L_CurrentLVDT",m_Config.CfgRPosParams[1].fCurrentLVDTmm=7.0*CLHEP::mm);
 
    declareProperty("A7L1U_PosType",m_Config.CfgRPosParams[2].eRPPosType=ERPPT_ACTIVE);
    declareProperty("A7L1U_MDGeometryType",m_Config.CfgRPosParams[2].eMDGeoType=EGST_IDEALGEOMETRY);
    declareProperty("A7L1U_ODGeometryType",m_Config.CfgRPosParams[2].eODGeoType=EGST_IDEALGEOMETRY);
    declareProperty("A7L1U_MDSource",m_Config.CfgRPosParams[2].strMDConnString=string(string("")));
    declareProperty("A7L1U_ODSource",m_Config.CfgRPosParams[2].strODConnString=string(string("")));
    declareProperty("A7L1U_CurrentLVDT",m_Config.CfgRPosParams[2].fCurrentLVDTmm=7.0*CLHEP::mm);
 
    declareProperty("A7L1L_PosType",m_Config.CfgRPosParams[3].eRPPosType=ERPPT_ACTIVE);
    declareProperty("A7L1L_MDGeometryType",m_Config.CfgRPosParams[3].eMDGeoType=EGST_IDEALGEOMETRY);
    declareProperty("A7L1L_ODGeometryType",m_Config.CfgRPosParams[3].eODGeoType=EGST_IDEALGEOMETRY);
    declareProperty("A7L1L_MDSource",m_Config.CfgRPosParams[3].strMDConnString=string(""));
    declareProperty("A7L1L_ODSource",m_Config.CfgRPosParams[3].strODConnString=string(""));
    declareProperty("A7L1L_CurrentLVDT",m_Config.CfgRPosParams[3].fCurrentLVDTmm=7.0*CLHEP::mm);
 
    declareProperty("A7R1U_PosType",m_Config.CfgRPosParams[4].eRPPosType=ERPPT_ACTIVE);
    declareProperty("A7R1U_MDGeometryType",m_Config.CfgRPosParams[4].eMDGeoType=EGST_IDEALGEOMETRY);
    declareProperty("A7R1U_ODGeometryType",m_Config.CfgRPosParams[4].eODGeoType=EGST_IDEALGEOMETRY);
    declareProperty("A7R1U_MDSource",m_Config.CfgRPosParams[4].strMDConnString=string(""));
    declareProperty("A7R1U_ODSource",m_Config.CfgRPosParams[4].strODConnString=string(""));
    declareProperty("A7R1U_CurrentLVDT",m_Config.CfgRPosParams[4].fCurrentLVDTmm=7.0*CLHEP::mm);
 
    declareProperty("A7R1L_PosType",m_Config.CfgRPosParams[5].eRPPosType=ERPPT_ACTIVE);
    declareProperty("A7R1L_MDGeometryType",m_Config.CfgRPosParams[5].eMDGeoType=EGST_IDEALGEOMETRY);
    declareProperty("A7R1L_ODGeometryType",m_Config.CfgRPosParams[5].eODGeoType=EGST_IDEALGEOMETRY);
    declareProperty("A7R1L_MDSource",m_Config.CfgRPosParams[5].strMDConnString=string(""));
    declareProperty("A7R1L_ODSource",m_Config.CfgRPosParams[5].strODConnString=string(""));
    declareProperty("A7R1L_CurrentLVDT",m_Config.CfgRPosParams[5].fCurrentLVDTmm=7.0*CLHEP::mm);
 
    declareProperty("B7R1U_PosType",m_Config.CfgRPosParams[6].eRPPosType=ERPPT_ACTIVE);
    declareProperty("B7R1U_MDGeometryType",m_Config.CfgRPosParams[6].eMDGeoType=EGST_IDEALGEOMETRY);
    declareProperty("B7R1U_ODGeometryType",m_Config.CfgRPosParams[6].eODGeoType=EGST_IDEALGEOMETRY);
    declareProperty("B7R1U_MDSource",m_Config.CfgRPosParams[6].strMDConnString=string(""));
    declareProperty("B7R1U_ODSource",m_Config.CfgRPosParams[6].strODConnString=string(""));
    declareProperty("B7R1U_CurrentLVDT",m_Config.CfgRPosParams[6].fCurrentLVDTmm=7.0*CLHEP::mm);
 
    declareProperty("B7R1L_PosType",m_Config.CfgRPosParams[7].eRPPosType=ERPPT_ACTIVE);
    declareProperty("B7R1L_MDGeometryType",m_Config.CfgRPosParams[7].eMDGeoType=EGST_IDEALGEOMETRY);
    declareProperty("B7R1L_ODGeometryType",m_Config.CfgRPosParams[7].eODGeoType=EGST_IDEALGEOMETRY);
    declareProperty("B7R1L_MDSource",m_Config.CfgRPosParams[7].strMDConnString=string(""));
    declareProperty("B7R1L_ODSource",m_Config.CfgRPosParams[7].strODConnString=string(""));
    declareProperty("B7R1L_CurrentLVDT",m_Config.CfgRPosParams[7].fCurrentLVDTmm=7.0*CLHEP::mm);
    //end of Geometry properties
 
    //for transformations
    m_bIsTransformInStation.assign(8, false);
    m_bIsTransformInDetector.assign(8, false);
 
    m_pointTransformInDetectorB7L1U.assign(3, 0.0);
    m_pointTransformInDetectorB7L1L.assign(3, 0.0);
    m_pointTransformInDetectorA7L1U.assign(3, 0.0);
    m_pointTransformInDetectorA7L1L.assign(3, 0.0);
    m_pointTransformInDetectorB7R1U.assign(3, 0.0);
    m_pointTransformInDetectorB7R1L.assign(3, 0.0);
    m_pointTransformInDetectorA7R1U.assign(3, 0.0);
    m_pointTransformInDetectorA7R1L.assign(3, 0.0);
 
    m_vecTransformInDetectorB7L1U.assign(7, 0.0);
    m_vecTransformInDetectorB7L1L.assign(7, 0.0);
    m_vecTransformInDetectorA7L1U.assign(7, 0.0);
    m_vecTransformInDetectorA7L1L.assign(7, 0.0);
    m_vecTransformInDetectorB7R1U.assign(7, 0.0);
    m_vecTransformInDetectorB7R1L.assign(7, 0.0);
    m_vecTransformInDetectorA7R1U.assign(7, 0.0);
    m_vecTransformInDetectorA7R1L.assign(7, 0.0);
 
    m_vecTransformInStationB7L1U.assign(7, 0.0);
    m_vecTransformInStationB7L1L.assign(7, 0.0);
    m_vecTransformInStationA7L1U.assign(7, 0.0);
    m_vecTransformInStationA7L1L.assign(7, 0.0);
    m_vecTransformInStationB7R1U.assign(7, 0.0);
    m_vecTransformInStationB7R1L.assign(7, 0.0);
    m_vecTransformInStationA7R1U.assign(7, 0.0);
    m_vecTransformInStationA7R1L.assign(7, 0.0);
 
    declareProperty("bIsTransformInStation", m_bIsTransformInStation, "status if transformation in station will be calculated");
    declareProperty("bIsTransformInDetector", m_bIsTransformInDetector, "status if transformation in station will be calculated");
 
    declareProperty("pointTransformInDetectorB7L1U", m_pointTransformInDetectorB7L1U, "transformation point in the detectorfor B7L1U RP");
    declareProperty("pointTransformInDetectorB7L1L", m_pointTransformInDetectorB7L1L, "transformation point in the detectorfor B7L1L RP");
    declareProperty("pointTransformInDetectorA7L1U", m_pointTransformInDetectorA7L1U, "transformation point in the detectorfor A7L1U RP");
    declareProperty("pointTransformInDetectorA7L1L", m_pointTransformInDetectorA7L1L, "transformation point in the detectorfor A7L1L RP");
    declareProperty("pointTransformInDetectorA7R1U", m_pointTransformInDetectorA7R1U, "transformation point in the detectorfor A7R1U RP");
    declareProperty("pointTransformInDetectorA7R1L", m_pointTransformInDetectorA7R1L, "transformation point in the detectorfor A7R1L RP");
    declareProperty("pointTransformInDetectorB7R1U", m_pointTransformInDetectorB7R1U, "transformation point in the detectorfor B7R1U RP");
    declareProperty("pointTransformInDetectorB7R1L", m_pointTransformInDetectorB7R1L, "transformation point in the detectorfor B7R1L RP");
 
    declareProperty("vecTransformInDetectorB7L1U", m_vecTransformInDetectorB7L1U, "transformation data in the detectorfor B7L1U RP");
    declareProperty("vecTransformInDetectorB7L1L", m_vecTransformInDetectorB7L1L, "transformation data in the detectorfor B7L1L RP");
    declareProperty("vecTransformInDetectorA7L1U", m_vecTransformInDetectorA7L1U, "transformation data in the detectorfor A7L1U RP");
    declareProperty("vecTransformInDetectorA7L1L", m_vecTransformInDetectorA7L1L, "transformation data in the detectorfor A7L1L RP");
    declareProperty("vecTransformInDetectorA7R1U", m_vecTransformInDetectorA7R1U, "transformation data in the detectorfor A7R1U RP");
    declareProperty("vecTransformInDetectorA7R1L", m_vecTransformInDetectorA7R1L, "transformation data in the detectorfor A7R1L RP");
    declareProperty("vecTransformInDetectorB7R1U", m_vecTransformInDetectorB7R1U, "transformation data in the detectorfor B7R1U RP");
    declareProperty("vecTransformInDetectorB7R1L", m_vecTransformInDetectorB7R1L, "transformation data in the detectorfor B7R1L RP");
 
    declareProperty("vecTransformInStationB7L1U", m_vecTransformInStationB7L1U, "transformation data in the stationfor B7L1U RP");
    declareProperty("vecTransformInStationB7L1L", m_vecTransformInStationB7L1L, "transformation data in the stationfor B7L1L RP");
    declareProperty("vecTransformInStationA7L1U", m_vecTransformInStationA7L1U, "transformation data in the stationfor A7L1U RP");
    declareProperty("vecTransformInStationA7L1L", m_vecTransformInStationA7L1L, "transformation data in the stationfor A7L1L RP");
    declareProperty("vecTransformInStationA7R1U", m_vecTransformInStationA7R1U, "transformation data in the stationfor A7R1U RP");
    declareProperty("vecTransformInStationA7R1L", m_vecTransformInStationA7R1L, "transformation data in the stationfor A7R1L RP");
    declareProperty("vecTransformInStationB7R1U", m_vecTransformInStationB7R1U, "transformation data in the stationfor B7R1U RP");
    declareProperty("vecTransformInStationB7R1L", m_vecTransformInStationB7R1L, "transformation data in the stationfor B7R1L RP");
 
    m_ListExistingRPots.clear();
 
    // data type using in the local reconstruction
    // for the simulation data the value is 0, for the real data the value is 1. Unset value is -1
    declareProperty("DataType", m_iDataType=1, "data type using in the local reconstruction");
 
    m_strKeyGeometryForReco              = "ALFA_GeometryForReco";
    m_strLocRecCollectionName          = "ALFA_LocRecEvCollection";
    m_strLocRecODCollectionName          = "ALFA_LocRecODEvCollection";
    m_strKeyLocRecEvCollection            = "ALFA_LocRecEvCollection";
    m_strKeyLocRecODEvCollection        = "ALFA_LocRecODEvCollection";
    m_strKeyLocRecCorrEvCollection        = "ALFA_LocRecCorrEvCollection";
    m_strKeyLocRecCorrODEvCollection    = "ALFA_LocRecCorrODEvCollection";
 
    m_bCoolData = true;
    declareProperty("CoolData", m_bCoolData);
 
    m_pLocRecCorrEvCollection   = nullptr;
    m_pLocRecCorrODEvCollection = nullptr;
    m_iEvt = 0;
 
    ATH_MSG_DEBUG("end ALFA_LocRecCorr::ALFA_LocRecCorr");
}

~ALFA_LocRecCorr()

ALFA_LocRecCorr::~ALFA_LocRecCorr

(

)

Definition at line 172 of file ALFA_LocRecCorr.cxx.

{
    //MsgStream LogStream(Athena::getMessageSvc(), "ALFA_LocRecCorr::~ALFA_LocRecCorr");
    ATH_MSG_DEBUG("begin ALFA_LocRecCorr::~ALFA_LocRecCorr");
 
    ATH_MSG_DEBUG("end ALFA_LocRecCorr::~ALFA_LocRecCorr");
}

Member Function Documentation

COOLUpdate()

StatusCode ALFA_LocRecCorr::COOLUpdate ( )

private

Definition at line 561 of file ALFA_LocRecCorr.cxx.

{
    ATH_MSG_DEBUG("begin ALFA_LocRecCorr::COOLUpdate()");
 
    SG::ReadCondHandleKey<CondAttrListCollection> key("/FWD/ALFA/position_calibration");
    SG::ReadCondHandle<CondAttrListCollection> listAttrColl(key);
    ATH_CHECK( listAttrColl.isValid() );
 
    for(CondAttrListCollection::const_iterator iterAttr=listAttrColl->begin();iterAttr!=listAttrColl->end();++iterAttr)
    {
        int iChannel=iterAttr->first; //RPot ID
        m_Config.CfgRPosParams[iChannel].swcorr.fXOffset=((iterAttr->second)[0]).data<float>();
        m_Config.CfgRPosParams[iChannel].swcorr.fTheta  =((iterAttr->second)[1]).data<float>();
        m_Config.CfgRPosParams[iChannel].swcorr.fYOffset=((iterAttr->second)[2]).data<float>();
 
        ATH_MSG_DEBUG("iChannel, fXOffset, fTheta, fYOffset = " << iChannel << ", " << m_Config.CfgRPosParams[iChannel].swcorr.fXOffset);
        ATH_MSG_DEBUG(", " << m_Config.CfgRPosParams[iChannel].swcorr.fTheta << ", " << m_Config.CfgRPosParams[iChannel].swcorr.fYOffset);
    }
 
    // update SW corrections - needs to be updated during the COOL DB check
    if (UpdateGeometryAtlas())
    {
        ATH_MSG_DEBUG("Geometry for the SW corrections updated successfully");
    }
    else
    {
        ATH_MSG_FATAL("Unable to update a geometry of the SW corrections!");
        ATH_MSG_DEBUG("end ALFA_LocRecCorr::COOLUpdate()");
        return StatusCode::FAILURE;
    }
 
    return StatusCode::SUCCESS;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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< Algorithm > >::detStore ( ) const

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode ALFA_LocRecCorr::execute

(

)

Definition at line 217 of file ALFA_LocRecCorr.cxx.

{
    ATH_MSG_DEBUG("begin ALFA_LocRecCorr::Execute()");
 
    StatusCode sc = StatusCode::SUCCESS;
 
    sc = RecordCollection();
    if (sc.isFailure())
    {
        ATH_MSG_ERROR("ALFA_LocRecCorr recordCollection failed");
        return StatusCode::SUCCESS;
    }
 
    sc = RecordODCollection();
    if (sc.isFailure())
    {
        ATH_MSG_ERROR("ALFA_LocRecCorr recordODCollection failed");
        return StatusCode::SUCCESS;
    }
 
    int iRPot, iSide;
    int iAlgo;
    double fRecPosX = -9999.0, fRecPosY = -9999.0, fRecPosOD = -9999.0;
    HepGeom::Point3D<double> PointInDetCS;
    HepGeom::Point3D<double> PointInPotCS;
    HepGeom::Point3D<double> PointInStatCS;
    HepGeom::Point3D<double> PointInAtlasCS;
 
    const ALFA_LocRecEvCollection* pLocRecCorrCol = nullptr;
    const ALFA_LocRecODEvCollection* pLocRecCorrODCol = nullptr;
 
    sc = evtStore()->retrieve(pLocRecCorrCol, m_strLocRecCollectionName);
    if(sc.isFailure() || !pLocRecCorrCol)
    {
        ATH_MSG_ERROR("Container "<< m_strLocRecCollectionName <<" NOT FOUND !!!!!!!");
//      return StatusCode::FAILURE;
    }
    else
    {
        ALFA_LocRecEvCollection::const_iterator mcColBeg = pLocRecCorrCol->begin();
        ALFA_LocRecEvCollection::const_iterator mcColEnd = pLocRecCorrCol->end();
 
        //loop over collection (container) with hits (i.e. over 1 event)
        for(; mcColBeg!=mcColEnd; ++mcColBeg)
        {
            iAlgo       = (*mcColBeg)->getAlgoNum();
            iRPot       = (*mcColBeg)->getPotNum();
            fRecPosX    = (*mcColBeg)->getXposition();
            fRecPosY    = (*mcColBeg)->getYposition();
    
            PointInDetCS = HepGeom::Point3D<double>(fRecPosX, fRecPosY, 10.0);
            PointInAtlasCS = m_pGeometryReader->GetDetPointInAtlas((eRPotName)(iRPot+1), PointInDetCS);
            PointInPotCS = m_pGeometryReader->GetDetPointInRPot((eRPotName)(iRPot+1), PointInDetCS);
            PointInStatCS = m_TransMatrixSt[iRPot]*PointInDetCS;
    
            m_pLocRecCorrEvCollection->push_back(new ALFA_LocRecCorrEvent(iAlgo, iRPot, PointInAtlasCS[0], PointInAtlasCS[1], PointInAtlasCS[2], PointInPotCS[0], PointInPotCS[1], PointInStatCS[0], PointInStatCS[1], -9999.0, -9999.0));
        }
    }
 
    sc = evtStore()->retrieve(pLocRecCorrODCol, m_strLocRecODCollectionName);
    if(sc.isFailure() || !pLocRecCorrODCol)
    {
        ATH_MSG_ERROR("Container "<< m_strLocRecODCollectionName <<" NOT FOUND !!!!!!!");
//      return StatusCode::FAILURE;
    }
    else
    {
        ALFA_LocRecODEvCollection::const_iterator mcColODBeg = pLocRecCorrODCol->begin();
        ALFA_LocRecODEvCollection::const_iterator mcColODEnd = pLocRecCorrODCol->end();
    
        //loop over collection (container) with hits (i.e. over 1 event)
        Int_t iSign;
        for(; mcColODBeg!=mcColODEnd; ++mcColODBeg)
        {
            iAlgo       = (*mcColODBeg)->getAlgoNum();
            iRPot       = (*mcColODBeg)->getPotNum();
            iSide       = (*mcColODBeg)->getSide();
            fRecPosOD   = (*mcColODBeg)->getYposition();
    
            iSign = (iSide==0)? -1 : 1;
            PointInDetCS = HepGeom::Point3D<double>(iSign*22, fRecPosOD, 35.5);
            PointInAtlasCS = m_pGeometryReader->GetDetPointInAtlas((eRPotName)(iRPot+1), PointInDetCS);
            PointInPotCS = m_pGeometryReader->GetDetPointInRPot((eRPotName)(iRPot+1), PointInDetCS);
            PointInStatCS = m_TransMatrixSt[iRPot]*PointInDetCS;
            m_pLocRecCorrODEvCollection->push_back(new ALFA_LocRecCorrODEvent(iAlgo, iRPot, iSide, PointInAtlasCS[1], PointInAtlasCS[2], PointInPotCS[1], PointInStatCS[1], -9999.0));
        }
    }
 
    ATH_MSG_DEBUG("end ALFA_LocRecCorr::execute()");
    return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::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

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

initialize()

StatusCode ALFA_LocRecCorr::initialize

(

)

Definition at line 180 of file ALFA_LocRecCorr.cxx.

{
    //MsgStream LogStream(Athena::getMessageSvc(), "ALFA_LocRecCorr::Initialize()");
    ATH_MSG_DEBUG("begin ALFA_LocRecCorr::Initialize()");
 
    //read ALFA_Geometry from StoreGate
    if (!detStore()->contains<ALFA_GeometryReader>(m_strKeyGeometryForReco))
    {
        ATH_MSG_ERROR("m_pGeometryReader is not in StoreGate");
    }
    else ATH_MSG_DEBUG("m_pGeometryReader is in StoreGate");
 
    if (StatusCode::SUCCESS != detStore()->retrieve(m_pGeometryReader, m_strKeyGeometryForReco))
    {
        ATH_MSG_ERROR("m_pGeometryReader: unable to retrieve data from SG");
    }
    else ATH_MSG_DEBUG("m_pGeometryReader: retrieved from SG");
 
    if (m_Config.eRPMetrologyGeoType==EMT_SWCORRECTIONS)
    {
        CHECK(COOLUpdate());
    }
 
    if(m_Config.eRPMetrologyGeoType==EMT_NOMINAL)
        SetNominalGeometry();
 
    // do update geometry at the end of the initialization process
    if (UpdateGeometryAtlas())
        ATH_MSG_DEBUG("Geometry updated successfully.");
    else
        ATH_MSG_FATAL("Unable to update a geometry!");
 
    ATH_MSG_DEBUG("end ALFA_LocRecCorr::initialize()");
 
    return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::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.

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Algorithm >::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< Algorithm > >::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.

Point3DInDetector()

HepGeom::Point3D< double > ALFA_LocRecCorr::Point3DInDetector ( eRPotName eRPName )

private

Definition at line 468 of file ALFA_LocRecCorr.cxx.

{
    //MsgStream LogStream(Athena::getMessageSvc(), "ALFA_LocRecCorr::Point3DInDetector(eRPotName eRPName)");
    ATH_MSG_DEBUG("begin ALFA_LocRecCorr::Point3DInDetector()");
 
    HepGeom::Point3D<double> Point;
 
    switch(eRPName)
    {
        case ERPN_B7L1U:
            Point = HepGeom::Point3D<double>(m_pointTransformInDetectorB7L1U[0], m_pointTransformInDetectorB7L1U[1], m_pointTransformInDetectorB7L1U[2]);
            break;
        case ERPN_B7L1L:
            Point = HepGeom::Point3D<double>(m_pointTransformInDetectorB7L1L[0], m_pointTransformInDetectorB7L1L[1], m_pointTransformInDetectorB7L1L[2]);
            break;
        case ERPN_A7L1U:
            Point = HepGeom::Point3D<double>(m_pointTransformInDetectorA7L1U[0], m_pointTransformInDetectorA7L1U[1], m_pointTransformInDetectorA7L1U[2]);
            break;
        case ERPN_A7L1L:
            Point = HepGeom::Point3D<double>(m_pointTransformInDetectorA7L1L[0], m_pointTransformInDetectorA7L1U[1], m_pointTransformInDetectorA7L1L[2]);
            break;
        case ERPN_A7R1U:
            Point = HepGeom::Point3D<double>(m_pointTransformInDetectorA7R1U[0], m_pointTransformInDetectorA7R1U[1], m_pointTransformInDetectorA7R1U[2]);
            break;
        case ERPN_A7R1L:
            Point = HepGeom::Point3D<double>(m_pointTransformInDetectorA7R1L[0], m_pointTransformInDetectorA7R1L[1], m_pointTransformInDetectorA7R1L[2]);
            break;
        case ERPN_B7R1U:
            Point = HepGeom::Point3D<double>(m_pointTransformInDetectorB7R1U[0], m_pointTransformInDetectorB7R1U[1], m_pointTransformInDetectorB7R1U[2]);
            break;
        case ERPN_B7R1L:
            Point = HepGeom::Point3D<double>(m_pointTransformInDetectorB7R1L[0], m_pointTransformInDetectorB7R1L[1], m_pointTransformInDetectorB7R1L[2]);
            break;
        default:
            ATH_MSG_WARNING("Unknown Roman pot, transformation point will be set to default (zero) value");
    }
 
    ATH_MSG_DEBUG("end ALFA_LocRecCorr::Point3DInDetector()");
 
    return Point;
}

RecordCollection()

StatusCode ALFA_LocRecCorr::RecordCollection ( )

private

Definition at line 510 of file ALFA_LocRecCorr.cxx.

{
    //MsgStream LogStream(Athena::getMessageSvc(), "ALFA_LocRecCorr::RecordCollection()");
    ATH_MSG_DEBUG("begin ALFA_LocRecCorr::RecordCollection()");
 
    StatusCode sc = StatusCode::SUCCESS;
 
    m_pLocRecCorrEvCollection = new ALFA_LocRecCorrEvCollection();
    sc = evtStore()->record(m_pLocRecCorrEvCollection, m_strKeyLocRecCorrEvCollection);
 
    if (sc.isFailure())
    {
        ATH_MSG_FATAL("MD - Could not record the empty LocRecCorrEv collection in StoreGate");
        return sc;
    }
    else
    {
        ATH_MSG_DEBUG("MD - LocRecCorrEv collection was recorded in StoreGate");
    }
 
    ATH_MSG_DEBUG("end ALFA_LocRecCorr::RecordCollection()");
 
    return sc;
}

RecordODCollection()

StatusCode ALFA_LocRecCorr::RecordODCollection ( )

private

Definition at line 535 of file ALFA_LocRecCorr.cxx.

{
    //MsgStream LogStream(Athena::getMessageSvc(), "ALFA_LocRecCorr::RecordODCollection()");
    ATH_MSG_DEBUG("begin ALFA_LocRecCorr::RecordODCollection()");
 
    StatusCode sc = StatusCode::SUCCESS;
 
    m_pLocRecCorrODEvCollection = new ALFA_LocRecCorrODEvCollection();
    sc = evtStore()->record(m_pLocRecCorrODEvCollection, m_strKeyLocRecCorrODEvCollection);
 
    if (sc.isFailure())
    {
        ATH_MSG_FATAL("OD - Could not record the empty LocRecCorrEv collection in StoreGate");
 
        return sc;
    }
    else
    {
         ATH_MSG_DEBUG("OD - LocRecCorrEv collection is recorded in StoreGate");
    }
 
    ATH_MSG_DEBUG("end ALFA_LocRecCorr::RecordODCollection()");
 
    return sc;
}

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< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

SetNominalGeometry()

void ALFA_LocRecCorr::SetNominalGeometry ( )

private

Definition at line 616 of file ALFA_LocRecCorr.cxx.

{
    eRPotName eRPName;
    for(int i=0;i<RPOTSCNT;i++)
    {
        eRPName=(eRPotName)(i+1);
        if(m_bIsTransformInDetector[i])
        {
            m_Config.CfgRPosParams[i].usercorr.bIsEnabledUserTranform=true;
            m_Config.CfgRPosParams[i].usercorr.UserOriginOfDetTransInRPot=Point3DInDetector(eRPName);
            m_Config.CfgRPosParams[i].usercorr.UserTransformOfDetInRPot=UserTransform3DInDetector(eRPName);
        }
        if(m_bIsTransformInStation[i])
        {
            m_Config.CfgRPosParams[i].usercorr.bIsEnabledUserTranform=true;
            m_Config.CfgRPosParams[i].usercorr.UserTransformOfRPInStation=UserTransform3DInStation(eRPName);
        }
    }
}

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::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.

UpdateGeometryAtlas()

bool ALFA_LocRecCorr::UpdateGeometryAtlas ( )

private

Definition at line 595 of file ALFA_LocRecCorr.cxx.

{
    //MsgStream LogStream(Athena::getMessageSvc(), "ALFA_LocRecCorr::UpdateGeometryAtlas()");
    ATH_MSG_DEBUG("begin ALFA_LocRecCorr::UpdateGeometryAtlas()");
 
    if(m_pGeometryReader->Initialize(&m_Config,EFCS_ATLAS))
    {
        ATH_MSG_DEBUG("Geometry successfully updated.");
        m_pGeometryReader->GetListOfExistingRPotIDs(&m_ListExistingRPots);
    }
    else
    {
        ATH_MSG_FATAL("Cannot update geometry. Initialization process failed.");
        ATH_MSG_DEBUG("end ALFA_LocRecCorr::UpdateGeometryAtlas()");
        return false;
    }
 
    ATH_MSG_DEBUG("end ALFA_LocRecCorr::UpdateGeometryAtlas()");
    return true;
}

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::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);
      }
    }
  }

UserTransform3DInDetector()

HepGeom::Transform3D ALFA_LocRecCorr::UserTransform3DInDetector ( eRPotName eRPName )

private

Definition at line 389 of file ALFA_LocRecCorr.cxx.

{
    //MsgStream LogStream(Athena::getMessageSvc(), "ALFA_LocRecCorr::UserTransform3DInDetector(eRPotName eRPName)");
    ATH_MSG_DEBUG("begin ALFA_LocRecCorr::UserTransform3DInDetector()");
 
    CLHEP::HepRep3x3 matRotation;
    USERTRANSFORM structUserTransform;
 
    switch(eRPName)
    {
        case ERPN_B7L1U:
            structUserTransform.fAngle = m_vecTransformInDetectorB7L1U[0];
            structUserTransform.vecRotation = CLHEP::Hep3Vector(m_vecTransformInDetectorB7L1U[1], m_vecTransformInDetectorB7L1U[2], m_vecTransformInDetectorB7L1U[3]);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(m_vecTransformInDetectorB7L1U[4], m_vecTransformInDetectorB7L1U[5], m_vecTransformInDetectorB7L1U[6]);
            break;
        case ERPN_B7L1L:
            structUserTransform.fAngle = m_vecTransformInDetectorB7L1L[0];
            structUserTransform.vecRotation = CLHEP::Hep3Vector(m_vecTransformInDetectorB7L1L[1], m_vecTransformInDetectorB7L1L[2], m_vecTransformInDetectorB7L1L[3]);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(m_vecTransformInDetectorB7L1L[4], m_vecTransformInDetectorB7L1L[5], m_vecTransformInDetectorB7L1L[6]);
            break;
        case ERPN_A7L1U:
            structUserTransform.fAngle = m_vecTransformInDetectorA7L1U[0];
            structUserTransform.vecRotation = CLHEP::Hep3Vector(m_vecTransformInDetectorA7L1U[1], m_vecTransformInDetectorA7L1U[2], m_vecTransformInDetectorA7L1U[3]);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(m_vecTransformInDetectorA7L1U[4], m_vecTransformInDetectorA7L1U[5], m_vecTransformInDetectorA7L1U[6]);
            break;
        case ERPN_A7L1L:
            structUserTransform.fAngle = m_vecTransformInDetectorA7L1L[0];
            structUserTransform.vecRotation = CLHEP::Hep3Vector(m_vecTransformInDetectorA7L1L[1], m_vecTransformInDetectorA7L1L[2], m_vecTransformInDetectorA7L1L[3]);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(m_vecTransformInDetectorA7L1L[4], m_vecTransformInDetectorA7L1L[5], m_vecTransformInDetectorA7L1L[6]);
            break;
        case ERPN_A7R1U:
            structUserTransform.fAngle = m_vecTransformInDetectorA7R1U[0];
            structUserTransform.vecRotation = CLHEP::Hep3Vector(m_vecTransformInDetectorA7R1U[1], m_vecTransformInDetectorA7R1U[2], m_vecTransformInDetectorA7R1U[3]);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(m_vecTransformInDetectorA7R1U[4], m_vecTransformInDetectorA7R1U[5], m_vecTransformInDetectorA7R1U[6]);
            break;
        case ERPN_A7R1L:
            structUserTransform.fAngle = m_vecTransformInDetectorA7R1L[0];
            structUserTransform.vecRotation = CLHEP::Hep3Vector(m_vecTransformInDetectorA7R1L[1], m_vecTransformInDetectorA7R1L[2], m_vecTransformInDetectorA7R1L[3]);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(m_vecTransformInDetectorA7R1L[4], m_vecTransformInDetectorA7R1L[5], m_vecTransformInDetectorA7R1L[6]);
            break;
        case ERPN_B7R1U:
            structUserTransform.fAngle = m_vecTransformInDetectorB7R1U[0];
            structUserTransform.vecRotation = CLHEP::Hep3Vector(m_vecTransformInDetectorB7R1U[1], m_vecTransformInDetectorB7R1U[2], m_vecTransformInDetectorB7R1U[3]);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(m_vecTransformInDetectorB7R1U[4], m_vecTransformInDetectorB7R1U[5], m_vecTransformInDetectorB7R1U[6]);
            break;
        case ERPN_B7R1L:
            structUserTransform.fAngle = m_vecTransformInDetectorB7R1L[0];
            structUserTransform.vecRotation = CLHEP::Hep3Vector(m_vecTransformInDetectorB7R1L[1], m_vecTransformInDetectorB7R1L[2], m_vecTransformInDetectorB7R1L[3]);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(m_vecTransformInDetectorB7R1L[4], m_vecTransformInDetectorB7R1L[5], m_vecTransformInDetectorB7R1L[6]);
            break;
        default:
            ATH_MSG_WARNING("Unknown Roman pot, detector transformation will be set to default (zero) values");
            structUserTransform.fAngle = 0.0;
            structUserTransform.vecRotation = CLHEP::Hep3Vector(0.0, 0.0, 0.0);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(0.0, 0.0, 0.0);
    }
 
    double fPhi = structUserTransform.fAngle;
 
    CLHEP::Hep3Vector vRotation = CLHEP::Hep3Vector(structUserTransform.vecRotation);
    CLHEP::Hep3Vector vTranslation = CLHEP::Hep3Vector(structUserTransform.vecTranslation);
 
    matRotation.xx_ = vRotation.x()*vRotation.x()*(1 - cos(fPhi)) + cos(fPhi);
    matRotation.xy_ = vRotation.x()*vRotation.y()*(1 - cos(fPhi)) - vRotation.z()*sin(fPhi);
    matRotation.xz_ = vRotation.x()*vRotation.z()*(1 - cos(fPhi)) + vRotation.y()*sin(fPhi);
 
    matRotation.yx_ = vRotation.y()*vRotation.x()*(1 - cos(fPhi)) + vRotation.z()*sin(fPhi);
    matRotation.yy_ = vRotation.y()*vRotation.y()*(1 - cos(fPhi)) + cos(fPhi);
    matRotation.yz_ = vRotation.y()*vRotation.z()*(1 - cos(fPhi)) - vRotation.x()*sin(fPhi);
 
    matRotation.zx_ = vRotation.z()*vRotation.x()*(1 - cos(fPhi)) - vRotation.y()*sin(fPhi);
    matRotation.zy_ = vRotation.z()*vRotation.y()*(1 - cos(fPhi)) + vRotation.x()*sin(fPhi);
    matRotation.zz_ = vRotation.z()*vRotation.z()*(1 - cos(fPhi)) + cos(fPhi);
 
    ATH_MSG_DEBUG("end ALFA_LocRecCorr::UserTransform3DInDetector()");
 
    return HepGeom::Transform3D(CLHEP::HepRotation(matRotation), vTranslation);
}

UserTransform3DInStation()

HepGeom::Transform3D ALFA_LocRecCorr::UserTransform3DInStation ( eRPotName eRPName )

private

Definition at line 310 of file ALFA_LocRecCorr.cxx.

{
    //MsgStream LogStream(Athena::getMessageSvc(), "ALFA_LocRecCorr::UserTransform3DInStation(eRPotName eRPName)");
    ATH_MSG_DEBUG("begin ALFA_LocRecCorr::UserTransform3DInStation()");
 
    CLHEP::HepRep3x3 matRotation;
    USERTRANSFORM structUserTransform;
 
    switch(eRPName)
    {
        case ERPN_B7L1U:
            structUserTransform.fAngle = m_vecTransformInStationB7L1U[0];
            structUserTransform.vecRotation = CLHEP::Hep3Vector(m_vecTransformInStationB7L1U[1], m_vecTransformInStationB7L1U[2], m_vecTransformInStationB7L1U[3]);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(m_vecTransformInStationB7L1U[4], m_vecTransformInStationB7L1U[5], m_vecTransformInStationB7L1U[6]);
            break;
        case ERPN_B7L1L:
            structUserTransform.fAngle = m_vecTransformInStationB7L1L[0];
            structUserTransform.vecRotation = CLHEP::Hep3Vector(m_vecTransformInStationB7L1L[1], m_vecTransformInStationB7L1L[2], m_vecTransformInStationB7L1L[3]);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(m_vecTransformInStationB7L1L[4], m_vecTransformInStationB7L1L[5], m_vecTransformInStationB7L1L[6]);
            break;
        case ERPN_A7L1U:
            structUserTransform.fAngle = m_vecTransformInStationA7L1U[0];
            structUserTransform.vecRotation = CLHEP::Hep3Vector(m_vecTransformInStationA7L1U[1], m_vecTransformInStationA7L1U[2], m_vecTransformInStationA7L1U[3]);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(m_vecTransformInStationA7L1U[4], m_vecTransformInStationA7L1U[5], m_vecTransformInStationA7L1U[6]);
            break;
        case ERPN_A7L1L:
            structUserTransform.fAngle = m_vecTransformInStationA7L1L[0];
            structUserTransform.vecRotation = CLHEP::Hep3Vector(m_vecTransformInStationA7L1L[1], m_vecTransformInStationA7L1L[2], m_vecTransformInStationA7L1L[3]);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(m_vecTransformInStationA7L1L[4], m_vecTransformInStationA7L1L[5], m_vecTransformInStationA7L1L[6]);
            break;
        case ERPN_A7R1U:
            structUserTransform.fAngle = m_vecTransformInStationA7R1U[0];
            structUserTransform.vecRotation = CLHEP::Hep3Vector(m_vecTransformInStationA7R1U[1], m_vecTransformInStationA7R1U[2], m_vecTransformInStationA7R1U[3]);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(m_vecTransformInStationA7R1U[4], m_vecTransformInStationA7R1U[5], m_vecTransformInStationA7R1U[6]);
            break;
        case ERPN_A7R1L:
            structUserTransform.fAngle = m_vecTransformInStationA7R1L[0];
            structUserTransform.vecRotation = CLHEP::Hep3Vector(m_vecTransformInStationA7R1L[1], m_vecTransformInStationA7R1L[2], m_vecTransformInStationA7R1L[3]);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(m_vecTransformInStationA7R1L[4], m_vecTransformInStationA7R1L[5], m_vecTransformInStationA7R1L[6]);
            break;
        case ERPN_B7R1U:
            structUserTransform.fAngle = m_vecTransformInStationB7R1U[0];
            structUserTransform.vecRotation = CLHEP::Hep3Vector(m_vecTransformInStationB7R1U[1], m_vecTransformInStationB7R1U[2], m_vecTransformInStationB7R1U[3]);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(m_vecTransformInStationB7R1U[4], m_vecTransformInStationB7R1U[5], m_vecTransformInStationB7R1U[6]);
            break;
        case ERPN_B7R1L:
            structUserTransform.fAngle = m_vecTransformInStationB7R1L[0];
            structUserTransform.vecRotation = CLHEP::Hep3Vector(m_vecTransformInStationB7R1L[1], m_vecTransformInStationB7R1L[2], m_vecTransformInStationB7R1L[3]);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(m_vecTransformInStationB7R1L[4], m_vecTransformInStationB7R1L[5], m_vecTransformInStationB7R1L[6]);
            break;
        default:
            ATH_MSG_WARNING("Unknown Roman pot, station transformation will be set to default (zero) values");
            structUserTransform.fAngle = 0.0;
            structUserTransform.vecRotation = CLHEP::Hep3Vector(0.0, 0.0, 0.0);
            structUserTransform.vecTranslation = CLHEP::Hep3Vector(0.0, 0.0, 0.0);
    }
 
    double fPhi = structUserTransform.fAngle;
 
    CLHEP::Hep3Vector vRotation = CLHEP::Hep3Vector(structUserTransform.vecRotation);
    CLHEP::Hep3Vector vTranslation = CLHEP::Hep3Vector(structUserTransform.vecTranslation);
 
    matRotation.xx_ = vRotation.x()*vRotation.x()*(1 - cos(fPhi)) + cos(fPhi);
    matRotation.xy_ = vRotation.x()*vRotation.y()*(1 - cos(fPhi)) - vRotation.z()*sin(fPhi);
    matRotation.xz_ = vRotation.x()*vRotation.z()*(1 - cos(fPhi)) + vRotation.y()*sin(fPhi);
 
    matRotation.yx_ = vRotation.y()*vRotation.x()*(1 - cos(fPhi)) + vRotation.z()*sin(fPhi);
    matRotation.yy_ = vRotation.y()*vRotation.y()*(1 - cos(fPhi)) + cos(fPhi);
    matRotation.yz_ = vRotation.y()*vRotation.z()*(1 - cos(fPhi)) - vRotation.x()*sin(fPhi);
 
    matRotation.zx_ = vRotation.z()*vRotation.x()*(1 - cos(fPhi)) - vRotation.y()*sin(fPhi);
    matRotation.zy_ = vRotation.z()*vRotation.y()*(1 - cos(fPhi)) + vRotation.x()*sin(fPhi);
    matRotation.zz_ = vRotation.z()*vRotation.z()*(1 - cos(fPhi)) + cos(fPhi);
 
    ATH_MSG_DEBUG("end ALFA_LocRecCorr::UserTransform3DInStation()");
 
    return HepGeom::Transform3D(CLHEP::HepRotation(matRotation), vTranslation);
}

Member Data Documentation

m_bCoolData

bool ALFA_LocRecCorr::m_bCoolData

private

Definition at line 69 of file ALFA_LocRecCorr.h.

m_bIsTransformInDetector

std::vector<bool> ALFA_LocRecCorr::m_bIsTransformInDetector

private

Definition at line 79 of file ALFA_LocRecCorr.h.

m_bIsTransformInStation

std::vector<bool> ALFA_LocRecCorr::m_bIsTransformInStation

private

Definition at line 78 of file ALFA_LocRecCorr.h.

m_Config

GEOMETRYCONFIGURATION ALFA_LocRecCorr::m_Config

private

Definition at line 59 of file ALFA_LocRecCorr.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_iDataType

Int_t ALFA_LocRecCorr::m_iDataType

private

Definition at line 75 of file ALFA_LocRecCorr.h.

m_iEvt

Int_t ALFA_LocRecCorr::m_iEvt

private

Definition at line 76 of file ALFA_LocRecCorr.h.

m_ListExistingRPots

std::list<eRPotName> ALFA_LocRecCorr::m_ListExistingRPots

private

Definition at line 70 of file ALFA_LocRecCorr.h.

m_pGeometryReader

ALFA_GeometryReader* ALFA_LocRecCorr::m_pGeometryReader

private

Definition at line 60 of file ALFA_LocRecCorr.h.

m_pLocRecCorrEvCollection

ALFA_LocRecCorrEvCollection* ALFA_LocRecCorr::m_pLocRecCorrEvCollection

private

Definition at line 66 of file ALFA_LocRecCorr.h.

m_pLocRecCorrODEvCollection

ALFA_LocRecCorrODEvCollection* ALFA_LocRecCorr::m_pLocRecCorrODEvCollection

private

Definition at line 67 of file ALFA_LocRecCorr.h.

m_pointTransformInDetectorA7L1L

std::vector<double> ALFA_LocRecCorr::m_pointTransformInDetectorA7L1L

private

Definition at line 83 of file ALFA_LocRecCorr.h.

m_pointTransformInDetectorA7L1U

std::vector<double> ALFA_LocRecCorr::m_pointTransformInDetectorA7L1U

private

Definition at line 82 of file ALFA_LocRecCorr.h.

m_pointTransformInDetectorA7R1L

std::vector<double> ALFA_LocRecCorr::m_pointTransformInDetectorA7R1L

private

Definition at line 87 of file ALFA_LocRecCorr.h.

m_pointTransformInDetectorA7R1U

std::vector<double> ALFA_LocRecCorr::m_pointTransformInDetectorA7R1U

private

Definition at line 86 of file ALFA_LocRecCorr.h.

m_pointTransformInDetectorB7L1L

std::vector<double> ALFA_LocRecCorr::m_pointTransformInDetectorB7L1L

private

Definition at line 81 of file ALFA_LocRecCorr.h.

m_pointTransformInDetectorB7L1U

std::vector<double> ALFA_LocRecCorr::m_pointTransformInDetectorB7L1U

private

Definition at line 80 of file ALFA_LocRecCorr.h.

m_pointTransformInDetectorB7R1L

std::vector<double> ALFA_LocRecCorr::m_pointTransformInDetectorB7R1L

private

Definition at line 85 of file ALFA_LocRecCorr.h.

m_pointTransformInDetectorB7R1U

std::vector<double> ALFA_LocRecCorr::m_pointTransformInDetectorB7R1U

private

Definition at line 84 of file ALFA_LocRecCorr.h.

m_rootInputFileName

std::string ALFA_LocRecCorr::m_rootInputFileName

private

Definition at line 114 of file ALFA_LocRecCorr.h.

m_strCollectionName

std::string ALFA_LocRecCorr::m_strCollectionName

private

Definition at line 110 of file ALFA_LocRecCorr.h.

m_strKeyGeometryForReco

std::string ALFA_LocRecCorr::m_strKeyGeometryForReco

private

Definition at line 105 of file ALFA_LocRecCorr.h.

m_strKeyLocRecCorrEvCollection

std::string ALFA_LocRecCorr::m_strKeyLocRecCorrEvCollection

private

Definition at line 108 of file ALFA_LocRecCorr.h.

m_strKeyLocRecCorrODEvCollection

std::string ALFA_LocRecCorr::m_strKeyLocRecCorrODEvCollection

private

Definition at line 109 of file ALFA_LocRecCorr.h.

m_strKeyLocRecEvCollection

std::string ALFA_LocRecCorr::m_strKeyLocRecEvCollection

private

Definition at line 106 of file ALFA_LocRecCorr.h.

m_strKeyLocRecODEvCollection

std::string ALFA_LocRecCorr::m_strKeyLocRecODEvCollection

private

Definition at line 107 of file ALFA_LocRecCorr.h.

m_strKeyRawDataCollection

std::string ALFA_LocRecCorr::m_strKeyRawDataCollection

private

Definition at line 113 of file ALFA_LocRecCorr.h.

m_strLocRecCollectionName

std::string ALFA_LocRecCorr::m_strLocRecCollectionName

private

Definition at line 72 of file ALFA_LocRecCorr.h.

m_strLocRecODCollectionName

std::string ALFA_LocRecCorr::m_strLocRecODCollectionName

private

Definition at line 73 of file ALFA_LocRecCorr.h.

m_strODCollectionName

std::string ALFA_LocRecCorr::m_strODCollectionName

private

Definition at line 111 of file ALFA_LocRecCorr.h.

m_strTruthCollectionName

std::string ALFA_LocRecCorr::m_strTruthCollectionName

private

Definition at line 112 of file ALFA_LocRecCorr.h.

m_TransMatrixLHC

HepGeom::Transform3D ALFA_LocRecCorr::m_TransMatrixLHC[RPOTSCNT]

private

Definition at line 117 of file ALFA_LocRecCorr.h.

m_TransMatrixSt

HepGeom::Transform3D ALFA_LocRecCorr::m_TransMatrixSt[RPOTSCNT]

private

Definition at line 116 of file ALFA_LocRecCorr.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vecTransformInDetectorA7L1L

std::vector<double> ALFA_LocRecCorr::m_vecTransformInDetectorA7L1L

private

Definition at line 91 of file ALFA_LocRecCorr.h.

m_vecTransformInDetectorA7L1U

std::vector<double> ALFA_LocRecCorr::m_vecTransformInDetectorA7L1U

private

Definition at line 90 of file ALFA_LocRecCorr.h.

m_vecTransformInDetectorA7R1L

std::vector<double> ALFA_LocRecCorr::m_vecTransformInDetectorA7R1L

private

Definition at line 95 of file ALFA_LocRecCorr.h.

m_vecTransformInDetectorA7R1U

std::vector<double> ALFA_LocRecCorr::m_vecTransformInDetectorA7R1U

private

Definition at line 94 of file ALFA_LocRecCorr.h.

m_vecTransformInDetectorB7L1L

std::vector<double> ALFA_LocRecCorr::m_vecTransformInDetectorB7L1L

private

Definition at line 89 of file ALFA_LocRecCorr.h.

m_vecTransformInDetectorB7L1U

std::vector<double> ALFA_LocRecCorr::m_vecTransformInDetectorB7L1U

private

Definition at line 88 of file ALFA_LocRecCorr.h.

m_vecTransformInDetectorB7R1L

std::vector<double> ALFA_LocRecCorr::m_vecTransformInDetectorB7R1L

private

Definition at line 93 of file ALFA_LocRecCorr.h.

m_vecTransformInDetectorB7R1U

std::vector<double> ALFA_LocRecCorr::m_vecTransformInDetectorB7R1U

private

Definition at line 92 of file ALFA_LocRecCorr.h.

m_vecTransformInStationA7L1L

std::vector<double> ALFA_LocRecCorr::m_vecTransformInStationA7L1L

private

Definition at line 99 of file ALFA_LocRecCorr.h.

m_vecTransformInStationA7L1U

std::vector<double> ALFA_LocRecCorr::m_vecTransformInStationA7L1U

private

Definition at line 98 of file ALFA_LocRecCorr.h.

m_vecTransformInStationA7R1L

std::vector<double> ALFA_LocRecCorr::m_vecTransformInStationA7R1L

private

Definition at line 103 of file ALFA_LocRecCorr.h.

m_vecTransformInStationA7R1U

std::vector<double> ALFA_LocRecCorr::m_vecTransformInStationA7R1U

private

Definition at line 102 of file ALFA_LocRecCorr.h.

m_vecTransformInStationB7L1L

std::vector<double> ALFA_LocRecCorr::m_vecTransformInStationB7L1L

private

Definition at line 97 of file ALFA_LocRecCorr.h.

m_vecTransformInStationB7L1U

std::vector<double> ALFA_LocRecCorr::m_vecTransformInStationB7L1U

private

Definition at line 96 of file ALFA_LocRecCorr.h.

m_vecTransformInStationB7R1L

std::vector<double> ALFA_LocRecCorr::m_vecTransformInStationB7R1L

private

Definition at line 101 of file ALFA_LocRecCorr.h.

m_vecTransformInStationB7R1U

std::vector<double> ALFA_LocRecCorr::m_vecTransformInStationB7R1U

private

Definition at line 100 of file ALFA_LocRecCorr.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• ALFA_LocRecCorr.h
• ALFA_LocRecCorr.cxx