Updates for CLHEP 2.1.2.3 compatibility - should be back-compatible with CLHEP...

Updates for CLHEP 2.1.2.3 compatibility - should be back-compatible with CLHEP 1.9.4.7. Tag as DetDescrConditions-00-01-21 (DetDescrConditions-00-01-21)

DetectorDescription/DetDescrCond/DetDescrConditions/DetDescrConditions/AlignableTransform.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef DETDESCRCOND_ALIGNTRANS_H
+#define DETDESCRCOND_ALIGNTRANS_H
+// AlignableTransform.h - simple class to hold Identifier and transform for
+//                        alignment information
+// Richard Hawkings, started 23/9/03
+//
+// AlignableTransform consists of a vector of AlignTransMember objects,
+// each of which is contains an Identifier and a HepGeom::Transform3D
+// It is designed to reside in the detector store and be kept in the 
+// conditionsDB. The AlignTransTool AlgTool (in DetDescrTools) provides
+// a user interface to manage these objects
+
+#include <vector>
+#include <algorithm>
+#include "Identifier/Identifier.h"
+#include "CLHEP/Geometry/Transform3D.h"
+
+#ifndef CLIDSVC_CLASSDEF_H
+#include "CLIDSvc/CLASS_DEF.h"
+#endif
+
+class AlignableTransform {
+ public:
+  AlignableTransform();
+  AlignableTransform(std::string tag);
+  virtual ~AlignableTransform();
+
+  // embedded class AlignTransMember holds the information for one module
+  // i.e. module identifier and associated transform
+  class AlignTransMember {
+  public:
+    AlignTransMember();
+    AlignTransMember(const Identifier& ident, const HepGeom::Transform3D& trans);
+    const Identifier& identify() const;
+    const HepGeom::Transform3D& transform() const;
+    void setTransform(const HepGeom::Transform3D& trans);
+
+  private:
+    Identifier m_ident;
+    HepGeom::Transform3D m_trans;
+  };
+
+  // const and non-const iterator definitions
+  typedef std::vector<AlignTransMember>::const_iterator AlignTransMem_citr;
+  AlignTransMem_citr begin() const;
+  AlignTransMem_citr end() const;
+  typedef std::vector<AlignTransMember>::iterator AlignTransMem_itr;
+  AlignTransMem_itr mbegin();
+  AlignTransMem_itr mend();
+  // return pointer to particular module
+  AlignTransMem_citr findIdent(const Identifier& ident) const;
+  AlignTransMem_itr findIdent(const Identifier& ident);
+  // return tag name for AlignableTransform
+  const std::string& tag() const;
+
+  // add a new member to the AlignableTransform
+  void add(Identifier ident,HepGeom::Transform3D trans);
+  // reset the specified transform
+  bool update(const Identifier ident,const HepGeom::Transform3D trans);
+  // tweak, i.e. combine new transform with that already existing
+  bool tweak(const Identifier ident,const HepGeom::Transform3D trans);
+  void print() const;
+  void print2() const;
+  // sort transform vector, to be called after adding new transforms
+  void sortv();
+
+ private:
+  std::string m_tag;
+  std::vector<AlignTransMember> m_vec;
+};
+
+CLASS_DEF(AlignableTransform,158187411,1)
+
+inline const Identifier& 
+AlignableTransform::AlignTransMember::identify() const
+{ return m_ident;}
+
+inline const HepGeom::Transform3D& 
+AlignableTransform::AlignTransMember::transform() const
+{ return m_trans;}
+
+inline void AlignableTransform::AlignTransMember::setTransform(
+   const HepGeom::Transform3D& trans) { m_trans=trans;}
+
+inline bool operator< (const AlignableTransform::AlignTransMember& lhs, 
+                const AlignableTransform::AlignTransMember& rhs) {
+  return (lhs.identify() < rhs.identify());
+}
+
+inline AlignableTransform::AlignableTransform() { m_tag="null"; }
+inline AlignableTransform::~AlignableTransform() {}
+
+inline AlignableTransform::AlignTransMem_citr
+   AlignableTransform::begin() const { return m_vec.begin();}
+inline AlignableTransform::AlignTransMem_citr
+   AlignableTransform::end() const { return m_vec.end();}
+
+inline AlignableTransform::AlignTransMem_itr
+   AlignableTransform::mbegin() { return m_vec.begin();}
+inline AlignableTransform::AlignTransMem_itr
+   AlignableTransform::mend() { return m_vec.end();}
+
+inline AlignableTransform::AlignTransMem_citr
+  AlignableTransform::findIdent(const Identifier& ident) const {
+  AlignableTransform::AlignTransMember obj(ident,HepGeom::Transform3D());
+  AlignableTransform::AlignTransMem_citr rc=std::lower_bound(m_vec.begin(),m_vec.end(),obj);
+  if (rc!=m_vec.end() && rc->identify()!=ident) rc=m_vec.end();
+  return rc;
+}
+
+// same as previous but non-const
+inline AlignableTransform::AlignTransMem_itr
+  AlignableTransform::findIdent(const Identifier& ident) {
+  AlignableTransform::AlignTransMember obj(ident,HepGeom::Transform3D());
+  AlignableTransform::AlignTransMem_itr rc=std::lower_bound(m_vec.begin(),m_vec.end(),obj);
+  if (rc!=m_vec.end() && rc->identify()!=ident) rc=m_vec.end();
+  return rc;
+}
+
+inline const std::string& AlignableTransform::tag() const {return m_tag;}
+
+inline void AlignableTransform::sortv() { 
+   sort(m_vec.begin(),m_vec.end()); }
+
+#endif // DETDESCRCOND_ALIGNTRANS_H

DetectorDescription/DetDescrCond/DetDescrConditions/DetDescrConditions/AlignableTransformContainer.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef DETDESCRCOND_ALIGNTRKCONTAINER_H
+#define DETDESCRCOND_ALIGNTRKCONTAINER_H
+// AlignableTransformContainer.h - a container for AlignableTransform objects
+// using the CondMultChanCollection to allow storage as a set of POOLrefs
+// in conditions database
+// Richard Hawkings, 31/8/05
+
+#ifndef CLIDSVC_CLASSDEF_H
+#include "CLIDSvc/CLASS_DEF.h"
+#endif
+#include "AthenaPoolUtilities/CondMultChanCollection.h"
+#include "DetDescrConditions/AlignableTransform.h"
+
+typedef CondMultChanCollection<AlignableTransform> AlignableTransformContainer;
+
+CLASS_DEF( AlignableTransformContainer , 1170039409 , 1 )
+
+#endif // DETDESCRCOND_ALIGNTRKCONTAINER_H

DetectorDescription/DetDescrCond/DetDescrConditions/DetDescrConditions/DetCondCFloat.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef DETDESCRCOND_DETCONDCFLOAT_H
+#define DETDESCRCOND_DETCONDCFLOAT_H
+// DetCondCFloat.h - class to hold sets of Identifiers and arrays of floats
+// for detector element specific information
+// Richard Hawkings, started 29/1/04
+// formerly DetCondFloat but renamed to DetCondCFloat to allow DetCondFloat
+// to be a parallel virtual class with no CLASS_DEF
+// Latter is inherited by specialised TRT conditions data classes
+//
+// Based on AlignableTransform but with vectors of floats of arbitrary size 
+// (at initialisation time). These objects are designed to reside in the
+// detector store and be kept in the conditionsDB.
+//
+// Methods are provided to create a new object with a float vector of a 
+// specified size, add an Identifier and associated array of floats,
+// and to associate a new Identifier with some already stored set of floats
+// This sharing mechanism can be used to tranparently associate one set of
+// constants to a large number of identifiers (i.e. detector elements)
+// and then increase the granularity later
+//
+// Access to the data is provided by the find method, which returns a pointer
+// to the floats associated with a particular identifier (or a null pointer
+// if the identifier is not known. The index within the internal storage
+// of a particular identifier's data can also be retrieved, for use in 
+// a subsequent call to the share method (this index is also returned by
+// the add method).
+// print and print2 methods print the data with varying amounts of detail
+
+#include <vector>
+#include <map>
+#include <algorithm>
+#include "Identifier/Identifier.h"
+
+#ifndef CLIDSVC_CLASSDEF_H
+#include "CLIDSvc/CLASS_DEF.h"
+#endif
+
+class DetCondCFloat {
+ public:
+  DetCondCFloat();
+  DetCondCFloat(const int size,const std::string tag);
+  virtual ~DetCondCFloat();
+
+  int size() const;
+  const std::string& tag() const;
+
+  int add(const Identifier& ident, const float* f);
+  void share(const Identifier& ident, const int index);
+  const float* find(const Identifier& ident) const;
+  int findindex(const Identifier& ident) const;
+  void print() const;
+  void print2() const;
+
+ private:
+  int m_size;
+  std::string m_tag;
+  typedef std::less<Identifier> lessp;
+  typedef std::map<Identifier,int,lessp> BufferMap;
+  BufferMap m_bufmap;
+  std::vector<float> m_buf;
+};
+
+CLASS_DEF(DetCondCFloat,247459965,1)
+
+// inline functions for DetCondCFloat
+
+inline DetCondCFloat::DetCondCFloat() : m_size(0), m_tag("null") {}
+
+inline DetCondCFloat::DetCondCFloat(int size,const std::string tag) : 
+m_size(size), m_tag(tag) {}
+
+inline DetCondCFloat::~DetCondCFloat() {}
+
+inline int DetCondCFloat::size() const {return m_size;}
+
+inline const std::string& DetCondCFloat::tag() const {return m_tag;}
+
+#endif // DETDESCRCOND_DETCONDCFLOAT_H

