MuonCalib::CscCalcPed Class Reference

does calibration of the CSC chambers More...

#include <CscCalcPed.h>

Inheritance diagram for MuonCalib::CscCalcPed:

Public Member Functions
	CscCalcPed (const std::string &name, ISvcLocator *pSvcLocator)
	~CscCalcPed ()=default
StatusCode	initialize (void)
	basic required functions
StatusCode	execute (void)
StatusCode	finalize (void)
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	collectEventInfo ()
	event loop functions
StatusCode	calculateParameters ()
	Finalize functions.
StatusCode	writeCalibrationFile ()
StatusCode	storeGateRecord ()
std::vector< TH2F * >	makeBitCorrelation ()
StatusCode	calOutput0 ()
StatusCode	calOutput1 ()
StatusCode	calOutput3 ()
void	outputParameter3 (const CscCalibResultCollection &results, std::ofstream &out)
StatusCode	hashToChamberName (IdentifierHash, std::string)
	Utility functions.
StatusCode	fillBitHist (TH1I *bitHist, const uint16_t &val, TH2F *bitProds)
template<typename dataType>
dataType	GetMinMax (std::vector< dataType > &vec)
void	onlineToOfflineHashId (const unsigned int &onlineId, unsigned int &hashId) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
	Services and tools.
SmartIF< IChronoStatSvc >	m_chronoSvc
ToolHandle< Muon::ICSC_RDO_Decoder >	m_cscRdoDecoderTool {this,"CscRdoDecoderTool","Muon::CscRDO_Decoder"}
SG::ReadCondHandleKey< CscCondDbData >	m_readKey {this, "ReadKey", "CscCondDbData", "Key of CscCondDbData"}
std::string	m_outputFileName
	Parameters input through joboptions.
std::string	m_titlePrefix
std::string	m_titlePostfix
std::string	m_calOutputVersion
bool	m_doCorrelation
float	m_thresholdMultiplier
int	m_expectedChamberLayer
std::string	m_onlineDbFile
	filename for file with online database information
unsigned int	m_maxStripHash
	Internally global variables.
unsigned int	m_ampHistLowBound
unsigned int	m_ampHistHighBound
unsigned int	m_ampHistNumBins
const unsigned int	m_numBits
bool	m_doBitHists
bool	m_doSampleHists
int	m_numSamplesExpected
bool	m_doF001
std::vector< TH1I * >	m_ampHists
std::vector< std::vector< TH1I * > >	m_sampHists
std::vector< TH1I * >	m_bitHists
DataVector< TH2F > *	m_bitProds
DataVector< TH1F > *	m_bitCorrelation
std::vector< int >	m_onlineThresholds
std::vector< int >	m_onlineThresholdFailureCount
CscCalibResultCollection *	m_peds
CscCalibResultCollection *	m_noises
CscCalibResultCollection *	m_rmses
CscCalibResultCollection *	m_f001s
CscCalibResultCollection *	m_onlineTHoldBreaches
int	m_eventCnt
double *	m_crossTalkFix
std::string	m_cmt_parameter
bool	m_doOnlineDbFile
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

does calibration of the CSC chambers

Author

lampe.nosp@m.n@ph.nosp@m.ysics.nosp@m..ari.nosp@m.zona..nosp@m.edu

Description

CscCalcPed is an algorithm that cycles through calibration events and generates the pedestals. A root file is also generated where the user can view the validity of the constants.

Definition at line 44 of file CscCalcPed.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

CscCalcPed()

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

Definition at line 23 of file CscCalcPed.cxx.

                                                                        :
    AthAlgorithm(name,pSvcLocator),
    m_maxStripHash(0),
    m_numBits(12),
    m_bitProds(nullptr),
    m_bitCorrelation(nullptr),
    m_peds(nullptr),
    m_noises(nullptr),
    m_rmses(nullptr),
    m_f001s(nullptr),
    m_onlineTHoldBreaches(nullptr),
    m_eventCnt(0),
    m_crossTalkFix(nullptr)
  {
    declareProperty("OutputFile", m_outputFileName = "output.cal");
    declareProperty("TitlePrefix",m_titlePrefix = "");  //Prefix appended to title of histograms and graphs
    declareProperty("TitlePostfix",m_titlePostfix = "");    //Prefix appended to title of histograms and graphs
    declareProperty("PedAmpHighBound", m_ampHistHighBound = 2600);
    declareProperty("PedAmpLowBound", m_ampHistLowBound = 1800); 
    declareProperty("PedAmpNumBins", m_ampHistNumBins = 800);
    declareProperty("ExpectedChamberLayer", m_expectedChamberLayer = 2);
    declareProperty("ThresholdMultiplier", m_thresholdMultiplier = 3.1);
    declareProperty("DoBitHists", m_doBitHists = false);
    declareProperty("CalOutputVersion", m_calOutputVersion="03-00");
    declareProperty("DoCorrelation", m_doCorrelation = false);
 
    declareProperty("DoSampHists", m_doSampleHists = false);
    declareProperty("NumSamplesExpected", m_numSamplesExpected = 4);
    declareProperty("DoF001", m_doF001 = true);
 
    declareProperty("OnlineCalibFile", m_onlineDbFile = "", "File with data currently stored in online configuration database");
    declareProperty("CompareOnlineCalibFile",m_doOnlineDbFile = true, "Compare new to online data?");
 
 
    //Can't do correlation without bitHists
    if(!m_doBitHists){ 
      m_doCorrelation = false;
    }
  }

~CscCalcPed()

MuonCalib::CscCalcPed::~CscCalcPed ( )

default

Member Function Documentation

calculateParameters()

StatusCode MuonCalib::CscCalcPed::calculateParameters ( )

private

Finalize functions.

