ATLAS Offline Software
Loading...
Searching...
No Matches
Classes | Public Types | Signals | Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Slots | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
VP1TrackingGeometrySystem Class Reference

#include <VP1TrackingGeometrySystem.h>

Inheritance diagram for VP1TrackingGeometrySystem:
Collaboration diagram for VP1TrackingGeometrySystem:

Classes

struct  Imp

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

 VP1TrackingGeometrySystem ()
virtual ~VP1TrackingGeometrySystem ()
void buildPermanentSceneGraph (StoreGateSvc *detstore, SoSeparator *root)
void buildEventSceneGraph (StoreGateSvc *, SoSeparator *)
QWidget * buildController ()
virtual void systemcreate (StoreGateSvc *detstore)
void ensureBuildController ()
void updateGUI ()
virtual void userPickedNode (SoNode *pickedNode, SoPath *pickedPath)
virtual void systemerase ()
virtual void systemuncreate ()
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
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 Member Functions

void registerController (QWidget *)

Private Slots

void changeTopLevelView ()
void retrieveTrackingGeometry ()
void activateClickedOutside ()

Private Member Functions

void processTrkVolume (const Trk::TrackingVolume *)
void processMsVolume (const Trk::TrackingVolume *, VP1ExtraSepLayerHelper *, VP1ExtraSepLayerHelper *)
void processTrkLayer (const Trk::Layer *, VP1ExtraSepLayerHelper *, unsigned int colorCode)
void processTrkSurface (const Trk::Surface *, VP1ExtraSepLayerHelper *, unsigned int colorCode)
void processMsLayDense (const Trk::TrackingVolume *tvol, VP1ExtraSepLayerHelper *sepHelper, VP1ExtraSepLayerHelper *layHelper, int color)
QByteArray saveState ()
void restoreFromState (QByteArray ba)
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

Imp * m_d

Static Private Attributes

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

Detailed Description

Definition at line 34 of file VP1TrackingGeometrySystem.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

◆ VP1TrackingGeometrySystem()

VP1TrackingGeometrySystem::VP1TrackingGeometrySystem ( )

Definition at line 260 of file VP1TrackingGeometrySystem.cxx.

261 : IVP13DSystemSimple("TrkGeo",
262 "This system displays the tracking geometry.",
263 "Andreas.Salzburger@cern.ch"),
264 m_d( new Imp)
265{
266 m_d->retrieveSuccess = false;
267 m_d->senderMapFilled = false;
268 m_d->volswitch = nullptr;
269
270 // beam pipe
271 m_d->beamPipeSwitch = nullptr;
272 m_d->sephelper_beamPipe = nullptr;
273
274 // Pixel section
275 m_d->pixSurfBarrelSwitch = nullptr;
276 m_d->pixSurfECASwitch = nullptr;
277 m_d->pixSurfECCSwitch = nullptr;
278 m_d->sephelper_pixSurfBarrel = nullptr;
279 m_d->sephelper_pixSurfECA = nullptr;
280 m_d->sephelper_pixSurfECC = nullptr;
281
282 m_d->pixLayBarrelSwitch = nullptr;
283 m_d->pixLayECASwitch = nullptr;
284 m_d->pixLayECCSwitch = nullptr;
285 m_d->sephelper_pixLayBarrel = nullptr;
286 m_d->sephelper_pixLayECA = nullptr;
287 m_d->sephelper_pixLayECC = nullptr;
288
289 // SCT section
290 m_d->sctSurfBarrelSwitch = nullptr;
291 m_d->sctSurfECASwitch = nullptr;
292 m_d->sctSurfECCSwitch = nullptr;
293 m_d->sephelper_sctSurfBarrel = nullptr;
294 m_d->sephelper_sctSurfECA = nullptr;
295 m_d->sephelper_sctSurfECC = nullptr;
296
297 m_d->sctLayBarrelSwitch = nullptr;
298 m_d->sctLayECASwitch = nullptr;
299 m_d->sctLayECCSwitch = nullptr;
300 m_d->sephelper_sctLayBarrel = nullptr;
301 m_d->sephelper_sctLayECA = nullptr;
302 m_d->sephelper_sctLayECC = nullptr;
303
304 // TRT section
305 m_d->trtSurfBarrelSwitch = nullptr;
306 m_d->trtSurfECASwitch = nullptr;
307 m_d->trtSurfECCSwitch = nullptr;
308 m_d->sephelper_trtSurfBarrel = nullptr;
309 m_d->sephelper_trtSurfECA = nullptr;
310 m_d->sephelper_trtSurfECC = nullptr;
311
312 m_d->trtLayBarrelSwitch = nullptr;
313 m_d->trtLayECASwitch = nullptr;
314 m_d->trtLayECCSwitch = nullptr;
315 m_d->sephelper_trtLayBarrel = nullptr;
316 m_d->sephelper_trtLayECA = nullptr;
317 m_d->sephelper_trtLayECC = nullptr;
318
319 // passive layers
320 m_d->passiveLayBarrelSwitch = nullptr;
321 m_d->passiveLayECASwitch = nullptr;
322 m_d->passiveLayECCSwitch = nullptr;
323 m_d->sephelper_passiveLayBarrel = nullptr;
324 m_d->sephelper_passiveLayECA = nullptr;
325 m_d->sephelper_passiveLayECC = nullptr;
326
327 m_d->clipswitch = nullptr;
328 m_d->msBswitch = nullptr;
329 m_d->msIswitch = nullptr;
330 m_d->msOswitch = nullptr;
331 m_d->msBIswitch = nullptr;
332 m_d->msBMswitch = nullptr;
333 m_d->msBOswitch = nullptr;
334 m_d->msEIswitch = nullptr;
335 m_d->msEMswitch = nullptr;
336 m_d->msEOswitch = nullptr;
337 m_d->msCSswitch = nullptr;
338 m_d->msTGswitch = nullptr;
339 m_d->msBIlayswitch = nullptr;
340 m_d->msBMlayswitch = nullptr;
341 m_d->msBOlayswitch = nullptr;
342 m_d->msEIlayswitch = nullptr;
343 m_d->msEMlayswitch = nullptr;
344 m_d->msEOlayswitch = nullptr;
345 m_d->msCSlayswitch = nullptr;
346 m_d->msTGlayswitch = nullptr;
347 m_d->msBTenvswitch = nullptr;
348 m_d->msETenvswitch = nullptr;
349 m_d->msShenvswitch = nullptr;
350 m_d->msFeenvswitch = nullptr;
351 m_d->msRaenvswitch = nullptr;
352 m_d->msBTdlswitch = nullptr;
353 m_d->msETdlswitch = nullptr;
354 m_d->msShdlswitch = nullptr;
355 m_d->msFedlswitch = nullptr;
356 m_d->msRadlswitch = nullptr;
357
358 m_d->sephelper_vol = nullptr;
359 m_d->sephelper_msB = nullptr;
360 m_d->sephelper_msI = nullptr;
361 m_d->sephelper_msO = nullptr;
362 m_d->sephelper_msBI = nullptr;
363 m_d->sephelper_msBM = nullptr;
364 m_d->sephelper_msBO = nullptr;
365 m_d->sephelper_msEI = nullptr;
366 m_d->sephelper_msEM = nullptr;
367 m_d->sephelper_msEO = nullptr;
368 m_d->sephelper_msCS = nullptr;
369 m_d->sephelper_msTG = nullptr;
370 m_d->sephelper_msBIlay = nullptr;
371 m_d->sephelper_msBMlay = nullptr;
372 m_d->sephelper_msBOlay = nullptr;
373 m_d->sephelper_msEIlay = nullptr;
374 m_d->sephelper_msEMlay = nullptr;
375 m_d->sephelper_msEOlay = nullptr;
376 m_d->sephelper_msCSlay = nullptr;
377 m_d->sephelper_msTGlay = nullptr;
378 m_d->sephelper_msBTenv = nullptr;
379 m_d->sephelper_msETenv = nullptr;
380 m_d->sephelper_msShenv = nullptr;
381 m_d->sephelper_msFeenv = nullptr;
382 m_d->sephelper_msRaenv = nullptr;
383 m_d->sephelper_msBTdl = nullptr;
384 m_d->sephelper_msETdl = nullptr;
385 m_d->sephelper_msShdl = nullptr;
386 m_d->sephelper_msFedl = nullptr;
387 m_d->sephelper_msRadl = nullptr;
388
389 m_d->trackvol2sonode = nullptr;
390 m_d->surface2sonode = nullptr;
391
392 m_d->lineEdit_TrackingGeometrySvcName = nullptr;
393 m_d->lineEdit_TrackingGeometryName = nullptr;
394 m_d->pushButton_Retrieve = nullptr;
395
396 m_d->checkBox_pixSurfBarrel = nullptr;
397 m_d->checkBox_pixSurfECA = nullptr;
398 m_d->checkBox_pixSurfECC = nullptr;
399 m_d->checkBox_sctSurfBarrel = nullptr;
400 m_d->checkBox_sctSurfECA = nullptr;
401 m_d->checkBox_sctSurfECC = nullptr;
402 m_d->checkBox_trtSurfBarrel = nullptr;
403 m_d->checkBox_trtSurfECA = nullptr;
404 m_d->checkBox_trtSurfECC = nullptr;
405
406 m_d->checkBox_beamPipe = nullptr;
407 m_d->checkBox_pixLayBarrel = nullptr;
408 m_d->checkBox_pixLayECA = nullptr;
409 m_d->checkBox_pixLayECC = nullptr;
410 m_d->checkBox_sctLayBarrel = nullptr;
411 m_d->checkBox_sctLayECA = nullptr;
412 m_d->checkBox_sctLayECC = nullptr;
413 m_d->checkBox_trtLayBarrel = nullptr;
414 m_d->checkBox_trtLayECA = nullptr;
415 m_d->checkBox_trtLayECC = nullptr;
416 m_d->checkBox_passiveLayBarrel = nullptr;
417 m_d->checkBox_passiveLayECA = nullptr;
418 m_d->checkBox_passiveLayECC = nullptr;
419
420 m_d->checkBox_TrackingVolumes = nullptr;
421 m_d->checkBox_ClipPlane = nullptr;
422 m_d->checkBox_MuonStaticFrameB = nullptr;
423 m_d->checkBox_MuonStaticFrameI = nullptr;
424 m_d->checkBox_MuonStaticFrameO = nullptr;
425 m_d->checkBox_msBIvol = nullptr;
426 m_d->checkBox_msBMvol = nullptr;
427 m_d->checkBox_msBOvol = nullptr;
428 m_d->checkBox_msEIvol = nullptr;
429 m_d->checkBox_msEMvol = nullptr;
430 m_d->checkBox_msEOvol = nullptr;
431 m_d->checkBox_msCSvol = nullptr;
432 m_d->checkBox_msTGvol = nullptr;
433 m_d->checkBox_msBIlay = nullptr;
434 m_d->checkBox_msBMlay = nullptr;
435 m_d->checkBox_msBOlay = nullptr;
436 m_d->checkBox_msEIlay = nullptr;
437 m_d->checkBox_msEMlay = nullptr;
438 m_d->checkBox_msEOlay = nullptr;
439 m_d->checkBox_msCSlay = nullptr;
440 m_d->checkBox_msTGlay = nullptr;
441 m_d->checkBox_msBTenv = nullptr;
442 m_d->checkBox_msETenv = nullptr;
443 m_d->checkBox_msShenv = nullptr;
444 m_d->checkBox_msFeenv = nullptr;
445 m_d->checkBox_msRaenv = nullptr;
446 m_d->checkBox_msBTdl = nullptr;
447 m_d->checkBox_msETdl = nullptr;
448 m_d->checkBox_msShdl = nullptr;
449 m_d->checkBox_msFedl = nullptr;
450 m_d->checkBox_msRadl = nullptr;
451
452 m_d->initialTrackingGeometrySvcName = "AtlasTrackingGeometrySvc";
453 m_d->initialTrackingGeometryName = "";
454
455 m_d->detStore = nullptr;
456 m_d->root = nullptr;
457}
IVP13DSystemSimple::IVP13DSystemSimple
IVP13DSystemSimple(const QString &name, const QString &information, const QString &contact_info)
Definition IVP13DSystemSimple.cxx:50

◆ ~VP1TrackingGeometrySystem()

VP1TrackingGeometrySystem::~VP1TrackingGeometrySystem ( )
virtual

Definition at line 460 of file VP1TrackingGeometrySystem.cxx.

461{
462
463 std::vector<VP1ExtraSepLayerHelper*>::iterator sepHelperIter = m_d->sepHelperContainer.begin();
464 std::vector<VP1ExtraSepLayerHelper*>::iterator sepHelperIterEnd = m_d->sepHelperContainer.end();
465 for ( ; sepHelperIter != sepHelperIterEnd; ++sepHelperIter){
466 if ((*sepHelperIter)) {
467 SoSeparator * sep = (*sepHelperIter)->topSeparator();
468 delete (*sepHelperIter);
469 sep->unref();
470 }
471 }
472
473 delete m_d->trackvol2sonode;
474 delete m_d->surface2sonode;
475 delete m_d;
476}

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}
IVP13DSystem::userClickedOnBgd
virtual void userClickedOnBgd()
Definition IVP13DSystem.cxx:62

◆ 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 * VP1TrackingGeometrySystem::buildController ( )
virtual

Reimplemented from IVP13DSystemSimple.

Definition at line 1315 of file VP1TrackingGeometrySystem.cxx.

1316{
1317 VP1JobConfigInfo::ensureInit(this);
1318 if (!(VP1JobConfigInfo::hasMuonGeometry()
1319 ||VP1JobConfigInfo::hasLArGeometry()
1320 ||VP1JobConfigInfo::hasTileGeometry()
1321 ||VP1JobConfigInfo::hasPixelGeometry()
1322 ||VP1JobConfigInfo::hasSCTGeometry()
1323 ||VP1JobConfigInfo::hasTRTGeometry()))
1324 {
1325 return new QLabel("Geometry not configured.");
1326 }
1327
1328 QWidget * controller = new QWidget(nullptr);
1329 Ui::TrackingGeometryControllerForm ui;
1330 ui.setupUi(controller);
1331
1332 if (!(VP1JobConfigInfo::hasLArGeometry()
1333 ||VP1JobConfigInfo::hasTileGeometry()
1334 ||VP1JobConfigInfo::hasPixelGeometry()
1335 ||VP1JobConfigInfo::hasSCTGeometry()
1336 ||VP1JobConfigInfo::hasTRTGeometry()))
1337 ui.groupBox_idandcalogeometry->setVisible(false);
1338
1339 if (!VP1JobConfigInfo::hasMuonGeometry()) {
1340 ui.groupBox_muonframe->setVisible(false);
1341 ui.groupBox_muonactivematerial->setVisible(false);
1342 ui.groupBox_muoninertmaterial->setVisible(false);
1343 }
1344
1345 connect(ui.checkBox_TrackingVolumes,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1346
1347 connect(ui.checkBox_BeamPipeLayer,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1348 connect(ui.checkBox_LayersECA,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1349 connect(ui.checkBox_LayersBarrel,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1350 connect(ui.checkBox_LayersECC,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1351 connect(ui.checkBox_PixelLayersECA,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1352 connect(ui.checkBox_PixelLayersBarrel,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1353 connect(ui.checkBox_PixelLayersECC,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1354 connect(ui.checkBox_SctLayersECA,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1355 connect(ui.checkBox_SctLayersBarrel,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1356 connect(ui.checkBox_SctLayersECC,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1357 connect(ui.checkBox_TrtLayersECA,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1358 connect(ui.checkBox_TrtLayersBarrel,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1359 connect(ui.checkBox_TrtLayersECC,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1360
1361 connect(ui.checkBox_PixelSurfacesECA,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1362 connect(ui.checkBox_PixelSurfacesBarrel,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1363 connect(ui.checkBox_PixelSurfacesECC,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1364 connect(ui.checkBox_SctSurfacesECA,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1365 connect(ui.checkBox_SctSurfacesBarrel,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1366 connect(ui.checkBox_SctSurfacesECC,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1367
1368 connect(ui.checkBox_ClipPlane,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1369 connect(ui.checkBox_MuonStaticFrameB,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1370 connect(ui.checkBox_MuonStaticFrameI,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1371 connect(ui.checkBox_MuonStaticFrameO,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1372 connect(ui.pushButton_Retrieve,SIGNAL(clicked()),this,SLOT(retrieveTrackingGeometry()));
1373 connect(ui.checkBoxBIVol,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1374 connect(ui.checkBoxBMVol,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1375 connect(ui.checkBoxBOVol,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1376 connect(ui.checkBoxEIVol,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1377 connect(ui.checkBoxEMVol,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1378 connect(ui.checkBoxEOVol,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1379 connect(ui.checkBoxCSCVol,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1380 connect(ui.checkBoxTGCVol,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1381 connect(ui.checkBoxBILay,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1382 connect(ui.checkBoxBMLay,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1383 connect(ui.checkBoxBOLay,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1384 connect(ui.checkBoxEILay,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1385 connect(ui.checkBoxEMLay,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1386 connect(ui.checkBoxEOLay,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1387 connect(ui.checkBoxCSCLay,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1388 connect(ui.checkBoxTGCLay,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1389 connect(ui.checkBoxBTEnv,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1390 connect(ui.checkBoxETEnv,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1391 connect(ui.checkBoxShEnv,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1392 connect(ui.checkBoxFeetEnv,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1393 connect(ui.checkBoxRailEnv,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1394 connect(ui.checkBoxBTDL,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1395 connect(ui.checkBoxETDL,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1396 connect(ui.checkBoxShDL,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1397 connect(ui.checkBoxFeetDL,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1398 connect(ui.checkBoxRailDL,SIGNAL(toggled(bool)),this,SLOT(changeTopLevelView()));
1399 connect( ui.lineEdit_TrackingGeometrySvcName, SIGNAL( returnPressed()),
1400 ui.pushButton_Retrieve, SIGNAL( clicked()));
1401 connect( ui.lineEdit_TrackingGeometryName, SIGNAL( returnPressed()),
1402 ui.pushButton_Retrieve, SIGNAL( clicked()));
1403
1404 m_d->lineEdit_TrackingGeometrySvcName = ui.lineEdit_TrackingGeometrySvcName;
1405 m_d->lineEdit_TrackingGeometryName = ui.lineEdit_TrackingGeometryName;
1406
1407 m_d->lineEdit_TrackingGeometrySvcName->setText( m_d->initialTrackingGeometrySvcName);
1408 m_d->lineEdit_TrackingGeometryName->setText( m_d->initialTrackingGeometryName);
1409
1410 m_d->pushButton_Retrieve = ui.pushButton_Retrieve;
1411 m_d->checkBox_TrackingVolumes = ui.checkBox_TrackingVolumes;
1412
1413 m_d->checkBox_beamPipe = ui.checkBox_BeamPipeLayer;
1414 m_d->checkBox_pixLayECA = ui.checkBox_PixelLayersECA;
1415 m_d->checkBox_pixLayBarrel = ui.checkBox_PixelLayersBarrel;
1416 m_d->checkBox_pixLayECC = ui.checkBox_PixelLayersECC;
1417 m_d->checkBox_sctLayECA = ui.checkBox_SctLayersECA;
1418 m_d->checkBox_sctLayBarrel = ui.checkBox_SctLayersBarrel;
1419 m_d->checkBox_sctLayECC = ui.checkBox_SctLayersECC;
1420 m_d->checkBox_trtLayECA = ui.checkBox_TrtLayersECA;
1421 m_d->checkBox_trtLayBarrel = ui.checkBox_TrtLayersBarrel;
1422 m_d->checkBox_trtLayECC = ui.checkBox_TrtLayersECC;
1423 m_d->checkBox_passiveLayECA = ui.checkBox_LayersECA;
1424 m_d->checkBox_passiveLayBarrel = ui.checkBox_LayersBarrel;
1425 m_d->checkBox_passiveLayECC = ui.checkBox_LayersECC;
1426
1427 m_d->checkBox_pixSurfECA = ui.checkBox_PixelSurfacesECA;
1428 m_d->surfacesNames.emplace_back("PixelECA");
1429 m_d->checkBox_pixSurfBarrel = ui.checkBox_PixelSurfacesBarrel;
1430 m_d->surfacesNames.emplace_back("PixelBarrel");
1431 m_d->checkBox_pixSurfECC = ui.checkBox_PixelSurfacesECC;
1432 m_d->surfacesNames.emplace_back("PixelECC");
1433 m_d->checkBox_sctSurfECA = ui.checkBox_SctSurfacesECA;
1434 m_d->surfacesNames.emplace_back("SCT_ECA");
1435 m_d->checkBox_sctSurfBarrel = ui.checkBox_SctSurfacesBarrel;
1436 m_d->surfacesNames.emplace_back("SCT_Barrel");
1437 m_d->checkBox_sctSurfECC = ui.checkBox_SctSurfacesECC;
1438 m_d->surfacesNames.emplace_back("SCT_ECC");
1439
1440 m_d->checkBox_ClipPlane = ui.checkBox_ClipPlane;
1441 m_d->checkBox_MuonStaticFrameB = ui.checkBox_MuonStaticFrameB;
1442 m_d->checkBox_MuonStaticFrameI = ui.checkBox_MuonStaticFrameI;
1443 m_d->checkBox_MuonStaticFrameO = ui.checkBox_MuonStaticFrameO;
1444 m_d->checkBox_msBIvol = ui.checkBoxBIVol;
1445 m_d->checkBox_msBMvol = ui.checkBoxBMVol;
1446 m_d->checkBox_msBOvol = ui.checkBoxBOVol;
1447 m_d->checkBox_msEIvol = ui.checkBoxEIVol;
1448 m_d->checkBox_msEMvol = ui.checkBoxEMVol;
1449 m_d->checkBox_msEOvol = ui.checkBoxEOVol;
1450 m_d->checkBox_msCSvol = ui.checkBoxCSCVol;
1451 m_d->checkBox_msTGvol = ui.checkBoxTGCVol;
1452 m_d->checkBox_msBIlay = ui.checkBoxBILay;
1453 m_d->checkBox_msBMlay = ui.checkBoxBMLay;
1454 m_d->checkBox_msBOlay = ui.checkBoxBOLay;
1455 m_d->checkBox_msEIlay = ui.checkBoxEILay;
1456 m_d->checkBox_msEMlay = ui.checkBoxEMLay;
1457 m_d->checkBox_msEOlay = ui.checkBoxEOLay;
1458 m_d->checkBox_msCSlay = ui.checkBoxCSCLay;
1459 m_d->checkBox_msTGlay = ui.checkBoxTGCLay;
1460 m_d->checkBox_msBTenv = ui.checkBoxBTEnv;
1461 m_d->checkBox_msBTdl = ui.checkBoxBTDL;
1462 m_d->checkBox_msETenv = ui.checkBoxETEnv;
1463 m_d->checkBox_msETdl = ui.checkBoxETDL;
1464 m_d->checkBox_msShenv = ui.checkBoxShEnv;
1465 m_d->checkBox_msShdl = ui.checkBoxShDL;
1466 m_d->checkBox_msFeenv = ui.checkBoxFeetEnv;
1467 m_d->checkBox_msFedl = ui.checkBoxFeetDL;
1468 m_d->checkBox_msRaenv = ui.checkBoxRailEnv;
1469 m_d->checkBox_msRadl = ui.checkBoxRailDL;
1470
1471
1472
1473 std::cout << " Filling map entry [ " << m_d->checkBox_pixSurfBarrel << " ] - with " << m_d->pixSurfBarrelSwitch << std::endl;
1474
1475 // loop and set initial state
1476 std::map<QObject*,std::pair<SoSwitch*,bool> >::iterator chbMapIter = m_d->checkBoxSwitchMap.begin();
1477 std::map<QObject*,std::pair<SoSwitch*,bool> >::iterator chbMapIterEnd = m_d->checkBoxSwitchMap.end();
1478
1479 for ( ; chbMapIter != chbMapIterEnd; ++chbMapIter ){
1480 QCheckBox* checkBox = dynamic_cast<QCheckBox*>((chbMapIter)->first);
1481 if (checkBox) checkBox->setChecked( ((chbMapIter)->second).second );
1482
1483 }
1484 return controller;
1485}
VP1JobConfigInfo::hasTileGeometry
static bool hasTileGeometry()
Definition VP1JobConfigInfo.cxx:133
VP1JobConfigInfo::hasTRTGeometry
static bool hasTRTGeometry()
Definition VP1JobConfigInfo.cxx:129
VP1JobConfigInfo::hasLArGeometry
static bool hasLArGeometry()
Definition VP1JobConfigInfo.cxx:132
VP1JobConfigInfo::hasPixelGeometry
static bool hasPixelGeometry()
Definition VP1JobConfigInfo.cxx:127
VP1JobConfigInfo::hasSCTGeometry
static bool hasSCTGeometry()
Definition VP1JobConfigInfo.cxx:128
VP1JobConfigInfo::ensureInit
static void ensureInit(IVP1System *)
Definition VP1JobConfigInfo.h:30
VP1JobConfigInfo::hasMuonGeometry
static bool hasMuonGeometry()
Definition VP1JobConfigInfo.cxx:134

◆ buildEventSceneGraph()

void VP1TrackingGeometrySystem::buildEventSceneGraph ( StoreGateSvc * ,
SoSeparator *  )
inlinevirtual

Implements IVP13DSystemSimple.

Definition at line 42 of file VP1TrackingGeometrySystem.h.

42{};

◆ buildExtraDisplayWidget()

virtual QWidget * IVP13DSystem::buildExtraDisplayWidget ( )
inlinevirtualinherited

Definition at line 106 of file IVP13DSystem.h.

106{ return 0; }

◆ buildPermanentSceneGraph()

void VP1TrackingGeometrySystem::buildPermanentSceneGraph ( StoreGateSvc * detstore,
SoSeparator * root )
virtual

Reimplemented from IVP13DSystemSimple.

Definition at line 479 of file VP1TrackingGeometrySystem.cxx.

480{
481 m_d->detStore = detstore;
482 m_d->root = root;
483}
sendEI_SPB.root
root
Definition sendEI_SPB.py:34

◆ changeTopLevelView

void VP1TrackingGeometrySystem::changeTopLevelView ( )
privateslot

Definition at line 1489 of file VP1TrackingGeometrySystem.cxx.

1490{
1491 if (! m_d->retrieveSuccess)
1492 return;
1493
1494
1495 if (! m_d->senderMapFilled ){
1496 // register the map for states and signal handling
1497 m_d->checkBoxSwitchMap[m_d->checkBox_TrackingVolumes] = std::make_pair(m_d->volswitch,false);
1498 m_d->checkBoxSwitchMap[m_d->checkBox_pixSurfBarrel] = std::make_pair(m_d->pixSurfBarrelSwitch,false);
1499 m_d->checkBoxSwitchMap[m_d->checkBox_pixSurfECA] = std::make_pair(m_d->pixSurfECASwitch,false);
1500 m_d->checkBoxSwitchMap[m_d->checkBox_pixSurfECC] = std::make_pair(m_d->pixSurfECCSwitch,false);
1501 m_d->checkBoxSwitchMap[m_d->checkBox_sctSurfBarrel] = std::make_pair(m_d->sctSurfBarrelSwitch,false);
1502 m_d->checkBoxSwitchMap[m_d->checkBox_sctSurfECA] = std::make_pair(m_d->sctSurfECASwitch,false);
1503 m_d->checkBoxSwitchMap[m_d->checkBox_sctSurfECC] = std::make_pair(m_d->sctSurfECCSwitch,false);
1504 m_d->checkBoxSwitchMap[m_d->checkBox_trtSurfBarrel] = std::make_pair(m_d->trtSurfBarrelSwitch,false);
1505 m_d->checkBoxSwitchMap[m_d->checkBox_trtSurfECA] = std::make_pair(m_d->trtSurfECASwitch,false);
1506 m_d->checkBoxSwitchMap[m_d->checkBox_trtSurfECC] = std::make_pair(m_d->trtSurfECCSwitch,false);
1507 m_d->checkBoxSwitchMap[m_d->checkBox_beamPipe] = std::make_pair(m_d->beamPipeSwitch,false);
1508 m_d->checkBoxSwitchMap[m_d->checkBox_pixLayBarrel] = std::make_pair(m_d->pixLayBarrelSwitch,false);
1509 m_d->checkBoxSwitchMap[m_d->checkBox_pixLayECA] = std::make_pair(m_d->pixLayECASwitch,false);
1510 m_d->checkBoxSwitchMap[m_d->checkBox_pixLayECC] = std::make_pair(m_d->pixLayECCSwitch,false);
1511 m_d->checkBoxSwitchMap[m_d->checkBox_sctLayBarrel] = std::make_pair(m_d->sctLayBarrelSwitch,false);
1512 m_d->checkBoxSwitchMap[m_d->checkBox_sctLayECA] = std::make_pair(m_d->sctLayECASwitch,false);
1513 m_d->checkBoxSwitchMap[m_d->checkBox_sctLayECC] = std::make_pair(m_d->sctLayECCSwitch,false);
1514 m_d->checkBoxSwitchMap[m_d->checkBox_trtLayBarrel] = std::make_pair(m_d->trtLayBarrelSwitch,false);
1515 m_d->checkBoxSwitchMap[m_d->checkBox_trtLayECA] = std::make_pair(m_d->trtLayECASwitch,false);
1516 m_d->checkBoxSwitchMap[m_d->checkBox_trtLayECC] = std::make_pair(m_d->trtLayECCSwitch,false);
1517 m_d->checkBoxSwitchMap[m_d->checkBox_passiveLayBarrel] = std::make_pair(m_d->passiveLayBarrelSwitch,false);
1518 m_d->checkBoxSwitchMap[m_d->checkBox_passiveLayECA] = std::make_pair(m_d->passiveLayECASwitch,false);
1519 m_d->checkBoxSwitchMap[m_d->checkBox_passiveLayECC] = std::make_pair(m_d->passiveLayECCSwitch,false);
1520 m_d->checkBoxSwitchMap[m_d->checkBox_ClipPlane] = std::make_pair(m_d->clipswitch,false);
1521 m_d->checkBoxSwitchMap[m_d->checkBox_MuonStaticFrameB] = std::make_pair(m_d->msBswitch,false);
1522 m_d->checkBoxSwitchMap[m_d->checkBox_MuonStaticFrameI] = std::make_pair(m_d->msIswitch,false);
1523 m_d->checkBoxSwitchMap[m_d->checkBox_MuonStaticFrameO] = std::make_pair(m_d->msOswitch,false);
1524 m_d->checkBoxSwitchMap[m_d->checkBox_msBIvol] = std::make_pair(m_d->msBIswitch,false);
1525 m_d->checkBoxSwitchMap[m_d->checkBox_msBIlay] = std::make_pair(m_d->msBMswitch,false);
1526 m_d->checkBoxSwitchMap[m_d->checkBox_msBMvol] = std::make_pair(m_d->msBOswitch,false);
1527 m_d->checkBoxSwitchMap[m_d->checkBox_msBMlay] = std::make_pair(m_d->msEIswitch,false);
1528 m_d->checkBoxSwitchMap[m_d->checkBox_msBOvol] = std::make_pair(m_d->msEMswitch,false);
1529 m_d->checkBoxSwitchMap[m_d->checkBox_msBOlay] = std::make_pair(m_d->msEOswitch,false);
1530 m_d->checkBoxSwitchMap[m_d->checkBox_msEIvol] = std::make_pair(m_d->msCSswitch,false);
1531 m_d->checkBoxSwitchMap[m_d->checkBox_msEIlay] = std::make_pair(m_d->msTGswitch,false);
1532 m_d->checkBoxSwitchMap[m_d->checkBox_msEMvol] = std::make_pair(m_d->msBIlayswitch,false);
1533 m_d->checkBoxSwitchMap[m_d->checkBox_msEMlay] = std::make_pair(m_d->msBMlayswitch,false);
1534 m_d->checkBoxSwitchMap[m_d->checkBox_msEOvol] = std::make_pair(m_d->msBOlayswitch,false);
1535 m_d->checkBoxSwitchMap[m_d->checkBox_msEOlay] = std::make_pair(m_d->msEIlayswitch,false);
1536 m_d->checkBoxSwitchMap[m_d->checkBox_msCSvol] = std::make_pair(m_d->msEMlayswitch,false);
1537 m_d->checkBoxSwitchMap[m_d->checkBox_msCSlay] = std::make_pair(m_d->msEOlayswitch,false);
1538 m_d->checkBoxSwitchMap[m_d->checkBox_msTGvol] = std::make_pair(m_d->msCSlayswitch,false);
1539 m_d->checkBoxSwitchMap[m_d->checkBox_msTGlay] = std::make_pair(m_d->msTGlayswitch,false);
1540 m_d->checkBoxSwitchMap[m_d->checkBox_msBTenv] = std::make_pair(m_d->msBTenvswitch,false);
1541 m_d->checkBoxSwitchMap[m_d->checkBox_msETenv] = std::make_pair(m_d->msETenvswitch,false);
1542 m_d->checkBoxSwitchMap[m_d->checkBox_msShenv] = std::make_pair(m_d->msShenvswitch,false);
1543 m_d->checkBoxSwitchMap[m_d->checkBox_msFeenv] = std::make_pair(m_d->msFeenvswitch,false);
1544 m_d->checkBoxSwitchMap[m_d->checkBox_msRaenv] = std::make_pair(m_d->msRaenvswitch,false);
1545 m_d->checkBoxSwitchMap[m_d->checkBox_msBTdl] = std::make_pair(m_d->msBTdlswitch,false);
1546 m_d->checkBoxSwitchMap[m_d->checkBox_msETdl] = std::make_pair(m_d->msETdlswitch,false);
1547 m_d->checkBoxSwitchMap[m_d->checkBox_msShdl] = std::make_pair(m_d->msShdlswitch,false);
1548 m_d->checkBoxSwitchMap[m_d->checkBox_msFedl] = std::make_pair(m_d->msFedlswitch,false);
1549 m_d->checkBoxSwitchMap[m_d->checkBox_msRadl] = std::make_pair(m_d->msRadlswitch,false);
1550 m_d->senderMapFilled = true;
1551 }
1552 // loop and set initial state
1553 std::map<QObject*,std::pair<SoSwitch*,bool> >::iterator chbMapIterEnd = m_d->checkBoxSwitchMap.end();
1554 std::map<QObject*,std::pair<SoSwitch*,bool> >::iterator chbMapIter = m_d->checkBoxSwitchMap.find(sender());
1555
1556 if ( chbMapIter != chbMapIterEnd ) {
1557 QCheckBox* checkBox = dynamic_cast<QCheckBox*>((chbMapIter)->first);
1558 SoSwitch* soswitch = ((chbMapIter)->second).first;
1559 if (checkBox && soswitch)
1560 soswitch->whichChild = checkBox->isChecked() ? SO_SWITCH_ALL : SO_SWITCH_NONE;
1561 } else {
1562 message("ERROR: Unknown checkbox");
1563 }
1564}
IVP1System::message
void message(const QString &) const
Definition IVP1System.cxx:336

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

◆ detectorStore()

StoreGateSvc * IVP1System::detectorStore ( ) const
inherited

Definition at line 318 of file IVP1System.cxx.

319{
320 return VP1AthenaPtrs::detectorStore();
321}
VP1AthenaPtrs::detectorStore
static StoreGateSvc * detectorStore()
Definition VP1AthenaPtrs.h:28

◆ disallowUpdateGUI()

void IVP1System::disallowUpdateGUI ( )
privateinherited

Definition at line 250 of file IVP1System.cxx.

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

◆ 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}
IVP13DSystemSimple::buildController
virtual QWidget * buildController()
Definition IVP13DSystemSimple.cxx:24
IVP1System::registerController
void registerController(QWidget *)
Definition IVP1System.cxx:224
VP1String::str
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");
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}
IVP13DSystemSimple::warnOnDisabledNotifications
void warnOnDisabledNotifications() const
Definition IVP13DSystemSimple.cxx:221

◆ eventStore()

StoreGateSvc * IVP1System::eventStore ( ) const
inherited

Definition at line 312 of file IVP1System.cxx.

313{
314 return VP1AthenaPtrs::eventStore();
315}
VP1AthenaPtrs::eventStore
static StoreGateSvc * eventStore()
Definition VP1AthenaPtrs.h:27

◆ 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}
IVP1System::sysmessage
void sysmessage(QString) const
VP1Msg::prefix_msg
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}
VP1Msg::debug
static bool debug()
Definition VP1Msg.h:32
VP1Msg::prefix_debug
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}
IVP1System::messageDebug
void messageDebug(const QString &) const
Definition IVP1System.cxx:347

◆ 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}
VP1Msg::prefix_verbose
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)
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

◆ processMsLayDense()

void VP1TrackingGeometrySystem::processMsLayDense ( const Trk::TrackingVolume * tvol,
VP1ExtraSepLayerHelper * sepHelper,
VP1ExtraSepLayerHelper * layHelper,
int color )
private

Definition at line 1261 of file VP1TrackingGeometrySystem.cxx.

1262{
1263 if (!tvol) return;
1264
1265 // ordered layers
1266 const Trk::BinnedArray< Trk::Layer >* confinedLayers = tvol->confinedLayers();
1267 if (confinedLayers){
1268 std::span<Trk::Layer const * const> layerVector = confinedLayers->arrayObjects();
1269 std::span<Trk::Layer const * const>::iterator layerIter = layerVector.begin();
1270 // loop over layers
1271 for ( ; layerIter != layerVector.end(); ++layerIter){
1272 // push_back the layer
1273 if (*layerIter){
1274 SoNode * node = m_d->surface2sonode->translateSurface((*layerIter)->surfaceRepresentation());
1275 if (node && layHelper ) {
1276 if ((*layerIter)->layerType()>0)
1277 layHelper->addNodeUnderMaterial(node,m_d->colorCodeConverter.getMaterialFromColorCode( color));
1278 else
1279 layHelper->addNodeUnderMaterial(node,m_d->colorCodeConverter.getMaterialFromColorCode( 1));
1280 }
1281 }
1282 }
1283 }
1284 // unordered layers
1285 Trk::ArraySpan<const Trk::Layer* const> confALays = tvol->confinedArbitraryLayers();
1286 if (!confALays.empty()) {
1287 // loop over layers
1288 for (const Trk::Layer* const layerIter : confALays) {
1289 // push_back the layer
1290 if (layerIter) {
1291 SoNode* node = m_d->surface2sonode->translateSurface(
1292 layerIter->surfaceRepresentation());
1293 if (node && layHelper) {
1294 if (layerIter->layerType() > 0)
1295 layHelper->addNodeUnderMaterial(
1296 node, m_d->colorCodeConverter.getMaterialFromColorCode(color));
1297 else
1298 layHelper->addNodeUnderMaterial(
1299 node, m_d->colorCodeConverter.getMaterialFromColorCode(1));
1300 }
1301 }
1302 }
1303 }
1304 // dense volumes
1305 const auto confVols = tvol->confinedDenseVolumes();
1306 if (!confVols.empty()){
1307 auto volIter = confVols.begin();
1308 for ( ; volIter != confVols.end(); ++volIter){
1309 if (*volIter && sepHelper ) processMsVolume( *volIter, nullptr, layHelper );
1310 }
1311 }
1312}
Trk::BinnedArray::arrayObjects
virtual std::span< T *const > arrayObjects()=0
Return all objects of the Array non-const we can still modify the T.
Trk::TrackingVolume::confinedLayers
const LayerArray * confinedLayers() const
Return the subLayer array.
Trk::TrackingVolume::confinedArbitraryLayers
ArraySpan< Layer const *const > confinedArbitraryLayers() const
Return the confined subLayer array.
Trk::TrackingVolume::confinedDenseVolumes
ArraySpan< TrackingVolume const *const > confinedDenseVolumes() const
Return unordered subVolumes - not the ownership.
VP1ExtraSepLayerHelper::addNodeUnderMaterial
void addNodeUnderMaterial(SoNode *, SoMaterial *)
Definition VP1ExtraSepLayerHelper.cxx:190
VP1TrackingGeometrySystem::processMsVolume
void processMsVolume(const Trk::TrackingVolume *, VP1ExtraSepLayerHelper *, VP1ExtraSepLayerHelper *)
Definition VP1TrackingGeometrySystem.cxx:1140
Trk::ArraySpan
std::span< T > ArraySpan
Definition TrackingVolume.h:59

◆ processMsVolume()

void VP1TrackingGeometrySystem::processMsVolume ( const Trk::TrackingVolume * tvol,
VP1ExtraSepLayerHelper * sepHelper,
VP1ExtraSepLayerHelper * layHelper )
private

Definition at line 1140 of file VP1TrackingGeometrySystem.cxx.

1141{
1142 if (!tvol)
1143 return;
1144
1145 std::string name = tvol->volumeName();
1146
1147 // only lowest level volumes displayed
1148
1149 if (!tvol->confinedVolumes()) {
1150 SoNode * volnode = m_d->trackvol2sonode->translateTrackingVolume(*tvol);
1151 if (!volnode) {
1152 message("Error: Volume shape not implemented");
1153 return;
1154 }
1155
1156 if ( name.substr(0,4) == "Muon" && tvol->colorCode() > 0 ) {
1157 if ( fabs(tvol->center().z())>12900 ) m_d->sephelper_msO->addNodeUnderMaterial(volnode,m_d->colorCodeConverter.getMaterialFromColorCode( tvol->colorCode()));
1158 else if ( fabs(tvol->center().z())>6750 ) m_d->sephelper_msI->addNodeUnderMaterial(volnode,m_d->colorCodeConverter.getMaterialFromColorCode( tvol->colorCode()));
1159 else m_d->sephelper_msB->addNodeUnderMaterial(volnode,m_d->colorCodeConverter.getMaterialFromColorCode( tvol->colorCode()));
1160 }
1161
1162 // envelopes
1163 if ( sepHelper ) {
1164 unsigned int colorCode = 17;
1165 if ( name.substr(0,3)=="MDT") colorCode = 2;
1166 if ( name.substr(0,3)=="RPC") colorCode = 4;
1167 if ( name.substr(0,2)=="CS") colorCode = 5;
1168 if ( name.substr(0,1)=="T") colorCode = 6;
1169 sepHelper->addNodeUnderMaterial(volnode,m_d->colorCodeConverter.getMaterialFromColorCode(colorCode) );
1170 if (layHelper) processMsLayDense( tvol, sepHelper, layHelper, colorCode );
1171 } else if ( layHelper ) {
1172 unsigned int colorCode = 13;
1173 layHelper->addNodeUnderMaterial(volnode,m_d->colorCodeConverter.getMaterialFromColorCode(colorCode) );
1174 }
1175
1176 } else {
1177 const Trk::BinnedArray<Trk::TrackingVolume >* confinedVolumes = tvol->confinedVolumes();
1178 // get the confined volumes and loop over it -> call recursively
1179 if (confinedVolumes){
1180 std::span<Trk::TrackingVolume const * const> volumes = confinedVolumes->arrayObjects();
1181 std::span<Trk::TrackingVolume const * const>::iterator volIter = volumes.begin();
1182 std::span<Trk::TrackingVolume const * const>::iterator volIterEnd = volumes.end();
1183 for ( ; volIter != volIterEnd; ++volIter)
1184 if (*volIter) processMsVolume(*volIter,sepHelper, layHelper);
1185 }
1186 }
1187
1188 Trk::ArraySpan<const Trk::DetachedTrackingVolume* const> detVols = tvol->confinedDetachedVolumes();
1189 if (!detVols.empty()) {
1190 // identify separators
1191 Trk::ArraySpan<const Trk::DetachedTrackingVolume* const>::iterator dIter = detVols.begin();
1192 for ( ;dIter!=detVols.end(); ++dIter) {
1193 if ( (tvol->inside((*dIter)->trackingVolume()->center(),0.) || (*dIter)->trackingVolume()->center().perp()<0.001) ) {
1194 std::string name = (*dIter)->name();
1195 if ( name.substr(0,2) == "BI" ) { sepHelper = m_d->sephelper_msBI; layHelper = m_d->sephelper_msBIlay; }
1196 else if ( name.substr(0,2) == "BM" ) { sepHelper = m_d->sephelper_msBM; layHelper = m_d->sephelper_msBMlay; }
1197 else if ( name.substr(0,2) == "BO" ) { sepHelper = m_d->sephelper_msBO; layHelper = m_d->sephelper_msBOlay; }
1198 else if ( name.substr(0,2) == "EI" ) { sepHelper = m_d->sephelper_msEI; layHelper = m_d->sephelper_msEIlay; }
1199 else if ( name.substr(0,2) == "EM" ) { sepHelper = m_d->sephelper_msEM; layHelper = m_d->sephelper_msEMlay; }
1200 else if ( name.substr(0,2) == "EO" ) { sepHelper = m_d->sephelper_msEO; layHelper = m_d->sephelper_msEOlay; }
1201 else if ( name.substr(0,2) == "CS" ) { sepHelper = m_d->sephelper_msCS; layHelper = m_d->sephelper_msCSlay; }
1202 else if ( name.substr(0,1) == "T" ) { sepHelper = m_d->sephelper_msTG; layHelper = m_d->sephelper_msTGlay; }
1203 else if ( name.substr(0,4) == "Rail" ) { sepHelper = m_d->sephelper_msRaenv; layHelper = m_d->sephelper_msRadl; }
1204 else if ( name.substr(0,7) == "MDTRail" ) { sepHelper = m_d->sephelper_msRaenv; layHelper = m_d->sephelper_msRadl; }
1205 else if ( name.substr(0,4) == "SADL" ) { sepHelper = m_d->sephelper_msRaenv; layHelper = m_d->sephelper_msRadl; }
1206 else if ( name.substr(0,4) == "TBWH" ) { sepHelper = m_d->sephelper_msRaenv; layHelper = m_d->sephelper_msRadl; }
1207 else if ( name.substr(0,4) == "MBAP" ) { sepHelper = m_d->sephelper_msRaenv; layHelper = m_d->sephelper_msRadl; }
1208 else if ( name.substr(0,4) == "MBWH" ) { sepHelper = m_d->sephelper_msRaenv; layHelper = m_d->sephelper_msRadl; }
1209 else if ( name.substr(0,3) == "PP2" ) { sepHelper = m_d->sephelper_msRaenv; layHelper = m_d->sephelper_msRadl; }
1210 else if ( name.substr(0,3) == "ECT" ) { sepHelper = m_d->sephelper_msETenv; layHelper = m_d->sephelper_msETdl; }
1211 else if ( name.substr(0,2) == "BT" || name.substr(0,6) == "EdgeBT" || name.substr(0,6) == "HeadBT" )
1212 { sepHelper = m_d->sephelper_msBTenv; layHelper = m_d->sephelper_msBTdl; }
1213 else if ( name.substr(0,3) == "BAR" )
1214 // && ( name.substr(0,18) == "BAR_ToroidBAR_Cold" || name.substr(0,22) == "BAR_ToroidBAR_Voussoir") )
1215 { sepHelper = m_d->sephelper_msBTenv; layHelper = m_d->sephelper_msBTdl; }
1216 else if ( name.substr(0,9) == "ForwardSh" || name.substr(0,8) == "ToroidSh" || name.substr(0,6) == "DiskSh" )
1217 { sepHelper = m_d->sephelper_msShenv; layHelper = m_d->sephelper_msShdl; }
1218 else if ( name.substr(0,5) == "StdFe" || name.substr(0,6) == "ExtrFe" || name.substr(0,6) == "ConnFe" )
1219 { sepHelper = m_d->sephelper_msFeenv; layHelper = m_d->sephelper_msFedl; }
1220 else if ( name.substr(0,4) == "Feet" )
1221 { sepHelper = m_d->sephelper_msFeenv; layHelper = m_d->sephelper_msFedl; }
1222 else // display somehow
1223 { sepHelper = m_d->sephelper_msFeenv; layHelper = m_d->sephelper_msFedl; }
1224 } else {
1225 std::string name = (*dIter)->name();
1226 //std::cout << "VP1 ignores volume:"<<name<< std::endl;
1227 if ( name.substr(0,3) == "BAR" &&
1228 name.substr(0,18) == "BAR_ToroidBAR_Cold" )
1229 { sepHelper = m_d->sephelper_msBTenv; layHelper = m_d->sephelper_msBTdl; }
1230 }
1231 if (sepHelper) processMsVolume( (*dIter)->trackingVolume(), sepHelper, layHelper);
1232 sepHelper = nullptr; layHelper = nullptr;
1233 }
1234 }
1235}
IVP1System::name
const QString & name() const
Definition IVP1System.cxx:50
Trk::TrackingVolume::confinedVolumes
const TrackingVolumeArray * confinedVolumes() const
Return the subLayer array.
Trk::TrackingVolume::volumeName
const std::string & volumeName() const
Returns the VolumeName - for debug reason, might be depreciated later.
Trk::TrackingVolume::confinedDetachedVolumes
ArraySpan< DetachedTrackingVolume const *const > confinedDetachedVolumes() const
Return detached subVolumes - not the ownership.
Trk::TrackingVolume::colorCode
unsigned int colorCode() const
Get the color code.
Trk::Volume::center
const Amg::Vector3D & center() const
returns the center of the volume
Definition Volume.h:90
Trk::Volume::inside
bool inside(const Amg::Vector3D &gp, double tol=0.) const
Inside() method for checks.
Definition Volume.cxx:72
VP1TrackingGeometrySystem::processMsLayDense
void processMsLayDense(const Trk::TrackingVolume *tvol, VP1ExtraSepLayerHelper *sepHelper, VP1ExtraSepLayerHelper *layHelper, int color)
Definition VP1TrackingGeometrySystem.cxx:1261

◆ processTrkLayer()

void VP1TrackingGeometrySystem::processTrkLayer ( const Trk::Layer * tlayer,
VP1ExtraSepLayerHelper * sepLayerHelper,
unsigned int colorCode )
private

Definition at line 1238 of file VP1TrackingGeometrySystem.cxx.

1241{
1242 if (!tlayer) return;
1243 SoNode * node = m_d->surface2sonode->translateSurface(tlayer->surfaceRepresentation());
1244 if (node) {
1245 sepLayerHelper->addNodeUnderMaterial(node,m_d->colorCodeConverter.getMaterialFromColorCode( colorCode));
1246 std::cout << "Adding Layer to Separator helper: " << sepLayerHelper << std::endl;
1247 }
1248}
Trk::Layer::surfaceRepresentation
virtual const Surface & surfaceRepresentation() const =0
Transforms the layer into a Surface representation for extrapolation.

◆ processTrkSurface()

void VP1TrackingGeometrySystem::processTrkSurface ( const Trk::Surface * tsurf,
VP1ExtraSepLayerHelper * sepLayerHelper,
unsigned int colorCode )
private

Definition at line 1251 of file VP1TrackingGeometrySystem.cxx.

1254{
1255 if (!tsurf) return;
1256 SoNode * node = m_d->surface2sonode->translateSurface(*tsurf);
1257 if (node) sepLayerHelper->addNodeUnderMaterial(node,m_d->colorCodeConverter.getMaterialFromColorCode( colorCode));
1258}

◆ processTrkVolume()

void VP1TrackingGeometrySystem::processTrkVolume ( const Trk::TrackingVolume * tvol)
private

current separator helpers

Definition at line 1006 of file VP1TrackingGeometrySystem.cxx.

1007{
1008 if (!tvol)
1009 return;
1010
1011 SoNode * volnode = m_d->trackvol2sonode->translateTrackingVolume(*tvol);
1012 if (!volnode) {
1013 message("Error: Volume shape not implemented");
1014 return;
1015 }
1016
1017 QString volumeName(tvol->volumeName().c_str());
1018
1019 messageVerbose("Processing volume: "+volumeName);
1020 m_d->sephelper_vol->addNodeUnderMaterial(volnode,m_d->colorCodeConverter.getMaterialFromColorCode( tvol->colorCode()));
1021
1022 const Trk::BinnedArray< Trk::Layer >* confinedLayers = tvol->confinedLayers();
1023
1024 // loop over confined layers
1025 if (confinedLayers){
1026 std::span<Trk::Layer const * const> layerVector = confinedLayers->arrayObjects();
1027 std::span<Trk::Layer const * const>::iterator layerIter = layerVector.begin();
1028 // loop over layers
1029 for ( ; layerIter != layerVector.end(); ++layerIter){
1030 // push_back the layer
1031 if (*layerIter){
1032
1033 // get the layerIndex
1034 const Trk::LayerIndex& layIndex = (*layerIter)->layerIndex();
1035
1036 // skip navigaion layers for the moment
1037 if (!layIndex.value()) continue;
1038
1039 /* check the surface array */
1040 const Trk::SurfaceArray* layerSubSurfaces = (*layerIter)->surfaceArray();
1041
1043 VP1ExtraSepLayerHelper* layerSepHelper = nullptr;
1044 VP1ExtraSepLayerHelper* surfaceSepHelper = nullptr;
1045
1046 if ( volumeName.contains("BeamPipe") > 0 ) {
1047 layerSepHelper = m_d->sephelper_beamPipe;
1048 } else if (volumeName.contains("Pixel") > 0 ) {
1049 // Pixel sector
1050 if ( volumeName.contains("Barrel") > 0 ){
1051 // pixel barrel surfaces & layers
1052 layerSepHelper = m_d->sephelper_pixLayBarrel;
1053 surfaceSepHelper = m_d->sephelper_pixSurfBarrel;
1054 } else if ( volumeName.contains("Endcap") > 0 ){
1055 // pixel endcap surfaces & layers
1056 if ( volumeName.contains("Pos") > 0){
1057 layerSepHelper = m_d->sephelper_pixLayECA;
1058 surfaceSepHelper = m_d->sephelper_pixSurfECA;
1059 } else {
1060 layerSepHelper = m_d->sephelper_pixLayECC;
1061 surfaceSepHelper = m_d->sephelper_pixSurfECC;
1062 }
1063 }
1064 } else if ((volumeName.contains("SCT") > 0) or (volumeName.contains("Strip") > 0)) {
1065 // SCT sector
1066 if ( volumeName.contains("Barrel") > 0 ){
1067 // sct barrel surfaces & layers
1068 layerSepHelper = m_d->sephelper_sctLayBarrel;
1069 surfaceSepHelper = m_d->sephelper_sctSurfBarrel;
1070 } else if ( volumeName.contains("Endcap") > 0 ){
1071 // sct endcap surfaces & layers
1072 if ( volumeName.contains("Pos") > 0){
1073 layerSepHelper = m_d->sephelper_sctLayECA;
1074 surfaceSepHelper = m_d->sephelper_sctSurfECA;
1075 } else {
1076 layerSepHelper = m_d->sephelper_sctLayECC;
1077 surfaceSepHelper = m_d->sephelper_sctSurfECC;
1078 }
1079 }
1080 } else if (volumeName.contains("TRT") > 0) {
1081 // TRT sector
1082 if ( volumeName.contains("Barrel") > 0 ){
1083 // trt barrel surfaces & layers
1084 layerSepHelper = m_d->sephelper_trtLayBarrel;
1085 surfaceSepHelper = m_d->sephelper_trtSurfBarrel;
1086 } else if ( volumeName.contains("Endcap") > 0 ){
1087 // trt endcap surfaces & layers
1088 if ( volumeName.contains("Pos") > 0 ){
1089 layerSepHelper = m_d->sephelper_trtLayECA;
1090 surfaceSepHelper = m_d->sephelper_trtSurfECA;
1091 } else {
1092 layerSepHelper = m_d->sephelper_trtLayECC;
1093 surfaceSepHelper = m_d->sephelper_trtSurfECC;
1094 }
1095 }
1096 } else {
1097 if ( volumeName.contains("Barrel") > 0 ){
1098 // trt barrel surfaces & layers
1099 layerSepHelper = m_d->sephelper_passiveLayBarrel;
1100 } else if ( volumeName.contains("Endcap") > 0 ){
1101 // trt endcap surfaces & layers
1102 if ( volumeName.contains("Pos") > 0 ){
1103 layerSepHelper = m_d->sephelper_passiveLayECA;
1104 } else {
1105 layerSepHelper = m_d->sephelper_passiveLayECC;
1106 }
1107 }
1108 }
1109
1110 std::cout << " VolumeName " << tvol->volumeName() << " / seperators : " << layerSepHelper << " / " << surfaceSepHelper << std::endl;
1111
1112 // process the layer with the correct separator helper
1113 if (layerSepHelper) processTrkLayer(*layerIter, layerSepHelper, tvol->colorCode());
1114 // Surface
1115 if (layerSubSurfaces && surfaceSepHelper){
1116 std::span<Trk::Surface const * const> surfaceVector = layerSubSurfaces->arrayObjects();
1117 std::span<Trk::Surface const * const>::iterator surfaceIter = surfaceVector.begin();
1118 for ( ; surfaceIter != surfaceVector.end(); ++surfaceIter ){
1119 // push_back the surface
1120 if (*surfaceIter)
1121 processTrkSurface(*surfaceIter, surfaceSepHelper, tvol->colorCode());
1122 }
1123 }
1124 }
1125 }
1126 }
1127
1128 const Trk::BinnedArray<Trk::TrackingVolume >* confinedVolumes = tvol->confinedVolumes();
1129 // get the confined volumes and loop over it -> call recursively
1130 if (confinedVolumes){
1131 std::span<Trk::TrackingVolume const * const> volumes = confinedVolumes->arrayObjects();
1132 std::span<Trk::TrackingVolume const * const>::iterator volIter = volumes.begin();
1133 std::span<Trk::TrackingVolume const * const>::iterator volIterEnd = volumes.end();
1134 for ( ; volIter != volIterEnd; ++volIter)
1135 if (*volIter) processTrkVolume(*volIter);
1136 }
1137}
Trk::LayerIndex::value
int value() const
layerIndex expressed in an integer
Definition LayerIndex.h:71
VP1TrackingGeometrySystem::processTrkSurface
void processTrkSurface(const Trk::Surface *, VP1ExtraSepLayerHelper *, unsigned int colorCode)
Definition VP1TrackingGeometrySystem.cxx:1251
VP1TrackingGeometrySystem::processTrkLayer
void processTrkLayer(const Trk::Layer *, VP1ExtraSepLayerHelper *, unsigned int colorCode)
Definition VP1TrackingGeometrySystem.cxx:1238
VP1TrackingGeometrySystem::processTrkVolume
void processTrkVolume(const Trk::TrackingVolume *)
Definition VP1TrackingGeometrySystem.cxx:1006
Trk::SurfaceArray
BinnedArray< Surface > SurfaceArray
Definition Layer.h:40

◆ 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}
IVP13DSystemSimple::systemcreate
virtual void systemcreate(StoreGateSvc *detstore)
Definition IVP13DSystemSimple.cxx:23
IVP13DSystemSimple::buildPermanentSceneGraph
virtual void buildPermanentSceneGraph(StoreGateSvc *detstore, SoSeparator *root)
Definition IVP13DSystemSimple.cxx:25
IVP13DSystemSimple::buildEventSceneGraph
virtual void buildEventSceneGraph(StoreGateSvc *sg, SoSeparator *root)=0
IVP1System::detectorStore
StoreGateSvc * detectorStore() const
Definition IVP1System.cxx:318

◆ 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}
IVP13DSystem::Imp::clickedoutside
static void clickedoutside(void *userdata, SoCooperativeSelection *sel)
Definition IVP13DSystem.cxx:65
IVP13DSystem::Imp::made_selection
static void made_selection(void *userdata, SoPath *path)
Definition IVP13DSystem.cxx:192
selection
const std::string selection
Definition fbtTestBasics.cxx:75
find
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 VP1TrackingGeometrySystem::restoreFromState ( QByteArray ba)
privatevirtual

sroe: none of the following code was reachable, coverity defect 17185 Setup stream for getting the contents of the byteArray: QBuffer buffer(&ba); buffer.open(QIODevice::ReadOnly); QDataStream state(&buffer);

Check version and pass on state info to base class: qint32 version; state >> version; if (version!=0) { message("Warning: State data in .vp1 file is in wrong format - ignoring!"); return; } ensureBuildController();

QByteArray basestate; state >> basestate; IVP13DSystemSimple::restoreFromState(basestate);

state >> m_d->initialTrackingGeometrySvcName; state >> m_d->initialTrackingGeometryName; m_d->lineEdit_TrackingGeometrySvcName->setText( m_d->initialTrackingGeometrySvcName); m_d->lineEdit_TrackingGeometryName->setText( m_d->initialTrackingGeometryName);

retrieveTrackingGeometry();

Reimplemented from IVP1System.

Definition at line 1604 of file VP1TrackingGeometrySystem.cxx.

1605{
1606 messageDebug("WARNING: VP1TrackingGeometrySystem persistification disabled for now due to crashes!");
1634}

◆ retrieveTrackingGeometry

void VP1TrackingGeometrySystem::retrieveTrackingGeometry ( )
privateslot

Definition at line 486 of file VP1TrackingGeometrySystem.cxx.

487{
488 if( m_d->retrieveSuccess)
489 {
490 message( "TrackingGeometry has already been successfully retrieved");
491 return;
492 }
493
494 VP1JobConfigInfo::ensureInit(this);
495 if (!(VP1JobConfigInfo::hasMuonGeometry()
496 ||VP1JobConfigInfo::hasLArGeometry()
497 ||VP1JobConfigInfo::hasTileGeometry()
498 ||VP1JobConfigInfo::hasPixelGeometry()
499 ||VP1JobConfigInfo::hasSCTGeometry()
500 ||VP1JobConfigInfo::hasTRTGeometry()))
501 {
502 message("Error: Geometry not configured!");
503 return;
504 }
505
506 if (!m_d->lineEdit_TrackingGeometrySvcName) {
507 message("Error: retrieveTrackingGeometry() invoked before controller built!");
508 return;
509 }
510
511
512 /*-----------------------------------------------------------------------
513 * Retrieving service locator
514 *-----------------------------------------------------------------------*/
515 ISvcLocator* svcLoc = serviceLocator();
516
517 if( !svcLoc)
518 {
519 message("Error: Got NULL pointer to the service locator!");
520 return;
521 }
522
523 /*-----------------------------------------------------------------------
524 * Retrieving TrackingGeometrySvc
525 *-----------------------------------------------------------------------*/
526 message( "Trying to retrieve TrackingGeometrySvc '" +
527 m_d->lineEdit_TrackingGeometrySvcName->text().trimmed() + "'");
528
529 auto trackingGeometrySvc =
530 svcLoc->service<Trk::ITrackingGeometrySvc>( m_d->lineEdit_TrackingGeometrySvcName->text().trimmed().toStdString() );
531
532 if( !trackingGeometrySvc )
533 {
534 message("Error: Could not retrieve TrackingGeometrySvc '" +
535 m_d->lineEdit_TrackingGeometrySvcName->text().trimmed() + "'\n"
536 "Check spelling and if you have added the correct jobOptions fragment");
537 return;
538 }
539
540 message( "Successfully retrieved TrackingGeometrySvc '" +
541 m_d->lineEdit_TrackingGeometrySvcName->text().trimmed() + "'");
542
543 /*-----------------------------------------------------------------------
544 * Retrieving TrackingGeometry
545 *-----------------------------------------------------------------------*/
546 const Trk::TrackingGeometry * trackingGeometry;
547 if( m_d->lineEdit_TrackingGeometryName->text().trimmed() == "")
548 {
549 message( "Trying to retrieve default TrackingGeometry");
550 trackingGeometry = trackingGeometrySvc->trackingGeometry();
551
552 if( !trackingGeometry)
553 {
554 message("Error: Could not retrieve default TrackingGeometry");
555 return;
556 }
557 else
558 {
559 message( "Successfully retrieved default TrackingGeometry");
560 }
561 }
562 else
563 {
564 message( "Trying to retrieve TrackingGeometry '" +
565 m_d->lineEdit_TrackingGeometryName->text().trimmed() +
566 "' from DetectorStore");
567 if (!m_d->detStore)
568 {
569 message("Error: Got NULL detectorstore.");
570 return;
571 }
572
573 if (m_d->detStore->retrieve(trackingGeometry, m_d->lineEdit_TrackingGeometryName->text().trimmed().toStdString()).isFailure()||!trackingGeometry)
574 {
575 message("Error: Could not retrieve TrackingGeometry '" +
576 m_d->lineEdit_TrackingGeometryName->text().trimmed() +
577 "' from DetectorStore.");
578 return;
579 }
580 else
581 {
582 message( "Successfully retrieved TrackingGeometry '" +
583 m_d->lineEdit_TrackingGeometryName->text().trimmed() + "'");
584 }
585 }
586
587 /*-----------------------------------------------------------------------
588 * Setup scene if retrieval was successful
589 *-----------------------------------------------------------------------*/
590 m_d->lineEdit_TrackingGeometrySvcName->setReadOnly( true);
591 m_d->lineEdit_TrackingGeometryName->setReadOnly( true);
592 m_d->pushButton_Retrieve->setEnabled( false);
593
594 // Pixel section
595 m_d->beamPipeSwitch = new SoSwitch();
596 m_d->pixSurfBarrelSwitch = new SoSwitch();
597 m_d->pixSurfECASwitch = new SoSwitch();
598 m_d->pixSurfECCSwitch = new SoSwitch();
599 m_d->pixLayBarrelSwitch = new SoSwitch();
600 m_d->pixLayECASwitch = new SoSwitch();
601 m_d->pixLayECCSwitch = new SoSwitch();
602 m_d->sctSurfBarrelSwitch = new SoSwitch();
603 m_d->sctSurfECASwitch = new SoSwitch();
604 m_d->sctSurfECCSwitch = new SoSwitch();
605 m_d->sctLayBarrelSwitch = new SoSwitch();
606 m_d->sctLayECASwitch = new SoSwitch();
607 m_d->sctLayECCSwitch = new SoSwitch();
608 m_d->trtSurfBarrelSwitch = new SoSwitch();
609 m_d->trtSurfECASwitch = new SoSwitch();
610 m_d->trtSurfECCSwitch = new SoSwitch();
611 m_d->trtLayBarrelSwitch = new SoSwitch();
612 m_d->trtLayECASwitch = new SoSwitch();
613 m_d->trtLayECCSwitch = new SoSwitch();
614 m_d->passiveLayBarrelSwitch = new SoSwitch();
615 m_d->passiveLayECASwitch = new SoSwitch();
616 m_d->passiveLayECCSwitch = new SoSwitch();
617
618 m_d->beamPipeSwitch->whichChild = SO_SWITCH_NONE;
619 m_d->pixSurfBarrelSwitch->whichChild = SO_SWITCH_NONE;
620 m_d->pixSurfECASwitch->whichChild = SO_SWITCH_NONE;
621 m_d->pixSurfECCSwitch->whichChild = SO_SWITCH_NONE;
622 m_d->pixLayBarrelSwitch->whichChild = SO_SWITCH_NONE;
623 m_d->pixLayECASwitch->whichChild = SO_SWITCH_NONE;
624 m_d->pixLayECCSwitch->whichChild = SO_SWITCH_NONE;
625 m_d->sctSurfBarrelSwitch->whichChild = SO_SWITCH_NONE;
626 m_d->sctSurfECASwitch->whichChild = SO_SWITCH_NONE;
627 m_d->sctSurfECCSwitch->whichChild = SO_SWITCH_NONE;
628 m_d->sctLayBarrelSwitch->whichChild = SO_SWITCH_NONE;
629 m_d->sctLayECASwitch->whichChild = SO_SWITCH_NONE;
630 m_d->sctLayECCSwitch->whichChild = SO_SWITCH_NONE;
631 m_d->trtSurfBarrelSwitch->whichChild = SO_SWITCH_NONE;
632 m_d->trtSurfECASwitch->whichChild = SO_SWITCH_NONE;
633 m_d->trtSurfECCSwitch->whichChild = SO_SWITCH_NONE;
634 m_d->trtLayBarrelSwitch->whichChild = SO_SWITCH_NONE;
635 m_d->trtLayECASwitch->whichChild = SO_SWITCH_NONE;
636 m_d->trtLayECCSwitch->whichChild = SO_SWITCH_NONE;
637 m_d->passiveLayBarrelSwitch->whichChild = SO_SWITCH_NONE;
638 m_d->passiveLayECASwitch->whichChild = SO_SWITCH_NONE;
639 m_d->passiveLayECCSwitch->whichChild = SO_SWITCH_NONE;
640
641 SoSeparator* sep_beamPipe = new SoSeparator(); sep_beamPipe->ref();
642 SoSeparator* sep_pixSurfBarrel = new SoSeparator(); sep_pixSurfBarrel->ref();
643 SoSeparator* sep_pixSurfECA = new SoSeparator(); sep_pixSurfECA->ref();
644 SoSeparator* sep_pixSurfECC = new SoSeparator(); sep_pixSurfECC->ref();
645 SoSeparator* sep_pixLayBarrel = new SoSeparator(); sep_pixLayBarrel->ref();
646 SoSeparator* sep_pixLayECA = new SoSeparator(); sep_pixLayECA->ref();
647 SoSeparator* sep_pixLayECC = new SoSeparator(); sep_pixLayECC->ref();
648 SoSeparator* sep_sctSurfBarrel = new SoSeparator(); sep_sctSurfBarrel->ref();
649 SoSeparator* sep_sctSurfECA = new SoSeparator(); sep_sctSurfECA->ref();
650 SoSeparator* sep_sctSurfECC = new SoSeparator(); sep_sctSurfECC->ref();
651 SoSeparator* sep_sctLayBarrel = new SoSeparator(); sep_sctLayBarrel->ref();
652 SoSeparator* sep_sctLayECA = new SoSeparator(); sep_sctLayECA->ref();
653 SoSeparator* sep_sctLayECC = new SoSeparator(); sep_sctLayECC->ref();
654 SoSeparator* sep_trtSurfBarrel = new SoSeparator(); sep_trtSurfBarrel->ref();
655 SoSeparator* sep_trtSurfECA = new SoSeparator(); sep_trtSurfECA->ref();
656 SoSeparator* sep_trtSurfECC = new SoSeparator(); sep_trtSurfECC->ref();
657 SoSeparator* sep_trtLayBarrel = new SoSeparator(); sep_trtLayBarrel->ref();
658 SoSeparator* sep_trtLayECA = new SoSeparator(); sep_trtLayECA->ref();
659 SoSeparator* sep_trtLayECC = new SoSeparator(); sep_trtLayECC->ref();
660 SoSeparator* sep_passiveLayBarrel = new SoSeparator(); sep_passiveLayBarrel->ref();
661 SoSeparator* sep_passiveLayECA = new SoSeparator(); sep_passiveLayECA->ref();
662 SoSeparator* sep_passiveLayECC = new SoSeparator(); sep_passiveLayECC->ref();
663
664 m_d->sephelper_beamPipe = new VP1ExtraSepLayerHelper(sep_beamPipe);
665 m_d->sephelper_pixSurfBarrel = new VP1ExtraSepLayerHelper(sep_pixSurfBarrel);
666 m_d->sephelper_pixSurfECA = new VP1ExtraSepLayerHelper(sep_pixSurfECA);
667 m_d->sephelper_pixSurfECC = new VP1ExtraSepLayerHelper(sep_pixSurfECC);
668 m_d->sephelper_pixLayBarrel = new VP1ExtraSepLayerHelper(sep_pixLayBarrel);
669 m_d->sephelper_pixLayECA = new VP1ExtraSepLayerHelper(sep_pixLayECA);
670 m_d->sephelper_pixLayECC = new VP1ExtraSepLayerHelper(sep_pixLayECC);
671 m_d->sephelper_sctSurfBarrel = new VP1ExtraSepLayerHelper(sep_sctSurfBarrel);
672 m_d->sephelper_sctSurfECA = new VP1ExtraSepLayerHelper(sep_sctSurfECA);
673 m_d->sephelper_sctSurfECC = new VP1ExtraSepLayerHelper(sep_sctSurfECC);
674 m_d->sephelper_sctLayBarrel = new VP1ExtraSepLayerHelper(sep_sctLayBarrel);
675 m_d->sephelper_sctLayECA = new VP1ExtraSepLayerHelper(sep_sctLayECA);
676 m_d->sephelper_sctLayECC = new VP1ExtraSepLayerHelper(sep_sctLayECC);
677 m_d->sephelper_trtSurfBarrel = new VP1ExtraSepLayerHelper(sep_trtSurfBarrel);
678 m_d->sephelper_trtSurfECA = new VP1ExtraSepLayerHelper(sep_trtSurfECA);
679 m_d->sephelper_trtSurfECC = new VP1ExtraSepLayerHelper(sep_trtSurfECC);
680 m_d->sephelper_trtLayBarrel = new VP1ExtraSepLayerHelper(sep_trtLayBarrel);
681 m_d->sephelper_trtLayECA = new VP1ExtraSepLayerHelper(sep_trtLayECA);
682 m_d->sephelper_trtLayECC = new VP1ExtraSepLayerHelper(sep_trtLayECC);
683 m_d->sephelper_passiveLayBarrel = new VP1ExtraSepLayerHelper(sep_passiveLayBarrel);
684 m_d->sephelper_passiveLayECA = new VP1ExtraSepLayerHelper(sep_passiveLayECA );
685 m_d->sephelper_passiveLayECC = new VP1ExtraSepLayerHelper(sep_passiveLayECC );
686
687 m_d->volswitch = new SoSwitch();
688 m_d->clipswitch = new SoSwitch();
689 m_d->msBswitch = new SoSwitch();
690 m_d->msIswitch = new SoSwitch();
691 m_d->msOswitch = new SoSwitch();
692 m_d->msBIswitch = new SoSwitch();
693 m_d->msBMswitch = new SoSwitch();
694 m_d->msBOswitch = new SoSwitch();
695 m_d->msEIswitch = new SoSwitch();
696 m_d->msEMswitch = new SoSwitch();
697 m_d->msEOswitch = new SoSwitch();
698 m_d->msCSswitch = new SoSwitch();
699 m_d->msTGswitch = new SoSwitch();
700 m_d->msBIlayswitch = new SoSwitch();
701 m_d->msBMlayswitch = new SoSwitch();
702 m_d->msBOlayswitch = new SoSwitch();
703 m_d->msEIlayswitch = new SoSwitch();
704 m_d->msEMlayswitch = new SoSwitch();
705 m_d->msEOlayswitch = new SoSwitch();
706 m_d->msCSlayswitch = new SoSwitch();
707 m_d->msTGlayswitch = new SoSwitch();
708 m_d->msBTenvswitch = new SoSwitch();
709 m_d->msETenvswitch = new SoSwitch();
710 m_d->msShenvswitch = new SoSwitch();
711 m_d->msFeenvswitch = new SoSwitch();
712 m_d->msRaenvswitch = new SoSwitch();
713 m_d->msBTdlswitch = new SoSwitch();
714 m_d->msETdlswitch = new SoSwitch();
715 m_d->msShdlswitch = new SoSwitch();
716 m_d->msFedlswitch = new SoSwitch();
717 m_d->msRadlswitch = new SoSwitch();
718
719 m_d->volswitch->whichChild = SO_SWITCH_NONE;
720 m_d->clipswitch->whichChild = SO_SWITCH_NONE;
721 m_d->msBswitch->whichChild = SO_SWITCH_NONE;
722 m_d->msIswitch->whichChild = SO_SWITCH_NONE;
723 m_d->msOswitch->whichChild = SO_SWITCH_NONE;
724 m_d->msBIswitch->whichChild = SO_SWITCH_NONE;
725 m_d->msBMswitch->whichChild = SO_SWITCH_NONE;
726 m_d->msBOswitch->whichChild = SO_SWITCH_NONE;
727 m_d->msEIswitch->whichChild = SO_SWITCH_NONE;
728 m_d->msEMswitch->whichChild = SO_SWITCH_NONE;
729 m_d->msEOswitch->whichChild = SO_SWITCH_NONE;
730 m_d->msCSswitch->whichChild = SO_SWITCH_NONE;
731 m_d->msTGswitch->whichChild = SO_SWITCH_NONE;
732 m_d->msBIlayswitch->whichChild = SO_SWITCH_NONE;
733 m_d->msBMlayswitch->whichChild = SO_SWITCH_NONE;
734 m_d->msBOlayswitch->whichChild = SO_SWITCH_NONE;
735 m_d->msEIlayswitch->whichChild = SO_SWITCH_NONE;
736 m_d->msEMlayswitch->whichChild = SO_SWITCH_NONE;
737 m_d->msEOlayswitch->whichChild = SO_SWITCH_NONE;
738 m_d->msCSlayswitch->whichChild = SO_SWITCH_NONE;
739 m_d->msTGlayswitch->whichChild = SO_SWITCH_NONE;
740 m_d->msBTenvswitch->whichChild = SO_SWITCH_NONE;
741 m_d->msETenvswitch->whichChild = SO_SWITCH_NONE;
742 m_d->msShenvswitch->whichChild = SO_SWITCH_NONE;
743 m_d->msFeenvswitch->whichChild = SO_SWITCH_NONE;
744 m_d->msRaenvswitch->whichChild = SO_SWITCH_NONE;
745 m_d->msBTdlswitch->whichChild = SO_SWITCH_NONE;
746 m_d->msETdlswitch->whichChild = SO_SWITCH_NONE;
747 m_d->msShdlswitch->whichChild = SO_SWITCH_NONE;
748 m_d->msFedlswitch->whichChild = SO_SWITCH_NONE;
749 m_d->msRadlswitch->whichChild = SO_SWITCH_NONE;
750
751 SoSeparator * sep_vol = new SoSeparator; sep_vol->ref();
752 SoSeparator * sep_msB = new SoSeparator; sep_msB->ref();
753 SoSeparator * sep_msI = new SoSeparator; sep_msI->ref();
754 SoSeparator * sep_msO = new SoSeparator; sep_msO->ref();
755 SoSeparator * sep_msBI = new SoSeparator; sep_msBI->ref();
756 SoSeparator * sep_msBM = new SoSeparator; sep_msBM->ref();
757 SoSeparator * sep_msBO = new SoSeparator; sep_msBO->ref();
758 SoSeparator * sep_msEI = new SoSeparator; sep_msEI->ref();
759 SoSeparator * sep_msEM = new SoSeparator; sep_msEM->ref();
760 SoSeparator * sep_msEO = new SoSeparator; sep_msEO->ref();
761 SoSeparator * sep_msCS = new SoSeparator; sep_msCS->ref();
762 SoSeparator * sep_msTG = new SoSeparator; sep_msTG->ref();
763 SoSeparator * sep_msBIlay = new SoSeparator; sep_msBIlay->ref();
764 SoSeparator * sep_msBMlay = new SoSeparator; sep_msBMlay->ref();
765 SoSeparator * sep_msBOlay = new SoSeparator; sep_msBOlay->ref();
766 SoSeparator * sep_msEIlay = new SoSeparator; sep_msEIlay->ref();
767 SoSeparator * sep_msEMlay = new SoSeparator; sep_msEMlay->ref();
768 SoSeparator * sep_msEOlay = new SoSeparator; sep_msEOlay->ref();
769 SoSeparator * sep_msCSlay = new SoSeparator; sep_msCSlay->ref();
770 SoSeparator * sep_msTGlay = new SoSeparator; sep_msTGlay->ref();
771 SoSeparator * sep_msBTenv = new SoSeparator; sep_msBTenv->ref();
772 SoSeparator * sep_msETenv = new SoSeparator; sep_msETenv->ref();
773 SoSeparator * sep_msShenv = new SoSeparator; sep_msShenv->ref();
774 SoSeparator * sep_msFeenv = new SoSeparator; sep_msFeenv->ref();
775 SoSeparator * sep_msRaenv = new SoSeparator; sep_msRaenv->ref();
776 SoSeparator * sep_msBTdl = new SoSeparator; sep_msBTdl->ref();
777 SoSeparator * sep_msETdl = new SoSeparator; sep_msETdl->ref();
778 SoSeparator * sep_msShdl = new SoSeparator; sep_msShdl->ref();
779 SoSeparator * sep_msFedl = new SoSeparator; sep_msFedl->ref();
780 SoSeparator * sep_msRadl = new SoSeparator; sep_msRadl->ref();
781
782 m_d->sephelper_vol = new VP1ExtraSepLayerHelper(sep_vol);
783 m_d->sephelper_msB = new VP1ExtraSepLayerHelper(sep_msB);
784 m_d->sephelper_msI = new VP1ExtraSepLayerHelper(sep_msI);
785 m_d->sephelper_msO = new VP1ExtraSepLayerHelper(sep_msO);
786 m_d->sephelper_msBI = new VP1ExtraSepLayerHelper(sep_msBI);
787 m_d->sephelper_msBM = new VP1ExtraSepLayerHelper(sep_msBM);
788 m_d->sephelper_msBO = new VP1ExtraSepLayerHelper(sep_msBO);
789 m_d->sephelper_msEI = new VP1ExtraSepLayerHelper(sep_msEI);
790 m_d->sephelper_msEM = new VP1ExtraSepLayerHelper(sep_msEM);
791 m_d->sephelper_msEO = new VP1ExtraSepLayerHelper(sep_msEO);
792 m_d->sephelper_msCS = new VP1ExtraSepLayerHelper(sep_msCS);
793 m_d->sephelper_msTG = new VP1ExtraSepLayerHelper(sep_msTG);
794 m_d->sephelper_msBIlay = new VP1ExtraSepLayerHelper(sep_msBIlay);
795 m_d->sephelper_msBMlay = new VP1ExtraSepLayerHelper(sep_msBMlay);
796 m_d->sephelper_msBOlay = new VP1ExtraSepLayerHelper(sep_msBOlay);
797 m_d->sephelper_msEIlay = new VP1ExtraSepLayerHelper(sep_msEIlay);
798 m_d->sephelper_msEMlay = new VP1ExtraSepLayerHelper(sep_msEMlay);
799 m_d->sephelper_msEOlay = new VP1ExtraSepLayerHelper(sep_msEOlay);
800 m_d->sephelper_msCSlay = new VP1ExtraSepLayerHelper(sep_msCSlay);
801 m_d->sephelper_msTGlay = new VP1ExtraSepLayerHelper(sep_msTGlay);
802 m_d->sephelper_msBTenv = new VP1ExtraSepLayerHelper(sep_msBTenv);
803 m_d->sephelper_msETenv = new VP1ExtraSepLayerHelper(sep_msETenv);
804 m_d->sephelper_msShenv = new VP1ExtraSepLayerHelper(sep_msShenv);
805 m_d->sephelper_msFeenv = new VP1ExtraSepLayerHelper(sep_msFeenv);
806 m_d->sephelper_msRaenv = new VP1ExtraSepLayerHelper(sep_msRaenv);
807 m_d->sephelper_msBTdl = new VP1ExtraSepLayerHelper(sep_msBTdl);
808 m_d->sephelper_msETdl = new VP1ExtraSepLayerHelper(sep_msETdl);
809 m_d->sephelper_msShdl = new VP1ExtraSepLayerHelper(sep_msShdl);
810 m_d->sephelper_msFedl = new VP1ExtraSepLayerHelper(sep_msFedl);
811 m_d->sephelper_msRadl = new VP1ExtraSepLayerHelper(sep_msRadl);
812
813 m_d->sepHelperContainer.reserve(100);
814 m_d->sepHelperContainer.push_back(m_d->sephelper_vol);
815 m_d->sepHelperContainer.push_back(m_d->sephelper_beamPipe);
816 m_d->sepHelperContainer.push_back(m_d->sephelper_pixSurfBarrel);
817 m_d->sepHelperContainer.push_back(m_d->sephelper_pixSurfECA);
818 m_d->sepHelperContainer.push_back(m_d->sephelper_pixSurfECC);
819 m_d->sepHelperContainer.push_back(m_d->sephelper_pixLayBarrel);
820 m_d->sepHelperContainer.push_back(m_d->sephelper_pixLayECA);
821 m_d->sepHelperContainer.push_back(m_d->sephelper_pixLayECC);
822 m_d->sepHelperContainer.push_back(m_d->sephelper_sctSurfBarrel);
823 m_d->sepHelperContainer.push_back(m_d->sephelper_sctSurfECA);
824 m_d->sepHelperContainer.push_back(m_d->sephelper_sctSurfECC);
825 m_d->sepHelperContainer.push_back(m_d->sephelper_sctLayBarrel);
826 m_d->sepHelperContainer.push_back(m_d->sephelper_sctLayECA);
827 m_d->sepHelperContainer.push_back(m_d->sephelper_sctLayECC);
828 m_d->sepHelperContainer.push_back(m_d->sephelper_trtSurfBarrel);
829 m_d->sepHelperContainer.push_back(m_d->sephelper_trtSurfECA);
830 m_d->sepHelperContainer.push_back(m_d->sephelper_trtSurfECC);
831 m_d->sepHelperContainer.push_back(m_d->sephelper_trtLayBarrel);
832 m_d->sepHelperContainer.push_back(m_d->sephelper_trtLayECA);
833 m_d->sepHelperContainer.push_back(m_d->sephelper_trtLayECC);
834 m_d->sepHelperContainer.push_back(m_d->sephelper_passiveLayBarrel);
835 m_d->sepHelperContainer.push_back(m_d->sephelper_passiveLayECA);
836 m_d->sepHelperContainer.push_back(m_d->sephelper_passiveLayECC);
837 m_d->sepHelperContainer.push_back(m_d->sephelper_msB);
838 m_d->sepHelperContainer.push_back(m_d->sephelper_msI);
839 m_d->sepHelperContainer.push_back(m_d->sephelper_msO);
840 m_d->sepHelperContainer.push_back(m_d->sephelper_msBI);
841 m_d->sepHelperContainer.push_back(m_d->sephelper_msBM);
842 m_d->sepHelperContainer.push_back(m_d->sephelper_msBO);
843 m_d->sepHelperContainer.push_back(m_d->sephelper_msEI);
844 m_d->sepHelperContainer.push_back(m_d->sephelper_msEM);
845 m_d->sepHelperContainer.push_back(m_d->sephelper_msEO);
846 m_d->sepHelperContainer.push_back(m_d->sephelper_msCS);
847 m_d->sepHelperContainer.push_back(m_d->sephelper_msTG);
848 m_d->sepHelperContainer.push_back(m_d->sephelper_msBIlay);
849 m_d->sepHelperContainer.push_back(m_d->sephelper_msBMlay);
850 m_d->sepHelperContainer.push_back(m_d->sephelper_msBOlay);
851 m_d->sepHelperContainer.push_back(m_d->sephelper_msEIlay);
852 m_d->sepHelperContainer.push_back(m_d->sephelper_msEMlay);
853 m_d->sepHelperContainer.push_back(m_d->sephelper_msEOlay);
854 m_d->sepHelperContainer.push_back(m_d->sephelper_msCSlay);
855 m_d->sepHelperContainer.push_back(m_d->sephelper_msTGlay);
856 m_d->sepHelperContainer.push_back(m_d->sephelper_msBTenv);
857 m_d->sepHelperContainer.push_back(m_d->sephelper_msETenv);
858 m_d->sepHelperContainer.push_back(m_d->sephelper_msShenv);
859 m_d->sepHelperContainer.push_back(m_d->sephelper_msFeenv);
860 m_d->sepHelperContainer.push_back(m_d->sephelper_msRaenv);
861 m_d->sepHelperContainer.push_back(m_d->sephelper_msBTdl);
862 m_d->sepHelperContainer.push_back(m_d->sephelper_msETdl);
863 m_d->sepHelperContainer.push_back(m_d->sephelper_msShdl);
864 m_d->sepHelperContainer.push_back(m_d->sephelper_msFedl);
865 m_d->sepHelperContainer.push_back(m_d->sephelper_msRadl);
866
867 std::cout << "To here !" << std::endl;
868
869 const Trk::TrackingVolume* highestVolume = trackingGeometry->highestTrackingVolume();
870
871 if (!highestVolume) {
872 message("Error: No highest tracking volume registered.");
873 return;
874 }
875
876 const Trk::TrackingVolume* idCalo = trackingGeometry->trackingVolume("MuonSpectrometerEntrance");
877
878 m_d->trackvol2sonode = new TrackingVolumeToSoNode();
879 m_d->surface2sonode = new SurfaceToSoNode();
880
881 if (idCalo) processTrkVolume(idCalo);
882 else processTrkVolume(highestVolume);
883
884 processMsVolume(highestVolume,nullptr,nullptr);
885
886 SoRotationXYZ* rotClip = new SoRotationXYZ;
887 rotClip->axis.setValue( SoRotationXYZ::X);
888 rotClip->angle.setValue( -M_PI/2.);
889
890 m_d->clipswitch->addChild( rotClip);
891 m_d->clipswitch->addChild( new SoClipPlane);
892 m_d->root->addChild(m_d->clipswitch);
893
894 m_d->volswitch->addChild(sep_vol);
895
896 m_d->beamPipeSwitch->addChild(sep_beamPipe);
897 m_d->pixSurfBarrelSwitch->addChild(sep_pixSurfBarrel);
898 m_d->pixSurfECASwitch->addChild(sep_pixSurfECA);
899 m_d->pixSurfECCSwitch->addChild(sep_pixSurfECC);
900 m_d->pixLayBarrelSwitch->addChild(sep_pixLayBarrel);
901 m_d->pixLayECASwitch->addChild(sep_pixLayECA);
902 m_d->pixLayECCSwitch->addChild(sep_pixLayECC);
903 m_d->sctSurfBarrelSwitch->addChild(sep_sctSurfBarrel);
904 m_d->sctSurfECASwitch->addChild(sep_sctSurfECA);
905 m_d->sctSurfECCSwitch->addChild(sep_sctSurfECC);
906 m_d->sctLayBarrelSwitch->addChild(sep_sctLayBarrel);
907 m_d->sctLayECASwitch->addChild(sep_sctLayECA);
908 m_d->sctLayECCSwitch->addChild(sep_sctLayECC);
909 m_d->trtSurfBarrelSwitch->addChild(sep_trtSurfBarrel);
910 m_d->trtSurfECASwitch->addChild(sep_trtSurfECA);
911 m_d->trtSurfECCSwitch->addChild(sep_trtSurfECC);
912 m_d->trtLayBarrelSwitch->addChild(sep_trtLayBarrel);
913 m_d->trtLayECASwitch->addChild(sep_trtLayECA);
914 m_d->trtLayECCSwitch->addChild(sep_trtLayECC);
915 m_d->passiveLayBarrelSwitch->addChild(sep_passiveLayBarrel);
916 m_d->passiveLayECASwitch->addChild(sep_passiveLayECA);
917 m_d->passiveLayECCSwitch->addChild(sep_passiveLayECC);
918
919 m_d->msBswitch->addChild(sep_msB);
920 m_d->msIswitch->addChild(sep_msI);
921 m_d->msOswitch->addChild(sep_msO);
922 m_d->msBIswitch->addChild(sep_msBI);
923 m_d->msBMswitch->addChild(sep_msBM);
924 m_d->msBOswitch->addChild(sep_msBO);
925 m_d->msEIswitch->addChild(sep_msEI);
926 m_d->msEMswitch->addChild(sep_msEM);
927 m_d->msEOswitch->addChild(sep_msEO);
928 m_d->msCSswitch->addChild(sep_msCS);
929 m_d->msTGswitch->addChild(sep_msTG);
930 m_d->msBIlayswitch->addChild(sep_msBIlay);
931 m_d->msBMlayswitch->addChild(sep_msBMlay);
932 m_d->msBOlayswitch->addChild(sep_msBOlay);
933 m_d->msEIlayswitch->addChild(sep_msEIlay);
934 m_d->msEMlayswitch->addChild(sep_msEMlay);
935 m_d->msEOlayswitch->addChild(sep_msEOlay);
936 m_d->msCSlayswitch->addChild(sep_msCSlay);
937 m_d->msTGlayswitch->addChild(sep_msTGlay);
938 m_d->msBTenvswitch->addChild(sep_msBTenv);
939 m_d->msETenvswitch->addChild(sep_msETenv);
940 m_d->msShenvswitch->addChild(sep_msShenv);
941 m_d->msFeenvswitch->addChild(sep_msFeenv);
942 m_d->msRaenvswitch->addChild(sep_msRaenv);
943 m_d->msBTdlswitch->addChild(sep_msBTdl);
944 m_d->msETdlswitch->addChild(sep_msETdl);
945 m_d->msShdlswitch->addChild(sep_msShdl);
946 m_d->msFedlswitch->addChild(sep_msFedl);
947 m_d->msRadlswitch->addChild(sep_msRadl);
948
949 m_d->root->addChild(m_d->volswitch);
950 m_d->root->addChild(m_d->beamPipeSwitch);
951 m_d->root->addChild(m_d->pixSurfBarrelSwitch);
952 m_d->root->addChild(m_d->pixSurfECASwitch);
953 m_d->root->addChild(m_d->pixSurfECCSwitch);
954 m_d->root->addChild(m_d->pixLayBarrelSwitch);
955 m_d->root->addChild(m_d->pixLayECASwitch);
956 m_d->root->addChild(m_d->pixLayECCSwitch);
957 m_d->root->addChild(m_d->sctSurfBarrelSwitch);
958 m_d->root->addChild(m_d->sctSurfECASwitch);
959 m_d->root->addChild(m_d->sctSurfECCSwitch);
960 m_d->root->addChild(m_d->sctLayBarrelSwitch);
961 m_d->root->addChild(m_d->sctLayECASwitch);
962 m_d->root->addChild(m_d->sctLayECCSwitch);
963 m_d->root->addChild(m_d->trtSurfBarrelSwitch);
964 m_d->root->addChild(m_d->trtSurfECASwitch);
965 m_d->root->addChild(m_d->trtSurfECCSwitch);
966 m_d->root->addChild(m_d->trtLayBarrelSwitch);
967 m_d->root->addChild(m_d->trtLayECASwitch);
968 m_d->root->addChild(m_d->trtLayECCSwitch);
969 m_d->root->addChild(m_d->passiveLayBarrelSwitch);
970 m_d->root->addChild(m_d->passiveLayECASwitch);
971 m_d->root->addChild(m_d->passiveLayECCSwitch);
972 m_d->root->addChild(m_d->msBswitch);
973 m_d->root->addChild(m_d->msIswitch);
974 m_d->root->addChild(m_d->msOswitch);
975 m_d->root->addChild(m_d->msBIswitch);
976 m_d->root->addChild(m_d->msBMswitch);
977 m_d->root->addChild(m_d->msBOswitch);
978 m_d->root->addChild(m_d->msEIswitch);
979 m_d->root->addChild(m_d->msEMswitch);
980 m_d->root->addChild(m_d->msEOswitch);
981 m_d->root->addChild(m_d->msCSswitch);
982 m_d->root->addChild(m_d->msTGswitch);
983 m_d->root->addChild(m_d->msBIlayswitch);
984 m_d->root->addChild(m_d->msBMlayswitch);
985 m_d->root->addChild(m_d->msBOlayswitch);
986 m_d->root->addChild(m_d->msEIlayswitch);
987 m_d->root->addChild(m_d->msEMlayswitch);
988 m_d->root->addChild(m_d->msEOlayswitch);
989 m_d->root->addChild(m_d->msCSlayswitch);
990 m_d->root->addChild(m_d->msTGlayswitch);
991 m_d->root->addChild(m_d->msBTenvswitch);
992 m_d->root->addChild(m_d->msETenvswitch);
993 m_d->root->addChild(m_d->msShenvswitch);
994 m_d->root->addChild(m_d->msFeenvswitch);
995 m_d->root->addChild(m_d->msRaenvswitch);
996 m_d->root->addChild(m_d->msBTdlswitch);
997 m_d->root->addChild(m_d->msETdlswitch);
998 m_d->root->addChild(m_d->msShdlswitch);
999 m_d->root->addChild(m_d->msFedlswitch);
1000 m_d->root->addChild(m_d->msRadlswitch);
1001
1002 m_d->retrieveSuccess = true;
1003}
M_PI
#define M_PI
Definition ActiveFraction.h:11
IVP1System::serviceLocator
ISvcLocator * serviceLocator() const
Definition IVP1System.cxx:324
Trk::TrackingGeometry::trackingVolume
const TrackingVolume * trackingVolume(const std::string &name) const
return the tracking Volume by name, 0 if it doesn't exist
Trk::TrackingGeometry::highestTrackingVolume
const TrackingVolume * highestTrackingVolume() const
return the world

◆ saveState()

QByteArray VP1TrackingGeometrySystem::saveState ( )
privatevirtual

sroe: unreachable code, coverity 17207 ensureBuildController(); Setup stream writing to a byteArray: QByteArray byteArray; QBuffer buffer(&byteArray); buffer.open(QIODevice::WriteOnly); QDataStream out(&buffer);

Write Data:

Version & base state: out << (qint32)0; //version out << IVP13DSystemSimple::saveState();//Always include state info from the base class.

out << m_d->lineEdit_TrackingGeometrySvcName->text(); out << m_d->lineEdit_TrackingGeometryName->text();

std::map<QObject*,std::pair<SoSwitch*,bool> >iterator chbMapIter = m_d->checkBoxSwitchMap.begin(); std::map<QObject*,std::pair<SoSwitch*,bool> >iterator chbMapIterEnd = m_d->checkBoxSwitchMap.end(); for ( ; chbMapIter != chbMapIterEnd; ++chbMapIter ){ QCheckBox* checkBox = dynamic_cast<QCheckBox*>((chbMapIter)->first); if (checkBox) out << checkBox->isChecked();

}

Last step buffer.close(); return byteArray;

Reimplemented from IVP1System.

Definition at line 1567 of file VP1TrackingGeometrySystem.cxx.

1568{
1569 //TK: BAD!!!!
1570 messageDebug("WARNING: VP1TrackingGeometrySystem persistification disabled for now due to crashes!");
1571 return {};
1601}

◆ serviceLocator()

ISvcLocator * IVP1System::serviceLocator ( ) const
inherited

Definition at line 324 of file IVP1System.cxx.

325{
326 return VP1AthenaPtrs::serviceLocator();
327}
VP1AthenaPtrs::serviceLocator
static ISvcLocator * serviceLocator()
Definition VP1AthenaPtrs.h:29

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

◆ 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.
IVP1System::eventStore
StoreGateSvc * eventStore() const
Definition IVP1System.cxx:312

◆ 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())+")"; }
read_hist_ntuple.t
t
Definition read_hist_ntuple.py:5

◆ 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{
38 return str(VP1QtInventorUtils::sbcol2qcol(c));
39}
VP1QtInventorUtils::sbcol2qcol
static QColor sbcol2qcol(const SbColor &)
Definition VP1QtInventorUtils.cxx:1145

◆ 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)+")"; }
y
#define y
x
#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)+")"; }
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 IVP13DSystemSimple::systemcreate ( StoreGateSvc * detstore)
virtualinherited

Reimplemented in VP1AODSystem, VP1CaloCellSystem, VP1CaloHitLegoSystem, VP1CaloLegoSystem, VP1CaloReadoutSystem, VP1GeometrySystem, VP1HVLegoSystem, VP1PrepRawDataSystem, VP1SimHitSystem, and VP1TrackSystem.

Definition at line 23 of file IVP13DSystemSimple.cxx.

23{}

◆ systemerase()

void IVP13DSystemSimple::systemerase ( )
virtualinherited

Reimplemented in VP1AODSystem, VP1CaloCellSystem, VP1CaloClusterSystem, VP1CaloHitLegoSystem, VP1CaloLegoSystem, VP1MissingEtSystem, VP1PrepRawDataSystem, VP1RawDataSystem, VP1TrackSystem, and VP1VertexSystem.

Definition at line 28 of file IVP13DSystemSimple.cxx.

29{
30 // messageVerbose("WARNING: Did not reimplement systemerase!");
31}

◆ systemuncreate()

void IVP13DSystemSimple::systemuncreate ( )
virtualinherited

Reimplemented in VP1AODSystem, VP1CaloCellSystem, VP1CaloHitLegoSystem, VP1CaloLegoSystem, VP1ExtraInputSystem, VP1GeometrySystem, VP1GuideLineSystem, VP1PrepRawDataSystem, VP1RawDataSystem, and VP1TrackSystem.

Definition at line 27 of file IVP13DSystemSimple.cxx.

27{}

◆ toolSvc()

IToolSvc * IVP1System::toolSvc ( ) const
inherited

Definition at line 330 of file IVP1System.cxx.

331{
332 return VP1AthenaPtrs::toolSvc();
333}
VP1AthenaPtrs::toolSvc
static IToolSvc * toolSvc()
Definition VP1AthenaPtrs.h:30

◆ 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}
IVP13DSystemSimple::systemuncreate
virtual void systemuncreate()
Definition IVP13DSystemSimple.cxx:27

◆ 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(); }
IVP1System::updateGUI
void updateGUI()
Definition IVP1System.cxx:262

◆ userChangedSelection()

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

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

Definition at line 61 of file IVP13DSystem.cxx.

61{}

◆ 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 IVP13DSystemSimple::userPickedNode ( SoNode * pickedNode,
SoPath * pickedPath )
virtualinherited

Reimplemented in Example3DSystem3, Example3DSystem4, Example3DSystem5, TrackingSurfacesSystem, TrackSystemDisplay, VP1AODSystem, VP1CaloCellSystem, VP1CaloClusterSystem, VP1CaloHitLegoSystem, VP1CaloLegoSystem, VP1CaloReadoutSystem, VP1GeometrySystem, VP1HVLegoSystem, VP1MissingEtSystem, VP1PrepRawDataSystem, VP1RawDataSystem, VP1TrackSystem, and VP1VertexSystem.

Definition at line 26 of file IVP13DSystemSimple.cxx.

26{}

◆ 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
IVP1System::s_vp1verbose
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_d

Imp* VP1TrackingGeometrySystem::m_d
private

Definition at line 60 of file VP1TrackingGeometrySystem.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:
Generated on for ATLAS Offline Software by doxygen 1.14.0