public static Loadcase GetLoadcase(cSapModel model, string id) { Loadcase bhLoadcase = new Loadcase(); int number; string name = "NA"; string[] nameNum = id.Split(new [] { ":::" }, StringSplitOptions.None); if (nameNum.Count() > 1) { name = nameNum[0]; int.TryParse(nameNum[1], out number); } else { int.TryParse(id, out number); } bhLoadcase.Name = name; bhLoadcase.Number = number; eLoadPatternType type = eLoadPatternType.Other; model.LoadPatterns.GetLoadType(id, ref type); bhLoadcase.Nature = GetLoadNature(type); return(bhLoadcase); }
/***************************************************/ /*** Helper Methods ***/ /***************************************************/ private LoadNature LoadPatternTypeToBHoM(eLoadPatternType loadPatternType) { switch (loadPatternType) { case eLoadPatternType.Dead: return(LoadNature.Dead); case eLoadPatternType.SuperDead: return(LoadNature.SuperDead); case eLoadPatternType.Live: return(LoadNature.Live); case eLoadPatternType.Temperature: return(LoadNature.Temperature); case eLoadPatternType.Braking: return(LoadNature.Accidental); case eLoadPatternType.Prestress: return(LoadNature.Prestress); case eLoadPatternType.Wind: return(LoadNature.Wind); case eLoadPatternType.Quake: return(LoadNature.Seismic); case eLoadPatternType.Snow: return(LoadNature.Snow); default: return(LoadNature.Other); } }
/***************************************************/ /*** Read Methods ***/ /***************************************************/ private List <Loadcase> ReadLoadcase(List <string> ids = null) { int nameCount = 0; string[] nameArr = { }; List <Loadcase> loadcaseList = new List <Loadcase>(); m_model.LoadPatterns.GetNameList(ref nameCount, ref nameArr); ids = FilterIds(ids, nameArr); foreach (string id in ids) { Loadcase bhLoadcase = new Loadcase(); eLoadPatternType type = eLoadPatternType.Other; if (m_model.LoadPatterns.GetLoadType(id, ref type) == 0) { bhLoadcase.Name = id; bhLoadcase.Nature = LoadPatternTypeToBHoM(type); } SetAdapterId(bhLoadcase, id); loadcaseList.Add(bhLoadcase); } return(loadcaseList); }
/***************************************************/ /**** Private Methods ****/ /***************************************************/ private List <Loadcase> ReadLoadcase(List <string> ids = null) { List <Loadcase> loadCases = new List <Loadcase>(); int nameCount = 0; string[] nameArr = null; m_model.LoadPatterns.GetNameList(ref nameCount, ref nameArr); ids = FilterIds(ids, nameArr); foreach (string id in ids) { Loadcase bhomCase = new Loadcase(); eLoadPatternType patternType = eLoadPatternType.Other; if (m_model.LoadPatterns.GetLoadType(id, ref patternType) == 0) { bhomCase.Name = id; bhomCase.Nature = patternType.ToBHoM(); } else { ReadElementError("Load Pattern", id); } SetAdapterId(bhomCase, id); loadCases.Add(bhomCase); } return(loadCases); }
/// <inheritdoc /> /// <summary> /// Returns the case type, design type, and auto flag for the specified load case. /// </summary> /// <param name="nameLoadCase">The name of an existing load case.</param> /// <param name="loadCaseType">Load case type corresponding to the name provided.</param> /// <param name="loadCaseSubType">Load case sub-type corresponding to the name provided.</param> /// <param name="designType">Load case design type corresponding to the name provided.</param> /// <param name="designTypeOption">Load case type corresponding to the name provided.</param> /// <param name="autoCreatedCase">This is a value indicating if the load case has been automatically created.</param> /// <exception cref="CSiException"><see cref="CSiApiBase.API_DEFAULT_ERROR_CODE" /></exception> public void GetCaseTypes(string nameLoadCase, out eLoadCaseType loadCaseType, out int loadCaseSubType, out eLoadPatternType designType, out eSpecificationSource designTypeOption, out eAutoCreatedCase autoCreatedCase) { loadCaseType = 0; loadCaseSubType = 0; designType = 0; CSiProgram.eLoadCaseType csiCaseType = CSiProgram.eLoadCaseType.Modal; CSiProgram.eLoadPatternType csiPatternType = CSiProgram.eLoadPatternType.Dead; int csiDesignTypeOption = 0; int csiAutoCreatedCase = 0; _callCode = _sapModel.LoadCases.GetTypeOAPI_1(nameLoadCase, ref csiCaseType, ref loadCaseSubType, ref csiPatternType, ref csiDesignTypeOption, ref csiAutoCreatedCase); if (throwCurrentApiException(_callCode)) { throw new CSiException(API_DEFAULT_ERROR_CODE); } loadCaseType = EnumLibrary.Convert(csiCaseType, loadCaseType); designType = EnumLibrary.Convert(csiPatternType, designType); designTypeOption = (eSpecificationSource)csiDesignTypeOption; autoCreatedCase = (eAutoCreatedCase)csiAutoCreatedCase; }
// TODO: Work into factory /// <summary> /// Adds a new load pattern. /// An error is returned if the <paramref name="name" /> item is already used for an existing load pattern. /// </summary> /// <param name="name">Name for the new load pattern.</param> /// <param name="loadPatternType">Load pattern type.</param> /// <param name="selfWeightMultiplier">Self weight multiplier for the new load pattern.</param> /// <param name="addLoadCase">True: A linear static load case corresponding to the new load pattern is added.</param> /// <exception cref="CSiException"><see cref="CSiApiBase.API_DEFAULT_ERROR_CODE" /></exception> public void Add(string name, eLoadPatternType loadPatternType, double selfWeightMultiplier = 0, bool addLoadCase = true) { // TODO: Decide how to handle this: An error is returned if the Name item is already used for an existing load pattern. _loadPattern.Add(Name, loadPatternType, selfWeightMultiplier, addLoadCase); }
public void GetCaseTypes(string nameLoadCase, ref eLoadCaseType loadCaseType, ref int loadCaseSubType, ref eLoadPatternType designType, ref eSpecificationSource designTypeOption, ref eAutoCreatedCase autoCreatedCase) { }
public static void SetLoadcase(cSapModel model, Loadcase loadcase) { //string name = loadcase.CustomData[AdapterId].ToString(); string name = CaseNameToCSI(loadcase); eLoadPatternType patternType = GetLoadPatternType(loadcase.Nature); model.LoadPatterns.Add(name, patternType); }
/// <summary> /// Gets the type of load. /// </summary> public void FillLoadType() { if (_apiLoadPattern == null) { return; } _type = _apiLoadPattern.GetLoadType(Name); }
public SapLoadPattern(cSapModel myObjectModel, eLoadPatternType _patternType, string _name, double _selfWtMultiplier, bool _addLoadCase) { this.myObjectModel = myObjectModel; this.patternType = _patternType; this.name = _name; this.selfWtMultiplier = _selfWtMultiplier; this.addLoadCase = _addLoadCase; //if true, a linear static load Case is added. }
/// <summary> /// This function assigns a load type to a load pattern. /// </summary> /// <param name="name">The name of an existing load pattern.</param> /// <param name="loadPatternType">This is one of the items in the eLoadPatternType enumeration.</param> /// <exception cref="CSiException"></exception> public void SetLoadType(string name, eLoadPatternType loadPatternType) { _callCode = _sapModel.LoadPatterns.SetLoadType(name, EnumLibrary.Convert <eLoadPatternType, CSiProgram.eLoadPatternType>(loadPatternType)); if (throwCurrentApiException(_callCode)) { throw new CSiException(); } }
/// <summary> /// Adds a new load pattern. /// An error is returned if the <paramref name="uniqueName" /> item is already used for an existing load pattern. /// </summary> /// <param name="app">The application.</param> /// <param name="uniqueName">Name for the new load pattern.</param> /// <param name="loadPatternType">Load pattern type.</param> /// <param name="selfWeightMultiplier">Self weight multiplier for the new load pattern.</param> /// <param name="addLoadCase">True: A linear static load case corresponding to the new load pattern is added.</param> /// <returns>LoadPattern.</returns> /// <exception cref="CSiException"><see cref="CSiApiBase.API_DEFAULT_ERROR_CODE" /></exception> internal static LoadPattern Add(ApiCSiApplication app, string uniqueName, eLoadPatternType loadPatternType, double selfWeightMultiplier = 0, bool addLoadCase = true) { ApiLoadPattern apiLoadPatterns = getApiLoadPattern(app); apiLoadPatterns.Add(uniqueName, loadPatternType, selfWeightMultiplier, addLoadCase); return(Factory(app, uniqueName)); }
/***************************************************/ /*** Create Methods ***/ /***************************************************/ public bool CreateObject(Loadcase loadcase) { eLoadPatternType patternType = LoadNatureToCSI(loadcase.Nature); double selfWeight = 0; int ret = m_model.LoadPatterns.Add(loadcase.Name, patternType, selfWeight, true); SetAdapterId(loadcase, loadcase.Name); return(true); }
/// <summary> /// Adds a new load pattern. /// </summary> /// <param name="uniqueName">Name for the new load pattern.</param> /// <param name="loadPatternType">Load pattern type.</param> /// <param name="selfWeightMultiplier">Self weight multiplier for the new load pattern.</param> /// <param name="addLoadCase">True: A linear static load case corresponding to the new load pattern is added.</param> /// <exception cref="CSiException"><see cref="CSiApiBase.API_DEFAULT_ERROR_CODE" /></exception> public bool Add(string uniqueName, eLoadPatternType loadPatternType, double selfWeightMultiplier = 0, bool addLoadCase = true) { if (Contains(uniqueName)) { return(false); } _items.Add(LoadPattern.Add(_apiApp, uniqueName, loadPatternType, selfWeightMultiplier, addLoadCase)); return(true); }
/// <summary> /// Sets the design type for the specified load case. /// </summary> /// <param name="designTypeOption">This is one of the options for <paramref name="designType" />.</param> /// <param name="designType">This item only applies when the <paramref name="designTypeOption" /> = <see cref="eSpecificationSource.UserSpecified"/>.</param> /// <exception cref="CSiException"><see cref="CSiApiBase.API_DEFAULT_ERROR_CODE" /></exception> public void SetDesignType( eSpecificationSource designTypeOption, eLoadPatternType designType = eLoadPatternType.Dead) { if (_apiLoadCases == null) { return; } _apiLoadCases.SetDesignType(Name, designTypeOption, designType); _designType = designType; _designTypeOption = designTypeOption; }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static eLoadPatternType ToCSI(this LoadNature loadNature) { eLoadPatternType patType = new eLoadPatternType(); switch (loadNature) { case LoadNature.Dead: patType = eLoadPatternType.Dead; break; case LoadNature.SuperDead: patType = eLoadPatternType.SuperDead; break; case LoadNature.Live: patType = eLoadPatternType.Live; break; case LoadNature.Seismic: patType = eLoadPatternType.Quake; break; case LoadNature.Wind: patType = eLoadPatternType.Wind; break; case LoadNature.Snow: patType = eLoadPatternType.Snow; break; case LoadNature.Other: patType = eLoadPatternType.Other; break; case LoadNature.Temperature: patType = eLoadPatternType.Temperature; break; case LoadNature.Notional: patType = eLoadPatternType.Notional; break; case LoadNature.Prestress: patType = eLoadPatternType.Prestress; break; default: patType = eLoadPatternType.Other; break; } return(patType); }
/// <summary> /// This function sets the design type for the specified load case. /// </summary> /// <param name="nameLoadCase">The name of an existing load case.</param> /// <param name="designTypeOption">This is one of the following options for the DesignType item.</param> /// <param name="designType">This item only applies when the DesignTypeOption is 1 (user specified). It is one of the following items in the eLoadPatternType enumeration.</param> /// <exception cref="CSiException"></exception> public void SetDesignType(string nameLoadCase, eSpecificationSource designTypeOption, eLoadPatternType designType = eLoadPatternType.Dead) { int csiDesignTypeOption = (int)designTypeOption; _callCode = _sapModel.LoadCases.SetDesignType(nameLoadCase, csiDesignTypeOption, EnumLibrary.Convert <eLoadPatternType, CSiProgram.eLoadPatternType>(designType)); if (throwCurrentApiException(_callCode)) { throw new CSiException(); } }
// === Get/Set /// <summary> /// This function retrieves the load type for a specified load pattern. /// </summary> /// <param name="name">The name of an existing load pattern.</param> /// <param name="loadPatternType">This is one of the items in the eLoadPatternType enumeration.</param> /// <exception cref="CSiException"></exception> public void GetLoadType(string name, ref eLoadPatternType loadPatternType) { CSiProgram.eLoadPatternType csiLoadPatternType = CSiProgram.eLoadPatternType.Other; _callCode = _sapModel.LoadPatterns.GetLoadType(name, ref csiLoadPatternType); if (throwCurrentApiException(_callCode)) { throw new CSiException(); } loadPatternType = EnumLibrary.Convert(csiLoadPatternType, loadPatternType); }
// === Get/Set /// <inheritdoc /> /// <summary> /// Returns the load type for a specified load pattern. /// </summary> /// <param name="name">The name of an existing load pattern.</param> /// <exception cref="CSiException"><see cref="CSiApiBase.API_DEFAULT_ERROR_CODE" /></exception> public eLoadPatternType GetLoadType(string name) { eLoadPatternType loadPatternType = 0; CSiProgram.eLoadPatternType csiLoadPatternType = CSiProgram.eLoadPatternType.Other; _callCode = _sapModel.LoadPatterns.GetLoadType(name, ref csiLoadPatternType); if (throwCurrentApiException(_callCode)) { throw new CSiException(API_DEFAULT_ERROR_CODE); } return(EnumLibrary.Convert(csiLoadPatternType, loadPatternType)); }
/// <summary> /// Adds a new load pattern. /// An error is returned if the <paramref name="name" /> item is already used for an existing load pattern. /// </summary> /// <param name="name">Name for the new load pattern.</param> /// <param name="loadPatternType">Load pattern type.</param> /// <param name="selfWeightMultiplier">Self weight multiplier for the new load pattern.</param> /// <param name="addLoadCase">True: A linear static load case corresponding to the new load pattern is added.</param> /// <exception cref="CSiException"></exception> public void Add(string name, eLoadPatternType loadPatternType, double selfWeightMultiplier = 0, bool addLoadCase = true) { // TODO: Decide how to handle this: An error is returned if the Name item is already used for an existing load pattern. _callCode = _sapModel.LoadPatterns.Add(name, EnumLibrary.Convert <eLoadPatternType, CSiProgram.eLoadPatternType>(loadPatternType), selfWeightMultiplier, addLoadCase); if (throwCurrentApiException(_callCode)) { throw new CSiException(); } }
/// <summary> /// Adds a new load pattern. /// </summary> /// <param name="uniqueName">Name for the new load pattern.</param> /// <param name="loadPatternType">Load pattern type.</param> /// <param name="selfWeightMultiplier">Self weight multiplier for the new load pattern.</param> public bool Add(string uniqueName, eLoadPatternType loadPatternType, double selfWeightMultiplier = 0) { if (Contains(uniqueName)) { return(false); } LoadPattern item = LoadPattern.Factory(uniqueName); item.Type = loadPatternType; item.SelfWeightMultiplier = selfWeightMultiplier; _items.Add(item); return(true); }
/// <summary> /// Gets the case types. /// </summary> public void FillCaseTypes() { if (_apiLoadCases == null) { return; } _apiLoadCases.GetCaseTypes(Name, out var loadCaseType, out var loadCaseSubType, out var designType, out var designTypeOption, out var autoCreatedCase); _type = loadCaseType; _subType = getCaseSubTypes(loadCaseType, loadCaseSubType); _designType = designType; _designTypeOption = designTypeOption; _autoCreatedCase = autoCreatedCase; }
public static void GetLoadPatterns(ref cSapModel Model, ref string[] LoadPatternNames, ref string[] LoadPatternTypes, ref double[] LoadPatternMultipliers) { int number = 0; int ret = Model.LoadPatterns.GetNameList(ref number, ref LoadPatternNames); LoadPatternMultipliers = new double[number]; LoadPatternTypes = new string[number]; foreach (string lpname in LoadPatternNames) { double mult = 0; eLoadPatternType type = eLoadPatternType.Dead; int pos = Array.IndexOf(LoadPatternNames, lpname); Model.LoadPatterns.GetLoadType(lpname, ref type); ret = Model.LoadPatterns.GetSelfWTMultiplier(lpname, ref mult); LoadPatternMultipliers[pos] = mult; //int typeInt = (int)type; LoadPatternTypes[pos] = type.ToString(); } }
public LoadType GetAndConvertEtabsLoadType(string name) { eLoadPatternType patternType = new eLoadPatternType(); Model.LoadPatterns.GetLoadType(name, ref patternType); switch (patternType) { case eLoadPatternType.Dead: return(LoadType.Dead); case eLoadPatternType.SuperDead: return(LoadType.SuperDead); case eLoadPatternType.Live: return(LoadType.Live); case eLoadPatternType.ReduceLive: return(LoadType.ReducibleLive); case eLoadPatternType.Quake: return(LoadType.SeismicStatic); case eLoadPatternType.Wind: return(LoadType.Wind); case eLoadPatternType.Snow: return(LoadType.Snow); case eLoadPatternType.Other: return(LoadType.Other); default: return(LoadType.Other); // Other (less frequent) load types to be converted later. } }
// DEFINE LOAD PATTERN In SAPMODEL METHOD public static void AddLoadPattern(ref cSapModel Model, string Name, string Type, double Multiplier) { eLoadPatternType type = (eLoadPatternType)Enum.Parse(typeof(eLoadPatternType), Type); int ret = Model.LoadPatterns.Add(Name, type, Multiplier); }
public void SetDesignType(string nameLoadCase, eSpecificationSource designTypeOption, eLoadPatternType designType = eLoadPatternType.Dead) { }
/// <summary> /// Assigns a load type to a load pattern. /// </summary> /// <param name="loadPatternType">This is one of the items in the eLoadPatternType enumeration.</param> /// <exception cref="CSiException"><see cref="CSiApiBase.API_DEFAULT_ERROR_CODE" /></exception> public void SetLoadType(eLoadPatternType loadPatternType) { _loadPattern?.SetLoadType(Name, loadPatternType); Type = loadPatternType; }
public void GetLoadType(string name, ref eLoadPatternType loadPatternType) { }
public void Add(string name, eLoadPatternType loadPatternType, double selfWeightMultiplier = 0, bool addLoadCase = true) { }
public void SetLoadType(string name, eLoadPatternType loadPatternType) { }