CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | Private Member Functions | Private Attributes
Vx3DHLTAnalyzer Class Reference

#include <Vx3DHLTAnalyzer.h>

Inheritance diagram for Vx3DHLTAnalyzer:
DQMEDAnalyzer edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > > edm::stream::EDAnalyzerBase edm::EDConsumerBase

Public Member Functions

 Vx3DHLTAnalyzer (const edm::ParameterSet &)
 
 ~Vx3DHLTAnalyzer ()
 
- Public Member Functions inherited from DQMEDAnalyzer
virtual void beginRun (edm::Run const &, edm::EventSetup const &) final
 
virtual void beginStream (edm::StreamID id) final
 
virtual void dqmBeginRun (edm::Run const &, edm::EventSetup const &)
 
 DQMEDAnalyzer (void)
 
virtual void endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
 
virtual void endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
 
uint32_t streamId () const
 
- Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
 EDAnalyzer ()=default
 
- Public Member Functions inherited from edm::stream::EDAnalyzerBase
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
 EDAnalyzerBase ()
 
ModuleDescription const & moduleDescription () const
 
virtual ~EDAnalyzerBase ()
 
- Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo > consumesInfo () const
 
 EDConsumerBase ()
 
ProductHolderIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
 
std::vector
< ProductHolderIndexAndSkipBit >
const & 		itemsToGetFromEvent () const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const
 
void modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
 
bool registeredToConsume (ProductHolderIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
void updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
 
virtual ~EDConsumerBase ()
 

Private Member Functions

void analyze (const edm::Event &iEvent, const edm::EventSetup &iSetup)
 
void beginLuminosityBlock (const edm::LuminosityBlock &lumiBlock, const edm::EventSetup &iSetup)
 
void bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
 
void endLuminosityBlock (const edm::LuminosityBlock &lumiBlock, const edm::EventSetup &iSetup)
 
std::string formatTime (const time_t &t)
 
unsigned int HitCounter (const edm::Event &iEvent)
 
int MyFit (std::vector< double > *vals)
 
void printFitParams (const std::vector< double > &fitResults)
 
void reset (std::string ResetType)
 
void writeToFile (std::vector< double > *vals, edm::TimeValue_t BeginTimeOfFit, edm::TimeValue_t EndTimeOfFit, unsigned int BeginLumiOfFit, unsigned int EndLumiOfFit, int dataType)
 

Private Attributes

unsigned int beginLumiOfFit
 
edm::TimeValue_t beginTimeOfFit
 
bool dataFromFit
 
bool debugMode
 
MonitorElement * dxdzlumi
 
MonitorElement * dydzlumi
 
unsigned int endLumiOfFit
 
edm::TimeValue_t endTimeOfFit
 
std::string fileName
 
MonitorElement * fitResults
 
MonitorElement * goodVxCounter
 
MonitorElement * hitCounter
 
bool internalDebug
 
unsigned int lastLumiOfFit
 
unsigned int lumiCounter
 
unsigned int maxLumiIntegration
 
unsigned int minNentries
 
double minVxDoF
 
double minVxWgt
 
MonitorElement * mXlumi
 
MonitorElement * mYlumi
 
MonitorElement * mZlumi
 
unsigned int nLumiFit
 
unsigned int nLumiXaxisRange
 
unsigned int nParams
 
unsigned int numberFits
 
unsigned int numberGoodFits
 
std::ofstream outputDebugFile
 
std::ofstream outputFile
 
edm::EDGetTokenT
< SiPixelRecHitCollection > 		pixelHitCollection
 
MonitorElement * reportSummary
 
MonitorElement * reportSummaryMap
 
unsigned int runNumber
 
MonitorElement * statusCounter
 
MonitorElement * sXlumi
 
MonitorElement * sYlumi
 
MonitorElement * sZlumi
 
unsigned int totalHits
 
edm::EDGetTokenT
< reco::VertexCollection > 		vertexCollection
 
MonitorElement * Vx_X
 
MonitorElement * Vx_XY
 
MonitorElement * Vx_Y
 
MonitorElement * Vx_Z
 
MonitorElement * Vx_ZX
 
MonitorElement * Vx_ZY
 
double xRange
 
double xStep
 
double yRange
 
double yStep
 
double zRange
 
double zStep
 

Additional Inherited Members

- Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T...> CacheTypes
 
typedef CacheTypes::GlobalCache GlobalCache
 
typedef AbilityChecker< T...> HasAbility
 
typedef
CacheTypes::LuminosityBlockCache 		LuminosityBlockCache
 
typedef
LuminosityBlockContextT
< LuminosityBlockCache,
RunCache, GlobalCache > 		LuminosityBlockContext
 
typedef
CacheTypes::LuminosityBlockSummaryCache 		LuminosityBlockSummaryCache
 
typedef CacheTypes::RunCache RunCache
 
typedef RunContextT< RunCache,
GlobalCache > 		RunContext
 
typedef CacheTypes::RunSummaryCache RunSummaryCache
 
- Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase ModuleType
 
- Public Types inherited from edm::EDConsumerBase
typedef ProductLabels Labels
 
- Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr
< dqmDetails::NoCache > 		globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)
 
static std::shared_ptr
< dqmDetails::NoCache > 		globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)
 
static void globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *, dqmDetails::NoCache *)
 
static void globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *, dqmDetails::NoCache *)
 
- Static Public Member Functions inherited from edm::stream::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 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 65 of file Vx3DHLTAnalyzer.h.

Constructor & Destructor Documentation

Vx3DHLTAnalyzer::Vx3DHLTAnalyzer ( const edm::ParameterSet &  iConfig)

Definition at line 32 of file Vx3DHLTAnalyzer.cc.

References considerVxCovariance, beampixel_dqm_sourceclient-live_cfg::dataFromFit, beampixel_dqm_sourceclient-live_cfg::debugMode, MillePedeFileConverter_cfg::fileName, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), HLT_25ns14e33_v1_cff::InputTag, beampixel_dqm_sourceclient-live_cfg::maxLumiIntegration, beampixel_dqm_sourceclient-live_cfg::minNentries, beampixel_dqm_sourceclient-live_cfg::minVxDoF, beampixel_dqm_sourceclient-live_cfg::minVxWgt, beampixel_dqm_sourceclient-live_cfg::nLumiFit, beampixel_dqm_sourceclient-live_cfg::nLumiXaxisRange, pi, beampixel_dqm_sourceclient-live_cfg::pixelHitCollection, GoodVertex_cfg::vertexCollection, VxErrCorr, beampixel_dqm_sourceclient-live_cfg::xRange, beampixel_dqm_sourceclient-live_cfg::xStep, beampixel_dqm_sourceclient-live_cfg::yRange, beampixel_dqm_sourceclient-live_cfg::yStep, beampixel_dqm_sourceclient-live_cfg::zRange, and beampixel_dqm_sourceclient-live_cfg::zStep.

