ICARUSgeometryChecker Namespace Reference

def ICARUSgeometryChecker.checkPlaneAlignment	(	planes,
		tolerance = `0.1`
	)

Check alignment in y and z position of planes on the same x.

Returns triples (distance, first plane, second plane) for each misaligned
pair of planes.

Definition at line 78 of file ICARUSgeometryChecker.py.

 
 def checkPlaneAlignment(planes, tolerance = 0.1):
   """Check alignment in y and z position of planes on the same x.
   
   Returns triples (distance, first plane, second plane) for each misaligned
   pair of planes.
   """
   assert tolerance >= 0.0
   PlanesByX = groupPlanesByX(planes, sortBy = 'z')
   inconsistentPlanes = {}
   for planesOnX in PlanesByX:
     if len(planesOnX) < 2: continue
     planeIter = iter(planesOnX)
     refPlane = next(planeIter)
     for nextPlane in planeIter:
       refBox = refPlane.BoundingBox()
       nextBox = nextPlane.BoundingBox()
       #
       # 1. check plane alignment on z direction
       #
       distance = nextBox.MinZ() - refBox.MaxZ()
       if abs(distance) > tolerance:
         logging.error(
          "Planes on x=%s are misaligned along z: ( %g -- %g ) (%s) vs. ( %g -- %g ) (%s)",
          refPlane.GetCenter().X(), refBox.MinZ(), refBox.MaxZ(), refPlane.ID(),
          nextBox.MinZ(), nextBox.MaxZ(), nextPlane.ID(),
          )
         inconsistentPlanes.setdefault('zalign', []) \
          .append( ( distance, refPlane, nextPlane, ) )
       # if misaligned on z
       
       #
       # 2. check plane alignment on y direction
       #
       topDistance = nextBox.MaxY() - refBox.MaxY()
       if abs(topDistance) > tolerance:
         logging.error(
          "Planes on x=%s are misaligned along y: ( %g -- %g ) (%s) vs. ( %g -- %g ) (%s)",
          refPlane.GetCenter().X(), refBox.MinY(), refBox.MaxY(), refPlane.ID(),
          nextBox.MinY(), nextBox.MaxY(), nextPlane.ID(),
          )
         inconsistentPlanes.setdefault('topYalign', []) \
          .append( ( topDistance, refPlane, nextPlane, ) )
       # if misaligned on top y
       bottomDistance = nextBox.MinY() - refBox.MinY()
       if abs(bottomDistance) > tolerance:
         inconsistentPlanes.setdefault('bottomYalign', []) \
          .append( ( bottomDistance, refPlane, nextPlane, ) )
       # if misaligned on bottom y
       if 'topYalign' in inconsistentPlanes or 'bottomYalign' in inconsistentPlanes:
         logging.error(
          "Planes on x=%s are misaligned along y: ( %g -- %g ) (%s) vs. ( %g -- %g ) (%s)",
          refPlane.GetCenter().X(), refBox.MinY(), refBox.MaxY(), refPlane.ID(),
          nextBox.MinY(), nextBox.MaxY(), nextPlane.ID(),
          )
       # if misaligned on bottom y
       
       #
       # 3. check wire view
       #
       if refPlane.View() != nextPlane.View():
         logging.error("Plane %s is on view '%s', %s is on view '%s'.",
          refPlane.ID(), ROOT.geo.PlaneGeo.ViewName(refPlane.View()),
          nextPlane.ID(), ROOT.geo.PlaneGeo.ViewName(nextPlane.View()),
          )
         inconsistentPlanes.setdefault('view', []) \
          .append( ( refPlane, nextPlane, ) )
       # if views do not match
       
       #
       # 4. check wire orientation
       #
       if 1.0 - refPlane.GetIncreasingWireDirection().Dot(nextPlane.GetIncreasingWireDirection()) > tolerance:
         logging.error("Plane %s measures direction %s, %s measures %s.",
          refPlane.ID(), refPlane.GetIncreasingWireDirection(),
          nextPlane.ID(), nextPlane.GetIncreasingWireDirection(),
          )
         inconsistentPlanes.setdefault('direction', []) \
          .append( ( refPlane, nextPlane, ) )
       # if views do not match
       
       #
       # 5. check wire extremes alignment along y and z
       # 
       # This check is different than the previous one in that it uses the actual
       # coverage of wires rather than the wire plane box boundaries.
       #
       refWireMinY = min(
         min(wire.GetStart().Y(), wire.GetEnd().Y())
         for wire in refPlane.IterateWires()
         )
       refWireMaxY = max(
         max(wire.GetStart().Y(), wire.GetEnd().Y())
         for wire in refPlane.IterateWires()
         )
       refWireMaxZ = max(
         max(wire.GetStart().Z(), wire.GetEnd().Z())
         for wire in refPlane.IterateWires()
         )
       nextWireMinY = min(
         min(wire.GetStart().Y(), wire.GetEnd().Y())
         for wire in nextPlane.IterateWires()
         )
       nextWireMaxY = max(
         max(wire.GetStart().Y(), wire.GetEnd().Y())
         for wire in nextPlane.IterateWires()
         )
       nextWireMinZ = min(
         min(wire.GetStart().Z(), wire.GetEnd().Z())
         for wire in nextPlane.IterateWires()
         )
       
       if abs(nextWireMinZ - refWireMaxZ) > tolerance:
         logging.error(
           "Wires of planes on x=%s are misaligned along z: %s ends at %g cm, %s restarts at %g cm",
           refPlane.GetCenter().X(), refPlane.ID(), refWireMaxZ, nextPlane.ID(), nextWireMinZ, 
           )
         inconsistentPlanes.setdefault('wireZalign', []) \
          .append( ( nextWireMinZ - refWireMaxZ, refPlane, nextPlane, ) )
       # if misaligned on z
       
       if abs(nextWireMaxY - refWireMaxY) > tolerance:
         logging.error(
           "Wires of planes on x=%s are misaligned along y: %s tops at %g cm, %s at %g cm",
           refPlane.GetCenter().X(), refPlane.ID(), refWireMaxY, nextPlane.ID(), nextWireMaxY, 
           )
         inconsistentPlanes.setdefault('wireTopYalign', []) \
          .append( ( nextWireMaxY - refWireMaxY, refPlane, nextPlane, ) )
       # if misaligned on top y
       
       if abs(nextWireMinY - refWireMinY) > tolerance:
         logging.error(
           "Wires of planes on x=%s are misaligned along y: %s floors at %g cm, %s at %g cm",
           refPlane.GetCenter().X(), refPlane.ID(), refWireMinY, nextPlane.ID(), nextWireMinY, 
           )
         inconsistentPlanes.setdefault('wireBottomYalign', []) \
          .append( ( nextWireMinY - refWireMinY, refPlane, nextPlane, ) )
       # if misaligned on top y
       
       
       refPlane = nextPlane
     # for all following planes on the same x
   # for groups of planes along the same x
   return inconsistentPlanes
 # checkPlaneAlignment()
 
   
# ------------------------------------------------------------------------------

then echo echo For and will not be changed by echo further linking echo echo B echo The symbol is in the uninitialized data multiple common symbols may appear with the echo same name If the symbol is defined the common echo symbols are treated as undefined references For more echo details on common see the discussion of warn common echo in *Note Linker see the discussion of warn common echo in *Note Linker such as a global int variable echo as opposed to a large global array echo echo I echo The symbol is an indirect reference to another symbol This echo is a GNU extension to the a out object file format which is echo rarely used echo echo N echo The symbol is a debugging symbol echo echo R echo The symbol is in a read only data section echo echo S echo The symbol is in an uninitialized data section for small echo objects echo echo T echo The symbol is in the the normal defined echo symbol is used with no error When a weak undefined symbol echo is linked and the symbol is not the value of the echo weak symbol becomes zero with no error echo echo W echo The symbol is a weak symbol that has not been specifically echo tagged as a weak object symbol When a weak defined symbol echo is linked with a normal defined the normal defined echo symbol is used with no error When a weak undefined symbol echo is linked and the symbol is not the value of the echo weak symbol becomes zero with no error echo echo echo The symbol is a stabs symbol in an a out object file In echo this the next values printed are the stabs other echo the stabs desc and the stab type Stabs symbols are echo used to hold debugging information For more echo see *Note or object file format specific echo echo For Mac OS X

Definition: find_global_symbol.sh:107

abs

T abs(T value)

Definition: sparse_vector_test.cc:30

ICARUSgeometryChecker.groupPlanesByX

def groupPlanesByX

Definition: ICARUSgeometryChecker.py:582

ICARUSgeometryChecker.checkPlaneAlignment

def checkPlaneAlignment

Definition: ICARUSgeometryChecker.py:78

def ICARUSgeometryChecker.checkPlaneWireAlignment	(	planeA,
		planeB,
		tolerance = `0.01`
	)

Wires in the plane A are verified to have a continuation in plane B as another
wire. Only wires that reach the side (extreme z coordinate) are tested.

Wires are assumed to have to go top to bottom on y direction.

The list of misaligned wires is returned in the 5-uple form:
    
    ( shift, left wire ID, left wire, right wire ID, right wire )
    
if the wire on the left plane was matched to one on the right plane, and
    
    ( None, left wire ID, left wire, None, None )
    
if the wire on the left plane was not matched to any wire on the right plane.

Definition at line 321 of file ICARUSgeometryChecker.py.

 
 def checkPlaneWireAlignment(planeA, planeB, tolerance = 0.01):
   """
   Wires in the plane A are verified to have a continuation in plane B as another
   wire. Only wires that reach the side (extreme z coordinate) are tested.
   
   Wires are assumed to have to go top to bottom on y direction.
   
   The list of misaligned wires is returned in the 5-uple form:
       
       ( shift, left wire ID, left wire, right wire ID, right wire )
       
   if the wire on the left plane was matched to one on the right plane, and
       
       ( None, left wire ID, left wire, None, None )
       
   if the wire on the left plane was not matched to any wire on the right plane.
   """
   # throughout this code, left refers to lower _z_, right to higher _z_
   
   misalignedWires = []
   
   # define a left and a right plane
   if planeA.GetCenter().Z() < planeB.GetCenter().Z():
     leftPlane, rightPlane = planeA, planeB
   else:
     leftPlane, rightPlane = planeB, planeA
   
    # wire pitch should be the same for the two planes
   rightWirePitch = rightPlane.WirePitch()
   assert abs(rightWirePitch - leftPlane.WirePitch()) < tolerance
   
   #
   # 1. determine the sides
   #
   leftMinY = min(
    min(wire.GetStart().Y(), wire.GetEnd().Y())
    for wire in leftPlane.IterateWires()
    )
   leftMaxY = max(
    max(wire.GetStart().Y(), wire.GetEnd().Y())
    for wire in leftPlane.IterateWires()
    )
   leftMaxZ = max(
    max(wire.GetStart().Z(), wire.GetEnd().Z())
    for wire in leftPlane.IterateWires()
    )
   # RminZ = min( min(wire.GetStart().Z(), wire.GetEnd().Z()) for wire in rightPlane.IterateWires() )
   
   #
   # 2. for each wire in left plane ending close to right side, pick and test
   #    the matching wire of the right plane
   #
   
   leftEndPos = lambda wire: \
    wire.GetStart() if wire.GetStart().Z() > wire.GetEnd().Z() else wire.GetEnd()
   rightStartPos = lambda wire: \
    wire.GetStart() if wire.GetStart().Z() < wire.GetEnd().Z() else wire.GetEnd()
   
   stats = StatCollector()
   wireNoDiff = None # offset in wire number only between matching wires
   for leftWireNo, leftWire in enumerate(leftPlane.IterateWires()):
     
     leftEnd = leftEndPos(leftWire)
     
     # 
     # 2.1. if the wire does not end on the right edge, move on;
     #      if the wire ends on a corner, also move on
     # 
     if abs(leftEnd.Z() - leftMaxZ) > 0.01: continue
     if abs(leftEnd.Y() - leftMaxY) < 0.01 or abs(leftEnd.Y() - leftMinY) < 0.01:
       continue
     
     #
     # 2.2. find the closest wire on the left 
     #
     leftWireID = ROOT.geo.WireID(leftPlane.ID(), leftWireNo)
     try:
       rightWireID = rightPlane.NearestWireID(leftEnd)
     #except ( TypeError, ROOT.geo.InvalidWireError ) as e:
     except TypeError as e:
       rightWireID = None
     except ROOT.geo.InvalidWireError as e:
       # this branch is a placeholder, since Python 3 is not able to catch
       # ROOT.geo.InvalidWireError (and if one is thrown, a TypeError will raise)
       logging.error(
        "No wire on %s is close enough to %s (closest is %s, but would have been %s)", 
        rightPlane.ID(), leftWireID,
        (e.suggestedWireID() if e.hasSuggestedWire() else "unknown"),
        (e.badWireID() if e.hasBadWire() else "unknown"),
        )
       rightWireID = e.badWireID() if e.hasBadWire() else None
       rightWireID.markInvalid()
       misalignedWires.append( ( None, leftWireID, leftWire, None, None, ) )
       continue
     # try ... except no wire matched
     if not rightWireID:
       msg = ""
       if rightWireID is None:
         msg += "No wire on {} is close enough to {}" \
          .format(rightPlane.ID(), leftWireID)
       else: # just invalid
         msg += "No wire on {} is close enough to {} (would have been {})" \
          .format(rightPlane.ID(), leftWireID, rightWireID)
       # if ... else
       
       wireCoord = rightPlane.WireCoordinate(leftEnd)
       msg += "; closest would have been {} W: {}" \
        .format(rightPlane.ID(), wireCoord)
       
       nearestWireID = ROOT.geo.WireID(rightPlane.ID(), int(0.5 + wireCoord)) \
        if 0.5 + wireCoord >= 0.0 else None
       nearestWire = None
       if nearestWireID and rightPlane.HasWire(nearestWireID):
         nearestWire = rightPlane.Wire(nearestWireID) 
       if nearestWire:
         msg += "; actual {} ends at: {}" \
          .format(nearestWireID, rightStartPos(nearestWire))
       
       logging.error(msg)
       misalignedWires.append( ( None, leftWireID, leftWire, None, None, ) )
       continue
     #
     
     rightWire = rightPlane.Wire(rightWireID)
     
     #
     # 2.3. check the projected distance of that wire from this one
     #
     shift = leftWire.DistanceFrom(rightWire)
     stats.add(shift)
     
     #
     # 2.4. compare wire orientation
     #
     leftWire.Direction().Dot(rightWire.Direction())
     if 1.0 - leftWire.Direction().Dot(rightWire.Direction()) > tolerance:
       logging.error(
        "Wire %s has direction %s, the matched %s has %s",
        leftWireID, leftWire.Direction(),
        rightWireID, rightWire.Direction(),
        )
     # if too far
     
     #
     # 2.5. check that wires touch
     #
     d = (leftEndPos(leftWire) - rightStartPos(rightWire)).Mag()
     if d > tolerance:
       logging.debug(
         "Distance of wire %s (%s) from the matched wire %s (%s): %g",
         leftWireID, leftEndPos(leftWire),
         rightWireID, rightStartPos(rightWire),
         d
         )
       # find which is the wire physically closest to leftWire
       closestWireID, d_min = rightWireID, d
       testWireID = rightWireID
       while testWireID.Wire > 0:
         testWireID.Wire -= 1
         testWire = rightPlane.Wire(testWireID)
         test_d = (leftEndPos(leftWire) - rightStartPos(testWire)).Mag()
         logging.debug("Distance from %s (%s): %g", testWireID, rightStartPos(testWire), test_d)
         if test_d >= d_min: break
         closestWireID, d_min = testWireID, test_d
       # while
       testWireID = rightWireID
       LastWireNo = rightPlane.Nwires() - 1
       while testWireID.Wire < LastWireNo:
         testWireID.Wire += 1
         testWire = rightPlane.Wire(testWireID)
         test_d = (leftEndPos(leftWire) - rightStartPos(testWire)).Mag()
         logging.debug("Distance from %s (%s): %g", testWireID, rightStartPos(testWire), test_d)
         if test_d >= d_min: break
         closestWireID, d_min = testWireID, test_d
       # while
       
       logging.error(
        "Wire %s ends at %s, the matched wire %s starts at %s, %g cm away.",
        leftWireID, leftEndPos(leftWire),
        rightWireID, rightStartPos(rightWire),
        d
        )
       if closestWireID != rightWireID:
         logging.error(
          " => the closest wire is actually %s starting at %s, %g cm away",
          closestWireID, rightPlane.Wire(closestWireID), d_min
          )
       # if
       
       misalignedWires.append( ( d_min, leftWireID, leftWire, rightWireID, rightWire ) )
       
     # if too far
     
   # for wires in the left plane
   
   if stats.entries() > 0:
     logging.debug("Shift for %d wires between %s and %s: %g +/- %g cm",
      stats.entries(), leftPlane.ID(), rightPlane.ID(),
      stats.average(), stats.RMS(),
      )
   else:
     logging.debug("No  wire shift statistics collected.")
   return misalignedWires
 # checkPlaneWireAlignment()
 
 
# ------------------------------------------------------------------------------

format

static std::string format(PyObject *obj, unsigned int pos, unsigned int indent, unsigned int maxlen, unsigned int depth)

Definition: fclmodule.cxx:374

util::enumerate

auto enumerate(Iterables &&...iterables)

Range-for loop helper tracking the number of iteration.

Definition: enumerate.h:69

abs

T abs(T value)

Definition: sparse_vector_test.cc:30

ICARUSgeometryChecker.StatCollector

Definition: ICARUSgeometryChecker.py:620

ICARUSgeometryChecker.checkPlaneWireAlignment

def checkPlaneWireAlignment

Definition: ICARUSgeometryChecker.py:321

def ICARUSgeometryChecker.checkWireAlignment	(	planes,
		tolerance = `0.1`
	)

Check alignment in z position of planes on the same x.

Returns triples (distance, first plane, second plane) for each misaligned
pair of planes.

Definition at line 528 of file ICARUSgeometryChecker.py.

 
 def checkWireAlignment(planes, tolerance = 0.1):
   """Check alignment in z position of planes on the same x.
   
   Returns triples (distance, first plane, second plane) for each misaligned
   pair of planes.
   """
   assert tolerance >= 0.0
   PlanesByX = groupPlanesByX(planes, sortBy = 'z')
   misalignedWires = [] # grouped by extended plane
   for planesOnX in PlanesByX:
     if len(planesOnX) < 2: continue
     misalignedWiresOnPlane = []
     planeIter = iter(planesOnX)
     leftPlane = next(planeIter)
     for rightPlane in planeIter:
       misalignedWiresOnPair \
        = checkPlaneWireAlignment(leftPlane, rightPlane, tolerance=tolerance)
       if misalignedWiresOnPair:
         misalignedWiresOnPlane.extend(misalignedWiresOnPair)
       leftPlane = rightPlane
     # for all following planes on the same x
     if misalignedWiresOnPlane: misalignedWires.append(misalignedWiresOnPlane)
   # for groups of planes along the same x
   return misalignedWires
 # checkWireAlignment()
 
   
# ------------------------------------------------------------------------------

ICARUSgeometryChecker.checkPlaneWireAlignment

def checkPlaneWireAlignment

Definition: ICARUSgeometryChecker.py:321

ICARUSgeometryChecker.checkWireAlignment

def checkWireAlignment

Definition: ICARUSgeometryChecker.py:528

ICARUSgeometryChecker.groupPlanesByX

def groupPlanesByX

Definition: ICARUSgeometryChecker.py:582

def ICARUSgeometryChecker.checkWireEndingsInPlane	(	plane,
		tolerance = `0.01`
	)

Wires which do not end on any border of the plane are returned.

The border is determined by the wires themselves rather than the plane box,
which could in principle extend further (but not less).

A dictionary is returned with key the ID of the wire not ending on a border,
and a list of end labels ('start', 'end') listing which end did not.

Definition at line 245 of file ICARUSgeometryChecker.py.

 
 def checkWireEndingsInPlane(plane, tolerance = 0.01):
   """Wires which do not end on any border of the plane are returned.
   
   The border is determined by the wires themselves rather than the plane box,
   which could in principle extend further (but not less).
   
   A dictionary is returned with key the ID of the wire not ending on a border,
   and a list of end labels ('start', 'end') listing which end did not.
   """
   
   assert tolerance >= 0.0
   
   #
   # 1. determine the boundaries (brute force, brute programming)
   #
   borderCoords = {
     'bottom': min(
       min(wire.GetStart().Y(), wire.GetEnd().Y())
       for wire in plane.IterateWires()
       ),
     'top': max(
       max(wire.GetStart().Y(), wire.GetEnd().Y())
       for wire in plane.IterateWires()
       ),
     'upstream': min(
       min(wire.GetStart().Z(), wire.GetEnd().Z())
       for wire in plane.IterateWires()
       ),
     'downstream': max(
       max(wire.GetStart().Z(), wire.GetEnd().Z())
       for wire in plane.IterateWires()
       ),
   } # borderCoords
   
   shorterWires = dict()
   for iWire, wire in enumerate(plane.IterateWires()):
     
     wireID = ROOT.geo.WireID(plane.ID(), iWire)
     
     #
     # 1. check the start
     #
     start = wire.GetStart()
     borders = wireEndBorders(start, borderCoords, tolerance)
 
     # there should be at least one border touched by each wire end
     if len(borders) == 0:
       logging.error(
        "Wire %s \"start\" at %s cm does not touch any plane border (%s)",
        wireID, start, ", ".join("%s: %g" % item for item in borderCoords.items()),
        )
       shorterWires.setdefault(wireID, []).append('start')
     # if error
     
     #
     # 2. check the end
     #
     end = wire.GetEnd()
     borders = wireEndBorders(end, borderCoords, tolerance)
 
     # there should be at least one border touched by each wire end
     if len(borders) == 0:
       logging.error(
        "Wire %s \"end\" at %s cm does not touch any plane border (%s)",
        wireID, end, ", ".join("%s: %g" % item for item in borderCoords.items()),
        )
       shorterWires.setdefault(wireID, []).append('end')
     # if error
     
   # for
   
   return shorterWires
 # checkWireEndingsInPlane()
 
 
# ------------------------------------------------------------------------------

ICARUSgeometryChecker.checkWireEndingsInPlane

def checkWireEndingsInPlane

Definition: ICARUSgeometryChecker.py:245

ICARUSgeometryChecker.wireEndBorders

def wireEndBorders

Definition: ICARUSgeometryChecker.py:225

util::enumerate

auto enumerate(Iterables &&...iterables)

Range-for loop helper tracking the number of iteration.

Definition: enumerate.h:69

opdet::factory::join

S join(S const &sep, Coll const &s)

Returns a concatenation of strings in s separated by sep.

Definition: OpRecoFactoryStuff.h:573

def ICARUSgeometryChecker.GeoPairToString ( pair )

Definition at line 45 of file ICARUSgeometryChecker.py.

 
 def GeoPairToString(pair):
   return " - ".join(map(lambda obj: str(obj.ID()), pair))

opdet::factory::join

S join(S const &sep, Coll const &s)

Returns a concatenation of strings in s separated by sep.

Definition: OpRecoFactoryStuff.h:573

ICARUSgeometryChecker.GeoPairToString

def GeoPairToString

Definition: ICARUSgeometryChecker.py:45

def ICARUSgeometryChecker.groupPlanesByX	(	planes,
		tolerance = `0.1`,
		sortBy = `None`
	)

Definition at line 582 of file ICARUSgeometryChecker.py.

 
 def groupPlanesByX(planes, tolerance = 0.1, sortBy = None):
   xPos = lambda plane: plane.GetCenter().X()
   cluster = SimpleProximityClusterer(xPos, tolerance) # 1 mm
   groupedByX = cluster(sorted(planes, key=xPos))
   if sortBy:
     if   sortBy.lower() == 'x':
       sortKey = xPos
     elif sortBy.lower() == 'y':
       sortKey = lambda plane: plane.GetCenter().Y()
     elif sortBy.lower() == 'z':
       sortKey = lambda plane: plane.GetCenter().Z()
     else:
       raise RuntimeError("Unsupported sorting requested: '%s'" % sortBy)
     for planes in groupedByX: planes.sort(key=sortKey)
   # if sorting
   return groupedByX
 # groupPlanesByX()
 
 
# ------------------------------------------------------------------------------

cluster

Cluster finding and building.

Definition: SmallClusterFilter_module.cc:34

Definition: find_global_symbol.sh:107

ICARUSgeometryChecker.SimpleProximityClusterer

Definition: ICARUSgeometryChecker.py:556

ICARUSgeometryChecker.groupPlanesByX

def groupPlanesByX

Definition: ICARUSgeometryChecker.py:582

def ICARUSgeometryChecker.performGeometryChecks ( argv )

Definition at line 647 of file ICARUSgeometryChecker.py.

 
 def performGeometryChecks(argv):
   
   import argparse
   
   Parser = argparse.ArgumentParser(description=__doc__)
   
   Parser.set_defaults()
   
   Parser.add_argument("config", help="configuration file [FHiCL]")
   
   Parser.add_argument("--servicetable", "-T", default='services',
    help="name of the FHiCL table where all services are configured ['%(default)s']"
    )
   
   Parser.add_argument("--debug", "-d", action="count", default=0,
    help="be more verbose")
   
   Parser.add_argument("--version", "-V", action="version", version=__version__)
   
   #argGroup = Parser.add_argument_group(title="Numerical output format")
   #argGroup.add_argument("--integer", "-d", "-i", action="store_false",
     #dest="bFloat", help="sets the sum of integral numbers")
   
   args = Parser.parse_args(args=argv[1:])
   
   # `logging.DEBUG` is the standard debugging level; 
   # `logging.DEBUG + 1` (args.debug = 0) is a bit less verbose, but still well
   #    within `logging.INFO` level
   logging.basicConfig(level=logging.DEBUG - (args.debug - 1))
   
   from ICARUSservices import ServiceManager
   import cppUtils
   import ROOT
   import ROOTutils
   
   # this is for a bug present in LArSoft v08_52_00 (and many other versions);
   # the header where exception geo::InvalidWireError is defined is not included.
   cppUtils.SourceCode.loadHeaderFromUPS("larcorealg/Geometry/Exceptions.h")
   
   global ROOT
 
   ServiceManager.setConfiguration(args.config, args.servicetable)
   
   geom = ServiceManager('Geometry')
   
   FailureSummary = []
   
   Cryostats = list(geom.IterateCryostats())
   TPCs = list(geom.IterateTPCs())
   Planes = list(geom.IteratePlanes())
   
   #
   # cryostat overlap
   #
   overlappingCryostats = CheckGeoObjOverlaps(Cryostats, "cryostat")
   if overlappingCryostats:
     msg = "%s cryostat overlaps detected: %s." % (
      len(overlappingCryostats),
      ", ".join(map(GeoPairToString, overlappingCryostats)),
      )
     logging.error(msg)
     FailureSummary.append(msg)
   else: logging.info("No cryostat overlap detected.")
   
   #
   # TPC overlaps
   #
   overlappingTPCs = CheckGeoObjOverlaps(TPCs, "TPC")
   if overlappingTPCs:
     msg = "%s TPC overlaps detected: %s." % (
      len(overlappingTPCs), ", ".join(map(GeoPairToString, overlappingTPCs)),
      )
     logging.error(msg)
     FailureSummary.append(msg)
   else: logging.info("No TPC overlap detected.")
   
   #
   # TPC active volume overlaps
   #
   overlappingActiveVolTPCs = CheckGeoObjOverlaps \
     (TPCs, "active TPC volume", extractBox=ROOT.geo.TPCGeo.ActiveBoundingBox)
   if overlappingActiveVolTPCs:
     msg = "%s TPC active volume overlaps detected: %s." % (
      len(overlappingActiveVolTPCs),
      ", ".join(map(GeoPairToString, overlappingActiveVolTPCs)),
      )
     logging.error(msg)
     FailureSummary.append(msg)
   else: logging.info("No TPC active volume overlap detected.")
   
   #
   # plane box overlaps
   #
   overlappingPlanes = CheckGeoObjOverlaps \
    (Planes, "wire planes", extractBox=ROOT.geo.PlaneGeo.BoundingBox)
   if overlappingPlanes:
     logging.error("%s wire plane overlaps detected: %s.",
      len(overlappingPlanes),
      ", ".join(map(GeoPairToString, overlappingPlanes))
      )
     FailureSummary.append \
       ("%s wire plane overlaps detected." % len(overlappingPlanes))
   else: logging.info("No wire plane overlap detected.")
   
   #
   # check plane alignment
   #
   inconsistentPlanes = checkPlaneAlignment(Planes, tolerance=0.0001) # 1 um (!!)
   
   try: planesWithIssues = inconsistentPlanes['zalign']
   except KeyError:
     logging.info("All %d planes are correctly aligned along z.", len(Planes))
   else:
     logging.error("%s wire planes present misalignment on z: %s",
       len(planesWithIssues), ", ".join(
         "%s vs. %s (%g mm)" % (planeA.ID(), planeB.ID(), distance)
         for distance, planeA, planeB in planesWithIssues
       ),
       )
     FailureSummary.append \
       ("%s wire planes present misalignment: " % len(misalignedPlanes))
   # if error
   
   try: planesWithIssues = inconsistentPlanes['topYalign']
   except KeyError:
     logging.info("Top of all %d planes is correctly aligned.", len(Planes))
   else:
     logging.error("%s wire planes present misalignment of top side: %s",
       len(planesWithIssues), ", ".join(
         "%s vs. %s (%g mm)" % (planeA.ID(), planeB.ID(), distance)
         for distance, planeA, planeB in planesWithIssues
       ),
       )
     FailureSummary.append \
       ("%s wire planes present misalignment on top side" % len(planesWithIssues))
   # if error
   
   try: planesWithIssues = inconsistentPlanes['bottomYalign']
   except KeyError:
     logging.info("Bottom of all %d planes is correctly aligned.", len(Planes))
   else:
     logging.error("%s wire planes present misalignment of bottom side: %s",
       len(planesWithIssues), ", ".join(
         "%s vs. %s (%g mm)" % (planeA.ID(), planeB.ID(), distance)
         for distance, planeA, planeB in planesWithIssues
       ),
       )
     FailureSummary.append \
       ("%s wire planes present misalignment on bottom side" % len(planesWithIssues))
   # if error
   
   try: planesWithIssues = inconsistentPlanes['wireZalign']
   except KeyError:
     logging.info(
      "Inter-plane areas covered by wires on all %d planes are correctly aligned.",
      len(Planes)
      )
   else:
     logging.error("%s planes have wires inconsistently covering the touching side: %s",
       len(planesWithIssues), ", ".join(
         "%s vs. %s (%g mm)" % (planeA.ID(), planeB.ID(), distance)
         for distance, planeA, planeB in planesWithIssues
       ),
       )
     FailureSummary.append(
      "%s planes present inconsistent wire coverage on touching side"
      % len(planesWithIssues)
      )
   # if error
   
   try: planesWithIssues = inconsistentPlanes['wireBottomYalign']
   except KeyError:
     logging.info(
      "Bottom of areas covered by wires on all %d planes is correctly aligned.",
      len(Planes)
      )
   else:
     logging.error("%s planes have wires inconsistently covering bottom side: %s",
       len(planesWithIssues), ", ".join(
         "%s vs. %s (%g mm)" % (planeA.ID(), planeB.ID(), distance)
         for distance, planeA, planeB in planesWithIssues
       ),
       )
     FailureSummary.append(
      "%s planes present inconsistent wire coverage on bottom side: "
      % len(misalignedPlanes)
      )
   # if error
   
   try: planesWithIssues = inconsistentPlanes['wireTopYalign']
   except KeyError:
     logging.info(
      "Top of areas covered by wires on all %d planes is correctly aligned.",
      len(Planes)
      )
   else:
     logging.error("%s planes have wires inconsistently covering top side: %s",
       len(planesWithIssues), ", ".join(
         "%s vs. %s (%g mm)" % (planeA.ID(), planeB.ID(), distance)
         for distance, planeA, planeB in planesWithIssues
       ),
       )
     FailureSummary.append(
      "%s planes present inconsistent wire coverage on top side: "
      % len(misalignedPlanes)
      )
   # if error
   
 
   
   try: planesWithIssues = inconsistentPlanes['view']
   except KeyError:
     logging.info("All %d planes have matching views.", len(Planes))
   else:
     logging.error("%s wire planes present direction inconsistencies:",
       len(planesWithIssues), ", ".join(
         "%s vs. %s" % (planeA.ID(), planeB.ID())
         for planeA, planeB in planesWithIssues
       ),
       )
     FailureSummary.append(
      "%s wire planes present direction inconsistencies." % len(planesWithIssues)
      )
   # if error
   
   try: planesWithIssues = inconsistentPlanes['direction']
   except KeyError:
     logging.info("All %d planes have consistent directions.", len(Planes))
   else:
     logging.error("%s wire planes present view inconsistencies:",
       len(planesWithIssues), ", ".join(
         "%s vs. %s" % (planeA.ID(), planeB.ID())
         for planeA, planeB in planesWithIssues
       ),
       )
     FailureSummary.append(
      "%s wire planes present view inconsistencies." % len(planesWithIssues)
      )
   # if error
   
   #
   # check wire alignment
   #
   shorterWires = {}
   for plane in Planes:
     shorterWires.update(checkWireEndingsInPlane(plane, tolerance=0.01))
   if shorterWires:
     logging.error("Wires not ending on plane frame found (%d):",
       len(shorterWires),
       )
     for wireID, ends in shorterWires.items():
       logging.error("  %s: %s", wireID, ", ".join(ends))
     FailureSummary.append \
       ("%d wires do not end on plane frame" % len(shorterWires))
   # if error
   
   
   misalignedWires = checkWireAlignment(Planes, tolerance=0.0001) # 1 um required
   if misalignedWires:
     logging.error("Misaligned wires found on %d extended planes:",
       len(misalignedWires),
       )
     for misalignedWiresOnPlane in misalignedWires:
       logging.error("  %d on wires on plane around x=%g cm:",
        len(misalignedWiresOnPlane),
        misalignedWiresOnPlane[0][2].GetCenter().X()
        )
       for shift, wireLid, wireL, wireRid, wireR in misalignedWiresOnPlane:
         if shift is None:
           logging.error("    %s did not match any wire", wireLid)
         else:
           logging.error("    %s and %s are misaligned by %g um",
            wireLid, wireRid, shift * 1.0e4,
            )
       # for all misaligned wire pairs
     # for
     FailureSummary.append \
       ("misaligned wires found on %d extended planes" % len(misalignedWires))
   else:
     logging.info("No misaligned wires detected.")
   
   if FailureSummary:
     logging.info("%d failure categories detected:\n - %s",
      len(FailureSummary), "\n - ".join(FailureSummary),
      )
   # if failures
   return 1 if FailureSummary else 0
 # performGeometryChecks()
 
 
# ##############################################################################

ICARUSgeometryChecker.CheckGeoObjOverlaps

def CheckGeoObjOverlaps

Definition: ICARUSgeometryChecker.py:59

ICARUSgeometryChecker.performGeometryChecks

def performGeometryChecks

Definition: ICARUSgeometryChecker.py:647

ICARUSgeometryChecker.checkWireEndingsInPlane

def checkWireEndingsInPlane

Definition: ICARUSgeometryChecker.py:245

Definition: find_global_symbol.sh:107

opdet::factory::join

S join(S const &sep, Coll const &s)

Returns a concatenation of strings in s separated by sep.

Definition: OpRecoFactoryStuff.h:573

ICARUSservices.ServiceManager

tuple ServiceManager

Definition: ICARUSservices.py:101

ICARUSgeometryChecker.checkWireAlignment

def checkWireAlignment

Definition: ICARUSgeometryChecker.py:528

list

Definition: file_to_url.sh:28

ICARUSgeometryChecker.checkPlaneAlignment

def checkPlaneAlignment

Definition: ICARUSgeometryChecker.py:78

Classes
class	NestedIteration

class	SimpleProximityClusterer

class	AccumulateExtrema

class	StatCollector

def ICARUSgeometryChecker.CheckGeoObjOverlaps	(	objs,
		objName = `None`,
		extractBox = `None`
	)

def ICARUSgeometryChecker.wireEndBorders	(	end,
		borderCoords,
		tolerance
	)

Classes

Functions

Variables

Function Documentation

Variable Documentation

Functions
def	GeoPairToString

def	BoxToString

def	boxID

def	CheckGeoObjOverlaps

def	checkPlaneAlignment

def	wireEndBorders

def	checkWireEndingsInPlane

def	checkPlaneWireAlignment

def	checkWireAlignment

def	groupPlanesByX

def	performGeometryChecks

Variables
string	__doc__

string	__version__ = "%(prog)s 2.1"

def ICARUSgeometryChecker.boxID	(	box,
		default
	)