DetectorDescription/DetDescrCond/DetDescrConditions/DetDescrConditions/DetCondFloat.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef DETDESCRCOND_DETCONDFLOAT_H
+#define DETDESCRCOND_DETCONDFLOAT_H
+// DetCondFloat.h - class to hold sets of Identifiers and arrays of floats
+// for detector element specific information
+// Richard Hawkings, started 29/1/04
+//
+// Based on AlignableTransform but with vectors of floats of arbitrary size 
+// (at initialisation time). These objects are designed to reside in the
+// detector store and be kept in the conditionsDB.
+//
+// Methods are provided to create a new object with a float vector of a 
+// specified size, add an Identifier and associated array of floats,
+// and to associate a new Identifier with some already stored set of floats
+// This sharing mechanism can be used to tranparently associate one set of
+// constants to a large number of identifiers (i.e. detector elements)
+// and then increase the granularity later
+//
+// Access to the data is provided by the find method, which returns a pointer
+// to the floats associated with a particular identifier (or a null pointer
+// if the identifier is not known. The index within the internal storage
+// of a particular identifier's data can also be retrieved, for use in 
+// a subsequent call to the share method (this index is also returned by
+// the add method).
+// print and print2 methods print the data with varying amounts of detail
+
+#include <vector>
+#include <map>
+#include <algorithm>
+#include "Identifier/Identifier.h"
+
+// remove classdef as this is now abstract class which TRT alignment inherits
+//#ifndef CLIDSVC_CLASSDEF_H
+//#include "CLIDSvc/CLASS_DEF.h"
+//#endif
+
+class DetCondFloat {
+ public:
+  DetCondFloat();
+  DetCondFloat(const int size,const std::string tag);
+  virtual ~DetCondFloat();
+
+  int size() const;
+  const std::string& tag() const;
+
+  int add(const Identifier& ident, const float* f);
+  void share(const Identifier& ident, const int index);
+  const float* find(const Identifier& ident) const;
+  int findindex(const Identifier& ident) const;
+  virtual void print() const;
+  virtual void print2() const;
+
+ protected:
+  int m_size;
+  std::string m_tag;
+  typedef std::less<Identifier> lessp;
+  typedef std::map<Identifier,int,lessp> BufferMap;
+  BufferMap m_bufmap;
+  std::vector<float> m_buf;
+};
+
+// CLASS_DEF(DetCondFloat,158187412,1);
+
+// inline functions for DetCondFloat
+
+inline DetCondFloat::DetCondFloat() : m_size(0), m_tag("null") {}
+
+inline DetCondFloat::DetCondFloat(int size,const std::string tag) : 
+m_size(size), m_tag(tag) {}
+
+inline DetCondFloat::~DetCondFloat() {}
+
+inline int DetCondFloat::size() const {return m_size;}
+
+inline const std::string& DetCondFloat::tag() const {return m_tag;}
+
+#endif // DETDESCRCOND_DETCONDFLOAT_H

DetectorDescription/DetDescrCond/DetDescrConditions/DetDescrConditions/DetCondKeyTrans.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef DETDESCRCOND_KEYTRANS_H
+#define DETDESCRCOND_KEYTRANS_H
+// DetCondKeyTrans.h - class to hold set of HepGeom::Transform3D keyed by string
+// value for storage in the conditions DB
+// typically for holding top-level transforms for GeoModel/G4
+// This class can be persistified (converters in DetDescrCondAthenaPool)
+//
+// Richard Hawkings, started 23/6/05
+
+#include <string>
+#include <map>
+#include "CLHEP/Geometry/Transform3D.h"
+
+#ifndef CLIDSVC_CLASSDEF_H
+#include "CLIDSvc/CLASS_DEF.h"
+#endif
+
+class DetCondKeyTrans {
+ public:
+  DetCondKeyTrans();
+  virtual ~DetCondKeyTrans();
+
+  // set a transform corresponding to a particular key value
+  // if a transform with this key is already present, it is overwritten
+  void setTransform(const std::string& key, const HepGeom::Transform3D& trans);
+
+  // get the transform corresponding to this key into result
+  // returns false if the transform cannot be found
+  bool getTransform(const std::string& key, HepGeom::Transform3D& result) const;
+
+  // check if transform corresponding to this key exists
+  bool exists(const std::string& key) const;
+
+  // print the set of key/transform pairs to stdout
+  void print() const;
+
+ private:
+  typedef std::map<std::string,HepGeom::Transform3D> KeyTrans;
+  KeyTrans m_keytrans;
+};
+
+CLASS_DEF(DetCondKeyTrans,254546453,1)
+
+// iterator declaration for SEAL dictionary
+// removed - perhaps will not be needed for reflex, causes problem for gcc344
+// template std::map<std::string,HepGeom::Transform3D>::iterator;
+
+// virtual destructor to satify requirement for persistent classes to have vtbl
+inline DetCondKeyTrans::~DetCondKeyTrans() {}
+
+inline void DetCondKeyTrans::setTransform(const std::string& key, 
+    const HepGeom::Transform3D&trans) { m_keytrans[key]=trans;}
+
+#endif // DETDESCRCOND_KEYTRANS_H

DetectorDescription/DetDescrCond/DetDescrConditions/DetDescrConditions/DetDescrConditionsDict.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef DETDESCRCONDITIONS_DETDESCRCONDDICT_H
+#define DETDESCRCONDITIONS_DETDESCRCONDDICT_H
+
+#include "DetDescrConditions/AlignableTransform.h"
+#include "DetDescrConditions/AlignableTransformContainer.h"
+#include "DetDescrConditions/DetCondFloat.h"
+#include "DetDescrConditions/DetCondCFloat.h"
+#include "DetDescrConditions/DetCondKeyTrans.h"
+#include "DetDescrConditions/DetStatusMap.h"
+
+struct dummy {
+  DetStatusMap::const_iterator m_it;
+};
+
+#endif 
+

DetectorDescription/DetDescrCond/DetDescrConditions/DetDescrConditions/DetStatus.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef DETDESCRCOND_DETSTATUS_H
+#define DETDESCRCOND_DETSTATUS_H
+// DetStatus.h - class to hold details of a subdetector status
+// Richard Hawkings, started 19/12/06
+
+#include<string>
+
+class DetStatus {
+ public:
+  DetStatus();
+  // constructor with parameters
+  DetStatus(const int fullcode, 
+	    const float deadfrac, const float deadthrust);
+
+  virtual ~DetStatus();
+
+  // access functions
+  int code() const;
+  int fullCode() const;
+  float deadFrac() const;
+  float deadThrust() const;
+  std::string colour() const;
+
+ private:
+  int m_code;
+  float m_deadfrac;
+  float m_deadthrust;
+};
+
+inline DetStatus::~DetStatus() {}
+
+inline int DetStatus::code() const { return m_code<0 ? m_code : m_code & 3; }
+inline int DetStatus::fullCode() const { return m_code; }
+inline float DetStatus::deadFrac() const { return m_deadfrac;}
+inline float DetStatus::deadThrust() const { return m_deadthrust;}
+
+#endif // DETDESCRCOND_DETSTATUS_H

DetectorDescription/DetDescrCond/DetDescrConditions/DetDescrConditions/DetStatusMap.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef DETDESCRCOND_DETSTATUSMAP_H
+#define DETDESCRCOND_DETSTATUSMAP_H
+// DetStatusMap.h - class to hold details of all subdetector status
+// can be written to POOL for ESD/AOD files
+// Richard Hawkings, started 13/12/06
+
+#include "CLIDSvc/CLASS_DEF.h"
+#include "GaudiKernel/DataObject.h"
+#include "GaudiKernel/MsgStream.h"
+#include "DetDescrConditions/DetStatus.h"
+#include <string>
+#include <vector>
+#include <algorithm>
+
+class DetStatusMap : public DataObject {
+ public:
+  typedef std::pair<std::string,DetStatus> DetStatusPair;
+  typedef std::vector<DetStatusPair>       StatusMap;
+  typedef StatusMap::const_iterator        const_iterator;
+
+  // Add this to allow python iteration over the contents.
+  typedef const_iterator iterator;
+
+  DetStatusMap();
+  virtual ~DetStatusMap();
+
+  // access methods to map
+  unsigned int   size() const;
+  const_iterator begin() const;
+  const_iterator end() const;
+  const_iterator find(const std::string& name) const;
+
+  // set methods
+  void clear();
+  void add(const std::string& name, const DetStatus& status);
+
+  // print method
+  MsgStream& toOutputStream(MsgStream& os) const;
+
+ private:
+
+  class PairSort {
+  public:
+    bool operator () (const DetStatusPair& x, const DetStatusPair& y) 
+    { return (x.first < y.first); }
+    bool operator () (const DetStatusPair& x, const std::string& y) 
+    { return (x.first < y); }
+  };
+
+  StatusMap m_statmap;
+};
+
+CLASS_DEF( DetStatusMap , 264405569 , 1 )
+
+inline DetStatusMap::~DetStatusMap() {}
+
+inline unsigned int DetStatusMap::size() const { return m_statmap.size(); }
+
+inline DetStatusMap::const_iterator DetStatusMap::begin() const 
+{ return m_statmap.begin(); }
+
+inline DetStatusMap::const_iterator DetStatusMap::end() const 
+{ return m_statmap.end(); }
+
+inline DetStatusMap::const_iterator DetStatusMap::find(const std::string& name) const 
+{
+  const_iterator result = std::lower_bound(m_statmap.begin(), 
+                                           m_statmap.end(),
+                                           name, PairSort()) ;
+  if ( result != m_statmap.end() && (*result).first == name )  return (result) ;
+  return m_statmap.end() ;
+}
+
+inline void DetStatusMap::clear() { m_statmap.clear(); }
+
+inline void DetStatusMap::add(const std::string& name, const DetStatus& status)
+{ 
+  m_statmap.push_back( DetStatusPair(name, status) ) ;
+  std::sort( m_statmap.begin() , m_statmap.end() , PairSort() );
+}
+
+inline MsgStream& DetStatusMap::toOutputStream(MsgStream& os) const {
+  os << "DetStatusMap of size: " << m_statmap.size() << endreq;
+  for (StatusMap::const_iterator itr=m_statmap.begin();itr!=m_statmap.end();
+       ++itr) os << itr->first << " : " << itr->second.colour() << " (" <<
+		itr->second.deadFrac() << "," << itr->second.deadThrust() <<
+		")" << endreq;
+  return os;
+}
+
+#endif // DETDESCRCOND_DETSTATUSMAP_H

