ATLAS Offline Software
Classes | Public Types | Signals | Public Member Functions | Static Public Member Functions | Protected Slots | Protected Member Functions | Private Slots | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
VP1CaloCellSystem Class Reference

#include <VP1CaloCellSystem.h>

Inheritance diagram for VP1CaloCellSystem:
Collaboration diagram for VP1CaloCellSystem:

Classes

class  Clockwork
 

Public Types

typedef std::set< SoCamera * > CamList
 
typedef CamList::iterator CamListItr
 
enum  State { CONSTRUCTED =0, REFRESHED, ERASED, UNCREATED }
 
enum  ActiveState { ON =0, OFF }
 

Signals

void itemFromSystemSelected ()
 
void sysmessage (QString) const
 
void inactiveSystemTurnedActive ()
 
void needErase ()
 

Public Member Functions

 VP1CaloCellSystem ()
 
 ~VP1CaloCellSystem ()
 
QWidget * buildController ()
 
void systemcreate (StoreGateSvc *detstore)
 
void systemerase ()
 
void systemuncreate ()
 
void buildEventSceneGraph (StoreGateSvc *sg, SoSeparator *root)
 
void userPickedNode (SoNode *pickedNode, SoPath *pickedPath)
 
QByteArray saveState ()
 
void restoreFromState (QByteArray ba)
 
void ensureBuildController ()
 
virtual void buildPermanentSceneGraph (StoreGateSvc *detstore, SoSeparator *root)
 
void updateGUI ()
 
void warnOnDisabledNotifications () const
 
void registerCamera (SoCamera *camera)
 
void registerViewer (SoQtViewer *viewer)
 
void registerSelectionNode (SoCooperativeSelection *)
 
void unregisterSelectionNode (SoCooperativeSelection *)
 
void setUserSelectionNotificationsEnabled (SoCooperativeSelection *sel, bool enabled)
 
virtual void userSelectedSingleNode (SoCooperativeSelection *, SoNode *, SoPath *)
 
virtual void userDeselectedSingleNode (SoCooperativeSelection *, SoNode *, SoPath *)
 
virtual void userChangedSelection (SoCooperativeSelection *, QSet< SoNode * >, QSet< SoPath * >)
 
virtual void userClickedOnBgd ()
 
virtual void deselectAll (SoCooperativeSelection *exception_sel=0)
 
CamList getCameraList ()
 
virtual QWidget * buildExtraDisplayWidget ()
 
const QString & name () const
 
const QString & information () const
 
const QString & contact_info () const
 
QWidget * controllerWidget ()
 
void message (const QString &) const
 
void message (const QStringList &, const QString &addtoend="") const
 
void message (const QString &addtostart, const QStringList &, const QString &addtoend="") const
 
void messageDebug (const QString &) const
 
void messageDebug (const QStringList &, const QString &addtoend="") const
 
void messageDebug (const QString &addtostart, const QStringList &, const QString &addtoend="") const
 
void messageVerbose (const QString &) const
 
void messageVerbose (const QStringList &, const QString &addtoend="") const
 
void messageVerbose (const QString &addtostart, const QStringList &, const QString &addtoend="") const
 
StoreGateSvc * storeGate () const
 
StoreGateSvc * eventStore () const
 
StoreGateSvc * detectorStore () const
 
ISvcLocator * serviceLocator () const
 
IToolSvc * toolSvc () const
 
State state () const
 
ActiveState activeState () const
 

Static Public Member Functions

static bool verbose ()
 
static QString str (const QString &s)
 
static QString str (const char *c)
 
static QString str (const bool b)
 
static QString str (const QColor &)
 
static QString str (const SbColor &)
 
static QString str (const VP1Interval &)
 
static QString str (const SbVec2d &)
 
static QString str (const SbVec2f &)
 
static QString str (const SbVec2s &)
 
static QString str (const SbVec3d &)
 
static QString str (const SbVec3f &)
 
static QString str (const SbVec3s &)
 
static QString str (const SbVec4d &)
 
static QString str (const SbVec4f &)
 
static QString str (short int n)
 
static QString str (unsigned short int n)
 
static QString str (long n)
 
static QString str (ulong n)
 
static QString str (int n)
 
static QString str (uint n)
 
static QString str (qlonglong n)
 
static QString str (qulonglong n)
 
static QString str (const double &d)
 
static QString str (const float &f)
 
static QString str (const void *)
 
template<class T >
static QString str (const T *t)
 
template<class T >
static QString str (const QFlags< T > &f)
 
template<class T >
static QString str (const HepGeom::BasicVector3D< T > &t)
 
static QString str (const Amg::Vector3D &t)
 
template<class T >
static QString str (const QList< T > &t)
 

Protected Slots

void energyMode ()
 

Protected Member Functions

void registerController (QWidget *)
 

Private Slots

void activateClickedOutside ()
 

Private Member Functions

void setupEnergyMode ()
 
SoSeparator * getSceneGraph () const
 
void create (StoreGateSvc *detstore)
 
void refresh (StoreGateSvc *storegate)
 
void erase ()
 
void uncreate ()
 
void disallowUpdateGUI ()
 
void allowUpdateGUI ()
 
void setChannel (IVP1ChannelWidget *)
 
IVP1ChannelWidget * channel () const
 
void deleteController ()
 
void setState (const State &)
 
void setActiveState (const ActiveState &, const bool &donttriggererase=true)
 
bool isRefreshing ()
 
void setRefreshing (const bool &)
 
void setCanRegisterController (const bool &)
 

Private Attributes

Clockwork * m_clockwork
 
Imp * m_d
 

Static Private Attributes

static const bool s_vp1verbose = VP1QtUtils::environmentVariableIsOn("VP1_VERBOSE_OUTPUT")
 

Detailed Description

Definition at line 10 of file VP1CaloCellSystem.h.

Member Typedef Documentation

◆ CamList

typedef std::set<SoCamera*> IVP13DSystem::CamList
inherited

Definition at line 90 of file IVP13DSystem.h.

◆ CamListItr

typedef CamList::iterator IVP13DSystem::CamListItr
inherited

Definition at line 91 of file IVP13DSystem.h.

Member Enumeration Documentation

◆ ActiveState

enum IVP1System::ActiveState
inherited
Enumerator
ON 
OFF 

Definition at line 144 of file IVP1System.h.

144 { ON=0, OFF };//Whether it is part of the erase/refresh cycle.

◆ State

enum IVP1System::State
inherited
Enumerator
CONSTRUCTED 
REFRESHED 
ERASED 
UNCREATED 

Definition at line 143 of file IVP1System.h.

143 { CONSTRUCTED=0, REFRESHED, ERASED, UNCREATED };

Constructor & Destructor Documentation

◆ VP1CaloCellSystem()

VP1CaloCellSystem::VP1CaloCellSystem ( )

Definition at line 429 of file VP1CaloCellSystem.cxx.

430 :IVP13DSystemSimple("Cells","Display energy of CaloCell objects","tsulaia@mail.cern.ch or rbianchi@cern.ch"),
431  m_clockwork(new Clockwork())
432 {
433 }

◆ ~VP1CaloCellSystem()

VP1CaloCellSystem::~VP1CaloCellSystem ( )

Definition at line 435 of file VP1CaloCellSystem.cxx.

436 {
437  delete m_clockwork;
438 }

Member Function Documentation

◆ activateClickedOutside

void IVP13DSystem::activateClickedOutside ( )
privateslotinherited

Definition at line 85 of file IVP13DSystem.cxx.

86 {
87  if (!m_d->clickedoutsideScheduled)
88  return;
89  m_d->clickedoutsideScheduled = false;
90  userClickedOnBgd();
91 }

◆ activeState()

IVP1System::ActiveState IVP1System::activeState ( ) const
inherited

Definition at line 135 of file IVP1System.cxx.

136 {
137  return m_d->activeState;
138 }

◆ allowUpdateGUI()

void IVP1System::allowUpdateGUI ( )
privateinherited

Definition at line 256 of file IVP1System.cxx.

257 {
258  m_d->allowupdategui=true;
259 }

◆ buildController()

QWidget * VP1CaloCellSystem::buildController ( )
virtual

Reimplemented from IVP13DSystemSimple.

Definition at line 440 of file VP1CaloCellSystem.cxx.

441 {
442  // Standard stuff
443  m_clockwork->controller = new VP1CaloCellController(this);
444 
445  // Connect controller signals to various slots
446  // Energy mode
447  connect(m_clockwork->controller,SIGNAL(energyModeEtChanged(bool)),
448  this,SLOT(energyMode()));
449 
450  // Mbts
451  m_clockwork->mbtsHelper->setController(m_clockwork->controller);
452  connect(m_clockwork->controller,SIGNAL(selectionMbtsChanged(VP1Interval)),
453  m_clockwork->mbtsHelper,SLOT(selectionUpdated(VP1Interval)));
454  connect(m_clockwork->controller,SIGNAL(showVolumeOutLinesChanged(bool)),
455  m_clockwork->mbtsHelper,SLOT(outlineUpdate(bool)));
456  if (m_clockwork->controller->customTourEditor()){
457  std::cout <<" Connecting to CVRC" <<std::endl;
458  connect(m_clockwork->controller->customTourEditor(),SIGNAL(clipVolumeRadiusChanged(double)),
459  m_clockwork->mbtsHelper,SLOT(clipVolumeRadiusChanged(double)));
460  }
461  return m_clockwork->controller;
462 }

◆ buildEventSceneGraph()

void VP1CaloCellSystem::buildEventSceneGraph ( StoreGateSvc *  sg,
SoSeparator *  root 
)
virtual

Implements IVP13DSystemSimple.

Definition at line 572 of file VP1CaloCellSystem.cxx.

573 {
574  if(m_clockwork->noCalo) return;
575 
576  root->addChild(m_clockwork->controller->drawOptions());
577 
578  // Iterators for SG keys
579  std::vector<std::string>::const_iterator firstKey, lastKey;
580 
581  // ---------------- Retrieve calo cells from SG ---------------------
582  // Check for SG keys
583  std::vector<std::string> strCaloCellKeys;
584  sg->keys<CaloCellContainer>(strCaloCellKeys);
585  firstKey = strCaloCellKeys.begin();
586  lastKey = strCaloCellKeys.end();
587 
588 
589  if(firstKey!=lastKey) {
590  // Some keys found
591  std::string keyCaloCell = *firstKey;
592  StatusCode status = sg->retrieve(m_clockwork->calocells,keyCaloCell);
593  if(status.isSuccess() && m_clockwork->calocells!=0) {
594  // Build a basis for the scene graph
595  // 1. Create one Separator and one Material for each member of VP1CC_SeparatorTypes
596  // 2. Also create Separator Helper objects
597  VP1CC_SeparatorTypesSet::iterator itSepType=m_clockwork->sepTypes.begin();
598  for(; itSepType!=m_clockwork->sepTypes.end(); ++itSepType) {
599  SoSeparator* childSep = new SoSeparator();
600  VP1ExtraSepLayerHelper* sepHelper = new VP1ExtraSepLayerHelper(childSep);
601 
602  root->addChild(m_clockwork->controller->GetMaterial(*itSepType));
603  root->addChild(childSep);
604 
605  m_clockwork->sepHelperMap[*itSepType] = sepHelper;
606  }
607 
608  setupEnergyMode();
609 
610  } else
611  message("Unable to retrieve Calo Cells from Store Gate for this event");
612 
613  while(++firstKey!=lastKey)
614  messageDebug("Another Calo Cell collection found in the SG with key = " + QString((*firstKey).c_str()));
615  } else
616  message("No Calo Cells in Store Gate for this event"); // No keys found
617 
618  // ---------------- Retrieve calo cells from SG ---------------------
619 
620  // -------------------------- Digits ---------------------------------
621  m_clockwork->controller->ClearHideDigitForms();
622  m_clockwork->controller->EnableDigitsCheckbox(false);
623  m_clockwork->noLArDigitsEvent = m_clockwork->noLArDigitsGlobal;
624  m_clockwork->noTileDigitsEvent = m_clockwork->noTileDigitsGlobal;
625 
626 
627  /*
628  if(m_clockwork->calo_badchannel == 0)
629  m_clockwork->mainController->chbxEnableBadChannels->setEnabled(false);
630  else
631  m_clockwork->mainController->chbxEnableBadChannels->setEnabled(true);
632  */
633 
634  if(!m_clockwork->noLArDigitsEvent) {
635  // Get keys for LArDigitContainers in the Store Gate
636  // If we have more than one container then it means we have All and/or Thinned and/or IIC -> use All if available, otherwise use Thinned
637  std::vector<std::string> strLArDigitKeys;
638  sg->keys<LArDigitContainer>(strLArDigitKeys);
639  firstKey = strLArDigitKeys.begin();
640  lastKey = strLArDigitKeys.end();
641 
642  if(firstKey==lastKey){
643  message("No LAr Digits in Store Gate for this event");
644  m_clockwork->noLArDigitsEvent = true;
645  } else {
646  std::string strLArDigitKeys(""), tagThinned(""), tagIIC(""), tagFirstOther("");
647 
648  for(;firstKey!=lastKey;++firstKey) {
649  if((*firstKey).find("Thinned")!=std::string::npos)
650  tagThinned = *firstKey;
651  else if((*firstKey).find("IIC")!=std::string::npos)
652  tagIIC = *firstKey;
653  else if(tagFirstOther=="")
654  tagFirstOther = *firstKey;
655  }
656 
657  if(tagFirstOther!="")
658  strLArDigitKeys = tagFirstOther;
659  else if(tagThinned!="")
660  strLArDigitKeys = tagThinned;
661  else
662  strLArDigitKeys = tagIIC;
663 
664  QString mess = QString("Retrieving LArDigitContainer with the key ") + QString(strLArDigitKeys.c_str());
665  messageDebug(mess);
666 
667  StatusCode status = sg->retrieve(m_clockwork->lar_digits,strLArDigitKeys);
668 
669  if(status.isSuccess() && m_clockwork->lar_digits != 0) {
670  m_clockwork->controller->EnableDigitsCheckbox(true);
671  std::ostringstream numLarDigits;
672  numLarDigits << m_clockwork->lar_digits->size();
673  message("Number of LAr digits for this event " + QString(numLarDigits.str().c_str()));
674  } else {
675  message("Unable to retrieve LAr digits from Store Gate for this event");
676  m_clockwork->lar_digits = 0;
677  m_clockwork->noLArDigitsEvent = true;
678  }
679  } // LArDigits found in the SG
680  }
681 
682  if(!m_clockwork->noTileDigitsEvent) {
683  // Get keys for TileDigitContainers in the Store Gate
684  // If we have more than one container then use the first one and issue a warning message
685  std::vector<std::string> strTileDigitKeys;
686  sg->keys<TileDigitsContainer>(strTileDigitKeys);
687  firstKey = strTileDigitKeys.begin();
688  lastKey = strTileDigitKeys.end();
689 
690  if(firstKey==lastKey){
691  message("No Tile Digits in Store Gate for this event");
692  m_clockwork->noTileDigitsEvent = true;
693  } else {
694  std::string keyTileDigits = *firstKey;
695  StatusCode status = sg->retrieve(m_clockwork->tile_digits,keyTileDigits);
696 
697  if(status.isFailure() || m_clockwork->tile_digits==0){
698  message("Unable to retrieve Tile digits from Store Gate for this event");
699  m_clockwork->tile_digits = 0;
700  m_clockwork->noTileDigitsEvent = true;
701  } else {
702  m_clockwork->controller->EnableDigitsCheckbox(true);
703 
704  // ------------ Tile Raw Channels (pulses) ------------------
705  std::vector<std::string> strTileRawchanKeys;
706  sg->keys<TileRawChannelContainer>(strTileRawchanKeys);
707  firstKey = strTileRawchanKeys.begin();
708  lastKey = strTileRawchanKeys.end();
709 
710  if(firstKey==lastKey) {
711  message("No Tile Raw Channels in Store Gate for this event");
712  m_clockwork->noTileDigitsEvent = true;
713  } else {
714  std::string keyTileRawChan = m_clockwork->SearchTileRawchanKeys(strTileRawchanKeys);
715 
716  // If no keys found from the specified order then just try the fisr one
717  if(keyTileRawChan=="")
718  keyTileRawChan = *firstKey;
719 
720  QString mess = QString("Retrieving Tile Raw Channels with the key ") + QString(keyTileRawChan.c_str());
721  messageDebug(mess);
722 
723  status = sg->retrieve(m_clockwork->tile_rawchannel,keyTileRawChan);
724  if(status.isFailure() || m_clockwork->tile_rawchannel==0) {
725  message("Unable to retrieve Tile raw channels from Store Gate for this event");
726  m_clockwork->tile_rawchannel = 0;
727  }
728  }
729  } // Digits retrieved successfully
730  } // Digit container keys found in SG
731  } // Tile digits
732 
733  // -------------------------- Digits ---------------------------------
734 
735  // -------------------------- MBTS ---------------------------------
736  // -- material
737  root->addChild(m_clockwork->controller->GetMaterial(VP1CC_SepMBTS));
738 
739  // -- separator
740  SoSeparator* mbtsSeparator = new SoSeparator;
741  root->addChild(mbtsSeparator);
742  try {
743  m_clockwork->mbtsHelper->buildEventSceneGraph(sg,mbtsSeparator);
744  m_clockwork->mbtsHelper->refreshGraph(m_clockwork->controller->selectionMbts());
745  } catch(std::runtime_error& err) {
746  message (err.what());
747  }
748  // -------------------------- MBTS ---------------------------------
749  messageDebug("end of buildEventSceneGraph()");
750 }

◆ buildExtraDisplayWidget()

virtual QWidget* IVP13DSystem::buildExtraDisplayWidget ( )
inlinevirtualinherited

Definition at line 106 of file IVP13DSystem.h.

106 { return 0; }

◆ buildPermanentSceneGraph()

void IVP13DSystemSimple::buildPermanentSceneGraph ( StoreGateSvc *  detstore,
SoSeparator *  root 
)
virtualinherited

Reimplemented in VP1GeometrySystem, VP1TrackingGeometrySystem, VP1GuideLineSystem, VP1PrepRawDataSystem, VP1PartSpectSystem, VP1CaloReadoutSystem, VP1CaloHitLegoSystem, VP1CaloLegoSystem, VP1HVLegoSystem, and VP1ExtraInputSystem.

Definition at line 25 of file IVP13DSystemSimple.cxx.

25 {}

◆ channel()

IVP1ChannelWidget * IVP1System::channel ( ) const
privateinherited

Definition at line 275 of file IVP1System.cxx.

276 {
277  if (VP1Msg::verbose()&&!m_d->channel){
278  messageVerbose("WARNING channel() returning NULL");
279  }
280  assert(m_d->channel);
281  return m_d->channel;
282 }

◆ contact_info()

const QString & IVP1System::contact_info ( ) const
inherited

Definition at line 62 of file IVP1System.cxx.

63 {
64  return m_d->contact_info;
65 }

◆ controllerWidget()

QWidget * IVP1System::controllerWidget ( )
inherited

Definition at line 202 of file IVP1System.cxx.

202  {
203  if (VP1Msg::verbose()) {
204  messageVerbose("controllerWidget()");
205  messageVerbose("registerController m_d->state==ERASED = "+QString(m_d->state==ERASED?"true":"false"));
206  messageVerbose("registerController m_d->state==REFRESHED = "+QString(m_d->state==REFRESHED?"true":"false"));
207  }
208  assert(m_d->state==REFRESHED||m_d->state==ERASED);
209  return m_d->controller;
210  }

◆ create()

void IVP13DSystemSimple::create ( StoreGateSvc *  detstore)
privatevirtualinherited

Implements IVP1System.

Definition at line 133 of file IVP13DSystemSimple.cxx.

134 {
135  if(VP1Msg::verbose()){
136  messageVerbose("IVP13DSystemSimple create");
137  }
138  assert(!m_d->wasrefreshed);
139  assert(!m_d->wascreated);
140  ensureBuildController();//TODO: Move to refresh.
141  m_d->wascreated=true;
142  m_d->wasrefreshed=false;
143 }

◆ deleteController()

void IVP1System::deleteController ( )
privateinherited

Definition at line 213 of file IVP1System.cxx.

214 {
215  if (VP1Msg::verbose()){
216  messageVerbose("deleteController()");
217  }
218  if (m_d->controller)
219  m_d->controller->deleteLater();
220  m_d->controller = 0;
221 }

◆ deselectAll()

void IVP13DSystem::deselectAll ( SoCooperativeSelection *  exception_sel = 0)
virtualinherited

Reimplemented in VP1PrepRawDataSystem.

Definition at line 331 of file IVP13DSystem.cxx.

332 {
333  static std::map<SoCooperativeSelection*,IVP13DSystem*>::iterator it, itE = Imp::selection2system.end();
334  for (it = Imp::selection2system.begin(); it!=itE;++it) {
335  if (it->second!=this)
336  continue;
337  if (it->first!=exception_sel) {
338  if (it->first->policy.getValue()!=SoCooperativeSelection::SINGLE) {
339  Imp::start_changeselection(this, it->first);
340  it->first->deselectAll();
341  Imp::finished_changeselection(this, it->first);
342  } else {
343  if (it->first->getList()->getLength()==1) {
344  Imp::start_changeselection(this, it->first);
345  SoPath * path = static_cast<SoPath*>(it->first->getList()->get(0));
346  Imp::made_deselection(it->first,path);
347  it->first->deselectAll();
348  Imp::finished_changeselection(this, it->first);
349  }
350  }
351  }
352  }
353 }

◆ detectorStore()

StoreGateSvc * IVP1System::detectorStore ( ) const
inherited

Definition at line 318 of file IVP1System.cxx.

319 {
320  return VP1AthenaPtrs::detectorStore();
321 }

◆ disallowUpdateGUI()

void IVP1System::disallowUpdateGUI ( )
privateinherited

Definition at line 250 of file IVP1System.cxx.

251 {
252  m_d->allowupdategui=false;
253 }

◆ energyMode

void VP1CaloCellSystem::energyMode ( )
protectedslot

Definition at line 1117 of file VP1CaloCellSystem.cxx.

1118 {
1119  // Remove objects from 3D scene
1120  while(m_clockwork->node2ccMap.begin()!=m_clockwork->node2ccMap.end()) {
1121  VP1CC_SoNode2CCMap::iterator it_node2cc = m_clockwork->node2ccMap.begin();
1122  it_node2cc->second->remove3DObjects(&m_clockwork->node2ccMap);
1123  }
1124 
1125  // Clear node 2 CC map
1126  m_clockwork->node2ccMap.clear();
1127 
1128  // Delete Cell Managers and clear the map
1129  VP1CCManagerContainer::iterator it_ccman = m_clockwork->cell_managers.begin();
1130  for(; it_ccman!=m_clockwork->cell_managers.end(); ++it_ccman)
1131  if(it_ccman->second) delete it_ccman->second;
1132 
1133  m_clockwork->cell_managers.clear();
1134 
1135  // Setup new managers from scratch in the new energy mode
1136  setupEnergyMode();
1137 }

◆ ensureBuildController()

void IVP13DSystemSimple::ensureBuildController ( )
inherited

Definition at line 90 of file IVP13DSystemSimple.cxx.

91 {
92  if (m_d->controllerBuilt)
93  return;
94  m_d->controllerBuilt=true;
95  if(VP1Msg::verbose()){
96  messageVerbose("IVP13DSystemSimple build controller");
97  }
98  QWidget * controller = buildController();
99  if (controller)
100  registerController(controller);
101  if(VP1Msg::verbose()){
102  messageVerbose("IVP13DSystemSimple controller was = "+str(controller));
103  }
104 }

◆ erase()

void IVP13DSystemSimple::erase ( )
privatevirtualinherited

Implements IVP1System.

Definition at line 173 of file IVP13DSystemSimple.cxx.

174 {
175  if(VP1Msg::verbose()){
176  messageVerbose("IVP13DSystemSimple::erase() start");
177  }
178  assert(m_d->wascreated);
179  assert(m_d->wasrefreshed);
180 
181  bool saveE = m_d->rootE->enableNotify(false);
182 
183  systemerase();
184  if(VP1Msg::verbose()){
185  messageVerbose("IVP13DSystemSimple::erase() Removing all event objects from scene");
186  warnOnDisabledNotifications();
187  }
188  m_d->rootE->removeAllChildren();
189 
190  if (saveE) {
191  m_d->rootE->enableNotify(true);
192  m_d->rootE->touch();
193  }
194 
195  m_d->wasrefreshed=false;
196  if(VP1Msg::verbose()){
197  messageVerbose("IVP13DSystemSimple::erase() end");
198  }
199 }

◆ eventStore()

StoreGateSvc * IVP1System::eventStore ( ) const
inherited

Definition at line 312 of file IVP1System.cxx.

313 {
314  return VP1AthenaPtrs::eventStore();
315 }

◆ getCameraList()

std::set< SoCamera * > IVP13DSystem::getCameraList ( )
inherited

Definition at line 395 of file IVP13DSystem.cxx.

396 {
397  std::set<SoCamera*> cameralist = m_d->staticcameras;
398  std::set<SoQtViewer*>::const_iterator it, itE=m_d->viewers.end();
399  for (it=m_d->viewers.begin();it!=itE;++it) {
400  SoCamera*cam = (*it)->getCamera();
401  if (cam)
402  cameralist.insert(cam);
403  }
404 
405  //m_d->camerasfromviewer
406  return cameralist;
407 }

◆ getSceneGraph()

SoSeparator * IVP13DSystemSimple::getSceneGraph ( ) const
privatevirtualinherited

Implements IVP13DSystem.

Definition at line 127 of file IVP13DSystemSimple.cxx.

128 {
129  return static_cast<SoSeparator*>(m_d->root);
130 }

◆ inactiveSystemTurnedActive

void IVP1System::inactiveSystemTurnedActive ( )
signalinherited

◆ information()

const QString & IVP1System::information ( ) const
inherited

Definition at line 56 of file IVP1System.cxx.

57 {
58  return m_d->information;
59 }

◆ isRefreshing()

bool IVP1System::isRefreshing ( )
privateinherited

Definition at line 108 of file IVP1System.cxx.

109 {
110  return m_d->refreshing;
111 }

◆ itemFromSystemSelected

void IVP13DSystem::itemFromSystemSelected ( )
signalinherited

◆ message() [1/3]

void IVP1System::message ( const QString &  str) const
inherited

Definition at line 336 of file IVP1System.cxx.

337 {
338  if (receivers(SIGNAL(sysmessage(QString))) > 0){
339  sysmessage(str);
340  }
341  else{
342  std::cout<<VP1Msg::prefix_msg()<<" ["<<m_d->name.toStdString()<<"]: "<<str.toStdString()<<std::endl;
343  }
344 }

◆ message() [2/3]

void IVP1System::message ( const QString &  addtostart,
const QStringList &  l,
const QString &  addtoend = "" 
) const
inherited

Definition at line 400 of file IVP1System.cxx.

401 {
402  if (addtostart.isEmpty()) {
403  message(l,addtoend);
404  return;
405  }
406  if (addtoend.isEmpty()) {
407  for (const QString& s : l)
408  message(addtostart+s);
409  } else {
410  for (const QString& s : l)
411  message(addtostart+s+addtoend);
412  }
413 }

◆ message() [3/3]

void IVP1System::message ( const QStringList &  l,
const QString &  addtoend = "" 
) const
inherited

Definition at line 362 of file IVP1System.cxx.

363 {
364  if (addtoend.isEmpty()) {
365  for (const QString& s : l)
366  message(s);
367  } else {
368  for (const QString& s : l)
369  message(s+addtoend);
370  }
371 }

◆ messageDebug() [1/3]

void IVP1System::messageDebug ( const QString &  str) const
inherited

Definition at line 347 of file IVP1System.cxx.

348 {
349  if (VP1Msg::debug())
350  std::cout<<VP1Msg::prefix_debug()<<" ["<<m_d->name.toStdString()<<"]: "<<str.toStdString()<<std::endl;
351 }

◆ messageDebug() [2/3]

void IVP1System::messageDebug ( const QString &  addtostart,
const QStringList &  l,
const QString &  addtoend = "" 
) const
inherited

Definition at line 416 of file IVP1System.cxx.

417 {
418  if (addtostart.isEmpty()) {
419  messageDebug(l,addtoend);
420  return;
421  }
422  if (addtoend.isEmpty()) {
423  for (const QString& s : l)
424  messageDebug(addtostart+s);
425  } else {
426  for (const QString& s : l)
427  messageDebug(addtostart+s+addtoend);
428  }
429 }

◆ messageDebug() [3/3]

void IVP1System::messageDebug ( const QStringList &  l,
const QString &  addtoend = "" 
) const
inherited

Definition at line 374 of file IVP1System.cxx.

375 {
376  if (addtoend.isEmpty()) {
377  for (const QString& s : l)
378  messageDebug(s);
379  } else {
380  for (const QString& s : l)
381  messageDebug(s+addtoend);
382  }
383 }

◆ messageVerbose() [1/3]

void IVP1System::messageVerbose ( const QString &  str) const
inherited

Definition at line 354 of file IVP1System.cxx.

355 {
356  if (VP1Msg::verbose())
357  std::cout<<VP1Msg::prefix_verbose()<<" ["<<m_d->name.toStdString()<<"]: "<<str.toStdString()<<std::endl;
358 }

◆ messageVerbose() [2/3]

void IVP1System::messageVerbose ( const QString &  addtostart,
const QStringList &  l,
const QString &  addtoend = "" 
) const
inherited

Definition at line 432 of file IVP1System.cxx.

433 {
434  if (!VP1Msg::verbose())
435  return;
436  if (addtostart.isEmpty()) {
437  messageVerbose(l,addtoend);
438  return;
439  }
440  if (addtoend.isEmpty()) {
441  for (const QString& s : l)
442  messageVerbose(addtostart+s);
443  } else {
444  for (const QString& s : l)
445  messageVerbose(addtostart+s+addtoend);
446  }
447 }

◆ messageVerbose() [3/3]

void IVP1System::messageVerbose ( const QStringList &  l,
const QString &  addtoend = "" 
) const
inherited

Definition at line 386 of file IVP1System.cxx.

387 {
388  if (!VP1Msg::verbose())
389  return;
390  if (addtoend.isEmpty()) {
391  for (const QString& s : l)
392  messageVerbose(s);
393  } else {
394  for (const QString& s : l)
395  messageVerbose(s+addtoend);
396  }
397 }

◆ name()

const QString & IVP1System::name ( ) const
inherited

Definition at line 50 of file IVP1System.cxx.

51 {
52  return m_d->name;
53 }

◆ needErase

void IVP1System::needErase ( )
signalinherited

◆ refresh()

void IVP13DSystemSimple::refresh ( StoreGateSvc *  storegate)
privatevirtualinherited

Implements IVP1System.

Definition at line 146 of file IVP13DSystemSimple.cxx.

147 {
148  assert(m_d->wascreated);
149  assert(!m_d->wasrefreshed);
150 
151  if (m_d->first) {
152  if(VP1Msg::verbose()){
153  messageVerbose("IVP13DSystemSimple first refresh - so calling create methods (i.e. delayed create).");
154  }
155  systemcreate(detectorStore());
156  m_d->first = false;
157  m_d->root->removeChild(m_d->rootR);
158  buildPermanentSceneGraph(detectorStore(),m_d->rootR);
159  m_d->root->addChild(m_d->rootR);
160  }
161 
162  m_d->root->removeChild(m_d->rootE);
163  updateGUI();
164  buildEventSceneGraph(sg, m_d->rootE);
165  updateGUI();
166  m_d->root->addChild(m_d->rootE);
167 
168  m_d->wasrefreshed=true;
169 
170 }

◆ registerCamera()

void IVP13DSystem::registerCamera ( SoCamera *  camera)
inherited

Definition at line 410 of file IVP13DSystem.cxx.

410  {
411  if (!cam)
412  return;
413  m_d->staticcameras.insert(cam);
414  cam->ref();
415 }

◆ registerController()

void IVP1System::registerController ( QWidget *  w)
protectedinherited

Definition at line 224 of file IVP1System.cxx.

225 {
226  if (VP1Msg::verbose()) {
227  messageVerbose("registerController ");
228  messageVerbose("registerController m_d->canregistercontroller = "+QString(m_d->canregistercontroller?"true":"false"));
229  messageVerbose("registerController m_d->state==CONSTRUCTED = "+QString(m_d->state==CONSTRUCTED?"true":"false"));
230  messageVerbose("registerController m_d->controller==0 = "+QString(m_d->controller==0?"true":"false"));
231  messageVerbose("registerController w!=0 = "+QString(w!=0?"true":"false"));
232  }
233  if (!m_d->canregistercontroller)
234  message("ERROR: Please don't register controllers after create().");
235  if (m_d->state!=CONSTRUCTED)
236  message("ERROR: Please only register controllers in CONSTRUCTED state.");
237  if (!w) {
238  message("ERROR: Attempt to register null controller.");
239  return;
240  }
241  if (m_d->controller) {
242  message("ERROR: Attempt to register controller twice.");
243  return;
244  }
245  m_d->controller = w;
246  w->setParent(0);
247 }

◆ registerSelectionNode()

void IVP13DSystem::registerSelectionNode ( SoCooperativeSelection *  selection)
inherited

Definition at line 257 of file IVP13DSystem.cxx.

258 {
259  if (!selection) {
260  message("registerSelectionNode Error: NULL selection pointer!");
261  return;
262  }
263  if (Imp::selection2system.find(selection)!=Imp::selection2system.end()) {
264  message("registerSelectionNode Error: Trying to register selection node more than once!");
265  return;
266  }
267 
268  selection->addSelectionCallback( Imp::made_selection, selection );
269  selection->addDeselectionCallback( Imp::made_deselection, selection );
270  selection->addStartCallback( Imp::start_changeselection, this );
271  selection->addFinishCallback( Imp::finished_changeselection, this );
272  selection->addClickOutsideCallback( Imp::clickedoutside, this );
273 
274  Imp::selection2system[selection] = this;
275  selection->ref();
276 
277  messageVerbose("selection node registered");
278 }

◆ registerViewer()

void IVP13DSystem::registerViewer ( SoQtViewer *  viewer)
inherited

Definition at line 418 of file IVP13DSystem.cxx.

419 {
420  if (!viewer)
421  return;
422  m_d->viewers.insert(viewer);
423 }

◆ restoreFromState()

void VP1CaloCellSystem::restoreFromState ( QByteArray  ba)
virtual

Reimplemented from IVP1System.

Definition at line 1100 of file VP1CaloCellSystem.cxx.

1101 {
1102  VP1Deserialise state(ba,this);
1103 
1104  if (state.version()!=0) {
1105  message("Warning: State data in .vp1 file is in wrong format - ignoring!");
1106  return;
1107  }
1108  ensureBuildController();
1109 
1110  IVP13DSystemSimple::restoreFromState(state.restoreByteArray());
1111 
1112  m_clockwork->controller->restoreSettings(state.restoreByteArray());
1113 
1114  state.disableUnrestoredChecks();
1115 }

◆ saveState()

QByteArray VP1CaloCellSystem::saveState ( )
virtual

Reimplemented from IVP1System.

Definition at line 1087 of file VP1CaloCellSystem.cxx.

1088 {
1089  VP1Serialise serialise(0/*version*/,this);
1090  serialise.save(IVP13DSystemSimple::saveState());
1091 
1092  ensureBuildController();
1093 
1094  serialise.save(m_clockwork->controller->saveSettings());
1095 
1096  serialise.disableUnsavedChecks();
1097  return serialise.result();
1098 }

◆ serviceLocator()

ISvcLocator * IVP1System::serviceLocator ( ) const
inherited

Definition at line 324 of file IVP1System.cxx.

