In This Package:

MixRootIOCnvSvc.cc

Go to the documentation of this file.

#include "MixRootIOCnvSvc.h"
#include "Event/RunHeader.h"
#include "Event/SimReadoutHeader.h"
#include "Event/RegistrationSequence.h"
#include "PerReadoutEvent/PerReadoutHeader.h"
#include "PerReadoutEvent/PerSimReadoutHeader.h"
#include "PerReadoutEvent/PerSimReadout.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "RootIOSvc/RootIOBaseCnv.h"
#include "GaudiKernel/IRndmGen.h"
#include "GaudiKernel/IRndmEngine.h"
#include "GaudiKernel/IRndmGenSvc.h"
#include "PerReadoutEvent/PerReadoutPmtCrate.h"

MixRootIOCnvSvc::MixRootIOCnvSvc(const string& name, ISvcLocator* svc)
                :RootIOCnvSvc(name, svc),/* m_ranSvc(0),*/ m_log(msgSvc(), "MixRootIOCnvSvc")
{
  declareProperty("SampleInputs" , m_inputSamples   , "Map of sample input files");
  declareProperty("SampleTaus"   , m_timeTau        , "Map of sample Tau");
  //declareProperty("SampleFileNum", m_fileEntryNum   , "Map of sample input files' numbers");
  declareProperty("MixingTime"   , m_days           , "Mix time window");
  declareProperty("BeginTime"    , m_lasttime = 0.0 , "Begin time");
  //declareProperty("RandomSeed"   , m_randomSeed     , "Random Seed of Mixing");
}

MixRootIOCnvSvc::~MixRootIOCnvSvc()
{
  m_log<< MSG::DEBUG<< "~MixRootIOCnvSvc()"<< endreq;
  
  delete m_firstBuffer;
  delete m_secondBuffer;
  delete m_tesBuffer;
}

StatusCode MixRootIOCnvSvc::initialize() 
{
  m_log<< MSG::DEBUG<< "initializing @"<< (void*)this<< endreq;
  StatusCode sc = RootIOCnvSvc::initialize();
  if(sc.isFailure()) 
  {
    m_log<< MSG::ERROR<< "parent class failed to initialize"<< endreq;
    return sc;
  }
  
  //m_randomNum.SetSeed(m_randomSeed);
  /*sc = service("RndmGenSvc", m_ranSvc, true);
  if(sc.isFailure())
  {
    m_log<< MSG::ERROR<< "Unable get RndmGenSvc service"<< m_ranSvc<< endreq;
    return sc;
    }*/

  sc = doInit();
  if(sc.isFailure())
  {
    m_log<< MSG::ERROR<< "Something Wrong before mixing."<<endreq;
    return sc;
  }
  return sc;
}

StatusCode MixRootIOCnvSvc::doInit()
{
  m_log<< MSG::DEBUG<< "reset some variables at begining."<< endreq;
  if(m_inputSamples.size() != m_timeTau.size() || m_timeTau.size() == 0) 
  {
    return StatusCode::FAILURE;
  }
  else
  {
    map<string, double>::iterator itt, tend = m_timeTau.end();
    map<string, vector<string> >::iterator iter; 
    for(itt = m_timeTau.begin(); itt != tend; itt++) 
    {
      iter = m_inputSamples.find(itt->first);
      if(iter == m_inputSamples.end()) 
      {
        m_log<< MSG::DEBUG<< "Configuration is not correct for mixing"<< endreq;
        return StatusCode::FAILURE;
      }
      m_fileNum[itt->first]       = 0;
      m_fileindex[itt->first]     = 0;
      m_fileentries[itt->first]   = 0;
      m_fileEntryNum[itt->first]  = 0;
      m_streamentries[itt->first] = 0;
    }
    m_maintau  = 0.0;
    m_maximum  = 0.0;
    TimeStamp  lastTime(m_lasttime);
    m_lastTime = lastTime;
  }
  return StatusCode::SUCCESS;
}

StatusCode MixRootIOCnvSvc::queryInterface(const InterfaceID& riid, void** ppint)
{
  if(IID_IMixingSvc.versionMatch(riid)) 
  {
    m_log<< MSG::DEBUG<< "queryInterface("<<riid<<")-->(IMixingSvc*)"<< (void*)this<< endreq;
    *ppint = (IMixingSvc*)this;
  }
  else 
  {
    return RootIOCnvSvc::queryInterface(riid, ppint);
  }
  addRef();
  return StatusCode::SUCCESS;
}

