TRT_AlignDbSvc Class Reference

Service to manage TRT alignment data. More...

#include <TRT_AlignDbSvc.h>

Inheritance diagram for TRT_AlignDbSvc:

Public Member Functions
	TRT_AlignDbSvc (const std::string &name, ISvcLocator *pSvcLocator)
	constructor
virtual	~TRT_AlignDbSvc ()
	destructor
virtual StatusCode	initialize ()
	tool initialize
virtual StatusCode	finalize ()
	tool finalize
StatusCode	IOVCallBack (IOVSVC_CALLBACK_ARGS)
	Call back function for alignment folders.
StatusCode	writeAlignTextFile (const std::string &file) const
	write AlignableTransforms to flat text file
StatusCode	writeStrawAlignTextFile (const std::string &file) const
StatusCode	writeGlobalFolderFile (const std::string &file) const
StatusCode	readAlignTextFile (const std::string &file)
	read AlignableTransforms from text file into TDS
StatusCode	streamOutAlignObjects () const
	write the alignment objects to output
StatusCode	registerAlignObjects (const std::string &tag, int run1, int event1, int run2, int event2) const
	register alignment objects with the IoV service
StatusCode	setAlignTransform (Identifier ident, Amg::Transform3D trans, unsigned int level)
	set AlignableTransform for an identifier
StatusCode	tweakAlignTransform (Identifier ident, Amg::Transform3D trans, unsigned int level)
	tweak AlignableTransform for an identifier
const Amg::Transform3D	getAlignmentTransform (const Identifier &ident, unsigned int level) const
	get AlignableTransform for an identifier
const Amg::Transform3D *	getAlignmentTransformPtr (const Identifier &ident, unsigned int level) const
	get Level L2 Transform for an identifier
StatusCode	tweakGlobalFolder (Identifier ident, const Amg::Transform3D &trans)
	tweak L1 DB for global folders for an identifier

Private Member Functions
StatusCode	setAlignTransformL1 (Identifier ident, const Amg::Transform3D &trans)
	set Level 1 AlignableTransform for an identifier
StatusCode	setAlignTransformL2 (Identifier ident, Amg::Transform3D trans)
	set Level 2 AlignableTransform for an identifier
StatusCode	setAlignTransformL3 (Identifier ident, Amg::Transform3D trans)
	set Level 3 AlignableTransform for an identifier
const Amg::Transform3D	getAlignmentTransformL1 (Identifier const &ident) const
	get Level 1 AlignableTransform for an identifier
const Amg::Transform3D *	getAlignmentTransformL1Ptr (Identifier const &ident) const
	get Level L1 Transform for an identifier
const Amg::Transform3D	getAlignmentTransformL2 (Identifier const &ident) const
	get Level 2 AlignableTransform for an identifier
const Amg::Transform3D *	getAlignmentTransformL2Ptr (Identifier const &ident) const
	get Level L2 Transform for an identifier
StatusCode	tweakAlignTransformL1 (Identifier ident, const Amg::Transform3D &trans)
	tweak Level 1 AlignableTransform for an identifier
StatusCode	tweakAlignTransformL2 (Identifier ident, const Amg::Transform3D &trans)
	tweak Level 2 AlignableTransform for an identifier
StatusCode	tweakAlignTransformL3 (Identifier ident, Amg::Transform3D trans)
	tweak Level 3 AlignableTransform for an identifier
AlignableTransform *	getTransPtr (const std::string &key) const
	get AlignableTransform pointer for an object key
const AlignableTransform *	cgetTransPtr (const std::string &key) const
	get const AlignableTransform pointer for an object key
bool	isOldKey (const std::string &input) const
	Returns the true if the input key is from the old endcap scheme.
void	printCondObjects () const
	Output the conditions objects currently in memory.
StatusCode	createAlignObjects () const
	Create an empty set of AlignableTransforms for the GeoModel setup.
StatusCode	createAlignObjectsWhichDoNotAlreadyExist ()
	Create an empty set of AlignableTransforms for the transforms which are not created by XXXXXXX from the conddb.
const AlignableTransformContainer *	getContainer () const
	Return the container.
std::string	findkey (const Identifier &ident, const std::string &type) const
	Return the object key for a given identifier and data type.

Static Private Member Functions
static int	getRingForStrawLayer (int strawlayer)
	Returns the ring for a given strawLayer.
static std::string	prefixtag (const std::string &key)
	Return the prefix tag for a given calibration folder.
static std::string	intToString (int input)
	Convert from an int to a string.
static void	printTransform (const std::string &thisName, const Amg::Transform3D &transform)
	Output the transform to the cout, for debugging.

Private Attributes
ServiceHandle< StoreGateSvc >	m_detStore
ServiceHandle< ITRT_StrawAlignDbSvc >	m_trtStrawAlignDbSvc
const TRT_ID *	m_trtid
	trt id helper
const InDetDD::TRT_DetectorManager *	m_trtman
	detector manager
std::string	m_alignroot
	root alignment folder
std::string	m_alignString
	alignment string searched for
std::string	m_par_alitextfile
	input text file
std::vector< std::string >	m_alignobjs
	folder names
std::vector< int >	m_alignchans
	channels
const DataHandle< AlignableTransformContainer >	m_aligncontainerhandle
ToolHandle< IAthenaOutputStreamTool >	m_streamer
	OutputStreamTool.
std::vector< Amg::Transform3D * >	m_amgTransformCache
std::string	m_alignDBprefix
bool	m_dynamicDB
bool	m_forceUserDBConfig

Detailed Description

Service to manage TRT alignment data.

Definition at line 45 of file TRT_AlignDbSvc.h.

Constructor & Destructor Documentation

TRT_AlignDbSvc()

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

constructor

Definition at line 37 of file TRT_AlignDbSvc.cxx.

  : base_class(name,pSvcLocator),
    m_detStore("DetectorStore",name),
    m_trtStrawAlignDbSvc("TRT_StrawAlignDbSvc",name),
    m_trtid(nullptr),
    m_trtman(nullptr),
    m_alignroot("/TRT/Align"),
    m_alignString("AL"),
    m_par_alitextfile(""),
    m_streamer("AthenaOutputStreamTool/CondStream1"),
    m_alignDBprefix("/TRT/Align/"),
    m_dynamicDB(false),
    m_forceUserDBConfig(false)
{
  declareProperty("StreamTool",m_streamer);
  declareProperty("alignroot",m_alignroot);
  declareProperty("alignTextFile",m_par_alitextfile);
  declareProperty("DetectorStore",m_detStore);
  declareProperty("TrtStrawAlignDbSvc",   m_trtStrawAlignDbSvc,"Service for interaction with the TRT straw alignment DB");
  declareProperty("alignString",m_alignString);
  declareProperty("alignDBprefix",m_alignDBprefix);
  declareProperty("forceUserDBConfig",m_forceUserDBConfig, "Set to true to override any DB auto-configuration");
}

~TRT_AlignDbSvc()

TRT_AlignDbSvc::~TRT_AlignDbSvc ( )

virtual

destructor

Definition at line 63 of file TRT_AlignDbSvc.cxx.

{}

Member Function Documentation

cgetTransPtr()

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

private

get const AlignableTransform pointer for an object key

Definition at line 1381 of file TRT_AlignDbSvc.cxx.

                                                                                 {
  ATH_MSG_DEBUG( "In cgetTransPtr"  );
  ATH_MSG_DEBUG( "Getting the poiter for key " << key  );
 
  // Retrieve AlignableTransform pointer for a given key - const version
  const AlignableTransform* pat=nullptr;
  const AlignableTransformContainer* patc= getContainer();
  // the retrieve is unnecessary. in fact, if patc==0, retrieve should
  // fail as well.
 
  if( patc || StatusCode::SUCCESS==m_detStore->retrieve(patc,m_alignroot)) {
    for(DataVector<AlignableTransform>::const_iterator dva=patc->begin();dva!=patc->end();++dva) {
      if( (*dva)->tag()==key ) {
    pat = *dva;
    break;
      }
    }
  }
  
  if(!pat){
    ATH_MSG_WARNING( "AlignableTransform poiter is NULL!!!!!"  );
    ATH_MSG_WARNING( "Failed to get the AlignableTransform for key " << key  );
  }
  
  ATH_MSG_DEBUG( "leaving cgetTransPtr "  );
  return pat;
}

createAlignObjects()

StatusCode TRT_AlignDbSvc::createAlignObjects ( ) const

private

Create an empty set of AlignableTransforms for the GeoModel setup.

create an empty set of AlignableTransforms for the GeoModel setup

Create empty alignment objects. Use when constants are read in from textfiles. Make sure that the objects are not read in by IOV before

check if collection already exists

Create the appropriate (empty) AlignableTransforms for this geometry

record it

Definition at line 1283 of file TRT_AlignDbSvc.cxx.

                                                   {

  ATH_MSG_DEBUG( "createAlignObjects method called"  );

  if (m_detStore->contains<AlignableTransformContainer>(m_alignroot)) {
    ATH_MSG_WARNING( "createAlignObjects: AlignableTransformContainer with name " << m_alignroot
                     << " already exists."  );
    return StatusCode::FAILURE;
  }
  
  auto patc = std::make_unique<AlignableTransformContainer>();
 
  for (unsigned int i=0;i<m_alignobjs.size();++i) {
    patc->push_back(std::make_unique<AlignableTransform>(m_alignobjs[i]));
    patc->add(m_alignchans[i]);
    ATH_MSG_INFO( " added empty AlignableTransform for key " << m_alignobjs[i]  );
  }

  ATH_CHECK( m_detStore->record(std::move(patc),m_alignroot) );
 
  ATH_MSG_DEBUG( "Leaving createAlignObjects"  );
  return StatusCode::SUCCESS;
}

createAlignObjectsWhichDoNotAlreadyExist()

StatusCode TRT_AlignDbSvc::createAlignObjectsWhichDoNotAlreadyExist ( )

private

Create an empty set of AlignableTransforms for the transforms which are not created by XXXXXXX from the conddb.

