Solver.cxx File Reference

#include "larreco/SpacePointSolver/Solver.h"
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <set>
#include <string>

Go to the source code of this file.

Functions
template<class T >
T	sqr (T x)
double	Metric (double q, double p)
QuadExpr	Metric (double q, QuadExpr p)
double	Metric (const std::vector< SpaceCharge * > &scs, double alpha)
double	Metric (const std::vector< CollectionWireHit * > &cwires, double alpha)
QuadExpr	Metric (const SpaceCharge *sci, const SpaceCharge *scj, double alpha)
QuadExpr	Metric (const SpaceCharge *sc, double alpha)
double	SolvePair (SpaceCharge *sci, SpaceCharge *scj, double alpha)
void	Iterate (CollectionWireHit *cwire, double alpha)
void	Iterate (SpaceCharge *sc, double alpha)
void	Iterate (const std::vector< CollectionWireHit * > &cwires, const std::vector< SpaceCharge * > &orphanSCs, double alpha)

Function Documentation

void Iterate	(	CollectionWireHit *	cwire,
		double	alpha
	)

Definition at line 260 of file Solver.cxx.

References SpaceCharge::AddCharge(), CollectionWireHit::fCrossings, SolvePair(), and x.

Referenced by Iterate(), and reco3d::SpacePointSolver::Minimize().

{
  // Consider all pairs of crossings
  const unsigned int N = cwire->fCrossings.size();

  for (unsigned int i = 0; i + 1 < N; ++i) {
    SpaceCharge* sci = cwire->fCrossings[i];

    for (unsigned int j = i + 1; j < N; ++j) {
      SpaceCharge* scj = cwire->fCrossings[j];

      const double x = SolvePair(sci, scj, alpha);

      if (x == 0) continue;

      // Actually make the update
      sci->AddCharge(+x);
      scj->AddCharge(-x);
    } // end for j
  }   // end for i
}

void Iterate	(	SpaceCharge *	sc,
		double	alpha
	)

Definition at line 283 of file Solver.cxx.

References SpaceCharge::AddCharge(), QuadExpr::Eval(), SpaceCharge::fPred, QuadExpr::Linear(), Metric(), QuadExpr::Quadratic(), and x.

{
  const QuadExpr chisq = Metric(sc, alpha);

  // Find the minimum of a quadratic expression
  double x = -chisq.Linear() / (2 * chisq.Quadratic());

  // Don't allow the SpaceCharge to go negative
  const double xmin = -sc->fPred;

  // Clamp to allowed range
  x = std::max(xmin, x);

  const double chisq_new = chisq.Eval(x);

  // Should try here too, because the function might be convex not concave, so
  // d/dx=0 gives the max not the min, and the true min is at one extreme of
  // the range.
  const double chisq_n = chisq.Eval(xmin);

  if (chisq_n < chisq_new)
    sc->AddCharge(xmin);
  else
    sc->AddCharge(x);
}

void Iterate	(	const std::vector< CollectionWireHit * > &	cwires,
		const std::vector< SpaceCharge * > &	orphanSCs,
		double	alpha
	)

Definition at line 310 of file Solver.cxx.

References Iterate(), and sc.

{
  // Visiting in a "random" order helps prevent local artefacts that are slow
  // to break up.
  unsigned int cwireIdx = 0;
  if (!cwires.empty()) {
    do {
      Iterate(cwires[cwireIdx], alpha);

      const unsigned int prime = 1299827;
      cwireIdx = (cwireIdx + prime) % cwires.size();
    } while (cwireIdx != 0);
  }

  for (SpaceCharge* sc : orphanSCs)
    Iterate(sc, alpha);
}

double Metric	(	double	q,
		double	p
	)

Definition at line 70 of file Solver.cxx.

References sqr().

Referenced by Iterate(), Metric(), reco3d::SpacePointSolver::Minimize(), and SolvePair().

{
  return sqr(q - p);
}

QuadExpr Metric	(	double	q,
		QuadExpr	p
	)

Definition at line 76 of file Solver.cxx.

References sqr().

{
  return sqr(q - p);
}

double Metric	(	const std::vector< SpaceCharge * > &	scs,
		double	alpha
	)

Definition at line 82 of file Solver.cxx.

References Metric(), sc, and sqr().

{
  double ret = 0;

  std::set<InductionWireHit*> iwires;
  for (const SpaceCharge* sc : scs) {
    if (sc->fWire1) iwires.insert(sc->fWire1);
    if (sc->fWire2) iwires.insert(sc->fWire2);

    if (alpha != 0) {
      ret -= alpha * sqr(sc->fPred);
      // "Double-counting" of the two ends of the connection is
      // intentional. Otherwise we'd have a half in the line above.
      ret -= alpha * sc->fPred * sc->fNeiPotential;
    }
  }

  for (const InductionWireHit* iwire : iwires) {
    ret += Metric(iwire->fCharge, iwire->fPred);
  }

  return ret;
}

double Metric	(	const std::vector< CollectionWireHit * > &	cwires,
		double	alpha
	)

Definition at line 107 of file Solver.cxx.

References Metric().

{
  std::vector<SpaceCharge*> scs;
  for (CollectionWireHit* cwire : cwires)
    scs.insert(scs.end(), cwire->fCrossings.begin(), cwire->fCrossings.end());
  return Metric(scs, alpha);
}

QuadExpr Metric	(	const SpaceCharge *	sci,
		const SpaceCharge *	scj,
		double	alpha
	)

Definition at line 116 of file Solver.cxx.

References InductionWireHit::fCharge, Neighbour::fCoupling, SpaceCharge::fNeighbours, SpaceCharge::fNeiPotential, InductionWireHit::fPred, SpaceCharge::fPred, Neighbour::fSC, SpaceCharge::fWire1, SpaceCharge::fWire2, Metric(), n, sqr(), x, and QuadExpr::X().

{
  QuadExpr ret = 0;

  // How much charge moves from scj to sci
  QuadExpr x = QuadExpr::X();

  if (alpha != 0) {
    const double scip = sci->fPred;
    const double scjp = scj->fPred;

    // Self energy. SpaceCharges are never the same object
    ret -= alpha * sqr(scip + x);
    ret -= alpha * sqr(scjp - x);

    // Interaction. We're only seeing one end of the double-ended connection
    // here, so multiply by two.
    ret -= 2 * alpha * (scip + x) * sci->fNeiPotential;
    ret -= 2 * alpha * (scjp - x) * scj->fNeiPotential;

    // This miscounts if i and j are neighbours of each other
    for (const Neighbour& n : sci->fNeighbours) {
      if (n.fSC == scj) {
        // If we detect that case, remove the erroneous terms
        ret += 2 * alpha * (scip + x) * scjp * n.fCoupling;
        ret += 2 * alpha * (scjp - x) * scip * n.fCoupling;

        // And replace with the correct interaction terms
        ret -= 2 * alpha * (scip + x) * (scjp - x) * n.fCoupling;
        break;
      }
    }
  }

  const InductionWireHit* iwire1 = sci->fWire1;
  const InductionWireHit* jwire1 = scj->fWire1;

  const double qi1 = iwire1 ? iwire1->fCharge : 0;
  const double pi1 = iwire1 ? iwire1->fPred : 0;

  const double qj1 = jwire1 ? jwire1->fCharge : 0;
  const double pj1 = jwire1 ? jwire1->fPred : 0;

  if (iwire1 == jwire1) {
    // Same wire means movement of charge cancels itself out
    if (iwire1) ret += Metric(qi1, pi1);
  }
  else {
    if (iwire1) ret += Metric(qi1, pi1 + x);
    if (jwire1) ret += Metric(qj1, pj1 - x);
  }

  const InductionWireHit* iwire2 = sci->fWire2;
  const InductionWireHit* jwire2 = scj->fWire2;

  const double qi2 = iwire2 ? iwire2->fCharge : 0;
  const double pi2 = iwire2 ? iwire2->fPred : 0;

  const double qj2 = jwire2 ? jwire2->fCharge : 0;
  const double pj2 = jwire2 ? jwire2->fPred : 0;

  if (iwire2 == jwire2) {
    if (iwire2) ret += Metric(qi2, pi2);
  }
  else {
    if (iwire2) ret += Metric(qi2, pi2 + x);
    if (jwire2) ret += Metric(qj2, pj2 - x);
  }

  return ret;
}

QuadExpr Metric	(	const SpaceCharge *	sc,
		double	alpha
	)

Definition at line 189 of file Solver.cxx.

References InductionWireHit::fCharge, SpaceCharge::fNeiPotential, InductionWireHit::fPred, SpaceCharge::fPred, SpaceCharge::fWire1, SpaceCharge::fWire2, Metric(), sqr(), x, and QuadExpr::X().

{
  QuadExpr ret = 0;

  // How much charge is added to sc
  QuadExpr x = QuadExpr::X();

  if (alpha != 0) {
    const double scp = sc->fPred;

    // Self energy
    ret -= alpha * sqr(scp + x);

    // Interaction. We're only seeing one end of the double-ended connection
    // here, so multiply by two.
    ret -= 2 * alpha * (scp + x) * sc->fNeiPotential;
  }

  // Prediction of the induction wires
  ret += Metric(sc->fWire1->fCharge, sc->fWire1->fPred + x);
  ret += Metric(sc->fWire2->fCharge, sc->fWire2->fPred + x);

  return ret;
}

double SolvePair	(	SpaceCharge *	sci,
		SpaceCharge *	scj,
		double	alpha
	)

Definition at line 215 of file Solver.cxx.

References QuadExpr::Eval(), SpaceCharge::fPred, QuadExpr::Linear(), Metric(), QuadExpr::Quadratic(), and x.

Referenced by Iterate().

{
  const QuadExpr chisq = Metric(sci, scj, alpha);
  const double chisq0 = chisq.Eval(0);

  // Find the minimum of a quadratic expression
  double x = -chisq.Linear() / (2 * chisq.Quadratic());

  // Don't allow either SpaceCharge to go negative
  const double xmin = -sci->fPred;
  const double xmax = scj->fPred;

  // Clamp to allowed range
  x = std::min(xmax, x);
  x = std::max(xmin, x);

  const double chisq_new = chisq.Eval(x);

  // Should try these too, because the function might be convex not concave, so
  // d/dx=0 gives the max not the min, and the true min is at one extreme of
  // the range.
  const double chisq_p = chisq.Eval(xmax);
  const double chisq_n = chisq.Eval(xmin);

  if (std::min(std::min(chisq_p, chisq_n), chisq_new) > chisq0 + 1) {
    std::cout << "Solution at " << x << " is worse than current state! Scan from " << xmin << " to "
              << xmax << std::endl;
    for (double x = xmin; x < xmax; x += .01 * (xmax - xmin)) {
      std::cout << x << " " << chisq.Eval(x) << std::endl;
    }

    std::cout << "Soln, original, up edge, low edge:" << std::endl;
    std::cout << chisq_new << " " << chisq0 << " " << chisq_p << " " << chisq_n << std::endl;
    abort();
  }

  if (std::min(chisq_n, chisq_p) < chisq_new) {
    if (chisq_n < chisq_p) return xmin;
    return xmax;
  }

  return x;
}

template<class T >

T sqr

(

T

x

)

Definition at line 10 of file Solver.cxx.

References x.

Referenced by Metric().

{
  return x * x;
}