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)
{
}