33 {
34  debugMode = true;
35  nLumiFit = 2; // Number of integrated lumis to perform the fit
36  maxLumiIntegration = 15; // If failing fits, this is the maximum number of integrated lumis after which a reset is issued
37  nLumiXaxisRange = 3000; // Correspond to about 20h of data taking: 20h * 60min * 60s / 23s per lumi-block = 3130
38  dataFromFit = true; // The Beam Spot data can be either taken from the histograms or from the fit results
39  minNentries = 20; // Minimum number of good vertices to perform the fit
40  xRange = 0.8; // [cm]
41  xStep = 0.001; // [cm]
42  yRange = 0.8; // [cm]
43  yStep = 0.001; // [cm]
44  zRange = 30.; // [cm]
45  zStep = 0.04; // [cm]
46  VxErrCorr = 1.3;
47  minVxDoF = 10.; // Good-vertex selection cut
48  // For vertex fitter without track-weight: d.o.f. = 2*NTracks - 3
49  // For vertex fitter with track-weight: d.o.f. = sum_NTracks(2*track_weight) - 3
50  minVxWgt = 0.5; // Good-vertex selection cut
51  fileName = "BeamPixelResults.txt";
52 
53  vertexCollection = consumes<VertexCollection> (iConfig.getUntrackedParameter<InputTag>("vertexCollection", InputTag("pixelVertices")));
54  pixelHitCollection = consumes<SiPixelRecHitCollection>(iConfig.getUntrackedParameter<InputTag>("pixelHitCollection", InputTag("siPixelRecHits")));
55 
56  debugMode = iConfig.getParameter<bool>("debugMode");
57  nLumiFit = iConfig.getParameter<unsigned int>("nLumiFit");
58  maxLumiIntegration = iConfig.getParameter<unsigned int>("maxLumiIntegration");
59  nLumiXaxisRange = iConfig.getParameter<unsigned int>("nLumiXaxisRange");
60  dataFromFit = iConfig.getParameter<bool>("dataFromFit");
61  minNentries = iConfig.getParameter<unsigned int>("minNentries");
62  xRange = iConfig.getParameter<double>("xRange");
63  xStep = iConfig.getParameter<double>("xStep");
64  yRange = iConfig.getParameter<double>("yRange");
65  yStep = iConfig.getParameter<double>("yStep");
66  zRange = iConfig.getParameter<double>("zRange");
67  zStep = iConfig.getParameter<double>("zStep");
68  VxErrCorr = iConfig.getParameter<double>("VxErrCorr");
69  minVxDoF = iConfig.getParameter<double>("minVxDoF");
70  minVxWgt = iConfig.getParameter<double>("minVxWgt");
71  fileName = iConfig.getParameter<string>("fileName");
72 
73 
74  // ### Set internal variables ###
75  nParams = 9; // Number of free parameters in the fit
76  internalDebug = false;
77  considerVxCovariance = true; // Deconvolute vertex covariance matrix
78  pi = 3.141592653589793238;
79  // ##############################
80 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
Vx3DHLTAnalyzer::maxLumiIntegration
unsigned int maxLumiIntegration
Definition: Vx3DHLTAnalyzer.h:101
Vx3DHLTAnalyzer::vertexCollection
edm::EDGetTokenT< reco::VertexCollection > vertexCollection
Definition: Vx3DHLTAnalyzer.h:96
Vx3DHLTAnalyzer::nLumiXaxisRange
unsigned int nLumiXaxisRange
Definition: Vx3DHLTAnalyzer.h:102
Vx3DHLTAnalyzer::minNentries
unsigned int minNentries
Definition: Vx3DHLTAnalyzer.h:103
Vx3DHLTAnalyzer::pixelHitCollection
edm::EDGetTokenT< SiPixelRecHitCollection > pixelHitCollection
Definition: Vx3DHLTAnalyzer.h:97
HLT_25ns14e33_v1_cff.InputTag
tuple InputTag
Definition: HLT_25ns14e33_v1_cff.py:45333
pi
const Double_t pi
Definition: trackSplitPlot.h:36
Vx3DHLTAnalyzer::nParams
unsigned int nParams
Definition: Vx3DHLTAnalyzer.h:162
considerVxCovariance
bool considerVxCovariance
Definition: Vx3DHLTAnalyzer.h:53
Vx3DHLTAnalyzer::fileName
std::string fileName
Definition: Vx3DHLTAnalyzer.h:112
VxErrCorr
double VxErrCorr
Definition: Vx3DHLTAnalyzer.h:62
Vx3DHLTAnalyzer::nLumiFit
unsigned int nLumiFit
Definition: Vx3DHLTAnalyzer.h:100
Vx3DHLTAnalyzer::~Vx3DHLTAnalyzer ( )

Definition at line 83 of file Vx3DHLTAnalyzer.cc.

References reset().

84 {
85  reset("scratch");
86 }
Vx3DHLTAnalyzer::reset
void reset(std::string ResetType)
Definition: Vx3DHLTAnalyzer.cc:626

Member Function Documentation

void Vx3DHLTAnalyzer::analyze ( const edm::Event &  iEvent,
const edm::EventSetup &  iSetup 
)
privatevirtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 89 of file Vx3DHLTAnalyzer.cc.

References gather_cfg::cout, VertexType::Covariance, beampixel_dqm_sourceclient-live_cfg::debugMode, DIM, MillePedeFileConverter_cfg::fileName, edm::Event::getByToken(), edm::Event::getLuminosityBlock(), i, edm::EventBase::id(), edm::isNotFinite(), j, beampixel_dqm_sourceclient-live_cfg::minVxDoF, beampixel_dqm_sourceclient-live_cfg::minVxWgt, dbtoconf::out, reset(), edm::EventID::run(), convertSQLiteXML::runNumber, tmp, GoodVertex_cfg::vertexCollection, Vertices, VertexType::x, VertexType::y, and VertexType::z.

90 {
91  Handle<VertexCollection> Vx3DCollection;
92  iEvent.getByToken(vertexCollection, Vx3DCollection);
93 
94  unsigned int i,j;
95  double det;
96  VertexType MyVertex;
97 
98  if (runNumber != iEvent.id().run())
99  {
100  reset("scratch");
101  runNumber = iEvent.id().run();
102 
103  if (debugMode == true)
104  {
105  stringstream debugFile;
106  string tmp(fileName);
107 
108  if (outputDebugFile.is_open() == true) outputDebugFile.close();
109  tmp.erase(strlen(fileName.c_str())-4,4);
110  debugFile << tmp.c_str() << "_Run" << iEvent.id().run() << ".txt";
111  outputDebugFile.open(debugFile.str().c_str(), ios::out);
112  outputDebugFile.close();
113  outputDebugFile.open(debugFile.str().c_str(), ios::app);
114  }
115 
116  beginLuminosityBlock(iEvent.getLuminosityBlock(),iSetup);
117  }
118  else if (beginTimeOfFit != 0)
119  {
120  totalHits += HitCounter(iEvent);
121 
122  if (internalDebug == true)
123  {
124  cout << "[Vx3DHLTAnalyzer]::\tI found " << totalHits << " pixel hits until now" << endl;
125  cout << "[Vx3DHLTAnalyzer]::\tIn this event there are " << Vx3DCollection->size() << " vertex cadidates" << endl;
126  }
127 
128  for (vector<Vertex>::const_iterator it3DVx = Vx3DCollection->begin(); it3DVx != Vx3DCollection->end(); it3DVx++)
129  {
130  if (internalDebug == true)
131  {
132  cout << "[Vx3DHLTAnalyzer]::\tVertex selections:" << endl;
133  cout << "[Vx3DHLTAnalyzer]::\tisValid = " << it3DVx->isValid() << endl;
134  cout << "[Vx3DHLTAnalyzer]::\tisFake = " << it3DVx->isFake() << endl;
135  cout << "[Vx3DHLTAnalyzer]::\tnodof = " << it3DVx->ndof() << endl;
136  cout << "[Vx3DHLTAnalyzer]::\ttracksSize = " << it3DVx->tracksSize() << endl;
137  }
138 
139  if ((it3DVx->isValid() == true) &&
140  (it3DVx->isFake() == false) &&
141  (it3DVx->ndof() >= minVxDoF) &&
142  (it3DVx->tracksSize() > 0) &&
143  ((it3DVx->ndof()+3.) / ((double)it3DVx->tracksSize()) >= 2.*minVxWgt))
144  {
145  for (i = 0; i < DIM; i++)
146  {
147  for (j = 0; j < DIM; j++)
148  {
149  MyVertex.Covariance[i][j] = it3DVx->covariance(i,j);
150  if (isNotFinite(MyVertex.Covariance[i][j]) == true) break;
151  }
152 
153  if (j != DIM) break;
154  }
155 
156  if (i == DIM)
157  det = std::fabs(MyVertex.Covariance[0][0])*(std::fabs(MyVertex.Covariance[1][1])*std::fabs(MyVertex.Covariance[2][2]) - MyVertex.Covariance[1][2]*MyVertex.Covariance[1][2]) -
158  MyVertex.Covariance[0][1]*(MyVertex.Covariance[0][1]*std::fabs(MyVertex.Covariance[2][2]) - MyVertex.Covariance[0][2]*MyVertex.Covariance[1][2]) +
159  MyVertex.Covariance[0][2]*(MyVertex.Covariance[0][1]*MyVertex.Covariance[1][2] - MyVertex.Covariance[0][2]*std::fabs(MyVertex.Covariance[1][1]));
160 
161  if ((i == DIM) && (det > 0.))
162  {
163  if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tVertex accepted !" << endl;
164 
165  MyVertex.x = it3DVx->x();
166  MyVertex.y = it3DVx->y();
167  MyVertex.z = it3DVx->z();
168  Vertices.push_back(MyVertex);
169 
170  Vx_X->Fill(it3DVx->x());
171  Vx_Y->Fill(it3DVx->y());
172  Vx_Z->Fill(it3DVx->z());
173 
174  Vx_ZX->Fill(it3DVx->z(), it3DVx->x());
175  Vx_ZY->Fill(it3DVx->z(), it3DVx->y());
176  Vx_XY->Fill(it3DVx->x(), it3DVx->y());
177  }
178  else if (internalDebug == true)
179  {
180  cout << "[Vx3DHLTAnalyzer]::\tVertex discarded !" << endl;
181 
182  for (i = 0; i < DIM; i++)
183  for (j = 0; j < DIM; j++)
184  cout << "(i,j) --> " << i << "," << j << " --> " << MyVertex.Covariance[i][j] << endl;
185  }
186  }
187  else if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tVertex discarded !" << endl;
188  }
189  }
190 }
edm::EventID::run
RunNumber_t run() const
Definition: EventID.h:39
i
int i
Definition: DBlmapReader.cc:9
Vx3DHLTAnalyzer::Vx_ZX
MonitorElement * Vx_ZX
Definition: Vx3DHLTAnalyzer.h:133
Vx3DHLTAnalyzer::totalHits
unsigned int totalHits
Definition: Vx3DHLTAnalyzer.h:156
Vx3DHLTAnalyzer::vertexCollection
edm::EDGetTokenT< reco::VertexCollection > vertexCollection
Definition: Vx3DHLTAnalyzer.h:96
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:464
Vx3DHLTAnalyzer::Vx_X
MonitorElement * Vx_X
Definition: Vx3DHLTAnalyzer.h:129
Vx3DHLTAnalyzer::beginTimeOfFit
edm::TimeValue_t beginTimeOfFit
Definition: Vx3DHLTAnalyzer.h:152
Vx3DHLTAnalyzer::HitCounter
unsigned int HitCounter(const edm::Event &iEvent)
Definition: Vx3DHLTAnalyzer.cc:193
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:170
Vx3DHLTAnalyzer::Vx_XY
MonitorElement * Vx_XY
Definition: Vx3DHLTAnalyzer.h:135
VertexType::Covariance
double Covariance[3][3]
Definition: Vx3DHLTAnalyzer.h:50
edm::isNotFinite
bool isNotFinite(T x)
Definition: isFinite.h:10
Vx3DHLTAnalyzer::Vx_ZY
MonitorElement * Vx_ZY
Definition: Vx3DHLTAnalyzer.h:134
Vx3DHLTAnalyzer::fileName
std::string fileName
Definition: Vx3DHLTAnalyzer.h:112
Vx3DHLTAnalyzer::outputDebugFile
std::ofstream outputDebugFile
Definition: Vx3DHLTAnalyzer.h:151
j
int j
Definition: DBlmapReader.cc:9
edm::Event::getLuminosityBlock
LuminosityBlock const & getLuminosityBlock() const
Definition: Event.h:84
Vx3DHLTAnalyzer::Vx_Z
MonitorElement * Vx_Z
Definition: Vx3DHLTAnalyzer.h:131
Vx3DHLTAnalyzer::reset
void reset(std::string ResetType)
Definition: Vx3DHLTAnalyzer.cc:626
Vx3DHLTAnalyzer::beginLuminosityBlock
void beginLuminosityBlock(const edm::LuminosityBlock &lumiBlock, const edm::EventSetup &iSetup)
Definition: Vx3DHLTAnalyzer.cc:865
dbtoconf.out
tuple out
Definition: dbtoconf.py:99
DIM
#define DIM
Definition: Vx3DHLTAnalyzer.h:43
tmp
std::vector< std::vector< double > > tmp
Definition: MVATrainer.cc:100
edm::EventBase::id
edm::EventID id() const
Definition: EventBase.h:60
Vx3DHLTAnalyzer::runNumber
unsigned int runNumber
Definition: Vx3DHLTAnalyzer.h:154
Vertices
std::vector< VertexType > Vertices
Definition: Vx3DHLTAnalyzer.h:52
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
Vx3DHLTAnalyzer::Vx_Y
MonitorElement * Vx_Y
Definition: Vx3DHLTAnalyzer.h:130
void Vx3DHLTAnalyzer::beginLuminosityBlock ( const edm::LuminosityBlock &  lumiBlock,
const edm::EventSetup &  iSetup 
)
privatevirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 865 of file Vx3DHLTAnalyzer.cc.

References edm::LuminosityBlockBase::beginTime(), edm::LuminosityBlockBase::luminosityBlock(), reset(), and edm::Timestamp::value().

866 {
867  // @@@ If statement to avoid problems with non-sequential lumisections @@@
868  if ((lumiCounter == 0) && (lumiBlock.luminosityBlock() > lastLumiOfFit))
869  {
870  beginTimeOfFit = lumiBlock.beginTime().value();
871  beginLumiOfFit = lumiBlock.luminosityBlock();
872  lumiCounter++;
873  }
874  else if ((lumiCounter != 0) && (lumiBlock.luminosityBlock() >= (beginLumiOfFit+lumiCounter))) lumiCounter++;
875  else reset("scratch");
876 }
Vx3DHLTAnalyzer::lumiCounter
unsigned int lumiCounter
Definition: Vx3DHLTAnalyzer.h:155
Vx3DHLTAnalyzer::beginLumiOfFit
unsigned int beginLumiOfFit
Definition: Vx3DHLTAnalyzer.h:159
Vx3DHLTAnalyzer::beginTimeOfFit
edm::TimeValue_t beginTimeOfFit
Definition: Vx3DHLTAnalyzer.h:152
edm::LuminosityBlockBase::beginTime
Timestamp const & beginTime() const
Definition: LuminosityBlockBase.h:54
edm::LuminosityBlockBase::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: LuminosityBlockBase.h:42
Vx3DHLTAnalyzer::reset
void reset(std::string ResetType)
Definition: Vx3DHLTAnalyzer.cc:626
Vx3DHLTAnalyzer::lastLumiOfFit
unsigned int lastLumiOfFit
Definition: Vx3DHLTAnalyzer.h:161
edm::Timestamp::value
TimeValue_t value() const
Definition: Timestamp.h:56
void Vx3DHLTAnalyzer::bookHistograms ( DQMStore::IBooker &  ibooker,
edm::Run const &  iRun,
edm::EventSetup const &   
)
overrideprivatevirtual

Implements DQMEDAnalyzer.

Definition at line 1169 of file Vx3DHLTAnalyzer.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::bookFloat(), MonitorElement::Fill(), MonitorElement::getTH1(), beampixel_dqm_sourceclient-live_cfg::nLumiXaxisRange, reset(), MonitorElement::setAxisTitle(), DQMStore::IBooker::setCurrentFolder(), beampixel_dqm_sourceclient-live_cfg::xRange, beampixel_dqm_sourceclient-live_cfg::xStep, beampixel_dqm_sourceclient-live_cfg::yRange, beampixel_dqm_sourceclient-live_cfg::yStep, beampixel_dqm_sourceclient-live_cfg::zRange, and beampixel_dqm_sourceclient-live_cfg::zStep.

1170 {
1171  ibooker.setCurrentFolder("BeamPixel");
1172 
1173  Vx_X = ibooker.book1D("F - vertex x", "Primary Vertex X Coordinate Distribution", int(rint(xRange/xStep)), -xRange/2., xRange/2.);
1174  Vx_Y = ibooker.book1D("F - vertex y", "Primary Vertex Y Coordinate Distribution", int(rint(yRange/yStep)), -yRange/2., yRange/2.);
1175  Vx_Z = ibooker.book1D("F - vertex z", "Primary Vertex Z Coordinate Distribution", int(rint(zRange/zStep)), -zRange/2., zRange/2.);
1176  Vx_X->setAxisTitle("Primary Vertices X [cm]",1);
1177  Vx_X->setAxisTitle("Entries [#]",2);
1178  Vx_Y->setAxisTitle("Primary Vertices Y [cm]",1);
1179  Vx_Y->setAxisTitle("Entries [#]",2);
1180  Vx_Z->setAxisTitle("Primary Vertices Z [cm]",1);
1181  Vx_Z->setAxisTitle("Entries [#]",2);
1182 
1183  mXlumi = ibooker.book1D("B - muX vs lumi", "#mu_{x} vs. Lumisection", nLumiXaxisRange, 0.5, ((double)nLumiXaxisRange)+0.5);
1184  mYlumi = ibooker.book1D("B - muY vs lumi", "#mu_{y} vs. Lumisection", nLumiXaxisRange, 0.5, ((double)nLumiXaxisRange)+0.5);
1185  mZlumi = ibooker.book1D("B - muZ vs lumi", "#mu_{z} vs. Lumisection", nLumiXaxisRange, 0.5, ((double)nLumiXaxisRange)+0.5);
1186  mXlumi->setAxisTitle("Lumisection [#]",1);
1187  mXlumi->setAxisTitle("#mu_{x} [cm]",2);
1188  mXlumi->getTH1()->SetOption("E1");
1189  mYlumi->setAxisTitle("Lumisection [#]",1);
1190  mYlumi->setAxisTitle("#mu_{y} [cm]",2);
1191  mYlumi->getTH1()->SetOption("E1");
1192  mZlumi->setAxisTitle("Lumisection [#]",1);
1193  mZlumi->setAxisTitle("#mu_{z} [cm]",2);
1194  mZlumi->getTH1()->SetOption("E1");
1195 
1196  sXlumi = ibooker.book1D("C - sigmaX vs lumi", "#sigma_{x} vs. Lumisection", nLumiXaxisRange, 0.5, ((double)nLumiXaxisRange)+0.5);
1197  sYlumi = ibooker.book1D("C - sigmaY vs lumi", "#sigma_{y} vs. Lumisection", nLumiXaxisRange, 0.5, ((double)nLumiXaxisRange)+0.5);
1198  sZlumi = ibooker.book1D("C - sigmaZ vs lumi", "#sigma_{z} vs. Lumisection", nLumiXaxisRange, 0.5, ((double)nLumiXaxisRange)+0.5);
1199  sXlumi->setAxisTitle("Lumisection [#]",1);
1200  sXlumi->setAxisTitle("#sigma_{x} [cm]",2);
1201  sXlumi->getTH1()->SetOption("E1");
1202  sYlumi->setAxisTitle("Lumisection [#]",1);
1203  sYlumi->setAxisTitle("#sigma_{y} [cm]",2);
1204  sYlumi->getTH1()->SetOption("E1");
1205  sZlumi->setAxisTitle("Lumisection [#]",1);
1206  sZlumi->setAxisTitle("#sigma_{z} [cm]",2);
1207  sZlumi->getTH1()->SetOption("E1");
1208 
1209  dxdzlumi = ibooker.book1D("D - dxdz vs lumi", "dX/dZ vs. Lumisection", nLumiXaxisRange, 0.5, ((double)nLumiXaxisRange)+0.5);
1210  dydzlumi = ibooker.book1D("D - dydz vs lumi", "dY/dZ vs. Lumisection", nLumiXaxisRange, 0.5, ((double)nLumiXaxisRange)+0.5);
1211  dxdzlumi->setAxisTitle("Lumisection [#]",1);
1212  dxdzlumi->setAxisTitle("dX/dZ [rad]",2);
1213  dxdzlumi->getTH1()->SetOption("E1");
1214  dydzlumi->setAxisTitle("Lumisection [#]",1);
1215  dydzlumi->setAxisTitle("dY/dZ [rad]",2);
1216  dydzlumi->getTH1()->SetOption("E1");
1217 
1218  Vx_ZX = ibooker.book2D("E - vertex zx", "Primary Vertex ZX Coordinate Distribution", int(rint(zRange/zStep)), -zRange/2., zRange/2., int(rint(xRange/xStep)), -xRange/2., xRange/2.);
1219  Vx_ZY = ibooker.book2D("E - vertex zy", "Primary Vertex ZY Coordinate Distribution", int(rint(zRange/zStep)), -zRange/2., zRange/2., int(rint(yRange/yStep)), -yRange/2., yRange/2.);
1220  Vx_XY = ibooker.book2D("E - vertex xy", "Primary Vertex XY Coordinate Distribution", int(rint(xRange/xStep)), -xRange/2., xRange/2., int(rint(yRange/yStep)), -yRange/2., yRange/2.);
1221  Vx_ZX->setAxisTitle("Primary Vertices Z [cm]",1);
1222  Vx_ZX->setAxisTitle("Primary Vertices X [cm]",2);
1223  Vx_ZX->setAxisTitle("Entries [#]",3);
1224  Vx_ZY->setAxisTitle("Primary Vertices Z [cm]",1);
1225  Vx_ZY->setAxisTitle("Primary Vertices Y [cm]",2);
1226  Vx_ZY->setAxisTitle("Entries [#]",3);
1227  Vx_XY->setAxisTitle("Primary Vertices X [cm]",1);
1228  Vx_XY->setAxisTitle("Primary Vertices Y [cm]",2);
1229  Vx_XY->setAxisTitle("Entries [#]",3);
1230 
1231  hitCounter = ibooker.book1D("H - pixelHits vs lumi", "# Pixel-Hits vs. Lumisection", nLumiXaxisRange, 0.5, ((double)nLumiXaxisRange)+0.5);
1232  hitCounter->setAxisTitle("Lumisection [#]",1);
1233  hitCounter->setAxisTitle("Pixel-Hits [#]",2);
1234  hitCounter->getTH1()->SetOption("E1");
1235 
1236  goodVxCounter = ibooker.book1D("G - good vertices vs lumi", "# Good vertices vs. Lumisection", nLumiXaxisRange, 0.5, ((double)nLumiXaxisRange)+0.5);
1237  goodVxCounter->setAxisTitle("Lumisection [#]",1);
1238  goodVxCounter->setAxisTitle("Good vertices [#]",2);
1239  goodVxCounter->getTH1()->SetOption("E1");
1240 
1241  statusCounter = ibooker.book1D("I - app status vs lumi", "Status vs. Lumisection", nLumiXaxisRange, 0.5, ((double)nLumiXaxisRange)+0.5);
1242  statusCounter->setAxisTitle("Lumisection [#]",1);
1243  statusCounter->setAxisTitle("App. status [0 = OK]",2);
1244  statusCounter->getTH1()->SetOption("E1");
1245 
1246  fitResults = ibooker.book2D("A - fit results","Results of Beam Spot Fit", 2, 0., 2., 9, 0., 9.);
1247  fitResults->setAxisTitle("Ongoing: bootstrapping", 1);
1248  fitResults->setBinLabel(9, "X[cm]", 2);
1249  fitResults->setBinLabel(8, "Y[cm]", 2);
1250  fitResults->setBinLabel(7, "Z[cm]", 2);
1251  fitResults->setBinLabel(6, "#sigma_{Z}[cm]", 2);
1252  fitResults->setBinLabel(5, "#frac{dX}{dZ}[rad]", 2);
1253  fitResults->setBinLabel(4, "#frac{dY}{dZ}[rad]", 2);
1254  fitResults->setBinLabel(3, "#sigma_{X}[cm]", 2);
1255  fitResults->setBinLabel(2, "#sigma_{Y}[cm]", 2);
1256  fitResults->setBinLabel(1, "Vtx[#]", 2);
1257  fitResults->setBinLabel(1, "Value", 1);
1258  fitResults->setBinLabel(2, "Error (stat)", 1);
1259  fitResults->getTH1()->SetOption("text");
1260 
1261 
1262  ibooker.setCurrentFolder("BeamPixel/EventInfo");
1263 
1264  reportSummary = ibooker.bookFloat("reportSummary");
1265  reportSummary->Fill(-1);
1266  reportSummaryMap = ibooker.book2D("reportSummaryMap","Pixel-Vertices Beam Spot: % Good Fits", 1, 0., 1., 1, 0., 1.);
1267  reportSummaryMap->getTH1()->SetBinContent(1, 1, -1);
1268 
1269  ibooker.setCurrentFolder("BeamPixel/EventInfo/reportSummaryContents");
1270 
1271  // Convention for reportSummary and reportSummaryMap:
1272  // - -1% at the moment of creation of the histogram (i.e. white histogram)
1273  // - n% numberGoodFits / numberFits
1274 
1275 
1276  reset("scratch"); // Initialize histograms after creation
1277 }
Vx3DHLTAnalyzer::statusCounter
MonitorElement * statusCounter
Definition: Vx3DHLTAnalyzer.h:139
Vx3DHLTAnalyzer::dxdzlumi
MonitorElement * dxdzlumi
Definition: Vx3DHLTAnalyzer.h:126
Vx3DHLTAnalyzer::Vx_ZX
MonitorElement * Vx_ZX
Definition: Vx3DHLTAnalyzer.h:133
Vx3DHLTAnalyzer::nLumiXaxisRange
unsigned int nLumiXaxisRange
Definition: Vx3DHLTAnalyzer.h:102
Vx3DHLTAnalyzer::Vx_X
MonitorElement * Vx_X
Definition: Vx3DHLTAnalyzer.h:129
MonitorElement::setBinLabel
void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:920
Vx3DHLTAnalyzer::mYlumi
MonitorElement * mYlumi
Definition: Vx3DHLTAnalyzer.h:119
Vx3DHLTAnalyzer::sYlumi
MonitorElement * sYlumi
Definition: Vx3DHLTAnalyzer.h:123
Vx3DHLTAnalyzer::reportSummaryMap
MonitorElement * reportSummaryMap
Definition: Vx3DHLTAnalyzer.h:142
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:170
Vx3DHLTAnalyzer::Vx_XY
MonitorElement * Vx_XY
Definition: Vx3DHLTAnalyzer.h:135
Vx3DHLTAnalyzer::sZlumi
MonitorElement * sZlumi
Definition: Vx3DHLTAnalyzer.h:124
Vx3DHLTAnalyzer::fitResults
MonitorElement * fitResults
Definition: Vx3DHLTAnalyzer.h:144
Vx3DHLTAnalyzer::Vx_ZY
MonitorElement * Vx_ZY
Definition: Vx3DHLTAnalyzer.h:134
Vx3DHLTAnalyzer::reportSummary
MonitorElement * reportSummary
Definition: Vx3DHLTAnalyzer.h:141
Vx3DHLTAnalyzer::goodVxCounter
MonitorElement * goodVxCounter
Definition: Vx3DHLTAnalyzer.h:137
DQMStore::IBooker::book1D
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
Vx3DHLTAnalyzer::dydzlumi
MonitorElement * dydzlumi
Definition: Vx3DHLTAnalyzer.h:127
MonitorElement::getTH1
TH1 * getTH1(void) const
Definition: MonitorElement.cc:1450
Vx3DHLTAnalyzer::Vx_Z
MonitorElement * Vx_Z
Definition: Vx3DHLTAnalyzer.h:131
Vx3DHLTAnalyzer::mXlumi
MonitorElement * mXlumi
Definition: Vx3DHLTAnalyzer.h:118
Vx3DHLTAnalyzer::reset
void reset(std::string ResetType)
Definition: Vx3DHLTAnalyzer.cc:626
Vx3DHLTAnalyzer::mZlumi
MonitorElement * mZlumi
Definition: Vx3DHLTAnalyzer.h:120
Vx3DHLTAnalyzer::sXlumi
MonitorElement * sXlumi
Definition: Vx3DHLTAnalyzer.h:122
DQMStore::IBooker::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:274
DQMStore::IBooker::book2D
MonitorElement * book2D(Args &&...args)
Definition: DQMStore.h:133
DQMStore::IBooker::bookFloat
MonitorElement * bookFloat(Args &&...args)
Definition: DQMStore.h:109
Vx3DHLTAnalyzer::hitCounter
MonitorElement * hitCounter
Definition: Vx3DHLTAnalyzer.h:138
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:947
Vx3DHLTAnalyzer::Vx_Y
MonitorElement * Vx_Y
Definition: Vx3DHLTAnalyzer.h:130
void Vx3DHLTAnalyzer::endLuminosityBlock ( const edm::LuminosityBlock &  lumiBlock,
const edm::EventSetup &  iSetup 
)
privatevirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 879 of file Vx3DHLTAnalyzer.cc.

References counterVx, gather_cfg::cout, beampixel_dqm_sourceclient-live_cfg::dataFromFit, beampixel_dqm_sourceclient-live_cfg::debugMode, alignCSCRings::e, edm::LuminosityBlockBase::endTime(), edm::service::formatTime(), i, edm::LuminosityBlockBase::luminosityBlock(), beampixel_dqm_sourceclient-live_cfg::maxLumiIntegration, beampixel_dqm_sourceclient-live_cfg::minNentries, beampixel_dqm_sourceclient-live_cfg::nLumiFit, beampixel_dqm_sourceclient-live_cfg::nLumiXaxisRange, funct::pow(), reset(), convertSQLiteXML::runNumber, mathSSE::sqrt(), create_public_pileup_plots::vals, and edm::Timestamp::value().

880 {
881  stringstream histTitle;
882  int goodData;
883 
884  if ((nLumiFit != 0) && (lumiCounter%nLumiFit == 0) && (beginTimeOfFit != 0) && (runNumber != 0))
885  {
886  endTimeOfFit = lumiBlock.endTime().value();
887  endLumiOfFit = lumiBlock.luminosityBlock();
888  lastLumiOfFit = endLumiOfFit;
889  vector<double> vals;
890 
891  hitCounter->getTH1()->SetBinContent(lastLumiOfFit, (double)totalHits);
892  hitCounter->getTH1()->SetBinError(lastLumiOfFit, std::sqrt((double)totalHits));
893 
894  if (dataFromFit == true)
895  {
896  vector<double> fitResults;
897 
898  fitResults.push_back(Vx_X->getTH1()->GetRMS()*Vx_X->getTH1()->GetRMS());
899  fitResults.push_back(Vx_Y->getTH1()->GetRMS()*Vx_Y->getTH1()->GetRMS());
900  fitResults.push_back(Vx_Z->getTH1()->GetRMS()*Vx_Z->getTH1()->GetRMS());
901  fitResults.push_back(0.0);
902  fitResults.push_back(0.0);
903  fitResults.push_back(0.0);
904  fitResults.push_back(Vx_X->getTH1()->GetMean());
905  fitResults.push_back(Vx_Y->getTH1()->GetMean());
906  fitResults.push_back(Vx_Z->getTH1()->GetMean());
907  for (unsigned int i = 0; i < nParams; i++) fitResults.push_back(0.0);
908 
909  if (internalDebug == true)
910  {
911  cout << "[Vx3DHLTAnalyzer]::\t@@@ Beam Spot parameters - prefit @@@" << endl;
912 
913  printFitParams(fitResults);
914 
915  cout << "Runnumber " << runNumber << endl;
916  cout << "BeginTimeOfFit " << formatTime(beginTimeOfFit >> 32) << " " << (beginTimeOfFit >> 32) << endl;
917  cout << "EndTimeOfFit " << formatTime(endTimeOfFit >> 32) << " " << (endTimeOfFit >> 32) << endl;
918  cout << "LumiRange " << beginLumiOfFit << " - " << endLumiOfFit << endl;
919  }
920 
921  goodData = MyFit(&fitResults);
922 
923  if (internalDebug == true)
924  {
925  cout << "[Vx3DHLTAnalyzer]::\t@@@ Beam Spot parameters - postfit @@@" << endl;
926 
927  printFitParams(fitResults);
928 
929  cout << "goodData --> " << goodData << endl;
930  cout << "Used vertices --> " << counterVx << endl;
931  }
932 
933  if (goodData == 0)
934  {
935  vals.push_back(fitResults[6]);
936  vals.push_back(fitResults[7]);
937  vals.push_back(fitResults[8]);
938  vals.push_back(std::sqrt(std::fabs(fitResults[2])));
939  vals.push_back(fitResults[5]);
940  vals.push_back(fitResults[4]);
941  vals.push_back(std::sqrt(std::fabs(fitResults[0])));
942  vals.push_back(std::sqrt(std::fabs(fitResults[1])));
943 
944  vals.push_back(std::pow(fitResults[6+nParams],2.));
945  vals.push_back(std::pow(fitResults[7+nParams],2.));
946  vals.push_back(std::pow(fitResults[8+nParams],2.));
947  vals.push_back(std::pow(std::fabs(fitResults[2+nParams]) / (2.*std::sqrt(std::fabs(fitResults[2]))),2.));
948  vals.push_back(std::pow(fitResults[5+nParams],2.));
949  vals.push_back(std::pow(fitResults[4+nParams],2.));
950  vals.push_back(std::pow(std::fabs(fitResults[0+nParams]) / (2.*std::sqrt(std::fabs(fitResults[0]))),2.));
951  vals.push_back(std::pow(std::fabs(fitResults[1+nParams]) / (2.*std::sqrt(std::fabs(fitResults[1]))),2.));
952  }
953  else for (unsigned int i = 0; i < (nParams-1)*2; i++) vals.push_back(0.0);
954 
955  fitResults.clear();
956  }
957  else
958  {
959  counterVx = Vx_X->getTH1F()->GetEntries();
960 
961  if (Vx_X->getTH1F()->GetEntries() >= minNentries)
962  {
963  goodData = 0;
964 
965  vals.push_back(Vx_X->getTH1F()->GetMean());
966  vals.push_back(Vx_Y->getTH1F()->GetMean());
967  vals.push_back(Vx_Z->getTH1F()->GetMean());
968  vals.push_back(Vx_Z->getTH1F()->GetRMS());
969  vals.push_back(0.0);
970  vals.push_back(0.0);
971  vals.push_back(Vx_X->getTH1F()->GetRMS());
972  vals.push_back(Vx_Y->getTH1F()->GetRMS());
973 
974  vals.push_back(std::pow(Vx_X->getTH1F()->GetMeanError(),2.));
975  vals.push_back(std::pow(Vx_Y->getTH1F()->GetMeanError(),2.));
976  vals.push_back(std::pow(Vx_Z->getTH1F()->GetMeanError(),2.));
977  vals.push_back(std::pow(Vx_Z->getTH1F()->GetRMSError(),2.));
978  vals.push_back(0.0);
979  vals.push_back(0.0);
980  vals.push_back(std::pow(Vx_X->getTH1F()->GetRMSError(),2.));
981  vals.push_back(std::pow(Vx_Y->getTH1F()->GetRMSError(),2.));
982  }
983  else
984  {
985  goodData = -2;
986  for (unsigned int i = 0; i < (nParams-1)*2; i++) vals.push_back(0.0);
987  }
988  }
989 
990  // vals[0] = X0
991  // vals[1] = Y0
992  // vals[2] = Z0
993  // vals[3] = sigmaZ0
994  // vals[4] = dxdz
995  // vals[5] = dydz
996  // vals[6] = BeamWidthX
997  // vals[7] = BeamWidthY
998 
999  // vals[8] = err^2 X0
1000  // vals[9] = err^2 Y0
1001  // vals[10] = err^2 Z0
1002  // vals[11] = err^2 sigmaZ0
1003  // vals[12] = err^2 dxdz
1004  // vals[13] = err^2 dydz
1005  // vals[14] = err^2 BeamWidthX
1006  // vals[15] = err^2 BeamWidthY
1007 
1008  numberFits++;
1009  writeToFile(&vals, beginTimeOfFit, endTimeOfFit, beginLumiOfFit, endLumiOfFit, 3);
1010  if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tUsed vertices: " << counterVx << endl;
1011 
1012  statusCounter->getTH1()->SetBinContent(lastLumiOfFit, (double)goodData);
1013  statusCounter->getTH1()->SetBinError(lastLumiOfFit, 1e-3);
1014 
1015  if (goodData == 0)
1016  {
1017  numberGoodFits++;
1018 
1019  histTitle << "Ongoing: fitted lumis " << beginLumiOfFit << " - " << endLumiOfFit;
1020  reset("whole");
1021  }
1022  else
1023  {
1024  if (goodData == -2) histTitle << "Ongoing: not enough evts (" << lumiCounter << " - " << maxLumiIntegration << " lumis)";
1025  else histTitle << "Ongoing: temporary problems (" << lumiCounter << " - " << maxLumiIntegration << " lumis)";
1026 
1027  if (lumiCounter > maxLumiIntegration)
1028  {
1029  statusCounter->getTH1()->SetBinContent(lastLumiOfFit, -5);
1030  statusCounter->getTH1()->SetBinError(lastLumiOfFit, 1e-3);
1031  reset("whole");
1032  }
1033  else reset("hitCounter");
1034  }
1035 
1036  reportSummary->Fill((numberFits != 0 ? ((double)numberGoodFits) / ((double)numberFits) : -1));
1037  reportSummaryMap->getTH1()->SetBinContent(1, 1, (numberFits != 0 ? ((double)numberGoodFits) / ((double)numberFits) : -1));
1038 
1039  fitResults->setAxisTitle(histTitle.str().c_str(), 1);
1040 
1041  fitResults->setBinContent(1, 9, vals[0]);
1042  fitResults->setBinContent(1, 8, vals[1]);
1043  fitResults->setBinContent(1, 7, vals[2]);
1044  fitResults->setBinContent(1, 6, vals[3]);
1045  fitResults->setBinContent(1, 5, vals[4]);
1046  fitResults->setBinContent(1, 4, vals[5]);
1047  fitResults->setBinContent(1, 3, vals[6]);
1048  fitResults->setBinContent(1, 2, vals[7]);
1049  fitResults->setBinContent(1, 1, counterVx);
1050 
1051  fitResults->setBinContent(2, 9, std::sqrt(vals[8]));
1052  fitResults->setBinContent(2, 8, std::sqrt(vals[9]));
1053  fitResults->setBinContent(2, 7, std::sqrt(vals[10]));
1054  fitResults->setBinContent(2, 6, std::sqrt(vals[11]));
1055  fitResults->setBinContent(2, 5, std::sqrt(vals[12]));
1056  fitResults->setBinContent(2, 4, std::sqrt(vals[13]));
1057  fitResults->setBinContent(2, 3, std::sqrt(vals[14]));
1058  fitResults->setBinContent(2, 2, std::sqrt(vals[15]));
1059  fitResults->setBinContent(2, 1, std::sqrt(counterVx));
1060 
1061  // Linear fit to the historical plots
1062  TF1* myLinFit = new TF1("myLinFit", "[0] + [1]*x", mXlumi->getTH1()->GetXaxis()->GetXmin(), mXlumi->getTH1()->GetXaxis()->GetXmax());
1063  myLinFit->SetLineColor(2);
1064  myLinFit->SetLineWidth(2);
1065  myLinFit->SetParName(0,"Inter.");
1066  myLinFit->SetParName(1,"Slope");
1067 
1068  mXlumi->getTH1()->SetBinContent(lastLumiOfFit, vals[0]);
1069  mXlumi->getTH1()->SetBinError(lastLumiOfFit, std::sqrt(vals[8]));
1070  myLinFit->SetParameter(0, mXlumi->getTH1()->GetMean(2));
1071  myLinFit->SetParameter(1, 0.0);
1072  mXlumi->getTH1()->Fit(myLinFit,"QR");
1073 
1074  mYlumi->getTH1()->SetBinContent(lastLumiOfFit, vals[1]);
1075  mYlumi->getTH1()->SetBinError(lastLumiOfFit, std::sqrt(vals[9]));
1076  myLinFit->SetParameter(0, mYlumi->getTH1()->GetMean(2));
1077  myLinFit->SetParameter(1, 0.0);
1078  mYlumi->getTH1()->Fit(myLinFit,"QR");
1079 
1080  mZlumi->getTH1()->SetBinContent(lastLumiOfFit, vals[2]);
1081  mZlumi->getTH1()->SetBinError(lastLumiOfFit, std::sqrt(vals[10]));
1082  myLinFit->SetParameter(0, mZlumi->getTH1()->GetMean(2));
1083  myLinFit->SetParameter(1, 0.0);
1084  mZlumi->getTH1()->Fit(myLinFit,"QR");
1085 
1086  sXlumi->getTH1()->SetBinContent(lastLumiOfFit, vals[6]);
1087  sXlumi->getTH1()->SetBinError(lastLumiOfFit, std::sqrt(vals[14]));
1088  myLinFit->SetParameter(0, sXlumi->getTH1()->GetMean(2));
1089  myLinFit->SetParameter(1, 0.0);
1090  sXlumi->getTH1()->Fit(myLinFit,"QR");
1091 
1092  sYlumi->getTH1()->SetBinContent(lastLumiOfFit, vals[7]);
1093  sYlumi->getTH1()->SetBinError(lastLumiOfFit, std::sqrt(vals[15]));
1094  myLinFit->SetParameter(0, sYlumi->getTH1()->GetMean(2));
1095  myLinFit->SetParameter(1, 0.0);
1096  sYlumi->getTH1()->Fit(myLinFit,"QR");
1097 
1098  sZlumi->getTH1()->SetBinContent(lastLumiOfFit, vals[3]);
1099  sZlumi->getTH1()->SetBinError(lastLumiOfFit, std::sqrt(vals[11]));
1100  myLinFit->SetParameter(0, sZlumi->getTH1()->GetMean(2));
1101  myLinFit->SetParameter(1, 0.0);
1102  sZlumi->getTH1()->Fit(myLinFit,"QR");
1103 
1104  dxdzlumi->getTH1()->SetBinContent(lastLumiOfFit, vals[4]);
1105  dxdzlumi->getTH1()->SetBinError(lastLumiOfFit, std::sqrt(vals[12]));
1106  myLinFit->SetParameter(0, dxdzlumi->getTH1()->GetMean(2));
1107  myLinFit->SetParameter(1, 0.0);
1108  dxdzlumi->getTH1()->Fit(myLinFit,"QR");
1109 
1110  dydzlumi->getTH1()->SetBinContent(lastLumiOfFit, vals[5]);
1111  dydzlumi->getTH1()->SetBinError(lastLumiOfFit, std::sqrt(vals[13]));
1112  myLinFit->SetParameter(0, dydzlumi->getTH1()->GetMean(2));
1113  myLinFit->SetParameter(1, 0.0);
1114  dydzlumi->getTH1()->Fit(myLinFit,"QR");
1115 
1116  delete myLinFit;
1117 
1118  // Exponential fit to the historical plot
1119  TF1* myExpFit = new TF1("myExpFit", "[0]*exp(-x/[1])", hitCounter->getTH1()->GetXaxis()->GetXmin(), hitCounter->getTH1()->GetXaxis()->GetXmax());
1120  myExpFit->SetLineColor(2);
1121  myExpFit->SetLineWidth(2);
1122  myExpFit->SetParName(0,"Ampli.");
1123  myExpFit->SetParName(1,"#tau");
1124 
1125  myExpFit->SetParameter(0, hitCounter->getTH1()->GetMaximum());
1126  myExpFit->SetParameter(1, nLumiXaxisRange/2);
1127  hitCounter->getTH1()->Fit(myExpFit,"QR");
1128 
1129  goodVxCounter->getTH1()->SetBinContent(lastLumiOfFit, (double)counterVx);
1130  goodVxCounter->getTH1()->SetBinError(lastLumiOfFit, std::sqrt((double)counterVx));
1131 
1132  myExpFit->SetParameter(0, goodVxCounter->getTH1()->GetMaximum());
1133  myExpFit->SetParameter(1, nLumiXaxisRange/2);
1134  goodVxCounter->getTH1()->Fit(myExpFit,"QR");
1135 
1136  delete myExpFit;
1137  vals.clear();
1138  }
1139  else if ((nLumiFit != 0) && (lumiCounter%nLumiFit != 0) && (beginTimeOfFit != 0) && (runNumber != 0))
1140  {
1141  histTitle << "Ongoing: accumulating evts (" << lumiCounter%nLumiFit << " - " << nLumiFit << " in " << lumiCounter << " - " << maxLumiIntegration << " lumis)";
1142  fitResults->setAxisTitle(histTitle.str().c_str(), 1);
1143  if ((debugMode == true) && (outputDebugFile.is_open() == true))
1144  {
1145  outputDebugFile << "Runnumber " << runNumber << endl;
1146  outputDebugFile << "BeginTimeOfFit " << formatTime(beginTimeOfFit >> 32) << " " << (beginTimeOfFit >> 32) << endl;
1147  outputDebugFile << "BeginLumiRange " << beginLumiOfFit << endl;
1148  outputDebugFile << histTitle.str().c_str() << "\n" << endl;
1149  }
1150  }
1151  else if ((nLumiFit == 0) || (beginTimeOfFit == 0) || (runNumber == 0))
1152  {
1153  histTitle << "Ongoing: no ongoing fits";
1154  fitResults->setAxisTitle(histTitle.str().c_str(), 1);
1155  if ((debugMode == true) && (outputDebugFile.is_open() == true)) outputDebugFile << histTitle.str().c_str() << "\n" << endl;
1156 
1157  endLumiOfFit = lumiBlock.luminosityBlock();
1158 
1159  hitCounter->getTH1()->SetBinContent(endLumiOfFit, (double)totalHits);
1160  hitCounter->getTH1()->SetBinError(endLumiOfFit, std::sqrt((double)totalHits));
1161 
1162  reset("whole");
1163  }
1164 
1165  if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tHistogram title: " << histTitle.str() << endl;
1166 }
Vx3DHLTAnalyzer::lumiCounter
unsigned int lumiCounter
Definition: Vx3DHLTAnalyzer.h:155
Vx3DHLTAnalyzer::statusCounter
MonitorElement * statusCounter
Definition: Vx3DHLTAnalyzer.h:139
i
int i
Definition: DBlmapReader.cc:9
Vx3DHLTAnalyzer::dxdzlumi
MonitorElement * dxdzlumi
Definition: Vx3DHLTAnalyzer.h:126
Vx3DHLTAnalyzer::totalHits
unsigned int totalHits
Definition: Vx3DHLTAnalyzer.h:156
Vx3DHLTAnalyzer::maxLumiIntegration
unsigned int maxLumiIntegration
Definition: Vx3DHLTAnalyzer.h:101
Vx3DHLTAnalyzer::numberFits
unsigned int numberFits
Definition: Vx3DHLTAnalyzer.h:158
Vx3DHLTAnalyzer::nLumiXaxisRange
unsigned int nLumiXaxisRange
Definition: Vx3DHLTAnalyzer.h:102
Vx3DHLTAnalyzer::beginLumiOfFit
unsigned int beginLumiOfFit
Definition: Vx3DHLTAnalyzer.h:159
Vx3DHLTAnalyzer::MyFit
int MyFit(std::vector< double > *vals)
Definition: Vx3DHLTAnalyzer.cc:287
Vx3DHLTAnalyzer::minNentries
unsigned int minNentries
Definition: Vx3DHLTAnalyzer.h:103
Vx3DHLTAnalyzer::Vx_X
MonitorElement * Vx_X
Definition: Vx3DHLTAnalyzer.h:129
Vx3DHLTAnalyzer::mYlumi
MonitorElement * mYlumi
Definition: Vx3DHLTAnalyzer.h:119
Vx3DHLTAnalyzer::beginTimeOfFit
edm::TimeValue_t beginTimeOfFit
Definition: Vx3DHLTAnalyzer.h:152
Vx3DHLTAnalyzer::endTimeOfFit
edm::TimeValue_t endTimeOfFit
Definition: Vx3DHLTAnalyzer.h:153
Vx3DHLTAnalyzer::sYlumi
MonitorElement * sYlumi
Definition: Vx3DHLTAnalyzer.h:123
Vx3DHLTAnalyzer::reportSummaryMap
MonitorElement * reportSummaryMap
Definition: Vx3DHLTAnalyzer.h:142
Vx3DHLTAnalyzer::writeToFile
void writeToFile(std::vector< double > *vals, edm::TimeValue_t BeginTimeOfFit, edm::TimeValue_t EndTimeOfFit, unsigned int BeginLumiOfFit, unsigned int EndLumiOfFit, int dataType)
Definition: Vx3DHLTAnalyzer.cc:718
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:170
Vx3DHLTAnalyzer::nParams
unsigned int nParams
Definition: Vx3DHLTAnalyzer.h:162
Vx3DHLTAnalyzer::sZlumi
MonitorElement * sZlumi
Definition: Vx3DHLTAnalyzer.h:124
edm::LuminosityBlockBase::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: LuminosityBlockBase.h:42
Vx3DHLTAnalyzer::fitResults
MonitorElement * fitResults
Definition: Vx3DHLTAnalyzer.h:144
Vx3DHLTAnalyzer::formatTime
std::string formatTime(const time_t &t)
Definition: Vx3DHLTAnalyzer.cc:207
Vx3DHLTAnalyzer::endLumiOfFit
unsigned int endLumiOfFit
Definition: Vx3DHLTAnalyzer.h:160
Vx3DHLTAnalyzer::numberGoodFits
unsigned int numberGoodFits
Definition: Vx3DHLTAnalyzer.h:157
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:48
Vx3DHLTAnalyzer::reportSummary
MonitorElement * reportSummary
Definition: Vx3DHLTAnalyzer.h:141
edm::LuminosityBlockBase::endTime
Timestamp const & endTime() const
Definition: LuminosityBlockBase.h:57
Vx3DHLTAnalyzer::goodVxCounter
MonitorElement * goodVxCounter
Definition: Vx3DHLTAnalyzer.h:137
Vx3DHLTAnalyzer::outputDebugFile
std::ofstream outputDebugFile
Definition: Vx3DHLTAnalyzer.h:151
Vx3DHLTAnalyzer::dydzlumi
MonitorElement * dydzlumi
Definition: Vx3DHLTAnalyzer.h:127
MonitorElement::getTH1
TH1 * getTH1(void) const
Definition: MonitorElement.cc:1450
Vx3DHLTAnalyzer::Vx_Z
MonitorElement * Vx_Z
Definition: Vx3DHLTAnalyzer.h:131
Vx3DHLTAnalyzer::mXlumi
MonitorElement * mXlumi
Definition: Vx3DHLTAnalyzer.h:118
Vx3DHLTAnalyzer::reset
void reset(std::string ResetType)
Definition: Vx3DHLTAnalyzer.cc:626
create_public_pileup_plots.vals
list vals
Definition: create_public_pileup_plots.py:203
Vx3DHLTAnalyzer::mZlumi
MonitorElement * mZlumi
Definition: Vx3DHLTAnalyzer.h:120
Vx3DHLTAnalyzer::sXlumi
MonitorElement * sXlumi
Definition: Vx3DHLTAnalyzer.h:122
Vx3DHLTAnalyzer::lastLumiOfFit
unsigned int lastLumiOfFit
Definition: Vx3DHLTAnalyzer.h:161
MonitorElement::getTH1F
TH1F * getTH1F(void) const
Definition: MonitorElement.cc:1457
Vx3DHLTAnalyzer::printFitParams
void printFitParams(const std::vector< double > &fitResults)
Definition: Vx3DHLTAnalyzer.cc:851
Vx3DHLTAnalyzer::runNumber
unsigned int runNumber
Definition: Vx3DHLTAnalyzer.h:154
counterVx
unsigned int counterVx
Definition: Vx3DHLTAnalyzer.h:54
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
Vx3DHLTAnalyzer::nLumiFit
unsigned int nLumiFit
Definition: Vx3DHLTAnalyzer.h:100
Vx3DHLTAnalyzer::hitCounter
MonitorElement * hitCounter
Definition: Vx3DHLTAnalyzer.h:138
edm::Timestamp::value
TimeValue_t value() const
Definition: Timestamp.h:56
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:40
Vx3DHLTAnalyzer::Vx_Y
MonitorElement * Vx_Y
Definition: Vx3DHLTAnalyzer.h:130
string Vx3DHLTAnalyzer::formatTime ( const time_t &  t)
private

Definition at line 207 of file Vx3DHLTAnalyzer.cc.

208 {
209  char ts[25];
210  strftime(ts, sizeof(ts), "%Y.%m.%d %H:%M:%S %Z", gmtime(&t));
211 
212  string ts_string(ts);
213 
214  return ts_string;
215 }
unsigned int Vx3DHLTAnalyzer::HitCounter ( const edm::Event &  iEvent)
private

Definition at line 193 of file Vx3DHLTAnalyzer.cc.

References counter, edm::Event::getByToken(), h, j, and beampixel_dqm_sourceclient-live_cfg::pixelHitCollection.

194 {
195  Handle<SiPixelRecHitCollection> rechitspixel;
196  iEvent.getByToken(pixelHitCollection, rechitspixel);
197 
198  unsigned int counter = 0;
199 
200  for (SiPixelRecHitCollection::const_iterator j = rechitspixel->begin(); j != rechitspixel->end(); j++)
201  for (edmNew::DetSet<SiPixelRecHit>::const_iterator h = j->begin(); h != j->end(); h++) counter += h->cluster()->size();
202 
203  return counter;
204 }
edmNew::DetSetVector::const_iterator
boost::transform_iterator< IterHelp, const_IdIter > const_iterator
Definition: DetSetVectorNew.h:126
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:464
Vx3DHLTAnalyzer::pixelHitCollection
edm::EDGetTokenT< SiPixelRecHitCollection > pixelHitCollection
Definition: Vx3DHLTAnalyzer.h:97
edmNew::DetSet::const_iterator
data_type const * const_iterator
Definition: DetSetNew.h:30
j
int j
Definition: DBlmapReader.cc:9
h
The Signals That Services Can Subscribe To This is based on ActivityRegistry h
Helper function to determine trigger accepts.
Definition: Activities.doc:4
counter
static std::atomic< unsigned int > counter
Definition: SharedResourceNames.cc:15
int Vx3DHLTAnalyzer::MyFit ( std::vector< double > *  vals)
private

Definition at line 287 of file Vx3DHLTAnalyzer.cc.

References counterVx, gather_cfg::cout, alignCSCRings::e, Gauss3DFunc(), i, edm::isNotFinite(), j, maxLongLength, maxTransRadius, beampixel_dqm_sourceclient-live_cfg::minNentries, HLT_25ns14e33_v1_cff::nSigmaZ, NULL, mathSSE::sqrt(), xPos, yPos, and zPos.

288 {
289  // ############################################
290  // # RETURN CODE: #
291  // # >0 == NO OK - fit status (MINUIT manual) #
292  // # 0 == OK #
293  // # -1 == NO OK - not finite edm #
294  // # -2 == NO OK - not enough "minNentries" #
295  // # -3 == NO OK - not finite errors #
296  // # -4 == NO OK - negative determinant #
297  // # -5 == NO OK - maxLumiIntegration reached #
298  // ############################################
299 
300  if ((vals != NULL) && (vals->size() == nParams*2))
301  {
302  double nSigmaXY = 10.;
303  double nSigmaZ = 10.;
304  double parDistanceXY = 1e-3; // Unit: [cm]
305  double parDistanceZ = 1e-2; // Unit: [cm]
306  double parDistanceddZ = 1e-3; // Unit: [rad]
307  double parDistanceCxy = 1e-5; // Unit: [cm^2]
308  double bestEdm;
309 
310  const unsigned int trials = 4;
311  double largerDist[trials] = {0.1, 5., 10., 100.};
312 
313  double covxz,covyz,det;
314  double deltaMean;
315  int bestMovementX = 1;
316  int bestMovementY = 1;
317  int bestMovementZ = 1;
318  int goodData;
319 
320  double edm;
321 
322  vector<double>::const_iterator it = vals->begin();
323 
324  ROOT::Math::Minimizer* Gauss3D = ROOT::Math::Factory::CreateMinimizer("Minuit2","Migrad");
325  Gauss3D->SetErrorDef(1.0);
326  if (internalDebug == true) Gauss3D->SetPrintLevel(3);
327  else Gauss3D->SetPrintLevel(0);
328 
329  ROOT::Math::Functor _Gauss3DFunc(&Gauss3DFunc,nParams);
330  Gauss3D->SetFunction(_Gauss3DFunc);
331 
332  if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\t@@@ START FITTING @@@" << endl;
333 
334  // @@@ Fit at X-deltaMean | X | X+deltaMean @@@
335  bestEdm = 1.;
336  for (int i = 0; i < 3; i++)
337  {
338  deltaMean = (double(i)-1.)*std::sqrt(*(it+0));
339  if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tdeltaMean --> " << deltaMean << endl;
340 
341  Gauss3D->Clear();
342 
343  Gauss3D->SetVariable(0,"var x ", *(it+0), parDistanceXY * parDistanceXY);
344  Gauss3D->SetVariable(1,"var y ", *(it+1), parDistanceXY * parDistanceXY);
345  Gauss3D->SetVariable(2,"var z ", *(it+2), parDistanceZ * parDistanceZ);
346  Gauss3D->SetVariable(3,"cov xy", *(it+3), parDistanceCxy);
347  Gauss3D->SetVariable(4,"dydz ", *(it+4), parDistanceddZ);
348  Gauss3D->SetVariable(5,"dxdz ", *(it+5), parDistanceddZ);
349  Gauss3D->SetVariable(6,"mean x", *(it+6)+deltaMean, parDistanceXY);
350  Gauss3D->SetVariable(7,"mean y", *(it+7), parDistanceXY);
351  Gauss3D->SetVariable(8,"mean z", *(it+8), parDistanceZ);
352 
353  // Set the central positions of the centroid for vertex rejection
354  xPos = Gauss3D->X()[6];
355  yPos = Gauss3D->X()[7];
356  zPos = Gauss3D->X()[8];
357 
358  // Set dimensions of the centroid for vertex rejection
359  maxTransRadius = nSigmaXY * std::sqrt(std::fabs(Gauss3D->X()[0]) + std::fabs(Gauss3D->X()[1])) / 2.;
360  maxLongLength = nSigmaZ * std::sqrt(std::fabs(Gauss3D->X()[2]));
361 
362  Gauss3D->Minimize();
363  goodData = Gauss3D->Status();
364  edm = Gauss3D->Edm();
365 
366  if (counterVx < minNentries) goodData = -2;
367  else if (isNotFinite(edm) == true) { goodData = -1; if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tNot finite edm !" << endl; }
368  else for (unsigned int j = 0; j < nParams; j++)
369  if (isNotFinite(Gauss3D->Errors()[j]) == true)
370  {
371  goodData = -3;
372  if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tNot finite errors !" << endl;
373  break;
374  }
375  if (goodData == 0)
376  {
377  covyz = Gauss3D->X()[4]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[1])) - Gauss3D->X()[5]*Gauss3D->X()[3];
378  covxz = Gauss3D->X()[5]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[0])) - Gauss3D->X()[4]*Gauss3D->X()[3];
379 
380  det = std::fabs(Gauss3D->X()[0]) * (std::fabs(Gauss3D->X()[1])*std::fabs(Gauss3D->X()[2]) - covyz*covyz) -
381  Gauss3D->X()[3] * (Gauss3D->X()[3]*std::fabs(Gauss3D->X()[2]) - covxz*covyz) +
382  covxz * (Gauss3D->X()[3]*covyz - covxz*std::fabs(Gauss3D->X()[1]));
383  if (det < 0.) { goodData = -4; if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tNegative determinant !" << endl; }
384  }
385 
386  if ((goodData == 0) && (std::fabs(edm) < bestEdm)) { bestEdm = edm; bestMovementX = i; }
387  }
388  if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tFound bestMovementX --> " << bestMovementX << endl;
389 
390  // @@@ Fit at Y-deltaMean | Y | Y+deltaMean @@@
391  bestEdm = 1.;
392  for (int i = 0; i < 3; i++)
393  {
394  deltaMean = (double(i)-1.)*std::sqrt(*(it+1));
395  if (internalDebug == true)
396  {
397  cout << "[Vx3DHLTAnalyzer]::\tdeltaMean --> " << deltaMean << endl;
398  cout << "[Vx3DHLTAnalyzer]::\tdeltaMean X --> " << (double(bestMovementX)-1.)*std::sqrt(*(it+0)) << endl;
399  }
400 
401  Gauss3D->Clear();
402 
403  Gauss3D->SetVariable(0,"var x ", *(it+0), parDistanceXY * parDistanceXY);
404  Gauss3D->SetVariable(1,"var y ", *(it+1), parDistanceXY * parDistanceXY);
405  Gauss3D->SetVariable(2,"var z ", *(it+2), parDistanceZ * parDistanceZ);
406  Gauss3D->SetVariable(3,"cov xy", *(it+3), parDistanceCxy);
407  Gauss3D->SetVariable(4,"dydz ", *(it+4), parDistanceddZ);
408  Gauss3D->SetVariable(5,"dxdz ", *(it+5), parDistanceddZ);
409  Gauss3D->SetVariable(6,"mean x", *(it+6)+(double(bestMovementX)-1.)*std::sqrt(*(it+0)), parDistanceXY);
410  Gauss3D->SetVariable(7,"mean y", *(it+7)+deltaMean, parDistanceXY);
411  Gauss3D->SetVariable(8,"mean z", *(it+8), parDistanceZ);
412 
413  // Set the central positions of the centroid for vertex rejection
414  xPos = Gauss3D->X()[6];
415  yPos = Gauss3D->X()[7];
416  zPos = Gauss3D->X()[8];
417 
418  // Set dimensions of the centroid for vertex rejection
419  maxTransRadius = nSigmaXY * std::sqrt(std::fabs(Gauss3D->X()[0]) + std::fabs(Gauss3D->X()[1])) / 2.;
420  maxLongLength = nSigmaZ * std::sqrt(std::fabs(Gauss3D->X()[2]));
421 
422  Gauss3D->Minimize();
423  goodData = Gauss3D->Status();
424  edm = Gauss3D->Edm();
425 
426  if (counterVx < minNentries) goodData = -2;
427  else if (isNotFinite(edm) == true) { goodData = -1; if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tNot finite edm !" << endl; }
428  else for (unsigned int j = 0; j < nParams; j++)
429  if (isNotFinite(Gauss3D->Errors()[j]) == true)
430  {
431  goodData = -3;
432  if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tNot finite errors !" << endl;
433  break;
434  }
435  if (goodData == 0)
436  {
437  covyz = Gauss3D->X()[4]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[1])) - Gauss3D->X()[5]*Gauss3D->X()[3];
438  covxz = Gauss3D->X()[5]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[0])) - Gauss3D->X()[4]*Gauss3D->X()[3];
439 
440  det = std::fabs(Gauss3D->X()[0]) * (std::fabs(Gauss3D->X()[1])*std::fabs(Gauss3D->X()[2]) - covyz*covyz) -
441  Gauss3D->X()[3] * (Gauss3D->X()[3]*std::fabs(Gauss3D->X()[2]) - covxz*covyz) +
442  covxz * (Gauss3D->X()[3]*covyz - covxz*std::fabs(Gauss3D->X()[1]));
443  if (det < 0.) { goodData = -4; if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tNegative determinant !" << endl; }
444  }
445 
446  if ((goodData == 0) && (std::fabs(edm) < bestEdm)) { bestEdm = edm; bestMovementY = i; }
447  }
448  if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tFound bestMovementY --> " << bestMovementY << endl;
449 
450  // @@@ Fit at Z-deltaMean | Z | Z+deltaMean @@@
451  bestEdm = 1.;
452  for (int i = 0; i < 3; i++)
453  {
454  deltaMean = (double(i)-1.)*std::sqrt(*(it+2));
455  if (internalDebug == true)
456  {
457  cout << "[Vx3DHLTAnalyzer]::\tdeltaMean --> " << deltaMean << endl;
458  cout << "[Vx3DHLTAnalyzer]::\tdeltaMean X --> " << (double(bestMovementX)-1.)*std::sqrt(*(it+0)) << endl;
459  cout << "[Vx3DHLTAnalyzer]::\tdeltaMean Y --> " << (double(bestMovementY)-1.)*std::sqrt(*(it+1)) << endl;
460  }
461 
462  Gauss3D->Clear();
463 
464  Gauss3D->SetVariable(0,"var x ", *(it+0), parDistanceXY * parDistanceXY);
465  Gauss3D->SetVariable(1,"var y ", *(it+1), parDistanceXY * parDistanceXY);
466  Gauss3D->SetVariable(2,"var z ", *(it+2), parDistanceZ * parDistanceZ);
467  Gauss3D->SetVariable(3,"cov xy", *(it+3), parDistanceCxy);
468  Gauss3D->SetVariable(4,"dydz ", *(it+4), parDistanceddZ);
469  Gauss3D->SetVariable(5,"dxdz ", *(it+5), parDistanceddZ);
470  Gauss3D->SetVariable(6,"mean x", *(it+6)+(double(bestMovementX)-1.)*std::sqrt(*(it+0)), parDistanceXY);
471  Gauss3D->SetVariable(7,"mean y", *(it+7)+(double(bestMovementY)-1.)*std::sqrt(*(it+1)), parDistanceXY);
472  Gauss3D->SetVariable(8,"mean z", *(it+8)+deltaMean, parDistanceZ);
473 
474  // Set the central positions of the centroid for vertex rejection
475  xPos = Gauss3D->X()[6];
476  yPos = Gauss3D->X()[7];
477  zPos = Gauss3D->X()[8];
478 
479  // Set dimensions of the centroid for vertex rejection
480  maxTransRadius = nSigmaXY * std::sqrt(std::fabs(Gauss3D->X()[0]) + std::fabs(Gauss3D->X()[1])) / 2.;
481  maxLongLength = nSigmaZ * std::sqrt(std::fabs(Gauss3D->X()[2]));
482 
483  Gauss3D->Minimize();
484  goodData = Gauss3D->Status();
485  edm = Gauss3D->Edm();
486 
487  if (counterVx < minNentries) goodData = -2;
488  else if (isNotFinite(edm) == true) { goodData = -1; if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tNot finite edm !" << endl; }
489  else for (unsigned int j = 0; j < nParams; j++)
490  if (isNotFinite(Gauss3D->Errors()[j]) == true)
491  {
492  goodData = -3;
493  if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tNot finite errors !" << endl;
494  break;
495  }
496  if (goodData == 0)
497  {
498  covyz = Gauss3D->X()[4]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[1])) - Gauss3D->X()[5]*Gauss3D->X()[3];
499  covxz = Gauss3D->X()[5]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[0])) - Gauss3D->X()[4]*Gauss3D->X()[3];
500 
501  det = std::fabs(Gauss3D->X()[0]) * (std::fabs(Gauss3D->X()[1])*std::fabs(Gauss3D->X()[2]) - covyz*covyz) -
502  Gauss3D->X()[3] * (Gauss3D->X()[3]*std::fabs(Gauss3D->X()[2]) - covxz*covyz) +
503  covxz * (Gauss3D->X()[3]*covyz - covxz*std::fabs(Gauss3D->X()[1]));
504  if (det < 0.) { goodData = -4; if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tNegative determinant !" << endl; }
505  }
506 
507  if ((goodData == 0) && (std::fabs(edm) < bestEdm)) { bestEdm = edm; bestMovementZ = i; }
508  }
509  if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tFound bestMovementZ --> " << bestMovementZ << endl;
510 
511  Gauss3D->Clear();
512 
513  // @@@ FINAL FIT @@@
514  Gauss3D->SetVariable(0,"var x ", *(it+0), parDistanceXY * parDistanceXY);
515  Gauss3D->SetVariable(1,"var y ", *(it+1), parDistanceXY * parDistanceXY);
516  Gauss3D->SetVariable(2,"var z ", *(it+2), parDistanceZ * parDistanceZ);
517  Gauss3D->SetVariable(3,"cov xy", *(it+3), parDistanceCxy);
518  Gauss3D->SetVariable(4,"dydz ", *(it+4), parDistanceddZ);
519  Gauss3D->SetVariable(5,"dxdz ", *(it+5), parDistanceddZ);
520  Gauss3D->SetVariable(6,"mean x", *(it+6)+(double(bestMovementX)-1.)*std::sqrt(*(it+0)), parDistanceXY);
521  Gauss3D->SetVariable(7,"mean y", *(it+7)+(double(bestMovementY)-1.)*std::sqrt(*(it+1)), parDistanceXY);
522  Gauss3D->SetVariable(8,"mean z", *(it+8)+(double(bestMovementZ)-1.)*std::sqrt(*(it+2)), parDistanceZ);
523 
524  // Set the central positions of the centroid for vertex rejection
525  xPos = Gauss3D->X()[6];
526  yPos = Gauss3D->X()[7];
527  zPos = Gauss3D->X()[8];
528 
529  // Set dimensions of the centroid for vertex rejection
530  maxTransRadius = nSigmaXY * std::sqrt(std::fabs(Gauss3D->X()[0]) + std::fabs(Gauss3D->X()[1])) / 2.;
531  maxLongLength = nSigmaZ * std::sqrt(std::fabs(Gauss3D->X()[2]));
532 
533  Gauss3D->Minimize();
534  goodData = Gauss3D->Status();
535  edm = Gauss3D->Edm();
536 
537  if (counterVx < minNentries) goodData = -2;
538  else if (isNotFinite(edm) == true) { goodData = -1; if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tNot finite edm !" << endl; }
539  else for (unsigned int j = 0; j < nParams; j++)
540  if (isNotFinite(Gauss3D->Errors()[j]) == true)
541  {
542  goodData = -3;
543  if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tNot finite errors !" << endl;
544  break;
545  }
546  if (goodData == 0)
547  {
548  covyz = Gauss3D->X()[4]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[1])) - Gauss3D->X()[5]*Gauss3D->X()[3];
549  covxz = Gauss3D->X()[5]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[0])) - Gauss3D->X()[4]*Gauss3D->X()[3];
550 
551  det = std::fabs(Gauss3D->X()[0]) * (std::fabs(Gauss3D->X()[1])*std::fabs(Gauss3D->X()[2]) - covyz*covyz) -
552  Gauss3D->X()[3] * (Gauss3D->X()[3]*std::fabs(Gauss3D->X()[2]) - covxz*covyz) +
553  covxz * (Gauss3D->X()[3]*covyz - covxz*std::fabs(Gauss3D->X()[1]));
554  if (det < 0.) { goodData = -4; if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tNegative determinant !" << endl; }
555  }
556 
557  // @@@ FIT WITH DIFFERENT PARAMETER DISTANCES @@@
558  for (unsigned int i = 0; i < trials; i++)
559  {
560  if ((goodData != 0) && (goodData != -2))
561  {
562  Gauss3D->Clear();
563 
564  if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tFIT WITH DIFFERENT PARAMETER DISTANCES - STEP " << i+1 << endl;
565 
566  Gauss3D->SetVariable(0,"var x ", *(it+0), parDistanceXY * parDistanceXY * largerDist[i]);
567  Gauss3D->SetVariable(1,"var y ", *(it+1), parDistanceXY * parDistanceXY * largerDist[i]);
568  Gauss3D->SetVariable(2,"var z ", *(it+2), parDistanceZ * parDistanceZ * largerDist[i]);
569  Gauss3D->SetVariable(3,"cov xy", *(it+3), parDistanceCxy * largerDist[i]);
570  Gauss3D->SetVariable(4,"dydz ", *(it+4), parDistanceddZ * largerDist[i]);
571  Gauss3D->SetVariable(5,"dxdz ", *(it+5), parDistanceddZ * largerDist[i]);
572  Gauss3D->SetVariable(6,"mean x", *(it+6)+(double(bestMovementX)-1.)*std::sqrt(*(it+0)), parDistanceXY * largerDist[i]);
573  Gauss3D->SetVariable(7,"mean y", *(it+7)+(double(bestMovementY)-1.)*std::sqrt(*(it+1)), parDistanceXY * largerDist[i]);
574  Gauss3D->SetVariable(8,"mean z", *(it+8)+(double(bestMovementZ)-1.)*std::sqrt(*(it+2)), parDistanceZ * largerDist[i]);
575 
576  // Set the central positions of the centroid for vertex rejection
577  xPos = Gauss3D->X()[6];
578  yPos = Gauss3D->X()[7];
579  zPos = Gauss3D->X()[8];
580 
581  // Set dimensions of the centroid for vertex rejection
582  maxTransRadius = nSigmaXY * std::sqrt(std::fabs(Gauss3D->X()[0]) + std::fabs(Gauss3D->X()[1])) / 2.;
583  maxLongLength = nSigmaZ * std::sqrt(std::fabs(Gauss3D->X()[2]));
584 
585  Gauss3D->Minimize();
586  goodData = Gauss3D->Status();
587  edm = Gauss3D->Edm();
588 
589  if (counterVx < minNentries) goodData = -2;
590  else if (isNotFinite(edm) == true) { goodData = -1; if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tNot finite edm !" << endl; }
591  else for (unsigned int j = 0; j < nParams; j++)
592  if (isNotFinite(Gauss3D->Errors()[j]) == true)
593  {
594  goodData = -3;
595  if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tNot finite errors !" << endl;
596  break;
597  }
598  if (goodData == 0)
599  {
600  covyz = Gauss3D->X()[4]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[1])) - Gauss3D->X()[5]*Gauss3D->X()[3];
601  covxz = Gauss3D->X()[5]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[0])) - Gauss3D->X()[4]*Gauss3D->X()[3];
602 
603  det = std::fabs(Gauss3D->X()[0]) * (std::fabs(Gauss3D->X()[1])*std::fabs(Gauss3D->X()[2]) - covyz*covyz) -
604  Gauss3D->X()[3] * (Gauss3D->X()[3]*std::fabs(Gauss3D->X()[2]) - covxz*covyz) +
605  covxz * (Gauss3D->X()[3]*covyz - covxz*std::fabs(Gauss3D->X()[1]));
606  if (det < 0.) { goodData = -4; if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tNegative determinant !" << endl; }
607  }
608  } else break;
609  }
610 
611  if (goodData == 0)
612  for (unsigned int i = 0; i < nParams; i++)
613  {
614  vals->operator[](i) = Gauss3D->X()[i];
615  vals->operator[](i+nParams) = Gauss3D->Errors()[i];
616  }
617 
618  delete Gauss3D;
619  return goodData;
620  }
621 
622  return -1;
623 }
i
int i
Definition: DBlmapReader.cc:9
maxLongLength
double maxLongLength
Definition: Vx3DHLTAnalyzer.h:56
zPos
double zPos
Definition: Vx3DHLTAnalyzer.h:57
Vx3DHLTAnalyzer::minNentries
unsigned int minNentries
Definition: Vx3DHLTAnalyzer.h:103
NULL
#define NULL
Definition: scimark2.h:8
maxTransRadius
double maxTransRadius
Definition: Vx3DHLTAnalyzer.h:55
Vx3DHLTAnalyzer::nParams
unsigned int nParams
Definition: Vx3DHLTAnalyzer.h:162
Gauss3DFunc
double Gauss3DFunc(const double *par)
Definition: Vx3DHLTAnalyzer.cc:218
xPos
double xPos
Definition: Vx3DHLTAnalyzer.h:57
edm::isNotFinite
bool isNotFinite(T x)
Definition: isFinite.h:10
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:48
j
int j
Definition: DBlmapReader.cc:9
yPos
double yPos
Definition: Vx3DHLTAnalyzer.h:57
create_public_pileup_plots.vals
list vals
Definition: create_public_pileup_plots.py:203
HLT_25ns14e33_v1_cff.nSigmaZ
tuple nSigmaZ
Definition: HLT_25ns14e33_v1_cff.py:4375
counterVx
unsigned int counterVx
Definition: Vx3DHLTAnalyzer.h:54
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
void Vx3DHLTAnalyzer::printFitParams ( const std::vector< double > &  fitResults)
private

Definition at line 851 of file Vx3DHLTAnalyzer.cc.

References gather_cfg::cout.

852 {
853  cout << "var x --> " << fitResults[0] << " +/- " << fitResults[0+nParams] << endl;
854  cout << "var y --> " << fitResults[1] << " +/- " << fitResults[1+nParams] << endl;
855  cout << "var z --> " << fitResults[2] << " +/- " << fitResults[2+nParams] << endl;
856  cout << "cov xy --> " << fitResults[3] << " +/- " << fitResults[3+nParams] << endl;
857  cout << "dydz --> " << fitResults[4] << " +/- " << fitResults[4+nParams] << endl;
858  cout << "dxdz --> " << fitResults[5] << " +/- " << fitResults[5+nParams] << endl;
859  cout << "mean x --> " << fitResults[6] << " +/- " << fitResults[6+nParams] << endl;
860  cout << "mean y --> " << fitResults[7] << " +/- " << fitResults[7+nParams] << endl;
861  cout << "mean z --> " << fitResults[8] << " +/- " << fitResults[8+nParams] << endl;
862 }
Vx3DHLTAnalyzer::nParams
unsigned int nParams
Definition: Vx3DHLTAnalyzer.h:162
Vx3DHLTAnalyzer::fitResults
MonitorElement * fitResults
Definition: Vx3DHLTAnalyzer.h:144
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
void Vx3DHLTAnalyzer::reset ( std::string  ResetType)
private

