'CMakeLists.txt' (TileEvent-00-09-52)

	* Tagging TileEvent-00-09-52.
	* TileEvent/TileLasCalib.h: Fix coverity warning: dead code.

2015-11-16  scott snyder  <snyder@bnl.gov>

	* Tagging TileEvent-00-09-51.
	* TileEvent/TileLasCalib.h: HG and LG should be static const, to
	comply with ATLAS naming conventions.
	* Tagging TileEvent-00-09-50.
	* gcc5 port:
	* TileEvent/TileBeamElem.h, src/TileBeamElem.cxx: Add constructor
	taking digits vector by move.  get_digits() should return by const
	reference, not by value.
	* TileEvent/TileCosmicMuon.h: Setters should take vectors by const
	reference instead of by value.  Add move setters.
	* TileEvent/TileDigits.h, src/TileDigits.cxx: Add constructor
	taking digits vector by move.
	* TileEvent/TileRawChannel.h, src/TileRawChannel.cxx: Add
	constructor taking vectors by move.  Add assign methods.  Add
...
(Long ChangeLog diff - truncated)

TileCalorimeter/TileEvent/CMakeLists.txt

+################################################################################
+# Package: TileEvent
+################################################################################
+
+# Declare the package name:
+atlas_subdir( TileEvent )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs( PUBLIC
+                          Calorimeter/CaloEvent
+                          Control/CLIDSvc
+                          Control/DataModel
+                          Control/StoreGate
+                          DetectorDescription/Identifier
+                          Event/EventContainers
+                          GaudiKernel
+                          TileCalorimeter/TileConditions
+                          TileCalorimeter/TileIdentifier
+                          TileCalorimeter/TileSimEvent
+                          PRIVATE
+                          Calorimeter/CaloDetDescr
+                          Calorimeter/CaloIdentifier
+                          Control/SGTools )
+
+# External dependencies:
+find_package( ROOT COMPONENTS Core Tree MathCore Hist RIO pthread )
+
+# Component(s) in the package:
+atlas_add_library( TileEvent
+                   src/Tile*.cxx
+                   PUBLIC_HEADERS TileEvent
+                   PRIVATE_INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
+                   LINK_LIBRARIES CaloEvent DataModel Identifier GaudiKernel TileIdentifier TileSimEvent StoreGateLib SGtests TileConditionsLib CaloDetDescrLib
+                   PRIVATE_LINK_LIBRARIES ${ROOT_LIBRARIES} CaloIdentifier SGTools )
+
+atlas_add_dictionary( TileEventDict
+                      TileEvent/TileEventDict.h
+                      TileEvent/selection.xml
+                      INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
+                      LINK_LIBRARIES ${ROOT_LIBRARIES} CaloEvent DataModel StoreGateLib SGtests Identifier GaudiKernel TileConditionsLib TileIdentifier TileSimEvent CaloDetDescrLib CaloIdentifier SGTools TileEvent )
+

TileCalorimeter/TileEvent/TileEvent/TileBeamElem.h

@@ -34,6 +34,7 @@ public:
     TileBeamElem(const Identifier& id, const std::vector<uint32_t>& digits );
 
     TileBeamElem(const HWIdentifier& HWid, const std::vector<uint32_t>& digits );
+    TileBeamElem(const HWIdentifier& HWid, std::vector<uint32_t>&& digits );
   
     TileBeamElem(const HWIdentifier& HWid, uint32_t digit );
   
@@ -45,7 +46,7 @@ public:
 
     inline int size(void) const { return m_digits.size(); }
   
-    inline std::vector<uint32_t>  get_digits(void)  const { return m_digits; }
+    inline const std::vector<uint32_t>&  get_digits(void)  const { return m_digits; }
 
     std::string whoami   (void) const { return "TileBeamElem"; }
     void        print    (void) const;

TileCalorimeter/TileEvent/TileEvent/TileCosmicMuon.h

@@ -56,15 +56,44 @@ class TileCosmicMuon
   inline void SetDirectionTheta(double theta)                     {m_directionTheta   = theta;}
   inline void SetFitQuality(double quality)                       {m_fitQuality	      = quality;}
   inline void SetFitNCells(int ncells)                            {m_fitNCells 	      = ncells;}
-  inline void SetPathTop(std::vector<double> path)                {m_pathTop          = path;}
-  inline void SetPathBottom(std::vector<double> path)             {m_pathBottom       = path;}
-  inline void SetEnergyTop(std::vector<double> energy)            {m_energyTop        = energy;}
-  inline void SetEnergyBottom(std::vector<double> energy)         {m_energyBottom     = energy;}
-  inline void SetTrackCellHash(std::vector<IdentifierHash> cells) {m_trackCellHash    = cells;}
-  inline void SetSegmentPath(std::vector<double> path)            {m_segmentPath      = path;}
-  inline void SetSegmentPartition(std::vector<int> partition)     {m_segmentPartition = partition;}
-  inline void SetSegmentModule(std::vector<int> module)           {m_segmentModule    = module;}
-  inline void SetSegmentSampling(std::vector<int> sampling)       {m_segmentSampling  = sampling;}
+
+  inline void SetPathTop(const std::vector<double>& path)
+  {m_pathTop          = path;}
+  inline void SetPathBottom(const std::vector<double>& path)
+  {m_pathBottom       = path;}
+  inline void SetEnergyTop(const std::vector<double>& energy)
+  {m_energyTop        = energy;}
+  inline void SetEnergyBottom(const std::vector<double>& energy)
+  {m_energyBottom     = energy;}
+  inline void SetTrackCellHash(const std::vector<IdentifierHash>& cells)
+  {m_trackCellHash    = cells;}
+  inline void SetSegmentPath(const std::vector<double>& path)
+  {m_segmentPath      = path;}
+  inline void SetSegmentPartition(const std::vector<int>& partition)
+  {m_segmentPartition = partition;}
+  inline void SetSegmentModule(const std::vector<int>& module)
+  {m_segmentModule    = module;}
+  inline void SetSegmentSampling(const std::vector<int>& sampling)
+  {m_segmentSampling  = sampling;}
+
+  inline void SetPathTop(std::vector<double>&& path)
+  {m_pathTop          = std::move(path);}
+  inline void SetPathBottom(std::vector<double>&& path)
+  {m_pathBottom       = std::move(path);}
+  inline void SetEnergyTop(std::vector<double>&& energy)
+  {m_energyTop        = std::move(energy);}
+  inline void SetEnergyBottom(std::vector<double>&& energy)
+  {m_energyBottom     = std::move(energy);}
+  inline void SetTrackCellHash(std::vector<IdentifierHash>&& cells)
+  {m_trackCellHash    = std::move(cells);}
+  inline void SetSegmentPath(std::vector<double>&& path)
+  {m_segmentPath      = std::move(path);}
+  inline void SetSegmentPartition(std::vector<int>&& partition)
+  {m_segmentPartition = std::move(partition);}
+  inline void SetSegmentModule(std::vector<int>&& module)
+  {m_segmentModule    = std::move(module);}
+  inline void SetSegmentSampling(std::vector<int>&& sampling)
+  {m_segmentSampling  = std::move(sampling);}
 
  
   /** Getters. See class members description. */

TileCalorimeter/TileEvent/TileEvent/TileDigits.h

@@ -44,6 +44,8 @@ public:
 
     TileDigits(const HWIdentifier& HWid, const std::vector<float>& digits );
 
+    TileDigits(const HWIdentifier& HWid, std::vector<float>&& digits );
+
 
     /** @return number of samples */
     int nsamples() const { return m_digits.size(); }

TileCalorimeter/TileEvent/TileEvent/TileLasCalib.h

