FixLArElecCalib Class Reference

fix electronic calibration constants for MC. More...

#include <FixLArElecCalib.h>

Inheritance diagram for FixLArElecCalib:

Public Member Functions
	FixLArElecCalib (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~FixLArElecCalib ()=default
virtual StatusCode	initialize () override
virtual StatusCode	execute () override
virtual StatusCode	finalize () override
virtual StatusCode stop	ATLAS_NOT_THREAD_SAFE () override
StatusCode	fix1 (const LArOnOffIdMapping *cabling)
StatusCode	fix2 (const LArOnOffIdMapping *cabling)
StatusCode fix3	ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling)
StatusCode fix4	ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling)
StatusCode fix5	ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling)
StatusCode fix6	ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling)
StatusCode fix7	ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling)
StatusCode fix8	ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling)
StatusCode fix9	ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling)
StatusCode fix10	ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling)
StatusCode fix11	ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling)
StatusCode	fix12 (const LArOnOffIdMapping *cabling)
StatusCode	fix13 (const LArOnOffIdMapping *cabling)
StatusCode	fix14 (const LArOnOffIdMapping *cabling)
StatusCode fix15	ATLAS_NOT_THREAD_SAFE ()
StatusCode fix16	ATLAS_NOT_THREAD_SAFE ()
StatusCode fix17	ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling)
StatusCode	fix18 (const LArCalibLineMapping *clmap)
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 std::pair< HWIdentifier, std::vector< float > >	ROW_t
typedef std::vector< ROW_t >	VROW_t
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	ReadFile (const std::string &filename, const LArOnOffIdMapping *cabling, bool EM, bool withGain, int nvar)
StatusCode	ReadFileAll (const std::string &filename, const LArOnOffIdMapping *cabling, bool withGain, int nvar)
StatusCode	update_DAC2uA (const std::string &em_filename, const std::string &hec_filename)
template<class T>
StatusCode update_EM_HEC	ATLAS_NOT_THREAD_SAFE (const std::string &em_filename, const std::string &hec_filename, const LArOnOffIdMapping *cabling, bool withGain, int nvar)
template<class T>
StatusCode update_All	ATLAS_NOT_THREAD_SAFE (const std::string &filename, const LArOnOffIdMapping *cabling, bool withGain, int nvar)
void	print_object (const std::string &msg, const LArNoiseMC::LArCondObj &obj)
void	set_object (LArNoiseMC::LArCondObj &obj, const std::vector< float > &v)
void	print_object (const std::string &msg, const LArAutoCorrMC::LArCondObj &obj)
void	set_object (LArAutoCorrMC::LArCondObj &obj, const std::vector< float > &v)
void	print_object (const std::string &msg, const LArRampMC::LArCondObj &obj)
void	set_object (LArRampMC::LArCondObj &obj, const std::vector< float > &v)
void	print_object (const std::string &msg, const LArShape32MC::LArCondObj &obj)
void	set_object (LArShape32MC::LArCondObj &obj, const std::vector< float > &v)
void	print_object (const std::string &msg, const LArSingleFloatP &obj)
void	set_object (LArSingleFloatP &obj, const std::vector< float > &v)
StatusCode	addMphysOverMcal (const LArOnOffIdMapping *cabling)
StatusCode fixDACuAMeV	ATLAS_NOT_THREAD_SAFE ()
StatusCode updateEMfSampl	ATLAS_NOT_THREAD_SAFE (const std::string &filename, const LArOnOffIdMapping *cabling)
StatusCode updateMinBias	ATLAS_NOT_THREAD_SAFE (const std::string &filename, const LArOnOffIdMapping *cabling)
StatusCode updateEM_DACuAMeV	ATLAS_NOT_THREAD_SAFE (const std::string &filename, const LArOnOffIdMapping *cabling)
StatusCode updateHADfSampl	ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
SG::ReadCondHandleKey< LArCalibLineMapping >	m_CLKey {this, "CalibLineKey", "LArCalibLineMap", "calib line key"}
IntegerProperty	m_fixFlag {this, "FixFlag", 1, "which fix to apply"}
StringProperty	m_g4Phys {this, "G4Phys", "", "which physics list to use"}
StringProperty	m_infile {this, "InputFile", "", "name of inpput file"}
const LArEM_ID *	m_em_idhelper
const LArHEC_ID *	m_hec_idhelper
const LArFCAL_ID *	m_fcal_idhelper
const LArOnlineID *	m_online_idhelper
const LArEM_SuperCell_ID *	m_sem_idhelper
const LArHEC_SuperCell_ID *	m_shec_idhelper
const LArOnline_SuperCellID *	m_sonline_idhelper
const CaloCell_SuperCell_ID *	m_scell_idhelper
VROW_t	m_cache [3]
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

fix electronic calibration constants for MC.

Author

Hong Ma hma@b.nosp@m.nl.g.nosp@m.ov

Purpose: read in the LAr electronic calib data, and fix them ready to be written out again as a new version.

This should be used with FixLArElecCalib_jobOptions.py to write a new POOL file.

Implemented fixes:

1. Flag = 1 Replacing values for barrel in LArDAC2uAMC Input barrel_dac2ua_oct06.txt
2. Flag=2 fix FCAL conditions data for new mapping in release 13.
3. Flag=3 replace fsampl for 4.8.2 June 13,2007: FCAL numbers updated by P. Krieger. Junly 10, 2007: updated the number for 13.0.20
4. Flag=4 replace uA2MeV DAC2uA with that in dac2ua_ua2mev_rel13.txt
5. Flag=5 replace FCAL noise and minbiasRMS from Sven Menke's new number for release 13.

6 Flag=6 replace All FCAL noise and ADC2DAC, uA2MeV and DAC2uA. <HG/MG> = 9.96 +/- 0.01 <MG/LG> = 9.67 +/- 0.01

7 Flag=7 replace sampling fraction for QGSP_BERT from 13.0.30.

8 Flag=8 replace EM/HEC autoCorr, noise, dac2ua, mphys, ramp, shape, ua2mev

9 Flag=9 fix FCAL AutoCorr

10 Flag=10 fix FCAL ramp. The scaling factor were inverted. Ramp_M = Ramp_H*9.96 Ramp_L = Ramp_H*9.96*9.67

11 Flag=11 Update HEC Ramp

12 Flag=12 Fill the LArMinBiasMC and LArMinBiasAverageMC from ntuple created by LArMinBiasAlg (in CaloCondPhysAlgs)
13 Flag=13 Filling the OnlOflMap for SC

14 Flag=14 Fill the LArMinBiasAverageMC type in LArPileupAverage folder for BCID correction from ntuple created by LArMinBiasAlg (in CaloCondPhysAlgs)

15 Flag=15 Scale the MinBiasAverage by constant

16 Flag=16 Fix the EMEC-A FT 7 slot 11 OnOfIdMap cable swap

17 Flag=17 replace All shape

18 Flag=18 Fix the calib. line mapping for the EMF, where all channels in EMB-A FT 0 has CL=channel

Definition at line 35 of file FixLArElecCalib.h.

Member Typedef Documentation

ROW_t

typedef std::pair<HWIdentifier,std::vector<float> > FixLArElecCalib::ROW_t

private

Definition at line 135 of file FixLArElecCalib.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

VROW_t

typedef std::vector<ROW_t> FixLArElecCalib::VROW_t

private

Definition at line 136 of file FixLArElecCalib.h.

Constructor & Destructor Documentation

FixLArElecCalib()

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

Definition at line 111 of file FixLArElecCalib.cxx.

                                                                                : 
  AthAlgorithm(name,pSvcLocator),
  m_em_idhelper(nullptr),
  m_hec_idhelper(nullptr),
  m_fcal_idhelper(nullptr),
  m_online_idhelper(nullptr),
  m_sem_idhelper(nullptr),
  m_shec_idhelper(nullptr),
  m_sonline_idhelper(nullptr),
  m_scell_idhelper(nullptr)
{ 
 
}

~FixLArElecCalib()

virtual FixLArElecCalib::~FixLArElecCalib ( )

virtualdefault

Member Function Documentation

addMphysOverMcal()

StatusCode FixLArElecCalib::addMphysOverMcal ( const LArOnOffIdMapping * cabling )

private

Definition at line 1424 of file FixLArElecCalib.cxx.

                                                                             {
  // add the contain to DetStore.
  // fill 1 for all FCAL/HEC channels
 
    ATH_MSG_INFO ( " addMphysOverMcal() " );
    // create LArMphysOverMcal with FCAL numbers = 1.
 
    std::unique_ptr<LArMphysOverMcalMC> mphys = std::make_unique<LArMphysOverMcalMC>(); 
    mphys->setGroupingType(LArConditionsContainerBase::SingleGroup);
    ATH_CHECK( mphys->initialize() );
 
    int n=0;
 
    std::string filename("FCal_noise_minbias_adc2mev.txt");
 
    std::ifstream infile(filename.c_str() ) ; 
 
    if(! infile.good() ) 
      {
    ATH_MSG_ERROR(" fail to open file "<<filename);
    return StatusCode::FAILURE; 
     }
    
 
   char s[200];
 
   ATH_MSG_INFO("Opened FCAL file");
   for(int i = 0;i<27;++i){
     infile.getline(s,200);
     ATH_MSG_INFO(s);
   }
 
   std::string str_id;
 
   float vol,noise_p,noise_h, noise_m,noise_l;
   float ramp_val,ua2MeV_val,dac2uA_val;
   std::string channel_type;
   while ( infile>>str_id >>vol>>noise_p >> noise_h>>noise_m>>noise_l
       >>channel_type>> ramp_val>>ua2MeV_val>>dac2uA_val )
     {
       const char* ch_id = str_id.c_str();
 
       if(str_id.substr(0,1)!=std::string("A")){
     ATH_MSG_INFO(" skipping string"<<str_id);
         continue;  
       }
 
       int mod,phi,eta;
       sscanf(ch_id, "A%d.%d.%d", &mod,&phi,&eta);
       if(phi>7){
          ATH_MSG_INFO(" skipping phi"<<str_id<<" phi="<<phi);
          continue; 
       }
 
       ++n;
 
       ATH_MSG_INFO(" Setting channel "<<str_id);
       Identifier id = m_fcal_idhelper->channel_id(2,mod,eta,phi); 
       HWIdentifier hid = cabling->createSignalChannelID(id);
 
       LArMphysOverMcalMC::LArCondObj t; 
       t.m_data =1. ;
       mphys->setPdata(hid,t,0);
       mphys->setPdata(hid,t,1);
       mphys->setPdata(hid,t,2);
     }
       
   ATH_MSG_INFO(" MphysOverMcal added  "<<n<<" FCAL channels");
 
   bool EM=false ;
   bool withGain=false; 
   int nvar = 1; 
   std::string hec_filename("mphys_hec.txt"); 
   ATH_CHECK( ReadFile(hec_filename,cabling,EM,withGain,nvar) );
   
   int igain=0;
   n=0; 
   for( ROW_t &it : m_cache[igain])
     {
       HWIdentifier hid = it.first;
       LArMphysOverMcalMC::LArCondObj t; 
       t.m_data =1. ;
       mphys->setPdata(hid,t,0);
       mphys->setPdata(hid,t,1);
       mphys->setPdata(hid,t,2);
       ++n; 
 
     }
 
   ATH_CHECK( detStore()->record(std::move(mphys),"LArMphysOverMcal") );
   ILArMphysOverMcal* imphys=nullptr;
   ATH_CHECK (detStore()->symLink(mphys.get(),imphys) );
 
   ATH_MSG_ERROR(" Number of HEC channel added "<<n <<" per gain ");
   return StatusCode::SUCCESS ;
}

ATLAS_NOT_THREAD_SAFE() [1/20]

StatusCode fix15 FixLArElecCalib::ATLAS_NOT_THREAD_SAFE

(

)

ATLAS_NOT_THREAD_SAFE() [2/20]

StatusCode fix16 FixLArElecCalib::ATLAS_NOT_THREAD_SAFE

(

)

ATLAS_NOT_THREAD_SAFE() [3/20]

StatusCode fixDACuAMeV FixLArElecCalib::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [4/20]

virtual StatusCode stop FixLArElecCalib::ATLAS_NOT_THREAD_SAFE ( )

overridevirtual

ATLAS_NOT_THREAD_SAFE() [5/20]

StatusCode fix3 FixLArElecCalib::ATLAS_NOT_THREAD_SAFE

(

const LArOnOffIdMapping *

cabling

)

ATLAS_NOT_THREAD_SAFE() [6/20]

StatusCode fix4 FixLArElecCalib::ATLAS_NOT_THREAD_SAFE

(

const LArOnOffIdMapping *

cabling

)

ATLAS_NOT_THREAD_SAFE() [7/20]

StatusCode fix5 FixLArElecCalib::ATLAS_NOT_THREAD_SAFE

(

const LArOnOffIdMapping *

cabling

)

ATLAS_NOT_THREAD_SAFE() [8/20]

StatusCode fix6 FixLArElecCalib::ATLAS_NOT_THREAD_SAFE

(

const LArOnOffIdMapping *

cabling

)

ATLAS_NOT_THREAD_SAFE() [9/20]

StatusCode fix7 FixLArElecCalib::ATLAS_NOT_THREAD_SAFE

(

const LArOnOffIdMapping *

cabling

)

ATLAS_NOT_THREAD_SAFE() [10/20]

StatusCode fix8 FixLArElecCalib::ATLAS_NOT_THREAD_SAFE

(

const LArOnOffIdMapping *

cabling

)

ATLAS_NOT_THREAD_SAFE() [11/20]

StatusCode fix9 FixLArElecCalib::ATLAS_NOT_THREAD_SAFE

(

const LArOnOffIdMapping *

cabling

)

ATLAS_NOT_THREAD_SAFE() [12/20]

StatusCode fix10 FixLArElecCalib::ATLAS_NOT_THREAD_SAFE

(

const LArOnOffIdMapping *

cabling

)

ATLAS_NOT_THREAD_SAFE() [13/20]

StatusCode fix11 FixLArElecCalib::ATLAS_NOT_THREAD_SAFE

(

const LArOnOffIdMapping *

cabling

)

ATLAS_NOT_THREAD_SAFE() [14/20]

StatusCode fix17 FixLArElecCalib::ATLAS_NOT_THREAD_SAFE

(

const LArOnOffIdMapping *

cabling

)

ATLAS_NOT_THREAD_SAFE() [15/20]

StatusCode updateHADfSampl FixLArElecCalib::ATLAS_NOT_THREAD_SAFE ( const LArOnOffIdMapping * cabling )

private

ATLAS_NOT_THREAD_SAFE() [16/20]

template<class T>

StatusCode update_EM_HEC FixLArElecCalib::ATLAS_NOT_THREAD_SAFE ( const std::string & em_filename, const std::string & hec_filename, const LArOnOffIdMapping * cabling, bool withGain, int nvar )

private

ATLAS_NOT_THREAD_SAFE() [17/20]

StatusCode updateEMfSampl FixLArElecCalib::ATLAS_NOT_THREAD_SAFE ( const std::string & filename, const LArOnOffIdMapping * cabling )

private

ATLAS_NOT_THREAD_SAFE() [18/20]

StatusCode updateMinBias FixLArElecCalib::ATLAS_NOT_THREAD_SAFE ( const std::string & filename, const LArOnOffIdMapping * cabling )

private

ATLAS_NOT_THREAD_SAFE() [19/20]

StatusCode updateEM_DACuAMeV FixLArElecCalib::ATLAS_NOT_THREAD_SAFE ( const std::string & filename, const LArOnOffIdMapping * cabling )

private

ATLAS_NOT_THREAD_SAFE() [20/20]

template<class T>

StatusCode update_All FixLArElecCalib::ATLAS_NOT_THREAD_SAFE ( const std::string & filename, const LArOnOffIdMapping * cabling, bool withGain, int nvar )

private

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 FixLArElecCalib::execute ( )

overridevirtual

Definition at line 143 of file FixLArElecCalib.cxx.

                                    {
 
  const EventContext& ctx = Gaudi::Hive::currentContext();  
 
  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey, ctx};
  const LArOnOffIdMapping* cabling{*cablingHdl};
  if(!cabling) {
     ATH_MSG_WARNING( "Do not have cabling mapping from key " << m_cablingKey.key() );
  }
  if(m_fixFlag==13)
    return fix13(cabling);
 
  return StatusCode::SUCCESS;
}

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();
}

finalize()

virtual StatusCode FixLArElecCalib::finalize ( )

inlineoverridevirtual

Definition at line 43 of file FixLArElecCalib.h.

{return StatusCode::SUCCESS;}  

fix1()

StatusCode FixLArElecCalib::fix1

(

const LArOnOffIdMapping *

cabling

)

