/// <summary>
/// Converts the Enum combination type to string
/// </summary>
/// <param name="combinationType"></param>
/// <returns>The combination type as a string</returns>
private LoadCombType LoadCombinationType(ELoadCombinationType combinationType)
{
LoadCombType loadCombinationType = LoadCombType.UltimateOrdinary;
if (combinationType == ELoadCombinationType.SixTenA || combinationType == ELoadCombinationType.SixTenB)
{
loadCombinationType = LoadCombType.UltimateOrdinary;
}
else if (combinationType == ELoadCombinationType.Characteristic)
{
loadCombinationType = LoadCombType.ServiceabilityCharacteristic;
}
else if (combinationType == ELoadCombinationType.Frequent)
{
loadCombinationType = LoadCombType.ServiceabilityFrequent;
}
else if (combinationType == ELoadCombinationType.QuasiPermanent)
{
loadCombinationType = LoadCombType.ServiceabilityQuasiPermanent;
}
return(loadCombinationType);
}
/// <summary>
/// Creates an instance of <see cref="LoadCombination">LoadCombination</see> from the load cases in <paramref name="temporaryLoadCases"/>,
/// the first load case is the leading action.
/// </summary>
/// <param name="temporaryLoadCases">List of permanent load cases to be included in the combination</param>
/// <param name="loadCombNumber">The index of the combination</param>
/// <param name="loadCombinationNameTag">The name tag used for naming the combination</param>
/// <param name="permanentLoadGroups">List of permanent load groups</param>
/// <param name="combinationType">Type of loda combination <see cref="ELoadCombinationType">ELoadCombinationType</see></param>
/// <returns></returns>
private LoadCombination CreateLoadCombination(List <ModelLoadCaseInGroup> temporaryLoadCases, int loadCombNumber, string loadCombinationNameTag,
List <LoadGroupPermanent> permanentLoadGroups, ELoadCombinationType combinationType)
{
List <double> loadCombGammas = new List <double>();
List <LoadCase> loadCases = new List <LoadCase>();
// Add permanent load cases and coefficients
AddPermanentLoadCases(permanentLoadGroups, loadCases, combinationType, loadCombGammas);
// Add variable load cases
string leadingActionName;
leadingActionName = AddTemporaryLoadCases(temporaryLoadCases, combinationType, loadCases,
loadCombGammas);
// Create load combination
string loadCombName;
if (combinationType == ELoadCombinationType.SixTenA)
{
loadCombName = "LC " + loadCombNumber.ToString() + " " + loadCombinationNameTag;
}
else
{
loadCombName = "LC " + loadCombNumber.ToString() + " " + loadCombinationNameTag + " - " + leadingActionName + " as leading action";
}
LoadCombination loadCombination = new LoadCombination(loadCombName, LoadCombinationType(combinationType), loadCases, loadCombGammas);
return(loadCombination);
}
/// <summary>
/// Adds the load combination gamma factor based on the combination type
/// </summary>
/// <param name="parentLoadGroup">The load group to take the coefficients from</param>
/// <param name="combinationType">The type of load combination</param>
/// <param name="loadCombGammas">The list of combinations factors to append to</param>
private void AddCombinationFactorLeadingAction(LoadGroupTemporary parentLoadGroup, ELoadCombinationType combinationType, List <double> loadCombGammas)
{
// Assign the combination factors
if (combinationType == ELoadCombinationType.SixTenB)
{
loadCombGammas.Add(parentLoadGroup.SafetyFactor);
}
else if (combinationType == ELoadCombinationType.Characteristic)
{
loadCombGammas.Add(1);
}
else if (combinationType == ELoadCombinationType.Frequent)
{
loadCombGammas.Add(parentLoadGroup.Psi1);
}
else if (combinationType == ELoadCombinationType.QuasiPermanent)
{
loadCombGammas.Add(parentLoadGroup.Psi2);
}
}
/// <summary>
/// Adds the load combination gamma factor based on the combination type
/// </summary>
/// <param name="parentLoadGroup">The load group to take the coefficients from</param>
/// <param name="combinationType">The type of load combination</param>
/// <param name="loadCombGammas">The list of combinations factors to append to</param>
private void AddCombinationFactorsAccompanyingAction(LoadGroupTemporary parentLoadGroup, ELoadCombinationType combinationType, List <double> loadCombGammas)
{
if (combinationType == ELoadCombinationType.SixTenB)
{
loadCombGammas.Add(parentLoadGroup.SafetyFactor * parentLoadGroup.Psi0);
}
else if (combinationType == ELoadCombinationType.Characteristic)
{
loadCombGammas.Add(parentLoadGroup.Psi0);
}
else if (combinationType == ELoadCombinationType.Frequent)
{
loadCombGammas.Add(parentLoadGroup.Psi2);
}
else if (combinationType == ELoadCombinationType.QuasiPermanent)
{
loadCombGammas.Add(parentLoadGroup.Psi2);
}
}
/// <summary>
/// Add temporary load cases and associated combination factors to the list of load cases and factors provided
/// </summary>
/// <param name="temporaryLoadCases">List of temporary load cases to add</param>
/// <param name="combinationType">Combination type used for the factors</param>
/// <param name="loadCases">A list of load cases to add to</param>
/// <param name="loadCombGammas">A list of combiation factors to add to</param>
private string AddTemporaryLoadCases(List <ModelLoadCaseInGroup> temporaryLoadCases, ELoadCombinationType combinationType,
List <LoadCase> loadCases, List <double> loadCombGammas)
{
string leadingActionName = "";
// Get the indices of the leading action (or actions)
List <int> indicesLeadingCases = GetLeadingLoadCaseIndices(temporaryLoadCases);
for (int i = 0; i < temporaryLoadCases.Count; i++)
{
LoadGroupTemporary parentLoadGroup = (LoadGroupTemporary)temporaryLoadCases[i].LoadGroup;
// If combination type is not 6.10a, include load case
if (combinationType != ELoadCombinationType.SixTenA)
{
loadCases.Add(parentLoadGroup.GetCorrespondingCompleteLoadCase(temporaryLoadCases[i]));
}
// If leading action
if (indicesLeadingCases.Contains(i))
{
leadingActionName = FindLeadingActionName(parentLoadGroup, temporaryLoadCases[i]);
AddCombinationFactorLeadingAction(parentLoadGroup, combinationType, loadCombGammas);
}
else //Else accompanying action
{
AddCombinationFactorsAccompanyingAction(parentLoadGroup, combinationType, loadCombGammas);
}
// Remove the load case if gamma is zero
if (loadCombGammas[loadCombGammas.Count - 1] == 0)
{
loadCombGammas.RemoveAt(loadCombGammas.Count - 1);
loadCases.RemoveAt(loadCases.Count - 1);
}
}
return(leadingActionName);
}
/// <summary>
/// Adds the load cases in <paramref name="permanentLoadGroups"/> to <paramref name="loadCases"/> and computes associated load coefficients
/// </summary>
/// <param name="permanentLoadGroups"></param>
/// <param name="loadCases"></param>
/// <param name="combinationType"></param>
/// <param name="loadCombGammas"></param>
private void AddPermanentLoadCases <T>(List <T> permanentLoadGroups, List <LoadCase> loadCases, ELoadCombinationType combinationType,
List <double> loadCombGammas) where T : LoadGroupBase
{
foreach (LoadGroupBase loadGroup in permanentLoadGroups)
{
foreach (LoadCase loadCase in loadGroup.LoadCase)
{
loadCases.Add(loadCase);
if (combinationType == ELoadCombinationType.SixTenA)
{
loadCombGammas.Add(((LoadGroupPermanent)loadGroup).StandardUnfavourable);
}
else if (combinationType == ELoadCombinationType.SixTenB)
{
loadCombGammas.Add(((LoadGroupPermanent)loadGroup).Xi * ((LoadGroupPermanent)loadGroup).StandardUnfavourable);
}
else if (combinationType == ELoadCombinationType.Characteristic)
{
loadCombGammas.Add(1);
}
else if (combinationType == ELoadCombinationType.Frequent)
{
loadCombGammas.Add(1);
}
else if (combinationType == ELoadCombinationType.QuasiPermanent)
{
loadCombGammas.Add(1);
}
}
}
}
/// <summary>
/// Combines the load cases in the list of load groups provided
/// </summary>
/// <param name="loadGroups"></param>
/// <param name="loadCombinationNameTag"></param>
/// <param name="combinationType"></param>
/// <returns>Returns a list of instances of load combinations and the set of all load cases used</returns>
public void GenerateLoadCombinations(List <LoadGroupBase> loadGroups, string loadCombinationNameTag, ELoadCombinationType combinationType)
{
// Separate out the permanent load groups and the temporary
List <LoadGroupPermanent> permanentLoadGroups = loadGroups.Where(lg => lg is LoadGroupPermanent).Cast <LoadGroupPermanent>().ToList();
List <LoadGroupTemporary> temporaryLoadGroups = loadGroups.Where(lg => lg is LoadGroupTemporary).Cast <LoadGroupTemporary>().ToList();
// Initiate lists for storing load cases for each combination
int loadCombCounter = 1;
List <LoadCase> loadCasesInComb = new List <LoadCase>();
List <double> loadCombGammas = new List <double>();
// Create a load combination for each permutation of temporary loads
List <List <ModelLoadCaseInGroup> > loadCasePermutations = CreateLoadCasePermutations(temporaryLoadGroups);
for (int i = 0; i < loadCasePermutations.Count; i++)
{
LoadCombination currentLoadCombination;
currentLoadCombination = CreateLoadCombination(loadCasePermutations[i], loadCombCounter,
loadCombinationNameTag, permanentLoadGroups, combinationType);
AddLoadCombination(currentLoadCombination);
// If 6.10a only one combination is needed
if (combinationType == ELoadCombinationType.SixTenA)
{
break;
}
loadCombCounter++;
}
}
protected override void SolveInstance(IGH_DataAccess DA)
{
// get data
List <FemDesign.Loads.ModelGeneralLoadGroup> loadGroups = new List <FemDesign.Loads.ModelGeneralLoadGroup>();
if (!DA.GetDataList(0, loadGroups))
{
return;
}
if (loadGroups == null)
{
return;
}
int combType = 0;
if (!DA.GetData(1, ref combType))
{
return;
}
// Convert combination type to enum
ELoadCombinationType combTypeEnum = ELoadCombinationType.SixTenB;
if (combType == 0)
{
combTypeEnum = ELoadCombinationType.SixTenA;
}
else if (combType == 1)
{
combTypeEnum = ELoadCombinationType.SixTenB;
}
else if (combType == 2)
{
combTypeEnum = ELoadCombinationType.Characteristic;
}
else if (combType == 3)
{
combTypeEnum = ELoadCombinationType.Frequent;
}
else if (combType == 4)
{
combTypeEnum = ELoadCombinationType.QuasiPermanent;
}
// Raise error if 6.10a and no permanent load group
int permanentGroupsCount = 0;
if (combTypeEnum == ELoadCombinationType.SixTenA)
{
foreach (ModelGeneralLoadGroup loadGroup in loadGroups)
{
if (loadGroup.GetSpecificLoadGroup() is LoadGroupPermanent)
{
permanentGroupsCount += 1;
}
}
if (permanentGroupsCount == 0)
{
throw new System.ArgumentException("6.10a requires at least one permanent load group");
}
}
// Create load combinations
List <FemDesign.Loads.LoadCombination> loadCombinations;
List <LoadGroupBase> specificLoadGroups = loadGroups.Select(lg => lg.GetSpecificLoadGroup()).ToList();
loadCombinations = CreateCombinations(specificLoadGroups, combTypeEnum);
DA.SetDataList(0, loadCombinations);
}
private List <LoadCombination> CreateCombinations(List <LoadGroupBase> loadGroups, ELoadCombinationType combinationType)
{
// Fix how the combination type is printed
string loadCombinationNameTag;
if (combinationType == ELoadCombinationType.SixTenA)
{
loadCombinationNameTag = "6.10a";
}
else if (combinationType == ELoadCombinationType.SixTenB)
{
loadCombinationNameTag = "6.10b";
}
else
{
loadCombinationNameTag = combinationType.ToString();
}
LoadCombinationTable loadCombinationTable = new LoadCombinationTable();
loadCombinationTable.GenerateLoadCombinations(loadGroups, loadCombinationNameTag, combinationType);
return(loadCombinationTable.LoadCombinations);
}