@@ -18,9 +18,7 @@ class TileLasCalib {
  public:
   
    TileLasCalib() 
-     : HG(1)
-     , LG(0)
-     , m_mean_LG(-99.)
+     : m_mean_LG(-99.)
      , m_sigma_LG(-99.)
      , m_mean_HG(-99.)
      , m_sigma_HG(-99.)
@@ -98,14 +96,14 @@ class TileLasCalib {
     bool isSet(int gain) const{
       if(gain == LG) return m_isSet_LG;
       if(gain == HG) return m_isSet_HG;
-      if(gain != LG && gain != HG) return false;
+      //if(gain != LG && gain != HG) return false;
       return false;
     } // isSet
     
   private:
     
-    int HG;
-    int LG;
+    static const int HG = 1;
+    static const int LG = 0;
     double m_mean_LG;
     double m_sigma_LG;
     double m_mean_HG;

TileCalorimeter/TileEvent/TileEvent/TileRawChannel.h

@@ -43,12 +43,47 @@ class TileRawChannel: public TileRawData {
 
     TileRawChannel(const Identifier& id, float amplitude, float time, float quality, float ped = 0.0);
     TileRawChannel(const HWIdentifier& HWid, float amplitude, float time, float quality, float ped = 0.0);
+    TileRawChannel(const HWIdentifier& HWid, 
+                   std::vector<float>&& amplitude,
+                   std::vector<float>&& time,
+                   std::vector<float>&& quality,
+                   float ped = 0.0);
 
     /* Destructor */
 
     ~TileRawChannel() {
     }
 
+    void assign (const HWIdentifier& id,
+                 float amplitude,
+                 float time,
+                 float quality,
+                 float ped = 0.0)
+    {
+      TileRawData::operator= (TileRawData (id));
+      m_amplitude.resize(1);
+      m_amplitude[0] = amplitude;
+      m_time.resize(1);
+      m_time[0] = time;
+      m_quality.resize(1);
+      m_quality[0] = quality;
+      m_pedestal = ped;
+    }
+
+    template <class IteratorA, class IteratorT, class IteratorQ>
+    void assign (const HWIdentifier& id,
+                 IteratorA amplitude_beg, IteratorA amplitude_end,
+                 IteratorT time_beg,      IteratorT time_end,
+                 IteratorQ qual_beg,      IteratorQ qual_end,
+                 float ped = 0.0)
+    {
+      TileRawData::operator= (TileRawData (id));
+      m_amplitude.assign (amplitude_beg, amplitude_end);
+      m_time.assign      (time_beg,      time_end);
+      m_quality.assign   (qual_beg,      qual_end);
+      m_pedestal = ped;
+    }
+
     int add(float amplitude, float time, float quality);
     void setPedestal(float ped) { m_pedestal = ped;  }
     void scaleAmplitude(float scale);
@@ -58,13 +93,15 @@ class TileRawChannel: public TileRawData {
     /* Inline access methods */
 
     inline float amplitude(int ind = 0) const { return m_amplitude[ind]; }
+    inline void setAmplitude (float a, int ind=0)  { m_amplitude[ind] = a; }
     inline float time(int ind = 0)      const { return m_time[ind]; }
     inline float uncorrTime()           const {  return m_time[m_time.size() - 1]; }
     inline float quality(int ind = 0)   const { return m_quality[ind]; }
     inline float pedestal(void)         const { return m_pedestal; }
 
-    inline int size(void) const { return m_amplitude.size(); }
-    inline int sizeTime(void) const { return m_time.size(); }
+    inline int size() const { return m_amplitude.size(); }
+    inline int sizeTime() const { return m_time.size(); }
+    inline int sizeQuality() const { return m_quality.size(); }
 
     std::string whoami(void) const { return "TileRawChannel"; }
     void print(void) const;

TileCalorimeter/TileEvent/TileEvent/TileRawData.h

@@ -37,7 +37,10 @@ public:
     /* Constructor: */
     TileRawData(){}
     TileRawData(const Identifier& id);
-    TileRawData(const HWIdentifier& HWid);
+    TileRawData(const HWIdentifier& HWid)
+      : m_adc_hwid (HWid)
+    {
+    }
 
     /* Destructor */
     virtual ~TileRawData() {}

TileCalorimeter/TileEvent/TileEvent/TileTTL1.h

@@ -35,6 +35,8 @@ public:
 
     TileTTL1(const Identifier& id, const std::vector<float>& digits );
 
+    TileTTL1(const Identifier& id, std::vector<float>&& digits );
+
     ~TileTTL1() {}
 
     /* Access methods */

TileCalorimeter/TileEvent/src/TileBeamElem.cxx

@@ -41,6 +41,14 @@ TileBeamElem::TileBeamElem( const HWIdentifier& HWid,
 {
 }
 
+TileBeamElem::TileBeamElem( const HWIdentifier& HWid,
+                            std::vector<uint32_t>&& digits )
+
+  : TileRawData( HWid )
+  , m_digits ( std::move(digits) )
+{
+}
+
 TileBeamElem::TileBeamElem( const HWIdentifier& HWid,
                             uint32_t digit )
 

TileCalorimeter/TileEvent/src/TileDigits.cxx

@@ -97,6 +97,15 @@ TileDigits::TileDigits( const HWIdentifier& HWid,
 }
 
 
+TileDigits::TileDigits( const HWIdentifier& HWid,
+                        std::vector<float>&& digits )
+  
+  : TileRawData( HWid )
+    , m_digits ( std::move(digits) )
+{
+}
+
+
 void TileDigits::print() const
 {
     std::cout << (std::string) (*this) << std::endl;

TileCalorimeter/TileEvent/src/TileRawChannel.cxx

@@ -46,6 +46,19 @@ TileRawChannel::TileRawChannel( const HWIdentifier& HWid,
 {
 }
 
+TileRawChannel::TileRawChannel(const HWIdentifier& HWid, 
+                               std::vector<float>&& amplitude,
+                               std::vector<float>&& time,
+                               std::vector<float>&& quality,
+                               float ped /*= 0.0*/)
+  : TileRawData( HWid ),
+    m_amplitude (std::move(amplitude)),
+    m_time (std::move(time)),
+    m_quality (std::move(quality)),
+    m_pedestal (ped)
+{
+}
+
 int TileRawChannel::add(float amplitude, float time, float quality) {
   m_amplitude.push_back(amplitude);
   m_time.push_back(time);

TileCalorimeter/TileEvent/src/TileRawData.cxx

@@ -31,10 +31,6 @@
 // get cabling
 TileCablingService * s_cabling = TileCablingService::getInstance();
 
-TileRawData::TileRawData( const HWIdentifier& hwid ) : m_adc_hwid( hwid )
-{
-}
-
 TileRawData::TileRawData( const Identifier& id )
 {
     m_adc_hwid = s_cabling->s2h_adc_id(id);

TileCalorimeter/TileEvent/src/TileTTL1.cxx

@@ -36,6 +36,13 @@ TileTTL1::TileTTL1( const Identifier& id,
   { }
 
 
+TileTTL1::TileTTL1( const Identifier& id,
+                    std::vector<float>&& digits ) :
+  m_ID (id),
+  m_TTL1digits (std::move(digits))
+  { }
+
+
 TileTTL1::TileTTL1( const Identifier& id,
 		    const std::vector<double>& digits ) :
   m_ID (id)