StatusCode MixRootIOCnvSvc::buildStream()
{
  m_log<< MSG::DEBUG<< "BuildStream"<< endreq;
  if(m_sampleInputStreamMap.size() == 0) 
  {
    m_log<< MSG::INFO<< "Building Streams from mixing sources."<< endreq;
    map<string,vector<string> >::iterator miter, mbegin, mend;
    mbegin = m_inputSamples.begin();
    mend   = m_inputSamples.end();
    m_log<< MSG::INFO<< "Initialize the MixBuffer here."<< endreq;
    
    // Initialize the files of each sample
    for(miter = mbegin; miter != mend; miter++) 
    {
      m_inputStreamMap.clear();

      vector<string> files = (*miter).second;
      setInputFiles(files);
      doInitialize();

      m_sampleInputStreamMap[(*miter).first] = inputStreams();
      m_simROMap[(*miter).first] = m_inputStreamMap[DayaBay::SimReadoutHeaderLocation::Default];
    }

    // Initialize the file numbers of each sample
    for(miter = mbegin; miter != mend; miter++)
    {
      int filenum = 0;
      vector<string> files = miter->second;
      for(vector<string>::iterator vit = files.begin(); vit != files.end(); vit++)
      {
        filenum++;
      }
      m_fileNum[miter->first] = filenum;
    }

    // Initialize the file index, file entry and stream entry for each sample
    for(map<string, RootInputStream*>::iterator it = m_simROMap.begin(); it != m_simROMap.end(); it++)
    {
      RootInputStream* ris       = it->second;
      //m_fileindex[it->first]     = flatdis((double)ris->getFiles().size());
      m_fileindex[it->first]     = flatdis((double)m_fileNum[it->first]);
      bool ifjump                = ris->getFiles().jump(m_fileindex[it->first]);
      if(ifjump == false)
      {
        m_log<< MSG::ERROR<< "Can't jump to the specified file!"<< endreq;
        return StatusCode::FAILURE;
      }
      m_fileEntryNum[it->first]  = ris->getFiles().current()->entries();
      m_fileentries[it->first]   = flatdis((double)m_fileEntryNum[it->first]);

      m_log<< MSG::INFO<< "Now needing to jump to "<< it->first<< ": "<< m_fileindex[it->first]<< ".root file"<< endreq;
      m_log<< MSG::INFO<< "Now the file entry is: "<< m_fileentries[it->first]<< endreq;
      m_log<< MSG::INFO<< "Now the file total entries is: "<< m_fileEntryNum[it->first]<< endreq;

      ris->setFileEntry(m_fileindex[it->first], m_fileentries[it->first], true);
      //m_log<< MSG::INFO<< "RootInputStream: "<< ris<< endreq;
      m_streamentries[it->first] = ris->getEntry();
      //m_log<< MSG::INFO<< "Get the RootInputStream entry."<< endreq;
    }

    //m_log<< MSG::INFO<< "Here."<< endreq;
    // Initialize the mix buffer
    m_tesBuffer    = new deque<MixHeader>();
    m_firstBuffer  = new deque<MixHeader>();
    m_secondBuffer = new deque<MixHeader>();
    //print();

    m_log<< MSG::INFO<< "TESBuffer Size    = "<< m_tesBuffer->size()<< endreq;
    m_log<< MSG::INFO<< "FirstBuffer Size  = "<< m_firstBuffer->size()<< endreq;
    m_log<< MSG::INFO<< "SecondBuffer Size = "<< m_secondBuffer->size()<< endreq;
    m_log<< MSG::INFO<< "SteamMap Size     = "<< m_sampleInputStreamMap.size()<< "/"<< m_simROMap.size()<< endreq;
    
    // Initialize the maintau, the time nod by the samples
    for(map<string, RootInputStream*>::iterator mit = m_simROMap.begin(); mit != m_simROMap.end(); mit++)
    { 
      m_maintau += 1/m_timeTau[mit->first];
      m_nod[mit->first] = m_maintau;
      m_log<< MSG::INFO<< "m_nod["<< mit->first<< "] is: "<< m_nod[mit->first]<< endreq;
      m_maximum  = m_maintau;
    }
    m_maintau = 1/m_maintau;
    m_log<< MSG::INFO<< "The main tau is: "<< m_maintau<< endreq;

    m_totalentries = m_days*86400.0/m_maintau;
    m_log<< MSG::INFO<< "The Total entries are: "<< m_totalentries<< endreq;
  }

  //if (m_uniSample.initialize(m_ranSvc, Rndm::Flat(0.0, m_maximum)).isFailure()) 
  //{
  //  m_log<< MSG::FATAL<< "Failed to initialize uniform random numbers" << endreq;
  //  return StatusCode::FAILURE;
  //}
  //if (m_exp.initialize(m_ranSvc, Rndm::Exponential(m_maintau)).isFailure()) 
  //{
  //  m_log<< MSG::FATAL<< "Failed to initialize Gaussian random numbers" << endreq;
  //  return StatusCode::FAILURE;
  //}

  StatusCode sc = updateBuffer();
  return sc;
}

StatusCode MixRootIOCnvSvc::readin(deque<MixHeader>* value)
{
  m_log<< MSG::DEBUG<< "Read Sample into deque!"<< endreq;

  double randomnum = flatdis(m_maximum);
  //double randomnum = m_uniSample();
  map<string, RootInputStream*>::iterator it;

  //Loop on the samples
  for(it = m_simROMap.begin(); it != m_simROMap.end(); ) 
  {
    if(randomnum < m_nod[it->first])
    {
      // SetEntry to find that if reaching the end of a file
      RootInputStream* ris = it->second;
      RootInputFile*   rif = ris->getFiles().current();
      
      if(m_fileentries[it->first] >= rif->entries())
      {
        /*m_fileindex[it->first]++;
          m_log<< MSG::DEBUG<< "After resetting, the file index is: "<< m_fileindex[it->first]<< endreq;*/
        m_fileindex[it->first]   = flatdis((double)m_fileNum[it->first]);
        bool ifjump              = ris->getFiles().jump(m_fileindex[it->first]);
        if(ifjump == false)
        {
          m_log<< MSG::ERROR<< "Can't jump to the specified file!"<< endreq;
          return StatusCode::FAILURE;
        }
        m_fileEntryNum[it->first]  = ris->getFiles().current()->entries();
        m_fileentries[it->first] = flatdis((double)m_fileEntryNum[it->first]);
        //m_log<< MSG::INFO<< "After resetting, the file entry is: "<< m_fileentries[it->first]<< endreq;
        //m_fileindex[it->first]   = flatdis((double)ris->getFiles().size());
 
        m_log<< MSG::INFO<< "Now needing to jump to "<< it->first<< ": "<< m_fileindex[it->first]<< ".root file"<< endreq;
        m_log<< MSG::INFO<< "Now the file entry is: "<< m_fileentries[it->first]<< endreq;
        m_log<< MSG::INFO<< "Now the file total entries is: "<< m_fileEntryNum[it->first]<< endreq;
        ris->setFileEntry(m_fileindex[it->first], m_fileentries[it->first], true);
        m_streamentries[it->first] = ris->getEntry();
        rif = ris->getFiles().current();
      }

      // SetEntry 
      m_log << MSG::DEBUG<< "SetEntry manually: "<< " The sample: "<< it->first
            << "  File entry: "     << m_fileentries[it->first]
            << "  Stream entry: "   << m_streamentries[it->first]
            << "  RootInputStream: "<< ris
            << "  Old entry: "      << ris->getEntry()<< endreq;
      ris->setFileEntry(m_fileindex[it->first], m_fileentries[it->first], true);
      rif = ris->getFiles().current();
      //bool ifend = ris->setEntry(m_streamentries[it->first] ,true);
      //if(ifend == false) return StatusCode::FAILURE;

      m_log<< MSG::DEBUG<< "Now the file is: "      << rif->filename()         << endreq;
      m_log<< MSG::DEBUG<< "Now the file index is: "<< m_fileindex[it->first]  << endreq;
      m_log<< MSG::DEBUG<< "Now the file entry is: "<< m_fileentries[it->first]<< endreq;

      // Read in Event
      m_log << MSG::DEBUG<< "Casting TObject to PerSimReadoutHeader."<< endreq;
      PerSimReadoutHeader* psro = (PerSimReadoutHeader*)((void*)(ris->obj()));
      m_log << MSG::DEBUG<< "======= PerSimReadoutHeader: "<< psro<< endreq;

      //Test the PerSimReadoutHeader's InputHeaders
      //vector<PerRef> iheaders = psro->inputHeaders;
      //m_log<< MSG::INFO<< "InputHeader's vector size: "<< iheaders.size()<< endreq;

      vector<PerSimReadout*> ro; 
      if(psro != NULL) 
      { 
        ro = psro->readouts;

        // Important parameters     
        TimeStamp newtime(nextTime(m_maintau));
        //TimeStamp newtime(m_exp());
        TimeStamp pretime = m_lastTime; 
     
        if(ro.size() == 0) // There is an empty event
        {
          m_log<< MSG::DEBUG<< "There is no Readouts in SimReadoutHeader!"<< endreq;
          m_fileentries[it->first]++;
          m_streamentries[it->first]++;
          m_log<< MSG::DEBUG<< "Set new file entry as: "<< m_fileentries[it->first]<< endreq;
          continue;
        }
        else 
        {
          m_log<< MSG::DEBUG<< "PerSimReadout from "<< it->first<< " with "<< ro.size()<< " PerSimReadouts"<< endreq;
          vector<MixHeader> mixVec;

          m_log<< MSG::DEBUG<< "Generte new time["<< newtime.GetSeconds()<< "sec] for sample ["<< it->first<< "]"<< endreq;
       
          // Distinguish subevents
          for(vector<PerSimReadout*>::size_type i = 0; i != ro.size(); i++) 
          {
            m_log << MSG::DEBUG<< "PmtChannelSize is: "
                  << (static_cast<PerReadoutPmtCrate*>(ro[i]->readout))->perChannelReadouts.size()
                  << " in: "<< ro[i]->readout<< endreq;
            // Copy the variables in PerReadout
            MixHeader             mh;
            PerReadout*           pro  = new PerReadoutPmtCrate();
            PerReadoutHeader*     proh = new PerReadoutHeader();
            
            pro->detector           = ro[i]->readout->detector;
            pro->triggerType        = ro[i]->readout->triggerType;
            pro->triggerNumber      = ro[i]->readout->triggerNumber;
            pro->triggerTimeSec     = ro[i]->readout->triggerTimeSec;
            pro->triggerTimeNanoSec = ro[i]->readout->triggerTimeNanoSec;

            // Deep-Copy the variables in PerReadoutPmtCrate
            vector<PerReadoutPmtChannel*> PmtVec;
            vector<PerReadoutPmtChannel*> pmtvec = (static_cast<PerReadoutPmtCrate*>(ro[i]->readout))->perChannelReadouts;
            for(vector<PerReadoutPmtChannel*>::iterator pit = pmtvec.begin(); pit != pmtvec.end(); pit++)
            {
              PerReadoutPmtChannel* propc = new PerReadoutPmtChannel();
              propc->tdc             = (*pit)->tdc;
              propc->adc             = (*pit)->adc;
              propc->mode            = (*pit)->mode;
              propc->adcCycle        = (*pit)->adcCycle;
              propc->adcRange        = (*pit)->adcRange;
              propc->pedestal        = (*pit)->pedestal;
              propc->channelId       = (*pit)->channelId;
              propc->tdcHitCount     = (*pit)->tdcHitCount;
              propc->waveAdcLow      = (*pit)->waveAdcLow;
              propc->waveAdcHigh     = (*pit)->waveAdcHigh;
              propc->waveAdcCycle    = (*pit)->waveAdcCycle;
              
              PmtVec.push_back(propc);
            }
            (static_cast<PerReadoutPmtCrate*>(pro))->perChannelReadouts = PmtVec;

            m_log<< MSG::DEBUG<< "TriggerSec: "     << pro->triggerTimeSec
                             << " TriggerNanoSec: "<< pro->triggerTimeNanoSec<< endreq; 
            proh->readout  = pro;
            m_log<< MSG::DEBUG<< "TriggerSec: "     << proh->readout->triggerTimeSec
                             << " TriggerNanoSec: "<< proh->readout->triggerTimeNanoSec<< endreq;

            proh->earliest = psro->earliest;
            proh->latest   = psro->latest;
            m_log<< MSG::DEBUG<< "The earliest TimeStamp: "<< proh->earliest
                             << " The latest TimeStamp: " << proh->latest<< endreq;

            proh->context  = psro->context;
            Detector det(pro->detector);
            proh->context.SetDetId(det.detectorId());
            m_log<< MSG::DEBUG<< "The TimeStamp in Context: "<< proh->context.GetTimeStamp()<< endreq;
            m_log<< MSG::DEBUG<< "The DetectorId in Context: "<< proh->context.GetDetId()
                 << "("<< DetectorId::AsString(proh->context.GetDetId())<< ")"<< endreq;

            //Create MixHeader and fill the mixbuffer
            mh.hder   = proh;
            mh.sample = it->first;
            mh.entry  = m_streamentries[it->first];
   
            mixVec.push_back(mh);
          }

          MixHeader   firstHeader;
          TimeStamp*  ftemp     = new TimeStamp(0.0);
          //double*     temp      = new double(0.0);
          TimeStamp*  TotalTime = new TimeStamp(0.0);
          pretime.Add(newtime);
          (*TotalTime) = pretime;
          // Find the earliest subevent
          for(vector<MixHeader>::size_type j = 0; j != mixVec.size(); j++)
          {
            TimeStamp rotime(mixVec[j].hder->readout->triggerTimeSec, mixVec[j].hder->readout->triggerTimeNanoSec);
            //double rotime = mixVec[j].hder->readout->triggerTimeSec + mixVec[j].hder->readout->triggerTimeNanoSec/1.0e9;
            if(j == 0 || *ftemp > rotime )
            {
              *ftemp = rotime;
              firstHeader = mixVec[j];
            }
          }
        
          // Reset the subevnets' triggertime and time window
          /*double de1 = firstHeader.hder->readout->triggerTimeSec - firstHeader.hder->earliest.GetSec()
                     + (firstHeader.hder->readout->triggerTimeNanoSec - firstHeader.hder->earliest.GetNanoSec())/1.0e9;
          double de2 = firstHeader.hder->latest.GetSec() - firstHeader.hder->readout->triggerTimeSec
                     + (firstHeader.hder->latest.GetNanoSec() - firstHeader.hder->readout->triggerTimeNanoSec)/1.0e9;
          */
          
          TimeStamp fde1 = *ftemp - firstHeader.hder->earliest;
          TimeStamp fde2 = firstHeader.hder->latest - *ftemp;

          for(vector<MixHeader>::size_type k = 0; k != mixVec.size(); k++)
          {
            if(mixVec[k] != firstHeader)
            {
              /*double de1 = mixVec[k].hder->readout->triggerTimeSec - mixVec[k].hder->earliest.GetSec()
                         + (mixVec[k].hder->readout->triggerTimeNanoSec - mixVec[k].hder->earliest.GetNanoSec())/1.0e9;
              double de2 = mixVec[k].hder->latest.GetSec() - mixVec[k].hder->readout->triggerTimeSec
                         + (mixVec[k].hder->latest.GetNanoSec() - mixVec[k].hder->readout->triggerTimeNanoSec)/1.0e9;
              */
              TimeStamp ktemp(mixVec[k].hder->readout->triggerTimeSec, mixVec[k].hder->readout->triggerTimeNanoSec);
              TimeStamp kde1 = ktemp - mixVec[k].hder->earliest;
              TimeStamp kde2 = mixVec[k].hder->latest - ktemp;

              mixVec[k].hder->readout->triggerTimeSec     -= firstHeader.hder->readout->triggerTimeSec;
              mixVec[k].hder->readout->triggerTimeNanoSec -= firstHeader.hder->readout->triggerTimeNanoSec;

              //double deltime = mixVec[k].hder->readout->triggerTimeSec + mixVec[k].hder->readout->triggerTimeNanoSec/1.0e9;
              //TimeStamp TriggerTime(deltime + TotalTime->GetSec() + TotalTime->GetNanoSec()/1.0e9);
              TimeStamp deltime(mixVec[k].hder->readout->triggerTimeSec, mixVec[k].hder->readout->triggerTimeNanoSec);
              deltime.Add((*TotalTime));
              TimeStamp TriggerTime = deltime;

              mixVec[k].hder->readout->triggerTimeSec      = TriggerTime.GetSec();
              mixVec[k].hder->readout->triggerTimeNanoSec  = TriggerTime.GetNanoSec();
  
              //double t = mixVec[k].hder->readout->triggerTimeSec + mixVec[k].hder->readout->triggerTimeNanoSec/1.0e9 - de1;
              TimeStamp ktempe(mixVec[k].hder->readout->triggerTimeSec, mixVec[k].hder->readout->triggerTimeNanoSec);
              ktempe = ktempe - kde1;
              mixVec[k].hder->earliest = ktempe;
              //t = mixVec[k].hder->readout->triggerTimeSec + mixVec[k].hder->readout->triggerTimeNanoSec/1.0e9 + de2;
              TimeStamp ktempt(mixVec[k].hder->readout->triggerTimeSec, mixVec[k].hder->readout->triggerTimeNanoSec);
              ktempt.Add(kde2);
              mixVec[k].hder->latest   = ktempt;
              (mixVec[k].hder->context).SetTimeStamp(mixVec[k].hder->earliest);          
            }
          }
                   
          firstHeader.hder->readout->triggerTimeSec     = TotalTime->GetSec();
          firstHeader.hder->readout->triggerTimeNanoSec = TotalTime->GetNanoSec();         

          //double t = firstHeader.hder->readout->triggerTimeSec + firstHeader.hder->readout->triggerTimeNanoSec/1.0e9 - de1;
          TimeStamp ftempe(firstHeader.hder->readout->triggerTimeSec, firstHeader.hder->readout->triggerTimeNanoSec);
          ftempe = ftempe - fde1;
          firstHeader.hder->earliest = ftempe;
          TimeStamp ftempt(firstHeader.hder->readout->triggerTimeSec, firstHeader.hder->readout->triggerTimeNanoSec);
          ftempt.Add(fde2);
          firstHeader.hder->latest   = ftempt;
          (firstHeader.hder->context).SetTimeStamp(firstHeader.hder->earliest);
         
          delete ftemp;
          delete TotalTime;

          m_fileentries[it->first]++;
          m_streamentries[it->first]++;
          m_lastTime = pretime;
          vector<MixHeader>::iterator pit;
          for(pit = mixVec.begin(); pit != mixVec.end(); pit++)
          {
            value->push_back(*pit);
          }
        }
      }
      else 
      {
        m_log<< MSG::ERROR<< "Can't retrive pointer to PerSimReadoutHeader : Terminated!"<< endreq;
        return StatusCode::FAILURE;
      }
      break;    
    }
    it++;
  }
  deque<MixHeader>::iterator dbeg, dend;
  dbeg = value->begin(); dend = value->end();
  sort(dbeg, dend);
  return StatusCode::SUCCESS;
}

StatusCode MixRootIOCnvSvc::updateBuffer()
{
  m_log<< MSG::DEBUG<< "UpdateBuffer"<< endreq;
  StatusCode sc;

  if(m_tesBuffer->size() != 0)
  {
    m_earliestHeader = m_tesBuffer->front();
    m_tesBuffer->pop_front();

    m_log<< MSG::DEBUG<< "m_currentEntry = " << m_earliestHeader.entry<<  endreq;
    m_log<< MSG::DEBUG<< "m_currentSample = "<< m_earliestHeader.sample<< endreq;

    m_inputStreamMap = m_sampleInputStreamMap[m_earliestHeader.sample];

    setInputFiles(m_inputSamples[m_earliestHeader.sample]);
    //print();

    return StatusCode::SUCCESS;
  }
  else
  { 
    if(m_firstBuffer->size() == 0 && m_secondBuffer->size() == 0) 
    { 
      sc = readin(m_firstBuffer);
      sc = readin(m_secondBuffer);
    }
    else if(m_firstBuffer->size() != 0 && m_secondBuffer->size() == 0) sc = readin(m_secondBuffer);
    else 
    { 
      m_log<< MSG::ERROR<< "There are some errors! "<< endreq;
      return StatusCode::FAILURE;
    }
    //print();
    if(sc == StatusCode::FAILURE) return StatusCode::FAILURE;
    performMixing();
    //print();
    return updateBuffer();
  }

  return StatusCode::SUCCESS;
}       

void MixRootIOCnvSvc::performMixing()
{
  m_log<< MSG::DEBUG<< "This is a place to perform mixing."<< endreq;

  if(m_firstBuffer->back() < m_secondBuffer->front())
  {
    deque<MixHeader>* tempbuffer;
    tempbuffer     = m_tesBuffer;
    m_tesBuffer    = m_firstBuffer;
    m_firstBuffer  = m_secondBuffer;
    m_secondBuffer = tempbuffer;  
  }
  else
  {
    deque<MixHeader>::iterator pos, dbegf, dendf, dbegs, dends, dbegt;
    dbegf = m_firstBuffer->begin();  dendf = m_firstBuffer->end();
    dbegs = m_secondBuffer->begin(); dends = m_secondBuffer->end();
    pos = lower_bound(dbegf, dendf, m_secondBuffer->front());

    m_tesBuffer->resize(distance(pos, dendf) + m_secondBuffer->size());
    dbegt = m_tesBuffer->begin();
    merge(pos, dendf, dbegs, dends, dbegt);

    m_firstBuffer->resize(distance(dbegf, pos));
    m_secondBuffer->clear();

    deque<MixHeader>* tempbuffer;
    tempbuffer    = m_tesBuffer;
    m_tesBuffer   = m_firstBuffer;
    m_firstBuffer = tempbuffer;
  }
  m_log<< MSG::DEBUG<< "Succesffully perform mixing."<<endreq;
}

double MixRootIOCnvSvc::flatdis(double maximum)
{
  //Rndm::Numbers flat(m_ranSvc, Rndm::Flat(0.0, maximum));
  //if(flat) return flat();
  //else
  //{
  //m_log<< MSG::ERROR<< "Random Engine was not correct."<< endreq;
  //return 0.0;
  //}
  //double tempnum = m_randomNum.Uniform(0.0, maximum);
  double tempnum = gRandom->Uniform(0.0, maximum);
  return tempnum;
}

double MixRootIOCnvSvc::nextTime(double tau)
{
  //Rndm::Numbers exponential(m_ranSvc, Rndm::Exponential(tau));
  //if(exponential)  return  exponential();
  //else 
  //{ 
  //m_log<< MSG::ERROR<< "Random Engine was not correct."<< endreq;
  //return 0.0; 
  //}
  //double tempnum = m_randomNum.Exp(tau);
  double tempnum = gRandom->Exp(tau);
  return tempnum;
}

MixHeader MixRootIOCnvSvc::fetchMixHeader() 
{
  m_log<<MSG::DEBUG<<"Return  one pointer to PerReadoutHeader."<<endreq;
  return m_earliestHeader;
}

void MixRootIOCnvSvc::print()
{
  MsgStream m_log(msgSvc(), "MixRootIOCnvSvc");
  m_log<< MSG::INFO<< "MixRootIOCnvSvc::print()"<< endreq;

  deque<MixHeader>::iterator fit;

  m_log<< MSG::INFO<< "FirstBuffer: "<< m_firstBuffer<< " Size: "<< m_firstBuffer->size()<< endreq; 
  for(fit = m_firstBuffer->begin(); fit != m_firstBuffer->end(); fit++)
  {
    m_log<< MSG::INFO<< fit->sample<<" : "<< fit->entry<< "--";
    m_log<< MSG::INFO<< fit->hder->readout->triggerTimeSec<<" : "<<fit->hder->readout->triggerTimeNanoSec<< endreq;
  }
  
  m_log<< MSG::INFO<< "SecondBuffer: "<< m_secondBuffer<< " Size: "<< m_secondBuffer->size()<< endreq; 
  for(fit = m_secondBuffer->begin(); fit != m_secondBuffer->end(); fit++)
  {
    m_log<< MSG::INFO<< fit->sample<<" : "<< fit->entry<< "--";
    m_log<< MSG::INFO<< fit->hder->readout->triggerTimeSec<<" : "<<fit->hder->readout->triggerTimeNanoSec<< endreq;
  }
  
  m_log<< MSG::INFO<< "TESBuffer: "<< m_tesBuffer<< " Size: "<< m_tesBuffer->size()<< endreq; 
  for(fit = m_tesBuffer->begin(); fit != m_tesBuffer->end(); fit++)
  {
    m_log<< MSG::INFO<< fit->sample<<" : "<< fit->entry<< "--";
    m_log<< MSG::INFO<< fit->hder->readout->triggerTimeSec<<" : "<<fit->hder->readout->triggerTimeNanoSec<< endreq;
  }  
}

long MixRootIOCnvSvc::entries()
{
  return m_totalentries;
}
 

---