Definition at line 500 of file CscCalcPed.cxx.

    {
      Chrono chrono(m_chronoSvc,"calculateParameters");
 
 
      //**********Calculate all the parameters from data collected during execute*****************//
 
      for(unsigned int stripHash = 0 ;stripHash <= m_maxStripHash; stripHash++)
      {
        if(stripHash < 50 || stripHash%1000 == 0)
        {
          ATH_MSG_INFO("Analyzing strip with hash " << stripHash << " out of " << m_maxStripHash); 
          ATH_MSG_VERBOSE((float)clock()/((float)CLOCKS_PER_SEC) << " is the time");
        }
 
        TH1I * ampHist = m_ampHists[stripHash];
        if(ampHist)
        {
          ATH_MSG_VERBOSE("Have data for strip hash " << stripHash);
          if(ampHist->GetEntries() >0) //If strip wasn't tested, it won't have entries
          {
            //Following Schernau's work
            float histMean = ampHist->GetMean();
            float histRMS = ampHist->GetRMS();
            float histRMSError = ampHist->GetRMSError();
 
            float lowbound = histMean - 3*histRMS;
            float highbound = histMean + 3*histRMS;
            ATH_MSG_VERBOSE("About to fit...");
 
            int result = ampHist->Fit("gaus","QL","",lowbound,highbound);
            ATH_MSG_VERBOSE("Result is " << result);
            TF1 * fittedFunction = ampHist->GetFunction("gaus");
            double meanError = fittedFunction->GetParError(1);
            double sigma = fittedFunction->GetParameter(2);
            double sigmaError = fittedFunction->GetParError(2);
            double chi2 = fittedFunction->GetChisquare();
            int ndf = fittedFunction->GetNDF();
 
            m_peds->push_back(new CscCalibResult(stripHash,histMean,meanError,chi2,ndf));
            m_noises->push_back(new CscCalibResult(stripHash,sigma,sigmaError,chi2,ndf));
            m_rmses->push_back(new CscCalibResult(stripHash,histRMS,histRMSError,0,0));
 
 
 
            //Integrated threshold (f001) calculation
            if(m_doF001){
              int num = (int)ampHist->GetEntries();
              int thr = ampHist->GetNbinsX() + 1; // start at overflow bin
              double maxSum = 0.001*num;  // 99.90 of pedestals under thr
              //double maxSum = 0.0001*num; // 99.99 of pedestals under thr
 
              double sum = 0;
              do{
                sum += ampHist->GetBinContent(thr);
                thr--;
              } while ((thr>0)&&(sum<maxSum));
 
              //double threshold = ampHist->GetXaxis()->GetBinLowEdge(thr) +2; //For some reason +2 here matches Michael Schernau's +1
              double threshold = ampHist->GetXaxis()->GetBinLowEdge(thr) +1; //For some reason +2 here matches Michael Schernau's +1
              m_f001s->push_back(new CscCalibResult(stripHash,threshold,0,0,0));
 
              if(m_doOnlineDbFile){
                m_onlineTHoldBreaches->push_back(new CscCalibResult(stripHash,m_onlineThresholdFailureCount[stripHash],0));
              }
            }
          }
        }
        else
          ATH_MSG_VERBOSE("Don't have data for strip hash " << stripHash);
      }//end loop over strips
 
 
      //don't need it anymore, clear ram taken by m_failure tests
      ATH_MSG_DEBUG("Clearing m_onlineThresholdFailureCount");
      m_onlineThresholdFailureCount.resize(0);
 
 
      ATH_MSG_INFO("Completed calculating parameters.");
 
      return StatusCode::SUCCESS;
    }//End calculateParameters()

calOutput0()

StatusCode MuonCalib::CscCalcPed::calOutput0 ( )

private

Definition at line 606 of file CscCalcPed.cxx.

                                      {
 
      std::ofstream out;
      out.open(m_outputFileName.c_str());
      if(!out.is_open())
      {
        ATH_MSG_ERROR("Can't open file " << m_outputFileName.c_str());
        return StatusCode::RECOVERABLE;
      }
 
      out << "00-00 ";
      out << m_peds->size() << " ";
      out << "ped ";
      out << "noise ";
      out << "rms ";
      out << "END_HEADER\n";            
 
      ATH_MSG_DEBUG("Begining loop over all " << m_peds->size() << " channels data was collected for.");
 
      //form is:hashID chamber LayerOrientationStrip  parametervalue parametervalue 
      CscCalibResultCollection::iterator pedItr = m_peds->begin();
      CscCalibResultCollection::iterator pedEnd = m_peds->end();
      CscCalibResultCollection::iterator noiseItr = m_noises->begin(); 
      CscCalibResultCollection::iterator rmsItr = m_rmses->begin(); 
      for(;pedItr!= pedEnd;++pedItr,++noiseItr, ++rmsItr)//,tholdItr++)
      {
        int hashId = (*pedItr)->hashId();
        double ped = (*pedItr)->value();
        double noise = (*noiseItr)->value();
        double rms = (*rmsItr)->value();
 
        ATH_MSG_DEBUG("we're on hash " << hashId << " with pedestal " << ped << "and noise " << noise);
        Identifier id;
        IdContext channelContext = m_idHelperSvc->cscIdHelper().channel_context();  
        m_idHelperSvc->cscIdHelper().get_id(hashId,id, &channelContext);
 
        Identifier chamberId = m_idHelperSvc->cscIdHelper().elementID(id);
        if(!m_idHelperSvc->cscIdHelper().valid(chamberId))
        {
          ATH_MSG_WARNING(chamberId.getString() << " is not a valid id!");
          ATH_MSG_WARNING("identifier is: " << m_idHelperSvc->cscIdHelper().show_to_string(chamberId));
        }
 
        IdentifierHash chamberHash;
        m_idHelperSvc->cscIdHelper().get_module_hash(id,chamberHash);
 
        //print out values.
        out << hashId;
        out <<" " << chamberHash;
        out << " " << m_idHelperSvc->cscIdHelper().show_to_string(id) << " ";
        out << " " << ped;
        out << " " << noise;
        out << " " << rms;
        out << "\n" ; 
      } //end loop over hash Ids
 
      out.close(); //done writing       
      ATH_MSG_INFO("File written");
      return StatusCode::SUCCESS;   
    }//end calOutput0

calOutput1()

StatusCode MuonCalib::CscCalcPed::calOutput1 ( )

private