Definition at line 219 of file FixLArElecCalib.cxx.

                                                                 {
 
   ATH_MSG_INFO ( " in fix1() " );
 
   // Fix1 is for updating the EM DAC2uA, assuming symmetry. 
   // Input should be MC Conditions data with DetDescrVersion=ATLAS-DC3-05
 
   // Pointer to StoreGate 
   const LArEM_ID* em_idhelper = nullptr;
   ATH_CHECK( detStore()->retrieve(em_idhelper) );
 
   const LArOnlineID* online_idhelper = nullptr;
   ATH_CHECK( detStore()->retrieve(online_idhelper) );
 
   // retrieve DetDescrManager
   SmartIF<IToolSvc> toolSvc{Gaudi::svcLocator()->service("ToolSvc")};
   ATH_CHECK(toolSvc.isValid());
 
   LArDAC2uAMC * dac2ua = nullptr;
   ATH_CHECK( detStore()->retrieve(dac2ua) );
 
   // read in the file
 
   std::ifstream infile("barrel_dac2ua_oct06.txt") ; 
   if(! infile.good() ) 
     {
       ATH_MSG_ERROR(" fail to open file ");
       return StatusCode::FAILURE; 
     }
 
 
   int   det,samp,reg,eta; 
   float value ; 
   int n = 0; 
   while ( infile>>det>>samp>>reg>>eta>>value )
    {
    ++n; 
    ATH_MSG_DEBUG(" det,samp,reg,eta,value="
                      <<det<<" " 
                      <<samp<<" " 
                      <<reg<<" " 
                      <<eta<<" " 
                      <<value<<" " );
 
    Identifier id ; 
    if ( det==1 && samp==1 && reg==0 && eta==0 ){
       // eta=0 for strip, not connected, but keep it
           // Removed disconnected channels: 03/2016 RDS 
           // ATH_MSG_DEBUG(" disconnected strip ");
       // id = em_idhelper->disc_channel_id(det,samp,reg,eta,0); 
        }else
     id = em_idhelper->channel_id(det,samp,reg,eta,0); 
 
    HWIdentifier hid = cabling->createSignalChannelID(id);
    LArDAC2uAComplete::LArCondObj & t = dac2ua->get(hid,0); 
    ATH_MSG_DEBUG(" online id = "<<online_idhelper->print_to_string(hid));
 
    if( t.isEmpty() ) 
    {
      ATH_MSG_WARNING(" No existing conditions data " );
      continue ; 
    }
    ATH_MSG_DEBUG(" Old DAC2uA = "<< t.m_data<< " " );
 
    t.m_data = value ; 
 
    const LArDAC2uAComplete::LArCondObj & t3 = dac2ua->get(hid,0); 
    ATH_MSG_DEBUG(" New DAC2uA = "<< t3.m_data << " " );
 
    }
 
   ATH_MSG_DEBUG("  Number of entries changes =  " <<n );
   return StatusCode::SUCCESS;
}

fix12()

StatusCode FixLArElecCalib::fix12

(

const LArOnOffIdMapping *

cabling

)

Definition at line 1997 of file FixLArElecCalib.cxx.

                                                                  {
    
   ATH_MSG_INFO ( " in fix12() " );
 
   // Fix12 is for filling the  MinBiasRMS and MinBiasAverage  from ntuple
 
   // Create new container 
   std::unique_ptr<LArMinBiasMC> minbias = std::make_unique<LArMinBiasMC>();
   ATH_CHECK( minbias->setGroupingType("Single", msg()) );
   ATH_CHECK( minbias->initialize() );
   std::unique_ptr<LArMinBiasAverageMC> minbias_av = std::make_unique<LArMinBiasAverageMC>();
   ATH_CHECK( minbias_av->setGroupingType("Single", msg()) );
   ATH_CHECK( minbias_av->initialize() );
   //
   std::unique_ptr<TFile> fin= std::make_unique<TFile>("ntuple_av.root");
   TTree *tin=dynamic_cast<TTree*>(fin->Get("m_tree"));
   if (!tin) {
     ATH_MSG_ERROR("Can't read tree m_tree");
     return StatusCode::FAILURE;
   }
   const int     nindex=1833;
   int           ncell;
   int           identifier[nindex];   
   int           layer[nindex];   
   int           region[nindex]; 
   int           ieta[nindex];   
   float         eta[nindex];   
   double        average[nindex];   
   double        rms[nindex];   
   TBranch        *b_ncell;   
   TBranch        *b_identifier;   
   TBranch        *b_layer;   
   TBranch        *b_region;   
   TBranch        *b_ieta;   
   TBranch        *b_eta;   
   TBranch        *b_average;   
   TBranch        *b_rms;   
   tin->SetMakeClass(1);
   tin->SetBranchAddress("ncell", &ncell, &b_ncell);
   tin->SetBranchAddress("identifier", identifier, &b_identifier);
   tin->SetBranchAddress("layer", layer, &b_layer);
   tin->SetBranchAddress("region", region, &b_region);
   tin->SetBranchAddress("ieta", ieta, &b_ieta);
   tin->SetBranchAddress("eta", eta, &b_eta);
   tin->SetBranchAddress("average", average, &b_average);
   tin->SetBranchAddress("rms", rms, &b_rms);
   tin->GetEntry(0);
 
   if(ncell>nindex) ncell=nindex;
   for(int icell=0; icell<ncell; ++icell)  {
 
       Identifier32 id32(identifier[icell]); 
       Identifier id(id32);
       HWIdentifier hid = cabling->createSignalChannelID(id);
 
       minbias->set(hid, rms[icell]);
       minbias_av->set(hid, average[icell]);
 
     }
 
     ATH_MSG_INFO(" number of channels in intuple ="<<ncell);
 
     ATH_MSG_INFO ( "Stored container " << minbias->totalNumberOfConditions() << " conditions, key LArMinBias " );
     ATH_CHECK( detStore()->record(std::move(minbias),"LArMinBias") );
     //ATH_CHECK( detStore()->symLink(minbias.get(), dynamic_cast<ILArMinBias*>(minbias.get())) );
     ATH_CHECK( detStore()->symLink(ClassID_traits<LArMinBiasMC>::ID(),"LArMinBias",ClassID_traits<ILArMinBias>::ID()));
     ATH_MSG_INFO ( "Stored container " << minbias_av->totalNumberOfConditions() << " conditions, key LArMinBiasAverage " );
     ATH_CHECK( detStore()->record(std::move(minbias_av),"LArMinBiasAverage") );
     //ATH_CHECK( detStore()->symLink(minbias_av.get(), dynamic_cast<ILArMinBiasAverage*>(minbias_av.get())) );
     ATH_CHECK( detStore()->symLink(ClassID_traits<LArMinBiasAverageMC>::ID(),"LArMinBiasAverage",ClassID_traits<ILArMinBiasAverage>::ID()));
 
     return StatusCode::SUCCESS;
}

fix13()

StatusCode FixLArElecCalib::fix13

(

const LArOnOffIdMapping *

cabling

)

