LArCompleteToFlat Class Reference

#include <LArCompleteToFlat.h>

Inheritance diagram for LArCompleteToFlat:

Collaboration diagram for LArCompleteToFlat:

Public Member Functions
	LArCompleteToFlat (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor with parameters: More...
virtual	~LArCompleteToFlat ()
	Destructor: More...
StatusCode	initialize ()
StatusCode	execute ()
StatusCode	finalize ()
virtual StatusCode	stop ()
virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
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. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
	LArCompleteToFlat ()
	Default constructor: More...
CondAttrListCollection *	singleFloatFlat (const char *blobName, const LArConditionsContainer< LArSingleFloatP > *input, const std::string &outputName, const unsigned nGain, const bool withFCAL=true)
CondAttrListCollection *	DAC2uAFlat (const ILArDAC2uA *input, const std::string &outputName)
CondAttrListCollection *	uA2MeVFlat (const ILAruA2MeV *input, const std::string &outputName)
CondAttrListCollection *	pedestalFlat (const ILArPedestal *input, const std::string &outputName)
CondAttrListCollection *	rampFlat (const ILArRamp *input, const std::string &outputName)
CondAttrListCollection *	ofcFlat (const ILArOFC *input, const std::string &outputName, const LArfSamplSC *weights=nullptr)
CondAttrListCollection *	shapeFlat (const LArShapeComplete *input, const std::string &outputName)
AthenaAttributeList *	DSPThresholdsFlat (const LArDSPThresholdsComplete *input, const std::string &outputName)
void	errIfConnected (const HWIdentifier chid, const int gain, const char *objName, const char *message=0) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
unsigned	m_hashMax
const LArOnlineID_Base *	m_onlineID
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKeySC {this,"CablingSCKey","LArOnOffIdMapSC","SG Key of LArOnOffIdMapping object"}
SG::ReadCondHandleKey< LArfSamplSC >	m_weightsKeySC {this,"WeightsSCKey","","SG Key of weights object"}
std::string	m_uA2MeVInput
	InputSGKeys. More...
std::string	m_DAC2uAInput
std::string	m_HVScaleCorrInput
std::string	m_PedestalInput
std::string	m_RampInput
std::string	m_MphysOverMcalInput
std::string	m_OFCInput
std::string	m_OFCCaliInput
std::string	m_ShapeInput
std::string	m_DSPThresholdsInput
std::string	m_nameOfSet
bool	m_isSC
bool	m_forceStop
bool	m_fakeEMBPSLowGain
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 32 of file LArCompleteToFlat.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

LArCompleteToFlat() [1/2]

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

Constructor with parameters:

Definition at line 41 of file LArCompleteToFlat.cxx.

                                         : 
  ::AthAlgorithm( name, pSvcLocator ),
  m_hashMax(0),
  m_onlineID(nullptr),
  m_isSC(false)
{
  declareProperty("isSC",m_isSC);
  declareProperty("uA2MeVInput",m_uA2MeVInput);//="LAruA2MeV");
  declareProperty("DAC2uAVInput",m_DAC2uAInput);//="LArDAC2uA");
  declareProperty("HVScaleCorrInput",m_HVScaleCorrInput);//="LArHVScaleCorr");
  declareProperty("PedestalInput",m_PedestalInput);//="Pedestal");
  declareProperty("RampInput",m_RampInput);//="LArRamp");
  declareProperty("MphysOverMcalInput",m_MphysOverMcalInput);//="LArMphysOverMcal");
  declareProperty("OFCInput",m_OFCInput);//="LArOFC");
  declareProperty("OFCCaliInput",m_OFCCaliInput);//="LArOFC");
  declareProperty("ShapeInput",m_ShapeInput);//="LArShape");
  declareProperty("DSPThresholdsInput",m_DSPThresholdsInput);//="LArDSPThresholds");
  declareProperty("NameOfSet",m_nameOfSet); // for DSPThreshold
 
  declareProperty("ForceStop",m_forceStop=true);
 
  declareProperty("FakeEMBPSLowGain",m_fakeEMBPSLowGain=false);
 
 
}

~LArCompleteToFlat()

LArCompleteToFlat::~LArCompleteToFlat ( )

virtualdefault

Destructor:

LArCompleteToFlat() [2/2]

LArCompleteToFlat::LArCompleteToFlat ( )

private

Default constructor:

Member Function Documentation

DAC2uAFlat()

CondAttrListCollection * LArCompleteToFlat::DAC2uAFlat ( const ILArDAC2uA *  input, const std::string &  outputName  )

private

Definition at line 554 of file LArCompleteToFlat.cxx.

                                                                                                          {
  coral::AttributeListSpecification* spec = new coral::AttributeListSpecification();
  spec->extend("DAC2uA", "blob");
  spec->extend<unsigned>("version");
  CondAttrListCollection* coll=new CondAttrListCollection(true);
  coral::AttributeList* attrList = new coral::AttributeList(*spec);
  (*attrList)["version"].setValue(0U);
  coral::Blob& blob=(*attrList)["DAC2uA"].data<coral::Blob>();
  blob.resize(m_hashMax*sizeof(float));
  float* pblob=static_cast<float*>(blob.startingAddress());
  for (unsigned hs=0;hs<m_hashMax;++hs) {
    const HWIdentifier chid=m_onlineID->channel_Id(hs);
    pblob[hs]=input->DAC2UA(chid);
  }
  coll->add(1,*attrList);
  //delete attrList;//???
  StatusCode sc=detStore()->record(coll,outputName);
  if (sc.isFailure()) {
    ATH_MSG_ERROR( "Failed to record CondAttrListCollection with key" << outputName );
    return nullptr;
  }
  return coll;
}

declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  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());
 
  }

declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > &  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; }

DSPThresholdsFlat()

AthenaAttributeList * LArCompleteToFlat::DSPThresholdsFlat ( const LArDSPThresholdsComplete *  input, const std::string &  outputName  )

