#include <VolumeTreeModel.h>

Inheritance diagram for VolumeTreeModel:

Collaboration diagram for VolumeTreeModel:

Classes
class	Imp

Public Member Functions
	VolumeTreeModel (QObject *parent=0)

virtual	~VolumeTreeModel ()

void	addSubSystem (VP1GeoFlags::SubSystemFlag flag, const VolumeHandle::VolumeHandleList &roothandles)

void	enableSubSystem (VP1GeoFlags::SubSystemFlag flag)

void	disableSubSystem (VP1GeoFlags::SubSystemFlag flag)

void	getRootHandles (std::vector< std::pair< VolumeHandle::VolumeHandleListItr, VolumeHandle::VolumeHandleListItr > > &) const

QModelIndex	index (int, int, const QModelIndex &) const

QModelIndex	parent (const QModelIndex &) const

int	rowCount (const QModelIndex &) const

int	columnCount (const QModelIndex &idx) const

QVariant	data (const QModelIndex &, int) const

Qt::ItemFlags	flags (const QModelIndex &index) const

QVariant	headerData (int section, Qt::Orientation orientation, int role) const

bool	hasChildren (const QModelIndex &parent=QModelIndex()) const

bool	canFetchMore (const QModelIndex &parent) const

void	fetchMore (const QModelIndex &parent)

void	cleanup ()

Private Attributes
Imp *	m_d

Detailed Description

Definition at line 14 of file VolumeTreeModel.h.

Constructor & Destructor Documentation

◆ VolumeTreeModel()

VolumeTreeModel::VolumeTreeModel ( QObject * parent = 0 )

Definition at line 103 of file VolumeTreeModel.cxx.

   : QAbstractItemModel(parent), m_d(new Imp())
 {
   if (Imp::section2string.empty()) {
     Imp::section2string[Imp::UNKNOWN] = "Unknown";
     Imp::section2string[Imp::INDET] = "Inner Detector";
     Imp::section2string[Imp::CALO] = "Calorimeters";
     Imp::section2string[Imp::MUON] = "Muon Spectrometer";
     Imp::section2string[Imp::MISC] = "Miscellaneous";
   }
   if (Imp::subsysflag2section.empty()) {
     Imp::defineSubSystem(VP1GeoFlags::None,"None",Imp::UNKNOWN);
     // Inner Detector
     Imp::defineSubSystem(VP1GeoFlags::Pixel,"Pixel",Imp::INDET);
     Imp::defineSubSystem(VP1GeoFlags::Pixel,"ITkPixel",Imp::INDET);
     Imp::defineSubSystem(VP1GeoFlags::SCT,"SCT",Imp::INDET);
     Imp::defineSubSystem(VP1GeoFlags::SCT,"ITkStrip",Imp::INDET);
     Imp::defineSubSystem(VP1GeoFlags::TRT,"TRT",Imp::INDET);
     Imp::defineSubSystem(VP1GeoFlags::InDetServMat,"Services",Imp::INDET);
     // Calorimeters
     Imp::defineSubSystem(VP1GeoFlags::LAr,"LAr",Imp::CALO);
     Imp::defineSubSystem(VP1GeoFlags::Tile,"Tile",Imp::CALO);
     //Toroids
     Imp::defineSubSystem(VP1GeoFlags::BarrelToroid,"Toroid Barrel",Imp::MUON);
     Imp::defineSubSystem(VP1GeoFlags::ToroidECA,"Toroid EndCap side A",Imp::MUON);
     Imp::defineSubSystem(VP1GeoFlags::ToroidECC,"Toroid EndCap side C",Imp::MUON);
     // Structure
     Imp::defineSubSystem(VP1GeoFlags::MuonFeet,"Feets",Imp::MUON);
     Imp::defineSubSystem(VP1GeoFlags::MuonShielding,"Shields, etc.",Imp::MUON);
     Imp::defineSubSystem(VP1GeoFlags::MuonToroidsEtc,"Muon etc.",Imp::MUON);
     // Muon chambers
     Imp::defineSubSystem(VP1GeoFlags::MuonBarrelStationInner,"Inner Barrel Stations",Imp::MUON);
     Imp::defineSubSystem(VP1GeoFlags::MuonBarrelStationMiddle,"Middle Barrel Stations",Imp::MUON);
     Imp::defineSubSystem(VP1GeoFlags::MuonBarrelStationOuter,"Outer Barrel Stations",Imp::MUON);
     Imp::defineSubSystem(VP1GeoFlags::MuonEndcapStationCSC,"Endcap CSC",Imp::MUON);
     Imp::defineSubSystem(VP1GeoFlags::MuonEndcapStationTGC,"Endcap TGC",Imp::MUON);
     Imp::defineSubSystem(VP1GeoFlags::MuonEndcapStationMDT,"Endcap MDT",Imp::MUON);
     Imp::defineSubSystem(VP1GeoFlags::MuonEndcapStationNSW,"Endcap NSW",Imp::MUON);
     // Beam Pipe
     Imp::defineSubSystem(VP1GeoFlags::BeamPipe,"Beam Pipe",Imp::MISC);
     // FWD detectors
     Imp::defineSubSystem(VP1GeoFlags::LUCID,"LUCID",Imp::MISC);
     Imp::defineSubSystem(VP1GeoFlags::ZDC,"ZDC",Imp::MISC);
     Imp::defineSubSystem(VP1GeoFlags::ForwardRegion,"ForwardRegion",Imp::MISC);
     // Cavern
     Imp::defineSubSystem(VP1GeoFlags::CavernInfra,"Cavern Infrastructure",Imp::MISC);
   }
 }

