Line data    Source code

       1             : #include "crpropa/module/Output.h"
       2             : #include "crpropa/Units.h"
       3             : 
       4             : #include <stdexcept>
       5             : 
       6             : namespace crpropa {
       7             : 
       8           4 : Output::Output() : outputName(OutputTypeName(Everything)), lengthScale(Mpc), energyScale(EeV), oneDimensional(false), count(0) {
       9           4 :         enableAll();
      10           4 : }
      11             : 
      12           8 : Output::Output(OutputType outputType) : outputName(OutputTypeName(outputType)), lengthScale(Mpc), energyScale(EeV), oneDimensional(false), count(0) {
      13           8 :         setOutputType(outputType);
      14           8 : }
      15             : 
      16          12 : std::string Output::OutputTypeName(OutputType outputType) {
      17          12 :         if (outputType == Trajectory1D)
      18           1 :                 return "Trajectory1D";
      19          11 :         if (outputType == Event1D)
      20           4 :                 return "Event1D";
      21           7 :         if (outputType == Trajectory3D)
      22           1 :                 return "Trajectory3D";
      23           6 :         if (outputType == Event3D)
      24           1 :                 return "Event3D";
      25           5 :         return "Everything";
      26             : }
      27             : 
      28          65 : void Output::modify() {
      29          65 :         if (count > 0)
      30           0 :                 throw std::runtime_error("Output: cannot change Output parameters after data has been written to file.");
      31          65 : }
      32             : 
      33          80 : void Output::process(Candidate *c) const {
      34          80 :         count++;
      35          80 : }
      36             : 
      37           8 : void Output::setOutputType(OutputType outputtype) {
      38           8 :         modify();
      39           8 :         if (outputtype == Trajectory1D) {
      40             :                 // X, ID, E
      41           1 :                 set(CurrentPositionColumn, true);
      42           1 :                 set(CurrentIdColumn, true);
      43           1 :                 set(CurrentEnergyColumn, true);
      44           1 :                 set1D(true);
      45           7 :         } else if (outputtype == Event1D) {
      46             :                 // D, ID, E, ID0, E0
      47           4 :                 set(TrajectoryLengthColumn, true);
      48           4 :                 set(CurrentIdColumn, true);
      49           4 :                 set(CurrentEnergyColumn, true);
      50           4 :                 set(SourceIdColumn, true);
      51           4 :                 set(SourceEnergyColumn, true);
      52           4 :                 set1D(true);
      53           3 :         } else if (outputtype == Trajectory3D) {
      54             :                 // D, ID, E, X, Y, Z, Px, Py, Pz
      55           1 :                 set(TrajectoryLengthColumn, true);
      56           1 :                 set(CurrentIdColumn, true);
      57           1 :                 set(CurrentEnergyColumn, true);
      58           1 :                 set(CurrentPositionColumn, true);
      59           1 :                 set(CurrentDirectionColumn, true);
      60           1 :                 set1D(false);
      61           2 :         } else if (outputtype == Event3D) {
      62             :                 // D, ID, E, X, Y, Z, Px, Py, Pz, ID0, E0, X0, Y0, Z0, P0x, P0y, P0z
      63           1 :                 set(TrajectoryLengthColumn, true);
      64           1 :                 set(CurrentIdColumn, true);
      65           1 :                 set(CurrentEnergyColumn, true);
      66           1 :                 set(CurrentPositionColumn, true);
      67           1 :                 set(CurrentDirectionColumn, true);
      68           1 :                 set(SourceIdColumn, true);
      69           1 :                 set(SourceEnergyColumn, true);
      70           1 :                 set(SourcePositionColumn, true);
      71           1 :                 set(SourceDirectionColumn, true);
      72           1 :                 set1D(false);
      73           1 :         } else if (outputtype == Everything) {
      74           1 :                 enableAll();
      75           1 :                 set1D(false);
      76             :         } else {
      77           0 :                 throw std::runtime_error("Output: unknown output type");
      78             :         }
      79           8 : }
      80             : 
      81           0 : void Output::setEnergyScale(double scale) {
      82           0 :         modify();
      83           0 :         energyScale = scale;
      84           0 : }
      85             : 
      86           0 : void Output::setLengthScale(double scale) {
      87           0 :         modify();
      88           0 :         lengthScale = scale;
      89           0 : }
      90             : 
      91           9 : void Output::set1D(bool value) {
      92           9 :         modify();
      93           9 :         oneDimensional = value;
      94           9 : }
      95             : 
      96           2 : void Output::enable(OutputColumn field) {
      97           2 :         modify();
      98           2 :         fields.set(field, true);
      99           2 : }
     100             : 
     101           1 : void Output::disable(OutputColumn field) {
     102           1 :         modify();
     103           1 :         fields.set(field, false);
     104           1 : }
     105             : 
     106          38 : void Output::set(OutputColumn field, bool value) {
     107          38 :         modify();
     108          38 :         fields.set(field, value);
     109          38 : }
     110             : 
     111           5 : void Output::enableAll() {
     112           5 :         modify();
     113             :         fields.set();
     114           5 : }
     115             : 
     116           1 : void Output::disableAll() {
     117           1 :         modify();
     118             :         fields.reset();
     119           1 : }
     120             : 
     121           1 : size_t Output::size() const {
     122           1 :         return count;
     123             : }
     124             : 
     125           1 : void Output::enableProperty(const std::string &property, const Variant &defaultValue, const std::string &comment) {
     126           1 :         modify();
     127           1 :         Property prop;
     128             :         prop.name = property;
     129             :         prop.comment = comment;
     130           1 :         prop.defaultValue = defaultValue;
     131           1 :         properties.push_back(prop);
     132           1 : };
     133             : 
     134             : } // namespace crpropa