#include <HLLHCEvtVtxGenerator.h>

Inheritance diagram for HLLHCEvtVtxGenerator:

Public Member Functions
TMatrixD const *	GetInvLorentzBoost () const override

	HLLHCEvtVtxGenerator (const edm::ParameterSet &p)

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

	~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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
	HLLHCEvtVtxGenerator (const HLLHCEvtVtxGenerator &p)=delete

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

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

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

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<>
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::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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 26 of file HLLHCEvtVtxGenerator.h.

Constructor & Destructor Documentation

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

Definition at line 53 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 ( )

override

Definition at line 83 of file HLLHCEvtVtxGenerator.cc.

84 {

85 }

HLLHCEvtVtxGenerator::HLLHCEvtVtxGenerator ( const HLLHCEvtVtxGenerator & p )

privatedelete

Copy constructor

Member Function Documentation

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

static

Definition at line 30 of file HLLHCEvtVtxGenerator.cc.

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

 {
     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 39 of file HLLHCEvtVtxGenerator.h.

39 {return nullptr;};

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

private

Definition at line 161 of file HLLHCEvtVtxGenerator.cc.

References bets, betx, constexpr, funct::cos(), JetChargeProducer_cfi::exp, gen::k, 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 137 of file HLLHCEvtVtxGenerator.cc.

References alphay, betagamma, bets, EnergyCorrector::c, constexpr, funct::cos(), PVValHelper::dy, epssn, JetChargeProducer_cfi::exp, integrandCC(), sigma(), funct::sin(), lumiQTWidget::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 88 of file HLLHCEvtVtxGenerator.cc.

References betagamma, bets, betx, KineDebug3::count(), epssn, epsxn, fMeanX, fMeanY, fMeanZ, fTimeOffset, mps_fire::i, intensity(), sigma(), sigs, lumiQTWidget::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 )

privatedelete

Copy assignment operator

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

private

Definition at line 130 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 82 of file HLLHCEvtVtxGenerator.h.

const double HLLHCEvtVtxGenerator::alphay

private

Definition at line 85 of file HLLHCEvtVtxGenerator.h.

Referenced by intensity().

const double HLLHCEvtVtxGenerator::beta

private

Definition at line 54 of file HLLHCEvtVtxGenerator.h.

const double HLLHCEvtVtxGenerator::betagamma

private

Definition at line 55 of file HLLHCEvtVtxGenerator.h.

Referenced by intensity(), and newVertex().

const double HLLHCEvtVtxGenerator::bets

private

Definition at line 70 of file HLLHCEvtVtxGenerator.h.

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

const double HLLHCEvtVtxGenerator::betx

private

Definition at line 67 of file HLLHCEvtVtxGenerator.h.

Referenced by integrandCC(), and newVertex().

const double HLLHCEvtVtxGenerator::epss

private

Definition at line 94 of file HLLHCEvtVtxGenerator.h.

const double HLLHCEvtVtxGenerator::epssn

private

Definition at line 76 of file HLLHCEvtVtxGenerator.h.

Referenced by intensity(), and newVertex().

const double HLLHCEvtVtxGenerator::epsx

private

Definition at line 91 of file HLLHCEvtVtxGenerator.h.

const double HLLHCEvtVtxGenerator::epsxn

private

Definition at line 73 of file HLLHCEvtVtxGenerator.h.

Referenced by newVertex().

const double HLLHCEvtVtxGenerator::fMeanX

private

Definition at line 49 of file HLLHCEvtVtxGenerator.h.

Referenced by newVertex().

const double HLLHCEvtVtxGenerator::fMeanY

private

Definition at line 49 of file HLLHCEvtVtxGenerator.h.

Referenced by newVertex().

const double HLLHCEvtVtxGenerator::fMeanZ

private

Definition at line 49 of file HLLHCEvtVtxGenerator.h.

Referenced by newVertex().

const double HLLHCEvtVtxGenerator::fTimeOffset

private

Definition at line 49 of file HLLHCEvtVtxGenerator.h.

Referenced by newVertex().

const double HLLHCEvtVtxGenerator::gamma

private

Definition at line 53 of file HLLHCEvtVtxGenerator.h.

const double HLLHCEvtVtxGenerator::momeV

private

Definition at line 52 of file HLLHCEvtVtxGenerator.h.

const double HLLHCEvtVtxGenerator::oncc

private

Definition at line 88 of file HLLHCEvtVtxGenerator.h.

const double HLLHCEvtVtxGenerator::phi

private

Definition at line 58 of file HLLHCEvtVtxGenerator.h.

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

const double HLLHCEvtVtxGenerator::phiCR

private

Definition at line 100 of file HLLHCEvtVtxGenerator.h.

Referenced by integrandCC().

const bool HLLHCEvtVtxGenerator::RF800

private

Definition at line 64 of file HLLHCEvtVtxGenerator.h.

Referenced by integrandCC().

const double HLLHCEvtVtxGenerator::sigs

private

Definition at line 79 of file HLLHCEvtVtxGenerator.h.

Referenced by integrandCC(), and newVertex().

const double HLLHCEvtVtxGenerator::sigx

private

Definition at line 97 of file HLLHCEvtVtxGenerator.h.

Referenced by integrandCC().

const double HLLHCEvtVtxGenerator::wcc

private

Definition at line 61 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