DetectorDescription/DetDescrCond/DetDescrConditions/DetDescrConditions/selection.xml

+<lcgdict>
+ <class name="AlignableTransform" id="E779C6B5-3F2A-473E-B35E-6CCB345E0665" /> 
+
+<!-- Temporarily commented out - done by hand in ../src/ DetDescrConditionsDict_dict_fixes.cxx -->
+<!-- Put back in as fix removed for ROOT5 migration (RJH) -->
+ <class name="AlignableTransform::AlignTransMember" />
+
+ <class name="std::vector<AlignableTransform::AlignTransMember>" />
+ <class name="AlignableTransformContainer" id="E6740904-E6F2-4D41-944A-C8EF92FE4B17" />
+ <class name="DataVector<AlignableTransform>" />
+ <class name="std::vector<AlignableTransform*>" />
+ <class name="DetCondFloat" id="C2CDCE81-DF11-4F14-97AA-B6618376ABFC" />
+ <class name="DetCondCFloat" id="DCE158E2-27A7-4A78-9778-D3E4D4F740CB" />
+ <class name="DetCondKeyTrans" id="A6DA54AC-D54E-4B6C-8489-C6D015277AD0" />
+ <class name="std::map<std::string,HepGeom::Transform3D>" />
+ <!-- <class name="std::set<unsigned long>"/> -->
+ <class name="DetStatusMap" id="CB1BFF00-64B1-4693-8035-19BB18867AF1" />
+ <class name="DetStatus" />
+ <class name="std::pair<std::string,DetStatus>" />
+ <class name="std::vector<std::pair<std::string,DetStatus> >" />
+ <class name="DetStatusMap::iterator"/>
+ <class name="__gnu_cxx::__normal_iterator<std::pair<std::string,DetStatus>*,std::vector<std::pair<std::string,DetStatus> > >"/>
+</lcgdict>

DetectorDescription/DetDescrCond/DetDescrConditions/cmt/requirements

+package DetDescrConditions
+##############################################################################
+# DetDescrConditions - data classes for subdetector independent alignment info
+#                      and other conditions data (to be added)
+##############################################################################
+
+author Richard Hawkings <richard.hawkings@cern.ch>
+
+use AtlasPolicy     AtlasPolicy-*
+use GaudiInterface  GaudiInterface-01-*   External
+use CLIDSvc         CLIDSvc-00-*          Control
+use Identifier      Identifier-00-*       DetectorDescription
+use AtlasCLHEP      AtlasCLHEP-00-*       External
+use AthenaPoolUtilities AthenaPoolUtilities-00-* Database/AthenaPOOL
+
+apply_pattern installed_library
+library DetDescrConditions  \
+           AlignableTransform.cxx \
+           DetCondFloat.cxx DetCondCFloat.cxx \
+           DetCondKeyTrans.cxx DetStatus.cxx DetStatusMap.cxx
+
+private 
+use AtlasReflex	AtlasReflex-00-*	 External -no_auto_imports
+
+apply_pattern lcgdict dict=DetDescrConditions selectionfile=selection.xml headerfiles="../DetDescrConditions/DetDescrConditionsDict.h" 
+
+# Now build a special (hand-written) library to build a dictionary for AlignTransMember
+# temporarily removed for ROOT5 migration (RJH)
+#apply_pattern lcgdictfix libname=DetDescrConditions  dictfiles="DetDescrConditionsDict_dict_fixes.cxx"
+
+
+end_private
+
+
+

DetectorDescription/DetDescrCond/DetDescrConditions/doc/mainpage.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+\mainpage The DetDescrCondtions package
+
+\section introductionDetDescrConditions Introduction
+
+This package collects together conditions database objects used in detector
+description applications. The POOL converters for all the objects are 
+defined in the package InDetCondAthenaPool.
+
+\section AlignableTransform
+
+This class consists of a vector of HepGeom::Transform3Ds each associated with
+an offline Identifier. It is used for example to store the alignment constants
+for each layer of the SCT and pixel detector. Methods are provided to
+get and set the tranforms using the Identifier as a key, to iterate over
+all the transforms in the class, and to print the contents.
+
+An AlignableTransformContainer is also defined, consisting of a DataVector
+of AlignableTransforms, allowing them to be read/written as a single entity.
+
+\section DetCondFloat
+
+This class consists of a vector of vectors of floats, each associated
+with an offline Identifier. Several identifiers can be mapped to the same
+set of floats to save space where common constants are required. This
+class is used for example by the TRT calibration data.
+
+\section DetDescrKeyTrans
+
+This class consists of a vector of HepGeom::Transform3Ds, each associated with
+an artbitrary string identifier. It is similar to AlignableTranform, but
+using strings instead of Identifiers, and the internal implementation is
+simpler (using a map instead of an embedded class).
+
+*/

DetectorDescription/DetDescrCond/DetDescrConditions/src/AlignableTransform.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// AlignableTransform.cxx
+// simple alignable transform
+// Richard Hawkings, started 23/9/03
+
+#include <iostream>
+#include "DetDescrConditions/AlignableTransform.h"
+
+AlignableTransform::AlignableTransform(std::string tag) : 
+   m_tag(tag), m_vec()
+{}
+
+void AlignableTransform::add(Identifier ident, HepGeom::Transform3D trans) {
+  m_vec.push_back(AlignTransMember(ident,trans));
+}
+
+void AlignableTransform::print() const {
+  std::cout << "AlignableTransform::print  tagname:" << m_tag << 
+    " vector size " << m_vec.size() << std::endl;
+}
+
+void AlignableTransform::print2() const {
+  print();
+  int i=0;
+  CLHEP::Hep3Vector trans;
+  for (AlignTransMem_citr cit=begin(); cit!=end(); ++cit) {
+    trans=(cit->transform()).getTranslation();
+    std::cout << "Member " << i++ << " transl [" << trans.x()*1.E3 << "," << 
+      trans.y()*1.E3 << "," << trans.z()*1.E3 << "]" << " ID: " << 
+      cit->identify().getString() << std::endl;
+  }
+}
+
+bool AlignableTransform::update(const Identifier ident,
+const HepGeom::Transform3D trans) {
+  AlignTransMem_itr itr=findIdent(ident);
+  if (itr==m_vec.end()) return false;
+  itr->setTransform(trans);
+  return true;
+}
+
+bool AlignableTransform::tweak(const Identifier ident,
+const HepGeom::Transform3D trans) {
+  AlignTransMem_itr itr=findIdent(ident);
+  if (itr==m_vec.end()) return false;
+  HepGeom::Transform3D newtrans=trans*(itr->transform());
+  itr->setTransform(newtrans);
+  return true;
+}
+
+AlignableTransform::AlignTransMember::AlignTransMember() :
+  m_ident(), m_trans()
+{}
+
+AlignableTransform::AlignTransMember::AlignTransMember
+(const Identifier& ident,const HepGeom::Transform3D& trans) :
+  m_ident(ident), m_trans(trans)
+{}
+
+

DetectorDescription/DetDescrCond/DetDescrConditions/src/DetCondCFloat.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// DetCondCFloat.cxx
+// class to hold sets of identifiers and vectors of floats for detector
+// element specific information
+// Richard Hawkings, started 30/1/04
+
+#include <iostream>
+#include "DetDescrConditions/DetCondCFloat.h"
+
+int DetCondCFloat::add(const Identifier& ident, const float* f) {
+  // get pointer to added objects
+  size_t j=m_buf.size();
+  // add them in to the buffer
+  m_buf.resize(j+m_size);
+  for (int i=0;i<m_size;++i) m_buf[j+i]=f[i];
+  // put new map entry
+  m_bufmap[ident]=j;
+  return j;
+}
+
+void DetCondCFloat::share(const Identifier& ident, const int index) {
+  // add object which is pointing to already existing buffer space
+  m_bufmap[ident]=index;
+}
+
+const float* DetCondCFloat::find(const Identifier& ident) const {
+  BufferMap::const_iterator itr=m_bufmap.find(ident);
+  if (itr!=m_bufmap.end()) {
+    // return pointer to datastructure
+    return &m_buf[itr->second];
+  } else {
+    // identifier not in map, return null pointer
+    return 0;
+  }
+}
+
+int DetCondCFloat::findindex(const Identifier& ident) const {
+  BufferMap::const_iterator itr=m_bufmap.find(ident);
+  if (itr!=m_bufmap.end()) {
+    // return index in datastructure, for subsequent share call
+    return itr->second;
+  } else {
+    // identifier not in map, return -ve offset to signal error
+    return -1;
+  }
+}
+
+void DetCondCFloat::print() const {
+  std::cout << "DetCondCFloat " << m_tag << " has granularity " << m_size <<
+    " with " << m_bufmap.size() << " entries and " << m_buf.size() <<
+    " elements" << std::endl;
+}
+
+void DetCondCFloat::print2() const {
+  print();
+  int i=0;
+  for (BufferMap::const_iterator itr=m_bufmap.begin(); 
+      itr!=m_bufmap.end(); ++itr,++i) {
+    int j=itr->second;
+    std::cout << "Element " << i << " ident " << (itr->first).getString() <<
+      "offset " << j << " values:";
+    for (int k=j; k<j+m_size; ++k) std::cout << " " << m_buf[k];
+  std::cout << std::endl;
+  }
+}	       

