/// <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;
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);
}
if (descriptor == null)
{
descriptor = new ForceCalculationDataDescriptor(elementId);
}
return(descriptor);
}
/// <summary>
/// Runs calculation for elements served in user implementation of cref="IEngineData".
/// </summary>
/// <param name="server">Acces to cref="Server".</param>
/// <param name="data">Acces to cref="ServiceData".</param>
public void Calculate(Server.Server server, Autodesk.Revit.DB.CodeChecking.ServiceData data)
{
List <Tuple <ElementId, ResultStatus> > listElementStatus = ReadListElementIdWithStatus(server, data);
if (listElementStatus.Count > 0)
{
CalculateSetOfElements(listElementStatus, server, data);
}
}
/// <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);
}
public override void Verify(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);
Main.Calculation.EngineData enginData = new Main.Calculation.EngineData();
Engine.Engine engine = new Engine.Engine(enginData);
engine.Calculate(this, data);
}
/// <summary>
/// Saves in Revit data base information collected in the list elements data.
/// </summary>
/// <param name="data">Acces to cref="ServiceData".</param>
/// <param name="listElementData">List of elements data.</param>
protected void SaveListElementData(Autodesk.Revit.DB.CodeChecking.ServiceData data, List <ObjectDataBase> listElementData)
{
Autodesk.Revit.DB.CodeChecking.NotificationService.ProgressStart(Resources.ResourceManager.GetString("DataSaving"), listElementData.Count);
int step = 0;
foreach (ElementDataBase elemData in listElementData)
{
SaveElementResult(elemData.ElementId, elemData.Result, elemData.Status, data);
step++;
Autodesk.Revit.DB.CodeChecking.NotificationService.ProgressStep(string.Format("{0:d}%", step * 100 / listElementData.Count));
}
}
/// <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>
/// 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>
/// Reads from Revit information about selected elements and store it in the list with elements data.
/// </summary>
/// <param name="data">Acces to cref="ServiceData".</param>
/// <param name="listElementStatus">List identyficators of elements with result status.</param>
/// <param name="parameters">Common parameters.</param>
/// <returns>List of elements data.</returns>
protected List <ObjectDataBase> ReadListElementData(Autodesk.Revit.DB.CodeChecking.ServiceData data, List <Tuple <ElementId, ResultStatus> > listElementStatus, CommonParametersBase parameters)
{
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);
List <ObjectDataBase> listElementData = new List <ObjectDataBase>();
foreach (Tuple <ElementId, ResultStatus> elemStatus in listElementStatus)
{
Element element = data.Document.GetElement(elemStatus.Item1);
if (element != null)
{
Autodesk.Revit.DB.CodeChecking.Storage.Label ccLabel = storageDocument.LabelsManager.GetLabel(element);
if (ccLabel != null)
{
Autodesk.Revit.DB.BuiltInCategory category = (Autodesk.Revit.DB.BuiltInCategory)element.Category.Id.IntegerValue;
StructuralAssetClass material = ccLabel.Material;
Autodesk.Revit.DB.ExtensibleStorage.Framework.SchemaClass label = EngineData.ReadElementLabel(category, material, ccLabel, data);
Autodesk.Revit.DB.ExtensibleStorage.Framework.SchemaClass result = EngineData.CreateElementResult(category, material);
ObjectDataBase objectData = new ObjectDataBase(elemStatus.Item1, category, material, label);
List <SectionDataBase> listSectionsData = new List <SectionDataBase>();
List <CalcPoint> listCalcPoints = EngineData.CreateCalcPointsForElement(data, parameters, elemStatus.Item1);
foreach (CalcPoint p in listCalcPoints)
{
SectionDataBase sectBase = new SectionDataBase(p, objectData);
SectionDataBase sectData = EngineData.CreateSectionData(sectBase);
listSectionsData.Add(sectData);
}
ElementDataBase elemBase = new ElementDataBase(result, listCalcPoints, listSectionsData, elemStatus.Item2, data.Document, objectData);
ElementDataBase elemData = EngineData.CreateElementData(elemBase);
listElementData.Add(elemData);
}
}
}
return(listElementData);
}
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;
}
}
}
return(forceTypes);
}
/// <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);
}
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);
}
/// <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)
{
return(Environment.ProcessorCount);
}
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));
}
/// <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;
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;
}
}
resultsWriter.StoreResultsInResultsBuilder("RCCalculationsResults");
//builder.Finish();
}
/// <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;
}
}
}
Autodesk.Revit.DB.CodeChecking.NotificationService.ProgressStep(string.Format("{0:d}%", ++step * 100 / listElementData.Count));
if (NotificationService.ProgressBreakInvoked())
{
break;
}
}
}
/// </structural_toolkit_2015>
/// <summary>
/// Read from Revit parameters common for all selected elements and stores them in cref="CommonParametersBase".
/// </summary>
/// <param name="listElementStatus">List identyficators of elements with result status.</param>
/// <param name="server">Acces to cref="Server".</param>
/// <param name="data">Acces to cref="ServiceData".</param>
/// <returns>Common parameters.</returns>
protected CommonParametersBase ReadCommonParameters(List <Tuple <ElementId, ResultStatus> > listElementStatus, Server.Server server, 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);
Guid activePackageId = storageDocument.CalculationParamsManager.CalculationParams.GetInputResultPackageId(server.GetServerId());
Autodesk.Revit.DB.ExtensibleStorage.Framework.SchemaClass calcParams = EngineData.ReadCalculationParameter(data);
List <ElementId> listCombinationId = new List <ElementId>();
if (server.LoadCasesAndCombinationsSupport())
{
listCombinationId = storageDocument.CalculationParamsManager.CalculationParams.GetLoadCasesAndCombinations(Server.Server.ID);
}
CommonParametersBase parameBase = new CommonParametersBase(listElementStatus, listCombinationId, activePackageId, calcParams);
CommonParametersBase parameters = EngineData.CreateCommonParameters(data, parameBase);
return(parameters);
}
/// <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));
}
break;
case StructuralAssetClass.Metal:
break;
}
}
return(null);
}
/// <summary>
/// Reads from Revit information about selected elements, next Calculates the list of elements, at the end saves calculation results in Revit Data Base.
/// </summary>
/// <param name="listElementStatus">List identyficators of elements with result status.</param>
/// <param name="server">Acces to cref="Server".</param>
/// <param name="data">Acces to cref="ServiceData".</param>
protected void CalculateSetOfElements(List <Tuple <ElementId, ResultStatus> > listElementStatus, Server.Server server, Autodesk.Revit.DB.CodeChecking.ServiceData data)
{
// reading from Revit Api
CommonParametersBase parameters = ReadCommonParameters(listElementStatus, server, data);
List <ObjectDataBase> listElementData = ReadListElementData(data, listElementStatus, parameters);
if (NotificationService.ProgressBreakInvoked() == false)
{
EngineData.ReadFromRevitDB(listElementData, parameters, data);
}
int maxNumberOfThreads = EngineData.GetNumberOfThreads(data);
if (maxNumberOfThreads < 1)
{
maxNumberOfThreads = 1;
}
// pure calculation (without any connection with Revit api)
List <ObjectDataBase> listElementFiltered = EngineData.FilterElementForCalculation(listElementData);
if (NotificationService.ProgressBreakInvoked() == false)
{
/// <structural_toolkit_2015>
CalculateElementList(listElementFiltered, parameters, maxNumberOfThreads, server);
}
/// </structural_toolkit_2015>
// writing to Revit Api
if (NotificationService.ProgressBreakInvoked() == false)
{
SaveListElementData(data, listElementData);
EngineData.SaveToRevitDB(listElementData, parameters, data);
}
}
/// <summary>
/// Reads from Revit selected elements identificators and collect in the list only that which has apprppriate label, material and category.
/// </summary>
/// <param name="server">Acces to cref="Server".</param>
/// <param name="data">Acces to cref="ServiceData".</param>
/// <returns>List identyficators of elements with result status.</returns>
protected List <Tuple <ElementId, ResultStatus> > ReadListElementIdWithStatus(Server.Server server, 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);
Guid activePackageId = storageDocument.CalculationParamsManager.CalculationParams.GetInputResultPackageId(server.GetServerId());
List <Tuple <ElementId, ResultStatus> > listElementId = new List <Tuple <ElementId, ResultStatus> >();
foreach (Element element in data.Selection)
{
Autodesk.Revit.DB.CodeChecking.Storage.Label ccLabel = storageDocument.LabelsManager.GetLabel(element);
if (ccLabel != null)
{
Autodesk.Revit.DB.BuiltInCategory category = (Autodesk.Revit.DB.BuiltInCategory)element.Category.Id.IntegerValue;
StructuralAssetClass material = ccLabel.Material;
if (server.GetSupportedMaterials().Contains(material) &&
server.GetSupportedCategories(material).Contains(category))
{
ElementId id = new ElementId(element.Id.IntegerValue);
SchemaClass label = EngineData.ReadElementLabel(category, material, ccLabel, data);
ResultStatus status = new Autodesk.Revit.DB.CodeChecking.Storage.ResultStatus(Server.Server.ID, activePackageId);
EngineData.VerifyElementLabel(category, material, label, ref status);
listElementId.Add(new Tuple <ElementId, ResultStatus>(id, status));
}
}
}
return(listElementId);
}
/// <summary>
/// Saves in Revit the result object of an element.
/// </summary>
/// <param name="elementId">Identificator of an element.</param>
/// <param name="resultSchema">Result object.</param>
/// <param name="status">Status of element's results.</param>
/// <param name="data">Acces to cref="ServiceData".</param>
protected void SaveElementResult(ElementId elementId, Autodesk.Revit.DB.ExtensibleStorage.Framework.SchemaClass resultSchema, Autodesk.Revit.DB.CodeChecking.Storage.ResultStatus status, 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);
Element element = data.Document.GetElement(elementId);
if (resultSchema != null)
{
storageDocument.ResultsManager.SetResult(resultSchema.GetEntity(), element, status, true);
}
}
