Example #1
0
        public static LevelDictionary <PointDrift> GetDesignBoundaryCornerDrifts(LevelDataDictionary <RigidAnalysis> analyses)
        {
            var drifts = new LevelDictionary <PointDrift>();

            List <BuildingLevelLateral2> sortedLevels =
                analyses.Select(l => l.Value.LateralLevel).OrderBy(l => l.Level.Elevation).ToList();

            for (var i = 0; i < sortedLevels.Count; i++)
            {
                BuildingLevel level = sortedLevels[i].Level;

                RigidAnalysis analysis = analyses[level];

                List <PointDrift> driftsAtLevel =
                    DisplacementsWithUnknownDrifts(level, analysis.Responses.NodalLoadCaseResults.Values.SelectMany(r => r));

                var storyHeight = sortedLevels[i].Height;

                if (i == 0)
                {
                    // Lowest level; compare to ground
                    driftsAtLevel.ForEach(d =>
                    {
                        d.Drift             = (Unitless)Result.Abs(d.Displacement / storyHeight);
                        d.CoordinateBelow   = d.Coordinate;
                        d.DisplacementBelow = new Length(0, LengthUnit.Inch);
                    });
                }
                else
                {
                    // Elevated level; compare to level below
                    List <PointDrift> driftsAtLevelBelow = drifts[sortedLevels[i - 1].Level];

                    driftsAtLevel.ForEach(d =>
                    {
                        PointDrift driftBelow = d.GetMatchingDriftAtLevelBelow(driftsAtLevelBelow);

                        d.Drift             = (Unitless)Result.Abs((d.Displacement - driftBelow.Displacement) / storyHeight);
                        d.CoordinateBelow   = driftBelow.Coordinate;
                        d.DisplacementBelow = driftBelow.Displacement;
                    });
                }

                drifts.Add(level, driftsAtLevel);
            }

            return(drifts);
        }
        // Assumes that the centers of mass stack vertically, so we can apply the design story shear directly
        public List <LateralLevelForce> GenerateAppliedLoadingAtLevel(BuildingLevelLateral2 lateralLevel)
        {
            var loads = new List <LateralLevelForce>();

            BuildingLevel level        = lateralLevel.Level;
            Point2D       CenterOfMass = lateralLevel.CenterOfMass;

            SeismicStoryForce storyShears = _storyShears[level];

            // Calculate direct seismic forces
            loads.Add(new LateralLevelForce
            {
                Level         = level,
                DirectX       = storyShears.X,
                LoadPattern   = LoadPattern.Seismic_East,
                CenterOfForce = CenterOfMass
            });

            loads.Add(new LateralLevelForce
            {
                Level         = level,
                DirectX       = (Force)(-storyShears.X),
                LoadPattern   = LoadPattern.Seismic_West,
                CenterOfForce = CenterOfMass
            });

            loads.Add(new LateralLevelForce
            {
                Level         = level,
                DirectY       = storyShears.Y,
                LoadPattern   = LoadPattern.Seismic_North,
                CenterOfForce = CenterOfMass
            });

            loads.Add(new LateralLevelForce
            {
                Level         = level,
                DirectY       = (Force)(-storyShears.Y),
                LoadPattern   = LoadPattern.Seismic_South,
                CenterOfForce = CenterOfMass
            });

            // Calculate accidental seismic forces
            Length lengthX = lateralLevel.LengthX;
            Length lengthY = lateralLevel.LengthY;
            AccidentalEccentricities eccentricities = lateralLevel.Eccentricities;

            loads.Add(new LateralLevelForce
            {
                Level         = level,
                AccidentalT   = (Moment)Result.Abs(eccentricities.SeismicX * lengthY * storyShears.X),
                LoadPattern   = LoadPattern.SeismicTorsion_XLoading,
                CenterOfForce = CenterOfMass
            });

            loads.Add(new LateralLevelForce
            {
                Level         = level,
                AccidentalT   = (Moment)Result.Abs(eccentricities.SeismicY * lengthX * storyShears.Y),
                LoadPattern   = LoadPattern.SeismicTorsion_YLoading,
                CenterOfForce = CenterOfMass
            });

            return(loads);
        }