ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
TBByteStreamCnvTool Class Reference

An AlgTool class to provide conversion ByteStream <-> TestBeam Instrumentation Data created Feb 2004 Walter Lampl. More...

#include <TBByteStreamCnvTool.h>

Inheritance diagram for TBByteStreamCnvTool:
Collaboration diagram for TBByteStreamCnvTool:

Public Member Functions

 TBByteStreamCnvTool (const std::string &type, const std::string &name, const IInterface *parent)
 constructor More...
 
virtual StatusCode initialize ()
 
virtual StatusCode finalize ()
 
StatusCode WriteFragment ()
 
StatusCode ReadFragment (int unrec_code)
 
StatusCode ReadFragment (TBTDC *&tdc, const std::string &key)
 
StatusCode ReadFragment (TBTDCRawCont *&tdcrawCont, const std::string &key)
 
StatusCode ReadFragment (TBADCRawCont *&adcrawCont, const std::string &key)
 
StatusCode ReadFragment (TBBPCRawCont *&bpcrawCont, const std::string &key)
 
StatusCode ReadFragment (TBMWPCRawCont *&mwpcrawCont, const std::string &key)
 
StatusCode ReadFragment (TBTriggerPatternUnit *&trigpat, const std::string &key)
 
StatusCode ReadFragment (TBScintillatorRawCont *&scintrawCont, const std::string &key)
 
StatusCode ReadFragment (TBTailCatcherRaw *&tailcatchraw, const std::string &key)
 
StatusCode ReadFragment (TBEventInfo *&tbeventinfo, const std::string &key)
 
StatusCode ReadFragment (TBLArDigitContainer *&tblardigitcont, const std::string &key)
 
StatusCode ReadFragment (TBLArCalibDigitContainer *&tblarcalibdigitcont, const std::string &key)
 
StatusCode BuildRODBlock (std::vector< uint32_t > *theRODBlock)
 
StatusCode GetRODBlock (eformat::SubDetector subdet_id, eformat::SubDetector subdet_rod_id=m_DontCheckRodSubDetID)
 
StatusCode H6BuildObjects (int unrec_code)
 
StatusCode H6RecordObjects (int unrec_code)
 
StatusCode H8BuildObjects (int unrec_code)
 
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 sysInitialize () override
 Perform system initialization for an algorithm. 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
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 

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

bool NextSubFrag ()
 
CaloGain::CaloGain getCaloGain (int gain)
 
unsigned short firstword (unsigned int w)
 
unsigned short secondword (unsigned int w)
 
unsigned short firstnbit (int n, unsigned short w)
 
bool testbit (int n, unsigned short w)
 
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

ServiceHandle< IByteStreamEventAccess > m_ByteStreamEventAccess
 
ServiceHandle< IROBDataProviderSvc > m_rdpSvc
 
EventID m_lastEventID {}
 
eformat::SubDetector m_subdet_id {}
 
std::vector< uint32_t > m_rodBlock
 
const LArOnlineID * m_onlineHelper {}
 
std::vector< uint32_t > * m_theRodBlock {}
 
OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment * m_theROB {}
 
bool m_H6run {}
 
bool m_H8run {}
 
bool m_force_Hchoice {}
 
bool m_dump {}
 
std::vector< std::string > m_keys
 
int m_subdet_key {}
 
int m_subfrag_id {}
 
int m_subfrag_size {}
 
int m_subfrag_firstdata {}
 
SG::ReadCondHandleKey< LArCalibLineMapping > m_CLKey {this, "CalibLineKey", "LArCalibLineMap", "SG calib line key"}
 
TBTDC * m_tbtdc {}
 
TBTDCRawCont * m_tdcrawCont {}
 
TBADCRawCont * m_adcrawCont {}
 
TBBPCRawCont * m_bpcrawCont {}
 
TBMWPCRawCont * m_mwpcrawCont {}
 
TBTriggerPatternUnit * m_trigpat {}
 
TBScintillatorRawCont * m_scintrawCont {}
 
TBTailCatcherRaw * m_tailcatchraw {}
 
TBEventInfo * m_eventinfo {}
 
TBLArDigitContainer * m_tblardigitcont [4] {}
 
TBLArCalibDigitContainer * m_tblarcalibdigitcont [4] {}
 
std::vector< int > m_boards
 
std::vector< int > m_samples
 
std::vector< int > m_gains
 
std::vector< int > m_febgain
 
std::vector< int > m_firstsamples
 
std::vector< short > m_arrayofsample [128][4]
 
CaloGain::CaloGain m_arrayofgain [128][4] {}
 
bool m_isCalib {}
 
unsigned char m_calib_pattern [16] {}
 
uint16_t m_calib_dac {}
 
uint16_t m_calib_delay {}
 
bool m_calib_error {}
 
int m_ev_number {}
 
unsigned int m_run_num {}
 
float m_beam_moment {}
 
std::string m_beam_part
 
float m_cryoX {}
 
float m_cryoAngle {}
 
float m_tableY {}
 
std::string m_summary_path
 
unsigned int m_h8_triggword {}
 
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
 

Static Private Attributes

static const eformat::SubDetector m_DontCheckRodSubDetID =(eformat::SubDetector)0xff
 

Detailed Description

An AlgTool class to provide conversion ByteStream <-> TestBeam Instrumentation Data created Feb 2004 Walter Lampl.

Definition at line 47 of file TBByteStreamCnvTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ TBByteStreamCnvTool()

TBByteStreamCnvTool::TBByteStreamCnvTool ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

constructor

Definition at line 39 of file TBByteStreamCnvTool.cxx.

41  : AthAlgTool(type,name,parent),
42  m_ByteStreamEventAccess("ByteStreamCnvSvc", name),
43  m_rdpSvc("ROBDataProviderSvc", name),
44  m_lastEventID(0, UINT_MAX), m_subdet_id(eformat::TDAQ_BEAM_CRATE),
45  m_theRodBlock(0), m_theROB(0)
46 {
47  declareInterface< TBByteStreamCnvTool >( this );
48  m_tbtdc=0;
49  declareProperty("ForceHchoice",m_force_Hchoice=false);
50  declareProperty("Dump",m_dump=false);
51  declareProperty("isH6Run",m_H6run=true);
52  declareProperty("isH8Run",m_H8run=false);
53  declareProperty("Keys",m_keys);
54  declareProperty("SubDetID",m_subdet_key);
55  declareProperty("SummaryPath",m_summary_path);
56 
57 }

Member Function Documentation

◆ BuildRODBlock()

StatusCode TBByteStreamCnvTool::BuildRODBlock ( std::vector< uint32_t > *  theRODBlock)

Build a ROD data block for all Beam detector classes found in SG. Working only with TBTDC class for testing

Definition at line 191 of file TBByteStreamCnvTool.cxx.

192 {
196  MsgStream logstr(msgSvc(), name());
197  //Get necessary Data objects
198  StatusCode sc;
199 
200  // TBTDCRaw part of the block :
201  const TBTDC* tbtdc = nullptr;
202  std::string tbtdc_Key("TBTDC");
203  sc=evtStore()->retrieve(tbtdc,tbtdc_Key);
204  if (sc!=StatusCode::SUCCESS)
205  {logstr << MSG::ERROR << "Can't retrieve TBTDC with key "<< tbtdc_Key << " from StoreGate" << endmsg;
206  return sc;
207  }
208  else {
209  theRodBlock->push_back(4); // TIME_SIZE
210  theRodBlock->push_back(0x03); // TIME_ID
211  theRodBlock->push_back(tbtdc->tdc());
212  theRodBlock->push_back(tbtdc->tdcmin());
213  }
214 
215 
216  // TBBPCRaw :
217 // TBBPCRawCont * bpcrawCont;
218 // sc = m_storeGate->retrieve(bpcrawCont, "BPCRawCont");
219 // if (sc.isFailure()){
220 // logstr << MSG::DEBUG << "BeamDetectorMonitoring: Retrieval of BPCRaw failed" << endmsg;
221 // }else {
222 // TBBPCRawCont::const_iterator it_bc = bpcrawCont->begin();
223 // TBBPCRawCont::const_iterator last_bc = bpcrawCont->end();
224 // // theRodBlock->push_back(2+bpcrawCont->size()*6); // BPC_SIZE
225 // // theRodBlock->push_back(0x05); // BPC_ID (BPCRaw)
226 
227 // for(it_bc= bpcrawCont->begin();it_bc!=last_bc;it_bc++){
228 // // theRodBlock->push_back((*it_bc)->getSignal((int) TBBPCRaw::tdcLeft));
229 // // theRodBlock->push_back((*it_bc)->getSignal((int) TBBPCRaw::tdcRight));
230 // // theRodBlock->push_back((*it_bc)->getSignal((int) TBBPCRaw::tdcUp));
231 // // theRodBlock->push_back((*it_bc)->getSignal((int) TBBPCRaw::tdcDown));
232 // // theRodBlock->push_back((*it_bc)->getSignal((int) TBBPCRaw::adcHorizontal));
233 // // theRodBlock->push_back((*it_bc)->getSignal((int) TBBPCRaw::adcVertical));
234 // }
235 // }
236 
237  // Trigger Pattern :
238 // TBTriggerPatternUnit *trigpat;
239 // sc = m_storeGate->retrieve(trigpat, "TBTrigPat");
240 // if (sc.isFailure()){
241 // logstr << MSG::DEBUG << "BeamDetectorMonitoring: Retrieval of TrigPat failed" << endmsg;
242 
243 // }else {
244 // theRodBlock->push_back(3); // TrigPat_SIZE
245 // theRodBlock->push_back(0x01); // TrigPat_ID (TrigPatRaw)
246 // theRodBlock->push_back(trigpat->getTriggerWord());
247 // }
248 
249 
250  return StatusCode::SUCCESS;
251 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

◆ finalize()

StatusCode TBByteStreamCnvTool::finalize ( )
virtual

Definition at line 122 of file TBByteStreamCnvTool.cxx.

123 {
124  return StatusCode::SUCCESS;
125 }

◆ firstnbit()

unsigned short TBByteStreamCnvTool::firstnbit ( int  n,
unsigned short  w 
)
inlineprivate

Definition at line 197 of file TBByteStreamCnvTool.h.

197  {
198  unsigned short tmp=0;
199  for(unsigned short i=0;i<n;i++) tmp = tmp | (1<<i);
200  return (w & tmp);
201  }

◆ firstword()

unsigned short TBByteStreamCnvTool::firstword ( unsigned int  w)
inlineprivate

Definition at line 190 of file TBByteStreamCnvTool.h.

190  {
191  return 65535 & w;
192  }

◆ getCaloGain()

CaloGain::CaloGain TBByteStreamCnvTool::getCaloGain ( int  gain)
inlineprivate

Definition at line 150 of file TBByteStreamCnvTool.h.

150  {
151  switch(gain){
152  case 0:
153  return CaloGain::LARLOWGAIN;
154  case 1:
155  return CaloGain::LARMEDIUMGAIN;
156  case 2:
157  return CaloGain::LARHIGHGAIN;
158  default:
159  return CaloGain::UNKNOWNGAIN;
160  }
161  }

◆ GetRODBlock()

StatusCode TBByteStreamCnvTool::GetRODBlock ( eformat::SubDetector  subdet_id,
eformat::SubDetector  subdet_rod_id = m_DontCheckRodSubDetID 
)

Definition at line 395 of file TBByteStreamCnvTool.cxx.

398 {MsgStream logstr(msgSvc(), name());
399  logstr << MSG::DEBUG << "GetRODBlock" << endmsg;
400  if (!m_rdpSvc)
401  {logstr << MSG::ERROR << "ROBDataProviderSvc not loaded. Can't read ByteStream" << endmsg;
402  return StatusCode::FAILURE;
403  }
404 
405  const RawEvent* re = m_rdpSvc->getEvent(Gaudi::Hive::currentContext());
406 
407  if (!re)
408  {logstr <<MSG::FATAL << "Can't get RawEvent!" << endmsg;
409  return StatusCode::FAILURE;
410  }
411 
412  const size_t MAX_ROBFRAGMENTS = 2048*1024;
413  OFFLINE_FRAGMENTS_NAMESPACE::PointerType robF[MAX_ROBFRAGMENTS];
414  size_t robcount = re->children(robF,MAX_ROBFRAGMENTS);
415  // re->start(robF);
416  if (robcount == MAX_ROBFRAGMENTS)
417  {
418  logstr <<MSG::FATAL << "ROB buffer overflow" << endmsg;
419  return StatusCode::FAILURE;
420  }
421 
422  for (size_t irob=0; irob<robcount; ++irob) //Loop over all ROB-Fragments
423  {
424  OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment rob(robF[irob]);
425 
426  logstr << MSG::DEBUG << "ROB Frag *****************************" << endmsg;
427  MSG::hex(logstr) << MSG::DEBUG <<"Marker : " << rob.marker() << endmsg;
428  MSG::hex(logstr) << MSG::DEBUG <<"Frag Size : " << rob.fragment_size_word() << endmsg;
429  MSG::hex(logstr) << MSG::DEBUG <<"Header Size: " << rob.header_size_word() << endmsg;
430  MSG::hex(logstr) << MSG::DEBUG <<"Source ID : " << rob.source_id() << endmsg;
431  MSG::hex(logstr) << MSG::DEBUG <<"Version : " << rob.version() << endmsg;
432  try
433  {
434  rob.check();
435  }
436  catch (...)
437  {
438  logstr << MSG::ERROR << "Got invalid ROB fragment!" << endmsg;
439  return StatusCode::FAILURE;
440  }
441 
442  logstr << MSG::DEBUG << "ROD Frag *****************************" << endmsg;
443  MSG::hex(logstr) << MSG::DEBUG <<"Frag Size : " << rob.rod_fragment_size_word() << endmsg;
444  MSG::hex(logstr) << MSG::DEBUG <<"Header Size: " << rob.rod_header_size_word() << endmsg;
445  MSG::hex(logstr) << MSG::DEBUG <<"Source ID : " << rob.rod_source_id() << endmsg;
446  MSG::hex(logstr) << MSG::DEBUG <<"Run num : " << rob.rod_run_no() << endmsg;
447  MSG::hex(logstr) << MSG::DEBUG <<"Version : " << rob.rod_version() << endmsg;
448 
449  eformat::helper::SourceIdentifier rod_sid(rob.rod_source_id());
450  if (subdet_rod_id==m_DontCheckRodSubDetID || rod_sid.subdetector_id()==subdet_rod_id)
451  {
452  MSG::hex(logstr) << MSG::DEBUG << "Found requested ROD (id="
453  << rod_sid.subdetector_id() << ")" << endmsg;
454  // Set H6 or H8 mode :
455  if (!m_force_Hchoice)
456  {
457  logstr<< MSG::INFO << "Guessing from ROD header -> " ;
458  if (rob.rod_detev_type()&1)
459  {
460  logstr<< " H6 !" << endmsg;
461  m_H6run = true;
462  m_H8run = false;
463  }
464  else
465  {
466  logstr<< " H8 !" << endmsg;
467  m_H6run = false;
468  m_H8run = true;
469  }
470  }
471  m_h8_triggword = rob.rod_lvl1_trigger_type();
472  // Event number ?
473  m_ev_number = rob.rod_lvl1_id();
474  if(m_dump) MSG::dec(logstr) << MSG::INFO << " Ev. number(header)=" << m_ev_number <<endmsg;
475 
476  OFFLINE_FRAGMENTS_NAMESPACE::PointerType rodPointer;
477  rob.rod_data(rodPointer);
478  m_rodBlock.clear();
479  for(size_t i=0; i<rob.rod_ndata(); ++i)
480  {
481  m_rodBlock.push_back(*rodPointer);
482  ++rodPointer;
483  }
484 
485  if (m_rodBlock.size()==0)
486  {
487  logstr << MSG::FATAL << "Error reading bytestream event: "
488  << "Empty ROD block" << endmsg;
489  return StatusCode::FAILURE;
490  }
491  logstr << MSG::DEBUG << "Got Rod Block for Test Beam Instrumentation data from ByteStream" << endmsg;
492  return StatusCode::SUCCESS;
493  }// end if requested ROD
494  }//end loop over ROBs
495 
496  MSG::hex(logstr) << MSG::WARNING << " Didn't find SubDet ID for Beam Instruments. Should be "<< subdet_id<<endmsg;
497  return StatusCode::FAILURE;
498 }

◆ H6BuildObjects()

StatusCode TBByteStreamCnvTool::H6BuildObjects ( int  unrec_code)

Build all beam detectors raw objects from m_rodBlock using H6 convention. Objects are recorded in SG if they do not correspond to unrec_code Will return faillure if : -one of the object could not be recorded in SG -the requested object (unrec_code) was not found

Definition at line 502 of file TBByteStreamCnvTool.cxx.

505 {
513  MsgStream logstr(msgSvc(), name());
514  logstr << MSG::DEBUG << "H6BuildObject called for " << unrec_code<< endmsg;
515 
516  const EventContext& ctx = Gaudi::Hive::currentContext();
517 
518  StatusCode sc=StatusCode::FAILURE;
519  //bool gotobject=false;
520  //bool recordfailure=false;
521 
522  // for string conversion
523  std::ostringstream os;
524 
525  // Get ROD block.
526  sc=GetRODBlock(m_subdet_id); //Possible improvement: Check if vector is already valid.
527  if (sc!=StatusCode::SUCCESS)
528  return sc;
529  if (m_rodBlock.size()<2)
530  {MsgStream logstr(msgSvc(), name());
531  logstr << MSG::ERROR << "ReadRodBlock: RodBlock too small!" << endmsg;
532  return StatusCode::FAILURE;
533  }
534 
535 
536 
537 
538  m_trigpat = new TBTriggerPatternUnit();
539  m_tailcatchraw = 0;
540  m_bpcrawCont = new TBBPCRawCont();
541  m_scintrawCont = new TBScintillatorRawCont();
542  m_mwpcrawCont = new TBMWPCRawCont();
543 
544  for(int i=0;i<4;i++) m_tblardigitcont[i] = new TBLArDigitContainer();
545  for(int i=0;i<4;i++) m_tblarcalibdigitcont[i] = new TBLArCalibDigitContainer();
546 
547  std::string name1,name2;
548  m_tdcrawCont = new TBTDCRawCont();
549  TBTDCRaw* dummytdc = new TBTDCRaw("dummy",true,0,true);
550  m_tdcrawCont->push_back(dummytdc);
551 
552  m_adcrawCont = new TBADCRawCont();
553  TBADCRaw* dummyadc = new TBADCRaw("dummy",true,0);
554  m_adcrawCont->push_back(dummyadc);
555 
556  SG::ReadCondHandle<LArCalibLineMapping> calibLine (m_CLKey, ctx);
557 
558 
559  // with this initialisation, first call of NextSubFrag will initialise correctly the index :
560  m_subfrag_id=0;
561  m_subfrag_size=2;
562  m_subfrag_firstdata=0;
563  while(NextSubFrag()){
564  MSG::dec(logstr) << MSG::DEBUG << "size "<<m_subfrag_size<<endmsg;
565  MSG::hex(logstr) << MSG::DEBUG << "ID "<< m_subfrag_id<<endmsg;
566  switch(m_subfrag_id){
567  case 0x01: // HEADER_ID -----------------------------------------
568  {
569  logstr << MSG::DEBUG << "H6BuildObject : HEADER_ID "<< m_subfrag_size << endmsg;
570  //m_trigpat = new TBTriggerPatternUnit();
571  m_trigpat->setTriggerWord(m_rodBlock[m_subfrag_firstdata+3]);
572  MSG::hex(logstr) << MSG::DEBUG << "Header "<<m_rodBlock[m_subfrag_firstdata];
573  MSG::hex(logstr) <<" "<<m_rodBlock[m_subfrag_firstdata+1];
574  MSG::hex(logstr) <<" "<<m_rodBlock[m_subfrag_firstdata+2];
575  MSG::hex(logstr) <<" "<<m_rodBlock[m_subfrag_firstdata+3]<<endmsg;
576  // if(unrec_code == 30 ) gotobject=true;
577  if(m_dump) MSG::dec(logstr) << MSG::INFO << " Ev. number(0x01)="<< m_rodBlock[m_subfrag_firstdata] <<endmsg;
578  m_eventinfo = new TBEventInfo(m_ev_number,
579  m_rodBlock[m_subfrag_firstdata+2],
580  m_rodBlock[m_subfrag_firstdata+1],
581  m_run_num,
582  m_beam_moment,
583  m_beam_part,
584  m_cryoX,
585  m_cryoAngle,
586  m_tableY);
587  }
588  break;
589 
590  case 0x02: // MINI-ROD Data Fragment ... oh what fun ... ------------
591  {
592  logstr << MSG::DEBUG << " Found mini-ROD data in beam crate fragment, size " << m_subfrag_size << endmsg;
593 
594  // bool calibdigit_requested = (unrec_code==20)||(unrec_code==21)||(unrec_code==22)||(unrec_code==23);
595  //
596  short m_feedthrough[8] = {0,0,0,0,1,1,1,1};
597  int m_sampleOrder[32] = {
598  0,1,2,3,4,5,6,7,8,9,10,
599  11,12,13,14,15,16,17,18,19,20,
600  21,22,23,24,25,26,27,28,29,30,
601  31};
602  int m_sort[64] = { 55, 39, 23, 7, 119, 103, 87, 71,
603  54, 38, 22, 6, 118, 102, 86, 70,
604  53, 37, 21, 5, 117, 101, 85, 69,
605  52, 36, 20, 4, 116, 100, 84, 68,
606  51, 35, 19, 3, 115, 99, 83, 67,
607  50, 34, 18, 2, 114, 98, 82, 66,
608  49, 33, 17, 1, 113, 97, 81, 65,
609  48, 32, 16, 0, 112, 96, 80, 64
610  } ;
611 
612 
613  constexpr short m_slot[8]={5,7,9,11,3,4,5,6};
614 
615  constexpr int NWREC = 8;
616  int pos=m_subfrag_firstdata;
617  for(unsigned int nfeb=0;nfeb<m_boards.size();nfeb++){ // FEB loop ----------------------------------
618  pos += NWREC*3; // skip FEB header
619  if(m_dump) logstr << MSG::DEBUG << " Board "<< nfeb << endmsg;
620  for(int s=0;s<m_samples[0];s++){ // sample loop ----------------------------------
621  pos +=NWREC;
622  int samp;
623  for(unsigned int g=0;g<m_gains.size();g++){ // gain loop ----------------------------------
624  int gainmode;
625 
626  // According to 'FebAuto' keys, sort sample (cf Petr G. doc)
627  if(m_febgain[nfeb]==0){ // Default behavior
628  gainmode=m_gains[g];
629  if((gainmode==0)&&((m_sampleOrder[0]=m_firstsamples[0])!=0))
630  {
631  for(int j=0;j<m_firstsamples[0];j++) {m_sampleOrder[j+1]=j;}
632  }
633  }
634  else { // this FEB is AutoGain and first sample given in m_febgain
635  gainmode=0;
636  if((m_sampleOrder[0]=m_febgain[nfeb])!=0){
637  for(int j=0;j<m_febgain[nfeb];j++) {m_sampleOrder[j+1]=j;}
638  }
639  }
640  samp=m_sampleOrder[s];
641 
642  if(m_dump&&(gainmode==2)) logstr << MSG::DEBUG << " channels ";
643  for( int i= 0 ;i<64; i++){ // channel loop ----------------------------------
644  int chan= m_sort[i];
645 
646  unsigned short tmp1 = firstword(m_rodBlock[pos]);
647  unsigned short gain1 = ((tmp1>>12)&3) - 1;
648  m_arrayofsample[chan+8][gainmode][samp]=firstnbit(12,tmp1);
649 
650  unsigned short tmp2 = secondword(m_rodBlock[pos]);
651  unsigned short gain2 = ((tmp2>>12)&3) - 1;
652  m_arrayofsample[chan][gainmode][samp]=firstnbit(12,tmp2);
653 
654  m_arrayofgain[chan+8][gainmode] = getCaloGain(gain1);
655  m_arrayofgain[chan][gainmode] = getCaloGain(gain2);
656 
657 
658  // if(m_dump&(gainmode==2)) logstr << MSG::INFO << " " <<firstnbit(12,tmp1);
659  if(m_dump&&(gainmode==2)) logstr << MSG::DEBUG << " (," << chan << ","<< gainmode <<"," << samp <<","<< m_arrayofsample[chan+8][gainmode][samp]<<")";
660  pos++;
661  } // end channel loop
662 
663  if(m_dump&&(gainmode==2)) logstr << MSG::DEBUG <<endmsg;
664  } // end gain loop
665  }// end sample loop
666  pos+= NWREC*2;
667  logstr << MSG::DEBUG << " Creating LArDigit for board "<< nfeb << ". m_febgain=" << m_febgain[nfeb] <<endmsg;
668  // create and store LArDigit.
669  for(unsigned int g=0;g<m_gains.size();g++){ // loop on reqested gains
670  int gainmode;
671  if(m_febgain[nfeb]==0){ // Default behavior
672  gainmode= m_gains[g];
673  } else { // this FEB is AutoGain and first sample given in m_febgain
674  gainmode=0;
675  }
676 
677  logstr << MSG::DEBUG << "Gain mode="<< gainmode <<endmsg;
678  for(int i=0;i<128;i++) { // loop on channels
679 
680  std::vector<short> samplevec(m_arrayofsample[i][gainmode]);
681  samplevec.resize(m_samples[0]);
682  CaloGain::CaloGain gain= m_arrayofgain[i][gainmode];
683  HWIdentifier hwid=m_onlineHelper->channel_Id(1,1,m_feedthrough[m_boards[nfeb]-1],m_slot[m_boards[nfeb]-1],i);
684  LArDigit * lardig= new LArDigit(hwid,gain,samplevec);
685  m_tblardigitcont[gainmode]->push_back(lardig);
686  if(m_isCalib) {
687  bool isPulsed=false;
688  const std::vector<HWIdentifier>& calibChannelIDs=calibLine->calibSlotLine(hwid);
689  if (calibChannelIDs.size() != 0) {
690  // Now figure out if any calibration line connected to this channel is pulsed.
691  // I'm going to cheat and use the fact that we only pulsed one board at a time
692  // and only wrote the corresponding digits (EMEC/HEC/FCAL)
693  for (HWIdentifier calChan : calibChannelIDs) {
694  int chan = m_onlineHelper->channel(calChan);
695  int bit = chan%8;
696  int byte = chan/8;
697  // if( 1<<bit & m_calib_pattern[byte] ) {
698  if( 128>>bit & m_calib_pattern[byte] ) {
699  isPulsed = true;
700  }
701  }
702  }
703  LArCalibDigit * larcalibdig= new LArCalibDigit(hwid,gain,samplevec,m_calib_dac,m_calib_delay,isPulsed);
704  m_tblarcalibdigitcont[gainmode]->push_back(larcalibdig);
705  }
706  }
707  if(m_febgain[nfeb]!=0){ // this FEB is AutoGain ignore every gain in FebGain
708  break;
709  }
710  }
711  }// FEB loop
712 
713  }
714  break;
715 
716  case 0x03: // TIME_ID -----------------------------------------
717  {
718  logstr << MSG::DEBUG << "H6BuildObject : TIME_ID "<< m_subfrag_size << endmsg;
719  name1="word1frag0x03chan";
720  name2="word2frag0x03chan";
721 
722 
723  if(m_subfrag_size!=5) {
724  logstr<<MSG::ERROR<< "Beam counter subfrag (0x03) has not expected size" <<endmsg;
725  sc=StatusCode::FAILURE;
726  break;
727  }
728  int pos=m_subfrag_firstdata;
729  int tmp1,tmp2;
730 
731  tmp1 = firstword(m_rodBlock[pos]);
732  tmp2 = secondword(m_rodBlock[pos]);
733 
734  if(m_dump) logstr << MSG::INFO << " sub frag 0x03 : word1="<<tmp1<<" word2="<< tmp2 <<endmsg;
735 
736  TBTDCRaw * clocktdc = new TBTDCRaw(name1+'0',false,tmp1,false);
737  TBTDCRaw * clock_deltdc = new TBTDCRaw(name2+'0',false,tmp2,false);
738  m_tdcrawCont->push_back(clocktdc);
739  m_tdcrawCont->push_back(clock_deltdc);
740 
741  tmp1 = firstword(m_rodBlock[pos+1]);
742  tmp2 = secondword(m_rodBlock[pos+1]);
743 
744  if(m_dump) logstr << MSG::INFO << " sub frag 0x03 : word1="<<tmp1<<" word2="<< tmp2 <<endmsg;
745 
746  TBTDCRaw * scale1 = new TBTDCRaw(name1+'1',false,tmp1,false);
747  TBTDCRaw * scale1bis = new TBTDCRaw(name2+'1',false,tmp2,false);
748  m_tdcrawCont->push_back(scale1);
749  m_tdcrawCont->push_back(scale1bis);
750 
751  tmp1 = firstword(m_rodBlock[pos+2]);
752  tmp2 = secondword(m_rodBlock[pos+2]);
753 
754  if(m_dump) logstr << MSG::INFO << " sub frag 0x03 : word1="<<tmp1<<" word2="<< tmp2 <<endmsg;
755 
756  TBTDCRaw * scale2 = new TBTDCRaw(name1+'2',false,tmp1,false);
757  TBTDCRaw * scale2bis = new TBTDCRaw(name2+'2',false,tmp2,false);
758  m_tdcrawCont->push_back(scale2);
759  m_tdcrawCont->push_back(scale2bis);
760 
761  }
762  break;
763  case 0x04: // TAIL_ID -----------------------------------------
764  {
765  name1="word1frag0x06chan";
766  name2="word2frag0x06chan";
767  std::string tcname="tc";
768  std::vector<TBScintillatorRaw *> theScints;
769  if(m_subfrag_size!=26) {
770  logstr<<MSG::ERROR<< "Beam counter subfrag (0x04) has not expected size" <<endmsg;
771  sc=StatusCode::FAILURE;
772  break;
773  }
774  logstr << MSG::DEBUG << "H6BuildObject : building tailcatcher " << endmsg;
775  for(unsigned int i=0;i<24;i++){
776  int tmp1,tmp2;
777  int pos=m_subfrag_firstdata+i;
778  unsigned short word1=firstword(m_rodBlock[pos]);
779  unsigned short word2=secondword(m_rodBlock[pos]);
780 
781  tmp1 = firstnbit(10,word1);
782  tmp2 = firstnbit(10,word2);
783 
784  os.str("");
785  os << name1 << i;
786  TBADCRaw* adc1 = new TBADCRaw(os.str(),false,abs(tmp1));
787  os.str("");
788  os << name2 << i;
789  TBADCRaw* adc2 = new TBADCRaw(os.str(),false,abs(tmp2));
790  if(testbit(10,word1)) adc1->setOverflow(); // if bit10=0 -> Overflow
791  if(testbit(10,word2)) adc2->setOverflow(); // if bit10=0 -> Overflow
792  m_adcrawCont->push_back(adc1);
793  m_adcrawCont->push_back(adc2);
794  os.str("");
795  os << tcname << 2*i;
796  TBScintillatorRaw* s1 = new TBScintillatorRaw(os.str(),m_tdcrawCont,dummytdc,m_adcrawCont,adc1);
797  os.str("");
798  os << tcname << 2*i+1;
799  TBScintillatorRaw* s2 = new TBScintillatorRaw(os.str(),m_tdcrawCont,dummytdc,m_adcrawCont,adc2);
800  theScints.push_back(s1);
801  theScints.push_back(s2);
802  }
803 
804  m_tailcatchraw = new TBTailCatcherRaw("TailCatherRaw",false,theScints);
805  //if(unrec_code == 4 ) gotobject=true;
806  }
807  break;
808 
809  case 0x05: // BPC_ID -----------------------------------------
810  {
811  name1="word1frag0x05chan";
812  name2="word2frag0x05chan";
813  //m_bpcrawCont = new TBBPCRawCont();
814  int bpcnum = (m_subfrag_size - 2) / 3; // cause we store 6 tdc/adc in 16bits word
815  logstr << MSG::DEBUG << "H6BuildObject : number of BPCRaw "<< bpcnum << endmsg;
816  // get bpc raw information for each chamber:
817  for(int i=0;i<bpcnum;i++){
818  std::string bpcname = "BPC";
819  os.str("");
820  os << bpcname << i;
821  bpcname= os.str();
822  std::vector<const TBTDCRaw*> theTDCs;
823  std::vector<const TBADCRaw*> theADCs;
824  int pos=m_subfrag_firstdata;
825 
826  unsigned int tmp1,tmp2;
827  tmp1=firstword(m_rodBlock[pos+i*3]);
828  tmp2=secondword(m_rodBlock[pos+i*3]);
829  os.str("");
830  os << name1 << (i*3);
831  TBADCRaw* tbadcH = new TBADCRaw(os.str(),(tmp1>1023),tmp1);
832  os.str("");
833  os << name2 << (i*3);
834  TBADCRaw* tbadcV = new TBADCRaw(os.str(),(tmp1>1023),tmp2);
835  m_adcrawCont->push_back(tbadcH);
836  m_adcrawCont->push_back(tbadcV);
837 
838  // first word is right :
839  tmp1=firstword(m_rodBlock[pos+i*3+1]);
840  tmp2=secondword(m_rodBlock[pos+i*3+1]);
841  os.str("");
842  os << name2 << (i*3+1);
843  TBTDCRaw * tbtdcL = new TBTDCRaw(os.str(),(tmp2>2047),tmp2,0);
844  os.str("");
845  os << name1 << (i*3+1);
846  TBTDCRaw * tbtdcR = new TBTDCRaw(os.str(),(tmp1>2047),tmp1,0);
847  // no under threshold ??
848  m_tdcrawCont->push_back(tbtdcR);
849  m_tdcrawCont->push_back(tbtdcL);
850  MSG::hex(logstr) << MSG::DEBUG << bpcname<< " "<< tmp1;
851  MSG::hex(logstr) << " "<< tmp2<<" ";
852 
853  tmp1=firstword(m_rodBlock[pos+i*3+2]);
854  tmp2=secondword(m_rodBlock[pos+i*3+2]);
855  os.str("");
856  os << name1 << (i*3+2);
857  TBTDCRaw * tbtdcU = new TBTDCRaw(os.str(),(tmp1>2047),tmp1,0);
858  os.str("");
859  os << name2 << (i*3+2);
860  TBTDCRaw * tbtdcD = new TBTDCRaw(os.str(),(tmp2>2047),tmp2,0);
861  // no under threshold ??
862  m_tdcrawCont->push_back(tbtdcU);
863  m_tdcrawCont->push_back(tbtdcD);
864  MSG::hex(logstr) << MSG::DEBUG << bpcname<< " "<< tmp1;
865  MSG::hex(logstr) << " "<< tmp2<<endmsg;
866 
867 
868  theTDCs.push_back(tbtdcL);
869  theTDCs.push_back(tbtdcR); // Fill the tdc/adc list
870  theTDCs.push_back(tbtdcU); // for this BPC
871  theTDCs.push_back(tbtdcD); // !! THE ORDER MATTERS !!
872  theADCs.push_back(tbadcH);
873  theADCs.push_back(tbadcV);
874  TBBPCRaw *bpcraw = new TBBPCRaw(bpcname,m_tdcrawCont,theTDCs,m_adcrawCont,theADCs);
875  m_bpcrawCont->push_back(bpcraw);
876  }
877  //if( unrec_code == 5 ) gotobject=true;
878 
879  }
880  break;
881 
882  case 0x06: // SCINTILLATOR_ID -----------------------------------------
883  {
884  name1="word1frag0x06chan";
885  name2="word2frag0x06chan";
886  if(m_subfrag_size!=11) {
887  logstr<<MSG::ERROR<< "Beam counter subfrag (0x06) has not expected size" <<endmsg;
888  sc=StatusCode::FAILURE;
889  break;
890  }
891 
892  logstr << MSG::DEBUG << " Building TBScintillatorRawCont with key " << m_keys[6] << endmsg;
893 
894  TBScintillatorRaw * S1 = new TBScintillatorRaw("S1");
895  TBScintillatorRaw * S2 = new TBScintillatorRaw("S2");
896  TBScintillatorRaw * S3 = new TBScintillatorRaw("S3");
897  TBScintillatorRaw * B = new TBScintillatorRaw("B");
898  TBScintillatorRaw * Veto = new TBScintillatorRaw("Veto");
899  TBScintillatorRaw * Halo = new TBScintillatorRaw("Halo");
900  TBScintillatorRaw * muon[8];
901 
902  logstr << MSG::DEBUG << " building muon counters:";
903  for(int i=0;i<8;i++) {
904  std::string scintname="muon";
905  os.str("");
906  os << scintname << (i+1);
907  scintname=os.str();
908  logstr << MSG::DEBUG << " " << scintname;
909  muon[i] = new TBScintillatorRaw(scintname);
910  }
911  logstr << endmsg;
912 
913  int tmp1,tmp2;
914  int pos=m_subfrag_firstdata;
915  unsigned short word1=firstword(m_rodBlock[pos]);
916  unsigned short word2=secondword(m_rodBlock[pos]);
917 
918  tmp1 = firstnbit(10,word1);
919  tmp2 = firstnbit(10,word2);
920 
921  TBADCRaw* Badc = new TBADCRaw(name1+'0',false,abs(tmp1));
922  TBADCRaw* Haloadc = new TBADCRaw(name2+'0',false,abs(tmp2));
923  if(testbit(10,word1)) Badc->setOverflow(); // if bit10=0 -> Overflow
924  if(testbit(10,word2)) Haloadc->setOverflow(); // if bit10=0 -> Overflow
925  m_adcrawCont->push_back(Badc);
926  m_adcrawCont->push_back(Haloadc);
927 
928  tmp1 = firstnbit(10,firstword(m_rodBlock[pos+1]));
929  tmp2 = firstnbit(10,secondword(m_rodBlock[pos+1]));
930  TBADCRaw* S3adc = new TBADCRaw(name1+'1',false,abs(tmp1));
931  TBADCRaw* S2adc = new TBADCRaw(name2+'1',false,abs(tmp2));
932  if(testbit(10,word1)) S3adc->setOverflow(); // if bit10=0 -> Overflow
933  if(testbit(10,word2)) S2adc->setOverflow(); // if bit10=0 -> Overflow
934  m_adcrawCont->push_back(S3adc);
935  m_adcrawCont->push_back(S2adc);
936 
937  tmp1 = firstnbit(10,firstword(m_rodBlock[pos+2]));
938  TBADCRaw* S1adc = new TBADCRaw(name1+'2',false,abs(tmp1));
939  if(testbit(10,word1)) S1adc->setOverflow(); // if bit10=0 -> Overflow
940  m_adcrawCont->push_back(S1adc);
941 
942  for(int i=0;i<4;i++) {
943  tmp1 = firstnbit(10,secondword(m_rodBlock[pos+2+i]));
944  tmp2 = firstnbit(10,firstword(m_rodBlock[pos+3+i]));
945  os.str("");
946  os << name1 << (0+2+i);
947  TBADCRaw* adc1 = new TBADCRaw(os.str(),false,abs(tmp1));
948  os.str("");
949  os << name2 << (0+3+i);
950  TBADCRaw* adc2 = new TBADCRaw(os.str(),false,abs(tmp2));
951  // muon[i]
952  // muon[i+1]->setSignal(abs(tmp2));
953  if(testbit(10,word1)) adc1->setOverflow(); // if bit10=0 -> Overflow
954  if(testbit(10,word2)) adc2->setOverflow(); // if bit10=0 -> Overflow
955  m_adcrawCont->push_back(adc1);
956  m_adcrawCont->push_back(adc2);
957  muon[2*i]->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,adc1);
958  muon[2*i+1]->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,adc2);
959  }
960 
961 
962  tmp1 = firstnbit(11,secondword(m_rodBlock[pos+6]));
963  TBTDCRaw* S2tdc = new TBTDCRaw(name2+'6',false,abs(tmp1),0);
964  m_tdcrawCont->push_back(S2tdc);
965 
966  // Overflows ?? underthreshold ??
967  tmp1 = firstnbit(11,firstword(m_rodBlock[pos+7]));
968  tmp2 = firstnbit(11,secondword(m_rodBlock[pos+7]));
969  TBTDCRaw* S3tdc = new TBTDCRaw(name1+'7',false,abs(tmp1),0);
970  TBTDCRaw* Btdc = new TBTDCRaw(name2+'7',false,abs(tmp2),0);
971  m_tdcrawCont->push_back(S3tdc);
972  m_tdcrawCont->push_back(Btdc);
973 
974  tmp1 = firstnbit(11,firstword(m_rodBlock[pos+8]));
975  tmp2 = firstnbit(11,secondword(m_rodBlock[pos+8]));
976  TBTDCRaw* Halotdc = new TBTDCRaw(name1+'8',false,abs(tmp1),0);
977  TBTDCRaw* VetoORtdc = new TBTDCRaw(name2+'8',false,abs(tmp2),0);
978  m_tdcrawCont->push_back(Halotdc);
979  m_tdcrawCont->push_back(VetoORtdc);
980 
981 
982  // Fill container
983  S1->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,S1adc);
984  S2->setSignals(m_tdcrawCont,S2tdc,m_adcrawCont,S2adc);
985 
986 
987  // logstr << MSG::INFO << "S1 adc ovf = "<< S1->isADCOverflow() << " // S1adc = "<< S1adc->isOverflow() <<endmsg;
988  // logstr << MSG::INFO << "S2 adc ovf = "<< S2->isADCOverflow() << " // S2adc = "<< S2adc->isOverflow() <<endmsg;
989 
990  S3->setSignals(m_tdcrawCont,S3tdc,m_adcrawCont,S3adc);
991  Veto->setSignals(m_tdcrawCont,VetoORtdc,m_adcrawCont,dummyadc);
992  Halo->setSignals(m_tdcrawCont,Halotdc,m_adcrawCont,Haloadc);
993  B->setSignals(m_tdcrawCont,Btdc,m_adcrawCont,Badc);
994 
995  m_scintrawCont->push_back(S1);
996  m_scintrawCont->push_back(S2);
997  m_scintrawCont->push_back(S3);
998  m_scintrawCont->push_back(Veto);
999  m_scintrawCont->push_back(Halo);
1000  m_scintrawCont->push_back(B);
1001  for(int i=0;i<8;i++) {
1002  m_scintrawCont->push_back(muon[i]);
1003  }
1004 
1005  logstr << MSG::DEBUG << " Should I record TBScintillatorRawCont with key " << m_keys[6] << " ? " << endmsg;
1006  //if(unrec_code == 6 ) gotobject=true;
1007  }
1008  break;
1009 
1010  case 0x07: // MWPC_ID -----------------------------------------
1011  {
1012  int pos=m_subfrag_firstdata;
1013  int nword = m_subfrag_size - 2;
1014  logstr << MSG::DEBUG << " Found MWPC subfragment. Nword= "<<nword << endmsg;
1015 
1016  std::string mwpcnames[8]= {"X2","Y2","X3","Y3","X4","Y4","X5","Y5"};
1017  bool isX[9]={true,false,true,false,true,false,true,false};
1018  TBMWPCRaw * mwpcraw[8];
1019  for( int i=0;i<8;i++){
1020  mwpcraw[i] = new TBMWPCRaw(mwpcnames[i]);
1021  }
1022 
1023  unsigned short status= secondword(m_rodBlock[pos+nword-1]);
1024  //bool error = false ;
1025  if(status==0) status= firstword(m_rodBlock[pos+nword-1]);
1026  else { // first 16 bit word is data
1027  unsigned short word1=firstword(m_rodBlock[pos+nword-1]);
1028  int w; // cluster width
1029  int c; // the starting channel of a cluster (0<start<4096)
1030  int chamber; // 0=X2, 1=Y2, 2=X3, 3=Y3, 4=X4, 5=Y4, 6=X5, 7=Y5
1031  int wire; // wire number
1032 
1033  w = (int) (word1>>12); c = (int) ((0xfff & word1) - w/2 + !(w&1));
1034  if( c < 768 ) {chamber = c/128; wire=c-chamber*128;}
1035  else {chamber=6+(c-768)/64; wire=c-768-(chamber-6)*64;}
1036 
1037  if(chamber>7){logstr << MSG::DEBUG << "Wrong MWPC chamber number : "<< chamber <<endmsg;}
1038  else{
1039  mwpcraw[chamber]->addCwireno(wire);
1040  mwpcraw[chamber]->addNwires(w);
1041  mwpcraw[chamber]->setXchambers(isX[chamber]);
1042  logstr << MSG::DEBUG << " MWPC chamber="<< chamber<< " wire=" << wire << " (w="<<w<<")" << " c="<<c<< endmsg;
1043  }
1044  }
1045 
1046  if(status != 0x1000) {MSG::hex(logstr)<< MSG::DEBUG << "MWPC status word error =" << status <<endmsg; /*error=true;*/}
1047 
1048  for( int i=0;i<m_subfrag_size-2;i++){ // "-2" because last full word contains status word (see above)
1049  unsigned short word1=firstword(m_rodBlock[pos+i]);
1050  unsigned short word2=secondword(m_rodBlock[pos+i]);
1051  int w; // cluster width
1052  int c; // the starting channel of a cluster (0<start<4096)
1053  int chamber; // 0=X2, 1=Y2, 2=X3, 3=Y3, 4=X4, 5=Y4, 6=X5, 7=Y5
1054  int wire; // wire number
1055 
1056  w = (int) (word1>>12); c = (int) ((0xfff & word1) - w/2 + !(w&1));
1057  if( c < 768 ) {chamber = c/128; wire=c-chamber*128;}
1058  else {chamber=6+(c-768)/64; wire=c-768-(chamber-6)*64;}
1059 
1060  if(chamber>7){logstr << MSG::DEBUG << "Wrong MWPC chamber number : "<< chamber <<endmsg;}
1061  else{
1062  mwpcraw[chamber]->addCwireno(wire);
1063  mwpcraw[chamber]->addNwires(w);
1064  mwpcraw[chamber]->setXchambers(isX[chamber]);
1065  logstr << MSG::DEBUG << " MWPC chamber="<< chamber<< " wire=" << wire << " (w="<<w<<")" << " c="<<c<< endmsg;
1066  }
1067 
1068  w = (int) (word2>>12); c = (int) ((0xfff & word2) - w/2 + !(w&1));
1069  if( c < 768 ) {chamber = c/128; wire=c-chamber*128;}
1070  else {chamber=6+(c-768)/64; wire=c-768-(chamber-6)*64;}
1071 
1072 
1073  if(chamber>7){logstr << MSG::INFO << "Wrong MWPC chamber number : "<< chamber <<endmsg;}
1074  else{
1075  mwpcraw[chamber]->addCwireno(wire);
1076  mwpcraw[chamber]->addNwires(w);
1077  mwpcraw[chamber]->setXchambers(isX[chamber]);
1078  logstr << MSG::DEBUG << " MWPC chamber="<< chamber<< " wire=" << wire << " (w="<<w<<")" << " c="<<c<< endmsg;
1079  }
1080 
1081  }
1082 
1083  for( int i=0;i<8;i++){
1084  m_mwpcrawCont->push_back(mwpcraw[i]);
1085  }
1086 
1087  logstr << MSG::DEBUG << " End of MWPC subfragment " << endmsg;
1088  //if(unrec_code == 7 ) gotobject=true;
1089 
1090  }
1091  break;
1092  case 0xf1: // Run header -----------------------------------------
1093  {
1094  int pos=m_subfrag_firstdata;
1095  char *strw;
1096  int nword = m_subfrag_size - 2;
1097  if(nword%16){
1098  logstr << MSG::ERROR << "bad number of lines. nwords=" << nword <<endmsg;
1099  break;
1100  }
1101  int nline= nword / 16;
1102  strw = (char*)&m_rodBlock[pos];
1103  for(int i=0;i<nline;i++){
1104  // strw = (char*) &m_rodBlock[pos+i*64];
1105  std::string sline="";
1106  std::string skey="";
1107  for(int j=0;j<63;j++) {
1108  if(strw[i*64+j]==0) break;
1109  sline+=strw[i*64+j];
1110  }
1111  //logstr << MSG::INFO << sline << endmsg;
1112  std::istringstream iss (sline);
1113  iss >> skey;
1114  if(skey=="RunNumber") {
1115  MSG::dec(logstr) << MSG::DEBUG << sline << endmsg;
1116  iss >> m_run_num;
1117  }
1118  if(skey=="BeamMomentum") {
1119  MSG::dec(logstr) << MSG::DEBUG << sline << endmsg;
1120  iss >> m_beam_moment;
1121  }
1122  if(skey=="BeamParticle") {
1123  MSG::dec(logstr) << MSG::DEBUG << sline << endmsg;
1124  iss >> m_beam_part;
1125  }
1126  if(skey=="CryoX") {
1127  MSG::dec(logstr) << MSG::DEBUG << sline << endmsg;
1128  iss >> m_cryoX;
1129  }
1130  if(skey=="CryoAngle") {
1131  MSG::dec(logstr) << MSG::DEBUG << sline << endmsg;
1132  iss >> m_cryoAngle;
1133  }
1134  if(skey=="TableY") {
1135  MSG::dec(logstr) << MSG::DEBUG << sline << endmsg;
1136  iss >> m_tableY;
1137  }
1138  if(skey=="miniROD") {
1139  logstr << MSG::DEBUG << sline << endmsg;
1140  m_boards.clear();
1141  int board;
1142  // iss>>board;
1143  while(iss.good()) {iss>>board;m_boards.push_back(board);}
1144  logstr << MSG::DEBUG << "Found nboards="<< m_boards.size() << endmsg;
1145  for(unsigned i=0;i<m_boards.size();i++)logstr << MSG::DEBUG << m_boards[i]<<" ";
1146  logstr << MSG::DEBUG<<endmsg;
1147  }
1148  if(skey=="FebSamples") {
1149  MSG::dec(logstr) << MSG::DEBUG << sline << endmsg;
1150  m_samples.clear();
1151  int sample;
1152  // iss>>sample;
1153  while(iss.good()) {iss>>sample;m_samples.push_back(sample);}
1154  MSG::dec(logstr) << MSG::DEBUG << "nsample="<< m_samples.size() << endmsg;
1155  for(unsigned i=0;i<m_samples.size();i++)logstr << MSG::DEBUG << m_samples[i]<<" ";
1156  logstr << MSG::DEBUG<<endmsg;
1157  }
1158  if(skey=="FebGains") {
1159  MSG::dec(logstr) << MSG::DEBUG << sline << endmsg;
1160  m_gains.clear();
1161  int gain;
1162  // iss>>gain;
1163  while(iss.good()) {iss>>gain;m_gains.push_back(gain);}
1164  int gs=m_gains.size() ;
1165  if(gs>1) if(m_gains[gs-1]==m_gains[gs-2])m_gains.resize(gs-1);
1166  MSG::dec(logstr) << MSG::DEBUG << "numb of gains="<< m_gains.size() << endmsg;
1167  for(unsigned i=0;i<m_gains.size();i++)logstr << MSG::DEBUG << m_gains[i]<<" ";
1168  logstr << MSG::DEBUG<<endmsg;
1169  }
1170  if(skey=="FebAuto") {
1171  MSG::dec(logstr) << MSG::DEBUG << sline << endmsg;
1172  m_febgain.clear();
1173  int gain;
1174  // iss>>gain;
1175  while(iss.good()) {iss>>gain;m_febgain.push_back(gain);}
1176  MSG::dec(logstr) << MSG::DEBUG << "n febauto="<< m_febgain.size() << " " << endmsg;
1177  for(unsigned i=0;i<m_febgain.size();i++)logstr << MSG::DEBUG << m_febgain[i]<<" ";
1178  logstr << MSG::DEBUG<<endmsg;
1179  }
1180  if(skey=="FebFirstSample") {
1181  MSG::dec(logstr) << MSG::DEBUG << sline << endmsg;
1182  m_firstsamples.clear();
1183  int firstsample;
1184  // iss>>firstsample;
1185  while(iss.good()) {iss>>firstsample;m_firstsamples.push_back(firstsample);}
1186  MSG::dec(logstr) << MSG::DEBUG << "firstsample="<< m_firstsamples.size() << endmsg;
1187  }
1188  }
1189 
1190  // If there was no febgain initialise to 0 :
1191  if(m_febgain.size()==0) m_febgain.resize(8,0);
1192  // now initialize every vector :
1193  for(int i=0;i<128;i++) {for(int j=0;j<4;j++) {m_arrayofsample[i][j].clear();m_arrayofsample[i][j].resize(32,0);}}
1194 
1195  // m_summary_path = m_summary_path+"/run";
1196 // m_summary_path = m_summary_path+m_run_num;
1197 // m_summary_path = m_summary_path+".summary";
1198  std::ofstream outfile(m_summary_path.c_str());
1199 
1200  outfile << "Run number " << m_run_num << std::endl;
1201  outfile << std::endl;
1202  outfile << "Beam Type \t " << m_beam_part << std::endl;
1203  outfile << "Beam Momentum \t " << m_beam_moment << std::endl;
1204  outfile << std::endl;
1205  outfile << "Cryostat X pos \t " << m_cryoX << std::endl;
1206  outfile << "Cryostat Angle \t " << m_cryoAngle << std::endl;
1207  outfile << "Table Y pos \t " << m_tableY << std::endl;
1208 
1209 
1210 
1211  }
1212  break;
1213  case 0xff : // Calib_ID ------------------------------------
1214  {
1215  int pos=m_subfrag_firstdata;
1216  int nword = m_subfrag_size - 2;
1217  logstr << MSG::DEBUG << " Found Calib_ID subfragment. Nword= "<<nword << endmsg;
1218  if(nword!=6) { // expect 6 words (to hold 22 bytes)
1219  logstr<<MSG::ERROR<< "Calibration subfrag (0xff) has not expected size" <<endmsg;
1220  sc=StatusCode::FAILURE;
1221  break;
1222  }
1223 
1224  m_isCalib = true;
1225 
1226  for(int i=0;i<4;i++){ // get channel pattern
1227  int first16 = firstword(m_rodBlock[pos+i]);
1228  int second16 = secondword(m_rodBlock[pos+i]);
1229 
1230  m_calib_pattern[4*i] = 255 & first16;
1231  m_calib_pattern[4*i+1] = first16 >> 8;
1232  m_calib_pattern[4*i+2] = 255 & second16;
1233  m_calib_pattern[4*i+3] = second16 >> 8;
1234  }
1235 
1236  logstr << MSG::DEBUG << "Found calibration header information " << endmsg;
1237  logstr << MSG::DEBUG << " Calib pattern: " << endmsg;
1238  for(int byte=0; byte<16; byte++) {
1239  logstr << MSG::DEBUG << " byte " << byte << " : " ;
1240  for(int bit=0; bit<8; bit++) {
1241  // bool onoff = 1<<bit & m_calib_pattern[byte];
1242  bool onoff = 128>>bit & m_calib_pattern[byte];
1243  logstr << MSG::DEBUG << onoff << "/" ;
1244  }
1245  logstr << MSG::DEBUG << endmsg;
1246  }
1247 
1248  // See http://cern.ch/atlas-fcaltb/Memos/DAQ/DataFormat.general.pdf
1249  // http://cern.ch/atlas-fcaltb/Data-taking/CBT2/Beam_fragment_format.sxw.pdf
1250  // (Petr Gorbunov H6 FCAL documentation.)
1251  m_calib_dac = firstword(m_rodBlock[pos+4]);
1252 
1253  unsigned first16 = firstword(m_rodBlock[pos+5]);
1254  m_calib_delay = 255 & first16;
1255  m_calib_error = ((first16 >> 8) != 0);
1256 
1257  // logstr << MSG::DEBUG << " Pattern 0/1/2/3 = " << m_calib_pattern[0]
1258  // << "/" << m_calib_pattern[1]
1259  // << "/" << m_calib_pattern[2]
1260  // << "/" << m_calib_pattern[3] << endmsg;
1261  logstr << MSG::DEBUG << " DAC = " << m_calib_dac << endmsg;
1262  logstr << MSG::DEBUG << " DELAY = " << m_calib_delay << endmsg;
1263  }
1264  break;
1265  default : // -----------------------------------------
1266  logstr << MSG::DEBUG << "Found undefined subfragment id= "<< m_subfrag_id << endmsg;
1267  break;
1268  }
1269  }
1270 
1271  sc = H6RecordObjects(unrec_code);
1272  return sc;
1273 
1274 
1275 }

◆ H6RecordObjects()

StatusCode TBByteStreamCnvTool::H6RecordObjects ( int  unrec_code)

Definition at line 1912 of file TBByteStreamCnvTool.cxx.

1913 {
1914 
1915  StatusCode sc;
1916  MsgStream logstr(msgSvc(), name());
1917  logstr << MSG::DEBUG << "About to try recording. unrec_code = " << unrec_code << endmsg;
1918 
1919  if( !m_tailcatchraw) {
1920  logstr << MSG::DEBUG << " WARNING! Did not find TailCatcher. Returning an empty one : this may crash every attempt to use it" << endmsg;
1921  m_tailcatchraw = new TBTailCatcherRaw();
1922  }
1923 
1924  if(unrec_code!=1) { // If object was not requested by the converter, store it in SG
1925  logstr << MSG::DEBUG << "Recording TBTriggerPatternUnit with key " << m_keys[1] << endmsg;
1926  sc = evtStore()->record(m_trigpat,m_keys[1]);
1927  if ( sc.isFailure( ) ) {
1928  logstr << MSG::ERROR << "Cannot record TBTrigPat " << endmsg;
1929  }
1930  }
1931 
1932  if(unrec_code!=4){ // If object was not requested by the converter, store it in SG
1933  logstr << MSG::DEBUG << "Recording TBTailCatcherRaw with key " << m_keys[4] << endmsg;
1934  sc = evtStore()->record(m_tailcatchraw,m_keys[4]);
1935  if ( sc.isFailure( ) ) {
1936  logstr << MSG::ERROR << "Cannot record TailCatcherRaw " << endmsg;
1937  }
1938  }
1939 
1940  if(unrec_code!=5) { // If object was not requested by the converter, store it in SG
1941  logstr << MSG::DEBUG << "Recording TBBPCRawCont with key " << m_keys[5] << endmsg;
1942  // if(! evtStore()->contains<TBBPCRawCont>(m_keys[5])) {
1943  sc = evtStore()->record(m_bpcrawCont,m_keys[5]);
1944  if ( sc.isFailure( ) ) {
1945  logstr << MSG::ERROR << "Cannot record BPCRawCont" << endmsg;
1946  }
1947  // } else {
1948  // logstr << MSG::ERROR << " Object TBBPCRawCont already in SG (memory leak!)" << endmsg;
1949  // }
1950  }
1951 
1952  if(unrec_code!=6){ // If object was not requested by the converter, store it in SG
1953  logstr << MSG::DEBUG << "Recording TBScintillatorRawCont with key " << m_keys[6] << endmsg;
1954  // if(! evtStore()->contains<TBScintillatorRawCont>(m_keys[6])) {
1955  sc = evtStore()->record(m_scintrawCont,m_keys[6]);
1956  if ( sc.isFailure( ) ) {
1957  logstr << MSG::ERROR << "Cannot record ScintRawCont " << endmsg;
1958  }
1959  // } else {
1960  // logstr << MSG::ERROR << " Object TBScintillatorRawCont already in SG (memory leak!)" << endmsg;
1961  // }
1962  }
1963 
1964  if(unrec_code!=7){ // If object was not requested by the converter, store it in SG
1965  // if(! evtStore()->contains<TBMWPCRawCont>(m_keys[7])) {
1966  logstr << MSG::DEBUG << "record TBMWPCRawCont with key " << m_keys[7] <<endmsg;
1967  sc = evtStore()->record(m_mwpcrawCont,m_keys[7]);
1968  if ( sc.isFailure( ) ) {
1969  logstr << MSG::ERROR << "Cannot record MWPCRawCont " << endmsg;
1970  }
1971  // } else {
1972  // logstr << MSG::ERROR << " Object TBMWPCRawCont already in SG (memory leak!)" << endmsg;
1973  // }
1974  }
1975 
1976  // TDCRaw and ADCRaw are special since they are build from all
1977  // subfragments in H6. Record them slightly differently.
1978 
1979  if(unrec_code!=2){ // If object was not requested by the converter, store it in SG
1980  logstr << MSG::DEBUG << "record TDC cont with key " << m_keys[2] << endmsg;
1981  // if(! evtStore()->contains<TBTDCRawCont>(m_keys[2])) {
1982  sc = evtStore()->record(m_tdcrawCont,m_keys[2]);
1983  if ( sc.isFailure( ) ) {
1984  logstr << MSG::ERROR << "Cannot record TDCCont " << endmsg;
1985  }
1986  }
1987  // } else {
1988  // logstr << MSG::ERROR << " Object TBTDCRawCont already in SG (memory leak!)" << endmsg;
1989  // }
1990 
1991 
1992  if(unrec_code!=3){ // If object was not requested by the converter, store it in SG
1993  logstr << MSG::DEBUG << "record ADC cont with key " << m_keys[3] << endmsg;
1994  // if(! evtStore()->contains<TBADCRawCont>(m_keys[3])) {
1995  sc = evtStore()->record(m_adcrawCont,m_keys[3]);
1996  if ( sc.isFailure( ) ) {
1997  logstr << MSG::FATAL << "Cannot record ADCCont " << endmsg;
1998  }
1999  }
2000  // } else {
2001  // logstr << MSG::ERROR << " Object TBADCRawCont already in SG (memory leak!)" << endmsg;
2002  // }
2003 
2004  for(int c=10;c<14;c++){
2005  if(unrec_code!=c){ // If object was not requested by the converter, store it in SG
2006 
2007  logstr << MSG::DEBUG << "record TBLArDigitContainer with key " << m_keys[c] << " and size " << m_tblardigitcont[c-10]->size() << endmsg;
2008  sc = evtStore()->record(m_tblardigitcont[c-10],m_keys[c]);
2009  if ( sc.isFailure( ) ) {
2010  logstr << MSG::FATAL << "Cannot record " <<m_keys[c-10]<< endmsg;
2011  }
2012  }
2013  }
2014 
2015  for(int c=10;c<14;c++){
2016  if(unrec_code!=c){ // If object was not requested by the converter, store it in SG
2017 
2018  logstr << MSG::DEBUG << "record TBLArCalibDigitContainer with key " << m_keys[c] << " and size " << m_tblarcalibdigitcont[c-10]->size() << endmsg;
2019  sc = evtStore()->record(m_tblarcalibdigitcont[c-10],m_keys[c]);
2020  if ( sc.isFailure( ) ) {
2021  logstr << MSG::FATAL << "Cannot record " <<m_keys[c-10]<< endmsg;
2022  }
2023  }
2024  }
2025 
2026  if(unrec_code!=30){ // If object was not requested by the converter, store it in SG
2027  sc = evtStore()->record(m_eventinfo,"TBEventInfo");
2028  if ( sc.isFailure( ) ) {
2029  logstr << MSG::FATAL << "Cannot record TBEventInfo "<< endmsg;
2030  }
2031  }
2032  // } else {
2033  // logstr << MSG::ERROR << " Object TBADCRawCont already in SG (memory leak!)" << endmsg;
2034  // }
2035 
2036  logstr << MSG::DEBUG << " End of H6 Record " << endmsg;
2037 
2038  // Print run summary in text file
2039 
2040  return sc;
2041 
2042 }

◆ H8BuildObjects()

StatusCode TBByteStreamCnvTool::H8BuildObjects ( int  unrec_code)

Build all beam detectors raw objects from m_rodBlock using H8 convention. Objects are recorded in SG if they do not correspond to unrec_code Will return faillure if : -one of the object could not be recorded in SG -the requested object (unrec_code) was not found

Definition at line 1279 of file TBByteStreamCnvTool.cxx.

1282 {
1291  MsgStream logstr(msgSvc(), name());
1292  logstr << MSG::DEBUG << "H8BuildObject invoked for code " << unrec_code<< endmsg;
1293 
1294  StatusCode sc=StatusCode::FAILURE;
1295  bool gotobject=false;
1296  bool recordfailure=false;
1297 
1298  bool goodRodBlock=true; // This is a hack to avoid runtime exceptions
1299 
1300  std::string name;
1301 
1302 
1303  // Get ROD block.
1304  sc=GetRODBlock(m_subdet_id,eformat::TDAQ_BEAM_CRATE); //Possible improvement: Check if vector is already valid.
1305  //sc=GetRODBlock(EventFormat::TDAQ_BEAM_CRATE);
1306 
1307  if (sc!=StatusCode::SUCCESS) {
1308  // return sc;
1309  logstr << MSG::ERROR << "ReadRodBlock: RodBlock error! Will try to fill SG with empty objects." << endmsg;
1310  goodRodBlock=false;
1311  }
1312  if (m_rodBlock.size()<2) {
1313  logstr << MSG::ERROR << "ReadRodBlock: RodBlock too small! Will try to fill SG with empty objects." << endmsg;
1314  // return StatusCode::FAILURE;
1315  goodRodBlock=false;
1316  }
1317 
1318  m_tdcrawCont = new TBTDCRawCont();
1319  m_adcrawCont = new TBADCRawCont();
1320 
1321  // Define some dummy ADC & TDC :
1322  TBADCRaw* dummyadc = new TBADCRaw("dummy",true,0);
1323  TBTDCRaw* dummytdc = new TBTDCRaw("dummy",true,0,true);
1324  m_tdcrawCont->push_back(dummytdc);
1325  m_adcrawCont->push_back(dummyadc);
1326 
1327 
1328  // Scintillator init :
1329  TBScintillatorRaw * S0 = new TBScintillatorRaw("S0");
1330  TBScintillatorRaw * S1 = new TBScintillatorRaw("S1");
1331  TBScintillatorRaw * S2up = new TBScintillatorRaw("S2-Up");
1332  TBScintillatorRaw * S2down = new TBScintillatorRaw("S2-Down");
1333  TBScintillatorRaw * S3left = new TBScintillatorRaw("S3-Left");
1334  TBScintillatorRaw * S3right = new TBScintillatorRaw("S3-Right");
1335  TBScintillatorRaw * C1 = new TBScintillatorRaw("C1");
1336  TBScintillatorRaw * C2 = new TBScintillatorRaw("C2");
1337  TBScintillatorRaw * muTag = new TBScintillatorRaw("muTag");
1338  TBScintillatorRaw * muHalo = new TBScintillatorRaw("muHalo");
1339  TBScintillatorRaw * muVeto = new TBScintillatorRaw("muVeto");
1340  TBScintillatorRaw * sTRT = new TBScintillatorRaw("TRTSci");
1341 
1342  // S0 has only TDC
1343  TBTDCRaw* S0tdc =dummytdc;
1344  // S1,S2,S3 have 1 TDC +1 ADC
1345  TBADCRaw * S1adc=dummyadc;
1346  TBTDCRaw * S1tdc=dummytdc;
1347 
1348  TBADCRaw * S2upadc=dummyadc;
1349  TBTDCRaw * S2uptdc=dummytdc;
1350  TBADCRaw * S2downadc=dummyadc;
1351  TBTDCRaw * S2downtdc=dummytdc;
1352 
1353  TBADCRaw * S3leftadc=dummyadc;
1354  TBTDCRaw * S3lefttdc=dummytdc;
1355  TBADCRaw * S3rightadc=dummyadc;
1356  TBTDCRaw * S3righttdc=dummytdc;
1357  //Clock phase
1358  TBTDCRaw * ClockPhasetdc=dummytdc;
1359 
1360  //The following Scintillators have only ADC
1361  TBADCRaw * muTagadc=dummyadc;
1362  TBADCRaw * C1adc=dummyadc;
1363  TBADCRaw * C2adc=dummyadc;
1364  TBADCRaw * muHaloadc=dummyadc;
1365  TBADCRaw * muVetoadc=dummyadc;
1366  TBADCRaw * sTRTadc=dummyadc;
1367 
1368  // Define BPCs
1369  // Some data words for tdc channels may be absent and if not they arrive in a
1370  // different order than the one we need to store in TBBPCRaw. So we need all this stuff to get
1371  // everything done :
1372  int BPCNum=5;
1373  TBBPCRaw* bpcraw[5];
1374  TBTDCRaw * BPCtdc[5][4];
1375  short tdc_order[4] = {2,3,0,1}; // bytestream : udlr - TBBPCRaw lrud
1376  for(int i=0;i<BPCNum;i++){
1377  bpcraw[i] = new TBBPCRaw("BPC");
1378  for(int j=0;j<4;j++) BPCtdc[i][j]=0;
1379  }
1380  bpcraw[0]->setDetectorName("BPC-2");
1381  bpcraw[1]->setDetectorName("BPC-1");
1382  bpcraw[2]->setDetectorName("BPC0");
1383  bpcraw[3]->setDetectorName("BPC1");
1384  bpcraw[4]->setDetectorName("BPC2");
1385 
1386  // for string conversion
1387  std::ostringstream os;
1388 
1389  // Now loop through fragment
1390 
1391  // with this initialisation, first call of NextSubFrag will initialise correctly the index :
1392  m_subfrag_id=0;
1393  m_subfrag_size=2;
1394  m_subfrag_firstdata=0;
1395  // while(NextSubFrag()){
1396  while(NextSubFrag() and goodRodBlock){ // Hack for bad ROD block
1397  switch(m_subfrag_id){
1398  case 0x10: // ADC1 block --------------------------------------
1399  {
1400  name="frag0x10chan";
1401  logstr << MSG::DEBUG << "Got SubFragment " << MSG::hex << m_subfrag_id << " name=" << name
1402  << " Data words = " << MSG::dec << m_subfrag_size-2<<endmsg;
1403 
1404  int pos=m_subfrag_firstdata;
1405 
1406  // Overflows ??
1407 
1408  S1adc = new TBADCRaw(name+"0",false,m_rodBlock[pos] & 0xfff);
1409  // do not set signal here cause we also need TDC (in 0x11)
1410  logstr << MSG::DEBUG << "S1adc: 0x" << MSG::hex << (int)(m_rodBlock[pos] & 0xfff) << " [0x" << m_rodBlock[pos] << "]"
1411  << MSG::dec << endmsg;
1412  m_adcrawCont->push_back(S1adc);
1413 
1414  pos++; // 2
1415  S2upadc = new TBADCRaw(name+"1",false,m_rodBlock[pos] & 0xfff);
1416  logstr << MSG::DEBUG << "S2 :" << MSG::hex << (m_rodBlock[pos] & 0xfff) << " [0x" << m_rodBlock[pos] << "]"
1417  << MSG::dec << endmsg;
1418  m_adcrawCont->push_back(S2upadc);
1419 
1420 
1421  pos++; // 2
1422  S3rightadc = new TBADCRaw(name+"2",false,m_rodBlock[pos] & 0xfff);
1423  logstr << MSG::DEBUG << "S3 :" << MSG::hex << (m_rodBlock[pos] & 0xfff) << " [0x" << m_rodBlock[pos] << "]"
1424  << MSG::dec << endmsg;
1425  m_adcrawCont->push_back(S3rightadc);
1426 
1427 
1428  pos++; // 2
1429  muTagadc = new TBADCRaw(name+"3",false,m_rodBlock[pos] & 0xfff);
1430  logstr << MSG::DEBUG << "muTag :" << MSG::hex << (m_rodBlock[pos] & 0xfff) << " [0x" << m_rodBlock[pos] << "]"
1431  << MSG::dec << endmsg;
1432  m_adcrawCont->push_back(muTagadc);
1433  //muTag->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,muTagadc);
1434 
1435  pos++; // 2
1436  C1adc = new TBADCRaw(name+"4",false,m_rodBlock[pos] & 0xfff);
1437  logstr << MSG::DEBUG << "C1 :" << MSG::hex << (m_rodBlock[pos] & 0xfff) << " [0x" << m_rodBlock[pos] << "]"
1438  << MSG::dec << endmsg;
1439  m_adcrawCont->push_back(C1adc);
1440  //C1->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,C1adc);
1441 
1442  pos++; // 2
1443  C2adc = new TBADCRaw(name+"5",false,m_rodBlock[pos] & 0xfff);
1444  logstr << MSG::DEBUG << "C2 :" << MSG::hex << (m_rodBlock[pos] & 0xfff) << " [0x" << m_rodBlock[pos] << "]"
1445  << MSG::dec << endmsg;
1446  m_adcrawCont->push_back(C2adc);
1447  //C2->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,C2adc);
1448 
1449 
1450  pos++; // 2
1451  muHaloadc = new TBADCRaw(name+"6",false,m_rodBlock[pos] & 0xfff);
1452  logstr << MSG::DEBUG << "muHalo :" << MSG::hex << (m_rodBlock[pos] & 0xfff) << " [0x" << m_rodBlock[pos] << "]"
1453  << MSG::dec << endmsg;
1454  m_adcrawCont->push_back(muHaloadc);
1455  //muHalo->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,muHaloadc);
1456 
1457  pos++; // 2
1458  muVetoadc = new TBADCRaw(name+"7",false,m_rodBlock[pos] & 0xfff);
1459  logstr << MSG::DEBUG << "muVeto :" << MSG::hex << (m_rodBlock[pos] & 0xfff) << " [0x" << m_rodBlock[pos] << "]"
1460  << MSG::dec << endmsg;
1461  m_adcrawCont->push_back(muVetoadc);
1462  //muVeto->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,muVetoadc);
1463 
1464  if(m_dump){
1465  logstr << MSG::INFO << " DUMP : ";
1466  logstr << name << " "<< m_subfrag_size-2 <<" words - " << S1adc->getADC() << " " << S2upadc->getADC();
1467  logstr << " " << S3rightadc->getADC()<< " " << muTagadc->getADC() << " " << C1adc->getADC();
1468  logstr << " " << C2adc->getADC() << " " << muHaloadc->getADC() << " "<< muVetoadc->getADC() <<endmsg ;
1469 
1470  }
1471 
1472  }
1473  break;
1474  case 0x11: // ADC2 segment ----------------------------------
1475  {
1476  name="frag0x11chan";
1477  logstr << MSG::DEBUG << "Got SubFragment " << MSG::hex << m_subfrag_id << " name=" << name
1478  << " Data words = " << MSG::dec << m_subfrag_size-2<<endmsg;
1479 
1480  int pos=m_subfrag_firstdata;
1481 
1482  // channel 0 not used
1483  // Modification: 2005/01/27 W.L. channel 0 used by TRT Scintillator
1484  sTRTadc = new TBADCRaw(name+"0",false,m_rodBlock[pos] & 0xfff);
1485  logstr << MSG::DEBUG << "sTRT:" << MSG::hex << (m_rodBlock[pos] & 0xfff) << " [0x" << m_rodBlock[pos] << "]"
1486  << MSG::dec << endmsg;
1487  pos++; //1
1488  S2downadc = new TBADCRaw(name+"1",false,m_rodBlock[pos] & 0xfff);
1489  logstr << MSG::DEBUG << "S2 :" << MSG::hex << (m_rodBlock[pos] & 0xfff) << " [0x" << m_rodBlock[pos] << "]"
1490  << MSG::dec << endmsg;
1491  m_adcrawCont->push_back(S2downadc);
1492 
1493  pos++; // 2
1494  S3leftadc = new TBADCRaw(name+"2",false,m_rodBlock[pos] & 0xfff);
1495  logstr << MSG::DEBUG << "S3 :" << MSG::hex << (m_rodBlock[pos] & 0xfff) << " [0x" << m_rodBlock[pos] << "]"
1496  << MSG::dec << endmsg;
1497  m_adcrawCont->push_back(S3leftadc);
1498 
1499  if(m_dump){
1500  logstr << MSG::INFO << " DUMP : ";
1501  logstr << name << " "<< m_subfrag_size-2 <<" words - " << S2downadc->getADC() << " " << S3leftadc->getADC()<<endmsg;
1502  }
1503 
1504  }
1505  break;
1506  case 0x12: // ps TDC --------------------------------------
1507  {
1508  name="frag0x12chan";
1509  logstr << MSG::DEBUG << "Got SubFragment " << MSG::hex << m_subfrag_id << " name=" << name
1510  << " Data words = " << MSG::dec << m_subfrag_size-2<<endmsg;
1511  int pos=m_subfrag_firstdata;
1512  if(m_dump) logstr << MSG::INFO << " DUMP : "<< name<< " "<< m_subfrag_size-2 <<" words - " ;
1513 
1514  for( int i=0;i<m_subfrag_size-2;i++){
1515  pos=m_subfrag_firstdata+i;
1516  // get channel number
1517  const int chan= (m_rodBlock[pos] >> 16) & 0x1F;
1518  const unsigned int tdc = m_rodBlock[pos] & 0xfff; // 12 first bits (0-11)
1519  const int corrup = (m_rodBlock[pos]>>21)&0x3f; // test bits 21-26
1520  const bool endofdata=(((m_rodBlock[pos] >> 24)&0x7)==0x4);
1521  // from doc it appears that endofdata <=> corrup==32
1522  const bool overflow=(m_rodBlock[pos]>>12)&1;
1523  const bool underthresh=(m_rodBlock[pos]>>13)&1;
1524  logstr << MSG::DEBUG << MSG::dec << "Pos=" << pos <<" Chan "<< chan << "=" << tdc << ", OV=" << overflow
1525  << ", UN=" <<underthresh << " EOD="<< endofdata << ", corrupt=" << corrup
1526  << " [0x" << MSG::hex << m_rodBlock[pos] << "]" << MSG::dec <<endmsg;
1527  if(m_dump)
1528  MSG::dec(logstr) << " "<< (m_rodBlock[pos] & 0xfff);
1529 
1530 
1531  if (!endofdata && !corrup) {
1532  os.str("");
1533  os << name << chan;
1534  switch(chan){
1535  case 0:
1536  ClockPhasetdc = new TBTDCRaw(os.str(),overflow,tdc,underthresh);
1537  m_tdcrawCont->push_back(ClockPhasetdc);
1538  break;
1539  case 1:
1540  S1tdc = new TBTDCRaw(os.str(),overflow,tdc,underthresh);
1541  m_tdcrawCont->push_back(S1tdc);
1542  break;
1543  case 2:
1544  S2downtdc = new TBTDCRaw(os.str(),overflow,tdc,underthresh);
1545  m_tdcrawCont->push_back(S2downtdc);
1546  break;
1547  case 3:
1548  S3lefttdc = new TBTDCRaw(os.str(),overflow,tdc,underthresh);
1549  m_tdcrawCont->push_back(S3lefttdc);
1550  break;
1551  case 4:
1552  S2uptdc = new TBTDCRaw(os.str(),overflow,tdc,underthresh);
1553  m_tdcrawCont->push_back(S2uptdc);
1554  break;
1555  case 5:
1556  S3righttdc = new TBTDCRaw(os.str(),overflow,tdc,underthresh);
1557  m_tdcrawCont->push_back(S3righttdc);
1558  break;
1559  case 6:
1560  S0tdc = new TBTDCRaw(os.str(),overflow,tdc,underthresh);
1561  m_tdcrawCont->push_back(S0tdc);
1562  break;
1563  default:
1564  break;
1565  } // end switch
1566  }//end if not corrupted and not end of data
1567  else
1568 
1569  if (endofdata) {
1570  if (i==m_subfrag_size-3)
1571  logstr << MSG::DEBUG << " End of data word found at pos " << pos <<endmsg;
1572  else
1573  logstr << MSG::ERROR << " Unexpected end-of-data word found at pos " << pos <<endmsg;
1574  }
1575  else // corrupt
1576  logstr<< MSG::ERROR << "Corrupted data in SubFragment 0x12 pos=" << pos << "channel=" <<chan << " [0x" <<
1577  MSG::hex << m_rodBlock[pos] << "]" << MSG::dec<<endmsg;
1578  } //end loop over subfrags
1579  if(m_dump) logstr << endmsg;
1580  }
1581  break;
1582  case 0x13: // ns TDC (for BPC) --------------------------------------
1583  {
1584  name="frag0x13chan";
1585  logstr << MSG::DEBUG << "Got SubFragment " << MSG::hex << m_subfrag_id << " name=" << name
1586  << " Data words = " << MSG::dec << m_subfrag_size-2<<endmsg;
1587  if(m_dump) logstr << MSG::INFO << " DUMP : "<< name<< " "<< m_subfrag_size-2 <<" words - " << endmsg;
1588  for( int i=0;i<m_subfrag_size-2;i++){
1589  int pos=m_subfrag_firstdata+i;
1590  // get channel number
1591  const int chan= (m_rodBlock[pos] >> 17) & 0xF; // bits 17-20
1592  const unsigned int tdc = m_rodBlock[pos] & 0xffff; // 16 first bits (0-15)
1593  const bool corrup = (m_rodBlock[pos]>>21)&0x1; // test bit 21
1594  const bool endofdata=!((m_rodBlock[pos] >> 23)&0x1); // test bit 23
1595  logstr << MSG::DEBUG << MSG::dec <<"Pos=" << pos << " Chan "<< chan << "=" << tdc
1596  << " EOD="<< endofdata << ", corrupt=" << corrup
1597  << " [0x" << MSG::hex << m_rodBlock[pos] << "]" << MSG::dec <<endmsg;
1598  if (!endofdata && !corrup) {
1599  os.str("");
1600  os << name << chan;
1601  TBTDCRaw * tbtdc = new TBTDCRaw(os.str(),false,tdc,false);
1602  m_tdcrawCont->push_back(tbtdc);
1603  const short bpc_ind = chan / 4 ;
1604  if(bpc_ind>4) {
1605  logstr<< MSG::DEBUG << "Error in 0x13 : found chan="<<chan<<" corresponding to bpc "<<bpc_ind<<endmsg;
1606  continue;
1607  }
1608  const short signaltype = tdc_order[chan % 4];
1609  if (BPCtdc[bpc_ind][signaltype]==NULL)
1610  BPCtdc[bpc_ind][signaltype] = tbtdc;
1611  }
1612  else
1613  if (endofdata) {
1614  if (i==m_subfrag_size-3)
1615  logstr << MSG::DEBUG << " End of data word found at pos " << pos <<endmsg;
1616  else
1617  logstr << MSG::ERROR << " Unexpected end-of-data word found at pos " << pos <<endmsg;
1618  }
1619  else // corrupt
1620  logstr<< MSG::ERROR << "Corrupted data in SubFragment 0x13 pos=" << pos << "channel=" <<chan << " [0x" <<
1621  MSG::hex << m_rodBlock[pos] << "]" << MSG::dec<<endmsg;
1622  } // end for loop
1623 
1624  }
1625  break;
1626  case 0x14: // ns TDC (for BPC) --------------------------------------
1627  {
1628  name="frag0x14chan";
1629  logstr << MSG::DEBUG << "Got SubFragment " << MSG::hex << m_subfrag_id << " name=" << name
1630  << " Data words = " << MSG::dec << m_subfrag_size-2<<endmsg;
1631 
1632 
1633  if(m_dump) logstr << MSG::INFO << " DUMP : "<< name<< " "<< m_subfrag_size-2 <<" words - " << endmsg;
1634 
1635 
1636  for( int i=0;i<m_subfrag_size-2;i++){
1637  int pos=m_subfrag_firstdata+i;
1638 
1639  // get channel number
1640  const int chan= (m_rodBlock[pos] >> 17) & 0xF; // bits 17-20
1641  const unsigned int tdc = m_rodBlock[pos] & 0xffff; // 16 first bits (0-15)
1642  const bool corrup = (m_rodBlock[pos]>>21)&0x1; // test bit 21
1643  const bool endofdata=!((m_rodBlock[pos] >> 23)&0x1); // test bit 23
1644  //const bool overflow=(m_rodBlock[pos]>>12)&1;
1645  //const bool underthresh=(m_rodBlock[pos]>>13)&1;
1646  logstr << MSG::DEBUG << MSG::dec << "Pos=" << pos << " Chan "<< chan << "=" << tdc
1647  << " EOD="<< endofdata << ", corrupt=" << corrup
1648  << " [0x" << MSG::hex << m_rodBlock[pos] << "]" << MSG::dec <<endmsg;
1649 
1650  if (!endofdata && !corrup) {
1651  os.str("");
1652  os << name << chan;
1653  TBTDCRaw * tbtdc = new TBTDCRaw(os.str(),false,tdc,false);
1654  m_tdcrawCont->push_back(tbtdc);
1655  const short bpc_ind = chan / 4 + 3;
1656  if(bpc_ind>4) { logstr<< MSG::DEBUG << "Error in 0x14 : found chan="<<chan<<" corresponding to bpc "<<bpc_ind<<endmsg;continue;}
1657  const short signaltype = tdc_order[chan % 4];
1658  if (BPCtdc[bpc_ind][signaltype]==NULL)
1659  BPCtdc[bpc_ind][signaltype] = tbtdc;
1660  }
1661  else
1662  if (endofdata) {
1663  if (i==m_subfrag_size-3)
1664  logstr << MSG::DEBUG << " End of data word found at pos " << pos <<endmsg;
1665  else
1666  logstr << MSG::ERROR << " Unexpected end-of-data word found at pos " << pos <<endmsg;
1667  }
1668  else // corrupt
1669  logstr<< MSG::ERROR << "Corrupted data in SubFragment 0x14 pos=" << pos << "channel=" <<chan << " [0x" <<
1670  MSG::hex << m_rodBlock[pos] << "]" << MSG::dec<<endmsg;
1671  } // end for loop
1672  }
1673  break;
1674  case 0x15: // trigger word --------------------------------------
1675  {
1676  logstr << MSG::INFO << "Found trigger word fragment" << endmsg;
1677  }
1678  break;
1679  default :
1680  logstr << MSG::DEBUG << "Found undefined subfragment id= "<< m_subfrag_id << endmsg;
1681  break;
1682 
1683  }
1684  }
1685 
1686 
1687 
1688  logstr << MSG::DEBUG << "Filling Scint" << endmsg;
1689 
1690  // fill scint container
1691  m_scintrawCont = new TBScintillatorRawCont();
1692  //m_scintrawCont->push_back(S0);
1693  //logstr << MSG::DEBUG << "S1 " << endmsg
1694 
1695  // Here some tdc maybe missing, so test for them :
1696  if(S0tdc) S0->setSignals(m_tdcrawCont,S0tdc,m_adcrawCont,dummyadc); //Scintillator 0 has only TDC
1697  else S0->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,dummyadc);
1698  m_scintrawCont->push_back(S0);
1699 
1700  if(S1tdc && S1adc) S1->setSignals(m_tdcrawCont,S1tdc,m_adcrawCont,S1adc);
1701  else S1->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,S1adc);
1702  m_scintrawCont->push_back(S1);
1703 
1704  if(S2uptdc) S2up->setSignals(m_tdcrawCont,S2uptdc,m_adcrawCont,S2upadc);
1705  else S2up->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,S2upadc);
1706  m_scintrawCont->push_back(S2up);
1707 
1708  if(S2downtdc) S2down->setSignals(m_tdcrawCont,S2downtdc,m_adcrawCont,S2downadc);
1709  else S2down->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,S2downadc);
1710  m_scintrawCont->push_back(S2down);
1711 
1712  if(S3lefttdc) S3left->setSignals(m_tdcrawCont,S3lefttdc,m_adcrawCont,S3leftadc);
1713  else S3left->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,S3leftadc);
1714  m_scintrawCont->push_back(S3left);
1715 
1716  if(S3righttdc) S3right->setSignals(m_tdcrawCont,S3righttdc,m_adcrawCont,S3rightadc);
1717  else S3right->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,S3rightadc);
1718  m_scintrawCont->push_back(S3right);
1719 
1720  C1->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,C1adc);
1721  m_scintrawCont->push_back(C1);
1722  C2->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,C2adc);
1723  m_scintrawCont->push_back(C2);
1724  muTag->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,muTagadc);
1725  m_scintrawCont->push_back(muTag);
1726  muHalo->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,muHaloadc);
1727  m_scintrawCont->push_back(muHalo);
1728  muVeto->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,muVetoadc);
1729  m_scintrawCont->push_back(muVeto);
1730  sTRT->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,sTRTadc);
1731  m_scintrawCont->push_back(sTRT);
1732 
1733 
1734  // fill bpc container
1735  logstr << MSG::DEBUG << "Filling BPC" << endmsg;
1736  m_bpcrawCont = new TBBPCRawCont();
1737 
1738  for(int i=0;i<BPCNum;i++){
1739  std::vector<const TBTDCRaw*> listtdc;
1740  std::vector<const TBADCRaw*> listadc;
1741  for(int j=0;j<4;j++){
1742  if(BPCtdc[i][j]==0) listtdc.push_back(dummytdc);
1743  else listtdc.push_back(BPCtdc[i][j]);
1744  }
1745  listadc.push_back(dummyadc); listadc.push_back(dummyadc);
1746  bpcraw[i]->setSignals(m_tdcrawCont,listtdc,m_adcrawCont,listadc);
1747  m_bpcrawCont->push_back(bpcraw[i]);
1748  }
1749 
1750 
1751 
1752  // -----------------------------------------------------------------------------------------------
1753 
1754  // Now Get info from TileAux RodBlock subdet ID = 0x70
1755  //sc=GetRODBlock((EventFormat::SubDetector) 0x70); //Possible improvement: Check if vector is already valid.
1756  sc=GetRODBlock(m_subdet_id,eformat::TILECAL_LASER_CRATE);
1757  if (sc!=StatusCode::SUCCESS) {
1758  // return sc;
1759  goodRodBlock = false;
1760  logstr << MSG::ERROR << "Tile laser crate ROD block error! Nothing valid in SG." << endmsg;
1761  }
1762  if (m_rodBlock.size()<2) {
1763  logstr << MSG::ERROR << "Tile laser crate ROD block too small! Nothing valid in SG" << endmsg;
1764  // return StatusCode::FAILURE;
1765  goodRodBlock = false;
1766  }
1767 
1768  // with this initialisation, first call of NextSubFrag will initialise correctly the index :
1769  m_subfrag_id=0;
1770  m_subfrag_size=2;
1771  m_subfrag_firstdata=0;
1772  // while(NextSubFrag()){
1773  while(NextSubFrag() and goodRodBlock ){
1774  switch(m_subfrag_id){
1775  case 0x1: // ADC1 block --------------------------------------
1776  {
1777  name="frag0x1chan";
1778  int pos=m_subfrag_firstdata;
1779  TBScintillatorRaw * SC1 = new TBScintillatorRaw("SC1");
1780  TBADCRaw* SC1adc = new TBADCRaw(name+"0",false,m_rodBlock[pos] & 0xfff);
1781  m_adcrawCont->push_back(SC1adc);
1782  SC1->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,SC1adc);
1783  m_scintrawCont->push_back(SC1);
1784 
1785  pos++;
1786  TBScintillatorRaw * SC2 = new TBScintillatorRaw("SC2");
1787  TBADCRaw* SC2adc = new TBADCRaw(name+"1",false,m_rodBlock[pos] & 0xfff);
1788  m_adcrawCont->push_back(SC2adc);
1789  SC2->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,SC2adc);
1790  m_scintrawCont->push_back(SC2);
1791  logstr << MSG::DEBUG << "Found Scintillator SC1 and SC2" << endmsg;
1792  break;
1793  }
1794  case 0x2: // ADC2 block --------------------------------------
1795  {
1796 
1797  int pos=m_subfrag_firstdata;
1798  for(int i=0;i<8;i++){
1799  pos=pos+i;
1800  std::stringstream RawName;
1801  RawName << "frag0x1chan"<<i;
1802  TBADCRaw* MuWalladc = new TBADCRaw(RawName.str(),false,m_rodBlock[pos] & 0xfff);
1803  m_adcrawCont->push_back(MuWalladc);
1804 
1805  std::stringstream MuWallName;
1806  MuWallName << "MuWall"<<i;
1807  TBScintillatorRaw* MuWallScint = new TBScintillatorRaw(MuWallName.str());
1808  MuWallScint->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,MuWalladc);
1809  m_scintrawCont->push_back(MuWallScint);
1810  }
1811  logstr << MSG::DEBUG << "Found first muWall block" << endmsg;
1812  break;
1813  }
1814  case 0x3: // ADC3 block --------------------------------------
1815  {
1816 
1817  int pos=m_subfrag_firstdata;
1818 
1819  for(int i=0;i<4;i++){
1820  pos=pos+i;
1821  std::stringstream RawName;
1822  RawName << "frag0x1chan"<<(i+8);
1823  TBADCRaw* MuWalladc = new TBADCRaw(name,false,m_rodBlock[pos] & 0xfff);
1824  m_adcrawCont->push_back(MuWalladc);
1825 
1826  std::stringstream MuWallName;
1827  MuWallName << "MuWall"<<i+8;
1828  TBScintillatorRaw* MuWallScint = new TBScintillatorRaw(MuWallName.str());
1829  MuWallScint->setSignals(m_tdcrawCont,dummytdc,m_adcrawCont,MuWalladc);
1830  m_scintrawCont->push_back(MuWallScint);
1831  }
1832  logstr << MSG::DEBUG << "Found second muWall block" << endmsg;
1833  break;
1834  }
1835  default :
1836  if (m_subfrag_id!=3 && m_subfrag_id!=5 && m_subfrag_id!=7)
1837  logstr << MSG::DEBUG << "Found undefined subfragment id= "<< m_subfrag_id << endmsg;
1838  break;
1839 
1840  }
1841  }
1842 
1843 
1844 
1845 
1846  // -----------------------------------------------------------------------------------------------
1847 
1848  // Now record object if they have not been invoked from converter
1849 
1850 // if(unrec_code!=1){ // If object was not requested by the converter, store it in SG
1851 // sc = m_storeGate->record(m_trigpat,m_keys[1]);
1852 // if ( sc.isFailure( ) ) {recordfailure=true;
1853 // logstr << MSG::FATAL << "Cannot record TBTrigPat " << endmsg;
1854 // }
1855 // }else {sc=StatusCode::SUCCESS; gotobject=true;} // else return success to converter
1856 
1857 
1858  if(unrec_code!=5){ // If object was not requested by the converter, store it in SG
1859  sc = evtStore()->record(m_bpcrawCont,m_keys[5]);
1860  if ( sc.isFailure( ) ) {recordfailure=true;
1861  logstr << MSG::FATAL << "Cannot record BPCRawCont" << endmsg;
1862  }
1863  }else {sc=StatusCode::SUCCESS; gotobject=true;} // else return success to converter
1864 
1865 
1866  if(unrec_code!=6){ // If object was not requested by the converter, store it in SG
1867  sc = evtStore()->record(m_scintrawCont,m_keys[6]);
1868  if ( sc.isFailure( ) ) {recordfailure=true;
1869  logstr << MSG::FATAL << "Cannot record ScintRawCont " << endmsg;
1870  }
1871  } else {sc=StatusCode::SUCCESS; gotobject=true;} // else return success to converter
1872 
1873 
1874  if(unrec_code!=2){ // If object was not requested by the converter, store it in SG
1875  sc = evtStore()->record(m_tdcrawCont,m_keys[2]);
1876  if ( sc.isFailure( ) ) {recordfailure=true;
1877  logstr << MSG::FATAL << "Cannot record TDCCont " << endmsg;
1878  }
1879  }else {sc=StatusCode::SUCCESS; gotobject=true;} // else return success to converter
1880 
1881  if(unrec_code!=3){ // If object was not requested by the converter, store it in SG
1882  sc = evtStore()->record(m_adcrawCont,m_keys[3]);
1883  if ( sc.isFailure( ) ) {recordfailure=true;
1884  logstr << MSG::FATAL << "Cannot record ADCCont " << endmsg;
1885  }
1886  }else {sc=StatusCode::SUCCESS; gotobject=true;} // else return success to converter
1887 
1888 
1889  m_trigpat = new TBTriggerPatternUnit();
1890  m_trigpat->setTriggerWord(m_h8_triggword);
1891  if(unrec_code!=1) { // If object was not requested by the converter, store it in SG
1892  logstr << MSG::DEBUG << "Recording TBTriggerPatternUnit with key " << m_keys[1] << endmsg;
1893  // if(! evtStore()->contains<TBTriggerPatternUnit>(m_keys[1])) {
1894  sc = evtStore()->record(m_trigpat,m_keys[1]);
1895  if ( sc.isFailure( ) ) {
1896  logstr << MSG::ERROR << "Cannot record TBTrigPat " << endmsg;
1897  }
1898  } else {
1899  sc=StatusCode::SUCCESS;
1900  gotobject=true;
1901  } // else return success to converter
1902 
1903 
1904  logstr << MSG::DEBUG << " End of H8 Build " << endmsg;
1905  if(!gotobject) {logstr<< MSG::ERROR<< " Could not find object of type "<<unrec_code << endmsg; sc=StatusCode::FAILURE;}
1906  if(recordfailure) {logstr<< MSG::ERROR<< " One object could not be recorded "<< endmsg; sc=StatusCode::FAILURE;}
1907 
1908 
1909  return sc;
1910 }

◆ initialize()

StatusCode TBByteStreamCnvTool::initialize ( )
virtual

Definition at line 59 of file TBByteStreamCnvTool.cxx.

60 {StatusCode sc=AthAlgTool::initialize();
61  if (sc!=StatusCode::SUCCESS)
62  return sc;
63  MsgStream logstr(msgSvc(), name());
64  logstr << MSG::DEBUG << "Initialize" << endmsg;
65 
66  const LArOnlineID* online_id;
67  sc = detStore()->retrieve(online_id, "LArOnlineID");
68  if (sc.isFailure()) {
69  logstr << MSG::FATAL << "Could not get LArOnlineID helper !" << endmsg;
70  return StatusCode::FAILURE;
71  }
72  else {
73  m_onlineHelper=online_id;
74  logstr << MSG::DEBUG << " Found the LArOnlineID helper. " << endmsg;
75  }
76 
77  ATH_CHECK( m_ByteStreamEventAccess.retrieve() );
78  ATH_CHECK( m_rdpSvc.retrieve() );
79 
80  std::vector<std::string>::const_iterator it = m_keys.begin();
81  std::vector<std::string>::const_iterator it_e = m_keys.end();
82  std::vector<std::string> keys;
83  keys.resize(24);
84  for(; it!=it_e;++it) {
85  const Gaudi::Utils::TypeNameString &item(*it);
86  const std::string &t = item.type();
87  const std::string &nm = item.name();
88  logstr << MSG::DEBUG << " type "<<t<<" name="<<nm<<endmsg;
89  if(t=="TBTDC") keys[0]=nm;
90  if(t=="TBTriggerPatternUnit") keys[1]=nm;
91  if(t=="TBTDCRawCont") keys[2]=nm;
92  if(t=="TBADCRawCont") keys[3]=nm;
93  if(t=="TBTailCatcherRaw") keys[4]=nm;
94  if(t=="TBBPCRawCont") keys[5]=nm;
95  if(t=="TBScintillatorRawCont") keys[6]=nm;
96  if(t=="TBMWPCRawCont") keys[7]=nm;
97  }
98  // Fixed name.
99  keys[10]="FREE";
100  keys[11]="LOW";
101  keys[12]="MEDIUM";
102  keys[13]="HIGH";
103  // name for Calib Digits
104  keys[20]="FREE";
105  keys[21]="LOW";
106  keys[22]="MEDIUM";
107  keys[23]="HIGH";
108 
109 
110  m_keys=std::move(keys);
111  m_subdet_id=(eformat::SubDetector)m_subdet_key;
112 
113  m_isCalib = false;
114 
115  m_febgain.clear();
116 
117  ATH_CHECK( m_CLKey.initialize() );
118 
119  return StatusCode::SUCCESS;
120 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

◆ interfaceID()

const InterfaceID & TBByteStreamCnvTool::interfaceID ( )
static

Definition at line 30 of file TBByteStreamCnvTool.cxx.

31 {
32  static const InterfaceID IID_ITBByteStreamCnvTool
33  ("TBByteStreamCnvTool", 1, 0);
34  return IID_ITBByteStreamCnvTool;
35 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ NextSubFrag()

bool TBByteStreamCnvTool::NextSubFrag ( )
inlineprivate

Definition at line 114 of file TBByteStreamCnvTool.h.

114  {
115  m_subfrag_firstdata+=m_subfrag_size;
116  if(m_subfrag_firstdata<int(m_rodBlock.size())){
117  m_subfrag_size=m_rodBlock[m_subfrag_firstdata-2];
118  m_subfrag_id=m_rodBlock[m_subfrag_firstdata-1];
119  return true;
120  }else return false;
121  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

◆ ReadFragment() [1/12]

StatusCode TBByteStreamCnvTool::ReadFragment ( int  unrec_code)

Definition at line 262 of file TBByteStreamCnvTool.cxx.

262  {
263 
264  StatusCode sc;
265  if(m_H6run) sc=H6BuildObjects(unrec_code); // build all objects, do not record object unrec_code
266  if(m_H8run) sc=H8BuildObjects(unrec_code); // build all objects, do not record object unrec_code
267  return sc;
268 }

◆ ReadFragment() [2/12]

StatusCode TBByteStreamCnvTool::ReadFragment ( TBADCRawCont *&  adcrawCont,
const std::string &  key 
)

Definition at line 309 of file TBByteStreamCnvTool.cxx.

310 {MsgStream logstr(msgSvc(), name());
311  logstr << MSG::DEBUG <<" in ReadFragment (TBADCRawCont) key="<<key<<endmsg;
312  StatusCode sc=ReadFragment(3);
313  if(sc) adcrawCont = m_adcrawCont;
314  return sc;
315 }

◆ ReadFragment() [3/12]

StatusCode TBByteStreamCnvTool::ReadFragment ( TBBPCRawCont *&  bpcrawCont,
const std::string &  key 
)

Definition at line 292 of file TBByteStreamCnvTool.cxx.

293 {MsgStream logstr(msgSvc(), name());
294  logstr << MSG::DEBUG <<" in ReadFragment (TBBPCRawCont) key="<<key<<endmsg;
295  StatusCode sc=ReadFragment(5);
296  if(sc) bpcrawCont = m_bpcrawCont;
297  logstr << MSG::DEBUG <<" End ReadFragment (TBBPCRawCont) key="<<key<<endmsg;
298  return sc;
299 }

◆ ReadFragment() [4/12]

StatusCode TBByteStreamCnvTool::ReadFragment ( TBEventInfo *&  tbeventinfo,
const std::string &  key 
)

Definition at line 347 of file TBByteStreamCnvTool.cxx.

348 {MsgStream logstr(msgSvc(), name());
349  logstr << MSG::DEBUG <<" in ReadFragment (TBEventInfo) key="<<key<<endmsg;
350  StatusCode sc=ReadFragment(30);
351  if(sc) tbeventinfo = m_eventinfo;
352  return sc;
353 }

◆ ReadFragment() [5/12]

StatusCode TBByteStreamCnvTool::ReadFragment ( TBLArCalibDigitContainer *&  tblarcalibdigitcont,
const std::string &  key 
)

Definition at line 374 of file TBByteStreamCnvTool.cxx.

375 {MsgStream logstr(msgSvc(), name());
376  logstr << MSG::DEBUG <<" in ReadFragment (TBLArCalibDigitContainer) key="<<key<<endmsg;
377  int code=0;
378  if(key=="FREE") code = 20;
379  if(key=="LOW") code = 21;
380  if(key=="HIGH") code = 22;
381  if(key=="MEDIUM") code = 23;
382  if(code){
383  StatusCode sc=ReadFragment(code);
384  if(sc) tblarcalibdigitcont = m_tblarcalibdigitcont[code-20];
385  return sc;
386  }else{
387  logstr << MSG::ERROR <<" Can not create a LArCalibDigitContainer with key="<<key<<endmsg;
388  tblarcalibdigitcont =0;
389  return StatusCode::FAILURE;
390  }
391 }

◆ ReadFragment() [6/12]

StatusCode TBByteStreamCnvTool::ReadFragment ( TBLArDigitContainer *&  tblardigitcont,
const std::string &  key 
)

Definition at line 355 of file TBByteStreamCnvTool.cxx.

356 {MsgStream logstr(msgSvc(), name());
357  logstr << MSG::DEBUG <<" in ReadFragment (TBLArDigitContainer) key="<<key<<endmsg;
358  int code=0;
359  if(key=="FREE") code = 10;
360  if(key=="LOW") code = 11;
361  if(key=="HIGH") code = 12;
362  if(key=="MEDIUM") code = 13;
363  if(code){
364  StatusCode sc=ReadFragment(code);
365  if(sc) tblardigitcont = m_tblardigitcont[code-10];
366  return sc;
367  }else{
368  logstr << MSG::ERROR <<" Can not create a LArDigitContainer with key="<<key<<endmsg;
369  tblardigitcont =0;
370  return StatusCode::FAILURE;
371  }
372 }

◆ ReadFragment() [7/12]

StatusCode TBByteStreamCnvTool::ReadFragment ( TBMWPCRawCont *&  mwpcrawCont,
const std::string &  key 
)

Definition at line 301 of file TBByteStreamCnvTool.cxx.

302 {MsgStream logstr(msgSvc(), name());
303  logstr << MSG::DEBUG <<" in ReadFragment (TBMWPCRawCont) key="<<key<<endmsg;
304  StatusCode sc=ReadFragment(7);
305  if(sc) mwpcrawCont = m_mwpcrawCont;
306  return sc;
307 }

◆ ReadFragment() [8/12]

StatusCode TBByteStreamCnvTool::ReadFragment ( TBScintillatorRawCont *&  scintrawCont,
const std::string &  key 
)

Definition at line 332 of file TBByteStreamCnvTool.cxx.

333 {MsgStream logstr(msgSvc(), name());
334  logstr << MSG::DEBUG <<" in ReadFragment (TBScintrawcont) key="<<key<<endmsg;
335  StatusCode sc=ReadFragment(6);
336  if(sc) scintrawCont = m_scintrawCont;
337  return sc;
338 }

◆ ReadFragment() [9/12]

StatusCode TBByteStreamCnvTool::ReadFragment ( TBTailCatcherRaw *&  tailcatchraw,
const std::string &  key 
)

Definition at line 340 of file TBByteStreamCnvTool.cxx.

341 {MsgStream logstr(msgSvc(), name());
342  logstr << MSG::DEBUG <<" in ReadFragment (TBTailCatcherRaw) key="<<key<<endmsg;
343  StatusCode sc=ReadFragment(4);
344  if(sc) tailcatchraw = m_tailcatchraw;
345  return sc;
346 }

◆ ReadFragment() [10/12]

StatusCode TBByteStreamCnvTool::ReadFragment ( TBTDC *&  tdc,
const std::string &  key 
)

This method is used only for testing

Definition at line 270 of file TBByteStreamCnvTool.cxx.

271 {
273  MsgStream logstr(msgSvc(), name());
274  logstr << MSG::DEBUG <<" in ReadFragment (TBTDC) key="<<key<<endmsg;
275  StatusCode sc=GetRODBlock(m_subdet_id); //Possible improvement: Check if vector is already valid.
276  if (sc!=StatusCode::SUCCESS)
277  return sc;
278  if (m_rodBlock.size()<2)
279  {
280  logstr << "ReadRodBlock: RodBlock too small!" << endmsg;
281  return StatusCode::FAILURE;
282  }
283  int tdc=m_rodBlock[0];
284  int tdcmin=m_rodBlock[1];
285  logstr << MSG::DEBUG <<" tdc = "<< tdc <<endmsg;
286  logstr << MSG::DEBUG <<" tdcmin = "<< tdcmin <<endmsg;
287  tbtdc=new TBTDC(tdc,tdcmin);
288  return StatusCode::SUCCESS;
289  // return sc;
290 }

◆ ReadFragment() [11/12]

StatusCode TBByteStreamCnvTool::ReadFragment ( TBTDCRawCont *&  tdcrawCont,
const std::string &  key 
)

Definition at line 316 of file TBByteStreamCnvTool.cxx.

317 {MsgStream logstr(msgSvc(), name());
318  logstr << MSG::DEBUG <<" in ReadFragment (TBTDCRawCont) key="<<key<<endmsg;
319  StatusCode sc=ReadFragment(2);
320  if(sc) tdcrawCont = m_tdcrawCont;
321  return sc;
322 }

◆ ReadFragment() [12/12]

StatusCode TBByteStreamCnvTool::ReadFragment ( TBTriggerPatternUnit *&  trigpat,
const std::string &  key 
)

Definition at line 324 of file TBByteStreamCnvTool.cxx.

325 {MsgStream logstr(msgSvc(), name());
326  logstr << MSG::DEBUG <<" in ReadFragment (TBTriggerPatternUnit) key="<<key<<endmsg;
327  StatusCode sc=ReadFragment(1);
328  if(sc) trigpat = m_trigpat;
329  return sc;
330 }

◆ 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< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ secondword()

unsigned short TBByteStreamCnvTool::secondword ( unsigned int  w)
inlineprivate

Definition at line 193 of file TBByteStreamCnvTool.h.

193  {
194  return w >> 16;
195  }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

◆ testbit()

bool TBByteStreamCnvTool::testbit ( int  n,
unsigned short  w 
)
inlineprivate

Definition at line 203 of file TBByteStreamCnvTool.h.

203  {
204  return (w & (1<<n));
205  }

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

◆ WriteFragment()

StatusCode TBByteStreamCnvTool::WriteFragment ( )

This creates the fragment for beam detectors calling BuildRodBlock method

Definition at line 133 of file TBByteStreamCnvTool.cxx.

134 {
138  MsgStream logstr(msgSvc(), name());
139  logstr << MSG::DEBUG << "WriteFragment" << endmsg;
140  //Check if Fragment is already written
141  const EventInfo* thisEventInfo;
142  StatusCode sc=evtStore()->retrieve(thisEventInfo);
143  if (sc!=StatusCode::SUCCESS)
144  {logstr << MSG::WARNING << "No EventInfo object found!" << endmsg;
145  return sc;
146  }
147  const EventID* thisEvent=thisEventInfo->event_ID();
148  if (m_lastEventID==*thisEvent)
149  {logstr << MSG::WARNING << "LArByteStrem persistency representation for Event #"<<thisEvent->event_number()
150  << " already created!" << endmsg;
151  return StatusCode::SUCCESS;
152  }
153  else //New event ID
154  m_lastEventID=*thisEvent;
155 
156  // Get the already existing part of the RawEvent
157  RawEventWrite* re = m_ByteStreamEventAccess->getRawEvent();
158 
159  // delete previous fragments
160  if (m_theRodBlock) delete m_theRodBlock;
161  if (m_theROB) delete m_theROB;
162 
163  //Make a new ROD-Fragment
164  m_theRodBlock=new std::vector<uint32_t>;
165 
166  sc=BuildRODBlock(m_theRodBlock);
167 
168  if (sc!=StatusCode::SUCCESS)
169  return sc;
170 
171  //Header elements for new Fragments
172  const uint8_t module_id=0;
173  const uint32_t lvl1_id=re->lvl1_id();
174  const uint32_t bc_id=0;
175  const uint32_t lvl1_type = 0;
176  const uint32_t detev_type=0;
177  const bool status_place=eformat::STATUS_BACK;
178  const uint32_t run_no=re->run_no();
179 
180  //Make a new ROB-Fragment...
181  eformat::helper::SourceIdentifier robsid(m_subdet_id, module_id);
182  m_theROB = new OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment
183  (robsid.code(),run_no,lvl1_id,bc_id,lvl1_type,detev_type,m_theRodBlock->size(),
184  &(*m_theRodBlock)[0],status_place);
185 
186  re->append(m_theROB); //Append the newly created Subdetector-Fragment to the full event
187  logstr << MSG::DEBUG << "Appended TestBeam fragment to ByteStream" << endmsg;
188  return StatusCode::SUCCESS;
189 }

Member Data Documentation

◆ m_adcrawCont

TBADCRawCont* TBByteStreamCnvTool::m_adcrawCont {}
private

Definition at line 129 of file TBByteStreamCnvTool.h.

◆ m_arrayofgain

CaloGain::CaloGain TBByteStreamCnvTool::m_arrayofgain[128][4] {}
private

Definition at line 147 of file TBByteStreamCnvTool.h.

◆ m_arrayofsample

std::vector<short> TBByteStreamCnvTool::m_arrayofsample[128][4]
private

Definition at line 146 of file TBByteStreamCnvTool.h.

◆ m_beam_moment

float TBByteStreamCnvTool::m_beam_moment {}
private

Definition at line 177 of file TBByteStreamCnvTool.h.

◆ m_beam_part

std::string TBByteStreamCnvTool::m_beam_part
private

Definition at line 178 of file TBByteStreamCnvTool.h.

◆ m_boards

std::vector<int> TBByteStreamCnvTool::m_boards
private

Definition at line 141 of file TBByteStreamCnvTool.h.

◆ m_bpcrawCont

TBBPCRawCont* TBByteStreamCnvTool::m_bpcrawCont {}
private

Definition at line 130 of file TBByteStreamCnvTool.h.

◆ m_ByteStreamEventAccess

ServiceHandle<IByteStreamEventAccess> TBByteStreamCnvTool::m_ByteStreamEventAccess
private

Definition at line 91 of file TBByteStreamCnvTool.h.

◆ m_calib_dac

uint16_t TBByteStreamCnvTool::m_calib_dac {}
private

Definition at line 168 of file TBByteStreamCnvTool.h.

◆ m_calib_delay

uint16_t TBByteStreamCnvTool::m_calib_delay {}
private

Definition at line 169 of file TBByteStreamCnvTool.h.

◆ m_calib_error

bool TBByteStreamCnvTool::m_calib_error {}
private

Definition at line 170 of file TBByteStreamCnvTool.h.

◆ m_calib_pattern

unsigned char TBByteStreamCnvTool::m_calib_pattern[16] {}
private

Definition at line 167 of file TBByteStreamCnvTool.h.

◆ m_CLKey

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

Definition at line 123 of file TBByteStreamCnvTool.h.

◆ m_cryoAngle

float TBByteStreamCnvTool::m_cryoAngle {}
private

Definition at line 180 of file TBByteStreamCnvTool.h.

◆ m_cryoX

float TBByteStreamCnvTool::m_cryoX {}
private

Definition at line 179 of file TBByteStreamCnvTool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_DontCheckRodSubDetID

const eformat::SubDetector TBByteStreamCnvTool::m_DontCheckRodSubDetID =(eformat::SubDetector)0xff
staticprivate

Definition at line 89 of file TBByteStreamCnvTool.h.

◆ m_dump

bool TBByteStreamCnvTool::m_dump {}
private

Definition at line 105 of file TBByteStreamCnvTool.h.

◆ m_ev_number

int TBByteStreamCnvTool::m_ev_number {}
private

Definition at line 175 of file TBByteStreamCnvTool.h.

◆ m_eventinfo

TBEventInfo* TBByteStreamCnvTool::m_eventinfo {}
private

Definition at line 135 of file TBByteStreamCnvTool.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_febgain

std::vector<int> TBByteStreamCnvTool::m_febgain
private

Definition at line 144 of file TBByteStreamCnvTool.h.

◆ m_firstsamples

std::vector<int> TBByteStreamCnvTool::m_firstsamples
private

Definition at line 145 of file TBByteStreamCnvTool.h.

◆ m_force_Hchoice

bool TBByteStreamCnvTool::m_force_Hchoice {}
private

Definition at line 104 of file TBByteStreamCnvTool.h.

◆ m_gains

std::vector<int> TBByteStreamCnvTool::m_gains
private

Definition at line 143 of file TBByteStreamCnvTool.h.

◆ m_H6run

bool TBByteStreamCnvTool::m_H6run {}
private

Definition at line 102 of file TBByteStreamCnvTool.h.

◆ m_h8_triggword

unsigned int TBByteStreamCnvTool::m_h8_triggword {}
private

Definition at line 187 of file TBByteStreamCnvTool.h.

◆ m_H8run

bool TBByteStreamCnvTool::m_H8run {}
private

Definition at line 103 of file TBByteStreamCnvTool.h.

◆ m_isCalib

bool TBByteStreamCnvTool::m_isCalib {}
private

Definition at line 166 of file TBByteStreamCnvTool.h.

◆ m_keys

std::vector<std::string> TBByteStreamCnvTool::m_keys
private

Definition at line 106 of file TBByteStreamCnvTool.h.

◆ m_lastEventID

EventID TBByteStreamCnvTool::m_lastEventID {}
private

Definition at line 93 of file TBByteStreamCnvTool.h.

◆ m_mwpcrawCont

TBMWPCRawCont* TBByteStreamCnvTool::m_mwpcrawCont {}
private

Definition at line 131 of file TBByteStreamCnvTool.h.

◆ m_onlineHelper

const LArOnlineID* TBByteStreamCnvTool::m_onlineHelper {}
private

Definition at line 96 of file TBByteStreamCnvTool.h.

◆ m_rdpSvc

ServiceHandle<IROBDataProviderSvc> TBByteStreamCnvTool::m_rdpSvc
private

Definition at line 92 of file TBByteStreamCnvTool.h.

◆ m_rodBlock

std::vector<uint32_t> TBByteStreamCnvTool::m_rodBlock
private

Definition at line 95 of file TBByteStreamCnvTool.h.

◆ m_run_num

unsigned int TBByteStreamCnvTool::m_run_num {}
private

Definition at line 176 of file TBByteStreamCnvTool.h.

◆ m_samples

std::vector<int> TBByteStreamCnvTool::m_samples
private

Definition at line 142 of file TBByteStreamCnvTool.h.

◆ m_scintrawCont

TBScintillatorRawCont* TBByteStreamCnvTool::m_scintrawCont {}
private

Definition at line 133 of file TBByteStreamCnvTool.h.

◆ m_subdet_id

eformat::SubDetector TBByteStreamCnvTool::m_subdet_id {}
private

Definition at line 94 of file TBByteStreamCnvTool.h.

◆ m_subdet_key

int TBByteStreamCnvTool::m_subdet_key {}
private

Definition at line 107 of file TBByteStreamCnvTool.h.

◆ m_subfrag_firstdata

int TBByteStreamCnvTool::m_subfrag_firstdata {}
private

Definition at line 112 of file TBByteStreamCnvTool.h.

◆ m_subfrag_id

int TBByteStreamCnvTool::m_subfrag_id {}
private

Definition at line 110 of file TBByteStreamCnvTool.h.

◆ m_subfrag_size

int TBByteStreamCnvTool::m_subfrag_size {}
private

Definition at line 111 of file TBByteStreamCnvTool.h.

◆ m_summary_path

std::string TBByteStreamCnvTool::m_summary_path
private

Definition at line 182 of file TBByteStreamCnvTool.h.

◆ m_tableY

float TBByteStreamCnvTool::m_tableY {}
private

Definition at line 181 of file TBByteStreamCnvTool.h.

◆ m_tailcatchraw

TBTailCatcherRaw* TBByteStreamCnvTool::m_tailcatchraw {}
private

Definition at line 134 of file TBByteStreamCnvTool.h.

◆ m_tblarcalibdigitcont

TBLArCalibDigitContainer* TBByteStreamCnvTool::m_tblarcalibdigitcont[4] {}
private

Definition at line 137 of file TBByteStreamCnvTool.h.

◆ m_tblardigitcont

TBLArDigitContainer* TBByteStreamCnvTool::m_tblardigitcont[4] {}
private

Definition at line 136 of file TBByteStreamCnvTool.h.

◆ m_tbtdc

TBTDC* TBByteStreamCnvTool::m_tbtdc {}
private

Definition at line 127 of file TBByteStreamCnvTool.h.

◆ m_tdcrawCont

TBTDCRawCont* TBByteStreamCnvTool::m_tdcrawCont {}
private

Definition at line 128 of file TBByteStreamCnvTool.h.

◆ m_theROB

OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment* TBByteStreamCnvTool::m_theROB {}
private

Definition at line 100 of file TBByteStreamCnvTool.h.

◆ m_theRodBlock

std::vector<uint32_t>* TBByteStreamCnvTool::m_theRodBlock {}
private

Definition at line 99 of file TBByteStreamCnvTool.h.

◆ m_trigpat

TBTriggerPatternUnit* TBByteStreamCnvTool::m_trigpat {}
private

Definition at line 132 of file TBByteStreamCnvTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
TBByteStreamCnvTool::m_tableY
float m_tableY
Definition: TBByteStreamCnvTool.h:181
TBTDCRaw
Definition: TBTDCRaw.h:21
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
RawEventWrite
OFFLINE_FRAGMENTS_NAMESPACE_WRITE::FullEventFragment RawEventWrite
data type for writing raw event
Definition: RawEvent.h:39
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
TBByteStreamCnvTool::m_h8_triggword
unsigned int m_h8_triggword
Definition: TBByteStreamCnvTool.h:187
ReadCellNoiseFromCoolCompare.s1
s1
Definition: ReadCellNoiseFromCoolCompare.py:378
TBByteStreamCnvTool::m_boards
std::vector< int > m_boards
Definition: TBByteStreamCnvTool.h:141
S1
struct TBPatternUnitContext S1
TBByteStreamCnvTool::m_tailcatchraw
TBTailCatcherRaw * m_tailcatchraw
Definition: TBByteStreamCnvTool.h:134
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
scale2
#define scale2
Definition: JetAttributeHisto.cxx:42
TBByteStreamCnvTool::m_cryoX
float m_cryoX
Definition: TBByteStreamCnvTool.h:179
ReadCellNoiseFromCool.name1
name1
Definition: ReadCellNoiseFromCool.py:233
DeMoUpdate.tmp2
string tmp2
Definition: DeMoUpdate.py:1168
xAOD::word1
word1
Definition: eFexEMRoI_v1.cxx:87
TBBPCRaw
raw data class for BPC measurement
Definition: TBBPCRaw.h:33
TBByteStreamCnvTool::m_summary_path
std::string m_summary_path
Definition: TBByteStreamCnvTool.h:182
TBADCRaw
Definition: TBADCRaw.h:21
python.Constants.FATAL
int FATAL
Definition: Control/AthenaCommon/python/Constants.py:19
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
TBByteStreamCnvTool::m_H8run
bool m_H8run
Definition: TBByteStreamCnvTool.h:103
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
TBMWPCRaw::addNwires
void addNwires(int nwire)
Definition: TBMWPCRaw.h:67
TBByteStreamCnvTool::m_firstsamples
std::vector< int > m_firstsamples
Definition: TBByteStreamCnvTool.h:145
TBByteStreamCnvTool::m_calib_error
bool m_calib_error
Definition: TBByteStreamCnvTool.h:170
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
Veto
struct TBPatternUnitContext Veto
TBByteStreamCnvTool::m_tbtdc
TBTDC * m_tbtdc
Definition: TBByteStreamCnvTool.h:127
calibdata.chamber
chamber
Definition: calibdata.py:32
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
CaloGain::UNKNOWNGAIN
@ UNKNOWNGAIN
Definition: CaloGain.h:20
initialize
void initialize()
Definition: run_EoverP.cxx:894
TBByteStreamCnvTool::m_ByteStreamEventAccess
ServiceHandle< IByteStreamEventAccess > m_ByteStreamEventAccess
Definition: TBByteStreamCnvTool.h:91
S3
struct TBPatternUnitContext S3
TBH6ByteStream-Monitor-EventStorage.tdcmin
tdcmin
Definition: TBH6ByteStream-Monitor-EventStorage.py:143
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
CaloTime_fillDB.gain2
gain2
Definition: CaloTime_fillDB.py:357
RawEvent
OFFLINE_FRAGMENTS_NAMESPACE::FullEventFragment RawEvent
data type for reading raw event
Definition: RawEvent.h:37
TBMWPCRawCont
Definition: TBMWPCRawCont.h:18
skel.it
it
Definition: skel.GENtoEVGEN.py:396
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
TBByteStreamCnvTool::m_keys
std::vector< std::string > m_keys
Definition: TBByteStreamCnvTool.h:106
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
TBByteStreamCnvTool::m_lastEventID
EventID m_lastEventID
Definition: TBByteStreamCnvTool.h:93
TBByteStreamCnvTool::m_H6run
bool m_H6run
Definition: TBByteStreamCnvTool.h:102
TBMWPCRaw
Definition: TBMWPCRaw.h:23
TBByteStreamCnvTool::m_arrayofgain
CaloGain::CaloGain m_arrayofgain[128][4]
Definition: TBByteStreamCnvTool.h:147
TBByteStreamCnvTool::getCaloGain
CaloGain::CaloGain getCaloGain(int gain)
Definition: TBByteStreamCnvTool.h:150
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
HWIdentifier
Definition: HWIdentifier.h:13
TBByteStreamCnvTool::m_theROB
OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment * m_theROB
Definition: TBByteStreamCnvTool.h:100
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
TBByteStreamCnvTool::m_CLKey
SG::ReadCondHandleKey< LArCalibLineMapping > m_CLKey
Definition: TBByteStreamCnvTool.h:124
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
TBByteStreamCnvTool::m_beam_moment
float m_beam_moment
Definition: TBByteStreamCnvTool.h:177
TBByteStreamCnvTool::m_rodBlock
std::vector< uint32_t > m_rodBlock
Definition: TBByteStreamCnvTool.h:95
TBByteStreamCnvTool::m_theRodBlock
std::vector< uint32_t > * m_theRodBlock
Definition: TBByteStreamCnvTool.h:99
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
TBByteStreamCnvTool::m_febgain
std::vector< int > m_febgain
Definition: TBByteStreamCnvTool.h:144
TBBeamDetector::setOverflow
virtual void setOverflow()
Definition: TBBeamDetector.h:51
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
TBByteStreamCnvTool::m_eventinfo
TBEventInfo * m_eventinfo
Definition: TBByteStreamCnvTool.h:135
TBByteStreamCnvTool::m_calib_pattern
unsigned char m_calib_pattern[16]
Definition: TBByteStreamCnvTool.h:167
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
TBLArCalibDigitContainer
Liquid Argon Calibration Digit Container
Definition: TBLArCalibDigitContainer.h:26
OFFLINE_FRAGMENTS_NAMESPACE::PointerType
const DataType * PointerType
Definition: RawEvent.h:25
TBByteStreamCnvTool::GetRODBlock
StatusCode GetRODBlock(eformat::SubDetector subdet_id, eformat::SubDetector subdet_rod_id=m_DontCheckRodSubDetID)
Definition: TBByteStreamCnvTool.cxx:395
histSizes.code
code
Definition: histSizes.py:129
TBByteStreamCnvTool::firstnbit
unsigned short firstnbit(int n, unsigned short w)
Definition: TBByteStreamCnvTool.h:197
LArOnlineID_Base::channel
int channel(const HWIdentifier id) const
Return the channel number of a hardware cell identifier channel = [0,127] in all FEB.
Definition: LArOnlineID_Base.cxx:1963
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
TBBeamDetector::setDetectorName
virtual void setDetectorName(const std::string &tbBeamDetectorName)
Definition: TBBeamDetector.h:48
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:113
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
LArDigit
Liquid Argon digit base class.
Definition: LArDigit.h:25
TBByteStreamCnvTool::H6RecordObjects
StatusCode H6RecordObjects(int unrec_code)
Definition: TBByteStreamCnvTool.cxx:1912
TBByteStreamCnvTool::m_gains
std::vector< int > m_gains
Definition: TBByteStreamCnvTool.h:143
eformat::ROBFragment
Definition: L1CaloBsDecoderUtil.h:12
lumiFormat.i
int i
Definition: lumiFormat.py:85
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
TBByteStreamCnvTool::m_samples
std::vector< int > m_samples
Definition: TBByteStreamCnvTool.h:142
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
beamspotman.n
n
Definition: beamspotman.py:731
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
EventInfo::event_ID
EventID * event_ID()
the unique identification of the event.
Definition: EventInfo/EventInfo/EventInfo.h:224
TBByteStreamCnvTool::m_mwpcrawCont
TBMWPCRawCont * m_mwpcrawCont
Definition: TBByteStreamCnvTool.h:131
TBByteStreamCnvTool::m_tdcrawCont
TBTDCRawCont * m_tdcrawCont
Definition: TBByteStreamCnvTool.h:128
LArOnlineID_Base::channel_Id
HWIdentifier channel_Id(int barrel_ec, int pos_neg, int feedthrough, int slot, int channel) const
create channel identifier from fields
Definition: LArOnlineID_Base.cxx:1565
TBScintillatorRaw
Definition: TBScintillatorRaw.h:26
TBByteStreamCnvTool::m_isCalib
bool m_isCalib
Definition: TBByteStreamCnvTool.h:166
test_pyathena.parent
parent
Definition: test_pyathena.py:15
TBByteStreamCnvTool::secondword
unsigned short secondword(unsigned int w)
Definition: TBByteStreamCnvTool.h:193
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TBByteStreamCnvTool::m_subdet_key
int m_subdet_key
Definition: TBByteStreamCnvTool.h:107
TBTDC::tdc
int tdc() const
Definition: TBTDC.h:28
TBTDCRawCont
Definition: TBTDCRawCont.h:21
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
TBByteStreamCnvTool::m_ev_number
int m_ev_number
Definition: TBByteStreamCnvTool.h:175
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
TBByteStreamCnvTool::ReadFragment
StatusCode ReadFragment(int unrec_code)
Definition: TBByteStreamCnvTool.cxx:262
TBTDC
Definition: TBTDC.h:17
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
TBTriggerPatternUnit::setTriggerWord
void setTriggerWord(unsigned int word)
Definition: TBTriggerPatternUnit.cxx:26
CaloTime_fillDB.gain1
gain1
Definition: CaloTime_fillDB.py:356
TBByteStreamCnvTool::NextSubFrag
bool NextSubFrag()
Definition: TBByteStreamCnvTool.h:114
TBByteStreamCnvTool::m_subfrag_firstdata
int m_subfrag_firstdata
Definition: TBByteStreamCnvTool.h:112
TBByteStreamCnvTool::H6BuildObjects
StatusCode H6BuildObjects(int unrec_code)
Definition: TBByteStreamCnvTool.cxx:502
TBByteStreamCnvTool::m_subfrag_id
int m_subfrag_id
Definition: TBByteStreamCnvTool.h:110
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
TBByteStreamCnvTool::m_trigpat
TBTriggerPatternUnit * m_trigpat
Definition: TBByteStreamCnvTool.h:132
TBByteStreamCnvTool::m_beam_part
std::string m_beam_part
Definition: TBByteStreamCnvTool.h:178
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
LArCalibDigit
Base class for LArDigits taken during calibration runs.
Definition: LArCalibDigit.h:29
EventInfo
This class provides general information about an event. Event information is provided by the accessor...
Definition: EventInfo/EventInfo/EventInfo.h:43
TBByteStreamCnvTool::m_rdpSvc
ServiceHandle< IROBDataProviderSvc > m_rdpSvc
Definition: TBByteStreamCnvTool.h:92
TBByteStreamCnvTool::m_run_num
unsigned int m_run_num
Definition: TBByteStreamCnvTool.h:176
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
dqt_zlumi_alleff_HIST.B
B
Definition: dqt_zlumi_alleff_HIST.py:110
LArOnlineID
Definition: LArOnlineID.h:20
item
Definition: ItemListSvc.h:43
CaloGain::LARHIGHGAIN
@ LARHIGHGAIN
Definition: CaloGain.h:18
TBByteStreamCnvTool::m_force_Hchoice
bool m_force_Hchoice
Definition: TBByteStreamCnvTool.h:104
TBByteStreamCnvTool::BuildRODBlock
StatusCode BuildRODBlock(std::vector< uint32_t > *theRODBlock)
Definition: TBByteStreamCnvTool.cxx:191
TBByteStreamCnvTool::m_cryoAngle
float m_cryoAngle
Definition: TBByteStreamCnvTool.h:180
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
CaloGain::CaloGain
CaloGain
Definition: CaloGain.h:11
TBByteStreamCnvTool::m_onlineHelper
const LArOnlineID * m_onlineHelper
Definition: TBByteStreamCnvTool.h:96
TBMWPCRaw::addCwireno
void addCwireno(int cwire)
Definition: TBMWPCRaw.h:59
TBByteStreamCnvTool::m_tblarcalibdigitcont
TBLArCalibDigitContainer * m_tblarcalibdigitcont[4]
Definition: TBByteStreamCnvTool.h:137
CaloGain::LARMEDIUMGAIN
@ LARMEDIUMGAIN
Definition: CaloGain.h:18
a
TList * a
Definition: liststreamerinfos.cxx:10
CalibCoolCompareRT.nm
nm
Definition: CalibCoolCompareRT.py:110
h
OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment
eformat::write::ROBFragment ROBFragment
Definition: RawEvent.h:33
TBEventInfo
Definition: TBEventInfo.h:27
TBTDC::tdcmin
int tdcmin() const
Definition: TBTDC.h:31
TBByteStreamCnvTool::m_calib_dac
uint16_t m_calib_dac
Definition: TBByteStreamCnvTool.h:168
TBByteStreamCnvTool::m_scintrawCont
TBScintillatorRawCont * m_scintrawCont
Definition: TBByteStreamCnvTool.h:133
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
TBByteStreamCnvTool::m_bpcrawCont
TBBPCRawCont * m_bpcrawCont
Definition: TBByteStreamCnvTool.h:130
re
const boost::regex re(r_e)
DEBUG
#define DEBUG
Definition: page_access.h:11
ReadCellNoiseFromCoolCompare.s2
s2
Definition: ReadCellNoiseFromCoolCompare.py:379
TBByteStreamCnvTool::m_calib_delay
uint16_t m_calib_delay
Definition: TBByteStreamCnvTool.h:169
S2
struct TBPatternUnitContext S2
EventID
This class provides a unique identification for each event, in terms of run/event number and/or a tim...
Definition: EventID.h:35
TBByteStreamCnvTool::H8BuildObjects
StatusCode H8BuildObjects(int unrec_code)
Definition: TBByteStreamCnvTool.cxx:1279
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
TBByteStreamCnvTool::m_DontCheckRodSubDetID
static const eformat::SubDetector m_DontCheckRodSubDetID
Definition: TBByteStreamCnvTool.h:89
TBADCRaw::getADC
signal_type getADC() const
Definition: TBADCRaw.h:35
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
merge.status
status
Definition: merge.py:17
TBTriggerPatternUnit
Definition: TBTriggerPatternUnit.h:27
scale1
#define scale1
Definition: JetAttributeHisto.cxx:41
TBByteStreamCnvTool::testbit
bool testbit(int n, unsigned short w)
Definition: TBByteStreamCnvTool.h:203
TBLArDigitContainer
Gaudi Class ID.
Definition: TBLArDigitContainer.h:40
TBByteStreamCnvTool::firstword
unsigned short firstword(unsigned int w)
Definition: TBByteStreamCnvTool.h:190
python.CaloScaleNoiseConfig.default
default
Definition: CaloScaleNoiseConfig.py:79
TBTailCatcherRaw
Definition: TBTailCatcherRaw.h:25
CaloGain::LARLOWGAIN
@ LARLOWGAIN
Definition: CaloGain.h:18
python.IoTestsLib.w
def w
Definition: IoTestsLib.py:200
TBMWPCRaw::setXchambers
void setXchambers(bool isX)
Definition: TBMWPCRaw.h:72
TBByteStreamCnvTool::m_subfrag_size
int m_subfrag_size
Definition: TBByteStreamCnvTool.h:111
TBByteStreamCnvTool::m_subdet_id
eformat::SubDetector m_subdet_id
Definition: TBByteStreamCnvTool.h:94
TBADCRawCont
Definition: TBADCRawCont.h:20
PrepareReferenceFile.outfile
outfile
Definition: PrepareReferenceFile.py:42
TBScintillatorRawCont
Definition: TBScintillatorRawCont.h:18
python.compressB64.c
def c
Definition: compressB64.py:93
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
TBScintillatorRaw::setSignals
void setSignals(const TBTDCRawCont *tdcCont, TBTDCRaw *tbtdc, const TBADCRawCont *adcCont, TBADCRaw *tbadc)
Definition: TBScintillatorRaw.cxx:20
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
TBBPCRaw::setSignals
void setSignals(const TBTDCRawCont *theTDCCont, const std::vector< const TBTDCRaw * > &theTDCs, const TBADCRawCont *theADCCont, const std::vector< const TBADCRaw * > &theADCs)
Definition: TBBPCRaw.cxx:35
TBByteStreamCnvTool::m_tblardigitcont
TBLArDigitContainer * m_tblardigitcont[4]
Definition: TBByteStreamCnvTool.h:136
TBByteStreamCnvTool::m_arrayofsample
std::vector< short > m_arrayofsample[128][4]
Definition: TBByteStreamCnvTool.h:146
fitman.k
k
Definition: fitman.py:528
TBBPCRawCont
Definition: TBBPCRawCont.h:17
TBByteStreamCnvTool::m_dump
bool m_dump
Definition: TBByteStreamCnvTool.h:105
TBByteStreamCnvTool::m_adcrawCont
TBADCRawCont * m_adcrawCont
Definition: TBByteStreamCnvTool.h:129
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Sun Dec 22 2024 21:45:47 for ATLAS Offline Software by   doxygen 1.8.18