ATLAS Offline Software
Loading...
Searching...
No Matches
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 *, const 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
StoreGateSvcstoreGate () const
StoreGateSvceventStore () const
StoreGateSvcdetectorStore () 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 *)
IVP1ChannelWidgetchannel () 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

Clockworkm_clockwork
Impm_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.

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"),
432{
433}
IVP13DSystemSimple(const QString &name, const QString &information, const QString &contact_info)

◆ ~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;
91}
virtual void userClickedOnBgd()

◆ 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
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}
Athena::TPCnvVers::Old Athena::TPCnvVers::Old Athena::TPCnvVers::Current Athena::TPCnvVers::Old Athena::TPCnvVers::Current TileRawChannelContainer
Athena::TPCnvVers::Old Athena::TPCnvVers::Old Athena::TPCnvVers::Current TileDigitsContainer
@ VP1CC_SepMBTS
void messageDebug(const QString &) const
void message(const QString &) const
StatusCode retrieve(const T *&ptr) const
Retrieve the default object into a const T*.
void keys(std::vector< std::string > &vkeys, bool includeAlias=false, bool onlyValid=true) const
provide list of all StoreGate keys associated with an object.
::StatusCode StatusCode
StatusCode definition for legacy code.
status
Definition merge.py:16

◆ 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

◆ 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}
void messageVerbose(const QString &) const
static bool verbose()
Definition VP1Msg.h:31

◆ 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}
static void start_changeselection(void *userdata, SoSelection *sel)
static void finished_changeselection(void *userdata, SoSelection *sel)
static std::map< SoCooperativeSelection *, IVP13DSystem * > selection2system
static void made_deselection(void *userdata, SoPath *path)
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition hcg.cxx:130
path
python interpreter configuration --------------------------------------—
Definition athena.py:128

◆ detectorStore()

StoreGateSvc * IVP1System::detectorStore ( ) const
inherited

Definition at line 318 of file IVP1System.cxx.

319{
321}
static StoreGateSvc * detectorStore()

◆ 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
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}
virtual QWidget * buildController()
void registerController(QWidget *)
static QString str(const QString &s)
Definition VP1String.h:49

◆ 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");
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}
void warnOnDisabledNotifications() const

◆ eventStore()

StoreGateSvc * IVP1System::eventStore ( ) const
inherited

Definition at line 312 of file IVP1System.cxx.

313{
315}
static StoreGateSvc * eventStore()

◆ 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){
340 }
341 else{
342 std::cout<<VP1Msg::prefix_msg()<<" ["<<m_d->name.toStdString()<<"]: "<<str.toStdString()<<std::endl;
343 }
344}
void sysmessage(QString) const
static const char * prefix_msg()
Definition VP1Msg.h:56

◆ 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}
static bool debug()
Definition VP1Msg.h:32
static const char * prefix_debug()
Definition VP1Msg.h:57

◆ 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}
static const char * prefix_verbose()
Definition VP1Msg.h:59

◆ 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)
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 }
156 m_d->first = false;
157 m_d->root->removeChild(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}
virtual void systemcreate(StoreGateSvc *detstore)
virtual void buildPermanentSceneGraph(StoreGateSvc *detstore, SoSeparator *root)
virtual void buildEventSceneGraph(StoreGateSvc *sg, SoSeparator *root)=0
StoreGateSvc * detectorStore() const

◆ 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 }
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
275 selection->ref();
276
277 messageVerbose("selection node registered");
278}
static void clickedoutside(void *userdata, SoCooperativeSelection *sel)
static void made_selection(void *userdata, SoPath *path)
const std::string selection
std::string find(const std::string &s)
return a remapped string
Definition hcg.cxx:138

◆ 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 }
1109
1110 IVP13DSystemSimple::restoreFromState(state.restoreByteArray());
1111
1112 m_clockwork->controller->restoreSettings(state.restoreByteArray());
1113
1114 state.disableUnrestoredChecks();
1115}
virtual void restoreFromState(QByteArray)
State state() const

◆ saveState()

QByteArray VP1CaloCellSystem::saveState ( )
virtual

Reimplemented from IVP1System.

Definition at line 1087 of file VP1CaloCellSystem.cxx.

1088{
1089 VP1Serialise serialise(0/*version*/,this);
1091
1093
1094 serialise.save(m_clockwork->controller->saveSettings());
1095
1096 serialise.disableUnsavedChecks();
1097 return serialise.result();
1098}
virtual QByteArray saveState()
void serialise(const std::vector< const IRoiDescriptor * > &rois, roiserial_type &s)
serialise an entire vector of IRoiDescriptors

◆ serviceLocator()

ISvcLocator * IVP1System::serviceLocator ( ) const
inherited

Definition at line 324 of file IVP1System.cxx.

325{
327}
static ISvcLocator * serviceLocator()

◆ 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:
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}
void inactiveSystemTurnedActive()
void needErase()

◆ 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}
QMap< VP1CC_SelectionTypes, VP1CCIntervalPair > VP1CCIntervalMap

◆ 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 }
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.
StoreGateSvc * eventStore() const

◆ str() [1/30]

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]

QString VP1String::str ( const bool b)
inlinestaticinherited

Definition at line 53 of file VP1String.h.

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

◆ str() [3/30]

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

Definition at line 50 of file VP1String.h.

50{ return c; }

◆ str() [4/30]

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

Definition at line 81 of file VP1String.h.

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

◆ str() [5/30]

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>
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>
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>
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]

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{
39}
static QColor sbcol2qcol(const SbColor &)

◆ 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)+")"; }
#define y
#define x

◆ 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)+")"; }
#define 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>
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]

QString VP1String::str ( int n)
inlinestaticinherited

Definition at line 77 of file VP1String.h.

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

◆ str() [24/30]

QString VP1String::str ( long n)
inlinestaticinherited

Definition at line 75 of file VP1String.h.

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

◆ str() [25/30]

QString VP1String::str ( qlonglong n)
inlinestaticinherited

Definition at line 79 of file VP1String.h.

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

◆ str() [26/30]

QString VP1String::str ( qulonglong n)
inlinestaticinherited

Definition at line 80 of file VP1String.h.

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

◆ str() [27/30]

QString VP1String::str ( short int n)
inlinestaticinherited

Definition at line 73 of file VP1String.h.

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

◆ str() [28/30]

QString VP1String::str ( uint n)
inlinestaticinherited

Definition at line 78 of file VP1String.h.

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

◆ str() [29/30]

QString VP1String::str ( ulong n)
inlinestaticinherited

Definition at line 76 of file VP1String.h.

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

◆ str() [30/30]

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:
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
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}
IToolSvc * toolSvc() const
static void initClass()
static const TileCablingService * getInstance()
get pointer to service instance

◆ 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}
static IToolSvc * toolSvc()

◆ 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);
214 m_d->root->removeAllChildren();
215 m_d->rootE->removeAllChildren();
216 m_d->rootR->removeAllChildren();
217 m_d->wascreated=false;
218}
virtual void systemuncreate()

◆ 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 }
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
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.

◆ userChangedSelection()

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

◆ userClickedOnBgd()

void IVP13DSystem::userClickedOnBgd ( )
virtualinherited

Reimplemented in VP1AODSystem, VP1CaloReadoutSystem, VP1PrepRawDataSystem, and VP1TrackSystem.

Definition at line 62 of file IVP13DSystem.cxx.

62{}

◆ userDeselectedSingleNode()

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

Reimplemented in VP1AODSystem, VP1PrepRawDataSystem, and VP1TrackSystem.

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}
DataModel_detail::const_iterator< DataVector > const_iterator
Definition DataVector.h:838
IVP1ChannelWidget * channel() const
int NtimeSamples(void) const
Definition TileDigits.h:62
const std::vector< float > & samples() const
Definition TileDigits.h:58
int GetFragChannel(const TileHWID *tile_hw_id, bool up, int &frag, int &channel)
int GetFragChannel(const TileHWID *tile_hw_id, bool up, int &frag, int &channel)
Identifier getID()
std::string tail(std::string s, const std::string &pattern)
tail of a string
MsgStream & msg
Definition testRead.cxx:32

◆ userSelectedSingleNode()

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

Reimplemented in VP1AODSystem, VP1PrepRawDataSystem, and VP1TrackSystem.

Definition at line 59 of file IVP13DSystem.cxx.

59{}

◆ verbose()

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
static const bool s_vp1verbose
Definition IVP1System.h:158

◆ 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: