VP1GeometrySystem::Imp Class Reference

Classes
class	SubSystemInfo

Public Member Functions
	Imp (VP1GeometrySystem *gs, const VP1GeoFlags::SubSystemFlags &ssf)
void	addSubSystem (const VP1GeoFlags::SubSystemFlag &, const QString &treetopregexp, const QString &childrenregexp="", const std::string &matname="", bool negatetreetopregexp=false, bool negatechildrenregexp=false, const QString &grandchildrenregexp="", bool negategrandchildrenregexp=false)
SubSystemInfo *	chamberPVToMuonSubSystemInfo (const GeoPVConstLink &chamberPV)
void	ensureInitVisAttributes ()
void	buildSystem (SubSystemInfo *)
void	updateTouchedMuonChamber (VolumeHandle *chamberhandle)
std::pair< SbVec3f, SbVec3f >	getClosestMuonDriftTubeDirections (const SbVec3f &cameraDirection, const SbVec3f &cameraUpDirection, VolumeHandle *chamberhandle)
std::pair< SbVec3f, SbVec3f >	getClosestCSCOrTGCEdgeDirections (const SbVec3f &cameraDirection, VolumeHandle *chamberhandle)
void	changeStateOfVisibleNonStandardVolumesRecursively (VolumeHandle *, VP1GeoFlags::VOLSTATE)
void	expandVisibleVolumesRecursively (VolumeHandle *, const QRegExp &, bool bymatname)
void	iconifyVisibleVolumesRecursively (VolumeHandle *, const QRegExp &, bool bymatname)
void	ensureInitPV2MuonStationMap ()
void	updatePV2MuonStationMap (const MuonGM::MuonReadoutElement *elem)
QStringList	stationInfo (const MuonGM::MuonStation *)
void	expandAllChildren (VolumeHandle *, bool isPixel, bool brl, bool ecA, bool ecC)
void	showPixelModules (VolumeHandle *)
void	showITkPixelModules (VolumeHandle *, bool brl, bool ecA, bool ecC)
void	showITkStripModules (VolumeHandle *, bool brl, bool ecA, bool ecC)
void	showSCTBarrelModules (VolumeHandle *)
void	showSCTEndcapModules (VolumeHandle *)
void	applyTopVolStates (const QMap< quint32, QByteArray > &, bool disablenotif=false)
void	createPathExtras (const VolumeHandle *, QString &, QStack< QString > &)

Static Public Member Functions
static double	exclusiveMass (const PVConstLink &pv)
static double	inclusiveMass (const PVConstLink &pv)
static double	volume (const PVConstLink &pv)
static void	catchKbdState (void *userData, SoEventCallback *CB)

Public Attributes
VP1GeometrySystem *	theclass
SoSeparator *	sceneroot
std::map< SoSeparator *, VolumeHandle * >	sonodesep2volhandle
QList< SubSystemInfo * >	subsysInfoList
DetVisAttributes *	detVisAttributes
MatVisAttributes *	matVisAttributes
VolVisAttributes *	volVisAttributes
VP1GeoFlags::SubSystemFlags	initialSubSystemsTurnedOn
GeoSysController *	controller
PhiSectorManager *	phisectormanager
VolumeTreeModel *	volumetreemodel
const SoKeyboardEvent *	kbEvent
std::map< PVConstLink, VolumeHandle * >	muonchambers_pv2handles
std::map< QObject *, std::set< GeoPVConstLink > >	sender2ChamberList
VolumeHandle *	previousAlignedChamberHandle
int	last_appropriatemdtprojections
SoSeparator *	m_textSep
	Separator used to hold all visible labels.
std::map< GeoPVConstLink, const MuonGM::MuonStation * >	pv2MuonStation
bool	pv2MuonStationInit
QMap< quint32, QByteArray >	restoredTopvolstates
QList< const std::map< GeoPVConstLink, float > * >	chamberT0s

Detailed Description

Definition at line 95 of file VP1GeometrySystem.cxx.

Constructor & Destructor Documentation

Imp()

VP1GeometrySystem::Imp::Imp ( VP1GeometrySystem * gs, const VP1GeoFlags::SubSystemFlags & ssf )

inline

Definition at line 97 of file VP1GeometrySystem.cxx.

    : theclass(gs), sceneroot(0),
      detVisAttributes(0), matVisAttributes(0), volVisAttributes(0),
      initialSubSystemsTurnedOn(ssf),controller(0),phisectormanager(0),
      volumetreemodel(0),kbEvent(0),previousAlignedChamberHandle(0),
      last_appropriatemdtprojections(-1),m_textSep(0)
      #ifndef BUILDVP1LIGHT
        ,pv2MuonStationInit(false)
      #endif
  {
    const unsigned n_chamber_t0_sources=2;
    for (unsigned i=0;i<n_chamber_t0_sources;++i)
      chamberT0s.append(0);
  }

Member Function Documentation

addSubSystem()

void VP1GeometrySystem::Imp::addSubSystem	(	const VP1GeoFlags::SubSystemFlag &	f,
		const QString &	treetopregexp,
		const QString &	childrenregexp = "",
		const std::string &	matname = "",
		bool	negatetreetopregexp = false,
		bool	negatechildrenregexp = false,
		const QString &	grandchildrenregexp = "",
		bool	negategrandchildrenregexp = false )

Definition at line 366 of file VP1GeometrySystem.cxx.

{
  theclass->messageDebug("VP1GeometrySystem::Imp::addSubSystem - flag: '" + QString(f) + "' - matName: '" + str(matname.c_str()) + "'." );
 
  QCheckBox * cb = controller->subSystemCheckBox(f);
  if (!cb) {
    theclass->message("Error: Problems retrieving checkbox for subsystem "+str(f));
    return;
  }
  subsysInfoList << new SubSystemInfo(cb,QRegExp(treetopregexp),negatetreetopregexp,
                      QRegExp(childrenregexp),negatechildrenregexp,f,matname,
                      QRegExp(grandchildrenregexp), negategrandchildrenregexp);
  //FIXME: DELETE!!!
}

applyTopVolStates()

void VP1GeometrySystem::Imp::applyTopVolStates	(	const QMap< quint32, QByteArray > &	topvolstates,
		bool	disablenotif = false )

Definition at line 1391 of file VP1GeometrySystem.cxx.

{
  if (disablenotif)
    phisectormanager->largeChangesBegin();
  QMap<quint32,QByteArray>::const_iterator topvolstatesItr;
  for (Imp::SubSystemInfo * subsys : subsysInfoList) {
    VolumeHandle::VolumeHandleListItr it(subsys->vollist.begin()),itE(subsys->vollist.end());
    for (;it!=itE;++it) {
      topvolstatesItr = topvolstates.find((*it)->hashID());
      if (topvolstatesItr!=topvolstates.end())
    (*it)->applyPersistifiableState(topvolstatesItr.value());
    }
  }
  if (disablenotif) {
    phisectormanager->updateRepresentationsOfVolsAroundZAxis();
    phisectormanager->largeChangesEnd();
  }
}

buildSystem()

void VP1GeometrySystem::Imp::buildSystem

(

SubSystemInfo *

si

)

Definition at line 1103 of file VP1GeometrySystem.cxx.

{
  VP1Msg::messageDebug("VP1GeometrySystem::Imp::buildSystem()" );
 
  if (!si||si->isbuilt)
    return;
  si->isbuilt = true;
  int ichild(0);
 
  ensureInitVisAttributes();
    #ifndef BUILDVP1LIGHT
      ensureInitPV2MuonStationMap(); // Needed for Muon Station names.
    #endif
 
//  // DEBUG
//  for (Imp::SubSystemInfo*si : m_d->subsysInfoList) {
//    VP1Msg::messageDebug("vol: " + QString((si->flag).str_c()) );
//  }
  
  assert(si->soswitch);
  SoSeparator * subsystemsep = new SoSeparator;
  phisectormanager->registerSubSystemSeparator(si->flag,subsystemsep);
  phisectormanager->largeChangesBegin();
 
  SbBool save = si->soswitch->enableNotify(false);
 
  if (si->geomodelchildrenregexp.isEmpty()) {
      //Loop over the treetop's that we previously selected:
      std::vector<SubSystemInfo::TreetopInfo>::const_iterator it, itE = si->treetopinfo.end();
      for (it=si->treetopinfo.begin();it!=itE;++it)
      {
          VP1Msg::messageDebug("toptree vol: " + QString(it->volname.c_str()) );
 
          //Find material:
          SoMaterial*m = detVisAttributes->get(it->volname);
          if (!m) {
              theclass->message("Warning: Did not find a predefined material for volume: "+QString(it->volname.c_str()));
          }
          VolumeHandleSharedData* volhandle_subsysdata = new VolumeHandleSharedData(controller,si->flag,&sonodesep2volhandle,it->pV,phisectormanager,
                  m,matVisAttributes,volVisAttributes,
                  controller->zappedVolumeListModel(),controller->volumeTreeBrowser(), m_textSep);
          SbMatrix matr;
          VP1LinAlgUtils::transformToMatrix(it->xf,matr);
          VolumeHandle * vh = new VolumeHandle(volhandle_subsysdata,0,it->pV,ichild++,VolumeHandle::NONMUONCHAMBER,matr);
          si->vollist.push_back(vh);
      // std::cout<<"Non muon chamber VH="<<vh<<std::endl;
      }
  } else {
      //Loop over the children of the physical volumes of the treetops that we previously selected:
      std::vector<SubSystemInfo::TreetopInfo>::const_iterator it, itE = si->treetopinfo.end();
      for (it=si->treetopinfo.begin();it!=itE;++it) {
 
          VP1Msg::messageDebug("group name: " + QString(si->matname.c_str()) );
 
          //NB: Here we use the si->matname. Above we use the si->volname. Historical reasons!
 
          //Find material for top-nodes:
          SoMaterial*mat_top(0);
          if (si->matname!="")
              mat_top = detVisAttributes->get(si->matname);
 
          VolumeHandleSharedData* volhandle_subsysdata = new VolumeHandleSharedData(controller,si->flag,&sonodesep2volhandle,it->pV,phisectormanager,
                  mat_top,matVisAttributes,volVisAttributes,
                  controller->zappedVolumeListModel(),controller->volumeTreeBrowser(),m_textSep);
          volhandle_subsysdata->ref();
 
          const bool hasMuonChambers=si->hasMuonChambers();
 
          GeoVolumeCursor av(it->pV);
      //unsigned int count=0;
          while (!av.atEnd()) {
 
              // DEBUG
//            VP1Msg::messageDebug("child vol: " + QString(av.getName().c_str()) );
 
              //Use the childrenregexp to select the correct child volumes:
              if (si->childrenRegExpNameCompatible(av.getName().c_str())) {
                  PVConstLink pVD = av.getVolume();
                  SbMatrix matr;
                  VP1LinAlgUtils::transformToMatrix(Amg::EigenTransformToCLHEP(av.getTransform()),matr);
                  VolumeHandle * vh=0;
          // std::cout<<count++<<": dump SubSystemInfo\n"<<"---"<<std::endl;
          // si->dump();
          // std::cout<<"---"<<std::endl;
                  if (hasMuonChambers){
                    #ifndef BUILDVP1LIGHT
                      vh = new MuonVolumeHandle(volhandle_subsysdata,0,pVD,ichild++,VolumeHandle::MUONCHAMBER_DIRTY,matr,pv2MuonStation[pVD],chamberT0s);
                    #endif
                    #ifdef BUILDVP1LIGHT
                      vh = new VolumeHandle(volhandle_subsysdata,0,pVD,ichild++,VolumeHandle::MUONCHAMBER_DIRTY,matr);
                    #endif
                    muonchambers_pv2handles[pVD] = vh;
                    if(VP1Msg::debug()){
                        std::cout<<"Has muon chamber VH="<<vh<<std::endl;
                    }
            
                  } else {
            
                      vh = new VolumeHandle(volhandle_subsysdata,0,pVD,ichild++,
                              VolumeHandle::NONMUONCHAMBER,matr);
                // std::cout<<"Does not have muon chamber (weird one) VH="<<vh<<std::endl;
                  }
 
                  // DEBUG
//                VP1Msg::messageDebug("granchild vol: " + vh->getName() + " - " + vh->getDescriptiveName() );
 
                  if (si->geomodelgrandchildrenregexp.isEmpty()) {
                      // append the volume to the current list
                      theclass->messageDebug("grandchild inserted : " + vh->getDescriptiveName() + " - " + vh->getName() );
                      si->vollist.push_back(vh);
 
                  } else {
                      VP1Msg::messageDebug("filtering at grandchild level...");
                      if (si->grandchildrenRegExpNameCompatible(vh->getName().toStdString() ) ) {
                          VP1Msg::messageDebug("filtered grandchild inserted : " + vh->getDescriptiveName() + " - " + vh->getName() );
                          // append the volume to the current list
                          si->vollist.push_back(vh);
                      } else {
              theclass->message("Zapping this volumehandle because it's probably junk."+vh->getDescriptiveName() + " - " + vh->getName());
              vh->setState(VP1GeoFlags::ZAPPED); // FIXME - better solution for this? Maybe just don't create them?
              
              // std::cout<<"Not adding "<<vh->getName().toStdString()<<"["<<vh<<"] to vollist"<<std::endl;
                      }
                  }
              }
              av.next(); // increment volume cursor.        
          }
          volhandle_subsysdata->unref();//To ensure it is deleted if it was not used.
      }
  }
 
  if (VP1Msg::debug()) si->dump();
 
  VP1Msg::messageDebug("volumetreemodel->addSubSystem...");
  volumetreemodel->addSubSystem( si->flag, si->vollist );
 
  //NB: We let the destructor of volumetreemodel take care of deleting
  //our (top) volume handles, since it has to keep a list of them
  //anyway.
 
  
  //Perform auto expansion of all ether volumes (needed for muon dead material):
  VP1Msg::messageDebug("Perform auto expansion of all ether volumes (needed for muon dead material)");
  VolumeHandle::VolumeHandleListItr it, itE(si->vollist.end());
  //int idx=0; // for debug
  for (it = si->vollist.begin(); it!=itE; ++it){
    //VP1Msg::messageDebug("\nexpanding idx: " + QString::number(++idx)); 
    (*it)->expandMothersRecursivelyToNonEther();
    //VP1Msg::messageDebug("expand DONE."); 
  }
  
 
  VP1Msg::messageDebug("addChild...");
  phisectormanager->updateRepresentationsOfVolsAroundZAxis();
  phisectormanager->largeChangesEnd();
  si->soswitch->addChild(subsystemsep);
  si->soswitch->enableNotify(save);
  if (save)
    si->soswitch->touch();
  VP1Msg::messageDebug("END of VP1GeometrySystem::Imp::buildSystem() " );
}

