Inheritance diagram for TkMSParameterizationBuilder:

Public Types
using	ReturnType = std::unique_ptr< TkMSParameterization >

Public Member Functions
ReturnType	produce (TkMSParameterizationRecord const &)

	TkMSParameterizationBuilder (edm::ParameterSet const &)

Public Member Functions inherited from edm::ESProducer
	ESProducer ()

	ESProducer (const ESProducer &)=delete

ESProxyIndex const *	getTokenIndices (unsigned int iIndex) const

ESRecordIndex const *	getTokenRecordIndices (unsigned int iIndex) const

bool	hasMayConsumes () const noexcept

size_t	numberOfTokenIndices (unsigned int iIndex) const

ESProducer const &	operator= (const ESProducer &)=delete

SerialTaskQueueChain &	queue ()

template<typename Record >
std::optional< std::vector< ESProxyIndex > >	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &) final

	~ESProducer () noexcept(false) override

Public Member Functions inherited from edm::ESProxyFactoryProducer
	ESProxyFactoryProducer ()

	ESProxyFactoryProducer (const ESProxyFactoryProducer &)=delete

const ESProxyFactoryProducer &	operator= (const ESProxyFactoryProducer &)=delete

	~ESProxyFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::DataProxyProvider
void	createKeyedProxies (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

	DataProxyProvider ()

	DataProxyProvider (const DataProxyProvider &)=delete

const ComponentDescription &	description () const

void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const

virtual void	initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const DataProxyProvider &	operator= (const DataProxyProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~DataProxyProvider () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from edm::eventsetup::DataProxyProvider
static void	prevalidate (ConfigurationDescriptions &)

Private Attributes
edm::ESGetToken< NavigationSchool, NavigationSchoolRecord >	theNavSchoolToken_

edm::ESGetToken< Propagator, TrackingComponentsRecord >	thePropagatorToken_

Additional Inherited Members
Protected Types inherited from edm::ESProxyFactoryProducer
using	EventSetupRecordKey = eventsetup::EventSetupRecordKey

Protected Types inherited from edm::eventsetup::DataProxyProvider
using	KeyedProxiesVector = std::vector< std::pair< DataKey, std::shared_ptr< DataProxy > >>

Protected Member Functions inherited from edm::ESProducer
template<typename T >
auto	setWhatProduced (T iThis, const char iLabel)

template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})

template<typename T >
auto	setWhatProduced (T *iThis, const std::string &iLabel)

template<typename T , typename TDecorator >
auto	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord >
auto	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord , typename TArg >
ESConsumesCollectorT< TRecord >	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel={})

void	usesResources (std::vector< std::string > const &)

Protected Member Functions inherited from edm::ESProxyFactoryProducer
template<class TFactory >
void	registerFactory (std::unique_ptr< TFactory > iFactory, const std::string &iLabel=std::string())

virtual void	registerFactoryWithKey (const EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ProxyFactoryBase > iFactory, const std::string &iLabel=std::string())

KeyedProxiesVector	registerProxies (const EventSetupRecordKey &, unsigned int iovIndex) override

Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &key)

Detailed Description

Definition at line 50 of file TkMSParameterizationBuilder.cc.

Member Typedef Documentation

◆ ReturnType

using TkMSParameterizationBuilder::ReturnType = std::unique_ptr<TkMSParameterization>

Definition at line 60 of file TkMSParameterizationBuilder.cc.

Constructor & Destructor Documentation

◆ TkMSParameterizationBuilder()

TkMSParameterizationBuilder::TkMSParameterizationBuilder ( edm::ParameterSet const & pset )

Definition at line 68 of file TkMSParameterizationBuilder.cc.

                                                                                     {
   auto cc = setWhatProduced(this, "");
   theNavSchoolToken_ = cc.consumes(edm::ESInputTag("", pset.getParameter<std::string>("navigationSchool")));
   thePropagatorToken_ = cc.consumes(edm::ESInputTag("", "PropagatorWithMaterial"));
 }

References muonDTDigis_cfi::pset, edm::ESProducer::setWhatProduced(), AlCaHLTBitMon_QueryRunRegistry::string, theNavSchoolToken_, and thePropagatorToken_.

Member Function Documentation

◆ fillDescriptions()

static void TkMSParameterizationBuilder::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

inlinestatic

Definition at line 53 of file TkMSParameterizationBuilder.cc.

                                                                            {
     edm::ParameterSetDescription desc;
     // desc.add<std::string>("ComponentName","TkMSParameterization");
     desc.add<std::string>("navigationSchool", "SimpleNavigationSchool");
     descriptions.add("TkMSParameterizationBuilder", desc);
   }

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ produce()

TkMSParameterizationBuilder::ReturnType TkMSParameterizationBuilder::produce ( TkMSParameterizationRecord const & iRecord )

Definition at line 74 of file TkMSParameterizationBuilder.cc.

                                                                                                                     {
   using namespace tkMSParameterization;
  
   ReturnType product = std::make_unique<TkMSParameterization>();
  
   auto& msParam = *product;
  
   //
   TkNavigationSchool const& navSchool = dynamic_cast<TkNavigationSchool const&>(iRecord.get(theNavSchoolToken_));
   auto const& searchGeom = navSchool.searchTracker();
   auto const& magfield = navSchool.field();
  
   //
   auto const& ANprop = iRecord.get(thePropagatorToken_);
  
   // error (very very small)
   ROOT::Math::SMatrixIdentity id;
   AlgebraicSymMatrix55 C(id);
   C *= 1.e-16;
  
   CurvilinearTrajectoryError err(C);
  
   Chi2MeasurementEstimator estimator(30., -3.0, 0.5, 2.0, 0.5, 1.e12);  // same as defauts....
   KFUpdator kfu;
   LocalError he(0.001 * 0.001, 0, 0.002 * 0.002);
  
   // loop over lambdas
   bool debug = false;
   float tl = 0;
   for (decltype(nLmBins()) ib = 0; ib < nLmBins(); ++ib, tl += lmBin()) {
     float pt = 1.0f;
     float tanlmd = tl;  // 0.1f;
     auto sinth2 = 1.f / (1.f + tanlmd * tanlmd);
     auto sinth = std::sqrt(sinth2);
     auto overp = sinth / pt;
     auto pz = pt * tanlmd;
  
     // debug= (tl>2.34f && tl<2.55f);
     if (debug)
       std::cout << tl << ' ' << pz << ' ' << 1. / overp << std::endl;
  
     float lastzz = -18.f;
     bool goFw = false;
     std::string loc = " Barrel";
     for (int iz = 0; iz < 2; ++iz) {
       if (iz > 0)
         goFw = true;
       for (float zz = lastzz; zz < 18.1f; zz += 0.2f) {
         float z = zz;
         GlobalPoint startingPosition(0, 0, z);
  
         constexpr int maxLayers = 6;
  
         std::vector<MSData> mserr[maxLayers][maxLayers];
  
         // define propagation from/to
         std::function<void(int, TrajectoryStateOnSurface, DetLayer const*, float, int)> propagate =
             [&](int from, TrajectoryStateOnSurface tsos, DetLayer const* layer, float z1, int stid) {
               for (auto il = from + 1; il < maxLayers; ++il) {
                 auto compLayers = navSchool.nextLayers(*layer, *tsos.freeState(), alongMomentum);
                 std::stable_sort(
                     compLayers.begin(), compLayers.end(), [](auto a, auto b) { return a->seqNum() < b->seqNum(); });
                 layer = nullptr;
                 for (auto it : compLayers) {
                   if (it->basicComponents().empty()) {
                     //this should never happen. but better protect for it
                     edm::LogError("TkMSParameterizationBuilder") << "a detlayer with no components: I cannot figure "
                                                                     "out a DetId from this layer. please investigate.";
                     continue;
                   }
                   if (debug)
                     std::cout << il << (it->isBarrel() ? " Barrel" : " Forward") << " layer " << it->seqNum()
                               << " SubDet " << it->subDetector() << std::endl;
                   auto const& detWithState = it->compatibleDets(tsos, ANprop, estimator);
                   if (detWithState.empty()) {
                     if (debug)
                       std::cout << "no det on this layer" << it->seqNum() << std::endl;
                     continue;
                   }
                   layer = it;
                   auto did = detWithState.front().first->geographicalId();
                   if (debug)
                     std::cout << "arrived at " << int(did) << std::endl;
                   tsos = detWithState.front().second;
                   if (debug)
                     std::cout << tsos.globalPosition() << ' ' << tsos.localError().positionError() << std::endl;
  
                   // save errs
                   auto globalError =
                       ErrorFrameTransformer::transform(tsos.localError().positionError(), tsos.surface());
                   auto gp = tsos.globalPosition();
                   float r = gp.perp();
                   float errorPhi = std::sqrt(float(globalError.phierr(gp)));
                   float errorR = std::sqrt(float(globalError.rerr(gp)));
                   float errorZ = std::sqrt(float(globalError.czz()));
                   float xerr = overp * errorPhi;
                   float zerr = overp * (layer->isBarrel() ? errorZ : errorR);
                   auto zo = layer->isBarrel() ? gp.z() : r;
                   //  std::cout << tanlmd << ' ' << z1 << ' ' << it->seqNum() << ':' << xerr <<'/'<<zerr << std::endl;
                   mserr[from][il - 1].emplace_back(MSData{stid, it->seqNum(), z1, zo, xerr, zerr});
  
                   if (from == 0) {
                     // spawn prop from this layer
                     // constrain it to this location (relevant for layer other than very first)
                     SiPixelRecHit::ClusterRef pref;
                     SiPixelRecHit hitpx(tsos.localPosition(), he, 1., *detWithState.front().first, pref);
                     auto tsosl = kfu.update(tsos, hitpx);
                     auto z1l = layer->isBarrel() ? tsos.globalPosition().z() : tsos.globalPosition().perp();
                     auto stidl = layer->seqNum();
                     propagate(il, tsosl, layer, z1l, stidl);
                   }
                   break;
                 }  // loop on compLayers
                 if (!layer)
                   break;
                 // if (!goFw) lastbz=z1;
                 if (from == 0)
                   lastzz = zz;
  
               }  // layer loop
  
               if (debug && mserr[from][from].empty()) {
                 std::cout << "tl " << tanlmd << loc << ' ' << from << std::endl;
                 for (auto il = from; il < maxLayers; ++il) {
                   std::cout << il << ' ';
                   for (auto const& e : mserr[from][il])
                     std::cout << e << ' ';  //  << '-' <<e.uerr*sinth <<'/'<<e.verr*sinth <<' ';
                   std::cout << std::endl;
                 }
               }
             };  // propagate
  
         float phi = 0.0415f;
         for (int ip = 0; ip < 5; ++ip) {
           phi += (3.14159f / 6.f) / 5.f;
           GlobalVector startingMomentum(pt * std::sin(phi), pt * std::cos(phi), pz);
  
           // make TSOS happy
           //Define starting plane
           PlaneBuilder pb;
           auto rot = rotation(startingMomentum);
           auto startingPlane = pb.plane(startingPosition, rot);
  
           TrajectoryStateOnSurface startingStateP(
               GlobalTrajectoryParameters(startingPosition, startingMomentum, 1, &magfield), err, *startingPlane);
           auto tsos0 = startingStateP;
  
           DetLayer const* layer0 = searchGeom.pixelBarrelLayers()[0];
           if (goFw)
             layer0 = searchGeom.posPixelForwardLayers()[0];
           int stid0 = layer0->seqNum();
  
           {
             auto it = layer0;
             if (debug)
               std::cout << "first layer " << (it->isBarrel() ? " Barrel" : " Forward") << " layer " << it->seqNum()
                         << " SubDet " << it->subDetector() << std::endl;
           }
  
           auto const& detWithState = layer0->compatibleDets(tsos0, ANprop, estimator);
           if (detWithState.empty()) {
             if (debug)
               std::cout << "no det on first layer" << layer0->seqNum() << std::endl;
             continue;
           }
           tsos0 = detWithState.front().second;
           if (debug)
             std::cout << "arrived at " << int(detWithState.front().first->geographicalId()) << ' '
                       << tsos0.globalPosition() << ' ' << tsos0.localError().positionError() << std::endl;
  
           // for barrel
           float z1l = tsos0.globalPosition().z();
           if (goFw) {
             loc = " Forward";
             z1l = tsos0.globalPosition().perp();
           }
  
           propagate(0, tsos0, layer0, z1l, stid0);
  
         }  // loop on phi
  
         // fill
         for (auto from = 0; from < maxLayers; ++from)
           for (auto il = from; il < maxLayers; ++il) {
             if (mserr[from][il].empty())
               continue;
             auto stid = mserr[from][il].front().stid;
             auto lid = mserr[from][il].front().lid;
             auto zi = mserr[from][il].front().zi;
             float xerr = 0;
             float zerr = 0;
             float zo = 0;
             for (auto const& e : mserr[from][il]) {
               if (e.stid != stid)
                 continue;
               lid = std::min(lid, e.lid);
             }
             float nn = 0;
             for (auto const& e : mserr[from][il]) {
               if (e.stid != stid || lid != e.lid)
                 continue;
               xerr += e.uerr;
               zerr += e.verr;
               zo += e.zo;
               ++nn;
             }
             xerr /= nn;
             zerr /= nn;
             zo /= nn;
             auto iid = packLID(stid, lid);
             auto& md = msParam.data[iid].data[ib].data;
             if (md.empty() || std::abs(xerr - md.back().uerr) > 0.2f * xerr ||
                 std::abs(zerr - md.back().verr) > 0.2f * zerr)
               md.emplace_back(Elem{zi, zo, xerr, zerr});
           }  // loop on layers
       }
     }  // loop on z
  
   }  // loop  on tanLa
  
   // sort
   for (auto& e : msParam.data)
     for (auto& d : e.second.data)
       std::stable_sort(d.data.begin(), d.data.end(), [](auto const& a, auto const& b) { return a.vo < b.vo; });
  
   return product;
 }