In This Package:

ElecHeaderCnv.cc

Go to the documentation of this file.

#include "ElecHeaderCnv.h"
#include "PerBaseEvent/HeaderObjectCnv.h"

#include "PerElecEvent/PerElecHeader.h"
#include "PerElecEvent/PerElecCrateHeader.h"
#include "PerElecEvent/PerElecFeeCrate.h"
#include "PerElecEvent/PerElecFeeChannel.h"

#include "Event/ElecCrate.h"
#include "Event/ElecFeeChannel.h"
#include "Event/ElecFeeCrate.h"
#include "Event/ElecCrateHeader.h"

#include "Conventions/DetectorId.h"
#include "Conventions/Detectors.h"
#include "Conventions/Electronics.h"

#include <vector>
#include <map>

#include <iostream>

using namespace DayaBay;
using namespace std;

ElecHeaderCnv::ElecHeaderCnv(ISvcLocator* svc)
    : RootIOTypedCnv<PerElecHeader,ElecHeader>("PerElecHeader",
                                             classID(),svc)
{
  // FIXME: Converters do not have properties
  //declareProperty("SaveChannelData",m_saveChannelData=true,
  //                "Save channel-level simulation data in output");
  //declareProperty("SaveBoardData",m_saveBoardData=true,
  //                "Save board-level simulation data in output");

  // Helper variables to allow control of writing electronics
  // simulation data

  m_savePulseData = true;
  m_saveChannelData = true;
  m_saveBoardData = true;
  m_saveEsumData = true;

  char* pruneElecSimData = getenv("NUWA_PRUNEELECSIM");
  if (pruneElecSimData) {
    m_savePulseData = false;
    m_saveChannelData = false;
    m_saveBoardData = false;
    m_saveEsumData = false;
  }

}

ElecHeaderCnv::~ElecHeaderCnv()
{
}


// From Persistent to Transient
StatusCode ElecHeaderCnv::PerToTran(const PerElecHeader& perobj,
                                   ElecHeader& tranobj)
{
    StatusCode sc = HeaderObjectCnv::toTran(perobj,tranobj);
    if (sc.isFailure()) return sc;

    MsgStream log(msgSvc(), "ElecHeaderCnv::PerToTran");

    PerElecCrateHeader* perECH = perobj.crateHeader ;
    ElecCrateHeader* transECH = 0;
    if( perECH!=0 ) {
      transECH = convert(*perECH);
      transECH->setHeader( &tranobj );
    }
    
    // convert ElecPulseHeader to PerElecPulseHeader
    PerElecPulseHeader* perEPH = perobj.pulseHeader ;
    ElecPulseHeader* transEPH = 0;
    if( perEPH!=0 ) {
      transEPH = convert(*perEPH);
      transEPH->setHeader( &tranobj );
    }
    
    tranobj.setCrateHeader(transECH);
    tranobj.setPulseHeader(transEPH);

    return StatusCode::SUCCESS;
}

// From Transient to Persistent
StatusCode ElecHeaderCnv::TranToPer(const ElecHeader& tranobj,
                                   PerElecHeader& perobj)
{ 
    MsgStream log(msgSvc(), "ElecHeaderCnv::TranToPer");
  
    StatusCode sc = HeaderObjectCnv::toPer(tranobj,perobj);
    if (sc.isFailure()) return sc;
 
    // convert PerElecCrateHeader to PerElecCrateHeader;
    if (perobj.crateHeader != 0 ) {
      delete perobj.crateHeader;   // delete the old one
    }
    const ElecCrateHeader* transECH = tranobj.crateHeader() ;
    PerElecCrateHeader* perECH = 0;
    if (transECH != 0) {
      perECH = convert(*transECH); // create a new one
    }
    perobj.crateHeader=perECH;
    
    // convert ElecPulseHeader to PerElecPulseHeader
    if (perobj.pulseHeader != 0 ) {
      delete perobj.pulseHeader;   // delete the old one
    }
    const ElecPulseHeader* transEPH = tranobj.pulseHeader() ;
    PerElecPulseHeader* perEPH = 0;
    if (transEPH != 0) {
      perEPH = convert(*transEPH); // create a new one
    }
    perobj.pulseHeader=perEPH;

    return StatusCode::SUCCESS;
}
    
StatusCode ElecHeaderCnv::fillRepRefs(IOpaqueAddress*, DataObject* dobj)
{
    MsgStream log(msgSvc(), "ElecHeaderCnv::fillRepRefs");
    ElecHeader* eh = dynamic_cast<ElecHeader*>(dobj);

    log << MSG::DEBUG
        << "Saving links to " << eh->inputHeaders().size() 
        << " input headers" << endreq;

    StatusCode sc = HeaderObjectCnv::fillPer(m_rioSvc,*eh,*m_perOutObj);
    if (sc.isFailure()) {
        log << MSG::ERROR << "Failed to fill HeaderObject part" << endreq;
        return sc;
    }

    // ... fill ElecHeader part...
    return sc;
}

StatusCode ElecHeaderCnv::fillObjRefs(IOpaqueAddress*, DataObject* dobj)
{
    MsgStream log(msgSvc(), "ElecHeaderCnv::fillObjRefs");
    HeaderObject* hobj = dynamic_cast<HeaderObject*>(dobj);
    StatusCode sc = HeaderObjectCnv::fillTran(m_rioSvc,*m_perInObj,*hobj);
    if (sc.isFailure()) {
        log << MSG::ERROR << "Failed to fill HeaderObject part" << endreq;
        return sc;
    }

    log << MSG::DEBUG
        << "Restored links to " << hobj->inputHeaders().size() 
        << " input headers" << endreq;

    // ... fill ElecHeader part...
    return sc;
}


// Convert Transient to Persistant

PerElecCrateHeader* ElecHeaderCnv::convert(const ElecCrateHeader& transCH){
  MsgStream log(msgSvc(), "ElecHeaderCnv");

  PerElecCrateHeader::detCrateVec cratevec;
  const map<Detector,ElecCrate*>& in_cmap = transCH.crates();
  map<Detector,ElecCrate*>::const_iterator it, done = in_cmap.end() ;
  for (it = in_cmap.begin(); it != done; ++it ){
    //short int detId = (it->first).siteDetPackedData();
    const ElecCrate* cr = it->second;
    PerElecCrate* pcr = convert(*cr);
    if(pcr!=0) {
      cratevec.push_back( pcr );
    } else {
      log<<MSG::ERROR<<"You are trying to save a null pointer of ElecCrate to file. Skipped."<<endreq;
      continue;
    }
  }
  return new PerElecCrateHeader(cratevec);
}

PerElecCrate* ElecHeaderCnv::convert(const ElecCrate& transCrate){
  Detector det = transCrate.detector();
  
  if(det.detectorId() == DetectorId::kUnknown){
      return 0; 
  }else if( det.detectorId() != DetectorId::kRPC ){
      return convert( static_cast<const ElecFeeCrate&>(transCrate) );
  }else{
      return convert( static_cast<const ElecFecCrate&>(transCrate) ); 
  }
   
}

PerElecFeeCrate* ElecHeaderCnv::convert(const ElecFeeCrate& transFeeCrate){
  // get detector Id
  short int det = (transFeeCrate.detector()).siteDetPackedData();
  
  // make channel map
  map<PerElecCrate::ChannelId_type,PerElecFeeChannel*> chan;
  if(m_saveChannelData){
    // Save channel data if requested
    const map<FeeChannelId, ElecFeeChannel>& in_channels = transFeeCrate.channelData();
    map<FeeChannelId, ElecFeeChannel>::const_iterator it, done=in_channels.end();
    for( it = in_channels.begin() ; it != done ; ++it ){
      chan[(it->first).fullPackedData()] = convert( it->second ) ;
    }
  }
  
  // make board energy map
  std::map<PerElecCrate::BoardId_type,AnalogSignal> BrdEnergy;
  // make board nHit map
  std::map<PerElecCrate::BoardId_type,DigitalSignal> BrdnHit;
    
  if(m_saveBoardData){

    const map<FeeChannelId,AnalogSignal> in_energy = transFeeCrate.esum();
    map<FeeChannelId,AnalogSignal>::const_iterator eIt;
    for(eIt = in_energy.begin() ; eIt != in_energy.end() ; ++eIt){
      BrdEnergy[(eIt->first).fullPackedData()] = eIt->second;
    }

    const map<FeeChannelId,DigitalSignal> in_nh = transFeeCrate.nhit();
    map<FeeChannelId,DigitalSignal>::const_iterator nIt;
    for(nIt = in_nh.begin() ; nIt != in_nh.end() ; ++nIt){
      BrdnHit[(nIt->first).fullPackedData()] = nIt->second;
    }

  }
  
  // make the esum vectors
  AnalogSignal  ues;
  AnalogSignal  les;
  AnalogSignal  tes;
  DigitalSignal des;
  
  if(m_saveEsumData){
      ues = transFeeCrate.esumUpper();
      les = transFeeCrate.esumLower();
      tes = transFeeCrate.esumTotal();
      des = transFeeCrate.esumADC();
  }
    
  return new PerElecFeeCrate(det,chan,BrdEnergy,BrdnHit,ues,les,tes,des);
}

PerElecFecCrate* ElecHeaderCnv::convert(const ElecFecCrate& transFecCrate){
  return new PerElecFecCrate();
}

PerElecFeeChannel* ElecHeaderCnv::convert(const ElecFeeChannel& in_ch){
  vector<int> hit = in_ch.hit();
  vector<int> adcHigh = in_ch.adcHigh();
  vector<int> adcLow = in_ch.adcLow();
  vector<int> tdc = in_ch.tdc();
  vector<double> energy = in_ch.energy();  
  return new PerElecFeeChannel(hit,adcHigh,adcLow,tdc,energy);
}

PerElecPulseHeader* ElecHeaderCnv::convert(const ElecPulseHeader& transPH){
  PerElecPulseHeader::detCollMap pulsemap;
  if(m_savePulseData){
    const map<Detector,ElecPulseCollection*>& in_pmap = transPH.pulseCollection();
    map<Detector,ElecPulseCollection*>::const_iterator it, done = in_pmap.end() ;
    for (it = in_pmap.begin(); it != done; ++it ){
      short int detId = (it->first).siteDetPackedData();
      const ElecPulseCollection* pls = it->second;
      pulsemap[detId] = convert(*pls);
    }
  }
  return new PerElecPulseHeader(pulsemap);
}

PerElecPulseCollection* ElecHeaderCnv::convert(const ElecPulseCollection& transPCol){
  PerElecPulseCollection::PulseContainer out_pulses;
  ElecPulseCollection::PulseContainer in_pulses = transPCol.pulses();
  ElecPulseCollection::PulseContainer::iterator it;
  
  for(it = in_pulses.begin(); it != in_pulses.end(); ++it){
    out_pulses.push_back( convert(**(it)) );
  }
  
  short int det = (transPCol.detector()).siteDetPackedData();
  return new PerElecPulseCollection(det,out_pulses);
}

PerElecPulse* ElecHeaderCnv::convert(const ElecPulse& transPulse){
  double out_t    = transPulse.time();
  int    out_cid  = (transPulse.channelId()).fullPackedData();
  float  out_amp  = transPulse.amplitude();
  int    out_type = transPulse.type();
  // PerSimHit* simhit = ...
  return new PerElecPulse( out_t, out_cid, out_amp, out_type);
}

// Convert Persistant to Transient

ElecCrateHeader* ElecHeaderCnv::convert(const PerElecCrateHeader& perCH){
  MsgStream log(msgSvc(), "ElecHeaderCnv");

  ElecCrateHeader *out_header = new ElecCrateHeader(); // make header to return;
  std::vector<PerElecCrate*> cratevec = perCH.crates;
  std::vector<PerElecCrate*>::iterator it;
  for(it = cratevec.begin(); it != cratevec.end(); ++it){
    PerElecCrate *perCrate = *it;
    if(perCrate==0) {
      log<<MSG::ERROR<<"What? You got a zero pointer from file?"<<endreq;
      continue;  // drop this turn
    }
    ElecCrate *transCrate = convert( *perCrate );
    // wangzhe
    if( transCrate==0 ) {
      log<<MSG::ERROR<<"What? A null pointer for a ElecCrate?"<<endreq;
      continue;  // drop this turn
    }
    // wz
    out_header->addCrate(transCrate);
  }
  return out_header;
}

ElecPulseHeader* ElecHeaderCnv::convert(const PerElecPulseHeader& perPH){
  ElecPulseHeader *out_pulseH = new ElecPulseHeader();
  PerElecPulseHeader::detCollMap colmap = perPH.pulseCollections;
  PerElecPulseHeader::detCollMap::iterator it;
  for(it=colmap.begin();it!=colmap.end();++it){
    ElecPulseCollection *coll = convert( *(it->second));
    coll->setHeader(out_pulseH);
    Detector det(it->first);
    coll->setDetector(det);
    out_pulseH->addPulseCollection(coll);
  }
  return out_pulseH;
}

ElecCrate* ElecHeaderCnv::convert(const PerElecCrate& perCrate){
  Detector det(perCrate.detId);
  
  if(det.detectorId() == DetectorId::kUnknown){
      return 0; 
  }else if( det.detectorId() != DetectorId::kRPC ){
      return convert( static_cast<const PerElecFeeCrate&>(perCrate) );
  }else{
      return convert( static_cast<const PerElecFecCrate&>(perCrate) ); 
  }
  
  return 0;
}

ElecFeeChannel* ElecHeaderCnv::convert(const PerElecFeeChannel& perChannel){
  ElecFeeChannel *outCh = new ElecFeeChannel();
  outCh->setHit(perChannel.nHit);
  outCh->setAdcHigh(perChannel.adcHigh);
  outCh->setAdcLow(perChannel.adcLow);
  outCh->setEnergy(perChannel.energy);
  outCh->setTdc(perChannel.tdc);
  return outCh;
}

ElecFecCrate* ElecHeaderCnv::convert(const PerElecFecCrate& perFecCrate){
  // get rid of unused variable warning
  return 0;
}

ElecFeeCrate* ElecHeaderCnv::convert(const PerElecFeeCrate& perFeeCrate){
  ElecFeeCrate *out_crate = new  ElecFeeCrate( Detector(perFeeCrate.detId) , 0);
  
  // convert channels
  map<PerElecCrate::ChannelId_type,PerElecFeeChannel*> chan = perFeeCrate.channels;
  map<PerElecCrate::ChannelId_type,PerElecFeeChannel*>::iterator chIt;
  for(chIt=chan.begin();chIt!=chan.end();++chIt){
    FeeChannelId feeId(chIt->first);
    PerElecFeeChannel* feeCh = chIt->second;
    out_crate->channel(feeId) = *convert( *feeCh );
  }
  
  // convert NHit
  std::map<PerElecCrate::BoardId_type,DigitalSignal> BrdnHit = perFeeCrate.boardNHit;
  std::map<PerElecCrate::BoardId_type,DigitalSignal>::iterator nhIt;
  for(nhIt=BrdnHit.begin();nhIt!=BrdnHit.end();++nhIt){
    FeeChannelId feeId(nhIt->first);
    out_crate->nhitSignal(feeId) = nhIt->second;
  }
  
  // convert ESum
  std::map<PerElecCrate::BoardId_type,AnalogSignal> BrdeSum = perFeeCrate.boardEnergy;
  std::map<PerElecCrate::BoardId_type,AnalogSignal>::iterator esIt;
  for(esIt=BrdeSum.begin();esIt!=BrdeSum.end();++esIt){
    FeeChannelId feeId(esIt->first);
    out_crate->esumSignal(feeId) = esIt->second;
  }
  
  out_crate->setEsumTotal(perFeeCrate.totalESum);
  out_crate->setEsumUpper(perFeeCrate.upperESum);
  out_crate->setEsumLower(perFeeCrate.lowerESum);
  out_crate->setEsumADC(perFeeCrate.digitalESum);
  
  return out_crate;  
}

ElecPulseCollection* ElecHeaderCnv::convert(const PerElecPulseCollection& perEPC){
  ElecPulseCollection* out_pcol = new ElecPulseCollection();
  ElecPulseCollection::PulseContainer out_pulseCon;
  const std::vector<PerElecPulse*>& in_pulseCon = perEPC.pulses;
  std::vector<PerElecPulse*>::const_iterator it;
  for(it=in_pulseCon.begin();it!=in_pulseCon.end();++it){
    ElecPulse *ep = convert(**it);
    ep->setPc(out_pcol);
    out_pulseCon.push_back(ep);
  }
  out_pcol->setPulses(out_pulseCon);
  return out_pcol;
}

ElecPulse* ElecHeaderCnv::convert(const PerElecPulse& perEP){
  ElecPulse *out_pulse = new ElecPulse();
  out_pulse->setTime(perEP.time);
  FeeChannelId feeId(perEP.channelId);
  out_pulse->setChannelId(feeId);
  out_pulse->setAmplitude(perEP.amplitude);
  out_pulse->setType(perEP.type);  
  //out_pulse->setAncestor()
  return out_pulse;
}

---