◆ ~VolumeTreeModel()

VolumeTreeModel::~VolumeTreeModel ( )

virtual

Definition at line 166 of file VolumeTreeModel.cxx.

 {
   delete m_d;
 }

Member Function Documentation

◆ addSubSystem()

void VolumeTreeModel::addSubSystem	(	VP1GeoFlags::SubSystemFlag	flag,
		const VolumeHandle::VolumeHandleList &	roothandles
	)

Definition at line 172 of file VolumeTreeModel.cxx.

 {
   //NB: This method does not need to be super-fast, thus we do a lot
   //of not-so-fast iterations over maps/lists rather than keep extra
   //maps/lists around.
  
   //Check whether we added this subsystem already:
   bool found(false);
   for(Imp::SectionInfo* section : m_d->allSections) {
     for(Imp::SubSystem* subsys : (section->enabledSubSystems+section->disabledSubSystems)) {
       if (subsys->subsysflag==flag) {
     found=true;
     break;
       }
     }
   }
  
   if (found) {
     std::cout<<"VolumeTreeModel::addSubSystem Error: System has already been added!"<<std::endl;
     return;
   }
  
   //Determine section flag:
   Imp::SECTION sectionflag;
   if (Imp::subsysflag2section.find(flag)==Imp::subsysflag2section.end()) {
     std::cout<<"VolumeTreeModel::addSubSystem Error: Unknown system flag! Please update the code!"<<std::endl;
     sectionflag=Imp::UNKNOWN;
   } else {
     sectionflag=Imp::subsysflag2section[flag];
   }
  
   //Find the section belonging to the system (create a new one if
   //needed - i.e. if this is the first subsystem in a given section):
   Imp::SectionInfo* section(0);
   found = false;
   for(Imp::SectionInfo* sec : m_d->allSections) {
       if (sec->sectionflag==sectionflag) {
           //std::cout << "added section: " << sec->sectionflag << std::endl;
           section = sec;
           break;
       }
   }
  
   if (!section) {
     section = new Imp::SectionInfo(sectionflag);
     //section->sectionflag = sectionflag;
     if (Imp::section2string.find(sectionflag)==Imp::section2string.end())
       section->name = "Unknown Section Flag";
     else
       section->name = Imp::section2string[sectionflag];
     m_d->allSections<<section;
     //We dont add it to m_d->activeSections since the subsystem (and
     //thus the section since it has no other subsystems) is considered
     //disabled until enabled by a call to enableSubSystem().
   }
  
   //Create SubSystem instance for this subsystem and give it the roothandles:
   Imp::SubSystem * subsys = new Imp::SubSystem(section,flag);
   //subsys->section = section;
   //subsys->subsysflag = flag;
   if (Imp::subsysflag2string.find(flag)==Imp::subsysflag2string.end())
     subsys->name = "Unknown subsystem flag";
   else
     subsys->name = Imp::subsysflag2string[flag];
   subsys->volhandlelist = roothandles;
  
   //Add the subsystem pointer to the relevant maps:
   section->disabledSubSystems << subsys;
   m_d->flag2subsystems[flag]=subsys;
 }

◆ canFetchMore()

bool VolumeTreeModel::canFetchMore ( const QModelIndex & parent ) const

Definition at line 496 of file VolumeTreeModel.cxx.

 {
   if (!parent.isValid())
     return false;
  
   VolumeHandle * parentHandle = Imp::handlePointer(parent);
  
   if (Imp::isRegularVolumeHandle(parentHandle)&&!parentHandle->childrenAreInitialised())
     return true;
  
   return false;
 }

◆ cleanup()

void VolumeTreeModel::cleanup ( )

Definition at line 153 of file VolumeTreeModel.cxx.

 {
   //This is where we delete all SectionInfo/SubSystem pointers (and thus also all VolumeHandles):
   std::map<VP1GeoFlags::SubSystemFlag,Imp::SubSystem*>::iterator it, itE = m_d->flag2subsystems.end();
   for (it = m_d->flag2subsystems.begin();it!=itE;++it)
     disableSubSystem(it->first);
   for (it = m_d->flag2subsystems.begin();it!=itE;++it)
     delete it->second;
   for (Imp::SectionInfo* section :  m_d->allSections)
     delete section;
 }

◆ columnCount()

int VolumeTreeModel::columnCount ( const QModelIndex & idx ) const

inline

Definition at line 35 of file VolumeTreeModel.h.

35 { return rowCount(idx) > 0 ? 1 : 0; }

◆ data()

QVariant VolumeTreeModel::data	(	const QModelIndex &	index,
		int	role
	)		const

Definition at line 446 of file VolumeTreeModel.cxx.

 {
   if ((role!=Qt::DisplayRole&&role!=Qt::ForegroundRole)||!index.isValid())
     return QVariant();
  
   VolumeHandle *volumeHandle = Imp::handlePointer(index);
   if (Imp::isRegularVolumeHandle(volumeHandle)) {
     if (role==Qt::ForegroundRole) {
       if (volumeHandle->isAttached())
     return QVariant();
       else
     return QColor::fromRgbF( 0.5, 0.5, 0.5 );
     }
     //DisplayRole:
     if (volumeHandle->nChildren()>1)
       return volumeHandle->getName()+" ["+QString::number(volumeHandle->nChildren())+"]";
     else
       return volumeHandle->getName();
   }
  
   if (role==Qt::ForegroundRole)
     return QVariant();
  
   if (Imp::isSubSystemPointer(volumeHandle))
     return Imp::subSystemPointer(volumeHandle)->name;
  
   Q_ASSERT(Imp::isSectionInfoPointer(volumeHandle));
   return Imp::sectionInfoPointer(volumeHandle)->name;
 }

◆ disableSubSystem()

void VolumeTreeModel::disableSubSystem ( VP1GeoFlags::SubSystemFlag flag )

Definition at line 292 of file VolumeTreeModel.cxx.

 {
     beginResetModel(); // see: http://doc.qt.io/qt-5/qabstractitemmodel-obsolete.html
  
   //If it was not even added previously we can just return:
   if (m_d->flag2subsystems.find(flag)==m_d->flag2subsystems.end())
     return;
  
   Imp::SubSystem * subsys = m_d->flag2subsystems[flag];
   //Find the appropriate section:
   Imp::SectionInfo* section(0);
   for(Imp::SectionInfo* sec : m_d->allSections) {
     if (sec->disabledSubSystems.contains(subsys)) {
       //It is already disabled
       assert(!sec->enabledSubSystems.contains(subsys));
       return;
     }
     if (sec->enabledSubSystems.contains(subsys)) {
       assert(!sec->disabledSubSystems.contains(subsys));
       section=sec;
       break;
     }
   }
   assert(section);
   if (!section) {
     std::cout<<"VolumeTreeModel::disableSubSystem Error: Did not find section of subsystem!."<<std::endl;
     return;
   }
  
   //Move the subsystem from the enabled to the disabled list:
   section->disabledSubSystems << subsys;
   section->enabledSubSystems.removeAll(subsys);
   //If the newly disabled subsystem was the only enabled subsystem, the section needs to be disabled as well:
   if (section->enabledSubSystems.count()==0) {
     assert(m_d->activeSections.contains(section));
     m_d->activeSections.removeAll(section);
   }
  
   //Remove volume handle pointers from quick subsystem access map:
   for (VolumeHandle* volhandle : subsys->volhandlelist ) {
     Q_ASSERT(m_d->volhandle2subsystem.find(volhandle)!=m_d->volhandle2subsystem.end());
     m_d->volhandle2subsystem.erase(m_d->volhandle2subsystem.find(volhandle));
   }
  
   endResetModel();
 //  reset();//Fixme: use proper insert rows/colums/etc. instead!
 }

◆ enableSubSystem()

void VolumeTreeModel::enableSubSystem ( VP1GeoFlags::SubSystemFlag flag )

Definition at line 245 of file VolumeTreeModel.cxx.

 {
   beginResetModel(); // see: http://doc.qt.io/qt-5/qabstractitemmodel-obsolete.html
  
   //Check the subsystem was added previously:
   if (m_d->flag2subsystems.find(flag)==m_d->flag2subsystems.end()) {
     std::cout<<"VolumeTreeModel::enableSubSystem Error: System never added!"<<std::endl;
     return;
   }
   Imp::SubSystem * subsys = m_d->flag2subsystems[flag];
   //Find the appropriate section:
   Imp::SectionInfo* section(0);
   for(Imp::SectionInfo* sec : m_d->allSections) {
     if (sec->enabledSubSystems.contains(subsys)) {
       //It is already enabled
       assert(!sec->disabledSubSystems.contains(subsys));
       return;
     }
     if (sec->disabledSubSystems.contains(subsys)) {
       assert(!sec->enabledSubSystems.contains(subsys));
       section=sec;
       break;
     }
   }
   assert(section);
   if (!section) {
     std::cout<<"VolumeTreeModel::enableSubSystem Error: Did not find section of subsystem!."<<std::endl;
     return;
   }
   //Move the subsystem from the disabled to the enabled list:
   section->enabledSubSystems << subsys;//Fixme: Ordering.
   section->disabledSubSystems.removeAll(subsys);
   //If the newly added subsystem is the only enabled subsystem, the section needs to be enabled as well:
   if (section->enabledSubSystems.count()==1) {
     assert(!m_d->activeSections.contains(section));
     m_d->activeSections << section;//Fixme: Ordering.
   }
   //Put volume handle pointers into quick subsystem access map:
   for (VolumeHandle* volhandle : subsys->volhandlelist ) {
     m_d->volhandle2subsystem[volhandle] = subsys;
   }
  
   endResetModel();
  
 }

◆ fetchMore()

void VolumeTreeModel::fetchMore ( const QModelIndex & parent )

Definition at line 510 of file VolumeTreeModel.cxx.

 {
   if (!parent.isValid())
     return;//should probably never happen
  
   VolumeHandle* parentHandle = Imp::handlePointer(parent);
  
   if (Imp::isRegularVolumeHandle(parentHandle)&&!parentHandle->childrenAreInitialised()) {
     //     beginInsertRows(parent,0,int(parentHandle->nChildren())-1);
     parentHandle->initialiseChildren();
     layoutChanged();//fixme??
     //     endInsertRows();
     return;
   }
 }

◆ flags()

Qt::ItemFlags VolumeTreeModel::flags ( const QModelIndex & index ) const

Definition at line 478 of file VolumeTreeModel.cxx.

 {
   if (!index.isValid())
     return Qt::ItemFlags();
  
   if (Imp::isRegularVolumeHandle(Imp::handlePointer(index)))
     return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
   else
     return Qt::ItemIsEnabled;
 }

◆ getRootHandles()

void VolumeTreeModel::getRootHandles ( std::vector< std::pair< VolumeHandle::VolumeHandleListItr, VolumeHandle::VolumeHandleListItr > > & out ) const

Definition at line 341 of file VolumeTreeModel.cxx.

 {
   out.clear();
   out.reserve(m_d->flag2subsystems.size());
   std::map<VP1GeoFlags::SubSystemFlag,Imp::SubSystem*>::iterator it, itE = m_d->flag2subsystems.end();
   for (it = m_d->flag2subsystems.begin();it!=itE;++it)
     out.push_back(std::pair<VolumeHandle::VolumeHandleListItr,VolumeHandle::VolumeHandleListItr>
           (it->second->volhandlelist.begin(),it->second->volhandlelist.end()));
  
 }

◆ hasChildren()

bool VolumeTreeModel::hasChildren ( const QModelIndex & parent = QModelIndex() ) const

Definition at line 527 of file VolumeTreeModel.cxx.

 {
   return rowCount(parent)>0;//Our rowCount is relatively fast (no looping to count).
 }

◆ headerData()

QVariant VolumeTreeModel::headerData	(	int	section,
		Qt::Orientation	orientation,
		int	role
	)		const

Definition at line 490 of file VolumeTreeModel.cxx.

 {
   return QVariant();
 }

◆ index()

QModelIndex VolumeTreeModel::index	(	int	row,
		int	column,
		const QModelIndex &	parent
	)		const

Definition at line 353 of file VolumeTreeModel.cxx.

 {
   //Check that row and column are in allowed ranges (positive and within row/column count of parent):
   if (!hasIndex(row, column, parent))
     return QModelIndex();
  
   if (!parent.isValid()) {
     //We must return the index of a section label:
     Q_ASSERT(row<m_d->activeSections.count());
     return createIndex(row, column, m_d->activeSections.at(row));
   }
  
   VolumeHandle * parentHandle = Imp::handlePointer(parent);
  
   if (Imp::isRegularVolumeHandle(parentHandle)) {
     if (!parentHandle->childrenAreInitialised())
       parentHandle->initialiseChildren();//Fixme: It seems that it is occasionally necessary to do this. Why?? Why not fetchMore??
     VolumeHandle * childHandle = parentHandle->child(row);
     Q_ASSERT(childHandle);
     return createIndex(row, column, childHandle);
   }
  
   if (Imp::isSubSystemPointer(parentHandle)) {
     //Return index of top-level volume:
     Q_ASSERT(unsigned(row)<Imp::subSystemPointer(parentHandle)->volhandlelist.size());
     return createIndex(row, column, Imp::subSystemPointer(parentHandle)->volhandlelist.at(row));
   }
  
   //Must be SectionInfo:
   Q_ASSERT(Imp::isSectionInfoPointer(parentHandle));
   Q_ASSERT(row<Imp::sectionInfoPointer(parentHandle)->enabledSubSystems.count());
   return createIndex(row, column, Imp::sectionInfoPointer(parentHandle)->enabledSubSystems.at(row));
 }

◆ parent()

QModelIndex VolumeTreeModel::parent ( const QModelIndex & index ) const

Definition at line 388 of file VolumeTreeModel.cxx.

 {
   if (!index.isValid())
     return QModelIndex();
  
   //See if we have a volumeHandle as index:
   VolumeHandle *childHandle = Imp::handlePointer(index);
  
   if (Imp::isRegularVolumeHandle(childHandle)) {
     VolumeHandle *parentHandle = childHandle->parent();
     if (parentHandle)
       return createIndex(parentHandle->childNumber(), 0, parentHandle);
  
     //childHandle has 0 parent pointer => parent must be a subsystem label:
     Q_ASSERT(m_d->volhandle2subsystem.find(childHandle)!=m_d->volhandle2subsystem.end());
     Imp::SubSystem * subsys = m_d->volhandle2subsystem[childHandle];
     Q_ASSERT(subsys);
     Q_ASSERT(subsys->section->enabledSubSystems.contains(subsys));
     return createIndex(subsys->section->enabledSubSystems.indexOf(subsys), 0, subsys);
   }
  
  
   if (Imp::isSubSystemPointer(childHandle)) {
       //Index is a SubSystem => parent must be a section label:
       Q_ASSERT(m_d->activeSections.contains(Imp::subSystemPointer(childHandle)->section));
       return createIndex(m_d->activeSections.indexOf(Imp::subSystemPointer(childHandle)->section), 0, Imp::subSystemPointer(childHandle)->section);
   }
  
   //Must be SectionInfo => parent is root (i.e. invalid):
   Q_ASSERT(Imp::isSectionInfoPointer(childHandle));
   return QModelIndex();
 }

◆ rowCount()

int VolumeTreeModel::rowCount ( const QModelIndex & parent ) const

Definition at line 422 of file VolumeTreeModel.cxx.

 {
   if (parent.column() > 0)
     return 0;
  
   if (!parent.isValid())
     return m_d->activeSections.size();//Number of active sections
  
   VolumeHandle * parentHandle = Imp::handlePointer(parent);
  
   if (Imp::isRegularVolumeHandle(parentHandle)) {
     return parentHandle->nChildren();
   }
  
   if (Imp::isSubSystemPointer(parentHandle)) {
     return Imp::subSystemPointer(parentHandle)->volhandlelist.size();
   }
  
   //Must be SectionInfo pointer:
   Q_ASSERT(Imp::isSectionInfoPointer(parentHandle));
   return Imp::sectionInfoPointer(parentHandle)->enabledSubSystems.count();
 }

Member Data Documentation

◆ m_d

Imp* VolumeTreeModel::m_d

private

Definition at line 47 of file VolumeTreeModel.h.

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

Classes

Public Member Functions

Private Attributes