create an empty set of AlignableTransforms for the transforms which are not created by XXXXXXX from the conddb

Create empty alignment objects for the object which do do already exist

check if collection already exists

Get the alignabletransformcontainer

Need to cost cast b/c were are chaning it, Ugly but so be it.

Only create the new keys that dont exist

If the pointer doesnt exist

Definition at line 1316 of file TRT_AlignDbSvc.cxx.

                                                                   {

  ATH_MSG_DEBUG( "createAlignObjectsWhichDoNotAlreadyExist method called"  );

  ATH_CHECK( m_detStore->contains<AlignableTransformContainer>(m_alignroot) );
  
  const AlignableTransformContainer* patc= getContainer();

  AlignableTransformContainer* patc_NonConst = const_cast<AlignableTransformContainer*>(patc);
  
  for (unsigned int i=0;i<m_alignobjs.size();++i) {
    
    if(m_alignString != "Alold" && !isOldKey(m_alignobjs[i] )){
      
      if(!cgetTransPtr(m_alignobjs[i])){
    
    AlignableTransform* pat=new AlignableTransform(m_alignobjs[i]);
    patc_NonConst->push_back(pat);
    patc_NonConst->add(m_alignchans[i]);
    ATH_MSG_INFO( " added empty AlignableTransform for key " << m_alignobjs[i]  );
 
      }
    }
  }
 
  ATH_MSG_DEBUG( "Leaving createAlignObjectsWhichDoNotAlreadyExist"  );
  return StatusCode::SUCCESS;
}

finalize()

StatusCode TRT_AlignDbSvc::finalize ( )

virtual

tool finalize

Definition at line 172 of file TRT_AlignDbSvc.cxx.

{
  ATH_MSG_INFO( "TRT_AlignDbSvc finalize method called"  );
  for(std::vector<Amg::Transform3D*>::iterator it = m_amgTransformCache.begin(); it != m_amgTransformCache.end(); ++it){
      delete *it;
  }
  return StatusCode::SUCCESS;
}

findkey()

std::string TRT_AlignDbSvc::findkey ( const Identifier & ident, const std::string & type ) const

private

Return the object key for a given identifier and data type.

return the object key for a given identifier and data type

given a TRT identifier and a type ("RT", "T0", "DF" or "AL") return the key for the associated ArrayStore or AlignableTransForm in TDS

The keys in the old (Lisbon) scheme coincide with TDS folder names:

/Indet/Align/TRTB0 AlignableTransform for barrel layer 0. Etc /Indet/Align/TRT_DF_B0 Wire shift FloatArrayStore for barrel layer 0. Etc /Indet/Calib/TRT_T0_B0 T0 FloatArrayStore for barrel layer 0. Etc /Indet/Calib/TRT_RT_B0 R(t) FloatArrayStore for barrel layer 0. Etc

In the COOL scheme there is only one folder for AlignableTransforms and one for FloatArrayStores (/TRT/Align and /TRT/Calib). These contains collections of objects with the following keys:

/TRT/Align/L2A AlignableTransform for Endcap A. /TRT/Align/AX DEPRECATED! Old AlignableTransform for Endcap A wheel X where X is [0-13]. /TRT/Align/B0 AlignableTransform for barrel layer 0. /TRT/Align/B1 AlignableTransform for barrel layer 1. /TRT/Align/B2 AlignableTransform for Endcap C. /TRT/Align/L2C AlignableTransform for barrel layer 0. /TRT/Align/CX DEPRECATED! Old AlignableTransform for Endcap C wheel X where X is [0-13]. /TRT/Calib/DF_B0 Wire shift FloatArrayStore for barrel layer 0. Etc /TRT/Calib/T0_B0 T0 FloatArrayStore for barrel layer 0. Etc /TRT/Calib/RT_B0 R(t) FloatArrayStore for barrel layer 0. Etc

So the result is eg /Indet/Calib/TRT_T0_A6 in the Lisbon scheme and /TRT/Calib/T0_A6 in the COOL scheme

• for the T0 folder for wheel 6 in endcap A

Definition at line 1147 of file TRT_AlignDbSvc.cxx.

                                                                                      {
  std::ostringstream result;
  if (!m_trtid->is_trt(ident)) return result.str();
  
  if(type=="AL" || type=="ALold") {
    //    result << "/TRT/Align/";
    result << m_alignDBprefix;
  } else if(type=="DF") {
    result << "/TRT/Calib/DF";
  } else return result.str();
 
  int bec=m_trtid->barrel_ec(ident);
 
  if(type!="AL" && type!="ALold") result << "_";
 
  if(type=="AL"){
    if(bec==2) {
      result << "L2A";
    } else if(bec==-2) {
      result << "L2C";
    } else {
      result << "B";
      int layer = m_trtid->layer_or_wheel(ident);
      result << layer;
    }
  }else if(type=="ALold"){
    if(bec==2) {
      result << "A";
    } else if(bec==-2) {
      result << "C";
    } else {
      result << "B";
    }
    int layer = m_trtid->layer_or_wheel(ident);
    result << layer;
  }
  
  
  return result.str();
}     

getAlignmentTransform()

const Amg::Transform3D TRT_AlignDbSvc::getAlignmentTransform	(	const Identifier &	ident,
		unsigned int	level ) const

get AlignableTransform for an identifier

get Level L2 Transform for an identifier

Definition at line 537 of file TRT_AlignDbSvc.cxx.

                                                                                                            {
  ATH_MSG_DEBUG( "In getAlignmentTransform"  );
  
  if(level != 1 && level != 2){
    ATH_MSG_ERROR( "Call to trans wrong!"  );
    ATH_MSG_ERROR( "Level must be 1 or 2!"  );
    ATH_MSG_ERROR( "Returning NULL"  );
    return Amg::Transform3D();
  }
 
  return (level == 1) ? getAlignmentTransformL1(ident) : getAlignmentTransformL2(ident);
}

getAlignmentTransformL1()

const Amg::Transform3D TRT_AlignDbSvc::getAlignmentTransformL1 ( Identifier const & ident ) const

private

get Level 1 AlignableTransform for an identifier

Definition at line 551 of file TRT_AlignDbSvc.cxx.

                                                                                          {
  ATH_MSG_DEBUG( "In getAlignmentTransformL1"  );
  // return level 1 AlignableTransform for the TRT subdetector bec (+-1,+-2)
  // or return null transform.
  
  std::string key="/TRT/Align/TRT";
  const AlignableTransform* pat=cgetTransPtr(key);
  if (!pat) return Amg::Transform3D();
 
  // get Amg::Transform3d via AlignTransMember
  AlignableTransform::AlignTransMem_citr itr = pat->findIdent(ident);
  return ( itr!=pat->end() ? Amg::CLHEPTransformToEigen(itr->transform()) : Amg::Transform3D() );
}

getAlignmentTransformL1Ptr()

const Amg::Transform3D * TRT_AlignDbSvc::getAlignmentTransformL1Ptr ( Identifier const & ident ) const

private

get Level L1 Transform for an identifier

Definition at line 611 of file TRT_AlignDbSvc.cxx.

                                                                                              {
  ATH_MSG_DEBUG( "In getAlignmentTransformL1Ptr"  );
  // get level 1 (despite name, will change soon) AlignableTransform for the subdetector containing ident
  const Amg::Transform3D* rc(nullptr) ;
  if( m_trtid->is_trt(ident) ) {
    const AlignableTransform* pat = cgetTransPtr( "/TRT/Align/TRT" ) ;
    if( pat ) {
      int bec=m_trtid->barrel_ec(ident);
      Identifier mid=m_trtid->module_id(bec,0,0);
      AlignableTransform::AlignTransMem_citr iter = pat->findIdent(mid) ;
      if(iter != pat->end() ) {
          Amg::Transform3D* amgTransform = new Amg::Transform3D((Amg::CLHEPTransformToEigen(iter->transform())));
          m_amgTransformCache.push_back(amgTransform);
          rc = amgTransform;
      }
    }
  }
  
  ATH_MSG_DEBUG( "Leaving getAlignmentTransformL1Ptr"  );
  return rc ;
}

getAlignmentTransformL2()

const Amg::Transform3D TRT_AlignDbSvc::getAlignmentTransformL2 ( Identifier const & ident ) const

private

get Level 2 AlignableTransform for an identifier

Definition at line 566 of file TRT_AlignDbSvc.cxx.

                                                                                         {
  ATH_MSG_DEBUG( "In getAlignmentTransformL2"  );
  // return level 2 AlignableTransform for the module containing ident
  // or return null transform.
  
  std::string key=findkey(ident,m_alignString);
  //does a key exist corresponding to this identifier?
  
  const AlignableTransform* pat=cgetTransPtr(key);
  if (!pat) return Amg::Transform3D();
 
  // OK it exists
  // get "module identifier" from identifier
  int bec=m_trtid->barrel_ec(ident);
  int layer=m_trtid->layer_or_wheel(ident);
  int sector=m_trtid->phi_module(ident);
  int strawLayer=m_trtid->straw_layer(ident);
  int ring = getRingForStrawLayer(strawLayer);
 
  Identifier mid;
  if(key == (m_alignDBprefix+"L2A") || key == (m_alignDBprefix+"L2C") )
    mid=m_trtid->layer_id(bec,0,layer,ring);
  else
    mid=m_trtid->module_id(bec,sector,layer);
  
  // get Amg::Transform3d via AlignTransMember
  AlignableTransform::AlignTransMem_citr itr = pat->findIdent(mid);
  return ( itr!=pat->end() ? Amg::CLHEPTransformToEigen(itr->transform()) : Amg::Transform3D() );
}

getAlignmentTransformL2Ptr()

const Amg::Transform3D * TRT_AlignDbSvc::getAlignmentTransformL2Ptr ( Identifier const & ident ) const

private

get Level L2 Transform for an identifier

Definition at line 634 of file TRT_AlignDbSvc.cxx.

                                                                                             {
  ATH_MSG_DEBUG( "In getAlignmentTransformL2Ptr"  );
  // set level 2 (despite name, will change soon) AlignableTransform for the module containing ident
  // or add a new one.
  const Amg::Transform3D* rc(nullptr) ;
  //does a folder exist corresponding to this identifier?
  if( m_trtid->is_trt(ident) ) {
    std::string key=findkey(ident,m_alignString);
    const AlignableTransform* pat=cgetTransPtr(key);
    if(pat) {
      // make sure the identifier is a "module identifier"
      int bec=m_trtid->barrel_ec(ident);
      int layer=m_trtid->layer_or_wheel(ident);
      int sector=m_trtid->phi_module(ident);
      int strawLayer=m_trtid->straw_layer(ident);
      int ring = getRingForStrawLayer(strawLayer);
      Identifier mid;
      if(key == (m_alignDBprefix+"L2A") || key == (m_alignDBprefix+"L2C") ){
    mid =m_trtid->layer_id(bec,0,layer,ring);
      }else
    mid =m_trtid->module_id(bec,sector,layer);
      
      AlignableTransform::AlignTransMem_citr iter = pat->findIdent(mid) ;
      if(iter != pat->end() ){
          AlignableTransform::AlignTransMem_citr iter = pat->findIdent(mid) ;
          Amg::Transform3D* amgTransform = new Amg::Transform3D((Amg::CLHEPTransformToEigen(iter->transform())));
          m_amgTransformCache.push_back(amgTransform);
          rc = amgTransform;
      }
 
      else
    ATH_MSG_WARNING( "Did not find the transform for " << m_trtid->show_to_string(mid)  );
    }
  }
  
  ATH_MSG_DEBUG( "Leaving getAlignmentTransformL2Ptr"  );
  return rc ;
}

getAlignmentTransformPtr()

const Amg::Transform3D * TRT_AlignDbSvc::getAlignmentTransformPtr	(	const Identifier &	ident,
		unsigned int	level ) const

get Level L2 Transform for an identifier

Definition at line 597 of file TRT_AlignDbSvc.cxx.

                                                                                                                {
  ATH_MSG_DEBUG( "In getAlignmentTransformPtr"  );
  
  if(level != 1 && level != 2){
    ATH_MSG_ERROR( "Call to trans wrong!"  );
    ATH_MSG_ERROR( "Level must be 1 or 2!"  );
    ATH_MSG_ERROR( "Returning NULL"  );
    return nullptr;
  }
 
  return (level == 1) ? getAlignmentTransformL1Ptr(ident) : getAlignmentTransformL2Ptr(ident);
}

getContainer()

const AlignableTransformContainer * TRT_AlignDbSvc::getContainer ( ) const

private

Return the container.

Definition at line 1599 of file TRT_AlignDbSvc.cxx.

{
  if (m_aligncontainerhandle.isValid())
    return m_aligncontainerhandle.cptr();
  const AlignableTransformContainer* ptr = nullptr;
  if (m_detStore->retrieve (ptr, m_alignroot).isFailure()) {
    ATH_MSG_ERROR ("Cannot retrieve " << m_alignroot << " from detStore ");
  }
  return ptr;
}

getRingForStrawLayer()

int TRT_AlignDbSvc::getRingForStrawLayer ( int strawlayer )

staticprivate

Returns the ring for a given strawLayer.

Definition at line 1411 of file TRT_AlignDbSvc.cxx.

                                                       {
  return strawlayer / 4 * 4;
}

getTransPtr()

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

private

get AlignableTransform pointer for an object key

Definition at line 1375 of file TRT_AlignDbSvc.cxx.

                                                                          {
  ATH_MSG_DEBUG( "In (and leaving) getTransPtr"  );
  return const_cast<AlignableTransform*>(cgetTransPtr(key)) ;
}

initialize()

StatusCode TRT_AlignDbSvc::initialize ( )

virtual

tool initialize

If the folder exists, register a callback, we read from the text file if it exists in the call back If the folder does not yet exist, create and record it.

This is the folder given by the conditions db.(Eg: from the global tag) One can block this via: conddb.blockFolder("/TRT/Align") in the jobOptions

This is the text files whence the constants.

register the callback

Reminder that the constants will be read from text file.

create alignment objects

Read the newly created objects

Definition at line 68 of file TRT_AlignDbSvc.cxx.

{
  ATH_MSG_INFO( " in initialize "  );
  
  ATH_CHECK( m_detStore.retrieve() );
  ATH_CHECK (m_trtStrawAlignDbSvc.retrieve() );
  ATH_MSG_INFO ("retrieved " << m_trtStrawAlignDbSvc);
 
  // Get the geometry.
  InDetDD::TRT_DetElementCollection::const_iterator iter,itermin,itermax;
  ATH_CHECK (m_detStore->retrieve(m_trtman,"TRT") );
 
  // Get TRT manager and ID helper
  itermin=m_trtman->getDetectorElementBegin();
  itermax=m_trtman->getDetectorElementEnd();
  ATH_CHECK( m_detStore->retrieve(m_trtid,"TRT_ID") );
  ATH_MSG_INFO( "found all TRT services "  );
 
  if (m_trtman->m_alignfoldertype == InDetDD::timedependent_run2 && !m_forceUserDBConfig){
    m_dynamicDB = true;
    m_alignroot = "/TRT/AlignL2";                                                         
    m_alignDBprefix = "/TRT/AlignL2/";
  }
  if (m_trtman->m_alignfoldertype == InDetDD::static_run1 && !m_forceUserDBConfig){
    m_dynamicDB = false;
    m_alignroot = "/TRT/Align";
    m_alignDBprefix = "/TRT/Align/";
  }
 
 
  // setup list of TDS objects from geometry description
  m_alignobjs.clear();
  m_alignchans.clear();
 
  // Include a level 1 alignment
  int ichan(0) ;
  if (!m_dynamicDB){
    m_alignobjs.emplace_back("/TRT/Align/TRT");
    ATH_MSG_INFO( "Adding key: /TRT/Align/TRT --> We are using static DB folder scheme"  );
    m_alignchans.push_back(ichan++);
  }
  
  //Check all detector elements in the present geometry setup
  for (iter=itermin;iter!=itermax;++iter) {
    const InDetDD::TRT_BaseElement* element=*iter;
    if (element!=nullptr) {
      const Identifier ident=element->identify();
      if (m_trtid->is_trt(ident)) {           //OK this Element is included
    std::string key = findkey(ident,m_alignString); 
    std::vector<std::string>::const_iterator ix = find(m_alignobjs.begin(),m_alignobjs.end(),key);
    if (ix==m_alignobjs.end()) {
      m_alignobjs.push_back(key);
      ATH_MSG_INFO( "Adding key: " << key  );
      m_alignchans.push_back(ichan++);
    }
      }
    }
  }
  

  bool alignFolderExists = m_detStore->contains<AlignableTransformContainer>(m_alignroot) ;
  if (m_dynamicDB) alignFolderExists = ( alignFolderExists && m_detStore->contains<CondAttrListCollection>("/TRT/AlignL1/TRT"));

  bool alignTextFileExists = !m_par_alitextfile.empty();
 
  if( alignFolderExists ) {    
    
    ATH_CHECK( m_detStore->regFcn(&TRT_AlignDbSvc::IOVCallBack,this,m_aligncontainerhandle,m_alignroot) );
    
    if( alignTextFileExists ) 
      ATH_MSG_INFO( "AlignableTransformContainer with name " << m_alignroot
                    << " exists. Will read text file from callback function."  );
  
  } else if ( alignTextFileExists ) {
    
    ATH_CHECK( this->createAlignObjects() );
    
    ATH_CHECK( this->readAlignTextFile(m_par_alitextfile) );
  
  } else {
    ATH_MSG_ERROR( "AlignableTransformContainer not in IOV service and no textfile specified."  );
  }
  
  ATH_MSG_DEBUG ("The TRT/Align keys and channels are:");
  for (unsigned int i=0;i<m_alignobjs.size();++i)
    ATH_MSG_DEBUG (" key " << m_alignobjs[i] << " chan " << m_alignchans[i]);
  
  return StatusCode::SUCCESS;
}

intToString()

std::string TRT_AlignDbSvc::intToString ( int input )

staticprivate

Convert from an int to a string.

Definition at line 1441 of file TRT_AlignDbSvc.cxx.

                                               {
  std::ostringstream stm;
  stm << input;
  return stm.str();
}

IOVCallBack()

StatusCode TRT_AlignDbSvc::IOVCallBack

(

IOVSVC_CALLBACK_ARGS

)

Call back function for alignment folders.

By the time this gets called the alignment transforms have been created. Either by the create method in initialize, or from the align folder content from the cond db. (Its not clear to johnda where the alignable tracnsforms get created from the conddb)

If we read the constants from the db, there is a chance that they only contained the alignable transforms for the old endcap keys. In which case we need to create the transforms for the new endcap keys

Print the keys were setting

print out the objects we have

Definition at line 182 of file TRT_AlignDbSvc.cxx.

{
  ATH_MSG_DEBUG( "In IOVCallBack"  );
  
  ATH_CHECK( createAlignObjectsWhichDoNotAlreadyExist() );
  
  for (std::list<std::string>::const_iterator itr=keys.begin(); itr!=keys.end(); ++itr)
    ATH_MSG_INFO( "IOVCALLBACK for key " << *itr<< " number " << I  );
  
  
  if(!m_par_alitextfile.empty()){
    ATH_CHECK( this->readAlignTextFile(m_par_alitextfile) );
  }else{
    ATH_MSG_INFO( "Text file " << m_par_alitextfile << " is empty"  );
  }

  printCondObjects() ;
 
  ATH_MSG_DEBUG( "Leaving IOVCallBack"  );
  return StatusCode::SUCCESS;
}

isOldKey()

bool TRT_AlignDbSvc::isOldKey ( const std::string & input ) const

private

Returns the true if the input key is from the old endcap scheme.

