A4WaterUtilities.GeoNetTools.TraceIsolation C# (CSharp) Method

TraceIsolation() public static method

public static TraceIsolation ( double x, double y, IApplication app, string sourceFLName, string valveFLName, string operableFieldNameValves, string operableFieldNameSources, double snapTol, bool processEvent, string opValues, string addSQL, bool traceIndeterminate, bool ZeroSourceCont, bool selectEdges, string MeterName, string MeterCritField, string MeterCritVal, string closedValveQuery, IFeatureLayer mainsFL, IPolyline &mergedLines, List &lineOIDs, bool addResultsAsLayer, bool suppressDialog = false ) : string
x double
y double
app IApplication
sourceFLName string
valveFLName string
operableFieldNameValves string
operableFieldNameSources string
snapTol double
processEvent bool
opValues string
addSQL string
traceIndeterminate bool
ZeroSourceCont bool
selectEdges bool
MeterName string
MeterCritField string
MeterCritVal string
closedValveQuery string
mainsFL IFeatureLayer
mergedLines IPolyline
lineOIDs List
addResultsAsLayer bool
suppressDialog bool
return string
        public static string TraceIsolation(double[] x, double[] y, IApplication app, string sourceFLName, string valveFLName, string operableFieldNameValves, string operableFieldNameSources,
                                  double snapTol, bool processEvent, string[] opValues, string addSQL, bool traceIndeterminate, bool ZeroSourceCont, bool selectEdges, string MeterName,
                                  string MeterCritField, string MeterCritVal, string closedValveQuery, IFeatureLayer mainsFL, out IPolyline mergedLines, out List<int> lineOIDs, bool addResultsAsLayer,
                                   bool suppressDialog= false)
        {
            mergedLines = null;
            lineOIDs = null;
            IMap map = null;

            List<int> valveFCClassIDs = new List<int>();

            IProgressDialogFactory pProDFact = null;
            IStepProgressor pStepPro = null;
            IProgressDialog2 pProDlg = null;
            ITrackCancel pTrkCan = null;

            int pointAlong = 0;

            List<IGeometricNetwork> gnList = null;
            int gnIdx;
            IGeometricNetwork gn = null;
            IPoint snappedPoint = null;
            int EID = -1;
            double distanceAlong;
            List<INetFlag> startNetFlag = null;
            List<IFlagDisplay> pFlagsDisplay = null;
            //Find feature classes
            string[] sourceFLs;
            IFeatureClass[] sourceFC = null;
            IFeatureLayer[] sourceFL = null;
            List<int> sourceFCClassIDs = new List<int>();

            string[] strValveFLs;
            IFeatureLayer pTempLay = null;
            List<IFeatureLayer> valveFLs = null;
            List<IFeatureClass> valveFCs = null;
            //IFeatureLayer meterFL = null;
            // string meterDSName;
            IJunctionFlag[] junctionFlag = null;
            IEdgeFlag[] edgeFlag = null;
            ITraceFlowSolverGEN traceFlowSolver = null;
            INetSolver netSolver = null;
            INetElementBarriersGEN netElementBarriers = null;

            INetElementBarriers nb = null;
            IEnumNetEID juncEIDs = null;
            IEnumNetEID edgeEIDs = null;
            IEnumEIDInfo enumEidInfoJunc = null;
            IEnumEIDInfo enumEidInfoEdge = null;

            IEIDInfo eidInfo = null;
            IEIDInfo valveEIDInfo = null;
            IEIDInfo sourceEIDInfo = null;
            IEIDInfo vEIDInfo = null;
            List<int[]> userIds = null;

            IEIDHelper eidHelper = null;
            List<Hashtable> valveEIDInfoHT = null;
            Hashtable sourceEIDInfoHT = null;
            System.Object[] segCosts = null;
            ISelectionSetBarriers netElementBarrier = null;

            List<IEdgeFlag> pEdgeFlags = null;
            List<IJunctionFlag> pJunctionFlags = null;
            //List<IEdgeFlag> pEdgeFlagsBar = null;
            //List<IJunctionFlag> pJunctionFlagsBar = null;
            INetElementBarriers pEdgeElementBarriers = null;
            INetElementBarriers pJunctionElementBarriers = null;
            ISelectionSetBarriers pSelectionSetBarriers = null;
            List<INetFlag> pNetFlags;
            //ITraceResult traceRes = null;
            IFlagDisplay pFlagDisplay = null;
            INetworkAnalysisExt pNetAnalysisExt = null;
            UID pID = null;

            IJunctionFlag[] junctionFlags = null;
            IEdgeFlag[] edgeFlags = null;

            Hashtable noSourceValveHT = null;
            Hashtable hasSourceValveHT = null;
            List<BarClassIDS> barrierIds = null;
            Hashtable sourceDirectEIDInfoHT = null;
            INetFlag netFlag1 = null;
            INetFlag netFlag2 = null;

            try
            {
                map = ((app.Document as IMxDocument).FocusMap);

                bool boolCont = true;
                if (processEvent)
                {
                    // Create a CancelTracker
                    pTrkCan = new CancelTrackerClass();
                    // Create the ProgressDialog. This automatically displays the dialog
                    pProDFact = new ProgressDialogFactoryClass();
                    pProDlg = (IProgressDialog2)pProDFact.Create(pTrkCan, 0);

                    // Set the properties of the ProgressDialog
                    pProDlg.CancelEnabled = true;

                    pProDlg.Description = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsDesc_16a");
                    pProDlg.Title = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsTitle_16a");

                    pProDlg.Animation = esriProgressAnimationTypes.esriProgressGlobe;

                    // Set the properties of the Step Progressor
                    pStepPro = (IStepProgressor)pProDlg;

                    pStepPro.MinRange = 0;
                    pStepPro.MaxRange = 20;
                    pStepPro.StepValue = 1;
                    pStepPro.Position = 0;
                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_4");

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_14a");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();

                    if (!boolCont)
                    {

                        pStepPro.Hide();
                        pProDlg.HideDialog();
                        pStepPro = null;
                        pProDlg = null;
                        pProDFact = null;
                        return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                    }
                }
                if (processEvent)
                {
                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_4");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();
                }

                if (!boolCont)
                {

                    pStepPro.Hide();
                    pProDlg.HideDialog();
                    pStepPro = null;
                    pProDlg = null;
                    pProDFact = null;
                    return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                }
                pointAlong++;

                gnList = Globals.GetGeometricNetworksCurrentlyVisible(ref map);
                gnIdx = -1;
                if (processEvent)
                {

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_14a");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();
                }

                if (!boolCont)
                {

                    pStepPro.Hide();
                    pProDlg.HideDialog();
                    pStepPro = null;
                    pProDlg = null;
                    pProDFact = null;
                    return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                }
                pointAlong++;

                // Create junction or edge flag at start of trace - also returns geometric network, snapped point, and EID of junction

                if (processEvent)
                {

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15a");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();
                }

                if (!boolCont)
                {

                    pStepPro.Hide();
                    pProDlg.HideDialog();
                    pStepPro = null;
                    pProDlg = null;
                    pProDFact = null;
                    return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                }

                startNetFlag = new List<INetFlag>();// null;// Globals.GetJunctionFlag(x, y, map, ref gnList, snapTol, ref gnIdx, out snappedPoint, out EID) as INetFlag;
                //if (startNetFlag == null)
                pFlagsDisplay = new List<IFlagDisplay>();
                if (x != null)
                {
                    for (int l = 0; l < x.Length; l++)
                    {
                        startNetFlag.Add(Globals.GetEdgeFlag(x[l], y[l], ref  map, ref gnList, snapTol, ref gnIdx, out snappedPoint, out EID, out distanceAlong, out pFlagDisplay, true) as INetFlag);
                        pFlagsDisplay.Add(pFlagDisplay);

                    }
                }
                pointAlong++;

                //Set network to trace
                if (gnIdx > -1)
                    gn = gnList[gnIdx] as IGeometricNetwork;

                INetElementBarriersGEN netElementBarriersClose;

                pID = new UID();

                pID.Value = "esriEditorExt.UtilityNetworkAnalysisExt";
                pNetAnalysisExt = (INetworkAnalysisExt)app.FindExtensionByCLSID(pID);
                if (gn != null)
                {
                    Globals.SetCurrentNetwork(ref pNetAnalysisExt, ref gn);
                }

                gn = pNetAnalysisExt.CurrentNetwork;

                traceFlowSolver = Globals.CreateTraceFlowSolverFromToolbar(ref pNetAnalysisExt, out pEdgeFlags, out pJunctionFlags, out pEdgeElementBarriers, out pJunctionElementBarriers, out pSelectionSetBarriers) as ITraceFlowSolverGEN;

                strValveFLs = valveFLName.Split('|');

                valveFLs = new List<IFeatureLayer>();//(IFeatureLayer)Globals.FindLayer(map, valveFLName);
                valveFCs = new List<IFeatureClass>();//[strValveFLs.Length];

                //closedValvesbarrierIds = new List<BarClassIDS>();
                IFeatureCursor pCurValBar = null;
                IFeature valBarFeat = null;
                QueryFilter pQFValBar = new QueryFilterClass();
                pQFValBar = new QueryFilterClass();
                if (closedValveQuery != "")
                {
                    pQFValBar.WhereClause = closedValveQuery;
                }
                //INetFlag closedValveBarr;
                List<int> closeVal = new List<int>();
                List<FeatureOIDs> selectBars = new List<FeatureOIDs>();
                FeatureOIDs featID;
                for (int i = 0; i < strValveFLs.Length; i++)
                {
                    bool FCorLayerTemp = true;

                    pTempLay = (IFeatureLayer)Globals.FindLayerFromMapDataset(map, strValveFLs[i], ref FCorLayerTemp, gn.FeatureDataset);
                    if (pTempLay != null)
                    {

                        if (pTempLay.FeatureClass != null)
                        {
                            valveFLs.Add(pTempLay);
                            valveFCs.Add(pTempLay.FeatureClass);
                            valveFCClassIDs.Add(pTempLay.FeatureClass.FeatureClassID);
                            try
                            {
                                if (closedValveQuery != "")
                                {

                                    pCurValBar = pTempLay.FeatureClass.Search(pQFValBar, true);

                                    while ((valBarFeat = pCurValBar.NextFeature()) != null)
                                    {

                                        //Attempt to use selection barriers
                                        //featID = new FeatureOIDs();
                                        //featID.ClassID = pTempLay.FeatureClass.FeatureClassID;
                                        //featID.ID = valBarFeat.OID;

                                        //selectBars.Add(featID);
                                        //pSelectionSetBarriers.Add(pTempLay.FeatureClass.FeatureClassID, valBarFeat.OID);

                                        //To Use a Edge Barries
                                        try
                                        {
                                            IPoint loc = (valBarFeat.ShapeCopy as IPoint);
                                            closeVal.Add(Globals.getEIDAtLocation(ref loc, ref map, ref gn, snapTol));
                                            loc = null;

                                        }
                                        catch (Exception ex)
                                        {

                                        }
                                    }

                                }
                            }
                            catch
                            { }

                        }
                    }

                }
                //To use closed valves as edge barriers
                if (closeVal.Count > 0)
                {
                    INetworkAnalysisExtBarriers pNetworkAnalysisExtBarriers = null;

                    INetElements pNetElements = gn.Network as INetElements;

                    pNetworkAnalysisExtBarriers = (INetworkAnalysisExtBarriers)pNetAnalysisExt;

                    int lngFlagCount = pNetworkAnalysisExtBarriers.EdgeBarrierCount;

                    //only execute this next bit if there are junction flags
                    if (lngFlagCount != 0)
                    {

                        for (int i = 0; i < lngFlagCount; i++)
                        {

                            pFlagDisplay = (IFlagDisplay)pNetworkAnalysisExtBarriers.get_EdgeBarrier(i);
                            closeVal.Add(pNetElements.GetEID(pFlagDisplay.FeatureClassID, pFlagDisplay.FID, pFlagDisplay.SubID, esriElementType.esriETEdge));

                        }

                    }

                    netElementBarriersClose = new NetElementBarriersClass() as INetElementBarriersGEN;
                    netElementBarriersClose.ElementType = esriElementType.esriETEdge;
                    //netElementBarriersClose.ElementType = esriElementType.esriETJunction;
                    netElementBarriersClose.Network = gn.Network;

                    int[] clo = closeVal.ToArray();

                    netElementBarriersClose.SetBarriersByEID(ref clo);
                    pEdgeElementBarriers = netElementBarriersClose as INetElementBarriers;

                }
                valBarFeat = null;
                pQFValBar = null;
                if (pCurValBar != null)
                    Marshal.ReleaseComObject(pCurValBar);
                pCurValBar = null;

                netSolver = traceFlowSolver as INetSolver;

                traceFlowSolver.TraceIndeterminateFlow = traceIndeterminate;
                pNetFlags = new List<INetFlag>();

                if (pEdgeFlags != null)
                {
                    foreach (IEdgeFlag pEdFl in pEdgeFlags)
                    {
                        pNetFlags.Add((INetFlag)pEdFl);

                    }
                }
                if (pJunctionFlags != null)
                {

                    foreach (IJunctionFlag pJcFl in pJunctionFlags)
                    {
                        pNetFlags.Add((INetFlag)pJcFl);
                    }
                }
                if (startNetFlag != null)
                {
                    if (startNetFlag.Count > 0)
                    {
                        foreach (INetFlag pNF in startNetFlag)
                        {
                            if (pNF != null)
                            {
                                pNetFlags.Add((INetFlag)pNF);
                            }
                        }
                    }

                    // pNetFlags.Add((INetFlag)startNetFlag);

                }
                if (pNetFlags.Count == 0)
                {
                    return A4LGSharedFunctions.Localizer.GetString("AddFlagOrClickReturnStatement");

                }

                // Stop if user point was not on a visible network feature, old trace results and selection are cleared
                if (gn == null || pNetFlags.Count == 0)
                {

                    return A4LGSharedFunctions.Localizer.GetString("NotIntersectReturnStatement");
                }
                pointAlong++;
                if (processEvent)
                {

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16a");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();
                }

                if (!boolCont)
                {

                    pStepPro.Hide();
                    pProDlg.HideDialog();
                    pStepPro = null;
                    pProDlg = null;
                    pProDFact = null;
                    return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                }
                //Find feature classes
                sourceFLs = sourceFLName.Split('|');
                sourceFC = new IFeatureClass[sourceFLs.Length];
                sourceFL = new IFeatureLayer[sourceFLs.Length];

                for (int i = 0; i < sourceFLs.Length; i++)
                {
                    bool FCorLayerTemp = true;
                    sourceFL[i] = (IFeatureLayer)Globals.FindLayerFromMapDataset(map, sourceFLs[i], ref FCorLayerTemp, gn.FeatureDataset);
                    if (sourceFL[i] != null)
                    {
                        sourceFC[i] = sourceFL[i].FeatureClass;
                        sourceFCClassIDs.Add(sourceFL[i].FeatureClass.FeatureClassID);
                    }

                }
                pointAlong++;
                //                IFeatureClass sourceFC = (IFeatureClass)Globals.GetFeatureClassFromGeometricNetwork(sourceFCName, gn, esriFeatureType.esriFTSimpleJunction);
                // IFeatureClass valveFC = (IFeatureClass)Globals.GetFeatureClassFromGeometricNetwork(valveFCName, gn, esriFeatureType.esriFTSimpleJunction);
                //strValveFLs = valveFLName.Split('|');

                //valveFLs = new List<IFeatureLayer>();//(IFeatureLayer)Globals.FindLayer(map, valveFLName);
                //valveFCs = new List<IFeatureClass>();//[strValveFLs.Length];

                //for (int i = 0; i < strValveFLs.Length; i++)
                //{
                //    bool FCorLayerTemp = true;
                //    pTempLay = (IFeatureLayer)Globals.FindLayer(map, strValveFLs[i], ref FCorLayerTemp);
                //    if (pTempLay != null)
                //    {

                //        if (pTempLay.FeatureClass != null)
                //        {
                //            valveFLs.Add(pTempLay);
                //            valveFCs.Add(pTempLay.FeatureClass);
                //            valveFCClassIDs.Add(pTempLay.FeatureClass.FeatureClassID);

                //        }
                //    }

                //}

                //  string strMeterFL = meterFLName;

                //meterFL = (IFeatureLayer)Globals.FindLayer(map, meterFLName);
                //meterDSName = "";
                //if (meterFL != null)
                //{
                //    if (meterFL is IDataset)
                //    {
                //        IDataset pTempDataset = (IDataset)meterFL;
                //        meterDSName = pTempDataset.BrowseName;
                //        if (meterDSName.Contains("."))
                //        {
                //            meterDSName = meterDSName.Substring(meterDSName.LastIndexOf(".") + 1);

                //        }
                //        Marshal.ReleaseComObject(pTempDataset);

                //        pTempDataset = null;
                //    }

                //}
                //meterFL = null;

                if (processEvent)
                {

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16a");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();
                }

                if (!boolCont)
                {

                    pStepPro.Hide();
                    pProDlg.HideDialog();
                    pStepPro = null;
                    pProDlg = null;
                    pProDFact = null;
                    return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                }
                pointAlong++;
                if (valveFCs == null)
                {
                    if (processEvent)
                    {

                        pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15d") + valveFLName + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15e") + Environment.NewLine +
                            A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15f");
                        pStepPro.Step();
                        boolCont = pTrkCan.Continue();
                    }

                    if (!boolCont)
                    {

                        pStepPro.Hide();
                        pProDlg.HideDialog();
                        pStepPro = null;
                        pProDlg = null;
                        pProDFact = null;
                        return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement"); ;
                    }
                    return A4LGSharedFunctions.Localizer.GetString("LambdaReturnStatement") + valveFLName + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15e") + Environment.NewLine +
                            A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15f");
                }
                pointAlong++;
                if (valveFCs.Count == 0)
                {
                    if (processEvent)
                    {

                        pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15d") + valveFLName + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15e") + Environment.NewLine +
                            A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15f");
                        pStepPro.Step();
                        boolCont = pTrkCan.Continue();
                    }

                    if (!boolCont)
                    {

                        pStepPro.Hide();
                        pProDlg.HideDialog();
                        pStepPro = null;
                        pProDlg = null;
                        pProDFact = null;
                        return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                    }
                    return A4LGSharedFunctions.Localizer.GetString("LambdaReturnStatement") + valveFLName + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15e") + Environment.NewLine +
                            A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15f");
                }

                if (sourceFC == null)
                {
                    if (processEvent)
                    {

                        pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15d") + sourceFLs + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15e") + Environment.NewLine +
                            A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15f");
                        pStepPro.Step();
                        boolCont = pTrkCan.Continue();
                    }

                    if (!boolCont)
                    {

                        pStepPro.Hide();
                        pProDlg.HideDialog();
                        pStepPro = null;
                        pProDlg = null;
                        pProDFact = null;
                        return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                    }
                    return A4LGSharedFunctions.Localizer.GetString("LambdaReturnStatement") + sourceFLs + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15e") + Environment.NewLine +
                            A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15f");
                }
                pointAlong++;
                if (sourceFC.Length == 0)
                {
                    if (processEvent)
                    {

                        pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15d") + sourceFLs + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15e") + Environment.NewLine +
                            A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15f");
                        pStepPro.Step();
                        boolCont = pTrkCan.Continue();
                    }

                    if (!boolCont)
                    {

                        pStepPro.Hide();
                        pProDlg.HideDialog();
                        pStepPro = null;
                        pProDlg = null;
                        pProDFact = null;
                        return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                    }
                    return A4LGSharedFunctions.Localizer.GetString("LambdaReturnStatement") + sourceFLs + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15e") + Environment.NewLine +
                            A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15f");
                }

                pointAlong++;

                if (processEvent)
                {

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16b");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();
                }

                if (!boolCont)
                {

                    pStepPro.Hide();
                    pProDlg.HideDialog();
                    pStepPro = null;
                    pProDlg = null;
                    pProDFact = null;
                    return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                }

                Globals.AddFlagsToTraceSolver(pNetFlags.ToArray(), ref traceFlowSolver, out junctionFlags, out edgeFlags);

                if (processEvent)
                {

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16c");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();
                }

                if (!boolCont)
                {

                    pStepPro.Hide();
                    pProDlg.HideDialog();
                    pStepPro = null;
                    pProDlg = null;
                    pProDFact = null;
                    return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                }

                //Create barriers based on all operable valves
                pointAlong++;
                netElementBarriers = new NetElementBarriersClass() as INetElementBarriersGEN;
                netElementBarriers.ElementType = esriElementType.esriETJunction;
                netElementBarriers.Network = gn.Network;

                userIds = Globals.GetOperableValveOIDs(valveFCs.ToArray(), operableFieldNameValves, opValues, addSQL);
                if (userIds == null)
                {
                    if (processEvent)
                    {

                        pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16d");
                        pStepPro.Step();
                        boolCont = pTrkCan.Continue();
                    }

                    if (!boolCont)
                    {

                        pStepPro.Hide();
                        pProDlg.HideDialog();
                        pStepPro = null;
                        pProDlg = null;
                        pProDFact = null;
                        return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                    }
                }

                else
                {
                    if (userIds.Count == 0)
                    {
                        if (processEvent)
                        {

                            pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16d");
                            pStepPro.Step();
                            boolCont = pTrkCan.Continue();
                        }

                        if (!boolCont)
                        {

                            pStepPro.Hide();
                            pProDlg.HideDialog();
                            pStepPro = null;
                            pProDlg = null;
                            pProDFact = null;
                            return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                        }
                    }
                    else
                    {
                        try
                        {
                            int idxUser = 0;
                            if (processEvent)
                            {

                                pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16e");
                                pStepPro.Step();
                                boolCont = pTrkCan.Continue();
                            }

                            if (!boolCont)
                            {

                                pStepPro.Hide();
                                pProDlg.HideDialog();
                                pStepPro = null;
                                pProDlg = null;
                                pProDFact = null;
                                return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                            }
                            foreach (IFeatureClass valveFC in valveFCs)
                            {
                                int[] usrid = userIds[idxUser];
                                if (usrid.Length > 0)
                                {
                                    netElementBarriers.SetBarriers(valveFC.FeatureClassID, ref usrid);  //error here after sum
                                    nb = netElementBarriers as INetElementBarriers;
                                    netSolver.set_ElementBarriers(esriElementType.esriETJunction, nb);
                                }
                                idxUser++;
                            }
                        }
                        catch (Exception Ex)
                        {
                            if (processEvent)
                            {

                                pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsError_16a") + Ex.Message;
                                pStepPro.Step();
                                boolCont = pTrkCan.Continue();
                                return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                            }

                            if (!boolCont)
                            {

                                pStepPro.Hide();
                                pProDlg.HideDialog();
                                pStepPro = null;
                                pProDlg = null;
                                pProDFact = null;
                                return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                            }
                        }
                    }
                }
                pointAlong++;
                if (processEvent)
                {

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16f");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();
                }

                if (!boolCont)
                {

                    pStepPro.Hide();
                    pProDlg.HideDialog();
                    pStepPro = null;
                    pProDlg = null;
                    pProDFact = null;
                    return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                }

                try
                {
                    juncEIDs = null;
                    edgeEIDs = null;
                    traceFlowSolver.FindFlowEndElements(esriFlowMethod.esriFMConnected, esriFlowElements.esriFEJunctionsAndEdges, out juncEIDs, out edgeEIDs);
                }
                catch (Exception ex)
                {
                    try
                    {
                        traceFlowSolver.FindFlowEndElements(esriFlowMethod.esriFMConnected, esriFlowElements.esriFEJunctionsAndEdges, out juncEIDs, out edgeEIDs);
                    }
                    catch (Exception ex2)
                    {
                        juncEIDs = null;
                        edgeEIDs = null;
                        if (processEvent)
                        {

                            pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("ErrorInThe") + "FindFlowEndElements";
                            pStepPro.Step();
                            boolCont = pTrkCan.Continue();
                        }

                        if (!boolCont)
                        {

                            pStepPro.Hide();
                            pProDlg.HideDialog();
                            pStepPro = null;
                            pProDlg = null;
                            pProDFact = null;
                            return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                        }
                        return A4LGSharedFunctions.Localizer.GetString("DontFindFlowEltReturnStatement");
                    }
                    //MessageBox.Show("Error in the FindFlowEndElements");
                }
                pointAlong++;
                eidHelper = new EIDHelperClass();
                eidHelper.GeometricNetwork = gn;
                eidHelper.ReturnFeatures = true;

                //Save valves which stopped the trace
                if (processEvent)
                {

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16g");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();
                }

                if (!boolCont)
                {

                    pStepPro.Hide();
                    pProDlg.HideDialog();
                    pStepPro = null;
                    pProDlg = null;
                    pProDFact = null;
                    return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                }
                pointAlong++;

                valveEIDInfoHT = new List<Hashtable>();
                int totalreachcount = 0;
                foreach (IFeatureClass valveFC in valveFCs)
                {
                    if (valveFC != null)
                    {
                        Hashtable valveEIDInfoHTtemp = Globals.GetEIDInfoListByFC(valveFC.FeatureClassID, juncEIDs, eidHelper);
                        totalreachcount = totalreachcount + valveEIDInfoHTtemp.Count;
                        valveEIDInfoHT.Add(valveEIDInfoHTtemp);
                    }

                }
                if (totalreachcount == 0)
                {
                    if (processEvent)
                    {

                        pStepPro.Message = (A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16a") + valveFLName + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15c") + Environment.NewLine +
                            Environment.NewLine +
                            A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16b") + valveFLName + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16c") + Environment.NewLine +
                            A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16d") + Environment.NewLine +
                            A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16e"));
                        pStepPro.Step();
                        boolCont = pTrkCan.Continue();
                    }

                    if (!boolCont)
                    {

                        pStepPro.Hide();
                        pProDlg.HideDialog();
                        pStepPro = null;
                        pProDlg = null;
                        pProDFact = null;
                        //return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                    }

                    //return A4LGSharedFunctions.Localizer.GetString("Error") + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16a") + valveFLName + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15c") + Environment.NewLine +
                    //        Environment.NewLine +
                    //        A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16b") + valveFLName + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16c") + Environment.NewLine +
                    //        A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16d") + Environment.NewLine +
                    //        A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16e");
                }
                pointAlong++;
                if (processEvent)
                {

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16h");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();
                }

                if (!boolCont)
                {

                    pStepPro.Hide();
                    pProDlg.HideDialog();
                    pStepPro = null;
                    pProDlg = null;
                    pProDFact = null;
                    return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                }

                traceFlowSolver = new TraceFlowSolverClass() as ITraceFlowSolverGEN;
                traceFlowSolver.TraceIndeterminateFlow = traceIndeterminate;
                netSolver = traceFlowSolver as INetSolver;

                netSolver.SourceNetwork = gn.Network;
                //Globals.AddFlagsToTraceSolver(startNetFlag.ToArray(), ref traceFlowSolver, out junctionFlag, out edgeFlag);
                Globals.AddFlagsToTraceSolver(pNetFlags.ToArray(), ref traceFlowSolver, out junctionFlag, out edgeFlag);
                Globals.AddBarriersToSolver(ref traceFlowSolver, ref pEdgeElementBarriers, ref pJunctionElementBarriers, ref pSelectionSetBarriers);

                pointAlong++;
                foreach (int sFC in sourceFCClassIDs)
                {
                    netSolver.DisableElementClass(sFC);
                }

                traceFlowSolver.FindFlowEndElements(esriFlowMethod.esriFMConnected, esriFlowElements.esriFEJunctions, out juncEIDs, out edgeEIDs);
                pointAlong++;
                //Save sources which are reachable
                if (processEvent)
                {

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16i");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();
                }

                if (!boolCont)
                {

                    pStepPro.Hide();
                    pProDlg.HideDialog();
                    pStepPro = null;
                    pProDlg = null;
                    pProDFact = null;
                    return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                }

                sourceEIDInfoHT = new Hashtable();

                //foreach (IFeatureClass sFC in sourceFC)
                //{
                Globals.GetEIDInfoListByFCWithHT(ref sourceEIDInfoHT, sourceFCClassIDs, operableFieldNameSources, opValues, juncEIDs, eidHelper);

                //}
                pointAlong++;
                if (sourceEIDInfoHT.Count == 0 && totalreachcount > 0)
                {
                    if (processEvent)
                    {

                        pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("No") + sourceFLName + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15c") + Environment.NewLine +
                         Environment.NewLine +
                         A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16b") + sourceFLName + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16c") + Environment.NewLine +
                         A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16j");
                        pStepPro.Step();
                        boolCont = pTrkCan.Continue();
                    }

                    if (!boolCont)
                    {

                        pStepPro.Hide();
                        pProDlg.HideDialog();
                        pStepPro = null;
                        pProDlg = null;
                        pProDFact = null;
                        return null;
                    }
                    return A4LGSharedFunctions.Localizer.GetString("Error") + A4LGSharedFunctions.Localizer.GetString("No") + sourceFLName + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_15c") + Environment.NewLine +
                         Environment.NewLine +
                         A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16b") + sourceFLName + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16c") + Environment.NewLine +
                         A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16j");
                }
                if (processEvent)
                {

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16k");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();
                }

                if (!boolCont)
                {

                    pStepPro.Hide();
                    pProDlg.HideDialog();
                    pStepPro = null;
                    pProDlg = null;
                    pProDFact = null;
                    return null;
                }

                traceFlowSolver = new TraceFlowSolverClass() as ITraceFlowSolverGEN;
                traceFlowSolver.TraceIndeterminateFlow = traceIndeterminate;
                netSolver = traceFlowSolver as INetSolver;
                netSolver.SourceNetwork = gn.Network;
                //Globals.AddFlagsToTraceSolver(startNetFlag.ToArray(), ref traceFlowSolver, out junctionFlag, out edgeFlag);
                Globals.AddFlagsToTraceSolver(pNetFlags.ToArray(), ref traceFlowSolver, out junctionFlag, out edgeFlag);
                Globals.AddBarriersToSolver(ref traceFlowSolver, ref pEdgeElementBarriers, ref pJunctionElementBarriers, ref pSelectionSetBarriers);

                pointAlong++;
                //Set the barriers in the network based on the saved valves
                if (processEvent)
                {

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16l");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();
                }

                if (!boolCont)
                {

                    pStepPro.Hide();
                    pProDlg.HideDialog();
                    pStepPro = null;
                    pProDlg = null;
                    pProDFact = null;
                    return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                }

                //Run the trace to find directly reachable sources (without passing valve)
                if (processEvent)
                {

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16m");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();
                }

                if (!boolCont)
                {

                    pStepPro.Hide();
                    pProDlg.HideDialog();
                    pStepPro = null;
                    pProDlg = null;
                    pProDFact = null;
                    return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                }

                netElementBarrier = new SelectionSetBarriersClass();

                totalreachcount = 0;
                foreach (Hashtable HTentry in valveEIDInfoHT)
                {
                    foreach (DictionaryEntry entry in HTentry)
                    {
                        eidInfo = entry.Value as IEIDInfo;
                        netElementBarrier.Add(eidInfo.Feature.Class.ObjectClassID, eidInfo.Feature.OID);
                    }
                    //totalreachcount++;
                }

                //attempt to use selection barriers for closed valves
                //foreach (FeatureOIDs featOIDS in selectBars)
                //{
                //    netElementBarrier.Add(featOIDS.ClassID, featOIDS.ID);
                //}
                pointAlong++;
                netSolver.SelectionSetBarriers = netElementBarrier;
                pointAlong++;
                Globals.AddBarriersToSolver(ref traceFlowSolver, ref pEdgeElementBarriers, ref pJunctionElementBarriers, ref pSelectionSetBarriers);

                traceFlowSolver.FindFlowElements(esriFlowMethod.esriFMConnected, esriFlowElements.esriFEJunctionsAndEdges, out juncEIDs, out edgeEIDs);
                // Hashtable sourceDirectEIDInfoHT = Globals.GetEIDInfoListByFC(sourceFC.FeatureClassID, juncEIDs, eidHelper);
                sourceDirectEIDInfoHT = new Hashtable();

                Globals.GetEIDInfoListByFCWithHT(ref sourceDirectEIDInfoHT, sourceFCClassIDs, operableFieldNameSources, opValues, juncEIDs, eidHelper);

                //Remove directly reachable sources from source array
                if (processEvent)
                {

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16n");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();
                }

                if (!boolCont)
                {

                    pStepPro.Hide();
                    pProDlg.HideDialog();
                    pStepPro = null;
                    pProDlg = null;
                    pProDFact = null;
                    return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                }
                pointAlong++;
                foreach (DictionaryEntry entry in sourceDirectEIDInfoHT)
                {
                    eidInfo = entry.Value as IEIDInfo;
                    sourceEIDInfoHT.Remove(eidInfo.Feature.OID);
                }
                pointAlong++;//21
                if (sourceEIDInfoHT.Count == 0 && totalreachcount > 0)
                {
                    if (processEvent)
                    {

                        pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("No") + sourceFLName + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16o") + Environment.NewLine +
                         Environment.NewLine +
                         A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16b") + sourceFLName + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16c") + Environment.NewLine +
                         A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16j");
                        pStepPro.Step();
                        boolCont = pTrkCan.Continue();
                    }

                    if (!boolCont)
                    {

                        pStepPro.Hide();
                        pProDlg.HideDialog();
                        pStepPro = null;
                        pProDlg = null;
                        pProDFact = null;
                        return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                    }
                    return A4LGSharedFunctions.Localizer.GetString("Error") + A4LGSharedFunctions.Localizer.GetString("No") + sourceFLName + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16o") + Environment.NewLine +
                         Environment.NewLine +
                         A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16b") + sourceFLName + A4LGSharedFunctions.Localizer.GetString("GeoNetToolsMess_16c") + Environment.NewLine +
                         A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16j");
                }
                pointAlong++;//22
                if (processEvent)
                {

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16p");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();
                }

                if (!boolCont)
                {

                    pStepPro.Hide();
                    pProDlg.HideDialog();
                    pStepPro = null;
                    pProDlg = null;
                    pProDFact = null;
                    return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                }

                noSourceValveHT = new Hashtable();
                hasSourceValveHT = new Hashtable();

                // IEIDInfo vEIDInfo;
                barrierIds = null;

                bool foundSource;
                // ArrayList barrierArrayList;
                pointAlong++;
                totalreachcount = 0;
                foreach (Hashtable valveHT in valveEIDInfoHT)
                {
                    foreach (DictionaryEntry valveEntry in valveHT)
                    {

                        foundSource = false;
                        valveEIDInfo = valveEntry.Value as IEIDInfo;

                        //Create array of all isolation valves excluding the current one
                        // barrierArrayList = new ArrayList();
                        barrierIds = new List<BarClassIDS>();

                        foreach (Hashtable valveHTBar in valveEIDInfoHT)
                        {
                            BarClassIDS barClID = new BarClassIDS();
                            List<int> tempIntArr = new List<int>();

                            foreach (DictionaryEntry valveEntryBar in valveHTBar)
                            {
                                vEIDInfo = valveEntryBar.Value as IEIDInfo;

                                barClID.ClassID = vEIDInfo.Feature.Class.ObjectClassID;

                                vEIDInfo = valveEntryBar.Value as IEIDInfo;
                                if (vEIDInfo.Feature.OID == valveEIDInfo.Feature.OID && vEIDInfo.Feature.Class.ObjectClassID == valveEIDInfo.Feature.Class.ObjectClassID)
                                {

                                }
                                else
                                {

                                    //  barrierArrayList.Add(vEIDInfo.Feature.OID);
                                    tempIntArr.Add(vEIDInfo.Feature.OID);
                                    //barrierIds.Add(vEIDInfo.Feature.OID);
                                }

                            }
                            barClID.IDs = tempIntArr.ToArray();
                            barrierIds.Add(barClID);
                        }
                        //if (valveHT.Count > 1)
                        //{

                        //    barrierArrayList = new ArrayList();
                        //    barrierIds = new int[valveHT.Count - 1];
                        //    foreach (DictionaryEntry v in valveHT)
                        //    {
                        //        vEIDInfo = v.Value as IEIDInfo;
                        //        if (vEIDInfo.Feature.OID != valveEIDInfo.Feature.OID)
                        //        {
                        //            barrierArrayList.Add(vEIDInfo.Feature.OID);
                        //        }
                        //    }
                        //    barrierArrayList.CopyTo(barrierIds);
                        //}
                        //else
                        //    barrierArrayList = null;

                        pointAlong++;
                        //For each source, attempt to trace

                        foreach (DictionaryEntry sourceEntry in sourceEIDInfoHT)
                        {

                            sourceEIDInfo = sourceEntry.Value as IEIDInfo;

                            //Setup trace to test each valve
                            traceFlowSolver = new TraceFlowSolverClass() as ITraceFlowSolverGEN;
                            traceFlowSolver.TraceIndeterminateFlow = traceIndeterminate;
                            netSolver = traceFlowSolver as INetSolver;
                            netSolver.SourceNetwork = gn.Network;
                            Globals.AddBarriersToSolver(ref traceFlowSolver, ref pEdgeElementBarriers, ref pJunctionElementBarriers, ref pSelectionSetBarriers);

                            //Set the first junction flag for path finding based this current valve
                            netFlag1 = new JunctionFlagClass();
                            netFlag1.UserClassID = valveEIDInfo.Feature.Class.ObjectClassID;
                            netFlag1.UserID = valveEIDInfo.Feature.OID;
                            netFlag1.UserSubID = 0;
                            netFlag1.Label = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsLbl_16a");
                            //AddFlagToTraceSolver(netFlag1, ref traceFlowSolver, out junctionFlag, out edgeFlag);

                            //Set the second (and last) trace flag at this source
                            netFlag2 = new JunctionFlagClass();
                            netFlag2.UserClassID = sourceEIDInfo.Feature.Class.ObjectClassID;
                            netFlag2.UserID = sourceEIDInfo.Feature.OID;
                            netFlag2.UserSubID = 0;
                            netFlag2.Label = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsLbl_16b");

                            Globals.AddTwoJunctionFlagsToTraceSolver(ref traceFlowSolver, netFlag1, netFlag2);

                            //Set as isolation valves (except the current one) as barriers
                            if (barrierIds != null && barrierIds.Count > 0)
                            {
                                netElementBarriers = new NetElementBarriersClass() as INetElementBarriersGEN;
                                netElementBarriers.ElementType = esriElementType.esriETJunction;
                                netElementBarriers.Network = gn.Network;
                                bool setBar = false;
                                foreach (BarClassIDS tempBarIDS in barrierIds)
                                {
                                    if (tempBarIDS.IDs.Length > 0)
                                    {
                                        int[] barIDs = tempBarIDS.IDs;

                                        netElementBarriers.SetBarriers(tempBarIDS.ClassID, ref barIDs);
                                        setBar = true;
                                    }
                                }
                                if (setBar)//required, it would produce an error if there where no other barriers
                                {
                                    nb = netElementBarriers as INetElementBarriers;
                                    netSolver.set_ElementBarriers(esriElementType.esriETJunction, nb);
                                }
                            }

                            //Run trace
                            segCosts = new System.Object[1];
                            segCosts[0] = new System.Object(); edgeEIDs = null;
                            traceFlowSolver.FindPath(esriFlowMethod.esriFMConnected, esriShortestPathObjFn.esriSPObjFnMinSum, out juncEIDs, out edgeEIDs, 1, ref segCosts);
                            if (edgeEIDs != null && edgeEIDs.Count > 0)
                            {
                                foundSource = true;
                                break;
                            }

                        } // End of source loop
                        pointAlong++;//25 -30ish
                        if (foundSource)
                        {
                            hasSourceValveHT.Add(valveEIDInfo.EID, valveEIDInfo);//valveEIDInfo.Feature.Class.ObjectClassID +":" +
                        }
                        else
                        {
                            noSourceValveHT.Add(valveEIDInfo.EID, valveEIDInfo);
                            //Set the second (and last) trace flag at this source
                            //netFlag2 = new JunctionFlagClass();
                            //netFlag2.UserClassID = valveEIDInfo.Feature.Class.ObjectClassID;
                            //netFlag2.UserID = valveEIDInfo.Feature.OID;
                            //netFlag2.UserSubID = 0;
                            //pNetFlags.Add(netFlag2);
                        }

                    } // End of valve loop
                    //totalreachcount++;
                }
                //Setup last trace with correct valve barriers

                if (hasSourceValveHT.Count == 0)
                {
                    if (ZeroSourceCont)
                        hasSourceValveHT = noSourceValveHT;
                    else
                        return A4LGSharedFunctions.Localizer.GetString("NoWaterSourceIdentifiedReturnStatement");

                }
                if (processEvent)
                {

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("GeoNetToolsProc_16q");
                    pStepPro.Step();
                    boolCont = pTrkCan.Continue();
                }

                if (!boolCont)
                {

                    pStepPro.Hide();
                    pProDlg.HideDialog();
                    pStepPro = null;
                    pProDlg = null;
                    pProDFact = null;
                    return A4LGSharedFunctions.Localizer.GetString("CanceledReturnStatement");
                }
                pointAlong++;
                traceFlowSolver = new TraceFlowSolverClass() as ITraceFlowSolverGEN;
                traceFlowSolver.TraceIndeterminateFlow = traceIndeterminate;
                netSolver = traceFlowSolver as INetSolver;
                netSolver.SourceNetwork = gn.Network;

                //Globals.AddFlagsToTraceSolver(startNetFlag.ToArray(), ref traceFlowSolver, out junctionFlag, out edgeFlag);
                Globals.AddFlagsToTraceSolver(pNetFlags.ToArray(), ref traceFlowSolver, out junctionFlag, out edgeFlag);
                INetElementBarriers nullTemp = null;
                Globals.AddBarriersToSolver(ref traceFlowSolver, ref pEdgeElementBarriers, ref pJunctionElementBarriers, ref pSelectionSetBarriers);

                //Set the barriers in the network based on the saved valves

                netElementBarrier = new SelectionSetBarriersClass();

                foreach (DictionaryEntry entry in hasSourceValveHT)
                {
                    eidInfo = entry.Value as IEIDInfo;

                    //netElementBarrier.Add(valveFC.FeatureClassID, eidInfo.Feature.OID);
                    netElementBarrier.Add(((IFeatureClass)eidInfo.Feature.Class).FeatureClassID, eidInfo.Feature.OID);
                }
                //attempt to use selection barriers for closed valves
                //foreach (FeatureOIDs featOIDS in selectBars)
                //{
                //    netElementBarrier.Add(featOIDS.ClassID, featOIDS.ID);
                //}
                netSolver.SelectionSetBarriers = netElementBarrier;

                pointAlong++;
                //Run last trace
                traceFlowSolver.FindFlowElements(esriFlowMethod.esriFMConnected, esriFlowElements.esriFEJunctionsAndEdges, out juncEIDs, out edgeEIDs);
                //skipped valves =>  //Hashtable skippedValvesEIDInfoHT = GetEIDInfoListByFC(valveFC.FeatureClassID, juncEIDs, eidHelper);

                //Select junction features
                pointAlong++; //51,44

                //Open identify dialog with selected features
                //IdentifySelected(map);

                if (snappedPoint != null)
                {
                    snappedPoint.Project(map.SpatialReference);
                    // traceRes.TracePoint = snappedPoint;

                }
                // return "Post1";

                //Globals.LoadJunctions(ref traceRes, ref gn, ref map, ref juncEIDs, ref meterDSName);
                // Globals.LoadValves(ref traceRes, ref gn, ref map, ref hasSourceValveHT);

                //Globals.LoadEdges(ref traceRes, ref gn, ref map, ref edgeEIDs);
                //((IMxDocument)app.Document).FocusMap.ClearSelection();
                //Globals.RemoveGraphics(((IMxDocument)app.Document).FocusMap, false);

                eidHelper = new EIDHelperClass();
                eidHelper.GeometricNetwork = gn;

                //eidHelper.OutputSpatialReference = map.SpatialReference;
                eidHelper.ReturnFeatures = true;
                eidHelper.ReturnGeometries = true;
                eidHelper.PartialComplexEdgeGeometry = true;

                if (processEvent)
                {
                    if (pNetAnalysisExt != null)
                    {
                        foreach (IFlagDisplay pFgDi in pFlagsDisplay)
                        {
                            Globals.AddFlagToGN(ref pNetAnalysisExt, ref gn, pFgDi);

                            // Globals.AddPointGraphic(map, pFgDi.Geometry as IPoint, false);
                        }
                    }
                    else
                    {
                        foreach (IFlagDisplay pFgDi in pFlagsDisplay)
                        {
                            //  Globals.AddFlagToGN(ref pNetAnalysisExt, ref gn,  pFgDi);

                            Globals.AddPointGraphic(map, pFgDi.Geometry as IPoint, false);
                        }
                    }
                }

                enumEidInfoJunc = eidHelper.CreateEnumEIDInfo(juncEIDs);
                enumEidInfoEdge = eidHelper.CreateEnumEIDInfo(edgeEIDs);

                int totalCount = hasSourceValveHT.Count;

                totalCount = totalCount + enumEidInfoJunc.Count;
                totalCount = totalCount + enumEidInfoEdge.Count;
                int totalPrompt = ConfigUtil.GetConfigValue("Trace_ResultTotalPrompt", 2000);

                if (totalCount > totalPrompt)
                {
                    if (suppressDialog == false)
                    {
                        DialogResult msgResult = MessageBox.Show(String.Format(A4LGSharedFunctions.Localizer.GetString("TraceResultsCount"), totalCount), A4LGSharedFunctions.Localizer.GetString("Proceed"), MessageBoxButtons.YesNo);
                        if (msgResult == DialogResult.No)
                        {
                            return "";
                        }
                    }
                }

                string returnVal = "";
                returnVal = Globals.SelectJunctions(ref map, ref gn, ref juncEIDs, ref junctionFlag, MeterName, MeterCritField, MeterCritVal, processEvent);
                if (processEvent)
                {
                    if (selectEdges)
                        Globals.SelectEdges(ref map, ref  gn, ref edgeEIDs);
                    else
                        Globals.DrawEdges(ref map, ref  gn, ref edgeEIDs);
                }
                mergedLines = Globals.MergeEdges(ref map, ref  gn, ref edgeEIDs, ref mainsFL, out lineOIDs);

                returnVal = Globals.SelectValveJunctions(ref map, ref hasSourceValveHT, ref valveFLs, processEvent) + "_" + returnVal;

                if (processEvent)
                {

                    Globals.GetCommand("esriArcMapUI.ZoomToSelectedCommand", app).Execute();

                }
                if (addResultsAsLayer)
                {

                    Globals.TraceResultsToLayer(ref app, ref  gn, ref enumEidInfoJunc, ref enumEidInfoEdge, ref hasSourceValveHT, ref valveFLs);

                }
                ((IMxDocument)app.Document).UpdateContents();
                return returnVal;
            }
            catch (Exception ex)
            {
                // MessageBox.Show(ex.ToString());
                return ex.Message.ToString() + "\n" + pointAlong;

            }
            finally
            {

                if (processEvent)
                {

                    pStepPro.Message = A4LGSharedFunctions.Localizer.GetString("Complete");
                    pStepPro.Step();

                }

                barrierIds = null;
                sourceDirectEIDInfoHT = null;
                netFlag1 = null;
                netFlag2 = null;
                junctionFlags = null;
                edgeFlags = null;
                pID = null;
                noSourceValveHT = null;
                hasSourceValveHT = null;

                if (pProDlg != null)
                {

                    pProDlg.HideDialog();
                }
                pStepPro = null;
                pProDlg = null;
                pProDFact = null;

                if (gnList != null)
                {
                    //   Marshal.ReleaseComObject(gnList);
                }
                if (gn != null)
                {
                    Marshal.ReleaseComObject(gn);
                }
                if (snappedPoint != null)
                {
                    Marshal.ReleaseComObject(snappedPoint);
                }
                if (startNetFlag != null)
                {
                    //   Marshal.ReleaseComObject(startNetFlag);
                }
                if (sourceFC != null)
                {

                    //  Marshal.ReleaseComObject(sourceFC);
                }
                if (sourceFL != null)
                {
                    //  Marshal.ReleaseComObject(sourceFL);
                }
                if (pTempLay != null)
                {
                    Marshal.ReleaseComObject(pTempLay);
                }
                if (valveFLs != null)
                {
                    // Marshal.ReleaseComObject(valveFLs);
                }
                if (valveFCs != null)
                {
                    // Marshal.ReleaseComObject(valveFCs);
                }
                //if (meterFL != null)
                //{
                //    Marshal.ReleaseComObject(meterFL);
                //}
                if (junctionFlag != null)
                {
                    // Marshal.ReleaseComObject(junctionFlag);
                }
                if (edgeFlag != null)
                {
                    // Marshal.ReleaseComObject(edgeFlag);
                }
                if (traceFlowSolver != null)
                {
                    Marshal.ReleaseComObject(traceFlowSolver);
                }
                if (netSolver != null)
                {
                    Marshal.ReleaseComObject(netSolver);
                }
                if (netElementBarriers != null)
                {
                    Marshal.ReleaseComObject(netElementBarriers);
                }
                if (nb != null)
                {
                    Marshal.ReleaseComObject(nb);
                }
                if (juncEIDs != null)
                {
                    Marshal.ReleaseComObject(juncEIDs);
                }
                if (edgeEIDs != null)
                {
                    Marshal.ReleaseComObject(edgeEIDs);
                }
                if (eidInfo != null)
                {
                    Marshal.ReleaseComObject(eidInfo);
                }
                if (valveEIDInfo != null)
                {
                    Marshal.ReleaseComObject(valveEIDInfo);
                }
                if (sourceEIDInfo != null)
                {
                    Marshal.ReleaseComObject(sourceEIDInfo);
                }
                if (enumEidInfoJunc != null)
                {
                    Marshal.ReleaseComObject(enumEidInfoJunc);
                }
                if (enumEidInfoEdge != null)
                {
                    Marshal.ReleaseComObject(enumEidInfoEdge);
                }

                if (vEIDInfo != null)
                {
                    Marshal.ReleaseComObject(vEIDInfo);
                }
                if (userIds != null)
                {
                    // Marshal.ReleaseComObject(userIds);
                }
                if (eidHelper != null)
                {
                    Marshal.ReleaseComObject(eidHelper);
                }
                if (valveEIDInfoHT != null)
                {
                    //  Marshal.ReleaseComObject(valveEIDInfoHT);
                }
                if (sourceEIDInfoHT != null)
                {
                    //  Marshal.ReleaseComObject(sourceEIDInfoHT);
                }
                if (segCosts != null)
                {
                    //  Marshal.ReleaseComObject(segCosts);
                }
                if (netElementBarrier != null)
                {
                    Marshal.ReleaseComObject(netElementBarrier);
                }
                //if (traceRes != null)
                //{
                //    traceRes.Dispose();
                //    // Marshal.ReleaseComObject(traceRes);
                //}

                pNetAnalysisExt = null;
                pFlagsDisplay = null;
                pEdgeFlags = null;
                pJunctionFlags = null;
                pNetFlags = null;
                pFlagDisplay = null;
                //pEdgeFlagsBar = null;
                //pJunctionFlagsBar = null;

                gnList = null;

                gn = null;
                snappedPoint = null;

                startNetFlag = null;

                sourceFC = null;
                sourceFL = null;

                pTempLay = null;
                valveFLs = null;
                valveFCs = null;
                //meterFL = null;

                junctionFlag = null;
                edgeFlag = null;
                traceFlowSolver = null;
                netSolver = null;
                netElementBarriers = null;
                nb = null;
                juncEIDs = null;
                edgeEIDs = null;
                eidInfo = null;
                valveEIDInfo = null;
                sourceEIDInfo = null;
                vEIDInfo = null;
                userIds = null;

                eidHelper = null;
                valveEIDInfoHT = null;
                sourceEIDInfoHT = null;
                segCosts = null;
                netElementBarrier = null;

                //traceRes = null;
            }
            GC.Collect();
            GC.WaitForFullGCComplete(300);
        }