outputparameters.h

Go to the documentation of this file.

/*
 *    Copyright (c) 2017-
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 */
#ifndef SRC_INCLUDE_OUTPUTPARAMETERS_H_
#define SRC_INCLUDE_OUTPUTPARAMETERS_H_

#include <set>
#include <string>

#include "configuration.h"
#include "density.h"
#include "forwarddeclarations.h"
#include "logging.h"

namespace smash {

struct OutputParameters {
  OutputParameters()
      : td_position(ThreeVector()),
        td_dens_type(DensityType::None),
        td_rho_eckart(false),
        td_tmn(false),
        td_tmn_landau(false),
        td_v_landau(false),
        td_jQBS(false),
        td_smearing(true),
        part_extended(false),
        part_only_final(true),
        coll_extended(false),
        coll_printstartend(false),
        dil_extended(false),
        photons_extended(false),
        ic_extended(false) {}

  explicit OutputParameters(Configuration&& conf) : OutputParameters() {
    const auto& log = logger<LogArea::Experiment>();
    log.trace(source_location);

    if (conf.has_value({"Thermodynamics"})) {
      auto subcon = conf["Thermodynamics"];
      if (subcon.has_value({"Position"})) {
        const std::array<double, 3> a = subcon.take({"Position"});
        td_position = ThreeVector(a[0], a[1], a[2]);
      }
      std::set<ThermodynamicQuantity> quan = subcon.take({"Quantities"});
      td_rho_eckart = (quan.count(ThermodynamicQuantity::EckartDensity) > 0);
      td_tmn = (quan.count(ThermodynamicQuantity::Tmn) > 0);
      td_tmn_landau = (quan.count(ThermodynamicQuantity::TmnLandau) > 0);
      td_v_landau = (quan.count(ThermodynamicQuantity::LandauVelocity) > 0);
      td_jQBS = (quan.count(ThermodynamicQuantity::j_QBS) > 0);
      td_dens_type = subcon.take({"Type"}, DensityType::Baryon);
      if (td_dens_type == DensityType::None &&
          (td_rho_eckart || td_tmn || td_tmn_landau || td_v_landau)) {
        log.warn("Requested Thermodynamics output with Density type None. ",
                 "Change the density type to avoid output being dropped.");
      }
      td_smearing = subcon.take({"Smearing"}, true);
    }

    if (conf.has_value({"Particles"})) {
      part_extended = conf.take({"Particles", "Extended"}, false);
      part_only_final = conf.take({"Particles", "Only_Final"}, true);
    }

    if (conf.has_value({"Collisions"})) {
      coll_extended = conf.take({"Collisions", "Extended"}, false);
      coll_printstartend = conf.take({"Collisions", "Print_Start_End"}, false);
    }

    if (conf.has_value({"Dileptons"})) {
      dil_extended = conf.take({"Dileptons", "Extended"}, false);
    }

    if (conf.has_value({"Photons"})) {
      photons_extended = conf.take({"Photons", "Extended"}, false);
    }

    if (conf.has_value({"Initial_Conditions"})) {
      ic_extended = conf.take({"Initial_Conditions", "Extended"}, false);
    }
  }

  bool get_coll_extended(std::string name) const {
    if (name == "Collisions") {
      return coll_extended;
    } else if (name == "Dileptons") {
      return dil_extended;
    } else if (name == "Photons") {
      return photons_extended;
    } else {
      return false;  // error
    }
  }

  ThreeVector td_position;

  DensityType td_dens_type;

  bool td_rho_eckart;

  bool td_tmn;

  bool td_tmn_landau;

  bool td_v_landau;

  bool td_jQBS;

  bool td_smearing;

  bool part_extended;

  bool part_only_final;

  bool coll_extended;

  bool coll_printstartend;

  bool dil_extended;

  bool photons_extended;

  bool ic_extended;
};

}  // namespace smash

#endif  // SRC_INCLUDE_OUTPUTPARAMETERS_H_