Skip to content
Snippets Groups Projects
Commit c8b46ffd authored by Ruth Pottgen's avatar Ruth Pottgen
Browse files

Revert "Merge branch '21.0-NN-update-final-dot-joke' into '21.0'" 

This reverts merge request !29139
parent 21735050
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 1127 additions and 199 deletions
InnerDetector/InDetExample/InDetRecExample/share/InDetRecLoadTools.py
+ 32
− 2
View file @ c8b46ffd
......@@ -43,12 +43,42 @@ if InDetFlags.doPixelClusterSplitting() and not InDetFlags.doSLHC():
print NeuralNetworkToHistoTool
# --- new NN factor
# --- put in a temporary hack here for 19.1.0, to select the necessary settings when running on run 1 data/MC
# --- since a correction is needed to fix biases when running on new run 2 compatible calibation
# --- a better solution is needed...
from SiClusterizationTool.SiClusterizationToolConf import InDet__NnClusterizationFactory
from SiClusterizationTool.ConfiguredNnClusterization import NnCalibMaker
NnClusterizationFactory = NnCalibMaker.get()
if not "R2" in globalflags.DetDescrVersion() and not "IBL3D25" in globalflags.DetDescrVersion():
NnClusterizationFactory = InDet__NnClusterizationFactory( name = "NnClusterizationFactory",
NetworkToHistoTool = NeuralNetworkToHistoTool,
doRunI = True,
useToT = False,
useRecenteringNNWithoutTracks = True,
useRecenteringNNWithTracks = False,
correctLorShiftBarrelWithoutTracks = 0,
correctLorShiftBarrelWithTracks = 0.030,
LoadNoTrackNetwork = True,
LoadWithTrackNetwork = True)
else:
NnClusterizationFactory = InDet__NnClusterizationFactory( name = "NnClusterizationFactory",
NetworkToHistoTool = NeuralNetworkToHistoTool,
LoadNoTrackNetwork = True,
useToT = InDetFlags.doNNToTCalibration(),
LoadWithTrackNetwork = True)
ToolSvc += NnClusterizationFactory
# special setup for DVRetracking mode
# if InDetFlags.doDVRetracking() :
# COOL binding
from IOVDbSvc.CondDB import conddb
if not conddb.folderRequested('/PIXEL/PixelClustering/PixelClusNNCalib'):
# COOL binding
conddb.addFolder("PIXEL_OFL","/PIXEL/PixelClustering/PixelClusNNCalib")
if InDetFlags.doTIDE_RescalePixelCovariances() :
if not conddb.folderRequested('/PIXEL/PixelClustering/PixelCovCorr'):
# COOL binding
......
InnerDetector/InDetExample/InDetRecExample/share/InDetRecPreProcessingSilicon.py
+ 23
− 1
View file @ c8b46ffd
......@@ -54,7 +54,7 @@ if InDetFlags.doPRDFormation():
clusterSplitProbTool = None
clusterSplitterTool = None
#
# --- do we use new splitting or not ?
# --- do we use new splittig or not ?
#
if InDetFlags.doPixelClusterSplitting():
#
......@@ -81,6 +81,26 @@ if InDetFlags.doPRDFormation():
# --- remember this prob tool
clusterSplitProbTool = NnPixelClusterSplitProbTool
# --- new NN splitter
if InDetFlags.doSLHC():
from SiClusterizationTool.SiClusterizationToolConf import InDet__TruthPixelClusterSplitter as PixelClusterSplitter
else:
from SiClusterizationTool.SiClusterizationToolConf import InDet__NnPixelClusterSplitter as PixelClusterSplitter
NnPixelClusterSplitter=PixelClusterSplitter(name = "NnPixelClusterSplitter",
NnClusterizationFactory = NnClusterizationFactory,
ThresholdSplittingIntoTwoClusters = 0.5, # temp.
ThresholdSplittingIntoThreeClusters = 0.25, # temp.
SplitOnlyOnBLayer = False,
useBeamSpotInfo = useBeamConstraint)
ToolSvc += NnPixelClusterSplitter
if (InDetFlags.doPrintConfigurables()):
print NnPixelClusterSplitter
# remember splitter tool
clusterSplitterTool = NnPixelClusterSplitter
#
# --- Neutral Network version ?
......@@ -111,6 +131,8 @@ if InDetFlags.doPRDFormation():
SplitClusterAmbiguityMap= InDetKeys.SplitClusterAmbiguityMap())
# assign the tools if there are any
if not InDetFlags.doTIDE_Ambi() and clusterSplitProbTool is not None : InDetMergedPixelsTool.SplitProbTool = clusterSplitProbTool
if not InDetFlags.doTIDE_Ambi() and clusterSplitterTool is not None : InDetMergedPixelsTool.ClusterSplitter = clusterSplitterTool
ToolSvc += InDetMergedPixelsTool
if (InDetFlags.doPrintConfigurables()):
......
InnerDetector/InDetRecTools/InDetRecToolInterfaces/InDetRecToolInterfaces/IPixelClusterSplitProbTool.h
+ 3
− 0
View file @ c8b46ffd
......@@ -34,6 +34,9 @@ namespace InDet
/** interface ID */
static const InterfaceID& interfaceID() { return IID_IPixelClusterSplitProbTool; }
/** take one, give many */
virtual InDet::PixelClusterSplitProb splitProbability(const InDet::PixelCluster& origCluster ) const = 0;
/** take one, give many */
virtual InDet::PixelClusterSplitProb splitProbability(const InDet::PixelCluster& origCluster, const Trk::TrackParameters& trackParameters ) const = 0;
......
InnerDetector/InDetRecTools/SiClusterizationTool/CMakeLists.txt
+ 1
− 3
View file @ c8b46ffd
......@@ -24,7 +24,6 @@ atlas_depends_on_subdirs(
InnerDetector/InDetRecTools/InDetRecToolInterfaces
Tracking/TrkEvent/TrkParameters
PRIVATE
Tools/PathResolver
Database/AthenaPOOL/AthenaPoolUtilities
DetectorDescription/AtlasDetDescr
DetectorDescription/DetDescrCond/DetDescrCondTools
......@@ -51,12 +50,11 @@ atlas_add_library( SiClusterizationToolLib
InDetReadoutGeometry InDetRawData InDetPrepRawData InDetRecToolInterfaces
TrkParameters TrkNeuralNetworkUtilsLib
PRIVATE_LINK_LIBRARIES ${CLHEP_LIBRARIES} AthenaPoolUtilities AtlasDetDescr
TrkSurfaces TrkEventPrimitives VxVertex PixelGeoModelLib PathResolver)
TrkSurfaces TrkEventPrimitives VxVertex PixelGeoModelLib )
atlas_add_component( SiClusterizationTool
src/components/*.cxx
LINK_LIBRARIES GaudiKernel SiClusterizationToolLib )
# Install files from the package:
atlas_install_python_modules( python/*.py )
atlas_install_joboptions( share/*.py )
InnerDetector/InDetRecTools/SiClusterizationTool/SiClusterizationTool/NnClusterizationFactory.h
+ 67
− 18
View file @ c8b46ffd
......@@ -28,7 +28,6 @@
#include <map>
#include <TString.h>
#include <TFile.h>
#include "AthenaKernel/IOVSvcDefs.h"
......@@ -39,6 +38,7 @@
class TTrainedNetwork;
class TH1;
class ICoolHistSvc;
class IPixelCalibSvc;
namespace Trk {
......@@ -66,6 +66,7 @@ namespace InDet {
float phi;
float theta;
float etaModule;
bool useTrackInfo;
int columnWeightedPosition;
int rowWeightedPosition;
};
......@@ -85,6 +86,11 @@ namespace InDet {
virtual StatusCode initialize();
virtual StatusCode finalize() { return StatusCode::SUCCESS; };
std::vector<double> estimateNumberOfParticles(const InDet::PixelCluster& pCluster,
Amg::Vector3D & beamSpotPosition,
int sizeX=7,
int sizeY=7);
std::vector<double> estimateNumberOfParticles(const InDet::PixelCluster& pCluster,
const Trk::Surface& pixelSurface,
......@@ -92,6 +98,14 @@ namespace InDet {
int sizeX=7,
int sizeY=7);
std::vector<Amg::Vector2D> estimatePositions(const InDet::PixelCluster& pCluster,
Amg::Vector3D & beamSpotPosition,
std::vector<Amg::MatrixX> & errors,
int numberSubClusters,
int sizeX=7,
int sizeY=7);
std::vector<Amg::Vector2D> estimatePositions(const InDet::PixelCluster& pCluster,
const Trk::Surface& pixelSurface,
const Trk::TrackParameters& trackParsAtSurface,
......@@ -101,10 +115,21 @@ namespace InDet {
int sizeY=7);
/** Callback for nnSetup */
StatusCode nnSetup();
StatusCode nnSetup( IOVSVC_CALLBACK_ARGS );
private:
void clearCache(std::vector<TTrainedNetwork*>& ttnn);
/* estimate position for both with and w/o tracks */
std::vector<Amg::Vector2D> estimatePositions(std::vector<double> inputData,
NNinput* input,
const InDet::PixelCluster& pCluster,
int sizeX,
int sizeY,
bool useTrackInfo,
int numberSubClusters,
std::vector<Amg::MatrixX> & errors);
/* algorithmic component */
NNinput* createInput(const InDet::PixelCluster& pCluster,
......@@ -119,10 +144,11 @@ namespace InDet {
const Trk::TrackParameters& trackParsAtSurface,
const double tanl);
/* neural networks: read from COOL using TTrainedNetwork? */
bool m_loadTTrainedNetworks;
/* neural network component */
bool m_loadNoTrackNetworks;
bool m_loadWithTrackNetworks;
TTrainedNetwork* retrieveNetwork(std::unique_ptr<TFile> & ifile, const std::string & folder);
TTrainedNetwork* retrieveNetwork(const std::string& folder, const std::string& subfolder);
std::vector<double> assembleInput(NNinput& input,
......@@ -130,6 +156,18 @@ namespace InDet {
int sizeY);
std::vector<double> assembleInputRunI(NNinput& input,
int sizeX,
int sizeY);
std::vector<double> assembleInputRunII(NNinput& input,
int sizeX,
int sizeY);
std::vector<Amg::Vector2D> getPositionsFromOutput(std::vector<double> & output,
NNinput & input,
const InDet::PixelCluster& pCluster,
......@@ -142,29 +180,40 @@ namespace InDet {
std::vector<Amg::MatrixX>& errorMatrix,
int nParticles);
// NN calibration file from which to load neural networks (TTrainedNetwork type)
std::string m_configTTrainedNetwork;
//use cool histogram service to load neural networks
ICoolHistSvc* m_coolHistSvc;
// TTrainedNetworks
TTrainedNetwork* m_NetworkEstimateNumberParticles;
std::vector<TTrainedNetwork*> m_NetworkEstimateImpactPoints;
std::vector<TTrainedNetwork*> m_NetworkEstimateImpactPointErrorsX;
std::vector<TTrainedNetwork*> m_NetworkEstimateImpactPointErrorsY;
TTrainedNetwork* m_NetworkEstimateNumberParticles;
TTrainedNetwork* m_NetworkEstimateNumberParticles_NoTrack;
std::vector<TTrainedNetwork*> m_NetworkEstimateImpactPoints;
std::vector<TTrainedNetwork*> m_NetworkEstimateImpactPoints_NoTrack;
std::string m_layerInfoHistogram;
std::string m_layerPrefix;
std::string m_weightIndicator;
std::string m_thresholdIndicator;
std::vector<TTrainedNetwork*> m_NetworkEstimateImpactPointErrorsX;
std::vector<TTrainedNetwork*> m_NetworkEstimateImpactPointErrorsX_NoTrack;
std::vector<TTrainedNetwork*> m_NetworkEstimateImpactPointErrorsY;
std::vector<TTrainedNetwork*> m_NetworkEstimateImpactPointErrorsY_NoTrack;
std::string m_coolFolder;
std::string m_layerInfoHistogram;
std::string m_layerPrefix;
std::string m_weightIndicator;
std::string m_thresholdIndicator;
ToolHandle<Trk::NeuralNetworkToHistoTool> m_networkToHistoTool;
ServiceHandle<IPixelCalibSvc> m_calibSvc;
bool m_useToT;
// Having no IBL changes treatment of inputs slightly
bool m_addIBL;
bool m_doRunI;
bool m_useRecenteringNNWithouTracks;
bool m_useRecenteringNNWithTracks;
double m_correctLorShiftBarrelWithoutTracks;
double m_correctLorShiftBarrelWithTracks;
};
......
InnerDetector/InDetRecTools/SiClusterizationTool/SiClusterizationTool/NnPixelClusterSplitProbTool.h
+ 2
− 0
View file @ c8b46ffd
......@@ -42,6 +42,8 @@ namespace InDet {
StatusCode initialize();
virtual InDet::PixelClusterSplitProb splitProbability(const InDet::PixelCluster& origCluster ) const;
virtual InDet::PixelClusterSplitProb splitProbability(const InDet::PixelCluster& origCluster, const Trk::TrackParameters& trackParameters ) const;
......
InnerDetector/InDetRecTools/SiClusterizationTool/SiClusterizationTool/NnPixelClusterSplitter.h 0 → 100644
+ 65
− 0
View file @ c8b46ffd
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
///////////////////////////////////////////////////////////////////
// NnPixelClusterSplitter.h, (c) ATLAS Detector software
///////////////////////////////////////////////////////////////////
#ifndef INDETRECTOOLS_NNPIXELCLUSTERSPLITTER_H
#define INDETRECTOOLS_NNPIXELCLUSTERSPLITTER_H
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
#include "InDetRecToolInterfaces/IPixelClusterSplitter.h"
#include "InDetPrepRawData/PixelClusterParts.h"
#include "InDetPrepRawData/PixelClusterSplitProb.h"
class IBeamCondSvc;
namespace InDet
{
class NnClusterizationFactory;
class PixelCluster;
/** @class NnPixelClusterSplitter
@author Andreas.Salzburger@cern.ch
*/
class NnPixelClusterSplitter : public AthAlgTool, virtual public IPixelClusterSplitter {
public :
/** Constructor*/
NnPixelClusterSplitter(const std::string &type,
const std::string &name,
const IInterface *parent);
/** Destructor*/
~NnPixelClusterSplitter();
/** AthAlgTool interface methods */
StatusCode initialize();
StatusCode finalize();
/** take one, give zero or many */
std::vector<InDet::PixelClusterParts> splitCluster(const InDet::PixelCluster& origCluster ) const;
/** take one, give zero or many - with split probability object */
std::vector<InDet::PixelClusterParts> splitCluster(const InDet::PixelCluster& origCluster,
const InDet::PixelClusterSplitProb& spo) const;
private:
ToolHandle<NnClusterizationFactory> m_NnClusterizationFactory;
ServiceHandle<IBeamCondSvc> m_iBeamCondSvc;
double m_thresholdSplittingIntoTwoClusters;
double m_thresholdSplittingIntoThreeClusters;
bool m_splitOnlyOnBLayer;
bool m_useBeamSpotInfo;
};
}
#endif
InnerDetector/InDetRecTools/SiClusterizationTool/python/ConfiguredNnClusterization.py deleted 100644 → 0
+ 0
− 48
View file @ 21735050
## Config file for handling all setup of NnClusterizationFactory.
## This is where we will change the default calibration files when
## we have updated the neural nets.
## It should then be inherited by all other files which set up
## NnClusterizationFactory so that defaults are handled from one spot.
class PixelNNCalibrationFinder:
# List of default values.
# Update here when required.
default_configs = {
"TTrainedNetwork" : "/cvmfs/atlas-condb.cern.ch/repo/conditions/cond09/cond09_mc.000130.gen.COND/cond09_mc.000130.gen.COND._0001.pool.root"
}
def get(self, number_config="") :
from AthenaCommon.GlobalFlags import globalflags
from SiClusterizationTool.SiClusterizationToolConf import InDet__NnClusterizationFactory
from AthenaCommon.AppMgr import ToolSvc
from InDetRecExample.InDetJobProperties import InDetFlags
# Original note on "Run 1" setup:
# --- put in a temporary hack here for 19.1.0, to select the necessary settings when running on run 1 data/MC
# --- since a correction is needed to fix biases when running on new run 2 compatible calibation
# --- a better solution is needed...
if not "R2" in globalflags.DetDescrVersion() and not "IBL3D25" in globalflags.DetDescrVersion():
NnClusterizationFactory = InDet__NnClusterizationFactory( name = "NnClusterizationFactory",
NetworkToHistoTool = ToolSvc.NeuralNetworkToHistoTool,
doRunI = True,
useToT = False,
correctLorShiftBarrelWithTracks = 0.030,
LoadTTrainedNetworks = True)
else:
NnClusterizationFactory = InDet__NnClusterizationFactory( name = "NnClusterizationFactory",
NetworkToHistoTool = ToolSvc.NeuralNetworkToHistoTool,
useToT = InDetFlags.doNNToTCalibration(),
LoadTTrainedNetworks = True)
if not number_config :
NnClusterizationFactory.TTrainedNetwork_configFile = self.default_configs["TTrainedNetwork"]
else :
NnClusterizationFactory.TTrainedNetwork_configFile = number_config
return NnClusterizationFactory
NnCalibMaker = PixelNNCalibrationFinder()
InnerDetector/InDetRecTools/SiClusterizationTool/src/MergedPixelsTool.cxx
+ 10
− 1
View file @ c8b46ffd
......@@ -409,7 +409,16 @@ namespace InDet {
// prepare for the return value of the pixel cluster
std::vector<InDet::PixelClusterParts> splitClusterParts;
if ( !m_clusterSplitter.empty() && (m_doIBLSplitting || m_IBLAbsent || !element->isBlayer()))
if ( !m_splitProbTool.empty() && (m_doIBLSplitting || m_IBLAbsent || !element->isBlayer())){
InDet::PixelClusterSplitProb splitProbObj = m_splitProbTool->splitProbability(*cluster);
clusterSplitP1 = splitProbObj.splitProbability(2);
clusterSplitP2 = splitProbObj.splitProbability(3);
ATH_MSG_VERBOSE( "Obtained split prob object with split prob: " << splitProbObj.splitProbability());
if ( splitProbObj.splitProbability() > m_minSplitProbability ) {
ATH_MSG_VERBOSE( "Trying to split cluster ... ");
splitClusterParts = m_clusterSplitter->splitCluster(*cluster,splitProbObj);
}
} else if ( !m_clusterSplitter.empty() && (m_doIBLSplitting || m_IBLAbsent || !element->isBlayer()))
splitClusterParts = m_clusterSplitter->splitCluster(*cluster);
// check if splitting worked
clusterModified = !m_emulateSplitter && splitClusterParts.size() > 0;
......
InnerDetector/InDetRecTools/SiClusterizationTool/src/NnPixelClusterSplitProbTool.cxx
+ 34
− 0
View file @ c8b46ffd
......@@ -69,6 +69,40 @@ namespace InDet
return StatusCode::SUCCESS;
}
InDet::PixelClusterSplitProb NnPixelClusterSplitProbTool::splitProbability(const InDet::PixelCluster& origCluster ) const
{
Trk::RecVertex beamposition(m_iBeamCondSvc->beamVtx());
Amg::Vector3D beamSpotPosition(beamposition.position()[0],
beamposition.position()[1],
beamposition.position()[2]);
if (!m_useBeamSpotInfo) beamSpotPosition=Amg::Vector3D(0,0,0);
std::vector<double> vectorOfProbs=m_NnClusterizationFactory->estimateNumberOfParticles(origCluster,beamSpotPosition);
ATH_MSG_VERBOSE(" Got splitProbability, size of vector: " << vectorOfProbs.size() );
if (vectorOfProbs.size()==0)
{
std::vector<double> vectorOfSplitProbs;
vectorOfSplitProbs.push_back(-100);
PixelClusterSplitProb clusterSplitProb(vectorOfSplitProbs);
ATH_MSG_VERBOSE(" Returning single split prob equal to -100 " );
return clusterSplitProb;
}
ATH_MSG_VERBOSE(
" P(1): " << vectorOfProbs[0] <<
" P(2): " << vectorOfProbs[1] <<
" P(>=3): " << vectorOfProbs[2] );
return compileSplitProbability(vectorOfProbs);
}
InDet::PixelClusterSplitProb NnPixelClusterSplitProbTool::splitProbability(const InDet::PixelCluster& origCluster, const Trk::TrackParameters& trackParameters ) const
{
......
InnerDetector/InDetRecTools/SiClusterizationTool/src/NnPixelClusterSplitter.cxx 0 → 100644
+ 280
− 0
View file @ c8b46ffd
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
/////////////////////////////////////////////////////////////////////////////////////////////////////
/// Name : NnClusterizationFactory.cxx
/// Package : SiClusterizationTool
/// Author : Andi Salzburger (CERN PH-ADP)
/// Giacinto Piacquadio (PH-ADE-ID)
/// Created : January 2011
///
/// DESCRIPTION: Split cluster in sub-clusters,
/// given a certain PixelClusterSplitProb
/// If no PixelClusterSplitProb is given
/// split cluster in 1,2 and 3 sub-clusters
/// and store all results.
///////////////////////////////////////////////////////////////////////////////////////////////////////
#include "SiClusterizationTool/NnPixelClusterSplitter.h"
#include "VxVertex/RecVertex.h"
#include "InDetPrepRawData/PixelCluster.h"
#include "InDetBeamSpotService/IBeamCondSvc.h"
#include "SiClusterizationTool/NnClusterizationFactory.h"
#include "InDetIdentifier/PixelID.h"
#include "InDetReadoutGeometry/SiDetectorElement.h"
#include "GeoPrimitives/GeoPrimitives.h"
#include "EventPrimitives/EventPrimitives.h"
InDet::NnPixelClusterSplitter::NnPixelClusterSplitter(const std::string &type,
const std::string &name,
const IInterface *parent) :
AthAlgTool(type,name,parent),
m_NnClusterizationFactory("InDet::NnClusterizationFactory/NnClusterizationFactory"),
m_iBeamCondSvc("BeamCondSvc",name),
m_useBeamSpotInfo(true)
{
declareInterface<IPixelClusterSplitter>(this);
declareProperty("NnClusterizationFactory",m_NnClusterizationFactory);
declareProperty("BeamCondSv",m_iBeamCondSvc);
declareProperty("ThresholdSplittingIntoTwoClusters",m_thresholdSplittingIntoTwoClusters=0.95);
declareProperty("ThresholdSplittingIntoThreeClusters",m_thresholdSplittingIntoThreeClusters=0.90);
declareProperty("SplitOnlyOnBLayer",m_splitOnlyOnBLayer=true);
declareProperty("useBeamSpotInfo",m_useBeamSpotInfo);
}
InDet::NnPixelClusterSplitter::~NnPixelClusterSplitter()
{}
StatusCode InDet::NnPixelClusterSplitter::initialize() {
if (m_NnClusterizationFactory.retrieve().isFailure())
{
ATH_MSG_ERROR(" Unable to retrieve "<< m_NnClusterizationFactory );
return StatusCode::FAILURE;
}
if (m_iBeamCondSvc.retrieve().isFailure())
{
ATH_MSG_ERROR( "Could not find BeamCondSvc." );
return StatusCode::FAILURE;
}
ATH_MSG_INFO(" Cluster splitter initialized successfully "<< m_NnClusterizationFactory );
return StatusCode::SUCCESS;
}
StatusCode InDet::NnPixelClusterSplitter::finalize() {
return StatusCode::SUCCESS;
}
/* default method which simply splits cluster into 2 */
std::vector<InDet::PixelClusterParts> InDet::NnPixelClusterSplitter::splitCluster(const InDet::PixelCluster& origCluster ) const
{
//add treatment for b-layer only HERE
Trk::RecVertex beamposition(m_iBeamCondSvc->beamVtx());
const std::vector<Identifier>& rdos = origCluster.rdoList();
const std::vector<int>& totList = origCluster.totList();
//fill lvl1group all with the same value... (not best way but ...)
std::vector<int> lvl1group;
lvl1group.reserve(rdos.size());
std::vector<Identifier>::const_iterator rdoBegin=rdos.begin();
std::vector<Identifier>::const_iterator rdoEnd=rdos.end();
for (std::vector<Identifier>::const_iterator rdoIter=rdoBegin;rdoIter!=rdoEnd;rdoIter++)
{
lvl1group.push_back(origCluster.LVL1A());
}
std::vector<Amg::Vector2D> allLocalPositions;
std::vector<Amg::MatrixX> allErrorMatrix;
std::vector<Amg::MatrixX> errorMatrix;
Amg::Vector3D beamSpotPosition=Amg::Vector3D(
beamposition.position()[0],
beamposition.position()[1],
beamposition.position()[2]);
if (!m_useBeamSpotInfo) beamSpotPosition=Amg::Vector3D(0,0,0);
std::vector<Amg::Vector2D> localPosition=m_NnClusterizationFactory->estimatePositions(origCluster,
beamSpotPosition,
errorMatrix,
2);
if (errorMatrix.size()!=2 || localPosition.size()!=2)
{
ATH_MSG_WARNING("Error matrix or local position vector size is not 2, it is:" << errorMatrix.size() << " or " << localPosition.size() << ".");
}
std::vector<InDet::PixelClusterParts> allMultiPClusters;
allMultiPClusters.push_back(PixelClusterParts(rdos,totList,lvl1group,localPosition[0],errorMatrix[0]));
allMultiPClusters.push_back(PixelClusterParts(rdos,totList,lvl1group,localPosition[1],errorMatrix[1]));
return allMultiPClusters;
}
std::vector<InDet::PixelClusterParts> InDet::NnPixelClusterSplitter::splitCluster(const InDet::PixelCluster& origCluster,
const InDet::PixelClusterSplitProb& splitProb) const
{
if (m_splitOnlyOnBLayer)
{
const InDetDD::SiDetectorElement* element=origCluster.detectorElement();
if (element==0) {
ATH_MSG_WARNING("Could not get detector element");
return std::vector<InDet::PixelClusterParts>();
}
const AtlasDetectorID* aid = element->getIdHelper();
if (aid==0)
{
ATH_MSG_WARNING("Could not get ATLASDetectorID");
return std::vector<InDet::PixelClusterParts>();
}
const PixelID* pixelIDp=dynamic_cast<const PixelID*>(aid);
if (!pixelIDp)
{
ATH_MSG_WARNING("Could not get PixelID pointer");
return std::vector<InDet::PixelClusterParts>();
}
//check if original pixel is on b-layer and if yes continue, otherwise interrupt...
Identifier pixelId = origCluster.identify();
if (!pixelIDp->is_blayer(pixelId))
{
//return empty object...
ATH_MSG_VERBOSE(" Cluster not on b-layer. Return empty object-->back to default clustering." );;
return std::vector<InDet::PixelClusterParts>();
}
}
//add treatment for b-layer only HERE
Trk::RecVertex beamposition(m_iBeamCondSvc->beamVtx());
const std::vector<Identifier>& rdos = origCluster.rdoList();
const std::vector<int>& totList = origCluster.totList();
//fill lvl1group all with the same value... (not best way but ...)
std::vector<int> lvl1group;
lvl1group.reserve(rdos.size());
std::vector<Identifier>::const_iterator rdoBegin=rdos.begin();
std::vector<Identifier>::const_iterator rdoEnd=rdos.end();
for (std::vector<Identifier>::const_iterator rdoIter=rdoBegin;rdoIter!=rdoEnd;rdoIter++)
{
lvl1group.push_back(origCluster.LVL1A());
}
if (splitProb.getHighestSplitMultiplicityStored()<3) return std::vector<InDet::PixelClusterParts>();
double splitProb2=splitProb.splitProbability(2);
double splitProb3rel=splitProb.splitProbability(3);
double splitProb3=splitProb3rel/(splitProb3rel+splitProb2);
ATH_MSG_VERBOSE( " SplitProb -->2 " << splitProb2 << " SplitProb -->3 " << splitProb3 );;
int nParticles=1;
if (splitProb2>m_thresholdSplittingIntoTwoClusters)
{
if (splitProb3>m_thresholdSplittingIntoThreeClusters)
{
nParticles=3;
}
else
{
nParticles=2;
}
}
ATH_MSG_VERBOSE( " Decided for n. particles: " << nParticles << "." );;
std::vector<Amg::Vector2D> allLocalPositions;
std::vector<Amg::MatrixX> allErrorMatrix;
Amg::Vector3D beamSpotPosition=Amg::Vector3D(
beamposition.position()[0],
beamposition.position()[1],
beamposition.position()[2]);
if (!m_useBeamSpotInfo) beamSpotPosition=Amg::Vector3D(0,0,0);
std::vector<InDet::PixelClusterParts> allMultiPClusters;
if (nParticles==1)
{
std::vector<Amg::MatrixX> errorMatrix;
std::vector<Amg::Vector2D> localPosition=m_NnClusterizationFactory->estimatePositions(origCluster,
beamSpotPosition,
errorMatrix,
1);
if (errorMatrix.size()!=1 || localPosition.size()!=1)
{
ATH_MSG_ERROR("Error matrix or local position vector size is not 1, it is:" << errorMatrix.size() << " or " << localPosition.size() << ".");
}
allMultiPClusters.push_back(PixelClusterParts(rdos,totList,lvl1group,localPosition[0],errorMatrix[0]));
}
else if (nParticles==2)
{
std::vector<Amg::MatrixX> errorMatrix;
std::vector<Amg::Vector2D> localPosition=m_NnClusterizationFactory->estimatePositions(origCluster,
beamSpotPosition,
errorMatrix,
2);
if (errorMatrix.size()!=2 || localPosition.size()!=2)
{
ATH_MSG_ERROR("Error matrix or local position vector size is not 2, it is:" << errorMatrix.size() << " or " << localPosition.size() << ".");
}
allMultiPClusters.push_back(PixelClusterParts(rdos,totList,lvl1group,localPosition[0],errorMatrix[0]));
allMultiPClusters.push_back(PixelClusterParts(rdos,totList,lvl1group,localPosition[1],errorMatrix[1]));
}
else if (nParticles==3)
{
std::vector<Amg::MatrixX> errorMatrix;
std::vector<Amg::Vector2D> localPosition=m_NnClusterizationFactory->estimatePositions(origCluster,
beamSpotPosition,
errorMatrix,
3);
if (errorMatrix.size()!=3 || localPosition.size()!=3)
{
ATH_MSG_ERROR("Error matrix or local position vector size is not 2, it is:" << errorMatrix.size() << " or " << localPosition.size() << ".");
}
allMultiPClusters.push_back(PixelClusterParts(rdos,totList,lvl1group,localPosition[0],errorMatrix[0]));
allMultiPClusters.push_back(PixelClusterParts(rdos,totList,lvl1group,localPosition[1],errorMatrix[1]));
allMultiPClusters.push_back(PixelClusterParts(rdos,totList,lvl1group,localPosition[2],errorMatrix[2]));
}
return allMultiPClusters;
}
InnerDetector/InDetRecTools/SiClusterizationTool/src/components/SiClusterizationTool_entries.cxx
+ 3
− 0
View file @ c8b46ffd
......@@ -9,6 +9,7 @@
#include "SiClusterizationTool/PixelGangedAmbiguitiesFinder.h"
#include "GaudiKernel/DeclareFactoryEntries.h"
#include "SiClusterizationTool/TotPixelClusterSplitter.h"
#include "SiClusterizationTool/NnPixelClusterSplitter.h"
#include "SiClusterizationTool/NnClusterizationFactory.h"
#include "SiClusterizationTool/NnPixelClusterSplitProbTool.h"
......@@ -19,6 +20,7 @@ DECLARE_NAMESPACE_TOOL_FACTORY( InDet, SCT_ClusteringTool )
DECLARE_NAMESPACE_TOOL_FACTORY( InDet, PixelGangedAmbiguitiesFinder )
DECLARE_NAMESPACE_TOOL_FACTORY( InDet, ClusterMakerTool )
DECLARE_NAMESPACE_TOOL_FACTORY( InDet, TotPixelClusterSplitter )
DECLARE_NAMESPACE_TOOL_FACTORY( InDet, NnPixelClusterSplitter )
DECLARE_NAMESPACE_TOOL_FACTORY( InDet, NnClusterizationFactory )
DECLARE_NAMESPACE_TOOL_FACTORY( InDet, NnPixelClusterSplitProbTool )
......@@ -29,6 +31,7 @@ DECLARE_FACTORY_ENTRIES( SiClusterizationTool ){
DECLARE_NAMESPACE_TOOL( InDet, PixelGangedAmbiguitiesFinder )
DECLARE_NAMESPACE_TOOL( InDet, ClusterMakerTool )
DECLARE_NAMESPACE_TOOL( InDet, TotPixelClusterSplitter )
DECLARE_NAMESPACE_TOOL( InDet, NnPixelClusterSplitter )
DECLARE_NAMESPACE_TOOL( InDet, NnClusterizationFactory )
DECLARE_NAMESPACE_TOOL( InDet, NnPixelClusterSplitProbTool )
......
Reconstruction/egamma/egammaRec/python/EMCommonRefitter.py
+ 26
− 3
View file @ c8b46ffd
......@@ -29,9 +29,32 @@ else :
ToolSvc += egNeuralNetworkToHistoTool
#--- new NN factor
from SiClusterizationTool.ConfiguredNnClusterization import NnCalibMaker
egNnClusterizationFactory = NnCalibMaker.get()
ToolSvc += egNnClusterizationFactory
# COOL binding
from IOVDbSvc.CondDB import conddb
conddb.addFolder("PIXEL_OFL","/PIXEL/PixelClustering/PixelClusNNCalib")
# --- Select the necessary settings when running on run 1 data/MC
# --- since a correction is needed to fix biases when running on new run 2 compatible calibation
from SiClusterizationTool.SiClusterizationToolConf import InDet__NnClusterizationFactory
if not "R2" in globalflags.DetDescrVersion() and not "IBL3D25" in globalflags.DetDescrVersion():
egNnClusterizationFactory = InDet__NnClusterizationFactory( name = "egNnClusterizationFactory",
NetworkToHistoTool = egNeuralNetworkToHistoTool,
doRunI = True,
useToT = False,
useRecenteringNNWithoutTracks = True,
useRecenteringNNWithTracks = False,
correctLorShiftBarrelWithoutTracks = 0,
correctLorShiftBarrelWithTracks = 0.030,
LoadNoTrackNetwork = True,
LoadWithTrackNetwork = True)
else:
egNnClusterizationFactory = InDet__NnClusterizationFactory( name = "egNnClusterizationFactory",
NetworkToHistoTool = egNeuralNetworkToHistoTool,
LoadNoTrackNetwork = True,
useToT = InDetFlags.doNNToTCalibration(),
LoadWithTrackNetwork = True)
ToolSvc += egNnClusterizationFactory
#End of do cluster splitting
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment