sppt::SpacePointAlg_TimeSort Class Reference

#include <SpacePointAlg_TimeSort.h>

Public Member Functions
	SpacePointAlg_TimeSort (fhicl::ParameterSet const &pset)
void	setTimeOffsets (detinfo::DetectorPropertiesData const &detProp)
void	fillCoordinatesArrays ()
void	createSpacePoints (detinfo::DetectorPropertiesData const &detProp, std::vector< art::Ptr< recob::Hit >> &hitVec_U, std::vector< art::Ptr< recob::Hit >> &hitVec_V, std::vector< art::Ptr< recob::Hit >> &hitVec_Y, std::unique_ptr< std::vector< recob::SpacePoint >> &spptCollection, std::unique_ptr< std::vector< std::vector< art::Ptr< recob::Hit >>>> &spptAssociatedHits)

Private Member Functions
void	sortHitsByTime (std::vector< art::Ptr< recob::Hit >> &hits_handle) const

Private Attributes
float	fTimeDiffMax
float	fYDiffMax
	Maximum allowed time difference. More...
float	fZDiffMax
	Maximum allowed y-coordinate difference. More...
bool	TIME_OFFSET_SET {false}
	Maximum allowed z-coordinate difference. More...
bool	COORDINATES_FILLED {false}
double	TIME_OFFSET_U
double	TIME_OFFSET_V
double	TIME_OFFSET_Y
double	TICKS_TO_X
boost::multi_array< double, 2 >	coordinates_UV_y
boost::multi_array< double, 2 >	coordinates_UV_z
boost::multi_array< double, 2 >	coordinates_UY_y
boost::multi_array< double, 2 >	coordinates_UY_z

Detailed Description

Definition at line 42 of file SpacePointAlg_TimeSort.h.

Constructor & Destructor Documentation

sppt::SpacePointAlg_TimeSort::SpacePointAlg_TimeSort ( fhicl::ParameterSet const &  pset )

explicit

Definition at line 49 of file SpacePointAlg_TimeSort.cxx.

  {
    fTimeDiffMax = pset.get<float>("TimeDiffMax");
    fZDiffMax = pset.get<float>("ZDiffMax");
    fYDiffMax = pset.get<float>("YDiffMax");

    //enforce a minimum time diff
    if (fTimeDiffMax < 0) {
      throw cet::exception("SpacePointAlg_TimeSort")
        << "Time difference must be greater than zero.";
    }
    if (fZDiffMax < 0) {
      throw cet::exception("SpacePointAlg_TimeSort")
        << "Z-coordinate difference must be greater than zero.";
    }
    if (fYDiffMax < 0) {
      throw cet::exception("SpacePointAlg_TimeSort")
        << "Y-coordinate difference must be greater than zero.";
    }
  }

Member Function Documentation

void sppt::SpacePointAlg_TimeSort::createSpacePoints	(	detinfo::DetectorPropertiesData const &	detProp,
		std::vector< art::Ptr< recob::Hit >> &	hitVec_U,
		std::vector< art::Ptr< recob::Hit >> &	hitVec_V,
		std::vector< art::Ptr< recob::Hit >> &	hitVec_Y,
		std::unique_ptr< std::vector< recob::SpacePoint >> &	spptCollection,
		std::unique_ptr< std::vector< std::vector< art::Ptr< recob::Hit >>>> &	spptAssociatedHits
	)

Definition at line 123 of file SpacePointAlg_TimeSort.cxx.

  {

    if (!TIME_OFFSET_SET) {
      mf::LogWarning("SpacePointAlg_TimeSort")
        << "Time offsets not set before createSpacePoints call!"
        << "\nYou should call SpacePointAlg_TimeSort::setTimeOffsets() in beginRun()!"
        << "\nWill be set now, but you should modify your code!";
      setTimeOffsets(detProp);
    }
    if (!COORDINATES_FILLED) {
      mf::LogWarning("SpacePointAlg_TimeSort")
        << "Coordinate arrays not filled before createSpacePoints call!"
        << "\nYou should call SpacePointAlg_TimeSort::fillCoordinateArrays() in beginRun()!"
        << "\nWill be filled now, but you should modify your code!";
      fillCoordinatesArrays();
    }

    //sort the hits by the time
    sortHitsByTime(hitVec_U);
    sortHitsByTime(hitVec_V);
    sortHitsByTime(hitVec_Y);

    MF_LOG_DEBUG("SpacePointAlg_TimeSort")
      << "Sorted " << hitVec_U.size() << " u hits, " << hitVec_V.size() << " v hits, "
      << hitVec_Y.size() << " y hits.";

    //now, do the loop to search for like-timed hits across the three planes
    std::vector<art::Ptr<recob::Hit>>::iterator ihitu = hitVec_U.begin();
    std::vector<art::Ptr<recob::Hit>>::iterator ihitv = hitVec_V.begin();
    std::vector<art::Ptr<recob::Hit>>::iterator ihity = hitVec_Y.begin();
    std::vector<art::Ptr<recob::Hit>>::iterator ihitv_inner, ihity_inner;
    double time_hitu = (*ihitu)->PeakTime() + TIME_OFFSET_U;
    double time_hitv = (*ihitv)->PeakTime() + TIME_OFFSET_V;
    double time_hity = (*ihity)->PeakTime() + TIME_OFFSET_Y;
    double time_hitv_inner, time_hity_inner;
    while (ihitu != hitVec_U.end()) {
      time_hitu = (*ihitu)->PeakTime() + TIME_OFFSET_U;

      mf::LogInfo("SpacePointAlg_TimeSort")
        << "Hit times (u,v,y)=(" << time_hitu << "," << time_hitv << "," << time_hity << ")";

      //if time_hitu is too much bigger than time_hitv, need to advance hitv iterator
      while ((time_hitu - time_hitv) > fTimeDiffMax) {
        ihitv++;
        if (ihitv == hitVec_V.end()) break;
        time_hitv = (*ihitv)->PeakTime() + TIME_OFFSET_V;
      }
      if (ihitv == hitVec_V.end()) break;

      //same thing with time_hitu and time_hity
      while ((time_hitu - time_hity) > fTimeDiffMax) {
        ihity++;
        if (ihity == hitVec_Y.end()) break;
        time_hity = (*ihity)->PeakTime() + TIME_OFFSET_Y;
      }
      if (ihity == hitVec_Y.end()) break;

      //OK, now we know time_hitu <= time_hitv and time_hitu <= time_hity.
      //Next, check if time_hitu is near time_hitv and time_hit y. If not,
      //we have to increment ihitu.
      if (std::abs(time_hitu - time_hitv) > fTimeDiffMax ||
          std::abs(time_hitu - time_hity) > fTimeDiffMax) {
        ihitu++;
        continue;
      }

      //OK! Note we KNOW that these three match in time:
      //  -- time_hitu is within fTimeDiffMax of both time_hitv and time_hity; and
      //  -- time_hitu <= time_hitv AND time_hitu <=time_hity, so time_hitv and time_hity are near too

      mf::LogInfo("SpacePointAlg_TimeSort") << "Matching hit times (u,v,y)=(" << time_hitu << ","
                                            << time_hitv << "," << time_hity << ")";

      //Next thing to do, we need to loop over all possible 3-hit matches for our given u-hit.
      //We need new iterators in v and y at this location, and will loop over those
      ihitv_inner = ihitv;
      time_hitv_inner = (*ihitv_inner)->PeakTime() + TIME_OFFSET_V;
      ihity_inner = ihity;
      time_hity_inner = (*ihity_inner)->PeakTime() + TIME_OFFSET_Y;

      while (std::abs(time_hitu - time_hitv_inner) < fTimeDiffMax &&
             std::abs(time_hitu - time_hity_inner) < fTimeDiffMax) {

        unsigned int uwire = (*ihitu)->WireID().Wire;
        unsigned int vwire = (*ihitv_inner)->WireID().Wire;
        unsigned int ywire = (*ihity_inner)->WireID().Wire;

        mf::LogInfo("SpacePointAlg_TimeSort")
          << "(y,z) coordinate for uv/uy: (" << coordinates_UV_y[vwire][uwire] << ","
          << coordinates_UV_z[vwire][uwire] << ")/(" << coordinates_UY_y[ywire][uwire] << ","
          << coordinates_UY_z[ywire][uwire] << ")";

        if (std::abs(coordinates_UV_y[vwire][uwire] - coordinates_UY_y[ywire][uwire]) < fYDiffMax &&
            std::abs(coordinates_UV_z[vwire][uwire] - coordinates_UY_z[ywire][uwire]) < fZDiffMax) {

          double xyz[3];
          double xyz_err[6];
          //triangular error matrix:
          // | 0.         |
          // | 0.  0.     |
          // | 0.  0.  0. |

          //get average y and z, with errors
          xyz[1] = (coordinates_UV_y[vwire][uwire] + coordinates_UY_y[ywire][uwire]) * 0.5;
          xyz_err[2] = std::abs(coordinates_UV_y[vwire][uwire] - xyz[1]);
          xyz[2] = (coordinates_UV_z[vwire][uwire] + coordinates_UY_z[ywire][uwire]) * 0.5;
          xyz_err[5] = std::abs(coordinates_UV_z[vwire][uwire] - xyz[2]);

          double t_val = (time_hitu + time_hitv_inner + time_hity_inner) / 3.;
          double t_err = 0.5 * std::sqrt((time_hitu - t_val) * (time_hitu - t_val) +
                                         (time_hitv_inner - t_val) * (time_hitv_inner - t_val) +
                                         (time_hity_inner - t_val) * (time_hity_inner - t_val));
          xyz[0] = TICKS_TO_X * t_val;
          xyz_err[0] = TICKS_TO_X * t_err;

          //make space point to put on event
          recob::SpacePoint spt(xyz, xyz_err, 0., spptCollection->size());
          spptCollection->push_back(spt);

          //make association with hits
          std::vector<art::Ptr<recob::Hit>> myhits = {*ihitu, *ihitv_inner, *ihity_inner};
          spptAssociatedHits->push_back(myhits);
        }

        //now increment the v or y hit, whichever is smalles (closest to u hit) in time
        if (time_hitv_inner <= time_hity_inner) {
          ihitv_inner++;
          if (ihitv_inner == hitVec_V.end()) break;
          time_hitv_inner = (*ihitv_inner)->PeakTime() + TIME_OFFSET_V;
        }
        else {
          ihity_inner++;
          if (ihity_inner == hitVec_Y.end()) break;
          time_hity_inner = (*ihity_inner)->PeakTime() + TIME_OFFSET_Y;
        }
      }

      ihitu++;
    } // end while looping over u hits

    MF_LOG_DEBUG("SpacePointAlg_TimeSort")
      << "Finished with " << spptCollection->size() << " spacepoints.";

  } //end createSpacePoints

void sppt::SpacePointAlg_TimeSort::fillCoordinatesArrays

(

)

Definition at line 84 of file SpacePointAlg_TimeSort.cxx.

  {
    art::ServiceHandle<geo::Geometry const> geom;
    unsigned int nwires_u = geom->Nwires(geo::View_t::kU);
    unsigned int nwires_v = geom->Nwires(geo::View_t::kV);
    unsigned int nwires_y = geom->Nwires(geo::View_t::kZ);

    coordinates_UV_y.resize(boost::extents[nwires_v][nwires_u]);
    coordinates_UV_z.resize(boost::extents[nwires_v][nwires_u]);
    coordinates_UY_y.resize(boost::extents[nwires_y][nwires_u]);
    coordinates_UY_z.resize(boost::extents[nwires_y][nwires_u]);
    for (unsigned int iu = 0; iu < nwires_u; iu++) {
      for (unsigned int iv = 0; iv < nwires_v; iv++) {
        geom->IntersectionPoint(iu,
                                iv,
                                geo::View_t::kU,
                                geo::View_t::kV,
                                0,
                                0,
                                coordinates_UV_y[iv][iu],  //y
                                coordinates_UV_z[iv][iu]); //z
      }
      for (unsigned int iy = 0; iy < nwires_y; iy++) {
        geom->IntersectionPoint(iu,
                                iy,
                                geo::View_t::kU,
                                geo::View_t::kZ,
                                0,
                                0,
                                coordinates_UY_y[iy][iu],
                                coordinates_UY_z[iy][iu]);
      }
    }

    COORDINATES_FILLED = true;
  }

void sppt::SpacePointAlg_TimeSort::setTimeOffsets

(

detinfo::DetectorPropertiesData const &

detProp

)

Definition at line 72 of file SpacePointAlg_TimeSort.cxx.

  {
    TIME_OFFSET_U = -1 * detProp.GetXTicksOffset(geo::View_t::kU, 0, 0);
    TIME_OFFSET_V = -1 * detProp.GetXTicksOffset(geo::View_t::kV, 0, 0);
    TIME_OFFSET_Y = -1 * detProp.GetXTicksOffset(geo::View_t::kZ, 0, 0);
    TICKS_TO_X = detProp.GetXTicksCoefficient();

    TIME_OFFSET_SET = true;
  }

void sppt::SpacePointAlg_TimeSort::sortHitsByTime ( std::vector< art::Ptr< recob::Hit >> &  hits_handle ) const

private

Definition at line 277 of file SpacePointAlg_TimeSort.cxx.

  {
    std::sort(hitVec.begin(), hitVec.end(), HitTimeComparison);
  }

Member Data Documentation

bool sppt::SpacePointAlg_TimeSort::COORDINATES_FILLED {false}

private

Definition at line 63 of file SpacePointAlg_TimeSort.h.

boost::multi_array<double, 2> sppt::SpacePointAlg_TimeSort::coordinates_UV_y

private

Definition at line 70 of file SpacePointAlg_TimeSort.h.

boost::multi_array<double, 2> sppt::SpacePointAlg_TimeSort::coordinates_UV_z

private

Definition at line 71 of file SpacePointAlg_TimeSort.h.

boost::multi_array<double, 2> sppt::SpacePointAlg_TimeSort::coordinates_UY_y

private

Definition at line 72 of file SpacePointAlg_TimeSort.h.

boost::multi_array<double, 2> sppt::SpacePointAlg_TimeSort::coordinates_UY_z

private

Definition at line 73 of file SpacePointAlg_TimeSort.h.

float sppt::SpacePointAlg_TimeSort::fTimeDiffMax

private

Definition at line 58 of file SpacePointAlg_TimeSort.h.

float sppt::SpacePointAlg_TimeSort::fYDiffMax

private

Maximum allowed time difference.

Definition at line 59 of file SpacePointAlg_TimeSort.h.

float sppt::SpacePointAlg_TimeSort::fZDiffMax

private

Maximum allowed y-coordinate difference.

Definition at line 60 of file SpacePointAlg_TimeSort.h.

double sppt::SpacePointAlg_TimeSort::TICKS_TO_X

private

Definition at line 68 of file SpacePointAlg_TimeSort.h.

bool sppt::SpacePointAlg_TimeSort::TIME_OFFSET_SET {false}

private

Maximum allowed z-coordinate difference.

Definition at line 62 of file SpacePointAlg_TimeSort.h.

double sppt::SpacePointAlg_TimeSort::TIME_OFFSET_U

private

Definition at line 65 of file SpacePointAlg_TimeSort.h.

double sppt::SpacePointAlg_TimeSort::TIME_OFFSET_V

private

Definition at line 66 of file SpacePointAlg_TimeSort.h.

double sppt::SpacePointAlg_TimeSort::TIME_OFFSET_Y

private

Definition at line 67 of file SpacePointAlg_TimeSort.h.

---

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

• SpacePointAlg_TimeSort.h
• SpacePointAlg_TimeSort.cxx