#include <interface/Vx3DHLTAnalyzer.h>

Inheritance diagram for Vx3DHLTAnalyzer:

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

	~Vx3DHLTAnalyzer ()

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

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

Public Member Functions inherited from edm::EDConsumerBase
	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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

virtual void	beginJob ()

virtual void	beginLuminosityBlock (const edm::LuminosityBlock &lumiBlock, const edm::EventSetup &iSetup)

virtual void	beginRun ()

virtual void	endJob ()

virtual void	endLuminosityBlock (const edm::LuminosityBlock &lumiBlock, const edm::EventSetup &iSetup)

virtual char *	formatTime (const time_t &t)

virtual unsigned int	HitCounter (const edm::Event &iEvent)

virtual int	MyFit (std::vector< double > *vals)

virtual void	reset (std::string ResetType)

virtual 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 *	goodVxCountHistory

MonitorElement *	hitCounter

MonitorElement *	hitCountHistory

bool	internalDebug

unsigned int	lastLumiOfFit

unsigned int	lumiCounter

unsigned int	lumiCounterHisto

unsigned int	maxLumiIntegration

unsigned int	minNentries

double	minVxDoF

MonitorElement *	mXlumi

MonitorElement *	mYlumi

MonitorElement *	mZlumi

unsigned int	nBinsHistoricalPlot

unsigned int	nBinsWholeHistory

unsigned int	nLumiReset

unsigned int	numberFits

unsigned int	numberGoodFits

std::ofstream	outputDebugFile

std::ofstream	outputFile

edm::EDGetTokenT < SiPixelRecHitCollection >	pixelHitCollection

unsigned int	prescaleHistory

MonitorElement *	reportSummary

MonitorElement *	reportSummaryMap

unsigned int	runNumber

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::EDAnalyzer
typedef EDAnalyzer	ModuleType

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

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

Description: beam-spot monitor entirely based on pixel detector information Implementation: the monitoring is based on a 3D fit to the vertex cloud

Definition at line 75 of file Vx3DHLTAnalyzer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 35 of file Vx3DHLTAnalyzer.cc.

References convertXMLtoSQLite_cfg::fileName, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), GoodVertex_cfg::vertexCollection, and VxErrCorr.

 {
   debugMode   = true;
   nLumiReset  = 1;     // Number of integrated lumis to perform the fit
   dataFromFit = true;  // The Beam Spot data can be either taken from the histograms or from the fit results
   minNentries = 35;    // Minimum number of good vertices to perform the fit
   xRange      = 2.;    // [cm]
   xStep       = 0.001; // [cm]
   yRange      = 2.;    // [cm]
   yStep       = 0.001; // [cm]
   zRange      = 30.;   // [cm]
   zStep       = 0.05;  // [cm]
   VxErrCorr   = 1.5;
   fileName    = "BeamPixelResults.txt";
 
 
   vertexCollection   = consumes<reco::VertexCollection>(iConfig.getUntrackedParameter<edm::InputTag>("vertexCollection", edm::InputTag("pixelVertices")));
   pixelHitCollection = consumes<SiPixelRecHitCollection>(iConfig.getUntrackedParameter<edm::InputTag>("pixelHitCollection", edm::InputTag("siPixelRecHits")));
 
   debugMode          = iConfig.getParameter<bool>("debugMode");
   nLumiReset         = iConfig.getParameter<unsigned int>("nLumiReset");
   dataFromFit        = iConfig.getParameter<bool>("dataFromFit");
   minNentries        = iConfig.getParameter<unsigned int>("minNentries");
   xRange             = iConfig.getParameter<double>("xRange");
   xStep              = iConfig.getParameter<double>("xStep");
   yRange             = iConfig.getParameter<double>("yRange");
   yStep              = iConfig.getParameter<double>("yStep");
   zRange             = iConfig.getParameter<double>("zRange");
   zStep              = iConfig.getParameter<double>("zStep");
   VxErrCorr          = iConfig.getParameter<double>("VxErrCorr");
   fileName           = iConfig.getParameter<string>("fileName");
 }

Vx3DHLTAnalyzer::~Vx3DHLTAnalyzer ( )

Definition at line 69 of file Vx3DHLTAnalyzer.cc.

70 {

71 }

Member Function Documentation

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

privatevirtual

Implements edm::EDAnalyzer.

Definition at line 74 of file Vx3DHLTAnalyzer.cc.

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

 {
   edm::Handle<reco::VertexCollection> Vx3DCollection;
   iEvent.getByToken(vertexCollection, Vx3DCollection);
 
   unsigned int i,j;
   double det;
   VertexType MyVertex;
 
   if (runNumber != iEvent.id().run())
     {
       reset("scratch");
       runNumber = iEvent.id().run();
 
       if (debugMode == true)
     {
       stringstream debugFile;
       string tmp(fileName);
 
       if (outputDebugFile.is_open() == true) outputDebugFile.close();
       tmp.erase(strlen(fileName.c_str())-4,4);
       debugFile << tmp.c_str() << "_Run" << iEvent.id().run() << ".txt";
       outputDebugFile.open(debugFile.str().c_str(), ios::out);
       outputDebugFile.close();
       outputDebugFile.open(debugFile.str().c_str(), ios::app);
     }
 
       beginLuminosityBlock(iEvent.getLuminosityBlock(),iSetup);
     }
   else if (beginTimeOfFit != 0)
     {
       totalHits += HitCounter(iEvent);
 
       for (vector<Vertex>::const_iterator it3DVx = Vx3DCollection->begin(); it3DVx != Vx3DCollection->end(); it3DVx++)
     {
       if ((it3DVx->isValid() == true) &&
           (it3DVx->isFake() == false) &&
           (it3DVx->ndof() >= minVxDoF))
         {
           for (i = 0; i < DIM; i++)
         {
           for (j = 0; j < DIM; j++)
             {
               MyVertex.Covariance[i][j] = it3DVx->covariance(i,j);
               if (edm::isNotFinite(MyVertex.Covariance[i][j]) == true) break;
             }
           if (j != DIM) break;
         }
           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]) -
         MyVertex.Covariance[0][1]*(MyVertex.Covariance[0][1]*std::fabs(MyVertex.Covariance[2][2]) - MyVertex.Covariance[0][2]*MyVertex.Covariance[1][2]) +
         MyVertex.Covariance[0][2]*(MyVertex.Covariance[0][1]*MyVertex.Covariance[1][2] - MyVertex.Covariance[0][2]*std::fabs(MyVertex.Covariance[1][1]));
           if ((i == DIM) && (det > 0.))
         {
           MyVertex.x = it3DVx->x();
           MyVertex.y = it3DVx->y();
           MyVertex.z = it3DVx->z();
           Vertices.push_back(MyVertex);
         }
           else if (internalDebug == true)
         {
           cout << "Vertex discarded !" << endl;
           for (i = 0; i < DIM; i++)
             for (j = 0; j < DIM; j++)
               cout << "(i,j) --> " << i << "," << j << " --> " << MyVertex.Covariance[i][j] << endl;
         }
           
           Vx_X->Fill(it3DVx->x());
           Vx_Y->Fill(it3DVx->y());
           Vx_Z->Fill(it3DVx->z());
           
           Vx_ZX->Fill(it3DVx->z(), it3DVx->x());
           Vx_ZY->Fill(it3DVx->z(), it3DVx->y());
           Vx_XY->Fill(it3DVx->x(), it3DVx->y());
         }
     }
     }
 }

void Vx3DHLTAnalyzer::beginJob ( void )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 1060 of file Vx3DHLTAnalyzer.cc.

References considerVxCovariance, pi, and reset().

 {
   // ### Set internal variables ###
   reset("scratch");
   prescaleHistory      = 1;    // Set the number of lumis to update historical plot
   maxLumiIntegration   = 15;   // If failing fits, this is the maximum number of integrated lumis after which a reset is issued
   minVxDoF             = 10.;  // Good vertex selection cut
   // For vertex fitter without track-weight: d.o.f. = 2*NTracks - 3
   // For vertex fitter with track-weight:    d.o.f. = sum_NTracks(2*track_weight) - 3
   internalDebug        = false;
   considerVxCovariance = true; // Deconvolute vertex covariance matrix
   pi = 3.141592653589793238;
   // ##############################
 }