Definition at line 1726 of file FixLArElecCalib.cxx.

                                                                  {
 
    ATH_MSG_INFO ( " in fix13() " );
    // update EM/HEC 7 data objects.
 
    ToolHandle<ICaloSuperCellIDTool> scidtool("CaloSuperCellIDTool");
    if ( scidtool.retrieve().isFailure() ) {
      ATH_MSG_ERROR ( " Could not retrieve scitool " );
    }
 
    std::set<Identifier> scidset;
    std::map<HWIdentifier,int> sslot_schannel_idx;
    std::vector<unsigned int> OrderOnlHash_OffID;
    std::vector<unsigned int> OrderOffHash_OnlID;
    OrderOnlHash_OffID.resize(40000,0);
    OrderOffHash_OnlID.resize(40000,0);
 
    Identifier::size_type channel_size = m_em_idhelper->channel_hash_max();
    unsigned int min_onl_hash = 999999;
    unsigned int max_onl_hash = 0;
    unsigned int min_off_hash = 999999;
    unsigned int max_off_hash = 0;
    std::ofstream hashes("AllHashChannels_All.txt");
    std::ofstream of("AllChannels_EM.txt");
 
    for(size_t i = 0; i < channel_size ; i++) {
    Identifier chid = m_em_idhelper->channel_id(i);
    bool isEM = ( m_em_idhelper->is_em_barrel( chid ) || m_em_idhelper->is_em_endcap( chid ) ) ;
        if ( ! isEM ) continue;
        Identifier SCID = scidtool->offlineToSuperCellID(chid);
    if ( scidset.find(SCID) == scidset.end() && (m_scell_idhelper->calo_cell_hash( SCID ).value() < 99999) )
        scidset.insert(SCID);
    else continue;
    HWIdentifier hwid = cabling->createSignalChannelID(chid);
    if ( i == 0 ){
        of << "Off ID\t\tSCID\t\tOnl ID\t\tFT\tslot\tB-E pos_neg\tSamp\teta\tphi\tFEB_ID\t\tSHWID\t" << std::endl;
    }
    of << chid.get_identifier32().get_compact() << "\t0x" <<
        SCID.get_identifier32().get_compact() << "\t0x" <<
        hwid.get_identifier32().get_compact() ;
    Identifier regId = m_em_idhelper->region_id( chid );
    int reg = m_em_idhelper->region( chid );
        IdentifierHash regHash = m_em_idhelper->region_hash( regId );
    int samp = m_em_idhelper->sampling( chid );
    int feedthrough = m_online_idhelper->feedthrough( hwid );
    int bar_ec = m_online_idhelper->barrel_ec( hwid );
    int pos_neg = m_online_idhelper->pos_neg( hwid );
    int slot = m_online_idhelper->slot( hwid );
    float etaG = m_em_idhelper->etaGranularity(regHash);
    float phiG = m_em_idhelper->phiGranularity(regHash);
    float eta0 = m_em_idhelper->eta0(regHash);
    float phi0 = m_em_idhelper->phi0(regHash);
    float eta = etaG*m_em_idhelper->eta( chid ) + eta0;
    float phi = phiG*m_em_idhelper->phi( chid ) + phi0;
        char etaChar[10];
        char phiChar[10];
        sprintf(etaChar,"%5.4f",eta);
        sprintf(phiChar,"%5.4f",phi);
    of << std::dec << "\t" << feedthrough << "\t" << slot;
    of << "\t" << bar_ec << "   " << pos_neg << "\t\t" << samp << "\t";
        of << etaChar << "  " << phiChar << "\t0x";
        HWIdentifier feb_id = m_online_idhelper->feb_Id(hwid);
        int sslot=1;
        bool InSlot= m_em_idhelper->is_em_endcap_inner ( chid );
        bool OutSlot= m_em_idhelper->is_em_endcap_outer ( chid )  ;
        bool secondOutSlot=false;
    if ( OutSlot ) {
        if ( (samp==1) && (reg==5) ) secondOutSlot=true;
        if ( (samp==2) && (reg==1) && ( m_em_idhelper->eta( chid )>=39 ) )
                secondOutSlot=true;
        if ( (samp==3) && (reg==0) && ( m_em_idhelper->eta( chid )>=18 ) )
                secondOutSlot=true;
    }
        HWIdentifier sfeb_id = m_sonline_idhelper->feb_Id(bar_ec,pos_neg,feedthrough,sslot);
        
        if ( InSlot ) {
            sfeb_id = m_sonline_idhelper->feb_Id(bar_ec,pos_neg,feedthrough-1,sslot+1);
    }
        if ( secondOutSlot ) {
            sfeb_id = m_sonline_idhelper->feb_Id(bar_ec,pos_neg,feedthrough,sslot+1);
    }
        if ( sslot_schannel_idx.find(sfeb_id) == sslot_schannel_idx.end() )
        sslot_schannel_idx[sfeb_id]=0;
    else sslot_schannel_idx[sfeb_id]++;
    HWIdentifier shwid = m_sonline_idhelper->channel_Id(sfeb_id,sslot_schannel_idx[sfeb_id]);
    unsigned int onl_hash = m_sonline_idhelper->channel_Hash( shwid ).value();
    if ( onl_hash > max_onl_hash ) max_onl_hash = onl_hash;
    if ( onl_hash < min_onl_hash ) min_onl_hash = onl_hash;
    unsigned int off_hash = m_scell_idhelper->calo_cell_hash( SCID ).value();
    if ( off_hash > max_off_hash ) max_off_hash = off_hash;
    if ( off_hash < min_off_hash ) min_off_hash = off_hash;
    of << std::hex;
    of << feb_id.get_identifier32().get_compact();
    of << "\t0x" << shwid.get_identifier32().get_compact();
    of << " " << m_online_idhelper->channel_name(hwid) << " " << m_sonline_idhelper->channel_name(shwid);
    of << std::dec;
    of << " " << onl_hash << " " << off_hash;
    of << std::endl;
 
    if ( m_scell_idhelper->calo_cell_hash( SCID ).value() < 40000 )
    OrderOffHash_OnlID[m_scell_idhelper->calo_cell_hash( SCID ).value()]  =  shwid.get_identifier32().get_compact();
    if ( m_sonline_idhelper->channel_Hash( shwid ).value() < 40000 )
    OrderOnlHash_OffID[m_sonline_idhelper->channel_Hash( shwid ).value()]  =  SCID.get_identifier32().get_compact();
    }
    of << "Hash check.  Onl : " << min_onl_hash << " " << max_onl_hash;
    of << ";   Off : " << min_off_hash << " " << max_off_hash << std::endl;;
    of.close();
 
    channel_size = m_hec_idhelper->channel_hash_max();
    min_onl_hash = 999999;
    max_onl_hash = 0;
    min_off_hash = 999999;
    max_off_hash = 0;
    std::ofstream of1("AllChannels_HEC.txt");
 
    of1 << "Off ID\t\tSCID\t\tOnl ID\t\tFT\tslot\tB-E pos_neg\tSamp\teta\tphi\tFEB_ID\t\tSHWID\t" << std::endl;
    for(size_t i = 0; i < channel_size ; i++) {
        Identifier chid = m_hec_idhelper->channel_id(i);
        if ( ! ( m_hec_idhelper->is_lar_hec( chid )  ) ) continue;
        Identifier SCID = scidtool->offlineToSuperCellID(chid);
        if ( scidset.find(SCID) == scidset.end() )
                scidset.insert(SCID);
        else continue;
        HWIdentifier hwid = cabling->createSignalChannelID(chid);
        of1 << chid.get_identifier32().get_compact() << "\t0x" <<
                SCID.get_identifier32().get_compact() << "\t0x" <<
                hwid.get_identifier32().get_compact() ;
        Identifier regId = m_hec_idhelper->region_id( chid );
        IdentifierHash regHash = m_hec_idhelper->region_hash( regId );
        int samp = m_hec_idhelper->sampling( chid );
        int feedthrough = m_online_idhelper->feedthrough( hwid );
        int bar_ec = m_online_idhelper->barrel_ec( hwid );
        int pos_neg = m_online_idhelper->pos_neg( hwid );
        int slot = m_online_idhelper->slot( hwid );
        float etaG = m_hec_idhelper->etaGranularity(regHash);
        float phiG = m_hec_idhelper->phiGranularity(regHash);
        float eta0 = m_hec_idhelper->eta0(regHash);
        float phi0 = m_hec_idhelper->phi0(regHash);
        float eta = etaG*m_hec_idhelper->eta( chid ) + eta0;
        float phi = phiG*m_hec_idhelper->phi( chid ) + phi0;
        char etaChar[10];
        char phiChar[10];
        sprintf(etaChar,"%5.4f",eta);
        sprintf(phiChar,"%5.4f",phi);
        of1 << std::dec << "\t" << feedthrough << "\t" << slot;
        of1 << "\t" << bar_ec << "   " << pos_neg << "\t\t" << samp << "\t";
        of1 << etaChar << "  " << phiChar << "\t0x";
        HWIdentifier feb_id = m_online_idhelper->feb_Id(hwid);
        int sslot=1;
        int subtract=0;
        HWIdentifier sfeb_id = m_sonline_idhelper->feb_Id(bar_ec,pos_neg,feedthrough,sslot);
        if ( sslot_schannel_idx.find(sfeb_id) == sslot_schannel_idx.end() )
                sslot_schannel_idx[sfeb_id]=0;
        else sslot_schannel_idx[sfeb_id]++;
        if ( (feedthrough==6) && (bar_ec==1) && (slot>9) ) {
                sfeb_id = m_sonline_idhelper->feb_Id(bar_ec,pos_neg,feedthrough,sslot+1);
                subtract=192;
        }
        HWIdentifier shwid = m_sonline_idhelper->channel_Id(sfeb_id,sslot_schannel_idx[sfeb_id]-subtract);
        unsigned int onl_hash = m_sonline_idhelper->channel_Hash( shwid ).value();
        if ( onl_hash > max_onl_hash ) max_onl_hash = onl_hash;
        if ( onl_hash < min_onl_hash ) min_onl_hash = onl_hash;
        unsigned int off_hash = m_scell_idhelper->calo_cell_hash( SCID ).value();
        if ( off_hash > max_off_hash ) max_off_hash = off_hash;
        if ( off_hash < min_off_hash ) min_off_hash = off_hash;
        of1 << std::hex;
        of1 << feb_id.get_identifier32().get_compact();
        of1 << "\t0x" << shwid.get_identifier32().get_compact();
        of1 << " " << m_online_idhelper->channel_name(hwid) << " " << m_sonline_idhelper->channel_name(shwid);
        of1 << std::dec;
        of1 << " " << onl_hash << " " << off_hash;
        of1 << std::endl;
 
        OrderOffHash_OnlID[m_scell_idhelper->calo_cell_hash( SCID ).value()]  =  shwid.get_identifier32().get_compact();
        OrderOnlHash_OffID[m_sonline_idhelper->channel_Hash( shwid ).value()]  =  SCID.get_identifier32().get_compact();
    }
 
    channel_size = m_fcal_idhelper->channel_hash_max();
    min_onl_hash = 999999;
    max_onl_hash = 0;
    min_off_hash = 999999;
    max_off_hash = 0;
    std::ofstream of3("AllChannels_FCAL.txt");
 
    of3 << "Off ID\t\tSCID\t\tOnl ID\t\tFT\tslot\tB-E pos_neg\tSamp\teta\tphi\tFEB_ID\t\tSHWID\t" << std::endl;
    for(size_t i = 0; i < channel_size ; i++) {
        Identifier chid = m_fcal_idhelper->channel_id(i);
        if ( ! ( m_fcal_idhelper->is_lar_fcal( chid )  ) ) continue;
        Identifier SCID = scidtool->offlineToSuperCellID(chid);
        if ( scidset.find(SCID) == scidset.end() )
                scidset.insert(SCID);
        else continue;
        HWIdentifier hwid = cabling->createSignalChannelID(chid);
        of3 << chid.get_identifier32().get_compact() << "\t0x" <<
                SCID.get_identifier32().get_compact() << "\t0x" <<
                hwid.get_identifier32().get_compact() ;
        int samp = 0;
        int feedthrough = m_online_idhelper->feedthrough( hwid );
        int bar_ec = m_online_idhelper->barrel_ec( hwid );
        int pos_neg = m_online_idhelper->pos_neg( hwid );
        int slot = m_online_idhelper->slot( hwid );
        of3 << std::dec << "\t" << feedthrough << "\t" << slot;
        of3 << "\t" << bar_ec << "   " << pos_neg << "\t\t" << samp << "\t";
        HWIdentifier feb_id = m_online_idhelper->feb_Id(hwid);
        int sslot=1;
        HWIdentifier sfeb_id = m_sonline_idhelper->feb_Id(bar_ec,pos_neg,feedthrough,sslot);
        if ( (feedthrough==6) && (bar_ec==1) && (slot>9) ) {
                sfeb_id = m_sonline_idhelper->feb_Id(bar_ec,pos_neg,feedthrough,sslot+1);
        }
        if ( sslot_schannel_idx.find(sfeb_id) == sslot_schannel_idx.end() )
                sslot_schannel_idx[sfeb_id]=0;
        else sslot_schannel_idx[sfeb_id]++;
        HWIdentifier shwid = m_sonline_idhelper->channel_Id(sfeb_id,sslot_schannel_idx[sfeb_id]);
        unsigned int onl_hash = m_sonline_idhelper->channel_Hash( shwid ).value();
        if ( onl_hash > max_onl_hash ) max_onl_hash = onl_hash;
        if ( onl_hash < min_onl_hash ) min_onl_hash = onl_hash;
        unsigned int off_hash = m_scell_idhelper->calo_cell_hash( SCID ).value();
        if ( off_hash > max_off_hash ) max_off_hash = off_hash;
        if ( off_hash < min_off_hash ) min_off_hash = off_hash;
        of3 << std::hex;
        of3 << feb_id.get_identifier32().get_compact();
        of3 << "\t0x" << shwid.get_identifier32().get_compact();
        of3 << " " << m_online_idhelper->channel_name(hwid) << " " << m_sonline_idhelper->channel_name(shwid);
        of3 << std::dec;
        of3 << " " << onl_hash << " " << off_hash;
        of3 << std::endl;
 
        OrderOffHash_OnlID[m_scell_idhelper->calo_cell_hash( SCID ).value()]  =  shwid.get_identifier32().get_compact();
        OrderOnlHash_OffID[m_sonline_idhelper->channel_Hash( shwid ).value()]  =  SCID.get_identifier32().get_compact();
    }
 
    of3 << "Hash check.  Onl : " << min_onl_hash << " " << max_onl_hash;
    of3 << ";   Off : " << min_off_hash << " " << max_off_hash << std::endl;;
    of3.close();
 
 
 
    const uint32_t onlHashMax=m_sonline_idhelper->channelHashMax(); 
    coral::AttributeListSpecification *spec_onOff = new coral::AttributeListSpecification();
    spec_onOff->extend("OnlineHashToOfflineId", "blob");
    spec_onOff->extend<unsigned>("version");
    std::unique_ptr<AthenaAttributeList> al_onOff = std::make_unique<AthenaAttributeList>(*spec_onOff);
    coral::Blob& blobOnOff=(*al_onOff)["OnlineHashToOfflineId"].data<coral::Blob>();
    (*al_onOff)["version"].setValue(0U);
    blobOnOff.resize(onlHashMax*sizeof(uint32_t));
    uint32_t* pBlobOnOff=static_cast<uint32_t*>(blobOnOff.startingAddress());
    unsigned nConn=0;
 
    const uint32_t emptyId=Identifier().get_identifier32().get_compact();
    for(size_t ii=0;ii<onlHashMax;ii++) {
      if (OrderOnlHash_OffID[ii] != 0) {
    pBlobOnOff[ii]=OrderOnlHash_OffID[ii];
    nConn++;
      }
      else
    pBlobOnOff[ii]=emptyId;
    }
 
    ATH_MSG_INFO ( "HashMax=" << onlHashMax << ", connected=" << nConn );
 
    ATH_CHECK( detStore()->record(std::move(al_onOff),"/LAR/IdentifierOfl/OnOffIdMap_SC") );
 
    hashes << "idx \t Off2OnlId \t Onl2OffId" << std::endl;
    for(size_t ii=0;ii<40000;ii++)
      if ( (OrderOffHash_OnlID[ii] != 0) || ( OrderOnlHash_OffID[ii] != 0 ) )
    hashes << std::dec << ii << std::hex << " \t " << OrderOffHash_OnlID[ii]  << " \t\t " << OrderOnlHash_OffID[ii]  << std::endl;
    hashes.close();
 
    return StatusCode::SUCCESS;
}