Definition at line 1418 of file TRT_AlignDbSvc.cxx.

                                                         {
  
  for(unsigned int i=0; i<14; ++i){
    std::string testA = "A"+intToString(i);
    ATH_MSG_VERBOSE( " The testA is " << testA << " " 
                     << bool(input.find(testA)!=std::string::npos)  );
    if(input.find(testA)!=std::string::npos){
      return true;
    }
 
    std::string testC = "C"+intToString(i);
    ATH_MSG_VERBOSE( " The testC is " << testC << " " 
                     << bool(input.find(testC)!=std::string::npos)  );
    if(input.find(testC)!=std::string::npos){
      return true;
    }
  
  }
  
  return false;
}

prefixtag()

std::string TRT_AlignDbSvc::prefixtag ( const std::string & key )

staticprivate

Return the prefix tag for a given calibration folder.

return the prefix tag for a given calibration folder

given a TRT calibration folder key, return the prefix tag for the associated (Float)ArrayStore or AlignableTransform.

This is used in version tags if big container is NOT used.

Prefixes are TrtDfB0_ Wire shift FloatArrayStore for barrel layer 0. Etc TrtT0B0_ T0 FloatArrayStore for barrel layer 0. Etc TrtRtB0_ R(t) FloatArrayStore for barrel layer 0. Etc TrtAlB0_ AlignableTransform for barrel layer 0. Etc TrtAlId_ AlignableTransform for TRT.

Definition at line 1218 of file TRT_AlignDbSvc.cxx.

                                                        {
 
  std::ostringstream result;
  std::string  detector=key.substr(1,3);
 
  std::string type,quantity;
  int ind,ind1;
  if(detector=="TRT") {
    type=key.substr(5,5);
    ind=11;
    ind1=11;
    quantity=key.substr(ind,2);
  } else if(detector=="Indet") {
    type=key.substr(7,5);
    ind=17;
    ind1=13;
    quantity="";
    if(type=="Align" && key.substr(ind1,2)!="ID") {
      if(key.substr(ind1+3,1)=="_") quantity="DF";
    }
  } else {
    return "";
  }
  if(type=="Calib") {
 
    if(quantity=="DF") {
       result << "TrtDf";
    } else if (quantity=="RT") {
       result <<  "TrtRt";
    } else if (quantity=="T0") {
       result <<  "TrtT0";
    } else {
       return "TrtDe_";
    }
    std::string module=key.substr(ind+3,2);
    result << module;
  } else if(type=="Align") {
    std::string  module=key.substr(ind1,2);
    if(module=="ID" || module=="TR") {
      return "TrtAl_";
    } else {
      result << "TrtAl";
    }
    module=key.substr(ind+3,2);
    result << module;
  } else {
    return "";
  }
  result << "_";
  return result.str();
}

printCondObjects()

void TRT_AlignDbSvc::printCondObjects ( ) const

private

Output the conditions objects currently in memory.

Definition at line 1353 of file TRT_AlignDbSvc.cxx.

                                            {
  ATH_MSG_DEBUG( " In printCondObjects "  );
  ATH_MSG_INFO( " TRT Conditions DB contains " << m_alignobjs.size() <<" AlignableTransforms: "  );
  
  const AlignableTransform *pat;
  std::vector<std::string>::const_iterator iobj=m_alignobjs.begin();
  std::vector<std::string>::const_iterator iobjE=m_alignobjs.end();
  for (;iobj!=iobjE;++iobj) {
    ATH_MSG_INFO( " " << *iobj  );
    pat=cgetTransPtr(*iobj);
    if (pat) {
      pat->print2();
    } else {
      ATH_MSG_ERROR( " Could not find key: " << *iobj  );
    }
  }
 
  ATH_MSG_DEBUG( " Leaving printCondObjects"  );
  return;
}

printTransform()

void TRT_AlignDbSvc::printTransform ( const std::string & thisName, const Amg::Transform3D & transform )

staticprivate

Output the transform to the cout, for debugging.

Out put the transfor to the cout, for debugging.

Definition at line 1448 of file TRT_AlignDbSvc.cxx.

                                                                                               { 
  std::cout << thisName << " " << transform(0,3) << " " << transform(1,3) << "  " << transform(2,3) << std::endl;
  std::cout << thisName << " " << transform(0,0) << " " << transform(0,1) << "  " << transform(0,2) << std::endl;
  std::cout << thisName << " " << transform(1,0) << " " << transform(1,1) << "  " << transform(1,2) << std::endl;
  std::cout << thisName << " " << transform(2,1) << " " << transform(2,1) << "  " << transform(2,2) << std::endl;
  return;
}

readAlignTextFile()

StatusCode TRT_AlignDbSvc::readAlignTextFile

(

const std::string &

file

)

read AlignableTransforms from text file into TDS

first clean the alignment container: loop over all AlignableTransforms and empty them.

force a call back

Definition at line 350 of file TRT_AlignDbSvc.cxx.

                                                                   {
  ATH_MSG_DEBUG( " In  readAlignTextFile " );
  ATH_MSG_INFO( "Read alignment constants from text file: " << file );
  std::ifstream infile;
  infile.open(file.c_str());

  const AlignableTransformContainer* container= getContainer();
  if(container) {
    AlignableTransformContainer* nccontainer = const_cast<AlignableTransformContainer*>(container) ;
 
    DataVector<AlignableTransform>::iterator it=nccontainer->begin();
    DataVector<AlignableTransform>::iterator itE=nccontainer->end();
    for(;it!=itE;++it)
      // there is no 'clear' function in alignable transform, so we do it with this hack
      **it = AlignableTransform( (*it)->tag() ) ;
  } else {
    return StatusCode::FAILURE ;
  }
  
  // loop over file
  int nobj=0;
  int ntrans=0;
  std::string atname;
  AlignableTransform* pat(nullptr) ;
  char line[512] ;
  
  while( infile.getline(line,512) ) {
    if(line[0] != '#') {
      
      std::string linestring(line) ;
      if( linestring.find('/') != std::string::npos) {
    // this must be a line with a container name
    atname = linestring ;
    ATH_MSG_INFO( "now reading container: " << atname  );
    pat=getTransPtr(atname);
    if (!pat) {
      ATH_MSG_ERROR( "Cannot find AlignableTransform object for key " << atname  );
      return StatusCode::FAILURE;
    } else {
      nobj++;
    } 
      } else if(pat!=nullptr) {
    // this must be a line with constants
    std::istringstream is(line) ;
    
    int bec(0),layer(0),sector(0),strawLayer(0);
    double dx,dy,dz,phi,theta,psi;
    
    if(atname == (m_alignDBprefix+"L2A") || atname == (m_alignDBprefix+"L2C") ){
      if( is >> bec >> layer >> strawLayer >> dx >> dy >> dz >> phi ) {
         CLHEP::Hep3Vector translation(dx, dy, dz);
         CLHEP::HepRotation rotation;
         if (is >> theta >> psi) {
           ATH_MSG_DEBUG ("read a line with euler angles!" << phi
                          << " " << theta << " " << psi);
            rotation.set(phi, theta, psi);
         }
        //We have to give a phi sector, so we'll give 0.
        Identifier ident=m_trtid->layer_id(bec,0,layer,strawLayer);
        ATH_MSG_DEBUG( "The identifier is for bec " << bec 
                           << " layer " << layer << " strawLayer " << strawLayer  );
        ATH_MSG_DEBUG( "The code is  " << m_trtid->show_to_string(ident)  );
        if( pat->findIdent(ident)!=pat->end() ) {
          ATH_MSG_WARNING ("WARNING: read module from file which was already in AlignableTransform. Will skip it."
                               << " bec,lay,sec,strawlay = " << bec << " " << layer << " " << sector << " " );
        } else {
          pat->add(ident,HepGeom::Transform3D(rotation, translation));
          HepGeom::Transform3D testtrans = HepGeom::Transform3D(rotation, translation);
          if(msgLvl(MSG::DEBUG)){
        std::string thisMess = atname+" for "+file;
        printTransform(thisMess,Amg::CLHEPTransformToEigen(testtrans));
          }
 
 
          ++ntrans;
          ATH_MSG_DEBUG( "Set transform: "
                             << " [" << bec << "," << layer << ","  << strawLayer 
                             << "] key " << atname 
                             << " rotation=(" << phi << "," << theta << "," << psi
                             << "),  translation=(" << dx << "," << dy << "," << dz << "])" 
                             );
        }
      } else if(!linestring.empty()) {
        ATH_MSG_WARNING( "Read invalid line from textfile. Line=\'" << line << "\'"  );
      }
    }//if endcap
    else{
      if( is >> bec >> layer >> sector >> dx >> dy >> dz >> phi ) {
        CLHEP::Hep3Vector translation(dx,dy,dz)  ;
        CLHEP::HepRotation rotation;
        if( is >> theta >> psi ) {
          ATH_MSG_DEBUG( "read a line with euler angles!" << phi << " " << theta << " " << psi );
            rotation.set(phi,theta,psi) ;
 
        } else {
          ATH_MSG_DEBUG( "read a line with angle in phi!" << phi  );
          rotation = CLHEP::HepRotationZ(phi) ;
        }
        
        Identifier ident=m_trtid->module_id(bec,sector,layer);
        if( pat->findIdent(ident)!=pat->end() ) {
          ATH_MSG_WARNING ("WARNING: read module from file which was already in AlignableTransform. Will skip it."
                               << " bec,lay,sec = " << bec << " " << layer << " " << sector);
        } else {
          pat->add(ident,HepGeom::Transform3D(rotation, translation));
          ++ntrans ;
          ATH_MSG_DEBUG( "Set transform: "
                             << " [" << bec << "," << layer << "," << sector 
                             << "] key " << atname << " rotation=(" << phi << "," << theta << "," << psi
                             << "),  translation=(" << dx << "," << dy << "," << dz << "])"  );
        }
      } else if(!linestring.empty()) {
        ATH_MSG_WARNING( "Read invalid line from textfile. Line=\'" << line << "\'"  );
      }
    }//if not the endcap
 
    
      }//if pat!=0
    }//if line != "#"
  }//while 
 
  infile.close() ;
  ATH_MSG_INFO( "Read " << nobj << " objects from file with " << ntrans << " transforms." 
                << " Now forcing callback in detector manager."  );

  if((const_cast<InDetDD::TRT_DetectorManager*>(m_trtman))->align().isFailure()){
    ATH_MSG_ERROR("Failed to force the alignment callback!" );
  }
  
  ATH_MSG_DEBUG( " Leaving  readAlignTextFile "  );
  return StatusCode::SUCCESS;
}  

registerAlignObjects()

StatusCode TRT_AlignDbSvc::registerAlignObjects	(	const std::string &	tag,
		int	run1,
		int	event1,
		int	run2,
		int	event2 ) const

register alignment objects with the IoV service

Definition at line 514 of file TRT_AlignDbSvc.cxx.

                                                                                                                      {
  
  ATH_MSG_INFO( "registerAlignObjects with IOV "  );
  ATH_MSG_INFO( "Run/evt1 [" << run1 << "," << event1 << "]"  );
  ATH_MSG_INFO( "Run/evt2 [" << run2 << "," << event2 << "]"  );
 
  // get pointer to registration svc
  SmartIF<IIOVRegistrationSvc> regsvc(service("IOVRegistrationSvc"));
  ATH_CHECK( regsvc.isValid() );
  
  if (StatusCode::SUCCESS==regsvc->registerIOV("AlignableTransformContainer",m_alignroot,tag,run1,run2,event1,event2)){
    ATH_MSG_INFO( " Register AlignableTransformContainer object " 
                  << m_alignroot  );
  } else {
    ATH_MSG_ERROR( " Failed to register AlignableTranformContainer " 
                   << m_alignroot  );
    return StatusCode::FAILURE;
  }
  
  return StatusCode::SUCCESS;
}

setAlignTransform()

StatusCode TRT_AlignDbSvc::setAlignTransform	(	Identifier	ident,
		Amg::Transform3D	trans,
		unsigned int	level )

set AlignableTransform for an identifier

Definition at line 674 of file TRT_AlignDbSvc.cxx.

                                                                                                       {
  ATH_MSG_DEBUG( "In getAlignmentTransform"  );
  
  if(level != 1 && level != 2 && level != 3){
    ATH_MSG_FATAL( "Call to setAlignTransform wrong!"  );
    ATH_MSG_FATAL( "Level must be 1,2 or 3!"  );
    return StatusCode::FAILURE;
  }
 
  switch (level) {
    
  case 1:
    ATH_CHECK( setAlignTransformL1(ident,trans) );
    break;
  case 2:
    ATH_CHECK( setAlignTransformL2(ident,trans) );
    break;
  case 3:
    ATH_CHECK( setAlignTransformL3(ident,trans) );
    break;
  }
 
  return StatusCode::SUCCESS;
}

setAlignTransformL1()

StatusCode TRT_AlignDbSvc::setAlignTransformL1 ( Identifier ident, const Amg::Transform3D & trans )

private

set Level 1 AlignableTransform for an identifier

AlignableTransform for the subdetector containing ident or add a new one.

Definition at line 700 of file TRT_AlignDbSvc.cxx.

                                                                                            {
  ATH_MSG_DEBUG( "In setAlignTransformL1"  );
  if(msgLvl(MSG::DEBUG)){
    printTransform("Transform in setAlignTransformL1",trans);
  }
 
  // New additions for new global folder structure
  // No ATs exist for levels 1 & 2 --> need alternative
  if (m_dynamicDB){
    if(!tweakGlobalFolder(ident, trans)) {
      ATH_MSG_ERROR( "Attempt tweak GlobalDB folder failed" );
      return StatusCode::FAILURE;
    }
  }
  else {
  
    //does a folder exist corresponding to this identifier?
    AlignableTransform* pat=getTransPtr("/TRT/Align/TRT");
    if (!pat){
      ATH_MSG_FATAL( "The AlignableTransform for key " << "/TRT/Align/TRT" << " does not exist "  );
      ATH_MSG_FATAL( "Failing ... "  );
      return StatusCode::FAILURE;
    }
    
    // make sure the identifier is a "subdetector identifier"
    if( !(m_trtid->is_trt(ident)) ){
      ATH_MSG_FATAL( "The identifier " << ident << " is not from the TRT "  );
      ATH_MSG_FATAL( "Failing ... "  );
      return StatusCode::FAILURE;
    }
    
    int bec=m_trtid->barrel_ec(ident);
    Identifier mid=m_trtid->module_id(bec,0,0);
    // update or add (mid,trans) pair
    HepGeom::Transform3D clhepTrans = Amg::EigenTransformToCLHEP(trans);
    if( !(pat->update(mid,clhepTrans)) ) {
      pat->add(mid,clhepTrans);
      pat->sortv() ;
    }
  }
 
  ATH_MSG_DEBUG( "Leaving setAlignTransformL1"  );
  return StatusCode::SUCCESS;
}

setAlignTransformL2()

StatusCode TRT_AlignDbSvc::setAlignTransformL2 ( Identifier ident, Amg::Transform3D trans )

private

set Level 2 AlignableTransform for an identifier

AlignableTransform for the module containing ident or add a new one.

Definition at line 749 of file TRT_AlignDbSvc.cxx.

                                                                                      {
  ATH_MSG_DEBUG( "In setAlignTransformL2"   );
  
  //does a folder exist corresponding to this identifier?
  std::string key=findkey(ident,m_alignString);
  AlignableTransform* pat=getTransPtr(key);
  if (!pat) return StatusCode::FAILURE;
  
  // make sure the identifier is a "module identifier"
  if( !(m_trtid->is_trt(ident)) ) return StatusCode::FAILURE;
  int bec=m_trtid->barrel_ec(ident);
  int layer=m_trtid->layer_or_wheel(ident);
  int sector=m_trtid->phi_module(ident);
  int strawLayer=m_trtid->straw_layer(ident);
  int ring = getRingForStrawLayer(strawLayer);
  Identifier ident2;
 
  ATH_MSG_DEBUG( "Setting the L2 Alignment for: " 
                 << " Bec= " << bec << " layer= " << layer << " sector= " << sector 
                 << " strawLayer= " << strawLayer  );
  ATH_MSG_DEBUG( "The translations are: x= " << trans(0,3) << " y= "<<trans(1,3) << " z= "<<trans(2,3)  );
 
  if(key == (m_alignDBprefix+"L2A") || key == (m_alignDBprefix+"L2C"))
    ident2=m_trtid->layer_id(bec,0,layer,ring);    
  else
    ident2=m_trtid->module_id(bec,sector,layer);
 
  // make sure the identifier is a TRT identifier
  if( !(m_trtid->is_trt(ident2)) ){
    ATH_MSG_FATAL( "The identifier " << ident2 << " is not from the TRT "  );
    ATH_MSG_FATAL( "Failing ... "  );
    return StatusCode::FAILURE;
  }
  
  // update or add (mid,trans) pair
  HepGeom::Transform3D clhepTrans = Amg::EigenTransformToCLHEP(trans);
  if( !(pat->update(ident2,clhepTrans)) ) {
    pat->add(ident2,clhepTrans);
    pat->sortv() ;
  }
  
  ATH_MSG_DEBUG( "Leaving setAlignTransformL2 "   );
  return StatusCode::SUCCESS;
}

setAlignTransformL3()

StatusCode TRT_AlignDbSvc::setAlignTransformL3 ( Identifier ident, Amg::Transform3D trans )

private

set Level 3 AlignableTransform for an identifier

Definition at line 798 of file TRT_AlignDbSvc.cxx.

                                                                                      {
  ATH_MSG_DEBUG( "In setAlignTransformL3"   );
    
  // make sure the identifier is a "module identifier"
  if( !(m_trtid->is_trt(ident)) ) return StatusCode::FAILURE;
  int bec=m_trtid->barrel_ec(ident);
  
  //Only L3 in the barrel is currently supported 
  if(abs(bec) == 1){
    
    // Currently at L3 only displacements in the plane of the straw layer can be stored.
    // For tracks coming from the interaction point this coorisponds to the sensitive coordinate
    ATH_MSG_INFO("Storing L3 Barrel constants, Only dx and rotz will be written to DB");
    float dx = trans.translation().x();
    float rotz = std::atan2(trans.rotation()(0,1),trans.rotation()(0,0));
 
    // Need the length of the wires to translate the rotation to a translation.
    const InDetDD::TRT_BaseElement* strawElement =  m_trtman->getElement( ident );
    double strawLenthOver2 = 0.5* strawElement->strawLength();
 
    // The alignment frames are the same for straws on side A and side C (verrify this!!)
    // but variables stored in the db are not. We'll calculate the dispacement of each end 
    // in the alignment frame and in a second step, convert to the values in the DB. 
    double delta_dx_atLargerZ = dx + strawLenthOver2 * std::sin(rotz);
    double delta_dx_atSmallerZ = dx - strawLenthOver2 * std::sin(rotz);
    
    // For the definition of dx1 and dx2 see TRT_ConditionsData/StrawDx.h
    // Now we need to know the real meaning of dx1 and dx2. Alas, we
    // are in the frame of either of the two barrel sides, but not
    // both, so we need to know which one.
    bool sideA = m_trtid->barrel_ec(ident) == 1;
    
    // Straw position closest to the electronics 
    double dx1_new = sideA ? delta_dx_atLargerZ : delta_dx_atSmallerZ;
    
    // Straw position away from the electronics 
    double dx2_new = sideA ? delta_dx_atSmallerZ : delta_dx_atLargerZ;
 
    // Uncertianty on straw positions (Arbitrary for now)
    double dxErr = 0.001;
    
    m_trtStrawAlignDbSvc->setDx(ident, dx1_new, dx2_new, dxErr);
  }else{
    // Currently at L3 only displacements in the plane of the straw layer can be stored.
    // For tracks coming from the interaction point this coorisponds to the sensitive coordinate
    ATH_MSG_INFO("Storing L3 Endcap constants, Only dy and rotz will be written to DB");
    
    // The expected transformation is in the local frame of the Endcap Straws
    // In the local straw frame:
    //   - the z-axis is along the straw and points toward the beampipe
    //   - the x-axis is along global-z and away from the interaction point 
    //          (locX = globZ A-side / locX = -1 *gobZ C-side) 
    //   - the y-axis is along global phi_hat direction determined by the other 2. 
    //          (clockwise C-side, counter clockwise A-Side)
    float dy = trans.translation().y();
    float rotx = std::atan2(trans.rotation()(1,2),trans.rotation()(2,2));
 
    // Need the length of the wires to translate the rotation to a translation.
    const InDetDD::TRT_BaseElement* strawElement =  m_trtman->getElement( ident );
    double strawLenthOver2 = 0.5* strawElement->strawLength();
 
    // In the global frame, 'dx1' corresponds to the readout side and 'dx2'
    // to the side closest the beampipe.
    double delta_dx_nearBeamPipe = dy + strawLenthOver2 * std::sin(rotx);
    double delta_dx_nearReadOut = dy - strawLenthOver2 * std::sin(rotx);
    
    // Uncertianty on straw positions (Arbitrary for now)
    double dxErr = 0.001;
    
    m_trtStrawAlignDbSvc->setDx(ident, delta_dx_nearReadOut, delta_dx_nearBeamPipe, dxErr);
  }
  
  ATH_MSG_DEBUG( "Leaving setAlignTransformL3 "   );
  return StatusCode::SUCCESS;
}