private

Definition at line 603 of file LArCompleteToFlat.cxx.

                                                                                                                            {
 
  coral::AttributeListSpecification* spec = new coral::AttributeListSpecification();
  spec->extend("tQThr", "blob");
  spec->extend("samplesThr", "blob");
  spec->extend("trigSumThr","blob");
  //spec->extend<unsigned>("version");
  spec->extend("Name","string");
  
  coral::AttributeList* attrList = new coral::AttributeList(*spec);    
  //(*attrList)["version"].setValue(0U);
  (*attrList)["Name"].setValue(m_nameOfSet);
  coral::Blob& QBlob=(*attrList)["tQThr"].data<coral::Blob>();
  coral::Blob& SamplesBlob=(*attrList)["samplesThr"].data<coral::Blob>();
  coral::Blob& TrigBlob=(*attrList)["trigSumThr"].data<coral::Blob>();
 
  QBlob.resize(m_hashMax*sizeof(float));
  SamplesBlob.resize(m_hashMax*sizeof(float));
  TrigBlob.resize(m_hashMax*sizeof(float));
  float* ptQThr=static_cast<float*>(QBlob.startingAddress());
  float* pSamplesThr=static_cast<float*>(SamplesBlob.startingAddress());
  float* pTrigThr=static_cast<float*>(TrigBlob.startingAddress());
 
  for (unsigned hs=0;hs<m_hashMax;++hs) {
    const HWIdentifier chid=m_onlineID->channel_Id(hs);
    
    ptQThr[hs] = input->tQThr(chid);
    pSamplesThr[hs] = input->samplesThr(chid);
    pTrigThr[hs] = input->trigSumThr(chid);
 
     ATH_MSG_INFO( "hwid: "<<chid.getString()<<" "<<hs<<" | "<<ptQThr[hs]<<" : "<<pSamplesThr[hs]<<" | "<<pTrigThr[hs] );
  }//end loop over hash ids
 
  AthenaAttributeList* coll=new AthenaAttributeList(*attrList);
    
  StatusCode sc=detStore()->record(coll,outputName);
  if (sc.isFailure()) {
    ATH_MSG_ERROR( "Failed to record AthenaAttributeList DSPThresholds with key " << outputName );
    return nullptr;
  }
 
  return coll;
}

errIfConnected()

void LArCompleteToFlat::errIfConnected ( const HWIdentifier  chid, const int  gain, const char *  objName, const char *  message = 0  ) const

private

Definition at line 898 of file LArCompleteToFlat.cxx.

                                                                                                                             {
 
  const LArOnOffIdMapping* cabling(nullptr);
  if(m_isSC){
    SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKeySC};
    cabling=*cablingHdl;
  }else{
    SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey};
    cabling=*cablingHdl;
  }
  if(!cabling) {
     ATH_MSG_ERROR( "Do not have cabling mapping from key " << m_cablingKey.key() );
     return;
  }
 
  if (cabling->isOnlineConnected(chid)) {
    if (gain!=2 || !m_onlineID->isEMBPS(chid)) { //No LG Presampler calibration
      ATH_MSG_ERROR( "No valid " << objName << " found for channel "  << m_onlineID->channel_name(chid) << ", gain " << gain << ". ");
      if (message) ATH_MSG_ERROR( message );
      ATH_MSG_ERROR( " Filling with default value." );
    }
  }
  }

evtStore() [1/2]

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

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode LArCompleteToFlat::execute ( )

inline

Definition at line 47 of file LArCompleteToFlat.h.