fix14()

StatusCode FixLArElecCalib::fix14

(

const LArOnOffIdMapping *

cabling

)

Definition at line 2071 of file FixLArElecCalib.cxx.

                                                                  {
    
    ATH_MSG_INFO ( " in fix14() " );
 
    // Fix14 is for filling the  LArPileupAverage  from ntuple
 
    const ILArfSampl* larfSampl = nullptr;
    ATH_CHECK( detStore()->retrieve(larfSampl,"") );
    // Will try to regenerate from scratch
   // Create new container 
   std::unique_ptr<LArMinBiasAverageMC> minbias_av = std::make_unique<LArMinBiasAverageMC>();
   ATH_CHECK( minbias_av->setGroupingType("Single", msg()) );
   ATH_CHECK( minbias_av->initialize() );
   //
   std::unique_ptr<TFile> fin= std::make_unique<TFile>(m_infile.value().c_str());
   TTree *tin=dynamic_cast<TTree*>(fin->Get("m_tree"));
   if (!tin) {
     ATH_MSG_ERROR("Can't read tree m_tree");
     return StatusCode::FAILURE;
   }
   int           ncell;
   std::vector<int> identifier(2862);
   std::vector<int> layer(2862);
   std::vector<int> region(2862);
   std::vector<int> ieta(2862);
   std::vector<float> eta(2862);
   std::vector<double> average(2862);
   std::vector<double> rms(2862);
   TBranch        *b_ncell;   
   TBranch        *b_identifier;   
   TBranch        *b_layer;   
   TBranch        *b_region;   
   TBranch        *b_ieta;   
   TBranch        *b_eta;   
   TBranch        *b_average;   
   TBranch        *b_rms;   
   tin->SetMakeClass(1);
   tin->SetBranchAddress("ncell", &ncell, &b_ncell);
   tin->SetBranchAddress("identifier", identifier.data(), &b_identifier);
   tin->SetBranchAddress("layer", layer.data(), &b_layer);
   tin->SetBranchAddress("region", region.data(), &b_region);
   tin->SetBranchAddress("ieta", ieta.data(), &b_ieta);
   tin->SetBranchAddress("eta", eta.data(), &b_eta);
   tin->SetBranchAddress("average", average.data(), &b_average);
   tin->SetBranchAddress("rms", rms.data(), &b_rms);
   tin->GetEntry(0);
 
 
   for(int icell=0; icell<ncell; ++icell)  {
 
       Identifier32 id32(identifier[icell]); 
       Identifier id(id32);
       HWIdentifier hid = cabling->createSignalChannelID(id);
       float fsampl = larfSampl->FSAMPL(hid);
       minbias_av->set(hid, 6.31*average[icell]/fsampl);
 
     }
 
     ATH_MSG_INFO(" number of channels in intuple ="<<ncell);
 
     ATH_MSG_INFO ( "Stored container " << minbias_av->totalNumberOfConditions() << " conditions, key LArPileupAverage " );
     ATH_CHECK( detStore()->record(std::move(minbias_av),"LArPileupAverage") );
     ATH_CHECK( detStore()->symLink(minbias_av.get(), dynamic_cast<ILArMinBiasAverage*>(minbias_av.get())) );
 
     return StatusCode::SUCCESS;
}

