RawTofConverter.cxx

Go to the documentation of this file.

#include "RawTofConverter.h"

#include "OnlineUtil/mdBlockDefinitions.h"
#include "Validity/VldTimeStamp.h"
#include "OnlineUtil/rdChecksum.h"

RawTofConverter::RawTofConverter(RawRecord* rr)
  :
  fRR(rr), fTDC(0), fNBlocks(0)
{
  if(fRR!=0){
    fTDC = static_cast<const RawRopTdcRawDataBlock*>
      (fRR->FindRawBlock("RawRopTdcRawDataBlock"));    
  }
  if(fTDC) ConstructTofBlocks();
}

RawTofConverter::~RawTofConverter()
{
  for(unsigned int blk=0; blk<fPackedRawTOFBlocks.size(); blk++)
    {
        delete [] fPackedRawTOFBlocks[blk];
    }
}
RawTOFBlock* RawTofConverter::AbandonRawTOFBlock(int n, long* varcp)
{

  // if you have the original hit data, use this one

  RawTOFBlock* result = 0;
  if(n>=fNBlocks) return result;

  int* p = fPackedRawTOFBlocks[n];
  p[7] = *varcp;
  p[8] = *(varcp+1);

  // compute the checksum
  rdxsum_fill(reinterpret_cast<long*>(p), 0);

  // its ready
  result = new RawTOFBlock(fPackedRawTOFBlocks[n]);
  return result;
}

int* RawTofConverter::GetPackedRawTOFBlock(int n, long* varcp)
{

  int* result = 0;
  if(n>=fNBlocks) return result;

  int* p = fPackedRawTOFBlocks[n];
  p[7] = *varcp;
  p[8] = *(varcp+1);

  // compute the checksum
  rdxsum_fill(reinterpret_cast<long*>(p), 0);

  result = p;
  // its ready
  return result;
}

RawTOFBlock* RawTofConverter::AbandonRawTOFBlock(int n, const RawDigit& rd)
{
  RawTOFBlock* result = 0;
  if(n>=fNBlocks) return result;

   int rcid_encoded= rd.GetChannel().GetEncoded();
   int adc = rd.GetADC();
   int tdc = rd.GetTDC();
  

  // fix up the raw digit part of the tdc readout
  // first to the channel+adc word
  // set initial bit
   int varc1 = 0x80000000;
  // assume fifo|calinject ok
  varc1|=0x20000000;
  // shift back rcid
  varc1|=(((rcid_encoded&0x00001fff)<<16)&0x1fff0000);
  // set mode to normal data taking
  varc1|=0x00008000;
  // pack in adc
  varc1|=(adc&0x00007fff);
  
  // now do the tdc part
   int varc2=0x0;
  varc2|=(tdc&0x3fffffff);

  // now recompute parities
  // assume they were originally correct
  // varc 1
  if(!ParityOK(varc1)) varc1|=0x40000000;
  // varc 2
  if(!ParityOK(varc2)) varc2|=0x40000000;
  

  // now add the varc stuff to the packed raw tof block
  int* p = fPackedRawTOFBlocks[n];
  p[7]=varc1;
  p[8]=varc2;

  // compute the checksum
  rdxsum_fill(reinterpret_cast<long*>(p), 0);

  // its ready
  result = new RawTOFBlock(fPackedRawTOFBlocks[n]);
  return result;
  
}

bool RawTofConverter::ParityOK(int i) const
{
   int sum = 0;
  for(int j=0; j<32; j++){
    sum+=(i&1);
    i=i>>1;
  }
  if(sum%2==0) return true;
  else return false;
}

void RawTofConverter::ReadDataWord(int input, int& v, int& un, int& ov, int& tdc)
{

  // see CAEN V775 manual, page 36
  const int vmask = 0x4000;
  const int unmask = 0x2000;
  const int ovmask = 0x1000;
  const int tdcmask = 0xfff;
  v = (input&vmask)>>14;
  un = (input&unmask)>>13;
  ov = (input&ovmask)>>12;
  tdc = input&tdcmask;

}

  
int RawTofConverter::ConstructTofBlocks()
{
  
  // the strategy here is to decompose the Rop blocks
  // which contain tdc data from many events
  // into a collection of integer arrays (one for each tof event)
  // in the format that RawTofBlock(int*) expects
  // I do not immediately create RawTofBlocks because
  // they require knowledge of the fake hit generated in the
  // detector when we have a tof coincidence
  
  
  if(fTDC==0) return 0;

  //unused: const int orig_cksum = fTDC->GetChecksum();
  const int orig_blkid = fTDC->GetBlockId().GetEncoded();
  const int orig_crid = fTDC->GetCrateId();
  //unused: const int orig_tf = fTDC->GetTimeFrame();
  //unused: const int orig_run = fTDC->GetRun();
  //unused: const int orig_subrum = fTDC->GetSubRun();
  //unused: const int orig_runtype = fTDC->GetRunType();
  const VldTimeStamp orig_ts = fTDC->GetTimeStamp();
  const int orig_t0_0 = orig_ts.GetSec();
  const int orig_t0_1 = orig_ts.GetNanoSec();
  //  cout<<"orig_blkid="<<hex<<orig_blkid<<dec<<endl;
  // below I get the packed up tdc data
  // format:
  //
  // header
  // data words
  // trailer
  //
  // header
  // etc..
  const int orig_bytes = fTDC->GetNumberOfTdcReadoutBytes();
  const char* orig_cdata = fTDC->GetTdcData();
  const int orig_nints = orig_bytes/sizeof(unsigned long);
  //  const int* orig_idata = static_cast<int*>(orig_cdata);
  //  const unsigned long* orig_idata = reinterpret_cast<const unsigned long*>(orig_cdata);
  const int* orig_idata = reinterpret_cast<const int*>(orig_cdata);

  // loop through raw tdc data
  //  const unsigned long* iptr = orig_idata;
  const int* iptr = orig_idata;
  
  //  unsigned long* raw_tof_blk = 0;
  int* raw_tof_blk = 0;
  while (iptr<(orig_idata+orig_nints))
    {
      // on header word
      //      const unsigned long* const  hptr = iptr;
      const int* const  hptr = iptr;
      
      // see CAEN v775 manual, p 36-37
      //      const unsigned long nchanmask = 0x3f00;
      const int nchanmask = 0x3f00;
      const int nchan = ((*iptr)&nchanmask)>>8;
      //      const unsigned long* const dptr = hptr+1;
      const int* const dptr = hptr+1;
      //      const unsigned long* const tptr = dptr+nchan;
      const int* const tptr = dptr+nchan;
      //  cout<<"nchan="<<nchan<<endl;
      // create the TofBlock data array

      // tof_blk_hdr_words: 7 words
      // one word each for:
      // nbytes in block
      // chksum
      // block id
      // crate id
      // # tof hits
      // t0 first word
      // t0 second word
      const int tof_blk_hdr_words = 9;

      // tof_blk_tdc_words:
      // one word each for:
      // header
      // trailer
      // number of channels read out
      const int tof_blk_tdc_words = 2 + nchan;

      // tof_blk_trl_words:
      // one word each for:
      // tof block trailer
      const int tof_blk_trl_words = 1;

      const int tof_blk_words = tof_blk_hdr_words
        + tof_blk_tdc_words
        + tof_blk_trl_words;
      //cout<<"tof_blk_words="<<tof_blk_words<<endl;
      //      raw_tof_blk = new unsigned long[tof_blk_words];
      //      if(raw_tof_blk==0){
        raw_tof_blk = new int[tof_blk_words];

        //      }

      // increment the number of tof blocks counter

      fNBlocks++;
      
      

      // set number of words
      //      raw_tof_blk[0] = tof_blk_words*sizeof(unsigned long);
      // isn't the first word in the block?
      // i guess not
      raw_tof_blk[0] = tof_blk_words-1;
      // do not compute checksum yet
      // this has to wait for the association with
      // the fake hit that the tof system generates
      raw_tof_blk[1] = 0;
      // set block id to TofReadout block id
      // from mdBlockDefinitions.h
      int newblkid = orig_blkid;
      newblkid&=0xfff000ff;
      //      newblkid|=0x00010400;
      newblkid|=((kMdBlockTofReadout<<8)&0x000fff00);
      raw_tof_blk[2] = newblkid;

      // set the crate id

      raw_tof_blk[3] = orig_crid;
      
      //      cout<<hex<<orig_crid<<endl;
      // set the number of tof hits
      // i assume a maximum of 1 tof hit per event
      // i may need to revisit this assumption
      raw_tof_blk[4] = 1;
      // set t0
      // for now copy from the RawRopTdcRawDataBlock
      // perhaps when I associate this tdc data with an event
      // this should change to reflect t0 from that event
      raw_tof_blk[5] = orig_t0_0;
      raw_tof_blk[6] = orig_t0_1;
      // set the varc readout
      // this must wait for the association of
      // this tdc data with the fake hit produced
      // by the tof system
      raw_tof_blk[7] = 0;
      raw_tof_blk[8] = 0;

      // set the tdc data
      // set the header
      raw_tof_blk[9] = *hptr;
      // if we have data then nchan>0 and we enter this loop
      // otherwise we just got a header and a trailer
      //cout<<"one event: "<<endl;

      for(int tdc_data_idx = 0; tdc_data_idx<nchan; tdc_data_idx++)
        {         
          //int v=0; int un=0; int ov=0; int tdc = 0;
          //ReadDataWord(*(dptr+tdc_data_idx), v, un, ov, tdc);
          //cout<<"v="<<v<<", un="<<un<<", ov="<<ov<<", tdc="<<tdc<<endl;
          raw_tof_blk[10+tdc_data_idx]=*(dptr+tdc_data_idx);
        }

      // on trailer word

      raw_tof_blk[10+nchan] = *tptr;
      //      int* testarray = new int[13];
      // increment iptr
      // header+trailer+nchannels

      iptr+=(2+nchan);

      // add raw_tof_blk to the vector
            fPackedRawTOFBlocks.push_back(raw_tof_blk);

    }
  return fNBlocks;
}


void RawTofConverter::Dump(ostream& os)
{

  os<<"Dumping the contents of RawTofConverter:"<<std::endl;
  for(unsigned int blk = 0; blk<fPackedRawTOFBlocks.size(); blk++)
    {
      RawTOFBlock rtb(fPackedRawTOFBlocks[blk]);
      rtb.FormatToOStream(os,"");
    }
}

---