mirror of
https://github.com/jeremytammik/RevitSdkSamples.git
synced 2026-08-11 15:36:18 +00:00
Jeremy Tammik
793 lines
41 KiB
C#
793 lines
41 KiB
C#
//
|
|
// (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;
|
|
using CodeCheckingConcreteExample.Engine;
|
|
using Autodesk.Revit.DB.CodeChecking.Engineering;
|
|
using Autodesk.Revit.DB.CodeChecking.Engineering.Tools;
|
|
using CodeCheckingConcreteExample.Utility;
|
|
using CodeCheckingConcreteExample.ConcreteTypes;
|
|
using Autodesk.Revit.DB.CodeChecking.Storage;
|
|
using CodeCheckingConcreteExample.Properties;
|
|
using Autodesk.Revit.DB.CodeChecking;
|
|
|
|
namespace CodeCheckingConcreteExample.Main.Calculation
|
|
{
|
|
/// <summary>
|
|
/// Represents user's implementation of interface for the main loop class. Parameter of the default constructor of the cref="Engine" class.
|
|
/// </summary>
|
|
public class EngineData : IEngineData
|
|
{
|
|
#region IEngineData Members
|
|
|
|
/// <summary>
|
|
/// Gets the display unit which user want to use in the project.
|
|
/// </summary>
|
|
/// <returns>cref="DisplayUnit"</returns>
|
|
public Autodesk.Revit.DB.DisplayUnit GetInputDataUnitSystem()
|
|
{
|
|
DisplayUnit displayUnit = DisplayUnit.IMPERIAL;
|
|
if (Server.Server.UnitSystem == Autodesk.Revit.DB.ResultsBuilder.UnitsSystem.Metric)
|
|
displayUnit = DisplayUnit.METRIC;
|
|
return displayUnit;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets number of available threads or processors. user could switch off parallel calculation by returning value 1.
|
|
/// </summary>
|
|
/// <param name="data">Service data.</param>
|
|
/// <returns>Number of threads</returns>
|
|
public int GetNumberOfThreads(Autodesk.Revit.DB.CodeChecking.ServiceData data)
|
|
{
|
|
/// <structural_toolkit_2015>
|
|
if(Tools.IsJournalPlayback)
|
|
return 1;
|
|
else
|
|
return Environment.ProcessorCount;
|
|
/// </structural_toolkit_2015>
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets ForceCalculationDataDescriptor object for the current structure
|
|
/// </summary>
|
|
/// <param name="data">Service Data</param>
|
|
/// <param name="combinations">List of selected combinations ids </param>
|
|
/// <param name="elementId">Id of Revit element</param>
|
|
/// <returns>Reference to ForceCalculationDataDescriptor</returns>
|
|
protected ForceCalculationDataDescriptor GetForceCalculationDataDescriptor(Autodesk.Revit.DB.CodeChecking.ServiceData data, List<ElementId> combinations, ElementId elementId)
|
|
{
|
|
Tuple<Label,CalculationParameter,BuiltInCategory,Element> intData = GetElementInternalData(data, elementId);
|
|
Label ccLabel = intData.Item1;
|
|
CalculationParameter calculationParameters = intData.Item2;
|
|
BuiltInCategory category = intData.Item3;
|
|
Element element = intData.Item4;
|
|
|
|
List<ForceType> forceTypes = new List<ForceType>();// { ForceType.Fx, ForceType.Fy, ForceType.Fz, ForceType.Mx, ForceType.My, ForceType.Mz };
|
|
|
|
forceTypes = GetForceTypes(data, new ElementId[] { elementId });
|
|
|
|
ForceCalculationDataDescriptor descriptor = null;
|
|
/// <structural_toolkit_2015>
|
|
switch (category)
|
|
{
|
|
case BuiltInCategory.OST_ColumnAnalytical:
|
|
case BuiltInCategory.OST_BeamAnalytical:
|
|
{
|
|
double elementLength = (element as Autodesk.Revit.DB.Structure.AnalyticalModel).GetCurve().Length;
|
|
elementLength = Autodesk.Revit.DB.UnitUtils.ConvertFromInternalUnits(elementLength, DisplayUnitType.DUT_METERS);
|
|
descriptor = new ForceCalculationDataDescriptorLinear(elementId, 1.0, calculationParameters.CalculationPointsSelector.GetPointCoordinates(data.Document, true, elementLength, elementId, combinations, forceTypes), true, forceTypes);
|
|
|
|
if (descriptor == null)
|
|
{
|
|
descriptor = new ForceCalculationDataDescriptorLinear(elementId);
|
|
}
|
|
}
|
|
break;
|
|
case BuiltInCategory.OST_FloorAnalytical:
|
|
case BuiltInCategory.OST_FoundationSlabAnalytical:
|
|
case BuiltInCategory.OST_WallAnalytical:
|
|
{
|
|
descriptor = new ForceCalculationDataDescriptor(elementId,forceTypes);
|
|
}
|
|
break;
|
|
}
|
|
if (descriptor == null)
|
|
{
|
|
descriptor = new ForceCalculationDataDescriptor(elementId,forceTypes);
|
|
}
|
|
/// </structural_toolkit_2015>
|
|
return descriptor;
|
|
|
|
}
|
|
|
|
/// <structural_toolkit_2015>
|
|
|
|
/// <summary>
|
|
/// Creates user imlementation of cref="ICalculationScenario" which consists list of calculation objects cref="ICalculatinObject".
|
|
/// </summary>
|
|
/// <param name="parameters">User common parameters.</param>
|
|
/// <returns>The new instance of cref="ICalculationScenario"</returns>
|
|
public ICalculationScenario CreateCalculationScenario(CommonParametersBase parameters)
|
|
{
|
|
return new CalculationScenario();
|
|
}
|
|
/// </structural_toolkit_2015>
|
|
|
|
/// <summary>
|
|
/// Creates new instance of user class wich represents a section of a structure element.
|
|
/// </summary>
|
|
/// <param name="sectionDataBase">Instance of base class for the section.</param>
|
|
/// <returns>New instance of user implementation of section class derived from cref="SectionDataBase".</returns>
|
|
public SectionDataBase CreateSectionData(SectionDataBase sectionDataBase)
|
|
{
|
|
switch (sectionDataBase.Material)
|
|
{
|
|
case StructuralAssetClass.Concrete:
|
|
switch (sectionDataBase.Category)
|
|
{
|
|
default:
|
|
break;
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_ColumnAnalytical:
|
|
return new ColumnSection(sectionDataBase);
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_BeamAnalytical:
|
|
return new BeamSection(sectionDataBase);
|
|
/// <structural_toolkit_2015>
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_FloorAnalytical:
|
|
return new FloorSection(sectionDataBase);
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_FoundationSlabAnalytical:
|
|
return new FloorSection(sectionDataBase);
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_WallAnalytical:
|
|
return new WallSection(sectionDataBase);
|
|
/// </structural_toolkit_2015>
|
|
}
|
|
break;
|
|
case StructuralAssetClass.Metal:
|
|
break;
|
|
}
|
|
|
|
return sectionDataBase;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates new instance of user class wich represents a structure element.
|
|
/// </summary>
|
|
/// <param name="elementDataBase">Instance of base class for the element.</param>
|
|
/// <returns>New instance of user implementation of element class derived from cref="ElementDataBase".</returns>
|
|
public ElementDataBase CreateElementData(ElementDataBase elementDataBase)
|
|
{
|
|
switch (elementDataBase.Material)
|
|
{
|
|
case StructuralAssetClass.Concrete:
|
|
switch (elementDataBase.Category)
|
|
{
|
|
default:
|
|
break;
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_ColumnAnalytical:
|
|
return new ColumnElement(elementDataBase);
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_BeamAnalytical:
|
|
return new BeamElement(elementDataBase);
|
|
/// <structural_toolkit_2015>
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_FloorAnalytical:
|
|
return new FloorElement(elementDataBase);
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_FoundationSlabAnalytical:
|
|
return new FloorElement(elementDataBase);
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_WallAnalytical:
|
|
return new WallElement(elementDataBase);
|
|
/// </structural_toolkit_2015>
|
|
}
|
|
break;
|
|
case StructuralAssetClass.Metal:
|
|
break;
|
|
}
|
|
|
|
return elementDataBase;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates new instance of class with results for the element.
|
|
/// </summary>
|
|
/// <param name="category">Category of the element.</param>
|
|
/// <param name="material">Material of the element.</param>
|
|
/// <returns>User result schema object for the element.</returns>
|
|
public Autodesk.Revit.DB.ExtensibleStorage.Framework.SchemaClass CreateElementResult(Autodesk.Revit.DB.BuiltInCategory category, Autodesk.Revit.DB.StructuralAssetClass material)
|
|
{
|
|
switch (material)
|
|
{
|
|
case StructuralAssetClass.Concrete:
|
|
switch (category)
|
|
{
|
|
default:
|
|
break;
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_BeamAnalytical:
|
|
return new ResultBeam();
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_ColumnAnalytical:
|
|
return new ResultColumn();
|
|
/// <structural_toolkit_2015>
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_FloorAnalytical:
|
|
return new ResultFloor();
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_FoundationSlabAnalytical:
|
|
return new ResultFloor();
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_WallAnalytical:
|
|
return new ResultWall();
|
|
/// </structural_toolkit_2015>
|
|
}
|
|
break;
|
|
case StructuralAssetClass.Metal:
|
|
break;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads calculation parameters from revit data base.
|
|
/// </summary>
|
|
/// <param name="data">Acces to cref="ServiceData".</param>
|
|
/// <returns>User calculation parameters schema object.</returns>
|
|
public Autodesk.Revit.DB.ExtensibleStorage.Framework.SchemaClass ReadCalculationParameter(Autodesk.Revit.DB.CodeChecking.ServiceData data)
|
|
{
|
|
Autodesk.Revit.DB.CodeChecking.Storage.StorageService service = Autodesk.Revit.DB.CodeChecking.Storage.StorageService.GetStorageService();
|
|
Autodesk.Revit.DB.CodeChecking.Storage.StorageDocument storageDocument = service.GetStorageDocument(data.Document);
|
|
CalculationParameter calculationParameter = storageDocument.CalculationParamsManager.CalculationParams.GetEntity<CalculationParameter>(data.Document);
|
|
return calculationParameter;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads parameters of user element label.
|
|
/// </summary>
|
|
/// <param name="category">Category of the element.</param>
|
|
/// <param name="material">Material of the element.</param>
|
|
/// <param name="label">Acces to the Revit storage with labels."</param>
|
|
/// <param name="data">Acces to cref="ServiceData".</param>
|
|
/// <returns>User label of the element.</returns>
|
|
public Autodesk.Revit.DB.ExtensibleStorage.Framework.SchemaClass ReadElementLabel(Autodesk.Revit.DB.BuiltInCategory category, Autodesk.Revit.DB.StructuralAssetClass material, Autodesk.Revit.DB.CodeChecking.Storage.Label label, Autodesk.Revit.DB.CodeChecking.ServiceData data)
|
|
{
|
|
if (label != null)
|
|
{
|
|
switch (material)
|
|
{
|
|
case StructuralAssetClass.Concrete:
|
|
switch (category)
|
|
{
|
|
default:
|
|
break;
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_ColumnAnalytical: return label.GetEntity<LabelColumn>(data.Document);
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_BeamAnalytical: return label.GetEntity<LabelBeam>(data.Document);
|
|
/// <structural_toolkit_2015>
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_FloorAnalytical: return label.GetEntity<LabelFloor>(data.Document);
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_FoundationSlabAnalytical: return label.GetEntity<LabelFloor>(data.Document);
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_WallAnalytical: return label.GetEntity<LabelWall>(data.Document);
|
|
/// </structural_toolkit_2015>
|
|
}
|
|
break;
|
|
case StructuralAssetClass.Metal:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verify parameters of steel in the label.
|
|
/// </summary>
|
|
/// <param name="steel">Steel properties</param>
|
|
/// <param name="longitudinal">Information about the type of reinforcement. True if longitudinal.</param>
|
|
/// <returns></returns>
|
|
public List<string> VerifySteel(CodeCheckingConcreteExample.UIComponents.RCSteelParameters.RCSteelParametersSchema steel, bool longitudinal)
|
|
{
|
|
List<string> errors = new List<string>();
|
|
|
|
if (steel.Material == null)
|
|
errors.Add(Resources.ResourceManager.GetString(longitudinal ? "ErrReinforcementMaterialL" : "ErrReinforcementMaterialT"));
|
|
else if (steel.MinimumYieldStress < Double.Epsilon)
|
|
errors.Add(Resources.ResourceManager.GetString(longitudinal ? "ErrReinforcementYieldStressL" : "ErrReinforcementYieldStressT"));
|
|
if (steel.RebarBarType == null || steel.BarDiameter < Double.Epsilon || steel.DeformationType == Autodesk.Revit.DB.CodeChecking.Engineering.Concrete.ConcreteTypes.SteelSurface.Unknown)
|
|
errors.Add(Resources.ResourceManager.GetString(longitudinal ? "ErrRebarL" : "ErrRebarT"));
|
|
|
|
return errors;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verify parameters of user element label.
|
|
/// </summary>
|
|
/// <param name="category">Category of the element.</param>
|
|
/// <param name="material">Material of the element.</param>
|
|
/// <param name="label">Element label."</param>
|
|
/// <param name="status">Reference to element's status".</param>
|
|
public void VerifyElementLabel(Autodesk.Revit.DB.BuiltInCategory category, StructuralAssetClass material, Autodesk.Revit.DB.ExtensibleStorage.Framework.SchemaClass label,
|
|
ref Autodesk.Revit.DB.CodeChecking.Storage.ResultStatus status)
|
|
{
|
|
if (label != null)
|
|
{
|
|
switch (material)
|
|
{
|
|
case StructuralAssetClass.Concrete:
|
|
switch (category)
|
|
{
|
|
default:
|
|
break;
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_ColumnAnalytical:
|
|
{
|
|
LabelColumn labelCol = label as LabelColumn;
|
|
if (labelCol != null)
|
|
{
|
|
if (labelCol.EnabledInternalForces.Count == 0)
|
|
status.AddError(Resources.ResourceManager.GetString("ErrNoChosenInternalForces"));
|
|
List<string> errors = VerifySteel(labelCol.LongitudinalReinforcement, true);
|
|
foreach(string s in errors)
|
|
status.AddError(s);
|
|
errors = VerifySteel(labelCol.TransversalReinforcement, false);
|
|
foreach(string s in errors)
|
|
status.AddError(s);
|
|
}
|
|
}
|
|
break;
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_BeamAnalytical:
|
|
{
|
|
LabelBeam labelBm = label as LabelBeam;
|
|
if (labelBm != null)
|
|
{
|
|
if (labelBm.EnabledInternalForces.Count == 0)
|
|
status.AddError(Resources.ResourceManager.GetString("ErrNoChosenInternalForces"));
|
|
List<string> errors = VerifySteel(labelBm.LongitudinalReinforcement, true);
|
|
foreach(string s in errors)
|
|
status.AddError(s);
|
|
errors = VerifySteel(labelBm.TransversalReinforcement, false);
|
|
foreach(string s in errors)
|
|
status.AddError(s);
|
|
}
|
|
}
|
|
break;
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_FloorAnalytical:
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_FoundationSlabAnalytical:
|
|
{
|
|
LabelFloor labelFloor = label as LabelFloor;
|
|
if (labelFloor != null)
|
|
{
|
|
if (labelFloor.EnabledInternalForces.Count == 0)
|
|
status.AddError(Resources.ResourceManager.GetString("ErrNoChosenInternalForces"));
|
|
List<string> errors = VerifySteel(labelFloor.PrimaryReinforcement, true);
|
|
foreach (string s in errors)
|
|
status.AddError(s);
|
|
errors = VerifySteel(labelFloor.SecondaryReinforcement, false);
|
|
foreach (string s in errors)
|
|
status.AddError(s);
|
|
}
|
|
}
|
|
break;
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_WallAnalytical:
|
|
{
|
|
LabelWall labelWall = label as LabelWall;
|
|
if (labelWall != null)
|
|
{
|
|
if (labelWall.EnabledInternalForces.Count == 0)
|
|
status.AddError(Resources.ResourceManager.GetString("ErrNoChosenInternalForces"));
|
|
List<string> errors = VerifySteel(labelWall.VerticalReinforcement, true);
|
|
foreach (string s in errors)
|
|
status.AddError(s);
|
|
errors = VerifySteel(labelWall.HorizontalReinforcement, false);
|
|
foreach (string s in errors)
|
|
status.AddError(s);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case StructuralAssetClass.Metal:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Filters list of elements due to e.g. a result status for calculation purposes.
|
|
/// </summary>
|
|
/// <param name="listElementData">List of user element objects.</param>
|
|
/// <returns>Filtered list of user element objects.</returns>
|
|
public List<ObjectDataBase> FilterElementForCalculation(List<ObjectDataBase> listElementData)
|
|
{
|
|
List<ObjectDataBase> listElementFiltered = new List<ObjectDataBase>();
|
|
|
|
foreach (ObjectDataBase obj in listElementData)
|
|
{
|
|
ElementDataBase elem = obj as ElementDataBase;
|
|
if (elem != null)
|
|
{
|
|
if (!elem.Status.IsError())
|
|
{
|
|
listElementFiltered.Add(elem);
|
|
}
|
|
}
|
|
}
|
|
|
|
return listElementFiltered;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates new instance of a user's class with common parameters.
|
|
/// </summary>
|
|
/// <param name="data">Acces to cref="ServiceData".</param>
|
|
/// <param name="parameters">Instance of base class with common parameters.</param>
|
|
/// <returns>New instance of user implementation of class derived from cref="CommonParametersBase".</returns>
|
|
public CommonParametersBase CreateCommonParameters(Autodesk.Revit.DB.CodeChecking.ServiceData data, CommonParametersBase parameters)
|
|
{
|
|
Autodesk.Revit.DB.CodeChecking.NotificationService.ProgressStart(Resources.ResourceManager.GetString("DataPreparation"), 1);
|
|
|
|
CommonParameters commonParameters = new CommonParameters(data, parameters);
|
|
|
|
List<ForceCalculationDataDescriptor> calculationDataDescriptors = new List<ForceCalculationDataDescriptor>();
|
|
foreach (Tuple<ElementId,ResultStatus> elemStatus in commonParameters.ListElementStatus)
|
|
{
|
|
ForceCalculationDataDescriptor forceCalculationDataDescriptor = GetForceCalculationDataDescriptor(data, parameters.ListCombinationId, elemStatus.Item1);
|
|
///<structural_toolkit_2015>
|
|
if (forceCalculationDataDescriptor is ForceCalculationDataDescriptorLinear)
|
|
{
|
|
forceCalculationDataDescriptor.AddBendingForceTypes(new ForceType[] { ForceType.Ux, ForceType.Uy, ForceType.Uz });
|
|
}
|
|
///</structural_toolkit_2015>
|
|
calculationDataDescriptors.Add(forceCalculationDataDescriptor);
|
|
if (NotificationService.ProgressBreakInvoked())
|
|
break;
|
|
}
|
|
|
|
ForceResultsPackageDescriptor[] vResPackDesc = new ForceResultsPackageDescriptor[] { ForceResultsPackageDescriptor.GetResultPackageDescriptor(data.Document, commonParameters.ActivePackageGuid) };
|
|
|
|
// Uncomment the code below to dump to a text file the time spent on accessing ResultsBuilder
|
|
// Int64 forceResultsCacheAccessTime = System.DateTime.Now.Ticks;
|
|
commonParameters.ResultCache = new ForceResultsCache(data.Document, calculationDataDescriptors, vResPackDesc, commonParameters.ListCombinationId, GetInputDataUnitSystem());
|
|
// Uncomment the code below to dump to a text file the time spent on accessing ResultsBuilder
|
|
// forceResultsCacheAccessTime = System.DateTime.Now.Ticks - forceResultsCacheAccessTime;
|
|
|
|
foreach (Tuple<ElementId, ResultStatus> elemStatus in commonParameters.ListElementStatus)
|
|
{
|
|
ForceResultsCache.ElementResultsStatus resultStatus = commonParameters.ResultCache.GetElementResultsStatus(elemStatus.Item1);
|
|
if (resultStatus != ForceResultsCache.ElementResultsStatus.ResultsOK)
|
|
{
|
|
elemStatus.Item2.AddError(Resources.ResourceManager.GetString("ErrStaticResults"));
|
|
}
|
|
}
|
|
|
|
// Uncomment the code below to dump to a text file the time spent on accessing ResultsBuilder
|
|
// using (System.IO.StreamWriter writer = new System.IO.StreamWriter(data.Document.PathName + ".RBAccessTimeInfo.txt", true))
|
|
// {
|
|
// string resultBuilderAccessTime = DateTime.Now.ToString() + " Cache: " + (new System.TimeSpan(forceResultsCacheAccessTime)).TotalSeconds + " RB: " + (new System.TimeSpan(commonParameters.ResultCache.ResultBuilderAccessTime)).TotalSeconds;
|
|
//
|
|
// writer.WriteLine(resultBuilderAccessTime);
|
|
// }
|
|
|
|
Autodesk.Revit.DB.CodeChecking.NotificationService.ProgressStep("");
|
|
return commonParameters;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates new instance of class with list of calculation points for user's elements.
|
|
/// </summary>
|
|
/// <param name="data">Acces to cref="ServiceData".</param>
|
|
/// <param name="parameters">User object with common parameters.</param>
|
|
/// <param name="elementId">Id of an element.</param>
|
|
/// <returns>List of calculation points for user's element.</returns>
|
|
public List<CalcPoint> CreateCalcPointsForElement(Autodesk.Revit.DB.CodeChecking.ServiceData data, CommonParametersBase parameters, ElementId elementId)
|
|
{
|
|
List<CalcPoint> calculationPoints = new List<CalcPoint>();
|
|
CommonParameters commonParameters = parameters as CommonParameters;
|
|
if (commonParameters != null)
|
|
calculationPoints = commonParameters.ResultCache.GetCalculationPoints(elementId);
|
|
return calculationPoints;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gives possibility to read data from Revit data base and puts them into user element's objects and into user section's objects and into user common parameters.
|
|
/// </summary>
|
|
/// <param name="listElementData">List of user element objects.</param>
|
|
/// <param name="parameters">User common parameters.</param>
|
|
/// <param name="data">Acces to cref="ServiceData".</param>
|
|
public void ReadFromRevitDB(List<ObjectDataBase> listElementData, CommonParametersBase parameters, Autodesk.Revit.DB.CodeChecking.ServiceData data)
|
|
{
|
|
// read additional information from Revit data and store them in user objects derived from ElementDataBase and listed in listElementData
|
|
|
|
Autodesk.Revit.DB.CodeChecking.NotificationService.ProgressStart(Resources.ResourceManager.GetString("ReadingGeometry"), listElementData.Count);
|
|
ElementAnalyser elementAnalyser = new ElementAnalyser(GetInputDataUnitSystem());
|
|
|
|
int step = 0;
|
|
foreach (ObjectDataBase elemData in listElementData)
|
|
{
|
|
Element element = data.Document.GetElement(elemData.ElementId);
|
|
if (element != null)
|
|
{
|
|
switch (elemData.Category)
|
|
{
|
|
default:
|
|
break;
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_ColumnAnalytical:
|
|
{
|
|
ColumnElement elem = elemData as ColumnElement;
|
|
if (elem != null && !elem.Status.IsError())
|
|
{
|
|
elem.Info = elementAnalyser.Analyse(element);
|
|
if (elem.Info.Material.Characteristics.YoungModulus.X < Double.Epsilon)
|
|
elem.Status.AddError(Resources.ResourceManager.GetString("ErrYoungModulus"));
|
|
|
|
MaterialConcreteCharacteristics concrete = (MaterialConcreteCharacteristics)elem.Info.Material.Characteristics.Specific;
|
|
if (concrete == null || concrete.Compression < Double.Epsilon)
|
|
elem.Status.AddError(Resources.ResourceManager.GetString("ErrConcreteCompression"));
|
|
|
|
foreach (SectionDataBase sectionDataBase in elem.ListSectionData)
|
|
{
|
|
ColumnSection sec = sectionDataBase as ColumnSection;
|
|
if (sec != null)
|
|
sec.Info = elem.Info;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_BeamAnalytical:
|
|
{
|
|
BeamElement elem = elemData as BeamElement;
|
|
if (elem != null && !elem.Status.IsError())
|
|
{
|
|
elementAnalyser.TSectionAnalysis = false;
|
|
LabelBeam labelBeam = elem.Label as LabelBeam;
|
|
if (labelBeam != null)
|
|
{
|
|
elementAnalyser.TSectionAnalysis = ( labelBeam.SlabBeamInteraction == BeamSectionType.WithSlabBeamInteraction );
|
|
}
|
|
|
|
elem.Info = elementAnalyser.Analyse(element);
|
|
if (elem.Info.Material.Characteristics.YoungModulus.X < Double.Epsilon)
|
|
elem.Status.AddError(Resources.ResourceManager.GetString("ErrYoungModulus"));
|
|
|
|
MaterialConcreteCharacteristics concrete = (MaterialConcreteCharacteristics)elem.Info.Material.Characteristics.Specific;
|
|
if (concrete == null || concrete.Compression < Double.Epsilon)
|
|
elem.Status.AddError(Resources.ResourceManager.GetString("ErrConcreteCompression"));
|
|
|
|
foreach (SectionDataBase sectionDataBase in elem.ListSectionData)
|
|
{
|
|
BeamSection sec = sectionDataBase as BeamSection;
|
|
if (sec != null)
|
|
sec.Info = elem.Info;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
/// <structural_toolkit_2015>
|
|
|
|
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_FloorAnalytical:
|
|
|
|
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_FoundationSlabAnalytical:
|
|
|
|
{
|
|
FloorElement slab = elemData as FloorElement;
|
|
if (slab != null)
|
|
{
|
|
slab.Info = elementAnalyser.Analyse(element);
|
|
|
|
foreach (SectionDataBase secData in slab.ListSectionData)
|
|
{
|
|
FloorSection sec = secData as FloorSection;
|
|
if (sec != null)
|
|
sec.Info = slab.Info;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_WallAnalytical:
|
|
{
|
|
WallElement wall = elemData as WallElement;
|
|
if (wall != null)
|
|
{
|
|
wall.Info = elementAnalyser.Analyse(element);
|
|
|
|
foreach (SectionDataBase secData in wall.ListSectionData)
|
|
{
|
|
WallSection sec = secData as WallSection;
|
|
if (sec != null)
|
|
sec.Info = wall.Info;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
/// </structural_toolkit_2015>
|
|
}
|
|
}
|
|
Autodesk.Revit.DB.CodeChecking.NotificationService.ProgressStep(string.Format("{0:d}%", ++step * 100 / listElementData.Count));
|
|
if (NotificationService.ProgressBreakInvoked())
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gives possibility to write data to Revit data base.
|
|
/// </summary>
|
|
/// <param name="listElementData">List of user element objects.</param>
|
|
/// <param name="parameters">User common parameters.</param>
|
|
/// <param name="data">Acces to cref="ServiceData".</param>
|
|
public void SaveToRevitDB(List<ObjectDataBase> listElementData, CommonParametersBase parameters, Autodesk.Revit.DB.CodeChecking.ServiceData data)
|
|
{
|
|
|
|
Autodesk.Revit.DB.ResultsBuilder.Storage.ResultsPackageBuilder builder = Autodesk.Revit.DB.CodeChecking.Storage.StorageService.GetStorageService().GetStorageDocument(data.Document).CalculationParamsManager.CalculationParams.GetOutputResultPackageBuilder(Server.Server.ID);
|
|
ForceResultsWriter resultsWriter = new ForceResultsWriter(data.Document, builder, Autodesk.Revit.DB.ResultsBuilder.UnitsSystem.Metric);
|
|
|
|
foreach (ObjectDataBase objectDataBase in listElementData)
|
|
{
|
|
ElementDataBase elementDataBase = objectDataBase as ElementDataBase;
|
|
if (!elementDataBase.Status.IsError())
|
|
{
|
|
switch (elementDataBase.Category)
|
|
{
|
|
default:
|
|
break;
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_ColumnAnalytical:
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_BeamAnalytical:
|
|
{
|
|
//TBD - RB doesn't support relative coordinates as input
|
|
//Begin mod
|
|
//IList<double> vx = (from sec in elementDataBase.ListSectionData select (sec as LinearSection).GetCalcResultsInPt()[ResultTypeLinear.X_Rel ]).ToList();
|
|
bool isListForces = true;
|
|
foreach (LinearSection sec in elementDataBase.ListSectionData)
|
|
{
|
|
if (sec.ListInternalForces == null || sec.ListInternalForces.Count == 0)
|
|
{
|
|
isListForces = false;
|
|
break;
|
|
}
|
|
}
|
|
if (isListForces)
|
|
{
|
|
IList<double> xCoordinates = (from sec in elementDataBase.ListSectionData select (sec as LinearSection).GetCalcResultsInPoint()[ResultTypeLinear.X]).ToList();
|
|
//End Mod
|
|
resultsWriter.SetMeasurementForElement(elementDataBase.ElementId, AxisDirection.X, xCoordinates);
|
|
|
|
ResultTypeLinear[] resultTypesLinear = new ResultTypeLinear[] { ResultTypeLinear.Abottom, ResultTypeLinear.Atop, ResultTypeLinear.Aleft, ResultTypeLinear.Aright };
|
|
foreach (ResultTypeLinear forceType in resultTypesLinear)
|
|
{
|
|
ICollection<double> valuesInPoints = (from LinearSection section in elementDataBase.ListSectionData select section.GetCalcResultsInPoint()[forceType]).ToList();
|
|
resultsWriter.AddResultsForElement(elementDataBase.ElementId, forceType.GetResultType(), valuesInPoints);
|
|
}
|
|
}
|
|
}
|
|
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:
|
|
IList<double> vx = (from sec in elementDataBase.ListSectionData select (sec as SurfaceSection).GetCalcResultsInPt()[ResultTypeSurface.X]).ToList();
|
|
IList<double> vy = (from sec in elementDataBase.ListSectionData select (sec as SurfaceSection).GetCalcResultsInPt()[ResultTypeSurface.Y]).ToList();
|
|
IList<double> vz = (from sec in elementDataBase.ListSectionData select (sec as SurfaceSection).GetCalcResultsInPt()[ResultTypeSurface.Z]).ToList();
|
|
resultsWriter.SetMeasurementForElement(elementDataBase.ElementId, AxisDirection.X, vx);
|
|
resultsWriter.SetMeasurementForElement(elementDataBase.ElementId, AxisDirection.Y, vy);
|
|
resultsWriter.SetMeasurementForElement(elementDataBase.ElementId, AxisDirection.Z, vz);
|
|
ResultTypeSurface[] vType = new ResultTypeSurface[] { ResultTypeSurface.AxxBottom, ResultTypeSurface.AxxTop, ResultTypeSurface.AyyBottom, ResultTypeSurface.AyyTop };
|
|
foreach (ResultTypeSurface forceType in vType)
|
|
{
|
|
ICollection<double> vVal = (from sec in elementDataBase.ListSectionData select (sec as SurfaceSection).GetCalcResultsInPt()[forceType]).ToList();
|
|
resultsWriter.AddResultsForElement(elementDataBase.ElementId, forceType.GetResultType(), vVal);
|
|
}
|
|
break;
|
|
/// </structural_toolkit_2015>
|
|
}
|
|
}
|
|
}
|
|
resultsWriter.StoreResultsInResultsBuilder("RCCalculationsResults");
|
|
}
|
|
|
|
|
|
private Tuple<Label,CalculationParameter,BuiltInCategory,Element> GetElementInternalData(Autodesk.Revit.DB.CodeChecking.ServiceData data, ElementId elementId)
|
|
{
|
|
Element element = data.Document.GetElement(elementId);
|
|
BuiltInCategory category = Autodesk.Revit.DB.CodeChecking.Tools.GetCategoryOfElement(element);
|
|
StorageDocument storageDocument = Autodesk.Revit.DB.CodeChecking.Storage.StorageService.GetStorageService().GetStorageDocument(data.Document);
|
|
CalculationParameter calculationParameter = storageDocument.CalculationParamsManager.CalculationParams.GetEntity<CalculationParameter>(data.Document);
|
|
Label ccLabel = storageDocument.LabelsManager.GetLabel(element);
|
|
|
|
return new Tuple<Label, CalculationParameter, BuiltInCategory, Element>(ccLabel, calculationParameter, category, element);
|
|
}
|
|
|
|
private List<ForceType> GetForceTypes(Autodesk.Revit.DB.CodeChecking.ServiceData data, IEnumerable<ElementId> elementsIds)
|
|
{
|
|
List<ForceType> forceTypes = new List<ForceType>();
|
|
foreach (ElementId elementId in elementsIds)
|
|
{
|
|
Tuple<Label, CalculationParameter, BuiltInCategory, Element> elementsInternalData = GetElementInternalData(data, elementId);
|
|
BuiltInCategory category = elementsInternalData.Item3;
|
|
Label ccLabel = elementsInternalData.Item1;
|
|
|
|
switch (category)
|
|
{
|
|
default:
|
|
break;
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_ColumnAnalytical:
|
|
{
|
|
LabelColumn label = ReadElementLabel(category, ccLabel.Material, ccLabel, data) as LabelColumn;
|
|
if (label != null)
|
|
{
|
|
forceTypes = label.EnabledInternalForces.Select(s => s.GetForceType()).ToList();
|
|
}
|
|
break;
|
|
}
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_BeamAnalytical:
|
|
{
|
|
LabelBeam label = ReadElementLabel(category, ccLabel.Material, ccLabel, data) as LabelBeam;
|
|
if (label != null)
|
|
{
|
|
forceTypes = label.EnabledInternalForces.Select(s => s.GetForceType()).ToList();
|
|
}
|
|
break;
|
|
}
|
|
/// <structural_toolkit_2015>
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_FloorAnalytical:
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_FoundationSlabAnalytical:
|
|
{
|
|
LabelFloor label = ReadElementLabel(category, ccLabel.Material, ccLabel, data) as LabelFloor;
|
|
if (label != null)
|
|
{
|
|
if (label.EnabledInternalForces.Contains(EnabledInternalForces.MY))
|
|
{
|
|
forceTypes.Add(ForceType.Mxx);
|
|
forceTypes.Add(ForceType.Myy);
|
|
}
|
|
if (label.EnabledInternalForces.Contains(EnabledInternalForces.FX))
|
|
{
|
|
forceTypes.Add(ForceType.Fyy);
|
|
forceTypes.Add(ForceType.Fxx);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case Autodesk.Revit.DB.BuiltInCategory.OST_WallAnalytical:
|
|
{
|
|
LabelWall label = ReadElementLabel(category, ccLabel.Material, ccLabel, data) as LabelWall;
|
|
if (label != null)
|
|
{
|
|
if (label.EnabledInternalForces.Contains(EnabledInternalForces.FX))
|
|
{
|
|
forceTypes.Add(ForceType.Fyy);
|
|
forceTypes.Add(ForceType.Fxx);
|
|
}
|
|
if (label.EnabledInternalForces.Contains(EnabledInternalForces.MY))
|
|
{
|
|
forceTypes.Add(ForceType.Mxx);
|
|
forceTypes.Add(ForceType.Myy);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
/// </structural_toolkit_2015>
|
|
|
|
}
|
|
}
|
|
return forceTypes;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|