{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()

StatusCode LArCompleteToFlat::finalize ( )

inline

Definition at line 48 of file LArCompleteToFlat.h.

{return StatusCode::SUCCESS;}

initialize()

StatusCode LArCompleteToFlat::initialize

(

)

Definition at line 75 of file LArCompleteToFlat.cxx.

{
  ATH_CHECK( m_cablingKey.initialize() );
  ATH_CHECK( m_cablingKeySC.initialize(m_isSC) );
  ATH_CHECK( m_weightsKeySC.initialize(m_isSC && !m_weightsKeySC.empty()) );
  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() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

ofcFlat()

CondAttrListCollection * LArCompleteToFlat::ofcFlat ( const ILArOFC *  input, const std::string &  outputName, const LArfSamplSC *  weights = nullptr  )

private

Definition at line 211 of file LArCompleteToFlat.cxx.

                                                                                                                                {
 
  ATH_MSG_INFO("LArCompleteToFlat::ofcFlat, starting");
  unsigned nChannels=0;
  unsigned nCopiedEMPS=0;
  unsigned nDefault=0;
 
  coral::AttributeListSpecification* spec = new coral::AttributeListSpecification();
  spec->extend("OFCa", "blob");
  spec->extend("OFCb", "blob");
  spec->extend("TimeOffset","blob");
  spec->extend<unsigned>("nSamples");
  spec->extend<unsigned>("version");
  CondAttrListCollection* collOFC=new CondAttrListCollection(true);
  int phase = 0;
  const unsigned nGain = m_isSC ? 1 : 3;
  for (unsigned gain=0;gain<nGain;++gain) {
    
    //Auto-detect the number of samples (at least in theory, could be different for each gain)
    unsigned nSamples=0;
    for (unsigned hs=0;hs<m_hashMax && nSamples==0;++hs) {
      const HWIdentifier chid=m_onlineID->channel_Id(hs);
      LArOFCFlat::OFCRef_t ofca= input->OFC_a(chid,gain);
      if ( input->nTimeBins(chid,gain) > 23 ){
    phase = 23;
    ofca = input->OFC_a(chid,gain,phase);
      }
    
      nSamples=ofca.size();
    }
    if (nSamples==0) {
      ATH_MSG_ERROR( "All input OFCs for gain " << gain << " have 0 samples!" );
      continue;//jump to the next gain
    }
    
    ATH_MSG_INFO( "Gain " << gain <<": Found " << nSamples << " OFC samples in input data" );
 
    coral::AttributeList* attrList = new coral::AttributeList(*spec);
    (*attrList)["version"].setValue(0U);
    coral::Blob& ofcaBlob=(*attrList)["OFCa"].data<coral::Blob>();
    coral::Blob& ofcbBlob=(*attrList)["OFCb"].data<coral::Blob>();
    coral::Blob& toBlob=(*attrList)["TimeOffset"].data<coral::Blob>();
 
    (*attrList)["nSamples"].setValue(nSamples);
      
    ofcaBlob.resize(m_hashMax*sizeof(float)*nSamples);
    ofcbBlob.resize(m_hashMax*sizeof(float)*nSamples);
    toBlob.resize(m_hashMax*sizeof(float));
    float* pOfca=static_cast<float*>(ofcaBlob.startingAddress());
    float* pOfcb=static_cast<float*>(ofcbBlob.startingAddress());
    float* pTimeOffset=static_cast<float*>(toBlob.startingAddress());
    for (unsigned hs=0;hs<m_hashMax;++hs) {
      const HWIdentifier chid=m_onlineID->channel_Id(hs);
      LArOFCFlat::OFCRef_t ofca= input->OFC_a(chid,gain,phase);
      LArOFCFlat::OFCRef_t ofcb= input->OFC_b(chid,gain,phase);
      float timeOffset=input->timeOffset(chid,gain);
      if (ofca.size()==0 && gain==2 && m_fakeEMBPSLowGain) {
    ofca= input->OFC_a(chid,1,phase);
    ofcb= input->OFC_b(chid,1,phase);
    timeOffset=input->timeOffset(chid,1);
    ++nCopiedEMPS;
      }
 
      if (ofca.size()==nSamples) {
    for (unsigned i=0;i<nSamples;++i) {
      pOfca[hs*nSamples+i]=ofca[i];
    }
      }
      else {
    std::stringstream message;
    message <<"Number of samples don't match. Expect " << nSamples << ", got " << ofca.size() << "."; 
    errIfConnected(chid,gain,"OFCa", message.str().c_str());
    for (unsigned i=0;i<nSamples;++i) {
      pOfca[hs*nSamples+i]=1.0;
    }
    ++nDefault;
      } 
     
      if (ofcb.size()==nSamples) {
    for (unsigned i=0;i<nSamples;++i) {
      pOfcb[hs*nSamples+i]=ofcb[i];
          // FIXME: it should be replaced by proper conditions per channel
      // HERE - multiplying HEC OFCb by 1.5 for SCs
          // https://its.cern.ch/jira/browse/ATLLARONL-1784
      //if (m_isSC && m_onlineID->isHECchannel(chid)){ 
      //  pOfcb[hs*nSamples+i]=ofcb[i]*1.5;
      //  ATH_MSG_WARNING("NOTE: this OFC for channel "<<chid<<" was multiplied by 1.5. This should be a HEC SC("<<m_onlineID->channel_name(chid)<<"). Was "<<ofcb[i]<<" now "<<pOfcb[hs*nSamples+i]);
      //}
      if (m_isSC && weights) pOfcb[hs*nSamples+i] *= weights->FSAMPL(chid);
      if (weights && weights->FSAMPL(chid) != 1.) ATH_MSG_WARNING("NOTE: this OFC for channel "<<chid<<" was multiplied by "<<weights->FSAMPL(chid)<<" This should be a  SC("<<m_onlineID->channel_name(chid)<<"). Was "<<ofcb[i]<<" now "<<pOfcb[hs*nSamples+i]);
    }
      }
      else {
    std::stringstream message;
    message <<"Number of samples don't match. Expect " << nSamples << ", got " << ofcb.size() << "."; 
    errIfConnected(chid,gain,"OFCb", message.str().c_str());
    for (unsigned i=0;i<nSamples;++i) {
      pOfcb[hs*nSamples+i]=1.0;
    }
      }
      pTimeOffset[hs]=timeOffset;
      ++nChannels;
 
    }//end loop over hash ids
    collOFC->add(gain,*attrList);
  }//end loop over gains
    
  StatusCode sc=detStore()->record(collOFC,outputName);//"/LAR/ElecCalibFlat/OFC");
  if (sc.isFailure()) {
    ATH_MSG_ERROR( "Failed to record CondAttrListCollection OFC with key " << outputName );
    return nullptr;
  }
 
  ATH_MSG_INFO( "Converted OFCs to inline storage. Total number of channels=" << nChannels );
  ATH_MSG_INFO( "Number of channels filled with default OFCs {1,1,1,1} " << nDefault << " (including disconnected)" );
  if (nCopiedEMPS) 
    ATH_MSG_INFO( "\t Number of low gain EMBPS channels copied from medium gain" <<  nCopiedEMPS );  
  return collOFC;
}

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.

pedestalFlat()

CondAttrListCollection * LArCompleteToFlat::pedestalFlat ( const ILArPedestal *  input, const std::string &  outputName  )

private

Definition at line 147 of file LArCompleteToFlat.cxx.

                                                                                                              { 
  ATH_MSG_INFO("LArCompleteToFlat::pedestalFlat, starting");
 
  unsigned nChannels=0;
  unsigned nCopiedEMPS=0;
 
  coral::AttributeListSpecification* spec = new coral::AttributeListSpecification();
  spec->extend("Pedestal", "blob");
  spec->extend("PedestalRMS", "blob");
  spec->extend<unsigned>("version");
 
  CondAttrListCollection* collPed=new CondAttrListCollection(true);
 
  const unsigned nGain = m_isSC ? 1 : 3;
  for (unsigned gain=0;gain<nGain;++gain) {
    coral::AttributeList* attrList = new coral::AttributeList(*spec);               
    (*attrList)["version"].setValue(0U);                               
    coral::Blob& blobPed=(*attrList)["Pedestal"].data<coral::Blob>();
    coral::Blob& blobRMS=(*attrList)["PedestalRMS"].data<coral::Blob>();
    blobPed.resize(m_hashMax*sizeof(float));
    blobRMS.resize(m_hashMax*sizeof(float));
    float* pblobPed=static_cast<float*>(blobPed.startingAddress());
    float* pblobRMS=static_cast<float*>(blobRMS.startingAddress());
    int nDefault=0;
    for (unsigned hs=0;hs<m_hashMax;++hs) {
      const HWIdentifier chid=m_onlineID->channel_Id(hs);
      float ped=input->pedestal(chid,gain);
      float pedRMS=input->pedestalRMS(chid,gain);
      if (gain==0){
    if (ped<0){
      ped = 1000;
      pedRMS = 1;
      ++nDefault;
    }
     
    
      }
      if (ped<0 && gain==2 && m_fakeEMBPSLowGain) {
    ped=input->pedestal(chid,1);
    pedRMS=input->pedestalRMS(chid,1);
    ++nCopiedEMPS;
      }
 
      pblobPed[hs]=ped;
      pblobRMS[hs]=pedRMS;
      ++nChannels; 
    }//end loop over hash ids
    collPed->add(gain,*attrList);
    ATH_MSG_INFO( "Number of channels filled with default Pedestal (1000) and PedestalRMS (1) "<< nDefault << " (including disconnected)" );
  }//end loop over gains
   
  StatusCode sc=detStore()->record(collPed,outputName);//"/LAR/ElecCalibFlat/Pedestal");
  if (sc.isFailure()) {
    ATH_MSG_ERROR( "Failed to record CondAttrListCollection for pedestal with key " << outputName );
    return nullptr;
  }
  ATH_MSG_INFO( "Converted Pedestal to inline storage. Total number of channels=" << nChannels );
  if (nCopiedEMPS) 
    ATH_MSG_INFO( "\t Number of low gain EMBPS channels copied from medium gain" <<  nCopiedEMPS );    
 
  return collPed;
}

rampFlat()

CondAttrListCollection * LArCompleteToFlat::rampFlat ( const ILArRamp *  input, const std::string &  outputName  )

private

Definition at line 443 of file LArCompleteToFlat.cxx.

                                                                                                      {
 
  ATH_MSG_INFO("LArCompleteToFlat::rampFlat, starting");
 
  unsigned nChannels=0;
  unsigned nCopiedEMPS=0;
  unsigned nDefault=0;
 
  coral::AttributeListSpecification* spec = new coral::AttributeListSpecification();
  spec->extend("RampVec", "blob");
  spec->extend<unsigned>("nPoints");
  spec->extend<unsigned>("version");
  CondAttrListCollection* coll=new CondAttrListCollection(true);
 
  std::vector<float> defaultRamp={0.0,1.0};
 
  const LArOnOffIdMapping* cabling(nullptr);
  if(m_isSC){
    SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKeySC};
    cabling=*cablingHdl;
  }else{
    SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey};
    cabling=*cablingHdl;
  }
  if(!cabling) {
     ATH_MSG_ERROR( "Do not have cabling mapping from key " << m_cablingKey.key() );
     return coll;
  }
 
  const unsigned nGain = m_isSC ? 1 : 3;
  for (unsigned gain=0;gain<nGain;++gain) {
 
    unsigned nPoints=0;
    for (unsigned hs=0;hs<m_hashMax && nPoints==0;++hs) {
      const HWIdentifier chid=m_onlineID->channel_Id(hs);
      const ILArRamp::RampRef_t ramp= input->ADC2DAC(chid,gain);
      nPoints=ramp.size();
    }
    if (nPoints==0) {
      ATH_MSG_ERROR( "All input Ramps for gain " << gain << " have 0 points!" );
      continue;//jump to the next gain
    }
 
    defaultRamp.resize(nPoints,0.0); //fill remaining points if needed
    ATH_MSG_INFO( "Gain " << gain << ": Found a ramp polynom of degree " << nPoints << " in input data" );
    coral::AttributeList* attrList = new coral::AttributeList(*spec);
    (*attrList)["version"].setValue(0U);
    coral::Blob& blobRamp=(*attrList)["RampVec"].data<coral::Blob>();
    (*attrList)["nPoints"].setValue(nPoints);
    blobRamp.resize(m_hashMax*sizeof(float)*nPoints);
    float* pblobRamp=static_cast<float*>(blobRamp.startingAddress());
 
    for (unsigned hs=0;hs<m_hashMax;++hs) {
      const HWIdentifier chid=m_onlineID->channel_Id(hs);
      std::vector<float> rampVec(input->ADC2DAC(chid,gain).asVector());
      if(rampVec.size()>=2 && rampVec[1]>500) {
         ATH_MSG_WARNING("Protection against crazy ramp values, set 500");
         rampVec[1]=500.;
      }
      if (rampVec.empty() && gain==2 && m_fakeEMBPSLowGain && cabling->isOnlineConnected(chid) ) { 
    rampVec=input->ADC2DAC(chid,1).asVector();
        if(rampVec.empty()) {
           ATH_MSG_WARNING("Filling EMBPS ramp with default values 0,10");
           rampVec.resize(2);
           rampVec[0]=0.;
           rampVec[1]=10.;
        } else {
       rampVec[1]*=10.0;
           if(rampVec[1]>500) {
              ATH_MSG_WARNING("Protection against crazy ramp values, set 500");
              rampVec[1]=500.;
           }
        }
    ++nCopiedEMPS;
      }
      
      if (rampVec.size()>=nPoints) {
    for (size_t i=0;i<nPoints;++i) {
      pblobRamp[nPoints*hs+i]=rampVec[i];
    }
      }
      else {
    std::stringstream message;
    message <<"Polynom degree doesn't match. Expect " << nPoints << ", got " << rampVec.size() << "."; 
    errIfConnected(chid,gain,"Ramp", message.str().c_str());
    for (size_t i=0;i<nPoints;++i) {
      pblobRamp[nPoints*hs+i]=defaultRamp[i];
    }
    ++nDefault;
      }
      ++nChannels;
    }//end loop over hash ids
    coll->add(gain,*attrList);
  }//end loop over gains
  
  StatusCode sc=detStore()->record(coll,outputName);//"/LAR/ElecCalibFlat/Ramp");
  if (sc.isFailure()) {
    ATH_MSG_ERROR( "Failed to record CondAttrListCollection for ramp with key " << outputName );
    return nullptr;
  }
 
  ATH_MSG_INFO( "Converted Ramps to inline storage. Total number of channels " << nChannels );
  ATH_MSG_INFO( "Number of channels filled with default ramp {0,1} " << nDefault << " (including disconnected)" );
  if (nCopiedEMPS) 
    ATH_MSG_INFO( "\t Number of low gain EMBPS channels copied from medium gain (applied factor 10)" <<  nCopiedEMPS );  
  
 
  return coll;
}

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

