#include <TrackingMaterialAnalyser.h>

Inheritance diagram for TrackingMaterialAnalyser:

Public Member Functions
	TrackingMaterialAnalyser (const edm::ParameterSet &)

	~TrackingMaterialAnalyser () override

Public Member Functions inherited from edm::one::EDAnalyzer<>
	EDAnalyzer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Types
enum	SplitMode { NEAREST_LAYER, INNER_LAYER, OUTER_LAYER, UNDEFINED }

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	beginJob () override

void	endJob () override

int	findLayer (const MaterialAccountingDetector &detector)

void	saveLayerPlots ()

void	saveParameters (const char *name)

void	saveXml (const char *name)

void	split (MaterialAccountingTrack &track)

Private Attributes
std::vector< std::string >	m_groupNames

std::vector< MaterialAccountingGroup * >	m_groups

bool	m_isHFNose

bool	m_isHGCal

edm::EDGetTokenT< std::vector< MaterialAccountingTrack > >	m_materialToken

TrackingMaterialPlotter *	m_plotter

bool	m_saveDetailedPlots

bool	m_saveParameters

bool	m_saveSummaryPlot

bool	m_saveXml

bool	m_skipAfterLastDetector

bool	m_skipBeforeFirstDetector

SplitMode	m_splitMode

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 16 of file TrackingMaterialAnalyser.h.

Member Enumeration Documentation

enum TrackingMaterialAnalyser::SplitMode

private

Enumerator
NEAREST_LAYER
INNER_LAYER
OUTER_LAYER
UNDEFINED

Definition at line 22 of file TrackingMaterialAnalyser.h.

22 { NEAREST_LAYER, INNER_LAYER, OUTER_LAYER, UNDEFINED };

TrackingMaterialAnalyser::UNDEFINED

Definition: TrackingMaterialAnalyser.h:22

TrackingMaterialAnalyser::NEAREST_LAYER

Definition: TrackingMaterialAnalyser.h:22

TrackingMaterialAnalyser::OUTER_LAYER

Definition: TrackingMaterialAnalyser.h:22

TrackingMaterialAnalyser::INNER_LAYER

Definition: TrackingMaterialAnalyser.h:22

Constructor & Destructor Documentation

TrackingMaterialAnalyser::TrackingMaterialAnalyser ( const edm::ParameterSet & iPSet )

explicit

Definition at line 29 of file TrackingMaterialAnalyser.cc.

References Exception, edm::ParameterSet::getParameter(), INNER_LAYER, edm::errors::LogicError, m_groupNames, m_isHFNose, m_isHGCal, m_materialToken, m_plotter, m_saveDetailedPlots, m_saveParameters, m_saveSummaryPlot, m_saveXml, m_skipAfterLastDetector, m_skipBeforeFirstDetector, m_splitMode, NEAREST_LAYER, OUTER_LAYER, AlCaHLTBitMon_QueryRunRegistry::string, and UNDEFINED.

                                                                                {
   m_materialToken =
       consumes<std::vector<MaterialAccountingTrack> >(iPSet.getParameter<edm::InputTag>("MaterialAccounting"));
   m_groupNames = iPSet.getParameter<std::vector<std::string> >("Groups");
   const std::string& splitmode = iPSet.getParameter<std::string>("SplitMode");
   if (strcasecmp(splitmode.c_str(), "NearestLayer") == 0) {
     m_splitMode = NEAREST_LAYER;
   } else if (strcasecmp(splitmode.c_str(), "InnerLayer") == 0) {
     m_splitMode = INNER_LAYER;
   } else if (strcasecmp(splitmode.c_str(), "OuterLayer") == 0) {
     m_splitMode = OUTER_LAYER;
   } else {
     m_splitMode = UNDEFINED;
     throw edm::Exception(edm::errors::LogicError)
         << "Invalid SplitMode \"" << splitmode
         << "\". Acceptable values are \"NearestLayer\", \"InnerLayer\", \"OuterLayer\".";
   }
   m_skipAfterLastDetector = iPSet.getParameter<bool>("SkipAfterLastDetector");
   m_skipBeforeFirstDetector = iPSet.getParameter<bool>("SkipBeforeFirstDetector");
   m_saveSummaryPlot = iPSet.getParameter<bool>("SaveSummaryPlot");
   m_saveDetailedPlots = iPSet.getParameter<bool>("SaveDetailedPlots");
   m_saveParameters = iPSet.getParameter<bool>("SaveParameters");
   m_saveXml = iPSet.getParameter<bool>("SaveXML");
   m_isHGCal = iPSet.getParameter<bool>("isHGCal");
   m_isHFNose = iPSet.getParameter<bool>("isHFNose");
   if (m_saveSummaryPlot) {
     if (m_isHGCal) {
       m_plotter = new TrackingMaterialPlotter(550., 300., 10);
     } else if (m_isHFNose) {
       m_plotter = new TrackingMaterialPlotter(1200., 350., 10);
     } else {
       m_plotter = new TrackingMaterialPlotter(300., 120., 10);
     }  // 10x10 points per cm2
   } else {
     m_plotter = nullptr;
   }
 }

