Commit f6913338 authored by Adam Edward Barton's avatar Adam Edward Barton
Browse files

Merge branch 'removeOfTauEventData' into 'master'

TrigTauRec: remove TauEventData (ATLASRECTS-3078)

See merge request !30549
parents 179b08eb 92eeacbe
......@@ -32,7 +32,6 @@ AthAlgorithm(name, pSvcLocator),
m_tools(this), //make tools private
m_maxEta(2.5),
m_minPt(10000),
m_data(),
m_cellMakerTool("",this)
{
declareProperty("Tools", m_tools);
......@@ -86,7 +85,6 @@ StatusCode TauProcessorAlg::initialize() {
for (; itT != itTE; ++itT) {
++tool_count;
ATH_MSG_INFO((*itT)->type() << " - " << (*itT)->name());
(*itT)->setTauEventData(&m_data);
}
ATH_MSG_INFO(" ");
ATH_MSG_INFO("------------------------------------");
......@@ -226,8 +224,14 @@ StatusCode TauProcessorAlg::execute() {
ToolHandleArray<ITauToolBase> ::iterator itTE = m_tools.end();
for (; itT != itTE; ++itT) {
ATH_MSG_DEBUG("ProcessorAlg Invoking tool " << (*itT)->name());
if ( (*itT)->name().find("ShotFinder") != std::string::npos){
if ((*itT)->type() == "TauVertexFinder" ) {
sc = (*itT)->executeVertexFinder(*pTau);
}
else if ( (*itT)->type() == "TauTrackFinder") {
sc = (*itT)->executeTrackFinder(*pTau);
}
else if ( (*itT)->name().find("ShotFinder") != std::string::npos){
sc = (*itT)->executeShotFinder(*pTau, *tauShotClusContainer, *tauShotPFOContainer);
}
else if ( (*itT)->name().find("Pi0ClusterFinder") != std::string::npos){
......
......@@ -28,8 +28,7 @@
TauRunnerAlg::TauRunnerAlg(const std::string &name,
ISvcLocator * pSvcLocator) :
AthAlgorithm(name, pSvcLocator),
m_tools(this), //make tools private
m_data()
m_tools(this) //make tools private
{
declareProperty("Tools", m_tools);
}
......@@ -78,7 +77,6 @@ StatusCode TauRunnerAlg::initialize() {
for (; itT != itTE; ++itT) {
++tool_count;
ATH_MSG_INFO((*itT)->type() << " - " << (*itT)->name());
(*itT)->setTauEventData(&m_data);
}
ATH_MSG_INFO(" ");
ATH_MSG_INFO("------------------------------------");
......
......@@ -9,8 +9,6 @@
#include "AthenaBaseComps/AthAlgorithm.h"
#include "tauRecTools/ITauToolBase.h"
#include "tauRecTools/TauEventData.h"
#include "InDetReadoutGeometry/SiDetectorElementCollection.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/ReadHandle.h"
......@@ -56,8 +54,7 @@ class TauProcessorAlg: public AthAlgorithm
double m_maxEta; //!< only build taus with eta_seed < m_maxeta
double m_minPt; //!< only build taus with pt_seed > m_minpt
TauEventData m_data;
const CaloCell_ID* m_cellID;
const CaloCell_ID* m_cellID;
/** @brief tool handles */
ToolHandle<ICaloCellMakerTool> m_cellMakerTool;
......
......@@ -9,8 +9,6 @@
#include "AthenaBaseComps/AthAlgorithm.h"
#include "tauRecTools/ITauToolBase.h"
#include "tauRecTools/TauEventData.h"
#include "StoreGate/ReadHandle.h"
#include "StoreGate/WriteHandle.h"
......@@ -54,8 +52,6 @@ class TauRunnerAlg: public AthAlgorithm
ToolHandleArray<ITauToolBase> m_tools{this, "TauRunnerTools", {}, "Tools building taus"};
TauEventData m_data;
SG::ReadHandleKey<xAOD::TauJetContainer> m_tauInputContainer{this,"Key_tauInputContainer","tmp_TauJets","input temp tau key"};
SG::ReadHandleKey<xAOD::CaloClusterContainer> m_pi0ClusterInputContainer{this,"Key_Pi0ClusterInputContainer", "TauPi0SubtractedClusters", "input pi0 cluster"};
......
......@@ -14,8 +14,6 @@
// 16/05/2011: (FF) fix if primaryVertexContainer==NULL (coverity 21734)
// Dez 2011: (FF) switch to full LC calibrated tau 4-vector for some variables
//-----------------------------------------------------------------------------
#include "tauRecTools/TauEventData.h"
#include "tauRecTools/TauCommonCalcVars.h"
#include "tauRecTools/KineUtils.h"
#include <vector>
......
......@@ -12,7 +12,6 @@
//-----------------------------------------------------------------------------
#include "FourMomUtils/P4Helpers.h"
#include "tauRecTools/TauEventData.h"
#include "tauRecTools/TauGenericPi0Cone.h"
#include "tauRecTools/TauTrackFilterUtils.h"
......
......@@ -9,8 +9,6 @@
#include "TEnv.h"
#include "THashList.h"
TauEventData defaultTauEventData;
//________________________________________
std::string TauRecToolBase::find_file(const std::string& fname) const {
std::string full_path;
......@@ -120,15 +118,6 @@ StatusCode TauRecToolBase::readConfig() {
return StatusCode::SUCCESS;
}
//________________________________________
void TauRecToolBase::setTauEventData(TauEventData* data){
m_data=data;
if(m_data==0) {
m_data=&defaultTauEventData;
m_data->clear();
}
}
//________________________________________
TauRecToolBase::TauRecToolBase(const std::string& name) :
asg::AsgTool(name) {
......@@ -154,6 +143,16 @@ StatusCode TauRecToolBase::execute(xAOD::TauJet&){
return StatusCode::FAILURE;
}
StatusCode TauRecToolBase::executeVertexFinder(xAOD::TauJet&, const xAOD::VertexContainer*, const xAOD::TrackParticleContainer*) {
ATH_MSG_ERROR("function not implemented");
return StatusCode::FAILURE;
}
StatusCode TauRecToolBase::executeTrackFinder(xAOD::TauJet&, const xAOD::TrackParticleContainer*) {
ATH_MSG_ERROR("function not implemented");
return StatusCode::FAILURE;
}
StatusCode TauRecToolBase::executeShotFinder(xAOD::TauJet& /*pTau*/, xAOD::CaloClusterContainer& /*shotClusterContainer*/, xAOD::PFOContainer& /*PFOContainer*/ ) {
ATH_MSG_ERROR("function not implemented");
return StatusCode::FAILURE;
......
......@@ -81,8 +81,6 @@ StatusCode TauSubstructureVariables::execute(xAOD::TauJet& pTau) {
//----------------------------------------
// Getting the jet seed
// By asking taujet instead of TauEventData->seed, we take advantage of the machinery already
// in place to retrieve a jet seed for track only candidates.
//------------------------------------------------------------------------------------------------
const xAOD::Jet* taujetseed = (*pTau.jetLink());
......
......@@ -13,7 +13,6 @@
#include "FourMomUtils/P4Helpers.h"
#include "tauRecTools/TauEventData.h"
#include "tauRecTools/TauTrackFilter.h"
#include "tauRecTools/TauTrackFilterUtils.h"
......
......@@ -6,7 +6,6 @@
#include "TFile.h"
#include "TH2.h"
#include "TString.h"
#include "tauRecTools/TauEventData.h"
#include "tauRecTools/TauWPDecorator.h"
#include "xAODEventInfo/EventInfo.h"
......
......@@ -3,8 +3,6 @@
*/
#ifndef XAOD_ANALYSIS
#include "tauRecTools/TauEventData.h"
#include "xAODTau/TauJetContainer.h"
#include "xAODTau/TauJetAuxContainer.h"
#include "xAODTau/TauJet.h"
......
......@@ -57,8 +57,10 @@ StatusCode TauTrackFinder::initialize() {
ATH_CHECK( m_caloExtensionTool.retrieve() );
// initialize ReadHandleKey
ATH_CHECK( m_trackPartInputContainer.initialize(!m_trackPartInputContainer.key().empty()) );
ATH_CHECK( m_ParticleCacheKey.initialize(!m_ParticleCacheKey.key().empty()) );
// allow empty for trigger
ATH_CHECK( m_trackPartInputContainer.initialize(SG::AllowEmpty) );
// use CaloExtensionTool when key is empty
ATH_CHECK( m_ParticleCacheKey.initialize(SG::AllowEmpty) );
return StatusCode::SUCCESS;
}
......@@ -69,7 +71,7 @@ StatusCode TauTrackFinder::finalize() {
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode TauTrackFinder::execute(xAOD::TauJet& pTau) {
StatusCode TauTrackFinder::executeTrackFinder(xAOD::TauJet& pTau, const xAOD::TrackParticleContainer* trackContainer) {
ElementLink< xAOD::TauTrackContainer > link = pTau.allTauTrackLinksNonConst().at(0);//we don't care about this specific link, just the container
xAOD::TauTrackContainer* tauTrackCon = link.getDataNonConstPtr();
......@@ -83,13 +85,9 @@ StatusCode TauTrackFinder::execute(xAOD::TauJet& pTau) {
std::vector<const xAOD::TrackParticle*> wideTracks;
std::vector<const xAOD::TrackParticle*> otherTracks;
const xAOD::TrackParticleContainer* trackParticleCont = 0;
if (m_trackPartInputContainer.key().empty()) {
ATH_CHECK(tauEventData()->getObject( "TrackContainer", trackParticleCont ));
}
else {
// Get the track particle container from StoreGate
const xAOD::TrackParticleContainer* trackParticleCont = nullptr;
if (! m_trackPartInputContainer.empty()) { // MT version of trigger or offline
SG::ReadHandle<xAOD::TrackParticleContainer> trackPartInHandle( m_trackPartInputContainer );
if (!trackPartInHandle.isValid()) {
ATH_MSG_ERROR ("Could not retrieve HiveDataObj with key " << trackPartInHandle.key());
......@@ -97,6 +95,15 @@ StatusCode TauTrackFinder::execute(xAOD::TauJet& pTau) {
}
trackParticleCont = trackPartInHandle.cptr();
}
else { // coule be possible in trigger
if (trackContainer != nullptr) {
trackParticleCont = trackContainer;
}
else {
ATH_MSG_WARNING("No track container found");
return StatusCode::FAILURE;
}
}
// get the primary vertex
const xAOD::Vertex* pVertex = pTau.vertexLink()!=0 ? (*pTau.vertexLink()) : NULL;
......
......@@ -62,7 +62,7 @@ public:
//! Algorithm functions
//-------------------------------------------------------------
virtual StatusCode initialize() override;
virtual StatusCode execute(xAOD::TauJet& pTau) override;
virtual StatusCode executeTrackFinder(xAOD::TauJet& pTau, const xAOD::TrackParticleContainer* trackContainer = nullptr) override;
virtual StatusCode finalize() override;
private:
......
......@@ -36,8 +36,9 @@ TauVertexFinder::~TauVertexFinder() {
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode TauVertexFinder::initialize() {
ATH_CHECK( m_vertexInputContainer.initialize() );
ATH_CHECK( m_trackPartInputContainer.initialize() );
ATH_CHECK( m_vertexInputContainer.initialize(SG::AllowEmpty) );
if (m_in_trigger)
ATH_CHECK( m_trackPartInputContainer.initialize(SG::AllowEmpty) );
ATH_CHECK( m_jetTrackVtxAssoc.initialize() );
if (m_useTJVA) ATH_MSG_INFO("using TJVA to determine tau vertex");
......@@ -52,62 +53,62 @@ StatusCode TauVertexFinder::finalize() {
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
StatusCode TauVertexFinder::execute(xAOD::TauJet& pTau) {
StatusCode TauVertexFinder::executeVertexFinder(xAOD::TauJet& pTau,
const xAOD::VertexContainer* vertexContainer,
const xAOD::TrackParticleContainer* trackContainer) {
const xAOD::VertexContainer * vxContainer = 0;
const xAOD::Vertex* primaryVertex = 0;
// find default PrimaryVertex (needed if TJVA is switched off or fails)
// see: https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/VertexReselectionOnAOD
// code adapted from
// https://svnweb.cern.ch/trac/atlasoff/browser/Tracking/TrkEvent/VxVertex/trunk/VxVertex/PrimaryVertexSelector.h
if ( !m_in_trigger ){
// get the primary vertex container from StoreGate
// do it here because of tau trigger
if (!m_vertexInputContainer.empty()) {
SG::ReadHandle<xAOD::VertexContainer> vertexInHandle( m_vertexInputContainer );
if (!vertexInHandle.isValid()) {
ATH_MSG_ERROR ("Could not retrieve HiveDataObj with key " << vertexInHandle.key());
return StatusCode::FAILURE;
}
vxContainer = vertexInHandle.cptr();
if (vxContainer->size()>0) {
// simple loop through and get the primary vertex
xAOD::VertexContainer::const_iterator vxIter = vxContainer->begin();
xAOD::VertexContainer::const_iterator vxIterEnd = vxContainer->end();
for ( size_t ivtx = 0; vxIter != vxIterEnd; ++vxIter, ++ivtx ){
// the first and only primary vertex candidate is picked
if ( (*vxIter)->vertexType() == xAOD::VxType::PriVtx){
primaryVertex = (*vxIter);
break;
}
}
}
}
else { // trigger mode
// find default PrimaryVertex (highest sum pt^2)
//for tau trigger
StatusCode sc = tauEventData()->getObject("VxPrimaryCandidate", vxContainer);
if ( sc.isFailure() ){
ATH_MSG_WARNING("Could not retrieve VxPrimaryCandidate");
else {
if (vertexContainer != nullptr) {
vxContainer = vertexContainer;
}
else {
ATH_MSG_WARNING ("No Vertex Container in trigger");
return StatusCode::FAILURE;
}
if (vxContainer->size()>0) primaryVertex = (*vxContainer)[0];
}
ATH_MSG_VERBOSE("size of VxPrimaryContainer is: " << vxContainer->size() );
if ( 0 == vxContainer->size()) return StatusCode::SUCCESS;
// find default PrimaryVertex (needed if TJVA is switched off or fails)
// see: https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/VertexReselectionOnAOD
// code adapted from
// https://svnweb.cern.ch/trac/atlasoff/browser/Tracking/TrkEvent/VxVertex/trunk/VxVertex/PrimaryVertexSelector.h
const xAOD::Vertex* primaryVertex = 0;
if ( m_in_trigger) { // trigger: find default PrimaryVertex (highest sum pt^2)
primaryVertex = (*vxContainer)[0];
}
else { // offline: the first and only primary vertex candidate is picked
for (const auto vertex : *vxContainer) {
if (vertex->vertexType() == xAOD::VxType::PriVtx) {
primaryVertex = vertex;
break;
}
}
}
// associate vertex to tau
if (primaryVertex) pTau.setVertex(vxContainer, primaryVertex);
//stop here if TJVA is disabled or vertex container is empty
if (!m_useTJVA || vxContainer->size()==0) return StatusCode::SUCCESS;
//stop here if TJVA is disabled
if (!m_useTJVA) return StatusCode::SUCCESS;
// try to find new PV with TJVA
ATH_MSG_DEBUG("TJVA enabled -> try to find new PV for the tau candidate");
float maxJVF = -100;
ElementLink<xAOD::VertexContainer> newPrimaryVertexLink =
getPV_TJVA(pTau, *vxContainer, maxJVF );
getPV_TJVA(pTau, *vxContainer, trackContainer, maxJVF );
if (newPrimaryVertexLink.isValid()) {
// set new primary vertex
// will overwrite default one which was set above
......@@ -127,6 +128,7 @@ StatusCode TauVertexFinder::execute(xAOD::TauJet& pTau) {
ElementLink<xAOD::VertexContainer>
TauVertexFinder::getPV_TJVA(const xAOD::TauJet& pTau,
const xAOD::VertexContainer& vertices,
const xAOD::TrackParticleContainer * trackContainer,
float& maxJVF)
{
const xAOD::Jet* pJetSeed = (*pTau.jetLink());
......@@ -139,11 +141,23 @@ TauVertexFinder::getPV_TJVA(const xAOD::TauJet& pTau,
const xAOD::TrackParticleContainer* trackParticleCont = 0;
std::vector<const xAOD::TrackParticle*> assocTracks;
if (m_in_trigger) {
StatusCode sc = tauEventData()->getObject( "TrackContainer", trackParticleCont ); // to be replaced by full FTK collection?
if (sc.isFailure() || !trackParticleCont){
ATH_MSG_WARNING("No TrackContainer for TJVA in trigger found");
return ElementLink<xAOD::VertexContainer>();
if (m_in_trigger) {
if (!m_trackPartInputContainer.empty()) {
SG::ReadHandle<xAOD::TrackParticleContainer> trackPartInHandle( m_trackPartInputContainer );
if (!trackPartInHandle.isValid()) {
ATH_MSG_WARNING("No TrackContainer for TJVA in trigger found");
return ElementLink<xAOD::VertexContainer>();
}
trackParticleCont = trackPartInHandle.cptr();
}
else {
if (trackContainer != nullptr) {
trackParticleCont = trackContainer;
}
else {
ATH_MSG_WARNING("No TrackContainer for TJVA in trigger found");
return ElementLink<xAOD::VertexContainer>();
}
}
// convert TrackParticleContainer in std::vector<const xAOD::TrackParticle*>
for (xAOD::TrackParticleContainer::const_iterator tpcItr = trackParticleCont->begin(); tpcItr != trackParticleCont->end(); ++tpcItr) {
......@@ -167,7 +181,6 @@ TauVertexFinder::getPV_TJVA(const xAOD::TauJet& pTau,
tracksForTJVA.push_back(xTrack);
}
// Get the TVA object
const jet::TrackVertexAssociation* tva = NULL;
......@@ -233,7 +246,6 @@ TauVertexFinder::getPV_TJVA(const xAOD::TauJet& pTau,
tva = tvaInHandle.cptr();
}
// Get the highest JVF vertex and store maxJVF for later use
// Note: the official JetMomentTools/JetVertexFractionTool doesn't provide any possibility to access the JVF value, but just the vertex.
maxJVF=-100.;
......
......@@ -40,13 +40,16 @@ public:
//! Algorithm functions
//-------------------------------------------------------------
virtual StatusCode initialize() override;
virtual StatusCode execute(xAOD::TauJet& pTau) override;
virtual StatusCode executeVertexFinder(xAOD::TauJet& pTau,
const xAOD::VertexContainer* vertexContainer = nullptr,
const xAOD::TrackParticleContainer* trackContainer = nullptr) override;
virtual StatusCode finalize() override;
private:
ElementLink<xAOD::VertexContainer>
getPV_TJVA(const xAOD::TauJet& tauJet,
const xAOD::VertexContainer& vertices,
const xAOD::TrackParticleContainer* trackContainer,
float& maxJVF);
float getJetVertexFraction(const xAOD::Vertex* vertex, const std::vector<const xAOD::TrackParticle*>& tracks, const jet::TrackVertexAssociation* tva) const;
......
......@@ -13,7 +13,6 @@
#include "BeamSpotConditionsData/BeamSpotData.h"
// forwards
class TauEventData;
namespace Trk {
class ITrackToVertexIPEstimator;
class IVertexFitter;
......
......@@ -6,11 +6,13 @@
#define ITOOLBASE_TAU_H
#include "AsgTools/IAsgTool.h"
#include "tauRecTools/TauEventData.h"
#include "xAODParticleEvent/Particle.h"
#include "xAODParticleEvent/ParticleContainer.h"
#include "xAODParticleEvent/ParticleAuxContainer.h"
#include "xAODTau/TauJetContainer.h"
#include "xAODTau/TauJetAuxContainer.h"
/**
* @brief The base class for all tau tools.
*
......@@ -41,6 +43,10 @@ class ITauToolBase : virtual public asg::IAsgTool
//! Execute - called for each tau candidate
//-----------------------------------------------------------------
virtual StatusCode execute(xAOD::TauJet& pTau) = 0;
virtual StatusCode executeVertexFinder(xAOD::TauJet& pTau,
const xAOD::VertexContainer* vertexContainer = nullptr,
const xAOD::TrackParticleContainer* trackContainer = nullptr) = 0;
virtual StatusCode executeTrackFinder(xAOD::TauJet& pTau, const xAOD::TrackParticleContainer* trackContainer = nullptr) = 0;
virtual StatusCode executeShotFinder(xAOD::TauJet& pTau, xAOD::CaloClusterContainer& shotClusterContainer, xAOD::PFOContainer& PFOContainer ) = 0;
virtual StatusCode executePi0CreateROI(xAOD::TauJet& pTau, CaloCellContainer& caloCellContainer, std::vector<CaloCell*>& map ) = 0;
virtual StatusCode executePi0ClusterCreator(xAOD::TauJet& pTau, xAOD::PFOContainer& neutralPFOContainer,
......@@ -62,8 +68,6 @@ class ITauToolBase : virtual public asg::IAsgTool
//-----------------------------------------------------------------
virtual StatusCode finalize() = 0;
virtual void setTauEventData(TauEventData* data) = 0;
//make pure
virtual StatusCode readConfig() = 0;
......
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
#ifndef TAUREC_EVENT_DATA_H
#define TAUREC_EVENT_DATA_H
//-----------------------------------------------------------------------------
// file: TauEventData.h was TauCandidateData.h
// package: Reconstruction/tauEvent
// authors: Lukasz Janyst
// date: 2007-02-13
//
// MODIFICATIONS
// 2008-04-22 nicom: moved setObject()/getObject() to TauEventData
//
//-----------------------------------------------------------------------------
#include <string>
#include <map>
#include <boost/any.hpp>
#include "xAODTau/TauJetContainer.h"
#include "xAODTau/TauJetAuxContainer.h"
#include "AsgTools/StatusCode.h"
/**
* @brief The tau candidate object.
*
* Holds all containers and information needed for the tau reconstruction process.
*
* @authors Lukasz Janyst
*/
class TauEventData
{
public:
//-----------------------------------------------------------------
//! Associate some object to a key - this is meant to be used by
//! TrigTauRec to pass container pointers to tauRec tools
//-----------------------------------------------------------------
template <typename P>
void setObject( std :: string key, P ptr );
//-----------------------------------------------------------------
//! Check if something has been associated with given key
//-----------------------------------------------------------------
bool hasObject( std :: string key ) const;
//-----------------------------------------------------------------
//! Get the pointer associated with given key, if types don't
//! match boost :: bad_any_cast exception is thrown
//-----------------------------------------------------------------
template <typename P>
StatusCode getObject( std :: string key, P &ptr );
xAOD::TauJetContainer* xAODTauContainer=0;
xAOD::TauJetAuxContainer *tauAuxContainer=0;
/* //think about changing this to IParticle */
/* const xAOD::Jet *seed=0; */
const xAOD::JetContainer *seedContainer=0;
unsigned int detailsNum=0;
std :: map<std :: string, boost :: any> m_ptrMap;
void clear();
inline void setInTrigger(bool v=true);
inline bool inTrigger() const;
private:
//don't clear this infomation
bool m_inTrigger = false;
};
//-------------------------------------------------------------------------
// Set pointer
//-------------------------------------------------------------------------
template <typename P>
inline void TauEventData :: setObject( std :: string key, P ptr )
{
m_ptrMap[key] = ptr;
}
//-------------------------------------------------------------------------
// Get pointer
//-------------------------------------------------------------------------
template <typename P>
inline StatusCode TauEventData :: getObject( std :: string key, P &ptr )
{
std :: map< std :: string, boost :: any> :: iterator p_it;
p_it = m_ptrMap.find( key );
if( p_it == m_ptrMap.end() )
return StatusCode :: FAILURE;
ptr = boost :: any_cast<P>( (*p_it).second );
return StatusCode :: SUCCESS;
}
//-------------------------------------------------------------------------
// Test if any pointer has been associated with given key
//-------------------------------------------------------------------------
inline bool TauEventData :: hasObject( std :: string key ) const
{
return m_ptrMap.find( key ) != m_ptrMap.end();
}
//-------------------------------------------------------------------------
// reset all information, nothing is deleted assuming pointers
// owned by storegate
//-------------------------------------------------------------------------
inline void TauEventData :: clear(){
xAODTauContainer=0;
tauAuxContainer=0;
seedContainer=0;
detailsNum=0;
m_ptrMap.clear();
}
<