shapeFlat()

CondAttrListCollection * LArCompleteToFlat::shapeFlat ( const LArShapeComplete *  input, const std::string &  outputName  )

private

Definition at line 332 of file LArCompleteToFlat.cxx.

                                                                                                               {
 
  ATH_MSG_INFO("LArCompleteToFlat::shapeFlat, starting");
 
  unsigned nChannels=0;
  unsigned nCopiedEMPS=0;
  unsigned nDefault=0;
 
  coral::AttributeListSpecification* spec = new coral::AttributeListSpecification();
  spec->extend("Shape", "blob");
  spec->extend("ShapeDer", "blob");
  spec->extend("TimeOffset","blob");
  spec->extend<unsigned>("nSamples");
  spec->extend<unsigned>("version");
  CondAttrListCollection* coll=new CondAttrListCollection(true);
  
  const unsigned nGain = m_isSC ? 1 : 3;
  for (unsigned gain=0;gain<nGain;++gain) {
 
    unsigned nSamples=0;
    for (unsigned hs=0;hs<m_hashMax && nSamples==0;++hs) {
      const HWIdentifier chid=m_onlineID->channel_Id(hs);
      ILArShape::ShapeRef_t shape= input->Shape(chid,gain);
      nSamples=shape.size();
    }
    if (nSamples==0) {
      ATH_MSG_ERROR( "All input Shapes for gain " << gain << " have 0 samples!" );
      continue;//jump to the next gain
    }
 
    ATH_MSG_INFO( "Gain " << gain <<": Found " << nSamples << " shape samples in input data" );
 
    coral::AttributeList* attrList = new coral::AttributeList(*spec);    
    (*attrList)["version"].setValue(0U);
    coral::Blob& shapeBlob=(*attrList)["Shape"].data<coral::Blob>();
    coral::Blob& shapeDerBlob=(*attrList)["ShapeDer"].data<coral::Blob>();
    coral::Blob& toBlob=(*attrList)["TimeOffset"].data<coral::Blob>();
 
    (*attrList)["nSamples"].setValue(nSamples);
      
    shapeBlob.resize(m_hashMax*sizeof(float)*nSamples);
    shapeDerBlob.resize(m_hashMax*sizeof(float)*nSamples);
    toBlob.resize(m_hashMax*sizeof(float));
    float* pShape=static_cast<float*>(shapeBlob.startingAddress());
    float* pShapeDer=static_cast<float*>(shapeDerBlob.startingAddress());
    float* pTimeOffset=static_cast<float*>(toBlob.startingAddress());
    for (unsigned hs=0;hs<m_hashMax;++hs) {
      const HWIdentifier chid=m_onlineID->channel_Id(hs);
      
      ILArShape::ShapeRef_t shape= input->Shape(chid,gain);
      ILArShape::ShapeRef_t shapeDer= input->ShapeDer(chid,gain);
      float timeOffset=input->timeOffset(chid,gain);
      if (shape.size()==0 && gain==2 && m_fakeEMBPSLowGain) { 
     shape=input->Shape(chid,1);
     shapeDer=input->ShapeDer(chid,1);
     timeOffset=input->timeOffset(chid,1);
     ++nCopiedEMPS;
      }
   
      if (shape.size()==nSamples) {
    for (unsigned i=0;i<nSamples;++i) {
      pShape[hs*nSamples+i]=shape[i];
    }
      }
      else {
    std::stringstream message;
    message <<"Number of samples don't match. Expect " << nSamples << ", got " << shape.size() << "."; 
    errIfConnected(chid,gain,"Shape", message.str().c_str());
    for (unsigned i=0;i<nSamples;++i) {
      pShape[hs*nSamples+i]=0.0;
    }
    ++nDefault;
      } 
     
   
      if (shapeDer.size()==nSamples) {
    for (unsigned i=0;i<nSamples;++i) {
      pShapeDer[hs*nSamples+i]=shapeDer[i];
    }
      }
      else {
    std::stringstream message;
    message <<"Number of samples don't match. Expect " << nSamples << ", got " << shapeDer.size() << "."; 
    errIfConnected(chid,gain,"ShapeDer", message.str().c_str());
    for (unsigned i=0;i<nSamples;++i) {
      pShapeDer[hs*nSamples+i]=0.0;
    }
      }
      pTimeOffset[hs]=timeOffset;
      ++nChannels;
 
    }//end loop over hash ids
    coll->add(gain,*attrList);
  }//end loop over gains
    
  StatusCode sc=detStore()->record(coll,outputName);//"/LAR/ElecCalibFlat/SHAPE");
  if (sc.isFailure()) {
    ATH_MSG_ERROR( "Failed to record CondAttrListCollection Shape with key " << outputName );
    return nullptr;
  }
 
  ATH_MSG_INFO( "Converted Shapes to inline storage. Total number of channels=" << nChannels );
   ATH_MSG_INFO( "Number of channels filled with default shape {0,0,0,0} " << nDefault << " (including disconnected)" );
  if (nCopiedEMPS) 
    ATH_MSG_INFO( "\t Number of low gain EMBPS channels copied from medium gain" <<  nCopiedEMPS );  
  
  return coll;
}

