Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2024-04-06 12:28:49

0001 // system include files
0002 #include <memory>
0003 
0004 // user include files
0005 #include "DataFormats/GeometrySurface/interface/BoundSurface.h"
0006 #include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
0007 #include "FWCore/Framework/interface/Event.h"
0008 #include "FWCore/Framework/interface/EventSetup.h"
0009 #include "FWCore/Framework/interface/Frameworkfwd.h"
0010 #include "FWCore/Framework/interface/MakerMacros.h"
0011 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
0012 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0013 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0014 #include "Geometry/CommonTopologies/interface/PixelTopology.h"
0015 #include "Geometry/CommonTopologies/interface/StripTopology.h"
0016 #include "Geometry/Records/interface/IdealGeometryRecord.h"
0017 #include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
0018 #include "Geometry/Records/interface/TrackerTopologyRcd.h"
0019 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
0020 #include "Geometry/TrackerNumberingBuilder/interface/GeometricDet.h"
0021 
0022 // ======= specific includes =======
0023 #include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h"
0024 #include "RecoTracker/TkDetLayers/interface/GeometricSearchTrackerBuilder.h"
0025 
0026 // for trie
0027 #include "Geometry/TrackerGeometryBuilder/interface/trackerHierarchy.h"
0028 #include "Geometry/CommonDetUnit/interface/GeomDet.h"
0029 #include "DataFormats/Common/interface/Trie.h"
0030 
0031 // for the test
0032 #include "TrackingTools/DetLayers/interface/CylinderBuilderFromDet.h"
0033 #include "DataFormats/GeometrySurface/interface/SimpleCylinderBounds.h"
0034 
0035 namespace {
0036 
0037   // FIXME here just to allow prototyping...
0038   namespace trackerTrie {
0039     typedef GeomDet const* PDet;
0040     typedef edm::Trie<PDet> DetTrie;
0041     typedef edm::TrieNode<PDet> Node;
0042     typedef Node const* node_pointer;  // sigh....
0043     typedef edm::TrieNodeIter<PDet> node_iterator;
0044   }  // namespace trackerTrie
0045 
0046   // Wrapper for trie call back
0047   template <typename F>
0048   struct WrapTrieCB {
0049     WrapTrieCB(F& fi) : f(fi) {}
0050     template <typename P>
0051     void operator()(P p, std::string const&) {
0052       f(*p);
0053     }
0054     F& f;
0055   };
0056 
0057 }  // namespace
0058 
0059 using namespace edm;
0060 using namespace std;
0061 
0062 class TkDetLayersAnalyzer : public edm::one::EDAnalyzer<> {
0063 public:
0064   TkDetLayersAnalyzer(const edm::ParameterSet&);
0065   ~TkDetLayersAnalyzer() = default;
0066   void analyze(edm::Event const& iEvent, edm::EventSetup const&) override;
0067 
0068 private:
0069   const edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> geomToken_;
0070   const edm::ESGetToken<GeometricDet, IdealGeometryRecord> geomDetToken_;
0071   const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> tTopoToken_;
0072 };
0073 
0074 TkDetLayersAnalyzer::TkDetLayersAnalyzer(const edm::ParameterSet& iConfig)
0075     : geomToken_(esConsumes()), geomDetToken_(esConsumes()), tTopoToken_(esConsumes()) {}
0076 
0077 void TkDetLayersAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
0078   const TrackerGeometry* pTrackerGeometry = &iSetup.getData(geomToken_);
0079 
0080   const GeometricDet* pDD = &iSetup.getData(geomDetToken_);
0081   edm::LogInfo("TkDetLayersAnalyzer") << " Top node is  " << &(*pDD) << "\n"
0082                                       << " And Contains  Daughters: " << (*pDD).components().size();
0083 
0084   const TrackerTopology* tTopo = &iSetup.getData(tTopoToken_);
0085 
0086   /*
0087 
0088   // -------- here it constructs only a TOBLayer -------------------------
0089   vector<const GeometricDet*> geometricDetLayers = (*pDD).components();
0090   const GeometricDet* geometricDetTob=0;
0091   
0092   for(vector<const GeometricDet*>::const_iterator it=geometricDetLayers.begin();
0093       it!=geometricDetLayers.end(); it++){
0094     if(  (*it)->type() == GeometricDet::TOB ) {
0095       edm::LogInfo("TkDetLayersAnalyzer") << "found TOB geometricDet!" ;
0096       geometricDetTob = (*it);
0097     }
0098   }
0099   
0100   edm::LogInfo("TkDetLayersAnalyzer") << "Tob geometricDet has " << geometricDetTob->components().size() << " daughter" ;
0101   const GeometricDet* geometricDetTOBlayer = geometricDetTob->components()[1];
0102 
0103   edm::LogInfo("TkDetLayersAnalyzer") << "this Tob layer has: " << geometricDetTOBlayer->components().size() << " daughter" ;
0104 
0105   */
0106 
0107   /*
0108     vector<const GeometricDet*> geometricDetTOBlayer3Strings = geometricDetTOBlayer3->components();
0109     for(vector<const GeometricDet*>::const_iterator it=geometricDetTOBlayer3Strings.begin();
0110     it!=geometricDetTOBlayer3Strings.end(); it++){
0111     
0112     cout << "string phi position: " << (*it)->positionBounds().phi()  << endl;
0113     cout << "string r position:   " << (*it)->positionBounds().perp() << endl;
0114     cout << "string z position:   " << (*it)->positionBounds().z() << endl;
0115     cout << endl;
0116     }
0117   */
0118 
0119   /*
0120   TOBLayerBuilder myTOBBuilder;
0121   TOBLayer* testTOBLayer = myTOBBuilder.build(geometricDetTOBlayer,&(*pTrackerGeometry),&(*tTopo_handle));
0122   edm::LogInfo("TkDetLayersAnalyzer") << "testTOBLayer: " << testTOBLayer;
0123 
0124   */
0125   // ------------- END -------------------------
0126 
0127   //
0128   // -------------- example of using the Trie ---------------------------------
0129   //  code from GeometricSearchTrackerBuilder
0130   //
0131 
0132   using namespace trackerTrie;
0133   // create a Trie
0134   DetTrie trie(0);
0135 
0136   {
0137     const TrackingGeometry::DetContainer& modules = pTrackerGeometry->detUnits();
0138     typedef TrackingGeometry::DetContainer::const_iterator Iter;
0139     Iter b = modules.begin();
0140     Iter e = modules.end();
0141     Iter last;
0142     try {
0143       for (; b != e; ++b) {
0144         last = b;
0145         unsigned int rawid = (*b)->geographicalId().rawId();
0146         trie.insert(trackerHierarchy(tTopo, rawid), *b);
0147       }
0148     } catch (edm::Exception const& e) {
0149       std::cout << "in filling " << e.what() << std::endl;
0150       unsigned int rawid = (*last)->geographicalId().rawId();
0151       int subdetid = (*last)->geographicalId().subdetId();
0152       std::cout << rawid << " " << subdetid << std::endl;
0153     }
0154   }
0155 
0156   // layers "ids"
0157   unsigned int layerId[] = {1, 3, 5, 21, 22, 41, 42, 61, 62};
0158 
0159   // TOB is "2"
0160   {
0161     std::string s;
0162     if (layerId[2] > 9)
0163       s += char(layerId[2] / 10);
0164     s += char(layerId[2] % 10);
0165     node_iterator e;
0166     node_iterator tobl(trie.node(s));
0167     for (; tobl != e; tobl++) {
0168       // for each  tob layer and compute cylinder geom (not the real ones though)
0169       CylinderBuilderFromDet cylbld;
0170       WrapTrieCB<CylinderBuilderFromDet> w(cylbld);
0171       edm::iterateTrieLeaves(w, *tobl);
0172       std::unique_ptr<BoundCylinder> cyl(cylbld.build());
0173       SimpleCylinderBounds const& cylb = static_cast<SimpleCylinderBounds const&>(cyl->bounds());
0174       std::cout << "cyl " << tobl.label() << ": " << cylb.length() << ", " << cylb.width() << ", " << cylb.thickness()
0175                 << std::endl;
0176     }
0177   }
0178 
0179   // ------------- END -------------------------
0180 
0181   // -------- here it constructs the whole GeometricSearchTracker --------------
0182   GeometricSearchTrackerBuilder myTrackerBuilder;
0183   GeometricSearchTracker* testTracker = myTrackerBuilder.build(&(*pDD), &(*pTrackerGeometry), &(*tTopo));
0184   edm::LogInfo("TkDetLayersAnalyzer") << "testTracker: " << testTracker;
0185 
0186   for (auto const& l : testTracker->allLayers()) {
0187     auto const& layer = *l;
0188     std::cout << layer.seqNum() << ' ' << layer.subDetector() << ' ' << layer.basicComponents().size() << '\n';
0189     //auto mx = std::minmax_element (layer.basicComponents().begin(),layer.basicComponents().end(),[](    );
0190     auto m_min(std::numeric_limits<float>::max());
0191     auto m_max(std::numeric_limits<float>::min());
0192     for (auto const& c : layer.basicComponents()) {
0193       auto const& det = *c;
0194       auto xi = det.specificSurface().mediumProperties().xi();
0195       m_min = std::min(m_min, xi);
0196       m_max = std::max(m_max, xi);
0197       // std::cout <<  det.specificSurface().mediumProperties().xi() <<',';
0198     }
0199     std::cout << "xi " << m_min << '/' << m_max;
0200     std::cout << std::endl;
0201   }
0202 
0203   // ------------- END -------------------------
0204 }
0205 
0206 //define this as a plug-in
0207 DEFINE_FWK_MODULE(TkDetLayersAnalyzer);