fix18()

StatusCode FixLArElecCalib::fix18

(

const LArCalibLineMapping *

clmap

)

Definition at line 2235 of file FixLArElecCalib.cxx.

                                                                    {
 
    ATH_MSG_INFO ( " in fix18() " );
 
    const uint32_t onlHashMax=m_online_idhelper->channelHashMax();
 
    coral::AttributeListSpecification* spec_calib = new coral::AttributeListSpecification();
    spec_calib->extend("OnlineHashToCalibIds", "blob");
    spec_calib->extend<unsigned>("version");
    std::unique_ptr<AthenaAttributeList> al_calib = std::make_unique<AthenaAttributeList>(*spec_calib);
    coral::Blob& blobCalib=(*al_calib)["OnlineHashToCalibIds"].data<coral::Blob>();
    (*al_calib)["version"].setValue(0U);
    blobCalib.resize(onlHashMax*sizeof(uint32_t)*4); //Bigger than necessary 
 
    spec_calib->release();
    // cppcheck-suppress memleak
    spec_calib = nullptr;
 
    uint32_t* pBlobCalib=static_cast<uint32_t*>(blobCalib.startingAddress());
    size_t calibIndex=0;
 
 
    // loop over all online hashes
    for (unsigned i=0;i<onlHashMax;++i) {
        const HWIdentifier hwid = m_online_idhelper->channel_Id(IdentifierHash(i));
 
        const std::vector<HWIdentifier>& calibIDs=cabling->calibSlotLine(hwid);
        const size_t nCalibLines=calibIDs.size();
 
        if (m_online_idhelper->isEMBchannel(hwid) &&  m_online_idhelper->pos_neg(hwid) == 1 && m_online_idhelper->feedthrough(hwid) == 0 ) { // EMB-A FT 0
           if(nCalibLines > 1) { //should not be in our channels
              ATH_MSG_ERROR("Wrong number of CL in our channels");
              return StatusCode::FAILURE;
           }
           if(nCalibLines==0) {
             pBlobCalib[calibIndex++]=0;
           } else {
              const HWIdentifier cmodule = m_online_idhelper->calib_module_Id(calibIDs[0]);
              const HWIdentifier newcl = m_online_idhelper->calib_channel_Id(cmodule,  m_online_idhelper->channel(hwid) );       
              if(!m_online_idhelper->isCalibration(newcl)) {
                  ATH_MSG_ERROR("Something wrong, new CL not a calibration");
                  ATH_MSG_ERROR("Channel: "<<hwid.get_identifier32().get_compact()<<" old CL: "<< calibIDs[0].get_identifier32().get_compact()<<" new CL: "<<newcl.get_identifier32().get_compact());
                 return StatusCode::FAILURE;
              }
              ATH_MSG_INFO("Channel: "<<hwid.get_identifier32().get_compact()<<" old CL: "<< calibIDs[0].get_identifier32().get_compact()<<" new CL: "<<newcl.get_identifier32().get_compact());
              pBlobCalib[calibIndex++]=1;
              pBlobCalib[calibIndex++]=newcl.get_identifier32().get_compact();
           }
        } else {
           pBlobCalib[calibIndex++]=nCalibLines;
           for(uint32_t iCalib=0;iCalib<nCalibLines;++iCalib) 
             pBlobCalib[calibIndex++]=calibIDs[iCalib].get_identifier32().get_compact();
        }
    }
    blobCalib.resize(calibIndex*sizeof(uint32_t)); //Size down to actual size
    ATH_MSG_INFO( "BlobSize CalibId:" << calibIndex);
 
    // and now record the blob to SG
    ATH_CHECK(detStore()->record(std::move(al_calib),"/LAR/Identifier/CalibIdMap_EMF"));
 
    return StatusCode::SUCCESS;
}

fix2()

StatusCode FixLArElecCalib::fix2

(

const LArOnOffIdMapping *

cabling

)

Definition at line 295 of file FixLArElecCalib.cxx.

                                                                 {
 
    ATH_MSG_INFO ( " in fix2() " );
 
    // Fix2 is for updating the FCAL conditions data after IdFix7
    // Input should be MC Conditions data with DetDescrVersion=ATLAS-DC3-05
 
    const LArFCAL_ID* fcal_idhelper = nullptr;
    ATH_CHECK( detStore()->retrieve(fcal_idhelper) );
    
    const LArOnlineID* online_idhelper = nullptr;
    ATH_CHECK( detStore()->retrieve(online_idhelper) );
    
    // retrieve DetDescrManager 
    SmartIF<IToolSvc> toolSvc{Gaudi::svcLocator()->service("ToolSvc")};
    ATH_CHECK(toolSvc.isValid());
    
    LArDAC2uAMC * dac2ua = nullptr;
    ATH_CHECK( detStore()->retrieve(dac2ua) );
    
    LAruA2MeVMC * ua2mev = nullptr;
    ATH_CHECK( detStore()->retrieve(ua2mev) );
    
    LArRampMC * ramp = nullptr;
    ATH_CHECK( detStore()->retrieve(ramp) );
    
    LArShape32MC * shape = nullptr;
    ATH_CHECK( detStore()->retrieve(shape) );
    
    LArNoiseMC * noise = nullptr;
    ATH_CHECK( detStore()->retrieve(noise) );
    
    LArfSamplMC * fsampl = nullptr;
    ATH_CHECK( detStore()->retrieve(fsampl) );
    
    LArMinBiasMC * minbias = nullptr;
    ATH_CHECK( detStore()->retrieve(minbias) );
    
    LArAutoCorrMC * ac = nullptr;
    ATH_CHECK( detStore()->retrieve(ac) );
    
    
    for( unsigned int gain=0;gain<3;++gain)
      {
    // loop over all the old data
    LArRampMC::ConditionsMapIterator  it = ramp->begin(gain);
    LArRampMC::ConditionsMapIterator  it_e = ramp->end(gain);
    
    int n=0;
    for (; it!=it_e;++it)
      {
        HWIdentifier hid = it.channelId(); 
        if( (*it).isEmpty() ) continue;  
        if(cabling->isOnlineConnected(hid)){
          continue;
        }else
          {
        ATH_MSG_DEBUG(" unconnected channel" 
                              << online_idhelper->print_to_string(hid) );
        ac->get(hid,gain) = LArAutoCorrComplete::LArCondObj(); 
        ramp->get(hid,gain) = LArRampComplete::LArCondObj(); 
        shape->get(hid,gain) = LArShape32MC::LArCondObj(); 
        noise->get(hid,gain) = LArNoiseComplete::LArCondObj(); 
        if(gain==0){
          dac2ua->get(hid,gain) = LArDAC2uAComplete::LArCondObj(); 
          ua2mev->get(hid,gain) = LAruA2MeVComplete::LArCondObj(); 
          fsampl->get(hid,gain) = LArfSamplComplete::LArCondObj(); 
          minbias->get(hid,gain) = LArMinBiasComplete::LArCondObj(); 
        }
        ++n ; 
          }
        
      }
        ATH_MSG_DEBUG("  Gain="<<gain<<
                      " Number of entries removed =  " <<n );
      }
    
 
    HWIdentifier hid_mod[3]; 
    hid_mod[0] = online_idhelper->channel_Id(1,1,6,1,33); 
    hid_mod[1] = online_idhelper->channel_Id(1,1,6,10,12); 
    hid_mod[2] = online_idhelper->channel_Id(1,1,6,14,12); 
 
    // loop over all FCAL channels 
    std::vector<Identifier>::const_iterator it= fcal_idhelper->fcal_begin();
    std::vector<Identifier>::const_iterator it_e= fcal_idhelper->fcal_end();
    int n = 0; 
    for(;it!=it_e; ++it)
    {
      Identifier id = *it; 
      int pn = fcal_idhelper->pos_neg(id);
      if(pn!=2) continue; 
      int phi = fcal_idhelper->phi(id);
      if (phi>7) continue; 
 
      int module = fcal_idhelper->module(id)-1;
 
      HWIdentifier hid = cabling->createSignalChannelID(id);
 
      for(unsigned int gain = 0;gain<3;++gain){
        
        LArRampComplete::LArCondObj& rampP = ramp->get(hid,gain) ;
        if (!rampP.isEmpty()) continue ;
 
        ATH_MSG_DEBUG(" channel needs repair " 
                              << online_idhelper->print_to_string(hid) );
        ATH_MSG_DEBUG ( fcal_idhelper->print_to_string(id) );
        ATH_MSG_DEBUG ( "module = "<<module );
 
        ++n;
 
        LArRampComplete::LArCondObj ramp_std = ramp->get(hid_mod[module],gain) ;
        ramp->setPdata(hid,ramp_std,gain); 
 
        LArAutoCorrComplete::LArCondObj ac_std = ac->get(hid_mod[module],gain) ;
        ac->setPdata(hid,ac_std,gain); 
 
        LArShape32MC::LArCondObj shape_std = shape->get(hid_mod[module],gain) ;
        shape->setPdata(hid,shape_std,gain); 
 
        LArNoiseComplete::LArCondObj noise_std = noise->get(hid_mod[module],gain) ;
        noise->setPdata(hid,noise_std,gain); 
 
        if(gain==0){
 
         LAruA2MeVComplete::LArCondObj ua2mev_std = ua2mev->get(hid_mod[module],gain) ;
         ua2mev->setPdata(hid,ua2mev_std,gain); 
 
         LArDAC2uAComplete::LArCondObj dac2ua_std = dac2ua->get(hid_mod[module],gain) ;
         dac2ua->setPdata(hid,dac2ua_std,gain); 
 
         LArfSamplComplete::LArCondObj fsampl_std = fsampl->get(hid_mod[module],gain) ;
         fsampl->setPdata(hid,fsampl_std,gain); 
 
         LArMinBiasComplete::LArCondObj minbias_std = minbias->get(hid_mod[module],gain) ;
         minbias->setPdata(hid,minbias_std,gain); 
 
        }
 
    }
    }
    
    ATH_MSG_DEBUG( " Number of entries fixed " <<n );
    return StatusCode::SUCCESS;    
}

