#include <HLLHCEvtVtxGenerator.h>

Inheritance diagram for HLLHCEvtVtxGenerator:

Public Member Functions
TMatrixD const *	GetInvLorentzBoost () const override

	HLLHCEvtVtxGenerator (const edm::ParameterSet &p)

	HLLHCEvtVtxGenerator (const HLLHCEvtVtxGenerator &p)=delete

HepMC::FourVector	newVertex (CLHEP::HepRandomEngine *) const override
	return a new event vertex More...

HLLHCEvtVtxGenerator &	operator= (const HLLHCEvtVtxGenerator &rhs)=delete

	~HLLHCEvtVtxGenerator () override

Public Member Functions inherited from BaseEvtVtxGenerator
	BaseEvtVtxGenerator (const edm::ParameterSet &)

void	produce (edm::Event &, const edm::EventSetup &) override

	~BaseEvtVtxGenerator () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
double	integrandCC (double x, double z, double t) const

double	intensity (double x, double y, double z, double t) const

double	sigma (double z, double epsilon, double beta, double betagamma) const

Private Attributes
const double	alphax

const double	alphay

const double	beta

const double	betagamma

const double	bets

const double	betx

const double	epss

const double	epssn

const double	epsx

const double	epsxn

const double	fMeanX

const double	fMeanY

const double	fMeanZ

const double	fTimeOffset

const double	gamma

const double	momeV

const double	oncc

const double	phi

const double	phiCR

const bool	RF800

const double	sigs

const double	sigx

const double	wcc

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 26 of file HLLHCEvtVtxGenerator.h.

Constructor & Destructor Documentation

HLLHCEvtVtxGenerator::HLLHCEvtVtxGenerator ( const edm::ParameterSet & p )

Definition at line 51 of file HLLHCEvtVtxGenerator.cc.

     : BaseEvtVtxGenerator(p),
       fMeanX(p.getParameter<double>("MeanXIncm") * cm),
       fMeanY(p.getParameter<double>("MeanYIncm") * cm),
       fMeanZ(p.getParameter<double>("MeanZIncm") * cm),
       fTimeOffset(p.getParameter<double>("TimeOffsetInns") * ns * c_light),
       momeV(p.getParameter<double>("EprotonInGeV") * 1e9),
       gamma(momeV / pmass + 1.0),
       beta(std::sqrt((1.0 - 1.0 / gamma) * ((1.0 + 1.0 / gamma)))),
       betagamma(beta * gamma),
       phi(p.getParameter<double>("CrossingAngleInurad") * 1e-6),
       wcc(p.getParameter<double>("CrabFrequencyInMHz") * 1e6),
       RF800(p.getParameter<bool>("RF800")),
       betx(p.getParameter<double>("BetaCrossingPlaneInm")),
       bets(p.getParameter<double>("BetaSeparationPlaneInm")),
       epsxn(p.getParameter<double>("HorizontalEmittance")),
       epssn(p.getParameter<double>("VerticalEmittance")),
       sigs(p.getParameter<double>("BunchLengthInm")),
       alphax(p.getParameter<double>("CrabbingAngleCrossingInurad") * 1e-6),
       alphay(p.getParameter<double>("CrabbingAngleSeparationInurad") * 1e-6),
       oncc(alphax / phi),
       epsx(epsxn / (betagamma)),
       epss(epsx),
       sigx(std::sqrt(epsx * betx)),
       phiCR(oncc * phi)
 
 {}

HLLHCEvtVtxGenerator::HLLHCEvtVtxGenerator ( const HLLHCEvtVtxGenerator & p )

delete

Copy constructor

HLLHCEvtVtxGenerator::~HLLHCEvtVtxGenerator ( )

override

Definition at line 79 of file HLLHCEvtVtxGenerator.cc.

79 {}

Member Function Documentation

void HLLHCEvtVtxGenerator::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 29 of file HLLHCEvtVtxGenerator.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and submitPVResolutionJobs::desc.

                                                                                       {
   edm::ParameterSetDescription desc;
   desc.add<double>("MeanXIncm", 0.0);
   desc.add<double>("MeanYIncm", 0.0);
   desc.add<double>("MeanZIncm", 0.0);
   desc.add<double>("TimeOffsetInns", 0.0);
   desc.add<double>("EprotonInGeV", 7000.0);
   desc.add<double>("CrossingAngleInurad", 510.0);
   desc.add<double>("CrabbingAngleCrossingInurad", 380.0);
   desc.add<double>("CrabbingAngleSeparationInurad", 0.0);
   desc.add<double>("CrabFrequencyInMHz", 400.0);
   desc.add<bool>("RF800", false);
   desc.add<double>("BetaCrossingPlaneInm", 0.20);
   desc.add<double>("BetaSeparationPlaneInm", 0.20);
   desc.add<double>("HorizontalEmittance", 2.5e-06);
   desc.add<double>("VerticalEmittance", 2.05e-06);
   desc.add<double>("BunchLengthInm", 0.09);
   desc.add<edm::InputTag>("src");
   desc.add<bool>("readDB");
   descriptions.add("HLLHCEvtVtxGenerator", desc);
 }

TMatrixD const* HLLHCEvtVtxGenerator::GetInvLorentzBoost ( ) const

inlineoverridevirtual

This method - and the comment - is a left-over from COBRA-OSCAR time : return the last generated event vertex. If no vertex has been generated yet, a NULL pointer is returned.

Implements BaseEvtVtxGenerator.

Definition at line 43 of file HLLHCEvtVtxGenerator.h.

43 { return nullptr; };

double HLLHCEvtVtxGenerator::integrandCC	(	double	x,
		double	z,
		double	t
	)		const

private

Definition at line 146 of file HLLHCEvtVtxGenerator.cc.

References bets, betx, funct::cos(), funct::exp(), isotrackApplyRegressor::k, relval_steps::k2, local_c_light, phi, phiCR, mps_fire::result, RF800, alignCSCRings::s, sigs, sigx, funct::sin(), mathSSE::sqrt(), wcc, and z.

Referenced by intensity().

                                                                             {
   constexpr double local_c_light = 2.99792458e8;
 
   const double k = wcc / local_c_light * two_pi;
   const double k2 = k * k;
   const double cos = std::cos(phi / 2.0);
   const double sin = std::sin(phi / 2.0);
   const double cos2 = cos * cos;
   const double sin2 = sin * sin;
 
   const double sigx2 = sigx * sigx;
   const double sigmax2 = sigx2 * (1 + z * z / (betx * betx));
 
   const double sigs2 = sigs * sigs;
 
   constexpr double factorRMSgauss4 =
       1. / sqrt2 / gamma34 * gamma14;  // # Factor to take rms sigma as input of the supergaussian
   constexpr double NormFactorGauss4 = sqrt2to5 * gamma54 * gamma54;
 
   const double sinCR = std::sin(phiCR / 2.0);
   const double sinCR2 = sinCR * sinCR;
 
   double result = -1.0;
 
   if (!RF800) {
     const double norm = 2.0 / (two_pi * sigs2);
     const double cosks = std::cos(k * z);
     const double sinkct = std::sin(k * ct);
     result = norm *
              std::exp(-ct * ct / sigs2 - z * z * cos2 / sigs2 -
                       1.0 / (4 * k2 * sigmax2) *
                           (
                               //-4*cosks*cosks * sinkct*sinkct * sinCR2 // comes from integral over x
                               -8 * z * k * std::sin(k * z) * std::cos(k * ct) * sin * sinCR + 2 * sinCR2 -
                               std::cos(2 * k * (z - ct)) * sinCR2 - std::cos(2 * k * (z + ct)) * sinCR2 +
                               4 * k2 * z * z * sin2) -
                       x * x * (cos2 / sigmax2 + sin2 / sigs2)               // contribution from x integrand
                       + x * ct * sin / sigs2                                // contribution from x integrand
                       + 2 * x * cos * cosks * sinkct * sinCR / k / sigmax2  // contribution from x integrand
                       //+(2*ct/k)*np.cos(k*s)*np.sin(k*ct) *(sin*sinCR)/(sigs2*cos)  # small term
                       //+ct**2*(sin2/sigs4)/(cos2/sigmax2)                            # small term
                       ) /
              (1.0 + (z * z) / (betx * betx)) / std::sqrt(1.0 + (z * z) / (bets * bets));
 
   } else {
     const double norm = 2.0 / (NormFactorGauss4 * sigs2 * factorRMSgauss4);
     const double sigs4 = sigs2 * sigs2 * factorRMSgauss4 * factorRMSgauss4;
     const double cosks = std::cos(k * z);
     const double sinct = std::sin(k * ct);
     result =
         norm *
         std::exp(-ct * ct * ct * ct / sigs4 - z * z * z * z * cos2 * cos2 / sigs4 - 6 * ct * ct * z * z * cos2 / sigs4 -
                  sin2 / (4 * k2 * sigmax2) *
                      (2 + 4 * k2 * z * z - std::cos(2 * k * (z - ct)) - std::cos(2 * k * (z + ct)) -
                       8 * k * s * std::cos(k * ct) * std::sin(k * z) - 4 * cosks * cosks * sinct * sinct)) /
         std::sqrt(1 + z * z / (betx * betx)) / std::sqrt(1 + z * z / (bets * bets));
   }
 
   return result;
 }

double HLLHCEvtVtxGenerator::intensity	(	double	x,
		double	y,
		double	z,
		double	t
	)		const

private

Definition at line 126 of file HLLHCEvtVtxGenerator.cc.

References alphay, betagamma, bets, c, funct::cos(), PVValHelper::dy, epssn, funct::exp(), integrandCC(), sigma(), funct::sin(), submitPVValidationJobs::t, and wcc.

Referenced by newVertex().

                                                                                    {
   //---c in m/s --- remember t is already in meters
   constexpr double c = 2.99792458e+8;  // m/s
 
   const double sigmay = sigma(z, epssn, bets, betagamma);
 
   const double alphay_mod = alphay * std::cos(wcc * (z - t) / c);
 
   const double cay = std::cos(alphay_mod);
   const double say = std::sin(alphay_mod);
 
   const double dy = -(z - t) * say - y * cay;
 
   const double xzt_density = integrandCC(x, z, t);
 
   const double norm = two_pi * sigmay;
 
   return (std::exp(-dy * dy / (sigmay * sigmay)) * xzt_density / norm);
 }

HepMC::FourVector HLLHCEvtVtxGenerator::newVertex ( CLHEP::HepRandomEngine * engine ) const

overridevirtual

return a new event vertex

Implements BaseEvtVtxGenerator.

Definition at line 81 of file HLLHCEvtVtxGenerator.cc.

References betagamma, bets, betx, submitPVResolutionJobs::count, epssn, epsxn, fMeanX, fMeanY, fMeanZ, fTimeOffset, mps_fire::i, intensity(), sigma(), sigs, submitPVValidationJobs::t, x, y, and z.

                                                                                   {
   double imax = intensity(0., 0., 0., 0.);
 
   double x(0.), y(0.), z(0.), t(0.), i(0.);
 
   int count = 0;
 
   auto shoot = [&]() { return CLHEP::RandFlat::shoot(engine); };
 
   do {
     z = (shoot() - 0.5) * 6.0 * sigs;
     t = (shoot() - 0.5) * 6.0 * sigs;
     x = (shoot() - 0.5) * 12.0 * sigma(0.0, epsxn, betx, betagamma);
     y = (shoot() - 0.5) * 12.0 * sigma(0.0, epssn, bets, betagamma);
 
     i = intensity(x, y, z, t);
 
     if (i > imax)
       edm::LogError("Too large intensity") << "i>imax : " << i << " > " << imax << endl;
     ++count;
   } while ((i < imax * shoot()) && count < 10000);
 
   if (count > 9999)
     edm::LogError("Too many tries ") << " count : " << count << endl;
 
   //---convert to mm
   x *= 1000.0;
   y *= 1000.0;
   z *= 1000.0;
   t *= 1000.0;
 
   x += fMeanX;
   y += fMeanY;
   z += fMeanZ;
   t += fTimeOffset;
 
   return HepMC::FourVector(x, y, z, t);
 }

HLLHCEvtVtxGenerator& HLLHCEvtVtxGenerator::operator= ( const HLLHCEvtVtxGenerator & rhs )

delete

Copy assignment operator

double HLLHCEvtVtxGenerator::sigma	(	double	z,
		double	epsilon,
		double	beta,
		double	betagamma
	)		const

private

Definition at line 120 of file HLLHCEvtVtxGenerator.cc.

References mathSSE::sqrt().

Referenced by intensity(), and newVertex().

                                                                                                 {
   double sigma = std::sqrt(epsilon * (beta + z * z / beta) / betagamma);
 
   return sigma;
 }

Member Data Documentation

const double HLLHCEvtVtxGenerator::alphax

private

Definition at line 80 of file HLLHCEvtVtxGenerator.h.

const double HLLHCEvtVtxGenerator::alphay

private

Definition at line 83 of file HLLHCEvtVtxGenerator.h.

Referenced by intensity().

const double HLLHCEvtVtxGenerator::beta

private

Definition at line 52 of file HLLHCEvtVtxGenerator.h.

const double HLLHCEvtVtxGenerator::betagamma

private

Definition at line 53 of file HLLHCEvtVtxGenerator.h.

Referenced by intensity(), and newVertex().

const double HLLHCEvtVtxGenerator::bets

private

Definition at line 68 of file HLLHCEvtVtxGenerator.h.

Referenced by integrandCC(), intensity(), and newVertex().

const double HLLHCEvtVtxGenerator::betx

private

Definition at line 65 of file HLLHCEvtVtxGenerator.h.

Referenced by integrandCC(), and newVertex().

const double HLLHCEvtVtxGenerator::epss

private

Definition at line 92 of file HLLHCEvtVtxGenerator.h.

const double HLLHCEvtVtxGenerator::epssn

private

Definition at line 74 of file HLLHCEvtVtxGenerator.h.

Referenced by intensity(), and newVertex().

const double HLLHCEvtVtxGenerator::epsx

private

Definition at line 89 of file HLLHCEvtVtxGenerator.h.

const double HLLHCEvtVtxGenerator::epsxn

private

Definition at line 71 of file HLLHCEvtVtxGenerator.h.

Referenced by newVertex().

const double HLLHCEvtVtxGenerator::fMeanX

private

Definition at line 43 of file HLLHCEvtVtxGenerator.h.

Referenced by newVertex().

const double HLLHCEvtVtxGenerator::fMeanY

private

Definition at line 43 of file HLLHCEvtVtxGenerator.h.

Referenced by newVertex().

const double HLLHCEvtVtxGenerator::fMeanZ

private

Definition at line 43 of file HLLHCEvtVtxGenerator.h.

Referenced by newVertex().

const double HLLHCEvtVtxGenerator::fTimeOffset

private

Definition at line 43 of file HLLHCEvtVtxGenerator.h.

Referenced by newVertex().

const double HLLHCEvtVtxGenerator::gamma

private

Definition at line 51 of file HLLHCEvtVtxGenerator.h.

const double HLLHCEvtVtxGenerator::momeV

private

Definition at line 50 of file HLLHCEvtVtxGenerator.h.

const double HLLHCEvtVtxGenerator::oncc

private

Definition at line 86 of file HLLHCEvtVtxGenerator.h.

const double HLLHCEvtVtxGenerator::phi

private

Definition at line 56 of file HLLHCEvtVtxGenerator.h.

Referenced by Particle.Particle::__str__(), integrandCC(), and ntupleDataFormat.Track::phiPull().

const double HLLHCEvtVtxGenerator::phiCR

private

Definition at line 98 of file HLLHCEvtVtxGenerator.h.

Referenced by integrandCC().

const bool HLLHCEvtVtxGenerator::RF800

private

Definition at line 62 of file HLLHCEvtVtxGenerator.h.

Referenced by integrandCC().

const double HLLHCEvtVtxGenerator::sigs

private

Definition at line 77 of file HLLHCEvtVtxGenerator.h.

Referenced by integrandCC(), and newVertex().

const double HLLHCEvtVtxGenerator::sigx

private

Definition at line 95 of file HLLHCEvtVtxGenerator.h.

Referenced by integrandCC().

const double HLLHCEvtVtxGenerator::wcc

private

Definition at line 59 of file HLLHCEvtVtxGenerator.h.

Referenced by integrandCC(), and intensity().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation