EmulateFE.cpp

Go to the documentation of this file.

// $Id: $

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

#include "TH1D.h"

// local
#include "FEB_v1.h"
//#include "Run.h"
//#include "Event.h"
#include "EmulateFE.h"

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

//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
EmulateFE::EmulateFE(  ) :
  m_filename(std::string("")),
  m_typeGeneration (0),
  m_signalRate(0.05),
  m_pedestal(128),
  m_noise(30),
  m_ntriggersMax(0),
  m_ntriggers(0),
  m_options(application()->options())
{
  setName ( "EmulateFE" );
  setType ( "FEB_v1" );
  setTitle( "FEB_v1 EmulateFE processing" );
}
//=============================================================================
// Destructor
//=============================================================================
EmulateFE::~EmulateFE() {}

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

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

  info("" );
  info("____________________________");
  info("FE emulation");
  info(" =>" + element()->path() + " " +
      element()->name() + " " + element()->type() );

  if (m_filename==std::string("")){
    warning("No ADC output data storage.");
    if (m_ntriggersMax<1){
      warning("No output file storage and no trigger. There is no processing to perform. Bad configuration.");
      return StatusCode::FAILURE;
    }
  }
  if ((m_filename!=std::string(""))&(m_options->dataStorage())){
    info("Input data will be stored in files "+m_filename);
  }
  m_nFile = 0;
  m_board=dynamic_cast<FEB_v1*>( element() );
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode EmulateFE::execute ( ) {
  debug("EmulateFE" , "execute");
  generateValues();
  if (m_filename!=std::string("") & m_options->dataStorage()){
    generateFile();
  }
  if (m_ntriggersMax>0){
    processingFE();
  }
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode EmulateFE::finalize ( ) {
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode EmulateFE::generateValues () {
  if (m_typeGeneration==0){
    for (int i=0; i<4096; ++i){
      m_adcin[4*i]   = m_random.Rndm()*4096;
      m_adcin[4*i+1] = m_random.Rndm()*4096;
      m_adcin[4*i+2] = m_random.Rndm()*4096;
      m_adcin[4*i+3] = m_random.Rndm()*4096;
    }
  }
  else {
    for (int i=0; i<4096; ++i){
      float noise0 = m_random.Gaus(m_pedestal, m_noise);
      float noise1 = m_random.Gaus(m_pedestal, m_noise);
      float noise2 = m_random.Gaus(m_pedestal, m_noise);
      float noise3 = m_random.Gaus(m_pedestal, m_noise);
      float sig0   = m_random.Rndm();
      float sig1   = m_random.Rndm();
      float sig2   = m_random.Rndm();
      float sig3   = m_random.Rndm();
      if (m_random.Rndm()<m_signalRate){ m_adcin[4*i]=noise0+(m_random.Rndm()*(4096-noise0)); }
      else m_adcin[4*i]=noise0;
      if (m_random.Rndm()<m_signalRate){ m_adcin[4*i+1]=noise1+(m_random.Rndm()*(4096-noise1)); }
      else m_adcin[4*i+1]=noise1;
      if (m_random.Rndm()<m_signalRate){ m_adcin[4*i+2]=noise2+(m_random.Rndm()*(4096-noise2)); }
      else m_adcin[4*i+2]=noise2;
      if (m_random.Rndm()<m_signalRate){ m_adcin[4*i+3]=noise3+(m_random.Rndm()*(4096-noise3)); }
      else m_adcin[4*i+3]=noise3;
    }    
  }
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode EmulateFE::generateFile () {
  std::string filename = m_options->storageFullPath();
  filename.append("/");
  filename.append(m_filename);
  filename.append("_");
  filename.append(itos(m_nFile));
  filename.append(".data");
  std::ofstream inputData;
  inputData.open( filename.c_str() );

  time_t rawtime;
  struct tm * timeinfo;  
  time ( &rawtime );
  timeinfo = localtime ( &rawtime );
  char* timechar =  asctime (timeinfo) ;
  std::string timing = std::string(timechar,24) + " ";

  if ( !inputData.fail() ){
    inputData<<"#################################################"<<std::endl;
    inputData<<"# Date : "<<timing<<std::endl;
    inputData<<"# Type of Generation : "<<m_typeGeneration<<std::endl;
    inputData<<"#      0 : Flat generation "<<std::endl;
    inputData<<"#      1 : Gaussian noise + Flat signal "<<std::endl;
    inputData<<"#                 Signal rate : "<<m_signalRate<<std::endl;
    inputData<<"#                 Pedestal    : "<<m_pedestal<<std::endl;
    inputData<<"#                 Noise width : "<<m_noise<<std::endl;    
    inputData<<"#################################################"<<std::endl;
    for (int i=0; i<4096; ++i){
      char buffer[50];
      sprintf (buffer, "%5i %5i %5i %5i \n",m_adcin[4*i], m_adcin[4*i+1], m_adcin[4*i+2], m_adcin[4*i+3]);
      inputData<<buffer;
    }
  }
  m_nFile++;
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode EmulateFE::processingFE () {
  return StatusCode::SUCCESS;
}