Definition at line 669 of file CscCalcPed.cxx.

                                      {
 
      std::ofstream out;
      std::string onlineFileName = m_outputFileName + "_online";
 
      out.open(onlineFileName.c_str());
      if(!out.is_open())
      {
        ATH_MSG_ERROR("Can't open online file " << m_outputFileName.c_str());
        return StatusCode::RECOVERABLE;
      }
 
      out << "32\n";
 
      ATH_MSG_DEBUG("Begining loop over all " << m_peds->size() << " channels data was collected for.");
 
      SG::ReadCondHandle<CscCondDbData> readHandle{m_readKey}; 
      const CscCondDbData* readCdo{*readHandle};
 
      //form is:hashID chamber LayerOrientationStrip  parametervalue parametervalue 
      CscCalibResultCollection::iterator pedItr = m_peds->begin();
      CscCalibResultCollection::iterator pedEnd = m_peds->end();
      CscCalibResultCollection::iterator noiseItr = m_noises->begin(); 
      CscCalibResultCollection::iterator rmsItr = m_rmses->begin(); 
      CscCalibResultCollection::iterator f001Itr = m_f001s->begin();
      for(;pedItr!= pedEnd;++pedItr,++noiseItr, ++rmsItr, ++f001Itr)//,tholdItr++)
      {
        int hashId = (*pedItr)->hashId();
        double ped = (*pedItr)->value();
        double noise = (*noiseItr)->value();
        //double rms = (*rmsItr)->value();
        double f001 = (*f001Itr)->value();
 
        //double thold = (*tholdItr)->value();
        std::string onlineHexId;
 
        //Online ids are same as "string ids" used internally in COOL db.
        readCdo->indexToStringId(&m_idHelperSvc->cscIdHelper(), hashId, "CHANNEL", onlineHexId).ignore();
 
        ATH_MSG_DEBUG("we're on hash " << hashId << " with pedestal " << ped << "and noise " << noise);
        Identifier id;
        IdContext channelContext = m_idHelperSvc->cscIdHelper().channel_context();  
        m_idHelperSvc->cscIdHelper().get_id(hashId,id, &channelContext);
 
        Identifier chamberId = m_idHelperSvc->cscIdHelper().elementID(id);
        if(!m_idHelperSvc->cscIdHelper().valid(chamberId))
        {
          ATH_MSG_WARNING(chamberId.getString() << " is not a valid id!");
          ATH_MSG_WARNING("identifier is: " << m_idHelperSvc->cscIdHelper().show_to_string(chamberId));
        }
 
        char orientationChar = (m_idHelperSvc->cscIdHelper().measuresPhi(id) ? 'Y':'X');
 
 
        IdentifierHash chamberHash;
        m_idHelperSvc->cscIdHelper().get_module_hash(id,chamberHash);
 
        //print out values.
        out.setf(std::ios::right);//right aligned columns
        out << std::setfill('0') << std::setw(8) << onlineHexId;
        out <<" " 
          << std::setw(2) << chamberHash << orientationChar << (m_idHelperSvc->cscIdHelper().wireLayer(id)-1)
          <<" "
          << std::setw(3) << m_idHelperSvc->cscIdHelper().strip(id) -1 << " " ;
        out.setf(std::ios::fixed);
 
 
        out << " " << std::setprecision(3) << std::setw(8) << ped << " 0000.00";
        out << " " << std::setprecision(3) << std::setw(8) << noise << " 0000.000";
        out << " " << f001;
        out << "\n" ; 
      } //end loop over hash Ids
 
      out.close(); //done writing       
      ATH_MSG_INFO("File written");
      return StatusCode::SUCCESS;   
    }//end calOutput1

calOutput3()

StatusCode MuonCalib::CscCalcPed::calOutput3 ( )

private

Definition at line 749 of file CscCalcPed.cxx.

                                      {
      std::ofstream out;
      out.open(m_outputFileName.c_str());
      if(!out.is_open())
      {
        ATH_MSG_ERROR("Can't open output 3 type file " << m_outputFileName.c_str() <<  " for writing ");
        return StatusCode::RECOVERABLE;
      }
      out << "03-00 <END_HEADER>";
 
      outputParameter3(*m_peds, out);
      outputParameter3(*m_noises,out);
      outputParameter3(*m_rmses,out);
      if(m_doF001)
        outputParameter3(*m_f001s,out);
      out << "\n<END_FILE>";
      out.close();
 
      return StatusCode::SUCCESS;
    }

collectEventInfo()

StatusCode MuonCalib::CscCalcPed::collectEventInfo ( )

private

event loop functions

