//
// (C) Copyright 2003-2013 by Autodesk, Inc.
//
// Permission to use, copy, modify, and distribute this software in
// object code form for any purpose and without fee is hereby granted,
// provided that the above copyright notice appears in all copies and
// that both that copyright notice and the limited warranty and
// restricted rights notice below appear in all supporting
// documentation.
//
// AUTODESK PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS.
// AUTODESK SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE. AUTODESK, INC.
// DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE
// UNINTERRUPTED OR ERROR FREE.
//
// Use, duplication, or disclosure by the U.S. Government is subject to
// restrictions set forth in FAR 52.227-19 (Commercial Computer
// Software - Restricted Rights) and DFAR 252.227-7013(c)(1)(ii)
// (Rights in Technical Data and Computer Software), as applicable.
//

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Autodesk.Revit.DB.CodeChecking.Engineering;
using Autodesk.Revit.DB.CodeChecking.Engineering.Tools;
using Autodesk.CodeChecking.Concrete;
using CodeCheckingConcreteExample.Engine;
using CodeCheckingConcreteExample.Concrete;
using CodeCheckingConcreteExample.Properties;
using CodeCheckingConcreteExample.ConcreteTypes;
using Autodesk.Revit.DB.ExtensibleStorage.Framework.Documentation;
using CodeCheckingConcreteExample.Utility;
using Autodesk.Revit.DB;
using Autodesk.Revit.DB.CodeChecking.Storage;

namespace CodeCheckingConcreteExample.Main.Calculation
{
   /// <summary>
   /// Represents user's calculation object which fills cref="Result" with data.
   /// </summary>
   public class FillResultData : ICalculationObject
   {
      #region ICalculationObject Members

      /// <summary>
      /// Runs calculation\operations for cref="BeamElement" and cref="ColumnElement".
      /// </summary>
      /// <param name="obj">cref="BeamElement" object or cref="ColumnElement" object.</param>
      /// <returns>Result of calculation.</returns>
      public bool Run(ObjectDataBase obj)
      {
         ElementDataBase elementData = obj as ElementDataBase;
         if (obj != null)
         {
            switch (elementData.Category)
            {
               default:
                  break;
               case Autodesk.Revit.DB.BuiltInCategory.OST_ColumnAnalytical:
               case Autodesk.Revit.DB.BuiltInCategory.OST_BeamAnalytical:
                  if (elementData.Result is ResultLinearElement)
                  {
                     CodeCheckingConcreteExample.Main.ResultLinearElement res = elementData.Result as ResultLinearElement;
                     if (res != null)
                     {
                        elementData.ListSectionData.ForEach(s => res.ValuesInPointsData.AddRange((s as LinearSection).GetCalcResultsInPoint().DataRaw));
                     }

                     UnitType xUnitType = ResultTypeLinear.X.GetUnitType();
                     DisplayUnitType xInternalDisplayUnitType = UnitsConverter.GetInternalUnit(xUnitType);
                     
                     // add info
                     IEnumerable<IGrouping<String, Tuple<String, Double>>> infoInSec = elementData.ListSectionData.
                        SelectMany(lsd => (lsd as LinearSection).DesignInfo.Select(dw => new Tuple<String, Double>(dw, (lsd.CalcPoint as CalcPointLinear).CoordAbsolute))).
                        GroupBy(s => s.Item1);

                     // add warnings
                     IEnumerable<IGrouping<String, Tuple<String, Double>>> warningsInSec = elementData.ListSectionData.
                        SelectMany(lsd => (lsd as LinearSection).DesignWarning.Select(dw => new Tuple<String, Double>(dw, (lsd.CalcPoint as CalcPointLinear).CoordAbsolute))).
                        GroupBy(s => s.Item1);

                     // add errors
                     IEnumerable<IGrouping<String, Tuple<String, Double>>> errosInSec = elementData.ListSectionData.
                        SelectMany(lsd => (lsd as LinearSection).DesignError.Select(dw => new Tuple<String, Double>(dw, (lsd.CalcPoint as CalcPointLinear).CoordAbsolute))).
                        GroupBy(s => s.Item1);

                     if (errosInSec.Count() > 0)
                     {
                        getResultStatusMessageLinear(errosInSec, xInternalDisplayUnitType, false, elementData.ListSectionData.Count).ForEach(s => elementData.AddFormatedError(s));
                        elementData.Status.Status = Status.Failed;
                     }
                     else
                     {
                        if (warningsInSec.Count() > 0)
                        {
                           getResultStatusMessageLinear(warningsInSec, xInternalDisplayUnitType, true, elementData.ListSectionData.Count).ForEach(s => elementData.AddFormatedWarning(s));
                           if (Status.Failed != elementData.Status.Status)
                              elementData.Status.Status = Status.Warning;
                        }
                        if (infoInSec.Count() > 0)
                        {
                           getResultStatusMessageLinear(infoInSec, xInternalDisplayUnitType, true, elementData.ListSectionData.Count).ForEach(s => elementData.AddFormatedInfo(s));
                        }
                     } 
                     if (Autodesk.Revit.DB.CodeChecking.Storage.Status.Undefined == elementData.Status.Status)
                        elementData.Status.Status = Autodesk.Revit.DB.CodeChecking.Storage.Status.Succeed;
                  }
                  break;
               /// <structural_toolkit_2015>
               case Autodesk.Revit.DB.BuiltInCategory.OST_FloorAnalytical:
               case Autodesk.Revit.DB.BuiltInCategory.OST_FoundationSlabAnalytical:
               case Autodesk.Revit.DB.BuiltInCategory.OST_WallAnalytical:
                  if (elementData.Result is CodeCheckingConcreteExample.Main.ResultSurfaceElement)
                  {
                     CodeCheckingConcreteExample.Main.ResultSurfaceElement res = elementData.Result as CodeCheckingConcreteExample.Main.ResultSurfaceElement;
                     if (res != null)
                     {
                        foreach (SectionDataBase sd in elementData.ListSectionData)
                        {
                           SurfaceSection sec = sd as SurfaceSection;
                           if (sec != null)
                              res.ValuesInPointsData.AddRange(sec.GetCalcResultsInPt().DataRaw);
                        }
                        res.ClearStructuralLayers();
                        if (elementData is FloorElement)
                        {
                           FloorElement elem = elementData as FloorElement;
                           res.MultiLayer = (elem.Info.Slabs.AsElement.Layers.Count() != 1);
                           res.AddStructuralLayer(elem.Info.Material.Properties.Name, elem.Info.Slabs.AsElement.StructuralLayer().Thickness);
                        }
                        if (elementData is WallElement)
                        {
                           WallElement elem = elementData as WallElement;
                           res.MultiLayer = (elem.Info.Walls.AsElement.Layers.Count() != 1);
                           res.AddStructuralLayer(elem.Info.Material.Properties.Name, elem.Info.Walls.AsElement.StructuralLayer().Thickness);
                        }
                     }
                     UnitType xUnitType = ResultTypeLinear.X.GetUnitType();
                     DisplayUnitType xInternalDisplayUnitType = UnitsConverter.GetInternalUnit(xUnitType);
                     int itemOnDirection = elementData.ListSectionData.Count();

                     int errorIndexX = elementData.ListSectionData.FindIndex(ss => (ss as SurfaceSection).DesignError[DimensioningDirection.X].Count() > 0);
                     int errorIndexY = elementData.ListSectionData.FindIndex(ss => (ss as SurfaceSection).DesignError[DimensioningDirection.Y].Count() > 0);
                     if (errorIndexX >= 0 || errorIndexY >= 0)
                     {
                        //// add errors
                        if (errorIndexX >= 0)
                        {
                           IEnumerable<IGrouping<String, Tuple<String, XYZ>>> errosInSecX = elementData.ListSectionData.
                              SelectMany(lsd => (lsd as SurfaceSection).DesignError[DimensioningDirection.X].Select(dw => new Tuple<String, XYZ>(dw, (lsd.CalcPoint as CalcPointSurface).Coord))).
                              GroupBy(s => s.Item1);
                           getResultStatusMessageSurface(errosInSecX, xInternalDisplayUnitType, DimensioningDirection.X,elementData.Category, false).ForEach(s => elementData.AddFormatedError(s));

                        }
                        if (errorIndexY >= 0)
                        {
                           IEnumerable<IGrouping<String, Tuple<String, XYZ>>> errosInSecY = elementData.ListSectionData.
                              SelectMany(lsd => (lsd as SurfaceSection).DesignError[DimensioningDirection.Y].Select(dw => new Tuple<String, XYZ>(dw, (lsd.CalcPoint as CalcPointSurface).Coord))).
                              GroupBy(s => s.Item1);
                           getResultStatusMessageSurface(errosInSecY, xInternalDisplayUnitType, DimensioningDirection.Y, elementData.Category, false).ForEach(s => elementData.AddFormatedError(s));
                        }
                     }
                     else
                     {
                        int warningX = elementData.ListSectionData.FindIndex(ss => (ss as SurfaceSection).DesignWarning[DimensioningDirection.X].Count() > 0);
                        int warningY = elementData.ListSectionData.FindIndex(ss => (ss as SurfaceSection).DesignWarning[DimensioningDirection.Y].Count() > 0);
                        if (warningX >= 0 || warningY >= 0)
                        {
                           //// add warnings
                           if (warningX >= 0)
                           {
                              IEnumerable<IGrouping<String, Tuple<String, XYZ>>> warningInSecX = elementData.ListSectionData.
                                 SelectMany(lsd => (lsd as SurfaceSection).DesignWarning[DimensioningDirection.X].Select(dw => new Tuple<String, XYZ>(dw, (lsd.CalcPoint as CalcPointSurface).Coord))).
                                 GroupBy(s => s.Item1);
                              getResultStatusMessageSurface(warningInSecX, xInternalDisplayUnitType, DimensioningDirection.X, elementData.Category, true, itemOnDirection).ForEach(s => elementData.AddFormatedWarning(s));
                           }
                           if (warningX >= 0)
                           {
                              IEnumerable<IGrouping<String, Tuple<String, XYZ>>> warningInSecY = elementData.ListSectionData.
                                 SelectMany(lsd => (lsd as SurfaceSection).DesignWarning[DimensioningDirection.Y].Select(dw => new Tuple<String, XYZ>(dw, (lsd.CalcPoint as CalcPointSurface).Coord))).
                                 GroupBy(s => s.Item1);
                              getResultStatusMessageSurface(warningInSecY, xInternalDisplayUnitType, DimensioningDirection.Y, elementData.Category, true, itemOnDirection).ForEach(s => elementData.AddFormatedWarning(s));
                           }
                        }
                        int infoX = elementData.ListSectionData.FindIndex(ss => (ss as SurfaceSection).DesignInfo[DimensioningDirection.X].Count() > 0);
                        int infoY = elementData.ListSectionData.FindIndex(ss => (ss as SurfaceSection).DesignInfo[DimensioningDirection.Y].Count() > 0);
                        if (infoX >= 0 || infoY >= 0)
                        {
                           //// add infos
                           if (infoX >= 0)
                           {
                              IEnumerable<IGrouping<String, Tuple<String, XYZ>>> infoInSecX = elementData.ListSectionData.
                                 SelectMany(lsd => (lsd as SurfaceSection).DesignInfo[DimensioningDirection.X].Select(dw => new Tuple<String, XYZ>(dw, (lsd.CalcPoint as CalcPointSurface).Coord))).
                                 GroupBy(s => s.Item1);
                              getResultStatusMessageSurface(infoInSecX, xInternalDisplayUnitType, DimensioningDirection.X, elementData.Category, true, itemOnDirection).ForEach(s => elementData.AddFormatedInfo(s));
                           }
                           if (infoY >= 0)
                           {
                              IEnumerable<IGrouping<String, Tuple<String, XYZ>>> infoInSecY = elementData.ListSectionData.
                                 SelectMany(lsd => (lsd as SurfaceSection).DesignInfo[DimensioningDirection.Y].Select(dw => new Tuple<String, XYZ>(dw, (lsd.CalcPoint as CalcPointSurface).Coord))).
                                 GroupBy(s => s.Item1);
                              getResultStatusMessageSurface(infoInSecY, xInternalDisplayUnitType, DimensioningDirection.Y, elementData.Category, true, itemOnDirection).ForEach(s => elementData.AddFormatedInfo(s));
                           }
                        }
                     } 
                     if (Autodesk.Revit.DB.CodeChecking.Storage.Status.Undefined == elementData.Status.Status)
                        elementData.Status.Status = Autodesk.Revit.DB.CodeChecking.Storage.Status.Succeed;
                  }
                  break;
                  /// </structural_toolkit_2015>

            }
         }

         return true;
      }

      /// <summary>
      /// Sets and gets common parameters.
      /// </summary>
      public CommonParametersBase Parameters { get; set; }

      /// <summary>
      /// Gets and sets type of the calculation object.
      /// </summary>
      public CalculationObjectType Type { get; set; }

      /// <summary>
      /// Gets and sets a type of error response of the calculation object.
      /// </summary>
      public ErrorResponse ErrorResponse { get; set; }

      /// <summary>
      /// Gets and sets categories for the calculation object.
      /// </summary>
      public IList<Autodesk.Revit.DB.BuiltInCategory> Categories { get; set; }

      #endregion

      /// <summary>
      /// Creats list of status messages for linear setions cref="LinearSection".
      /// </summary>
      /// <param name="messages">List of messages</param>
      /// <param name="xInternalDisplayUnitType">Type of display unit  as cref="DisplayUnitType"</param>
      /// <param name="detailSecInfo">Messages with information about section position.</param>
      /// <param name="sectionCount">Number of sections.</param>
      /// <returns>List of status messages.for linear element</returns>
      List<ResultStatusMessage> getResultStatusMessageLinear(IEnumerable<IGrouping<String, Tuple<String, Double>>> messages, DisplayUnitType xInternalDisplayUnitType, bool detailSecInfo = true, int sectionCount = 0)
      {
         List<ResultStatusMessage> resultStatusMessages = new List<ResultStatusMessage>();
         foreach (IGrouping<String, Tuple<String, Double>> message in messages)
         {
            ResultStatusMessage msg = new ResultStatusMessage();
            msg.Message.Add(new ResultStatusMessageItem(message.Key));
            if (detailSecInfo)
            {
               msg.Message.Add(new ResultStatusMessageItem(" " + Resources.ResourceManager.GetString("AppliesToSections")));
               if (sectionCount != message.Count())
               {
                  foreach (Tuple<String, Double> s in message)
                  {
                     msg.Message.Add(new ResultStatusMessageItem(UnitType.UT_Length, xInternalDisplayUnitType, (double)s.Item2));
                     msg.Message.Add(new ResultStatusMessageItem("; "));
                  }
               }
               else
               {
                  msg.Message.Add(new ResultStatusMessageItem(" " + Resources.ResourceManager.GetString("AllSections")));
               }
            }
            resultStatusMessages.Add(msg);
         }
         return resultStatusMessages;
      }

      /// <structural_toolkit_2015>

      /// <summary>
      /// Creats list of status messages for surface setions cref="SurfaceSection".
      /// </summary>
      /// <param name="messages">List of messages</param>
      /// <param name="xInternalDisplayUnitType">Type of display unit  as cref="DisplayUnitType"</param>
      /// <param name="direction">Direction of calculation as cref="DimensioningDirection"</param>
      /// <param name="elementType">Type of elemets as cref="Autodesk.Revit.DB.BuiltInCategory"</param>
      /// <param name="detailSecInfo">Messages with information about section position.</param>
      /// <param name="sectionCount">Number of sections.</param>
      /// <returns>List of status messages for surface element</returns>
      List<ResultStatusMessage> getResultStatusMessageSurface(IEnumerable<IGrouping<String, Tuple<String, XYZ>>> messages, DisplayUnitType xInternalDisplayUnitType, DimensioningDirection direction, Autodesk.Revit.DB.BuiltInCategory elementType, bool detailSecInfo = true, int sectionCount = 0)
      {
         List<ResultStatusMessage> resultStatusMessages = new List<ResultStatusMessage>();
         if (messages.Count() > 0)
         {
            ResultStatusMessage msgDirection = new ResultStatusMessage();
            switch (elementType)
            {
               case Autodesk.Revit.DB.BuiltInCategory.OST_WallAnalytical:
                  if (direction == DimensioningDirection.X)
                     msgDirection.Message.Add(new ResultStatusMessageItem(" " + Resources.ResourceManager.GetString("DimensioningDirectionXWall") + ". "));
                  else
                     msgDirection.Message.Add(new ResultStatusMessageItem(" " + Resources.ResourceManager.GetString("DimensioningDirectionYWall") + ". "));
                  break;
               case BuiltInCategory.OST_FloorAnalytical:
               case BuiltInCategory.OST_FoundationSlabAnalytical:
                  if (direction == DimensioningDirection.X)
                     msgDirection.Message.Add(new ResultStatusMessageItem(" " + Resources.ResourceManager.GetString("DimensioningDirectionXFloor") + ". "));
                  else
                     msgDirection.Message.Add(new ResultStatusMessageItem(" " + Resources.ResourceManager.GetString("DimensioningDirectionYFloor") + ". "));
                  break;
               default:
                  break;
            }
            resultStatusMessages.Add(msgDirection);
            foreach (IGrouping<String, Tuple<String, XYZ>> message in messages)
            {
               ResultStatusMessage msg = new ResultStatusMessage();
               msg.Message.Add(new ResultStatusMessageItem(message.Key));
               if (detailSecInfo)
               {
                  msg.Message.Add(new ResultStatusMessageItem(" " + Resources.ResourceManager.GetString("AppliesToSections")));
                  if (sectionCount != message.Count())
                  {
                     foreach (Tuple<String, XYZ> s in message)
                     {
                        msg.Message.Add(new ResultStatusMessageItem("x="));
                        msg.Message.Add(new ResultStatusMessageItem(UnitType.UT_Length, xInternalDisplayUnitType, (double)s.Item2.X));
                        msg.Message.Add(new ResultStatusMessageItem("/y="));
                        msg.Message.Add(new ResultStatusMessageItem(UnitType.UT_Length, xInternalDisplayUnitType, (double)s.Item2.Y));
                        msg.Message.Add(new ResultStatusMessageItem("; "));
                     }
                  }
                  else
                  {
                     msg.Message.Add(new ResultStatusMessageItem(" " + Resources.ResourceManager.GetString("AllSections") + "."));
                  }
               }
               resultStatusMessages.Add(msg);
            }
         }
         return resultStatusMessages;
      }
      /// </structural_toolkit_2015>
      
   }
 
   /// <summary>
   /// Represents user's calculation object which modify element forces.
   /// </summary>
   public class ModifyElementForces : ICalculationObject
   {
      #region ICalculationObject Members

      /// <summary>
      /// Runs calculation\operations for cref="BeamElement" and cref="ColumnElement".
      /// </summary>
      /// <param name="obj">cref="BeamElement" object or cref="ColumnElement" object.</param>
      /// <returns>Result of calculation.</returns>
      public bool Run(ObjectDataBase obj)
      {
         bool isOk = true;
         if (obj != null)
         {
            switch (obj.Category)
            {
               default:
                  isOk = false;
                  break;
               /// <structural_toolkit_2015>
               case Autodesk.Revit.DB.BuiltInCategory.OST_FloorAnalytical:
               case Autodesk.Revit.DB.BuiltInCategory.OST_FoundationSlabAnalytical:
               case Autodesk.Revit.DB.BuiltInCategory.OST_WallAnalytical:
                  {
                     isOk = true;
                  }
                  break;
               /// </structural_toolkit_2015>
               case Autodesk.Revit.DB.BuiltInCategory.OST_ColumnAnalytical:
                  {
                     ModifyForcesBecauseOfBuckling(obj);
                  }
                  break;
               case Autodesk.Revit.DB.BuiltInCategory.OST_BeamAnalytical:
                  {
                     ModifySupportForces(obj);
                  }
                  break;
            }
         }
         return isOk;
      }
      /// <structural_toolkit_2015>

      /// <summary>
      /// Example explaining how to use force modification for beam:
      /// additonal minimum bending moment over support M=0.1*Mmax in ULS 
      /// </summary>
      /// <param name="obj">cref="BeamElement" object or cref="ColumnElement" object.</param>
      private void ModifySupportForces(ObjectDataBase obj)
      {
         BeamElement elem = obj as BeamElement;

         double maximumM = elem.ListSectionData.Max(sd => ((sd as BeamSection).ListInternalForces).Max(f => (f as InternalForcesLinear).Forces.MomentMy));
         bool isMaximumM = (maximumM > 0.0);
         if(isMaximumM)
         {
            List<int> indexSupport = new List<int>();
            double maximumL = elem.ListSectionData.Max(sd => ((sd as BeamSection).CalcPoint as CalcPointLinear).CoordRelative);
            indexSupport.Add(elem.ListSectionData.FindIndex(sd => ((sd as BeamSection).CalcPoint as CalcPointLinear).CoordRelative.Equals(maximumL)));
            double minimumL = elem.ListSectionData.Min(sd => ((sd as BeamSection).CalcPoint as CalcPointLinear).CoordRelative);
            indexSupport.Add(elem.ListSectionData.FindIndex(sd => ((sd as BeamSection).CalcPoint as CalcPointLinear).CoordRelative.Equals(minimumL)));
            foreach (int i in indexSupport)
            {
               if (i > -1)
               {
                  BeamSection bs = elem.ListSectionData[i] as BeamSection;
                  if (bs != null)
                  {
                     double fVMax = bs.ListInternalForces.Where(f => (f as InternalForcesLinear).Forces.LimitState == ForceLimitState.Uls).Max(fUls => Math.Abs((fUls as InternalForcesLinear).Forces.ForceFz));
                     if (CalculationUtility.IsZeroN(fVMax))
                        continue;
                     double Mmin = bs.ListInternalForces.Where(f=>(f as InternalForcesLinear).Forces.LimitState == ForceLimitState.Uls ).Min(fUls => (fUls as InternalForcesLinear).Forces.MomentMy);
                     double MAdd = -0.1 * maximumM;
                     if (Mmin > MAdd)
                     {
                        double Mmax = Mmin;
                        if(bs.ListInternalForces.Count !=1)
                           Mmax = bs.ListInternalForces.Where(f=>(f as InternalForcesLinear).Forces.LimitState == ForceLimitState.Uls ).Max(fUls => (fUls as InternalForcesLinear).Forces.MomentMy);
                        InternalForcesLinear forces = bs.ListInternalForces.Find(f => (f as InternalForcesLinear).Forces.MomentMy.Equals(Mmax)) as InternalForcesLinear;
                        forces.Forces.MomentMy = MAdd; 
                        bs.ListInternalForces.Add(forces);
                     }
                  }
               }
            }
         }
      }

      /// </structural_toolkit_2015>
  
      /// <summary>
      /// Simple buckling effect calculation:
      /// This is only example: braced (non-sway) structure and single curvature!
      /// </summary>
      /// <param name="obj">cref="BeamElement" object or cref="ColumnElement" object.</param>
      private void ModifyForcesBecauseOfBuckling(ObjectDataBase obj)
      {
         ColumnElement elem = obj as ColumnElement;
         CodeCheckingConcreteExample.Main.LabelColumn rcLabelColumn = elem.Label as CodeCheckingConcreteExample.Main.LabelColumn;
         bool dirY = rcLabelColumn.EnabledInternalForces.Contains(ConcreteTypes.EnabledInternalForces.MY);
         bool dirZ = rcLabelColumn.EnabledInternalForces.Contains(ConcreteTypes.EnabledInternalForces.MZ);
         dirY &= rcLabelColumn.BucklingDirectionY;
         dirZ &= rcLabelColumn.BucklingDirectionZ;
         if (dirY || dirZ)
         {
            double lambdaLim = 15.0;
            double lambdaY = 0;
            double lambdaZ = 0;
            double length = elem.Info.GeomLength();

            bool modifMy = false;
            bool modifMz = false;
            if (dirY)
            {
               lambdaY = (length * rcLabelColumn.LengthCoefficientY) / elem.Info.SectionsParams.AtTheBeg.Characteristics.ry;
               modifMy = lambdaY > lambdaLim;
            }
            if (dirZ)
            {
               lambdaZ = (length * rcLabelColumn.LengthCoefficientZ) / elem.Info.SectionsParams.AtTheBeg.Characteristics.rz;
               modifMz = lambdaZ > lambdaLim;
            }
            double additionalMy = 0;
            double additionalMz = 0;
            double My = 0;
            double Mz = 0;
            double N = 0;
            double dimY = elem.Info.SectionsParams.AtTheBeg.Dimensions.vpy + elem.Info.SectionsParams.AtTheBeg.Dimensions.vy;
            double dimZ = elem.Info.SectionsParams.AtTheBeg.Dimensions.vpz + elem.Info.SectionsParams.AtTheBeg.Dimensions.vz;
            foreach (SectionDataBase sd in elem.ListSectionData)
            {
               ColumnSection sec = sd as ColumnSection;
               if (sec != null)
               {
                  foreach (InternalForcesBase forces in sec.ListInternalForces)
                  {
                     InternalForcesLinear f = forces as InternalForcesLinear;
                     if (f != null)
                     {
                        if (f.Forces.LimitState == ForceLimitState.Uls)
                        {
                           CalcPointLinear calcPoint = sec.CalcPoint as CalcPointLinear;
                           N = f.Forces.ForceFx;
                           if (N > Double.Epsilon)
                           {
                              if (dirY)
                              {
                                 My = f.Forces.MomentMy;
                                 additionalMy = (-0.002 * N / dimZ);
                                 additionalMy *= rcLabelColumn.LengthCoefficientY * rcLabelColumn.LengthCoefficientY;
                                 additionalMy *= (calcPoint.CoordAbsolute * calcPoint.CoordAbsolute - length * calcPoint.CoordAbsolute);
                                 f.Forces.MomentMy += f.Forces.MomentMy > 0.0 ? additionalMy : -additionalMy;
                              }
                              if (dirZ)
                              {
                                 Mz = f.Forces.MomentMz;
                                 additionalMz = (-0.002 * N / dimY);
                                 additionalMz *= rcLabelColumn.LengthCoefficientZ * rcLabelColumn.LengthCoefficientZ;
                                 additionalMz *= (calcPoint.CoordAbsolute * calcPoint.CoordAbsolute - length * calcPoint.CoordAbsolute);
                                 f.Forces.MomentMz += f.Forces.MomentMz > 0.0 ? additionalMz : -additionalMz;
                              }
                           }
                        }
                     }
                  }
               }
            }
         }
      }
      /// <summary>
      /// Sets and gets common parameters.
      /// </summary>
      public CommonParametersBase Parameters { get; set; }

      /// <summary>
      /// Gets and sets type of the calculation object.
      /// </summary>
      public CalculationObjectType Type { get; set; }

      /// <summary>
      /// Gets and sets a type of error response of the calculation object.
      /// </summary>
      public ErrorResponse ErrorResponse { get; set; }

      /// <summary>
      /// Gets and sets categories for the calculation object.
      /// </summary>
      public IList<Autodesk.Revit.DB.BuiltInCategory> Categories { get; set; }

      #endregion
   }

   /// <summary>
   /// Represents user's calculation object which prepare data for elements' sections.
   /// </summary>
   public class PrepareSectionData : ICalculationObject
   {
      #region ICalculationObject Members

     /// <summary>
     /// Runs calculation\operations for cref="BeamSection" and cref="ColumnSection".
     /// </summary>
     /// <param name="obj">cref="BeamSection" object or cref="ColumnSection" object.</param>
     /// <returns>Result of calculation.</returns>
     public bool Run(ObjectDataBase obj)
     {
        SectionDataBase sectionData = obj as SectionDataBase;
        if (obj != null)
        {
           CommonParameters commParams = Parameters as CommonParameters;

           ForceResultsCache cache = null;
           if (commParams != null)
              cache = commParams.ResultCache;

           Section sec = null;

           switch (sectionData.Category)
           {
             default:
                break;
             case Autodesk.Revit.DB.BuiltInCategory.OST_ColumnAnalytical:
                if (sectionData is ColumnSection)
                {
                   ColumnSection section = sectionData as ColumnSection;

                   if (section.Info != null)
                   {
                      SectionsInfo secInfo = section.Info.Sections.AtTheBeg;

                      if (secInfo.Sections.Count > 0)
                         sec = secInfo.Sections[0];
                   }
                }
                break;
             case Autodesk.Revit.DB.BuiltInCategory.OST_BeamAnalytical:
                if (sectionData is BeamSection && sectionData.Label is LabelBeam)
                {
                   BeamSection section = sectionData as BeamSection;
                   LabelBeam label = sectionData.Label as LabelBeam;

                   if (section.Info != null)
                   {
                      SectionsInfo secInfo = section.Info.Sections.AtTheBeg;
                      if (secInfo.Sections.Count > 0)
                      {
                         sec = secInfo.Sections[0];

                         if (label.SlabBeamInteraction == ConcreteTypes.BeamSectionType.WithSlabBeamInteraction && section.Info.Slabs != null && section.Info.Slabs.TSection != null)
                         {
                            int nbrPoints = (sec.Contour != null && sec.Contour.Points != null) ? sec.Contour.Points.Count : 0;
                            double relativeX = (section.CalcPoint as CalcPointLinear).CoordRelative;
                            double maxFlangeWidth = 0.5 * section.Info.SectionsParams.AtThePoint(relativeX).Dimensions.h;
                            sec = section.Info.Slabs.TSection.GetContour( relativeX, maxFlangeWidth, maxFlangeWidth );
                            if (sec.Contour.Points.Count != nbrPoints)
                            {
                               section.IsTSection = true;
                               section.DesignInfo.Add(Resources.ResourceManager.GetString("SlabBeamInteraction"));
                            }
                         }
                      }
                   }
                }
                break;
          }
          switch (sectionData.Category)
          {
             default:
                break;
             case Autodesk.Revit.DB.BuiltInCategory.OST_ColumnAnalytical:
             case Autodesk.Revit.DB.BuiltInCategory.OST_BeamAnalytical:
                if (sectionData is LinearSection)
                {
                   LinearSection section = sectionData as LinearSection;

                  if (sec != null && sec.Contour != null)
                  {
                     foreach (Autodesk.Revit.DB.XYZ p in sec.Contour.Points)
                        section.Geometry.Add(p.X, p.Y);

                     Autodesk.Revit.DB.XYZ pmin = sec.GetMinimumBoundary();
                     Autodesk.Revit.DB.XYZ pmax = sec.GetMaximumBoundary();
                     section.Width = Math.Abs(pmin.X - pmax.X);
                     section.Height = Math.Abs(pmin.Y - pmax.Y);
                  }
                   if (cache != null)
                   {
                      IList<ForceLoadCaseDescriptor> loadCaseDescriptors = cache.GetLoadCaseDescriptors();
                      List<double> vFx = cache.GetForceForPoint(sectionData.ElementId, loadCaseDescriptors, sectionData.CalcPoint, ForceType.Fx);
                      List<double> vFy = cache.GetForceForPoint(sectionData.ElementId, loadCaseDescriptors, sectionData.CalcPoint, ForceType.Fy);
                      List<double> vFz = cache.GetForceForPoint(sectionData.ElementId, loadCaseDescriptors, sectionData.CalcPoint, ForceType.Fz);
                      List<double> vMx = cache.GetForceForPoint(sectionData.ElementId, loadCaseDescriptors, sectionData.CalcPoint, ForceType.Mx);
                      List<double> vMy = cache.GetForceForPoint(sectionData.ElementId, loadCaseDescriptors, sectionData.CalcPoint, ForceType.My);
                      List<double> vMz = cache.GetForceForPoint(sectionData.ElementId, loadCaseDescriptors, sectionData.CalcPoint, ForceType.Mz);

                      List<double> vUx = cache.GetForceForPoint(sectionData.ElementId, loadCaseDescriptors, sectionData.CalcPoint, ForceType.Ux);
                      List<double> vUy = cache.GetForceForPoint(sectionData.ElementId, loadCaseDescriptors, sectionData.CalcPoint, ForceType.Uy);
                      List<double> vUz = cache.GetForceForPoint(sectionData.ElementId, loadCaseDescriptors, sectionData.CalcPoint, ForceType.Uz);

                      int i = -1;
                      foreach (ForceLoadCaseDescriptor cas in loadCaseDescriptors)
                      {
                         i++;
                         InternalForcesLinear linForces = new InternalForcesLinear();
                         InternalForcesContainer forces = new InternalForcesContainer();

                         forces.CaseName = cas.Name;
                         forces.LimitState = cas.State;

                           forces.ForceFx      = vFx.Count == 0 ? 0.0 : vFx[i];
                           forces.ForceFy      = vFy.Count == 0 ? 0.0 : vFy[i];
                           forces.ForceFz      = vFz.Count == 0 ? 0.0 : vFz[i];
                           forces.MomentMx     = vMx.Count == 0 ? 0.0 : vMx[i];
                           forces.MomentMy     = vMy.Count == 0 ? 0.0 : vMy[i];
                           forces.MomentMz     = vMz.Count == 0 ? 0.0 : vMz[i];
                           forces.DeflectionUx = vUx.Count == 0 ? 0.0 : vUx[i];
                           forces.DeflectionUy = vUy.Count == 0 ? 0.0 : vUy[i];
                           forces.DeflectionUz = vUz.Count == 0 ? 0.0 : vUz[i];

                         linForces.Forces = forces;

                         section.ListInternalForces.Add(linForces);
                      }
                   }
                }
                break;
            /// <structural_toolkit_2015>
             case Autodesk.Revit.DB.BuiltInCategory.OST_FloorAnalytical:
             case Autodesk.Revit.DB.BuiltInCategory.OST_FoundationSlabAnalytical:
                if (sectionData is FloorSection)
                {
                   FloorSection section = sectionData as FloorSection;
                   if (section.Info != null)
                   {
                      section.Width = 1.0;
                      section.Height = section.Info.Slabs.AsElement.StructuralLayer().Thickness;

                      section.Geometry.Add(-0.5*section.Width, -0.5*section.Height);
                      section.Geometry.Add( 0.5*section.Width, -0.5*section.Height);
                      section.Geometry.Add( 0.5*section.Width,  0.5*section.Height);
                      section.Geometry.Add(-0.5*section.Width,  0.5*section.Height);
                   }
                   if (cache != null)
                   {
                      List<double> vFxx = cache.GetForceForPoint(sectionData.ElementId, cache.GetLoadCaseDescriptors(), sectionData.CalcPoint, ForceType.Fxx);
                      List<double> vFyy = cache.GetForceForPoint(sectionData.ElementId, cache.GetLoadCaseDescriptors(), sectionData.CalcPoint, ForceType.Fyy);
                      List<double> vFxy = cache.GetForceForPoint(sectionData.ElementId, cache.GetLoadCaseDescriptors(), sectionData.CalcPoint, ForceType.Fxy);
                      List<double> vMxx = cache.GetForceForPoint(sectionData.ElementId, cache.GetLoadCaseDescriptors(), sectionData.CalcPoint, ForceType.Mxx);
                      List<double> vMyy = cache.GetForceForPoint(sectionData.ElementId, cache.GetLoadCaseDescriptors(), sectionData.CalcPoint, ForceType.Myy);
                      List<double> vMxy = cache.GetForceForPoint(sectionData.ElementId, cache.GetLoadCaseDescriptors(), sectionData.CalcPoint, ForceType.Mxy);
                      List<double> vQxx = cache.GetForceForPoint(sectionData.ElementId, cache.GetLoadCaseDescriptors(), sectionData.CalcPoint, ForceType.Qxx);
                      List<double> vQyy = cache.GetForceForPoint(sectionData.ElementId, cache.GetLoadCaseDescriptors(), sectionData.CalcPoint, ForceType.Qyy);

                      int i = -1;
                      foreach (ForceLoadCaseDescriptor cas in cache.GetLoadCaseDescriptors())
                      {
                         i++;
                         InternalForcesSurface forces = new InternalForcesSurface();

                         forces.ForceDescription = cas.Name;
                         forces.LimitState = cas.State;

                         forces.ForceFxx = i < vFxx.Count ? vFxx[i] : 0.0;
                         forces.ForceFyy = i < vFyy.Count ? vFyy[i] : 0.0;
                         forces.ForceFxy = i < vFxy.Count ? vFxy[i] : 0.0;
                         forces.MomentMxx = i < vMxx.Count ? vMxx[i] : 0.0;
                         forces.MomentMyy = i < vMyy.Count ? vMyy[i] : 0.0;
                         forces.MomentMxy = i < vMxy.Count ? vMxy[i] : 0.0;
                         forces.ForceQxx = i < vQxx.Count ? vQxx[i] : 0.0;
                         forces.ForceQyy = i < vQyy.Count ? vQyy[i] : 0.0;

                         section.ListInternalForces.Add(forces);
                      }
                   }
                }
                break;
             case Autodesk.Revit.DB.BuiltInCategory.OST_WallAnalytical:
                if (sectionData is WallSection)
                {
                   WallSection section = sectionData as WallSection;
                   if (section.Info != null)
                   {
                      section.Width = 1.0;
                      section.Height = section.Info.Walls.AsElement.StructuralLayer().Thickness;

                      section.Geometry.Add(-0.5 * section.Width, -0.5 * section.Height);
                      section.Geometry.Add(0.5 * section.Width, -0.5 * section.Height);
                      section.Geometry.Add(0.5 * section.Width, 0.5 * section.Height);
                      section.Geometry.Add(-0.5 * section.Width, 0.5 * section.Height);
                   }
                   if (cache != null)
                   {
                      List<double> vFxx = cache.GetForceForPoint(sectionData.ElementId, cache.GetLoadCaseDescriptors(), sectionData.CalcPoint, ForceType.Fxx);
                      List<double> vFyy = cache.GetForceForPoint(sectionData.ElementId, cache.GetLoadCaseDescriptors(), sectionData.CalcPoint, ForceType.Fyy);
                      List<double> vFxy = cache.GetForceForPoint(sectionData.ElementId, cache.GetLoadCaseDescriptors(), sectionData.CalcPoint, ForceType.Fxy);
                      // here we are reinterprating direction vectors for bending moments
                      List<double> vMxx = cache.GetForceForPoint(sectionData.ElementId, cache.GetLoadCaseDescriptors(), sectionData.CalcPoint, ForceType.Myy);
                      List<double> vMyy = cache.GetForceForPoint(sectionData.ElementId, cache.GetLoadCaseDescriptors(), sectionData.CalcPoint, ForceType.Mxx);
                      List<double> vMxy = cache.GetForceForPoint(sectionData.ElementId, cache.GetLoadCaseDescriptors(), sectionData.CalcPoint, ForceType.Mxy);
                      List<double> vQxx = cache.GetForceForPoint(sectionData.ElementId, cache.GetLoadCaseDescriptors(), sectionData.CalcPoint, ForceType.Qxx);
                      List<double> vQyy = cache.GetForceForPoint(sectionData.ElementId, cache.GetLoadCaseDescriptors(), sectionData.CalcPoint, ForceType.Qyy);

                      int i = -1;
                      foreach (ForceLoadCaseDescriptor cas in cache.GetLoadCaseDescriptors())
                      {
                         i++;
                         InternalForcesSurface forces = new InternalForcesSurface();

                         forces.ForceDescription = cas.Name;
                         forces.LimitState = cas.State;

                         forces.ForceFxx = i < vFxx.Count ? vFxx[i] : 0.0;
                         forces.ForceFyy = i < vFyy.Count ? vFyy[i] : 0.0;
                         forces.ForceFxy = i < vFxy.Count ? vFxy[i] : 0.0;
                         forces.MomentMxx = i < vMxx.Count ? vMxx[i] : 0.0;
                         forces.MomentMyy = i < vMyy.Count ? vMyy[i] : 0.0;
                         forces.MomentMxy = i < vMxy.Count ? vMxy[i] : 0.0;
                         forces.ForceQxx = i < vQxx.Count ? vQxx[i] : 0.0;
                         forces.ForceQyy = i < vQyy.Count ? vQyy[i] : 0.0;

                         section.ListInternalForces.Add(forces);
                      }
                   }
                }
                break;
               /// </structural_toolkit_2015>
             }

       }
       return true;
     }

     /// <summary>
     /// Sets and gets common parameters.
     /// </summary>
     public CommonParametersBase Parameters { get; set; }

     /// <summary>
     /// Gets and sets type of the calculation object.
     /// </summary>
     public CalculationObjectType Type { get; set; }

     /// <summary>
     /// Gets and sets a type of error response of the calculation object.
     /// </summary>
     public ErrorResponse ErrorResponse { get; set; }

     /// <summary>
     /// Gets and sets categories for the calculation object.
     /// </summary>
     public IList<Autodesk.Revit.DB.BuiltInCategory> Categories { get; set; }

     #endregion
   }

   /// <summary>
   /// Represents user's calculation object which calculate sections.
   /// </summary>
   public class CalculateSection : ICalculationObject
   {
      #region ICalculationObject Members

      /// <summary>
      /// Runs calculation\operations for cref="BeamSection" and cref="ColumnSection".
      /// </summary>
      /// <param name="obj">cref="BeamSection" object or cref="ColumnSection" object.</param>
      /// <returns>Result of calculation.</returns>
      public bool Run(ObjectDataBase obj)
      {
         bool ret = true;
         SectionDataBase sectionData = obj as SectionDataBase;
         if (obj != null)
         {
            Concrete.ConcreteSectionDesign design = new ConcreteSectionDesign();
            design.ElementType = sectionData.Category;
            switch (sectionData.Category)
            {
               default:
                  break;
               case BuiltInCategory.OST_ColumnAnalytical:
               case BuiltInCategory.OST_BeamAnalytical:
                  if (sectionData.Label is LabelColumn)
                  {
                     CodeCheckingConcreteExample.Main.LabelColumn label = sectionData.Label as CodeCheckingConcreteExample.Main.LabelColumn;
                     design.LongitudinalReinforcementMinimumYieldStress = label.LongitudinalReinforcement.MinimumYieldStress;
                     design.LongitudinalReinforcementArea = label.LongitudinalReinforcement.Area;
                     design.LongitudinalReinforcementDiameter = label.LongitudinalReinforcement.BarDiameter;
                     design.LongitudinalCalculationType = label.LongitudinalCalculationType;
                     design.TransversalReinforcementMinimumYieldStress = label.TransversalReinforcement.MinimumYieldStress;
                     design.TransversalReinforcementArea = label.TransversalReinforcement.Area;
                     design.TransversalReinforcementDiameter = label.TransversalReinforcement.BarDiameter;
                     design.TransversalCalculationType = label.TransversalCalculationType;
                     design.CreepCoefficient = label.CreepCoefficient;
                  }
                  if (sectionData.Label is LabelBeam)
                  {
                     CodeCheckingConcreteExample.Main.LabelBeam label = sectionData.Label as CodeCheckingConcreteExample.Main.LabelBeam;

                     design.LongitudinalReinforcementMinimumYieldStress = label.LongitudinalReinforcement.MinimumYieldStress;
                     design.LongitudinalReinforcementArea = label.LongitudinalReinforcement.Area;
                     design.LongitudinalReinforcementDiameter = label.LongitudinalReinforcement.BarDiameter;
                     design.LongitudinalCalculationType = label.LongitudinalCalculationType;
                     design.TransversalReinforcementMinimumYieldStress = label.TransversalReinforcement.MinimumYieldStress;
                     design.TransversalReinforcementArea = label.TransversalReinforcement.Area;
                     design.TransversalReinforcementDiameter = label.TransversalReinforcement.BarDiameter;
                     design.TransversalCalculationType = label.TransversalCalculationType;
                     design.CreepCoefficient = label.CreepCoefficient;
                  }
                  if (sectionData is LinearSection)
                  {
                     LinearSection section = sectionData as LinearSection;
                     if (section.Info != null)
                     {
                        design.CoverTop = 0.0;
                        design.CoverBottom = 0.0;
                        if (section.Info.RebarCovers != null)
                        {
                           if (section is BeamSection)
                           {
                              if (section.Info.RebarCovers.Exist(BuiltInParameter.CLEAR_COVER_BOTTOM))
                                 design.CoverBottom = section.Info.RebarCovers.GetDistance(BuiltInParameter.CLEAR_COVER_BOTTOM);
                              if (section.Info.RebarCovers.Exist(BuiltInParameter.CLEAR_COVER_TOP))
                                 design.CoverTop = section.Info.RebarCovers.GetDistance(BuiltInParameter.CLEAR_COVER_TOP);
                           }
                           if (section is ColumnSection)
                           {
                              if (section.Info.RebarCovers.Exist(BuiltInParameter.CLEAR_COVER_OTHER))
                              {
                                 design.CoverBottom = section.Info.RebarCovers.GetDistance(BuiltInParameter.CLEAR_COVER_OTHER);
                                 design.CoverTop = section.Info.RebarCovers.GetDistance(BuiltInParameter.CLEAR_COVER_OTHER);
                              }
                           }
                        }
                        if (section.Info.SectionsParams == null)
                           design.Type = SectionShapeType.RectangularBar;
                        else
                           design.Type = section.Info.SectionsParams.ShapeType;

                        if (section is BeamSection)
                           if ((section as BeamSection).IsTSection)
                              design.Type = SectionShapeType.T;

                        design.YoungModulus = section.Info.Material.Characteristics.YoungModulus.X;
                        MaterialConcreteCharacteristics concrete = (MaterialConcreteCharacteristics)section.Info.Material.Characteristics.Specific;
                        if (concrete != null)
                           design.Compression = concrete.Compression;
                        design.Geometry = section.Geometry;
                        design.Width = section.Width;
                        design.Height = section.Height;
                        List<InternalForcesContainer> listInternalForces = new List<InternalForcesContainer>();
                        foreach (InternalForcesLinear force in section.ListInternalForces)
                           listInternalForces.Add(force.Forces);

                        design.ListInternalForces = listInternalForces; ;
                        //
                        // calculation
                        //
                        design.Calculate();
                        //
                        // save result
                        //
                        section.AsBottom = design.AsBottom;
                        section.AsTop = design.AsTop;
                        section.AsRight = design.AsRight;
                        section.AsLeft = design.AsLeft;
                        section.Spacing = design.Spacing;
                        section.TransversalDensity = design.TransversalDensity;
                        section.MinStiffness = design.MinStiffness;
                        section.DesignInfo.AddRange(design.DesignInfo);
                        section.DesignError.AddRange(design.DesignError);
                        section.DesignWarning.AddRange(design.DesignWarning);
                        if (section.DesignError.Count > 0)
                        {
                           ret = false;
                        }
                     }
                  }
                  break;
               /// <structural_toolkit_2015>
               case Autodesk.Revit.DB.BuiltInCategory.OST_FloorAnalytical:
               case Autodesk.Revit.DB.BuiltInCategory.OST_FoundationSlabAnalytical:
               case Autodesk.Revit.DB.BuiltInCategory.OST_WallAnalytical:
                  if (sectionData is SurfaceSection)
                  {
                     CodeCheckingConcreteExample.LabelFloor labelFloor = sectionData.Label as CodeCheckingConcreteExample.LabelFloor;
                     CodeCheckingConcreteExample.LabelWall labelWall = sectionData.Label as CodeCheckingConcreteExample.LabelWall;

                     SurfaceSection section = sectionData as SurfaceSection;
                     double[] coverT = { 0, 0 };
                     double[] coverB = { 0, 0 };
                     if (section.Info != null)
                     {
                        if (section.Info.RebarCovers != null)
                        {
                           if (section is FloorSection)
                           {
                              if (section.Info.RebarCovers.Exist(BuiltInParameter.CLEAR_COVER_BOTTOM))
                                 coverB[0] = section.Info.RebarCovers.GetDistance(BuiltInParameter.CLEAR_COVER_BOTTOM);
                              if (section.Info.RebarCovers.Exist(BuiltInParameter.CLEAR_COVER_TOP))
                                 coverT[0] = section.Info.RebarCovers.GetDistance(BuiltInParameter.CLEAR_COVER_TOP);
                           }
                           if (section is WallSection)
                           {
                              if (section.Info.RebarCovers.Exist(BuiltInParameter.CLEAR_COVER_INTERIOR)) 
                                 coverB[0] = section.Info.RebarCovers.GetDistance(BuiltInParameter.CLEAR_COVER_INTERIOR);
                              if (section.Info.RebarCovers.Exist(BuiltInParameter.CLEAR_COVER_EXTERIOR))
                                 coverT[0] = section.Info.RebarCovers.GetDistance(BuiltInParameter.CLEAR_COVER_EXTERIOR);
                           }
                           coverT[1] = coverT[0];
                           coverB[1] = coverB[0];
                        }
                        if( labelFloor!=null)
                        { 
                           coverT[1] += labelFloor.PrimaryReinforcement.BarDiameter;
                           coverB[1] += labelFloor.PrimaryReinforcement.BarDiameter;
                           design.LongitudinalCalculationType = labelFloor.LongitudinalCalculationType;
                           design.CreepCoefficient = labelFloor.CreepCoefficient;
                        } 
                        if( labelWall!=null)
                        { 
                           coverT[1] += labelWall.VerticalReinforcement.BarDiameter;
                           coverB[1] += labelWall.VerticalReinforcement.BarDiameter;
                           design.LongitudinalCalculationType = labelWall.LongitudinalCalculationType;
                           design.CreepCoefficient = labelWall.CreepCoefficient;
                        }

                        design.Type = SectionShapeType.RectangularBar;
                        design.YoungModulus = section.Info.Material.Characteristics.YoungModulus.X;
                        if (section.Info.Material.Characteristics.YoungModulus.X < 1)
                           design.YoungModulus = 20e9;
                        MaterialConcreteCharacteristics concrete = (MaterialConcreteCharacteristics)section.Info.Material.Characteristics.Specific;
                        if (concrete != null)
                           design.Compression = concrete.Compression;
                        else
                           design.Compression = 25e6;
                     }
                     design.Geometry = section.Geometry;
                     design.Width = 1.0;
                     design.Height = section.Height;
                     DimensioningDirection[] directions = new DimensioningDirection[] { DimensioningDirection.X, DimensioningDirection.Y };
                     foreach (DimensioningDirection direction in directions)
                     {
                        if (direction == DimensioningDirection.Y)
                        {
                           if ((section is FloorSection) && section.Info.Slabs.AsElement.IsOneWay)
                           {
                              break;
                           }
                           else
                           {
                              if( labelFloor != null ) 
                              {
                                 design.LongitudinalReinforcementMinimumYieldStress = labelFloor.SecondaryReinforcement.MinimumYieldStress;
                                 design.LongitudinalReinforcementArea =  labelFloor.SecondaryReinforcement.Area;
                                 design.LongitudinalReinforcementDiameter = labelFloor.SecondaryReinforcement.BarDiameter;
                              }
                              if( labelWall != null ) 
                              {
                                 design.LongitudinalReinforcementMinimumYieldStress = labelWall.HorizontalReinforcement.MinimumYieldStress;
                                 design.LongitudinalReinforcementArea = labelWall.HorizontalReinforcement.Area;
                                 design.LongitudinalReinforcementDiameter = labelWall.HorizontalReinforcement.BarDiameter;
                              }
                              design.CoverBottom = coverB[1];
                              design.CoverTop = coverT[1];
                           }
                        }
                        else
                        {
                           if( labelFloor!=null ) 
                           {
                              design.LongitudinalReinforcementMinimumYieldStress = labelFloor.PrimaryReinforcement.MinimumYieldStress;
                              design.LongitudinalReinforcementArea               = labelFloor.PrimaryReinforcement.Area;
                              design.LongitudinalReinforcementDiameter           = labelFloor.PrimaryReinforcement.BarDiameter;
                           }
                           if( labelWall!=null)
                           {
                              design.LongitudinalReinforcementMinimumYieldStress = labelWall.VerticalReinforcement.MinimumYieldStress;
                              design.LongitudinalReinforcementArea               = labelWall.VerticalReinforcement.Area;
                              design.LongitudinalReinforcementDiameter           = labelWall.VerticalReinforcement.BarDiameter;
                           }
                           design.CoverBottom = coverB[0];
                           design.CoverTop = coverT[0];
                        }
                        design.DimensioningDirection = direction;
                        design.ListInternalForces = section.ListInternalForces.Select(s => (s as InternalForcesSurface).Forces(direction)).ToList();
                        //
                        // calculation
                        //
                        design.Calculate();
                        //
                        // save result
                        //
                        section.AsBottom[direction] = design.AsBottom;
                        section.AsTop[direction] = design.AsTop;
                        section.MinStiffnes[direction] = design.MinStiffness;
                        section.DesignInfo[direction] = design.DesignInfo;
                        section.DesignWarning[direction] = design.DesignWarning;
                        section.DesignError[direction] = design.DesignError;
                        if (section.DesignError[direction].Count > 0)
                        {
                           ret = false;
                        }
                     }
                  }
                  break;
                  /// </structural_toolkit_2015>
            }
         }
         return ret;
      }

      /// <summary>
      /// Sets and gets common parameters.
      /// </summary>
      public CommonParametersBase Parameters { get; set; }

      /// <summary>
      /// Gets and sets type of the calculation object.
      /// </summary>
      public CalculationObjectType Type { get; set; }

      /// <summary>
      /// Gets and sets a type of error response of the calculation object.
      /// </summary>
      public ErrorResponse ErrorResponse { get; set; }

      /// <summary>
      /// Gets and sets categories for the calculation object.
      /// </summary>
      public IList<Autodesk.Revit.DB.BuiltInCategory> Categories { get; set; }

      #endregion
   }

   /// <summary>
   /// Represents user's calculation object which calculate deflection of a beam epresented by cref="BeamElement".
   /// </summary>
   public class CalculateDeflection : ICalculationObject
   {
      #region ICalculationObject Members

      /// <summary>
      /// Runs calculation\operations for cref="BeamElement".
      /// </summary>
      /// <param name="obj">cref="BeamElement".</param>
      /// <returns>Result of calculation.</returns>
      public bool Run(ObjectDataBase obj)
      {
         ElementDataBase elementData = obj as ElementDataBase;
         if (obj != null)
         {
            BeamElement objBeam = obj as BeamElement;
            if (objBeam != null)
            {
               CodeCheckingConcreteExample.Main.ResultBeam res = elementData.Result as CodeCheckingConcreteExample.Main.ResultBeam;
               if (res != null)
               {
                  double young = objBeam.Info.Material.Characteristics.YoungModulus.X;
                  double maxCoef = 0;
                  double stifCoef = 0.0;
                  double avrCoef = 0.0;
                  int sectionNo = 0;
                  foreach (SectionDataBase sd in elementData.ListSectionData)
                  {
                     BeamSection sec = sd as BeamSection;

                     if (sec != null)
                     {
                        if (sec.MinStiffness > Double.Epsilon)
                        {
                           CalcPointLinear calcPoint = sec.CalcPoint as CalcPointLinear;
                           double Iy = sec.Info.SectionsParams.AtThePoint(calcPoint.CoordRelative).Characteristics.Iy;
                           stifCoef = (Iy * young) / sec.MinStiffness;
                        }
                        else
                        {
                           stifCoef = 0;
                           break;
                        }
                        ++sectionNo;
                        maxCoef = Math.Max(maxCoef, stifCoef);
                        avrCoef += stifCoef;
                     }
                  }
                  double finStiffnes = 0;
                  if (stifCoef > Double.Epsilon)
                  {
                     avrCoef /= sectionNo;
                     finStiffnes = 0.5 * (maxCoef + avrCoef);
                  }
                  else
                  {
                     objBeam.AddFormatedWarning(new ResultStatusMessage("Calculation of deflections was not performed."));
                  }
                  foreach (SectionDataBase sd in elementData.ListSectionData)
                  {
                     BeamSection sec = sd as BeamSection;
                     if (sec != null)
                        sec.StiffnesCoeff = finStiffnes;
                  }
               }
            }
         }
         return true;
      }

      /// <summary>
      /// Sets and gets common parameters.
      /// </summary>
      public CommonParametersBase Parameters { get; set; }

      /// <summary>
      /// Gets and sets type of the calculation object.
      /// </summary>
      public CalculationObjectType Type { get; set; }

      /// <summary>
      /// Gets and sets a type of error response of the calculation object.
      /// </summary>
      public ErrorResponse ErrorResponse { get; set; }

      /// <summary>
      /// Gets and sets categories for the calculation object.
      /// </summary>
      public IList<Autodesk.Revit.DB.BuiltInCategory> Categories { get; set; }

      #endregion
   }

}