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:
virtual	~LArCompleteToFlat ()
	Destructor:
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &) const override
virtual StatusCode	stop () override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

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

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
	LArCompleteToFlat ()=delete
	Default constructor:
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, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
unsigned	m_hashMax = 0
const LArOnlineID_Base *	m_onlineID = nullptr
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"}
StringProperty	m_uA2MeVInput { this, "uA2MeVInput", "" }
	InputSGKeys.
StringProperty	m_DAC2uAInput { this, "DAC2uAVInput", "" }
StringProperty	m_HVScaleCorrInput { this, "HVScaleCorrInput", "" }
StringProperty	m_PedestalInput { this, "PedestalInput", "" }
StringProperty	m_RampInput { this, "RampInput", "" }
StringProperty	m_MphysOverMcalInput { this, "MphysOverMcalInput", "" }
std::string	m_OFCInput
std::string	m_OFCCaliInput
std::string	m_ShapeInput
std::string	m_DSPThresholdsInput
std::string	m_nameOfSet
BooleanProperty	m_isSC = { this, "isSC", false }
bool	m_forceStop
bool	m_fakeEMBPSLowGain
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
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

Definition at line 32 of file LArCompleteToFlat.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::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.

                                         : 
  ::AthReentrantAlgorithm( name, pSvcLocator )
{
  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 ( )

privatedelete

Default constructor:

Member Function Documentation

DAC2uAFlat()

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

private

Definition at line 559 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()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::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< Gaudi::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< Gaudi::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 608 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 903 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()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::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()

virtual StatusCode LArCompleteToFlat::execute ( const EventContext & ) const

inlineoverridevirtual

Definition at line 47 of file LArCompleteToFlat.h.

{return StatusCode::SUCCESS;}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::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 & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 89 of file AthCommonAlgorithm.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 BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

initialize()

StatusCode LArCompleteToFlat::initialize ( )

overridevirtual

Definition at line 64 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< Gaudi::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.

isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

                                           {
    return true;
  }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::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 200 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) {
          if(std::isnan(ofca[i]) || std::isinf(ofca[i]) || (m_isSC && fabs(ofca[i])> 10.)) { // protection
            pOfca[hs*nSamples+i]=1.0;
          } else { 
        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) {
          if(std::isnan(ofcb[i]) || std::isinf(ofcb[i]) || (m_isSC && fabs(ofcb[i])> 100.)) { // protection
             pOfcb[hs*nSamples+i]=1.0;
          } else { 
         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< Gaudi::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 136 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 448 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< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

shapeFlat()

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

private

Definition at line 329 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) {
          if(std::isnan(shape[i]) || std::isinf(shape[i])) {
         pShape[hs*nSamples+i]=0.0;
          } else {
         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) {
          if(std::isnan(shapeDer[i]) || std::isinf(shapeDer[i])) {
         pShapeDer[hs*nSamples+i]=0.0;
          } else {
         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 74 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 ( )

overridevirtual

Definition at line 654 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 = static_cast<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 = static_cast<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,false); //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; 
}

sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::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< Gaudi::Algorithm > >.

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

Definition at line 60 of file AthCommonAlgorithm.cxx.

                                                      {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::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< Gaudi::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 584 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< Gaudi::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 71 of file LArCompleteToFlat.h.

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

m_cablingKeySC

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

private

Definition at line 72 of file LArCompleteToFlat.h.

{this,"CablingSCKey","LArOnOffIdMapSC","SG Key of LArOnOffIdMapping object"};

m_DAC2uAInput

StringProperty LArCompleteToFlat::m_DAC2uAInput { this, "DAC2uAVInput", "" }

private

Definition at line 77 of file LArCompleteToFlat.h.

{ this, "DAC2uAVInput", "" }; // LArDAC2uA

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::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 85 of file LArCompleteToFlat.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

m_fakeEMBPSLowGain

bool LArCompleteToFlat::m_fakeEMBPSLowGain

private

Definition at line 92 of file LArCompleteToFlat.h.

m_forceStop

bool LArCompleteToFlat::m_forceStop

private

Definition at line 91 of file LArCompleteToFlat.h.

m_hashMax

unsigned LArCompleteToFlat::m_hashMax = 0

private

Definition at line 68 of file LArCompleteToFlat.h.

m_HVScaleCorrInput

StringProperty LArCompleteToFlat::m_HVScaleCorrInput { this, "HVScaleCorrInput", "" }

private

Definition at line 78 of file LArCompleteToFlat.h.

{ this, "HVScaleCorrInput", "" }; // LArHVScaleCorr

m_isSC

BooleanProperty LArCompleteToFlat::m_isSC = { this, "isSC", false }

private

Definition at line 90 of file LArCompleteToFlat.h.

{ this, "isSC", false };

m_MphysOverMcalInput

StringProperty LArCompleteToFlat::m_MphysOverMcalInput { this, "MphysOverMcalInput", "" }

private

Definition at line 81 of file LArCompleteToFlat.h.

{ this, "MphysOverMcalInput", "" }; // LArMphysOverMcal

m_nameOfSet

std::string LArCompleteToFlat::m_nameOfSet

private

Definition at line 88 of file LArCompleteToFlat.h.

m_OFCCaliInput

std::string LArCompleteToFlat::m_OFCCaliInput

private

Definition at line 83 of file LArCompleteToFlat.h.

m_OFCInput

std::string LArCompleteToFlat::m_OFCInput

private

Definition at line 82 of file LArCompleteToFlat.h.

m_onlineID

const LArOnlineID_Base* LArCompleteToFlat::m_onlineID = nullptr

private

Definition at line 69 of file LArCompleteToFlat.h.

m_PedestalInput

StringProperty LArCompleteToFlat::m_PedestalInput { this, "PedestalInput", "" }

private

Definition at line 79 of file LArCompleteToFlat.h.

{ this, "PedestalInput", "" }; // Pedestal

m_RampInput

StringProperty LArCompleteToFlat::m_RampInput { this, "RampInput", "" }

private

Definition at line 80 of file LArCompleteToFlat.h.

{ this, "RampInput", "" }; // LArRamp

m_ShapeInput

std::string LArCompleteToFlat::m_ShapeInput

private

Definition at line 84 of file LArCompleteToFlat.h.

m_uA2MeVInput

StringProperty LArCompleteToFlat::m_uA2MeVInput { this, "uA2MeVInput", "" }

private

InputSGKeys.

Definition at line 76 of file LArCompleteToFlat.h.

{ this, "uA2MeVInput",  "" }; // LAruA2MeV

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::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 73 of file LArCompleteToFlat.h.

{this,"WeightsSCKey","","SG Key of weights object"};

---

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

• LArCompleteToFlat.h
• LArCompleteToFlat.cxx