Core/src/FWOverlapTableManager.cc

0001 #include "Fireworks/Core/src/FWOverlapTableManager.h"
0002 #include "Fireworks/Core/src/FWOverlapTableView.h"
0003 #include "Fireworks/Core/src/FWEveDigitSetScalableMarker.h"
0004 #include "Fireworks/Core/interface/FWGeometryTableViewManager.h"
0005 #include "Fireworks/Core/interface/fwLog.h"
0006
0007 #include "TEveQuadSet.h"
0008 #include "TGeoVolume.h"
0009 #include "TGeoMatrix.h"
0010 #include "TGeoShape.h"
0011 #include "TGeoBBox.h"
0012 #include "TGeoMatrix.h"
0013 #include "TEveUtil.h"
0014 #include "TObjString.h"
0015 #include "TGeoNode.h"
0016 #include "TGeoOverlap.h"
0017 #include "TGeoManager.h"
0018 #include "TPolyMarker3D.h"
0019
0020 #include "TStopwatch.h"
0021 #include "TTimer.h"
0022 #if ROOT_VERSION_CODE < ROOT_VERSION(6, 37, 0)
0023 #include "TGeoPainter.h"
0024 #else
0025 #include "TGeoChecker.h"
0026 #endif
0027 #include "TPRegexp.h"
0028
0029 FWOverlapTableManager::FWOverlapTableManager(FWOverlapTableView* v) : FWGeometryTableManagerBase(), m_browser(v) {}
0030
0031 FWOverlapTableManager::~FWOverlapTableManager() {}
0032
0033 std::vector<std::string> FWOverlapTableManager::getTitles() const {
0034   std::vector<std::string> returnValue;
0035   returnValue.reserve(numberOfColumns());
0036
0037   returnValue.push_back("Name");
0038   returnValue.push_back("Color");
0039   returnValue.push_back("Opcty");
0040   returnValue.push_back("RnrSelf");
0041   returnValue.push_back("RnrChildren");
0042   returnValue.push_back("Overlap");
0043   returnValue.push_back("RnrMarker");
0044   return returnValue;
0045 }
0046
0047 //---------------------------------------------------------------------------------
0048 void FWOverlapTableManager::importOverlaps(std::string iPath, double iPrecision) {
0049   m_entries.clear();
0050   m_mapNodeOverlaps.clear();
0051   m_browser->getMarker()->Reset(TEveQuadSet::kQT_FreeQuad, kFALSE, 32);
0052
0053   TEveGeoManagerHolder mangeur(FWGeometryTableViewManager::getGeoMangeur());
0054   // gGeoManager->cd();
0055   NodeInfo topNodeInfo;
0056   topNodeInfo.m_node = gGeoManager->GetTopNode();
0057   topNodeInfo.m_level = 0;
0058   topNodeInfo.m_color = gGeoManager->GetTopNode()->GetVolume()->GetLineColor();
0059   topNodeInfo.m_transparency = gGeoManager->GetTopNode()->GetVolume()->GetTransparency();
0060   topNodeInfo.m_parent = -1;
0061   topNodeInfo.resetBit(kVisNodeSelf);
0062
0063   m_entries.resize(gGeoManager->GetNNodes());
0064   m_entries[0] = topNodeInfo;
0065
0066   m_entries.resize(gGeoManager->GetNNodes());
0067
0068   TGeoVolume* topVol = topNodeInfo.m_node->GetVolume();
0069   Int_t icheck = 0;
0070   Int_t ncheck = 0;
0071   TStopwatch* timer;
0072   Int_t i;
0073   bool checkingOverlaps = false;
0074   TGeoManager* geom = topVol->GetGeoManager();
0075   ncheck = topNodeInfo.m_node->CountDaughters(kFALSE);
0076   timer = new TStopwatch();
0077   geom->ClearOverlaps();
0078   geom->SetCheckingOverlaps(kTRUE);
0079
0080   int oldS = 0;
0081   timer->Start();
0082 #if ROOT_VERSION_CODE < ROOT_VERSION(6, 37, 0)
0083   geom->GetGeomPainter()->OpProgress(topVol->GetName(), icheck, ncheck, timer, kFALSE);
0084 #else
0085   geom->GetGeomChecker()->OpProgress(topVol->GetName(), icheck, ncheck, timer, kFALSE);
0086 #endif
0087   //   topVol->CheckOverlaps(iPrecision);
0088   icheck++;
0089   TGeoIterator git(topVol);
0090   Entries_i eit = m_entries.begin();
0091   /*
0092      if (gGeoManager->GetListOfOverlaps()->GetEntriesFast()) {
0093      int newCnt =  gGeoManager->GetListOfOverlaps()->GetEntriesFast();
0094      for (int i=0; i<newCnt; ++i) {
0095      addOverlapEntry((TGeoOverlap*)gGeoManager->GetListOfOverlaps()->At(i), new TGeoHMatrix(*geom->GetCurrentMatrix()), topNode, next);
0096      }
0097      oldS= newCnt;
0098      }*/
0099   eit++;
0100   TGeoNode* node;
0101   icheck = 1;
0102
0103   int topNodeIdx = m_browser->getTopNodeIdx();
0104
0105   while ((node = git())) {
0106     if (!eit->testBit(kOverlap))
0107       eit->resetBit(kVisNodeSelf);
0108     eit->m_node = node;
0109     eit->m_color = node->GetVolume()->GetLineColor();
0110     eit->m_transparency = node->GetVolume()->GetTransparency();
0111     eit->m_level = git.GetLevel();
0112     eit->m_parent = icheck;
0113
0114     if ((topNodeIdx) == icheck || !topNodeIdx) {
0115       //  printf("start to check overlaps on topNodeIdx %s \n", eit->name());
0116       checkingOverlaps = true;
0117     } else if (checkingOverlaps && (eit->m_level <= m_entries[m_browser->getTopNodeIdx()].m_level)) {
0118       checkingOverlaps = false;
0119     }
0120     // parent index
0121     Entries_i pit = eit;
0122     do {
0123       --pit;
0124       --(eit->m_parent);
0125       if (pit->m_level < eit->m_level)
0126         break;
0127     } while (pit != m_entries.begin());
0128
0129     // overlap bits
0130     if (checkingOverlaps) {
0131       if (!node->GetVolume()->IsSelected()) {
0132 #if ROOT_VERSION_CODE < ROOT_VERSION(6, 37, 0)
0133         geom->GetGeomPainter()->OpProgress(node->GetVolume()->GetName(), icheck + 1, ncheck, timer, kFALSE);
0134 #else
0135         geom->GetGeomChecker()->OpProgress(node->GetVolume()->GetName(), icheck + 1, ncheck, timer, kFALSE);
0136 #endif
0137         node->GetVolume()->SelectVolume(kFALSE);
0138
0139         node->GetVolume()->CheckOverlaps(iPrecision);
0140
0141         if (oldS != gGeoManager->GetListOfOverlaps()->GetEntriesFast()) {
0142           // printf("mother %s overlaps \n", node->GetName());
0143
0144           eit->setBit(kOverlapChild);
0145           eit->setBit(kVisNodeChld);
0146           eit->setBit(kVisMarker);
0147
0148           TGeoHMatrix* motherm = new TGeoHMatrix(*geom->GetCurrentMatrix());
0149           {
0150             TGeoNode* ni = topNodeInfo.m_node;
0151             for (Int_t i = 1; i <= git.GetLevel(); i++) {
0152               ni = ni->GetDaughter(git.GetIndex(i));
0153               motherm->Multiply(ni->GetMatrix());
0154             }
0155           }
0156
0157           int newCnt = gGeoManager->GetListOfOverlaps()->GetEntriesFast();
0158
0159           for (int i = oldS; i < newCnt; ++i) {
0160             //                  printf("add %p %p \n", (void*)node->GetVolume(), (void*)m_entries[icheck].m_node->GetVolume());
0161             addOverlapEntry((TGeoOverlap*)gGeoManager->GetListOfOverlaps()->At(i), i, icheck, motherm);
0162           }
0163
0164           oldS = newCnt;
0165         }
0166       }
0167     }
0168     eit++;
0169     icheck++;
0170   }
0171
0172   m_browser->getMarker()->RefitPlex();
0173
0174   topVol->SelectVolume(kTRUE);
0175   geom->SetCheckingOverlaps(kFALSE);
0176   //   geom->SortOverlaps();
0177   TObjArray* overlaps = geom->GetListOfOverlaps();
0178   Int_t novlps = overlaps->GetEntriesFast();
0179   TNamed* obj;
0180   for (i = 0; i < novlps; i++) {
0181     obj = (TNamed*)overlaps->At(i);
0182     obj->SetName(Form("ov%05d", i));
0183   }
0184 #if ROOT_VERSION_CODE < ROOT_VERSION(6, 37, 0)
0185   geom->GetGeomPainter()->OpProgress("Check overlaps:", icheck, ncheck, timer, kTRUE);
0186 #else
0187   geom->GetGeomChecker()->OpProgress("Check overlaps:", icheck, ncheck, timer, kTRUE);
0188 #endif
0189   Info("CheckOverlaps", "Number of illegal overlaps/extrusions : %d\n", novlps);
0190   delete timer;
0191 }
0192
0193 //______________________________________________________________________________
0194
0195 void FWOverlapTableManager::addOverlapEntry(TGeoOverlap* ovl, int ovlIdx, Int_t parentIdx, TGeoHMatrix* motherm) {
0196   // printf("add %s \n", ovl->GetTitle());
0197   // get doughter indices of overlaps
0198   /*
0199       TPMERegexp re(" ", "o");
0200       re.Split(TString(ovl->GetTitle()));
0201       printf("add title %s \n", ovl->GetTitle());
0202    */
0203   int pcnt = parentIdx + 1;
0204   int dOff = 0;
0205   TGeoNode* mothern = m_entries[parentIdx].m_node;
0206
0207   QuadId* quid = new QuadId(ovl, parentIdx);
0208
0209   for (int i = 0; i < mothern->GetNdaughters(); ++i) {
0210     TGeoNode* n = mothern->GetDaughter(i);
0211
0212     int cnt = pcnt + i + dOff;
0213
0214     if (ovl->IsOverlap()) {
0215       if (n->GetVolume() == ovl->GetFirstVolume() && (*(ovl->GetFirstMatrix()) == *(n->GetMatrix()))) {
0216         // std::string x = re[0].Data();
0217         //if (x.find(n->GetName()) == std::string::npos) printf("ERROT \n");
0218
0219         m_entries[cnt].setBit(kOverlap);
0220         m_entries[cnt].setBit(kVisNodeSelf);
0221         m_mapNodeOverlaps.insert(std::pair<int, int>(cnt, ovlIdx));
0222         int nno;
0223         n->GetOverlaps(nno);
0224         nno |= BIT(1);
0225         n->SetOverlaps(nullptr, nno);
0226         quid->m_nodes.push_back(cnt);
0227       }
0228     }
0229
0230     if (n->GetVolume() == ovl->GetSecondVolume() && (*(ovl->GetSecondMatrix()) == *(n->GetMatrix()))) {
0231       //printf("-----------------------------------------------\n");
0232       // std::string x = re[2].Data();
0233       // if (x.find(n->GetName()) == std::string::npos) printf("ERROT \n");
0234
0235       m_entries[cnt].setBit(kOverlap);
0236       m_entries[cnt].setBit(kVisNodeSelf);
0237
0238       m_mapNodeOverlaps.insert(std::pair<int, int>(cnt, ovlIdx));
0239       int nno;
0240       n->GetOverlaps(nno);
0241       nno |= (ovl->IsOverlap() ? BIT(1) : BIT(2));
0242       n->SetOverlaps(nullptr, nno);
0243
0244       quid->m_nodes.push_back(cnt);
0245     }
0246
0247     FWGeometryTableManagerBase::getNNodesTotal(n, dOff);
0248   }
0249
0250   TPolyMarker3D* pm = ovl->GetPolyMarker();
0251   for (int j = 0; j < pm->GetN(); ++j) {
0252     double pl[3];
0253     double pg[3];
0254     pm->GetPoint(j, pl[0], pl[1], pl[2]);
0255     motherm->LocalToMaster(pl, pg);
0256
0257     float dx = TMath::Abs(ovl->GetOverlap());
0258     if (dx > 1e5) {
0259       fwLog(fwlog::kInfo) << Form("WARNING [%s], overlap size = %.1f \n", ovl->GetTitle(), dx);
0260       dx = 10;
0261     }
0262     float dy = dx, dz = 0;
0263     float fp[3];
0264     fp[0] = pg[0];
0265     fp[1] = pg[1];
0266     fp[2] = pg[2];
0267     float bb[12] = {fp[0] + dx,
0268                     fp[1] - dy,
0269                     fp[2] - dz,
0270                     fp[0] + dx,
0271                     fp[1] + dy,
0272                     fp[2] + dz,
0273                     fp[0] - dx,
0274                     fp[1] + dy,
0275                     fp[2] + dz,
0276                     fp[0] - dx,
0277                     fp[1] - dy,
0278                     fp[2] - dz};
0279     m_browser->getMarker()->AddQuad(&bb[0]);
0280     m_browser->getMarker()->QuadId(quid);
0281   }
0282
0283   int aIdx = parentIdx;
0284   int aLev = m_entries[aIdx].m_level;
0285   int topNodeIdx = m_browser->getTopNodeIdx();
0286
0287   while (aIdx > topNodeIdx) {
0288     aIdx--;
0289     if (m_entries[aIdx].m_level < aLev) {
0290       m_entries[aIdx].setBit(kOverlapChild);
0291       m_entries[aIdx].setBit(kVisNodeChld);
0292       //  printf("stamp %s \n", m_entries[aIdx].name());
0293       aLev--;
0294     }
0295   }
0296 }
0297
0298 //_____________________________________________________________________________
0299
0300 void FWOverlapTableManager::recalculateVisibility() {
0301   // printf("overlap recalcuate vis \n");
0302   m_row_to_index.clear();
0303   int i = m_browser->getTopNodeIdx();
0304   m_row_to_index.push_back(i);
0305
0306   if (m_entries[i].testBit(kExpanded))
0307     recalculateVisibilityNodeRec(i);
0308 }
0309
0310 void FWOverlapTableManager::recalculateVisibilityNodeRec(int pIdx) {
0311   TGeoNode* parentNode = m_entries[pIdx].m_node;
0312   int nD = parentNode->GetNdaughters();
0313   int dOff = 0;
0314   for (int n = 0; n != nD; ++n) {
0315     int idx = pIdx + 1 + n + dOff;
0316     NodeInfo& data = m_entries[idx];
0317
0318     if (m_browser->listAllNodes() || data.testBitAny(kOverlap | kOverlapChild))
0319       m_row_to_index.push_back(idx);
0320
0321     if ((m_browser->listAllNodes() || data.testBit(kOverlapChild)) && data.testBit(kExpanded))
0322       recalculateVisibilityNodeRec(idx);
0323
0324     FWGeometryTableManagerBase::getNNodesTotal(parentNode->GetDaughter(n), dOff);
0325   }
0326 }
0327
0328 //______________________________________________________________________________
0329
0330 bool FWOverlapTableManager::nodeIsParent(const NodeInfo& data) const {
0331   return m_browser->listAllNodes() ? data.m_node->GetNdaughters() : data.testBit(kOverlapChild);
0332 }
0333
0334 void FWOverlapTableManager::printOverlaps(int idx) const {
0335   TEveGeoManagerHolder gmgr(FWGeometryTableViewManager::getGeoMangeur());
0336   std::pair<std::multimap<int, int>::const_iterator, std::multimap<int, int>::const_iterator> ppp;
0337   ppp = m_mapNodeOverlaps.equal_range(idx);
0338   for (std::multimap<int, int>::const_iterator it2 = ppp.first; it2 != ppp.second; ++it2) {
0339     const TGeoOverlap* ovl = (const TGeoOverlap*)gGeoManager->GetListOfOverlaps()->At((*it2).second);
0340     if (ovl)
0341       ovl->Print();
0342   }
0343 }
0344
0345 void FWOverlapTableManager::getOverlapTitles(int idx, TString& txt) const {
0346   TEveGeoManagerHolder gmgr(FWGeometryTableViewManager::getGeoMangeur());
0347   std::pair<std::multimap<int, int>::const_iterator, std::multimap<int, int>::const_iterator> ppp;
0348   ppp = m_mapNodeOverlaps.equal_range(idx);
0349   for (std::multimap<int, int>::const_iterator it2 = ppp.first; it2 != ppp.second; ++it2) {
0350     const TGeoOverlap* ovl = (const TGeoOverlap*)gGeoManager->GetListOfOverlaps()->At((*it2).second);
0351     {
0352       txt += "\n";
0353
0354       if (ovl) {
0355         txt += Form("%s: %g, ", ovl->IsOverlap() ? "Ovl" : "Extr", ovl->GetOverlap());
0356         txt += ovl->GetTitle();
0357       }
0358     }
0359   }
0360 }
0361 //______________________________________________________________________________
0362 /*
0363   const char* FWOverlapTableManager::cellName(const NodeInfo& data) const
0364   {
0365   if (data.m_parent == -1)
0366   {
0367   int ne = 0;
0368   int no = 0;
0369   TGeoOverlap* ovl;
0370   TEveGeoManagerHolder gmgr( FWGeometryTableViewManager::getGeoMangeur());
0371   TIter next_ovl(gGeoManager->GetListOfOverlaps());
0372   while((ovl = (TGeoOverlap*)next_ovl()))
0373   ovl->IsOverlap() ? no++ : ne++;
0374
0375   return Form("%s Ovl[%d] Ext[%d]", data.m_node->GetName(), no, ne);
0376   }
0377   else
0378   {
0379   return data.name();
0380   }
0381   }*/
0382
0383 //______________________________________________________________________________
0384
0385 FWTableCellRendererBase* FWOverlapTableManager::cellRenderer(int iSortedRowNumber, int iCol) const {
0386   if (m_row_to_index.empty())
0387     return &m_renderer;
0388
0389   int unsortedRow = m_row_to_index[iSortedRowNumber];
0390
0391   if (unsortedRow < 0)
0392     printf("!!!!!!!!!!!!!!!! error %d %d \n", unsortedRow, iSortedRowNumber);
0393
0394   // editor state
0395   //
0396   m_renderer.showEditor(unsortedRow == m_editTransparencyIdx && iCol == 2);
0397
0398   // selection state
0399   //
0400   const NodeInfo& data = m_entries[unsortedRow];
0401
0402   bool isSelected = data.testBit(kHighlighted) || data.testBit(kSelected);
0403   if (m_browser->listAllNodes())
0404     isSelected = isSelected || data.testBit(kOverlap);
0405
0406   if (data.testBit(kSelected)) {
0407     m_highlightContext->SetBackground(0xc86464);
0408   } else if (data.testBit(kHighlighted)) {
0409     m_highlightContext->SetBackground(0x6464c8);
0410   } else if (m_browser->listAllNodes() && data.testBit(kOverlap)) {
0411     m_highlightContext->SetBackground(0xdddddd);
0412   }
0413
0414   // set column content
0415   //
0416   if (iCol == 0) {
0417     if (unsortedRow == m_browser->getTopNodeIdx()) {
0418       int no = 0, ne = 0;
0419       TEveGeoManagerHolder gmgr(FWGeometryTableViewManager::getGeoMangeur());
0420       TIter next_ovl(gGeoManager->GetListOfOverlaps());
0421       const TGeoOverlap* ovl;
0422       while ((ovl = (TGeoOverlap*)next_ovl()))
0423         ovl->IsOverlap() ? no++ : ne++;
0424
0425       m_renderer.setData(Form("%s Ovl[%d] Ext[%d]", data.m_node->GetName(), no, ne), isSelected);
0426     } else {
0427       m_renderer.setData(data.name(), isSelected);
0428     }
0429     m_renderer.setIsParent(nodeIsParent(data));
0430
0431     m_renderer.setIsOpen(data.testBit(FWGeometryTableManagerBase::kExpanded));
0432
0433     int level = data.m_level - m_levelOffset;
0434     if (nodeIsParent(data))
0435       m_renderer.setIndentation(20 * level);
0436     else
0437       m_renderer.setIndentation(20 * level + FWTextTreeCellRenderer::iconWidth());
0438   } else {
0439     m_renderer.setIsParent(false);
0440     m_renderer.setIndentation(0);
0441
0442     if (iCol == 5) {
0443       if (data.testBit(kOverlap)) {
0444         std::string x;
0445         std::pair<std::multimap<int, int>::const_iterator, std::multimap<int, int>::const_iterator> ppp;
0446         ppp = m_mapNodeOverlaps.equal_range(unsortedRow);
0447
0448         TEveGeoManagerHolder gmgr(FWGeometryTableViewManager::getGeoMangeur());
0449
0450         for (std::multimap<int, int>::const_iterator it2 = ppp.first; it2 != ppp.second; ++it2) {
0451           const TGeoOverlap* ovl = (const TGeoOverlap*)gGeoManager->GetListOfOverlaps()->At((*it2).second);
0452           if (ovl)
0453             x += Form("%s: %g ", ovl->IsOverlap() ? "Ovl" : "Extr", ovl->GetOverlap());
0454           else
0455             x += "err";
0456         }
0457         m_renderer.setData(x, isSelected);
0458       } else {
0459         m_renderer.setData("", isSelected);
0460       }
0461     }
0462     if (iCol == 1) {
0463       m_colorBoxRenderer.setData(data.m_color, isSelected);
0464       return &m_colorBoxRenderer;
0465     } else if (iCol == 2) {
0466       m_renderer.setData(Form("%d", 100 - data.m_transparency), isSelected);
0467     } else if (iCol == 3) {
0468       m_renderer.setData(data.testBit(kVisNodeSelf) ? "On" : "-", isSelected);
0469
0470     } else if (iCol == 4) {
0471       m_renderer.setData(data.testBit(kVisNodeChld) ? "On" : "-", isSelected);
0472
0473     } else if (iCol == 6) {
0474       std::cerr << "This shoud not happen! \n";
0475     }
0476   }
0477   return &m_renderer;
0478 }
0479
0480 //______________________________________________________________________________
0481
0482 void FWOverlapTableManager::setDaughtersSelfVisibility(int selectedIdx, bool v) {
0483   int dOff = 0;
0484   TGeoNode* parentNode = m_entries[selectedIdx].m_node;
0485   int nD = parentNode->GetNdaughters();
0486   for (int n = 0; n != nD; ++n) {
0487     int idx = selectedIdx + 1 + n + dOff;
0488     NodeInfo& data = m_entries[idx];
0489
0490     data.setBitVal(FWGeometryTableManagerBase::kVisNodeChld, v);
0491     data.setBitVal(FWGeometryTableManagerBase::kVisNodeSelf, v);
0492
0493     FWGeometryTableManagerBase::getNNodesTotal(parentNode->GetDaughter(n), dOff);
0494   }
0495 }