示例#1
0
        private List<Section> GetSections(ContactSimple inCnt, string curName)
        {
            List<ContactSimple> nebors = new List<ContactSimple>();
            List<ContactSimple> neborsFst = inCnt.GetAnyNeborPoints();

            int start = neborsFst.FindIndex(el => GetAnyPoint(el).name == curName);
            int end = neborsFst.FindIndex(el => GetAnyPoint(el).name != curName);

            //if (b && ((end < 0) || (end == 0 && start < 0)))
            //	b = true;
            /*foreach (ContactSimple cnt in neborsFst)
            {
                if (cnt.x == 39 && cnt.y == 14 && cnt.layer == 1)
                {
                    NodePoint pn = GetPoint(cnt);
                    if (pn.name == Material.blankName)
                        b = false;
                }
            }*/

            /*if (end < 0)
                return CheckBigArea(inCnt);//true
            if (end == 0 && start < 0 && (!IsBridge(inCnt)))
                return true;*/
            int start2 = 0;
            if (end >= 0)
                start2 = neborsFst.FindIndex(end, el => GetAnyPoint(el).name == curName);
            /*if (end == 0 && start > 0)
            {
                end = neborsFst.FindIndex(start, el => GetAnyPoint(el).name == curName);
                start2 = neborsFst.FindIndex(end, el => GetAnyPoint(el).name == curName);
            }
            else//
            if (end == 0 && end < start)
            {
                nebors.AddRange(neborsFst.GetRange(start, neborsFst.Count - start));
                nebors.AddRange(neborsFst.GetRange(0, start));
            }
            else*/
            if (end < start2)
            {
                nebors.AddRange(neborsFst.GetRange(start2, neborsFst.Count - start2));
                nebors.AddRange(neborsFst.GetRange(0, start2));
            }
            else
                nebors = neborsFst;

            List<Section> sections = new List<Section>();
            List<PairInt> oneSection = new List<PairInt>();
            bool sectEnd = true;
            bool isSection = false;

            for (int i = 0; i < nebors.Count; i++)
            {
                if ((nebors[i].y < Params.topEdge) && (nebors[i].x < wide) &&
                    (nebors[i].y >= 0) && (nebors[i].x >= 0) &&
                    (GetPoint(nebors[i]).name == curName))
                {
                    if (sectEnd)
                    {
                        oneSection.Clear();
                        isSection = false;
                    }
                    if (nebors[i].x == inCnt.x || nebors[i].y == inCnt.y)
                        isSection = true;
                        //sections.Add(new Section());
                    //sections[sectCount].points.Add(nebors[i]);
                    oneSection.Add(new PairInt(nebors[i]));
                    sectEnd = false;
                }
                else if (!sectEnd)
                {
                    sectEnd = true;
                    if (isSection)
                    {
                        sections.Add(new Section(oneSection));
                        isSection = false;
                    }
                }
            }
            if (isSection)
                sections.Add(new Section(oneSection));

            return sections;
        }
示例#2
0
        /*private void SetPoint_old(PairInt inCnt)
        {
            bool replased = false;
            foreach (int curLayer in Params.UsedLayers)
                if (GetPoint(inCnt, curLayer).isReplace)
                    replased = true;
            if (!replased)
                return;
            //if ((!GetPoint(inCnt, Layers.metal1Trace).isReplace) &&
              // (!GetPoint(inCnt, Layers.siliconTrace).isReplace))
              //  return;

            bool b;
            if (inCnt.x == 20 && inCnt.y == 16 )
                b = false;

            List<NodePoint> best = GetBest_old(inCnt);
            NodePoint bestPoint = best[0];
            NodePoint bestMet1 = best[1];
            NodePoint bestSil = best[2];

            if (diffusionExeption.FindIndex(el => el == bestPoint.name) >= 0)
            {
                SetPointWithExept(inCnt, best);
                return;
            }

            if (bestPoint == bestMet1)
            {
                bool useBestPoint = false;
                if (GetPoint(inCnt, Layers.metal1Trace).isReplace)
                {
                    if (SetOneOfBest_old(inCnt, Layers.metal1Trace, bestPoint) &&
                        GetPoint(inCnt, Layers.contactTrace).name != Material.diffusionName &&
                        IsJumpAble(inCnt, Layers.siliconTrace) &&
                        SetOneOfBest_old(inCnt, Layers.siliconTrace, bestPoint))
                        useBestPoint = true;
                }
                if (!useBestPoint)
                    SetOneOfBest_old(inCnt, Layers.siliconTrace, bestSil);
            }
            else
            {
                bool useBestPoint = false;
                if (GetPoint(inCnt, Layers.siliconTrace).isReplace)
                {
                    if (SetOneOfBest_old(inCnt, Layers.siliconTrace, bestPoint) &&
                        GetPoint(inCnt, Layers.contactTrace).name != Material.diffusionName &&
                        IsJumpAble(inCnt, Layers.metal1Trace) &&
                        SetOneOfBest_old(inCnt, Layers.metal1Trace, bestPoint))
                        useBestPoint = true;
                }
                if (!useBestPoint)
                    SetOneOfBest_old(inCnt, Layers.metal1Trace, bestMet1);
            }
        }*/
        private void SetPoint(PairInt inCnt)
        {
            bool replased = false;

            foreach (int curLayer in Params.UsedLayers)
                if (GetPoint(inCnt, curLayer).isReplace)
                    replased = true;
            if (!replased)
                return;

            //if (inCnt.x == 12 && inCnt.y == 24 &&  (AddingSpace(layoutMap[13][24][Layers.metal2Trace].name) == "66204"))
            //	replased = true;
            bool b = false;
            if (inCnt.x == 27 && inCnt.y == 17 )//"N6859613")
                b = false;

            List<BestPointSet> best = GetBest(inCnt);
            List<int> closedLayers = new List<int>();
            if (Params.UsedLayers.Count > 2)
                best = SortBestPoints(best);

            if ( inCnt.x == 14 && (inCnt.y == 38) )// || inCnt.y == 37) )
            {
                ContactSimple tmp = new ContactSimple(inCnt, 0);
                List<ContactSimple> tp = tmp.GetAnyNeborPoints();
                List<NodePoint> p = new List<NodePoint> ();
                foreach(ContactSimple t in tp)
                    p.Add(GetPoint(t));
                p.Add(GetPoint(tmp));
            }

            foreach (BestPointSet bestPoint in best)
            {
                if ((!bestPoint.isOneLayer) && (closedLayers.FindIndex(el => el == bestPoint.point.layer) < 0))
                {
                    if (diffusionException.FindIndex(el => el == bestPoint.point.name) >= 0)
                    {
                        if (Params.IsDiffusExeptionLayer(bestPoint.point.layer))
                        {
                            SetOneOfBest(inCnt, bestPoint.point.layer, bestPoint.point);
                            closedLayers.Add(bestPoint.point.layer);
                        }
                    }
                    else
                    {
                        if (SetOneOfBest(inCnt, bestPoint.point.layer, bestPoint.point))
                        {
                            foreach (int related in Params.LayersRange[bestPoint.point.layer])
                            {
                                if ((related != bestPoint.point.layer) &&
                                    IsDiffusionLimit(inCnt, related, bestPoint.point.layer) &&
                                    IsJumpAble(inCnt, related) &&
                                    SetOneOfBest(inCnt, related, bestPoint.point))
                                    closedLayers.Add(related);
                            }
                        }
                        else
                        {
                            foreach (int lay in  DefineSameLayers(inCnt, bestPoint, best))
                            {
                                if (SetOneOfBest(inCnt, lay, bestPoint.point))
                                {
                                    foreach (int related in Params.LayersRange[lay])
                                    {
                                        if ((related != lay) &&
                                            IsDiffusionLimit(inCnt, related, lay) &&
                                            IsJumpAble(inCnt, related) &&
                                            SetOneOfBest(inCnt, related, bestPoint.point))
                                            closedLayers.Add(related);
                                    }
                                }
                            }
                        }
                        closedLayers.Add(bestPoint.point.layer);
                    }
                }
            }
            foreach (BestPointSet bestPoint in best)
            {
                if ((bestPoint.isOneLayer) && (closedLayers.FindIndex(el => el == bestPoint.point.layer) < 0))
                {
                    SetOneOfBest(inCnt, bestPoint.point.layer, bestPoint.point);
                }
            }
        }
示例#3
0
        private bool CheckNebors(ContactSimple inCnt)
        {
            List<NodePoint> ndPns = new List<NodePoint>();
            bool returnValue = true;

            string curName = layoutMap[inCnt.x][inCnt.y][inCnt.layer].name;

            List<NodePoint> neborsN = new List<NodePoint>();
            List<NodePoint> neborsOpposN = new List<NodePoint>();

            bool b = false;
            /*if (inCnt.x == 21  && inCnt.y == 39 &&
                inCnt.layer == Layers.metal1Trace && curName == "N6864112")//"N6866204")//"N6862737")//"N6859613")
                b = false;
            /*
            b = false;
            if (inCnt.x == 39 && inCnt.y == 14)
                b = false;*/
            if (inCnt.x == 29 && inCnt.y == 38 &&
                inCnt.layer == Layers.siliconTrace && curName == "INC")
            {
                foreach (int lay in Params.UsedLayers)
                {
                    foreach (ContactSimple cs in inCnt.GetAnyNeborPoints())
                    {
                        neborsN.Add(GetPoint(cs, lay));
                    }
                    neborsN.Add(GetPoint(inCnt, lay));
                }
                //neborsOpposN.Add(GetOppositePoint(inCnt));
                b=true;
            }

            if (curName == Material.blankName)
                return true;
            if ((curName == Material.diffusionName) &&
                (layoutMap[inCnt.x][inCnt.y][Layers.contactTrace].name == Material.diffusionName))
                return false;
            if (GetPoint(inCnt).isSource && !(FindSource(inCnt)))
                return false;
            if (GetPoint(inCnt).isFixed)
                return false;

            List<Section> sections = GetSections(inCnt, curName);

            /*if (end < 0)
                return CheckBigArea(inCnt);//true
            if (end == 0 && start < 0 && (!IsBridge(inCnt)))
                return true;*/
            if (sections.Count <= 1)
                returnValue = !IsBridge2(sections, inCnt, inCnt.layer, curName);//!!!!!!
            else
            {
                List<PairInt> area = ((PairInt)inCnt).GetAnyNeborPoints();//new List<PairInt>(nebors);
                area.Add(inCnt);
                //returnValue = IsSectionsConnected(sections, area, related, curName);
                foreach (int related in Params.LayersRange[inCnt.layer])
                {
                    if (related != inCnt.layer)
                        returnValue = IsSectionsConnected(sections, area, inCnt.layer, related, curName);//CheckRelatePoint(nebors, curName, related);
                    if (!returnValue)
                        break;
                }
            }

            //if (!returnValue && b)
            //	b = true;
            //bool diffus = ((nebors[0].layer == Layers.metal1Trace) && (opposLayer == Layers.siliconTrace)) ||
                //((nebors[0].layer == Layers.siliconTrace) && (opposLayer == Layers.metal1Trace));

            //if (returnValue && IsBridge(inCnt))//(Params.UsedLayers.Count == 2) &&
              //  returnValue = false;

            bool isCheckBigArea = true;
            if (returnValue)
            {
                foreach (int lay in Params.LayersRange[inCnt.layer])
                {
                    if ((lay != inCnt.layer) && (GetPoint(inCnt, lay).name == curName))
                        isCheckBigArea = false;
                }
            }

            if (returnValue && isCheckBigArea)//(GetPoint(inCnt, opposLayer).name != curName))
                returnValue = CheckBigArea(inCnt);
            /*
            if (returnValue && ((inCnt.x == 22 && inCnt.y == 47 && inCnt.layer == Layers.siliconTrace) ||
                                (inCnt.x == 21 && inCnt.y == 46 && inCnt.layer == Layers.siliconTrace)) &&
                  curName == "INC")
                b = true;*/

            if (returnValue && inCnt.x == 20  && inCnt.y == 38 &&
                inCnt.layer == Layers.siliconTrace && curName == "N6864112")//"N6859613")
                b = false;
            return returnValue;
        }