singleFloatFlat()

CondAttrListCollection * LArCompleteToFlat::singleFloatFlat ( const char *  blobName, const LArConditionsContainer< LArSingleFloatP > *  input, const std::string &  outputName, const unsigned  nGain, const bool  withFCAL = true  )

private

Definition at line 85 of file LArCompleteToFlat.cxx.

                                                                                                      {
 
  unsigned nChannels=0;
  unsigned nCopiedEMPS=0;
  unsigned nDefault=0;
 
  coral::AttributeListSpecification* spec = new coral::AttributeListSpecification();
  spec->extend(blobName, "blob");
  spec->extend<unsigned>("version");
  CondAttrListCollection* coll=new CondAttrListCollection(true);
  for (unsigned gain=0;gain<nGain;++gain) {
    coral::AttributeList* attrList = new coral::AttributeList(*spec);
    (*attrList)["version"].setValue(0U);
    coral::Blob& blob=(*attrList)[blobName].data<coral::Blob>();
    blob.resize(m_hashMax*sizeof(float));
    float* pblob=static_cast<float*>(blob.startingAddress());
    for (unsigned hs=0;hs<m_hashMax;++hs) {
      const HWIdentifier chid=m_onlineID->channel_Id(hs);
      float value;
      if (!withFCAL && m_onlineID->isFCALchannel(chid)) {
    value=1.0; //Fill fcal channels with 1.0. for MPhysOverMcal
      }
      else
    value=input->get(chid,gain).m_data;
 
      if (value<0 && gain==2 && m_fakeEMBPSLowGain) { 
    //Fill medium gain for EMB PS low gain
    value=input->get(chid,1).m_data;
    ++nCopiedEMPS;
      }
      if (value < 0) {
    errIfConnected(chid,gain,blobName);
    value=1.0; //Default vaue is 1.0, since these are multiplicative constants
    ++nDefault;
      } 
      pblob[hs]=value;
      ++nChannels;
    }
    unsigned coolChan=gain;
    //Special case: Store single-gain constant in channel 1 
    //To avoid AttrList vs AttrListCollection confusion in Athena DB infrastructure
    if (nGain==1) coolChan=1;
 
    coll->add(coolChan,*attrList);
    //delete attrList;//???
  }
 
  ATH_MSG_INFO( "Converted " << blobName << " to inline storage. Total number of channels=" << nChannels );
  ATH_MSG_INFO( "Number of channels filled with default value (1.0) " << nDefault << " (including disconnected)" );
  if (nCopiedEMPS) 
    ATH_MSG_INFO( "\t Number of low gain EMBPS channels copied from medium gain" <<  nCopiedEMPS );  
  StatusCode sc=detStore()->record(coll,outputName);
  if (sc.isFailure()) {
    ATH_MSG_ERROR( "Failed to record CondAttrListCollection with key" << outputName );
    return nullptr;
  }
  return coll;
}