initialize()

StatusCode FixLArElecCalib::initialize ( )

overridevirtual

Definition at line 125 of file FixLArElecCalib.cxx.

                                       {
  ATH_MSG_INFO ( " in initialize " );
  
  ATH_CHECK( detStore()->retrieve(m_em_idhelper) );
  ATH_CHECK( detStore()->retrieve(m_hec_idhelper) );
  ATH_CHECK( detStore()->retrieve(m_fcal_idhelper) );
  ATH_CHECK( detStore()->retrieve(m_sem_idhelper) );
  ATH_CHECK( detStore()->retrieve(m_shec_idhelper) );
  ATH_CHECK( detStore()->retrieve(m_online_idhelper) );
  ATH_CHECK( detStore()->retrieve(m_sonline_idhelper) );
  ATH_CHECK( detStore()->retrieve(m_scell_idhelper) );
 
  ATH_CHECK( m_cablingKey.initialize() );
  ATH_CHECK( m_CLKey.initialize() );
 
  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.

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);
  }

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.

print_object() [1/5]

void FixLArElecCalib::print_object ( const std::string & msg, const LArAutoCorrMC::LArCondObj & obj )

private

Definition at line 1301 of file FixLArElecCalib.cxx.

{
  if( obj.isEmpty()){
    ATH_MSG_INFO(" LArAutoCorrMC " << s << " is empty" );
  }else 
    {
      msg()<<MSG::DEBUG<<" LArAutoCorrMC" << s ;
      for (unsigned int i =0 ; i<obj.m_vAutoCorr.size();++i)
    msg()<< " " << obj.m_vAutoCorr[i];
      msg()<<endmsg; 
    }
  return ; 
}

print_object() [2/5]

void FixLArElecCalib::print_object ( const std::string & msg, const LArNoiseMC::LArCondObj & obj )

private

Definition at line 1281 of file FixLArElecCalib.cxx.

{
  if( obj.isEmpty()){
    ATH_MSG_INFO(" LArNoiseMC " << msg << " is empty" );
  }else 
    ATH_MSG_DEBUG(" LArNoiseMC" << msg << obj.m_Noise );
  return ; 
}

print_object() [3/5]

void FixLArElecCalib::print_object ( const std::string & msg, const LArRampMC::LArCondObj & obj )

private

Definition at line 1328 of file FixLArElecCalib.cxx.

{
  if( obj.isEmpty()){
    ATH_MSG_INFO(" LArRampMC " << s << " is empty" );
  }else 
    {
      msg()<<MSG::DEBUG<<" LArRampMC" << s ;
      for (unsigned int i =0 ; i<obj.m_vRamp.size();++i)
    msg()<< " " << obj.m_vRamp[i];
      msg()<<endmsg; 
    }
  return ; 
}

print_object() [4/5]

void FixLArElecCalib::print_object ( const std::string & msg, const LArShape32MC::LArCondObj & obj )

private

Definition at line 1357 of file FixLArElecCalib.cxx.

{
  if( obj.isEmpty()){
    ATH_MSG_INFO(" LArShape32MC " << s << " is empty" );
  }else 
    {
      msg()<<MSG::DEBUG<<" LArShape" << s ;
      for (unsigned int i =0 ; i<obj.m_vShape.size();++i)
    msg()<< " " << obj.m_vShape[i];
      msg()<<endmsg; 
 
      msg()<<MSG::DEBUG<<" LArShapeDer" << s ;
      for (unsigned int i =0 ; i<obj.m_vShapeDer.size();++i)
    msg()<< " " << obj.m_vShapeDer[i];
      msg()<<endmsg; 
    }
  return ; 
}

print_object() [5/5]

void FixLArElecCalib::print_object ( const std::string & msg, const LArSingleFloatP & obj )

private

Definition at line 1401 of file FixLArElecCalib.cxx.

{
  if( obj.isEmpty()){
    ATH_MSG_INFO(" LArSingleFloatP " << msg << " is empty" );
  }else
    ATH_MSG_DEBUG(" LArSingleFloatP " << msg << obj.m_data );
  return ;
}

ReadFile()

StatusCode FixLArElecCalib::ReadFile ( const std::string & filename, const LArOnOffIdMapping * cabling, bool EM, bool withGain, int nvar )

private

Definition at line 1142 of file FixLArElecCalib.cxx.

                                                                                                                                   {
 
   std::ifstream infile(filename.c_str() ) ; 
 
   if(! infile.good() ) 
     {
       ATH_MSG_ERROR(" fail to open file "<<filename );
       return StatusCode::FAILURE; 
     }
 
   ATH_MSG_INFO(" Opened file "<<filename );
 
   m_cache[0].clear();
   m_cache[1].clear();
   m_cache[2].clear();
 
   char s[200];
   infile.getline(s,200);
   ATH_MSG_INFO(" first line of the file  "<<s);
 
   int   det=2;
   int   samp,reg,eta;
   int first; 
   while ( infile>>first )
     {
       if (EM) {
     det = first;
     infile>>samp>>reg>>eta;
       }else
     {
       samp=first;
       infile>>reg>>eta;
     }
 
       int gain=0;
       if(withGain) infile>>gain ; 
       std::vector<float> vfl;
       float x;
       
       for (int i=0;i<nvar;++i)
     { 
       infile>>x;
       vfl.push_back(x);
     }
    ATH_MSG_DEBUG(" det,samp,reg,eta,values="
                      <<det<<" " 
                      <<samp<<" " 
                      <<reg<<" " 
                      <<eta<<" "  );
 
    Identifier id ; 
    if (EM)
    {
      if ( det==1 && samp==1 && reg==0 && eta==0 ){
       // eta=0 for strip, not connected, but keep it
           // Removed disconnected channels: 03/2016 RDS 
           ATH_MSG_DEBUG(" disconnected strip ");
      }else
        id = m_em_idhelper->channel_id(det,samp,reg,eta,0); 
    }else //HEC
      {
        id = m_hec_idhelper->channel_id(2,samp,reg,eta,0); 
      }
    HWIdentifier hid = cabling->createSignalChannelID(id);
 
        if (gain >= 0 && gain < 3)
          m_cache[gain].push_back(ROW_t(hid,vfl));
     }
 
   return StatusCode::SUCCESS; 
}