Definition at line 338 of file CscCalcPed.cxx.

  {
    //start the timer
    Chrono chrono(m_chronoSvc,"collectEventInfo");
 
 
    m_eventCnt++;
    ATH_MSG_DEBUG("Collecting event info for event " << m_eventCnt);
    //Below might need to be changed depending on how we get data
    const CscRawDataContainer* rawDataContainer;
    StatusCode sc_read = evtStore()->retrieve(rawDataContainer, "CSCRDO"); 
    if (sc_read != StatusCode::SUCCESS)
    {
      ATH_MSG_FATAL("Could not find event");
      return StatusCode::FAILURE;
    }
 
    ATH_MSG_VERBOSE("Retrieved RDO from storegate ");
 
    if(rawDataContainer->size() == 0)
    {
      ATH_MSG_FATAL("no rods in RDO!");
      return StatusCode::FAILURE;
    }
 
    ATH_MSG_VERBOSE("There are " << rawDataContainer->size() << " rods in the RDO");
 
    IdContext channelContext = m_idHelperSvc->cscIdHelper().channel_context();  
 
    //Loop over RODs (data from 2 chambers), each of which is in
    //a single CscRawaData collection.
    //Names of timers used in this loop
    static const std::string rodChronoStr{"RodItr"};
    static const std::string clusterChronoStr{"ClusterItr"};
    static const std::string stripChronoStr{"stripItr"};
    static const std::string afterId1Str{"afterID1"};
    static const std::string afterId2Str{"afterID2"};
    //
    for(const auto rod : *rawDataContainer)
    {
      Chrono chronoRod(m_chronoSvc,rodChronoStr);
      ATH_MSG_VERBOSE("Examining a ROD");
 
      ATH_MSG_VERBOSE("There are " << rod->size() << " clusters in the ROD");
      if(rod->size() >0) 
      {
        //Loop over strips in rod
 
 
        for(const auto cluster: *rod)
        {
          Chrono chronoClus(m_chronoSvc,clusterChronoStr);
          int numStrips = cluster->width();
          int samplesPerStrip = (cluster->samples()).size()/numStrips;
 
          ATH_MSG_VERBOSE("About to collect info from " << numStrips << " strips");
          for(int stripItr = 0; stripItr <numStrips; stripItr++)
          {
 
            Chrono chronoStrip(m_chronoSvc,stripChronoStr);
            // WP Added
            Identifier channelId =m_cscRdoDecoderTool->channelIdentifier(cluster, &m_idHelperSvc->cscIdHelper(), stripItr);
            IdentifierHash cscChannelHashId;
            m_idHelperSvc->cscIdHelper().get_channel_hash(channelId, cscChannelHashId);

            int stripHash = cscChannelHashId;
 
            Identifier stripId;
            m_idHelperSvc->cscIdHelper().get_id(stripHash, stripId, &channelContext);
 
 
            Chrono chronoAfterId(m_chronoSvc,afterId1Str);
 
            if( m_idHelperSvc->cscIdHelper().chamberLayer(channelId) != m_expectedChamberLayer)
            {
              ATH_MSG_WARNING("Wrong chamber layer  a hash ("
                << stripHash << ")  from the wrong multilayer has appeared in the data. Its string id is " << m_idHelperSvc->cscIdHelper().show_to_string(stripId)
                <<  "  " << m_idHelperSvc->cscIdHelper().show_to_string(channelId));
 
              ATH_MSG_INFO("WP added (1) "
                << m_idHelperSvc->cscIdHelper().stationEta(stripId) << " " << m_idHelperSvc->cscIdHelper().measuresPhi(stripId) << " "
                << stripHash << " " << cscChannelHashId);
 
              ATH_MSG_INFO("WP added (2) "
                << m_idHelperSvc->cscIdHelper().stationEta(stripId) << " " << m_idHelperSvc->cscIdHelper().measuresPhi(stripId) << " "
                << stripId << " " << channelId);
 
              stripId = m_idHelperSvc->cscIdHelper().channelID(
                  m_idHelperSvc->cscIdHelper().stationName(stripId),
                  m_idHelperSvc->cscIdHelper().stationEta(stripId),
                  m_idHelperSvc->cscIdHelper().stationPhi(stripId),
                  2,
                  m_idHelperSvc->cscIdHelper().wireLayer(stripId),
                  m_idHelperSvc->cscIdHelper().measuresPhi(stripId),
                  m_idHelperSvc->cscIdHelper().strip(stripId)
                  ); 
              IdentifierHash newHash;
              m_idHelperSvc->cscIdHelper().get_channel_hash(stripId, newHash );
              if (!newHash.is_valid())[[unlikely]]{
                ATH_MSG_WARNING("Hash "<< newHash <<" is invalid");
                continue;
              }
              stripHash = newHash;
              ATH_MSG_DEBUG("New hash " << stripHash);
            }
            else{
              if(m_idHelperSvc->cscIdHelper().measuresPhi(stripId))
                ATH_MSG_VERBOSE(" good id Measures Phi");
              else
                ATH_MSG_VERBOSE(" good id is eta");
            }
 
            Chrono chronoAfterId2(m_chronoSvc, afterId2Str);
 
            //Get samples. Each shows amplitude of pulse at different
            //time slice.
            std::vector<uint16_t> samples;
            cluster->samples(stripItr,samplesPerStrip,samples);
 
            //Test for threshold breach... 
            size_t sampCnt = 0;
           
           
            for(const auto & thisSample: samples)
            {
              m_ampHists[stripHash]->Fill(thisSample);
              if(m_doSampleHists)
                m_sampHists[stripHash][sampCnt]->Fill(thisSample);
              if(m_doBitHists && sampCnt==1)
              {
                TH2F* prodHist = nullptr;
                if(m_bitProds)
                  prodHist = (*m_bitProds)[stripHash];
                if(!fillBitHist(m_bitHists[stripHash],thisSample, prodHist).isSuccess())
                  ATH_MSG_WARNING("Failed recording bits for strip " << stripHash);
              }//end if(m_doBitHists)
 
              if(m_doOnlineDbFile){//m_doF001){
                //test if any samples are obvoe the online threshold
                if (thisSample > m_onlineThresholds[stripHash] ){
                  m_onlineThresholdFailureCount[stripHash]++;
                  ATH_MSG_VERBOSE("StripHash: " << stripHash  << 
                    " has online threshold breach. Sample: " << thisSample << " Thold: " 
                      << m_onlineThresholds[stripHash]);
                }
              }
              sampCnt++;
              }//end Sample loop
          }//end strip loop
          }//end cluster loop
        }
        else
          ATH_MSG_DEBUG("There is an empty rod (CscRawDataContainer).");
      }//end rod loop
      ATH_MSG_DEBUG("end collectEventInfo()");
      return StatusCode::SUCCESS;
    }// end collectEventInfo()

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode MuonCalib::CscCalcPed::execute

(

void

)

Definition at line 276 of file CscCalcPed.cxx.

  {
    ATH_MSG_DEBUG("Begin execute"); 
    //collectEventInfo collects infomation about each event by filling ampHistCollection and peaktHist.
    StatusCode sc = collectEventInfo();
 
    if(!sc.isSuccess())
    {
      ATH_MSG_ERROR("There was an error collecting information from the RDO this event.");
      return StatusCode::RECOVERABLE;
    }
    ATH_MSG_DEBUG("End execute");   
    return StatusCode::SUCCESS;
  } //end execute()

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

fillBitHist()

StatusCode MuonCalib::CscCalcPed::fillBitHist ( TH1I * bitHist, const uint16_t & val, TH2F * bitProds )

inlineprivate

Definition at line 139 of file CscCalcPed.h.

  {
    if(!bitHist)
      return StatusCode::RECOVERABLE;
 
    //Num bits should always be m_numBits
    std::bitset<12> bitVal(val);
 
    for(unsigned int bitIndex = 0; bitIndex < m_numBits; bitIndex++){
      if(bitVal[bitIndex]){
        bitHist->Fill(bitIndex);
        if(bitProds){
          for(unsigned int bitIndex2 = 0 ; bitIndex2 <= bitIndex ; bitIndex2++) {
            if(bitVal[bitIndex2]){
              bitProds->Fill(bitIndex,bitIndex2);
              if(bitIndex != bitIndex2)
                bitProds->Fill(bitIndex2,bitIndex);
            }
 
          }
        }
      }
 
    }
 
 
    return StatusCode::SUCCESS;
  }

finalize()

StatusCode MuonCalib::CscCalcPed::finalize

(

void

)

Definition at line 291 of file CscCalcPed.cxx.

                                  {
    if(m_eventCnt ==0)
    {
      ATH_MSG_FATAL("No events processed!");
      return StatusCode::FAILURE;
    }
    else
      ATH_MSG_INFO("In finalize() after analyzing " << m_eventCnt << " events ");
 
    StatusCode sc;
 
    ATH_MSG_INFO("not dump all hists!");
 
    //calculateParameters() finds means and fits gain curves from the data in 
    //m_ampHistCollection and/or m_peaktHist 
    sc =calculateParameters();
    if(!sc.isSuccess())
    {
      ATH_MSG_FATAL("Calculation of parameters failed!");
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG("Finished calculating parameters");
 
 
    //writeCalibrationFile() writes the calculated parameters into a calibration fie.
    sc = writeCalibrationFile();
    if(!sc.isSuccess())
    {
      ATH_MSG_FATAL("Calculation of parameters failed!");
      return StatusCode::FAILURE;
    }
 
    //Record report (ampHists) and results to storegate for future algorithms
    //like COOL database storage or monitoring to collect
    sc =storeGateRecord(); 
    if (!sc.isSuccess())
    {
      ATH_MSG_FATAL("Failed recording data in storegate");
      return StatusCode::FAILURE;
    }
 
    ATH_MSG_INFO("Finished finalize");
    return StatusCode::SUCCESS; 
  }//end finalize()

GetMinMax()

template<typename dataType>

dataType MuonCalib::CscCalcPed::GetMinMax ( std::vector< dataType > & vec )

inlineprivate

Definition at line 74 of file CscCalcPed.h.

                                                                                 {
        const auto [pMin, pMax] = std::minmax_element(vec.begin(), vec.end());
        return *pMax - *pMin;
      }

hashToChamberName()

StatusCode MuonCalib::CscCalcPed::hashToChamberName ( IdentifierHash , std::string  )

private

Utility functions.

initialize()

StatusCode MuonCalib::CscCalcPed::initialize

(

void

)

basic required functions

Store Gate active store

Definition at line 63 of file CscCalcPed.cxx.

  {
    ATH_MSG_INFO("CscCalcPed::initialize() called");
 
    if(m_doOnlineDbFile && m_onlineDbFile ==""){
      ATH_MSG_FATAL("Either specify an OnlineCalibFile or set CompareOnlineCalibFile to false");
      return StatusCode::FAILURE;
    }
 
    //*******Register services and tools *********/     
 
    ATH_CHECK(m_idHelperSvc.retrieve());
 
    ATH_CHECK(m_readKey.initialize());
 
    m_chronoSvc = service("ChronoStatSvc");
    ATH_CHECK(m_chronoSvc.isValid());
 
    ATH_CHECK(m_cscRdoDecoderTool.retrieve());
 
    // Histograms are owned by ROOT.
    m_ampHists.clear();
    if(m_doSampleHists) m_sampHists.clear();
    if(m_doBitHists) m_bitHists.clear();
 
    //Loop through ids to find out what hash range we're working on (in case we're using some 
    //unusual geometry)
    const std::vector<Identifier> &ids = m_idHelperSvc->cscIdHelper().idVector();
   
   
    m_maxStripHash = 0;
 
    for(const auto &thisChamberId: ids)
    {
      std::vector<Identifier> stripVect;
      m_idHelperSvc->cscIdHelper().idChannels(thisChamberId,stripVect);
 
     
     
      for(const auto & thisStrip: stripVect)
      {
        IdentifierHash stripHash;
        m_idHelperSvc->cscIdHelper().get_channel_hash(thisStrip,stripHash);
        if((unsigned int)stripHash > m_maxStripHash)
          m_maxStripHash = (int)stripHash;
      }//End strip loop
    }//end chamber loop     
 
 
    //Now creating ampHists. It wasn't done in last loop since there 
    //is no gaurantee that it will come out in strip order, and we assume
    //later that m_ampHists's index = stripHash
    ATH_MSG_DEBUG("Preparing ampHists. Only allowing those for " << " chamberLayer " << m_expectedChamberLayer);
    for(unsigned int stripItr = 0 ; stripItr <=m_maxStripHash; stripItr++)
    {        
 
      IdentifierHash stripHash =stripItr;
      Identifier stripId;
      IdContext channelContext = m_idHelperSvc->cscIdHelper().channel_context();    
      m_idHelperSvc->cscIdHelper().get_id(stripHash, stripId, &channelContext);
 
      int chamLayer = m_idHelperSvc->cscIdHelper().chamberLayer(stripId);
      if(chamLayer == m_expectedChamberLayer) //Only second chamber layer exists
      {
        int stationEta = m_idHelperSvc->cscIdHelper().stationEta(stripId);
        int stationPhi = m_idHelperSvc->cscIdHelper().stationPhi(stripId);
        int stripNumber = m_idHelperSvc->cscIdHelper().strip(stripId);
        int wireLayer = m_idHelperSvc->cscIdHelper().wireLayer(stripId);
        char orientation = m_idHelperSvc->cscIdHelper().measuresPhi(stripId) ? 'Y':'X';
 
 
        char name[30],titleSeed[600];
        TH1I* hist = nullptr;
 
        int stationName = m_idHelperSvc->cscIdHelper().stationName(stripId);        
        //Amplitude histogram
        sprintf(name, "ampHist%u",stripItr);
        sprintf(titleSeed, "Amplitude Histogram for eta %d, sector %d, layer %d%c, strip %d",
            stationEta,(2*stationPhi+50 - stationName),wireLayer,orientation,stripNumber);
        std::string title = m_titlePrefix + titleSeed + m_titlePostfix;
 
        hist = new TH1I(name,title.c_str(),m_ampHistNumBins,m_ampHistLowBound,
            m_ampHistHighBound);
        hist->GetXaxis()->SetTitle("Amplitude (ADC value)");
        hist->GetYaxis()->SetTitle("Counts");
        m_ampHists.push_back(hist);
 
        if(m_doSampleHists) {
          std::vector<TH1I*> tempVect;
          for(int cnt = 0; cnt < m_numSamplesExpected ; cnt++) {
            sprintf(name, "sampHist%u_%d",stripItr,cnt);
            sprintf(titleSeed, "Amplitude Histogram for eta %d, sector %d, layer %d%c, strip %d, sample %d",
                stationEta,(2*stationPhi+50 - stationName),wireLayer,orientation,stripNumber,cnt);
 
            hist = new TH1I(name,title.c_str(),m_ampHistNumBins,m_ampHistLowBound,
                m_ampHistHighBound);
            tempVect.push_back(hist);
 
          }
          m_sampHists.push_back(std::move(tempVect));
        }
 
        if(m_doBitHists)
        {
          //Bit histogram (for looking for stuck-bits)
          sprintf(name, "bitHist%u",stripItr);
          sprintf(titleSeed, "Bit histogram for eta %d, sector %d, layer %d%c strip %d", 
              stationEta,(2*stationPhi+50 - stationName),wireLayer,orientation,stripNumber);
          title = m_titlePrefix + titleSeed + m_titlePostfix;
          hist = new TH1I(name, title.c_str(), m_numBits, 0, m_numBits); //12 bits
          hist->GetXaxis()->SetTitle("Bit");
          hist->GetYaxis()->SetTitle("Counts");
          m_bitHists.push_back(hist);
          if(m_doCorrelation) { 
            (*m_bitProds)[stripItr] = new TH2F(TString::Format("bitProds%d",stripItr),"Bit products", m_numBits,0,m_numBits, m_numBits, 0, m_numBits);
 
          }
        }
      }
      else
      {
        m_ampHists.push_back(nullptr);
        if(m_doBitHists) m_bitHists.push_back(nullptr);
        if(m_doSampleHists) m_sampHists.push_back(std::vector<TH1I*>());
      }
    }//end strip loop
 
    //Setup result collections. These will be passed to storegate for any monitoring later
    m_peds = new CscCalibResultCollection("ped");
    m_noises = new CscCalibResultCollection("noise");
    m_rmses = new CscCalibResultCollection("rms");
    if(m_doF001){
      ATH_MSG_DEBUG("Doing f001");
      //For f001 values
      m_f001s = new CscCalibResultCollection("f001");
 
      //Initializing for comparing new values to an online database file
      if(m_doOnlineDbFile){
 
        //How many samples failed the online threshold test of f001 +2*RMS 
        //(f001 and RMS read from a file from online configuration db)
        m_onlineTHoldBreaches = new CscCalibResultCollection("OnlTHoldBreaches");
 
 
 
        //Vector we use to count the online thresholds
        m_onlineThresholdFailureCount.resize(m_maxStripHash+1,0);
 
        //Retrieve current online thresholds
        m_onlineThresholds.resize(m_maxStripHash+1);
        std::ifstream ifile; ifile.open(m_onlineDbFile.c_str());
        if(!ifile.is_open()){
          ATH_MSG_FATAL("Failed to open online database file " << m_onlineDbFile);
          return StatusCode::FAILURE;
        }
        std::string buf;
        ifile >> buf; // skip 32 at start of file
        unsigned int onlineId;
        unsigned int hashId;
        double rms;
        double f001;
 
        if(!ifile){
          ATH_MSG_FATAL("Problem with file after one word read in.");
          return StatusCode::FAILURE;
        }
 
 
        ATH_MSG_DEBUG("Reading in online thresholds from file " <<  m_onlineDbFile);
        ATH_MSG_DEBUG("First (junk) word: " << buf);
        int chanCnt = 0;
        while(ifile >> std::hex >> onlineId >> std::dec) { 
          chanCnt++;
          onlineToOfflineHashId(onlineId,hashId);
 
          ifile >> buf >> buf >> buf >> buf >>  rms >> buf >> f001;
          double thold = f001 + 2*rms;
          ATH_MSG_VERBOSE("onlid: " <<  std::hex << onlineId << std::dec << " hash: " << hashId << " rms: " << rms << " f001: " << f001 << " thold: " << thold);
          m_onlineThresholds.at(hashId) = thold;
            if(!ifile)
              ATH_MSG_VERBOSE("input file is done, ready to close!");
          else 
            ATH_MSG_VERBOSE("Input file still good!");
 
 
        }
        if(chanCnt != 30720){
          ATH_MSG_FATAL("Did not retrieve expected 30720 channels from online database! Retrieved: " << chanCnt);
          ATH_MSG_FATAL("Last onlineId read: " << std::hex << onlineId << std::dec);
          return StatusCode::FAILURE;
        }
 
      }//if m_doOnlineDBFile
    }//db file
 
    ATH_MSG_INFO("highest strip hash id is " << m_maxStripHash);
 
    //If we're doing correlation plots, set up the product histogram array
    if(m_doCorrelation){
      m_bitProds = new DataVector<TH2F>(SG::VIEW_ELEMENTS);
      m_bitProds->resize(m_maxStripHash+1);
    }
 
 
 
 
 
    ATH_MSG_INFO("m_prods value: " << m_bitProds <<  "\ndoCorrelation" << m_doCorrelation);
    return StatusCode::SUCCESS;
  }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

makeBitCorrelation()

std::vector< TH2F * > MuonCalib::CscCalcPed::makeBitCorrelation ( )

private

Definition at line 861 of file CscCalcPed.cxx.

                                                    {
 
      std::vector<TH2F*> correlations;
      if(!m_bitProds || !m_doBitHists)
        return correlations;
 
      correlations.resize(m_maxStripHash +1);
 
      for(unsigned int hashItr =0; hashItr <= m_maxStripHash; hashItr++) {
        IdentifierHash stripHash =hashItr;
        Identifier stripId;
        IdContext channelContext = m_idHelperSvc->cscIdHelper().channel_context();  
        m_idHelperSvc->cscIdHelper().get_id(stripHash, stripId, &channelContext);
 
        int chamLayer = m_idHelperSvc->cscIdHelper().chamberLayer(stripId);
        if(chamLayer == m_expectedChamberLayer) //Only second chamber layer exists
        {
          int stationName = m_idHelperSvc->cscIdHelper().stationName(stripId);
          //int stationEta = m_idHelperSvc->cscIdHelper().stationEta(stripId);
          int stationPhi = m_idHelperSvc->cscIdHelper().stationPhi(stripId);
          int stripNumber = m_idHelperSvc->cscIdHelper().strip(stripId);
          int wireLayer = m_idHelperSvc->cscIdHelper().wireLayer(stripId);
          char orientation = m_idHelperSvc->cscIdHelper().measuresPhi(stripId) ? 'Y':'X';
 
          int sector = 2*stationPhi + 50 - stationName;
 
          std::stringstream name; 
          name << "h_bitCorr_sector_" << std::setfill('0') << std::setw(2) << sector << 
            "_lay_" << wireLayer  << orientation << "_strip_" << std::setw(3) << stripNumber; 
          std::stringstream title; 
          title << "h_bitCorr_sector_" << std::setfill('0') << std::setw(2) << sector << 
            "_lay_" << wireLayer  << orientation << "_strip_" << std::setw(3) << stripNumber; 
 
          TH2F* correlationHist = new TH2F(
              name.str().c_str(), 
              title.str().c_str(),
              m_numBits, 0, m_numBits,
              m_numBits, 0, m_numBits
              );
          correlations[hashItr] = correlationHist;
 
          //each amphis is filled exaclty the number of times the bits are sampled,
          //so its a good place to get n
          double n = m_ampHists[hashItr]->GetEntries();
          TH1I * bitHist = m_bitHists[hashItr];
          TH2F * bitProds = (*m_bitProds)[hashItr];
          for(unsigned int bit1 = 1; bit1 <=m_numBits; bit1++){
            for(unsigned int bit2 = 1; bit2 <=bit1; bit2++){
 
              float xy = bitProds->GetBinContent(bit1,bit2);
              float x = bitHist->GetBinContent(bit1);
              float y = bitHist->GetBinContent(bit2);
 
              float r;
              float denom = (n*x-x*x)*(n*y-y*y);
              if(denom <= 0 )
                r= 0;
              else 
                r = (n*xy - x*y)/std::sqrt(denom);
 
              //Pearson r
              correlationHist->SetBinContent(bit1,bit2,r);
              if(bit1!=bit2)
                correlationHist->SetBinContent(bit2,bit1,r);
 
 
            }
          }
        }
      }
      return correlations;
    }//end makeBitCorrelations

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

onlineToOfflineHashId()

void MuonCalib::CscCalcPed::onlineToOfflineHashId ( const unsigned int & onlineId, unsigned int & hashId ) const

private

Definition at line 935 of file CscCalcPed.cxx.

    {
      int stationName =       ((onlineId >> 16)&0x1) + 50;
      int phi =               ((onlineId >> 13)&0x7)+1;
      int eta =               ((((onlineId >> 12)&0x1) == 1) ? 1:-1);
      int chamLay =           ((onlineId>>11)&0x1) +1;
      int wireLay =           ((onlineId>>9)&0x3) +1;
      int measuresPhi =       ((onlineId >> 8)&0x1);
      int strip;
 
      // Online and offline phi ids are flipped on A wheel
      if( measuresPhi && eta == 1){
        strip = 48 - ((onlineId)&0xff) ; //equivalent: 49 -( onlineId&0xff +1)
      }
      else {
        strip = ((onlineId)&0xff) +1;
      }
 
      Identifier chanId = m_idHelperSvc->cscIdHelper().channelID(stationName,eta,phi,chamLay,wireLay,measuresPhi,strip);
 
      IdentifierHash chanHash;
      m_idHelperSvc->cscIdHelper().get_channel_hash(chanId, chanHash);
 
      hashId = (unsigned int)chanHash;
 
    }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

outputParameter3()

void MuonCalib::CscCalcPed::outputParameter3 ( const CscCalibResultCollection & results, std::ofstream & out )

private

Definition at line 772 of file CscCalcPed.cxx.

                                                                                                {
 
      SG::ReadCondHandle<CscCondDbData> readHandle{m_readKey}; 
      const CscCondDbData* readCdo{*readHandle};
 
      out << "\n";
      out << "<NEW_PAR> " << results.parName() << "\n";
      std::string idString;
 
      CscCalibResultCollection::const_iterator resItr = results.begin();
      CscCalibResultCollection::const_iterator resEnd = results.end();
      for(; resItr != resEnd; ++resItr){
        unsigned int hashId = (*resItr)->hashId();
        double value = (*resItr)->value();
        std::string idString;
 
        readCdo->indexToStringId(&m_idHelperSvc->cscIdHelper(), hashId, "CHANNEL", idString).ignore();
 
        out << idString << " " << value << "\n";
      }
 
      out << "<END_PAR>" ;
    }

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

storeGateRecord()

StatusCode MuonCalib::CscCalcPed::storeGateRecord ( )

private

Definition at line 800 of file CscCalcPed.cxx.

    {
      StatusCode sc = StatusCode::SUCCESS;
 
      bool thereIsAnError = false;
 
      std::string histKey = "cscPedCalibReport";
      ATH_MSG_DEBUG("Recording pedestal amplitude histograms to TDS with key " << histKey);
 
      //CscCalibReport has extraraneous monitoring information
      CscCalibReportPed * report = new CscCalibReportPed("pedAmps");
      report->setPedAmpHists(std::move(m_ampHists));
      report->setBitHists(std::move(m_bitHists));
      if(m_doSampleHists){
        report->setSampHists(std::move(m_sampHists));
      }
      if(m_bitProds){
        report->setBitCorrelation( makeBitCorrelation());
      }
 
      CscCalibReportContainer * repCont = new CscCalibReportContainer(histKey);
      repCont->push_back(report);  
 
      sc = evtStore()->record(repCont, histKey);
      if(!sc.isSuccess())
      {
        ATH_MSG_ERROR("Failed to record CscCalibReportPed to storegate");
        thereIsAnError = true;
        delete repCont;
      }
 
 
      //CscCalibResult contains the actual parameters that we recorded, mostly things that should be entered
      //into cool
      std::string key = "CscCalibResultPed";
      ATH_MSG_DEBUG("Recording calibration results to TDS with key " << key);
 
      CscCalibResultContainer * calibResults 
        = new CscCalibResultContainer("CscCalibResultPed");
      calibResults->push_back(m_peds);
      calibResults->push_back(m_noises);
      calibResults->push_back(m_rmses);
      calibResults->push_back(m_f001s);
      if(m_doOnlineDbFile)
        calibResults->push_back(m_onlineTHoldBreaches);
 
      sc = evtStore()->record(calibResults,key);
      if(!sc.isSuccess())
      {
        ATH_MSG_ERROR("Failed to record data to storegate");
        thereIsAnError = true;
        delete calibResults;
      }
 
      if(thereIsAnError)
        return StatusCode::RECOVERABLE;
 
      return StatusCode::SUCCESS;
    }

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

writeCalibrationFile()

StatusCode MuonCalib::CscCalcPed::writeCalibrationFile ( )

private

Definition at line 584 of file CscCalcPed.cxx.

    {
      Chrono chrono(m_chronoSvc,"writeFile");
      //***Take conditions data held in summary histograms and  print to the calibration file***//
      ATH_MSG_INFO("Parameters calculated, preparing to output to file: " << m_outputFileName << " Types 1 and " << m_calOutputVersion);
 
      ATH_CHECK( calOutput1() );
 
      if(m_calOutputVersion == "00-00"){
        return calOutput0();
      }
      else if(m_calOutputVersion == "03-00") {
        return calOutput3();
      }
      else{
        ATH_MSG_WARNING("Don't know how to write calibration file version " << m_calOutputVersion);
        return StatusCode::RECOVERABLE;
      }
      // this part of the code cannot be reached since one of the if statements before already exits the code
      // return StatusCode::SUCCESS;
    }

Member Data Documentation

m_ampHistHighBound

unsigned int MuonCalib::CscCalcPed::m_ampHistHighBound

private

Definition at line 105 of file CscCalcPed.h.

m_ampHistLowBound

unsigned int MuonCalib::CscCalcPed::m_ampHistLowBound

private

Definition at line 105 of file CscCalcPed.h.

m_ampHistNumBins

unsigned int MuonCalib::CscCalcPed::m_ampHistNumBins

private

Definition at line 105 of file CscCalcPed.h.

m_ampHists

std::vector<TH1I*> MuonCalib::CscCalcPed::m_ampHists

private

Definition at line 116 of file CscCalcPed.h.

m_bitCorrelation

DataVector<TH1F>* MuonCalib::CscCalcPed::m_bitCorrelation

private

Definition at line 120 of file CscCalcPed.h.

m_bitHists

std::vector<TH1I*> MuonCalib::CscCalcPed::m_bitHists

private

Definition at line 118 of file CscCalcPed.h.

m_bitProds

DataVector<TH2F>* MuonCalib::CscCalcPed::m_bitProds

private

Definition at line 119 of file CscCalcPed.h.

m_calOutputVersion

std::string MuonCalib::CscCalcPed::m_calOutputVersion

private

Definition at line 92 of file CscCalcPed.h.

m_chronoSvc

SmartIF<IChronoStatSvc> MuonCalib::CscCalcPed::m_chronoSvc

private

Definition at line 84 of file CscCalcPed.h.

m_cmt_parameter

std::string MuonCalib::CscCalcPed::m_cmt_parameter

private

Definition at line 132 of file CscCalcPed.h.

m_crossTalkFix

double* MuonCalib::CscCalcPed::m_crossTalkFix

private

Definition at line 129 of file CscCalcPed.h.

m_cscRdoDecoderTool

ToolHandle<Muon::ICSC_RDO_Decoder> MuonCalib::CscCalcPed::m_cscRdoDecoderTool {this,"CscRdoDecoderTool","Muon::CscRDO_Decoder"}

private

Definition at line 85 of file CscCalcPed.h.

{this,"CscRdoDecoderTool","Muon::CscRDO_Decoder"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_doBitHists

bool MuonCalib::CscCalcPed::m_doBitHists

private

Definition at line 109 of file CscCalcPed.h.

m_doCorrelation

bool MuonCalib::CscCalcPed::m_doCorrelation

private

Definition at line 93 of file CscCalcPed.h.

m_doF001

bool MuonCalib::CscCalcPed::m_doF001

private

Definition at line 114 of file CscCalcPed.h.

m_doOnlineDbFile

bool MuonCalib::CscCalcPed::m_doOnlineDbFile

private

Definition at line 134 of file CscCalcPed.h.

m_doSampleHists

bool MuonCalib::CscCalcPed::m_doSampleHists

private

Definition at line 110 of file CscCalcPed.h.

m_eventCnt

int MuonCalib::CscCalcPed::m_eventCnt

private

Definition at line 128 of file CscCalcPed.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_expectedChamberLayer

int MuonCalib::CscCalcPed::m_expectedChamberLayer

private

Definition at line 98 of file CscCalcPed.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_f001s

CscCalibResultCollection* MuonCalib::CscCalcPed::m_f001s

private

Definition at line 126 of file CscCalcPed.h.

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonCalib::CscCalcPed::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Services and tools.

Definition at line 83 of file CscCalcPed.h.

{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_maxStripHash

unsigned int MuonCalib::CscCalcPed::m_maxStripHash

private

Internally global variables.

Definition at line 103 of file CscCalcPed.h.

m_noises

CscCalibResultCollection* MuonCalib::CscCalcPed::m_noises

private

Definition at line 124 of file CscCalcPed.h.

m_numBits

const unsigned int MuonCalib::CscCalcPed::m_numBits

private

Definition at line 107 of file CscCalcPed.h.

m_numSamplesExpected

int MuonCalib::CscCalcPed::m_numSamplesExpected

private

Definition at line 112 of file CscCalcPed.h.

m_onlineDbFile

std::string MuonCalib::CscCalcPed::m_onlineDbFile

private

filename for file with online database information

Definition at line 100 of file CscCalcPed.h.

m_onlineTHoldBreaches

CscCalibResultCollection* MuonCalib::CscCalcPed::m_onlineTHoldBreaches

private

Definition at line 127 of file CscCalcPed.h.

m_onlineThresholdFailureCount

std::vector<int> MuonCalib::CscCalcPed::m_onlineThresholdFailureCount

private

Definition at line 122 of file CscCalcPed.h.

m_onlineThresholds

std::vector<int> MuonCalib::CscCalcPed::m_onlineThresholds

private

Definition at line 121 of file CscCalcPed.h.

m_outputFileName

std::string MuonCalib::CscCalcPed::m_outputFileName

private

Parameters input through joboptions.

Definition at line 90 of file CscCalcPed.h.

m_peds

CscCalibResultCollection* MuonCalib::CscCalcPed::m_peds

private

Definition at line 123 of file CscCalcPed.h.

m_readKey

SG::ReadCondHandleKey<CscCondDbData> MuonCalib::CscCalcPed::m_readKey {this, "ReadKey", "CscCondDbData", "Key of CscCondDbData"}

private

Definition at line 86 of file CscCalcPed.h.

{this, "ReadKey", "CscCondDbData", "Key of CscCondDbData"};   

m_rmses

CscCalibResultCollection* MuonCalib::CscCalcPed::m_rmses

private

Definition at line 125 of file CscCalcPed.h.

m_sampHists

std::vector< std::vector<TH1I*> > MuonCalib::CscCalcPed::m_sampHists

private

Definition at line 117 of file CscCalcPed.h.

m_thresholdMultiplier

float MuonCalib::CscCalcPed::m_thresholdMultiplier

private

Definition at line 97 of file CscCalcPed.h.

m_titlePostfix

std::string MuonCalib::CscCalcPed::m_titlePostfix

private

Definition at line 91 of file CscCalcPed.h.

m_titlePrefix

std::string MuonCalib::CscCalcPed::m_titlePrefix

private

Definition at line 91 of file CscCalcPed.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• CscCalcPed.h
• CscCalcPed.cxx