void Vx3DHLTAnalyzer::beginLuminosityBlock	(	const edm::LuminosityBlock &	lumiBlock,
		const edm::EventSetup &	iSetup
	)

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 781 of file Vx3DHLTAnalyzer.cc.

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

 {
   if ((lumiCounter == 0) && (lumiBlock.luminosityBlock() > lastLumiOfFit))
     {
       beginTimeOfFit = lumiBlock.beginTime().value();
       beginLumiOfFit = lumiBlock.luminosityBlock();
       lumiCounter++;
       lumiCounterHisto++;
     }
   else if ((lumiCounter != 0) && (lumiBlock.luminosityBlock() >= (beginLumiOfFit+lumiCounter))) { lumiCounter++; lumiCounterHisto++; }
 }

void Vx3DHLTAnalyzer::beginRun ( )

privatevirtual

Definition at line 1079 of file Vx3DHLTAnalyzer.cc.

References DQMStore::book1D(), DQMStore::book2D(), DQMStore::bookFloat(), MonitorElement::Fill(), cppFunctionSkipper::operator, MonitorElement::setAxisTitle(), and DQMStore::setCurrentFolder().

 {
   DQMStore* dbe = 0;
   dbe = Service<DQMStore>().operator->();
  
   // ### Set internal variables ###
   nBinsHistoricalPlot = 80;
   nBinsWholeHistory   = 3000; // Correspond to about 20h of data taking: 20h * 60min * 60s / 23s per lumi-block = 3130
   // ##############################
 
   if ( dbe ) 
     {
       dbe->setCurrentFolder("BeamPixel");
 
       Vx_X = dbe->book1D("vertex x", "Primary Vertex X Coordinate Distribution", int(rint(xRange/xStep)), -xRange/2., xRange/2.);
       Vx_Y = dbe->book1D("vertex y", "Primary Vertex Y Coordinate Distribution", int(rint(yRange/yStep)), -yRange/2., yRange/2.);
       Vx_Z = dbe->book1D("vertex z", "Primary Vertex Z Coordinate Distribution", int(rint(zRange/zStep)), -zRange/2., zRange/2.);
       Vx_X->setAxisTitle("Primary Vertices X [cm]",1);
       Vx_X->setAxisTitle("Entries [#]",2);
       Vx_Y->setAxisTitle("Primary Vertices Y [cm]",1);
       Vx_Y->setAxisTitle("Entries [#]",2);
       Vx_Z->setAxisTitle("Primary Vertices Z [cm]",1);
       Vx_Z->setAxisTitle("Entries [#]",2);
  
       mXlumi = dbe->book1D("muX vs lumi", "\\mu_{x} vs. Lumisection", nBinsHistoricalPlot, 0.5, (double)nBinsHistoricalPlot+0.5);
       mYlumi = dbe->book1D("muY vs lumi", "\\mu_{y} vs. Lumisection", nBinsHistoricalPlot, 0.5, (double)nBinsHistoricalPlot+0.5);
       mZlumi = dbe->book1D("muZ vs lumi", "\\mu_{z} vs. Lumisection", nBinsHistoricalPlot, 0.5, (double)nBinsHistoricalPlot+0.5);
       mXlumi->setAxisTitle("Lumisection [#]",1);
       mXlumi->setAxisTitle("\\mu_{x} [cm]",2);
       mXlumi->getTH1()->SetOption("E1");
       mYlumi->setAxisTitle("Lumisection [#]",1);
       mYlumi->setAxisTitle("\\mu_{y} [cm]",2);
       mYlumi->getTH1()->SetOption("E1");
       mZlumi->setAxisTitle("Lumisection [#]",1);
       mZlumi->setAxisTitle("\\mu_{z} [cm]",2);
       mZlumi->getTH1()->SetOption("E1");
 
       sXlumi = dbe->book1D("sigmaX vs lumi", "\\sigma_{x} vs. Lumisection", nBinsHistoricalPlot, 0.5, (double)nBinsHistoricalPlot+0.5);
       sYlumi = dbe->book1D("sigmaY vs lumi", "\\sigma_{y} vs. Lumisection", nBinsHistoricalPlot, 0.5, (double)nBinsHistoricalPlot+0.5);
       sZlumi = dbe->book1D("sigmaZ vs lumi", "\\sigma_{z} vs. Lumisection", nBinsHistoricalPlot, 0.5, (double)nBinsHistoricalPlot+0.5);
       sXlumi->setAxisTitle("Lumisection [#]",1);
       sXlumi->setAxisTitle("\\sigma_{x} [cm]",2);
       sXlumi->getTH1()->SetOption("E1");
       sYlumi->setAxisTitle("Lumisection [#]",1);
       sYlumi->setAxisTitle("\\sigma_{y} [cm]",2);
       sYlumi->getTH1()->SetOption("E1");
       sZlumi->setAxisTitle("Lumisection [#]",1);
       sZlumi->setAxisTitle("\\sigma_{z} [cm]",2);
       sZlumi->getTH1()->SetOption("E1");
 
       dxdzlumi = dbe->book1D("dxdz vs lumi", "dX/dZ vs. Lumisection", nBinsHistoricalPlot, 0.5, (double)nBinsHistoricalPlot+0.5);
       dydzlumi = dbe->book1D("dydz vs lumi", "dY/dZ vs. Lumisection", nBinsHistoricalPlot, 0.5, (double)nBinsHistoricalPlot+0.5);
       dxdzlumi->setAxisTitle("Lumisection [#]",1);
       dxdzlumi->setAxisTitle("dX/dZ [rad]",2);
       dxdzlumi->getTH1()->SetOption("E1");
       dydzlumi->setAxisTitle("Lumisection [#]",1);
       dydzlumi->setAxisTitle("dY/dZ [rad]",2);
       dydzlumi->getTH1()->SetOption("E1");
 
       Vx_ZX = dbe->book2D("vertex zx", "Primary Vertex ZX Coordinate Distribution", int(rint(zRange/zStep/5.)), -zRange/2., zRange/2., int(rint(xRange/xStep/5.)), -xRange/2., xRange/2.);
       Vx_ZY = dbe->book2D("vertex zy", "Primary Vertex ZY Coordinate Distribution", int(rint(zRange/zStep/5.)), -zRange/2., zRange/2., int(rint(yRange/yStep/5.)), -yRange/2., yRange/2.);
       Vx_XY = dbe->book2D("vertex xy", "Primary Vertex XY Coordinate Distribution", int(rint(xRange/xStep/5.)), -xRange/2., xRange/2., int(rint(yRange/yStep/5.)), -yRange/2., yRange/2.);
       Vx_ZX->setAxisTitle("Primary Vertices Z [cm]",1);
       Vx_ZX->setAxisTitle("Primary Vertices X [cm]",2);
       Vx_ZX->setAxisTitle("Entries [#]",3);
       Vx_ZY->setAxisTitle("Primary Vertices Z [cm]",1);
       Vx_ZY->setAxisTitle("Primary Vertices Y [cm]",2);
       Vx_ZY->setAxisTitle("Entries [#]",3);
       Vx_XY->setAxisTitle("Primary Vertices X [cm]",1);
       Vx_XY->setAxisTitle("Primary Vertices Y [cm]",2);
       Vx_XY->setAxisTitle("Entries [#]",3);
 
       hitCounter = dbe->book1D("pixelHits vs lumi", "# Pixel-Hits vs. Lumisection", nBinsHistoricalPlot, 0.5, (double)nBinsHistoricalPlot+0.5);
       hitCounter->setAxisTitle("Lumisection [#]",1);
       hitCounter->setAxisTitle("Pixel-Hits [#]",2);
       hitCounter->getTH1()->SetOption("E1");
 
       hitCountHistory = dbe->book1D("hist pixelHits vs lumi", "History: # Pixel-Hits vs. Lumi", nBinsWholeHistory, 0.5, (double)nBinsWholeHistory+0.5);
       hitCountHistory->setAxisTitle("Lumisection [#]",1);
       hitCountHistory->setAxisTitle("Pixel-Hits [#]",2);
       hitCountHistory->getTH1()->SetOption("E1");
 
       goodVxCounter = dbe->book1D("good vertices vs lumi", "# Good vertices vs. Lumisection", nBinsHistoricalPlot, 0.5, (double)nBinsHistoricalPlot+0.5);
       goodVxCounter->setAxisTitle("Lumisection [#]",1);
       goodVxCounter->setAxisTitle("Good vertices [#]",2);
       goodVxCounter->getTH1()->SetOption("E1");
 
       goodVxCountHistory = dbe->book1D("hist good vx vs lumi", "History: # Good vx vs. Lumi", nBinsWholeHistory, 0.5, (double)nBinsWholeHistory+0.5);
       goodVxCountHistory->setAxisTitle("Lumisection [#]",1);
       goodVxCountHistory->setAxisTitle("Good vertices [#]",2);
       goodVxCountHistory->getTH1()->SetOption("E1");
 
       fitResults = dbe->book2D("fit results","Results of Beam Spot Fit", 2, 0., 2., 9, 0., 9.);
       fitResults->setAxisTitle("Fitted Beam Spot [cm]", 1);
       fitResults->setBinLabel(9, "X", 2);
       fitResults->setBinLabel(8, "Y", 2);
       fitResults->setBinLabel(7, "Z", 2);
       fitResults->setBinLabel(6, "\\sigma_{Z}", 2);
       fitResults->setBinLabel(5, "#frac{dX}{dZ}[rad]", 2);
       fitResults->setBinLabel(4, "#frac{dY}{dZ}[rad]", 2);
       fitResults->setBinLabel(3, "\\sigma_{X}", 2);
       fitResults->setBinLabel(2, "\\sigma_{Y}", 2);
       fitResults->setBinLabel(1, "Vertices", 2);
       fitResults->setBinLabel(1, "Value", 1);
       fitResults->setBinLabel(2, "Stat. Error", 1);
       fitResults->getTH1()->SetOption("text");
 
       dbe->setCurrentFolder("BeamPixel/EventInfo");
       reportSummary = dbe->bookFloat("reportSummary");
       reportSummary->Fill(0.);
       reportSummaryMap = dbe->book2D("reportSummaryMap","Pixel-Vertices Beam Spot: % Good Fits", 1, 0., 1., 1, 0., 1.);
       reportSummaryMap->Fill(0.5, 0.5, 0.);
       dbe->setCurrentFolder("BeamPixel/EventInfo/reportSummaryContents");
 
       // Convention for reportSummary and reportSummaryMap:
       // - 0%  at the moment of creation of the histogram
       // - n%  numberGoodFits / numberFits
     }
 }

void Vx3DHLTAnalyzer::endJob ( void )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 1076 of file Vx3DHLTAnalyzer.cc.

References reset().

1076 { reset("scratch"); }

Vx3DHLTAnalyzer::reset

virtual void reset(std::string ResetType)

Definition: Vx3DHLTAnalyzer.cc:551

void Vx3DHLTAnalyzer::endLuminosityBlock	(	const edm::LuminosityBlock &	lumiBlock,
		const edm::EventSetup &	iSetup
	)

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 795 of file Vx3DHLTAnalyzer.cc.

References counterVx, gather_cfg::cout, edm::LuminosityBlockBase::endTime(), i, edm::LuminosityBlockBase::luminosityBlock(), funct::pow(), reset(), convertSQLiteXML::runNumber, mathSSE::sqrt(), create_public_pileup_plots::vals, and edm::Timestamp::value().

 {
   stringstream histTitle;
   int goodData;
   unsigned int nParams = 9;
 
   if ((lumiCounter%nLumiReset == 0) && (nLumiReset != 0) && (beginTimeOfFit != 0) && (runNumber != 0))
     {
       endTimeOfFit  = lumiBlock.endTime().value();
       endLumiOfFit  = lumiBlock.luminosityBlock();
       lastLumiOfFit = endLumiOfFit;
       vector<double> vals;
 
       hitCounter->ShiftFillLast((double)totalHits, std::sqrt((double)totalHits), nLumiReset);
 
       if (lastLumiOfFit % prescaleHistory == 0)
     {
       hitCountHistory->getTH1()->SetBinContent(lastLumiOfFit, (double)totalHits);
       hitCountHistory->getTH1()->SetBinError(lastLumiOfFit, std::sqrt((double)totalHits));
     }
 
       if (dataFromFit == true)
     {
       vector<double> fitResults;
 
       fitResults.push_back(Vx_X->getTH1()->GetRMS()*Vx_X->getTH1()->GetRMS());
       fitResults.push_back(Vx_Y->getTH1()->GetRMS()*Vx_Y->getTH1()->GetRMS());
       fitResults.push_back(Vx_Z->getTH1()->GetRMS()*Vx_Z->getTH1()->GetRMS());
       fitResults.push_back(0.0);
       fitResults.push_back(0.0);
       fitResults.push_back(0.0);
       fitResults.push_back(Vx_X->getTH1()->GetMean());
       fitResults.push_back(Vx_Y->getTH1()->GetMean());
       fitResults.push_back(Vx_Z->getTH1()->GetMean());
       for (unsigned int i = 0; i < nParams; i++) fitResults.push_back(0.0);
       
       goodData = MyFit(&fitResults);              
 
       if (internalDebug == true) 
         {
           cout << "goodData --> " << goodData << endl;
           cout << "Used vertices --> " << counterVx << endl;
           cout << "var x -->  " << fitResults[0] << " +/- " << fitResults[0+nParams] << endl;
           cout << "var y -->  " << fitResults[1] << " +/- " << fitResults[1+nParams] << endl;
           cout << "var z -->  " << fitResults[2] << " +/- " << fitResults[2+nParams] << endl;
           cout << "cov xy --> " << fitResults[3] << " +/- " << fitResults[3+nParams] << endl;
           cout << "dydz   --> " << fitResults[4] << " +/- " << fitResults[4+nParams] << endl;
           cout << "dxdz   --> " << fitResults[5] << " +/- " << fitResults[5+nParams] << endl;
           cout << "mean x --> " << fitResults[6] << " +/- " << fitResults[6+nParams] << endl;
           cout << "mean y --> " << fitResults[7] << " +/- " << fitResults[7+nParams] << endl;
           cout << "mean z --> " << fitResults[8] << " +/- " << fitResults[8+nParams] << endl;
         }
 
       if (goodData == 0)
         {        
           vals.push_back(fitResults[6]);
           vals.push_back(fitResults[7]);
           vals.push_back(fitResults[8]);
           vals.push_back(std::sqrt(std::fabs(fitResults[2])));
           vals.push_back(fitResults[5]);
           vals.push_back(fitResults[4]);
           vals.push_back(std::sqrt(std::fabs(fitResults[0])));
           vals.push_back(std::sqrt(std::fabs(fitResults[1])));
 
           vals.push_back(std::pow(fitResults[6+nParams],2.));
           vals.push_back(std::pow(fitResults[7+nParams],2.));
           vals.push_back(std::pow(fitResults[8+nParams],2.));
           vals.push_back(std::pow(std::fabs(fitResults[2+nParams]) / (2.*std::sqrt(std::fabs(fitResults[2]))),2.));
           vals.push_back(std::pow(fitResults[5+nParams],2.));
           vals.push_back(std::pow(fitResults[4+nParams],2.));
           vals.push_back(std::pow(std::fabs(fitResults[0+nParams]) / (2.*std::sqrt(std::fabs(fitResults[0]))),2.));
           vals.push_back(std::pow(std::fabs(fitResults[1+nParams]) / (2.*std::sqrt(std::fabs(fitResults[1]))),2.));
         }
       else for (unsigned int i = 0; i < 8*2; i++) vals.push_back(0.0);
 
       fitResults.clear();
     }
       else
     {
       counterVx = Vx_X->getTH1F()->GetEntries();
         
       if (Vx_X->getTH1F()->GetEntries() >= minNentries)
         {
         goodData = 0;
         
         vals.push_back(Vx_X->getTH1F()->GetMean());
         vals.push_back(Vx_Y->getTH1F()->GetMean());
         vals.push_back(Vx_Z->getTH1F()->GetMean());
         vals.push_back(Vx_Z->getTH1F()->GetRMS());
         vals.push_back(0.0);
         vals.push_back(0.0);
         vals.push_back(Vx_X->getTH1F()->GetRMS());
         vals.push_back(Vx_Y->getTH1F()->GetRMS());
         
         vals.push_back(std::pow(Vx_X->getTH1F()->GetMeanError(),2.));
         vals.push_back(std::pow(Vx_Y->getTH1F()->GetMeanError(),2.));
         vals.push_back(std::pow(Vx_Z->getTH1F()->GetMeanError(),2.));
         vals.push_back(std::pow(Vx_Z->getTH1F()->GetRMSError(),2.));
         vals.push_back(0.0);
         vals.push_back(0.0);
         vals.push_back(std::pow(Vx_X->getTH1F()->GetRMSError(),2.));
         vals.push_back(std::pow(Vx_Y->getTH1F()->GetRMSError(),2.));
         }
       else
         {
           goodData = -2;
           for (unsigned int i = 0; i < 8*2; i++) vals.push_back(0.0);
         }
     }
 
       // vals[0]  = X0
       // vals[1]  = Y0
       // vals[2]  = Z0
       // vals[3]  = sigmaZ0
       // vals[4]  = dxdz
       // vals[5]  = dydz
       // vals[6]  = BeamWidthX
       // vals[7]  = BeamWidthY
 
       // vals[8]  = err^2 X0
       // vals[9]  = err^2 Y0
       // vals[10] = err^2 Z0
       // vals[11] = err^2 sigmaZ0
       // vals[12] = err^2 dxdz
       // vals[13] = err^2 dydz
       // vals[14] = err^2 BeamWidthX
       // vals[15] = err^2 BeamWidthY
 
       // "goodData" CODE:
       //  0 == OK --> Reset
       // -2 == NO OK - not enough "minNentries" --> Wait for more lumisections
       // Any other number == NO OK --> Reset
 
       numberFits++;
       if (goodData == 0)
     {
       writeToFile(&vals, beginTimeOfFit, endTimeOfFit, beginLumiOfFit, endLumiOfFit, 3);
       if ((internalDebug == true) && (outputDebugFile.is_open() == true)) outputDebugFile << "Used vertices: " << counterVx << endl;
 
       numberGoodFits++;
 
       histTitle << "Fitted Beam Spot [cm] (Lumi start: " << beginLumiOfFit << " - Lumi end: " << endLumiOfFit << ")";
       if (lumiCounterHisto >= maxLumiIntegration) reset("whole");
       else reset("partial");
     }
       else
     {
       writeToFile(&vals, beginTimeOfFit, endTimeOfFit, beginLumiOfFit, endLumiOfFit, -1);
       if ((internalDebug == true) && (outputDebugFile.is_open() == true)) outputDebugFile << "Used vertices: " << counterVx << endl;
 
       if (goodData == -2)
         {
           histTitle << "Fitted Beam Spot [cm] (not enough statistics)";
           if (lumiCounter >= maxLumiIntegration) reset("whole");
           else reset("hitCounter");
         }
       else
         {
           histTitle << "Fitted Beam Spot [cm] (problems)";
           if (lumiCounterHisto >= maxLumiIntegration) reset("whole");
           else reset("partial");
 
           counterVx = 0;
         }
     }
 
       reportSummary->Fill(numberFits != 0 ? (double)numberGoodFits/(double)numberFits : 0.0);
       reportSummaryMap->Fill(0.5, 0.5, numberFits != 0 ? (double)numberGoodFits/(double)numberFits : 0.0);
 
       fitResults->setAxisTitle(histTitle.str().c_str(), 1);
       
       fitResults->setBinContent(1, 9, vals[0]);
       fitResults->setBinContent(1, 8, vals[1]);
       fitResults->setBinContent(1, 7, vals[2]);
       fitResults->setBinContent(1, 6, vals[3]);
       fitResults->setBinContent(1, 5, vals[4]);
       fitResults->setBinContent(1, 4, vals[5]);
       fitResults->setBinContent(1, 3, vals[6]);
       fitResults->setBinContent(1, 2, vals[7]);
       fitResults->setBinContent(1, 1, counterVx);
       
       fitResults->setBinContent(2, 9, std::sqrt(vals[8]));
       fitResults->setBinContent(2, 8, std::sqrt(vals[9]));
       fitResults->setBinContent(2, 7, std::sqrt(vals[10]));
       fitResults->setBinContent(2, 6, std::sqrt(vals[11]));
       fitResults->setBinContent(2, 5, std::sqrt(vals[12]));
       fitResults->setBinContent(2, 4, std::sqrt(vals[13]));
       fitResults->setBinContent(2, 3, std::sqrt(vals[14]));
       fitResults->setBinContent(2, 2, std::sqrt(vals[15]));
       fitResults->setBinContent(2, 1, std::sqrt(counterVx));
 
       // Linear fit to the historical plots
       TF1* myLinFit = new TF1("myLinFit", "[0] + [1]*x", mXlumi->getTH1()->GetXaxis()->GetXmin(), mXlumi->getTH1()->GetXaxis()->GetXmax());
       myLinFit->SetLineColor(2);
       myLinFit->SetLineWidth(2);
       myLinFit->SetParName(0,"Intercept");
       myLinFit->SetParName(1,"Slope");
 
       mXlumi->ShiftFillLast(vals[0], std::sqrt(vals[8]), nLumiReset);
       myLinFit->SetParameter(0, mXlumi->getTH1()->GetMean(2));
       myLinFit->SetParameter(1, 0.0);
       mXlumi->getTH1()->Fit("myLinFit","QR");
 
       mYlumi->ShiftFillLast(vals[1], std::sqrt(vals[9]), nLumiReset);
       myLinFit->SetParameter(0, mYlumi->getTH1()->GetMean(2));
       myLinFit->SetParameter(1, 0.0);
       mYlumi->getTH1()->Fit("myLinFit","QR");
 
       mZlumi->ShiftFillLast(vals[2], std::sqrt(vals[10]), nLumiReset);
       myLinFit->SetParameter(0, mZlumi->getTH1()->GetMean(2));
       myLinFit->SetParameter(1, 0.0);
       mZlumi->getTH1()->Fit("myLinFit","QR");
 
       sXlumi->ShiftFillLast(vals[6], std::sqrt(vals[14]), nLumiReset);
       myLinFit->SetParameter(0, sXlumi->getTH1()->GetMean(2));
       myLinFit->SetParameter(1, 0.0);
       sXlumi->getTH1()->Fit("myLinFit","QR");
 
       sYlumi->ShiftFillLast(vals[7], std::sqrt(vals[15]), nLumiReset);
       myLinFit->SetParameter(0, sYlumi->getTH1()->GetMean(2));
       myLinFit->SetParameter(1, 0.0);
       sYlumi->getTH1()->Fit("myLinFit","QR");
 
       sZlumi->ShiftFillLast(vals[3], std::sqrt(vals[11]), nLumiReset);
       myLinFit->SetParameter(0, sZlumi->getTH1()->GetMean(2));
       myLinFit->SetParameter(1, 0.0);
       sZlumi->getTH1()->Fit("myLinFit","QR");
 
       dxdzlumi->ShiftFillLast(vals[4], std::sqrt(vals[12]), nLumiReset);
       myLinFit->SetParameter(0, dxdzlumi->getTH1()->GetMean(2));
       myLinFit->SetParameter(1, 0.0);
       dxdzlumi->getTH1()->Fit("myLinFit","QR");
 
       dydzlumi->ShiftFillLast(vals[5], std::sqrt(vals[13]), nLumiReset);
       myLinFit->SetParameter(0, dydzlumi->getTH1()->GetMean(2));
       myLinFit->SetParameter(1, 0.0);
       dydzlumi->getTH1()->Fit("myLinFit","QR");
       
       goodVxCounter->ShiftFillLast((double)counterVx, std::sqrt((double)counterVx), nLumiReset);      
       myLinFit->SetParameter(0, goodVxCounter->getTH1()->GetMean(2));
       myLinFit->SetParameter(1, 0.0);
       goodVxCounter->getTH1()->Fit("myLinFit","QR");
 
       if (lastLumiOfFit % prescaleHistory == 0)
     {
       goodVxCountHistory->getTH1()->SetBinContent(lastLumiOfFit, (double)counterVx);
       goodVxCountHistory->getTH1()->SetBinError(lastLumiOfFit, std::sqrt((double)counterVx));
     }
 
       delete myLinFit;
 
       vals.clear();
     }
   else if (nLumiReset == 0)
     {
       histTitle << "Fitted Beam Spot [cm] (no ongoing fits)";
       fitResults->setAxisTitle(histTitle.str().c_str(), 1);
       reportSummaryMap->Fill(0.5, 0.5, 1.0);
       hitCounter->ShiftFillLast(totalHits, std::sqrt(totalHits), 1);
       reset("nohisto");
     }
 }

char * Vx3DHLTAnalyzer::formatTime ( const time_t & t )

privatevirtual

Definition at line 167 of file Vx3DHLTAnalyzer.cc.

 {
   static char ts[25];
   strftime(ts, sizeof(ts), "%Y.%m.%d %H:%M:%S %Z", gmtime(&t));
 
   return ts;
 }

unsigned int Vx3DHLTAnalyzer::HitCounter ( const edm::Event & iEvent )

privatevirtual

Definition at line 153 of file Vx3DHLTAnalyzer.cc.

References counter, edm::Event::getByToken(), h, and j.

 {
   edm::Handle<SiPixelRecHitCollection> rechitspixel;
   iEvent.getByToken(pixelHitCollection, rechitspixel);
 
   unsigned int counter = 0;
   
   for (SiPixelRecHitCollection::const_iterator j = rechitspixel->begin(); j != rechitspixel->end(); j++)
     for (edmNew::DetSet<SiPixelRecHit>::const_iterator h = j->begin(); h != j->end(); h++) counter += h->cluster()->size();   
   
   return counter;
 }

int Vx3DHLTAnalyzer::MyFit ( std::vector< double > * vals )

privatevirtual

Definition at line 245 of file Vx3DHLTAnalyzer.cc.

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

 {
   // RETURN CODE:
   //  0 == OK
   // -2 == NO OK - not enough "minNentries"
   // Any other number == NO OK
   unsigned int nParams = 9;
  
   if ((vals != NULL) && (vals->size() == nParams*2))
     {
       double nSigmaXY       = 100.;
       double nSigmaZ        = 100.;
       double varFactor      = 4./25.; // Take into account the difference between the RMS and sigma (RMS usually greater than sigma)
       double parDistanceXY  = 0.005;  // Unit: [cm]
       double parDistanceZ   = 0.5;    // Unit: [cm]
       double parDistanceddZ = 1e-3;   // Unit: [rad]
       double parDistanceCxy = 1e-5;   // Unit: [cm^2]
       double bestEdm        = 1e-1;
 
       const unsigned int trials = 4;
       double largerDist[trials] = {0.1, 5., 10., 100.};
 
       double covxz,covyz,det;
       double deltaMean;
       int bestMovementX = 1;
       int bestMovementY = 1;
       int bestMovementZ = 1;
       int goodData;
 
       double edm;
 
       vector<double>::const_iterator it = vals->begin();
 
       ROOT::Math::Minimizer* Gauss3D = ROOT::Math::Factory::CreateMinimizer("Minuit2","Migrad");
       Gauss3D->SetMaxFunctionCalls(1e4);
       Gauss3D->SetTolerance(1e-9); // Tolerance on likelihood
       if (internalDebug == true) Gauss3D->SetPrintLevel(3);
       else                       Gauss3D->SetPrintLevel(0);
 
       ROOT::Math::Functor _Gauss3DFunc(&Gauss3DFunc,nParams);
       Gauss3D->SetFunction(_Gauss3DFunc);
 
       if (internalDebug == true) cout << "\n@@@ START FITTING @@@" << endl;
 
       // @@@ Fit at X-deltaMean | X | X+deltaMean @@@
       bestEdm = 1.;
       for (int i = 0; i < 3; i++)
     {
       deltaMean = (double(i)-1.)*std::sqrt((*(it+0))*varFactor);
       if (internalDebug == true) cout << "deltaMean --> " << deltaMean << endl;
 
       Gauss3D->Clear();
 
       Gauss3D->SetVariable(0,"var x ", *(it+0)*varFactor, parDistanceXY*parDistanceXY);
       Gauss3D->SetVariable(1,"var y ", *(it+1)*varFactor, parDistanceXY*parDistanceXY);
       Gauss3D->SetVariable(2,"var z ", *(it+2), parDistanceZ*parDistanceZ);
       Gauss3D->SetVariable(3,"cov xy", *(it+3), parDistanceCxy);
       Gauss3D->SetVariable(4,"dydz  ", *(it+4), parDistanceddZ);
       Gauss3D->SetVariable(5,"dxdz  ", *(it+5), parDistanceddZ);
       Gauss3D->SetVariable(6,"mean x", *(it+6)+deltaMean, parDistanceXY);
       Gauss3D->SetVariable(7,"mean y", *(it+7), parDistanceXY);
       Gauss3D->SetVariable(8,"mean z", *(it+8), parDistanceZ);
 
       // Set the central positions of the centroid for vertex rejection
       xPos = Gauss3D->X()[6];
       yPos = Gauss3D->X()[7];
       zPos = Gauss3D->X()[8];
 
       // Set dimensions of the centroid for vertex rejection
       maxTransRadius = nSigmaXY * std::sqrt(std::fabs(Gauss3D->X()[0]) + std::fabs(Gauss3D->X()[1])) / 2.;
       maxLongLength  = nSigmaZ  * std::sqrt(std::fabs(Gauss3D->X()[2]));
 
       Gauss3D->Minimize();
       goodData = Gauss3D->Status();
       edm = Gauss3D->Edm();
 
       if (counterVx < minNentries) goodData = -2;
       else if (edm::isNotFinite(edm) == true) goodData = -1;
       else for (unsigned int j = 0; j < nParams; j++) if (edm::isNotFinite(Gauss3D->Errors()[j]) == true) { goodData = -1; break; }
       if (goodData == 0)
         {
           covyz = Gauss3D->X()[4]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[1])) - Gauss3D->X()[5]*Gauss3D->X()[3];
           covxz = Gauss3D->X()[5]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[0])) - Gauss3D->X()[4]*Gauss3D->X()[3];
           
           det = std::fabs(Gauss3D->X()[0]) * (std::fabs(Gauss3D->X()[1])*std::fabs(Gauss3D->X()[2]) - covyz*covyz) -
         Gauss3D->X()[3] * (Gauss3D->X()[3]*std::fabs(Gauss3D->X()[2]) - covxz*covyz) +
         covxz * (Gauss3D->X()[3]*covyz - covxz*std::fabs(Gauss3D->X()[1]));
           if (det < 0.) { goodData = -1; if (internalDebug == true) cout << "Negative determinant !" << endl; }
         }
 
       if ((goodData == 0) && (std::fabs(edm) < bestEdm)) { bestEdm = edm; bestMovementX = i; }
     }
       if (internalDebug == true) cout << "Found bestMovementX --> " << bestMovementX << endl;
 
       // @@@ Fit at Y-deltaMean | Y | Y+deltaMean @@@
       bestEdm = 1.;
       for (int i = 0; i < 3; i++)
     {
       deltaMean = (double(i)-1.)*std::sqrt((*(it+1))*varFactor);
       if (internalDebug == true)
         {
           cout << "deltaMean --> " << deltaMean << endl;
           cout << "deltaMean X --> " << (double(bestMovementX)-1.)*std::sqrt((*(it+0))*varFactor) << endl;
         }
 
       Gauss3D->Clear();
 
       Gauss3D->SetVariable(0,"var x ", *(it+0)*varFactor, parDistanceXY*parDistanceXY);
       Gauss3D->SetVariable(1,"var y ", *(it+1)*varFactor, parDistanceXY*parDistanceXY);
       Gauss3D->SetVariable(2,"var z ", *(it+2), parDistanceZ*parDistanceZ);
       Gauss3D->SetVariable(3,"cov xy", *(it+3), parDistanceCxy);
       Gauss3D->SetVariable(4,"dydz  ", *(it+4), parDistanceddZ);
       Gauss3D->SetVariable(5,"dxdz  ", *(it+5), parDistanceddZ);
       Gauss3D->SetVariable(6,"mean x", *(it+6)+(double(bestMovementX)-1.)*std::sqrt((*(it+0))*varFactor), parDistanceXY);
       Gauss3D->SetVariable(7,"mean y", *(it+7)+deltaMean, parDistanceXY);
       Gauss3D->SetVariable(8,"mean z", *(it+8), parDistanceZ);
 
       // Set the central positions of the centroid for vertex rejection
       xPos = Gauss3D->X()[6];
       yPos = Gauss3D->X()[7];
       zPos = Gauss3D->X()[8];
 
       // Set dimensions of the centroid for vertex rejection
       maxTransRadius = nSigmaXY * std::sqrt(std::fabs(Gauss3D->X()[0]) + std::fabs(Gauss3D->X()[1])) / 2.;
       maxLongLength  = nSigmaZ  * std::sqrt(std::fabs(Gauss3D->X()[2]));
 
           Gauss3D->Minimize();
           goodData = Gauss3D->Status();
       edm = Gauss3D->Edm();
 
       if (counterVx < minNentries) goodData = -2;
       else if (edm::isNotFinite(edm) == true) goodData = -1;
       else for (unsigned int j = 0; j < nParams; j++) if (edm::isNotFinite(Gauss3D->Errors()[j]) == true) { goodData = -1; break; }
       if (goodData == 0)
         {
           covyz = Gauss3D->X()[4]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[1])) - Gauss3D->X()[5]*Gauss3D->X()[3];
           covxz = Gauss3D->X()[5]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[0])) - Gauss3D->X()[4]*Gauss3D->X()[3];
           
           det = std::fabs(Gauss3D->X()[0]) * (std::fabs(Gauss3D->X()[1])*std::fabs(Gauss3D->X()[2]) - covyz*covyz) -
         Gauss3D->X()[3] * (Gauss3D->X()[3]*std::fabs(Gauss3D->X()[2]) - covxz*covyz) +
         covxz * (Gauss3D->X()[3]*covyz - covxz*std::fabs(Gauss3D->X()[1]));
           if (det < 0.) { goodData = -1; if (internalDebug == true) cout << "Negative determinant !" << endl; }
         }
       
       if ((goodData == 0) && (std::fabs(edm) < bestEdm)) { bestEdm = edm; bestMovementY = i; }
     }
       if (internalDebug == true) cout << "Found bestMovementY --> " << bestMovementY << endl;
 
       // @@@ Fit at Z-deltaMean | Z | Z+deltaMean @@@
       bestEdm = 1.;
       for (int i = 0; i < 3; i++)
     {
       deltaMean = (double(i)-1.)*std::sqrt(*(it+2));
       if (internalDebug == true)
         {
           cout << "deltaMean --> " << deltaMean << endl;
           cout << "deltaMean X --> " << (double(bestMovementX)-1.)*std::sqrt((*(it+0))*varFactor) << endl;
           cout << "deltaMean Y --> " << (double(bestMovementY)-1.)*std::sqrt((*(it+1))*varFactor) << endl;
         }
 
       Gauss3D->Clear();
 
       Gauss3D->SetVariable(0,"var x ", *(it+0)*varFactor, parDistanceXY*parDistanceXY);
       Gauss3D->SetVariable(1,"var y ", *(it+1)*varFactor, parDistanceXY*parDistanceXY);
       Gauss3D->SetVariable(2,"var z ", *(it+2), parDistanceZ*parDistanceZ);
       Gauss3D->SetVariable(3,"cov xy", *(it+3), parDistanceCxy);
       Gauss3D->SetVariable(4,"dydz  ", *(it+4), parDistanceddZ);
       Gauss3D->SetVariable(5,"dxdz  ", *(it+5), parDistanceddZ);
       Gauss3D->SetVariable(6,"mean x", *(it+6)+(double(bestMovementX)-1.)*std::sqrt((*(it+0))*varFactor), parDistanceXY);
       Gauss3D->SetVariable(7,"mean y", *(it+7)+(double(bestMovementY)-1.)*std::sqrt((*(it+1))*varFactor), parDistanceXY);
       Gauss3D->SetVariable(8,"mean z", *(it+8)+deltaMean, parDistanceZ);
 
       // Set the central positions of the centroid for vertex rejection
       xPos = Gauss3D->X()[6];
       yPos = Gauss3D->X()[7];
       zPos = Gauss3D->X()[8];
 
       // Set dimensions of the centroid for vertex rejection
       maxTransRadius = nSigmaXY * std::sqrt(std::fabs(Gauss3D->X()[0]) + std::fabs(Gauss3D->X()[1])) / 2.;
       maxLongLength  = nSigmaZ  * std::sqrt(std::fabs(Gauss3D->X()[2]));
 
           Gauss3D->Minimize();
           goodData = Gauss3D->Status();
       edm = Gauss3D->Edm();
 
       if (counterVx < minNentries) goodData = -2;
       else if (edm::isNotFinite(edm) == true) goodData = -1;
       else for (unsigned int j = 0; j < nParams; j++) if (edm::isNotFinite(Gauss3D->Errors()[j]) == true) { goodData = -1; break; }
       if (goodData == 0)
         {
           covyz = Gauss3D->X()[4]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[1])) - Gauss3D->X()[5]*Gauss3D->X()[3];
           covxz = Gauss3D->X()[5]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[0])) - Gauss3D->X()[4]*Gauss3D->X()[3];
 
           det = std::fabs(Gauss3D->X()[0]) * (std::fabs(Gauss3D->X()[1])*std::fabs(Gauss3D->X()[2]) - covyz*covyz) -
         Gauss3D->X()[3] * (Gauss3D->X()[3]*std::fabs(Gauss3D->X()[2]) - covxz*covyz) +
         covxz * (Gauss3D->X()[3]*covyz - covxz*std::fabs(Gauss3D->X()[1]));
           if (det < 0.) { goodData = -1; if (internalDebug == true) cout << "Negative determinant !" << endl; }
         }
       
       if ((goodData == 0) && (std::fabs(edm) < bestEdm)) { bestEdm = edm; bestMovementZ = i; }
     }
       if (internalDebug == true) cout << "Found bestMovementZ --> " << bestMovementZ << endl;
 
       Gauss3D->Clear();
 
       // @@@ FINAL FIT @@@
       Gauss3D->SetVariable(0,"var x ", *(it+0)*varFactor, parDistanceXY*parDistanceXY);
       Gauss3D->SetVariable(1,"var y ", *(it+1)*varFactor, parDistanceXY*parDistanceXY);
       Gauss3D->SetVariable(2,"var z ", *(it+2), parDistanceZ*parDistanceZ);
       Gauss3D->SetVariable(3,"cov xy", *(it+3), parDistanceCxy);
       Gauss3D->SetVariable(4,"dydz  ", *(it+4), parDistanceddZ);
       Gauss3D->SetVariable(5,"dxdz  ", *(it+5), parDistanceddZ);
       Gauss3D->SetVariable(6,"mean x", *(it+6)+(double(bestMovementX)-1.)*std::sqrt((*(it+0))*varFactor), parDistanceXY);
       Gauss3D->SetVariable(7,"mean y", *(it+7)+(double(bestMovementY)-1.)*std::sqrt((*(it+1))*varFactor), parDistanceXY);
       Gauss3D->SetVariable(8,"mean z", *(it+8)+(double(bestMovementZ)-1.)*std::sqrt(*(it+2)), parDistanceZ);
 
       // Set the central positions of the centroid for vertex rejection
       xPos = Gauss3D->X()[6];
       yPos = Gauss3D->X()[7];
       zPos = Gauss3D->X()[8];
 
       // Set dimensions of the centroid for vertex rejection
       maxTransRadius = nSigmaXY * std::sqrt(std::fabs(Gauss3D->X()[0]) + std::fabs(Gauss3D->X()[1])) / 2.;
       maxLongLength  = nSigmaZ  * std::sqrt(std::fabs(Gauss3D->X()[2]));
 
       Gauss3D->Minimize();
       goodData = Gauss3D->Status();
       edm = Gauss3D->Edm();
       
       if (counterVx < minNentries) goodData = -2;
       else if (edm::isNotFinite(edm) == true) goodData = -1;
       else for (unsigned int j = 0; j < nParams; j++) if (edm::isNotFinite(Gauss3D->Errors()[j]) == true) { goodData = -1; break; }
       if (goodData == 0)
     {
       covyz = Gauss3D->X()[4]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[1])) - Gauss3D->X()[5]*Gauss3D->X()[3];
       covxz = Gauss3D->X()[5]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[0])) - Gauss3D->X()[4]*Gauss3D->X()[3];
 
       det = std::fabs(Gauss3D->X()[0]) * (std::fabs(Gauss3D->X()[1])*std::fabs(Gauss3D->X()[2]) - covyz*covyz) -
         Gauss3D->X()[3] * (Gauss3D->X()[3]*std::fabs(Gauss3D->X()[2]) - covxz*covyz) +
         covxz * (Gauss3D->X()[3]*covyz - covxz*std::fabs(Gauss3D->X()[1]));
       if (det < 0.) { goodData = -1; if (internalDebug == true) cout << "Negative determinant !" << endl; }
     }
 
       // @@@ FIT WITH DIFFERENT PARAMETER DISTANCES @@@
       for (unsigned int i = 0; i < trials; i++)
     {
       if ((goodData != 0) && (goodData != -2))
         {
           Gauss3D->Clear();
       
           if (internalDebug == true) cout << "FIT WITH DIFFERENT PARAMETER DISTANCES - STEP " << i+1 << endl;      
 
           Gauss3D->SetVariable(0,"var x ", *(it+0)*varFactor, parDistanceXY*parDistanceXY * largerDist[i]);
           Gauss3D->SetVariable(1,"var y ", *(it+1)*varFactor, parDistanceXY*parDistanceXY * largerDist[i]);
           Gauss3D->SetVariable(2,"var z ", *(it+2), parDistanceZ*parDistanceZ * largerDist[i]);
           Gauss3D->SetVariable(3,"cov xy", *(it+3), parDistanceCxy * largerDist[i]);
           Gauss3D->SetVariable(4,"dydz  ", *(it+4), parDistanceddZ * largerDist[i]);
           Gauss3D->SetVariable(5,"dxdz  ", *(it+5), parDistanceddZ * largerDist[i]);
           Gauss3D->SetVariable(6,"mean x", *(it+6)+(double(bestMovementX)-1.)*std::sqrt((*(it+0))*varFactor), parDistanceXY * largerDist[i]);
           Gauss3D->SetVariable(7,"mean y", *(it+7)+(double(bestMovementY)-1.)*std::sqrt((*(it+1))*varFactor), parDistanceXY * largerDist[i]);
           Gauss3D->SetVariable(8,"mean z", *(it+8)+(double(bestMovementZ)-1.)*std::sqrt(*(it+2)), parDistanceZ * largerDist[i]);
 
           // Set the central positions of the centroid for vertex rejection
           xPos = Gauss3D->X()[6];
           yPos = Gauss3D->X()[7];
           zPos = Gauss3D->X()[8];
 
           // Set dimensions of the centroid for vertex rejection
           maxTransRadius = nSigmaXY * std::sqrt(std::fabs(Gauss3D->X()[0]) + std::fabs(Gauss3D->X()[1])) / 2.;
           maxLongLength  = nSigmaZ  * std::sqrt(std::fabs(Gauss3D->X()[2]));
 
           Gauss3D->Minimize();
           goodData = Gauss3D->Status();
           edm = Gauss3D->Edm();
       
           if (counterVx < minNentries) goodData = -2;
           else if (edm::isNotFinite(edm) == true) goodData = -1;
           else for (unsigned int j = 0; j < nParams; j++) if (edm::isNotFinite(Gauss3D->Errors()[j]) == true) { goodData = -1; break; }
           if (goodData == 0)
         {
           covyz = Gauss3D->X()[4]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[1])) - Gauss3D->X()[5]*Gauss3D->X()[3];
           covxz = Gauss3D->X()[5]*(std::fabs(Gauss3D->X()[2])-std::fabs(Gauss3D->X()[0])) - Gauss3D->X()[4]*Gauss3D->X()[3];
           
           det = std::fabs(Gauss3D->X()[0]) * (std::fabs(Gauss3D->X()[1])*std::fabs(Gauss3D->X()[2]) - covyz*covyz) -
             Gauss3D->X()[3] * (Gauss3D->X()[3]*std::fabs(Gauss3D->X()[2]) - covxz*covyz) +
             covxz * (Gauss3D->X()[3]*covyz - covxz*std::fabs(Gauss3D->X()[1]));
           if (det < 0.) { goodData = -1; if (internalDebug == true) cout << "Negative determinant !" << endl; }
         }
         } else break;
     }
 
       if (goodData == 0)
     for (unsigned int i = 0; i < nParams; i++)
       {
         vals->operator[](i) = Gauss3D->X()[i];
         vals->operator[](i+nParams) = Gauss3D->Errors()[i];
       }
       
       delete Gauss3D;
       return goodData;
     }
   
   return -1;
 }

void Vx3DHLTAnalyzer::reset ( std::string ResetType )

privatevirtual

Definition at line 551 of file Vx3DHLTAnalyzer.cc.

References convertSQLiteXML::runNumber, and Vertices.

 {
   if (ResetType.compare("scratch") == 0)
     {
       runNumber      = 0;
       numberGoodFits = 0;
       numberFits     = 0;
       lastLumiOfFit  = 0;
       
       Vx_X->Reset();
       Vx_Y->Reset();
       Vx_Z->Reset();
       
       Vx_ZX->Reset();
       Vx_ZY->Reset();
       Vx_XY->Reset();
       
       mXlumi->Reset();
       mYlumi->Reset();
       mZlumi->Reset();
 
       sXlumi->Reset();
       sYlumi->Reset();
       sZlumi->Reset();
 
       dxdzlumi->Reset();
       dydzlumi->Reset();
 
       hitCounter->Reset();
       hitCountHistory->Reset();
       goodVxCounter->Reset();
       goodVxCountHistory->Reset();
       fitResults->Reset();
 
       reportSummary->Fill(0.);
       reportSummaryMap->Fill(0.5, 0.5, 0.);
 
       Vertices.clear();
       
       lumiCounter      = 0;
       lumiCounterHisto = 0;
       totalHits        = 0;
       beginTimeOfFit   = 0;
       endTimeOfFit     = 0;
       beginLumiOfFit   = 0;
       endLumiOfFit     = 0;
     }
   else if (ResetType.compare("whole") == 0)
     {
       Vx_X->Reset();
       Vx_Y->Reset();
       Vx_Z->Reset();
       
       Vx_ZX->Reset();
       Vx_ZY->Reset();
       Vx_XY->Reset();
       
       Vertices.clear();
       
       lumiCounter      = 0;
       lumiCounterHisto = 0;
       totalHits        = 0;
       beginTimeOfFit   = 0;
       endTimeOfFit     = 0;
       beginLumiOfFit   = 0;
       endLumiOfFit     = 0;
     }
   else if (ResetType.compare("partial") == 0)
     {
       Vx_X->Reset();
       Vx_Y->Reset();
       Vx_Z->Reset();
       
       Vertices.clear();
       
       lumiCounter      = 0;
       totalHits        = 0;
       beginTimeOfFit   = 0;
       endTimeOfFit     = 0;
       beginLumiOfFit   = 0;
       endLumiOfFit     = 0;
     }
   else if (ResetType.compare("nohisto") == 0)
     {
       Vertices.clear();
       
       lumiCounter      = 0;
       lumiCounterHisto = 0;
       totalHits        = 0;
       beginTimeOfFit   = 0;
       endTimeOfFit     = 0;
       beginLumiOfFit   = 0;
       endLumiOfFit     = 0;
     }
   else if (ResetType.compare("hitCounter") == 0)
     totalHits          = 0;
 }

void Vx3DHLTAnalyzer::writeToFile	(	std::vector< double > *	vals,
		edm::TimeValue_t	BeginTimeOfFit,
		edm::TimeValue_t	EndTimeOfFit,
		unsigned int	BeginLumiOfFit,
		unsigned int	EndLumiOfFit,
		int	dataType
	)

privatevirtual

Definition at line 650 of file Vx3DHLTAnalyzer.cc.

References convertXMLtoSQLite_cfg::fileName, edm::service::formatTime(), NULL, dbtoconf::out, download_sqlite_cfg::outputFile, convertSQLiteXML::runNumber, and mathSSE::sqrt().

 {
   stringstream BufferString;
   BufferString.precision(5);
 
   outputFile.open(fileName.c_str(), ios::out);
 
   if ((outputFile.is_open() == true) && (vals != NULL) && (vals->size() == 8*2))
     {
       vector<double>::const_iterator it = vals->begin();
 
       outputFile << "Runnumber " << runNumber << endl;
       outputFile << "BeginTimeOfFit " << formatTime(beginTimeOfFit >> 32) << " " << (beginTimeOfFit >> 32) << endl;
       outputFile << "EndTimeOfFit " << formatTime(endTimeOfFit >> 32) << " " << (endTimeOfFit >> 32) << endl;
       outputFile << "LumiRange " << beginLumiOfFit << " - " << endLumiOfFit << endl;
       outputFile << "Type " << dataType << endl;
       // 3D Vertexing with Pixel Tracks:
       // Good data = Type  3
       // Bad data  = Type -1
 
       BufferString << *(it+0);
       outputFile << "X0 " << BufferString.str().c_str() << endl;
       BufferString.str("");
 
       BufferString << *(it+1);
       outputFile << "Y0 " << BufferString.str().c_str() << endl;
       BufferString.str("");
 
       BufferString << *(it+2);
       outputFile << "Z0 " << BufferString.str().c_str() << endl;
       BufferString.str("");
 
       BufferString << *(it+3);
       outputFile << "sigmaZ0 " << BufferString.str().c_str() << endl;
       BufferString.str("");
 
       BufferString << *(it+4);
       outputFile << "dxdz " << BufferString.str().c_str() << endl;
       BufferString.str("");
 
       BufferString << *(it+5);
       outputFile << "dydz " << BufferString.str().c_str() << endl;
       BufferString.str("");
 
       BufferString << *(it+6);
       outputFile << "BeamWidthX " << BufferString.str().c_str() << endl;
       BufferString.str("");
 
       BufferString << *(it+7);
       outputFile << "BeamWidthY " << BufferString.str().c_str() << endl;
       BufferString.str("");
 
       outputFile << "Cov(0,j) " << *(it+8) << " 0.0 0.0 0.0 0.0 0.0 0.0" << endl;
       outputFile << "Cov(1,j) 0.0 " << *(it+9) << " 0.0 0.0 0.0 0.0 0.0" << endl;
       outputFile << "Cov(2,j) 0.0 0.0 " << *(it+10) << " 0.0 0.0 0.0 0.0" << endl;
       outputFile << "Cov(3,j) 0.0 0.0 0.0 " << *(it+11) << " 0.0 0.0 0.0" << endl;
       outputFile << "Cov(4,j) 0.0 0.0 0.0 0.0 " << *(it+12) << " 0.0 0.0" << endl;
       outputFile << "Cov(5,j) 0.0 0.0 0.0 0.0 0.0 " << *(it+13) << " 0.0" << endl;
       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;
 
       outputFile << "EmittanceX 0.0" << endl;
       outputFile << "EmittanceY 0.0" << endl;
       outputFile << "BetaStar 0.0" << endl;
     }
   outputFile.close();
 
   if ((debugMode == true) && (outputDebugFile.is_open() == true) && (vals != NULL) && (vals->size() == 8*2))
     {
       vector<double>::const_iterator it = vals->begin();
 
       outputDebugFile << "Runnumber " << runNumber << endl;
       outputDebugFile << "BeginTimeOfFit " << formatTime(beginTimeOfFit >> 32) << " " << (beginTimeOfFit >> 32) << endl;
       outputDebugFile << "EndTimeOfFit " << formatTime(endTimeOfFit >> 32) << " " << (endTimeOfFit >> 32) << endl;
       outputDebugFile << "LumiRange " << beginLumiOfFit << " - " << endLumiOfFit << endl;
       outputDebugFile << "Type " << dataType << endl;
       // 3D Vertexing with Pixel Tracks:
       // Good data = Type  3
       // Bad data  = Type -1
       
       BufferString << *(it+0);
       outputDebugFile << "X0 " << BufferString.str().c_str() << endl;
       BufferString.str("");
       
       BufferString << *(it+1);
       outputDebugFile << "Y0 " << BufferString.str().c_str() << endl;
       BufferString.str("");
       
       BufferString << *(it+2);
       outputDebugFile << "Z0 " << BufferString.str().c_str() << endl;
       BufferString.str("");
       
       BufferString << *(it+3);
       outputDebugFile << "sigmaZ0 " << BufferString.str().c_str() << endl;
       BufferString.str("");
       
       BufferString << *(it+4);
       outputDebugFile << "dxdz " << BufferString.str().c_str() << endl;
       BufferString.str("");
       
       BufferString << *(it+5);
       outputDebugFile << "dydz " << BufferString.str().c_str() << endl;
       BufferString.str("");
       
       BufferString << *(it+6);
       outputDebugFile << "BeamWidthX " << BufferString.str().c_str() << endl;
       BufferString.str("");
       
       BufferString << *(it+7);
       outputDebugFile << "BeamWidthY " << BufferString.str().c_str() << endl;
       BufferString.str("");
       
       outputDebugFile << "Cov(0,j) " << *(it+8) << " 0.0 0.0 0.0 0.0 0.0 0.0" << endl;
       outputDebugFile << "Cov(1,j) 0.0 " << *(it+9) << " 0.0 0.0 0.0 0.0 0.0" << endl;
       outputDebugFile << "Cov(2,j) 0.0 0.0 " << *(it+10) << " 0.0 0.0 0.0 0.0" << endl;
       outputDebugFile << "Cov(3,j) 0.0 0.0 0.0 " << *(it+11) << " 0.0 0.0 0.0" << endl;
       outputDebugFile << "Cov(4,j) 0.0 0.0 0.0 0.0 " << *(it+12) << " 0.0 0.0" << endl;
       outputDebugFile << "Cov(5,j) 0.0 0.0 0.0 0.0 0.0 " << *(it+13) << " 0.0" << endl;
       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;
       
       outputDebugFile << "EmittanceX 0.0" << endl;
       outputDebugFile << "EmittanceY 0.0" << endl;
       outputDebugFile << "BetaStar 0.0" << endl;
     }
 }

Member Data Documentation

unsigned int Vx3DHLTAnalyzer::beginLumiOfFit

private

Definition at line 170 of file Vx3DHLTAnalyzer.h.

edm::TimeValue_t Vx3DHLTAnalyzer::beginTimeOfFit

private

Definition at line 158 of file Vx3DHLTAnalyzer.h.

bool Vx3DHLTAnalyzer::dataFromFit

private

Definition at line 109 of file Vx3DHLTAnalyzer.h.

bool Vx3DHLTAnalyzer::debugMode

private

Definition at line 107 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::dxdzlumi

private

Definition at line 131 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::dydzlumi

private

Definition at line 132 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::endLumiOfFit

private

Definition at line 171 of file Vx3DHLTAnalyzer.h.

edm::TimeValue_t Vx3DHLTAnalyzer::endTimeOfFit

private

Definition at line 159 of file Vx3DHLTAnalyzer.h.

std::string Vx3DHLTAnalyzer::fileName

private

Definition at line 117 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::fitResults

private

Definition at line 151 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::goodVxCounter

private

Definition at line 142 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::goodVxCountHistory

private

Definition at line 143 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::hitCounter

private

Definition at line 145 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::hitCountHistory

private

Definition at line 146 of file Vx3DHLTAnalyzer.h.

bool Vx3DHLTAnalyzer::internalDebug

private

Definition at line 174 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::lastLumiOfFit

private

Definition at line 172 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::lumiCounter

private

Definition at line 163 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::lumiCounterHisto

private

Definition at line 164 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::maxLumiIntegration

private

Definition at line 166 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::minNentries

private

Definition at line 110 of file Vx3DHLTAnalyzer.h.

double Vx3DHLTAnalyzer::minVxDoF

private

Definition at line 173 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::mXlumi

private

Definition at line 123 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::mYlumi

private

Definition at line 124 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::mZlumi

private

Definition at line 125 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::nBinsHistoricalPlot

private

Definition at line 160 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::nBinsWholeHistory

private

Definition at line 161 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::nLumiReset

private

Definition at line 108 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::numberFits

private

Definition at line 169 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::numberGoodFits

private

Definition at line 168 of file Vx3DHLTAnalyzer.h.

std::ofstream Vx3DHLTAnalyzer::outputDebugFile

private

Definition at line 157 of file Vx3DHLTAnalyzer.h.

std::ofstream Vx3DHLTAnalyzer::outputFile

private

Definition at line 156 of file Vx3DHLTAnalyzer.h.

edm::EDGetTokenT<SiPixelRecHitCollection> Vx3DHLTAnalyzer::pixelHitCollection

private

Definition at line 106 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::prescaleHistory

private

Definition at line 167 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::reportSummary

private

Definition at line 148 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::reportSummaryMap

private

Definition at line 149 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::runNumber

private

Definition at line 162 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::sXlumi

private

Definition at line 127 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::sYlumi

private

Definition at line 128 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::sZlumi

private

Definition at line 129 of file Vx3DHLTAnalyzer.h.

unsigned int Vx3DHLTAnalyzer::totalHits

private

Definition at line 165 of file Vx3DHLTAnalyzer.h.

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

private

Definition at line 105 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::Vx_X

private

Definition at line 134 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::Vx_XY

private

Definition at line 140 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::Vx_Y

private

Definition at line 135 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::Vx_Z

private

Definition at line 136 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::Vx_ZX

private

Definition at line 138 of file Vx3DHLTAnalyzer.h.

MonitorElement* Vx3DHLTAnalyzer::Vx_ZY

private

Definition at line 139 of file Vx3DHLTAnalyzer.h.

double Vx3DHLTAnalyzer::xRange

private

Definition at line 111 of file Vx3DHLTAnalyzer.h.

double Vx3DHLTAnalyzer::xStep

private

Definition at line 112 of file Vx3DHLTAnalyzer.h.

double Vx3DHLTAnalyzer::yRange

private

Definition at line 113 of file Vx3DHLTAnalyzer.h.

double Vx3DHLTAnalyzer::yStep

private

Definition at line 114 of file Vx3DHLTAnalyzer.h.

double Vx3DHLTAnalyzer::zRange

private

Definition at line 115 of file Vx3DHLTAnalyzer.h.

double Vx3DHLTAnalyzer::zStep

private

Definition at line 116 of file Vx3DHLTAnalyzer.h.

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation