JSupernovaProcessor.cc

Go to the documentation of this file.

#include <iostream>
#include <iomanip>
#include <queue>
#include <string>
 
#include "nlohmann/json.hpp"
 
#include "JDAQ/JDAQTimesliceIO.hh"
#include "JDAQ/JDAQEventIO.hh"
#include "JDAQ/JDAQSummarysliceIO.hh"
#include "JDAQ/JDAQTags.hh"
#include "JDAQ/JDAQEvaluator.hh"
 
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
 
#include "JNet/JControlHostObjectIterator.hh"
#include "JNet/JControlHost.hh"
 
#include "JLang/JObjectIterator.hh"
 
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"
#include "Jeep/JProperties.hh"
 
#include "JROOT/JROOTClassSelector.hh"
 
#include "JTrigger/JDAQHitToTSelector.hh"
 
#include "JSupport/JSupport.hh"
#include "JMath/JRandom.hh"
#include "JSupport/JTreeScanner.hh"
 
#include "JSupernova.hh"
 
#include "JSupernovaProcessor.hh"
 
using json = nlohmann::json;
 
/**
 * \file
 *
 * Online supernova processor
 * \author mlincett,selhedri,iagoos,gvannoye
 */
int main(int argc, char* argv[]) {
  using namespace std;
  using namespace JPP;
  using namespace KM3NETDAQ;
 
  string inputLigier;
  string ligierFireDrill;
  string inputFileName;
  string outputLigier;
  JTag outputTag, tagFireDrill;
  string outputFileName;
  int nEntries;
  int debug;
 
  string detectorFile;
  string domDetectorFile;
 
  JTimeval timeout_us = JTimeval(1e6); // timeout for input [us]
  int numberOfTimeouts = 1e3; // number of timeouts before stop
  int queueLength = 100; // number of timeslices of trigger queue
  int windowLength = 5; // number of timeslices of trigger sliding window
 
  int TMax_ns = 10; // coincidence time window [ns]
  int preTriggerThreshold = 4; // muon veto multiplicity threshold
  JDAQHitToTSelector totSelector_ns = JDAQHitToTSelector(4, 255); // hit selector
  double TVeto_ns = 1000; // muon veto time interval [ns]
  JRange<int> M = JRange<int>(6, 10); // multiplicity range for SN coincidence level
  JRange<int> M_BDT = JRange<int>(6, 10); // multiplicity range for SN coincidence level (with BDT)
 
  string summaryFile = ""; // summary output file
  int statPrintInterval_s = 30; // statistics & file print interval [s]
 
  try {
 
    JProperties properties;
    string properties_description = "\n";
 
    properties.setEndOfLine(";");
 
    properties.insert(gmake_property(timeout_us));
    properties_description.append("\ttimeout_us: timeout for input [us]\n");
    properties.insert(gmake_property(numberOfTimeouts));
    properties_description.append("\tnumberOfTimeouts: number of timeouts before stop\n");
    properties.insert(gmake_property(queueLength));
    properties_description.append("\tqueueLength: number of timeslices of trigger queue\n");
    properties.insert(gmake_property(windowLength));
    properties_description.append("\twindowLength: number of timeslices of trigger sliding window\n");
 
    properties.insert(gmake_property(TMax_ns));
    properties_description.append("\tTMax_ns: coincidence time window [ns]\n");
    properties.insert(gmake_property(preTriggerThreshold));
    properties_description.append("\tpreTriggerThreshold: muon veto multiplicity threshold\n");
    properties.insert(gmake_property(totSelector_ns));
    properties_description.append("\ttotSelector_ns: hit selector\n");
    properties.insert(gmake_property(TVeto_ns));
    properties_description.append("\tTVeto_ns: muon veto time interval [ns]\n");
    properties.insert(gmake_property(M));
    properties_description.append("\tM: multiplicity range for SN coincidence level\n");
    properties.insert(gmake_property(M_BDT));
    properties_description.append("\tM_BDT: multiplicity range for SN coincidence level (with BDT)\n");
 
    properties.insert(gmake_property(summaryFile));
    properties_description.append("\tsummaryFile: summary output file\n");
    properties.insert(gmake_property(statPrintInterval_s));
    properties_description.append("\tstatPrintInterval_s: statistics & file print interval [s]");
 
    JParser<> zap("Supernova realtime processor");
 
    zap['H'] = make_field(inputLigier, "Input Ligier server") = "";
    zap['l'] = make_field(ligierFireDrill, "Ligier server for the fire drill") = "";
    zap['g'] = make_field(tagFireDrill, "Ligier tag for the fire drill") = JTag("FDRILL");
    zap['f'] = make_field(inputFileName) = "";
    zap['L'] = make_field(outputLigier, "Output Ligier server") = "";
    zap['T'] = make_field(outputTag, "Output tag for the json messages") = JTag();
    zap['o'] = make_field(outputFileName, "Output json file name (no output to Ligier)") = "";
    zap['n'] = make_field(nEntries, "Number of entries to write") = -1;
    zap['a'] = make_field(detectorFile);
    zap['b'] = make_field(domDetectorFile) = "";
    zap['d'] = make_field(debug) = 1;
    zap['@'] = make_field(properties, properties_description) = JPARSER::initialised();
 
    zap(argc, argv);
 
  }
 
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
 
  if (queueLength <= windowLength) {
    FATAL("Length of the trigger window must be smaller than the queue.");
  }
 
 
  setDAQLongprint(debug >= JEEP::debug_t);
 
  using namespace JSUPERNOVA;
 
  // -------------------------------
  // load detector and build routers
  // -------------------------------
 
  JDetector detector;
  JDetector domDetector;
 
  try {
    load(detectorFile, detector);
  }
  catch(const JException& error) {
    FATAL(error);
  }
 
  try {
    load(domDetectorFile, domDetector);
  }
  catch(const JException& error) {
    domDetector = JDetector();
  }
 
  const JDAQHitRouter hitRouter(detector);
 
  const JModuleRouter& moduleRouter = hitRouter;
 
  const int DETID = detector.getID();
 
  const int detectorSize = detector.size();
 
  JSNFilterM F_M1(M, 1);
 
  // -------------------------------
  // initialize processing queue
  // -------------------------------
 
  typedef JTriggerSN trigger_type;
 
  typedef priority_queue<trigger_type, vector<trigger_type>, greater<trigger_type> > queue_type;
 
  typedef deque<trigger_type> window_type;
 
 
 
  typedef map<int, map<int, double> > rates_type; // (frameindex, DOMID) -> DOM rate [kHz]
  typedef map<int, int>               npmt_type ; // (frameindex)        -> # active PMTs
  typedef map<int, JVetoSet>          veto_type ; // (frameindex)        -> vetoes
 
  queue_type  trgQueue;
  window_type trgWindow;
  rates_type  rates;
  npmt_type   pmts;
  veto_type   veto;
  map<int, vector<int>> doms;
 
  JTriggerSNStats stats(detectorSize);
 
  long int counter_live_ts = 0;
  long int counter_lost_ts = 0;
 
  double frameTime_s = getFrameTime() / 1.0e9;
 
  // Initialize output file name and number of entries for testing
  ofstream outputFile;
  int nWrittenEntries = 0;
  if (outputFileName != ""){
    outputFile.open(outputFileName);
  }
 
  // -------------------------------
  // main processing
  // -------------------------------
 
  try {
 
    // setup input
 
    typedef JDAQTimesliceSN  data_type;
    typedef JDAQSummaryslice summary_type;
    typedef JDAQEvent        event_type;
 
    JObjectIterator<data_type>* in = NULL;
    JObjectIterator<summary_type>* sm = NULL;
    JObjectIterator<event_type>* ev = NULL;
 
    if (inputFileName != "") {
      in = new JTreeScanner<data_type, JDAQEvaluator>(inputFileName);
      sm = new JTreeScanner<summary_type, JDAQEvaluator>(inputFileName);
      ev = new JTreeScanner<event_type, JDAQEvaluator>(inputFileName);
 
    }
    else if (inputLigier != "") {
      in = new JControlHostObjectIterator<data_type>(inputLigier, timeout_us, true);
 
      // timeout for the asynchronous reading of summary and event data
      // needs to be smaller than the timeslice duration
      const double asyncTimeout_us = 1000.0;
 
      sm = new JControlHostObjectIterator<summary_type>(inputLigier, asyncTimeout_us, true);
      ev = new JControlHostObjectIterator<event_type>(inputLigier, asyncTimeout_us, true);
    }
    else { FATAL("Need either a root file or a ligier as input!" << endl); }
 
    JControlHost* out = NULL;
    if (outputLigier != "") {
      out = new JControlHost(outputLigier);
    }
 
    JControlHost fireDrill(ligierFireDrill);
 
    if (ligierFireDrill != "") {
      JSubscriptionList buffer;
      buffer.add(JSubscriptionAll(tagFireDrill));
 
      fireDrill.MyId("JGetMessage");
      fireDrill.Subscribe(buffer);
      fireDrill.SendMeAlways();
    }
 
    ofstream outputFile;
    if (outputFileName != "") {
      outputFile.open(outputFileName);
    }
 
    // setup state
 
    int RUN = 0;
    int timesliceSize = 0;
 
    // Fire drill variables
    int startedFireDrill = false;
    vector<char> fireDrillFile;
    JPrefix prefix;
    ifstream fireDrillData;
    int fireDrillTimeslice = 0;
    double fireDrillOffsetTime, timeFireDrill, MultFireDrill, RFireDrill, CThetaFireDrill, TotalToTFireDrill, DeltaTFireDrill;
    int timeSinceLastFireDrill = 10000;
 
    for (int i = 0; i != numberOfTimeouts; ) {
 
      if (in->hasNext()) {
 
        data_type* timeslice = in->next();
 
        DEBUG(timeslice->getDAQHeader() << endl);
 
        timesliceSize = timeslice->size();
 
        // --------------------------------
        // run number initialise and update
        // --------------------------------
 
        const int r = timeslice->getRunNumber();
 
        if (r != RUN) {
 
          if (RUN != 0) {
 
            NOTICE("RUN CHANGE" << endl);
 
            while (trgQueue.size() > 0) { trgQueue.pop(); }
 
            trgWindow.clear();
 
            rates.clear();
 
            pmts.clear();
 
            veto.clear();
 
          }
 
          RUN = r;
 
        }
 
        // ------------------------------
        // process pending summary slices
        // ------------------------------
 
        while ( sm->hasNext() ) {
 
          JDAQSummaryslice* summary = sm->next();
 
          DEBUG("SUM " << summary->getDAQHeader() << endl);
 
          int frame_index = summary->getFrameIndex();
 
          for (JDAQSummaryslice::const_iterator summary_frame = summary->begin();
               summary_frame != summary->end();
               ++summary_frame) {
 
            int DOMID = summary_frame->getModuleID();
 
            for (int ipmt = 0 ; ipmt < NUMBER_OF_PMTS ; ipmt++) {
              rates[frame_index][DOMID] += summary_frame->getRate(ipmt, 1.0/1000);
            }
 
            doms[frame_index].push_back(DOMID);
 
            pmts[frame_index] += summary_frame->countActiveChannels();
          }
 
        }
 
        while ( ev->hasNext() ) {
 
          JDAQEvent* event = ev->next();
 
          DEBUG("EVT " << event->getDAQHeader() << endl);
 
          int frame_index = event->getFrameIndex();
 
          veto[frame_index].push_back(JVeto(*event, hitRouter));
 
        }
 
        // -----------------
        // process timeslice
        // -----------------
 
        JDataSN preTrigger(TMax_ns, preTriggerThreshold);
 
        preTrigger(timeslice, moduleRouter, totSelector_ns, domDetector);
 
        JTriggerSN trigger(TVeto_ns);
 
        trigger(preTrigger);
 
        JTriggerSN trigger_final(TVeto_ns);
        trigger_final.frameIndex = trigger.frameIndex;
        trigger_final.timeUTC = trigger.timeUTC;
 
        //----------------
        // Inject fake CCSN candidates (fire drill)
        //----------------
 
        if (!startedFireDrill){
 
          timeSinceLastFireDrill += 0.1;
 
          // Get input file name for simulated CCSN signal
          int drill = fireDrill.CheckHead(prefix);
          if (drill){
            fireDrillFile.resize(prefix.getSize());
            fireDrill.GetFullData(fireDrillFile.data(), fireDrillFile.size());
          }
 
          // Determines whether to start fire drill and set
          // Enforce 100s wait time between fire drills to make sure the triggers do not pile up
          if (fireDrillFile.size()>0 && timeSinceLastFireDrill > 100) { 
            startedFireDrill = true;
            fireDrillOffsetTime = 0.05; // seconds
            fireDrillTimeslice = 0;
            string fireDrillFileName(fireDrillFile.begin()+1, fireDrillFile.end()-1); 
            fireDrillData.open(fireDrillFileName.c_str());
            timeFireDrill = -100;
          } else {
            trigger_final = trigger;
          }
        } 
 
        // Read simulated signal and inject it into data
        if (startedFireDrill) {
 
            double tmin = 0.1*fireDrillTimeslice;
            double tmax = tmin + 0.1;
 
            if (fireDrillTimeslice == 0) { // At start of injection, read first event in signal file
              fireDrillData >> timeFireDrill >> MultFireDrill >> CThetaFireDrill >> RFireDrill >> TotalToTFireDrill >> DeltaTFireDrill; 
              timeFireDrill += fireDrillOffsetTime;
            }
 
            // Read first event in timeslice (in real data)
            auto sn_it = trigger.begin();
            double event_time = (sn_it==trigger.end()) ? 100 : sn_it->getPeak().time/1.0e9; // If no data in timeslice set event time to large value
 
            // Iterate over signal file (text file)
            while (fireDrillData && timeFireDrill < tmax) {
 
              // Add data until we reach the time of the simulated event
              while(event_time < timeFireDrill-tmin && sn_it != trigger.end()) {
                trigger_final.push_back(*sn_it);
                sn_it++;
                if (sn_it != trigger.end()) event_time = sn_it->getPeak().time/1.0e9;
              }
 
              if (sn_it > trigger.begin() && event_time > timeFireDrill-tmin) sn_it -= 1; // Offset back one unit
 
              // Inject signal event
              if (timeFireDrill >= tmin && timeFireDrill < tmax) {
 
                // Get random DOM ID
                int frame_number = timeslice->getFrameIndex();
                int dom_id = doms[frame_number][(int) getRandom(0,(int)doms[frame_number].size())];
                // Build JCoincidenceSN object, put it in a JClusterSN, add to the trigger
                JCoincidenceSN sn((timeFireDrill-tmin)*1e9, (int) MultFireDrill, dom_id, 0, CThetaFireDrill, RFireDrill, DeltaTFireDrill, TotalToTFireDrill, -1, true);// the last argument "true" means the event is flagged as fake
                JClusterSN sncluster;
                sncluster.push_back(sn); // Neglect accidental coincidences with background events
                trigger_final.push_back(sncluster); // Add SN cluster to trigger
 
              }
 
              // Read new event
              fireDrillData >> timeFireDrill >> MultFireDrill >> CThetaFireDrill >> RFireDrill >> TotalToTFireDrill >> DeltaTFireDrill; 
              timeFireDrill += fireDrillOffsetTime;
 
            }
 
            // Pad with what remains of noise in timeslice
            while(sn_it != trigger.end()) {
              trigger_final.push_back(*sn_it);
              sn_it++;
            }
 
            fireDrillTimeslice++; // Increment the timeslice counter
 
            // If no signal left in file, fire drill injection is finished
            if (!fireDrillData){
              startedFireDrill = false;
              fireDrillFile.clear();
              timeSinceLastFireDrill = 0;
              fireDrillData.close();
            }
        
        }
 
        trgQueue.push(trigger_final);
 
        //----------------
        // compute trigger
        //----------------
 
        if ( trgQueue.size() >= (unsigned) queueLength ) {
 
          while ( trgWindow.size() <= (unsigned) windowLength ) {
 
            trigger_type pending = trgQueue.top();
 
            if ( trgWindow.size() == 0 || pending > trgWindow.back() ) {
 
              trgWindow.push_back( pending );
 
              counter_live_ts++;
 
            }
            else {
              // latecoming (out of order) timeslice
              counter_lost_ts++;
            }
 
            trgQueue.pop();
 
          }
        }
        else {
          NOTICE("Filling trigger queue: " << trgQueue.size() << "/" << queueLength << '\r');
        }
      }
 
      else if ( inputFileName != "" ) {
        // if we are reading from a file and we don't have timeslices anymore, we are at the end of the file
        // we can push the content of the queue to the trigger window to process it
        if ( trgQueue.size() > 0 ) {
          while ( trgQueue.size() > 0 ) {
            trgWindow.push_back(trgQueue.top());
            trgQueue.pop();
          }
        }
        else if ( trgWindow.size() < (unsigned) windowLength ) {
          i = numberOfTimeouts;
        }
      }
      else {
        NOTICE("timeout " << setw(3) << i << endl);
 
        ++i;
      }
 
      if (trgWindow.size() >= (unsigned) windowLength) {
 
        // build triggered modules with both data and simulated signal
 
        vector<double> observables;
        vector<int> multiplicities;
 
        int trg_cc_counts   = 0;
        int trg_cc_modules  = 0;
        set<int> cc_modules;
 
        int trg_ev_counts   = 0;
        int trg_ev_modules  = 0;
        set<int> ev_modules;
 
        // build triggered modules with only data
 
        vector<double> observables_nofakes;
        vector<int> multiplicities_nofakes;
 
        int trg_cc_counts_nofakes   = 0;
        int trg_cc_modules_nofakes  = 0;
        set<int> cc_modules_nofakes;
 
        int trg_ev_counts_nofakes   = 0;
        int trg_ev_modules_nofakes  = 0;
        set<int> ev_modules_nofakes;
 
        // loop over the trigger window and count the triggers
        for (int its = 0; its < windowLength; its++) {
 
          const int frame_index = trgWindow[its].frameIndex;
 
          JVetoSet vetoSet;
          if (veto.count(frame_index)) {
            vetoSet = veto.at(frame_index);
          }
 
          JSNFilterMV F_MV(M, vetoSet);
          JSNFilterMV F_MV_BDT(M_BDT, vetoSet);
 
          set<int> cc_vec = trgWindow[its].getModules(F_M1);
          set<int> ev_vec = trgWindow[its].getModules(F_MV);
 
          // Get cluster and event counts without the simulated CCSN signal
          set<int> cc_vec_nofakes;
          set<int> ev_vec_nofakes;
 
          for (auto &trg: trgWindow[its]){
            if (F_M1(trg)){
              if (!trg.getPeak().fake) trg_cc_counts_nofakes++;
              for (auto &snc: trg){
                if (!snc.fake){
                  cc_vec_nofakes.insert(snc.moduleID);
                }
              }
            }
            if (F_MV(trg)){
              if (!trg.getPeak().fake) trg_ev_counts_nofakes++;
              for (auto &snc: trg){
                if (!snc.fake){
                  ev_vec_nofakes.insert(snc.moduleID);
                }
              }
            }
          }
 
          cc_modules.insert(cc_vec.begin(), cc_vec.end());
          ev_modules.insert(ev_vec.begin(), ev_vec.end());
 
          cc_modules_nofakes.insert(cc_vec_nofakes.begin(), cc_vec_nofakes.end());
          ev_modules_nofakes.insert(ev_vec_nofakes.begin(), ev_vec_nofakes.end());
 
          trg_cc_counts += count_if(trgWindow[its].begin(), trgWindow[its].end(), F_M1);
          trg_ev_counts += count_if(trgWindow[its].begin(), trgWindow[its].end(), F_MV);
 
          // Write table of observables
          for (auto &trg: trgWindow[its]){
            auto sn_candidate = trg.getPeak();
            if (F_MV_BDT(sn_candidate)){
              multiplicities.push_back(sn_candidate.multiplicity);
              observables.push_back(sn_candidate.total_ToT);
              observables.push_back(sn_candidate.deltaT);
              observables.push_back(sn_candidate.mean_dir_norm);
              observables.push_back(sn_candidate.mean_dir_ctheta);
 
              if (!sn_candidate.fake){
                multiplicities_nofakes.push_back(sn_candidate.multiplicity);
                observables_nofakes.push_back(sn_candidate.total_ToT);
                observables_nofakes.push_back(sn_candidate.deltaT);
                observables_nofakes.push_back(sn_candidate.mean_dir_norm);
                observables_nofakes.push_back(sn_candidate.mean_dir_ctheta);
              }
            }
          }
        }
 
        trg_cc_modules = cc_modules.size();
        trg_ev_modules = ev_modules.size();
 
        trg_cc_modules_nofakes = cc_modules_nofakes.size();
        trg_ev_modules_nofakes = ev_modules_nofakes.size();
 
        // trigger window slide of one element
 
        int currentFrame             = trgWindow[0].frameIndex;
        JDAQUTCExtended currentTime  = trgWindow[0].timeUTC;
 
        trgWindow.pop_front();
 
        // calculate trigger
 
        ++stats[trg_cc_counts];
 
        // calculate active modules
 
        int    activeModules =  -1;
        double detectorRate  = 0.0;
 
        if (!rates.empty()          &&
              rates.count(currentFrame)) {
 
          activeModules = 0;
 
          for (map<int, double>::const_iterator p = rates.at(currentFrame).begin();
               p != rates.at(currentFrame).end(); p++ ) {
 
            detectorRate  += p->second;
 
            activeModules += (p->second > 0);
 
          }
        } else {
 
          activeModules = timesliceSize;
 
        }
 
        // build summary message
 
        json jd;
        string daq_time = to_string(currentTime);
 
        // Output with only data (even in case of a signal injection)
        jd[detid_name]                     = DETID;
        jd[active_doms_name]               = activeModules;
        jd[detector_rate_name]             = int(detectorRate / 1000.0);
        jd[run_number_name]                = RUN;
        jd[frame_index_name]               = currentFrame;
        jd[daq_time_name]                  = daq_time;
        jd[trigger_name][cc_name][c_name]  = trg_cc_counts_nofakes;
        jd[trigger_name][cc_name][m_name]  = trg_cc_modules_nofakes;
        jd[trigger_name][ev_name][c_name]  = trg_ev_counts_nofakes;
        jd[trigger_name][ev_name][m_name]  = trg_ev_modules_nofakes;
        jd[active_pmts_name]               = pmts[currentFrame];
        jd[observables_name]               = observables_nofakes;
        jd[multiplicities_name]            = multiplicities_nofakes;
 
        string msg = jd.dump();
 
        DEBUG(msg << endl);
 
        // If a simulated signal has been injected, write the corresponding output
        // DET ID is set to a negative value to distinguish it from the real output
        string msg2 = "";
        if (multiplicities.size() != multiplicities_nofakes.size()){
          jd[detid_name]                     = -DETID;
          jd[active_doms_name]               = activeModules;
          jd[detector_rate_name]             = int(detectorRate / 1000.0);
          jd[run_number_name]                = RUN;
          jd[frame_index_name]               = currentFrame;
          jd[daq_time_name]                  = daq_time;
          jd[trigger_name][cc_name][c_name]  = trg_cc_counts;
          jd[trigger_name][cc_name][m_name]  = trg_cc_modules;
          jd[trigger_name][ev_name][c_name]  = trg_ev_counts;
          jd[trigger_name][ev_name][m_name]  = trg_ev_modules;
          jd[active_pmts_name]               = pmts[currentFrame];
          jd[observables_name]               = observables;
          jd[multiplicities_name]            = multiplicities;
 
          msg2 = jd.dump();
 
          DEBUG(msg2 << endl);
        }
 
        if (outputFileName != ""){
          if (nWrittenEntries < nEntries || nEntries == -1) {
            // write summary information to output file (first nEntries)
            outputFile << msg << endl;
            nWrittenEntries++;
          }
          else {
            // When entries written, close output file and exit loop
            outputFile.close();
            break;
          }
        }
        else {
          // send summary information to output ligier
 
          if (out != NULL) {
            if (msg2 != "") out->PutFullString(outputTag, msg2);
            out->PutFullString(outputTag, msg);
          }
        }
 
        // print stats
 
        if ( (counter_live_ts % ((int)(statPrintInterval_s / frameTime_s)) == 0 ) ) {
 
          double livetime = counter_live_ts * frameTime_s;
 
          stats.setLiveTime(livetime);
 
          NOTICE(endl);
          NOTICE(stats.toString());
          NOTICE("=> discarded out-of-order timeslices = " << counter_lost_ts << endl);
 
          if (summaryFile != "") {
            ofstream of(summaryFile.c_str());
            of << stats.toSummaryFile();
            of.close();
          }
 
        }
      }
    }
  }
 
  catch(const JSocketException& error) {
    ERROR(error.what() << endl);
  }
 
  if (outputFileName != "") { outputFile.close(); }
 
}