325 {
326  return VP1AthenaPtrs::serviceLocator();
327 }

◆ setActiveState()

void IVP1System::setActiveState ( const ActiveState &  s,
const bool &  donttriggererase = true 
)
privateinherited

Definition at line 162 of file IVP1System.cxx.

163 {
164  //First handle case where we dont actually change state. Only
165  //special consideration is OFF->OFF where we have to do something if
166  //we need to erase:
167  if (m_d->activeState==OFF&&s==OFF&&(m_d->state==REFRESHED||m_d->refreshing)&&!donttriggererase) {
168  needErase();
169  m_d->channel->emitRefreshInfoChanged();
170  return;
171  } else if (m_d->activeState==s) {
172  m_d->channel->emitRefreshInfoChanged();
173  return;
174  }
175 
176  //Ok, we know that we are either ON->OFF or OFF->ON.
177  m_d->activeState = s;
178 
179  if (s==ON) {
180  //OFF->ON: We might need a refresh, so send out a signal for the scheduler:
181  inactiveSystemTurnedActive();
182  } else {
183  //ON->OFF: We might need an erase signal:
184  if ((m_d->state==REFRESHED||m_d->refreshing)&&!donttriggererase) {
185  needErase();
186  }
187  }
188  m_d->channel->emitRefreshInfoChanged();
189 }

◆ setCanRegisterController()

void IVP1System::setCanRegisterController ( const bool &  c)
privateinherited

Definition at line 285 of file IVP1System.cxx.

286 {
287  if (VP1Msg::verbose()){
288  messageVerbose("setCanRegisterController called with"+QString(c?"true":"false"));
289  }
290  m_d->canregistercontroller=c;
291 }

◆ setChannel()

void IVP1System::setChannel ( IVP1ChannelWidget *  cw)
privateinherited

Definition at line 94 of file IVP1System.cxx.

95 {
96  if (VP1Msg::verbose()) {
97  messageVerbose("setChannel ");
98  messageVerbose("setChannel m_d->state==CONSTRUCTED = "+QString(m_d->state==CONSTRUCTED?"true":"false"));
99  messageVerbose("setChannel cw!=0 = "+QString(cw!=0?"true":"false"));
100  }
101  assert(!m_d->channel);
102  assert(cw);
103  assert(m_d->state==CONSTRUCTED);
104  m_d->channel = cw;
105 }

◆ setRefreshing()

void IVP1System::setRefreshing ( const bool &  b)
privateinherited

Definition at line 114 of file IVP1System.cxx.

115 {
116  if (VP1Msg::verbose()){
117  messageVerbose("setRefreshing() called with b="+QString(b?"true":"false"));
118  }
119  if (b) {
120  assert(m_d->state==ERASED);
121  } else {
122  assert(m_d->state==REFRESHED);
123  }
124  m_d->refreshing = b;
125 }

◆ setState()

void IVP1System::setState ( const State &  s)
privateinherited

Definition at line 141 of file IVP1System.cxx.

142 {
143 #ifndef NDEBUG
144  assert (m_d->state != s);
145  assert(s!=CONSTRUCTED);
146  if (s==REFRESHED) {
147  assert(m_d->state==ERASED);
148  }
149  if (s==ERASED) {
150  assert(m_d->state==REFRESHED||m_d->state==CONSTRUCTED);
151  }
152  if (s==UNCREATED) {
153  assert(m_d->state==ERASED);
154  }
155 #endif
156  m_d->state = s;
157  if (s==REFRESHED||s==ERASED)
158  m_d->channel->emitRefreshInfoChanged();
159 }

◆ setupEnergyMode()

void VP1CaloCellSystem::setupEnergyMode ( )
private

Definition at line 1139 of file VP1CaloCellSystem.cxx.

1140 {
1141  // Prepare Separator Helpers for large changes
1142  VP1CC_SeparatorMap::iterator itSepHelp = m_clockwork->sepHelperMap.begin();
1143  for(;itSepHelp != m_clockwork->sepHelperMap.end(); ++itSepHelp)
1144  itSepHelp->second->largeChangesBegin();
1145 
1146  // Create Managers
1147  m_clockwork->BuildCellManagers();
1148 
1149  // Assign Cells to Managers
1150  m_clockwork->FillManagers();
1151 
1152  // Update scene with initial values of controller objects
1153  const VP1CCIntervalMap& intervals = m_clockwork->controller->selectionIntervals();
1154  VP1CCManagerContainer::iterator it = m_clockwork->cell_managers.begin();
1155  for(; it!=m_clockwork->cell_managers.end(); ++it)
1156  it->second->selectionUpdated(intervals);
1157 
1158  // Large changes over
1159  itSepHelp = m_clockwork->sepHelperMap.begin();
1160  for(;itSepHelp != m_clockwork->sepHelperMap.end(); ++itSepHelp)
1161  itSepHelp->second->largeChangesEnd();
1162 
1163  updateGUI();
1164 }

◆ setUserSelectionNotificationsEnabled()

void IVP13DSystem::setUserSelectionNotificationsEnabled ( SoCooperativeSelection *  sel,
bool  enabled 
)
inherited

Definition at line 310 of file IVP13DSystem.cxx.

311 {
312  if (!selection) {
313  message("setUserSelectionNotificationsEnabled Error: NULL selection pointer!");
314  return;
315  }
316  if (Imp::selection2system.find(selection)==Imp::selection2system.end()) {
317  message("setUserSelectionNotificationsEnabled Error: Called for selection which was never registered!");
318  return;
319  }
320  if (enabled != m_d->selectionsWithDisabledNotifications.contains(selection))
321  return;
322 
323  if (enabled)
324  m_d->selectionsWithDisabledNotifications.remove(selection);
325  else
326  m_d->selectionsWithDisabledNotifications << selection;
327 
328 }

◆ state()

IVP1System::State IVP1System::state ( ) const
inherited

Definition at line 129 of file IVP1System.cxx.

130 {
131  return m_d->state;
132 }

◆ storeGate()

StoreGateSvc* IVP1System::storeGate ( ) const
inlineinherited

Definition at line 119 of file IVP1System.h.

119 { return eventStore(); }//OBSOLETE NAME. Use eventStore() instead.

◆ str() [1/30]

static QString VP1String::str ( const Amg::Vector3D &  t)
inlinestaticinherited

Definition at line 98 of file VP1String.h.

98 { return "("+str(t.x())+", "+str(t.y())+", "+str(t.z())+")"; }

◆ str() [2/30]

static QString VP1String::str ( const bool  b)
inlinestaticinherited

Definition at line 53 of file VP1String.h.

53 { return b?"True":"False"; }

◆ str() [3/30]

static QString VP1String::str ( const char *  c)
inlinestaticinherited

Definition at line 50 of file VP1String.h.

50 { return c; }

◆ str() [4/30]

static QString VP1String::str ( const double &  d)
inlinestaticinherited

Definition at line 81 of file VP1String.h.

81 { return QString::number(d); }

◆ str() [5/30]

static QString VP1String::str ( const float &  f)
inlinestaticinherited

Definition at line 82 of file VP1String.h.

82 { return QString::number(f); }

◆ str() [6/30]

template<class T >
static QString VP1String::str ( const HepGeom::BasicVector3D< T > &  t)
inlinestaticinherited

Definition at line 95 of file VP1String.h.

95 { return "("+str(t.x())+", "+str(t.y())+", "+str(t.z())+")"; }

◆ str() [7/30]

QString VP1String::str ( const QColor &  c)
staticinherited

Definition at line 30 of file VP1String.cxx.

31 {
32  return c.isValid() ? c.name() : "Invalid";
33 }

◆ str() [8/30]

template<class T >
static QString VP1String::str ( const QFlags< T > &  f)
inlinestaticinherited

Definition at line 91 of file VP1String.h.

91 { return "0x"+QString::number(f, 16).toUpper().rightJustified(8,'0'); }

◆ str() [9/30]

template<class T >
static QString VP1String::str ( const QList< T > &  t)
inlinestaticinherited

Definition at line 102 of file VP1String.h.

102 { return "QList of size"+QString::number(t.size()); }

◆ str() [10/30]

static QString VP1String::str ( const QString &  s)
inlinestaticinherited

Definition at line 49 of file VP1String.h.

49 { return s; }

◆ str() [11/30]

QString VP1String::str ( const SbColor &  c)
staticinherited

Definition at line 36 of file VP1String.cxx.

37 {
38  return str(VP1QtInventorUtils::sbcol2qcol(c));
39 }

◆ str() [12/30]

QString VP1String::str ( const SbVec2d &  v)
staticinherited

Definition at line 61 of file VP1String.cxx.

61 { double x,y; v.getValue(x,y); return "("+str(x)+", "+str(y)+")"; }

◆ str() [13/30]

QString VP1String::str ( const SbVec2f &  v)
staticinherited

Definition at line 62 of file VP1String.cxx.

62 { float x,y; v.getValue(x,y); return "("+str(x)+", "+str(y)+")"; }

◆ str() [14/30]

QString VP1String::str ( const SbVec2s &  v)
staticinherited

Definition at line 63 of file VP1String.cxx.

63 { short x,y; v.getValue(x,y); return "("+str(x)+", "+str(y)+")"; }

◆ str() [15/30]

QString VP1String::str ( const SbVec3d &  v)
staticinherited

Definition at line 64 of file VP1String.cxx.

64 { double x,y,z; v.getValue(x,y,z); return "("+str(x)+", "+str(y)+", "+str(z)+")"; }

◆ str() [16/30]

QString VP1String::str ( const SbVec3f &  v)
staticinherited

Definition at line 65 of file VP1String.cxx.

65 { float x,y,z; v.getValue(x,y,z); return "("+str(x)+", "+str(y)+", "+str(z)+")"; }

◆ str() [17/30]

QString VP1String::str ( const SbVec3s &  v)
staticinherited

Definition at line 66 of file VP1String.cxx.

66 { short x,y,z; v.getValue(x,y,z); return "("+str(x)+", "+str(y)+", "+str(z)+")"; }

◆ str() [18/30]

QString VP1String::str ( const SbVec4d &  v)
staticinherited

Definition at line 67 of file VP1String.cxx.

67 { double x,y,z,t; v.getValue(x,y,z,t); return "("+str(x)+", "+str(y)+", "+str(z)+", "+str(t)+")"; }

◆ str() [19/30]

QString VP1String::str ( const SbVec4f &  v)
staticinherited

Definition at line 68 of file VP1String.cxx.

68 { float x,y,z,t; v.getValue(x,y,z,t); return "("+str(x)+", "+str(y)+", "+str(z)+", "+str(t)+")"; }

◆ str() [20/30]

template<class T >
static QString VP1String::str ( const T *  t)
inlinestaticinherited

Definition at line 87 of file VP1String.h.

87 { return str(static_cast<const void* >(t)); }

◆ str() [21/30]

QString VP1String::str ( const void *  p)
staticinherited

Definition at line 48 of file VP1String.cxx.

49 {
50  if (p) {
51  std::ostringstream s;
52  s << p;
53  // Explicitly naming QString here avoids a cppcheck warning.
54  return QString (s.str().c_str());
55  } else {
56  return "NULL";
57  }
58 }

◆ str() [22/30]

QString VP1String::str ( const VP1Interval &  i)
staticinherited

Definition at line 42 of file VP1String.cxx.

43 {
44  return i.toString();
45 }

◆ str() [23/30]

static QString VP1String::str ( int  n)
inlinestaticinherited

Definition at line 77 of file VP1String.h.

77 { return QString::number(n); }

◆ str() [24/30]

static QString VP1String::str ( long  n)
inlinestaticinherited

Definition at line 75 of file VP1String.h.

75 { return QString::number(n); }

◆ str() [25/30]

static QString VP1String::str ( qlonglong  n)
inlinestaticinherited

Definition at line 79 of file VP1String.h.

79 { return QString::number(n); }

◆ str() [26/30]

static QString VP1String::str ( qulonglong  n)
inlinestaticinherited

Definition at line 80 of file VP1String.h.

80 { return QString::number(n); }

◆ str() [27/30]

static QString VP1String::str ( short int  n)
inlinestaticinherited

Definition at line 73 of file VP1String.h.

73 { return QString::number(n); }

◆ str() [28/30]

static QString VP1String::str ( uint  n)
inlinestaticinherited

Definition at line 78 of file VP1String.h.

78 { return QString::number(n); }

◆ str() [29/30]

static QString VP1String::str ( ulong  n)
inlinestaticinherited

Definition at line 76 of file VP1String.h.

76 { return QString::number(n); }

◆ str() [30/30]

static QString VP1String::str ( unsigned short int  n)
inlinestaticinherited

Definition at line 74 of file VP1String.h.

74 { return QString::number(n); }

◆ sysmessage

void IVP1System::sysmessage ( QString  ) const
signalinherited

◆ systemcreate()

void VP1CaloCellSystem::systemcreate ( StoreGateSvc *  detstore)
virtual

Reimplemented from IVP13DSystemSimple.

Definition at line 464 of file VP1CaloCellSystem.cxx.

465 {
466  // Make sure we can use required custom 3D objects:
467  SoGenericBox::initClass();
468 
469  // ------------- DD Managers and ID Helpers -------------
470  StatusCode status = detstore->retrieve(m_clockwork->tile_dd_man);
471  if(status.isFailure() || m_clockwork->tile_dd_man==nullptr) {
472  m_clockwork->noCalo = true;
473  messageDebug("Unable to retrieve Tile DD Manager");
474  return;
475  }
476 
477  status = detstore->retrieve(m_clockwork->calo_id,"CaloCell_ID");
478  if(status.isFailure() || m_clockwork->calo_id==nullptr) {
479  m_clockwork->noCalo = true;
480  messageDebug("0 pointer to Calo ID Helper");
481  return;
482  }
483 
484  m_clockwork->tile_id = m_clockwork->tile_dd_man->get_id();
485  if(m_clockwork->tile_id ==nullptr) {
486  m_clockwork->noCalo = true;
487  messageDebug("0 pointer to Tile ID Helper");
488  return;
489  }
490 
491  status = detstore->retrieve(m_clockwork->tile_hw_id);
492  if(status.isFailure() || m_clockwork->tile_hw_id==nullptr) {
493  messageDebug("Unable to retrieve Tile HWID");
494  m_clockwork->tile_hw_id = nullptr;
495  m_clockwork->noTileDigitsGlobal = true;
496  }
497  // ------------- DD Managers and ID Helpers -------------
498 
499 
500  // ------------- Tools/Services -------------
501  status = detstore->retrieve(m_clockwork->tile_info,"TileInfo");
502  if(status.isFailure() || m_clockwork->tile_info==nullptr) {
503  messageDebug("Unable to retrieve Tile Info");
504  m_clockwork->tile_info = nullptr;
505  m_clockwork->noTileDigitsGlobal = true;
506  }
507 
508  m_clockwork->tile_cabling = TileCablingService::getInstance();
509  if(m_clockwork->tile_cabling==nullptr) {
510  messageDebug("0 pointer to TileCabling");
511  m_clockwork->noTileDigitsGlobal = true;
512  }
513 
514  status = detstore->retrieve(m_clockwork->lar_onlineID,"LArOnlineID");
515  if (status.isFailure() || m_clockwork->lar_onlineID == nullptr) {
516  messageDebug("Failed to retrieve LAr online ID");
517  m_clockwork->lar_onlineID = nullptr;
518  }
519 
520 
521  status = toolSvc()->retrieveTool("CaloBadChanTool",m_clockwork->calo_badchannel);
522  if (status.isFailure() || m_clockwork->calo_badchannel == nullptr) {
523  messageDebug("Failed to locate Calo Bad Channel Tool");
524  m_clockwork->calo_badchannel = nullptr;
525  }
526 
527  // Pass retrieved pointers to the controller (for Tile Pulse display)
528  m_clockwork->controller->initTilePulse(m_clockwork->tile_hw_id,
529  m_clockwork->tile_info,
530  m_clockwork->tile_cabling);
531  // ------------- Tools/Services -------------
532 
533 
534  // -------------- MBTS ----------------
535  try {
536  m_clockwork->mbtsHelper->systemcreate(detstore);
537  } catch(std::runtime_error& err) {
538  message (err.what());
539  }
540  // -------------- MBTS ----------------
541 }

◆ systemerase()

void VP1CaloCellSystem::systemerase ( )
virtual

Reimplemented from IVP13DSystemSimple.

Definition at line 543 of file VP1CaloCellSystem.cxx.

544 {
545  // Clear node 2 CC map
546  m_clockwork->node2ccMap.clear();
547 
548  // Delete Cell Managers and clear the map
549  VP1CCManagerContainer::iterator it = m_clockwork->cell_managers.begin();
550  for(; it!=m_clockwork->cell_managers.end(); ++it)
551  if(it->second) delete it->second;
552 
553  m_clockwork->cell_managers.clear();
554  m_clockwork->calocells = 0;
555 
556  // delete separator helpers and clear the separator helper map
557  VP1CC_SeparatorMap::iterator itSepHelper = m_clockwork->sepHelperMap.begin();
558  for(; itSepHelper!= m_clockwork->sepHelperMap.end(); ++itSepHelper)
559  if(itSepHelper->second) delete itSepHelper->second;
560  m_clockwork->sepHelperMap.clear();
561 
562  // MBTS
563  m_clockwork->mbtsHelper->systemerase();
564 }

◆ systemuncreate()

void VP1CaloCellSystem::systemuncreate ( )
virtual

Reimplemented from IVP13DSystemSimple.

Definition at line 566 of file VP1CaloCellSystem.cxx.

567 {
568  messageDebug("VP1CaloCellSystem::systemuncreate()...");
569  m_clockwork->controller->DeleteDigitForms();
570 }

◆ toolSvc()

IToolSvc * IVP1System::toolSvc ( ) const
inherited

Definition at line 330 of file IVP1System.cxx.

331 {
332  return VP1AthenaPtrs::toolSvc();
333 }

◆ uncreate()

void IVP13DSystemSimple::uncreate ( )
privatevirtualinherited

Reimplemented from IVP1System.

Definition at line 202 of file IVP13DSystemSimple.cxx.

203 {
204 
205  if(VP1Msg::verbose()){
206  messageDebug("uncreate()...");
207  }
208 
209  assert(m_d->wascreated);
210  assert(!m_d->wasrefreshed);
211  m_d->rootE->enableNotify(false);
212  m_d->rootR->enableNotify(false);
213  systemuncreate();
214  m_d->root->removeAllChildren();
215  m_d->rootE->removeAllChildren();
216  m_d->rootR->removeAllChildren();
217  m_d->wascreated=false;
218 }

◆ unregisterSelectionNode()

void IVP13DSystem::unregisterSelectionNode ( SoCooperativeSelection *  selection)
inherited

Definition at line 281 of file IVP13DSystem.cxx.

282 {
283  if (!selection) {
284  message("unregisterSelectionNode Error: NULL selection pointer!");
285  return;
286  }
287  if (Imp::selection2system.find(selection)==Imp::selection2system.end()) {
288  message("registerSelectionNode Error: Trying to unregister unknown selection node!");
289  return;
290  }
291 
292  selection->removeSelectionCallback( Imp::made_selection, selection );
293  selection->removeDeselectionCallback( Imp::made_deselection, selection );
294  selection->removeStartCallback( Imp::start_changeselection, this );
295  selection->removeFinishCallback( Imp::finished_changeselection, this );
296  selection->removeClickOutsideCallback( Imp::clickedoutside, this );
297 
298  Imp::selection2system.erase(Imp::selection2system.find(selection));
299  if (m_d->selectionsWithDisabledNotifications.contains(selection))
300  m_d->selectionsWithDisabledNotifications.remove(selection);
301  selection->unref();
302 
303  messageVerbose("selection node unregistered");
304 
305 }

◆ updateGUI()

void IVP13DSystemSimple::updateGUI ( )
inlineinherited

Definition at line 89 of file IVP13DSystemSimple.h.

89 { IVP13DSystem::updateGUI(); }

◆ userChangedSelection()

void IVP13DSystem::userChangedSelection ( SoCooperativeSelection *  ,
QSet< SoNode * >  ,
QSet< SoPath * >   
)
virtualinherited

Reimplemented in VP1AODSystem, VP1TrackSystem, VP1PrepRawDataSystem, TrackSystemDisplay, Example3DSystem5, and TrackingSurfacesSystem.

Definition at line 61 of file IVP13DSystem.cxx.

61 {}

◆ userClickedOnBgd()

void IVP13DSystem::userClickedOnBgd ( )
virtualinherited

Reimplemented in VP1AODSystem, VP1TrackSystem, VP1PrepRawDataSystem, and VP1CaloReadoutSystem.

Definition at line 62 of file IVP13DSystem.cxx.

62 {}

◆ userDeselectedSingleNode()

void IVP13DSystem::userDeselectedSingleNode ( SoCooperativeSelection *  ,
SoNode *  ,
SoPath *   
)
virtualinherited

Reimplemented in VP1AODSystem, VP1TrackSystem, and VP1PrepRawDataSystem.

Definition at line 60 of file IVP13DSystem.cxx.

60 {}

◆ userPickedNode()

void VP1CaloCellSystem::userPickedNode ( SoNode *  pickedNode,
SoPath *  pickedPath 
)
virtual

Reimplemented from IVP13DSystemSimple.

Definition at line 752 of file VP1CaloCellSystem.cxx.

753 {
754  messageDebug("VP1CaloCellSystem::userPickedNode()");
755 
756  SoNode* tail = pickedPath->getTail();
757 
758  // Find the VP1CC object which correspond to the selected 3D object
759  VP1CC_SoNode2CCMap::iterator itNode2CC = m_clockwork->node2ccMap.find(tail);
760 
761  if(itNode2CC!=m_clockwork->node2ccMap.end()){
762  // VP1CC object found.
763 
764  SG::ReadCondHandleKey<LArOnOffIdMapping> cablingKey ("LArOnOffIdMap");
765  cablingKey.initialize().ignore();
766  SG::ReadCondHandle<LArOnOffIdMapping> cabling (cablingKey);
767 
768  std::string channel_string = "";
769  if ( cabling.isValid() && m_clockwork->lar_onlineID ) {
770  VP1CC_LAr* larCC = dynamic_cast<VP1CC_LAr*>((*itNode2CC).second);
771  if(larCC) {
772  Identifier cellOffline = larCC->getID();
773 
774  std::ostringstream idstring;
775  if ( m_clockwork->calo_id->is_em(cellOffline) || m_clockwork->calo_id->is_hec(cellOffline) ) {
776  idstring <<"(b_ec=" << m_clockwork->calo_id->pos_neg(cellOffline) << ", samp="
777  << m_clockwork->calo_id->sampling(cellOffline) << ", reg="
778  << m_clockwork->calo_id->region(cellOffline) << ", eta="
779  << m_clockwork->calo_id->eta(cellOffline) << ", phi="
780  << m_clockwork->calo_id->phi(cellOffline) << ") ";
781  }
782  else if ( m_clockwork->calo_id->is_fcal(cellOffline) ) {
783  idstring <<"(pos_neg=" << m_clockwork->calo_id->pos_neg(cellOffline) << ",mod="
784  << m_clockwork->calo_id->sampling(cellOffline) << ",eta="
785  << m_clockwork->calo_id->eta(cellOffline) << ",phi="
786  << m_clockwork->calo_id->phi(cellOffline) << ") ";
787  }
788  channel_string = idstring.str();
789 
790  HWIdentifier hwId;
791  try {
792  hwId = cabling->createSignalChannelID(cellOffline);
793  } catch(LArID_Exception&) {
794  message("LArID Exception caught while creating signal channel id");
795  m_clockwork->controller->ClearHideDigitForms();
796  return;
797  }
798  channel_string += m_clockwork->lar_onlineID->channel_name(hwId);
799  }
800  }
801 
802  // Print information to the log window
803  std::vector<std::string> msg;
804  try {
805  msg = (*itNode2CC).second->ToString(m_clockwork->calo_id, channel_string);
806  } catch(std::runtime_error& err) {
807  message(err.what());
808  return;
809  }
810 
811  for(unsigned int ii=0; ii<msg.size(); ++ii)
812  message((msg[ii]).c_str());
813 
814  // Digits
815  if(m_clockwork->controller->showDigits()) {
816 
817  messageDebug("showDigits() is checked...");
818 
819 
820  // ---------------------- LAr -------------------------
821  VP1CC_LAr* larCC = dynamic_cast<VP1CC_LAr*>((*itNode2CC).second);
822  if(larCC) {
823  messageDebug("LAr node selected");
824  if(!m_clockwork->noLArDigitsEvent) {
825  Identifier cellOffline = larCC->getID();
826  HWIdentifier hwId;
827  try {
828  hwId = cabling->createSignalChannelID(cellOffline);
829  } catch(LArID_Exception& e) {
830  message("EXCEPTION!! LArIDException caught while creating signal channel id!!");
831  m_clockwork->controller->ClearHideDigitForms();
832  return;
833  }
834 
835  LArDigitContainer::const_iterator itLArDig=m_clockwork->lar_digits->begin();
836  for(;itLArDig!=m_clockwork->lar_digits->end(); ++itLArDig) {
837  if((*itLArDig)->hardwareID()==hwId) {
838 
839  message("displaying LAr digits...");
840 
841  try {
842  m_clockwork->controller->displayLArDigits( (*itLArDig)->nsamples(),
843  (*itLArDig)->samples(),
844  msg);
845  } catch (std::exception& e) {
846  message("Exception caught!!");
847  std::cout << "ERROR!!! Exception caught! --> " << e.what() << std::endl;
848  QString title = "ERROR!!! Exception caught!";
849  QString mex = "While displaying LAr digits, an exception has been caught!\n\nException details:\n\n" + QString::fromStdString(e.what());
850  messageDebug("Clearing the DigitForm and returning...");
851  m_clockwork->controller->ClearHideDigitForms();
852  messageDebug("Displaying the QMessageBox...");
853  QWidget* widget = 0; // the message box will be parentless
854  QMessageBox::warning( widget, title,
855  mex,
856  QMessageBox::Ok,
857  QMessageBox::Ok
858  );
859  messageDebug("Box shown. Returning...");
860  return;
861  }
862  messageDebug("Ok. Returning...");
863  return;
864  } // we found the digit container
865  } // loop over digit containers
866 
867  // if not found the right cell and thus if not returning, we arrive here...
868  message("Unable to find digits for the selected cell");
869  } else {
870  message("LAr digit display not available");
871  }
872 
873  // Since we are here, hide digits widgets
874  messageDebug("LAr. Clearing digits form...");
875  m_clockwork->controller->ClearHideDigitForms();
876  messageDebug("Cleared. Returning...");
877  return;
878  }// we are in LAr CC
879 
880 
881  // ------------- Tile Barrel & End Cap ------------------
882  VP1CC_TileBarEc* tileCC = dynamic_cast<VP1CC_TileBarEc*>((*itNode2CC).second);
883  if(tileCC) {
884  messageDebug("Tile Barrel & End Cap");
885  if(!m_clockwork->noTileDigitsEvent) {
886  int frag1, channel1, frag2, channel2;
887  if((tileCC->GetFragChannel(m_clockwork->tile_hw_id,false,frag1,channel1)==0) &&
888  (tileCC->GetFragChannel(m_clockwork->tile_hw_id,true,frag2,channel2)==0)) {
889 
890  // ----------------- Plot digits -------------------
891  const TileDigits* digits1 = 0;
892  TileDigitsContainer::const_iterator itTileDig = m_clockwork->tile_digits->begin();
893 
894  // loop over Tile digits
895  for(;itTileDig!=m_clockwork->tile_digits->end();++itTileDig) {
896  if((*itTileDig)->size() >0 && (*itTileDig)->identify()==frag1) {
897  messageDebug("Baa");
898  digits1 = (**itTileDig)[channel1];
899 
900  // search for another container when we are in D0
901  const TileDigits* digits2 = 0;
902  if(channel2==channel1) {
903  itTileDig = m_clockwork->tile_digits->begin();
904 
905  for(;itTileDig!=m_clockwork->tile_digits->end();++itTileDig) {
906  if((*itTileDig)->size() >0 && (*itTileDig)->identify()==frag2) {
907  digits2 = (**itTileDig)[channel2];
908  break;
909  }
910  }
911  } else { // D0
912  messageDebug("CCC");
913  digits2 = (**itTileDig)[channel2];
914  }
915 
916  if(digits2==0) {
917  messageDebug("DDD");
918  message("Unable to find digits for the PMT 1");
919  m_clockwork->controller->ClearHideDigitForms();
920  return;
921  }
922  messageDebug("Displaying Tile digits...");
923  m_clockwork->controller->displayTileDigits(digits1->NtimeSamples(),
924  digits1->samples(),
925  digits2->samples(),
926  msg);
927  break;
928  } // found digits 1
929  } // loop over tile digits
930 
931 
932  if(digits1==0) {
933  message("Unable to find digits for the PMT 0");
934  m_clockwork->controller->ClearHideDigitForms();
935  return;
936  }
937  // ----------------- Plot digits -------------------
938 
939  // ---------------- Plot pulse --------------------
940  messageDebug("Tile BB & EC plot pulse");
941  TileRawChannelContainer::const_iterator itTileRawCh = m_clockwork->tile_rawchannel->begin();
942  const TileRawChannel* rawchannel1 = 0;
943  // loop over Tile channels
944  for(;itTileRawCh!=m_clockwork->tile_rawchannel->end();++itTileRawCh) {
945 
946  if((*itTileRawCh)->size()>0 && (*itTileRawCh)->identify()==frag1) {
947  rawchannel1 = (**itTileRawCh)[channel1];
948 
949  // find Raw Channel 2
950  const TileRawChannel* rawchannel2 = 0;
951  if(channel2==channel1) {
952  messageDebug("channel2==_channel1");
953  // D0
954  itTileRawCh = m_clockwork->tile_rawchannel->begin();
955  for(;itTileRawCh!=m_clockwork->tile_rawchannel->end();++itTileRawCh)
956  if((*itTileRawCh)->size()>0 && (*itTileRawCh)->identify()==frag2) {
957  messageDebug("Get channel2...");
958  //the following value is never used, gets immediately overwritten after the
959  // break from loop
960  //rawchannel2 = (**itTileRawCh)[channel2];
961  break;
962  }
963  } else{
964  messageDebug("channel2!=_channel1. Get channel2...");
965  }
966  rawchannel2 = (**itTileRawCh)[channel2];
967 
968  if(rawchannel2==0) {
969  message("Unable to get raw channel for PMT1");
970  break;
971  }
972 
973  messageDebug("Displaying Tile pulse...");
974  std::cout << "debug vars :" << rawchannel1 << " - " << rawchannel2 << std::endl;
975  std::cout << m_clockwork->tile_rawchannel << std::endl;
976  std::cout << digits1->samples().size() << std::endl;
977 
978  // note: the controller is the VP1CaloCellController class
979  try {
980  m_clockwork->controller->displayTilePulse(rawchannel1,rawchannel2,m_clockwork->tile_rawchannel,digits1->samples().size());
981  } catch (TileCalib::InvalidRawChanUnit& e) {
982  message("Exception caught!!");
983  std::cout << "ERROR!!! Exception caught from Tile! --> " << e.what() << std::endl;
984  QString title = "ERROR!!! Exception caught!";
985  QString mex = "While displaying Tile Pulse, an exception has been caught!\n\nException details:\n\n" + QString::fromStdString(e.what());
986  messageDebug("Clearing the DigitForm and returning...");
987  m_clockwork->controller->ClearHideDigitForms();
988  messageDebug("Displaying the QMessageBox...");
989  QWidget* widget = 0; // the message box will be parentless
990  QMessageBox::warning( widget, title,
991  mex,
992  QMessageBox::Ok,
993  // | QMessageBox::Discard
994  // | QMessageBox::Cancel,
995  QMessageBox::Ok
996  );
997  messageDebug("Returning...");
998  return;
999  }
1000  messageDebug("Displayed Tile pulse.");
1001  break;
1002  }
1003  }
1004 
1005  if(rawchannel1==0) {
1006  message("Unable to get raw channel for PMT0");
1007  }
1008  // ---------------- Plot pulse --------------------
1009  messageDebug("Returning...");
1010  return;
1011  }
1012  message("Unable to get drawer and channel IDs");
1013  } else
1014  message("Tile digit display not available");
1015 
1016 
1017  messageDebug("clearing...");
1018  m_clockwork->controller->ClearHideDigitForms();
1019  messageDebug("cleared. Return...");
1020  return;
1021  }
1022 
1023  // -------------------------- Tile Crack ------------------------------
1024 
1025  VP1CC_TileCrack* tileCrack = dynamic_cast<VP1CC_TileCrack*>((*itNode2CC).second);
1026  if(tileCrack) {
1027  messageDebug("Tile Crack");
1028  if(!m_clockwork->noTileDigitsEvent) {
1029  int frag, channel;
1030  if(tileCrack->GetFragChannel(m_clockwork->tile_hw_id,false,frag,channel)==0) {
1031  // ----------------- Plot digits -------------------
1032  const TileDigits* digits = 0;
1033  TileDigitsContainer::const_iterator itTileDig = m_clockwork->tile_digits->begin();
1034  for(;itTileDig!=m_clockwork->tile_digits->end();++itTileDig) {
1035  if((*itTileDig)->size() >0 && (*itTileDig)->identify()==frag) {
1036  digits = (**itTileDig)[channel];
1037 
1038  m_clockwork->controller->displayTileDigits(digits->NtimeSamples(),
1039  digits->samples(),
1040  msg);
1041  break;
1042  }
1043  }
1044  if(digits==0) {
1045  message("Unable to find digits");
1046  m_clockwork->controller->ClearHideDigitForms();
1047  return;
1048  }
1049  // ----------------- Plot digits -------------------
1050 
1051  // ---------------- Plot pulse --------------------
1052  TileRawChannelContainer::const_iterator itTileRawCh = m_clockwork->tile_rawchannel->begin();
1053  const TileRawChannel* rawchannel = 0;
1054  for(;itTileRawCh!=m_clockwork->tile_rawchannel->end();++itTileRawCh) {
1055  messageDebug("Tile Crack plot pulse");
1056  if((*itTileRawCh)->size()>0 && (*itTileRawCh)->identify()==frag) {
1057  rawchannel = (**itTileRawCh)[channel];
1058  m_clockwork->controller->displayTilePulse(rawchannel,m_clockwork->tile_rawchannel,digits->samples().size());
1059  }
1060  }
1061  if(rawchannel==0)
1062  message("Unable to get raw channel");
1063  // ---------------- Plot pulse --------------------
1064  return;
1065  }
1066  message("Unable to get drawer and channel ID");
1067  } else
1068  message("Tile digit display not available");
1069 
1070  m_clockwork->controller->ClearHideDigitForms();
1071 
1072  return;
1073  }
1074 
1075  }// show digits
1076  return;
1077  }// Find node in the VP1CC map
1078 
1079  messageDebug("out of the big loop on nodes...");
1080 
1081  // Maybe MBTS has been selected?
1082  std::vector<std::string> msg = m_clockwork->mbtsHelper->userPickedNode(pickedNode);
1083  for(unsigned int ii=0; ii<msg.size(); ++ii)
1084  message((msg[ii]).c_str());
1085 }

◆ userSelectedSingleNode()

void IVP13DSystem::userSelectedSingleNode ( SoCooperativeSelection *  ,
SoNode *  ,
SoPath *   
)
virtualinherited

Reimplemented in VP1AODSystem, VP1TrackSystem, and VP1PrepRawDataSystem.

Definition at line 59 of file IVP13DSystem.cxx.

59 {}

◆ verbose()

static bool IVP1System::verbose ( )
inlinestaticinherited

Definition at line 86 of file IVP1System.h.

86 { return s_vp1verbose; }// Returns true if env var VP1_VERBOSE_OUTPUT=1

◆ warnOnDisabledNotifications()

void IVP13DSystemSimple::warnOnDisabledNotifications ( ) const
inherited

Definition at line 221 of file IVP13DSystemSimple.cxx.

222 {
223  QList<SoNode*> nodesR;
224  QList<SoNode*> nodesE;
225  m_d->getNodesWithDisabledNotifications(m_d->rootR, nodesR);
226  m_d->getNodesWithDisabledNotifications(m_d->rootE, nodesE);
227  if (!nodesR.isEmpty()) {
228  message("WARNING: Found "+str(nodesR.count())+" node"+QString(nodesR.count()>1?"s":0)+" with disabled notifications in permanent scenegraph:");
229  for (SoNode * node : nodesR)
230  message(" => Node ("+str(node)+") of type "+QString(node->getTypeId().getName().getString())+", named "+QString(node->getName().getString()));
231  }
232  if (!nodesE.isEmpty()) {
233  message("WARNING: Found "+str(nodesE.count())+" node"+QString(nodesE.count()>1?"s":0)+" with disabled notifications in event scenegraph:");
234  for (SoNode * node : nodesE)
235  message(" => Node ("+str(node)+") of type "+QString(node->getTypeId().getName().getString())+", named "+QString(node->getName().getString()));
236  }
237 }

Member Data Documentation

◆ m_clockwork

Clockwork* VP1CaloCellSystem::m_clockwork
private

Definition at line 35 of file VP1CaloCellSystem.h.

◆ m_d

Imp* IVP13DSystemSimple::m_d
privateinherited

Definition at line 80 of file IVP13DSystemSimple.h.

◆ s_vp1verbose

const bool IVP1System::s_vp1verbose = VP1QtUtils::environmentVariableIsOn("VP1_VERBOSE_OUTPUT")
staticprivateinherited

Definition at line 158 of file IVP1System.h.

The documentation for this class was generated from the following files:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
IVP13DSystemSimple::systemuncreate
virtual void systemuncreate()
Definition: IVP13DSystemSimple.cxx:27
VP1CaloCell::getID
Identifier getID()
Definition: VP1CaloCells.cxx:53
VP1CaloCellController::displayTileDigits
void displayTileDigits(int n_samples, std::vector< float > samples1, std::vector< float > samples2, std::vector< std::string > &msg)
Definition: VP1CaloCellController.cxx:953
TileRawChannelContainer
Definition: TileRawChannelContainer.h:13
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
VP1CaloCellController::ClearHideDigitForms
void ClearHideDigitForms()
Definition: VP1CaloCellController.cxx:842
IVP1System::Imp::contact_info
const QString contact_info
Definition: IVP1System.cxx:39
VP1CC_TileBarEc::GetFragChannel
int GetFragChannel(const TileHWID *tile_hw_id, bool up, int &frag, int &channel)
Definition: VP1CaloCells.cxx:574
VP1CaloCellSystem::Clockwork::noCalo
bool noCalo
Definition: VP1CaloCellSystem.cxx:91
IVP13DSystem::Imp::selection2system
static std::map< SoCooperativeSelection *, IVP13DSystem * > selection2system
Definition: IVP13DSystem.cxx:46
VP1CaloCellController::displayTilePulse
void displayTilePulse(const TileRawChannel *rawchannel1, const TileRawChannel *rawchannel2, const TileRawChannelContainer *rawchannel_cont, size_t digitsize)
Definition: VP1CaloCellController.cxx:1016
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
VP1Serialise
Definition: VP1Serialise.h:45
VP1CaloCellController::DeleteDigitForms
void DeleteDigitForms()
Definition: VP1CaloCellController.cxx:851
CaloCell_Base_ID::region
int region(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
VP1MbtsHelper::refreshGraph
void refreshGraph(const VP1Interval &interval)
Definition: VP1MbtsHelper.cxx:311
VP1CaloCellController::GetMaterial
SoMaterial * GetMaterial(VP1CC_SeparatorTypes type)
Definition: VP1CaloCellController.cxx:1067
athena.path
path
python interpreter configuration --------------------------------------—
Definition: athena.py:128
IVP13DSystem::Imp::made_selection
static void made_selection(void *userdata, SoPath *path)
Definition: IVP13DSystem.cxx:192
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
VP1CC_LAr
Definition: VP1CaloCells.h:212
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
IVP13DSystemSimple::IVP13DSystemSimple
IVP13DSystemSimple(const QString &name, const QString &information, const QString &contact_info)
Definition: IVP13DSystemSimple.cxx:50
IVP13DSystem::Imp::viewers
std::set< SoQtViewer * > viewers
Definition: IVP13DSystem.cxx:37
IVP13DSystemSimple::buildController
virtual QWidget * buildController()
Definition: IVP13DSystemSimple.cxx:24
RoiUtil::serialise
void serialise(const std::vector< const IRoiDescriptor * > &rois, roiserial_type &s)
serialise an entire vector of IRoiDescriptors
Definition: RoiSerialise.cxx:45
TileCablingService::getInstance
static const TileCablingService * getInstance()
get pointer to service instance
Definition: TileCablingService.cxx:24
VP1CC_TileCrack::GetFragChannel
int GetFragChannel(const TileHWID *tile_hw_id, bool up, int &frag, int &channel)
Definition: VP1CaloCells.cxx:844
tail
std::string tail(std::string s, const std::string &pattern)
tail of a string
Definition: computils.cxx:301
VP1CaloCellSystem::Clockwork::lar_onlineID
const LArOnlineID * lar_onlineID
Definition: VP1CaloCellSystem.cxx:119
IVP1System::CONSTRUCTED
@ CONSTRUCTED
Definition: IVP1System.h:143
TileCalib::InvalidRawChanUnit
Signals invalid use of TileRawChannelUnit.
Definition: TileCalorimeter/TileConditions/TileConditions/Exception.h:20
VP1CaloCellController::initTilePulse
void initTilePulse(const TileHWID *tile_hw_id, const TileInfo *tile_info, const TileCablingService *tile_cabling)
Definition: VP1CaloCellController.cxx:833
hist_file_dump.d
d
Definition: hist_file_dump.py:137
VP1CaloCellSystem::Clockwork::calo_badchannel
const ICaloBadChanTool * calo_badchannel
Definition: VP1CaloCellSystem.cxx:120
CaloCell_Base_ID::pos_neg
int pos_neg(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
fillPileUpNoiseLumi.connect
string connect
Definition: fillPileUpNoiseLumi.py:70
IVP13DSystemSimple::Imp::rootR
SoSeparator * rootR
Definition: IVP13DSystemSimple.cxx:37
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
skel.it
it
Definition: skel.GENtoEVGEN.py:396
VP1Controller::restoreSettings
void restoreSettings(const QByteArray &)
Definition: VP1Controller.cxx:387
IVP1System::m_d
Imp * m_d
Definition: IVP1System.h:130
IVP13DSystemSimple::Imp::rootE
SoSeparator * rootE
Definition: IVP13DSystemSimple.cxx:38
VP1CaloCellController
Definition: VP1CaloCellController.h:33
TileDigits::NtimeSamples
int NtimeSamples(void) const
Definition: TileDigits.h:62
VP1CaloCellController::selectionMbts
VP1Interval selectionMbts() const
Definition: VP1CaloCellController.cxx:1142
IVP1System::inactiveSystemTurnedActive
void inactiveSystemTurnedActive()
VP1Msg::debug
static bool debug()
Definition: VP1Msg.h:32
VP1CaloCellSystem::Clockwork::controller
VP1CaloCellController * controller
Definition: VP1CaloCellSystem.cxx:84
VP1CaloCellController::displayLArDigits
void displayLArDigits(int n_samples, std::vector< short > samples, std::vector< std::string > &msg)
Definition: VP1CaloCellController.cxx:888
VP1CC_TileBarEc
Definition: VP1CaloCells.h:314
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
IVP1System::Imp::refreshing
bool refreshing
Definition: IVP1System.cxx:45
VP1CaloCellSystem::Clockwork::tile_rawchannel
const TileRawChannelContainer * tile_rawchannel
Definition: VP1CaloCellSystem.cxx:130
IVP13DSystem::Imp::clickedoutside
static void clickedoutside(void *userdata, SoCooperativeSelection *sel)
Definition: IVP13DSystem.cxx:65
sendEI_SPB.root
root
Definition: sendEI_SPB.py:34
IVP1ChannelWidget::emitRefreshInfoChanged
void emitRefreshInfoChanged()
Definition: IVP1ChannelWidget.cxx:268
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
StoreGateSvc::keys
void keys(std::vector< std::string > &vkeys, bool includeAlias=false, bool onlyValid=true) const
provide list of all StoreGate keys associated with an object.
VP1CaloCellSystem::Clockwork::SearchTileRawchanKeys
std::string SearchTileRawchanKeys(const std::vector< std::string > &inputKeys)
Definition: VP1CaloCellSystem.cxx:401
TileDigitsContainer
Definition: TileDigitsContainer.h:13
VP1MbtsHelper::systemerase
void systemerase()
Definition: VP1MbtsHelper.cxx:295
VP1CCIntervalMap
QMap< VP1CC_SelectionTypes, VP1CCIntervalPair > VP1CCIntervalMap
Definition: VP1CaloCells.h:119
HWIdentifier
Definition: HWIdentifier.h:13
x
#define x
VP1String::str
static QString str(const QString &s)
Definition: VP1String.h:49
VP1Controller::saveSettings
QByteArray saveSettings() const
Definition: VP1Controller.cxx:405
IVP13DSystemSimple::buildPermanentSceneGraph
virtual void buildPermanentSceneGraph(StoreGateSvc *detstore, SoSeparator *root)
Definition: IVP13DSystemSimple.cxx:25
CaloCell_Base_ID::is_hec
bool is_hec(const Identifier id) const
test if the id belongs to the HEC
IVP1System::s_vp1verbose
static const bool s_vp1verbose
Definition: IVP1System.h:158
VP1CaloCellSystem::Clockwork::noTileDigitsEvent
bool noTileDigitsEvent
Definition: VP1CaloCellSystem.cxx:95
TruthTest.itE
itE
Definition: TruthTest.py:25
VP1CaloCellSystem::Clockwork::tile_hw_id
const TileHWID * tile_hw_id
Definition: VP1CaloCellSystem.cxx:110
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
IVP1System::state
State state() const
Definition: IVP1System.cxx:129
VP1CaloCellSystem::Clockwork::noLArDigitsGlobal
bool noLArDigitsGlobal
Definition: VP1CaloCellSystem.cxx:92
IVP1System::saveState
virtual QByteArray saveState()
Definition: IVP1System.cxx:294
VP1CaloCellSystem::Clockwork::tile_dd_man
const TileDetDescrManager * tile_dd_man
Definition: VP1CaloCellSystem.cxx:105
StoreGateSvc::retrieve
StatusCode retrieve(const T *&ptr) const
Retrieve the default object into a const T*.
IVP13DSystemSimple::Imp::root
SoCooperativeSelection * root
Definition: IVP13DSystemSimple.cxx:36
SoGenericBox::initClass
static void initClass()
Definition: SoGenericBox.cxx:62
VP1CaloCellSystem::Clockwork::tile_digits
const TileDigitsContainer * tile_digits
Definition: VP1CaloCellSystem.cxx:129
IVP13DSystemSimple::buildEventSceneGraph
virtual void buildEventSceneGraph(StoreGateSvc *sg, SoSeparator *root)=0
VP1Controller::customTourEditor
static VP1CustomTourEditor * customTourEditor()
Definition: VP1Controller.h:61
IVP1System::needErase
void needErase()
VP1CaloCellSystem::Clockwork::BuildCellManagers
void BuildCellManagers()
Definition: VP1CaloCellSystem.cxx:186
CaloCell_Base_ID::is_em
bool is_em(const Identifier id) const
test if the id belongs to LArEM
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
VP1MbtsHelper::buildEventSceneGraph
void buildEventSceneGraph(StoreGateSvc *sg, SoSeparator *root)
Definition: VP1MbtsHelper.cxx:274
VP1Msg::prefix_msg
static const char * prefix_msg()
Definition: VP1Msg.h:56
VP1ExtraSepLayerHelper
Definition: VP1ExtraSepLayerHelper.h:22
VP1CaloCellSystem::Clockwork::sepHelperMap
VP1CC_SeparatorMap sepHelperMap
Definition: VP1CaloCellSystem.cxx:155
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:182
IVP1System::Imp::information
const QString information
Definition: IVP1System.cxx:38
IVP13DSystem::Imp::start_changeselection
static void start_changeselection(void *userdata, SoSelection *sel)
Definition: IVP13DSystem.cxx:94
VP1CaloCellSystem::Clockwork::sepTypes
VP1CC_SeparatorTypesSet sepTypes
Definition: VP1CaloCellSystem.cxx:158
lumiFormat.i
int i
Definition: lumiFormat.py:85
z
#define z
CaloCell_Base_ID::is_fcal
bool is_fcal(const Identifier id) const
test if the id belongs to the FCAL - true also for MiniFCAL
beamspotman.n
n
Definition: beamspotman.py:731
VP1CaloCellController::drawOptions
SoGroup * drawOptions() const
Definition: VP1CaloCellController.cxx:828
CaloCell_Base_ID::sampling
int sampling(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
IVP13DSystemSimple::systemerase
virtual void systemerase()
Definition: IVP13DSystemSimple.cxx:28
covarianceTool.title
title
Definition: covarianceTool.py:542
calibdata.exception
exception
Definition: calibdata.py:496
VP1MbtsHelper::systemcreate
void systemcreate(StoreGateSvc *detstore)
Definition: VP1MbtsHelper.cxx:67
TileRawChannel
Definition: TileRawChannel.h:35
CaloCell_Base_ID::eta
int eta(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
IVP1System::REFRESHED
@ REFRESHED
Definition: IVP1System.h:143
IVP1System::Imp::activeState
ActiveState activeState
Definition: IVP1System.cxx:43
VP1CaloCellSystem::Clockwork::noTileDigitsGlobal
bool noTileDigitsGlobal
Definition: VP1CaloCellSystem.cxx:94
IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition: IdentifiableContainerMT.h:239
hist_file_dump.f
f
Definition: hist_file_dump.py:135
VP1CaloCellSystem::Clockwork::cell_managers
VP1CCManagerContainer cell_managers
Definition: VP1CaloCellSystem.cxx:137
VP1CaloCellController::showDigits
bool showDigits() const
Definition: VP1CaloCellController.cxx:1154
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:79
IVP13DSystemSimple::systemcreate
virtual void systemcreate(StoreGateSvc *detstore)
Definition: IVP13DSystemSimple.cxx:23
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition: IdentifiableContainerMT.h:233
IVP13DSystemSimple::ensureBuildController
void ensureBuildController()
Definition: IVP13DSystemSimple.cxx:90
VP1CaloCellSystem::Clockwork::noLArDigitsEvent
bool noLArDigitsEvent
Definition: VP1CaloCellSystem.cxx:93
VP1CaloCellSystem::Clockwork::tile_id
const TileID * tile_id
Definition: VP1CaloCellSystem.cxx:109
IVP1System::Imp::allowupdategui
bool allowupdategui
Definition: IVP1System.cxx:41
VP1Deserialise
Definition: VP1Deserialise.h:44
TileDigits::samples
const std::vector< float > & samples() const
Definition: TileDigits.h:58
IVP1System::UNCREATED
@ UNCREATED
Definition: IVP1System.h:143
IVP1System::eventStore
StoreGateSvc * eventStore() const
Definition: IVP1System.cxx:312
VP1CaloCellSystem::Clockwork::FillManagers
void FillManagers()
Definition: VP1CaloCellSystem.cxx:259
IVP1System::sysmessage
void sysmessage(QString) const
VP1CaloCellSystem::Clockwork::calo_id
const CaloCell_ID * calo_id
Definition: VP1CaloCellSystem.cxx:108
VP1AthenaPtrs::serviceLocator
static ISvcLocator * serviceLocator()
Definition: VP1AthenaPtrs.h:29
IVP1System::ON
@ ON
Definition: IVP1System.h:144
IVP13DSystemSimple::Imp::first
bool first
Definition: IVP13DSystemSimple.cxx:43
VP1AthenaPtrs::eventStore
static StoreGateSvc * eventStore()
Definition: VP1AthenaPtrs.h:27
VP1QtInventorUtils::sbcol2qcol
static QColor sbcol2qcol(const SbColor &)
Definition: VP1QtInventorUtils.cxx:1142
IVP13DSystem::Imp::staticcameras
std::set< SoCamera * > staticcameras
Definition: IVP13DSystem.cxx:36
selection
const std::string selection
Definition: fbtTestBasics.cxx:74
IVP1System::channel
IVP1ChannelWidget * channel() const
Definition: IVP1System.cxx:275
VP1CaloCellSystem::m_clockwork
Clockwork * m_clockwork
Definition: VP1CaloCellSystem.h:34
VP1MbtsHelper::setController
void setController(VP1CaloCellController *)
Definition: VP1MbtsHelper.cxx:324
IVP1System::messageDebug
void messageDebug(const QString &) const
Definition: IVP1System.cxx:347
python.selection.number
number
Definition: selection.py:20
IVP1System::detectorStore
StoreGateSvc * detectorStore() const
Definition: IVP1System.cxx:318
IVP13DSystemSimple::Imp::controllerBuilt
bool controllerBuilt
Definition: IVP13DSystemSimple.cxx:42
TileDigits
Definition: TileDigits.h:30
VP1AthenaPtrs::toolSvc
static IToolSvc * toolSvc()
Definition: VP1AthenaPtrs.h:30
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
IVP13DSystemSimple::Imp::getNodesWithDisabledNotifications
void getNodesWithDisabledNotifications(SoGroup *, QList< SoNode * > &) const
Definition: IVP13DSystemSimple.cxx:240
IVP1System::Imp::controller
QWidget * controller
Definition: IVP1System.cxx:44
VP1Msg::prefix_debug
static const char * prefix_debug()
Definition: VP1Msg.h:57
VP1CaloCellSystem::energyMode
void energyMode()
Definition: VP1CaloCellSystem.cxx:1117
CaloCell_Base_ID::phi
int phi(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
VP1CaloCellController::EnableDigitsCheckbox
void EnableDigitsCheckbox(bool enable)
Definition: VP1CaloCellController.cxx:883
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
IVP1System::registerController
void registerController(QWidget *)
Definition: IVP1System.cxx:224
IVP1System::toolSvc
IToolSvc * toolSvc() const
Definition: IVP1System.cxx:330
VP1MbtsHelper::userPickedNode
std::vector< std::string > userPickedNode(SoNode *pickedNode)
Definition: VP1MbtsHelper.cxx:335
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
SG::ReadCondHandleKey< LArOnOffIdMapping >
python.PyAthena.v
v
Definition: PyAthena.py:154
VP1Msg::prefix_verbose
static const char * prefix_verbose()
Definition: VP1Msg.h:59
IVP13DSystemSimple::updateGUI
void updateGUI()
Definition: IVP13DSystemSimple.h:89
VP1Interval
Definition: VP1Interval.h:23
y
#define y
IVP13DSystem::Imp::made_deselection
static void made_deselection(void *userdata, SoPath *path)
Definition: IVP13DSystem.cxx:227
VP1CaloCellSystem::Clockwork::tile_info
const TileInfo * tile_info
Definition: VP1CaloCellSystem.cxx:117
IVP1System::updateGUI
void updateGUI()
Definition: IVP1System.cxx:262
VP1CC_TileCrack
Definition: VP1CaloCells.h:351
VP1CaloCellController::selectionIntervals
VP1CCIntervalMap selectionIntervals() const
Definition: VP1CaloCellController.cxx:1076
IVP1System::Imp::channel
IVP1ChannelWidget * channel
Definition: IVP1System.cxx:40
IVP13DSystemSimple::warnOnDisabledNotifications
void warnOnDisabledNotifications() const
Definition: IVP13DSystemSimple.cxx:221
VP1CaloCellSystem::setupEnergyMode
void setupEnergyMode()
Definition: VP1CaloCellSystem.cxx:1139
VP1CC_SepMBTS
@ VP1CC_SepMBTS
Definition: VP1CaloCells.h:105
IVP13DSystem::Imp::selectionsWithDisabledNotifications
QSet< SoCooperativeSelection * > selectionsWithDisabledNotifications
Definition: IVP13DSystem.cxx:50
IVP13DSystemSimple::m_d
Imp * m_d
Definition: IVP13DSystemSimple.h:79
LArDigitContainer
Container class for LArDigit.
Definition: LArDigitContainer.h:24
IVP13DSystem::Imp::finished_changeselection
static void finished_changeselection(void *userdata, SoSelection *sel)
Definition: IVP13DSystem.cxx:121
str
Definition: BTagTrackIpAccessor.cxx:11
IVP13DSystem::userClickedOnBgd
virtual void userClickedOnBgd()
Definition: IVP13DSystem.cxx:62
VP1Msg::verbose
static bool verbose()
Definition: VP1Msg.h:31
merge.status
status
Definition: merge.py:17
VP1CaloCellSystem::Clockwork::tile_cabling
const TileCablingService * tile_cabling
Definition: VP1CaloCellSystem.cxx:118
IVP13DSystem::Imp::clickedoutsideScheduled
bool clickedoutsideScheduled
Definition: IVP13DSystem.cxx:53
python.IoTestsLib.w
def w
Definition: IoTestsLib.py:200
IVP1System::Imp::canregistercontroller
bool canregistercontroller
Definition: IVP1System.cxx:46
VP1AthenaPtrs::detectorStore
static StoreGateSvc * detectorStore()
Definition: VP1AthenaPtrs.h:28
IVP13DSystemSimple::Imp::wascreated
bool wascreated
Definition: IVP13DSystemSimple.cxx:41
LArOnlineID_Base::channel_name
std::string channel_name(const HWIdentifier id) const
Return a string corresponding to a feedthrough name given an identifier.
Definition: LArOnlineID_Base.cxx:219
IVP13DSystem::m_d
Imp * m_d
Definition: IVP13DSystem.h:116
VP1CaloCellSystem::Clockwork::node2ccMap
VP1CC_SoNode2CCMap node2ccMap
Definition: VP1CaloCellSystem.cxx:152
python.compressB64.c
def c
Definition: compressB64.py:93
VP1CaloCellSystem::Clockwork::calocells
const CaloCellContainer * calocells
Definition: VP1CaloCellSystem.cxx:127
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
VP1CaloCellSystem::Clockwork::mbtsHelper
VP1MbtsHelper * mbtsHelper
Definition: VP1CaloCellSystem.cxx:144
VP1CaloCellSystem::Clockwork::lar_digits
const LArDigitContainer * lar_digits
Definition: VP1CaloCellSystem.cxx:128
IVP1System::message
void message(const QString &) const
Definition: IVP1System.cxx:336
LArID_Exception
Exception class for LAr Identifiers.
Definition: LArID_Exception.h:20
IVP1System::OFF
@ OFF
Definition: IVP1System.h:144
IVP1System::Imp::state
State state
Definition: IVP1System.cxx:42
IVP1System::messageVerbose
void messageVerbose(const QString &) const
Definition: IVP1System.cxx:354
node
Definition: memory_hooks-stdcmalloc.h:74
IVP1System::ERASED
@ ERASED
Definition: IVP1System.h:143
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
IVP1System::Imp::name
const QString name
Definition: IVP1System.cxx:37
IVP13DSystemSimple::Imp::wasrefreshed
bool wasrefreshed
Definition: IVP13DSystemSimple.cxx:40
IVP1System::restoreFromState
virtual void restoreFromState(QByteArray)
Definition: IVP1System.cxx:302
TileDetDescrManager::get_id
const TileID * get_id() const
Definition: TileDetDescrManager.h:172
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Sun Dec 22 2024 21:54:23 for ATLAS Offline Software by   doxygen 1.8.18