InDetAlignDBTool Class Reference

#include <InDetAlignDBTool.h>

Inheritance diagram for InDetAlignDBTool:

Collaboration diagram for InDetAlignDBTool:

Public Member Functions
	InDetAlignDBTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~InDetAlignDBTool ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual void	createDB () const override
virtual void	dispGroup (const int dettype, const int bec, const int layer, const int ring, const int sector, const float rphidisp, const float rdisp, const float zdisp, const int syst, const int level, const int skip) const override
virtual void	writeFile (const bool ntuple, const std::string &file) const override
virtual void	writeIBLDistFile (const std::string &file) const override
virtual void	writeGlobalFolderFile (const std::string &file) const override
virtual void	readTextFile (const std::string &file) const override
virtual void	readNtuple (const std::string &file) const override
virtual bool	idToDetSet (const Identifier ident, int &det, int &bec, int &layer, int &ring, int &sector, int &side) const override
virtual std::string	dirkey (const Identifier &, const int) const override
virtual std::string	dirkey (const int, const int, const int, const int) const override
virtual std::string	dirkey (const int, const int, const int, const int, const int) const override
virtual std::string	DBMkey (const int, const int, const int, const int) const override
virtual bool	setTrans (const Identifier &ident, const int level, const Amg::Transform3D &trans) const override
virtual bool	setTrans (const Identifier &ident, const int level, const Amg::Vector3D &translate, double alpha, double beta, double gamma) const override
virtual bool	tweakTrans (const Identifier &ident, const int level, const Amg::Transform3D &trans) const override
virtual bool	tweakTrans (const Identifier &ident, const int level, const Amg::Vector3D &translate, double alpha, double beta, double gamma) const override
virtual bool	tweakIBLDist (const int, const float) const override
	This is the tweak function for the IBLDist DB. More...
virtual bool	tweakGlobalFolder (const Identifier &ident, const int level, const Amg::Transform3D &trans) const
	This is the tweak function for the GlobalFolder DB. More...
virtual Identifier	getL1L2fromL3Identifier (const Identifier &ident, const int &level) const override
	convert L3 module identifier to L1 or L2 More...
virtual Amg::Transform3D	getTransL123 (const Identifier &ident) const override
	get cumulative L1, L2, L3 trafo for (L3-) module. More...
virtual Amg::Transform3D	getTrans (const Identifier &ident, const int level) const override
	return value of particular transform specified by identifier and level calculates L1 and L2 identifiers automatically by getL1L2fromL3Identifier if L3 identifier passed. More...
virtual StatusCode	outputObjs () override
virtual void	fillDB (const std::string &tag, const unsigned int run1, const unsigned int event1, const unsigned int run2, const unsigned int event2) const override
virtual void	printDB (const int level) const override
virtual void	sortTrans () const override
void	extractAlphaBetaGamma (const Amg::Transform3D &trans, double &alpha, double &beta, double &gamma) const override
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
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. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
AlignableTransform *	getTransPtr (const std::string &key) const
const AlignableTransform *	cgetTransPtr (const std::string &key) const
void	fakeGeom (const int nbpix, const int necpix, const int nbsct, const int necsct)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
const PixelID *	m_pixid
const SCT_ID *	m_sctid
const InDetDD::PixelDetectorManager *	m_pixman
const InDetDD::SCT_DetectorManager *	m_sctman
std::vector< const InDetDD::SiDetectorManager * >	m_managers
std::vector< std::string >	m_alignobjs
std::vector< int >	m_alignchans
CondAttrListCollection *	m_attrListCollection
bool	m_par_newdb
bool	m_par_scttwoside
int	m_par_fake
ToolHandle< IAthenaOutputStreamTool >	m_par_condstream
Gaudi::Property< std::string >	m_par_dbroot { this, "AlignmentRootFolder", "/Indet/Align", "Root folder for alignment" }
	name of the root folder for constants, which can be set via the <key> syntax. More...
std::string	m_par_dbkey
	the base part of the key for loading AlignableTransform objects from the Transient Data Store. More...
bool	m_par_oldTextFile
bool	m_dynamicDB
bool	m_forceUserDBConfig
Gaudi::Property< std::string >	m_pixmanName {this, "PixelManager", "Pixel", "Pixel manager name" }
Gaudi::Property< std::string >	m_sctmanName {this, "SCT_Manager", "SCT", "SCT manager name" }
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 53 of file InDetAlignDBTool.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

InDetAlignDBTool()

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

Definition at line 60 of file InDetAlignDBTool.cxx.

  : AthAlgTool(type,name,parent),
    m_pixid(nullptr),
    m_sctid(nullptr),
    m_pixman(nullptr),
    m_sctman(nullptr),
    m_attrListCollection(nullptr),
    m_par_newdb(true),
    m_par_scttwoside(false),
    m_par_fake(0),
    m_par_condstream("AthenaOutputStreamTool/AthenaOutputStreamTool", this),
    m_par_dbroot( "/Indet/Align" ),
    m_par_dbkey( "/Indet/Align" ),
    m_par_oldTextFile(false),
    m_dynamicDB(false),
    m_forceUserDBConfig(false)
{
  declareInterface<IInDetAlignDBTool>(this);
  declareProperty("NewDB",       m_par_newdb);     //Take out at some point; New is misleading!! Very old developments!
  declareProperty("SCTTwoSide",  m_par_scttwoside);
  declareProperty("FakeDB",      m_par_fake);
  declareProperty("CondStream",  m_par_condstream);
  declareProperty("DBRoot",      m_par_dbroot,"name of the root folder for constants");
  declareProperty("DBKey",       m_par_dbkey,"base part of the key for loading AlignableTransforms");
  declareProperty("OldTextFile", m_par_oldTextFile);
  declareProperty("forceUserDBConfig",m_forceUserDBConfig, "Set to true to override any DB auto-configuration");
}

~InDetAlignDBTool()

InDetAlignDBTool::~InDetAlignDBTool ( )

virtual

Definition at line 89 of file InDetAlignDBTool.cxx.

{}

Member Function Documentation

cgetTransPtr()

const AlignableTransform * InDetAlignDBTool::cgetTransPtr ( const std::string &  key ) const

private

Definition at line 1336 of file InDetAlignDBTool.cxx.

        {
  // look in collection to retrieve pointer to AlignableTransform object of 
  // given key and return it, return 0 if not collection or key value not found
  // const version
  const AlignableTransformContainer* patc;
  const AlignableTransform* pat=nullptr;
  if (m_par_newdb) {
    if (StatusCode::SUCCESS==detStore()->retrieve(patc,m_par_dbroot )) {
      for (DataVector<AlignableTransform>::const_iterator dva=patc->begin();
     dva!=patc->end();++dva) {
        if ((*dva)->tag()==key) {
    pat=*dva;
    break;
  }
      }
    }
  } else {
    if (StatusCode::SUCCESS!=detStore()->retrieve(pat,key)) pat=nullptr;
  }
  return pat;
}

createDB()

void InDetAlignDBTool::createDB ( ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 253 of file InDetAlignDBTool.cxx.

{
  
  ATH_MSG_DEBUG("createDB method called");
  // check not running in fake mode (need real geometry here)
  if (m_par_fake) {
    ATH_MSG_FATAL("Cannot create new database when geometry is faked");
  }
  AlignableTransform* pat;
  AlignableTransformContainer* patc=nullptr;
  // loop over all SiDetectorElements (pixel and SCT) and fill corresponding
  // AlignableTransform objects with default values
 
  // first create the empty AlignableTransform objects in TDS
  if (m_par_newdb) {
    // check object does not already exist
    if (detStore()->contains<AlignableTransformContainer>(m_par_dbroot)) {
      ATH_MSG_ERROR("createDB: AlignableTransformContainer already exists");
      return;
    }
    // put them in a collection /Indet/Align
    ATH_MSG_DEBUG( "Setup database structures in AlignableTransformContainer");
    patc=new AlignableTransformContainer;
  } 
  else {
    ATH_MSG_DEBUG( "Setup separate AlignableTransform for each layer");
  }
 
  if (msgLvl(MSG::DEBUG)) {
    if (m_par_scttwoside) ATH_MSG_DEBUG( "Produce separate transforms for each side of SCT modules" );
    else ATH_MSG_DEBUG( "Treat both sides of SCT module as single entity" );
  }
 
  for (unsigned int i=0;i<m_alignobjs.size();++i) {
    pat=new AlignableTransform(m_alignobjs[i]);
    if (m_par_newdb) {
      // add to collection and set corresponding channel number
      patc->push_back(pat);
      patc->add(m_alignchans[i]);
    } else {
      // store directly in SG
      // first check object not already there
      if (detStore()->contains<AlignableTransform>(m_alignobjs[i])) {
        ATH_MSG_FATAL( "create DB: AlignableTransform " << m_alignobjs[i] << " already exists" );
        delete pat;
        pat=nullptr;
        return;
      }
      if (StatusCode::SUCCESS!=detStore()->record(pat,m_alignobjs[i]))
        ATH_MSG_ERROR( "Could not record AlignableTransform "<< m_alignobjs[i] );
    }
  }
  if (m_par_newdb) {
    // record collection in SG
    if (StatusCode::SUCCESS!=detStore()->record(patc,m_par_dbroot))
        ATH_MSG_ERROR("Could not record AlignableTransformContainer");
    ATH_MSG_DEBUG( "Collection has size " <<  patc->size() );
  }
 
  // now loop over all detector modules and add null level 3 transforms
  std::vector<std::string> level2;
  for (const InDetDD::SiDetectorManager * manager: m_managers) {
      const InDetDD::SCT_DetectorManager * testSCT = nullptr;
      const InDetDD::PixelDetectorManager * testPixel = nullptr;
      testPixel = dynamic_cast<const InDetDD::PixelDetectorManager *>(manager);
      if(!testPixel) testSCT = dynamic_cast<const InDetDD::SCT_DetectorManager *>(manager);
      for (const InDetDD::SiDetectorElement* element: *manager->getDetectorElementCollection()) {
            if (element!=nullptr) {
                const Identifier ident=element->identify();
                std::string key=dirkey(ident,3);
                // do not produce AlignableTrasnforms for SCT side 1 if option set
                if (!(m_sctid && m_sctid->is_sct(ident) && m_sctid->side(ident)==1) || m_par_scttwoside) {
                    if ((pat=getTransPtr(key))) {
                        pat->add(ident,Amg::EigenTransformToCLHEP( Amg::Transform3D::Identity() ) );
                    } 
                else ATH_MSG_ERROR( "Cannot retrieve AlignableTransform for key " << key );
                }
                // add level 2 transform if needed - do this the first time a module
                // for this level 3 key is seen
                std::vector<std::string>::const_iterator ix = find(level2.begin(),level2.end(),key);
                if (ix==level2.end()) {
                    level2.push_back(key);
                    // construct identifier of level 2 transform
                    Identifier ident2;
                    if(testPixel){
                        if (m_pixid->is_pixel(ident)) {
                            ident2=m_pixid->wafer_id(m_pixid->barrel_ec(ident), m_pixid->layer_disk(ident),
                            m_pixid->phi_module(ident),0); // needed to be extended to phi-module due to DBM
                        }
                    } 
                    if(testSCT){
                        if (m_sctid->is_sct(ident)) {
                            ident2=m_sctid->wafer_id(m_sctid->barrel_ec(ident), m_sctid->layer_disk(ident),0,0,0);
                        }
                    }
                    std::string key2=dirkey(ident,2);
                    if ((pat=getTransPtr(key2))) {
                        pat->add(ident2,Amg::EigenTransformToCLHEP( Amg::Transform3D::Identity() ) );
                    } else ATH_MSG_ERROR( "Cannot retrieve AlignableTransform for key " << key2 );
                }
            }
      }
  }
  // create the global ID object with positions for the pixels (one unit)
  // and SCT barrel/endcap
  Identifier ident1;
  std::string key1=dirkey(ident1,1);
  if ((pat=getTransPtr(key1))) {
    Amg::Transform3D globshift;
    globshift.setIdentity();
    if(m_pixid){
        // pixel - barrel and endcap as one, treated as barrel layer 0 module 0
        ident1=m_pixid->wafer_id(0,0,0,0);
        pat->add(ident1,Amg::EigenTransformToCLHEP(globshift));
    }
    if(m_sctid){
        // SCT barrel - barrel 0 module 0
        ident1=m_sctid->wafer_id(0,0,0,0,0);
        pat->add(ident1,Amg::EigenTransformToCLHEP(globshift));
        // SCT endcaps A and C
        ident1=m_sctid->wafer_id(-2,0,0,0,0);
        pat->add(ident1,Amg::EigenTransformToCLHEP(globshift));
        ident1=m_sctid->wafer_id(2,0,0,0,0);
        pat->add(ident1,Amg::EigenTransformToCLHEP(globshift));
    }
  } else {
    ATH_MSG_ERROR( "Cannot retrieve AlignableTransform for key " << key1 );
  }
  // sort the created objects (in case, usually come out sorted from GeoModel)
  sortTrans();
  // list out size of all created objects
  ATH_MSG_DEBUG( "Dumping size of created AlignableTransform objects");
  for (unsigned int i=0;i<m_alignobjs.size();++i)
    if ((pat=getTransPtr(m_alignobjs[i]))) pat->print();
}

DBMkey()

std::string InDetAlignDBTool::DBMkey ( const int  det, const int  bec, const int  level, const int  sector  ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 479 of file InDetAlignDBTool.cxx.

                                                                              {
  // given SCT/pixel det/bec/layer/sector, and level (1,2 or 3) return
  // additional directory key name for associated DBM alignment
  std::ostringstream result;
  if (det==1 && level==3 && abs(bec)==2) { // slightly unnecessary check
    if (bec==2) result << "EADBM";
    if (bec==-2) result << "ECDBM";
    result << 1+sector;
  }
  return result.str();
}

declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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());
 
  }

declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  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.

{ return m_detStore; }

dirkey() [1/3]

std::string InDetAlignDBTool::dirkey ( const Identifier &  ident, const int  level  ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 416 of file InDetAlignDBTool.cxx.

                                    {
  // given SCT or pixel identifier, and level (1,2 or 3) return
  // directory key name for associated alignment data
  int det,bec,layer,ring,sector,side;
  idToDetSet(ident,det,bec,layer,ring,sector,side);
  return dirkey(det,bec,layer,level,sector);
}

dirkey() [2/3]

std::string InDetAlignDBTool::dirkey ( const int  det, const int  bec, const int  layer, const int  level  ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 427 of file InDetAlignDBTool.cxx.

                                               {
  // given SCT/pixel det/bec/layer, and level (1,2 or 3) return
  // directory key name for associated alignment data
  std::ostringstream result;
  result << m_par_dbkey << "/" ;
  if (level==1) {
    result << "ID";
  } else {
    if (det==1) result << "PIX";
    if (det==2) result << "SCT";
    if (level==3) {
      if (bec==1) result << "EA";
      if (bec==0) result << "B";
      if (bec==-1) result << "EC";
      result << 1+layer;
    }
  }
  return result.str();
}

dirkey() [3/3]

std::string InDetAlignDBTool::dirkey ( const int  det, const int  bec, const int  layer, const int  level, const int  sector  ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 448 of file InDetAlignDBTool.cxx.

                                                                                         {
  // given SCT/pixel det/bec/layer/sector, and level (1,2 or 3) return
  // directory key name for associated alignment data
  std::ostringstream result;
  if (m_dynamicDB){
    result << "/Indet/AlignL";
    result << level;
    result << "/" ;          // new folders have L1, L2, L3 structure
  }
  else{
    result << m_par_dbkey << "/" ;
  }
  if (level==1) {
    result << "ID";
  } else {
    if (det==1) result << "PIX";
    if (det==2) result << "SCT";
    if (level==3) {
      if (det==1 && abs(bec)==2) result << DBMkey(det,bec,level,sector);
      else {
        if (bec==1) result << "EA";
        if (bec==0) result << "B";
        if (bec==-1) result << "EC";
        result << 1+layer;
      }
    }
  }
  return result.str();
}

dispGroup()

void InDetAlignDBTool::dispGroup ( const int  dettype, const int  bec, const int  layer, const int  ring, const int  sector, const float  rphidisp, const float  rdisp, const float  zdisp, const int  syst, const int  level, const int  skip  ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 496 of file InDetAlignDBTool.cxx.

                                                                                        {
 
  ATH_MSG_DEBUG( "dispGroup called: level " << level << " syst " << syst);
  int nmod=0;
  // random number service
  IRndmGenSvc* randsvc;
  if (StatusCode::SUCCESS!=service("RndmGenSvc",randsvc,true))
    ATH_MSG_ERROR("Cannot find RndmGenSvc" );
  Rndm::Numbers gauss(randsvc,Rndm::Gauss(0.,1.));
  if (skip>0) {
    ATH_MSG_DEBUG("Skip random numbers " << skip ); 
    for (int i=0;i<skip;++i) gauss();
  }
  // for syst 5, choose random shifts based on the input numbers
  float rpd=0,rd=0,zd=0;
  if (syst==5) {
    rpd=rphidisp*gauss();
    rd=rdisp*gauss();
    zd=zdisp*gauss();
  } 
  // keep a list of level1/2 transform IDs to make sure they are only set once
  std::vector<Identifier> lvl12id;
  // loop over all pixel and SCT modules
  AlignableTransform* pat;
  for (int idet=1;idet<3;++idet) {
    for (const InDetDD::SiDetectorElement* element: *(idet==1 ? m_pixman->getDetectorElementCollection() : m_sctman->getDetectorElementCollection())) {
      if (element!=nullptr) {
        const Identifier ident=element->identify();
        int mdet,mbec,mlayer,mring,msector,mside;
        idToDetSet(ident,mdet,mbec,mlayer,mring,msector,mside);
        // find matching modules - note side=1 modules never touched
        if ((dettype==-1 || mdet==dettype) && (bec==-1 || std::abs(2*mbec)==bec) &&
            (layer==-1 || mlayer==layer) && (ring==-1 || mring==ring) && 
            (sector== -1 || msector==sector) && mside==0) {
          // displace this module - first choose displacement type
          // dont choose new displacements if seeing second side of SCT module
          // ensures they both move together
          // depends on the side1 module immediatly following side 0 in list
          // which is currently the case - fragile
          // also for syst 6 choose number only for new ring (eta) slice
          if (dettype!=2 || mside!=1) {
            if (syst==2 || syst==4 || (syst==6 && mring==-6)) {
              rpd=rphidisp*gauss();
              rd=rdisp*gauss();
              zd=zdisp*gauss();
              if (syst==6) ATH_MSG_DEBUG("New rndm at layer/ring " << 
                                         mlayer << " " << mring << " z " << zd );
            } else if (syst<5) {
              rpd=rphidisp;
              rd=rdisp;
              zd=zdisp;
            }
          }
          // interpretation as rphi/r or x/y
          float xd,yd;
          if (syst<=2 || syst==6) {
            // rphi displacement - calculate from module position in x/y
            const Amg::Vector3D modcent=element->center();
            float dx=modcent.x();
            float dy=modcent.y();
            float dr=std::sqrt(dx*dx+dy*dy);
                  xd=(rd*dx-rpd*dy)/dr;
            yd=(rd*dy+rpd*dx)/dr;
          } else {
            xd=rpd;
            yd=rd;
          }
          // find the corresponding AlignableTransform object
          std::string key=dirkey(mdet,mbec,mlayer,level);
          // first get as const as transforms might have been read in
          const AlignableTransform* cpat=cgetTransPtr(key);
                pat=const_cast<AlignableTransform*>(cpat);
          if (pat) {
            Identifier ident2;
            bool update=true;
            if (level==3) {
              ident2=ident;
            } else if (level==2) {
              // identifier for layer in level 2 transform
              if (mdet==1) {
                ident2=m_pixid->wafer_id(m_pixid->barrel_ec(ident),
                       m_pixid->layer_disk(ident),0,0);
              } else {
                ident2=m_sctid->wafer_id(m_sctid->barrel_ec(ident),
                 m_sctid->layer_disk(ident),0,0,0);
              }
              // check this identifier has not been updated before
              std::vector<Identifier>::const_iterator ix=
                find(lvl12id.begin(),lvl12id.end(),ident2);
              if (ix==lvl12id.end()) {
                lvl12id.push_back(ident2);
              } else {
                update=false;
              }
            } else {
              // identifier for ID 
              if (mdet==1) {
                ident2=m_pixid->wafer_id(0,0,0,0);
              } else {
                ident2=m_sctid->wafer_id(0,0,0,0,0);
              }
              // check this identifier has not been updated before
              std::vector<Identifier>::const_iterator ix=
                find(lvl12id.begin(),lvl12id.end(),ident2);
              if (ix==lvl12id.end()) {
                lvl12id.push_back(ident2);
              } else {
                update=false;
              }
            }
            // update, adding to any existing shift
            if (update) {
            
              Amg::Transform3D shift =   Amg::Translation3D(xd,yd,zd) * Amg::RotationMatrix3D::Identity(); 
              pat->tweak(ident2,Amg::EigenTransformToCLHEP(shift));
              ATH_MSG_VERBOSE( "Updated module " << mdet << "," << mbec 
                               << "," << mlayer << "," << mring << "," << msector << " to xyz" <<
                               xd << "," << yd << "," << zd );
                                ++nmod;
            }
          } else {
            ATH_MSG_ERROR("Cannot find AlignableTransform for key" << key );
          }
        }
      }
    }
  }
 ATH_MSG_DEBUG( "Added displacement to " << nmod << " modules " << dettype << "," 
             << bec << "," << layer << " [" << rphidisp << "," << rdisp 
             << "," << zdisp << "]"
             << " type " << syst );
}

evtStore() [1/2]

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.

{ return m_evtStore; }

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

extractAlphaBetaGamma()

void InDetAlignDBTool::extractAlphaBetaGamma ( const Amg::Transform3D &  trans, double &  alpha, double &  beta, double &  gamma  ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 1427 of file InDetAlignDBTool.cxx.

{
  double siny = trans(0,2);
  beta = asin(siny);
  // Check if cosy = 0. This requires special treatment.
  // can check either element (1,2),(2,2) both equal zero
  // or (0,1) and (0,0)
  // Probably not likely it will be exactly 0 and may still 
  // have some problems when very close to zero. We mostly
  // deal with small rotations so its not too important.
  if ((trans(1,2) == 0) && (trans(2,2) == 0)) {
    // alpha and gamma are degenerate. We arbitrarily choose
    // gamma = 0.
    gamma = 0;
    alpha = atan2(trans(1,1),trans(2,1));
  } else {
    alpha = atan2(-trans(1,2),trans(2,2));
    gamma = atan2(-trans(0,1),trans(0,0));
    if (alpha == 0) alpha = 0; // convert -0 to 0
    if (gamma == 0) gamma = 0; // convert -0 to 0
  }
}

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

fakeGeom()

void InDetAlignDBTool::fakeGeom ( const int  nbpix, const int  necpix, const int  nbsct, const int  necsct  )

private

Definition at line 1359 of file InDetAlignDBTool.cxx.

                                           {
  // set alignment keys for fake geometry with given numbers of 
  // barrel/endcap PIX/SCT layers
  // this code is somewhat fragile, trying to reproduce the order of
  // keys in the same way that GeoModel returns them
  // will not work for layouts with missing middle pixel layer
 
  int ichan3=200;
  // level 1 object - ID
  m_alignobjs.push_back(dirkey(1,0,0,1));
  m_alignchans.push_back(0);
  // level 2 objects - pixel
  if (nbpix!=0 || necpix!=0) {
    m_alignobjs.push_back(dirkey(1,0,0,2));
    m_alignchans.push_back(100);
  }
  // level 3 objects - pixel
  // objects done in this order to get COOL channels correct
  // endcap A pixel
  for (int i=0;i<necpix;++i) {
    m_alignobjs.push_back(dirkey(1,-1,i,3));
    m_alignchans.push_back(ichan3++);
  }
  // barrel pixel
  for (int i=0;i<nbpix;++i) {
    m_alignobjs.push_back(dirkey(1,0,i,3));
    m_alignchans.push_back(ichan3++);
  }
  // endcap C pixel
  for (int i=0;i<necpix;++i) {
    m_alignobjs.push_back(dirkey(1,1,i,3));
    m_alignchans.push_back(ichan3++);
  }
  // level 2 objects - SCT
  if (nbsct!=0 || necsct!=0) {
    m_alignobjs.push_back(dirkey(2,0,0,2));
    m_alignchans.push_back(101);
  }
  // level 3 objects - SCT
  // endcap A SCT
  for (int i=0;i<necsct;++i) {
    m_alignobjs.push_back(dirkey(2,-1,i,3));
    m_alignchans.push_back(ichan3++);
  }
  // barrel SCT
  for (int i=0;i<nbsct;++i) {
    m_alignobjs.push_back(dirkey(2,0,i,3));
    m_alignchans.push_back(ichan3++);
  }
  // endcap C SCT
  for (int i=0;i<necsct;++i) {
    m_alignobjs.push_back(dirkey(2,1,i,3));
    m_alignchans.push_back(ichan3++);
  }
}

fillDB()

void InDetAlignDBTool::fillDB ( const std::string &  tag, const unsigned int  run1, const unsigned int  event1, const unsigned int  run2, const unsigned int  event2  ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 1233 of file InDetAlignDBTool.cxx.

                                                                      {
  
  ATH_MSG_DEBUG( "fillDB: Data tag " << tag );
  ATH_MSG_DEBUG( "Run/evt1 [" << run1 << "," << event1 << "]" );
  ATH_MSG_DEBUG("Run/evt2 [" << run2 << "," << event2 << "]" );
 
  // get pointer to registration svc
  IIOVRegistrationSvc* regsvc;
  if (StatusCode::SUCCESS!=
      service("IOVRegistrationSvc",regsvc)) {
    ATH_MSG_FATAL( "IOVRegistrationSvc not found" );
    return;
  }
  // loop over all AlignableTransform objects created earlier and save them
  int nobj=0; 
  if (m_par_newdb) {
    if (StatusCode::SUCCESS==regsvc->registerIOV(
             "AlignableTransformContainer",m_par_dbroot,tag,run1,run2,event1,event2)) {
      ATH_MSG_DEBUG( "Stored AlignableTransform object " << m_par_dbroot );
      ++nobj;
    } else {
      ATH_MSG_ERROR("Failed (registerIOV) to store object " << m_par_dbroot );
    }
  } else {
    // old way - register all objects separately
    for (std::vector<std::string>::const_iterator iobj=m_alignobjs.begin();
      iobj!=m_alignobjs.end();++iobj) {
      if (StatusCode::SUCCESS==regsvc->registerIOV("AlignableTransform",
               *iobj,tag,run1,run2,event1,event2)) {
        ATH_MSG_DEBUG( "Stored AlignableTransform object " << *iobj );
        ++nobj;
      } else {
        ATH_MSG_ERROR("Failed (registerIOV) to store object " << *iobj );
      }
    }
  }
  ATH_MSG_DEBUG( " Written " << nobj << " AlignableTransform objects to conditions database" );
}

finalize()

StatusCode InDetAlignDBTool::finalize ( )

overridevirtual

Definition at line 247 of file InDetAlignDBTool.cxx.

{
  ATH_MSG_DEBUG( "InDetAlignDBTool finalize method called" );
  return StatusCode::SUCCESS;
}

getL1L2fromL3Identifier()

Identifier InDetAlignDBTool::getL1L2fromL3Identifier ( const Identifier &  ident, const int &  level  ) const

overridevirtual

convert L3 module identifier to L1 or L2

< no translation needed

check whether PIX

< Whole pixel det. at L1

check whether SCT

< barrel + 2 x EC at L1

< take care of the case where level != 1,2,3 or ident neither pix nor sct

Implements IInDetAlignDBTool.

Definition at line 1103 of file InDetAlignDBTool.cxx.

                          {
  if( level == 3 ) return ident ; 
 
  if( m_pixid->is_pixel(ident) ) {
    if( level == 1 ) {
      return m_pixid->wafer_id( 0, 0, 0, 0 ) ; 
    }
    if( level == 2 ) {
      int barrel_ec  = m_pixid->barrel_ec(  ident ) ;
      int layer_disk = m_pixid->layer_disk( ident ) ;
      return m_pixid->wafer_id( barrel_ec, layer_disk, 0, 0 ) ;
    }
  }
  if( m_sctid->is_sct(ident) ) {
    if( level == 1 ) {
      int barrel_ec  = m_sctid->barrel_ec(  ident ) ;
      return m_sctid->wafer_id( barrel_ec, 0, 0, 0, 0 ) ; 
    }
    if( level == 2 ) {
      int barrel_ec  = m_sctid->barrel_ec(  ident ) ;
      int layer_disk = m_sctid->layer_disk( ident ) ;
      return m_sctid->wafer_id( barrel_ec, layer_disk, 0, 0, 0 ) ;
    }
  }
  return ident ; 
}

getTrans()

Amg::Transform3D InDetAlignDBTool::getTrans ( const Identifier &  ident, const int  level  ) const

overridevirtual

return value of particular transform specified by identifier and level calculates L1 and L2 identifiers automatically by getL1L2fromL3Identifier if L3 identifier passed.

return value of particular transform specified by identifier and level calculates L1 and L2 identifiers automatically by getL1L2fromL3Identifier if L3 identifier passed

L1, L2 are in global, L3 in local frame.

Implements IInDetAlignDBTool.

Definition at line 1158 of file InDetAlignDBTool.cxx.

                                   {
  const Identifier identifier = getL1L2fromL3Identifier( ident, level ) ;
  Amg::Transform3D result;
  const std::string key=dirkey(identifier,level);
  const AlignableTransform* pat;
  if ((pat=cgetTransPtr(key))) {
    AlignableTransform::AlignTransMem_citr itr=pat->findIdent(identifier);
    if (itr!=pat->end()) result= Amg::CLHEPTransformToEigen(itr->transform());
  }
  return result;
}

getTransL123()

Amg::Transform3D InDetAlignDBTool::getTransL123 ( const Identifier &  ident ) const

overridevirtual

get cumulative L1, L2, L3 trafo for (L3-) module.

get cumulative L1, L2, L3 trafo for (L3-) module

Result is in local frame.

Implements IInDetAlignDBTool.

Definition at line 1134 of file InDetAlignDBTool.cxx.

                                                                             {
 
  Amg::Transform3D result ;
  InDetDD::SiDetectorElement* element = m_pixman->getDetectorElement( ident ) ;
  if( !element ) {
    element = m_sctman->getDetectorElement( ident ) ;
  }
  if( !element ) {
    ATH_MSG_ERROR("getTransL123(): Module not found in PIX or SCT!" );
    return result ;
  }
  Amg::Transform3D trfL1 = getTrans( ident, 1 ) ;
  Amg::Transform3D trfL2 = getTrans( ident, 2 ) ;
  Amg::Transform3D trfL3 = getTrans( ident, 3 ) ;
  ATH_MSG_FATAL("Code needs to corrected otherwise you will get nonsensical results-- IndetAlignDBTool:2060");
  //const Amg::Transform3D trfNominal   ; //= element->defModuleTransform() ;
  //result = trfNominal.inverse() * trfL1 * trfL2 * trfNominal * trfL3 ;
  result = trfL1 * trfL2 * trfL3 ;
  return result ;
}

getTransPtr()

AlignableTransform * InDetAlignDBTool::getTransPtr ( const std::string &  key ) const

private

Definition at line 1314 of file InDetAlignDBTool.cxx.

        {
  // look in collection to retrieve pointer to AlignableTransform object of 
  // given key and return it, return 0 if not collection or key value not found
  AlignableTransformContainer* patc;
  AlignableTransform* pat=nullptr;
  if (m_par_newdb) {
    if (StatusCode::SUCCESS==detStore()->retrieve(patc,m_par_dbroot )) {
      for (DataVector<AlignableTransform>::iterator dva=patc->begin();
     dva!=patc->end();++dva) {
        if ((*dva)->tag()==key) {
    pat=*dva;
    break;
  }
      }
    }
  } else {
    if (StatusCode::SUCCESS!=detStore()->retrieve(pat,key)) pat=nullptr;
  }
  return pat;
}

idToDetSet()

bool InDetAlignDBTool::idToDetSet ( const Identifier  ident, int &  det, int &  bec, int &  layer, int &  ring, int &  sector, int &  side  ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 389 of file InDetAlignDBTool.cxx.

                                                               {
  // transform Identifier to list of integers specifiying dettype,bec,layer
  // ring, sector, side
  // note bec is +-1 or 0, not +-2 as returned by idenfitiers
 
  bool resok=false;
  if (m_pixman && m_pixid->is_pixel(ident)) {
    det=1;
    bec=m_pixid->barrel_ec(ident)/2;
    layer=m_pixid->layer_disk(ident);
    ring=m_pixid->eta_module(ident);
    sector=m_pixid->phi_module(ident);
    side=0;
    resok=true;
  } else if (m_sctman && m_sctid->is_sct(ident)) {
    det=2;
    bec=m_sctid->barrel_ec(ident)/2;
    layer=m_sctid->layer_disk(ident);
    ring=m_sctid->eta_module(ident);
    sector=m_sctid->phi_module(ident);
    side=m_sctid->side(ident);
    resok=true;
  }
  return resok;
}

initialize()

StatusCode InDetAlignDBTool::initialize ( )

overridevirtual

Definition at line 92 of file InDetAlignDBTool.cxx.

{
  
  ATH_MSG_DEBUG("InDetAlignDBTool initialize instance: " << name() );
  
  // get storegate access to conditions store
  if (detStore().retrieve().isFailure()){ 
    ATH_MSG_FATAL("Detector store not found");
  }
 
  if ( m_par_condstream.retrieve().isFailure() ) {
    ATH_MSG_FATAL( "Failed to retrieve AthenaOutputStreamTool");
    return StatusCode::FAILURE;
  } else 
    ATH_MSG_DEBUG( "Retrieved AthenaOutputStreamTool with name" << m_par_condstream.name());
 
  // attempt to get ID helpers from detector store 
  // (relying on GeoModel to put them)
  m_alignobjs.clear();
  m_alignchans.clear();
  int ndet[2];
  ndet[0]=0;
  ndet[1]=0;
 
  //We use the presence of the DetManagers as proxies for whether we run with the detector enabled everywhere
  if (StatusCode::SUCCESS!=detStore()->retrieve(m_pixman,m_pixmanName) || m_pixman==nullptr) {
    ATH_MSG_INFO( "Could not find pixel manager "<<m_pixmanName<<" running without pixel");
  }
  else m_managers.push_back(m_pixman);
 
  if (StatusCode::SUCCESS!=detStore()->retrieve(m_sctman,m_sctmanName) || m_sctman==nullptr) {
    ATH_MSG_INFO("Could not find SCT manager "<<m_sctmanName<<" running without SCT/Strip");
  }
  else m_managers.push_back(m_sctman);
 
  if(m_pixman){  
      if (m_pixman->m_alignfoldertype == InDetDD::static_run1 && !m_forceUserDBConfig){
        m_dynamicDB = false;
      }
      if (m_pixman->m_alignfoldertype == InDetDD::timedependent_run2 && !m_forceUserDBConfig){
        m_par_dbroot = "/Indet/AlignL3";
        m_dynamicDB = true;
      }  
  }
 
  if (m_pixman && m_sctman){
      if (m_pixman->m_alignfoldertype!=m_sctman->m_alignfoldertype) {
          ATH_MSG_FATAL("Pixel and SCT Managers have different alignfolder type registered --> Check ");
          return StatusCode::FAILURE;
      }
  }
  
  m_par_dbkey = m_par_dbroot;
 
  if(m_pixman && (detStore()->retrieve(m_pixid).isFailure())) {
    ATH_MSG_FATAL("No Pixel ID Found!");
    return StatusCode::FAILURE;
  }
 
  if(m_sctman && (detStore()->retrieve(m_sctid).isFailure())) {
    ATH_MSG_FATAL("No SCT ID Found!");
    return StatusCode::FAILURE;
  }
 
  //optionally fake up the geometry
  if (m_par_fake==1) {
    ATH_MSG_INFO("Initialising fake full ATLAS geometry");
    fakeGeom(3,3,4,9);
  } else if (m_par_fake==2) {
    ATH_MSG_INFO("Initialising fake CTB geometry");
    fakeGeom(3,0,4,0);
  } else {
    // setup list of alignable transforms from geometry
    int chan[3];
    int TransfLevel_low = 0; // depending on alignfolder sheme; 0 for old, 2 for new
    if (m_dynamicDB) TransfLevel_low = 2;
 
    for (int i=0;i<3;++i) chan[i]=100*i;
    std::string man_name;
    int idet = 0;
    for (auto manager:m_managers) {
      for (const InDetDD::SiDetectorElement* element : * manager->getDetectorElementCollection()) {
        if (element!=nullptr) {
          const Identifier ident=element->identify();
          int det,bec,layer,ring,sector,side;
          if (idToDetSet(ident,det,bec,layer,ring,sector,side)) {
              std::string level[3];
              for (int i=TransfLevel_low;i<3;++i) {  
                level[i]=dirkey(det,bec,layer,1+i,sector);
                // add this to list if not seen already
                std::vector<std::string>::const_iterator ix=
                find(m_alignobjs.begin(),m_alignobjs.end(),level[i]);
                if (ix==m_alignobjs.end()) {
                  m_alignobjs.push_back(level[i]);
                  m_alignchans.push_back(chan[i]++);
                }
              }
              ++ndet[idet];
          } else {
              ATH_MSG_ERROR("Si detector element type " << idet << " has no detset conversion" );
          }
        }
      }
      idet++;
    }
  }
    ATH_MSG_INFO( "Geometry initialisation sees " << ndet[0] << 
      " pixel and " <<  ndet[1] << " SCT modules giving " << m_alignobjs.size() 
    << " alignment keys" );
 
  if (msgLvl(MSG::DEBUG)) {
    ATH_MSG_DEBUG( "Database root folder " << m_par_dbroot );
    ATH_MSG_DEBUG( "Geometry initialisation sees " << ndet[0] << 
      " pixel and " <<  ndet[1] << " SCT modules giving " << m_alignobjs.size() 
    << " alignment keys" );
    ATH_MSG_DEBUG("Keys/channels are:");
    
    for (unsigned int i=0;i<m_alignobjs.size();++i)
      ATH_MSG_DEBUG( " " << m_alignobjs[i] << " [" << m_alignchans[i] << "]" );
    
    if (m_par_newdb)
      ATH_MSG_DEBUG("Assuming new COOL alignment DB model based on AlignableTransformContainer");
    else
      //Do we still use this anywhere? Candidate for removal?
      ATH_MSG_DEBUG("Assuming old (Lisbon) alignment DB model based on separate AlignableTransforms");
  }
 
  // make a new empty CondAttrListCollection with the IBLDist structure:  
  if (m_attrListCollection) delete m_attrListCollection;
  m_attrListCollection = new CondAttrListCollection(true); // not really sure....
  
  coral::AttributeListSpecification* spec = new coral::AttributeListSpecification();
  spec->extend("stave", "int");
  spec->extend("eta", "int");
  spec->extend("mag", "float");
  spec->extend("base", "float");
  spec->extend("free", "float");
 
  const int ibl_stave_max = 14;
  // create a full collection first with NULL entries to ensure fail save operation 
  for (int this_stave=0; this_stave<ibl_stave_max; this_stave++){
 
    coral::AttributeList atrlist(*spec);
    // Set value of each row for the current channel
    atrlist[ "stave" ].data<int>()=this_stave;
    atrlist[ "eta" ].data<int>()=0;
    atrlist[ "mag" ].data<float>()=0;
    atrlist[ "base" ].data<float>()=0;
    atrlist[ "free" ].data<float>()=0;
    m_attrListCollection->add(100*(1+this_stave),atrlist);
  }
 
  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.

interfaceID()

const InterfaceID & IInDetAlignDBTool::interfaceID ( )

inlinestaticinherited

Definition at line 70 of file IInDetAlignDBTool.h.

{ return   IID_INDETALIGN_IInDetAlignDBTool; }

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

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.

outputObjs()

StatusCode InDetAlignDBTool::outputObjs ( )

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 1171 of file InDetAlignDBTool.cxx.

                                        {
  
  ATH_MSG_DEBUG( "Output AlignableTranform objects to stream" << m_par_condstream );
  // get the AthenaOutputStream tool
  
  if (StatusCode::SUCCESS!=m_par_condstream->connectOutput()) {
    ATH_MSG_ERROR("Could not connect stream to output" );
    return StatusCode::FAILURE;
  }else{
    ATH_MSG_DEBUG("Stream is connected to output" );
  }
  // construct list of objects to be written out, either 
  // AlignableTransformContainer or several of AlignableTransforms
  int npairs=m_alignobjs.size();
  if (m_par_newdb) npairs=1;
  IAthenaOutputStreamTool::TypeKeyPairs typekeys(npairs);
  if (m_par_newdb) {
    typekeys[0]=
      IAthenaOutputStreamTool::TypeKeyPair("AlignableTransformContainer",
             m_par_dbroot);
    if (!(detStore()->contains<AlignableTransformContainer>(m_par_dbroot)))
      ATH_MSG_ERROR(
        "Expected " << m_par_dbroot << " object not found" );
  } else {
    for (unsigned int i=0;i<m_alignobjs.size();++i) {
      typekeys[i]=IAthenaOutputStreamTool::TypeKeyPair("AlignableTransform",
                   m_alignobjs[i]);
      if (!(detStore()->contains<AlignableTransform>(m_alignobjs[i]))) 
        ATH_MSG_ERROR("Expected " << m_alignobjs[i] << " object not found" );
    }
  }
  // write objects to stream
  if (StatusCode::SUCCESS!=m_par_condstream->streamObjects(typekeys)) {
  }else{
    ATH_MSG_DEBUG("Streamed output objects" );
  }
 
  {
    // additional IBLDist DB
    ATH_MSG_DEBUG( "starting to register typeKey for IBLDist" );
    IAthenaOutputStreamTool::TypeKeyPairs typekeys_IBLDist(1);
    IAthenaOutputStreamTool::TypeKeyPair pair("CondAttrListCollection", "/Indet/IBLDist");
    typekeys_IBLDist[0] = pair;
    
    // write objects to stream                                                                                                                  
    if (StatusCode::SUCCESS!=m_par_condstream->streamObjects(typekeys_IBLDist)) {
      ATH_MSG_ERROR("Could not stream output IBLDist objects" );
      return StatusCode::FAILURE;
    }else{
      ATH_MSG_DEBUG("Streamed output IBLDist objects" );
    }
 
  }
 
  // commit output
  if (StatusCode::SUCCESS!=m_par_condstream->commitOutput()) {
    ATH_MSG_ERROR("Could not commit output" );
  }
  ATH_MSG_DEBUG( "Written " << typekeys.size() << " objects to stream " << m_par_condstream);
  return StatusCode::SUCCESS;
}

printDB()

void InDetAlignDBTool::printDB ( const int  level ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 1274 of file InDetAlignDBTool.cxx.

                                                    {
  
  ATH_MSG_DEBUG("Printout InDetAlign database contents, detail level" << level );
 
  for (std::vector<std::string>::const_iterator iobj=m_alignobjs.begin();
       iobj!=m_alignobjs.end();++iobj) {
    const AlignableTransform* pat;
    if ((pat=cgetTransPtr(*iobj))) {
      ATH_MSG_DEBUG( "AlignableTransform object " << *iobj );
      int nobj=0;
      for (AlignableTransform::AlignTransMem_citr cit=pat->begin();
        cit!=pat->end();++cit) {
        const Identifier& ident=cit->identify();
        const Amg::Transform3D& trans= Amg::CLHEPTransformToEigen( cit->transform() );
        Amg::Vector3D shift=trans.translation();
        //Amg::RotationMatrix3D rot=trans.rotation();
        int det,bec,layer,ring,sector,side;
        if (idToDetSet(ident,det,bec,layer,ring,sector,side)) {
          if (level>1) {
            double alpha, beta, gamma;
            extractAlphaBetaGamma(trans, alpha, beta, gamma);
            ATH_MSG_DEBUG( "ID [" << det << "," << bec << "," << layer << 
                              "," << ring << "," << sector << "," << side << "] Trans:(" <<
                                shift.x() << "," << shift.y() << "," << shift.z() << ") Rot:{"
                                << alpha << "," << beta << "," << gamma << "}");
          }
          ++nobj;
              } else {
          ATH_MSG_ERROR("Unknown identifier in AlignableTransform" );
        }
      }
      ATH_MSG_DEBUG( "Object contains " << nobj << " transforms" );
    } else {
      ATH_MSG_ERROR( "AlignableTransform " << *iobj << " not found" );
    }
  }
}

readNtuple()

void InDetAlignDBTool::readNtuple ( const std::string &  file ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 957 of file InDetAlignDBTool.cxx.

                                                             {
  ATH_MSG_DEBUG("readNtuple - set alignment constants from ntuple path: " << file );
  INTupleSvc* ntsvc;
  if (StatusCode::SUCCESS!=service("NTupleSvc",ntsvc,true))
    ATH_MSG_ERROR("Cannot find NTupleSvc" );
  const std::string path=file+"/9002";
  NTuplePtr nt(ntsvc,path);
  if (nt) {
    StatusCode sc;
    sc=nt->item( "MODPROP/DetType",nt_dettype);
    sc=nt->item("MODPROP/Bec",nt_bec);
    sc=nt->item("MODPROP/Layer",nt_layer);
    sc=nt->item("MODPROP/Ring",nt_ring);
    sc=nt->item("MODPROP/Sector",nt_sector);
    sc=nt->item("MODPROP/Side",nt_side);
    sc=nt->item("MODPROP/Level",nt_level);
    sc=nt->item("MODPROP/Xofs",nt_xofs);
    sc=nt->item("MODPROP/Yofs",nt_yofs);
    sc=nt->item("MODPROP/Zofs",nt_zofs);
    sc=nt->item("MODPROP/Phi",nt_phi);
    sc=nt->item("MODPROP/Theta",nt_theta);
    sc=nt->item("MODPROP/Psi",nt_psi);
 
    if (sc!=StatusCode::SUCCESS) ATH_MSG_ERROR(
           "Error booking ntuple 9002 contents" );
    int ntrans=0;
    while (nt->read().isSuccess()) {
      Identifier ident=Identifier();
      if (nt_dettype==1) {
        ident=m_pixid->wafer_id(2*nt_bec,nt_layer,nt_sector,nt_ring);
      } else if (nt_dettype==2) {
        ident=m_sctid->wafer_id(2*nt_bec,nt_layer,nt_sector,nt_ring,nt_side);
      } else {
        ATH_MSG_ERROR("Cannot construct identifier for dettype "
              << nt_dettype );
      }
      
      Amg::Translation3D  newtranslation(nt_xofs,nt_yofs,nt_zofs);    
      Amg::Transform3D newtrans = newtranslation * Amg::RotationMatrix3D::Identity();
      newtrans *= Amg::AngleAxis3D(nt_psi, Amg::Vector3D(0.,0.,1.));
      newtrans *= Amg::AngleAxis3D(nt_theta, Amg::Vector3D(0.,1.,0.));
      newtrans *= Amg::AngleAxis3D(nt_phi, Amg::Vector3D(1.,0.,0.));
 
      setTrans(ident,nt_level,newtrans);
      ++ntrans;
    }
    ATH_MSG_DEBUG( "Read " << ntrans << " transforms from ntuple");
  } else {
    ATH_MSG_ERROR( "Problem opening ntuple at path " << path );
  }
}

readTextFile()

void InDetAlignDBTool::readTextFile ( const std::string &  file ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 834 of file InDetAlignDBTool.cxx.

                                                               {
  //  if (m_par_oldTextFile) return readOldTextFile(file);
 
  ATH_MSG_DEBUG("readTextFile - set alignment constants from text file: " << file );
  std::ifstream infile;
  infile.open(file.c_str());
  if (!infile) {
    ATH_MSG_ERROR("Error opening file " << file );
    return;
  }
 
  // loop over lines in file
  int nobj=0;
  int ntrans=0;
 
  std::string channelName; // Channel name
  const AlignableTransform* pat = nullptr;
 
  while (infile) {
    std::string tmpline; 
    std::getline(infile, tmpline);
    if (!infile) break;
 
    // Skip comment line
    if ((tmpline.substr(0,2) == "//") || (tmpline.substr(0,1) == "#")) continue; 
 
    std::istringstream instring(tmpline);
    std::string tmpstr; 
    instring >> tmpstr;
 
    // Skip blank line
    if (tmpstr.empty()) continue;
 
    if (tmpstr[0] == '/') { 
      // Its a valid channel name
      channelName = tmpstr;
      ATH_MSG_DEBUG("Read in AlignableTransform data, key " << channelName );
      // find the AlignableTransform with this key
      pat = nullptr;
      if (!(pat=cgetTransPtr(channelName))) {
  ATH_MSG_ERROR("Cannot find AlignableTransform object for key" 
              << channelName );
      } else {
  nobj++;
      }
    } else {
      // Its a data line
 
      if (!pat) {
        // If pat = 0, then either no channel name was specified or it could not be found.
        ATH_MSG_ERROR("No channel specified. Skipping input " );
 
      } else {
        // normal data
        std::istringstream datastream(tmpline);
  
        int subsystem,dettype,bec,layer,phiModule,etaModule,side;
        float dx,dy,dz,alpha,beta,gamma;
        datastream >> subsystem >> dettype >> bec >> layer >> phiModule >> etaModule >> side >> dx
             >> dy >> dz >> alpha >> beta >> gamma;
  
        if (datastream.fail()) {
          ATH_MSG_ERROR("Error in input" );
        } else {
          alpha *= CLHEP::mrad;
          beta  *= CLHEP::mrad;
          gamma *= CLHEP::mrad;
 
          // construct identifier
          Identifier ident=Identifier();
          if (dettype==1) {
            ident=m_pixid->wafer_id(bec,layer,phiModule,etaModule);
          } else if (dettype==2) {
            ident=m_sctid->wafer_id(bec,layer,phiModule,etaModule,side);
          } else {
            ATH_MSG_ERROR("Cannot construct identifier for dettype "
                  << dettype );
          }
          if (!ident.is_valid()) {
            ATH_MSG_ERROR("Error in identifier : " <<
                    " [" << subsystem << "," << dettype << "," << bec << "," << layer << "," << 
                    phiModule << "," << etaModule << "," << side << "] key " << channelName << 
                    " shift [" << dx << "," << dy << "," << dz << "]" );
          } else {
 
            // construct new transform
            // Order of rotations is defined as around z, then y, then x.
            // For small angles it doesn't really matter though.
            Amg::Translation3D  newtranslation(dx,dy,dz);   
            Amg::Transform3D newtrans = newtranslation * Amg::RotationMatrix3D::Identity();
            newtrans *= Amg::AngleAxis3D(gamma, Amg::Vector3D(0.,0.,1.));
            newtrans *= Amg::AngleAxis3D(beta, Amg::Vector3D(0.,1.,0.));
            newtrans *= Amg::AngleAxis3D(alpha, Amg::Vector3D(1.,0.,0.));
    
      
      
            // find pointer to existing transform, currently missing write access
            // via findIdent, so have to search manually
            AlignableTransform* pat2;
            pat2=const_cast<AlignableTransform*>(pat);
            AlignableTransform::AlignTransMem_itr itr=pat2->mbegin();
            while ((itr->identify()!=ident) && (itr!=pat2->mend())) ++itr;
            if (itr!=pat2->mend()) {
              ++ntrans;
              itr->setTransform( Amg::EigenTransformToCLHEP(newtrans) );
              ATH_MSG_VERBOSE (  "Set transform done");
            } else {
              ATH_MSG_WARNING("Cannot find existing transform for");
            }
            // Can uses either id helper
            ATH_MSG_DEBUG(m_pixid->show_to_string(ident)  << " key " << channelName << 
                          " shift [" << dx << "," << dy << "," << dz << "]" );
          }
        } //  end if (datastream.fail())  
      } // end if (!pat)
    } // end if (tmpstr[0] == '/')  
  } // end while (infile) 
 
  infile.close();
  ATH_MSG_DEBUG( "Read " << nobj << " objects from file with " << ntrans << " transforms" ); 
}

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();
  }

setTrans() [1/2]

bool InDetAlignDBTool::setTrans ( const Identifier &  ident, const int  level, const Amg::Transform3D &  trans  ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 1009 of file InDetAlignDBTool.cxx.

                                           {
 
  bool result=false;
 
  // New additions for new global folder structure -- setTrans for this might need to be revisited
  // No ATs exist for levels 1 & 2 --> need alternative
  if (m_dynamicDB && level!=3){
    result=tweakGlobalFolder(ident, level, trans);
    if (!result ) ATH_MSG_ERROR( "Attempt tweak GlobalDB folder failed" );
  }
  else {
    // find transform key, then set appropriate transform
    // do storegate const retrieve, then cast to allow update of locked data
    std::string key=dirkey(ident,level);
    const AlignableTransform* pat;
    AlignableTransform* pat2;
    bool result=false;
    if ((pat=cgetTransPtr(key))) {
      pat2=const_cast<AlignableTransform*>(pat);
      if (pat2!=nullptr) {
    result=pat2->update(ident, Amg::EigenTransformToCLHEP(trans) );
    if (!result) ATH_MSG_ERROR( "Attempt to set non-existant transform" );
      } 
    } else {
      ATH_MSG_ERROR( "setTrans: cannot retrieve AlignableTransform for key" << key );
    }
  }
 
  return result;
}

setTrans() [2/2]

bool InDetAlignDBTool::setTrans ( const Identifier &  ident, const int  level, const Amg::Vector3D &  translate, double  alpha, double  beta, double  gamma  ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 1041 of file InDetAlignDBTool.cxx.

{
  
  Amg::Translation3D  newtranslation(translate);    
  Amg::Transform3D newtrans = newtranslation * Amg::RotationMatrix3D::Identity();
  newtrans *= Amg::AngleAxis3D(gamma, Amg::Vector3D(0.,0.,1.));
  newtrans *= Amg::AngleAxis3D(beta, Amg::Vector3D(0.,1.,0.));
  newtrans *= Amg::AngleAxis3D(alpha, Amg::Vector3D(1.,0.,0.));
  
  return setTrans(ident, level,  newtrans);
}

sortTrans()

void InDetAlignDBTool::sortTrans ( ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 1416 of file InDetAlignDBTool.cxx.

                                       {
  // loop through all the AlignableTransform objects and sort them
  
  ATH_MSG_DEBUG( "Sorting all AlignableTransforms in TDS" );
  AlignableTransform* pat;
  // use cget and a const cast to allow containers that have been read in
  // (and hence are locked by StoreGate) to be sorted
  for (unsigned int i=0;i<m_alignobjs.size();++i)
    if ((pat=const_cast<AlignableTransform*>(cgetTransPtr(m_alignobjs[i])))) pat->sortv();
}

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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

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.

tweakGlobalFolder()

bool InDetAlignDBTool::tweakGlobalFolder ( const Identifier &  ident, const int  level, const Amg::Transform3D &  trans  ) const

virtual

This is the tweak function for the GlobalFolder DB.

Definition at line 1499 of file InDetAlignDBTool.cxx.

                                                         {
 
  // find transform key, then set appropriate transform           
  const CondAttrListCollection* atrlistcol1=nullptr;
  CondAttrListCollection* atrlistcol2=nullptr;
  bool result=false;
  std::string key=dirkey(ident,level);
  int det,bec,layer,ring,sector,side;
  idToDetSet(ident,det,bec,layer,ring,sector,side);
  const unsigned int DBident=det*10000+2*bec*1000+layer*100+ring*10+sector;  
  // so far not a very fancy DB identifier, but seems elaborate enough for this simple structure
  
  if (StatusCode::SUCCESS==detStore()->retrieve(atrlistcol1,key)) {
    // loop over objects in collection                                    
    //atrlistcol1->dump();
    atrlistcol2 = const_cast<CondAttrListCollection*>(atrlistcol1);
    if (atrlistcol2!=nullptr){
      for (CondAttrListCollection::const_iterator citr=atrlistcol2->begin(); citr!=atrlistcol2->end();++citr) {
    
    const coral::AttributeList& atrlist=citr->second;
    coral::AttributeList& atrlist2  = const_cast<coral::AttributeList&>(atrlist);
 
    if(citr->first!=DBident) continue;
    else {
      msg(MSG::DEBUG) << "Tweak Old global DB -- channel: " << citr->first
                          << " ,det: "    << atrlist2["det"].data<int>()
                          << " ,bec: "    << atrlist2["bec"].data<int>()
                          << " ,layer: "  << atrlist2["layer"].data<int>()
                          << " ,ring: "   << atrlist2["ring"].data<int>()
                          << " ,sector: " << atrlist2["sector"].data<int>()
                          << " ,Tx: "     << atrlist2["Tx"].data<float>()
                          << " ,Ty: "     << atrlist2["Ty"].data<float>()
                          << " ,Tz: "     << atrlist2["Tz"].data<float>()
                          << " ,Rx: "     << atrlist2["Rx"].data<float>()
                          << " ,Ry: "     << atrlist2["Ry"].data<float>()
                          << " ,Rz: "     << atrlist2["Rz"].data<float>() << endmsg;
 
 
      // Order of rotations is defined as around z, then y, then x.  
      Amg::Translation3D  oldtranslation(atrlist2["Tx"].data<float>(),atrlist2["Ty"].data<float>(),atrlist2["Tz"].data<float>());
      Amg::Transform3D oldtrans = oldtranslation * Amg::RotationMatrix3D::Identity();
      oldtrans *= Amg::AngleAxis3D(atrlist2["Rz"].data<float>()*CLHEP::mrad, Amg::Vector3D(0.,0.,1.));
      oldtrans *= Amg::AngleAxis3D(atrlist2["Ry"].data<float>()*CLHEP::mrad, Amg::Vector3D(0.,1.,0.));
      oldtrans *= Amg::AngleAxis3D(atrlist2["Rx"].data<float>()*CLHEP::mrad, Amg::Vector3D(1.,0.,0.));
      
      // get the new transform
      Amg::Transform3D newtrans = trans*oldtrans;
 
      // Extract the values we need to write to DB     
      Amg::Vector3D shift=newtrans.translation();
      double alpha, beta, gamma;
      extractAlphaBetaGamma(newtrans, alpha, beta, gamma);
 
      atrlist2["Tx"].data<float>() = shift.x();
      atrlist2["Ty"].data<float>() = shift.y();
      atrlist2["Tz"].data<float>() = shift.z();
      atrlist2["Rx"].data<float>() = alpha/CLHEP::mrad ;
      atrlist2["Ry"].data<float>() = beta/CLHEP::mrad ;
      atrlist2["Rz"].data<float>() = gamma/CLHEP::mrad ;
      
      result = true;
      msg(MSG::DEBUG) << "Tweak New global DB -- channel: " << citr->first
                          << " ,det: "    << atrlist2["det"].data<int>()
                          << " ,bec: "    << atrlist2["bec"].data<int>()
                          << " ,layer: "  << atrlist2["layer"].data<int>()
                          << " ,ring: "   << atrlist2["ring"].data<int>()
                          << " ,sector: " << atrlist2["sector"].data<int>()
                          << " ,Tx: "     << atrlist2["Tx"].data<float>()
                          << " ,Ty: "     << atrlist2["Ty"].data<float>()
                          << " ,Tz: "     << atrlist2["Tz"].data<float>()
                          << " ,Rx: "     << atrlist2["Rx"].data<float>()
                          << " ,Ry: "     << atrlist2["Ry"].data<float>()
                          << " ,Rz: "     << atrlist2["Rz"].data<float>() << endmsg;
      
    }   
      }
    }
    else {
      ATH_MSG_ERROR("tweakGlobalFolder: cast fails for DBident " << DBident );
      return false;
   }
  }
  else {
    ATH_MSG_ERROR("tweakGlobalFolder: cannot retrieve CondAttrListCollection for key " << key );
    return false;
  }
 
  return result;  
}

tweakIBLDist()

bool InDetAlignDBTool::tweakIBLDist ( const int  stave, const float  bowx  ) const

overridevirtual

This is the tweak function for the IBLDist DB.

Implements IInDetAlignDBTool.

Definition at line 1452 of file InDetAlignDBTool.cxx.

                                                                           {
 
  // find transform key, then set appropriate transform           
  const CondAttrListCollection* atrlistcol1=nullptr;
  CondAttrListCollection* atrlistcol2=nullptr;
  bool result=false;
  if (StatusCode::SUCCESS==detStore()->retrieve(atrlistcol1,"/Indet/IBLDist")) {
    // loop over objects in collection                                    
    atrlistcol2 = const_cast<CondAttrListCollection*>(atrlistcol1);
    if (atrlistcol2!=nullptr){
      for (CondAttrListCollection::const_iterator citr=atrlistcol2->begin(); citr!=atrlistcol2->end();++citr) {
    
    const coral::AttributeList& atrlist=citr->second;
    coral::AttributeList& atrlist2  = const_cast<coral::AttributeList&>(atrlist);
 
    if(atrlist2["stave"].data<int>()!=stave) continue;
    else {
      msg(MSG::DEBUG) << "IBLDist DB -- channel before update: " << citr->first
             << " ,stave: " << atrlist2["stave"].data<int>()
             << " ,mag: " << atrlist2["mag"].data<float>()
             << " ,base: " << atrlist2["base"].data<float>() << endmsg;
 
      atrlist2["mag"].data<float>() += bowx;
      result = true;
      msg(MSG::DEBUG) << "IBLDist DB -- channel after update: " << citr->first
             << " ,stave: " << atrlist2["stave"].data<int>()
             << " ,mag: " << atrlist2["mag"].data<float>()
             << " ,base: " << atrlist2["base"].data<float>() << endmsg;
      
    }   
      }
    }
    else {
      ATH_MSG_ERROR("tweakIBLDist: cast fails for stave " << stave );
      return false;
   }
  }
  else {
    ATH_MSG_ERROR("tweakIBLDist: cannot retrieve CondAttrListCollection for key /Indet/IBLDist" );
    return false;
  }
 
  return result;  
}

tweakTrans() [1/2]

bool InDetAlignDBTool::tweakTrans ( const Identifier &  ident, const int  level, const Amg::Transform3D &  trans  ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 1055 of file InDetAlignDBTool.cxx.

                                             {
 
  bool result=false;
 
  // New additions for new global folder structure 
  // No ATs exist for levels 1 & 2 --> need alternative
  if (m_dynamicDB && level!=3){
    result=tweakGlobalFolder(ident, level, trans);
    if (!result ) ATH_MSG_ERROR( "Attempt tweak GlobalDB folder failed" );
  }
  else {
    // find transform key, then set appropriate transform
    std::string key=dirkey(ident,level);
    const AlignableTransform* pat;
    AlignableTransform* pat2;
    if ((pat=cgetTransPtr(key))) {
      pat2=const_cast<AlignableTransform*>(pat);
      if (pat2!=nullptr) {
    result=pat2->tweak(ident,Amg::EigenTransformToCLHEP(trans));
      if (!result) ATH_MSG_ERROR(
                 "Attempt to tweak non-existent transform for element "<<m_pixid->show_to_string(ident));
      } else {
    ATH_MSG_ERROR("tweakTrans: cast fails for key " << key );
      }
    } else {
      ATH_MSG_ERROR(
            "tweakTrans: cannot retrieve AlignableTransform for key" << key );
    }
  }
 
  return result;
}

tweakTrans() [2/2]

bool InDetAlignDBTool::tweakTrans ( const Identifier &  ident, const int  level, const Amg::Vector3D &  translate, double  alpha, double  beta, double  gamma  ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 1089 of file InDetAlignDBTool.cxx.

{
  
  Amg::Translation3D  newtranslation(translate);    
  Amg::Transform3D newtrans = newtranslation * Amg::RotationMatrix3D::Identity();
  newtrans *= Amg::AngleAxis3D(gamma, Amg::Vector3D(0.,0.,1.));
  newtrans *= Amg::AngleAxis3D(beta, Amg::Vector3D(0.,1.,0.));
  newtrans *= Amg::AngleAxis3D(alpha, Amg::Vector3D(1.,0.,0.));
  
  return tweakTrans(ident, level, newtrans);
}

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);
      }
    }
  }

writeFile()

void InDetAlignDBTool::writeFile ( const bool  ntuple, const std::string &  file  ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 632 of file InDetAlignDBTool.cxx.

        {
  std::ofstream* outfile=nullptr;
  INTupleSvc* ntsvc;
  if (StatusCode::SUCCESS!=service("NTupleSvc",ntsvc,true))
    ATH_MSG_ERROR("Cannot find NTupleSvc" );
  const std::string path=file+"/9002";
  NTuplePtr nt(ntsvc,path);
 
  if (ntuple) {
    ATH_MSG_DEBUG( "writeFile: Write AlignableTransforms on ntuple 9002, path: " << file );
    const int ntid=9002;
    if (nt) {
      ATH_MSG_DEBUG( "Ntuple " << path << " is already booked" );
    } else {
      ATH_MSG_DEBUG("Attempting to book ntuple " << path );
      nt=ntsvc->book(file,ntid,CLID_ColumnWiseTuple,"AlignDB");
      if (!nt) ATH_MSG_ERROR("Ntuple booking fails" );
    }
    StatusCode sc;
    sc=nt->addItem("MODPROP/DetType",nt_dettype);
    sc=nt->addItem("MODPROP/Bec",nt_bec);
    sc=nt->addItem("MODPROP/Layer",nt_layer);
    sc=nt->addItem("MODPROP/Ring",nt_ring);
    sc=nt->addItem("MODPROP/Sector",nt_sector);
    sc=nt->addItem("MODPROP/Side",nt_side);
    sc=nt->addItem("MODPROP/Level",nt_level);
    sc=nt->addItem("MODPROP/Xofs",nt_xofs);
    sc=nt->addItem("MODPROP/Yofs",nt_yofs);
    sc=nt->addItem("MODPROP/Zofs",nt_zofs);
    sc=nt->addItem("MODPROP/Phi",nt_phi);
    sc=nt->addItem("MODPROP/Theta",nt_theta);
    sc=nt->addItem("MODPROP/Psi",nt_psi);
    sc=nt->addItem("MODPROP/Phi",nt_phi);
    sc=nt->addItem("MODPROP/Theta",nt_theta);
    sc=nt->addItem("MODPROP/Psi",nt_psi);
    if (sc!=StatusCode::SUCCESS) ATH_MSG_ERROR(
                 "Error booking ntuple 9002 contents" );
  } else {
    ATH_MSG_DEBUG( "writeFile: Write AlignableTransforms on text file: " << file );
    outfile=new std::ofstream(file.c_str());
  }
  int nobj=0;
  int ntrans=0;
  for (std::vector<std::string>::const_iterator iobj=m_alignobjs.begin();
       iobj!=m_alignobjs.end();++iobj) {
    const AlignableTransform* pat;
    if ((pat=cgetTransPtr(*iobj))) {
      ++nobj;
      if (!ntuple) *outfile << *iobj << std::endl;
      for (AlignableTransform::AlignTransMem_citr cit=pat->begin();
        cit!=pat->end();++cit) {
        const Identifier& ident=cit->identify();
        const Amg::Transform3D& trans=Amg::CLHEPTransformToEigen( cit->transform() );
        int det,bec,layer,ring,sector,side;
        float dx,dy,dz,phi,theta,psi;
        if (!idToDetSet(ident,det,bec,layer,ring,sector,side)) {
          // can fail for testbeam whe identifier with all layer
          // and wafer indices set to zero is not valid in the dictionary
          // these transforms are not actually used by testbeam GeoModel anyway
          ATH_MSG_WARNING( "Ident for unknown detector type in " << *iobj  );
            det=1;bec=0;layer=0;ring=0;sector=0;side=0;
        }
        Amg::Vector3D shift=trans.translation();
        Amg::RotationMatrix3D rot=trans.rotation();
        dx=shift.x();
        dy=shift.y();
        dz=shift.z();
        double alpha, beta, gamma;
        extractAlphaBetaGamma(trans, alpha, beta, gamma);
        
        //ATH_MSG_WARNING("THIS NEEDS TO BE CHECKED --- InDetAlignDBTool.cxx:647"); 
    // checked and appears all good, keep this in for now in case we have to recheck things
        Amg::Vector3D ea = rot.eulerAngles(2, 0, 2); 
        
        phi= ea[0];
        theta=ea[1];
        psi=ea[2];
        ++ntrans;
        if (ntuple) {
          nt_dettype=det;
          nt_bec=bec;
          nt_layer=layer;
          nt_ring=ring;
          nt_sector=sector;
          nt_level=3;
          // derive level by looking for objects ending in /ID, SCT or PIX
          std::string r3=iobj->substr(iobj->size()-3,3);
          if (r3=="/ID") nt_level=1;
          if (r3=="SCT" || r3=="PIX") nt_level=2;
          nt_side=side;
          nt_xofs=dx;
          nt_yofs=dy;
          nt_zofs=dz;
          nt_phi=phi;
          nt_theta=theta;
          nt_psi=psi;
          nt_alpha=alpha;
          nt_beta=beta;
          nt_gamma=gamma;
          if (StatusCode::SUCCESS!=nt->write()) ATH_MSG_ERROR("Problem filling ntuple 9002" );
        } else {
                *outfile << "2 " << det << " " << 2*bec << " " << layer << " " << sector << 
            " " << ring << " " << side << " " << dx << " "  << dy << " "
             << dz << " " << alpha/CLHEP::mrad << " " << beta/CLHEP::mrad << " " << gamma/CLHEP::mrad << std::endl;
        }
      }
    } else {
      ATH_MSG_ERROR("Cannot find AlignableTransform for key "
            << *iobj );
    }
  }
  if (ntuple) {
  } else {
    outfile->close();
    delete outfile;
  }
  ATH_MSG_DEBUG("Written " << nobj << " AlignableTransform objects" << " with " << ntrans << " transforms to text file" );
}

writeGlobalFolderFile()

void InDetAlignDBTool::writeGlobalFolderFile ( const std::string &  file ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 785 of file InDetAlignDBTool.cxx.

        {
  std::ofstream* outfile=nullptr;
 
  if (m_dynamicDB){
    ATH_MSG_DEBUG( "writeFile: Write GlobalFolder DB in text file: " << file );
    outfile=new std::ofstream(file.c_str());
    std::vector<std::string> folder_list = {"/Indet/AlignL1/ID", "/Indet/AlignL2/PIX", "/Indet/AlignL2/SCT"};
    
    for (std::vector<std::string>::iterator it = folder_list.begin(); it != folder_list.end(); ++it){
 
      *outfile << *it << std::endl;
    
      const CondAttrListCollection* atrlistcol=nullptr;
      if (StatusCode::SUCCESS==detStore()->retrieve(atrlistcol,*it)) {
    // loop over objects in collection
    for (CondAttrListCollection::const_iterator citr=atrlistcol->begin(); citr!=atrlistcol->end();++citr) {
    
      const coral::AttributeList& atrlist=citr->second;
      *outfile  << atrlist["subsystem"].data<int>()
            << " "     << atrlist["det"].data<int>()
            << " "     << atrlist["bec"].data<int>()
            << " "     << atrlist["layer"].data<int>()
            << " "     << atrlist["ring"].data<int>()
            << " "     << atrlist["sector"].data<int>()
            << " "     << atrlist["side"].data<int>()
            << " "     << atrlist["Tx"].data<float>()
            << " "     << atrlist["Ty"].data<float>()
            << " "     << atrlist["Tz"].data<float>()
            << " "     << atrlist["Rx"].data<float>()
            << " "     << atrlist["Ry"].data<float>()
            << " "     << atrlist["Rz"].data<float>() << std::endl;
    }
      }
      else {
    if (msgLvl(MSG::INFO))
      msg(MSG::INFO) << "Cannot find " << *it << " Container - cannot write DB in text file " << endmsg;
      }
    }
    outfile->close();
    delete outfile;
  }
  else {
    ATH_MSG_DEBUG( "writeFile: No dynamic Run2 DB structure is present --> skipping writing file " << file );
  }
}

writeIBLDistFile()

void InDetAlignDBTool::writeIBLDistFile ( const std::string &  file ) const

overridevirtual

Implements IInDetAlignDBTool.

Definition at line 753 of file InDetAlignDBTool.cxx.

        {
  std::ofstream* outfile=nullptr;
 
  ATH_MSG_DEBUG( "writeFile: Write IBLDist DB in text file: " << file );
  outfile=new std::ofstream(file.c_str());
  *outfile << "/Indet/IBLDist" << std::endl;
 
  const CondAttrListCollection* atrlistcol=nullptr;
  if (StatusCode::SUCCESS==detStore()->retrieve(atrlistcol,"/Indet/IBLDist")) {
    // loop over objects in collection                                                                                                             
    for (CondAttrListCollection::const_iterator citr=atrlistcol->begin(); citr!=atrlistcol->end();++citr) {
 
      const coral::AttributeList& atrlist=citr->second;
      *outfile  << citr->first << " " << atrlist["stave"].data<int>()
        << " " << atrlist["eta"].data<int>()
        << " " << atrlist["mag"].data<float>()
        << " " << atrlist["base"].data<float>() << std::endl;
    }
  }
  else {
    if (msgLvl(MSG::INFO))
      msg(MSG::INFO) << "Cannot find IBLDist Container - cannot write IBLDist DB in text file " << endmsg;
  }
 
  outfile->close();
  delete outfile;
  
}

Member Data Documentation

m_alignchans

std::vector<int> InDetAlignDBTool::m_alignchans

private

Definition at line 188 of file InDetAlignDBTool.h.

m_alignobjs

std::vector<std::string> InDetAlignDBTool::m_alignobjs

private

Definition at line 187 of file InDetAlignDBTool.h.

m_attrListCollection

CondAttrListCollection* InDetAlignDBTool::m_attrListCollection

private

Definition at line 190 of file InDetAlignDBTool.h.

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_dynamicDB

bool InDetAlignDBTool::m_dynamicDB

private

Definition at line 209 of file InDetAlignDBTool.h.

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_forceUserDBConfig

bool InDetAlignDBTool::m_forceUserDBConfig

private

Definition at line 210 of file InDetAlignDBTool.h.

m_managers

std::vector<const InDetDD::SiDetectorManager *> InDetAlignDBTool::m_managers

private

Definition at line 185 of file InDetAlignDBTool.h.

m_par_condstream

ToolHandle<IAthenaOutputStreamTool> InDetAlignDBTool::m_par_condstream

private

Definition at line 195 of file InDetAlignDBTool.h.

m_par_dbkey

std::string InDetAlignDBTool::m_par_dbkey

private

the base part of the key for loading AlignableTransform objects from the Transient Data Store.

Default: /Indet/Align

Definition at line 201 of file InDetAlignDBTool.h.

m_par_dbroot

Gaudi::Property<std::string> InDetAlignDBTool::m_par_dbroot { this, "AlignmentRootFolder", "/Indet/Align", "Root folder for alignment" }

private

name of the root folder for constants, which can be set via the <key> syntax.

Default: /Indet/Align.

Definition at line 198 of file InDetAlignDBTool.h.

m_par_fake

int InDetAlignDBTool::m_par_fake

private

Definition at line 194 of file InDetAlignDBTool.h.

m_par_newdb

bool InDetAlignDBTool::m_par_newdb

private

Definition at line 192 of file InDetAlignDBTool.h.

m_par_oldTextFile

bool InDetAlignDBTool::m_par_oldTextFile

private

Definition at line 202 of file InDetAlignDBTool.h.

m_par_scttwoside

bool InDetAlignDBTool::m_par_scttwoside

private

Definition at line 193 of file InDetAlignDBTool.h.

m_pixid

const PixelID* InDetAlignDBTool::m_pixid

private

Definition at line 181 of file InDetAlignDBTool.h.

m_pixman

const InDetDD::PixelDetectorManager* InDetAlignDBTool::m_pixman

private

Definition at line 183 of file InDetAlignDBTool.h.

m_pixmanName

Gaudi::Property<std::string> InDetAlignDBTool::m_pixmanName {this, "PixelManager", "Pixel", "Pixel manager name" }

private

Definition at line 212 of file InDetAlignDBTool.h.

m_sctid

const SCT_ID* InDetAlignDBTool::m_sctid

private

Definition at line 182 of file InDetAlignDBTool.h.

m_sctman

const InDetDD::SCT_DetectorManager* InDetAlignDBTool::m_sctman

private

Definition at line 184 of file InDetAlignDBTool.h.

m_sctmanName

Gaudi::Property<std::string> InDetAlignDBTool::m_sctmanName {this, "SCT_Manager", "SCT", "SCT manager name" }

private

Definition at line 213 of file InDetAlignDBTool.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:

• InDetAlignDBTool.h
• InDetAlignDBTool.cxx