DybShuffle.cc

Go to the documentation of this file.

//Author: Johnny Goett - 2 SEP 2008
//
// Set the earliest and latest of RndmHead to GetBOT, 0.
// Zhe Wang, Feb 9, 2009
// bv@bnl.gov, seed ROOT's randoms. Thu Mar 17 13:13:29 2011

#include "DybShuffle.h"
#include "GaudiKernel/IRndmEngine.h"

#include "TRandom.h"

#include <boost/functional/hash.hpp>

#include <bitset>


DybShuffle::DybShuffle(const std::string& name, ISvcLocator* pSvcLocator) 
    : DybAlgorithm<DayaBay::RandomHeader>(name, pSvcLocator)
    , m_hostid(0)
    , m_run(1)
    , m_countOffset(0)
    , m_burnCount(100)
    , m_dohash(true)
{
  // Part 1: Declare the properties
  declareProperty("HostID", m_hostid, "The systems Host 'ID'entification number");
  declareProperty("Run",m_run,"The run number");
  declareProperty("ExecCountOffset",m_countOffset,"Number to add to the execution count");
  declareProperty("BurnCount",m_burnCount,"Number of random numbers to burn with a new seed");
  declareProperty("SeedVec", m_seedvec, "Random seed vector manually");
  declareProperty("Hash", m_dohash, "Hash the seed");
}

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 

StatusCode DybShuffle::initialize(){
  
  // Part 1: Print where you are
  verbose() << " DybShuffle initialize()" << endreq;

  //Retrieve Engine and write to Header
  m_rndSvc = randSvc();
  m_engine = m_rndSvc->engine();

  IProperty* prop=0;
  StatusCode sc = m_rndSvc->queryInterface(IProperty::interfaceID(),(void**)&prop);
  if (sc.isFailure()) return sc;

  m_engineName = prop->getProperty("Engine").toString();
  
  if (m_uni.initialize(m_rndSvc, Rndm::Flat(0,1)).isFailure()) {
    fatal() << "Failed to initialize uniform random numbers" << endreq;
    return StatusCode::FAILURE;
  }

  this->seed();

  return StatusCode::SUCCESS;
}

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 

StatusCode DybShuffle::execute() {
  
  verbose() << "DybShuffle execute()" << endreq;

  //make output header object
  DayaBay::RandomHeader* RndmHead = MakeHeaderObject();

  // wangzhe
  // Here the time stamps of earliest and latest are set to zero explicitly
  RndmHead->setEarliest(TimeStamp::GetBOT());
  RndmHead->setLatest(TimeStamp::GetBOT());
  // wz

  RndmHead->setHEPEngine(m_engineName);
  
  // Don't re-set the seed on first execution as this was done in initialize()
  if (this->getExecNum() > 1) {
    std::vector<long> NewSeeds = this->seed();
    RndmHead->setRndmSeeds(NewSeeds);
  }

  return StatusCode::SUCCESS;
}

std::vector<long> DybShuffle::seed()
{

  std::vector<long> NewSeeds;
  std::vector<long> CurrSeeds;
  
  if(m_seedvec.size())
  {
    NewSeeds=m_seedvec;
  }

  else
  {

    //Determine and set seed(s).... some generators use more than one seed.
    if (m_hostid == 0)
    {
        m_hostid = (long) gethostid();
    }

    std::bitset<32> a ((long) 0);
    std::bitset<32> site ((long) 0);
    std::bitset<32> run ((long) 0);
    std::bitset<32> evt ((long) 0);
    std::bitset<32> seed ((long) 0);

    site = (long)m_hostid;
    run = m_run;

    //iterations on MakeHeader().... or, how many times this execute
    // method has been called.  Plus offset in order to reproduce
    // isolated execution cycle.
    evt = m_countOffset + this->getExecNum();

    for ( int i = 32-1-1; i >= 0 ; i-- )
    {
      if ( run.test(i) ) a.set(31-1-i) ;
    }

    seed = (a|evt)^site;
    // set highest bit to zero to avoid negative seed
    if ( seed.test(31) ) seed.reset(31);
    int MySeed = seed.to_ulong();

    if (m_dohash) {
      boost::hash<int> hasher;
      MySeed = hasher(MySeed);
    }

    NewSeeds.push_back(MySeed);

    debug () << "Run " << m_run 
            << ", exec# = " << evt.to_ulong()
            << ", host = " << (void*)site.to_ulong() 
            << ", seeds:";
    std::vector<long>::iterator it, done = NewSeeds.end();
    for (it=NewSeeds.begin(); it != done; ++it) {
      debug () << " " << *it;
    }
    debug () << endreq;

  }


  m_engine->setSeeds(NewSeeds);
  m_engine->seeds(CurrSeeds);
  gRandom->SetSeed(NewSeeds[0]);
  
  // now that the new seeds are set, burn some random numbers (to avoid correlations)
  int irndm;
  double b;
  for(irndm=0;irndm<m_burnCount;irndm++)
  {
    b=m_uni();
  }

  return NewSeeds;
}

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 

StatusCode DybShuffle::finalize() {
  
  // Part 1: Print where you are
  verbose() << "DybShuffle finalize()" << endreq;
  
  return StatusCode::SUCCESS;
}

// Local Variables: **
// c-basic-offset:2 **
// indent-tabs-mode:nil **
// End: **