DetectorDescription/DetDescrCond/DetDescrConditions/src/DetCondFloat.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// DetCondFloat.cxx
+// class to hold sets of identifiers and vectors of floats for detector
+// element specific information
+// Richard Hawkings, started 30/1/04
+
+#include <iostream>
+#include "DetDescrConditions/DetCondFloat.h"
+
+int DetCondFloat::add(const Identifier& ident, const float* f) {
+  // get pointer to added objects
+  size_t j=m_buf.size();
+  // add them in to the buffer
+  m_buf.resize(j+m_size);
+  for (int i=0;i<m_size;++i) m_buf[j+i]=f[i];
+  // put new map entry
+  m_bufmap[ident]=j;
+  return j;
+}
+
+void DetCondFloat::share(const Identifier& ident, const int index) {
+  // add object which is pointing to already existing buffer space
+  m_bufmap[ident]=index;
+}
+
+const float* DetCondFloat::find(const Identifier& ident) const {
+  BufferMap::const_iterator itr=m_bufmap.find(ident);
+  if (itr!=m_bufmap.end()) {
+    // return pointer to datastructure
+    return &m_buf[itr->second];
+  } else {
+    // identifier not in map, return null pointer
+    return 0;
+  }
+}
+
+int DetCondFloat::findindex(const Identifier& ident) const {
+  BufferMap::const_iterator itr=m_bufmap.find(ident);
+  if (itr!=m_bufmap.end()) {
+    // return index in datastructure, for subsequent share call
+    return itr->second;
+  } else {
+    // identifier not in map, return -ve offset to signal error
+    return -1;
+  }
+}
+
+void DetCondFloat::print() const {
+  std::cout << "DetCondFloat " << m_tag << " has granularity " << m_size <<
+    " with " << m_bufmap.size() << " entries and " << m_buf.size() <<
+    " elements" << std::endl;
+}
+
+void DetCondFloat::print2() const {
+  print();
+  int i=0;
+  for (BufferMap::const_iterator itr=m_bufmap.begin(); 
+      itr!=m_bufmap.end(); ++itr,++i) {
+    int j=itr->second;
+    std::cout << "Element " << i << " ident " << (itr->first).getString() <<
+      "offset " << j << " values:";
+    for (int k=j; k<j+m_size; ++k) std::cout << " " << m_buf[k];
+  std::cout << std::endl;
+  }
+}	       

DetectorDescription/DetDescrCond/DetDescrConditions/src/DetCondKeyTrans.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// DetCondKeyTrans.cxx - set of HepGeom::Transform3Ds keyed by string
+// Richard Hawkings, started 23/6/05
+
+#include <iostream>
+#include "DetDescrConditions/DetCondKeyTrans.h"
+
+DetCondKeyTrans::DetCondKeyTrans() :
+  m_keytrans() {}
+
+bool DetCondKeyTrans::getTransform(const std::string& key,
+              HepGeom::Transform3D& result) const {
+  KeyTrans::const_iterator ik=m_keytrans.lower_bound(key);
+  if (ik!=m_keytrans.end()) {
+    result=(ik->second);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool DetCondKeyTrans::exists(const std::string& key) const {
+  KeyTrans::const_iterator ik=m_keytrans.lower_bound(key);
+  return (ik!=m_keytrans.end());
+}
+
+void DetCondKeyTrans::print() const {
+  for (KeyTrans::const_iterator ik=m_keytrans.begin(); ik!=m_keytrans.end();
+       ++ik) {
+    CLHEP::Hep3Vector trans=ik->second.getTranslation();
+    CLHEP::HepRotation rot=ik->second.getRotation();
+    std::cout << "Dump DetCondKeyTrans object:" << std::endl;
+    std::cout << "Key " << ik->first << " transl [" << trans.x()
+	      << "," << trans.y() << "," << trans.z() << "] rotation ("
+	      << rot.phi() << "," << rot.theta() << "," <<  rot.psi() << ")"
+	      << std::endl;
+  }
+}

DetectorDescription/DetDescrCond/DetDescrConditions/src/DetDescrConditionsDict_dict_fixes.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// Generated at Sun Jul 17 15:33:29 2005. Do not modify it
+
+#ifdef _WIN32
+#pragma warning ( disable : 4786 )
+#ifndef LCGDICT_STRING 
+#include <string> // Included here since it is sensitive to private->public trick
+#endif
+#endif
+#define private public
+#define protected public
+#include "../DetDescrConditions/DetDescrConditionsDict.h"
+#undef private
+#undef protected
+#include "ReflectionBuilder/ReflectionBuilder.h"
+#include "ReflectionBuilder/CollectionProxy.h"
+#include <typeinfo>
+using namespace seal::reflect;
+
+//------Dictionary for class AlignTransMember -------------------------------
+class AlignableTransform__AlignTransMember_dict { 
+  public:
+  AlignableTransform__AlignTransMember_dict();
+  static void* constructor_4747( void*, const std::vector<void*>& );
+  static void  destructor( void* o ) { ((AlignableTransform::AlignTransMember*)o)->~AlignTransMember(); }
+  static void* constructor_4749( void* );
+  static void* constructor_4750( void*, const std::vector<void*>& );
+  static void* method_4751( void* );
+  static void* method_4752( void* );
+  static void  method_4753( void*, const std::vector<void*>& );
+};
+AlignableTransform__AlignTransMember_dict::AlignableTransform__AlignTransMember_dict() {
+  ClassBuilder _c_("AlignableTransform::AlignTransMember", "", typeid(AlignableTransform::AlignTransMember), sizeof(AlignableTransform::AlignTransMember),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC);
+  _c_.addField("m_ident", "Identifier", "", (size_t)(&((AlignableTransform::AlignTransMember*)64)->m_ident)-64, PRIVATE );
+  _c_.addField("m_trans", "HepGeom::Transform3D", "", (size_t)(&((AlignableTransform::AlignTransMember*)64)->m_trans)-64, PRIVATE );
+  _c_.addMethod("AlignTransMember", "", "AlignableTransform::AlignTransMember", "AlignableTransform::AlignTransMember&", constructor_4747, PUBLIC);
+  _c_.addMethod("~AlignTransMember", "", destructor, PUBLIC);
+  _c_.addMethod("AlignTransMember", "", "AlignableTransform::AlignTransMember", constructor_4749, PUBLIC);
+  _c_.addMethod("AlignTransMember", "", "AlignableTransform::AlignTransMember", "Identifier&; HepGeom::Transform3D&", constructor_4750, PUBLIC);
+  _c_.addMethod("identify", "", "Identifier&", method_4751, PUBLIC);
+  _c_.addMethod("transform", "", "HepGeom::Transform3D&", method_4752, PUBLIC);
+  _c_.addMethod("setTransform", "", "HepGeom::Transform3D&", method_4753, PUBLIC);
+  _c_.build();
+}
+
+//------Stub functions for class AlignTransMember -------------------------------
+void* AlignableTransform__AlignTransMember_dict::constructor_4747( void* mem, const std::vector<void*>& arg) {
+  return ::new(mem) AlignableTransform::AlignTransMember(*(const AlignableTransform::AlignTransMember*)arg[0]);
+}
+
+void* AlignableTransform__AlignTransMember_dict::constructor_4749( void* mem) {
+  return ::new(mem) AlignableTransform::AlignTransMember();
+}
+
+void* AlignableTransform__AlignTransMember_dict::constructor_4750( void* mem, const std::vector<void*>& arg) {
+  return ::new(mem) AlignableTransform::AlignTransMember(*(const Identifier*)arg[0],
+                                                         *(const HepGeom::Transform3D*)arg[1]);
+}
+
+void* AlignableTransform__AlignTransMember_dict::method_4751( void* o)
+{
+  return (void*)&((const AlignableTransform::AlignTransMember*)o)->identify();
+}
+
+void* AlignableTransform__AlignTransMember_dict::method_4752( void* o)
+{
+  return (void*)&((const AlignableTransform::AlignTransMember*)o)->transform();
+}
+
+void AlignableTransform__AlignTransMember_dict::method_4753( void* o, const std::vector<void*>& arg)
+{
+  ((AlignableTransform::AlignTransMember*)o)->setTransform(*(const HepGeom::Transform3D*)arg[0]);
+}
+
+
+namespace {
+  struct Dictionaries {
+    Dictionaries() {
+      AlignableTransform__AlignTransMember_dict();
+      Class::resolvePending();
+    }
+  };
+  static Dictionaries instance;
+}
+
+
+
+// This file has been generated by lcgdict with the --capabilities option
+static  const char* clnames[] = {
+//--Begin DetDescrConditionsDict
+  "LCGDict/AlignableTransform::AlignTransMember",
+//--End   DetDescrConditionsDict
+//--Final End
+};
+
+extern "C" void SEAL_CAPABILITIES (const char**& names, int& n )
+{ 
+  names = clnames;
+  n = sizeof(clnames)/sizeof(char*);
+}

DetectorDescription/DetDescrCond/DetDescrConditions/src/DetStatus.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// DetStatus.cxx - class to hold status of one detector
+// Richard Hawkings, started 19/12/06
+#include "DetDescrConditions/DetStatus.h"
+
+DetStatus::DetStatus() {}
+
+DetStatus::DetStatus(const int fullcode, const float deadfrac,
+ 			    const float deadthrust) :
+  m_code(fullcode), m_deadfrac(deadfrac), m_deadthrust(deadthrust) {}
+
+std::string DetStatus::colour() const {
+  // endcoding of colours here 0=unknown, 1=RED, 2=YELLOW, 3=GREEN
+  // only lowest two bits are used - rest is free for subdetector use
+  // unless code is -1, indicating BLACK (absent)
+  if (m_code<0) return "BLACK"; 
+  int code=m_code & 3;
+  if (code==1) return "RED";
+  if (code==2) return "YELLOW";
+  if (code==3) return "GREEN";
+  return "UNKNOWN";
+}

DetectorDescription/DetDescrCond/DetDescrConditions/src/DetStatusMap.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// DetStatusMap.cxx - implementation for DetStatusMap class
+// Richard Hawkings started 12/06
+#include "DetDescrConditions/DetStatusMap.h"
+
+DetStatusMap::DetStatusMap() : m_statmap() {}