run_raw_bmn.C

Go to the documentation of this file.

TString gRawRootFilePath = "";   // store intermediate RAW ROOT file path
/// Converts and/or decodes BM@N raw data file to a file with detector digits
///
/// The macro drives BmnRawDataDecoder through up to two steps:
///  1. conversion of the binary .data file into an intermediate RAW ROOT file
///     containing the electronics digits (ADC, TDC, ..., sync);
///  2. decoding of that RAW ROOT file into detector digits using the mapping
///     and calibration files selected for the given period, run and setup.
///
/// \param file          full path to the input raw file (.data for todo = 1 or 2;
///                      RAW ROOT file for todo = 0)
/// \param outfile       full path to the output file with detector digits;
///                      if empty, built as bmn_run<runId><_evXX_pXX><.compress>_digi.root
/// \param nEvents       number of events to process, 0 means all events
/// \param period        BM@N run period number, to pick up mapping and calibration files
/// \param todo          0 - RAW_ROOT -> DIGI, 1 - RAW -> DIGI, 2 - RAW -> RAW_ROOT
/// \param doHoldRawRoot if kFALSE, the intermediate RAW ROOT file is deleted after
///                      decoding (ignored when todo = 2)
void run_raw_bmn(TString file = "",
                 TString outfile = "",
                 Long_t nEvents = 0,
                 UInt_t period = 8,
                 UInt_t todo = 1,
                 Bool_t doHoldRawRoot = kTRUE)
{
    gSystem->ExpandPathName(file);
    gSystem->ExpandPathName(outfile);
    bool doConvert = (todo == 1) || (todo == 2);
    bool doDecode = (todo == 1) || (todo == 0);
 
    Int_t iVerbose = 0;   ///<- Verbosity level: 0 - summary info on progress; 1 - event level, 2 - event objects level,
                          ///< 3 - full debug output
    FairLogger::GetLogger()->SetLogToScreen(true);
    FairLogger::GetLogger()->SetLogScreenLevel("info");   // for info write "INFO"
 
    TStopwatch timer;
    TStopwatch timer_conv;
    timer.Start();
 
    BmnRawDataDecoder* rdd = new BmnRawDataDecoder(file, outfile, nEvents, period);
    BmnStatus convert_status;
    BmnStatus decode_status;
    //    rdd->SetRawRootDirPath("/dev/shm/temp_raw/");
    // use kSRCSETUP for Short-Range Correlation program and kBMNSETUP otherwise
    BmnSetup stp = kBMNSETUP;   //(decoder->GetRunId() >= 2041 && decoder->GetRunId() <= 3588) ? kSRCSETUP : kBMNSETUP;
    rdd->SetBmnSetup(stp);
    rdd->SetVerbose(iVerbose);
 
    std::map<DetectorId, bool> setup;       // flags to determine BM@N setup
    setup.insert(std::make_pair(kBC, 1));   // TRIGGERS
    // setup.insert(std::make_pair(kMWPC,      0)); // MWPC
    setup.insert(std::make_pair(kSILICON, 1));   // SILICON
    setup.insert(std::make_pair(kGEM, 1));       // GEM
    setup.insert(std::make_pair(kTOF1, 1));      // TOF-400
    // setup.insert(std::make_pair(kTOF, 1));       // TOF-700
    setup.insert(std::make_pair(kTOF701, 1));   // TOF-701
    setup.insert(std::make_pair(kDCH, 1));      // DCH
    // setup.insert(std::make_pair(kZDC,       0)); // ZDC
    // setup.insert(std::make_pair(kECAL,      0)); // ECAL
    setup.insert(std::make_pair(kCSC, 1));      // CSC
    setup.insert(std::make_pair(kSCWALL, 1));   // SCWALL
    setup.insert(std::make_pair(kFHCAL, 1));    // FHCAL
    setup.insert(std::make_pair(kHODO, 1));     // HODO
    setup.insert(std::make_pair(kNDET, 1));     // Neutron Calorimeter Prototype
    setup.insert(std::make_pair(kHGND, 1));     // Neutron Calorimeter
    setup.insert(std::make_pair(kSiBT, 1));     // SiBD
    setup.insert(std::make_pair(kVSP, 1));      // VSP
    rdd->SetDetectorSetup(setup);
 
    // Set converter/decoder general parameters
    rdd->SetDecoderConfigFileName(string(getenv("VMCWORKDIR")) + "/config/bmnconf.json");
 
    if (doConvert) {
        timer_conv.Start();
        BmnStatus convert_status = rdd->ConvertRawToRoot();   // Convert raw data in .data format into adc-,tdc-, ...,
                                                              // sync-digits in .root format
        if (convert_status == kBMNERROR)
            return;
        gRawRootFilePath = rdd->GetRootFileName();
        printf("Root File Name: %s\n", gRawRootFilePath.Data());
        timer_conv.Stop();
    }
 
    if (doDecode) {
        rdd->CreateDecoder();
        BmnDecoder* decoder = rdd->GetDecoder();
        TString PeriodSetupExt = Form("%d%s.txt", period, ((stp == kBMNSETUP) ? "" : "_SRC"));
        decoder->SetTrigPlaceMapping(TString("Trig_PlaceMap_Run") + PeriodSetupExt);
        decoder->SetTrigChannelMapping(TString("Trig_map_Run") + PeriodSetupExt);
        decoder->SetSiliconMapping(TString("SILICON_map_run") + PeriodSetupExt);
        decoder->SetSiBTMapping(TString("SiBT_map_period") + PeriodSetupExt);
        decoder->SetGemMapping(TString("GEM_map_run") + PeriodSetupExt);
        decoder->SetCSCMapping(TString("CSC_map_period")
                               + Form("%d%s%s.txt", period, ((stp == kBMNSETUP) ? "" : "_SRC"),
                                      (decoder->GetRunId() < 7013 ? "_before_run_7013" : "")));
        decoder->SetMSCMapping(TString("MSC_map_Run") + PeriodSetupExt);
        // in case comment out the line decoder->SetTof400Mapping("...")
        // the maps of TOF400 will be read from DB (only for JINR network)
        decoder->SetTof400Mapping(TString("TOF400_PlaceMap_RUN") + PeriodSetupExt,
                                  TString("TOF400_StripMap_RUN") + PeriodSetupExt);
        decoder->SetTof701Mapping(TString("TOF701_PlaceMap_RUN") + PeriodSetupExt,
                                  TString("TOF701_StripMap_RUN") + PeriodSetupExt);
        // decoder->SetZDCMapping("ZDC_map_period_5.txt");
        // decoder->SetZDCCalibration("zdc_muon_calibration.txt");
        decoder->SetScWallMapping(Form("SCWALL_map_period%d.json", period));
        decoder->SetFHCalMapping(TString("FHCAL_map_period") + PeriodSetupExt);
        decoder->SetFHCalCalibration(TString("FHCAL_calibration_period") + PeriodSetupExt);
        decoder->SetHodoMapping(Form("HODO_map_period%d.json", period));
        decoder->SetNdetMapping(TString("NDET_map_period") + PeriodSetupExt);
        if ((decoder->GetRunId() >= 7506 && decoder->GetRunId() <= 7534)
            || (decoder->GetRunId() >= 8203 && decoder->GetRunId() <= 8258))
            decoder->SetNdetCalibration(TString("NDET_calibration_period")
                                        + Form("%d_run_7506_7534_or_8203_8258.txt", period));
        else
            decoder->SetNdetCalibration(TString("NDET_calibration_period") + PeriodSetupExt);
        decoder->SetHgndMapping(Form("HGND_map_period%d.json", period));
        decoder->SetHgndCalibration(Form("HGND_calibration_period%d.json", period));
        // decoder->SetECALMapping(TString("ECAL_map_period_") + PeriodSetupExt);
        // decoder->SetECALCalibration("");
        // decoder->SetMwpcMapping(TString("MWPC_map_period") + ((period == 6 && decoder->GetRunId() < 1397) ? 5 :
        // PeriodSetupExt));
 
        decoder->SetApplyThreshold(kTRUE);         // set kFALSE to check pedestals
        decoder->SetUseCalibFile(kFALSE);          // set kTRUE to save and load strip signal calibration data
        decode_status = rdd->DecodeDataToDigi();   // Decode data into detector-digits using current mappings.
        if (!doHoldRawRoot) {
            printf("Removing %s\n", decoder->GetRootFileName().Data());
            gSystem->Exec(TString::Format("rm -f %s", decoder->GetRootFileName().Data()));
        }
        printf("Output digi file: %s\n", decoder->GetDigiFileName().Data());
    }
    timer.Stop();
 
    if ((doConvert && (convert_status == kBMNSUCCESS)) || (doDecode && (decode_status == kBMNSUCCESS)))
        printf("\tMacro finished successfully!\n\n");   // marker of successfully execution for software testing systems
    if (doConvert) {
        Double_t rtime_conv = timer_conv.RealTime();
        Double_t ctime_conv = timer_conv.CpuTime();
        printf("Converter: Real time %f s, CPU time %f s\n", rtime_conv, ctime_conv);
    }
    Double_t rtime = timer.RealTime();
    Double_t ctime = timer.CpuTime();
    printf("All steps: Real time %f s, CPU time %f s\n", rtime, ctime);
    delete rdd;
}