Trajectory.tcc

Go to the documentation of this file.

/**
 * @file   Trajectory.tcc
 * @brief  Template implementation for Trajectory.h
 * @author Gianluca Petrillo (petrillo@fnal.gov)
 * @date   January 3, 2016
 * 
 * This file is directly included in `Trajectory.h`.
 * 
 */

#ifndef LARDATAOBJ_RECOBASE_TRAJECTORY_TCC
#define LARDATAOBJ_RECOBASE_TRAJECTORY_TCC

#ifndef LARDATAOBJ_RECOBASE_TRAJECTORY_H
# error "Do not include Trajectory.tcc. Include in Trajectory.h instead."
#endif // !LARDATAOBJ_RECOBASE_TRAJECTORY_H


// LArSoft libraries
#include "lardataobj/Utilities/DataIOmanip.h" // util::manip::vector3D

// C/C++ standard libraries
#include <algorithm> // std::max()
#include <utility> // std::forward()


//------------------------------------------------------------------------------
template <typename Stream>
void recob::Trajectory::Dump(
  Stream&& out,
  unsigned int verbosity,
  std::string indent, std::string indentFirst
  ) const
{
  /*
   * This implementation follows this table:
   * 
   * 
   * * level `0`: start position, direction, momentum modulus and number of
   *     points
   * * level `1`: also end position, direction and momentum modulus
   * * level `2`: also trajectory length
   * * level `3`: also angles at start
   * * level `4`: also 9 intermediate trajectory points
   * * level `5`: also 10 more intermediate trajectory points (19 total)
   * * level `6`: all trajectory points
   * 
   */
  
  if (NPoints() < 2) {
    out << indentFirst
      << "invalid trajectory with " << NPoints() << " points";
    return;
  }
  
  //----------------------------------------------------------------------------
  out << indentFirst
    << "trajectory with " << NPoints() << " points at "
    << util::manip::vector3D(Start()) << " cm toward "
    << util::manip::vector3D(StartDirection());
  if (HasMomentum()) out << " with momentum " << StartMomentum() << " GeV/c";
//  else out << " (no momentum information)"; // this is already evident...
  
  if (verbosity <= 0) return;
  //----------------------------------------------------------------------------
  out << indentFirst
    << "\n" << indent << "ends at " << util::manip::vector3D(End())
    << " cm toward " << util::manip::vector3D(EndDirection());
  if (HasMomentum()) out << " with momentum " << EndMomentum() << " GeV/c";
  
  if (verbosity <= 1) return;
  //----------------------------------------------------------------------------
  out
    << " running " << Length() << " cm long";
  
  if (verbosity <= 2) return;
  //----------------------------------------------------------------------------
  
  out << "\n" << indent
    << "starting with theta " << Theta() << " rad, phi " << Phi()
    << " rad; zenith: " << ZenithAngle() << " rad, azimuth: " << AzimuthAngle()
    << " rad";
  
  if (verbosity <= 3) return;
  //----------------------------------------------------------------------------
  auto const nPoints = NPoints();
  unsigned int nPrintedPoints;
  switch (verbosity) {
    case 4:
      nPrintedPoints =  9; break;
    case 5:
      nPrintedPoints = 19; break;
    case 6:
    default:
      nPrintedPoints = nPoints - 2; break;
  } // switch
  float delta = std::max(float(nPoints - 1) / (nPrintedPoints + 1), 1.0f);
  // number of trajectory points printed per line:
  constexpr unsigned int pointsPerLine = 2;
  unsigned int pointsInLine = 0;
  out << " through:";
  
  for (unsigned int step = 1; step <= nPrintedPoints; ++step) {
    size_t iPoint = delta * step;
    if (iPoint >= LastPoint()) break;
    
    // new line every pointsPerLine points
    if (pointsInLine++ == 0) out << "\n" << indent;
    if (pointsInLine >= pointsPerLine) pointsInLine = 0;
    
    out << "  [#" << iPoint << "] at "
      << util::manip::vector3D(LocationAtPoint(iPoint)) << " cm, "
      << util::manip::vector3D(MomentumVectorAtPoint(iPoint));
    if (HasMomentum()) out << " GeV/c";
    
  } // for
  
  
  if (verbosity <= 6) return;
  //----------------------------------------------------------------------------
  static_assert(MaxDumpVerbosity == 6,
    "recob::Trajectory: either Dump() code or MaxDumpVerbosity value must be updated"
    );
  
} // recob::Trajectory::Dump()


//------------------------------------------------------------------------------
template <typename Stream>
void recob::Trajectory::LowLevelDump
  (Stream&& out, std::string indent, std::string indentFirst) const
{
  out << indentFirst << "recob::Trajectory[" << ((void*) this) << "]("
    << "\n" << indent << "fPositions={ // " << fPositions.size() << " elements";
  for (size_t i = 0; i < fPositions.size(); ++i) {
    out << "\n" << indent << " [" << i << "] "
      << util::manip::vector3D(fPositions[i]);
  }
  out
    << "\n" << indent << "},"
    << "\n" << indent << "fMomenta={ // " << fMomenta.size() << " elements";
  for (size_t i = 0; i < fMomenta.size(); ++i) {
    out << "\n" << indent << " [" << i << "] "
      << util::manip::vector3D(fMomenta[i]);
  }
  out
    << "\n" << indent << "},"
    << "\n" << indent << "fHasMomenta=" << fHasMomentum
    << "\n" << indent << ")";
  
} // recob::Trajectory::LowLevelDump()


//------------------------------------------------------------------------------
template <typename Vect>
void recob::details::legacy::FillVector
  (Vect const& source, std::vector<double>& dest)
{
  dest.resize(3);
  dest[0] = source.X();
  dest[1] = source.Y();
  dest[2] = source.Z();
} // recob::details::legacy::FillVector(std::vector<double>)

template <typename Vect>
void recob::details::legacy::FillVector
  (Vect const& source, double* dest)
{
  // just hope there is enough space
  dest[0] = source.X();
  dest[1] = source.Y();
  dest[2] = source.Z();
} // recob::details::legacy::FillVector(double*)


template <typename SrcVect, typename DestVect>
void recob::details::legacy::FillTwoVectors(
  SrcVect const& firstSource, SrcVect const& secondSource,
  DestVect&& firstDest, DestVect&& secondDest
  )
{
  FillVector(firstSource, std::forward<DestVect>(firstDest));
  FillVector(secondSource, std::forward<DestVect>(secondDest));
} // recob::details::legacy::FillTwoVectors()


//------------------------------------------------------------------------------


#endif // LARDATAOBJ_RECOBASE_TRAJECTORY_TCC