In This Package:

MixingAlgorithm.cc

Go to the documentation of this file.

#include "Mixing/MixingAlgorithm.h"
#include "Event/GenHeader.h"
#include "Event/SimHeader.h"
#include "Event/ElecHeader.h"
#include "Event/SimTrigHeader.h"
#include "Event/RegistrationSequence.h"
#include "Event/SimReadoutHeader.h"
#include "RootIOSvc/IRootIOSvc.h"
#include "RootIOSvc/RootIOAddress.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "PerReadoutEvent/PerSimReadout.h"

using namespace std;
using namespace DayaBay;

MixingAlgorithm::MixingAlgorithm(const string& name, ISvcLocator* pSvcLocator) 
  :DybAlgorithm<ReadoutHeader>(name,pSvcLocator)
{
}

StatusCode MixingAlgorithm::initialize()
{
    StatusCode status= this->GaudiAlgorithm::initialize();
    if (status.isFailure()) 
    { 
         error() << "error when initializing  GaudiAlgorithm" << endreq;
         return status;
     }
   
     info() << "MixingAlgorithm ininalize()" << endreq; 
     IService* isvc=0;
     StatusCode sc = serviceLocator()->service("RootIOCnvSvc", isvc, false);
     if (sc.isFailure()) {
         error() << "Conversion service RootIOCnvSvc"<< " could not be retrieved" << endreq;
         return sc;
     }
     isvc->addRef();
     sc = isvc->queryInterface(IMixingSvc::interfaceID(), (void**)&m_mixSvc);
     if (sc.isFailure()) {
         error() << "Conversion service RootIOCnvSvc"  << " does not implement IRootIOCnvSvc" << endreq;
         
     }
  return sc;
}

StatusCode MixingAlgorithm::execute() 
{
  debug()<< "Now into Algorithm executation!"<< endreq;
  MixHeader mh = m_mixSvc->fetchMixHeader();
                              
  if(&mh != NULL)
  {
    // Using some functions in RegistrationSequence
    RegistrationSequence* seq = get<RegistrationSequence>(evtSvc(), RegistrationSequenceLocation::Default);
    debug()<< "ATTENTION!===========> Size = "<< seq->size()<< endreq;
    seq->setEarliest(mh.hder->earliest);
    seq->setLatest(mh.hder->latest);

    //If the sample coming from MDC, the codes below needed
    IRegistrationSequence::Registrations& regs = const_cast<IRegistrationSequence::Registrations&>(seq->registrations());
    IRegistrationSequence::Registrations::iterator regit;
    for(regit = regs.begin(); regit != regs.end(); regit++)
    {
      debug()<< regit->path()<< endreq;
      if(regit->path() == "/Event/Sim/SimHeader")
      {
        DataObject* child = const_cast<DataObject*>(regit->object());   
        SimHeader*  sh  = dynamic_cast<SimHeader*>(child);
        debug()<< sh->timeStamp().GetSeconds()<< endreq;
        //regit->setStore(false);
        const SimHitHeader* chits = sh->hits();
        if(!chits)
        {
          debug()<< "No SimHitHeader, my job is already done"<< endreq;
          return StatusCode::SUCCESS;
        }
        SimHitHeader* shits = const_cast<SimHitHeader*>(chits);
        debug() << "Pruning " << shits->hitCollection().size() << " hit collections" << endreq;
        sh->setHits(0);
        delete shits; 
        //info()<< "Not Storing: "<< regit->path()<< endreq;
      }
      else if(regit->path() == "/Event/SimReadout/SimReadoutHeader")
      {
        DataObject* child       = const_cast<DataObject*>(regit->object());   
        SimReadoutHeader*  sroh = dynamic_cast<SimReadoutHeader*>(child);
        debug()<< sroh->timeStamp().GetSeconds()<< endreq;
        regit->setStore(false);
        debug()<< "Not Storing: "<< regit->path()<< endreq;
      }
      else continue;
    }

    // Create Readout and it's header in TES with SimReadoutHeader as its inputHeader
    ReadoutHeader* roHeader = MakeHeaderObject();
    debug()<< "The Address of ReadoutHeader is "<< roHeader << endreq;
    SimHeader* sh = get<SimHeader>(evtSvc(), SimHeaderLocation::Default);
    debug()<< "InputHeader in ReadoutHeader: "<< roHeader->inputHeaders().size()<< endreq;
    //roHeader->addInputHeader(sh);
    this->AppendInputHeader(sh);
    debug()<< "InputHeader in ReadoutHeader: "<< roHeader->inputHeaders().size()<< endreq;   
    Readout*       readout;

    // Conversion : Per to tran
    debug()<< "There is some information ."<< endreq;
    PerReadout* pro = mh.hder->readout;

    if(pro) 
    {
      debug()<< "detector id = "       << pro->detector<< endreq;
      debug()<< "trigger Type = "      << pro->triggerType<< endreq; 
      debug()<< "triggerNumber = "     << pro->triggerNumber<< endreq;
      debug()<< "triggerTimeSec = "    << pro->triggerTimeSec<< endreq; 
      debug()<< "triggerTimeNanoSec = "<< pro->triggerTimeNanoSec<< endreq;
       
      //Conversion is here!
      debug()<< "PerPmtChannelSize is: "<< (static_cast<PerReadoutPmtCrate*>(pro))->perChannelReadouts.size()<< endreq;
      readout = convert(*pro);
      debug()<< "TranPmtChannelSize is: "<< (static_cast<ReadoutPmtCrate*>(readout))->channelReadout().size()<< endreq;
      roHeader->setContext(mh.hder->context);
      roHeader->setTimeStamp(mh.hder->earliest);
      roHeader->setEarliest(mh.hder->earliest);
      roHeader->setLatest(mh.hder->latest);
    }
    debug()<< "DetectorId: "<< roHeader->context().GetDetId()
          << "("<< DetectorId::AsString(roHeader->context().GetDetId())<< ")"<< endreq;
    debug()<< "Earliest time "<< mh.hder->earliest<< endreq;
    debug()<< "Latest   time "<< mh.hder->latest<< endreq;     
    
    readout->setHeader(roHeader);
    roHeader->setReadout(readout);
   
    // Copy this Readout into SimReadout
    /*ReadoutHeader* RoHeader = new ReadoutHeader();
    debug()<< "The Address of ReadoutHeader is "<< RoHeader << endreq;
    Readout*       ro;
    ro = assign(*readout);
    debug()<< "Readout triggerTime: "<< ro->triggerTime().GetSec()<< "--"
          << ro->triggerTime().GetNanoSec()<< endreq;
    RoHeader->setContext(mh.hder->context);
    RoHeader->setTimeStamp(mh.hder->earliest);
    RoHeader->setEarliest(mh.hder->earliest);
    RoHeader->setLatest(mh.hder->latest);
    ro->setHeader(RoHeader);
    RoHeader->setReadout(ro);
 
    SimReadoutHeader* sroh = get<SimReadoutHeader>(evtSvc(), SimReadoutHeaderLocation::Default);
    vector<SimReadout*> sros = sroh->readouts();
    debug()<< "Size of sros is "<< sros.size()<< endreq;
    debug()<< sroh->earliest()<<": "<< sroh->latest()<< endreq;
    // Now we need to clear the vector
    vector<SimReadout*>::iterator simit = sros.begin();
    ++simit;
    for(; simit != sros.end();)
    {
      delete (*simit);
      simit = sros.erase(simit);
    }
    debug()<< "After change, the size of sros is "<< sros.size()<< endreq;

    for(vector<SimReadout*>::size_type i = 0 ; i != sros.size(); i++)
    {
      debug()<< "readout is "<< readout<< endreq;
      debug()<< "ro is "<< ro<< endreq;
      const Readout* roo = sros[i]->readout();
      delete roo;
      sros[i]->setReadout(ro);
      const Readout* Ro = sros[i]->readout();
      debug()<< "After reset, m_readout is "<< Ro<< endreq;
    }
    //sroh->setTimeStamp(mh.hder->earliest);
    //sroh->setEarliest(mh.hder->earliest);
    //sroh->setLatest(mh.hder->latest);
    sroh->setReadouts(sros);*/
   
    reSetTimeStamps(mh.hder);
  
    //info()<< "SimReadoutHeader===earlist is: "<< sroh->earliest()<< endreq;
    //info()<< "SimReadoutHeader===context is: "<< sroh->timeStamp()<< endreq;
    //info()<< "SimReadoutHeader===latest  is: "<< sroh->latest()<< endreq;
  }

  PerReadoutHeader* proh = mh.hder;
  delete proh;
  debug()<< "MixingAlgorithm execute() finalized!" << endreq;
  return StatusCode::SUCCESS;
}

StatusCode MixingAlgorithm::finalize() 
{
  info() << "MixingAlgorithm finalize()" << endreq;
  return StatusCode::SUCCESS;
}
 
Readout* MixingAlgorithm::convert(const PerReadout& perRo)
{
   Detector det(perRo.detector);
   if(det.detectorId() == DetectorId::kUnknown)  return 0; 
   else if(det.detectorId() != DetectorId::kRPC) return convert(static_cast<const PerReadoutPmtCrate&>(perRo));
   else return 0;   
   return 0;
}

ReadoutPmtCrate* MixingAlgorithm::convert(const PerReadoutPmtCrate& perRoPcr)
{
  ReadoutPmtCrate *out_crate = new ReadoutPmtCrate();
  Detector det(perRoPcr.detector);
  out_crate->setDetector(det);
  out_crate->setTriggerType( Trigger::TriggerType_t(perRoPcr.triggerType));
  out_crate->setTriggerNumber(perRoPcr.triggerNumber);
  
  timespec value = {perRoPcr.triggerTimeSec, perRoPcr.triggerTimeNanoSec};
  TimeStamp tstamp(value);
  out_crate->setTriggerTime(tstamp); 
  
  ReadoutPmtCrate::PmtChannelReadouts out_channels;
  
  PerReadoutPmtCrate::PerPmtChannelReadouts in_channels = perRoPcr.perChannelReadouts;
  PerReadoutPmtCrate::PerPmtChannelReadouts::const_iterator it;
  
  for(it=in_channels.begin(); it!=in_channels.end(); ++it)
  {
    ReadoutPmtChannel out_channel = convert(**it);
    out_channel.setReadout(out_crate);
    out_channels[out_channel.channelId()]=out_channel;
  }  
  out_crate->setChannelReadout(out_channels);
  return out_crate;
}

ReadoutPmtChannel MixingAlgorithm::convert(const PerReadoutPmtChannel& perRoPch)
{
  ReadoutPmtChannel out_ch;
  out_ch.setTdc(perRoPch.tdc);
  out_ch.setTdcHitCount(perRoPch.tdcHitCount);
  out_ch.setAdc(perRoPch.adc);
  out_ch.setAdcRange(perRoPch.adcRange);
  out_ch.setPedestal(perRoPch.pedestal);
  out_ch.setAdcCycle(perRoPch.adcCycle);
  FeeChannelId id(perRoPch.channelId);
  out_ch.setMode(perRoPch.mode);
  out_ch.setChannelId(id);
  out_ch.setWaveAdcLow(perRoPch.waveAdcLow);
  out_ch.setWaveAdcHigh(perRoPch.waveAdcHigh);
  out_ch.setWaveAdcCycle(perRoPch.waveAdcCycle);
  //if(perRoPch.isLow) out_ch.setAdcGain(FeeGain::kLow);
  //else out_ch.setAdcGain(FeeGain::kHigh);
  return out_ch;
}

Readout* MixingAlgorithm::assign(const Readout& Ro)
{
  const Detector& det = Ro.detector();
  if(det.detectorId() == DetectorId::kUnknown)  return 0;
  else if(det.detectorId() != DetectorId::kRPC) return assign(static_cast<const ReadoutPmtCrate&>(Ro));
  else return 0;
}

ReadoutPmtCrate* MixingAlgorithm::assign(const ReadoutPmtCrate& RoPcr)
{
  ReadoutPmtCrate *out_crate = new ReadoutPmtCrate();

  out_crate->setDetector(RoPcr.detector());
  out_crate->setTriggerType(RoPcr.triggerType());
  out_crate->setTriggerTime(RoPcr.triggerTime());
  out_crate->setTriggerNumber(RoPcr.triggerNumber());
  debug()<<"Old DetectorId is "<< RoPcr.detector()<<endreq;
  debug()<<"New DetectorId is "<< out_crate->detector()<<endreq;

  debug()<<"Old time is "<< RoPcr.triggerTime()<< endreq;
  debug()<<"New time is "<< out_crate->triggerTime()<< endreq;
  ReadoutPmtCrate::PmtChannelReadouts out_channels; 
  ReadoutPmtCrate::PmtChannelReadouts in_channels = RoPcr.channelReadout();
  ReadoutPmtCrate::PmtChannelReadouts::const_iterator it;  
  for(it=in_channels.begin(); it!=in_channels.end(); ++it)
  {
    ReadoutPmtChannel out_channel = assign(it->second);
    out_channel.setReadout(out_crate);
    out_channels[out_channel.channelId()]=out_channel;
  }  
  out_crate->setChannelReadout(out_channels);
  return out_crate;
}

ReadoutPmtChannel MixingAlgorithm::assign(const ReadoutPmtChannel& RoPch)
{
  ReadoutPmtChannel out_ch;
  out_ch.setTdc(RoPch.tdc());
  out_ch.setTdcHitCount(RoPch.tdcHitCount());
  out_ch.setAdc(RoPch.adc());
  out_ch.setAdcRange(RoPch.adcRange());
  out_ch.setAdcCycle(RoPch.adcCycle());
  out_ch.setMode(RoPch.mode());
  out_ch.setChannelId(RoPch.channelId());
  out_ch.setWaveAdcLow(RoPch.waveAdcLow());
  out_ch.setWaveAdcHigh(RoPch.waveAdcHigh());
  out_ch.setWaveAdcCycle(RoPch.waveAdcCycle());
  return out_ch;
}

void MixingAlgorithm::reSetTimeStamps(const PerReadoutHeader* proh)
{
  // Reset these Headers
  RegistrationSequence* seq = get<RegistrationSequence>(evtSvc(), RegistrationSequenceLocation::Default);
  debug()<< "Reset the Time info.: Time Window!"<< endreq;

  IRegistrationSequence::Registrations& regs = const_cast<IRegistrationSequence::Registrations&>(seq->registrations());
  IRegistrationSequence::Registrations::iterator regit;
  for(regit = regs.begin(); regit != regs.end(); regit++)
  {
    debug()<< regit->path()<< endreq;
    // Reset GenHeader time
    if(regit->path() == GenHeaderLocation::Default)
    {
      GenHeader*  gh        = get<GenHeader>(evtSvc(), GenHeaderLocation::Default);
      SimReadoutHeader* srh = get<SimReadoutHeader>(evtSvc(), SimReadoutHeaderLocation::Default);
      TimeStamp temp        = proh->earliest - srh->earliest();
      gh->setContext(proh->context);
      temp.Add(gh->earliest());
      gh->setTimeStamp(temp);
      gh->setEarliest(temp);
      temp = proh->earliest - srh->earliest();
      temp.Add(gh->latest());
      gh->setLatest(temp);
      debug()<< "GenHeader===earlist is: "<< gh->earliest()<< endreq;
      debug()<< "GenHeader===context is: "<< gh->timeStamp()<< endreq;
      debug()<< "GenHeader===latest  is: "<< gh->latest()<< endreq;
    }

    // Reset SimHeader time
    if(regit->path() == SimHeaderLocation::Default)
    {  
      SimHeader*  sh        = get<SimHeader>(evtSvc(), SimHeaderLocation::Default);
      SimReadoutHeader* srh = get<SimReadoutHeader>(evtSvc(), SimReadoutHeaderLocation::Default);
      TimeStamp temp        = proh->earliest - srh->earliest();
      sh->setContext(proh->context);
      temp.Add(sh->earliest());
      sh->setTimeStamp(temp);
      sh->setEarliest(temp);
      temp = proh->earliest - srh->earliest();
      temp.Add(sh->latest());
      sh->setLatest(temp);
      debug()<< "SimHeader===earlist is: "<< sh->earliest()<< endreq;
      debug()<< "SimHeader===context is: "<< sh->timeStamp()<< endreq;
      debug()<< "SimHeader===latest  is: "<< sh->latest()<< endreq;
    }
    
    // Reset SimTrigHeader time
    /* if(regit->path() == SimTrigHeaderLocation::Default)
    {
      SimTrigHeader* sth = get<SimTrigHeader>(evtSvc(), SimTrigHeaderLocation::Default);
      sth->setContext(proh->context);
      sth->setTimeStamp(proh->earliest);
      sth->setEarliest(proh->earliest);
      sth->setLatest(proh->latest);
      debug()<< "SimTrigHeader===earlist is: "<< sth->earliest()<< endreq;
      debug()<< "SimTrigHeader===context is: "<< sth->timeStamp()<< endreq;
      debug()<< "SimTrigHeader===latest  is: "<< sth->latest()<< endreq;
      }*/
    
    // Reset ElecHeader time
    /*if(regit->path() == ElecHeaderLocation::Default)
    {
      ElecHeader* eh = get<ElecHeader>(evtSvc(), ElecHeaderLocation::Default);
      eh->setContext(proh->context);
      eh->setTimeStamp(proh->earliest);
      eh->setEarliest(proh->earliest);
      eh->setLatest(proh->latest);
      debug()<< "ElecHeader===earlist is: "<< eh->earliest()<< endreq;
      debug()<< "ElecHeader===context is: "<< eh->timeStamp()<< endreq;
      debug()<< "ElecHeader===latest  is: "<< eh->latest()<< endreq;
      }*/

    // Reset SimReadoutHeader time
    /*if(regit->path() == SimReadoutHeaderLocation::Default)
    {
      SimReadoutHeader* srh = get<SimReadoutHeader>(evtSvc(), SimReadoutHeaderLocation::Default);
      srh->setContext(proh->context);
      srh->setTimeStamp(proh->earliest);
      srh->setEarliest(proh->earliest);
      srh->setLatest(proh->latest);
      debug()<< "SimReadoutHeader===earlist is: "<< srh->earliest()<< endreq;
      debug()<< "SimReadoutHeader===context is: "<< srh->timeStamp()<< endreq;
      debug()<< "SimReadoutHeader===latest  is: "<< srh->latest()<< endreq;
      }*/
  }
}

---