TrackingMaterialAnalyser::~TrackingMaterialAnalyser ( void )

override

Definition at line 68 of file TrackingMaterialAnalyser.cc.

References m_plotter.

                                                         {
   if (m_plotter)
     delete m_plotter;
 }

Member Function Documentation

void TrackingMaterialAnalyser::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	setup
	)

overrideprivate

Definition at line 145 of file TrackingMaterialAnalyser.cc.

References end, edm::EventSetup::get(), mps_fire::i, m_groupNames, m_groups, m_materialToken, split(), OrderedSet::t, and HLT_2018_cff::track.

                                                                                         {
   using namespace edm;
   ESTransientHandle<DDCompactView> hDDD;
   setup.get<IdealGeometryRecord>().get(hDDD);
 
   m_groups.reserve(m_groupNames.size());
   // Initialize m_groups iff it has size equal to zero, so that we are
   // sure it will never be repopulated with the same entries over and
   // over again in the eventloop, at each call of the analyze method.
   if (m_groups.empty()) {
     for (unsigned int i = 0; i < m_groupNames.size(); ++i)
       m_groups.push_back(new MaterialAccountingGroup(m_groupNames[i], *hDDD));
 
     LogInfo("TrackingMaterialAnalyser") << "TrackingMaterialAnalyser: List of the tracker groups: " << std::endl;
     for (unsigned int i = 0; i < m_groups.size(); ++i)
       LogInfo("TrackingMaterialAnalyser") << i << " TrackingMaterialAnalyser:\t" << m_groups[i]->info() << std::endl;
   }
   Handle<std::vector<MaterialAccountingTrack> > h_tracks;
   event.getByToken(m_materialToken, h_tracks);
 
   for (std::vector<MaterialAccountingTrack>::const_iterator t = h_tracks->begin(), end = h_tracks->end(); t != end;
        ++t) {
     MaterialAccountingTrack track(*t);
     split(track);
   }
 }

void TrackingMaterialAnalyser::beginJob ( void )

inlineoverrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 25 of file TrackingMaterialAnalyser.h.

References hgcalTestNeighbor_cfi::detector, endJob(), findLayer(), Skims_PA_cff::name, saveLayerPlots(), saveParameters(), saveXml(), split(), and HLT_2018_cff::track.

25 {}

void TrackingMaterialAnalyser::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 126 of file TrackingMaterialAnalyser.cc.

References m_plotter, m_saveDetailedPlots, m_saveParameters, m_saveSummaryPlot, m_saveXml, saveLayerPlots(), saveParameters(), and saveXml().

Referenced by beginJob().

                                           {
   if (m_saveParameters)
     saveParameters("parameters");
 
   if (m_saveXml)
     saveXml("parameters.xml");
 
   if (m_saveDetailedPlots)
     saveLayerPlots();
 
   if (m_saveSummaryPlot and m_plotter) {
     m_plotter->normalize();
     m_plotter->draw();
   }
 }

int TrackingMaterialAnalyser::findLayer ( const MaterialAccountingDetector & detector )

private

Definition at line 339 of file TrackingMaterialAnalyser.cc.

References beam_dqm_sourceclient-live_cfg::cerr, DEFINE_FWK_MODULE, alignBH_cfg::fixed, mps_fire::i, m_groups, PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::phi(), MaterialAccountingDetector::position(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by beginJob(), and split().

                                                                                   {
   int index = 0;
   size_t inside = 0;
   for (size_t i = 0; i < m_groups.size(); ++i)
     if (m_groups[i]->inside(detector)) {
       ++inside;
       index = i + 1;
     }
   if (inside == 0) {
     index = 0;
     std::cerr << "TrackingMaterialAnalyser::findLayer(...): ERROR: detector does not belong to any DetLayer"
               << std::endl;
     std::cerr << "TrackingMaterialAnalyser::findLayer(...): detector position: " << std::fixed
               << " (r: " << std::setprecision(1) << std::setw(5) << detector.position().perp()
               << ", z: " << std::setprecision(1) << std::setw(6) << detector.position().z()
               << ", phi: " << std::setprecision(3) << std::setw(6) << detector.position().phi() << ")" << std::endl;
   }
   if (inside > 1) {
     index = 0;
     std::cerr << "TrackingMaterialAnalyser::findLayer(...): ERROR: detector belongs to " << inside << " DetLayers"
               << std::endl;
     std::cerr << "TrackingMaterialAnalyser::findLayer(...): detector position: " << std::fixed
               << " (r: " << std::setprecision(1) << std::setw(5) << detector.position().perp()
               << ", z: " << std::setprecision(1) << std::setw(6) << detector.position().z()
               << ", phi: " << std::setprecision(3) << std::setw(6) << detector.position().phi() << ")" << std::endl;
   }
 
   return index;
 }

void TrackingMaterialAnalyser::saveLayerPlots ( )

private

Definition at line 118 of file TrackingMaterialAnalyser.cc.

References mps_fire::i, m_groups, and MaterialAccountingGroup::savePlots().

Referenced by beginJob(), and endJob().

                                               {
   for (unsigned int i = 0; i < m_groups.size(); ++i) {
     MaterialAccountingGroup& layer = *(m_groups[i]);
     layer.savePlots();
   }
 }

void TrackingMaterialAnalyser::saveParameters ( const char * name )

private

Definition at line 74 of file TrackingMaterialAnalyser.cc.

References MaterialAccountingGroup::averageEnergyLoss(), MaterialAccountingGroup::averageLength(), MaterialAccountingGroup::averageRadiationLengths(), gather_cfg::cout, dqm-mbProfile::format, mps_fire::i, m_groups, MaterialAccountingGroup::name(), MaterialAccountingGroup::sigmaEnergyLoss(), MaterialAccountingGroup::sigmaLength(), MaterialAccountingGroup::sigmaRadiationLengths(), and MaterialAccountingGroup::tracks().

Referenced by beginJob(), and endJob().

                                                               {
   std::ofstream parameters(name);
   std::cout << std::endl;
   for (unsigned int i = 0; i < m_groups.size(); ++i) {
     MaterialAccountingGroup& layer = *(m_groups[i]);
     std::cout << layer.name() << std::endl;
     std::cout << boost::format("\tnumber of hits:               %9d") % layer.tracks() << std::endl;
     std::cout << boost::format("\tnormalized segment length:    %9.1f ± %9.1f cm") % layer.averageLength() %
                      layer.sigmaLength()
               << std::endl;
     std::cout << boost::format("\tnormalized radiation lengths: %9.3f ± %9.3f") % layer.averageRadiationLengths() %
                      layer.sigmaRadiationLengths()
               << std::endl;
     std::cout << boost::format("\tnormalized energy loss:       %6.5fe-03 ± %6.5fe-03 GeV") %
                      layer.averageEnergyLoss() % layer.sigmaEnergyLoss()
               << std::endl;
     parameters << boost::format("%-20s\t%7d\t%5.1f ± %5.1f cm\t%6.4f ± %6.4f \t%6.4fe-03 ± %6.4fe-03 GeV") %
                       layer.name() % layer.tracks() % layer.averageLength() % layer.sigmaLength() %
                       layer.averageRadiationLengths() % layer.sigmaRadiationLengths() % layer.averageEnergyLoss() %
                       layer.sigmaEnergyLoss()
                << std::endl;
   }
   std::cout << std::endl;
 
   parameters.close();
 }

void TrackingMaterialAnalyser::saveXml ( const char * name )

private

Definition at line 102 of file TrackingMaterialAnalyser.cc.

References MaterialAccountingGroup::averageEnergyLoss(), MaterialAccountingGroup::averageRadiationLengths(), mps_fire::i, m_groups, and MaterialAccountingGroup::name().

Referenced by beginJob(), and endJob().

                                                        {
   std::ofstream xml(name);
   xml << "<?xml version=\"1.0\" encoding=\"utf-8\"?>" << std::endl;
   xml << "<Groups>" << std::endl;
   for (unsigned int i = 0; i < m_groups.size(); ++i) {
     MaterialAccountingGroup& layer = *(m_groups[i]);
     xml << "  <Group name=\"" << layer.name() << "\">\n"
         << "    <Parameter name=\"TrackerRadLength\" value=\"" << layer.averageRadiationLengths() << "\"/>\n"
         << "    <Parameter name=\"TrackerXi\" value=\"" << layer.averageEnergyLoss() << "\"/>\n"
         << "  </Group>\n"
         << std::endl;
   }
   xml << "</Groups>" << std::endl;
 }

void TrackingMaterialAnalyser::split ( MaterialAccountingTrack & track )

private

Definition at line 181 of file TrackingMaterialAnalyser.cc.

References begin, beam_dqm_sourceclient-live_cfg::cerr, MuonGeometrySanityCheck_cfi::detectors(), MaterialAccountingTrack::detectors(), end, Exception, findLayer(), HLT_2018_cff::fraction, watchdog::group, mps_fire::i, INNER_LAYER, MaterialAccountingStep::length(), TH2PolyOfflineMaps::limits, edm::errors::LogicError, m_groups, m_plotter, m_skipAfterLastDetector, m_skipBeforeFirstDetector, m_splitMode, NEAREST_LAYER, or, OUTER_LAYER, contentValuesFiles::parts, TrackingMaterialPlotter::plotSegmentInLayer(), TrackingMaterialPlotter::plotSegmentUnassigned(), MaterialAccountingStep::split(), MaterialAccountingTrack::steps(), MaterialAccountingTrack::summary(), and UNDEFINED.

Referenced by analyze(), and beginJob().

                                                                    {
   using namespace edm;
   // group sensitive detectors by their DetLayer
   std::vector<int> group(track.detectors().size());
   for (unsigned int i = 0; i < track.detectors().size(); ++i)
     group[i] = findLayer(track.detectors()[i]);
 
   for (unsigned int i = 0; i < group.size(); ++i)
     if (group[i] > 0)
       LogInfo("TrackingMaterialAnalyser") << "For detector i: " << i << " index: " << group[i]
                                           << " R-ranges: " << m_groups[group[i] - 1]->getBoundingR().first << ", "
                                           << m_groups[group[i] - 1]->getBoundingR().second << group[i]
                                           << " Z-ranges: " << m_groups[group[i] - 1]->getBoundingZ().first << ", "
                                           << m_groups[group[i] - 1]->getBoundingZ().second << std::endl;
 
   unsigned int detectors = track.detectors().size();
   if (detectors == 0) {
     // the track doesn't cross any active detector:
     // keep al material as unassigned
     if (m_plotter)
       for (unsigned int i = 1; i < track.steps().size(); ++i)
         m_plotter->plotSegmentUnassigned(track.steps()[i]);
   } else {
     const double TOLERANCE = 0.0001;  // 1 um tolerance
     std::vector<double> limits(detectors + 2);
 
     // define the trivial limits
     if (m_skipBeforeFirstDetector)
       limits[0] = track.detectors()[0].m_curvilinearIn - TOLERANCE;
     else
       limits[0] = -TOLERANCE;
     if (m_skipAfterLastDetector)
       limits[detectors] = track.detectors()[detectors - 1].m_curvilinearOut + TOLERANCE;
     else
       limits[detectors] = track.summary().length() + TOLERANCE;
     limits[detectors + 1] = INFINITY;  // this is probably no more needed, but doesn't harm...
 
     // pick the algorithm to define the non-trivial limits
     switch (m_splitMode) {
       // assign each segment to the the nearest layer
       // e.g. the material between pixel barrel 3 and TIB 1 will be split among the two
       case NEAREST_LAYER:
         for (unsigned int i = 1; i < detectors; ++i) {
           limits[i] = (track.detectors()[i - 1].m_curvilinearOut + track.detectors()[i].m_curvilinearIn) / 2.;
         }
         break;
 
       // assign each segment to the the inner layer
       // e.g. all material between pixel barrel 3 and TIB 1 will go into the pixel barrel
       case INNER_LAYER:
         for (unsigned int i = 1; i < detectors; ++i)
           limits[i] = track.detectors()[i].m_curvilinearIn - TOLERANCE;
         break;
 
       // assign each segment to the the outer layer
       // e.g. all material between pixel barrel 3 and TIB 1 will go into the TIB
       case OUTER_LAYER:
         for (unsigned int i = 1; i < detectors; ++i)
           limits[i] = track.detectors()[i - 1].m_curvilinearOut + TOLERANCE;
         break;
 
       case UNDEFINED:
         [[fallthrough]];
 
       default:
         // throw something
         throw edm::Exception(edm::errors::LogicError) << "Invalid SplitMode";
     }
 
     double begin = 0.;   // beginning of step, along the track
     double end = 0.;     // end of step, along the track
     unsigned int i = 1;  // step conter
 
     // skip the material before the first layer
     while (end < limits[0]) {
       const MaterialAccountingStep& step = track.steps()[i++];
       end = begin + step.length();
 
       // do not account material before the first layer
       if (m_plotter)
         m_plotter->plotSegmentUnassigned(step);
 
       begin = end;
     }
 
     unsigned int index = 0;  // which detector
     while (i < track.steps().size()) {
       const MaterialAccountingStep& step = track.steps()[i++];
 
       end = begin + step.length();
 
       if (begin > limits[detectors]) {
         // segment after last layer and skipping requested in configuation
         if (m_plotter)
           m_plotter->plotSegmentUnassigned(step);
         begin = end;
         continue;
       }
 
       // from here onwards we should be in the accountable region, either completely in a single layer:
       //   limits[index] <= begin < end <= limits[index+1]
       // or possibly split between 2 layers
       //   limits[index] < begin < limits[index+1] < end <  limits[index+2]
       if (begin < limits[index] or end > limits[index + 2]) {
         // sanity check
         std::cerr << "MaterialAccountingTrack::split(): ERROR: internal logic error, expected " << limits[index]
                   << " < " << begin << " < " << limits[index + 1] << std::endl;
         break;
       }
 
       if (limits[index] <= begin and end <= limits[index + 1]) {
         // step completely inside current detector range
         track.detectors()[index].account(step, begin, end);
         if (m_plotter)
           m_plotter->plotSegmentInLayer(step, group[index]);
       } else {
         // step shared beteewn two detectors, transition at limits[index+1]
         double fraction = (limits[index + 1] - begin) / (end - begin);
         assert(fraction < 1.);
         std::pair<MaterialAccountingStep, MaterialAccountingStep> parts = step.split(fraction);
 
         if (m_plotter) {
           if (index > 0)
             m_plotter->plotSegmentInLayer(parts.first, group[index]);
           else
             // track outside acceptance, keep as unassocated
             m_plotter->plotSegmentUnassigned(parts.first);
 
           if (index + 1 < detectors)
             m_plotter->plotSegmentInLayer(parts.second, group[index + 1]);
           else
             // track outside acceptance, keep as unassocated
             m_plotter->plotSegmentUnassigned(parts.second);
         }
 
         track.detectors()[index].account(parts.first, begin, limits[index + 1]);
         ++index;  // next layer
         if (index < detectors)
           track.detectors()[index].account(parts.second, limits[index + 1], end);
       }
       begin = end;
     }
   }
 
   // add the material from each detector to its layer (if there is one and only one)
   for (unsigned int i = 0; i < track.detectors().size(); ++i)
     if (group[i] != 0)
       m_groups[group[i] - 1]->addDetector(track.detectors()[i]);
 
   // end of track: commit internal buffers and reset the m_groups internal state for a new track
   for (unsigned int i = 0; i < m_groups.size(); ++i)
     m_groups[i]->endOfTrack();
 }