streamOutAlignObjects()

StatusCode TRT_AlignDbSvc::streamOutAlignObjects

(

)

const

write the alignment objects to output

Definition at line 488 of file TRT_AlignDbSvc.cxx.

                                                      {
  ATH_MSG_DEBUG( "In streamOutAlignObjects "   );
 
  // Get Output Stream tool for writing
  ATH_CHECK( m_streamer.retrieve() );
  
  IAthenaOutputStreamTool*  streamer=const_cast<IAthenaOutputStreamTool*>(&(*m_streamer));
  
  ATH_CHECK( streamer->connectOutput() );
  
  IAthenaOutputStreamTool::TypeKeyPairs  typeKeys;
  IAthenaOutputStreamTool::TypeKeyPair arraypair("AlignableTransformContainer",m_alignroot);
  typeKeys.push_back(arraypair);
  ATH_CHECK( m_detStore->contains<AlignableTransformContainer>(m_alignroot) );
  
  ATH_CHECK( streamer->streamObjects(typeKeys) );
  ATH_CHECK( streamer->commitOutput() );
  
  ATH_MSG_INFO( "   Streamed out and committed AlignableTransformContainer"  );
  printCondObjects() ;
 
  ATH_MSG_DEBUG( "Leaving streamOutAlignObjects "   );
  return StatusCode::SUCCESS;
}

tweakAlignTransform()

StatusCode TRT_AlignDbSvc::tweakAlignTransform	(	Identifier	ident,
		Amg::Transform3D	trans,
		unsigned int	level )

tweak AlignableTransform for an identifier

Definition at line 875 of file TRT_AlignDbSvc.cxx.

                                                                                                         {
  
  ATH_MSG_DEBUG( "In tweakAlignTransform"  );
  
  if(level != 1 && level != 2 && level != 3){
    ATH_MSG_FATAL( "Incorrect call to tweakTrans"  );
    ATH_MSG_FATAL( "level must be 1,2 or 3"  );
    return StatusCode::FAILURE;
  }
  
  if(level == 1){
    if(tweakAlignTransformL1(ident,trans).isFailure()){
      
      ATH_MSG_WARNING( "tweak failed...just setting it."  );
      
      if(setAlignTransformL1(ident,trans).isFailure()){
    ATH_MSG_FATAL( "Set also failed!"  );
    ATH_MSG_FATAL( "Fail for real."  );
    return StatusCode::FAILURE;
      }
    }
  }
  
  else if(level == 2){
    if(tweakAlignTransformL2(ident,trans).isFailure()){
      
      ATH_MSG_WARNING( "tweak failed...just setting it."  );
      
      if(setAlignTransformL2(ident,trans).isFailure()){
    ATH_MSG_FATAL( "Set also failed!"  );
    ATH_MSG_FATAL( "Fail for real."  );
    return StatusCode::FAILURE;
      }
    }    
  }
  
  else if(level == 3){
    if(tweakAlignTransformL3(ident,trans).isFailure()){
      
      ATH_MSG_WARNING( "tweak failed...just setting it."  );
      
      if(setAlignTransformL3(ident,trans).isFailure()){
    ATH_MSG_FATAL( "Set also failed!"  );
    ATH_MSG_FATAL( "Fail for real."  );
    return StatusCode::FAILURE;
      }
    }    
  }
    
  ATH_MSG_DEBUG( "Leaving tweakAlignTransform"  );
  return StatusCode::SUCCESS;
}

tweakAlignTransformL1()

StatusCode TRT_AlignDbSvc::tweakAlignTransformL1 ( Identifier ident, const Amg::Transform3D & trans )

private

tweak Level 1 AlignableTransform for an identifier

multiply level 1 AlignableTransform for the module containing ident by an additional transform.

does a folder exist corresponding to this identifier?

OK the key exists make sure the identifier is a "subdetector identifier"

multiply the additional transformation

Definition at line 929 of file TRT_AlignDbSvc.cxx.

                                                                                              {
  ATH_MSG_DEBUG( "In tweakAlignTransformL1"  );
 
  // New additions for new global folder structure                                                                                                                    
  // No ATs exist for levels 1 & 2 --> need alternative                                                                                                               
  if (m_dynamicDB){
    if(!tweakGlobalFolder(ident, trans)) {
      ATH_MSG_ERROR( "Attempt tweak GlobalDB folder failed" );
      return StatusCode::FAILURE;
    }
  }
  else {
    
    AlignableTransform* pat=getTransPtr("/TRT/Align/TRT");
    if (!pat){
      ATH_MSG_WARNING( "The AlignableTransform for key " << "/TRT/Align/TRT" << " does not exist "  );
      ATH_MSG_WARNING( "Failing ... "  );
      return StatusCode::FAILURE;
    }
    
    if( !(m_trtid->is_trt(ident)) ){
      ATH_MSG_WARNING( "The identifier " << ident << " is not from the TRT "  );
      ATH_MSG_WARNING( "Failing ... "  );
      return StatusCode::FAILURE;
    }
    
    int bec=m_trtid->barrel_ec(ident);
    Identifier mid=m_trtid->module_id(bec,0,0);
    
    if( !(pat->tweak(mid,Amg::EigenTransformToCLHEP(trans))) ){
      ATH_MSG_WARNING( "The Alignable transfor tweek failed for " << mid  );
      ATH_MSG_WARNING( "Failing ... "  );
      return StatusCode::FAILURE;
    }
  }
 
  ATH_MSG_DEBUG( "Leaving tweakAlignTransformL1"  );
  return StatusCode::SUCCESS;
}

tweakAlignTransformL2()

StatusCode TRT_AlignDbSvc::tweakAlignTransformL2 ( Identifier ident, const Amg::Transform3D & trans )

private

tweak Level 2 AlignableTransform for an identifier

Definition at line 978 of file TRT_AlignDbSvc.cxx.

                                                                                              {
  ATH_MSG_DEBUG( "In tweakAlignTransformL2"  );
  // multiply level 2 AlignableTransform for the module containing ident
  // by an additional transform.
 
  //does a folder exist corresponding to this identifier?
  std::string key=findkey(ident,m_alignString);
  AlignableTransform* pat=getTransPtr(key);
  if (!pat){
    ATH_MSG_WARNING( "The transfor for key: " << key << "Does not exist"  );
    ATH_MSG_WARNING( " Failing ... "  );
    return StatusCode::FAILURE;
  }
 
  //OK the key exists
  // make sure the identifier is a "module identifier"
  if( !(m_trtid->is_trt(ident)) ) return StatusCode::FAILURE;
  int bec=m_trtid->barrel_ec(ident);
  int layer=m_trtid->layer_or_wheel(ident);
  int sector=m_trtid->phi_module(ident);
  int strawLayer=m_trtid->straw_layer(ident);
  int ring = getRingForStrawLayer(strawLayer);
  Identifier mid;
  if(key == (m_alignDBprefix+"L2A") || key == (m_alignDBprefix+"L2C"))
    mid = m_trtid->layer_id(bec,0,layer,ring);
  else
    mid = m_trtid->module_id(bec,sector,layer);
 
  // multiply the additional transformation
  if( !(pat->tweak(mid,Amg::EigenTransformToCLHEP(trans))) ){
    ATH_MSG_WARNING( "Leaving tweakAlignTransformL2.  TWEAK FAILED!!"  );
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG( "Leaving tweakAlignTransformL2"  );
  return StatusCode::SUCCESS;
}

tweakAlignTransformL3()

StatusCode TRT_AlignDbSvc::tweakAlignTransformL3 ( Identifier ident, Amg::Transform3D trans )

private

tweak Level 3 AlignableTransform for an identifier

Definition at line 1017 of file TRT_AlignDbSvc.cxx.

                                                                                        {
  ATH_MSG_DEBUG( "In tweakAlignTransformL3"   );
    
  // make sure the identifier is a "module identifier"
  if( !(m_trtid->is_trt(ident)) ) return StatusCode::FAILURE;
  int bec=m_trtid->barrel_ec(ident);
  
  //Only L3 in the barrel is currently supported 
  if(abs(bec) == 1){
    
    // Currently at L3 only displacements in the plane of the straw layer can be stored.
    // For tracks coming from the interaction point this coorisponds to the sensitive coordinate
    ATH_MSG_INFO("Storing L3 constants, Only dx and rotz will be written to DB");
    float dx = trans.translation().x();
 
    ATH_MSG_DEBUG("xx: " << trans.rotation()(0,0));    
    ATH_MSG_DEBUG("xy: " << trans.rotation()(0,1));    
    ATH_MSG_DEBUG("xz: " << trans.rotation()(0,2));    
    ATH_MSG_DEBUG("yx: " << trans.rotation()(1,0));    
    ATH_MSG_DEBUG("yy: " << trans.rotation()(1,1));    
    ATH_MSG_DEBUG("yz: " << trans.rotation()(1,2));    
    ATH_MSG_DEBUG("zx: " << trans.rotation()(2,0));    
    ATH_MSG_DEBUG("zy: " << trans.rotation()(2,1));    
    ATH_MSG_DEBUG("zz: " << trans.rotation()(2,2));    
    
    // For the definition of dx1 and dx2 see TRT_ConditionsData/StrawDx.h
    // Now we need to know the real meaning of dx1 and dx2. Alas, we
    // are in the frame of either of the two barrel sides, but not
    // both, so we need to know which one.
    bool sideA = m_trtid->barrel_ec(ident) == 1;
 
    float rotz = std::atan2(trans.rotation()(0,2),trans.rotation()(0,0));
 
    // Need the length of the wires to translate the rotation to a translation.
    const InDetDD::TRT_BaseElement* strawElement =  m_trtman->getElement( ident );
    double strawLenthOver2 = 0.5* strawElement->strawLength();
 
    // Old way (buggy)
    //double delta_dx_atLargerZ = dx + strawLenthOver2 * std::sin(rotz);
    //double delta_dx_atSmallerZ = dx - strawLenthOver2 * std::sin(rotz);
 
    // New way - The rotation is opposite for side A as compared to side C
    double delta_dx_atLargerZ;
    double delta_dx_atSmallerZ;
    if (sideA){
      delta_dx_atLargerZ = dx - strawLenthOver2 * std::sin(rotz);
      delta_dx_atSmallerZ = dx + strawLenthOver2 * std::sin(rotz);
    }
    else{
      delta_dx_atLargerZ = dx + strawLenthOver2 * std::sin(rotz);
      delta_dx_atSmallerZ = dx - strawLenthOver2 * std::sin(rotz);
    }
 
    // Straw position closest to the electronics 
    double delta_dx1 = sideA ? delta_dx_atLargerZ : delta_dx_atSmallerZ;
    
    // Straw position away from the electronics 
    double delta_dx2 = sideA ? delta_dx_atSmallerZ : delta_dx_atLargerZ;
 
    // Uncertianty on straw positions
    double dxErr = 0.001;
    
    // now we do some gymnastics: because the strawdisplacement is
    // binned, we would rather not just 'add' the current change,
    // but rather 'set' the total change. note that this goes
    // wrong if there were other straw corrections
    // applied. We might have to worry about that at
    // some point. 
    double dx1_current = m_trtStrawAlignDbSvc->getDx1(ident);
    double dx2_current = m_trtStrawAlignDbSvc->getDx2(ident) ;
    ATH_MSG_DEBUG("Current dx1 is: " << dx1_current);
    ATH_MSG_DEBUG("Current dx2 is: " << dx2_current);
    
    double dx1_new = dx1_current + delta_dx1;
    double dx2_new = dx2_current + delta_dx2;
 
    //ATH_MSG_INFO("New dx1 is: " << dx1_new);
    //ATH_MSG_INFO("New dx2 is: " << dx2_new);
 
    m_trtStrawAlignDbSvc->setDx(ident, dx1_new, dx2_new, dxErr);
  }else{
    
    // Currently at L3 only displacements in the plane of the straw layer can be stored.
    // For tracks coming from the interaction point this coorisponds to the sensitive coordinate
    ATH_MSG_INFO("Storing L3 Endcap constants, Only dy and rotz will be written to DB");
    
    // The expected transformation is in the local frame of the Endcap Straws
    // In the local straw frame:
    //   - the z-axis is along the straw and points toward the beampipe
    //   - the x-axis is along global-z and away from the interaction point 
    //          (locX = globZ A-side / locX = -1 *gobZ C-side) 
    //   - the y-axis is along global phi_hat direction determined by the other 2. 
    //          (clockwise C-side, counter clockwise A-Side)
    float dy = trans.translation().y();
    float rotx = std::atan2(trans.rotation()(1,2),trans.rotation()(2,2));
 
    // Need the length of the wires to translate the rotation to a translation.
    const InDetDD::TRT_BaseElement* strawElement =  m_trtman->getElement( ident );
    double strawLenthOver2 = 0.5* strawElement->strawLength();
 
    // In the global frame, 'dx1' corresponds to the readout side and 'dx2'
    // to the side closest the beampipe.
    double delta_dx_nearBeamPipe = dy + strawLenthOver2 * std::sin(rotx);
    double delta_dx_nearReadOut = dy - strawLenthOver2 * std::sin(rotx);
 
    // Uncertianty on straw positions
    double dxErr = 0.001;
 
    // now we do some gymnastics: because the strawdisplacement is
    // binned, we would rather not just 'add' the current change,
    // but rather 'set' the total change. note that this goes
    // wrong if there were other straw corrections
    // applied. We might have to worry about that at
    // some point. 
    double dx1_current = m_trtStrawAlignDbSvc->getDx1(ident);
    double dx2_current = m_trtStrawAlignDbSvc->getDx2(ident) ;
    ATH_MSG_DEBUG("Current dx1 is: " << dx1_current);
    ATH_MSG_DEBUG("Current dx2 is: " << dx2_current);
    
    double dx1_new = dx1_current + delta_dx_nearReadOut;
    double dx2_new = dx2_current + delta_dx_nearBeamPipe;
 
    m_trtStrawAlignDbSvc->setDx(ident, dx1_new, dx2_new, dxErr);
  }
  
  ATH_MSG_DEBUG( "Leaving tweakAlignTransformL3 "   );
  return StatusCode::SUCCESS;
}

tweakGlobalFolder()

StatusCode TRT_AlignDbSvc::tweakGlobalFolder	(	Identifier	ident,
		const Amg::Transform3D &	trans )

tweak L1 DB for global folders for an identifier

Definition at line 1506 of file TRT_AlignDbSvc.cxx.

                                                                                           {
 
  // find transform key, then set appropriate transform
  const CondAttrListCollection* atrlistcol1=nullptr;
  CondAttrListCollection* atrlistcol2=nullptr;
  bool result = false;
  std::string key="/TRT/AlignL1/TRT";
  ATH_MSG_DEBUG( " Identifier is valid: "<< ident.is_valid()  );
  int bec=m_trtid->barrel_ec(ident);
  const unsigned int DBident=1000+bec*100;
  // so far not a very fancy DB identifier, but seems elaborate enough for this simple structure
 
  if (StatusCode::SUCCESS==m_detStore->retrieve(atrlistcol1,key)) {
    // loop over objects in collection
    atrlistcol2 = const_cast<CondAttrListCollection*>(atrlistcol1);
    if (atrlistcol1!=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){
          ATH_MSG_DEBUG( "tweakGlobalFolder fails due to identifier mismatch"  );
          continue;
    }
        else {
          ATH_MSG_DEBUG( "Tweak Old global DB -- channel: " << citr->first
                         << " ,bec: "    << atrlist2["bec"].data<int>()
                         << " ,layer: "  << atrlist2["layer"].data<int>()
                         << " ,sector: " << atrlist2["sector"].data<int>()
                         << " ,Tx: "     << atrlist2["Tx"].data<float>()
                         << " ,Ty: "     << atrlist2["Ty"].data<float>()
                         << " ,Tz: "     << atrlist2["Tz"].data<float>()
                         << " ,phi: "    << atrlist2["phi"].data<float>()
                         << " ,theta: "  << atrlist2["theta"].data<float>()
                         << " ,psi: "    << atrlist2["psi"].data<float>()  );
 
 
          // Follow same definitions as in TRT_AlignDbSvc.cxx                                                                                               
      CLHEP::Hep3Vector  oldtranslation(atrlist2["Tx"].data<float>(),atrlist2["Ty"].data<float>(),atrlist2["Tz"].data<float>());
      CLHEP::HepRotation oldrotation;
      oldrotation.set(atrlist["phi"].data<float>(),atrlist["theta"].data<float>(),atrlist["psi"].data<float>());
      HepGeom::Transform3D oldtransform(oldrotation, oldtranslation);
          
          // get the new transform
      HepGeom::Transform3D newtrans = Amg::EigenTransformToCLHEP(trans)*oldtransform;
      Amg::Transform3D newtransAMG = trans*Amg::CLHEPTransformToEigen(oldtransform);
 
          // Extract the values we need to write to DB
      Amg::Vector3D shift=newtransAMG.translation();
      CLHEP::HepRotation rot=newtrans.getRotation();
      Amg::Vector3D eulerangles;
          eulerangles[0] = rot.getPhi();
          eulerangles[1] = rot.getTheta();
          eulerangles[2] = rot.getPsi();      
 
          atrlist2["Tx"].data<float>() = shift.x();
          atrlist2["Ty"].data<float>() = shift.y();
          atrlist2["Tz"].data<float>() = shift.z();
          atrlist2["phi"].data<float>()   = eulerangles[0] ;
          atrlist2["theta"].data<float>() = eulerangles[1] ;
          atrlist2["psi"].data<float>()   = eulerangles[2] ;
 
      result = true;
      ATH_MSG_DEBUG( "Tweak New global DB -- channel: " << citr->first
                         << " ,bec: "    << atrlist2["bec"].data<int>()
                         << " ,layer: "  << atrlist2["layer"].data<int>()
                         << " ,sector: " << atrlist2["sector"].data<int>()
                         << " ,Tx: "     << atrlist2["Tx"].data<float>()
                         << " ,Ty: "     << atrlist2["Ty"].data<float>()
                         << " ,Tz: "     << atrlist2["Tz"].data<float>()
                         << " ,phi: "    << atrlist2["phi"].data<float>()
                         << " ,theta: "  << atrlist2["theta"].data<float>()
                         << " ,psi: "    << atrlist2["psi"].data<float>()  );
 
        }
      }
    }
    else {
      ATH_MSG_ERROR("tweakGlobalFolder: cast fails for DBident " << DBident );
      return StatusCode::FAILURE;
    }
  }
  else {
    ATH_MSG_ERROR("tweakGlobalFolder: cannot retrieve CondAttrListCollection for key " << key );
    return StatusCode::FAILURE;
  }
 
  if (result) return StatusCode::SUCCESS;
  else return StatusCode::FAILURE;
}

writeAlignTextFile()

StatusCode TRT_AlignDbSvc::writeAlignTextFile

(

const std::string &

file

)

const

write AlignableTransforms to flat text file

Loop over created AlignableTransforms

Only write out new keys unless explicitly ask for old keys

The object must exist in detector store

Keep track of total number of transforms

get the relavent identifing info

Get the translation and rotation

Definition at line 216 of file TRT_AlignDbSvc.cxx.

{
  ATH_MSG_DEBUG(" in writeAlignTextFile ");
  ATH_MSG_INFO( " Write AlignableTransforms to text file: "<< file );
  std::ofstream  outfile(file);
 
  int ntrans=0;
  int nobj=0;

  std::vector<std::string>::const_iterator iobj=m_alignobjs.begin();
  std::vector<std::string>::const_iterator iobjE=m_alignobjs.end();
  for (;iobj!=iobjE; ++iobj) {
    const AlignableTransform* pat=cgetTransPtr(*iobj);
    std::string key=*iobj;
    
    if(isOldKey(key) && m_alignString != "ALold")
      continue;

    if (!pat){
      ATH_MSG_ERROR( "Cannot find AlignableTransform for key "<< key  );
      ATH_MSG_ERROR( "Skipping it. "  );
      outfile << key << std::endl;
      continue;
    }
    
    // first record is the name
    ATH_MSG_INFO( " Write folder: " << key  );
    outfile << key << std::endl;
    ++nobj;
    
    // loop over all transforms in the AlignableTransform object
    AlignableTransform::AlignTransMem_citr cit= pat->begin();
    AlignableTransform::AlignTransMem_citr citE= pat->end();
    for (;cit!=citE;++cit) {
      
      int bec(0);
      int layer(0);
      int sector(0);
      int strawLayer(0);
      
      ++ntrans;
      
      const Identifier& ident=cit->identify();
      bec=m_trtid->barrel_ec(ident);
      layer=m_trtid->layer_or_wheel(ident);
      sector=m_trtid->phi_module(ident);
      strawLayer=m_trtid->straw_layer(ident);
       
      const Amg::Transform3D& trans = Amg::CLHEPTransformToEigen(cit->transform());
 
      if(msgLvl(MSG::DEBUG)){
    std::string thisMess = key+" for "+file;
    printTransform(thisMess,trans);
      }
 
 
      HepGeom::Transform3D transCLHEP  =  Amg::EigenTransformToCLHEP(trans);
      CLHEP::HepRotation rot=transCLHEP.getRotation(); 
      Amg::Vector3D eulerangles;
      eulerangles[0] = rot.getPhi();
      eulerangles[1] = rot.getTheta();
      eulerangles[2] = rot.getPsi();
 
      Amg::Vector3D shift=trans.translation();
      //Matthias: was initially 2,1,2 --> this should be equivalent to complicated method above
      //Amg::Vector3D eulerangles = trans.rotation().eulerAngles(2,0,2) ; 
 
      if(key == (m_alignDBprefix+"L2A") || key == (m_alignDBprefix+"L2C") ){
 
    ATH_MSG_INFO( "   Write member: "
                      << ident << " " << bec << " " << layer << " " << strawLayer << " "  << key  );
    
    outfile << bec << " " << layer << " " << strawLayer << " "
         << std::setprecision(10) << " "
         << shift.x() << " " << shift.y() << " " << shift.z() << " "
         << eulerangles[0] << " " << eulerangles[1] << " " << eulerangles[2]
         << std::endl;
 
    ATH_MSG_DEBUG( "Writing transform to log file "  );
    ATH_MSG_DEBUG( bec << " " << layer << " " << strawLayer << " "
            << std::setprecision(10) << " "
            << shift.x() << " " << shift.y() << " " << shift.z() << " "
                << eulerangles[0] << " " << eulerangles[1] << " " << eulerangles[2]
                       );
 
      }else{
    //Need to validate this for writing out L1 Endcap alignments 
    ATH_MSG_INFO( "   Write member: "
                      << ident << " " << bec << " " << layer << " " << sector << " "  << key  );
    
    outfile << bec << " " << layer << " " << sector << " "
         << std::setprecision(10) << " "
         << shift.x() << " " << shift.y() << " " << shift.z() << " "
         << eulerangles[0] << " " << eulerangles[1] << " " << eulerangles[2]
         << std::endl;
 
    ATH_MSG_DEBUG( "Writing transform to log file "  );
    ATH_MSG_DEBUG( bec << " " << layer << " " << sector << " "
            << std::setprecision(10) << " "
            << shift.x() << " " << shift.y() << " " << shift.z() << " "
                << eulerangles[0] << " " << eulerangles[1] << " " << eulerangles[2]
                       );
      }
      
    }
  }
  
  outfile.close();
  
  ATH_MSG_INFO( "Written " << nobj << " AlignableTransform objects" << " with " << ntrans 
         << " transforms to text file" );
  
  ATH_MSG_DEBUG( " leaving writeAlignTextFile " );
  return StatusCode::SUCCESS;
}

writeGlobalFolderFile()

StatusCode TRT_AlignDbSvc::writeGlobalFolderFile

(

const std::string &

file

)

const

Definition at line 1457 of file TRT_AlignDbSvc.cxx.

        {
 
  if (m_dynamicDB){
    ATH_MSG_DEBUG( "writeFile: Write GlobalFolder DB in text file: " << file );
    std::ofstream outfile(file);
    std::vector<std::string> folder_list = {"/TRT/AlignL1/TRT"};
 
    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==m_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["bec"].data<int>()
                    << " "     << atrlist["layer"].data<int>()
                    << " "     << atrlist["sector"].data<int>()
                    << " "     << atrlist["Tx"].data<float>()
                    << " "     << atrlist["Ty"].data<float>()
                    << " "     << atrlist["Tz"].data<float>()
                    << " "     << atrlist["phi"].data<float>()
                    << " "     << atrlist["theta"].data<float>()
                    << " "     << atrlist["psi"].data<float>() << std::endl;
        }
      }
      else {
        if (msgLvl(MSG::INFO)){
          ATH_MSG_INFO( "Cannot find " << *it << " Container - cannot write DB in text file "  );
      return StatusCode::FAILURE;
    }
      }
    }
 
    return StatusCode::SUCCESS;
  }
  else {
    ATH_MSG_DEBUG( "writeFile: No dynamic Run2 DB structure is present --> skipping writing file " << file );
    return StatusCode::SUCCESS;
  }
}

writeStrawAlignTextFile()

StatusCode TRT_AlignDbSvc::writeStrawAlignTextFile

(

const std::string &

file

)

const

Definition at line 338 of file TRT_AlignDbSvc.cxx.

{
  ATH_MSG_DEBUG( " in writeAlignTextFile "  );
  
  ATH_MSG_INFO( "Writing the straw  alignments "  );
  if( m_trtStrawAlignDbSvc -> writeTextFile(file) != StatusCode::SUCCESS )
    ATH_MSG_ERROR("Cannot write to file "<< file  );
  
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_alignchans

std::vector<int> TRT_AlignDbSvc::m_alignchans

private

channels

Definition at line 166 of file TRT_AlignDbSvc.h.

m_aligncontainerhandle

const DataHandle<AlignableTransformContainer> TRT_AlignDbSvc::m_aligncontainerhandle

private

Definition at line 167 of file TRT_AlignDbSvc.h.

m_alignDBprefix

std::string TRT_AlignDbSvc::m_alignDBprefix

private

Definition at line 171 of file TRT_AlignDbSvc.h.

m_alignobjs

std::vector<std::string> TRT_AlignDbSvc::m_alignobjs

private

folder names

Definition at line 165 of file TRT_AlignDbSvc.h.

m_alignroot

std::string TRT_AlignDbSvc::m_alignroot

private

root alignment folder

Definition at line 162 of file TRT_AlignDbSvc.h.

m_alignString

std::string TRT_AlignDbSvc::m_alignString

private

alignment string searched for

Definition at line 163 of file TRT_AlignDbSvc.h.

m_amgTransformCache

std::vector<Amg::Transform3D*> TRT_AlignDbSvc::m_amgTransformCache

mutableprivate

Definition at line 169 of file TRT_AlignDbSvc.h.

m_detStore

ServiceHandle<StoreGateSvc> TRT_AlignDbSvc::m_detStore

private

Definition at line 158 of file TRT_AlignDbSvc.h.

m_dynamicDB

bool TRT_AlignDbSvc::m_dynamicDB

private

Definition at line 173 of file TRT_AlignDbSvc.h.

m_forceUserDBConfig

bool TRT_AlignDbSvc::m_forceUserDBConfig

private

Definition at line 174 of file TRT_AlignDbSvc.h.

m_par_alitextfile

std::string TRT_AlignDbSvc::m_par_alitextfile

private

input text file

Definition at line 164 of file TRT_AlignDbSvc.h.

m_streamer

ToolHandle<IAthenaOutputStreamTool> TRT_AlignDbSvc::m_streamer

private

OutputStreamTool.

Definition at line 168 of file TRT_AlignDbSvc.h.

m_trtid

const TRT_ID* TRT_AlignDbSvc::m_trtid

private

trt id helper

Definition at line 160 of file TRT_AlignDbSvc.h.

m_trtman

const InDetDD::TRT_DetectorManager* TRT_AlignDbSvc::m_trtman

private

detector manager

Definition at line 161 of file TRT_AlignDbSvc.h.

m_trtStrawAlignDbSvc

ServiceHandle<ITRT_StrawAlignDbSvc> TRT_AlignDbSvc::m_trtStrawAlignDbSvc

private

Definition at line 159 of file TRT_AlignDbSvc.h.

---

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

• TRT_AlignDbSvc.h
• TRT_AlignDbSvc.cxx