VertexChargeVacuum_module.cc File Reference

#include "art/Framework/Core/EDProducer.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.h"
#include "art/Framework/Principal/Run.h"
#include "art/Framework/Principal/SubRun.h"
#include "canvas/Utilities/InputTag.h"
#include "fhiclcpp/ParameterSet.h"
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "lardata/Utilities/AssociationUtil.h"
#include <memory>
#include "lardataobj/RecoBase/Wire.h"
#include "lardataobj/RecoBase/Vertex.h"
#include "lardataobj/RecoBase/Hit.h"
#include "lardataobj/RecoBase/SpacePoint.h"
#include "lardataobj/RecoBase/Cluster.h"
#include "larcore/Geometry/Geometry.h"
#include "larcore/CoreUtils/ServiceUtil.h"
#include "larcorealg/Geometry/GeometryCore.h"
#include "lardataalg/DetectorInfo/DetectorPropertiesStandard.h"
#include "lardata/DetectorInfoServices/DetectorPropertiesService.h"
#include "lardataobj/RecoBase/Slice.h"
#include "lardataobj/RecoBase/Track.h"
#include "lardataobj/RecoBase/PFParticle.h"
#include "larreco/Calorimetry/CalorimetryAlg.h"
#include "larreco/Calorimetry/INormalizeCharge.h"
#include "larevt/SpaceCharge/SpaceCharge.h"
#include "larevt/SpaceChargeServices/SpaceChargeService.h"
#include "art/Utilities/make_tool.h"
#include "sbnobj/Common/Reco/VertexHit.h"
#include "sbncode/TPCReco/VertexStub/StubMergeAlgorithms.h"

Go to the source code of this file.

Classes
class	sbn::VertexChargeVacuum

Namespaces
	sbn
	This module creates Common Analysis Files.

Functions
	produces< art::Assns< recob::Slice, sbn::VertexHit > > ()
	produces< art::Assns< recob::Hit, sbn::VertexHit > > ()
	produces< art::Assns< recob::Vertex, sbn::VertexHit > > ()
std::array< float, 2 >	HitVector (const recob::Hit &hit, const geo::GeometryCore *geo, const detinfo::DetectorPropertiesData &dprop)
std::array< float, 2 >	VertexVector (const recob::Vertex &vert, const geo::PlaneID &plane, const geo::GeometryCore *geo, const detinfo::DetectorPropertiesData &dprop)
float	Vert2HitDistance (const recob::Hit &hit, const recob::Vertex &vert, const geo::GeometryCore *geo, const detinfo::DetectorPropertiesData &dprop)
std::array< float, 2 >	HitDirection (const std::vector< art::Ptr< recob::Hit >> &hits, const recob::Vertex &vert, const geo::GeometryCore *geo, const detinfo::DetectorPropertiesData &dprop)
float	TrackDirectionParallel (const recob::Track &trk, const geo::PlaneID &plane, const geo::GeometryCore *geo, const detinfo::DetectorPropertiesData &dprop)
geo::Point_t	PlaceHitAlongTrack (const recob::Track &trk, const recob::Vertex &vert, const recob::Hit &hit, const geo::GeometryCore *geo, const detinfo::DetectorPropertiesData &dprop)

Function Documentation

std::array<float, 2> HitDirection	(	const std::vector< art::Ptr< recob::Hit >> &	hits,
		const recob::Vertex &	vert,
		const geo::GeometryCore *	geo,
		const detinfo::DetectorPropertiesData &	dprop
	)

Definition at line 139 of file VertexChargeVacuum_module.cc.

                                                                                       {
  if (!hits.size()) return {0., 0.};

  geo::Vector_t avg(0., 0., 0.);

  std::array<float, 2> vert_v = VertexVector(vert, hits[0]->WireID(), geo, dprop);
  geo::Point_t vert_p(vert_v[0], vert_v[1], 0.);

  for (const art::Ptr<recob::Hit> &h: hits) {
    std::array<float, 2> hit_v = HitVector(*h, geo, dprop);
    geo::Point_t hit_p(hit_v[0], hit_v[1], 0.);
    avg += (hit_p - vert_p).Unit(); 
  }

  avg = avg.Unit();

  return {(float)avg.X(), (float)avg.Y()};
}

std::array<float, 2> HitVector	(	const recob::Hit &	hit,
		const geo::GeometryCore *	geo,
		const detinfo::DetectorPropertiesData &	dprop
	)

Definition at line 115 of file VertexChargeVacuum_module.cc.

                                                                                                                          {
  float wire_distance = hit.WireID().Wire;
  // convert to cm
  float wire_distance_cm = wire_distance * geo->WirePitch();
  // and the time difference
  float time_distance = hit.PeakTime();
  // convert to cm
  float time_distance_cm = dprop.ConvertTicksToX(time_distance, hit.WireID());

  return {wire_distance_cm, time_distance_cm};
}

geo::Point_t PlaceHitAlongTrack	(	const recob::Track &	trk,
		const recob::Vertex &	vert,
		const recob::Hit &	hit,
		const geo::GeometryCore *	geo,
		const detinfo::DetectorPropertiesData &	dprop
	)

Definition at line 170 of file VertexChargeVacuum_module.cc.

                                                                                       {
  // project the vertex onto the hit Plane
  std::array<float, 2> v_plane = VertexVector(vert, hit.WireID(), geo, dprop); 

  // also get the 2d hit location
  std::array<float, 2> h_plane = HitVector(hit, geo, dprop);

  float t_dir_parallel_plane = TrackDirectionParallel(trk, hit.WireID(), geo, dprop);

  // Get the distance from the vertex to the hit on the plane.
  //
  // The track "should" be along the same direction as the vertex to the hit in the plane,
  // so this distance is the same as the distance along the track
  float plane_dist = (h_plane[0] - v_plane[0]) + (h_plane[1] - v_plane[1]);
 
  // Use this distance to place the hit along the track trajectory in 3D
  float dist_3d = plane_dist / t_dir_parallel_plane;

  // std::cout << "Placing Hit\n";
  // std::cout << "Hit wire: " << hit.WireID() << std::endl;
  // std::cout << "Hit plane coord: " << h_plane[0] << " " << h_plane[1] << std::endl;
  // std::cout << "Vtx plane coord: " << v_plane[0] << " " << v_plane[1] << std::endl;
  // std::cout << "Trk dir: " << trk.StartDirection().x() << " " << trk.StartDirection().y() << " " << trk.StartDirection().z() << std::endl;
  // std::cout << "Vtx pos: " << vert.position().x() << " " << vert.position().y() << " " << vert.position().z() << std::endl;

  // std::cout << "Trk parallel dir: " << t_dir_parallel_plane << std::endl;
  // std::cout << "Hit plane dist: " << plane_dist << std::endl;
  // std::cout << "Hit 3d dist: " << dist_3d << std::endl;

  geo::Vector_t trk_dir(trk.StartDirection().x(), trk.StartDirection().y(), trk.StartDirection().z());

  return vert.position() + trk_dir * dist_3d;
}

produces< art::Assns< recob::Hit, sbn::VertexHit > >

(

)

produces< art::Assns< recob::Slice, sbn::VertexHit > >

(

)

produces< art::Assns< recob::Vertex, sbn::VertexHit > >

(

)

float TrackDirectionParallel	(	const recob::Track &	trk,
		const geo::PlaneID &	plane,
		const geo::GeometryCore *	geo,
		const detinfo::DetectorPropertiesData &	dprop
	)

Definition at line 159 of file VertexChargeVacuum_module.cc.

                                                                                       {
  double angleToVert = geo->WireAngleToVertical(geo->View(plane), plane) - 0.5*::util::pi<>();
  double cosgamma = std::abs(std::sin(angleToVert)*trk.StartDirection().y() + std::cos(angleToVert)*trk.StartDirection().z());

  float ret = sqrt(cosgamma * cosgamma + trk.StartDirection().x() * trk.StartDirection().x());

  return ret;
  
}

float Vert2HitDistance	(	const recob::Hit &	hit,
		const recob::Vertex &	vert,
		const geo::GeometryCore *	geo,
		const detinfo::DetectorPropertiesData &	dprop
	)

Definition at line 131 of file VertexChargeVacuum_module.cc.

                                                                                                                                             {
  std::array<float, 2> vert_v = VertexVector(vert, hit.WireID(), geo, dprop);
  std::array<float, 2> hit_v = HitVector(hit, geo, dprop);

  return sqrt((vert_v[0] - hit_v[0]) * (vert_v[0] - hit_v[0]) + (vert_v[1] - hit_v[1]) * (vert_v[1] - hit_v[1]));
}

std::array<float, 2> VertexVector	(	const recob::Vertex &	vert,
		const geo::PlaneID &	plane,
		const geo::GeometryCore *	geo,
		const detinfo::DetectorPropertiesData &	dprop
	)

Definition at line 127 of file VertexChargeVacuum_module.cc.

                                                                                                                                                          {
  return {(float)(geo->WireCoordinate(vert.position(), plane) * geo->WirePitch()), (float)vert.position().X()};
}