smash::ThermodynamicLatticeOutput Class Reference

#include <thermodynamiclatticeoutput.h>

Writes the thermodynamic quantities at lattice points versus time.

This class is a temporary solution to write thermodynamic quantities out. Calculations are called directly inside the output functions. In future it should be substituted by some more general output.

Definition at line 42 of file thermodynamiclatticeoutput.h.

Inheritance diagram for smash::ThermodynamicLatticeOutput:

Public Member Functions
	ThermodynamicLatticeOutput (const std::filesystem::path &path, const std::string &name, const OutputParameters &out_par, const bool enable_ascii, const bool enable_binary)
	Construct Output. More...
	~ThermodynamicLatticeOutput ()
	Default destructor. More...
void	at_eventstart (const int event_number, const ThermodynamicQuantity tq, const DensityType dens_type, const RectangularLattice< DensityOnLattice > lattice) override
	Output launched at event start after initialization, when particles are generated but not yet propagated. More...
void	at_eventstart (const int event_number, const ThermodynamicQuantity tq, const DensityType dens_type, const RectangularLattice< EnergyMomentumTensor > lattice) override
	Output launched at event start after initialization, when particles are generated but not yet propagated. More...
void	at_eventend (const ThermodynamicQuantity tq) override
	Final actions at the end of each event (it closes the output files). More...
void	thermodynamics_lattice_output (RectangularLattice< DensityOnLattice > &lattice, double current_time) override
	Prints the density lattice on a grid. More...
void	thermodynamics_lattice_output (RectangularLattice< DensityOnLattice > &lattice, const double current_time, const std::vector< Particles > &ensembles, const DensityParameters &dens_param) override
	Prints the density lattice on a grid. More...
void	thermodynamics_lattice_output (const ThermodynamicQuantity tq, RectangularLattice< EnergyMomentumTensor > &lattice, double current_time) override
	Prints the energy-momentum-tensor lattice on a grid. More...
Public Member Functions inherited from smash::OutputInterface
	OutputInterface (std::string name)
	Construct output interface. More...
virtual	~OutputInterface ()=0
	Pure virtual destructor to make class abstract and prevent its instantiation. More...
virtual void	at_eventstart (const Particles &, const int, const EventInfo &)
	Output launched at event start after initialization, when particles are generated but not yet propagated. More...
virtual void	at_eventstart (const std::vector< Particles > &, int)
	Output launched at event start after initialization, when particles are generated but not yet propagated. More...
virtual void	at_eventend (const int, const ThermodynamicQuantity, const DensityType)
	Output launched at event end. More...
virtual void	at_eventend (const Particles &, const int, const EventInfo &)
	Output launched at event end. More...
virtual void	at_eventend (const std::vector< Particles > &, const int)
	Output launched at event end. More...
virtual void	at_interaction (const Action &, const double)
	Called whenever an action modified one or more particles. More...
virtual void	at_intermediate_time (const Particles &, const std::unique_ptr< Clock > &, const DensityParameters &, const EventInfo &)
	Output launched after every N'th time-step. More...
virtual void	at_intermediate_time (const std::vector< Particles > &, const std::unique_ptr< Clock > &, const DensityParameters &)
	Output launched after every N'th timestep. More...
virtual void	thermodynamics_output (const ThermodynamicQuantity, const DensityType, RectangularLattice< DensityOnLattice > &)
	Output to write thermodynamics from the lattice. More...
virtual void	thermodynamics_output (const ThermodynamicQuantity, const DensityType, RectangularLattice< EnergyMomentumTensor > &)
	Output to write energy-momentum tensor and related quantities from the lattice. More...
virtual void	thermodynamics_output (const GrandCanThermalizer &)
	Output to write energy-momentum tensor and related quantities from the thermalizer class. More...
virtual void	fields_output (const std::string, const std::string, RectangularLattice< std::pair< ThreeVector, ThreeVector >> &)
	Write fields in vtk output Fields are a pair of threevectors for example electric and magnetic field. More...
bool	is_dilepton_output () const
	Get, whether this is the dilepton output? More...
bool	is_photon_output () const
	Get, whether this is the photon output? More...
bool	is_IC_output () const
	Get, whether this is the IC output? More...
const char *	to_string (const ThermodynamicQuantity tq)
	Convert thermodynamic quantities to strings. More...
const char *	to_string (const DensityType dens_type)
	Convert density types to strings. More...

Static Public Attributes
static const double_t	version = 1.0
	Version of the thermodynamic lattice output. More...

Private Member Functions
std::string	make_filename (const std::string &description, const int event_number, const char type)
	Makes a file name given a description and a counter. More...
std::string	make_varname (const ThermodynamicQuantity tq, const DensityType dens_type)
	Makes a variable name given quantity and density type. More...
void	write_therm_lattice_ascii_header (std::shared_ptr< std::ofstream > file, const ThermodynamicQuantity &tq)
	Writes the header for the ASCII output files. More...
void	write_therm_lattice_binary_header (std::shared_ptr< std::ofstream > file, const ThermodynamicQuantity &tq)
	Writes the header for the binary output files. More...
int	to_int (const ThermodynamicQuantity &tq)
	Convert a ThermodynamicQuantity into an int. More...

Private Attributes
const OutputParameters	out_par_
	Structure that holds all the information about what to printout. More...
const std::filesystem::path	base_path_
	filesystem path for output More...
std::map< ThermodynamicQuantity, std::shared_ptr< std::ofstream > >	output_ascii_files_
	map of output file handlers for ASCII format More...
std::map< ThermodynamicQuantity, std::shared_ptr< std::ofstream > >	output_binary_files_
	map of output file handlers for binary format More...
std::array< int, 3 >	nodes_
	number of nodes in the lattice along the three axes More...
std::array< double, 3 >	sizes_
	lattice resolution along the three axes More...
std::array< double, 3 >	origin_
	lattice origin orientation: if 0,0,0 is the origin of a cube with face widths 10, the center is at 5,5,5 More...
bool	enable_ascii_
	enable output type ASCII More...
bool	enable_binary_
	enable output type Binary More...
bool	enable_output_
	enable output, of any kind (if False, the object does nothing) More...

Additional Inherited Members
Protected Attributes inherited from smash::OutputInterface
const bool	is_dilepton_output_
	Is this the dilepton output? More...
const bool	is_photon_output_
	Is this the photon output? More...
const bool	is_IC_output_
	Is this the IC output? More...

Constructor & Destructor Documentation

ThermodynamicLatticeOutput()

smash::ThermodynamicLatticeOutput::ThermodynamicLatticeOutput	(	const std::filesystem::path &	path,
		const std::string &	name,
		const OutputParameters &	out_par,
		const bool	enable_ascii,
		const bool	enable_binary
	)

Construct Output.

Parameters

[in]	path	Path to output
[in]	name	Filename
[in]	out_par	Parameters of output
[in]	enable_ascii	Bool (True or False) to enable ASCII format
[in]	enable_binary	Bool (True or False) to enable binary format

Definition at line 184 of file thermodynamiclatticeoutput.cc.

    : OutputInterface(name),
      out_par_(out_par),
      base_path_(std::move(path)),
      enable_ascii_(enable_ascii),
      enable_binary_(enable_binary) {
  if (enable_ascii_ || enable_binary_) {
    enable_output_ = true;
  } else {
    enable_output_ = false;
  }
  if (enable_ascii_) {
    if (out_par_.td_rho_eckart) {
      output_ascii_files_[ThermodynamicQuantity::EckartDensity] =
          std::make_shared<std::ofstream>(nullptr);
    }
    if (out_par_.td_tmn_landau) {
      output_ascii_files_[ThermodynamicQuantity::TmnLandau] =
          std::make_shared<std::ofstream>(nullptr);
    }
    if (out_par_.td_tmn) {
      output_ascii_files_[ThermodynamicQuantity::Tmn] =
          std::make_shared<std::ofstream>(nullptr);
    }
    if (out_par_.td_v_landau) {
      output_ascii_files_[ThermodynamicQuantity::LandauVelocity] =
          std::make_shared<std::ofstream>(nullptr);
    }
    if (out_par_.td_jQBS) {
      output_ascii_files_[ThermodynamicQuantity::j_QBS] =
          std::make_shared<std::ofstream>(nullptr);
    }
  }
  if (enable_binary_) {
    if (out_par_.td_rho_eckart) {
      output_binary_files_[ThermodynamicQuantity::EckartDensity] =
          std::make_shared<std::ofstream>(nullptr);
    }
    if (out_par_.td_tmn_landau) {
      output_binary_files_[ThermodynamicQuantity::TmnLandau] =
          std::make_shared<std::ofstream>(nullptr);
    }
    if (out_par_.td_tmn) {
      output_binary_files_[ThermodynamicQuantity::Tmn] =
          std::make_shared<std::ofstream>(nullptr);
    }
    if (out_par_.td_v_landau) {
      output_binary_files_[ThermodynamicQuantity::LandauVelocity] =
          std::make_shared<std::ofstream>(nullptr);
    }
    if (out_par_.td_jQBS) {
      output_binary_files_[ThermodynamicQuantity::j_QBS] =
          std::make_shared<std::ofstream>(nullptr);
    }
  }
}

