diff --git a/InnerDetector/InDetConditions/SCT_ConditionsData/SCT_ConditionsData/SCT_CondParameterData.h b/InnerDetector/InDetConditions/SCT_ConditionsData/SCT_ConditionsData/SCT_CondParameterData.h
new file mode 100644
index 0000000000000000000000000000000000000000..0766f2166aa63d0aa8336d581cc4ea317444ba49
--- /dev/null
+++ b/InnerDetector/InDetConditions/SCT_ConditionsData/SCT_ConditionsData/SCT_CondParameterData.h
@@ -0,0 +1,80 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * SCT_CondParameterData.h
+ * @file header file for data object
+ * @author Susumu Oda - 2018-01-25
+ **/
+
+#ifndef SCT_CONDPARAMETERDATA_H
+#define SCT_CONDPARAMETERDATA_H
+
+// STL include
+#include <vector>
+
+// boost include
+#include "boost/array.hpp"
+
+// Athena includes
+#include "Identifier/IdentifierHash.h"
+#include "AthenaKernel/CLASS_DEF.h"
+
+class SCT_CondParameterData {
+public:
+ // Parameters
+ enum ParameterIndex{AVG_THRESHOLD, N_PARAMETERS, INVALID_PARAMETER};
+
+ //constructor
+ SCT_CondParameterData();
+
+ //destructor
+ virtual ~SCT_CondParameterData();
+ //@name main methods
+ //@{
+ /// Get the indicated value for a module identifier hash
+ float getValue(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam) const;
+ /// Fill a user-provided vector with the values
+ void getValues(std::vector<float>& userVector, const SCT_CondParameterData::ParameterIndex iparam) const;
+ /// Get the indicated value for a module identifier hash
+ void setValue(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam, const float value);
+ /// Extended methods for data structure insertion
+ bool insert(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam, const float value);
+ /// Is a given value within acceptable limits?
+ bool isValid(const float parameterValue, const SCT_CondParameterData::ParameterIndex iparam) const;
+ /// What is the default error value for this parameter?
+ float invalid(const unsigned int iparam) const;
+ /// Get maximum value
+ float max(const SCT_CondParameterData::ParameterIndex iparam) const;
+ /// Get minimum value
+ float min(const SCT_CondParameterData::ParameterIndex iparam) const;
+ /// Get average value
+ float avg(const SCT_CondParameterData::ParameterIndex iparam) const;
+ /// Get standard deviation
+ float sd(const SCT_CondParameterData::ParameterIndex iparam) const;
+ /// Get the number of values
+ unsigned int n(const SCT_CondParameterData::ParameterIndex iparam) const;
+ /// Clear all data members
+ void clear();
+ //@}
+
+private:
+ enum {N_ELEMENTS=8176};
+
+ boost::array<boost::array<float, N_PARAMETERS>, N_ELEMENTS > m_values;
+
+ float m_min[N_PARAMETERS];
+ float m_max[N_PARAMETERS];
+ unsigned int m_n[N_PARAMETERS];
+ float m_sum[N_PARAMETERS];
+ float m_sumsq[N_PARAMETERS];
+};
+
+CLASS_DEF( SCT_CondParameterData , 34383719 , 1 )
+
+#include "AthenaKernel/CondCont.h"
+CONDCONT_DEF( SCT_CondParameterData, 3856939 );
+
+
+#endif // SCT_CONDPARAMETERDATA_H
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsData/src/SCT_CondParameterData.cxx b/InnerDetector/InDetConditions/SCT_ConditionsData/src/SCT_CondParameterData.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..37eecd5da17853993641367aeefc644cf3c46df3
--- /dev/null
+++ b/InnerDetector/InDetConditions/SCT_ConditionsData/src/SCT_CondParameterData.cxx
@@ -0,0 +1,114 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "SCT_ConditionsData/SCT_CondParameterData.h"
+
+#include <limits>
+#include <cmath>
+
+// constructor
+SCT_CondParameterData::SCT_CondParameterData() {
+ clear();
+}
+
+// destructor
+SCT_CondParameterData::~SCT_CondParameterData() {
+}
+
+// Get the indicated value for a module identifier hash
+float SCT_CondParameterData::getValue(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam) const {
+ return m_values[idHash][iparam];
+}
+
+// Fill a user-provided vector with the values
+void SCT_CondParameterData::getValues(std::vector<float>& userVector, const SCT_CondParameterData::ParameterIndex iparam) const {
+ for (unsigned int i{0}; i!=m_values.size(); ++i) {
+ userVector.push_back(m_values[i][iparam]);
+ }
+}
+
+/// Get the indicated value for a module identifier hash
+void SCT_CondParameterData::setValue(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam, const float value) {
+ if (insert(idHash, iparam, value)) {
+ m_n[iparam]++;
+ m_sum[iparam] += value;
+ m_sumsq[iparam] += value*value;
+ m_min[iparam] = std::min(m_min[iparam], value);
+ m_max[iparam] = std::max(m_max[iparam], value);
+ }
+}
+
+// Extended methods for data structure insertion
+bool SCT_CondParameterData::insert(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam, const float theValue) {
+ // theValue must be valid
+ if (not isValid(theValue, iparam)) return false;
+ boost::array<float,N_PARAMETERS>& paramArray = m_values[idHash];
+ // initial value should be invalid, only insert if this is the case
+ if (not isValid(paramArray[iparam], iparam)) {
+ paramArray[iparam] = theValue;
+ return true;
+ } else {
+ return false;
+ }
+}
+
+// Is a given value within acceptable limits?
+bool SCT_CondParameterData::isValid(const float parameterValue, const SCT_CondParameterData::ParameterIndex iparam) const {
+ // Second condition is to check if it is nan.
+ if (iparam==AVG_THRESHOLD and (parameterValue!=parameterValue)) return false;
+ return true;
+}
+
+// What is the default error value for this parameter?
+float SCT_CondParameterData::invalid(const unsigned int iparam) const {
+ float result{0.0};
+ if (iparam==AVG_THRESHOLD) {
+ result=std::numeric_limits<float>::quiet_NaN();
+ }
+ return result;
+}
+
+// Get maximum value
+float SCT_CondParameterData::max(const SCT_CondParameterData::ParameterIndex iparam) const {
+ return m_max[iparam];
+}
+
+// Get minimum value
+float SCT_CondParameterData::min(const SCT_CondParameterData::ParameterIndex iparam) const {
+ return m_min[iparam];
+}
+
+// Get average value
+float SCT_CondParameterData::avg(const SCT_CondParameterData::ParameterIndex iparam) const {
+ return (m_n[iparam]!=0)?(m_sum[iparam]/m_n[iparam]):(std::numeric_limits<float>::quiet_NaN());
+}
+
+// Get standard deviation
+float SCT_CondParameterData::sd(const SCT_CondParameterData::ParameterIndex iparam) const {
+ float mu{m_sum[iparam]/m_n[iparam]};
+ return std::sqrt((m_sumsq[iparam]/m_n[iparam]) - mu*mu);
+}
+
+// Get the number of values
+unsigned int SCT_CondParameterData::n(const SCT_CondParameterData::ParameterIndex iparam) const {
+ return m_n[iparam];
+}
+
+// Clear all data members
+void SCT_CondParameterData::clear() {
+ boost::array<float, N_PARAMETERS> init;
+ for (unsigned int i{0}; i!=N_PARAMETERS; ++i) {
+ m_min[i] = std::numeric_limits<float>::max();
+ m_max[i] = std::numeric_limits<float>::min();
+ m_n[i] = 0;
+ m_sum[i] = 0.0;
+ m_sumsq[i] = 0.0;
+ init[i] = invalid(i);
+ }
+
+ //initialize boost array
+ for (unsigned int i{0}; i!=N_ELEMENTS; ++i) {
+ m_values[i] = init;
+ }
+}
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsServices/SCT_ConditionsServices/ISCT_ConditionsParameterSvc.h b/InnerDetector/InDetConditions/SCT_ConditionsServices/SCT_ConditionsServices/ISCT_ConditionsParameterSvc.h
index 2ec3e1865c6a3d1c9b69d6d7737e5730e36e98a3..c8910b628a2630cf95cd3631da31a9f667da72d7 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsServices/SCT_ConditionsServices/ISCT_ConditionsParameterSvc.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsServices/SCT_ConditionsServices/ISCT_ConditionsParameterSvc.h
@@ -18,7 +18,7 @@
#include "GaudiKernel/IInterface.h"
//local includes
-#include "SCT_ConditionsServices/SCT_ConditionsParameters.h"
+#include "SCT_ConditionsData/SCT_CondParameterData.h"
//fwd declarations
class IdentifierHash;
@@ -33,37 +33,37 @@ class ISCT_ConditionsParameterSvc: virtual public IInterface {
static const InterfaceID& interfaceID(); //!< reimplemented from IInterface
///Is the required parameter available?
- virtual bool available(const SCT_ConditionsServices::ParameterIndex iparam)=0;
+ virtual bool available(const SCT_CondParameterData::ParameterIndex iparam)=0;
///Give the indicated value for a module identifier hash
- virtual float value(const IdentifierHash& idHash, const SCT_ConditionsServices::ParameterIndex iparam)=0;
+ virtual float value(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam)=0;
///Measure of how many valid values went to calculate it. Should be 1 but if, say, 3 chip values were valid out of 6, it could be less (0.5 in this case)
- virtual float validity(const IdentifierHash& idHash, const SCT_ConditionsServices::ParameterIndex iparam)=0;
+ virtual float validity(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam)=0;
///Is a given value within acceptable limits?
- virtual bool isValid(const float parameterValue, const SCT_ConditionsServices::ParameterIndex iparam)=0;
+ virtual bool isValid(const float parameterValue, const SCT_CondParameterData::ParameterIndex iparam)=0;
///What is the default error value for this parameter?
virtual float invalid(const unsigned int iparam) const =0;
///Maximum value read in from the database
- virtual float max(const SCT_ConditionsServices::ParameterIndex iparam)=0;
+ virtual float max(const SCT_CondParameterData::ParameterIndex iparam)=0;
///Minimum value read in from the database
- virtual float min(const SCT_ConditionsServices::ParameterIndex iparam)=0;
+ virtual float min(const SCT_CondParameterData::ParameterIndex iparam)=0;
///Average value
- virtual float avg(const SCT_ConditionsServices::ParameterIndex iparam)=0;
+ virtual float avg(const SCT_CondParameterData::ParameterIndex iparam)=0;
///Standard deviation
- virtual float sd(const SCT_ConditionsServices::ParameterIndex iparam)=0;
+ virtual float sd(const SCT_CondParameterData::ParameterIndex iparam)=0;
///Number of values read in
- virtual unsigned int n(const SCT_ConditionsServices::ParameterIndex iparam)=0;
+ virtual unsigned int n(const SCT_CondParameterData::ParameterIndex iparam)=0;
///Fill a user-provided vector with the values (hopefully won't be needed?)
- virtual void getValues(std::vector<float>& userVector, const SCT_ConditionsServices::ParameterIndex iparam)=0;
+ virtual void getValues(std::vector<float>& userVector, const SCT_CondParameterData::ParameterIndex iparam)=0;
///Report whether the structure was filled
virtual bool filled() const =0;
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsServices/SCT_ConditionsServices/SCT_ConditionsParameters.h b/InnerDetector/InDetConditions/SCT_ConditionsServices/SCT_ConditionsServices/SCT_ConditionsParameters.h
index b8821e674ec6690497bda938d6503a58e60a3214..3b2c25139444b11c412aaa269d6ad6714b97af72 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsServices/SCT_ConditionsServices/SCT_ConditionsParameters.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsServices/SCT_ConditionsServices/SCT_ConditionsParameters.h
@@ -26,8 +26,6 @@ namespace SCT_ConditionsServices{
INDEX_HVfraction=1,
INDEX_MajorityState=3};
enum Bec{bec_ECC=-2, bec_BARREL=0, bec_ECA=+2};
- enum ParameterIndex{AVG_THRESHOLD, N_PARAMETERS, INVALID_PARAMETER};
- static const std::string parameterNames[]{"average threshold per module side","number of parameters"};
}
#endif // SCT_ConditionsParameters_h
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsServices/share/testParameters.py b/InnerDetector/InDetConditions/SCT_ConditionsServices/share/testParameters.py
index c992fe7f958aee2a8c43044b69c097ceafbc4304..4bc586fc2e68b28f72ba161b9d75bbdc5607d14a 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsServices/share/testParameters.py
+++ b/InnerDetector/InDetConditions/SCT_ConditionsServices/share/testParameters.py
@@ -118,8 +118,16 @@ from IOVDbSvc.CondDB import conddb
conddb.dbdata="COMP200"
IOVDbSvc.GlobalTag=globalflags.ConditionsTag()
IOVDbSvc.OutputLevel = 3
-conddb.addFolder('',"<db>COOLONL_SCT/COMP200</db> /SCT/DAQ/Configuration/Chip")
+conddb.addFolder('',"<db>COOLONL_SCT/COMP200</db> /SCT/DAQ/Configuration/Chip", className="CondAttrListVec")
conddb.addFolder("","<db>COOLONL_SCT/COMP200</db> /SCT/DAQ/Configuration/ROD")
conddb.addFolder("","<db>COOLONL_SCT/COMP200</db> /SCT/DAQ/Configuration/Geog")
conddb.addFolder("","<db>COOLONL_SCT/COMP200</db> /SCT/DAQ/Configuration/RODMUR")
conddb.addFolder("","<db>COOLONL_SCT/COMP200</db> /SCT/DAQ/Configuration/MUR")
+
+from IOVSvc.IOVSvcConf import CondSvc
+ServiceMgr += CondSvc()
+from AthenaCommon.AlgSequence import AthSequencer
+condSeq = AthSequencer("AthCondSeq")
+
+from SCT_ConditionsServices.SCT_ConditionsServicesConf import SCT_ConditionsParameterCondAlg
+condSeq += SCT_ConditionsParameterCondAlg( "SCT_ConditionsParameterCondAlg" )
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterCondAlg.cxx b/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..d09d725974394637603bb3288870ba7db448fbee
--- /dev/null
+++ b/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterCondAlg.cxx
@@ -0,0 +1,193 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "SCT_ConditionsParameterCondAlg.h"
+
+#include "SCT_Chip.h"
+#include "AthenaPoolUtilities/CondAttrListVec.h"
+#include "Identifier/IdentifierHash.h"
+#include "GaudiKernel/EventIDRange.h"
+
+namespace {//anonymous namespace introduces file-scoped functions
+ //is the value 'Not-a-Number' ?
+ template <typename T>
+ bool is_nan(const T& val) {
+ return val!=val; //NaN is only value for which this is true
+ }
+ //response curve fit possibilities
+ enum ResponseCurveFit{NO_CURVE=0, POLYNOMIAL, GRILLO, EXPONENTIAL, LINEAR, N_FUNCS}; //'Grillo' refers to Alex Grillo, Santa Cruz, who worked on SCT electronics development
+ //response curve fit function
+ float responseCurve(const float param0, const float param1, const float param2, const float vthreshold, const unsigned int rcFunc) {
+ float result{std::numeric_limits<float>::quiet_NaN()};
+ switch (rcFunc) {
+ case LINEAR:
+ if (param1!=0.0) {
+ result = (vthreshold - param0)/param1;
+ }
+ break;
+ case EXPONENTIAL:
+ if ((vthreshold - param2)!=0) {
+ float err2{param0/(vthreshold-param2)-1.0f};
+ if (err2 > 0.0) {
+ result = -param1*std::log(err2);
+ }
+ }
+ break;
+ case GRILLO:
+ if (param2!=0) {
+ float err3{param1*(1.0f-((vthreshold-param0)/param2))};
+ if (err3!=0) {
+ result = (vthreshold-param0)/err3;
+ }
+ }
+ break;
+ case POLYNOMIAL:
+ if (param2!=0) {
+ result = (-param1 + std::sqrt((param1*param1)-(4.0*param2*(param0-vthreshold)))) / 2.0*param2;
+ }
+ break;
+ default:
+ //nop
+ break;
+ }//switch
+ if (is_nan(result)) return result;
+ result *= result;
+ return result;
+ }//func responseCurve
+
+ void parseResponseCurveArguments(float* p, const std::string& arguments) {
+ //string is of form:
+ //p0 1.284730e+03 p1 5.830000e+00 p2 -5.989900e+02
+ float *p0{&p[0]};
+ float *p1{&p[1]};
+ float *p2{&p[2]};
+ std::sscanf(arguments.c_str(), "p0 %50e p1 %50e p2 %50e", p0, p1, p2);
+ }
+ //folder to retrieve for threshold parameters
+ const std::string chipFolderName{"/SCT/DAQ/Configuration/Chip"}; //CoraCool folder in the DB
+}//namespace
+
+SCT_ConditionsParameterCondAlg::SCT_ConditionsParameterCondAlg(const std::string& name, ISvcLocator* pSvcLocator)
+ : ::AthAlgorithm(name, pSvcLocator)
+ , m_readKey{"/SCT/DAQ/Configuration/Chip"}
+ , m_writeKey{"SCT_CondParameterData"}
+ , m_cablingSvc{"SCT_CablingSvc", name}
+ , m_condSvc{"CondSvc", name}
+{
+ declareProperty("ReadKey", m_readKey, "Key of input (raw) chip conditions folder");
+ declareProperty("WriteKey", m_writeKey, "Key of output (derived) average threshold conditions folder");
+}
+
+SCT_ConditionsParameterCondAlg::~SCT_ConditionsParameterCondAlg() {
+}
+
+StatusCode SCT_ConditionsParameterCondAlg::initialize() {
+ ATH_MSG_DEBUG("initialize " << name());
+
+ // Cabling service
+ ATH_CHECK(m_cablingSvc.retrieve());
+ // CondSvc
+ ATH_CHECK(m_condSvc.retrieve());
+ // Read Cond Handle
+ ATH_CHECK(m_readKey.initialize());
+ // Write Cond Handle
+ ATH_CHECK(m_writeKey.initialize());
+ if(m_condSvc->regHandle(this, m_writeKey).isFailure()) {
+ ATH_MSG_FATAL("unable to register WriteCondHandle " << m_writeKey.fullKey() << " with CondSvc");
+ return StatusCode::FAILURE;
+ }
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode SCT_ConditionsParameterCondAlg::execute() {
+ ATH_MSG_DEBUG("execute " << name());
+
+ // Write Cond Handle
+ SG::WriteCondHandle<SCT_CondParameterData> writeHandle{m_writeKey};
+ // Do we have a valid Write Cond Handle for current time?
+ if (writeHandle.isValid()) {
+ // in theory this should never be called in MT
+ writeHandle.updateStore();
+ ATH_MSG_DEBUG("CondHandle " << writeHandle.fullKey() << " is already valid."
+ << ". In theory this should not be called, but may happen"
+ << " if multiple concurrent events are being processed out of order."
+ << " Forcing update of Store contents");
+ return StatusCode::SUCCESS;
+ }
+
+ // Read Cond Handle
+ SG::ReadCondHandle<CondAttrListVec> readHandle{m_readKey};
+ const CondAttrListVec* readCdo{*readHandle};
+ if (readCdo==nullptr) {
+ ATH_MSG_FATAL("Null pointer to the read conditions object");
+ return StatusCode::FAILURE;
+ }
+ // Get the validitiy range
+ EventIDRange rangeW;
+ if (not readHandle.range(rangeW)) {
+ ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandle.key());
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("Size of CondAttrListVec " << readHandle.fullKey() << " readCdo->size()= " << readCdo->size());
+ ATH_MSG_INFO("Range of input is " << rangeW);
+
+ // Construct the output Cond Object and fill it in
+ SCT_CondParameterData* writeCdo{new SCT_CondParameterData()};
+
+ // Loop over elements (i.e groups of 6 chips) in DB folder
+ const unsigned int nChipsPerModule{12};
+ const unsigned int nChipsPerSide{6};
+ const float mVperDacBit{2.5};
+ CondAttrListVec::const_iterator modItr{readCdo->begin()};
+ CondAttrListVec::const_iterator modEnd{readCdo->end()};
+ for (; modItr != modEnd; modItr += nChipsPerModule) {
+ // Get SN and identifiers (the channel number is serial number+1)
+ const unsigned int truncatedSerialNumber{modItr->first - 1};
+ const IdentifierHash& moduleHash{m_cablingSvc->getHashFromSerialNumber(truncatedSerialNumber)};
+ if (not moduleHash.is_valid()) continue;
+ // Loop over chips within module
+
+ for (unsigned int side{0}; side!=2; ++side) {
+ IdentifierHash elementHash{moduleHash + side};
+ CondAttrListVec::const_iterator channelItr{modItr};
+ CondAttrListVec::const_iterator channelEnd{modItr + nChipsPerSide};
+ std::vector<SCT_Chip*> chipsInMod;
+ chipsInMod.reserve(nChipsPerSide);
+ float parameters[3]{0.0, 0.0, 0.0};
+ float chipsum{0.0};
+ for (; channelItr != channelEnd; ++channelItr) {
+ // Can get AttributeList from second (see http://lcgapp.cern.ch/doxygen/CORAL/CORAL_1_9_3/doxygen/html/classcoral_1_1_attribute_list.html)
+ //short id = channelItr->second[2].data<short>(); //chip 0-11
+ float vthr{mVperDacBit * channelItr->second[10].data<short>()}; //threshold setting
+ short rcFunctionIndex{channelItr->second[15].data<short>()}; //response curve function
+ std::string rcArgumentString{channelItr->second[16].data<std::string>()}; //response curve arguments
+ parseResponseCurveArguments(parameters, rcArgumentString);
+ //float target = channelItr->second[18].data<float>(); //trim target...use for debugging only
+ float femtoCoulombThreshold{responseCurve(parameters[0], parameters[1], parameters[2], vthr, rcFunctionIndex)};
+ chipsum+=femtoCoulombThreshold;
+ }
+ float moduleAverage{chipsum/nChipsPerSide};
+ writeCdo->setValue(elementHash, SCT_CondParameterData::AVG_THRESHOLD, moduleAverage);
+ }//side loop
+ }//module loop
+
+ // Record the output cond object
+ if (writeHandle.record(rangeW, writeCdo).isFailure()) {
+ ATH_MSG_FATAL("Could not record SCT_CondParameterData " << writeHandle.key()
+ << " with EventRange " << rangeW
+ << " into Conditions Store");
+ delete writeCdo;
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO("recorded new CDO " << writeHandle.key() << " with range " << rangeW << " into Conditions Store");
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode SCT_ConditionsParameterCondAlg::finalize()
+{
+ ATH_MSG_DEBUG("finalize " << name());
+ return StatusCode::SUCCESS;
+}
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterCondAlg.h b/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterCondAlg.h
new file mode 100644
index 0000000000000000000000000000000000000000..62647f43bce799c6f70734bc59a14fee1cc93582
--- /dev/null
+++ b/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterCondAlg.h
@@ -0,0 +1,37 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef SCT_CONDITIONSPARAMETERCONDALG
+#define SCT_CONDITIONSPARAMETERCONDALG
+
+#include "AthenaBaseComps/AthAlgorithm.h"
+
+#include "StoreGate/ReadCondHandleKey.h"
+#include "AthenaPoolUtilities/CondAttrListVec.h"
+#include "StoreGate/WriteCondHandleKey.h"
+#include "SCT_ConditionsData/SCT_CondParameterData.h"
+#include "SCT_Cabling/ISCT_CablingSvc.h"
+
+#include "GaudiKernel/ICondSvc.h"
+
+#include "GaudiKernel/Property.h"
+
+class SCT_ConditionsParameterCondAlg : public AthAlgorithm
+{
+ public:
+ SCT_ConditionsParameterCondAlg(const std::string& name, ISvcLocator* pSvcLocator);
+ ~SCT_ConditionsParameterCondAlg();
+ StatusCode initialize();
+ StatusCode execute();
+ StatusCode finalize();
+
+ private:
+ SG::ReadCondHandleKey<CondAttrListVec> m_readKey;
+ SG::WriteCondHandleKey<SCT_CondParameterData> m_writeKey;
+
+ ServiceHandle<ISCT_CablingSvc> m_cablingSvc;//!< Handle on SCT cabling service
+ ServiceHandle<ICondSvc> m_condSvc;
+};
+
+#endif // SCT_CONDITIONSPARAMETERCONDALG
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterSvc.cxx b/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterSvc.cxx
index f2b1239a565bc86023caa5de51dd2ab4ad15c8c7..84ea715b9e8ec641ebbb39d624cc23fa22bef1fb 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterSvc.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterSvc.cxx
@@ -8,121 +8,21 @@
* @author shaun.roe@cern.ch
**/
#include <limits>
-#include <cmath>
-#include <cstdio>
#include "SCT_ConditionsParameterSvc.h"
#include "SCT_Chip.h"
-//
-#include "InDetIdentifier/SCT_ID.h"
-
-
-namespace {//anonymous namespace introduces file-scoped functions
- //is the value 'Not-a-Number' ?
- template <typename T>
- bool is_nan(const T& val) {
- return val!=val; //NaN is only value for which this is true
- }
- //response curve fit possibilities
- enum ResponseCurveFit{NO_CURVE=0, POLYNOMIAL, GRILLO, EXPONENTIAL, LINEAR, N_FUNCS}; //'Grillo' refers to Alex Grillo, Santa Cruz, who worked on SCT electronics development
- //response curve fit function
- float responseCurve(const float param0, const float param1, const float param2, const float vthreshold, const unsigned int rcFunc) {
- float result{std::numeric_limits<float>::quiet_NaN()};
- switch (rcFunc) {
- case LINEAR:
- if (param1!=0.0) {
- result = (vthreshold - param0)/param1;
- }
- break;
- case EXPONENTIAL:
- if ((vthreshold - param2)!=0) {
- float err2{param0/(vthreshold-param2)-1.0f};
- if (err2 > 0.0) {
- result = -param1*std::log(err2);
- }
- }
- break;
- case GRILLO:
- if (param2!=0) {
- float err3{param1*(1.0f-((vthreshold-param0)/param2))};
- if (err3!=0) {
- result = (vthreshold-param0)/err3;
- }
- }
- break;
- case POLYNOMIAL:
- if (param2!=0) {
- result = (-param1 + std::sqrt((param1*param1)-(4.0*param2*(param0-vthreshold)))) / 2.0*param2;
- }
- break;
- default:
- //nop
- break;
- }//switch
- if (is_nan(result)) return result;
- result *= result;
- return result;
- }//func responseCurve
-
- void parseResponseCurveArguments(float* p, const std::string& arguments) {
- //string is of form:
- //p0 1.284730e+03 p1 5.830000e+00 p2 -5.989900e+02
- float *p0{&p[0]};
- float *p1{&p[1]};
- float *p2{&p[2]};
- std::sscanf(arguments.c_str(), "p0 %50e p1 %50e p2 %50e", p0, p1, p2);
- }
- //folder to retrieve for threshold parameters
- const std::string chipFolderName{"/SCT/DAQ/Configuration/Chip"}; //CoraCool folder in the DB
-}//namespace
//c'tor
SCT_ConditionsParameterSvc::SCT_ConditionsParameterSvc(const std::string& name, ISvcLocator* pSvcLocator):
AthService(name, pSvcLocator),
- m_detStore{"DetectorStore", name},
- m_cablingSvc{"SCT_CablingSvc", name},
- m_pHelper{nullptr},
- m_filled{false} {
- boost::array<float, SCT_ConditionsServices::N_PARAMETERS> init;
- for (unsigned int i{0}; i!=SCT_ConditionsServices::N_PARAMETERS; ++i) {
- m_invalidParameters[i]=invalid(i);
- m_min[i]=std::numeric_limits<float>::max();
- m_max[i]=std::numeric_limits<float>::min();
- m_n[i]=0;
- m_sum[i]=0.0;
- m_sumsq[i]=0.0;
- init[i]=0.0;
- }
-
- //initialize boost array, doesnt provide constructor
- for (unsigned int i{0}; i!=N_ELEMENTS; ++i) {
- m_values[i]=init;
- }
+ m_condKey{"SCT_CondParameterData"} {
}
//
StatusCode
SCT_ConditionsParameterSvc::initialize() {
- // Retrieve detector store
- if (m_detStore.retrieve().isFailure()) {
- ATH_MSG_FATAL("Detector service not found !");
- return StatusCode::FAILURE;
- }
- // Retrieve cabling service
- if (m_cablingSvc.retrieve().isFailure()) {
- ATH_MSG_FATAL("Can't get the cabling service.");
- return StatusCode::FAILURE;
- }
- // Retrieve SCT ID helper
- if (m_detStore->retrieve(m_pHelper, "SCT_ID").isFailure()) {
- ATH_MSG_FATAL("Could not get SCT ID helper");
- return StatusCode::FAILURE;
- }
- //
- if (m_detStore->regFcn(&SCT_ConditionsParameterSvc::fillData, this, m_thresholdData, chipFolderName).isFailure()) {
- ATH_MSG_FATAL("Failed to register callback");
- return StatusCode::FAILURE;
- }
+ ATH_CHECK(m_condKey.initialize());
+
return StatusCode::SUCCESS;
}
@@ -147,34 +47,37 @@ SCT_ConditionsParameterSvc::queryInterface(const InterfaceID& riid, void** ppvIn
///Is the required parameter available?
bool
-SCT_ConditionsParameterSvc::available(const SCT_ConditionsServices::ParameterIndex iparam) {
- return (iparam==SCT_ConditionsServices::AVG_THRESHOLD);
+SCT_ConditionsParameterSvc::available(const SCT_CondParameterData::ParameterIndex iparam) {
+ return (iparam==SCT_CondParameterData::AVG_THRESHOLD);
}
///Give the indicated value for a module identifier hash
float
-SCT_ConditionsParameterSvc::value(const IdentifierHash& idHash, const SCT_ConditionsServices::ParameterIndex iparam) {
- return m_values[idHash][iparam];
+SCT_ConditionsParameterSvc::value(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam) {
+ const SCT_CondParameterData* data{getCondData()};
+ if (data==nullptr) return invalid(iparam);
+ return data->getValue(idHash, iparam);
}
///Measure of how many valid values went to calculate it. Should be 1 but if, say, 3 chip values were valid out of 6, it could be less (0.5 in this case)
float
-SCT_ConditionsParameterSvc::validity(const IdentifierHash& /*idHash*/, const SCT_ConditionsServices::ParameterIndex /*iparam*/) {
+SCT_ConditionsParameterSvc::validity(const IdentifierHash& /*idHash*/, const SCT_CondParameterData::ParameterIndex /*iparam*/) {
return 1.0;
}
///Is a given value within acceptable limits?
bool
-SCT_ConditionsParameterSvc::isValid(const float parameterValue, const SCT_ConditionsServices::ParameterIndex iparam) {
- if (iparam==SCT_ConditionsServices::AVG_THRESHOLD and is_nan(parameterValue)) return false;
- return true;
+SCT_ConditionsParameterSvc::isValid(const float parameterValue, const SCT_CondParameterData::ParameterIndex iparam) {
+ const SCT_CondParameterData* data{getCondData()};
+ if (data==nullptr) return invalid(iparam);
+ return data->isValid(parameterValue, iparam);
}
///What is the default error value for this parameter?
float
SCT_ConditionsParameterSvc::invalid(const unsigned int iparam) const {
float result{0.0};
- if (iparam==SCT_ConditionsServices::AVG_THRESHOLD) {
+ if (iparam==SCT_CondParameterData::AVG_THRESHOLD) {
result=std::numeric_limits<float>::quiet_NaN();
}
return result;
@@ -182,125 +85,70 @@ SCT_ConditionsParameterSvc::invalid(const unsigned int iparam) const {
///Maximum value read in from the database
float
-SCT_ConditionsParameterSvc::max(const SCT_ConditionsServices::ParameterIndex iparam) {
- return m_max[iparam];
+SCT_ConditionsParameterSvc::max(const SCT_CondParameterData::ParameterIndex iparam) {
+ const SCT_CondParameterData* data{getCondData()};
+ if (data==nullptr) return invalid(iparam);
+ return data->max(iparam);
}
///Minimum value read in from the database
float
-SCT_ConditionsParameterSvc::min(const SCT_ConditionsServices::ParameterIndex iparam) {
- return m_min[iparam];
+SCT_ConditionsParameterSvc::min(const SCT_CondParameterData::ParameterIndex iparam) {
+ const SCT_CondParameterData* data{getCondData()};
+ if (data==nullptr) return invalid(iparam);
+ return data->min(iparam);
}
///Average value
float
-SCT_ConditionsParameterSvc::avg(const SCT_ConditionsServices::ParameterIndex iparam) {
- return (m_n[iparam]!=0)?(m_sum[iparam]/m_n[iparam]):(std::numeric_limits<float>::quiet_NaN());
+SCT_ConditionsParameterSvc::avg(const SCT_CondParameterData::ParameterIndex iparam) {
+ const SCT_CondParameterData* data{getCondData()};
+ if (data==nullptr) return invalid(iparam);
+ return data->avg(iparam);
}
///Standard deviation
float
-SCT_ConditionsParameterSvc::sd(const SCT_ConditionsServices::ParameterIndex iparam) {
- float mu{m_sum[iparam]/m_n[iparam]};
- return std::sqrt((m_sumsq[iparam]/m_n[iparam]) - mu*mu);
+SCT_ConditionsParameterSvc::sd(const SCT_CondParameterData::ParameterIndex iparam) {
+ const SCT_CondParameterData* data{getCondData()};
+ if (data==nullptr) return invalid(iparam);
+ return data->sd(iparam);
}
///Number of values read in
unsigned int
-SCT_ConditionsParameterSvc::n(const SCT_ConditionsServices::ParameterIndex iparam) {
- return m_n[iparam];
+SCT_ConditionsParameterSvc::n(const SCT_CondParameterData::ParameterIndex iparam) {
+ const SCT_CondParameterData* data{getCondData()};
+ if (data==nullptr) return 0;
+ return data->n(iparam);
}
///Fill a user-provided vector with the values (hopefully won't be needed?)
void
-SCT_ConditionsParameterSvc::getValues(std::vector<float>& userVector, const SCT_ConditionsServices::ParameterIndex iparam) {
- for (unsigned int i{0}; i!=m_values.size(); ++i) {
- userVector.push_back(m_values[i][iparam]);
- }
+SCT_ConditionsParameterSvc::getValues(std::vector<float>& userVector, const SCT_CondParameterData::ParameterIndex iparam) {
+ const SCT_CondParameterData* data{getCondData()};
+ if (data!=nullptr) data->getValues(userVector, iparam);
//no return value
}
///Report whether the structure was filled
bool
SCT_ConditionsParameterSvc::filled() const {
- return m_filled;
-}
-
-///extended methods for data structure insertion
-bool
-SCT_ConditionsParameterSvc::insert(const IdentifierHash& idHash, const SCT_ConditionsServices::ParameterIndex iparam, const float theValue) {
- //theValue must be valid
- if (not isValid(theValue, iparam)) return false;
- boost::array<float,SCT_ConditionsServices::N_PARAMETERS>& paramArray = m_values[idHash];
- //initial value should be invalid, only insert if this is the case
- if (not isValid(paramArray[iparam], iparam)) {
- paramArray[iparam]=theValue;
- return true;
- } else {
- return false;
- }
+ const SCT_CondParameterData* data{getCondData()};
+ return (data!=nullptr);
}
///Callback for fill from database
StatusCode
SCT_ConditionsParameterSvc::fillData(int& /* i */, std::list<std::string>& /*keys*/) {
- if (m_detStore->retrieve(m_thresholdData, chipFolderName).isFailure()) {
- ATH_MSG_FATAL("Could not fill chip configuration data");
- return StatusCode::FAILURE;
- }
- for (unsigned int i{0}; i!=SCT_ConditionsServices::N_PARAMETERS; ++i) {
- m_n[i]=0;
- m_sum[i]=0.0;
- m_sumsq[i]=0.0;
- m_min[i]=std::numeric_limits<float>::max();
- m_max[i]=std::numeric_limits<float>::min();
- }
- // Loop over elements (i.e groups of 6 chips) in DB folder
- const unsigned int nChipsPerModule{12};
- const unsigned int nChipsPerSide{6};
- const float mVperDacBit{2.5};
- //initialize the values to be invalid
- for (unsigned int i{0}; i!=m_values.size(); ++i) m_values[i]=m_invalidParameters;
- CondAttrListVec::const_iterator modItr{m_thresholdData->begin()};
- CondAttrListVec::const_iterator modEnd{m_thresholdData->end()};
- for (; modItr != modEnd; modItr += nChipsPerModule) {
- // Get SN and identifiers (the channel number is serial number+1)
- const unsigned int truncatedSerialNumber{modItr->first - 1};
- const IdentifierHash& moduleHash{m_cablingSvc->getHashFromSerialNumber(truncatedSerialNumber)};
- if (not moduleHash.is_valid()) continue;
- // Loop over chips within module
-
- for (unsigned int side{0}; side!=2; ++side) {
- IdentifierHash elementHash{moduleHash + side};
- CondAttrListVec::const_iterator channelItr{modItr};
- CondAttrListVec::const_iterator channelEnd{modItr + nChipsPerSide};
- std::vector<SCT_Chip*> chipsInMod;
- chipsInMod.reserve(nChipsPerSide);
- float parameters[3]{0.0, 0.0, 0.0};
- float chipsum{0.0};
- for (; channelItr != channelEnd; ++channelItr) {
- // Can get AttributeList from second (see http://lcgapp.cern.ch/doxygen/CORAL/CORAL_1_9_3/doxygen/html/classcoral_1_1_attribute_list.html)
- //short id = channelItr->second[2].data<short>(); //chip 0-11
- float vthr{mVperDacBit * channelItr->second[10].data<short>()}; //threshold setting
- short rcFunctionIndex{channelItr->second[15].data<short>()}; //response curve function
- std::string rcArgumentString{channelItr->second[16].data<std::string>()}; //response curve arguments
- parseResponseCurveArguments(parameters, rcArgumentString);
- //float target = channelItr->second[18].data<float>(); //trim target...use for debugging only
- float femtoCoulombThreshold{responseCurve(parameters[0], parameters[1], parameters[2], vthr, rcFunctionIndex)};
- chipsum+=femtoCoulombThreshold;
- }
- float moduleAverage{chipsum/nChipsPerSide};
- if (insert(elementHash, SCT_ConditionsServices::AVG_THRESHOLD, moduleAverage)) {
- m_n[SCT_ConditionsServices::AVG_THRESHOLD]++;
- m_sum[SCT_ConditionsServices::AVG_THRESHOLD]+=moduleAverage;
- m_sumsq[SCT_ConditionsServices::AVG_THRESHOLD]+=moduleAverage*moduleAverage;
- m_min[SCT_ConditionsServices::AVG_THRESHOLD]=std::min(m_min[SCT_ConditionsServices::AVG_THRESHOLD], moduleAverage);
- m_max[SCT_ConditionsServices::AVG_THRESHOLD]=std::max(m_max[SCT_ConditionsServices::AVG_THRESHOLD], moduleAverage);
- } else {
- ATH_MSG_WARNING("Insertion failed for hash: "<<elementHash<<" and parameter: "<<SCT_ConditionsServices::parameterNames[SCT_ConditionsServices::AVG_THRESHOLD]);
- }
- }//side loop
- }//module loop
- m_filled=true;
return StatusCode::SUCCESS;
}
+
+const SCT_CondParameterData* SCT_ConditionsParameterSvc::getCondData() const {
+ SG::ReadCondHandle<SCT_CondParameterData> condData{m_condKey};
+ if (not condData.isValid()) {
+ ATH_MSG_ERROR("Failed to get " << m_condKey.key());
+ return nullptr;
+ }
+ return *condData;
+}
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterSvc.h b/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterSvc.h
index d368dfccb3deecf41b908c95af6dcfe5cc5a5fda..cc4a3650f268d3491164f7152f1a6209784cf239 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterSvc.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterSvc.h
@@ -21,26 +21,21 @@
#include "GaudiKernel/IInterface.h"
#include "GaudiKernel/ServiceHandle.h"
#include "AthenaBaseComps/AthService.h"
-#include "StoreGate/DataHandle.h"
-#include "StoreGate/StoreGateSvc.h"
//Athena includes
#include "Identifier/IdentifierHash.h"
-#include "AthenaKernel/IIOVDbSvc.h"
-#include "AthenaPoolUtilities/CondAttrListVec.h"
+#include "StoreGate/ReadCondHandleKey.h"
//InnerDetector includes
-#include "SCT_Cabling/ISCT_CablingSvc.h"
+#include "SCT_ConditionsData/SCT_CondParameterData.h"
//local includes
-#include "SCT_ConditionsServices/SCT_ConditionsParameters.h"
#include "SCT_ConditionsServices/ISCT_ConditionsParameterSvc.h"
//fwd declarations
template <class TYPE> class SvcFactory;
class ISvcLocator;
-class StatusCode;
-class SCT_ID;
+
/**
* @class SCT_ConditionsParameterSvc
* Class to give a numerical value from conditions for each detector element (module side)
@@ -63,37 +58,37 @@ class SCT_ConditionsParameterSvc: virtual public ISCT_ConditionsParameterSvc, vi
//@}
///Is the required parameter available?
- virtual bool available(const SCT_ConditionsServices::ParameterIndex iparam);
+ virtual bool available(const SCT_CondParameterData::ParameterIndex iparam);
///Give the indicated value for a module identifier hash
- virtual float value(const IdentifierHash& idHash, const SCT_ConditionsServices::ParameterIndex iparam);
+ virtual float value(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam);
///Measure of how many valid values went to calculate it. Should be 1 but if, say, 3 chip values were valid out of 6, it could be less (0.5 in this case)
- virtual float validity(const IdentifierHash& idHash, const SCT_ConditionsServices::ParameterIndex iparam);
+ virtual float validity(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam);
///Is a given value within acceptable limits?
- virtual bool isValid(const float parameterValue, const SCT_ConditionsServices::ParameterIndex iparam);
+ virtual bool isValid(const float parameterValue, const SCT_CondParameterData::ParameterIndex iparam);
///What is the default error value for this parameter?
virtual float invalid(const unsigned int iparam) const;
///Maximum value read in from the database
- virtual float max(const SCT_ConditionsServices::ParameterIndex iparam);
+ virtual float max(const SCT_CondParameterData::ParameterIndex iparam);
///Minimum value read in from the database
- virtual float min(const SCT_ConditionsServices::ParameterIndex iparam);
+ virtual float min(const SCT_CondParameterData::ParameterIndex iparam);
///Average value
- virtual float avg(const SCT_ConditionsServices::ParameterIndex iparam);
+ virtual float avg(const SCT_CondParameterData::ParameterIndex iparam);
///Standard deviation
- virtual float sd(const SCT_ConditionsServices::ParameterIndex iparam);
+ virtual float sd(const SCT_CondParameterData::ParameterIndex iparam);
///Number of values read in
- virtual unsigned int n(const SCT_ConditionsServices::ParameterIndex iparam);
+ virtual unsigned int n(const SCT_CondParameterData::ParameterIndex iparam);
///Fill a user-provided vector with the values (hopefully won't be needed?)
- virtual void getValues(std::vector<float>& userVector, const SCT_ConditionsServices::ParameterIndex iparam);
+ virtual void getValues(std::vector<float>& userVector, const SCT_CondParameterData::ParameterIndex iparam);
///Report whether the structure was filled
virtual bool filled() const;
@@ -102,28 +97,9 @@ class SCT_ConditionsParameterSvc: virtual public ISCT_ConditionsParameterSvc, vi
StatusCode fillData(int& i, std::list<std::string>& keys);
private:
- enum {N_ELEMENTS=8176};
- //Declare Storegate container
- ServiceHandle<StoreGateSvc> m_detStore;
- ServiceHandle<ISCT_CablingSvc> m_cablingSvc;//!< Handle on SCT cabling service
- const SCT_ID* m_pHelper;//!< ID helper for SCT
-
//the data structure
- boost::array<boost::array<float, SCT_ConditionsServices::N_PARAMETERS>, N_ELEMENTS > m_values;
- //a structure for initialization
- boost::array<float, SCT_ConditionsServices::N_PARAMETERS> m_invalidParameters;
- //DataHandle for callback
- const DataHandle<CondAttrListVec> m_thresholdData;//!<implies that CoraCool is used
- //extended method for data structure insertion
- bool insert(const IdentifierHash& idHash, const SCT_ConditionsServices::ParameterIndex iparam, const float theValue);
-
- //internal values to be calculated during data filling
- float m_min[SCT_ConditionsServices::N_PARAMETERS];
- float m_max[SCT_ConditionsServices::N_PARAMETERS];
- unsigned int m_n[SCT_ConditionsServices::N_PARAMETERS];
- float m_sum[SCT_ConditionsServices::N_PARAMETERS];
- float m_sumsq[SCT_ConditionsServices::N_PARAMETERS];
- bool m_filled;
+ SG::ReadCondHandleKey<SCT_CondParameterData> m_condKey;
+ const SCT_CondParameterData* getCondData() const;
};
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterTestAlg.cxx b/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterTestAlg.cxx
index 32021f10cf3ddf29be3a36d10c8f155666387dcf..abe25c597066184942f0d4d9cab45b5a3e650257 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterTestAlg.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsServices/src/SCT_ConditionsParameterTestAlg.cxx
@@ -10,6 +10,7 @@
#include "SCT_ConditionsParameterTestAlg.h"
#include "SCT_ConditionsServices/ISCT_ConditionsParameterSvc.h"
#include "SCT_ConditionsServices/SCT_ConditionsParameters.h"
+#include "SCT_ConditionsData/SCT_CondParameterData.h"
#include "SCT_SimpleHisto.h"
#include "SCT_ConditionsUtilities.h"
@@ -91,12 +92,12 @@ StatusCode SCT_ConditionsParameterTestAlg::execute() {
}
try {
- float maxval{m_conditionsParameterSvc->max(AVG_THRESHOLD)};
- float minval{m_conditionsParameterSvc->min(AVG_THRESHOLD)};
- float avg{m_conditionsParameterSvc->avg(AVG_THRESHOLD)};
- float sd{m_conditionsParameterSvc->sd(AVG_THRESHOLD)};
- unsigned int n{m_conditionsParameterSvc->n(AVG_THRESHOLD)};
- float thresh{m_conditionsParameterSvc->value(IdentifierHash{1760}, AVG_THRESHOLD)};
+ float maxval{m_conditionsParameterSvc->max(SCT_CondParameterData::AVG_THRESHOLD)};
+ float minval{m_conditionsParameterSvc->min(SCT_CondParameterData::AVG_THRESHOLD)};
+ float avg{m_conditionsParameterSvc->avg(SCT_CondParameterData::AVG_THRESHOLD)};
+ float sd{m_conditionsParameterSvc->sd(SCT_CondParameterData::AVG_THRESHOLD)};
+ unsigned int n{m_conditionsParameterSvc->n(SCT_CondParameterData::AVG_THRESHOLD)};
+ float thresh{m_conditionsParameterSvc->value(IdentifierHash{1760}, SCT_CondParameterData::AVG_THRESHOLD)};
ATH_MSG_INFO(" value element 1760: " << thresh);
ATH_MSG_INFO(" max threshold: " << maxval);
ATH_MSG_INFO(" min threshold: " << minval);
@@ -111,7 +112,7 @@ StatusCode SCT_ConditionsParameterTestAlg::execute() {
SCT_ConditionsServices::S_t histo;
init(histo, 0.0, 8.0, 100);
std::vector<float> values;
- m_conditionsParameterSvc->getValues(values, AVG_THRESHOLD);
+ m_conditionsParameterSvc->getValues(values, SCT_CondParameterData::AVG_THRESHOLD);
for (float i: values) {
fill(histo, i);
}
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsServices/src/components/SCT_ConditionsServices_entries.cxx b/InnerDetector/InDetConditions/SCT_ConditionsServices/src/components/SCT_ConditionsServices_entries.cxx
index ed976d68f714e64bf0076096054c89ce241de6b6..1f08e6c529427ac8c863cf706297a8c30a9c024c 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsServices/src/components/SCT_ConditionsServices_entries.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsServices/src/components/SCT_ConditionsServices_entries.cxx
@@ -51,6 +51,7 @@
#include "../SCT_TdaqEnabledTestAlg.h"
#include "../SCT_ConditionsParameterSvc.h"
+#include "../SCT_ConditionsParameterCondAlg.h"
#include "../SCT_ConditionsParameterTestAlg.h"
#include "../SCT_SensorsSvc.h"
@@ -99,6 +100,7 @@ DECLARE_COMPONENT( SCT_ConfigurationConditionsTestAlg )
DECLARE_COMPONENT( SCT_ConfigurationCondAlg )
DECLARE_COMPONENT( SCT_MajorityCondAlg )
DECLARE_COMPONENT( SCT_MajorityConditionsTestAlg )
+DECLARE_COMPONENT( SCT_ConditionsParameterCondAlg )
DECLARE_COMPONENT( SCT_ConditionsParameterTestAlg )
DECLARE_COMPONENT( SCT_SensorsCondAlg )
DECLARE_COMPONENT( SCT_SensorsTestAlg )