StorageFifoAcquisition.cpp

Go to the documentation of this file.

// $Id: $

// include files

// local
#include "Proto40MHz_v1.h"
#include "A3PE.h"
#include "RAM.h"
#include "StorageFifoAcquisition.h"

//-----------------------------------------------------------------------------
// Implementation file for class : StorageFifoAcquisition
//
// 2006-10-23 :²
//-----------------------------------------------------------------------------

//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
StorageFifoAcquisition::StorageFifoAcquisition(  ) :
  m_channels(0xFF),
  m_nbins(100),
  m_minRange(0.),
  m_maxRange(4095),
  m_depth(5)
{
  setName ( "StorageFifoAcquisition" );
  setType ( "Proto40MHz_v1" );
  setTitle( "Proto40MHz_v1 Storage Fifo" );
}
//=============================================================================
// Destructor
//=============================================================================
StorageFifoAcquisition::~StorageFifoAcquisition() {} 

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

//=========================================================================
//
//=========================================================================
StatusCode StorageFifoAcquisition::initialize ( ) {
  debug("StorageFifoAcquisition" , "initialize");

  info("" );
  info("____________________________");
  info("Proto 40 MHZ - Storage FIFO Acquisition");
  info(" =>" + element()->path() + " " +
       element()->name() + " " + element()->type() );

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

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

  for (int i=0; i<8; ++i){
    for (unsigned int d=0; d<m_depthmax; ++d){
      m_h[m_depthmax*i+d]=0;
    }
  }

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

  for (int i=0; i<8; ++i) m_pga->setEnableADC(i,true);
    
  int channel=m_channels;
  char name[100], title[100];
  for (int i=0; i<8; ++i){
    if ((channel>>i)&1==1){
      for (unsigned int d=0; d<m_depth; ++d){
    sprintf(name,"Ch_%i_%i",i,d);
    sprintf(title,"Ch %i - %i",i,d);
    m_h[m_depth*i+d]=new TH1D(name, title , m_nbins , m_minRange, m_maxRange);
    addHisto1d(m_h[m_depth*i+d]);
      }
      sprintf(name,"Ch_%i_sigma",i);
      sprintf(title,"Ch %i Sigma",i);
      m_sh[i]=new TH1D(name, title, m_depth , 0., m_depth);
      addHisto1d(m_sh[i]);
      sprintf(name,"Ch_%i_average",i);
      sprintf(title,"Ch %i Average",i);
      m_ah[i]=new TH1D(name, title, m_depth , 0., m_depth);
      addHisto1d(m_ah[i]);
    }
  }
  return StatusCode::SUCCESS;
}


//=========================================================================
//
//=========================================================================
StatusCode StorageFifoAcquisition::execute ( ) {
  debug("StorageFifoAcquisition" , "execute");

  m_pga->acquisition();
  m_fifo->read();
    
  int channel=m_channels;

  int val[12], data[12];
  for (unsigned int d=0; d<m_depth; ++d){
    //      d+=0.5;
    val[0] =m_fifo->io()->dataU8( 0+12*d);
    val[1] =m_fifo->io()->dataU8( 1+12*d);
    val[2] =m_fifo->io()->dataU8( 2+12*d);
    val[3] =m_fifo->io()->dataU8( 3+12*d);
    val[4] =m_fifo->io()->dataU8( 4+12*d);
    val[5] =m_fifo->io()->dataU8( 5+12*d);
    val[6] =m_fifo->io()->dataU8( 6+12*d);
    val[7] =m_fifo->io()->dataU8( 7+12*d);
    val[8] =m_fifo->io()->dataU8( 8+12*d);
    val[9] =m_fifo->io()->dataU8( 9+12*d);
    val[10]=m_fifo->io()->dataU8(10+12*d);
    val[11]=m_fifo->io()->dataU8(11+12*d);
    data[0]=val[0]+((val[1]&0xf)<<8);
    data[1]=(val[1]>>4)+(val[2]<<4);
    data[2]=val[3]+((val[4]&0xf)<<8);
    data[3]=(val[4]>>4)+(val[5]<<4);
    data[4]=val[6]+((val[7]&0xf)<<8);
    data[5]=(val[7]>>4)+(val[8]<<4);
    data[6]=val[9]+((val[10]&0xf)<<8);
    data[7]=(val[10]>>4)+(val[11]<<4);
    for (int i=0; i<8; ++i){
      if ((channel>>i)&1==1){
    m_h[m_depth*i+d]->Fill(data[i]);
      }
    }
  }
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode StorageFifoAcquisition::finalize ( ) {
  int channel=m_channels;
  for (int i=0; i<8; ++i){
    if ((channel>>i)&1==1){
      for (unsigned int d=0; d<m_depth; ++d){
    m_ah[i]->Fill(i,m_h[m_depth*i+d]->GetMean());
    m_sh[i]->Fill(i,m_h[m_depth*i+d]->GetRMS());
      }
    }
  } 
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode StorageFifoAcquisition::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 StorageFifoAcquisition::setChannels(unsigned int channels) {
  if (channels>0xFF){
    channels=(channels&0xFF);
    warning("Channels coding not appropriate. Truncated at 0xFF.");
  }
  m_channels=channels;
  return StatusCode::SUCCESS;
}