Definition at line 626 of file Vx3DHLTAnalyzer.cc.

References gather_cfg::cout, beampixel_dqm_sourceclient-live_cfg::debugMode, edm::service::formatTime(), convertSQLiteXML::runNumber, and Vertices.

627 {
628  if ((debugMode == true) && (outputDebugFile.is_open() == true))
629  {
630  outputDebugFile << "Runnumber " << runNumber << endl;
631  outputDebugFile << "BeginTimeOfFit " << formatTime(beginTimeOfFit >> 32) << " " << (beginTimeOfFit >> 32) << endl;
632  outputDebugFile << "BeginLumiRange " << beginLumiOfFit << endl;
633  outputDebugFile << "EndTimeOfFit " << formatTime(endTimeOfFit >> 32) << " " << (endTimeOfFit >> 32) << endl;
634  outputDebugFile << "EndLumiRange " << endLumiOfFit << endl;
635  outputDebugFile << "LumiCounter " << lumiCounter << endl;
636  outputDebugFile << "LastLumiOfFit " << lastLumiOfFit << endl;
637  }
638 
639 
640  if (ResetType.compare("scratch") == 0)
641  {
642  runNumber = 0;
643  numberGoodFits = 0;
644  numberFits = 0;
645  lastLumiOfFit = 0;
646 
647  Vx_X->Reset();
648  Vx_Y->Reset();
649  Vx_Z->Reset();
650 
651  Vx_ZX->Reset();
652  Vx_ZY->Reset();
653  Vx_XY->Reset();
654 
655  mXlumi->Reset();
656  mYlumi->Reset();
657  mZlumi->Reset();
658 
659  sXlumi->Reset();
660  sYlumi->Reset();
661  sZlumi->Reset();
662 
663  dxdzlumi->Reset();
664  dydzlumi->Reset();
665 
666  hitCounter->Reset();
667  goodVxCounter->Reset();
668  statusCounter->Reset();
669  fitResults->Reset();
670 
671  reportSummary->Fill(-1);
672  reportSummaryMap->getTH1()->SetBinContent(1, 1, -1);
673 
674  Vertices.clear();
675 
676  lumiCounter = 0;
677  totalHits = 0;
678  beginTimeOfFit = 0;
679  endTimeOfFit = 0;
680  beginLumiOfFit = 0;
681  endLumiOfFit = 0;
682 
683  if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tReset issued: scratch" << endl;
684  if ((debugMode == true) && (outputDebugFile.is_open() == true)) outputDebugFile << "Reset -scratch- issued\n" << endl;
685  }
686  else if (ResetType.compare("whole") == 0)
687  {
688  Vx_X->Reset();
689  Vx_Y->Reset();
690  Vx_Z->Reset();
691 
692  Vx_ZX->Reset();
693  Vx_ZY->Reset();
694  Vx_XY->Reset();
695 
696  Vertices.clear();
697 
698  lumiCounter = 0;
699  totalHits = 0;
700  beginTimeOfFit = 0;
701  endTimeOfFit = 0;
702  beginLumiOfFit = 0;
703  endLumiOfFit = 0;
704 
705  if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tReset issued: whole" << endl;
706  if ((debugMode == true) && (outputDebugFile.is_open() == true)) outputDebugFile << "Reset -whole- issued\n" << endl;
707  }
708  else if (ResetType.compare("hitCounter") == 0)
709  {
710  totalHits = 0;
711 
712  if (internalDebug == true) cout << "[Vx3DHLTAnalyzer]::\tReset issued: hitCounter" << endl;
713  if ((debugMode == true) && (outputDebugFile.is_open() == true)) outputDebugFile << "Reset -hitCounter- issued\n" << endl;
714  }
715 }
Vx3DHLTAnalyzer::lumiCounter
unsigned int lumiCounter
Definition: Vx3DHLTAnalyzer.h:155
Vx3DHLTAnalyzer::statusCounter
MonitorElement * statusCounter
Definition: Vx3DHLTAnalyzer.h:139
Vx3DHLTAnalyzer::dxdzlumi
MonitorElement * dxdzlumi
Definition: Vx3DHLTAnalyzer.h:126
Vx3DHLTAnalyzer::Vx_ZX
MonitorElement * Vx_ZX
Definition: Vx3DHLTAnalyzer.h:133
Vx3DHLTAnalyzer::totalHits
unsigned int totalHits
Definition: Vx3DHLTAnalyzer.h:156
Vx3DHLTAnalyzer::numberFits
unsigned int numberFits
Definition: Vx3DHLTAnalyzer.h:158
Vx3DHLTAnalyzer::beginLumiOfFit
unsigned int beginLumiOfFit
Definition: Vx3DHLTAnalyzer.h:159
Vx3DHLTAnalyzer::Vx_X
MonitorElement * Vx_X
Definition: Vx3DHLTAnalyzer.h:129
Vx3DHLTAnalyzer::mYlumi
MonitorElement * mYlumi
Definition: Vx3DHLTAnalyzer.h:119
Vx3DHLTAnalyzer::beginTimeOfFit
edm::TimeValue_t beginTimeOfFit
Definition: Vx3DHLTAnalyzer.h:152
Vx3DHLTAnalyzer::endTimeOfFit
edm::TimeValue_t endTimeOfFit
Definition: Vx3DHLTAnalyzer.h:153
Vx3DHLTAnalyzer::sYlumi
MonitorElement * sYlumi
Definition: Vx3DHLTAnalyzer.h:123
Vx3DHLTAnalyzer::reportSummaryMap
MonitorElement * reportSummaryMap
Definition: Vx3DHLTAnalyzer.h:142
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:170
Vx3DHLTAnalyzer::Vx_XY
MonitorElement * Vx_XY
Definition: Vx3DHLTAnalyzer.h:135
Vx3DHLTAnalyzer::sZlumi
MonitorElement * sZlumi
Definition: Vx3DHLTAnalyzer.h:124
Vx3DHLTAnalyzer::fitResults
MonitorElement * fitResults
Definition: Vx3DHLTAnalyzer.h:144
Vx3DHLTAnalyzer::Vx_ZY
MonitorElement * Vx_ZY
Definition: Vx3DHLTAnalyzer.h:134
Vx3DHLTAnalyzer::formatTime
std::string formatTime(const time_t &t)
Definition: Vx3DHLTAnalyzer.cc:207
Vx3DHLTAnalyzer::endLumiOfFit
unsigned int endLumiOfFit
Definition: Vx3DHLTAnalyzer.h:160
Vx3DHLTAnalyzer::numberGoodFits
unsigned int numberGoodFits
Definition: Vx3DHLTAnalyzer.h:157
Vx3DHLTAnalyzer::reportSummary
MonitorElement * reportSummary
Definition: Vx3DHLTAnalyzer.h:141
Vx3DHLTAnalyzer::goodVxCounter
MonitorElement * goodVxCounter
Definition: Vx3DHLTAnalyzer.h:137
Vx3DHLTAnalyzer::outputDebugFile
std::ofstream outputDebugFile
Definition: Vx3DHLTAnalyzer.h:151
Vx3DHLTAnalyzer::dydzlumi
MonitorElement * dydzlumi
Definition: Vx3DHLTAnalyzer.h:127
MonitorElement::getTH1
TH1 * getTH1(void) const
Definition: MonitorElement.cc:1450
Vx3DHLTAnalyzer::Vx_Z
MonitorElement * Vx_Z
Definition: Vx3DHLTAnalyzer.h:131
Vx3DHLTAnalyzer::mXlumi
MonitorElement * mXlumi
Definition: Vx3DHLTAnalyzer.h:118
Vx3DHLTAnalyzer::mZlumi
MonitorElement * mZlumi
Definition: Vx3DHLTAnalyzer.h:120
Vx3DHLTAnalyzer::sXlumi
MonitorElement * sXlumi
Definition: Vx3DHLTAnalyzer.h:122
Vx3DHLTAnalyzer::lastLumiOfFit
unsigned int lastLumiOfFit
Definition: Vx3DHLTAnalyzer.h:161
Vx3DHLTAnalyzer::runNumber
unsigned int runNumber
Definition: Vx3DHLTAnalyzer.h:154
Vertices
std::vector< VertexType > Vertices
Definition: Vx3DHLTAnalyzer.h:52
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
Vx3DHLTAnalyzer::hitCounter
MonitorElement * hitCounter
Definition: Vx3DHLTAnalyzer.h:138
MonitorElement::Reset
void Reset(void)
reset ME (ie. contents, errors, etc)
Definition: MonitorElement.cc:453
Vx3DHLTAnalyzer::Vx_Y
MonitorElement * Vx_Y
Definition: Vx3DHLTAnalyzer.h:130
void Vx3DHLTAnalyzer::writeToFile ( std::vector< double > *  vals,
edm::TimeValue_t  BeginTimeOfFit,
edm::TimeValue_t  EndTimeOfFit,
unsigned int  BeginLumiOfFit,
unsigned int  EndLumiOfFit,
int  dataType 
)
private

