/// <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); }