DCMSimulator.cpp

Go to the documentation of this file.

/* 
 * File:   DCMSimulator.cpp
 * Author: denis
 * 
 * Created on January 31, 2012, 5:15 PM
 */

#ifdef NOVACMAKE
#include "MockDataDAQ/include/DCMSimulator.h"
#include "MockDataDAQ/include/GlobalEventTime.h"
#include "MockDataDAQ/include/Configuration.h"
#else
#include "MockDataDAQ/DCMSimulator.h"
#include "MockDataDAQ/GlobalEventTime.h"
#include "MockDataDAQ/Configuration.h"
#endif

#include "DAQDataFormats/FEBSimulator.h"
#include "DAQDataFormats/RawMicroSlice.h"
#include "CMap/service/CMapService.h"

// ART includes
#include "art/Framework/Services/Registry/ServiceHandle.h"

namespace mcdatadaq{

//------------------------------------------------------------------------------
DCMSimulator::DCMSimulator(const daqchannelmap::diblock_t diblock, const daqchannelmap::dcm_id_t dcm):
              fDiblockNumber(diblock)
            , fDCMNumber(dcm)
            //, fMilliSlice(10000)
            , fOutputMicroslicesFile(NULL)
            , fOutputMillislicesFile(NULL)
{
    const Configuration* config = Configuration::getInstance();

    const daqdataformats::version_t nanoslice_version = config->getNanoSliceVersion();
    /// Construct 64 front-end-boards
    for(daqdataformats::link_id_t ifeb = 0; ifeb < 64; ifeb++){
        fFrontEndBoards.push_back(new daqdataformats::FEBSimulator(ifeb, nanoslice_version));
    }// end of loop over FEBs

    /// Setup the milliclice
    fMilliSlice.setDetId(config->getDetector());
    fMilliSlice.setDiblockId(diblock);
    fMilliSlice.setDCMId(fDCMNumber);
    fMilliSlice.setMonteCarloFlag(true);
    fMilliSlice.setComplete(true);
    fMilliSlice.setDestBuffID(1);

    /// Figure out the output file name for the MicroSlices for the DCM
    std::stringstream final_file_name_microslices_addition;
    final_file_name_microslices_addition<<"MicroSlices_Diblock"<<fDiblockNumber<<"_Dcmnum"<<fDCMNumber;
    const std::string final_file_name_microslices = config->getFullFileName(final_file_name_microslices_addition.str());

    /// Open the file
    fOutputMicroslicesFile = config->openFile(final_file_name_microslices);
    /// Now we need to write DAQ Simulation version in the beginning of the file
    config->writeDAQSimulatorVersionIntoFile(fOutputMicroslicesFile);

    if(config->isProducingMilliSlices()){

        /// Figure out the output file name for the MilliSlices for the DCM
        std::stringstream final_file_name_millislices_addition;
        final_file_name_millislices_addition<<"MilliSlices_Diblock"<<fDiblockNumber<<"_Dcmnum"<<fDCMNumber;
        const std::string final_file_name_millislices = config->getFullFileName(final_file_name_millislices_addition.str());
        
        /// Open the file
        fOutputMillislicesFile = config->openFile(final_file_name_millislices);
        /// Now we need to write DAQ Simulation version in the beginning of the file
        config->writeDAQSimulatorVersionIntoFile(fOutputMillislicesFile);
    }

}// end of constructor


//------------------------------------------------------------------------------
DCMSimulator::~DCMSimulator() {

    /// Delete 64 front-end-boards
    for(uint32_t ifeb = 0; ifeb < fFrontEndBoards.size(); ifeb++){
        delete fFrontEndBoards[ifeb];
    }// end of loop over FEBs

    /// Close the MicroSlices file
    if(fOutputMicroslicesFile) fclose(fOutputMicroslicesFile);

    /// Close the Millislice file
    if(fOutputMillislicesFile) fclose(fOutputMillislicesFile);
}// end of destructor

//------------------------------------------------------------------------------
bool DCMSimulator::generateNanoSlice(const daqchannelmap::dchan daqchannel, 
                                     const uint32_t simulated_time_stamp,
                                     const uint32_t pulse_height){

    std::vector <uint32_t> data;
    data.push_back(pulse_height);
    
    return generateNanoSlice(daqchannel, simulated_time_stamp, data);
    
}// end of generateNanoSlice

//------------------------------------------------------------------------------
bool DCMSimulator::generateNanoSlice(const daqchannelmap::dchan daqchannel,
                                     const uint32_t simulated_time_stamp,
                                     const std::vector<uint32_t>& data){
    
    art::ServiceHandle<cmap::CMap>  cmap;
    const Configuration*            config                      = Configuration::getInstance();

    /// Front End Board number
    const daqchannelmap::feb_t      feb                         = cmap->Map()->getFEB(daqchannel);

    /// Pixel Number on the APD
    const daqchannelmap::pixel_t    pixel                       = cmap->Map()->getPixel(daqchannel);

    /// Need to advance by the time of the event
    const GlobalEventTime*          global_event_time           = GlobalEventTime::getInstance();
    const uint32_t                  simulated_hit_time_in_event = simulated_time_stamp + uint32_t(global_event_time->getGlobalEventTime());

    /// Get the right FEB simulator for the FEB
    daqdataformats::FEBSimulator*   feb_simulator               = getFEBSimulator(feb);
    /// Generate a nanoslice in that FEB
    feb_simulator->generateNanoSlice(pixel, simulated_hit_time_in_event, data);

    /// Get that nanoslice
    daqdataformats::RawNanoSlice*   last_nanoslice_pointer = feb_simulator->getLastNanoSlice();

    /// The MicroSlice number corresponding to the nanoslice
    const uint32_t                microslice_number      = simulated_time_stamp / config->getMicrosliceDT();

    /// Fill that MicroSlice with the nanoslice that we have just generated
    fillMicroSlice(microslice_number, last_nanoslice_pointer);

    return true;
}

//------------------------------------------------------------------------------
daqdataformats::FEBSimulator* DCMSimulator::getFEBSimulator(const daqchannelmap::feb_t feb){return fFrontEndBoards[feb];}

//------------------------------------------------------------------------------
bool DCMSimulator::fillMicroSlice(const uint32_t microslice_number, daqdataformats::RawNanoSlice* nanoslice){

    /// Number of microslices created so far
    const uint32_t number_of_created_microslices_in_event = fMicroSlice.size();

    /// Create new microslices if needed
    for(uint32_t i_microslice = number_of_created_microslices_in_event; i_microslice <=microslice_number; i_microslice++){
        RawMicroSlice_shrptr microslice(createMicroSlice(i_microslice));
        fMicroSlice.push_back(microslice);

    }// end of creating new microslices if needed

    daqdataformats::RawMicroSlice* microslice = fMicroSlice[microslice_number].get();

    microslice->addNanoSlice(nanoslice->getBuffer());

    return true;
}// end of fillMicroSlice

//------------------------------------------------------------------------------
daqdataformats::RawMicroSlice* DCMSimulator::createMicroSlice(const uint32_t microslice_number){

    daqdataformats::RawMicroSlice* microslice       = new daqdataformats::RawMicroSlice();

    const Configuration*     config                   = Configuration::getInstance();
    const GlobalEventTime*   global_event_time        = GlobalEventTime::getInstance();
    const unsigned long long microslice_time_in_event = config->getMicrosliceDT()*microslice_number + global_event_time->getGlobalEventTime();
    
    microslice->setMonteCarloFlag(true);
    microslice->setTime(microslice_time_in_event);

    return microslice;
}// end of createMicroSlice


//------------------------------------------------------------------------------
daqdataformats::RawMilliSlice* DCMSimulator::fillMilliSlice(){
    
    const GlobalEventTime* global_event_time = GlobalEventTime::getInstance();
    fMilliSlice.setTimeStart(global_event_time->getGlobalEventTime());

    /// Add all microslices for the DCM into the millislice
    for(uint32_t imicro = 0; imicro < fMicroSlice.size(); imicro++){
        fMilliSlice.addMicroSlice(fMicroSlice[imicro]->getBuffer());
    }/// end of adding microslices
    /// Close MilliSlice
    fMilliSlice.close();

    return &fMilliSlice;
}// end of fillMilliSlice

//------------------------------------------------------------------------------
bool DCMSimulator::writeMicroSlices(){

    const Configuration* config        = Configuration::getInstance();

    /// Loop over Microslices and write them out
    for(uint32_t imicro = 0; imicro < fMicroSlice.size(); imicro++){
        config->writeToFile(fOutputMicroslicesFile, *(fMicroSlice[imicro]));
    }/// end of adding microslices

    return true;

}// end of writeMicroSlices

//------------------------------------------------------------------------------
bool DCMSimulator::writeMilliSlices(){

    const Configuration* config        = Configuration::getInstance();

    if(!config->isProducingMilliSlices()) return true;

    return config->writeToFile(fOutputMillislicesFile, fMilliSlice);
}// end of writeMicroSlices

//------------------------------------------------------------------------------
bool DCMSimulator::nextEvent(){

    // Next MilliSlice
    fMilliSlice.getHeader()->setSliceSize(fMilliSlice.getHeader()->sizeofdata());
    fMilliSlice.getHeader()->setMicrosliceNumber(0);
    fMilliSlice.getHeader()->advanceMilliSliceSEQ();
    fMilliSlice.setDestBuffID(fMilliSlice.getDestBuffID() + 1);
    
    fMicroSlice.clear();

    return true;
}// end of nextEvent

}// end of namespace