Configuration.cpp

Go to the documentation of this file.

/* 
 * File:   Configuration.cpp
 * Author: denis
 * 
 * Configuration of the job
 *
 *
 * Created on February 1, 2012, 8:41 AM
 */
// ART includes
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "fhiclcpp/ParameterSet.h"

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

#include "Geometry/Geometry.h"
#include "NovaDAQConventions/DAQConventions.h"

#include <stdio.h>
#include <sys/stat.h>


namespace mcdatadaq{

Configuration* Configuration::finstanceID = NULL;

//------------------------------------------------------------------------------
Configuration* Configuration::getInstance(){
  if(finstanceID == NULL){                     // Check if there is an instance active
    finstanceID = new Configuration();       // If there is not, make a new one
  }
  return finstanceID;
}

//------------------------------------------------------------------------------
/// Method to set the class instance with parameters from fhicl
bool Configuration::setInstance(fhicl::ParameterSet const& parameters){

    /// If the configuration already exists, then we delete it
    if(!finstanceID) delete finstanceID;

    /// Issue a brand new Configuration
    finstanceID = new Configuration(parameters);

    return true;
}

//------------------------------------------------------------------------------
Configuration::Configuration():
    fDetector(novadaq::cnv::kUNKNOWN_DET)
    ,fNumberOfMicroslicesInMilliSlice(DEFAULT_NUMBER_MICROSLICES_IN_MILLISLICE)
    ,fMicrosliceDT(DEFAULT_DCM_MICROSLICE_DT)
    ,fNumberOfBufferNodes(DEFAULT_NUMBER_OF_BUFFERNODES)
    ,fOutputDir(".")
    ,fFileName("muon")
    ,fEventTimeDifference(DEFAULT_TIME_DIFF)
    ,fIsProducingJustMicroSlices(false)
    ,fIsProducingRunObject(false)
    ,fIsProducingMilliSlices(false)
    ,fNanoSliceVersion(DEFAULT_NANOSLICE_VERSION)
    ,fMicroBlockVersion(0)
{
    print();
}

//------------------------------------------------------------------------------
Configuration::Configuration(fhicl::ParameterSet const& parameters):
    fDetector(novadaq::cnv::kUNKNOWN_DET)
   ,fNumberOfMicroslicesInMilliSlice(parameters.get< uint32_t >("NumberOfMicroslicesInMilliSlice"))
   ,fMicrosliceDT(parameters.get< uint32_t >("MicrosliceDT"))
   ,fNumberOfBufferNodes(parameters.get< uint32_t >("NumberOfBufferNodes"))
   ,fOutputDir(parameters.get< std::string >("OutputDir"))
   ,fFileName(parameters.get< std::string >("FileName"))
   ,fEventTimeDifference(parameters.get< uint32_t >("EventTimeDifference"))
   ,fIsProducingJustMicroSlices(parameters.get< bool >("ProduceJustMicroSlices"))
   ,fIsProducingRunObject(parameters.get< bool >("FillRunObject"))
   ,fIsProducingMilliSlices(parameters.get< bool >("FillMilliSlices"))
   ,fNanoSliceVersion(parameters.get< daqdataformats::version_t >("NanoSliceVersion"))
   ,fMicroBlockVersion(parameters.get< daqdataformats::version_t >("MicroBlockVersion"))
{
    print();
    struct stat sb;
    assert((stat(fOutputDir.c_str(), &sb) == 0 && S_ISDIR(sb.st_mode)) && "Output directory doesn't exist or we don't have permissions to it, fail.");
}

//------------------------------------------------------------------------------
Configuration::~Configuration() { }

//------------------------------------------------------------------------------
bool Configuration::init(){

      art::ServiceHandle<geo::Geometry> geo;
      fDetector = geo->DetId();

      /// Checking if detectorID is invalid. If so, return false.
      if(fDetector <= novadaq::cnv::kUNKNOWN_DET ||
         fDetector >= novadaq::cnv::kNDetector) return false;

      
      std::cout<<"Setting detector to "<<novadaq::cnv::DetInfo::GetName(fDetector)<<"\n";

      return true;

}// end of init

//------------------------------------------------------------------------------
int         Configuration::getDetector() const { return fDetector;}
bool        Configuration::isDetectorUnknown() const            { return (fDetector == novadaq::cnv::kUNKNOWN_DET);}// end of isDetectorUnknown
uint32_t    Configuration::getMicrosliceDT() const              { return fMicrosliceDT;}
uint32_t    Configuration::getNumberOfBufferNodes() const       { return fNumberOfBufferNodes;}
std::string Configuration::getOutputDir() const                 { return fOutputDir;}
std::string Configuration::getFileName() const                  { return fFileName;}
uint32_t    Configuration::getEventTimeDifference() const       { return fEventTimeDifference;}
bool        Configuration::isProducingJustMicroSlices() const   { return fIsProducingJustMicroSlices;}
bool        Configuration::isProducingRunObject() const         { return fIsProducingRunObject;}


daqdataformats::version_t Configuration::getNanoSliceVersion() const { return fNanoSliceVersion;}
daqdataformats::version_t Configuration::getMicroBlockVersion() const { return fMicroBlockVersion;}

//------------------------------------------------------------------------------
std::string Configuration::getFullFileName(const std::string addition_to_file_name) const{

    const std::string file_extention = ".raw";
    const std::string full_file_name = getOutputDir()
                                     + "/"
                                     + getFileName()
                                     + "_"
                                     + addition_to_file_name
                                     + file_extention;
    return full_file_name;
}

//------------------------------------------------------------------------------
// Print Configuration
bool Configuration::print() const{

    std::cout<<"MockDataDAQ Configuration: ";
            
    std::cout<<"   Detector="<<fDetector<<std::endl;;
    std::cout<<"   Produce Just MicroSlices="<<fIsProducingJustMicroSlices<<std::endl;
    std::cout<<"   Producing MilliSlices="<<fIsProducingMilliSlices<<std::endl;
    std::cout<<"   Number Of Microslices In MilliSlice="<<fNumberOfMicroslicesInMilliSlice<<std::endl;;
    std::cout<<"   Microslice DT="<<fMicrosliceDT<<std::endl;;
    std::cout<<"   Number Of Buffer Nodes="<<fNumberOfBufferNodes<<std::endl;
    std::cout<<"   Event Time Difference="<<fEventTimeDifference<<std::endl;

    std::cout<<"   Output Directory:"<<fOutputDir<<std::endl;
    std::cout<<"   FileName:"<<fFileName<<std::endl;
    std::cout<<"   NanoSliceVersion:"<<fNanoSliceVersion<<std::endl;

    return true;
}

//------------------------------------------------------------------------------
/// Write data into a file
bool Configuration::writeToFile(FILE* file, const daqdataformats::RawDAQData& daq_data) const{

    /// If empty file, exit
    if(!file) return true;

    const size_t size_of_data_in_words = daq_data.sizeofdata();

    if(size_of_data_in_words == 0) return true;

    fwrite (daq_data.getBuffer(), 4, size_of_data_in_words, file);
    return true;
}

//------------------------------------------------------------------------------
// Open file for binary write access
FILE* Configuration::openFile(const std::string file_name) const {
    return fopen (file_name.c_str(), "wb");
}

//------------------------------------------------------------------------------
uint32_t Configuration::getDAQSimulatorVersion() const { return DAQSIMULATION_VERSION;}

//------------------------------------------------------------------------------
bool     Configuration::writeDAQSimulatorVersionIntoFile(FILE* file) const {

    const uint32_t daq_sim_version = getDAQSimulatorVersion();
    fwrite (&daq_sim_version, 4 , 1, file);

    return true;
}

}// end of namespace