Definition at line 718 of file Vx3DHLTAnalyzer.cc.

References counterVx, beampixel_dqm_sourceclient-live_cfg::debugMode, MillePedeFileConverter_cfg::fileName, edm::service::formatTime(), NULL, dbtoconf::out, download_sqlite_cfg::outputFile, convertSQLiteXML::runNumber, and mathSSE::sqrt().

724 {
725  stringstream BufferString;
726  BufferString.precision(5);
727 
728  outputFile.open(fileName.c_str(), ios::out);
729 
730  if ((outputFile.is_open() == true) && (vals != NULL) && (vals->size() == (nParams-1)*2))
731  {
732  vector<double>::const_iterator it = vals->begin();
733 
734  outputFile << "Runnumber " << runNumber << endl;
735  outputFile << "BeginTimeOfFit " << formatTime(beginTimeOfFit >> 32) << " " << (beginTimeOfFit >> 32) << endl;
736  outputFile << "EndTimeOfFit " << formatTime(endTimeOfFit >> 32) << " " << (endTimeOfFit >> 32) << endl;
737  outputFile << "LumiRange " << beginLumiOfFit << " - " << endLumiOfFit << endl;
738  outputFile << "Type " << dataType << endl;
739  // 3D Vertexing with Pixel Tracks:
740  // Good data = Type 3
741  // Bad data = Type -1
742 
743  BufferString << *(it+0);
744  outputFile << "X0 " << BufferString.str().c_str() << endl;
745  BufferString.str("");
746 
747  BufferString << *(it+1);
748  outputFile << "Y0 " << BufferString.str().c_str() << endl;
749  BufferString.str("");
750 
751  BufferString << *(it+2);
752  outputFile << "Z0 " << BufferString.str().c_str() << endl;
753  BufferString.str("");
754 
755  BufferString << *(it+3);
756  outputFile << "sigmaZ0 " << BufferString.str().c_str() << endl;
757  BufferString.str("");
758 
759  BufferString << *(it+4);
760  outputFile << "dxdz " << BufferString.str().c_str() << endl;
761  BufferString.str("");
762 
763  BufferString << *(it+5);
764  outputFile << "dydz " << BufferString.str().c_str() << endl;
765  BufferString.str("");
766 
767  BufferString << *(it+6);
768  outputFile << "BeamWidthX " << BufferString.str().c_str() << endl;
769  BufferString.str("");
770 
771  BufferString << *(it+7);
772  outputFile << "BeamWidthY " << BufferString.str().c_str() << endl;
773  BufferString.str("");
774 
775  outputFile << "Cov(0,j) " << *(it+8) << " 0.0 0.0 0.0 0.0 0.0 0.0" << endl;
776  outputFile << "Cov(1,j) 0.0 " << *(it+9) << " 0.0 0.0 0.0 0.0 0.0" << endl;
777  outputFile << "Cov(2,j) 0.0 0.0 " << *(it+10) << " 0.0 0.0 0.0 0.0" << endl;
778  outputFile << "Cov(3,j) 0.0 0.0 0.0 " << *(it+11) << " 0.0 0.0 0.0" << endl;
779  outputFile << "Cov(4,j) 0.0 0.0 0.0 0.0 " << *(it+12) << " 0.0 0.0" << endl;
780  outputFile << "Cov(5,j) 0.0 0.0 0.0 0.0 0.0 " << *(it+13) << " 0.0" << endl;
781  outputFile << "Cov(6,j) 0.0 0.0 0.0 0.0 0.0 0.0 " << ((*(it+14)) + (*(it+15)) + 2.*std::sqrt((*(it+14))*(*(it+15)))) / 4. << endl;
782 
783  outputFile << "EmittanceX 0.0" << endl;
784  outputFile << "EmittanceY 0.0" << endl;
785  outputFile << "BetaStar 0.0" << endl;
786  }
787  outputFile.close();
788 
789  if ((debugMode == true) && (outputDebugFile.is_open() == true) && (vals != NULL) && (vals->size() == (nParams-1)*2))
790  {
791  vector<double>::const_iterator it = vals->begin();
792 
793  outputDebugFile << "Runnumber " << runNumber << endl;
794  outputDebugFile << "BeginTimeOfFit " << formatTime(beginTimeOfFit >> 32) << " " << (beginTimeOfFit >> 32) << endl;
795  outputDebugFile << "EndTimeOfFit " << formatTime(endTimeOfFit >> 32) << " " << (endTimeOfFit >> 32) << endl;
796  outputDebugFile << "LumiRange " << beginLumiOfFit << " - " << endLumiOfFit << endl;
797  outputDebugFile << "Type " << dataType << endl;
798  // 3D Vertexing with Pixel Tracks:
799  // Good data = Type 3
800  // Bad data = Type -1
801 
802  BufferString << *(it+0);
803  outputDebugFile << "X0 " << BufferString.str().c_str() << endl;
804  BufferString.str("");
805 
806  BufferString << *(it+1);
807  outputDebugFile << "Y0 " << BufferString.str().c_str() << endl;
808  BufferString.str("");
809 
810  BufferString << *(it+2);
811  outputDebugFile << "Z0 " << BufferString.str().c_str() << endl;
812  BufferString.str("");
813 
814  BufferString << *(it+3);
815  outputDebugFile << "sigmaZ0 " << BufferString.str().c_str() << endl;
816  BufferString.str("");
817 
818  BufferString << *(it+4);
819  outputDebugFile << "dxdz " << BufferString.str().c_str() << endl;
820  BufferString.str("");
821 
822  BufferString << *(it+5);
823  outputDebugFile << "dydz " << BufferString.str().c_str() << endl;
824  BufferString.str("");
825 
826  BufferString << *(it+6);
827  outputDebugFile << "BeamWidthX " << BufferString.str().c_str() << endl;
828  BufferString.str("");
829 
830  BufferString << *(it+7);
831  outputDebugFile << "BeamWidthY " << BufferString.str().c_str() << endl;
832  BufferString.str("");
833 
834  outputDebugFile << "Cov(0,j) " << *(it+8) << " 0.0 0.0 0.0 0.0 0.0 0.0" << endl;
835  outputDebugFile << "Cov(1,j) 0.0 " << *(it+9) << " 0.0 0.0 0.0 0.0 0.0" << endl;
836  outputDebugFile << "Cov(2,j) 0.0 0.0 " << *(it+10) << " 0.0 0.0 0.0 0.0" << endl;
837  outputDebugFile << "Cov(3,j) 0.0 0.0 0.0 " << *(it+11) << " 0.0 0.0 0.0" << endl;
838  outputDebugFile << "Cov(4,j) 0.0 0.0 0.0 0.0 " << *(it+12) << " 0.0 0.0" << endl;
839  outputDebugFile << "Cov(5,j) 0.0 0.0 0.0 0.0 0.0 " << *(it+13) << " 0.0" << endl;
840  outputDebugFile << "Cov(6,j) 0.0 0.0 0.0 0.0 0.0 0.0 " << ((*(it+14)) + (*(it+15)) + 2.*std::sqrt((*(it+14))*(*(it+15)))) / 4. << endl;
841 
842  outputDebugFile << "EmittanceX 0.0" << endl;
843  outputDebugFile << "EmittanceY 0.0" << endl;
844  outputDebugFile << "BetaStar 0.0" << endl;
845 
846  outputDebugFile << "Used vertices: " << counterVx << "\n" << endl;
847  }
848 }
Vx3DHLTAnalyzer::beginLumiOfFit
unsigned int beginLumiOfFit
Definition: Vx3DHLTAnalyzer.h:159
NULL
#define NULL
Definition: scimark2.h:8
Vx3DHLTAnalyzer::beginTimeOfFit
edm::TimeValue_t beginTimeOfFit
Definition: Vx3DHLTAnalyzer.h:152
Vx3DHLTAnalyzer::endTimeOfFit
edm::TimeValue_t endTimeOfFit
Definition: Vx3DHLTAnalyzer.h:153
Vx3DHLTAnalyzer::nParams
unsigned int nParams
Definition: Vx3DHLTAnalyzer.h:162
Vx3DHLTAnalyzer::fileName
std::string fileName
Definition: Vx3DHLTAnalyzer.h:112
Vx3DHLTAnalyzer::formatTime
std::string formatTime(const time_t &t)
Definition: Vx3DHLTAnalyzer.cc:207
Vx3DHLTAnalyzer::endLumiOfFit
unsigned int endLumiOfFit
Definition: Vx3DHLTAnalyzer.h:160
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:48
Vx3DHLTAnalyzer::outputDebugFile
std::ofstream outputDebugFile
Definition: Vx3DHLTAnalyzer.h:151
create_public_pileup_plots.vals
list vals
Definition: create_public_pileup_plots.py:203
dtTPAnalyzer_cfg.dataType
tuple dataType
Definition: dtTPAnalyzer_cfg.py:26
dbtoconf.out
tuple out
Definition: dbtoconf.py:99
Vx3DHLTAnalyzer::outputFile
std::ofstream outputFile
Definition: Vx3DHLTAnalyzer.h:150
Vx3DHLTAnalyzer::runNumber
unsigned int runNumber
Definition: Vx3DHLTAnalyzer.h:154
counterVx
unsigned int counterVx
Definition: Vx3DHLTAnalyzer.h:54

