FWOverlapTableManager Class Reference

#include <Fireworks/Core/interface/FWOverlapTableManager.h>

Inheritance diagram for FWOverlapTableManager:

Classes
class	QuadId

Public Types
enum	OverlapBits { kVisMarker = BIT(5), kOverlap = BIT(6), kOverlapChild = BIT(7) }
Public Types inherited from FWGeometryTableManagerBase
enum	Bits {   kExpanded = BIT(0), kVisNodeSelf = BIT(1), kVisNodeChld = BIT(2), kHighlighted = BIT(3),   kSelected = BIT(4) }
typedef Entries_v::iterator	Entries_i
typedef std::vector< NodeInfo >	Entries_v

Public Member Functions
FWTableCellRendererBase *	cellRenderer (int iSortedRowNumber, int iCol) const override
	FWOverlapTableManager (FWOverlapTableView *)
void	getOverlapTitles (int, TString &) const
std::vector< std::string >	getTitles () const override
	returns the title names for each column More...
void	importOverlaps (std::string path, double precision)
int	numberOfColumns () const override
	Number of columns in the table. More...
void	printOverlaps (int) const
void	recalculateVisibility () override
virtual void	recalculateVisibilityNodeRec (int)
void	setDaughtersSelfVisibility (int i, bool v) override
	~FWOverlapTableManager () override
Public Member Functions inherited from FWGeometryTableManagerBase
virtual void	applyColorTranspToDaughters (int selectedIdx, bool recurse)
void	applyTransparencyFromEditor ()
void	cancelEditor (bool)
bool	cellDataIsSortable () const override
virtual const char *	cellName (const NodeInfo &) const
bool	firstColumnClicked (int row, int xPos)
	FWGeometryTableManagerBase ()
	FWGeometryTableManagerBase (const FWGeometryTableManagerBase &)
int	getLevelOffset () const
void	getNodeMatrix (const NodeInfo &nodeInfo, TGeoHMatrix &mat) const
void	getNodePath (int, std::string &) const
NodeInfo *	getSelected ()
virtual bool	getVisibility (const NodeInfo &nodeInfo) const
virtual bool	getVisibilityChld (const NodeInfo &nodeInfo) const
void	implSort (int, bool) override
	Called by 'sort' method to actually handle the sorting of the rows. Arguments are the same as 'sort'. More...
bool	isNodeRendered (int idx, int top_node_idx) const
void	loadGeometry (TGeoNode *, TObjArray *)
bool	nodeImported (int idx) const
int	numberOfRows () const override
	Number of rows in the table. More...
const FWGeometryTableManagerBase &	operator= (const FWGeometryTableManagerBase &)
void	redrawTable (bool setExpand=false)
Entries_v &	refEntries ()
NodeInfo &	refEntry (int i)
std::vector< int >	rowToIndex ()
void	setBackgroundToWhite (bool)
void	setCellValueEditor (TGTextEntry *editor)
void	setDaughtersSelfVisibility (bool)
void	setLevelOffset (int x)
virtual void	setVisibility (NodeInfo &, bool)
virtual void	setVisibilityChld (NodeInfo &, bool)
void	showEditor (int)
virtual const std::string	title () const
int	unsortedRowNumber (int unsorted) const override
	when passed the index to the sorted order of the rows it returns the original row number from the underlying data More...
	~FWGeometryTableManagerBase () override
Public Member Functions inherited from FWTableManagerBase
virtual void	buttonPressedInRowHeader (Int_t row, Event_t *event, Int_t relX, Int_t relY)
	Called if mouse button pressed in Row Header, defaults is to do nothing. More...
virtual void	buttonReleasedInRowHeader (Int_t row, Event_t *event, Int_t relX, Int_t relY)
virtual unsigned int	cellHeight () const
	require all cells to be the same height More...
	ClassDefOverride (FWTableManagerBase, 0)
void	dataChanged ()
	Classes which inherit from FWTableManagerBase must call this when their underlying data changes. More...
	FWTableManagerBase ()
virtual bool	hasLabelHeaders () const
virtual bool	hasRowHeaders () const
	Returns 'true' if this table has row headers. Defaults return value is false. More...
virtual std::vector< unsigned int >	maxWidthForColumns () const
	for each column in the table this returns the present maximum width for that column More...
virtual FWTableCellRendererBase *	rowHeader (int iSortedRowNumber) const
	Returns the renderer for the row header for the sorted row number iSortedRowNumber. More...
void	sort (int iCol, bool iSortOrder)
	Call to have table sorted on values in column iCol with the sort order being descending if iSortOrder is 'true'. More...
int	sortColumn (void)
	The current sort column. More...
bool	sortOrder (void)
	The current sort order for the table. More...
void	visualPropertiesChanged ()
	Classes which inherit from FWTableManagerBase must call this when how the data is shown (e.g. color) changes. More...
	~FWTableManagerBase () override

Protected Member Functions
bool	nodeIsParent (const NodeInfo &) const override

Private Member Functions
void	addOverlapEntry (TGeoOverlap *, int, int, TGeoHMatrix *)
	FWOverlapTableManager (const FWOverlapTableManager &)=delete
const FWOverlapTableManager &	operator= (const FWOverlapTableManager &)=delete

Private Attributes
FWOverlapTableView *	m_browser
std::multimap< int, int >	m_mapNodeOverlaps

Additional Inherited Members
Static Public Member Functions inherited from FWGeometryTableManagerBase
static void	getNNodesTotal (TGeoNode *geoNode, int &off)
Public Attributes inherited from FWGeometryTableManagerBase
ColorBoxRenderer	m_colorBoxRenderer
TGTextEntry *	m_editor
int	m_editTransparencyIdx
Entries_v	m_entries
TGGC *	m_highlightContext
int	m_highlightIdx
int	m_levelOffset
FWTextTreeCellRenderer	m_renderer
std::vector< int >	m_row_to_index

Detailed Description

Description: [one line class summary]

Usage: <usage>

Definition at line 31 of file FWOverlapTableManager.h.

Member Enumeration Documentation

enum FWOverlapTableManager::OverlapBits

Enumerator
kVisMarker
kOverlap
kOverlapChild

Definition at line 33 of file FWOverlapTableManager.h.

{ kVisMarker = BIT(5), kOverlap = BIT(6), kOverlapChild = BIT(7) };

Constructor & Destructor Documentation

FWOverlapTableManager::FWOverlapTableManager

(

FWOverlapTableView *

v

)

Definition at line 40 of file FWOverlapTableManager.cc.

Referenced by numberOfColumns().

: FWGeometryTableManagerBase(), m_browser(v) {}

FWOverlapTableManager::~FWOverlapTableManager ( )

override

Definition at line 42 of file FWOverlapTableManager.cc.

{}

FWOverlapTableManager::FWOverlapTableManager ( const FWOverlapTableManager &  )

privatedelete

Member Function Documentation

void FWOverlapTableManager::addOverlapEntry ( TGeoOverlap *  , int  , int  , TGeoHMatrix *    )

private

Definition at line 194 of file FWOverlapTableManager.cc.

References Abs(), PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, personalPlayback::fp, fwLog, FWGeometryTableViewBase::getMarker(), FWGeometryTableManagerBase::getNNodesTotal(), FWGeometryTableViewBase::getTopNodeIdx(), mps_fire::i, dqmiolumiharvest::j, fwlog::kInfo, kOverlap, kOverlapChild, FWGeometryTableManagerBase::kVisNodeChld, FWGeometryTableManagerBase::kVisNodeSelf, m_browser, FWGeometryTableManagerBase::m_entries, m_mapNodeOverlaps, FWOverlapTableManager::QuadId::m_nodes, and dqmiodumpmetadata::n.

Referenced by importOverlaps(), and numberOfColumns().

                                                                                                               {
  // printf("add %s \n", ovl->GetTitle());
  // get doughter indices of overlaps
  /* 
      TPMERegexp re(" ", "o");
      re.Split(TString(ovl->GetTitle()));
      printf("add title %s \n", ovl->GetTitle());
   */
  int pcnt = parentIdx + 1;
  int dOff = 0;
  TGeoNode* mothern = m_entries[parentIdx].m_node;

  QuadId* quid = new QuadId(ovl, parentIdx);

  for (int i = 0; i < mothern->GetNdaughters(); ++i) {
    TGeoNode* n = mothern->GetDaughter(i);

    int cnt = pcnt + i + dOff;

    if (ovl->IsOverlap()) {
      if (n->GetVolume() == ovl->GetFirstVolume() && (*(ovl->GetFirstMatrix()) == *(n->GetMatrix()))) {
        // std::string x = re[0].Data();
        //if (x.find(n->GetName()) == std::string::npos) printf("ERROT \n");

        m_entries[cnt].setBit(kOverlap);
        m_entries[cnt].setBit(kVisNodeSelf);
        m_mapNodeOverlaps.insert(std::pair<int, int>(cnt, ovlIdx));
        int nno;
        n->GetOverlaps(nno);
        nno |= BIT(1);
        n->SetOverlaps(nullptr, nno);
        quid->m_nodes.push_back(cnt);
      }
    }

    if (n->GetVolume() == ovl->GetSecondVolume() && (*(ovl->GetSecondMatrix()) == *(n->GetMatrix()))) {
      //printf("-----------------------------------------------\n");
      // std::string x = re[2].Data();
      // if (x.find(n->GetName()) == std::string::npos) printf("ERROT \n");

      m_entries[cnt].setBit(kOverlap);
      m_entries[cnt].setBit(kVisNodeSelf);

      m_mapNodeOverlaps.insert(std::pair<int, int>(cnt, ovlIdx));
      int nno;
      n->GetOverlaps(nno);
      nno |= (ovl->IsOverlap() ? BIT(1) : BIT(2));
      n->SetOverlaps(nullptr, nno);

      quid->m_nodes.push_back(cnt);
    }

    FWGeometryTableManagerBase::getNNodesTotal(n, dOff);
  }

  TPolyMarker3D* pm = ovl->GetPolyMarker();
  for (int j = 0; j < pm->GetN(); ++j) {
    double pl[3];
    double pg[3];
    pm->GetPoint(j, pl[0], pl[1], pl[2]);
    motherm->LocalToMaster(pl, pg);

    float dx = TMath::Abs(ovl->GetOverlap());
    if (dx > 1e5) {
      fwLog(fwlog::kInfo) << Form("WARNING [%s], overlap size = %.1f \n", ovl->GetTitle(), dx);
      dx = 10;
    }
    float dy = dx, dz = 0;
    float fp[3];
    fp[0] = pg[0];
    fp[1] = pg[1];
    fp[2] = pg[2];
    float bb[12] = {fp[0] + dx,
                    fp[1] - dy,
                    fp[2] - dz,
                    fp[0] + dx,
                    fp[1] + dy,
                    fp[2] + dz,
                    fp[0] - dx,
                    fp[1] + dy,
                    fp[2] + dz,
                    fp[0] - dx,
                    fp[1] - dy,
                    fp[2] - dz};
    m_browser->getMarker()->AddQuad(&bb[0]);
    m_browser->getMarker()->QuadId(quid);
  }

  int aIdx = parentIdx;
  int aLev = m_entries[aIdx].m_level;
  int topNodeIdx = m_browser->getTopNodeIdx();

  while (aIdx > topNodeIdx) {
    aIdx--;
    if (m_entries[aIdx].m_level < aLev) {
      m_entries[aIdx].setBit(kOverlapChild);
      m_entries[aIdx].setBit(kVisNodeChld);
      //  printf("stamp %s \n", m_entries[aIdx].name());
      aLev--;
    }
  }
}

FWTableCellRendererBase * FWOverlapTableManager::cellRenderer ( int  iSortedRowNumber, int  iCol  ) const

overridevirtual

Returns the particular renderer used to handle the requested cell. Arguments: iSortedRowNumber: the row number from the present sort (i.e. the cell number of the view) iCol: the column number of the cell. The returned value must be used immediately and not held onto since the same Renderer can be used for subsequent calls

Implements FWTableManagerBase.

Definition at line 384 of file FWOverlapTableManager.cc.

References beam_dqm_sourceclient-live_cfg::cerr, data, FWGeometryTableViewManager::getGeoMangeur(), FWGeometryTableViewBase::getTopNodeIdx(), FWTextTreeCellRenderer::iconWidth(), FWGeometryTableManagerBase::kExpanded, FWGeometryTableManagerBase::kHighlighted, kOverlap, FWGeometryTableManagerBase::kSelected, FWGeometryTableManagerBase::kVisNodeChld, FWGeometryTableManagerBase::kVisNodeSelf, personalPlayback::level, FWOverlapTableView::listAllNodes(), m_browser, FWGeometryTableManagerBase::NodeInfo::m_color, FWGeometryTableManagerBase::m_colorBoxRenderer, FWGeometryTableManagerBase::m_editTransparencyIdx, FWGeometryTableManagerBase::m_entries, FWGeometryTableManagerBase::m_highlightContext, FWGeometryTableManagerBase::NodeInfo::m_level, FWGeometryTableManagerBase::m_levelOffset, m_mapNodeOverlaps, FWGeometryTableManagerBase::NodeInfo::m_node, FWGeometryTableManagerBase::m_renderer, FWGeometryTableManagerBase::m_row_to_index, FWGeometryTableManagerBase::NodeInfo::m_transparency, FWGeometryTableManagerBase::NodeInfo::name(), Vispa.Plugins.EdmBrowser.EdmDataAccessor::ne(), nodeIsParent(), FWTextTableCellRenderer::setData(), FWGeometryTableManagerBase::ColorBoxRenderer::setData(), FWTextTreeCellRenderer::setIndentation(), FWTextTreeCellRenderer::setIsOpen(), FWTextTreeCellRenderer::setIsParent(), FWTextTreeCellRenderer::showEditor(), AlCaHLTBitMon_QueryRunRegistry::string, FWGeometryTableManagerBase::NodeInfo::testBit(), and x.

Referenced by numberOfColumns().

                                                                                                 {
  if (m_row_to_index.empty())
    return &m_renderer;

  int unsortedRow = m_row_to_index[iSortedRowNumber];

  if (unsortedRow < 0)
    printf("!!!!!!!!!!!!!!!! error %d %d \n", unsortedRow, iSortedRowNumber);

  // editor state
  //
  m_renderer.showEditor(unsortedRow == m_editTransparencyIdx && iCol == 2);

  // selection state
  //
  const NodeInfo& data = m_entries[unsortedRow];

  bool isSelected = data.testBit(kHighlighted) || data.testBit(kSelected);
  if (m_browser->listAllNodes())
    isSelected = isSelected || data.testBit(kOverlap);

  if (data.testBit(kSelected)) {
    m_highlightContext->SetBackground(0xc86464);
  } else if (data.testBit(kHighlighted)) {
    m_highlightContext->SetBackground(0x6464c8);
  } else if (m_browser->listAllNodes() && data.testBit(kOverlap)) {
    m_highlightContext->SetBackground(0xdddddd);
  }

  // set column content
  //
  if (iCol == 0) {
    if (unsortedRow == m_browser->getTopNodeIdx()) {
      int no = 0, ne = 0;
      TEveGeoManagerHolder gmgr(FWGeometryTableViewManager::getGeoMangeur());
      TIter next_ovl(gGeoManager->GetListOfOverlaps());
      const TGeoOverlap* ovl;
      while ((ovl = (TGeoOverlap*)next_ovl()))
        ovl->IsOverlap() ? no++ : ne++;

      m_renderer.setData(Form("%s Ovl[%d] Ext[%d]", data.m_node->GetName(), no, ne), isSelected);
    } else {
      m_renderer.setData(data.name(), isSelected);
    }
    m_renderer.setIsParent(nodeIsParent(data));

    m_renderer.setIsOpen(data.testBit(FWGeometryTableManagerBase::kExpanded));

    int level = data.m_level - m_levelOffset;
    if (nodeIsParent(data))
      m_renderer.setIndentation(20 * level);
    else
      m_renderer.setIndentation(20 * level + FWTextTreeCellRenderer::iconWidth());
  } else {
    m_renderer.setIsParent(false);
    m_renderer.setIndentation(0);

    if (iCol == 5) {
      if (data.testBit(kOverlap)) {
        std::string x;
        std::pair<std::multimap<int, int>::const_iterator, std::multimap<int, int>::const_iterator> ppp;
        ppp = m_mapNodeOverlaps.equal_range(unsortedRow);

        TEveGeoManagerHolder gmgr(FWGeometryTableViewManager::getGeoMangeur());

        for (std::multimap<int, int>::const_iterator it2 = ppp.first; it2 != ppp.second; ++it2) {
          const TGeoOverlap* ovl = (const TGeoOverlap*)gGeoManager->GetListOfOverlaps()->At((*it2).second);
          if (ovl)
            x += Form("%s: %g ", ovl->IsOverlap() ? "Ovl" : "Extr", ovl->GetOverlap());
          else
            x += "err";
        }
        m_renderer.setData(x, isSelected);
      } else {
        m_renderer.setData("", isSelected);
      }
    }
    if (iCol == 1) {
      m_colorBoxRenderer.setData(data.m_color, isSelected);
      return &m_colorBoxRenderer;
    } else if (iCol == 2) {
      m_renderer.setData(Form("%d", 100 - data.m_transparency), isSelected);
    } else if (iCol == 3) {
      m_renderer.setData(data.testBit(kVisNodeSelf) ? "On" : "-", isSelected);

    } else if (iCol == 4) {
      m_renderer.setData(data.testBit(kVisNodeChld) ? "On" : "-", isSelected);

    } else if (iCol == 6) {
      std::cerr << "This shoud not happen! \n";
    }
  }
  return &m_renderer;
}

void FWOverlapTableManager::getOverlapTitles	(	int	idx,
		TString &	txt
	)		const

Definition at line 344 of file FWOverlapTableManager.cc.

References FWGeometryTableViewManager::getGeoMangeur(), and m_mapNodeOverlaps.

Referenced by numberOfColumns().

                                                                        {
  TEveGeoManagerHolder gmgr(FWGeometryTableViewManager::getGeoMangeur());
  std::pair<std::multimap<int, int>::const_iterator, std::multimap<int, int>::const_iterator> ppp;
  ppp = m_mapNodeOverlaps.equal_range(idx);
  for (std::multimap<int, int>::const_iterator it2 = ppp.first; it2 != ppp.second; ++it2) {
    const TGeoOverlap* ovl = (const TGeoOverlap*)gGeoManager->GetListOfOverlaps()->At((*it2).second);
    {
      txt += "\n";

      if (ovl) {
        txt += Form("%s: %g, ", ovl->IsOverlap() ? "Ovl" : "Extr", ovl->GetOverlap());
        txt += ovl->GetTitle();
      }
    }
  }
}

std::vector< std::string > FWOverlapTableManager::getTitles ( ) const

overridevirtual

returns the title names for each column

Reimplemented from FWGeometryTableManagerBase.

Definition at line 44 of file FWOverlapTableManager.cc.

References numberOfColumns().

Referenced by numberOfColumns().

                                                            {
  std::vector<std::string> returnValue;
  returnValue.reserve(numberOfColumns());

  returnValue.push_back("Name");
  returnValue.push_back("Color");
  returnValue.push_back("Opcty");
  returnValue.push_back("RnrSelf");
  returnValue.push_back("RnrChildren");
  returnValue.push_back("Overlap");
  returnValue.push_back("RnrMarker");
  return returnValue;
}

void FWOverlapTableManager::importOverlaps	(	std::string	path,
		double	precision
	)

Definition at line 59 of file FWOverlapTableManager.cc.

References addOverlapEntry(), relativeConstraints::geom, FWGeometryTableViewManager::getGeoMangeur(), FWGeometryTableViewBase::getMarker(), FWGeometryTableViewBase::getTopNodeIdx(), mps_fire::i, kOverlap, kOverlapChild, kVisMarker, FWGeometryTableManagerBase::kVisNodeChld, FWGeometryTableManagerBase::kVisNodeSelf, m_browser, FWGeometryTableManagerBase::NodeInfo::m_color, FWGeometryTableManagerBase::m_entries, FWGeometryTableManagerBase::NodeInfo::m_level, m_mapNodeOverlaps, FWGeometryTableManagerBase::NodeInfo::m_node, FWGeometryTableManagerBase::NodeInfo::m_parent, FWGeometryTableManagerBase::NodeInfo::m_transparency, getGTfromDQMFile::obj, analyzePatCleaning_cfg::overlaps, and FWGeometryTableManagerBase::NodeInfo::resetBit().

Referenced by FWOverlapTableView::recalculate().

                                                                             {
  m_entries.clear();
  m_mapNodeOverlaps.clear();
  m_browser->getMarker()->Reset(TEveQuadSet::kQT_FreeQuad, kFALSE, 32);

  TEveGeoManagerHolder mangeur(FWGeometryTableViewManager::getGeoMangeur());
  // gGeoManager->cd();
  NodeInfo topNodeInfo;
  topNodeInfo.m_node = gGeoManager->GetTopNode();
  topNodeInfo.m_level = 0;
  topNodeInfo.m_color = gGeoManager->GetTopNode()->GetVolume()->GetLineColor();
  topNodeInfo.m_transparency = gGeoManager->GetTopNode()->GetVolume()->GetTransparency();
  topNodeInfo.m_parent = -1;
  topNodeInfo.resetBit(kVisNodeSelf);

  m_entries.resize(gGeoManager->GetNNodes());
  m_entries[0] = topNodeInfo;

  m_entries.resize(gGeoManager->GetNNodes());

  TGeoVolume* topVol = topNodeInfo.m_node->GetVolume();
  Int_t icheck = 0;
  Int_t ncheck = 0;
  TStopwatch* timer;
  Int_t i;
  bool checkingOverlaps = false;
  TGeoManager* geom = topVol->GetGeoManager();
  ncheck = topNodeInfo.m_node->CountDaughters(kFALSE);
  timer = new TStopwatch();
  geom->ClearOverlaps();
  geom->SetCheckingOverlaps(kTRUE);

  int oldS = 0;
  timer->Start();
  geom->GetGeomPainter()->OpProgress(topVol->GetName(), icheck, ncheck, timer, kFALSE);
  //   topVol->CheckOverlaps(iPrecision);
  icheck++;
  TGeoIterator git(topVol);
  Entries_i eit = m_entries.begin();
  /*
     if (gGeoManager->GetListOfOverlaps()->GetEntriesFast()) {
     int newCnt =  gGeoManager->GetListOfOverlaps()->GetEntriesFast();
     for (int i=0; i<newCnt; ++i) {
     addOverlapEntry((TGeoOverlap*)gGeoManager->GetListOfOverlaps()->At(i), new TGeoHMatrix(*geom->GetCurrentMatrix()), topNode, next); 
     }
     oldS= newCnt;
     }*/
  eit++;
  TGeoNode* node;
  icheck = 1;

  int topNodeIdx = m_browser->getTopNodeIdx();

  while ((node = git())) {
    if (!eit->testBit(kOverlap))
      eit->resetBit(kVisNodeSelf);
    eit->m_node = node;
    eit->m_color = node->GetVolume()->GetLineColor();
    eit->m_transparency = node->GetVolume()->GetTransparency();
    eit->m_level = git.GetLevel();
    eit->m_parent = icheck;

    if ((topNodeIdx) == icheck || !topNodeIdx) {
      //  printf("start to check overlaps on topNodeIdx %s \n", eit->name());
      checkingOverlaps = true;
    } else if (checkingOverlaps && (eit->m_level <= m_entries[m_browser->getTopNodeIdx()].m_level)) {
      checkingOverlaps = false;
    }
    // parent index
    Entries_i pit = eit;
    do {
      --pit;
      --(eit->m_parent);
      if (pit->m_level < eit->m_level)
        break;
    } while (pit != m_entries.begin());

    // overlap bits
    if (checkingOverlaps) {
      if (!node->GetVolume()->IsSelected()) {
        geom->GetGeomPainter()->OpProgress(node->GetVolume()->GetName(), icheck + 1, ncheck, timer, kFALSE);
        node->GetVolume()->SelectVolume(kFALSE);

        node->GetVolume()->CheckOverlaps(iPrecision);

        if (oldS != gGeoManager->GetListOfOverlaps()->GetEntriesFast()) {
          // printf("mother %s overlaps \n", node->GetName());

          eit->setBit(kOverlapChild);
          eit->setBit(kVisNodeChld);
          eit->setBit(kVisMarker);

          TGeoHMatrix* motherm = new TGeoHMatrix(*geom->GetCurrentMatrix());
          {
            TGeoNode* ni = topNodeInfo.m_node;
            for (Int_t i = 1; i <= git.GetLevel(); i++) {
              ni = ni->GetDaughter(git.GetIndex(i));
              motherm->Multiply(ni->GetMatrix());
            }
          }

          int newCnt = gGeoManager->GetListOfOverlaps()->GetEntriesFast();

          for (int i = oldS; i < newCnt; ++i) {
            //                  printf("add %p %p \n", (void*)node->GetVolume(), (void*)m_entries[icheck].m_node->GetVolume());
            addOverlapEntry((TGeoOverlap*)gGeoManager->GetListOfOverlaps()->At(i), i, icheck, motherm);
          }

          oldS = newCnt;
        }
      }
    }
    eit++;
    icheck++;
  }

  m_browser->getMarker()->RefitPlex();

  topVol->SelectVolume(kTRUE);
  geom->SetCheckingOverlaps(kFALSE);
  //   geom->SortOverlaps();
  TObjArray* overlaps = geom->GetListOfOverlaps();
  Int_t novlps = overlaps->GetEntriesFast();
  TNamed* obj;
  for (i = 0; i < novlps; i++) {
    obj = (TNamed*)overlaps->At(i);
    obj->SetName(Form("ov%05d", i));
  }
  geom->GetGeomPainter()->OpProgress("Check overlaps:", icheck, ncheck, timer, kTRUE);
  Info("CheckOverlaps", "Number of illegal overlaps/extrusions : %d\n", novlps);
  delete timer;
}

bool FWOverlapTableManager::nodeIsParent ( const NodeInfo &  data ) const

overrideprotectedvirtual

Reimplemented from FWGeometryTableManagerBase.

Definition at line 329 of file FWOverlapTableManager.cc.

References kOverlapChild, FWOverlapTableView::listAllNodes(), m_browser, FWGeometryTableManagerBase::NodeInfo::m_node, and FWGeometryTableManagerBase::NodeInfo::testBit().

Referenced by cellRenderer(), and numberOfColumns().

                                                                   {
  return m_browser->listAllNodes() ? data.m_node->GetNdaughters() : data.testBit(kOverlapChild);
}

int FWOverlapTableManager::numberOfColumns ( ) const

inlineoverridevirtual

Number of columns in the table.

Implements FWTableManagerBase.

Definition at line 58 of file FWOverlapTableManager.h.

References addOverlapEntry(), cellRenderer(), FWOverlapTableManager(), getOverlapTitles(), getTitles(), mps_fire::i, nodeIsParent(), operator=(), printOverlaps(), setDaughtersSelfVisibility(), and findQualityFiles::v.

Referenced by getTitles().

{ return 6; }

const FWOverlapTableManager& FWOverlapTableManager::operator= ( const FWOverlapTableManager &  )

privatedelete

Referenced by numberOfColumns().

void FWOverlapTableManager::printOverlaps

(

int

idx

)

const

Definition at line 333 of file FWOverlapTableManager.cc.

References FWGeometryTableViewManager::getGeoMangeur(), and m_mapNodeOverlaps.

Referenced by FWOverlapTableView::chosenItem(), and numberOfColumns().

                                                       {
  TEveGeoManagerHolder gmgr(FWGeometryTableViewManager::getGeoMangeur());
  std::pair<std::multimap<int, int>::const_iterator, std::multimap<int, int>::const_iterator> ppp;
  ppp = m_mapNodeOverlaps.equal_range(idx);
  for (std::multimap<int, int>::const_iterator it2 = ppp.first; it2 != ppp.second; ++it2) {
    const TGeoOverlap* ovl = (const TGeoOverlap*)gGeoManager->GetListOfOverlaps()->At((*it2).second);
    if (ovl)
      ovl->Print();
  }
}

void FWOverlapTableManager::recalculateVisibility ( )

overridevirtual

Implements FWGeometryTableManagerBase.

Definition at line 299 of file FWOverlapTableManager.cc.

References FWGeometryTableViewBase::getTopNodeIdx(), mps_fire::i, FWGeometryTableManagerBase::kExpanded, m_browser, FWGeometryTableManagerBase::m_entries, FWGeometryTableManagerBase::m_row_to_index, and recalculateVisibilityNodeRec().

                                                  {
  // printf("overlap recalcuate vis \n");
  m_row_to_index.clear();
  int i = m_browser->getTopNodeIdx();
  m_row_to_index.push_back(i);

  if (m_entries[i].testBit(kExpanded))
    recalculateVisibilityNodeRec(i);
}

void FWOverlapTableManager::recalculateVisibilityNodeRec ( int  pIdx )

virtual

Definition at line 309 of file FWOverlapTableManager.cc.

References data, FWGeometryTableManagerBase::getNNodesTotal(), training_settings::idx, FWGeometryTableManagerBase::kExpanded, kOverlap, kOverlapChild, FWOverlapTableView::listAllNodes(), m_browser, FWGeometryTableManagerBase::m_entries, FWGeometryTableManagerBase::m_row_to_index, dqmiodumpmetadata::n, FWGeometryTableManagerBase::NodeInfo::testBit(), and FWGeometryTableManagerBase::NodeInfo::testBitAny().

Referenced by recalculateVisibility().

                                                                 {
  TGeoNode* parentNode = m_entries[pIdx].m_node;
  int nD = parentNode->GetNdaughters();
  int dOff = 0;
  for (int n = 0; n != nD; ++n) {
    int idx = pIdx + 1 + n + dOff;
    NodeInfo& data = m_entries[idx];

    if (m_browser->listAllNodes() || data.testBitAny(kOverlap | kOverlapChild))
      m_row_to_index.push_back(idx);

    if ((m_browser->listAllNodes() || data.testBit(kOverlapChild)) && data.testBit(kExpanded))
      recalculateVisibilityNodeRec(idx);

    FWGeometryTableManagerBase::getNNodesTotal(parentNode->GetDaughter(n), dOff);
  }
}

void FWOverlapTableManager::setDaughtersSelfVisibility ( int  i, bool  v  )

overridevirtual

Reimplemented from FWGeometryTableManagerBase.

Definition at line 481 of file FWOverlapTableManager.cc.

References data, FWGeometryTableManagerBase::getNNodesTotal(), training_settings::idx, FWGeometryTableManagerBase::kVisNodeChld, FWGeometryTableManagerBase::kVisNodeSelf, FWGeometryTableManagerBase::m_entries, dqmiodumpmetadata::n, and FWGeometryTableManagerBase::NodeInfo::setBitVal().

Referenced by numberOfColumns().

                                                                              {
  int dOff = 0;
  TGeoNode* parentNode = m_entries[selectedIdx].m_node;
  int nD = parentNode->GetNdaughters();
  for (int n = 0; n != nD; ++n) {
    int idx = selectedIdx + 1 + n + dOff;
    NodeInfo& data = m_entries[idx];

    data.setBitVal(FWGeometryTableManagerBase::kVisNodeChld, v);
    data.setBitVal(FWGeometryTableManagerBase::kVisNodeSelf, v);

    FWGeometryTableManagerBase::getNNodesTotal(parentNode->GetDaughter(n), dOff);
  }
}

Member Data Documentation

FWOverlapTableView* FWOverlapTableManager::m_browser

private

Definition at line 78 of file FWOverlapTableManager.h.

Referenced by addOverlapEntry(), cellRenderer(), importOverlaps(), nodeIsParent(), recalculateVisibility(), and recalculateVisibilityNodeRec().

std::multimap<int, int> FWOverlapTableManager::m_mapNodeOverlaps

private

Definition at line 80 of file FWOverlapTableManager.h.

Referenced by addOverlapEntry(), cellRenderer(), getOverlapTitles(), importOverlaps(), and printOverlaps().