ATHRNG Namespace Reference

Classes
class	RNGWrapper
	A wrapper class for event-slot-local random engines. More...

Functions
size_t	calculateSeedMC16 (const std::string &algName, uint64_t ev, uint64_t run, uint32_t offset=0)
	Helper methods. More...
size_t	calculateSeedMC20 (const std::string &algName, uint64_t ev, uint64_t run)
	Set the random seed using a string (e.g. More...
void	calculateSeedsMC21 (long *seeds, const std::string &algName, uint64_t ev, uint64_t run, uint64_t offset=0)
	Set the random seed using a string (e.g. More...
long	calculateSeedsPython (const std::string &algName, uint64_t ev, uint64_t run, uint64_t offset=0)

Function Documentation

calculateSeedMC16()

size_t ATHRNG::calculateSeedMC16	(	const std::string &	algName,
		uint64_t	ev,
		uint64_t	run,
		uint32_t	offset = 0
	)

Helper methods.

Set the random seed using a string (e.g.

Set the random seed using a string (e.g. algorithm name) and the current slot, event, and run numbers and an optional offset. - MC16 Legacy Version attempting to reproduce seeds from thread-unsafe random number services

algorithm name) and the current slot, event, and run numbers and an optional offset. - MC16 Legacy Version attempting to reproduce seeds from thread-unsafe random number services

Definition at line 15 of file RNGWrapper.cxx.

                                                                                                     {
  uint32_t theHash = static_cast<uint32_t>(ev);
  if (0 != offset) theHash=crc_combine(theHash, offset);
  uint32_t runNumber = static_cast<uint32_t>(run);
  theHash=crc_combine(theHash, runNumber);
  theHash=crc_combine(theHash, algName);
  return theHash;
}

calculateSeedMC20()

size_t ATHRNG::calculateSeedMC20	(	const std::string &	algName,
		uint64_t	ev,
		uint64_t	run
	)

Set the random seed using a string (e.g.

algorithm name) and the current slot, event, and run numbers. MC20 seeding algorithm

Definition at line 26 of file RNGWrapper.cxx.

                                                                                    {
  auto algHash = std::hash<std::string>{}(algName);
  auto evHash = std::hash<uint64_t>{}(ev);
  auto runHash = std::hash<uint64_t>{}(run);
  auto hsh = evHash ^ (runHash + (evHash << 6) + (evHash >> 2));
  hsh = hsh ^ (algHash + (hsh << 6) + (hsh >> 2));
  return hsh;
}

calculateSeedsMC21()

void ATHRNG::calculateSeedsMC21	(	long *	seeds,
		const std::string &	algName,
		uint64_t	ev,
		uint64_t	run,
		uint64_t	offset = 0
	)

Set the random seed using a string (e.g.

algorithm name) and the current slot, event, and run numbers. MC21 seeding algorithm

Definition at line 37 of file RNGWrapper.cxx.

                                                                                                                 {
  //RanecuEngine only takes the first seed, so the first seed should be good on it's own
  //using 64bit crc which is already performing quite well on it's own
  uint64_t theHash = CxxUtils::crc64(algName);
  theHash = CxxUtils::crc64addint(theHash,ev);
  theHash = CxxUtils::crc64addint(theHash,offset);
  theHash = CxxUtils::crc64addint(theHash,run);
 
  size_t iseed=0;
  seeds[iseed]=(long)theHash; //CLHEP takes a zero terminated array for seeding. Avoid 0
  if(seeds[iseed]!=0) ++iseed; //if zero, make the seed vector shorter, which should in itself already cause a different seeding
  seeds[iseed]=(long)ev; //CLHEP takes a zero terminated array for seeding. Avoid ev==0
  if(seeds[iseed]!=0) ++iseed; //Avoid 0
  seeds[iseed]=(long)(ev >> 32); //explicitly split out the upper 32bit as dSFMTEngine only takes 32bits. 
  if(seeds[iseed]!=0) ++iseed; //Avoid 0
  seeds[iseed]=(long)run; 
  if(seeds[iseed]!=0) ++iseed; //Avoid 0
  uint64_t algHash = CxxUtils::MurmurHash64A ( algName.data(), algName.size(), 0 );
  seeds[iseed]=(long)algHash;
  if(seeds[iseed]!=0) ++iseed; //Avoid 0
  seeds[iseed]=(long)offset; 
  if(seeds[iseed]!=0) ++iseed; //Avoid 0
  seeds[iseed]=0; //CLHEP takes a zero terminated array for seeding, so end with 0
  return;
}

calculateSeedsPython()

long ATHRNG::calculateSeedsPython	(	const std::string &	algName,
		uint64_t	ev,
		uint64_t	run,
		uint64_t	offset = 0
	)

Definition at line 63 of file RNGWrapper.cxx.

                                                                                                      {
  long seeds[7];
  calculateSeedsMC21(seeds, algName, ev, run, offset);
  return seeds[0];
}