Member Data Documentation

unsigned int Vx3DHLTAnalyzer::beginLumiOfFit
private

Definition at line 159 of file Vx3DHLTAnalyzer.h.

edm::TimeValue_t Vx3DHLTAnalyzer::beginTimeOfFit
private

Definition at line 152 of file Vx3DHLTAnalyzer.h.

bool Vx3DHLTAnalyzer::dataFromFit
private

Definition at line 99 of file Vx3DHLTAnalyzer.h.

bool Vx3DHLTAnalyzer::debugMode
private

Definition at line 98 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::dxdzlumi
private

Definition at line 126 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::dydzlumi
private

Definition at line 127 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::endLumiOfFit
private

Definition at line 160 of file Vx3DHLTAnalyzer.h.

edm::TimeValue_t Vx3DHLTAnalyzer::endTimeOfFit
private

Definition at line 153 of file Vx3DHLTAnalyzer.h.

std::string Vx3DHLTAnalyzer::fileName
private

Definition at line 112 of file Vx3DHLTAnalyzer.h.

Referenced by readConfig.fileINI::read().

MonitorElement* Vx3DHLTAnalyzer::fitResults
private

Definition at line 144 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::goodVxCounter
private

Definition at line 137 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::hitCounter
private

Definition at line 138 of file Vx3DHLTAnalyzer.h.

bool Vx3DHLTAnalyzer::internalDebug
private

Definition at line 163 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::lastLumiOfFit
private

Definition at line 161 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::lumiCounter
private

Definition at line 155 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::maxLumiIntegration
private

Definition at line 101 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::minNentries
private

Definition at line 103 of file Vx3DHLTAnalyzer.h.

double Vx3DHLTAnalyzer::minVxDoF
private

Definition at line 110 of file Vx3DHLTAnalyzer.h.

double Vx3DHLTAnalyzer::minVxWgt
private

Definition at line 111 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::mXlumi
private

Definition at line 118 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::mYlumi
private

Definition at line 119 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::mZlumi
private

Definition at line 120 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::nLumiFit
private

Definition at line 100 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::nLumiXaxisRange
private

Definition at line 102 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::nParams
private

Definition at line 162 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::numberFits
private

Definition at line 158 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::numberGoodFits
private

Definition at line 157 of file Vx3DHLTAnalyzer.h.

std::ofstream Vx3DHLTAnalyzer::outputDebugFile
private

Definition at line 151 of file Vx3DHLTAnalyzer.h.

std::ofstream Vx3DHLTAnalyzer::outputFile
private

Definition at line 150 of file Vx3DHLTAnalyzer.h.

edm::EDGetTokenT<SiPixelRecHitCollection> Vx3DHLTAnalyzer::pixelHitCollection
private

Definition at line 97 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::reportSummary
private

Definition at line 141 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::reportSummaryMap
private

Definition at line 142 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::runNumber
private

Definition at line 154 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::statusCounter
private

Definition at line 139 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::sXlumi
private

Definition at line 122 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::sYlumi
private

Definition at line 123 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::sZlumi
private

Definition at line 124 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::totalHits
private

Definition at line 156 of file Vx3DHLTAnalyzer.h.

edm::EDGetTokenT<reco::VertexCollection> Vx3DHLTAnalyzer::vertexCollection
private

Definition at line 96 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::Vx_X
private

Definition at line 129 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::Vx_XY
private

Definition at line 135 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::Vx_Y
private

Definition at line 130 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::Vx_Z
private

Definition at line 131 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::Vx_ZX
private

Definition at line 133 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::Vx_ZY
private

Definition at line 134 of file Vx3DHLTAnalyzer.h.

double Vx3DHLTAnalyzer::xRange
private

Definition at line 104 of file Vx3DHLTAnalyzer.h.

double Vx3DHLTAnalyzer::xStep
private

Definition at line 105 of file Vx3DHLTAnalyzer.h.

double Vx3DHLTAnalyzer::yRange
private

Definition at line 106 of file Vx3DHLTAnalyzer.h.

double Vx3DHLTAnalyzer::yStep
private

Definition at line 107 of file Vx3DHLTAnalyzer.h.

double Vx3DHLTAnalyzer::zRange
private

Definition at line 108 of file Vx3DHLTAnalyzer.h.

double Vx3DHLTAnalyzer::zStep
private

Definition at line 109 of file Vx3DHLTAnalyzer.h.

Generated for CMSSW Reference Manual by doxygen 1.8.5