X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=org.simantics.plant3d%2Fsrc%2Forg%2Fsimantics%2Fplant3d%2Fscenegraph%2Fcontrolpoint%2FPipingRules.java;h=3d38107990b4c25e53a4389fb42803ba529039bd;hb=refs%2Fchanges%2F88%2F4288%2F1;hp=e930b8d6d07094035a188933141c4519085c5382;hpb=47edf45b081e0b06aa8839a39098edba737b162f;p=simantics%2F3d.git diff --git a/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/PipingRules.java b/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/PipingRules.java index e930b8d6..3d381079 100644 --- a/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/PipingRules.java +++ b/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/PipingRules.java @@ -18,9 +18,12 @@ import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.Direction; import org.simantics.plant3d.utils.ComponentUtils; import org.simantics.utils.datastructures.Pair; import org.simantics.utils.ui.ErrorLogger; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; public class PipingRules { - private static final boolean DEBUG = false; + private static final Logger LOGGER = LoggerFactory.getLogger(PipingRules.class); + private static final boolean DUMMY = false; private static double MIN_TURN_ANGLE = 0.001; // Threshold for removing turn components. @@ -57,7 +60,7 @@ public class PipingRules { public static void requestUpdate(PipeControlPoint pcp) { if (!PipingRules.enabled) return; - if (DEBUG) System.out.println("PipingRules request " + pcp); + if (LOGGER.isTraceEnabled()) LOGGER.trace("PipingRules request " + pcp); synchronized (updateMutex) { if (!requestUpdates.contains(pcp)) requestUpdates.add(pcp); @@ -113,7 +116,7 @@ public class PipingRules { if (pcp.getPipeRun() == null) return false; try { - if (DEBUG) System.out.println("PipingRules " + pcp); + if (LOGGER.isTraceEnabled()) LOGGER.trace("PipingRules " + pcp); updating = true; allowInsertRemove = allowIR; triedIR = false; @@ -133,7 +136,7 @@ public class PipingRules { return true; } finally { updating = false; -// System.out.println("PipingRules done " + pcp); +// LOGGER.trace("PipingRules done " + pcp); } } @@ -201,8 +204,8 @@ public class PipingRules { } private static void updatePathLegEndControlPoint(PipeControlPoint pcp) throws Exception { - if (DEBUG) - System.out.println("PipingRules.updatePathLegEndControlPoint() " + pcp); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.updatePathLegEndControlPoint() " + pcp); if (pcp.getNext() != null) { updatePathLegNext(pcp, pcp, PathLegUpdateType.NEXT_S); } @@ -213,8 +216,8 @@ public class PipingRules { } private static void updateInlineControlPoint(PipeControlPoint pcp) throws Exception { - if (DEBUG) - System.out.println("PipingRules.updateInlineControlPoint() " + pcp); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.updateInlineControlPoint() " + pcp); PipeControlPoint start = pcp.findPreviousEnd(); updatePathLegNext(start, pcp, PathLegUpdateType.NONE); @@ -231,8 +234,8 @@ public class PipingRules { } private static PipeControlPoint insertElbow(PipeControlPoint pcp1, PipeControlPoint pcp2, Vector3d pos) throws Exception{ - if (DEBUG) - System.out.println("PipingRules.insertElbow() " + pcp1 + " " + pcp2 + " " + pos); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.insertElbow() " + pcp1 + " " + pcp2 + " " + pos); if (pcp1.getNext() == pcp2 && pcp2.getPrevious() == pcp1) { } else if (pcp1.getNext() == pcp2 && pcp1.isDualInline() && pcp2.getPrevious() == pcp1.getDualSub()) { @@ -264,8 +267,8 @@ public class PipingRules { } private static PipeControlPoint insertStraight(PipeControlPoint pcp1, PipeControlPoint pcp2, Vector3d pos, double length) throws Exception { - if (DEBUG) - System.out.println("PipingRules.insertStraight() " + pcp1 + " " + pcp2 + " " + pos); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.insertStraight() " + pcp1 + " " + pcp2 + " " + pos); if (pcp1.getNext() == pcp2 && pcp2.getPrevious() == pcp1) { } else if (pcp1.getNext() == pcp2 && pcp1.isDualInline() && pcp2.getPrevious() == pcp1.getDualSub()) { @@ -301,8 +304,8 @@ public class PipingRules { } private static PipeControlPoint insertStraight(PipeControlPoint pcp, Direction direction , Vector3d pos, double length) throws Exception { - if (DEBUG) - System.out.println("PipingRules.insertStraight() " + pcp + " " + direction + " " + pos); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.insertStraight() " + pcp + " " + direction + " " + pos); InlineComponent component = ComponentUtils.createStraight((P3DRootNode)pcp.getRootNode()); PipeControlPoint scp = component.getControlPoint(); @@ -323,7 +326,7 @@ public class PipingRules { private static void updatePathLegNext(PipeControlPoint start, PipeControlPoint updated, PathLegUpdateType lengthChange) throws Exception { UpdateStruct2 us = createUS(start, Direction.NEXT, 0, new ArrayList(), updated); if (us == null) { - System.out.println("Null update struct " + start); + LOGGER.trace("Null update struct " + start); return; } updatePathLeg(us, lengthChange); @@ -332,7 +335,7 @@ public class PipingRules { private static void updatePathLegPrev(PipeControlPoint start, PipeControlPoint updated, PathLegUpdateType lengthChange) throws Exception { UpdateStruct2 us = createUS(start, Direction.PREVIOUS, 0, new ArrayList(), updated); if (us == null) { - System.out.println("Null update struct " + start); + LOGGER.trace("Null update struct " + start); return; } updatePathLeg(us, lengthChange); @@ -466,8 +469,8 @@ public class PipingRules { dir.scale(1.0/Math.sqrt(l)); } - if (DEBUG) - System.out.println("calcOffset s:"+ startPoint + " e:" + endPoint + " d:" + dir + " o:"+offset) ; + if (LOGGER.isTraceEnabled()) + LOGGER.trace("calcOffset s:"+ startPoint + " e:" + endPoint + " d:" + dir + " o:"+offset) ; return true; } @@ -593,16 +596,16 @@ public class PipingRules { } private static void updateFreePathLeg(UpdateStruct2 u, PathLegUpdateType lengthChange) throws Exception { - if (DEBUG) - System.out.println("PipingRules.updateFreePipeRun " + u + " " + lengthChange); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.updateFreePipeRun " + u + " " + lengthChange); checkExpandPathLeg(u, lengthChange); if (u.start.isInline() || u.end.isInline() || u.start.asFixedAngle()|| u.end.asFixedAngle()) processPathLeg(u, true, false); } private static void updateInlineControlPoints(UpdateStruct2 u, boolean checkSizes) throws Exception{ - if (DEBUG) - System.out.println("PipingRules.updateInlineControlPoints() " + u); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.updateInlineControlPoints() " + u); Vector3d start = new Vector3d(u.startPoint); Vector3d end = new Vector3d(u.endPoint); @@ -727,7 +730,7 @@ public class PipingRules { for (PipeControlPoint pcp : u.list) setError(pcp, "Not enough available space"); } -// System.out.println(u.start.getPipelineComponent().toString() + " " + pathLegLength + " " + availableLength + " " + u.end.getPipelineComponent().toString() + " " + u.start.getInlineLength() + " " + u.end.getInlineLength()); +// LOGGER.trace(u.start.getPipelineComponent().toString() + " " + pathLegLength + " " + availableLength + " " + u.end.getPipelineComponent().toString() + " " + u.start.getInlineLength() + " " + u.end.getInlineLength()); } } @@ -935,8 +938,8 @@ public class PipingRules { triedIR = true; return false; } - if (DEBUG) - System.out.println("PipingRules.updateVariableLength removing " + icp); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.updateVariableLength removing " + icp); icp._remove(); return true; } else { @@ -1010,13 +1013,13 @@ public class PipingRules { double l = beginPos.distance(endPos); if (Double.isNaN(l)) - System.out.println("Length for " + icp + " is NaN"); + LOGGER.debug("Length for " + icp + " is NaN"); dir.scale(l * 0.5); beginPos.add(dir); // center position - if (DEBUG) - System.out.println("PipingRules.updateInlineControlPoints() setting variable length to " + l); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.updateInlineControlPoints() setting variable length to " + l); icp.setLength(l); icp.setWorldPosition(new Vector3d(beginPos)); @@ -1030,8 +1033,8 @@ public class PipingRules { * @throws Exception */ private static void ppNoOffset(UpdateStruct2 u, boolean updateEnds) throws Exception { - if (DEBUG) - System.out.println("PipingRules.ppNoOffset() " + u); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.ppNoOffset() " + u); Vector3d offset = new Vector3d(); if (u.hasOffsets) { for (PipeControlPoint icp : u.list) { @@ -1046,8 +1049,8 @@ public class PipingRules { } private static void ppNoDir(PipeControlPoint start, Vector3d startPoint, ArrayList list, PipeControlPoint end, Vector3d endPoint, boolean hasOffsets, int iter, boolean reversed, ArrayList toRemove, PipeControlPoint updated) throws Exception { - if (DEBUG) - System.out.println("PipingRules.ppNoDir() " + start + " " + end + " " + iter + " " + toRemove.size()); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.ppNoDir() " + start + " " + end + " " + iter + " " + toRemove.size()); // FIXME : extra loop (dir should be calculated here) Vector3d dir = new Vector3d(); Vector3d offset = new Vector3d(); @@ -1060,8 +1063,8 @@ public class PipingRules { } private static void checkExpandPathLeg(UpdateStruct2 u, PathLegUpdateType lengthChange, boolean updateEnds) throws Exception { - if (DEBUG) - System.out.println("PipingRules.checkExpandPathLeg() " + u + " " + lengthChange); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.checkExpandPathLeg() " + u + " " + lengthChange); if (lengthChange != PathLegUpdateType.NONE) { // FIXME : turns cannot be checked before inline cps are updated, // since their position affects calculation of turns @@ -1078,8 +1081,8 @@ public class PipingRules { } private static void updateDirectedPathLeg(UpdateStruct2 u, PathLegUpdateType lengthChange) throws Exception { - if (DEBUG) - System.out.println("PipingRules.updateDirectedPipeRun() " + u + " " + lengthChange); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.updateDirectedPipeRun() " + u + " " + lengthChange); PipeControlPoint dcp; PipeControlPoint other; boolean canMoveOther = false; @@ -1185,8 +1188,8 @@ public class PipingRules { } if (canMoveOther) { - if (DEBUG) - System.out.println("PipingRules.updateDirectedPipeRun() moved end " + other + " to " + closest); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.updateDirectedPipeRun() moved end " + other + " to " + closest); // Not aligned - we need to recalculate the offset to reflect new end points. Vector3d offset; @@ -1238,8 +1241,8 @@ public class PipingRules { throw new UnsupportedOperationException("not implemented"); } if (canMoveOther) { - if (DEBUG) - System.out.println("PipingRules.updateDirectedPipeRun() moved end " + other + " to " + bintersect); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.updateDirectedPipeRun() moved end " + other + " to " + bintersect); // is required branch position is in possible range bcp.setWorldPosition(bintersect); if (dcpStart) { @@ -1268,8 +1271,8 @@ public class PipingRules { } private static void updateDualDirectedPathLeg(UpdateStruct2 u, PathLegUpdateType lengthChange) throws Exception { - if (DEBUG) - System.out.println("PipingRules.updateDualDirectedPipeRun() " + u + " " + lengthChange); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.updateDualDirectedPipeRun() " + u + " " + lengthChange); PipeControlPoint dcp1 = u.start; PipeControlPoint dcp2 = u.end; @@ -1340,8 +1343,8 @@ public class PipingRules { PipeControlPoint tcp1 = insertElbow(dcp, next, p1); PipeControlPoint tcp2 = insertElbow(tcp1, next, p2); - if (DEBUG) - System.out.println("PipingRules.updateDualDirectedPipeRun() created two turns " + tcp1 + " " + tcp2); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.updateDualDirectedPipeRun() created two turns " + tcp1 + " " + tcp2); if (!u.reversed) { Vector3d dd = new Vector3d(p2); @@ -1459,8 +1462,8 @@ public class PipingRules { tcp.setPosition(p); closest = p; - if (DEBUG) - System.out.println("PipingRules.updateDirectedPipeRun() inserted " + tcp); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.updateDirectedPipeRun() inserted " + tcp); if (dcpStart) { // update pipe run from new turn to other end @@ -1479,8 +1482,8 @@ public class PipingRules { * Checks if turns can be removed (turn angle near zero) */ private static int checkTurns(UpdateStruct2 u, PathLegUpdateType lengthChange) throws Exception { - if (DEBUG) - System.out.println("PipingRules.checkTurns() " + u.start + " " + u.end); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.checkTurns() " + u.start + " " + u.end); boolean startRemoved = false; boolean endRemoved = false; if (u.start.isVariableAngle()) { @@ -1518,8 +1521,8 @@ public class PipingRules { } } } - if (DEBUG) - System.out.println("PipingRules.checkTurns() res " + startRemoved + " " + endRemoved); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.checkTurns() res " + startRemoved + " " + endRemoved); if (!startRemoved && !endRemoved) return REMOVE_NONE; if (startRemoved && endRemoved) @@ -1534,8 +1537,8 @@ public class PipingRules { * */ private static void expandPathLeg(UpdateStruct2 u, int type) throws Exception { - if (DEBUG) - System.out.println("PipingRules.expandPipeline " + u.start + " " + u.end); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.expandPipeline " + u.start + " " + u.end); ArrayList newList = new ArrayList(); switch (type) { case REMOVE_NONE: @@ -1580,8 +1583,8 @@ public class PipingRules { ErrorLogger.defaultLogError("Updating pipe run, found offset controlpoint " + icp, new Exception("ASSERT!")); } } - if (DEBUG) - System.out.println("PipingRules.expandPipeline expanded " + u.start + " " + u.end); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.expandPipeline expanded " + u.start + " " + u.end); u.iter++; updatePathLeg(u, PathLegUpdateType.NONE); } @@ -1591,8 +1594,8 @@ public class PipingRules { */ private static void backIter(UpdateStruct2 u) throws Exception { - if (DEBUG) - System.out.println("PipingRules.backIter" + u.start + " " + u.end); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.backIter" + u.start + " " + u.end); if (u.iter == 0) throw new RuntimeException("Error in piping rules"); ExpandIterInfo info = u.toRemove.get(u.toRemove.size() - 1); @@ -1639,25 +1642,25 @@ public class PipingRules { // toRemove) throws TransactionException { private static void processPathLeg(UpdateStruct2 u) throws Exception { - if (DEBUG) - System.out.println("PipingRules.processPathLeg " + u.start + " " + u.end); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.processPathLeg " + u.start + " " + u.end); processPathLeg(u, true, true); } private static void processPathLeg(UpdateStruct2 u, boolean updateEnds, boolean updateInline) throws Exception { - if (DEBUG) - System.out.println("PipingRules.processPathLeg " + (updateEnds ? "ends " : "") + (updateInline ? "inline " : "") + u.start + " " + u.end); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.processPathLeg " + (updateEnds ? "ends " : "") + (updateInline ? "inline " : "") + u.start + " " + u.end); if (u.toRemove.size() > 0) { for (ExpandIterInfo info : u.toRemove) { if (info.getStart() != null) { - if (DEBUG) - System.out.println("PipingRules.processPathLeg removing start " + info.getStart()); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.processPathLeg removing start " + info.getStart()); info.getStart()._remove(); } if (info.getEnd() != null) { - if (DEBUG) - System.out.println("PipingRules.processPathLeg removing end " + info.getEnd()); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.processPathLeg removing end " + info.getEnd()); info.getEnd()._remove(); } } @@ -1713,8 +1716,8 @@ public class PipingRules { // { @SuppressWarnings("unused") private static void processPathLegNoOffset(UpdateStruct2 u) throws Exception { - if (DEBUG) - System.out.println("PipingRules.processPathLeg " + u.start + " " + u.end); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.processPathLeg " + u.start + " " + u.end); Vector3d offset = new Vector3d(); if (u.hasOffsets) { u.dir.normalize(); @@ -1746,8 +1749,8 @@ public class PipingRules { * @param prevPoint */ private static void updateInlineControlPoint(PipeControlPoint icp, Vector3d prev, Vector3d next, Vector3d dir) { - if (DEBUG) - System.out.println("PipingRules.updateInlineControlPoint() " + icp); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.updateInlineControlPoint() " + icp); Vector3d inlinePoint = icp.getWorldPosition(); Vector3d prevPoint = new Vector3d(prev); @@ -1762,7 +1765,7 @@ public class PipingRules { } } boolean canCalc = MathTools.distance(prevPoint, nextPoint) > ALLOWED_OFFSET; - if (DEBUG) + if (LOGGER.isTraceEnabled()) System.out.print("InlineControlPoint update " + icp + " " + inlinePoint + " " + prevPoint + " " + nextPoint); Vector3d newInlinePoint = null; if (canCalc) { @@ -1798,8 +1801,8 @@ public class PipingRules { newInlinePoint = new Vector3d(); double mu[] = new double[2]; MathTools.intersectStraightStraight(new Vector3d(prevPoint), dir1, new Vector3d(branchLegEnd), dir2, newInlinePoint, new Vector3d(), mu); - if (DEBUG) - System.out.println(mu[0]); + if (LOGGER.isTraceEnabled()) + LOGGER.trace(Double.toString(mu[0])); // FIXME : reserve space if (mu[0] < 0.0) { newInlinePoint = new Vector3d(prevPoint); @@ -1812,8 +1815,8 @@ public class PipingRules { // prevPoint == nextPoint newInlinePoint = new Vector3d(prevPoint); } - if (DEBUG) - System.out.println(" " + newInlinePoint); + if (LOGGER.isTraceEnabled()) + LOGGER.trace(" " + newInlinePoint); icp.setWorldPosition(newInlinePoint); icp.orientToDirection(dir); @@ -1829,8 +1832,8 @@ public class PipingRules { * @param prevPoint */ private static void updateEndComponentControlPoint(PipeControlPoint ecp, Vector3d dir) throws Exception { - if (DEBUG) - System.out.println("PipingRules.updateEndComponentControlPoint() " + ecp); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.updateEndComponentControlPoint() " + ecp); if (!ecp.isFixed()) // prevent overriding nozzle orientations.. ecp.orientToDirection(dir); @@ -1847,14 +1850,14 @@ public class PipingRules { * @param bcp */ private static void updateBranchControlPointBranches(PipeControlPoint bcp) throws Exception { - if (DEBUG) - System.out.println("PipingRules.updateBranchControlPointBranches() " + bcp); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingRules.updateBranchControlPointBranches() " + bcp); if (bcp.isDualInline()) return; Collection branches = bcp.getChildPoints(); if (branches.size() == 0) { - if (DEBUG) - System.out.println("No Branches found"); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("No Branches found"); return; } @@ -1908,8 +1911,8 @@ public class PipingRules { tcp.orientToDirection(prev); - if (DEBUG) - System.out.println("PipingTools.updateTurnControlPointTurn " + prev + " " + next + " " + turnAngle + " " + turnAxis); + if (LOGGER.isTraceEnabled()) + LOGGER.trace("PipingTools.updateTurnControlPointTurn " + prev + " " + next + " " + turnAngle + " " + turnAxis); return turnAngle; } else { @@ -2104,26 +2107,26 @@ public class PipingRules { synchronized (ruleMutex) { Collection pcps = pipeRun.getControlPoints(); int count = 0; - //System.out.println("Validate " + pipeRun.getName()); + //LOGGER.trace("Validate " + pipeRun.getName()); for (PipeControlPoint pcp : pcps) { if (pcp.getParentPoint() == null || pcp.getParentPoint().getPipeRun() != pipeRun) count++; } List runPcps = getControlPoints(pipeRun); if (runPcps.size() != count) { - System.out.println("Run " + pipeRun.getName() + " contains unconnected control points, found " + runPcps.size() + " connected, " + pcps.size() + " total."); + LOGGER.debug("Run " + pipeRun.getName() + " contains unconnected control points, found " + runPcps.size() + " connected, " + pcps.size() + " total."); for (PipeControlPoint pcp : pcps) { if (!runPcps.contains(pcp)) { - System.out.println("Unconnected " + pcp + " " + pcp.getPipelineComponent()); + LOGGER.debug("Unconnected " + pcp + " " + pcp.getPipelineComponent()); } } } for (PipeControlPoint pcp : pcps) { if (pcp.getPipeRun() == null) { - System.out.println("PipeRun ref missing " + pcp + " " + pcp.getPipelineComponent()); + LOGGER.debug("PipeRun ref missing " + pcp + " " + pcp.getPipelineComponent()); } if (!pcp.isDirected() && pcp.getNext() == null && pcp.getPrevious() == null) - System.out.println("Orphan undirected " + pcp + " " + pcp.getPipelineComponent()); + LOGGER.debug("Orphan undirected " + pcp + " " + pcp.getPipelineComponent()); } for (PipeControlPoint pcp : pcps) { if (pcp.getParentPoint() == null) { @@ -2134,7 +2137,7 @@ public class PipingRules { PipeControlPoint prev = pcp.getPrevious(); if (next != null) { if (!(next.getPrevious() == pcp || next.getPrevious() == sub)) { - System.out.println("Inconsistency between " + pcp + " -> " +next ); + LOGGER.debug("Inconsistency between " + pcp + " -> " +next ); } } if (prev != null) { @@ -2142,10 +2145,10 @@ public class PipingRules { if (prev.isDualSub()) { prevParent = prev.getParentPoint(); } else if (prev.isDualInline()) { - System.out.println("Inconsistency between " + pcp + " <-- " +prev ); + LOGGER.debug("Inconsistency between " + pcp + " <-- " +prev ); } if (!(prev.getNext() == pcp && (prevParent == null || prevParent.getNext() == pcp))) { - System.out.println("Inconsistency between " + pcp + " <-- " +prev ); + LOGGER.debug("Inconsistency between " + pcp + " <-- " +prev ); } } }