VolumeTreeModel Class Reference

#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::ITkPixel,"ITkPixel",Imp::INDET);
    Imp::defineSubSystem(VP1GeoFlags::SCT,"SCT",Imp::INDET);
    Imp::defineSubSystem(VP1GeoFlags::ITkStrip,"ITkStrip",Imp::INDET);
    Imp::defineSubSystem(VP1GeoFlags::TRT,"TRT",Imp::INDET);
    Imp::defineSubSystem(VP1GeoFlags::InDetServMat,"Services",Imp::INDET);
    //HGTD
    Imp::defineSubSystem(VP1GeoFlags::HGTD,"HGTD",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 168 of file VolumeTreeModel.cxx.

{
  delete m_d;
}

Member Function Documentation

addSubSystem()

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

Definition at line 174 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 498 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 155 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.

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

data()

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

Definition at line 448 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 294 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 247 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 512 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 480 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 343 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 529 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 492 of file VolumeTreeModel.cxx.

{
  return QVariant();
}

index()

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

Definition at line 355 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 390 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 424 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:

• VolumeTreeModel.h
• VolumeTreeModel.cxx