Acquisition.cpp

Go to the documentation of this file.

// $Id: $

// include files
#include "TTree.h"

// local
#include "Proto40MHz_v1.h"
#include "A3PE.h"
#include "Run.h"
#include "Event.h"
#include "Acquisition.h"

//-----------------------------------------------------------------------------
// Implementation file for class : Acquisition
//
// 2006-10-23 : 
//-----------------------------------------------------------------------------

//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
Acquisition::Acquisition(  ) :
  m_store_tree(true),
  m_store_hist(false),
  m_store_sample(true),
  m_channels(0xFF),
  m_depth(5),
  m_trig(true),
  m_nsample(0),
  m_nbins(100),
  m_minRange(0.),
  m_maxRange(4096.),
  m_deadtime(1000.)
{
  setName ( "Acquisition" );
  setType ( "Proto40MHz_v1" );
  setTitle( "Proto40MHz_v1 data acquisition" );
}
//=============================================================================
// Destructor
//=============================================================================
Acquisition::~Acquisition() {} 

//=============================================================================

//=========================================================================
//
//=========================================================================
StatusCode Acquisition::initialize ( ) {
  debug("Acquisition" , "initialize");
  info("" );
  info("____________________________");
  info("Acquisition run");
  info(" =>" + element()->path() + " " +
      element()->name() + " " + element()->type() );

  m_board=dynamic_cast<Proto40MHz_v1*>( element() );

  if (!m_board){
    warning("Acquisition","No Proto40MHz_v1 board found. Interrupt."  );
    return false;
  }

  m_pga=m_board->a3pe();
  m_fifo = m_pga->storageRam();
  m_pga->setFifoDepth(m_depth);
  m_pga->setSoftwareTrigger(m_trig);
  m_pga->setWriteStorageFifoUsb(false);

  m_nch=0;
  char hname[25];
  char title[50];
  for (int c=0; c<8; c++){
    m_chEnable[c]=0;
    m_channel[c]=-1;
    if ((m_channels>>c)&1) {
      m_pga->setEnableADC(c,true);
      if (m_store_hist){
        sprintf(hname,"Average_Ch_%1i",c);
        sprintf(title,"Average Ch %1i",c);
        m_a[c]=new TH1D(hname, title, m_depth , -0.5, (float)(m_depth)-0.5);
        sprintf(hname,"RMS_Ch_%1i",c);
        sprintf(title,"RMS Ch %1i",c);
        m_s[c]=new TH1D(hname, title, m_depth , -0.5, (float)(m_depth)-0.5);
        addHisto1d(m_a[c]);
        addHisto1d(m_s[c]);
      }
      if (m_store_sample){
        sprintf(hname,"Acquisition_Ch_%1i_%1i",c,m_nsample);
        sprintf(title,"Acquisition Ch %1i - Sample %1i",c,m_nsample);
        m_hsample[c]=new TH1D(hname, title, m_nbins, m_minRange, m_maxRange);
        addHisto1d( m_hsample[c] );
      }
      m_chEnable[c]=1;
      m_nch++;
    }
    else {
      //      m_channel[c]=-1.;
      m_pga->setEnableADC(c,false);
    }
  }
  if (m_store_tree){
    m_tree = new TTree("Acquisition",name().c_str());
    m_tree->Branch("Run",&m_runNumber,"Run/I");
    m_tree->Branch("Event",&m_evtNumber,"Event/I");
    m_tree->Branch("Time",&m_timestamp,"Time/D");
    m_tree->Branch("Sample",&m_sample,"Sample/I");
    m_tree->Branch("Channel",m_channel,"Channel[8]/I");
    m_tree->Branch("ChEnable",m_chEnable,"ChEnable[8]/I");
  }
  m_runNumber=application()->options()->runNumber();
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode Acquisition::execute ( ) {
  debug("Acquisition" , "execute");
  m_pga->enableStorage();
  m_evtNumber=application()->options()->nEvt()-1;
#ifdef WIN32
    double time_unit=1000000.;
#else
    double time_unit=1.e8;
#endif
  clock_t start=clock();
  double deadtime=(float)(m_deadtime);
  double elapsed=0.;
  if (m_trig) {m_pga->trigger();}
  bool dataready=false;
  while ((!dataready)&&(deadtime-elapsed>0)){    
      m_timestamp=(double)(clock());
//      wait(1);
      elapsed++;
//      elapsed=((double)(CLOCKS_PER_SEC))/time_unit*(m_timestamp-(double)(start));
      dataready=m_pga->dataReady();
//      if (0==((int(elapsed/10000.))%10)) warning("Waiting for the acknowledge");
  }
  if (!dataready){
    warning("Acquisition deadtime reached ("+
        itos(m_deadtime)+"). Execution stopped.");
    return StatusCode::FAILURE;
  }
  m_fifo->read();
  int nch, c;
  for (int d=0; d<m_depth; ++d){
    m_sample=d;
    nch=0; c=0;
    while (nch<m_nch) {
      if(m_chEnable[c]>0){
        m_channel[c]=decodeFormat(c,d,m_fifo);
//        info("sample "+itos(d)+"- channel "+itos(c)+" - value="+itos(m_channel[c]));
        if (m_store_hist) {
          v[c+8*d]+=m_channel[c];
          v2[c+8*d]+=m_channel[c]*m_channel[c];
        }
        if (m_nsample==d){
          if (m_store_sample) m_hsample[c]->Fill(m_channel[c]);
        }
        nch++;
      }
      c++;
    }
    if (m_store_tree) m_tree->Fill();
  }
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode Acquisition::finalize ( ) {
  int nch; int c;
  double val,tmp;
  if (m_store_tree) m_tree->Print();
  if (m_store_hist){
    for (int d=0; d<m_depth; ++d){
      nch=0; c=0;
      while (nch<m_nch){
        if((m_channels>>c)&1){
          tmp=v[c+8*d]/(m_evtNumber+1);
          m_a[c]->Fill(d,tmp);
          if (m_evtNumber>0){
            val=(v2[c+8*d]
                 -v[c+8*d]*tmp
                 )/(m_evtNumber);
            m_s[c]->Fill(d,val>0.?sqrt(val):0.);
          }
          nch++;
        }
        c++;
      }
    }
  }
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode Acquisition::setDepth (unsigned int depth) {
  if (depth>512){
    warning("Cannot acquire more than 512 consecutive events. Interrupt.");
    return StatusCode::FAILURE;
  }
  m_depth=depth;
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode Acquisition::setChannels(unsigned int channels) {
  if (channels>0xFF){
    channels=(channels&0xFF);
    warning("Channels coding not appropriate. Truncated at 0xFF.");
  }
  m_channels=channels;
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
unsigned int Acquisition::decodeFormat (unsigned int channel, unsigned int evt, RAM* ram){
  unsigned int val=0;
  switch (channel) {
  case 0: 
    val=ram->io()->dataU8(0+12*evt)+((ram->io()->dataU8(1+12*evt)&0xf)<<8);
    break; 
  case 1:
    val=(ram->io()->dataU8(1+12*evt)>>4)+(ram->io()->dataU8(2+12*evt)<<4);
    break;
  case 2:
    val=ram->io()->dataU8(3+12*evt)+((ram->io()->dataU8(4+12*evt)&0xf)<<8);
    break;
  case 3:
    val=(ram->io()->dataU8(4+12*evt)>>4)+(ram->io()->dataU8(5+12*evt)<<4);
    break;
  case 4:
    val=ram->io()->dataU8(6+12*evt)+((ram->io()->dataU8(7+12*evt)&0xf)<<8);
    break;
  case 5:
    val=(ram->io()->dataU8(7+12*evt)>>4)+(ram->io()->dataU8(8+12*evt)<<4); 
    break;
  case 6:
    val=ram->io()->dataU8(9+12*evt)+((ram->io()->dataU8(10+12*evt)&0xf)<<8); 
    break;
  case 7:
    val=(ram->io()->dataU8(10+12*evt)>>4)+(ram->io()->dataU8(11+12*evt)<<4);
    break;
  }
  return val;
}