messages.h

Go to the documentation of this file.

 
#ifndef messages_h
#define messages_h
 
#include <fstream>
#include <iostream>
 
#include "arts.h"
#include "arts_omp.h"
 
class Verbosity {
 public:
  Verbosity() : va(0), vs(0), vf(0), in_main_agenda(false) {}
 
  Verbosity(Index vagenda, Index vscreen, Index vfile)
      : va(vagenda), vs(vscreen), vf(vfile), in_main_agenda(false) {}
 
  bool valid() const {
    return (va >= 0 && va <= 3) && (vs >= 0 && vs <= 3) && (vf >= 0 && vf <= 3);
  }
 
  Index get_agenda_verbosity() const { return va; }
  Index get_screen_verbosity() const { return vs; }
  Index get_file_verbosity() const { return vf; }
  bool is_main_agenda() const { return in_main_agenda; }
 
  void set_agenda_verbosity(Index v) { va = v; }
  void set_screen_verbosity(Index v) { vs = v; }
  void set_file_verbosity(Index v) { vf = v; }
  void set_main_agenda(bool main_agenda) { in_main_agenda = main_agenda; }
 
  friend ostream& operator<<(ostream& os, const Verbosity& v);
 
 private:
  Index va;
  Index vs;
  Index vf;
  bool in_main_agenda;
};
 
class ArtsOut {
 public:
  ArtsOut(const int p, const Verbosity& v) : verbosity(v), priority(p) {}
 
  int get_priority() const { return priority; }
  const Verbosity& get_verbosity() const { return verbosity; }
 
  bool sufficient_priority() const {
    return (sufficient_priority_agenda() &&
            (sufficient_priority_screen() || sufficient_priority_file()));
  }
 
  bool sufficient_priority_agenda() const {
    return (in_main_agenda() || verbosity.get_agenda_verbosity() >= priority);
  }
 
  bool sufficient_priority_screen() const {
    return verbosity.get_screen_verbosity() >= priority;
  }
 
  bool sufficient_priority_file() const {
    return verbosity.get_file_verbosity() >= priority;
  }
 
  bool in_main_agenda() const { return verbosity.is_main_agenda(); }
 
 private:
  const Verbosity& verbosity;
  int priority;
};
 
class ArtsOut0 : public ArtsOut {
 public:
  ArtsOut0(const Verbosity& v) : ArtsOut(0, v) {}
};
 
class ArtsOut1 : public ArtsOut {
 public:
  ArtsOut1(const Verbosity& v) : ArtsOut(1, v) {}
};
 
class ArtsOut2 : public ArtsOut {
 public:
  ArtsOut2(const Verbosity& v) : ArtsOut(2, v) {}
};
 
class ArtsOut3 : public ArtsOut {
 public:
  ArtsOut3(const Verbosity& v) : ArtsOut(3, v) {}
};
 
template <class T>
ArtsOut& operator<<(ArtsOut& aos, const T& t) {
  extern ofstream report_file;
 
  // cout << "Printing object of type: " << typeid(t).name() << "\n";
 
  // If we are not in the main agenda, then the condition for agenda
  // output must be fulfilled in addition to the condition for
  // screen or file.
 
  if (aos.sufficient_priority_agenda()) {
    // We are marking the actual output operations as omp
    // critical, to somewhat reduce the mess when several threads
    // output simultaneously.
 
    // This works well if the output operations themselves are
    // atomic, that is if a string is prepared beforehand and then
    // put to outx with a single << operation.
 
    if (aos.sufficient_priority_screen()) {
#pragma omp critical(ArtsOut_screen)
      {
        if (aos.get_priority() == 0)
          cerr << t << flush;
        else
          cout << t << flush;
      }
    }
 
    if (aos.sufficient_priority_file()) {
#pragma omp critical(ArtsOut_file)
      {
        //    if (report_file)              // Check if report file is good
        report_file << t << flush;
        // The flush here is necessary to make the output really
        // appear in the report file. We are not producing a huge
        // amount of output to the report file, so I think the
        // performance penalty here is acceptable.
      }
    }
  }
 
  return aos;
}
 
#define CREATE_OUT0 ArtsOut0 out0(verbosity)
#define CREATE_OUT1 ArtsOut1 out1(verbosity)
#define CREATE_OUT2 ArtsOut2 out2(verbosity)
#define CREATE_OUT3 ArtsOut3 out3(verbosity)
 
#define CREATE_OUTS         \
  ArtsOut0 out0(verbosity); \
  ArtsOut1 out1(verbosity); \
  ArtsOut2 out2(verbosity); \
  ArtsOut3 out3(verbosity)
 
#endif  // messages_h