catchKbdState()

void VP1GeometrySystem::Imp::catchKbdState ( void * userData, SoEventCallback * CB )

static

Definition at line 510 of file VP1GeometrySystem.cxx.

                                                                           {
  VP1GeometrySystem::Imp *This=static_cast<VP1GeometrySystem::Imp*>(address);
  if (This)
    This->kbEvent = static_cast<const SoKeyboardEvent *>(CB->getEvent());
}

chamberPVToMuonSubSystemInfo()

VP1GeometrySystem::Imp::SubSystemInfo * VP1GeometrySystem::Imp::chamberPVToMuonSubSystemInfo

(

const GeoPVConstLink &

chamberPV

)

Definition at line 1757 of file VP1GeometrySystem.cxx.

{
  VP1Msg::messageDebug("VP1GeometrySystem::Imp::chamberPVToMuonSubSystemInfo()");
 
  std::string name = chamberPV->getLogVol()->getName();
 
  VP1Msg::messageDebug("name: " + QString::fromStdString(name) );
 
  for (SubSystemInfo * subsys : subsysInfoList) {
    if (!subsys->hasMuonChambers())
      continue;
    if (subsys->childrenRegExpNameCompatible(name)) {
      //NB: We assume once again that all muon chambers are to be
      //compared with childrenRegExp.
      return subsys;
    }
  }
  return 0;
}

changeStateOfVisibleNonStandardVolumesRecursively()

void VP1GeometrySystem::Imp::changeStateOfVisibleNonStandardVolumesRecursively	(	VolumeHandle *	handle,
		VP1GeoFlags::VOLSTATE	target )

Definition at line 2016 of file VP1GeometrySystem.cxx.

{
  assert(target!=VP1GeoFlags::CONTRACTED);
  if (handle->isAttached()) {
    //The volume is visible, so ignore daughters
    if (handle->isInitialisedAndHasNonStandardShape()) {
      if (target!=VP1GeoFlags::EXPANDED||handle->nChildren()>0)
    handle->setState(target);
    }
    return;
  } else if (handle->state()==VP1GeoFlags::ZAPPED)
    return;
  //Must be expanded: Let us call on any (initialised) children instead.
  if (handle->nChildren()==0||!handle->childrenAreInitialised())
    return;
  VolumeHandle::VolumeHandleListItr it(handle->childrenBegin()), itE(handle->childrenEnd());
  for(;it!=itE;++it)
    changeStateOfVisibleNonStandardVolumesRecursively(*it,target);
 
}

createPathExtras()

void VP1GeometrySystem::Imp::createPathExtras	(	const VolumeHandle *	volhandle,
		QString &	prefix,
		QStack< QString > &	entries )

Definition at line 1411 of file VP1GeometrySystem.cxx.

{
  switch(volhandle->subsystem()){
  case VP1GeoFlags::Pixel: {
    prefix = QString("Pixel::");
    entries.push("IDET::IDET");
    if (VP1JobConfigInfo::hasITkGeometry())
      entries.push("ITkPixel::ITkPixel");
    else
      entries.push("Pixel::Pixel");
    return;
  }
  case VP1GeoFlags::SCT:{
    prefix = QString("SCT::");
    entries.push("IDET::IDET");
    if (VP1JobConfigInfo::hasITkGeometry())
      entries.push("ITkStrip::ITkStrip");
    else
      entries.push("SCT::SCT");
    return;
  }
  case VP1GeoFlags::HGTD: {
    prefix = QString("HGTD::");
    entries.push("IDET::IDET");
    entries.push("HGTD::HGTD");
    return;
  }
  case VP1GeoFlags::TRT:{
    prefix = QString("TRT::");
    entries.push("IDET::IDET");
    entries.push("TRT::TRT");
    return;
  }
  case VP1GeoFlags::InDetServMat:{
    prefix = QString("InDetServMat::");
    entries.push("IDET::IDET");
    return;
  }
  case VP1GeoFlags::LAr:{
    prefix = QString("LArMgr::");
    entries.push("CALO::CALO");
    entries.push("LArMgr::LArMgr");
    return;
  }
  case VP1GeoFlags::Tile:{
    prefix = QString("Tile::");
    entries.push("CALO::CALO");
    entries.push("Tile::Tile");
    return;
  }
  case VP1GeoFlags::MuonToroidsEtc:
  case VP1GeoFlags::BarrelToroid:
  case VP1GeoFlags::ToroidECA:
  case VP1GeoFlags::ToroidECC:
  case VP1GeoFlags::MuonFeet:
  case VP1GeoFlags::MuonShielding:
  case VP1GeoFlags::MuonBarrelStationInner:
  case VP1GeoFlags::MuonBarrelStationMiddle:
  case VP1GeoFlags::MuonBarrelStationOuter:
  case VP1GeoFlags::MuonEndcapStationCSC:
  case VP1GeoFlags::MuonEndcapStationTGC:
  case VP1GeoFlags::MuonEndcapStationMDT:
  case VP1GeoFlags::AllMuonChambers:{
    prefix = QString("Muon::");
    entries.push("MUONQ02::MUONQ02");
    entries.push("Muon::MuonSys");
    return;
  }
  case VP1GeoFlags::BeamPipe:{
    prefix = QString("BeamPipe::");
    entries.push("BeamPipe::BeamPipe");
    return;
  }
  case VP1GeoFlags::None:
  case VP1GeoFlags::CavernInfra:
  case VP1GeoFlags::LUCID:
  case VP1GeoFlags::ZDC:
  case VP1GeoFlags::ALFA:
  case VP1GeoFlags::AFP:
  case VP1GeoFlags::ForwardRegion:
  case VP1GeoFlags::AllUnrecognisedVolumes:
  default:{
    return;
  }
  }
}

ensureInitPV2MuonStationMap()

void VP1GeometrySystem::Imp::ensureInitPV2MuonStationMap

(

)

Definition at line 2200 of file VP1GeometrySystem.cxx.

{
  if (pv2MuonStationInit) {
      VP1Msg::messageDebug("MuonStation map already initialized.");
      return;
  }
  pv2MuonStationInit = true;
  theclass->messageVerbose("Initializing physical volume link -> MuonStation map.");
 
  const MuonGM::MuonDetectorManager * mgr = VP1DetInfo::muonDetMgr();
  if (!mgr) {
    VP1Msg::message("WARNING: Could not get muon detector manager to construct volume -> muon station map!");
    return;
  }
  if (mgr->nMdtRE()) {
    for (auto det_el = mgr->mdtIdHelper()->detectorElement_begin();
               det_el != mgr->mdtIdHelper()->detectorElement_end(); ++det_el) {
        updatePV2MuonStationMap(mgr->getMdtReadoutElement(*det_el));
    }
  }
  if (mgr->nRpcRE()) {
    for (auto det_el = mgr->rpcIdHelper()->detectorElement_begin();
               det_el != mgr->rpcIdHelper()->detectorElement_end(); ++det_el) {
          updatePV2MuonStationMap(mgr->getRpcReadoutElement(*det_el));
      }    
  }
  if (mgr->nCscRE()) {
    for (auto det_el = mgr->cscIdHelper()->detectorElement_begin();
              det_el != mgr->cscIdHelper()->detectorElement_end(); ++det_el) {
        updatePV2MuonStationMap(mgr->getCscReadoutElement(*det_el));
    }
  }
  if (mgr->nTgcRE()) {
    for (auto det_el = mgr->tgcIdHelper()->detectorElement_begin();
              det_el != mgr->tgcIdHelper()->detectorElement_end(); ++det_el) {
        updatePV2MuonStationMap(mgr->getTgcReadoutElement(*det_el));
    }
  }
 
  VP1Msg::messageDebug("Initialised physical volume link -> MuonStation map. Found "+str(pv2MuonStation.size())+" stations.");
 
}

ensureInitVisAttributes()

void VP1GeometrySystem::Imp::ensureInitVisAttributes ( )

inline

Definition at line 237 of file VP1GeometrySystem.cxx.

                                 {
    if (!detVisAttributes) detVisAttributes = new DetVisAttributes();
    if (!matVisAttributes) matVisAttributes = new MatVisAttributes();
    if (!volVisAttributes) volVisAttributes = new VolVisAttributes();
  }

exclusiveMass()

double VP1GeometrySystem::Imp::exclusiveMass ( const PVConstLink & pv )

static

Definition at line 1266 of file VP1GeometrySystem.cxx.

                                                                {
  const GeoLogVol* lv       = pv->getLogVol();
  const GeoMaterial      *material = lv->getMaterial();
  double density = material->getDensity();
  return density*volume(pv);
}

expandAllChildren()

void VP1GeometrySystem::Imp::expandAllChildren	(	VolumeHandle *	h,
		bool	isPixel,
		bool	brl,
		bool	ecA,
		bool	ecC )

Definition at line 2604 of file VP1GeometrySystem.cxx.

                                                                                                        {
 
  if (h->nChildren()==0) {
    if (isPixel and (ecA or ecC)) {
      float translation_x, translation_y, translation_z, rotaxis_x, rotaxis_y, rotaxis_z, rotangle_radians;
      VP1LinAlgUtils::decodeTransformation( h->getGlobalTransformToVolume(),
                                            translation_x, translation_y, translation_z,
                                            rotaxis_x, rotaxis_y, rotaxis_z, rotangle_radians );
      if ((!ecA || !ecC) && ((ecA and (translation_z<0.)) or (ecC and (translation_z>0.) ))) {
        h->setState(VP1GeoFlags::ZAPPED);
        return;
      }
    }
 
    // check if you have to select it
    std::vector< std::string > selected_volumes = {};
    if (brl) {
      if (isPixel) {
        selected_volumes.push_back("InnerBarrelSingleMod_Sensor");
        selected_volumes.push_back("InnerBarrelQuadMod_Sensor");
        selected_volumes.push_back("OuterBarrelQuadMod_Sensor");
        selected_volumes.push_back("LongeronCoolingTube");
        selected_volumes.push_back("InnerPixBarrelSupport_Stave");
        selected_volumes.push_back("InnerPixBarrelSupport_Stave1");
        selected_volumes.push_back("LongeronCornerBase");
        selected_volumes.push_back("LongeronCornerEnd");
        selected_volumes.push_back("LongeronTrussWall");
        selected_volumes.push_back("LongeronCapBase");
        selected_volumes.push_back("LongeronTopCap");
 
      } else {
        selected_volumes.push_back("BRLSensorSS");
        selected_volumes.push_back("BRLSensorMS");
        selected_volumes.push_back("B_HybridPCB");
        selected_volumes.push_back("DCDC_PCB");
        selected_volumes.push_back("DCDC_Box");
        selected_volumes.push_back("Bex_HybridPCB_near");
        selected_volumes.push_back("Bex_HybridPCB_far");
      }
    }
    if (ecA or ecC) {
      if (isPixel) {
        selected_volumes.push_back("InclinedQuadMod_Sensor");
        selected_volumes.push_back("InnerRingSingleMod_Sensor");
        selected_volumes.push_back("InnerEndcapQuadMod_Sensor");
        selected_volumes.push_back("OuterEndcapQuadMod_Sensor");
        selected_volumes.push_back("L2HalfRingCoolingPipe");
        selected_volumes.push_back("L3HalfRingCoolingPipe");
        selected_volumes.push_back("L4endcapcoolingpipe");
        selected_volumes.push_back("InclL2HalfShell");
        selected_volumes.push_back("InclL2Support");
        selected_volumes.push_back("InclL3HalfShell");
        selected_volumes.push_back("InclL3Support");
        selected_volumes.push_back("InclL4HalfShell");
        selected_volumes.push_back("InclL4Support");
        selected_volumes.push_back("InnerPixEndcap_CoupledRingSupport");
        selected_volumes.push_back("InnerPixEndcap_IntermediateRingSupport");
        selected_volumes.push_back("InnerPixEndcap_L1RingSupport");
        selected_volumes.push_back("L2HalfRingCarbonFoamInner");
        selected_volumes.push_back("L2HalfRingCarbonFoamOuter");
        selected_volumes.push_back("L2HalfRingFaceSheet");
        selected_volumes.push_back("L3HalfRingCarbonFoamInner");
        selected_volumes.push_back("L3HalfRingCarbonFoamOuter");
        selected_volumes.push_back("L3HalfRingFaceSheet");
        selected_volumes.push_back("L4endcapinnerCarbonFoam");
        selected_volumes.push_back("L4endcapouterCarbonFoam");
        selected_volumes.push_back("L4endcapFaceSheet");
        selected_volumes.push_back("L2HalfShell");
        selected_volumes.push_back("L3HalfShell");
        selected_volumes.push_back("L4HalfShell");
      } else {
        selected_volumes.push_back("ECSensor0");
        selected_volumes.push_back("ECSensor1");
        selected_volumes.push_back("ECSensor2");
        selected_volumes.push_back("ECSensor3");
        selected_volumes.push_back("ECSensor4");
        selected_volumes.push_back("ECSensor5");
        selected_volumes.push_back("ECSensorBack0");
        selected_volumes.push_back("ECSensorBack1");
        selected_volumes.push_back("ECSensorBack2");
        selected_volumes.push_back("ECSensorBack3");
        selected_volumes.push_back("ECSensorBack4");
        selected_volumes.push_back("ECSensorBack5");
      }
    }
 
    std::string name = h->getName().toStdString();
 
    if (not isPixel and (ecA or ecC)) {
      // check servises in the endcap
      if (name.starts_with("ECHybrid") or name.starts_with("DCDC_EC"))
        return;
    }
 
    if (std::find(selected_volumes.begin(), selected_volumes.end(), name) == selected_volumes.end()) {
      h->setState(VP1GeoFlags::ZAPPED);
      return;
    }
    return;
  } else if (not isPixel and (h->getName().toStdString()=="PetalCore" or
                              h->getName().toStdString()=="StaveCoreSS" or 
                              h->getName().toStdString() =="StaveCoreMS")) {
    return;
  }
  h->initialiseChildren();
  
  h->setState(VP1GeoFlags::EXPANDED);
  VolumeHandle::VolumeHandleListItr it(h->childrenBegin()),itE(h->childrenEnd());
  for (;it!=itE;++it) {
    expandAllChildren(*it, isPixel, brl, ecA, ecC);
  }
}

expandVisibleVolumesRecursively()

void VP1GeometrySystem::Imp::expandVisibleVolumesRecursively	(	VolumeHandle *	handle,
		const QRegExp &	selregexp,
		bool	bymatname )

Definition at line 2106 of file VP1GeometrySystem.cxx.

{
  if (handle->state()==VP1GeoFlags::ZAPPED)
    return;
  if (handle->state()==VP1GeoFlags::CONTRACTED) {
    //See if we match (and have children) - if so, update state.
    if (handle->nChildren()>0
    && selregexp.exactMatch(bymatname?QString(handle->geoMaterial()->getName().c_str()):handle->getName())) {
      handle->setState(VP1GeoFlags::EXPANDED);
    }
    return;
  }
  //Must be expanded: Let us call on any (initialised) children instead.
  if (handle->nChildren()==0||!handle->childrenAreInitialised())
    return;
  VolumeHandle::VolumeHandleListItr it(handle->childrenBegin()), itE(handle->childrenEnd());
  for(;it!=itE;++it)
    expandVisibleVolumesRecursively(*it,selregexp,bymatname);
}

getClosestCSCOrTGCEdgeDirections()

std::pair< SbVec3f, SbVec3f > VP1GeometrySystem::Imp::getClosestCSCOrTGCEdgeDirections	(	const SbVec3f &	cameraDirection,
		VolumeHandle *	chamberhandle )

Definition at line 1968 of file VP1GeometrySystem.cxx.

{
  // It turns out that the correct chamber directions for CSC/TGC chambers is the y and z axes.
  std::vector<SbVec3f> directions;
  directions.push_back(SbVec3f(0.0f,1.0f,0.0f));
  directions.push_back(SbVec3f(0.0f,-1.0f,0.0f));
  directions.push_back(SbVec3f(0.0f,0.0f,1.0f));
  directions.push_back(SbVec3f(0.0f,0.0f,-1.0f));
 
  directions.push_back(SbVec3f(1.0f,0.0f,0.0f));
  directions.push_back(SbVec3f(-1.0f,0.0f,0.0f));
 
  //Get local->global transformation for chamber:
  SbVec3f translation, scale;
  SbRotation rotation, scalerotation;
  chamberhandle->getGlobalTransformToVolume().getTransform(translation,rotation,scale,scalerotation);
 
  //Put directions into global coordinates:
  for (unsigned i = 0; i<directions.size();++i)
    rotation.multVec(directions[i],directions[i]);
 
  //Find the one closest to the camera:
  SbVec3f chamberDir(-cameraDirection);
  float smallestcosangle(1.1);
  for (unsigned i = 0; i<directions.size();++i) {
    if (directions.at(i).dot(cameraDirection)<smallestcosangle) {
      smallestcosangle = directions.at(i).dot(cameraDirection);
      chamberDir = directions.at(i);
    }
  }
 
  //cameraUpDirection should always (0,1,0) transformed to global
  //coordinates:
  SbVec3f chamberUp;
  float x,y,z;
  chamberDir.getValue(x,y,z);
  if (x!=0.0f) {
    rotation.multVec(SbVec3f(0.0f,1.0f,0.0f),chamberUp);
  } else {
    rotation.multVec(SbVec3f(1.0f,0.0f,0.0f),chamberUp);
  }
 
  //Done:
  return std::pair<SbVec3f,SbVec3f>(chamberDir,chamberUp);
}

getClosestMuonDriftTubeDirections()

std::pair< SbVec3f, SbVec3f > VP1GeometrySystem::Imp::getClosestMuonDriftTubeDirections	(	const SbVec3f &	cameraDirection,
		const SbVec3f &	cameraUpDirection,
		VolumeHandle *	chamberhandle )

Definition at line 1917 of file VP1GeometrySystem.cxx.

{
  //We assume chamberhandle is to an MDT station (barrel or endcap).
  SbVec3f closesttubedir(cameraDirection);
  SbVec3f closesttubeupvec(cameraUpDirection);
  float smallestcosangle(1.1);
 
  //Barrel/Endcap MDT. Expand two levels and then check the individual tubes.
  chamberhandle->initialiseChildren();
  VolumeHandle::VolumeHandleListItr itch(chamberhandle->childrenBegin()), itchE(chamberhandle->childrenEnd());
  for (;itch!=itchE;++itch) {
    //Any daughter with the name "Ded..." should be ignored
    std::string name1 = (*itch)->getNameStdString();
    if (name1.size()>2&&name1[0]=='D'&&name1[1]=='e'&&name1[2]=='d')
      continue;
 
    (*itch)->initialiseChildren();
    VolumeHandle::VolumeHandleListItr itch2((*itch)->childrenBegin()), itch2E((*itch)->childrenEnd());
    //Various variables needed to deal with each tube:
    const SbVec3f unitz(0.0f,0.0f,1.0f);
    const SbVec3f unity(0.0f,1.0f,0.0f);
    SbVec3f tubeglob;
    SbVec3f translation, scale;
    SbRotation rotation, scalerotation;
 
    for (;itch2!=itch2E;++itch2) {
      if ((*itch2)->getNameStdString()=="MDTDriftWall") {
    //OK, we got the handle of a tube (wall). Lets find its direction!
    //->We assume that the tube, in its local coordinate system, is aligned with the z axis.
    //Get global rotation of tube:
    (*itch2)->getGlobalTransformToVolume().getTransform(translation,rotation,scale,scalerotation);
    rotation.multVec (unitz, tubeglob);
    if (tubeglob.dot(cameraDirection)<smallestcosangle) {
      smallestcosangle = tubeglob.dot(cameraDirection);
      closesttubedir = tubeglob;
      rotation.multVec(unity, closesttubeupvec);
    }
    if (tubeglob.dot(-cameraDirection)<smallestcosangle) {
      smallestcosangle = tubeglob.dot(-cameraDirection);
      closesttubedir = -tubeglob;
      rotation.multVec(unity, closesttubeupvec);
    }
      }
    }
  }
  return std::pair<SbVec3f,SbVec3f>(closesttubedir,closesttubeupvec);
}

iconifyVisibleVolumesRecursively()

void VP1GeometrySystem::Imp::iconifyVisibleVolumesRecursively	(	VolumeHandle *	handle,
		const QRegExp &	selregexp,
		bool	bymatname )

Definition at line 2127 of file VP1GeometrySystem.cxx.

{
  if (handle->state()==VP1GeoFlags::ZAPPED)
    return;
  
  if (handle->state()==VP1GeoFlags::CONTRACTED) {
    //See if we match -- if so, update state.
    if( selregexp.exactMatch(bymatname?QString(handle->geoMaterial()->getName().c_str()):handle->getName())) {
      handle->setState(VP1GeoFlags::ZAPPED);
    }
    return;
  }
  //Must be expanded: Let us call on any (initialised) children instead.
  if (handle->nChildren()==0||!handle->childrenAreInitialised())
    return;
  VolumeHandle::VolumeHandleListItr it(handle->childrenBegin()), itE(handle->childrenEnd());
  for(;it!=itE;++it)
    iconifyVisibleVolumesRecursively(*it,selregexp,bymatname);
}

inclusiveMass()

double VP1GeometrySystem::Imp::inclusiveMass ( const PVConstLink & pv )

static

Definition at line 1283 of file VP1GeometrySystem.cxx.

                                                                {
 
  const GeoLogVol*        lv       = pv->getLogVol();
  const GeoMaterial      *material = lv->getMaterial();
  double density = material->getDensity();
 
  double mass = exclusiveMass(pv);
 
  GeoVolumeCursor av(pv);
  while (!av.atEnd()) {
    mass += inclusiveMass(av.getVolume());
    mass -= volume(av.getVolume())*density;
    av.next();
  }
 
  return mass;
}

showITkPixelModules()

void VP1GeometrySystem::Imp::showITkPixelModules	(	VolumeHandle *	h,
		bool	brl,
		bool	ecA,
		bool	ecC )

Definition at line 2717 of file VP1GeometrySystem.cxx.

{
  VP1Msg::messageDebug("VP1GeometrySystem::Imp::showITkPixelModules()");
  h->initialiseChildren();
  VolumeHandle::VolumeHandleListItr it(h->childrenBegin()),itE(h->childrenEnd());
  // std::cout << "Processing volume with name = " << h->getName().toStdString() << " and " << h->nChildren() << " children..." << std::endl;
  for (;it!=itE;++it) {
    expandAllChildren(*it, true, brl, ecA, ecC);
  }
}

showITkStripModules()

void VP1GeometrySystem::Imp::showITkStripModules	(	VolumeHandle *	h,
		bool	brl,
		bool	ecA,
		bool	ecC )

Definition at line 2729 of file VP1GeometrySystem.cxx.

{
  VP1Msg::messageDebug("VP1GeometrySystem::Imp::showITkStripModules()");
  h->initialiseChildren();
  VolumeHandle::VolumeHandleListItr it(h->childrenBegin()),itE(h->childrenEnd());
  // std::cout << "Processing volume with name = " << h->getName().toStdString() << " and " << h->nChildren() << " children..." << std::endl;
  for (;it!=itE;++it) {
    if (brl and (*it)->hasName("ITkStrip_Barrel")) {
      expandAllChildren(*it, false, brl, ecA, ecC);
    }
    else if (ecA and (*it)->hasName("ITkStrip_ForwardPlus")) {
      expandAllChildren(*it, false, brl, ecA, ecC);
    }
    else if (ecC and (*it)->hasName("ITkStrip_ForwardMinus")) {
      expandAllChildren(*it, false, brl, ecA, ecC);
    } else
      (*it)->setState(VP1GeoFlags::ZAPPED);
  }
}

showPixelModules()

void VP1GeometrySystem::Imp::showPixelModules

(

VolumeHandle *

h

)

Definition at line 2569 of file VP1GeometrySystem.cxx.

{
    VP1Msg::messageDebug("VP1GeometrySystem::Imp::showPixelModules()");
  h->initialiseChildren();
  VolumeHandle::VolumeHandleListItr it(h->childrenBegin()),itE(h->childrenEnd());
  for (;it!=itE;++it) {
    if ((*it)->hasName("moduleLog")) {
      (*it)->setState(VP1GeoFlags::ZAPPED);
      (*it)->contractDaughtersRecursively();
      (*it)->initialiseChildren();
      VolumeHandle::VolumeHandleListItr itMod((*it)->childrenBegin()),itModE((*it)->childrenEnd());
      for (;itMod!=itModE;++itMod) {
    if ((*itMod)->getName().startsWith("si"))
      (*itMod)->setState(VP1GeoFlags::CONTRACTED);
    else
      (*itMod)->setState(VP1GeoFlags::ZAPPED);
      }
      (*it)->setState(VP1GeoFlags::EXPANDED);
      continue;
    }
    if ((*it)->hasName("pigtailLog")||(*it)->hasName("omegaLog")) {
      (*it)->setState(VP1GeoFlags::ZAPPED);
      (*it)->contractDaughtersRecursively();
      continue;
    }
    if ((*it)->nChildren()<1) {
      (*it)->setState(VP1GeoFlags::ZAPPED);
      continue;
    }
    (*it)->setState(VP1GeoFlags::ZAPPED);
    showPixelModules(*it);
    (*it)->setState(VP1GeoFlags::EXPANDED);
  }
}

showSCTBarrelModules()

void VP1GeometrySystem::Imp::showSCTBarrelModules

(

VolumeHandle *

h

)

Definition at line 2750 of file VP1GeometrySystem.cxx.

{
    VP1Msg::messageDebug("VP1GeometrySystem::Imp::showSCTBarrelModules()");
  h->initialiseChildren();
  VolumeHandle::VolumeHandleListItr it(h->childrenBegin()),itE(h->childrenEnd());
  for (;it!=itE;++it) {
    if ((*it)->getName().startsWith("Layer")) {
      (*it)->setState(VP1GeoFlags::ZAPPED);
      (*it)->initialiseChildren();
      VolumeHandle::VolumeHandleListItr itLay((*it)->childrenBegin()),itLayE((*it)->childrenEnd());
      for (;itLay!=itLayE;++itLay) {
    if ((*itLay)->getName().endsWith("Active")&&(*itLay)->getName().startsWith("Layer")) {
      (*itLay)->setState(VP1GeoFlags::ZAPPED);
      (*itLay)->initialiseChildren();
      VolumeHandle::VolumeHandleListItr itActLay((*itLay)->childrenBegin()),itActLayE((*itLay)->childrenEnd());
      for (;itActLay!=itActLayE;++itActLay) {
        if ((*itActLay)->getName().startsWith("Ski")) {
          (*itActLay)->setState(VP1GeoFlags::ZAPPED);
          (*itActLay)->initialiseChildren();
          VolumeHandle::VolumeHandleListItr itSki((*itActLay)->childrenBegin()),itSkiE((*itActLay)->childrenEnd());
          for (;itSki!=itSkiE;++itSki) {
        //Ends with "Envelope": open, otherwise zap. Of those, zap all without "Sensor" in the name.
        if ((*itSki)->hasName("Module")) {
          //Open and zap those without "Sensor" in the name:
          (*itSki)->setState(VP1GeoFlags::ZAPPED);
          (*itSki)->initialiseChildren();
          VolumeHandle::VolumeHandleListItr itMod((*itSki)->childrenBegin()),itModE((*itSki)->childrenEnd());
          for (;itMod!=itModE;++itMod) {
            if ((*itMod)->getName().contains("Envelope")) {
              (*itMod)->setState(VP1GeoFlags::ZAPPED);
              (*itMod)->initialiseChildren();
              VolumeHandle::VolumeHandleListItr itEnv((*itMod)->childrenBegin()),itEnvE((*itMod)->childrenEnd());
              for(;itEnv!=itEnvE;++itEnv) {
            if ((*itEnv)->getName().contains("Sensor"))
              (*itEnv)->reset();
            else
              (*itEnv)->setState(VP1GeoFlags::ZAPPED);
              }
              (*itMod)->setState(VP1GeoFlags::EXPANDED);
            } else {
              (*itMod)->setState(VP1GeoFlags::ZAPPED);
            }
          }
          (*itSki)->setState(VP1GeoFlags::EXPANDED);
        } else {
          (*itSki)->setState(VP1GeoFlags::ZAPPED);
        }//end if-elsi "Envelope"
          }//endfor itSki
          (*itActLay)->setState(VP1GeoFlags::EXPANDED);
        } else {
          (*itActLay)->setState(VP1GeoFlags::ZAPPED);
        }//end if-else "Ski"
      }
      (*itLay)->setState(VP1GeoFlags::EXPANDED);
    } else {
      (*itLay)->setState(VP1GeoFlags::ZAPPED);
      (*itLay)->contractDaughtersRecursively();
    }
      }
      (*it)->setState(VP1GeoFlags::EXPANDED);
    } else {
      (*it)->setState(VP1GeoFlags::ZAPPED);
      (*it)->contractDaughtersRecursively();
    }
  }
}

showSCTEndcapModules()

void VP1GeometrySystem::Imp::showSCTEndcapModules

(

VolumeHandle *

h

)

Definition at line 2818 of file VP1GeometrySystem.cxx.

{
    VP1Msg::messageDebug("VP1GeometrySystem::Imp::showSCTEndcapModules()");
  h->initialiseChildren();
  VolumeHandle::VolumeHandleListItr it(h->childrenBegin()),itE(h->childrenEnd());
  for (;it!=itE;++it) {
    if ((*it)->getName().startsWith("Wheel")) {
      (*it)->setState(VP1GeoFlags::ZAPPED);
      (*it)->initialiseChildren();
      VolumeHandle::VolumeHandleListItr itWhl((*it)->childrenBegin()),itWhlE((*it)->childrenEnd());
      for (;itWhl!=itWhlE;++itWhl) {
    if ((*itWhl)->getName().startsWith("Ring")) {
      (*itWhl)->setState(VP1GeoFlags::ZAPPED);
      (*itWhl)->initialiseChildren();
      VolumeHandle::VolumeHandleListItr itRng((*itWhl)->childrenBegin()),itRngE((*itWhl)->childrenEnd());
      for (;itRng!=itRngE;++itRng) {
        if ((*itRng)->getName().startsWith("FwdModule")) {
          (*itRng)->setState(VP1GeoFlags::ZAPPED);
          (*itRng)->initialiseChildren();
          VolumeHandle::VolumeHandleListItr itMod((*itRng)->childrenBegin()),itModE((*itRng)->childrenEnd());
          for(;itMod!=itModE;++itMod) {
        if ((*itMod)->getName().startsWith("ECSensor")) {
          (*itMod)->reset();
        } else {
          (*itMod)->setState(VP1GeoFlags::ZAPPED);
        }
          }
          (*itRng)->setState(VP1GeoFlags::EXPANDED);
        } else {
          (*itRng)->setState(VP1GeoFlags::ZAPPED);
        }
      }
      (*itWhl)->setState(VP1GeoFlags::EXPANDED);
    } else {
      (*itWhl)->setState(VP1GeoFlags::ZAPPED);
      (*itWhl)->contractDaughtersRecursively();
    }
      }
      (*it)->setState(VP1GeoFlags::EXPANDED);
     } else {
       (*it)->setState(VP1GeoFlags::ZAPPED);
       (*it)->contractDaughtersRecursively();
    }
  }
}

stationInfo()

QStringList VP1GeometrySystem::Imp::stationInfo

(

const MuonGM::MuonStation *

station

)

Definition at line 2244 of file VP1GeometrySystem.cxx.

{
  QStringList l;
  if (!station) {
    l <<"Null ptr!";
    return l;
  }
  l << "Name: "+str(station->getStationName().c_str());
  l << "(Eta,Phi) index: ("+str(station->getEtaIndex())+", "+str(station->getPhiIndex())+")";
  return l;
}

updatePV2MuonStationMap()

void VP1GeometrySystem::Imp::updatePV2MuonStationMap

(

const MuonGM::MuonReadoutElement *

elem

)

Definition at line 2186 of file VP1GeometrySystem.cxx.

{
  if (!elem)
    return;
  GeoPVConstLink pvlink = elem->getMaterialGeom()->getParent();
  const MuonGM::MuonStation * station = elem->parentMuonStation();
  if (!station) {
    theclass->message("WARNING: Ignored null station pointer");
    return;
  }
  pv2MuonStation[pvlink] = station;
}

updateTouchedMuonChamber()

void VP1GeometrySystem::Imp::updateTouchedMuonChamber

(

VolumeHandle *

chamberhandle

)

Definition at line 1632 of file VP1GeometrySystem.cxx.

{
  std::string stationname = chamberhandle->getNameStdString();
  if (stationname.empty()) {
    theclass->message("Warning: Asked to handle muon chamber (station) with empty name!");
    return;
  }
  //NB: For efficiency we make sure that mothers are ZAPPED while
  //changing state of their children.
  
  //options:
  
  VP1GeoFlags::MuonChamberAdaptionStyleFlags f(controller->muonChamberAdaptionStyle());
  bool option_openmdtchambers = f & VP1GeoFlags::OpenMDTChambers;
  bool option_hidetubes = f & VP1GeoFlags::HideMDTTubes;
  bool option_hiderpcvolumes = f & VP1GeoFlags::HideRPCVolumes;
  bool option_opencscchambers = f & VP1GeoFlags::OpenCSCChambers;
  bool option_opentgcchambers = f & VP1GeoFlags::OpenTGCChambers;
  
  char firstletter = stationname[0];
  std::string name1,name2;
  if (firstletter=='E' || firstletter =='B') {
    //Barrel/Endcap MDT.
    // If we are to open it, we expand two levels.
    // -> and possibly zap the tubes/rpc volumes also according to options.
    if (option_openmdtchambers) {
      chamberhandle->setState(VP1GeoFlags::ZAPPED);
      chamberhandle->contractDaughtersRecursively();
      chamberhandle->initialiseChildren();
      VolumeHandle::VolumeHandleListItr itch(chamberhandle->childrenBegin()), itchE(chamberhandle->childrenEnd());
      for (;itch!=itchE;++itch) {
        //Any daughter with the name "Ded..." should be zapped,
        //otherwise we loop over the children to zap tubes/rpc vols.
        (*itch)->setState(VP1GeoFlags::ZAPPED);
        name1 = (*itch)->getNameStdString();
        if (name1.size()>2&&name1[0]=='D'&&name1[1]=='e'&&name1[2]=='d')
          continue;
        
        (*itch)->initialiseChildren();
        VolumeHandle::VolumeHandleListItr itch2((*itch)->childrenBegin()), itch2E((*itch)->childrenEnd());
        for (;itch2!=itch2E;++itch2) {
          //Any of these daughters with the name
          //"MDTDriftWall"/"Rpc..."/"RPC..."/"Ded..." should be
          //zapped (according to options). Others should be contracted.
          name2 = (*itch2)->getNameStdString();
          bool zap = false;
          if (option_hidetubes&&name2=="MDTDriftWall") {
            zap = true;
          } else if (name2.size()>2&&name2[0]=='R'&&((name2[1]=='p'&&name2[2]=='c')||(name2[1]=='P'&&name2[2]=='C'))) {
            zap = (option_hiderpcvolumes||name2!="Rpclayer");
          } else if (name2.size()>2&&name2[0]=='D'&&name2[1]=='e'&&name2[2]=='d') {
            zap = true;
          }
          (*itch2)->setState(zap?VP1GeoFlags::ZAPPED:VP1GeoFlags::CONTRACTED);
        }
        (*itch)->setState(VP1GeoFlags::EXPANDED);
      }
      chamberhandle->setState(VP1GeoFlags::EXPANDED);
    } else {
      chamberhandle->reset();
    }
  } else {
    if (firstletter=='C') {
      //CSC: We either contract completely or expand once + zap "CscArCO2" + zap spacers
      chamberhandle->setState(VP1GeoFlags::ZAPPED);
      chamberhandle->contractDaughtersRecursively();//To put into default state
      if (option_opencscchambers) {
        //We must zap spacers, and otherwise expand down three levels and zap all "CscArCO2":
        chamberhandle->initialiseChildren();
        VolumeHandle::VolumeHandleListItr itch(chamberhandle->childrenBegin()), itchE(chamberhandle->childrenEnd());
        for (;itch!=itchE;++itch) {
          if ((*itch)->hasName("CSCspacer")) {
            (*itch)->setState(VP1GeoFlags::ZAPPED);
            continue;
          }
          if ((*itch)->nChildren()<1)
            continue;
          (*itch)->initialiseChildren();
          VolumeHandle::VolumeHandleListItr itch2((*itch)->childrenBegin()), itch2E((*itch)->childrenEnd());
          for (;itch2!=itch2E;++itch2) {
            if ((*itch2)->nChildren()<1)
              continue;
            (*itch2)->initialiseChildren();
            VolumeHandle::VolumeHandleListItr itch3((*itch2)->childrenBegin()), itch3E((*itch2)->childrenEnd());
            for (;itch3!=itch3E;++itch3) {
              if ((*itch3)->getNameStdString()=="CscArCO2")
                (*itch3)->setState(VP1GeoFlags::ZAPPED);
            }
            (*itch2)->setState(VP1GeoFlags::EXPANDED);
          }
          (*itch)->setState(VP1GeoFlags::EXPANDED);
        }
        chamberhandle->setState(VP1GeoFlags::EXPANDED);
      } else {
        chamberhandle->setState(VP1GeoFlags::CONTRACTED);
      }
    } else {
      //TGC: If 'open' we expand two levels and zap all gas volumes.
      chamberhandle->setState(VP1GeoFlags::ZAPPED);
      chamberhandle->contractDaughtersRecursively();//To put into default state
      if (option_opentgcchambers) {
        //Expand once more and then zap daughters called "muo::TGCGas"
        chamberhandle->initialiseChildren();
        VolumeHandle::VolumeHandleListItr itch(chamberhandle->childrenBegin()), itchE(chamberhandle->childrenEnd());
        for (;itch!=itchE;++itch) {
          if ((*itch)->nChildren()<1)
            continue;
          (*itch)->initialiseChildren();
          VolumeHandle::VolumeHandleListItr itch2((*itch)->childrenBegin()), itch2E((*itch)->childrenEnd());
          for (;itch2!=itch2E;++itch2) {
            if ((*itch2)->getNameStdString()=="muo::TGCGas")
              (*itch2)->setState(VP1GeoFlags::ZAPPED);
          }
          (*itch)->setState(VP1GeoFlags::EXPANDED);
        }
        chamberhandle->setState(VP1GeoFlags::EXPANDED);
      } else {
        chamberhandle->setState(VP1GeoFlags::CONTRACTED);
      }
    }
  }
  chamberhandle->setMuonChamberDirty(false);
}

volume()

double VP1GeometrySystem::Imp::volume ( const PVConstLink & pv )

static

Definition at line 1275 of file VP1GeometrySystem.cxx.

                                                         {
  const GeoLogVol        * lv       = pv->getLogVol();
  const GeoShape         *shape    = lv->getShape();
  return shape->volume();
}

Member Data Documentation

chamberT0s

QList<const std::map<GeoPVConstLink, float>*> VP1GeometrySystem::Imp::chamberT0s

Definition at line 300 of file VP1GeometrySystem.cxx.

controller

GeoSysController* VP1GeometrySystem::Imp::controller

Definition at line 245 of file VP1GeometrySystem.cxx.

detVisAttributes

DetVisAttributes* VP1GeometrySystem::Imp::detVisAttributes

Definition at line 234 of file VP1GeometrySystem.cxx.

initialSubSystemsTurnedOn

VP1GeoFlags::SubSystemFlags VP1GeometrySystem::Imp::initialSubSystemsTurnedOn

Definition at line 243 of file VP1GeometrySystem.cxx.

kbEvent

const SoKeyboardEvent* VP1GeometrySystem::Imp::kbEvent

Definition at line 256 of file VP1GeometrySystem.cxx.

last_appropriatemdtprojections

int VP1GeometrySystem::Imp::last_appropriatemdtprojections

Definition at line 269 of file VP1GeometrySystem.cxx.

m_textSep

SoSeparator* VP1GeometrySystem::Imp::m_textSep

Separator used to hold all visible labels.

Definition at line 275 of file VP1GeometrySystem.cxx.

matVisAttributes

MatVisAttributes* VP1GeometrySystem::Imp::matVisAttributes

Definition at line 235 of file VP1GeometrySystem.cxx.

muonchambers_pv2handles

std::map<PVConstLink,VolumeHandle*> VP1GeometrySystem::Imp::muonchambers_pv2handles

Definition at line 259 of file VP1GeometrySystem.cxx.

phisectormanager

PhiSectorManager* VP1GeometrySystem::Imp::phisectormanager

Definition at line 246 of file VP1GeometrySystem.cxx.

previousAlignedChamberHandle

VolumeHandle* VP1GeometrySystem::Imp::previousAlignedChamberHandle

Definition at line 266 of file VP1GeometrySystem.cxx.

pv2MuonStation

std::map<GeoPVConstLink,const MuonGM::MuonStation*> VP1GeometrySystem::Imp::pv2MuonStation

Definition at line 278 of file VP1GeometrySystem.cxx.

pv2MuonStationInit

bool VP1GeometrySystem::Imp::pv2MuonStationInit

Definition at line 279 of file VP1GeometrySystem.cxx.

restoredTopvolstates

QMap<quint32,QByteArray> VP1GeometrySystem::Imp::restoredTopvolstates

Definition at line 292 of file VP1GeometrySystem.cxx.

sceneroot

SoSeparator* VP1GeometrySystem::Imp::sceneroot

Definition at line 113 of file VP1GeometrySystem.cxx.

sender2ChamberList

std::map<QObject*,std::set<GeoPVConstLink> > VP1GeometrySystem::Imp::sender2ChamberList

Definition at line 261 of file VP1GeometrySystem.cxx.

sonodesep2volhandle

std::map<SoSeparator*,VolumeHandle*> VP1GeometrySystem::Imp::sonodesep2volhandle

Definition at line 115 of file VP1GeometrySystem.cxx.

subsysInfoList

QList<SubSystemInfo*> VP1GeometrySystem::Imp::subsysInfoList

Definition at line 226 of file VP1GeometrySystem.cxx.

theclass

VP1GeometrySystem* VP1GeometrySystem::Imp::theclass

Definition at line 112 of file VP1GeometrySystem.cxx.

volumetreemodel

VolumeTreeModel* VP1GeometrySystem::Imp::volumetreemodel

Definition at line 247 of file VP1GeometrySystem.cxx.

volVisAttributes

VolVisAttributes* VP1GeometrySystem::Imp::volVisAttributes

Definition at line 236 of file VP1GeometrySystem.cxx.

---

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

• VP1GeometrySystem.cxx