~ThermodynamicLatticeOutput()

smash::ThermodynamicLatticeOutput::~ThermodynamicLatticeOutput

(

)

Default destructor.

Definition at line 244 of file thermodynamiclatticeoutput.cc.

{}

Member Function Documentation

at_eventstart() [1/2]

void smash::ThermodynamicLatticeOutput::at_eventstart ( const int  event_number, const ThermodynamicQuantity  tq, const DensityType  dens_type, const RectangularLattice< DensityOnLattice >  lattice  )

overridevirtual

Output launched at event start after initialization, when particles are generated but not yet propagated.

Parameters

[in]	event_number	Number of the current event.
[in]	tq	Thermodynamic quantity to deal with
[in]	dens_type	Density type for the reference frame.
[in]	lattice	Specialized Lattice for DensityOnLattice

Reimplemented from smash::OutputInterface.

Definition at line 246 of file thermodynamiclatticeoutput.cc.

                                                                               {
  if (!enable_output_) {
    return;
  }
  assert((tq == ThermodynamicQuantity::EckartDensity) ||
         (tq == ThermodynamicQuantity::j_QBS));
  // at the next refactoring of the code,
  // this piece should go in the constructor
  const auto dim = lattice.n_cells();
  const auto cs = lattice.cell_sizes();
  const auto orig = lattice.origin();
  for (int l = 0; l < 3; l++) {
    nodes_[l] = dim[l];
    sizes_[l] = cs[l];
    origin_[l] = orig[l];
  }
  std::shared_ptr<std::ofstream> fp(nullptr);
  std::string varname;
  std::string filename;
  varname = make_varname(tq, dens_type);
  if (tq == ThermodynamicQuantity::EckartDensity) {
    if (enable_ascii_) {
      filename = make_filename(varname, event_number, 'a');
      try {
        output_ascii_files_[ThermodynamicQuantity::EckartDensity]->open(
            filename, std::ios::out);
      } catch (std::ofstream::failure &e) {
        logg[LogArea::Main::id].fatal()
            << "Error in opening " << filename << std::endl;
        throw std::runtime_error(
            "Not possible to write thermodynamic "
            "lattice output to file.");
      }
      fp = output_ascii_files_[ThermodynamicQuantity::EckartDensity];
      write_therm_lattice_ascii_header(fp, tq);
    }
    if (enable_binary_) {
      filename = make_filename(varname, event_number, 'b');
      try {
        output_binary_files_[ThermodynamicQuantity::EckartDensity]->open(
            filename, std::ios::out | std::ios::binary);
      } catch (std::ofstream::failure &e) {
        logg[LogArea::Main::id].fatal()
            << "Error in opening " << filename << std::endl;
        throw std::runtime_error(
            "Not possible to write thermodynamic "
            "lattice output to file.");
      }
      fp = output_binary_files_[ThermodynamicQuantity::EckartDensity];
      write_therm_lattice_binary_header(fp, tq);
    }
  } else {
    if (enable_ascii_) {
      filename = make_filename(varname, event_number, 'a');
      try {
        output_ascii_files_[ThermodynamicQuantity::j_QBS]->open(filename,
                                                                std::ios::out);
      } catch (std::ofstream::failure &e) {
        logg[LogArea::Main::id].fatal()
            << "Error in opening " << filename << std::endl;
        throw std::runtime_error(
            "Not possible to write thermodynamic "
            "lattice output to file.");
      }
      fp = output_ascii_files_[ThermodynamicQuantity::j_QBS];
      write_therm_lattice_ascii_header(fp, tq);
    }
    if (enable_binary_) {
      filename = make_filename(varname, event_number, 'b');
      try {
        output_binary_files_[ThermodynamicQuantity::j_QBS]->open(
            filename, std::ios::out | std::ios::binary);
      } catch (std::ofstream::failure &e) {
        logg[LogArea::Main::id].fatal()
            << "Error in opening " << filename << std::endl;
        throw std::runtime_error(
            "Not possible to write thermodynamic "
            "lattice output to file.");
      }
      fp = output_binary_files_[ThermodynamicQuantity::j_QBS];
      write_therm_lattice_binary_header(fp, tq);
    }
  }
}

at_eventstart() [2/2]

void smash::ThermodynamicLatticeOutput::at_eventstart ( const int  event_number, const ThermodynamicQuantity  tq, const DensityType  dens_type, const RectangularLattice< EnergyMomentumTensor >  lattice  )

overridevirtual

Output launched at event start after initialization, when particles are generated but not yet propagated.

Parameters

[in]	event_number	Number of the current event.
[in]	tq	Thermodynamic quantity to deal with.
[in]	dens_type	Density type for the reference frame.
[in]	lattice	Specialized Lattice for EnergyMomentumTensor

Reimplemented from smash::OutputInterface.

Definition at line 333 of file thermodynamiclatticeoutput.cc.

                                                      {
  if (!enable_output_) {
    return;
  }
  const auto dim = lattice.n_cells();
  const auto cs = lattice.cell_sizes();
  const auto orig = lattice.origin();
  for (int l = 0; l < 3; l++) {
    nodes_[l] = dim[l];
    sizes_[l] = cs[l];
    origin_[l] = orig[l];
  }
  std::shared_ptr<std::ofstream> fp(nullptr);
  std::string varname;
  std::string filename;
  varname = make_varname(tq, dens_type);
  if (enable_ascii_) {
    filename = make_filename(varname, event_number, 'a');
    if (tq == ThermodynamicQuantity::TmnLandau) {
      try {
        output_ascii_files_[ThermodynamicQuantity::TmnLandau]->open(
            filename, std::ios::out);
      } catch (std::ofstream::failure &e) {
        logg[LogArea::Main::id].fatal()
            << "Error in opening " << filename << std::endl;
        throw std::runtime_error(
            "Not possible to write thermodynamic "
            "lattice output to file.");
      }
      fp = output_ascii_files_[ThermodynamicQuantity::TmnLandau];
    } else if (tq == ThermodynamicQuantity::Tmn) {
      try {
        output_ascii_files_[ThermodynamicQuantity::Tmn]->open(filename,
                                                              std::ios::out);
      } catch (std::ofstream::failure &e) {
        logg[LogArea::Main::id].fatal()
            << "Error in opening " << filename << std::endl;
        throw std::runtime_error(
            "Not possible to write thermodynamic "
            "lattice output to file.");
      }
      fp = output_ascii_files_[ThermodynamicQuantity::Tmn];
    } else if (tq == ThermodynamicQuantity::LandauVelocity) {
      try {
        output_ascii_files_[ThermodynamicQuantity::LandauVelocity]->open(
            filename, std::ios::out);
      } catch (std::ofstream::failure &e) {
        logg[LogArea::Main::id].fatal()
            << "Error in opening " << filename << std::endl;
        throw std::runtime_error(
            "Not possible to write thermodynamic "
            "lattice output to file.");
      }
      fp = output_ascii_files_[ThermodynamicQuantity::LandauVelocity];
    } else {
      try {
        output_ascii_files_[ThermodynamicQuantity::j_QBS]->open(filename,
                                                                std::ios::out);
      } catch (std::ofstream::failure &e) {
        logg[LogArea::Main::id].fatal()
            << "Error in opening " << filename << std::endl;
        throw std::runtime_error(
            "Not possible to write thermodynamic "
            "lattice output to file.");
      }
    }
    write_therm_lattice_ascii_header(fp, tq);
  }
  if (enable_binary_) {
    filename = make_filename(varname, event_number, 'b');
    if (tq == ThermodynamicQuantity::TmnLandau) {
      try {
        output_binary_files_[ThermodynamicQuantity::TmnLandau]->open(
            filename, std::ios::out | std::ios::binary);
      } catch (std::ofstream::failure &e) {
        logg[LogArea::Main::id].fatal()
            << "Error in opening " << filename << std::endl;
        throw std::runtime_error(
            "Not possible to write thermodynamic "
            "lattice output to file.");
      }
      fp = output_binary_files_[ThermodynamicQuantity::TmnLandau];
    } else if (tq == ThermodynamicQuantity::Tmn) {
      try {
        output_binary_files_[ThermodynamicQuantity::Tmn]->open(
            filename, std::ios::out | std::ios::binary);
      } catch (std::ofstream::failure &e) {
        logg[LogArea::Main::id].fatal()
            << "Error in opening " << filename << std::endl;
        throw std::runtime_error(
            "Not possible to write thermodynamic "
            "lattice output to file.");
      }
      fp = output_binary_files_[ThermodynamicQuantity::Tmn];
    } else if (tq == ThermodynamicQuantity::LandauVelocity) {
      try {
        output_binary_files_[ThermodynamicQuantity::LandauVelocity]->open(
            filename, std::ios::out | std::ios::binary);
      } catch (std::ofstream::failure &e) {
        logg[LogArea::Main::id].fatal()
            << "Error in opening " << filename << std::endl;
        throw std::runtime_error(
            "Not possible to write thermodynamic "
            "lattice output to file.");
      }
      fp = output_binary_files_[ThermodynamicQuantity::LandauVelocity];
    } else {
      try {
        output_binary_files_[ThermodynamicQuantity::j_QBS]->open(filename,
                                                                 std::ios::out);
      } catch (std::ofstream::failure &e) {
        logg[LogArea::Main::id].fatal()
            << "Error in opening " << filename << std::endl;
        throw std::runtime_error(
            "Not possible to write thermodynamic "
            "lattice output to file.");
      }
    }
    write_therm_lattice_binary_header(fp, tq);
  }
}

at_eventend()

void smash::ThermodynamicLatticeOutput::at_eventend ( const ThermodynamicQuantity  tq )

overridevirtual

Final actions at the end of each event (it closes the output files).

Parameters

[in]

tq

The quantity that has been written in the output file, see ThermodynamicQuantity.

Reimplemented from smash::OutputInterface.

Definition at line 458 of file thermodynamiclatticeoutput.cc.

                                                                           {
  if (!enable_output_) {
    return;
  }
  if (tq == ThermodynamicQuantity::EckartDensity) {
    if (enable_ascii_) {
      output_ascii_files_[ThermodynamicQuantity::EckartDensity]->close();
    }
    if (enable_binary_) {
      output_binary_files_[ThermodynamicQuantity::EckartDensity]->close();
    }
    return;
  }
  if (tq == ThermodynamicQuantity::Tmn) {
    if (enable_ascii_) {
      output_ascii_files_[ThermodynamicQuantity::Tmn]->close();
    }
    if (enable_binary_) {
      output_binary_files_[ThermodynamicQuantity::Tmn]->close();
    }
    return;
  }
  if (tq == ThermodynamicQuantity::TmnLandau) {
    if (enable_ascii_) {
      output_ascii_files_[ThermodynamicQuantity::TmnLandau]->close();
    }
    if (enable_binary_) {
      output_binary_files_[ThermodynamicQuantity::TmnLandau]->close();
    }
    return;
  }
  if (tq == ThermodynamicQuantity::LandauVelocity) {
    if (enable_ascii_) {
      output_ascii_files_[ThermodynamicQuantity::LandauVelocity]->close();
    }
    if (enable_binary_) {
      output_binary_files_[ThermodynamicQuantity::LandauVelocity]->close();
    }
    return;
  }
  if (tq == ThermodynamicQuantity::j_QBS) {
    if (enable_ascii_) {
      output_ascii_files_[ThermodynamicQuantity::j_QBS]->close();
    }
    if (enable_binary_) {
      output_binary_files_[ThermodynamicQuantity::j_QBS]->close();
    }
    return;
  }
}

thermodynamics_lattice_output() [1/3]

void smash::ThermodynamicLatticeOutput::thermodynamics_lattice_output ( RectangularLattice< DensityOnLattice > &  lattice, double  current_time  )

overridevirtual

Prints the density lattice on a grid.

• Parameters

  [in]	lattice	DensityOnLattice lattice to use.
  [in]	current_time	The output time in the computational frame

Reimplemented from smash::OutputInterface.

Definition at line 509 of file thermodynamiclatticeoutput.cc.

                                                                 {
  double result;
  const auto dim = lattice.n_cells();
  std::shared_ptr<std::ofstream> fp(nullptr);
  if (enable_ascii_) {
    fp = output_ascii_files_[ThermodynamicQuantity::EckartDensity];
    *fp << std::setprecision(14);
    *fp << std::scientific;
    *fp << ctime << std::endl;
  }
  if (enable_binary_) {
    fp = output_binary_files_[ThermodynamicQuantity::EckartDensity];
    assert(sizeof(ctime) == sizeof(double));
    fp->write(reinterpret_cast<char *>(&ctime), sizeof(ctime));
  }
  lattice.iterate_sublattice(
      {0, 0, 0}, dim, [&](DensityOnLattice &node, int ix, int, int) {
        if (enable_ascii_) {
          *fp << node.rho() << " ";
          if (ix == dim[0] - 1) {
            *fp << "\n";
          }
        }
        if (enable_binary_) {
          result = node.rho();
          fp->write(reinterpret_cast<char *>(&result), sizeof(double));
        }
      });
}

thermodynamics_lattice_output() [2/3]

void smash::ThermodynamicLatticeOutput::thermodynamics_lattice_output ( RectangularLattice< DensityOnLattice > &  lattice, const double  current_time, const std::vector< Particles > &  ensembles, const DensityParameters &  dens_param  )

overridevirtual

Prints the density lattice on a grid.

Parameters

[in]	lattice	DensityOnLattice lattice to use.
[in]	current_time	The output time in the computational frame
[in]	ensembles	Particles, from which the 4-currents j_{Q,B,S} are computed
[in]	dens_param	set of parameters, defining smearing. For more info about smearing see ASCII thermodynamics output.

Reimplemented from smash::OutputInterface.

Definition at line 540 of file thermodynamiclatticeoutput.cc.

                                         {
  if (!enable_output_) {
    return;
  }
  double result;
  const auto dim = lattice.n_cells();
  std::shared_ptr<std::ofstream> fp(nullptr);
  FourVector jQ = FourVector(), jB = FourVector(), jS = FourVector();
  constexpr bool compute_gradient = false;
  if (enable_ascii_) {
    fp = output_ascii_files_[ThermodynamicQuantity::j_QBS];
    *fp << std::setprecision(14);
    *fp << std::scientific;
    *fp << ctime << std::endl;
  }
  if (enable_binary_) {
    fp = output_binary_files_[ThermodynamicQuantity::j_QBS];
    assert(sizeof(ctime) == sizeof(double));
    fp->write(reinterpret_cast<char *>(&ctime), sizeof(ctime));
  }
  lattice.iterate_sublattice(
      {0, 0, 0}, dim, [&](DensityOnLattice &, int ix, int iy, int iz) {
        const ThreeVector position = lattice.cell_center(ix, iy, iz);
        jQ.reset();
        jB.reset();
        jS.reset();
        for (const Particles &particles : ensembles) {
          jQ += std::get<1>(current_eckart(
              position, particles, dens_param, DensityType::Charge,
              compute_gradient, out_par_.td_smearing));
          jB += std::get<1>(current_eckart(
              position, particles, dens_param, DensityType::Baryon,
              compute_gradient, out_par_.td_smearing));
          jS += std::get<1>(current_eckart(
              position, particles, dens_param, DensityType::Strangeness,
              compute_gradient, out_par_.td_smearing));
        }
        if (enable_ascii_) {
          *fp << jQ[0];
          for (int l = 1; l < 4; l++) {
            *fp << " " << jQ[l];
          }
          for (int l = 0; l < 4; l++) {
            *fp << " " << jB[l];
          }
          for (int l = 0; l < 4; l++) {
            *fp << " " << jS[l];
          }
          *fp << "\n";
        }
        if (enable_binary_) {
          for (int l = 0; l < 4; l++) {
            result = jQ[l];
            fp->write(reinterpret_cast<char *>(&result), sizeof(double));
          }
          for (int l = 0; l < 4; l++) {
            result = jB[l];
            fp->write(reinterpret_cast<char *>(&result), sizeof(double));
          }
          for (int l = 0; l < 4; l++) {
            result = jS[l];
            fp->write(reinterpret_cast<char *>(&result), sizeof(double));
          }
        }
      });
}

thermodynamics_lattice_output() [3/3]

void smash::ThermodynamicLatticeOutput::thermodynamics_lattice_output ( const ThermodynamicQuantity  tq, RectangularLattice< EnergyMomentumTensor > &  lattice, double  current_time  )

overridevirtual

Prints the energy-momentum-tensor lattice on a grid.

Parameters

[in]	tq	The quantity whose energy-momentum tensor should be written, see ThermodynamicQuantity.
[in]	lattice	EnergyMomentumTensor lattice to use.
[in]	current_time	The output time in the computational frame

Reimplemented from smash::OutputInterface.

Definition at line 610 of file thermodynamiclatticeoutput.cc.

                                                                     {
  if (!enable_output_) {
    return;
  }
  double result;
  const auto dim = lattice.n_cells();
  std::shared_ptr<std::ofstream> fp(nullptr);
  if (enable_ascii_) {
    switch (tq) {
      case ThermodynamicQuantity::Tmn:
        fp = output_ascii_files_[ThermodynamicQuantity::Tmn];
        break;
      case ThermodynamicQuantity::TmnLandau:
        fp = output_ascii_files_[ThermodynamicQuantity::TmnLandau];
        break;
      case ThermodynamicQuantity::LandauVelocity:
        fp = output_ascii_files_[ThermodynamicQuantity::LandauVelocity];
        break;
      default:
        return;
    }
    *fp << std::setprecision(14);
    *fp << std::scientific;
    *fp << ctime << std::endl;
  }
  if (enable_binary_) {
    switch (tq) {
      case ThermodynamicQuantity::Tmn:
        fp = output_binary_files_[ThermodynamicQuantity::Tmn];
        break;
      case ThermodynamicQuantity::TmnLandau:
        fp = output_binary_files_[ThermodynamicQuantity::TmnLandau];
        break;
      case ThermodynamicQuantity::LandauVelocity:
        fp = output_binary_files_[ThermodynamicQuantity::LandauVelocity];
        break;
      default:
        return;
    }
    assert(sizeof(ctime) == sizeof(double));
    fp->write(reinterpret_cast<char *>(&ctime), sizeof(double));
  }
  switch (tq) {
    case ThermodynamicQuantity::Tmn:
      for (int i = 0; i < 4; i++) {
        for (int j = i; j < 4; j++) {
          lattice.iterate_sublattice(
              {0, 0, 0}, dim,
              [&](EnergyMomentumTensor &node, int ix, int, int) {
                if (enable_ascii_) {
                  *fp << node[EnergyMomentumTensor::tmn_index(i, j)] << " ";
                  if (ix == dim[0] - 1) {
                    *fp << "\n";
                  }
                }
                if (enable_binary_) {
                  result = node[EnergyMomentumTensor::tmn_index(i, j)];
                  fp->write(reinterpret_cast<char *>(&result), sizeof(double));
                }
              });
        }
      }
      break;
    case ThermodynamicQuantity::TmnLandau:
      for (int i = 0; i < 4; i++) {
        for (int j = i; j < 4; j++) {
          lattice.iterate_sublattice(
              {0, 0, 0}, dim,
              [&](EnergyMomentumTensor &node, int ix, int, int) {
                if (enable_ascii_) {
                  const FourVector u = node.landau_frame_4velocity();
                  const EnergyMomentumTensor Tmn_L = node.boosted(u);
                  *fp << Tmn_L[EnergyMomentumTensor::tmn_index(i, j)] << " ";
                  if (ix == dim[0] - 1) {
                    *fp << "\n";
                  }
                }
                if (enable_binary_) {
                  const FourVector u = node.landau_frame_4velocity();
                  const EnergyMomentumTensor Tmn_L = node.boosted(u);
                  result = Tmn_L[EnergyMomentumTensor::tmn_index(i, j)];
                  fp->write(reinterpret_cast<char *>(&result), sizeof(double));
                }
              });
        }
      }
      break;
    case ThermodynamicQuantity::LandauVelocity:
      lattice.iterate_sublattice(
          {0, 0, 0}, dim, [&](EnergyMomentumTensor &node, int, int, int) {
            if (enable_ascii_) {
              const FourVector u = node.landau_frame_4velocity();
              const ThreeVector v = -u.velocity();
              *fp << v.x1() << " " << v.x2() << " " << v.x3() << "\n";
            }
            if (enable_binary_) {
              const FourVector u = node.landau_frame_4velocity();
              ThreeVector v = -u.velocity();
              fp->write(reinterpret_cast<char *>(&v), 3 * sizeof(double));
            }
          });
      break;
    default:
      return;
  }
}

make_filename()

std::string smash::ThermodynamicLatticeOutput::make_filename ( const std::string &  description, const int  event_number, const char  type  )

private

Makes a file name given a description and a counter.

Parameters

[in]	description	The description.
[in]	event_number	The event number.
[in]	type	Flag for the file type: 'a' for ASCII, 'b' for Binary

Definition at line 738 of file thermodynamiclatticeoutput.cc.

                                                                       {
  char suffix[13];
  assert((type == 'a') || (type == 'b'));
  if (type == 'a') {
    snprintf(suffix, sizeof(suffix), "_%07i.dat", event_number);
  } else {
    snprintf(suffix, sizeof(suffix), "_%07i.bin", event_number);
  }
  return base_path_.string() + std::string("/") + descr + std::string(suffix);
}

make_varname()

std::string smash::ThermodynamicLatticeOutput::make_varname ( const ThermodynamicQuantity  tq, const DensityType  dens_type  )

private

Makes a variable name given quantity and density type.

Parameters

[in]	tq	The quantity.
[in]	dens_type	The density type.

Definition at line 751 of file thermodynamiclatticeoutput.cc.

                                                                 {
  return std::string(to_string(dens_type)) + std::string("_") +
         std::string(to_string(tq));
}

write_therm_lattice_ascii_header()

void smash::ThermodynamicLatticeOutput::write_therm_lattice_ascii_header ( std::shared_ptr< std::ofstream >  file, const ThermodynamicQuantity &  tq  )

private

Writes the header for the ASCII output files.

Parameters

	file	Output file.
[in]	tq	The quantity to be written, see ThermodynamicQuantity.

Definition at line 757 of file thermodynamiclatticeoutput.cc.

                                                                    {
  *fp << std::setprecision(2);
  *fp << std::fixed;
  *fp << "#Thermodynamic Lattice Output version: "
      << ThermodynamicLatticeOutput::version << std::endl;
  *fp << std::setprecision(6);
  *fp << "#Quantity:"
      << " " << std::string(to_string(tq)) << std::endl;
  *fp << "#Grid dimensions: " << nodes_[0] << " " << nodes_[1] << " "
      << nodes_[2] << std::endl;
  *fp << "#Grid spacing: " << sizes_[0] << " " << sizes_[1] << " " << sizes_[2]
      << std::endl;
  *fp << "#Grid origin: " << origin_[0] << " " << origin_[1] << " "
      << origin_[2] << std::endl;
}

write_therm_lattice_binary_header()

void smash::ThermodynamicLatticeOutput::write_therm_lattice_binary_header ( std::shared_ptr< std::ofstream >  file, const ThermodynamicQuantity &  tq  )

private

Writes the header for the binary output files.

Parameters

[in]	file	Output file.
[in]	tq	The quantity to be written, see ThermodynamicQuantity.

Definition at line 774 of file thermodynamiclatticeoutput.cc.

                                                                    {
  auto variable_id = to_int(tq);
  fp->write(
      reinterpret_cast<const char *>(&ThermodynamicLatticeOutput::version),
      sizeof(double));
  fp->write(reinterpret_cast<char *>(&variable_id), sizeof(int));
  fp->write(reinterpret_cast<char *>(&nodes_), sizeof(nodes_));
  fp->write(reinterpret_cast<char *>(&sizes_), sizeof(sizes_));
  fp->write(reinterpret_cast<char *>(&origin_), sizeof(origin_));
}

to_int()

int smash::ThermodynamicLatticeOutput::to_int ( const ThermodynamicQuantity &  tq )

private

Convert a ThermodynamicQuantity into an int.

Parameters

[in]

tq

The quantity to be converted, see ThermodynamicQuantity.

Returns

An int corresponding to ThermodynamicQuantity.

Definition at line 719 of file thermodynamiclatticeoutput.cc.

                                                                      {
  switch (tq) {
    case ThermodynamicQuantity::EckartDensity:
      return 0;
    case ThermodynamicQuantity::Tmn:
      return 1;
    case ThermodynamicQuantity::TmnLandau:
      return 2;
    case ThermodynamicQuantity::LandauVelocity:
      return 3;
    case ThermodynamicQuantity::j_QBS:
      return 4;
    default:
      throw std::runtime_error(
          "Error when converting a thermodynamic quantity "
          "to an int, unknown quantity.");
  }
}

Member Data Documentation

version

const double_t smash::ThermodynamicLatticeOutput::version = 1.0

static

Version of the thermodynamic lattice output.

Definition at line 45 of file thermodynamiclatticeoutput.h.

out_par_

const OutputParameters smash::ThermodynamicLatticeOutput::out_par_

private

Structure that holds all the information about what to printout.

Definition at line 134 of file thermodynamiclatticeoutput.h.

base_path_

const std::filesystem::path smash::ThermodynamicLatticeOutput::base_path_

private

filesystem path for output

Definition at line 183 of file thermodynamiclatticeoutput.h.

output_ascii_files_

std::map<ThermodynamicQuantity, std::shared_ptr<std::ofstream> > smash::ThermodynamicLatticeOutput::output_ascii_files_

private

map of output file handlers for ASCII format

Definition at line 187 of file thermodynamiclatticeoutput.h.

output_binary_files_

std::map<ThermodynamicQuantity, std::shared_ptr<std::ofstream> > smash::ThermodynamicLatticeOutput::output_binary_files_

private

map of output file handlers for binary format

Definition at line 191 of file thermodynamiclatticeoutput.h.

nodes_

std::array<int, 3> smash::ThermodynamicLatticeOutput::nodes_

private

number of nodes in the lattice along the three axes

Definition at line 194 of file thermodynamiclatticeoutput.h.

sizes_

std::array<double, 3> smash::ThermodynamicLatticeOutput::sizes_

private

lattice resolution along the three axes

Definition at line 197 of file thermodynamiclatticeoutput.h.

origin_

std::array<double, 3> smash::ThermodynamicLatticeOutput::origin_

private

lattice origin orientation: if 0,0,0 is the origin of a cube with face widths 10, the center is at 5,5,5

Definition at line 202 of file thermodynamiclatticeoutput.h.

enable_ascii_

bool smash::ThermodynamicLatticeOutput::enable_ascii_

private

enable output type ASCII

Definition at line 205 of file thermodynamiclatticeoutput.h.

enable_binary_

bool smash::ThermodynamicLatticeOutput::enable_binary_

private

enable output type Binary

Definition at line 208 of file thermodynamiclatticeoutput.h.

enable_output_

bool smash::ThermodynamicLatticeOutput::enable_output_

private

enable output, of any kind (if False, the object does nothing)

Definition at line 211 of file thermodynamiclatticeoutput.h.

---

The documentation for this class was generated from the following files:

• src/include/smash/thermodynamiclatticeoutput.h
• src/thermodynamiclatticeoutput.cc