A3PE_BitFlip.cpp

Go to the documentation of this file.

// $Id: $

// include files
#include <fstream>
#include <iostream>
#include <string>

#include "TH1D.h"

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

//-----------------------------------------------------------------------------
// Implementation file for class : A3PE_BitFlip
//
// 2012-07-12 :
//-----------------------------------------------------------------------------

//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
A3PE_BitFlip::A3PE_BitFlip(  ) :
  m_filename(std::string("")),
  m_offset(-6),
  m_latencyMin(1000),
  m_latencyMax(100000),
  m_hLatency (0),
  m_hErrorsLatency(0),
  m_hErrorsWord(0)
{
  setName ( "A3PE_BitFlip" );
  setType ( "Proto40MHz_v1" );
  setTitle( "Proto40MHz_v1 A3PE_BitFlip test" );
}
//=============================================================================
// Destructor
//=============================================================================
A3PE_BitFlip::~A3PE_BitFlip() {}

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

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

  info("" );
  info("____________________________");
  info("A3PE bit flip test");
  info(" =>" + element()->path() + " " +
      element()->name() + " " + element()->type() );

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

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

  m_pga=m_board->a3pe();
  m_fromAX = m_pga->fromAXRam();
  m_toAX   = m_pga->toAXRam();

  m_data         =m_toAX->io()->dataU8();
  m_dataProcessed=m_fromAX->io()->dataU8();

  m_length=m_pga->lengthAX();
  m_latency=m_pga->latencyAX();

  if (m_pga->internalAXSequence()){
    m_offset=-2;}
  else {
    m_offset=-5;
  }

  if (m_filename!=std::string("")){
      m_pga->loadToAX(m_filename);
      info("Static RAM mode ["+m_filename+"].");
  }
  else
    info("Dynamic Random RAM mode.");
  if (0==m_latency) info("Latency = random");
  else info("Latency ="+itos(m_latency));
  info("Length  ="+itos(m_length));
  info("Offset  ="+itos(m_offset));

  warning("In internal loop the offset should be -3 with a Latency of 4 at least"); 
  warning("In external loop the offset should be -6 with a Latency of 5 at least"); 
  warning("The offset for this run is "+itos(m_offset));

  m_hLatency=new TH1D("Latency","Latency", 100, m_latencyMin, m_latencyMax );
  m_hErrorsLatency =new TH1D("ErrorsLatency","Errors (Latency)", 100, m_latencyMin, m_latencyMax);
  m_hErrorsWord =new TH1D("ErrorsWord","Errors (Word)", 100, 0, m_length);
  addHisto1d( m_hLatency );
  addHisto1d( m_hErrorsLatency );
  addHisto1d( m_hErrorsWord );

  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode A3PE_BitFlip::execute ( ) {
  debug("A3PE_BitFlip" , "execute");
  unsigned long latency;    

  if (0==m_latency){
        latency=m_latencyMin+((float)(rand())/RAND_MAX*((float)(m_latencyMax-m_latencyMin)));
        m_pga->setLatencyAX(latency);
  }
  else latency=m_latency;

  if (m_filename==std::string("")){
      randomValues();
  }
  
  m_hLatency->Fill((float)(latency));
  m_pga->startSequenceAX();

  m_pga->setAXRamUsb(true);
  m_pga->setAddFromAXRam(0);
  m_fromAX->read();

  bool error=false;

  char line[100];
  bool errLatencySeen=false;
  for (unsigned int d=0; d<m_length; ++d){
    unsigned int position=(d+latency+m_offset)%512;
    if ((m_dataProcessed[4*d]!=m_data[4*position])||
    (m_dataProcessed[4*d+1]!=m_data[4*position+1])||
    (m_dataProcessed[4*d+2]!=m_data[4*position+2])||
    (m_dataProcessed[4*d+3]!=m_data[4*position+3]))
      {
        if (!errLatencySeen) {
            m_hErrorsLatency->Fill((float)(latency));
            errLatencySeen=true;
        }
        m_hErrorsWord->Fill((float)(d));
    sprintf(line,"%3d -> %1d %1d %1d %1d / %1d %1d %1d %1d",
        d,
        m_dataProcessed[4*d],m_dataProcessed[1+4*d],m_dataProcessed[2+4*d],m_dataProcessed[3+4*d],
        m_data[4*position],m_data[1+4*position],m_data[2+4*position],m_data[3+4*position]);
    warning(line);
      error = true;
      }
  }
  if (error) return StatusCode::FAILURE;
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode A3PE_BitFlip::finalize ( ) {
  if (0==m_latency) m_pga->setLatencyAX(0);
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode A3PE_BitFlip::randomValues () {
  m_pga->setAXRamUsb(true);
  m_pga->setAddToAXRam(0);
  int depth=m_toAX->depth();

  for (int i=0; i<depth ; ++i){
    m_data[4*i  ]=(unsigned int) ( (float)rand()/RAND_MAX * 255. );
    m_data[4*i+1]=(unsigned int) ( (float)rand()/RAND_MAX * 255. );
    m_data[4*i+2]=(unsigned int) ( (float)rand()/RAND_MAX * 255. );
    m_data[4*i+3]=(unsigned int) ( (float)rand()/RAND_MAX * 255. );
  }

  m_toAX->write();
  return StatusCode::SUCCESS;
}