Пример #1
0
 public void ApplyPointLoadsByPattern(string patternName)
 {
     foreach (sNode sn in this.nodes)
     {
         StatNode stn = sn.extraData as StatNode;
         if (stn != null)
         {
             if (sn.pointLoads != null && sn.pointLoads.Count > 0)
             {
                 sXYZ load = sXYZ.Zero();
                 //sXYZ moment = sXYZ.Zero();
                 foreach (sPointLoad pl in sn.pointLoads)
                 {
                     if (pl.loadPatternName == patternName)
                     {
                         load += pl.forceVector;
                         //moment += pl.momentVector;
                         //currently StatSystem cannot do moment load
                     }
                 }
                 if (load.GetLength() > 0.0)
                 {
                     stn.AddLoad(load.X, load.Y, load.Z);
                 }
             }
         }
     }
 }
Пример #2
0
        private void BuildFESystem()
        {
            this.FEsystem = new StatSystem();
            this.FEsystem.PointMergeTolerance = this.systemSettings.mergeTolerance_m;

            this.FEsystem.MergeNewNodes = true;

            sStatConverter conv = new sStatConverter();

            foreach (IFrameSet bs in this.frameSets)
            {
                foreach (sFrame b in bs.frames)
                {
                    StatCrossSection cs = conv.ToStatCrossSection(b, bs.AsMinuteDensity);

                    StatNode n0 = this.FEsystem.AddNode(conv.ToCVector(b.node0));
                    StatNode n1 = this.FEsystem.AddNode(conv.ToCVector(b.node1));

                    C_vector uv = conv.ToCVector(b.upVector);

                    StatBeam sb = this.FEsystem.AddBeam(n0, n1, cs, uv);

                    b.extraData  = sb;
                    sb.ExtraData = b;
                }
            }

            foreach (sNode sn in this.nodes)
            {
                StatNode n = null;
                if (sn.boundaryCondition != null)
                {
                    //n = this.FEsystem.AddNode(sn.location.X, sn.location.Y, sn.location.Z);
                    n = FindStatNode(sn, this.systemSettings.mergeTolerance_m);
                    if (sn.boundaryCondition.supportType == eSupportType.FIXED)
                    {
                        n.SupportType = BOUNDARYCONDITIONS.ALL;
                    }
                    else if (sn.boundaryCondition.supportType == eSupportType.PINNED)
                    {
                        n.SupportType = BOUNDARYCONDITIONS.TRANSLATIONS;
                    }
                    else if (sn.boundaryCondition.supportType == eSupportType.CUSTOM)
                    {
                    }
                }

                if (sn.pointLoads != null && sn.pointLoads.Count > 0)
                {
                    n = FindStatNode(sn, this.systemSettings.mergeTolerance_m);
                }

                if (n != null)
                {
                    sn.extraData = n;
                    n.ExtraData  = sn;
                }
            }
        }
 public StatMismatchWarning(int line, StatNode expected, StatNode actual, string message = "Statements differ")
 {
     if (expected.Equals(actual))
     {
         throw new ArgumentException("Expected different objects");
     }
     this.Expected = expected;
     this.Actual   = actual;
     this.Message  = message;
     this.Line     = line;
 }
Пример #4
0
        public override ASTNode VisitLabeledStatement([NotNull] LabeledStatementContext ctx)
        {
            if (ctx.Identifier() is null)
            {
                throw new NotImplementedException();
            }

            string   label     = ctx.Identifier().GetText();
            StatNode statement = this.Visit(ctx.statement()).As <StatNode>();

            return(new LabeledStatNode(ctx.Start.Line, label, statement));
        }
Пример #5
0
        public void ApplyPointLoadsByCombo(string comboName, ref double deadFactor)
        {
            sLoadCombination combo = GetLoadComboByName(comboName);

            //double Dfactor = 0.0;

            foreach (sNode sn in this.nodes)
            {
                StatNode stn = sn.extraData as StatNode;
                if (stn != null)
                {
                    if (sn.pointLoads != null && sn.pointLoads.Count > 0)
                    {
                        sPointLoad comboLoad = new sPointLoad();
                        if (combo.combinationType == eCombinationType.LinearAdditive)
                        {
                            for (int i = 0; i < combo.patterns.Count; ++i)
                            {
                                string pattern = combo.patterns[i];
                                double factor  = combo.factors[i];

                                if (pattern != "DEAD")
                                {
                                    sn.UpdatePointLoadByPatternFactor_LinearAdditive(pattern, factor, ref comboLoad);
                                }
                                else
                                {
                                    deadFactor = factor;
                                }
                            }
                        }
                        //else what?

                        if (comboLoad.forceVector != null || comboLoad.momentVector != null)
                        {
                            //need to reset node load????????????????
                            comboLoad.location = sn.location;
                            if (comboLoad.forceVector != null)
                            {
                                stn.AddLoad(comboLoad.forceVector.X, comboLoad.forceVector.Y, comboLoad.forceVector.Z);

                                object t = stn;
                            }
                            if (comboLoad.momentVector != null)
                            {
                                stn.AddLoad(comboLoad.momentVector.X, comboLoad.momentVector.Y, comboLoad.momentVector.Z);
                            }
                        }
                    }
                }
            }
        }
Пример #6
0
        private void CGStat(FuncInfo funcInfo, StatNode node)
        {
            switch (node.Type)
            {
            case GrammarNodeType.FunctionCallStat:
                CGFuncCallStat(funcInfo, node as FuncCallStatNode);
                break;

            case GrammarNodeType.BreakStat:
                int pc = funcInfo.EmitJMP(0, 0);
                funcInfo.AddBreakJmp(pc);
                break;

            case GrammarNodeType.DoStat:
                CGDoStat(funcInfo, node as DoStatNode);
                break;

            case GrammarNodeType.RepeatStat:
                CGRepeatStat(funcInfo, node as RepeatStatNode);
                break;

            case GrammarNodeType.WhileStat:
                CGWhileStat(funcInfo, node as WhileStatNode);
                break;

            case GrammarNodeType.ForInStat:
                CGWhileStat(funcInfo, node as WhileStatNode);
                break;

            case GrammarNodeType.IfStat:
                CGIfStat(funcInfo, node as IfStatNode);
                break;

            case GrammarNodeType.ForNumStat:
                CGForNumStat(funcInfo, node as ForNumStatNode);
                break;

            case GrammarNodeType.LocalVarDecStat:
                CGLocalVarDefStat(funcInfo, node as LocalVarDecStatNode);
                break;

            case GrammarNodeType.LocalFuncDefStat:
                CGLocalFuncDefStat(funcInfo, node as LoacalFuncDefStatNode);
                break;

            case GrammarNodeType.AssignStat:
                CGAssignStat(funcInfo, node as AssignStatNode);
                break;
            }
        }
Пример #7
0
        public StatNode FindStatNode(sNode jn, double tol)
        {
            StatNode clnode = null;

            foreach (StatNode n in this.FEsystem.Nodes)
            {
                C_vector jv = new C_vector(jn.location.X, jn.location.Y, jn.location.Z);
                if (jv.DistanceTo(n.p) < tol)
                {
                    clnode = n;
                    break;
                }
            }

            return(clnode);
        }
Пример #8
0
        public override ASTNode VisitSelectionStatement([NotNull] SelectionStatementContext ctx)
        {
            switch (ctx.children.First().GetText())
            {
            case "if":
                ExprNode           condition     = this.Visit(ctx.expression()).As <ExprNode>();
                StatementContext[] statements    = ctx.statement();
                StatNode           thenStatement = this.Visit(statements.First()).As <StatNode>();
                StatNode?          elseStatement = statements.Length > 1 ? this.Visit(statements.Last()).As <StatNode>() : null;
                return(elseStatement is null
                        ? new IfStatNode(ctx.Start.Line, condition, thenStatement)
                        : new IfStatNode(ctx.Start.Line, condition, thenStatement, elseStatement));

            case "switch":
                throw new NotImplementedException("switch");

            default:
                throw new SyntaxErrorException("Unknown construct", ctx.Start.Line, ctx.Start.Column);
            }
        }
Пример #9
0
        public override ASTNode VisitIterationStatement([NotNull] IterationStatementContext ctx)
        {
            IterStatNode it;
            StatNode     statement = this.Visit(ctx.statement()).As <StatNode>();

            if (ctx.For() is { })
Пример #10
0
 public ForNode(IDNode id, TypeNode type, int from, int to, StatNode stat, LexLocation location)
 {
     ID = id; Type = type; From = from; To = to; Statement = stat; Location = location;
 }
Пример #11
0
 public LoopNode(ExprNode count, StatNode stat, LexLocation location)
 {
     Count = count; Statement = stat; Location = location;
 }
Пример #12
0
 public void AddStatement(StatNode node)
 {
     Statements.Add(node);
 }
Пример #13
0
 public BlockNode(StatNode node, LexLocation location)
 {
     Statements.Add(node); Location = location;
 }