#include <StepHistogram.h>

Inheritance diagram for G4UA::StepHistogram:

Collaboration diagram for G4UA::StepHistogram:

Classes
struct	Config

struct	Report
	this holds all the data from individual threads that needs to be merged at EoR More...

Public Types
typedef std::map< G4String, TH1 * >	HistoMap_t

typedef std::map< G4String, HistoMap_t >	HistoMapMap_t

Public Member Functions
virtual void	UserSteppingAction (const G4Step *) override
	the hooks for G4 UA handling More...

	StepHistogram (const Config &)
	ctor More...

const Report &	getReport () const

bool	msgLvl (const MSG::Level lvl) const
	Test the output level. More...

MsgStream &	msg () const
	The standard message stream. More...

MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream. More...

void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

Private Member Functions
void	InitializeFillHistogram2D (HistoMapMap_t &hMapMap, const char *suffix, const G4String &pdgId, const G4String &vol, int nbinsx, double xmin, double xmax, int nbinsy, double ymin, double ymax, double valuex, double valuey, double weight)

void	InitializeFillHistogram (HistoMapMap_t &hMapMap, const char *suffix, const G4String &pdgId, const G4String &vol, int nbins, double xmin, double xmax, double value, double weight)

void	InitializeFillHistogram (HistoMapMap_t &hMapMap, const char suffix, const G4String &pdgId, const G4String &vol, int nbins, double edges, double value, double weight)

void	initMessaging () const
	Initialize our message level and MessageSvc. More...

Private Attributes
Report	m_report

Config	m_config
	configuration data More...

float	m_initialKineticEnergyOfStep

G4String	m_initialVolume

G4String	m_initialMaterial

G4String	m_initialProcess

int	m_trackID = 0

std::string	m_nm
	Message source name. More...

boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...

std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...

std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...

std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging) More...

Detailed Description

Definition at line 29 of file StepHistogram.h.

Member Typedef Documentation

◆ HistoMap_t

typedef std::map<G4String, TH1*> G4UA::StepHistogram::HistoMap_t

Definition at line 39 of file StepHistogram.h.

◆ HistoMapMap_t

typedef std::map<G4String, HistoMap_t> G4UA::StepHistogram::HistoMapMap_t

Definition at line 40 of file StepHistogram.h.

Constructor & Destructor Documentation

◆ StepHistogram()

G4UA::StepHistogram::StepHistogram ( const Config & config )

ctor

Definition at line 30 of file StepHistogram.cxx.

                                                   :
     AthMessaging(Gaudi::svcLocator()->service<IMessageSvc>("MessageSvc"),"StepHistogram"),
     m_config(config),
     m_initialKineticEnergyOfStep(),
     m_initialVolume(),
     m_initialMaterial(),
     m_initialProcess()
   {}

Member Function Documentation

◆ getReport()

const Report& G4UA::StepHistogram::getReport ( ) const

inline

Definition at line 116 of file StepHistogram.h.

116 { return m_report; }

◆ InitializeFillHistogram() [1/2]

void G4UA::StepHistogram::InitializeFillHistogram	(	HistoMapMap_t &	hMapMap,
		const char *	suffix,
		const G4String &	pdgId,
		const G4String &	vol,
		int	nbins,
		double *	edges,
		double	value,
		double	weight
	)

private

Definition at line 256 of file StepHistogram.cxx.

   {
     const auto& [pStringMapPair, inserted] = hMapMap.try_emplace(vol,HistoMap_t());
     HistoMap_t &hMap = pStringMapPair->second;
     if ( hMap.find(particleName) == hMap.end() ) {
       // initialize histogram if not yet exist
       std::ostringstream stringStream;
       stringStream << vol << "_" << particleName << "_" << suffix;
       hMap[particleName] = new TH1F(stringStream.str().c_str(), stringStream.str().c_str(), nbins, edges);
     }
     hMap[particleName]->Fill(value, weight);
   }

◆ InitializeFillHistogram() [2/2]

void G4UA::StepHistogram::InitializeFillHistogram	(	HistoMapMap_t &	hMapMap,
		const char *	suffix,
		const G4String &	pdgId,
		const G4String &	vol,
		int	nbins,
		double	xmin,
		double	xmax,
		double	value,
		double	weight
	)

private

Definition at line 241 of file StepHistogram.cxx.

   {
     const auto& [pStringMapPair, inserted] = hMapMap.try_emplace(vol,HistoMap_t());
     HistoMap_t &hMap = pStringMapPair->second;
     if ( hMap.find(particleName) == hMap.end() ) {
       // initialize histogram if not yet exist
       std::ostringstream stringStream;
       stringStream << vol << "_" << particleName << "_" << suffix;
       hMap[particleName] = new TH1F(stringStream.str().c_str(), stringStream.str().c_str(), nbins, xmin, xmax);
     }
     hMap[particleName]->Fill(value, weight);
   }

◆ InitializeFillHistogram2D()

void G4UA::StepHistogram::InitializeFillHistogram2D	(	HistoMapMap_t &	hMapMap,
		const char *	suffix,
		const G4String &	pdgId,
		const G4String &	vol,
		int	nbinsx,
		double	xmin,
		double	xmax,
		int	nbinsy,
		double	ymin,
		double	ymax,
		double	valuex,
		double	valuey,
		double	weight
	)

private

Definition at line 224 of file StepHistogram.cxx.

   {
     const auto& [pStringMapPair, inserted] = hMapMap.try_emplace(vol,HistoMap_t());
     HistoMap_t &hMap = pStringMapPair->second;
     if ( hMap.find(particleName) == hMap.end() ) {
       // initialize histogram if not yet exist
       std::ostringstream stringStream;
       stringStream << vol << "_" << particleName << "_" << suffix;
       hMap[particleName] = new TH2F(stringStream.str().c_str(), stringStream.str().c_str(), nbinsx, xmin, xmax, nbinsy, ymin, ymax);
     }
     static_cast<TH2*>(hMap[particleName])->Fill(valuex, valuey, weight);
   }

◆ initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 42 of file AthMessaging.cxx.

 {
   m_imsg = Athena::getMessageSvc();
   m_lvl = m_imsg ?
     static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
     MSG::INFO;
 }

◆ msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 164 of file AthMessaging.h.

 {
   MsgStream* ms = m_msg_tls.get();
   if (!ms) {
     if (!m_initialized.test_and_set()) initMessaging();
     ms = new MsgStream(m_imsg,m_nm);
     m_msg_tls.reset( ms );
   }
  
   ms->setLevel (m_lvl);
   return *ms;
 }

◆ msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 179 of file AthMessaging.h.

180 { return msg() << lvl; }

◆ msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns: boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

 {
   if (!m_initialized.test_and_set()) initMessaging();
   if (m_lvl <= lvl) {
     msg() << lvl;
     return true;
   } else {
     return false;
   }
 }

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

 {
   // Ensure initMessaging was called to avoid that the user
   // defined message level is being overwritten (ATEAM-1117).
   if (!m_initialized.test_and_set()) initMessaging();
   m_lvl = lvl;
 }

◆ UserSteppingAction()

void G4UA::StepHistogram::UserSteppingAction ( const G4Step * aStep )

overridevirtual

the hooks for G4 UA handling

Definition at line 39 of file StepHistogram.cxx.

                                                             {
  
     // track
     G4Track *tr = aStep->GetTrack();
  
     // pre-step point
     G4StepPoint *PreStepPoint = aStep->GetPreStepPoint();
  
     // post-step point
     G4StepPoint *PostStepPoint = aStep->GetPostStepPoint();
  
     // pre-step kinetic energy
     double stepKinetic = PreStepPoint->GetKineticEnergy();
  
     // post-step kinetic energy
     double postStepKinetic = PostStepPoint->GetKineticEnergy();
  
     // pre-step position
     const G4ThreeVector& myPos = PreStepPoint->GetPosition();
  
     // particle name
     G4String particleName = "nucleus";
     if (!(tr->GetDefinition()->GetParticleType() == "nucleus"))
       particleName = G4DebuggingHelpers::ClassifyParticle(tr->GetParticleDefinition());
  
     // pre-step volume
     G4String volumeName = PreStepPoint->GetPhysicalVolume()->GetName();
     volumeName = G4DebuggingHelpers::ClassifyVolume(volumeName);
  
     // pre-step material
     G4String materialName = PreStepPoint->GetMaterial()->GetName();
     materialName = G4DebuggingHelpers::ClassifyMaterial(materialName);
  
     // process name (uses post-step point)
     G4String processName = PostStepPoint->GetProcessDefinedStep() ?
                            PostStepPoint->GetProcessDefinedStep()->GetProcessName() : "Unknown";
  
     // secondaries
     const std::vector<const G4Track*>* secondaries = aStep->GetSecondaryInCurrentStep();
  
     // 2D map
     if (m_config.do2DHistograms) {
       float DepositedE = aStep->GetTotalEnergyDeposit();
       InitializeFillHistogram2D(m_report.histoMapMap2D_vol_RZ, "vol_RZ", particleName, volumeName,
                               2000, -20000, 20000, 1000, 0, 5000, myPos.getZ(), myPos.perp(), 1.);
       InitializeFillHistogram2D(m_report.histoMapMap2D_mat_RZ, "mat_RZ", particleName, materialName,
                               2000, -20000, 20000, 1000, 0, 5000, myPos.getZ(), myPos.perp(), 1.);
       InitializeFillHistogram2D(m_report.histoMapMap2D_prc_RZ, "prc_RZ", particleName, processName,
                               2000, -20000, 20000, 1000, 0, 5000, myPos.getZ(), myPos.perp(), 1.);
       InitializeFillHistogram2D(m_report.histoMapMap2D_vol_RZ_E, "vol_RZ_E", particleName, volumeName,
                               2000, -20000, 20000, 1000, 0, 5000, myPos.getZ(), myPos.perp(), DepositedE);
       InitializeFillHistogram2D(m_report.histoMapMap2D_mat_RZ_E, "mat_RZ_E", particleName, materialName,
                               2000, -20000, 20000, 1000, 0, 5000, myPos.getZ(), myPos.perp(), DepositedE);
     }
  
     // step length
     InitializeFillHistogram(m_report.histoMapMap_vol_stepSize, "vol_stepLength", particleName, volumeName,
                             1000, -12, 4, std::log10(aStep->GetStepLength()), 1.);
     InitializeFillHistogram(m_report.histoMapMap_mat_stepSize, "mat_stepLength", particleName, materialName,
                             1000, -12, 4, std::log10(aStep->GetStepLength()), 1.);
     InitializeFillHistogram(m_report.histoMapMap_prc_stepSize, "prc_stepLength", particleName, processName,
                             1000, -12, 4, std::log10(aStep->GetStepLength()), 1.);
  
     // step pseudorapidity    
     InitializeFillHistogram(m_report.histoMapMap_vol_stepPseudorapidity, "vol_stepPseudorapidity", particleName, volumeName,
                             200, -10, 10, myPos.eta(), 1.);
     InitializeFillHistogram(m_report.histoMapMap_mat_stepPseudorapidity, "mat_stepPseudorapidity", particleName, materialName,
                             200, -10, 10, myPos.eta(), 1.);
     InitializeFillHistogram(m_report.histoMapMap_prc_stepPseudorapidity, "prc_stepPseudorapidity", particleName, processName,
                             200, -10, 10, myPos.eta(), 1.);
  
     // step kinetic energy
     InitializeFillHistogram(m_report.histoMapMap_vol_stepKineticEnergy, "vol_stepKineticEnergy", particleName, volumeName,
                             1000, -9, 7, std::log10(stepKinetic), 1.);
     InitializeFillHistogram(m_report.histoMapMap_mat_stepKineticEnergy, "mat_stepKineticEnergy", particleName, materialName,
                             1000, -9, 7, std::log10(stepKinetic), 1.);
     InitializeFillHistogram(m_report.histoMapMap_prc_stepKineticEnergy, "prc_stepKineticEnergy", particleName, processName,
                             1000, -9, 7, std::log10(stepKinetic), 1.);
     InitializeFillHistogram(m_report.histoMapMap_stepKinetic, "stepKineticEnergy", particleName, "AllATLAS",
                             1000, -9, 7, std::log10(stepKinetic), 1.);
  
     // post step kinetic energy
     InitializeFillHistogram(m_report.histoMapMap_vol_postStepKineticEnergy, "vol_postStepKineticEnergy", particleName, volumeName,
                             1000, -9, 7, std::log10(postStepKinetic), 1.);
     InitializeFillHistogram(m_report.histoMapMap_mat_postStepKineticEnergy, "mat_postStepKineticEnergy", particleName, materialName,
                             1000, -9, 7, std::log10(postStepKinetic), 1.);
     InitializeFillHistogram(m_report.histoMapMap_prc_postStepKineticEnergy, "prc_postStepKineticEnergy", particleName, processName,
                             1000, -9, 7, std::log10(postStepKinetic), 1.);
     InitializeFillHistogram(m_report.histoMapMap_postStepKinetic, "postStepKineticEnergy", particleName, "AllATLAS",
                             1000, -9, 7, std::log10(postStepKinetic), 1.);
  
     // step energy deposit
     InitializeFillHistogram(m_report.histoMapMap_vol_stepEnergyDeposit, "vol_stepEnergyDeposit", particleName, volumeName,
                             1000, -11, 3, std::log10(aStep->GetTotalEnergyDeposit()), 1.);
     InitializeFillHistogram(m_report.histoMapMap_mat_stepEnergyDeposit, "mat_stepEnergyDeposit", particleName, materialName,
                             1000, -11, 3, std::log10(aStep->GetTotalEnergyDeposit()), 1.);
     InitializeFillHistogram(m_report.histoMapMap_prc_stepEnergyDeposit, "prc_stepEnergyDeposit", particleName, processName,
                             1000, -11, 3, std::log10(aStep->GetTotalEnergyDeposit()), 1.);
  
     // step non-ionizing energy deposit
     InitializeFillHistogram(m_report.histoMapMap_vol_stepEnergyNonIonDeposit, "vol_stepEnergyNonIonDeposit", particleName, volumeName,
                             1000, -11, 1, std::log10(aStep->GetNonIonizingEnergyDeposit()), 1.);
     InitializeFillHistogram(m_report.histoMapMap_mat_stepEnergyNonIonDeposit, "mat_stepEnergyNonIonDeposit", particleName, materialName,
                             1000, -11, 1, std::log10(aStep->GetNonIonizingEnergyDeposit()), 1.);
     InitializeFillHistogram(m_report.histoMapMap_prc_stepEnergyNonIonDeposit, "prc_stepEnergyNonIonDeposit", particleName, processName,
                             1000, -11, 1, std::log10(aStep->GetNonIonizingEnergyDeposit()), 1.);
  
     // secondary kinetic energy
     for (const auto &track : *secondaries) {
       G4String secondary_particleName = G4DebuggingHelpers::ClassifyParticle(track->GetParticleDefinition());
       InitializeFillHistogram(m_report.histoMapMap_vol_stepSecondaryKinetic, "vol_stepSecondaryKinetic", secondary_particleName, volumeName,
                               1000, -7, 5, std::log10(track->GetKineticEnergy()), 1.);
       InitializeFillHistogram(m_report.histoMapMap_mat_stepSecondaryKinetic, "mat_stepSecondaryKinetic", secondary_particleName, materialName,
                               1000, -7, 5, std::log10(track->GetKineticEnergy()), 1.);
       InitializeFillHistogram(m_report.histoMapMap_prc_stepSecondaryKinetic, "prc_stepSecondaryKinetic", secondary_particleName, processName,
                               1000, -7, 5, std::log10(track->GetKineticEnergy()), 1.);
     }
  
     // stop here if 'general' histograms not activated
     // _______________________________________________
     if (!m_config.doGeneralHistograms)
       return;
  
     // first step (after initial step)
     if (tr->GetCurrentStepNumber()==1) {
       // initial kinetic energy
       m_initialKineticEnergyOfStep = stepKinetic;
       
       // initial volume/material/processes
       m_initialVolume = std::move(volumeName);
       m_initialMaterial = std::move(materialName);
       m_initialProcess = std::move(processName);
  
       // save track ID for checking if we later have the same track
       m_trackID = tr->GetTrackID();
  
       // initial energy
       InitializeFillHistogram(m_report.histoMapMap_InitialE, "InitialE", particleName, "AllATLAS",
                               1000, -9, 7, std::log10(m_initialKineticEnergyOfStep), 1.0);
       InitializeFillHistogram(m_report.histoMapMap_vol_InitialE, "vol_InitialE", particleName, m_initialVolume,
                               1000, -9, 7, std::log10(m_initialKineticEnergyOfStep), 1.0);
       InitializeFillHistogram(m_report.histoMapMap_mat_InitialE, "mat_InitialE", particleName, m_initialMaterial,
                               1000, -9, 7, std::log10(m_initialKineticEnergyOfStep), 1.0);
       InitializeFillHistogram(m_report.histoMapMap_prc_InitialE, "prc_InitialE", particleName, m_initialProcess,
                               1000, -9, 7, std::log10(m_initialKineticEnergyOfStep), 1.0);
     }
  
     // last step
     if ( tr->GetTrackStatus() == 2 ) {
       // assert to check if we have the correct track
       if (not (tr->GetTrackID() == m_trackID)) {
         ATH_MSG_ERROR("Track ID changed between the assumed first step and the last.");
         throw std::exception();
       }
       // number of steps
       int nSteps = tr->GetCurrentStepNumber() + 1;
       InitializeFillHistogram(m_report.histoMapMap_numberOfSteps, "numberOfSteps", particleName, "AllATLAS",
                               10000, 0.5, 10000.5, nSteps, 1.);
       InitializeFillHistogram(m_report.histoMapMap_vol_numberOfSteps, "vol_numberOfSteps", particleName, m_initialVolume,
                               10000, 0.5, 10000.5, nSteps, 1.);
       InitializeFillHistogram(m_report.histoMapMap_mat_numberOfSteps, "mat_numberOfSteps", particleName, m_initialMaterial,
                               10000, 0.5, 10000.5, nSteps, 1.);
       InitializeFillHistogram(m_report.histoMapMap_prc_numberOfSteps, "prc_numberOfSteps", particleName, m_initialProcess,
                               10000, 0.5, 10000.5, nSteps, 1.);
       // number of steps vs initial energy
       InitializeFillHistogram(m_report.histoMapMap_numberOfStepsPerInitialE, "numberOfStepsPerInitialE", particleName, "AllATLAS",
                               1000, -9, 7, std::log10(m_initialKineticEnergyOfStep), nSteps);
       InitializeFillHistogram(m_report.histoMapMap_vol_numberOfStepsPerInitialE, "vol_numberOfStepsPerInitialE", particleName, m_initialVolume,
                               1000, -9, 7, std::log10(m_initialKineticEnergyOfStep), nSteps);
       InitializeFillHistogram(m_report.histoMapMap_mat_numberOfStepsPerInitialE, "mat_numberOfStepsPerInitialE", particleName, m_initialMaterial,
                               1000, -9, 7, std::log10(m_initialKineticEnergyOfStep), nSteps);
       InitializeFillHistogram(m_report.histoMapMap_prc_numberOfStepsPerInitialE, "prc_numberOfStepsPerInitialE", particleName, m_initialProcess,
                               1000, -9, 7, std::log10(m_initialKineticEnergyOfStep), nSteps);
       // track length vs initial energy
       InitializeFillHistogram(m_report.histoMapMap_trackLengthPerInitialE, "trackLengthPerInitialE", particleName, "AllATLAS",
                               1000, -9, 7, std::log10(tr->GetTrackLength()), 1.);
       InitializeFillHistogram(m_report.histoMapMap_vol_trackLengthPerInitialE, "vol_trackLengthPerInitialE", particleName, m_initialVolume,
                               1000, -9, 7, std::log10(tr->GetTrackLength()), 1.);
       InitializeFillHistogram(m_report.histoMapMap_mat_trackLengthPerInitialE, "mat_trackLengthPerInitialE", particleName, m_initialMaterial,
                               1000, -9, 7, std::log10(tr->GetTrackLength()), 1.);
       InitializeFillHistogram(m_report.histoMapMap_prc_trackLengthPerInitialE, "prc_trackLengthPerInitialE", particleName, m_initialProcess,
                               1000, -9, 7, std::log10(tr->GetTrackLength()), 1.);
     }
   }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_config

Config G4UA::StepHistogram::m_config

private

configuration data

Definition at line 123 of file StepHistogram.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_initialKineticEnergyOfStep

float G4UA::StepHistogram::m_initialKineticEnergyOfStep

private

Definition at line 140 of file StepHistogram.h.

◆ m_initialMaterial

G4String G4UA::StepHistogram::m_initialMaterial

private

Definition at line 142 of file StepHistogram.h.

◆ m_initialProcess

G4String G4UA::StepHistogram::m_initialProcess

private

Definition at line 143 of file StepHistogram.h.

◆ m_initialVolume

G4String G4UA::StepHistogram::m_initialVolume

private

Definition at line 141 of file StepHistogram.h.

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_report

Report G4UA::StepHistogram::m_report

private

Definition at line 120 of file StepHistogram.h.

◆ m_trackID

int G4UA::StepHistogram::m_trackID = 0

private

Definition at line 144 of file StepHistogram.h.

The documentation for this class was generated from the following files:

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ HistoMap_t

◆ HistoMapMap_t

Constructor & Destructor Documentation

◆ StepHistogram()

Member Function Documentation

◆ getReport()

◆ InitializeFillHistogram() [1/2]

◆ InitializeFillHistogram() [2/2]

◆ InitializeFillHistogram2D()

◆ initMessaging()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ setLevel()

◆ UserSteppingAction()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_config

◆ m_imsg

◆ m_initialKineticEnergyOfStep

◆ m_initialMaterial

◆ m_initialProcess

◆ m_initialVolume

◆ m_lvl

◆ m_msg_tls

◆ m_nm

◆ m_report

◆ m_trackID