ReadFileAll()

StatusCode FixLArElecCalib::ReadFileAll ( const std::string & filename, const LArOnOffIdMapping * cabling, bool withGain, int nvar )

private

Definition at line 1214 of file FixLArElecCalib.cxx.

                                                                                                                             {
 
   std::ifstream infile(filename.c_str() ) ; 
 
   if(! infile.good() ) 
     {
       ATH_MSG_ERROR(" fail to open file "<<filename );
       return StatusCode::FAILURE; 
     }
 
   ATH_MSG_INFO(" Opened file "<<filename );
 
   m_cache[0].clear();
   m_cache[1].clear();
   m_cache[2].clear();
 
   char s[200];
   infile.getline(s,200);
   ATH_MSG_INFO(" first line of the file  "<<s);
 
   int   det=0,samp=0,reg=0,eta=0;
   int first=0;
   while ( infile>>first>>samp>>reg>>eta ) {
       Identifier id ; 
       int gain=0;
       float x;
       if(first <= 2) { // Calo 0,1,2 is EM
          det = first+1;
      if ( det==1 && samp==1 && reg==0 && eta==0 ){
       // eta=0 for strip, not connected, but keep it
           // Removed disconnected channels: 03/2016 RDS 
           ATH_MSG_DEBUG(" disconnected strip ");
       // id = m_em_idhelper->disc_channel_id(det,samp,reg,eta,0); 
      }else
        id = m_em_idhelper->channel_id(det,samp,reg,eta,0); 
       } else if (first == 3) { // HEC
      id = m_hec_idhelper->channel_id(2,samp,reg,eta,0); 
       } else if (first == 4) { // FCAL
          id = m_fcal_idhelper->channel_id(2,samp+1,eta,0);
       } else {
          ATH_MSG_WARNING(" Wrong calo number "<<first<<" skipping !!!");
          if(withGain) infile>>gain ; 
          for (int i=0;i<nvar;++i) infile>>x;
          continue;
       }
       if(withGain) infile>>gain ; 
       std::vector<float> vfl;
       
       for (int i=0;i<nvar;++i)
     { 
       infile>>x;
       vfl.push_back(x);
     }
    ATH_MSG_DEBUG(" first, det,samp,reg,eta,values="
                      <<first<<"  " <<det<<" " <<samp<<" " <<reg<<" " <<eta<<" "  );
 
    HWIdentifier hid = cabling->createSignalChannelID(id);
 
        if (gain >= 0 && gain < 3) m_cache[gain].push_back(ROW_t(hid,vfl));
        else {
           ATH_MSG_WARNING(" Wrong gain " <<gain<<" skipping !");
        }
     }// while 
 
   return StatusCode::SUCCESS; 
}

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();
  }

set_object() [1/5]

void FixLArElecCalib::set_object ( LArAutoCorrMC::LArCondObj & obj, const std::vector< float > & v )

private

Definition at line 1315 of file FixLArElecCalib.cxx.

{
  if (v.size()<4 )
    {
      ATH_MSG_ERROR( "for LArAutoCorrMC, size of vector = "<< v.size()<<" is less then 4" );
      return ; 
    }
 
  obj.m_vAutoCorr.resize(4);
  std::copy_n(v.begin(), 4, obj.m_vAutoCorr.begin());
  return;
} 

set_object() [2/5]

void FixLArElecCalib::set_object ( LArNoiseMC::LArCondObj & obj, const std::vector< float > & v )

private

Definition at line 1290 of file FixLArElecCalib.cxx.

{
  if (v.size()!=1)
    {
      ATH_MSG_ERROR ("for LArNoiseMC, size of vector = "<< v.size() <<" differs from one");
      return ; 
    }
  obj.m_Noise = v[0]; 
  return;
} 

set_object() [3/5]

void FixLArElecCalib::set_object ( LArRampMC::LArCondObj & obj, const std::vector< float > & v )

private

Definition at line 1342 of file FixLArElecCalib.cxx.

{
  if (v.size()!=1 )
    {
      ATH_MSG_ERROR ("for LArRampMC, size of vector = "<< v.size());
      return ; 
    }
  obj.m_vRamp.resize(3);
  obj.m_vRamp[0]=0;
  obj.m_vRamp[1]=v[0]; 
  obj.m_vRamp[2]=0; 
 
  return;
} 

set_object() [4/5]

void FixLArElecCalib::set_object ( LArShape32MC::LArCondObj & obj, const std::vector< float > & v )

private

Definition at line 1376 of file FixLArElecCalib.cxx.

{
  
  if (v.size()!=64 && v.size()!=32 )
    {
      ATH_MSG_ERROR ("for LArShape32MC, size of vector = "<< v.size());
      return ; 
    }
 
  unsigned int size = 32; 
  obj.m_vShape.resize(size);
  obj.m_vShapeDer.resize(size);
 
  for(unsigned int i=0;i<size;++i){
    obj.m_vShape[i]=v[i];
    if(v.size() == 64 ) obj.m_vShapeDer[i]=v[i+size]; else obj.m_vShapeDer[i]=0.;
  }
 
  return;
} 

set_object() [5/5]

void FixLArElecCalib::set_object ( LArSingleFloatP & obj, const std::vector< float > & v )

private

Definition at line 1410 of file FixLArElecCalib.cxx.

{
  if (v.size()!=1)
    {
      ATH_MSG_ERROR( "for LArSingleFloatP, size of vector = "<< v.size() );
      return ;
    }
  obj.m_data = v[0];
  return;
}

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.

update_DAC2uA()

StatusCode FixLArElecCalib::update_DAC2uA ( const std::string & em_filename, const std::string & hec_filename )

private

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);
      }
    }
  }

Member Data Documentation

m_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> FixLArElecCalib::m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}

private

Definition at line 67 of file FixLArElecCalib.h.

{this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"};

m_cache

VROW_t FixLArElecCalib::m_cache[3]

private

Definition at line 138 of file FixLArElecCalib.h.

m_CLKey

SG::ReadCondHandleKey<LArCalibLineMapping> FixLArElecCalib::m_CLKey {this, "CalibLineKey", "LArCalibLineMap", "calib line key"}

private

Definition at line 68 of file FixLArElecCalib.h.

{this, "CalibLineKey", "LArCalibLineMap", "calib line key"};

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_em_idhelper

const LArEM_ID* FixLArElecCalib::m_em_idhelper

private

Definition at line 123 of file FixLArElecCalib.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_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_fcal_idhelper

const LArFCAL_ID* FixLArElecCalib::m_fcal_idhelper

private

Definition at line 125 of file FixLArElecCalib.h.

m_fixFlag

IntegerProperty FixLArElecCalib::m_fixFlag {this, "FixFlag", 1, "which fix to apply"}

private

Definition at line 70 of file FixLArElecCalib.h.

{this, "FixFlag", 1, "which fix to apply"};

m_g4Phys

StringProperty FixLArElecCalib::m_g4Phys {this, "G4Phys", "", "which physics list to use"}

private

Definition at line 71 of file FixLArElecCalib.h.

{this, "G4Phys", "", "which physics list to use"};

m_hec_idhelper

const LArHEC_ID* FixLArElecCalib::m_hec_idhelper

private

Definition at line 124 of file FixLArElecCalib.h.

m_infile

StringProperty FixLArElecCalib::m_infile {this, "InputFile", "", "name of inpput file"}

private

Definition at line 72 of file FixLArElecCalib.h.

{this, "InputFile", "", "name of inpput file"};

m_online_idhelper

const LArOnlineID* FixLArElecCalib::m_online_idhelper

private

Definition at line 126 of file FixLArElecCalib.h.

m_scell_idhelper

const CaloCell_SuperCell_ID* FixLArElecCalib::m_scell_idhelper

private

Definition at line 130 of file FixLArElecCalib.h.

m_sem_idhelper

const LArEM_SuperCell_ID* FixLArElecCalib::m_sem_idhelper

private

Definition at line 127 of file FixLArElecCalib.h.

m_shec_idhelper

const LArHEC_SuperCell_ID* FixLArElecCalib::m_shec_idhelper

private

Definition at line 128 of file FixLArElecCalib.h.

m_sonline_idhelper

const LArOnline_SuperCellID* FixLArElecCalib::m_sonline_idhelper

private

Definition at line 129 of file FixLArElecCalib.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:

• FixLArElecCalib.h
• FixLArElecCalib.cxx