stop()

StatusCode LArCompleteToFlat::stop ( )

virtual

Definition at line 649 of file LArCompleteToFlat.cxx.

                                   {  
  std::string flatName = "/LAR/ElecCalibFlat";
  StatusCode sc;
    if(m_isSC){
      flatName += "SC";
      const LArOnline_SuperCellID* ll = nullptr;
      sc = detStore()->retrieve(ll, "LArOnline_SuperCellID");
      if (sc.isFailure()) {
    ATH_MSG_ERROR( "Could not get LArOnlineID helper !" );
    return StatusCode::FAILURE;
      }
      else {
    m_onlineID = (const LArOnlineID_Base*)ll;
    ATH_MSG_DEBUG("Found the LArOnlineID helper");
      }
    }else{
      const LArOnlineID* ll = nullptr;
      sc = detStore()->retrieve(ll, "LArOnlineID");
      if (sc.isFailure()) {
    ATH_MSG_ERROR( "Could not get LArOnlineID helper !" );
    return StatusCode::FAILURE;
      }
      else {
    m_onlineID = (const LArOnlineID_Base*)ll;
    ATH_MSG_DEBUG(" Found the LArOnlineID helper. ");
      }
 
    }
 
  m_hashMax=m_onlineID->channelHashMax();
  
  if (!m_uA2MeVInput.empty()) {
    const ILAruA2MeV* uA2MeVComplete = nullptr;
    sc=detStore()->retrieve(uA2MeVComplete,m_uA2MeVInput);
    if (sc.isFailure()) {
      if(m_forceStop) { 
    ATH_MSG_ERROR( "Failed to get LAruA2MeV with key " << m_uA2MeVInput );
    return sc;
      } else {
    ATH_MSG_WARNING( "Will not process LAruA2MeV" );
      }
    } else {
      uA2MeVFlat(uA2MeVComplete, flatName+"/uA2MeV");
    }
  }//end if have m_uA2MeV
    
 
  if (!m_DAC2uAInput.empty()) {
    const ILArDAC2uA* DAC2uAComplete = nullptr;
    sc=detStore()->retrieve(DAC2uAComplete,m_DAC2uAInput);
    if (sc.isFailure()) {
      if(m_forceStop) { 
    ATH_MSG_ERROR( "Failed to get LArDAC2uA with key " << m_DAC2uAInput );
    return sc;
      } else {
    ATH_MSG_WARNING( "Will not process LArDAC2uA" );
      }  
    } else {
      DAC2uAFlat(DAC2uAComplete, flatName+"/DAC2uA");
    }
  }//end if have m_DAC2uAInput
 
  if (!m_MphysOverMcalInput.empty()) {
    const LArMphysOverMcalComplete* MphysOverMcalComplete = nullptr;
    sc=detStore()->retrieve(MphysOverMcalComplete,m_MphysOverMcalInput);
    if (sc.isFailure()) {
      if(m_forceStop) { 
    ATH_MSG_ERROR( "Failed to get LArMphysOverMcal with key " << m_MphysOverMcalInput );
    return sc;
      } else {
    ATH_MSG_WARNING( "Will not process LArMphysOverMcal" );
      }   
    } else {
      const int nGain = m_isSC ? 1 : 3;
      const bool wfcal = m_isSC ? true : false;
      singleFloatFlat("MphysOverMcal", MphysOverMcalComplete, flatName+"/MphysOverMcal",nGain,wfcal); //No MphysOverMCal for FCAL
    }
  }//end if have m_MphysOverMcalInput
 
 
  if (!m_HVScaleCorrInput.empty()) {
    const LArHVScaleCorrComplete* HVScaleCorrComplete = nullptr;
    sc=detStore()->retrieve(HVScaleCorrComplete,m_HVScaleCorrInput);
    if (sc.isFailure()) {
      if(m_forceStop) { 
    ATH_MSG_ERROR( "Failed to get LArHVScaleCorr with key " << m_HVScaleCorrInput );
    return sc;
      } else {
    ATH_MSG_WARNING( "Will not process LArHVScaleCorr" );
      }   
    } else {
      singleFloatFlat("HVScaleCorr", HVScaleCorrComplete, flatName+"/HVScaleCorr",1);
    }
  }//end if have m_HVScaleCorrInput
 
  if (!m_PedestalInput.empty()) {
    const LArPedestalComplete* pedComplete = nullptr;
    sc=detStore()->retrieve(pedComplete,m_PedestalInput);
    if (sc.isFailure()) {
      if(m_forceStop) { 
    ATH_MSG_ERROR( "Failed to get LArPedestal" );
    return sc;
      } else {
    ATH_MSG_WARNING( "Will not process LArPedestal" );
      }   
    } else {
      pedestalFlat(pedComplete,flatName+"/Pedestal");
 
      /*
     CondAttrListCollection* coll=pedestalFlat(pedComplete,"/LAR/ElecCalibFlat/Pedestal");
     LArPedestalFlat* pf=new LArPedestalFlat(coll);
  
     sc=detStore()->record(pf,"PedestalFlat");
     if (sc.isFailure()) {
       ATH_MSG_ERROR( "Failed to record LArPedestalFlat" );
     }
   
     ILArPedestal* iped=pf;
     sc=detStore()->symLink(pf,iped);
     if (sc.isFailure()) {
       ATH_MSG_ERROR( "Failed to symlink LArPedestalFlat" );
     }
   }
      */
    }
  }//end if have m_pedestalInput
 
  //OFC:
  if (!m_OFCInput.empty()) {
    const LArOFCComplete* ofcComplete = nullptr;
    sc=detStore()->retrieve(ofcComplete,m_OFCInput);
    if (sc.isFailure()) {
      if(m_forceStop) { 
    ATH_MSG_ERROR( "Failed to get LArOFCComplete object" );
    return sc;
      } else {
    ATH_MSG_WARNING( "Will not process LArOFCComplete" );
      }
    } else {
      const LArfSamplSC* weightsComplete(nullptr);
      if(m_isSC && !m_weightsKeySC.empty()) { 
         SG::ReadCondHandle<LArfSamplSC> wHdl{m_weightsKeySC};
         weightsComplete=*wHdl;
         if(!weightsComplete) {
            ATH_MSG_WARNING("Do not have OFCb weights !!!! Not applying");
         }
      } 
      ofcFlat(ofcComplete,flatName+"/OFC",weightsComplete);
    }
  }//end have m_OFCInput
  if (!m_OFCCaliInput.empty()) {
    const LArOFCComplete* ofcComplete = nullptr;
    sc=detStore()->retrieve(ofcComplete,m_OFCCaliInput);
    if (sc.isFailure()) {
      if(m_forceStop) { 
    ATH_MSG_ERROR( "Failed to get LArOFCComplete object (cali)" );
    return sc;
      } else {
    ATH_MSG_WARNING( "Will not process LArOFCComplete (cali)" );
      }
    } else {
      ofcFlat(ofcComplete,flatName+"/OFCCali");
 
    }
  }//end have m_OFCInput
  //Shape:
  if (!m_ShapeInput.empty()) {
    const LArShapeComplete* shapeComplete = nullptr;
    sc=detStore()->retrieve(shapeComplete,m_ShapeInput);
    if (sc.isFailure()) {
      if(m_forceStop) { 
    ATH_MSG_ERROR( "Failed to get LArShapeComplete object" );
    return sc;
      } else {
    ATH_MSG_WARNING( "Will not process LArShapeComplete" );
      }   
    } else {
      shapeFlat(shapeComplete,flatName+"/Shape");
      /*
      CondAttrListCollection* coll=shapeFlat(shapeComplete,"/LAR/ElecCalibFlat/Shape");
 
      LArShapeFlat* sf=new LArShapeFlat(coll);
     
      sc=detStore()->record(sf,"ShapeFlat");
      if (sc.isFailure()) {
    ATH_MSG_ERROR( "Failed to record LArShapeFlat" );
      }
   
      ILArShape* ishape=sf;
      sc=detStore()->symLink(sf,ishape);
      if (sc.isFailure()) {
    ATH_MSG_ERROR( "Failed to symlink LArShapeFlat" );
      }
      */
    }
  }//end if have m_shapeInput
 
  //Ramp
  if (!m_RampInput.empty()) { 
    const LArRampComplete* rampComplete = nullptr;
    sc=detStore()->retrieve(rampComplete,m_RampInput);
    if (sc.isFailure()) {
      if(m_forceStop) { 
    ATH_MSG_ERROR( "Failed to get LArRampComplete object" );
    return sc;
      } else {
    ATH_MSG_WARNING( "Will not process LArRampComplete" );
      }   
    } else {
      rampFlat(rampComplete,flatName+"/Ramp");
    }
  }
  
  if(!m_DSPThresholdsInput.empty()) {
    //DSPThresh:
    const LArDSPThresholdsComplete* DSPTComplete = nullptr;
    sc=detStore()->retrieve(DSPTComplete,m_DSPThresholdsInput);
    if (sc.isFailure()) {
      if(m_forceStop) { 
    ATH_MSG_ERROR( "Failed to get LArDSPThresholdsComplete object" );
    return sc;
      } else {
    ATH_MSG_WARNING( "Will not process LArDSPThresholdsComplete" );
      }   
    }
    DSPThresholdsFlat(DSPTComplete,"/LAR/Configuration/DSPThresholdFlat/Templates");
    /*
    AthenaAttributeList *cl=DSPThresholdsFlat(DSPTComplete,"/LAR/Configuration/DSPThresholdFlat/Templates");
    
    LArDSPThresholdsFlat* df;
    if(cl) {
      df=new LArDSPThresholdsFlat(cl);
      
      sc=detStore()->record(df,"DSPThresholdsFlat");
      if (sc.isFailure()) {
    ATH_MSG_ERROR( "Failed to record LArDSPThresholdsFlat" );
      }
    } 
    */
  } //end if have m__DSPThresholdsInput
  
 
  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, PyAthena::Alg, and AthHistogramAlgorithm.

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.

uA2MeVFlat()

CondAttrListCollection * LArCompleteToFlat::uA2MeVFlat ( const ILAruA2MeV *  input, const std::string &  outputName  )

private

Definition at line 579 of file LArCompleteToFlat.cxx.

                                                                                                          {
  coral::AttributeListSpecification* spec = new coral::AttributeListSpecification();
  spec->extend("uA2MeV", "blob");
  spec->extend<unsigned>("version");
  CondAttrListCollection* coll=new CondAttrListCollection(true);
  coral::AttributeList* attrList = new coral::AttributeList(*spec);
  (*attrList)["version"].setValue(0U);
  coral::Blob& blob=(*attrList)["uA2MeV"].data<coral::Blob>();
  blob.resize(m_hashMax*sizeof(float));
  float* pblob=static_cast<float*>(blob.startingAddress());
  for (unsigned hs=0;hs<m_hashMax;++hs) {
    const HWIdentifier chid=m_onlineID->channel_Id(hs);
    pblob[hs]=input->UA2MEV(chid);
  }
  coll->add(1,*attrList);
  //delete attrList;//???
  StatusCode sc=detStore()->record(coll,outputName);
  if (sc.isFailure()) {
    ATH_MSG_ERROR( "Failed to record CondAttrListCollection with key" << outputName );
    return nullptr;
  }
  return coll;
}

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> LArCompleteToFlat::m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}

private

Definition at line 72 of file LArCompleteToFlat.h.

m_cablingKeySC

SG::ReadCondHandleKey<LArOnOffIdMapping> LArCompleteToFlat::m_cablingKeySC {this,"CablingSCKey","LArOnOffIdMapSC","SG Key of LArOnOffIdMapping object"}

private

Definition at line 73 of file LArCompleteToFlat.h.

m_DAC2uAInput

std::string LArCompleteToFlat::m_DAC2uAInput

private

Definition at line 78 of file LArCompleteToFlat.h.

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_DSPThresholdsInput

std::string LArCompleteToFlat::m_DSPThresholdsInput

private

Definition at line 86 of file LArCompleteToFlat.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_fakeEMBPSLowGain

bool LArCompleteToFlat::m_fakeEMBPSLowGain

private

Definition at line 93 of file LArCompleteToFlat.h.

m_forceStop

bool LArCompleteToFlat::m_forceStop

private

Definition at line 92 of file LArCompleteToFlat.h.

m_hashMax

unsigned LArCompleteToFlat::m_hashMax

private

Definition at line 69 of file LArCompleteToFlat.h.

m_HVScaleCorrInput

std::string LArCompleteToFlat::m_HVScaleCorrInput

private

Definition at line 79 of file LArCompleteToFlat.h.

m_isSC

bool LArCompleteToFlat::m_isSC

private

Definition at line 91 of file LArCompleteToFlat.h.

m_MphysOverMcalInput

std::string LArCompleteToFlat::m_MphysOverMcalInput

private

Definition at line 82 of file LArCompleteToFlat.h.

m_nameOfSet

std::string LArCompleteToFlat::m_nameOfSet

private

Definition at line 89 of file LArCompleteToFlat.h.

m_OFCCaliInput

std::string LArCompleteToFlat::m_OFCCaliInput

private

Definition at line 84 of file LArCompleteToFlat.h.

m_OFCInput

std::string LArCompleteToFlat::m_OFCInput

private

Definition at line 83 of file LArCompleteToFlat.h.

m_onlineID

const LArOnlineID_Base* LArCompleteToFlat::m_onlineID

private

Definition at line 70 of file LArCompleteToFlat.h.

m_PedestalInput

std::string LArCompleteToFlat::m_PedestalInput

private

Definition at line 80 of file LArCompleteToFlat.h.

m_RampInput

std::string LArCompleteToFlat::m_RampInput

private

Definition at line 81 of file LArCompleteToFlat.h.

m_ShapeInput

std::string LArCompleteToFlat::m_ShapeInput

private

Definition at line 85 of file LArCompleteToFlat.h.

m_uA2MeVInput

std::string LArCompleteToFlat::m_uA2MeVInput

private

InputSGKeys.

Definition at line 77 of file LArCompleteToFlat.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.

m_weightsKeySC

SG::ReadCondHandleKey<LArfSamplSC> LArCompleteToFlat::m_weightsKeySC {this,"WeightsSCKey","","SG Key of weights object"}

private

Definition at line 74 of file LArCompleteToFlat.h.

---

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

• LArCompleteToFlat.h
• LArCompleteToFlat.cxx